OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* config/powerpc/tm-ppc-aix4.h, config/rs6000/tm-rs6000-aix4.h 

(DONT_RELOCATE_SYMFILE_OBJFILE):  Removed.
	* xcoffsolib.h (struct vmap):  Add new members tvma, toffs and dvma,
	remove tadj.
	* exec.c (bfdsec_to_vmap):  Initialize new vmap members, initialize
	tstart and dstart with section VMA.
	* rs6000-nat.c (vmap_symtab):  Relocate relative to the VMA in the
	object file.
	(vmap_ldinfo, xcoff_relocate_core):  Adjust tstart by section offset
	of the text section, remove DONT_RELOCATE_SYMFILE_OBJFILE hack.
	(vmap_exec):  Relocate relative to the VMA in the object file,
	relocate .bss section as well.
	(xcoff_relocate_core):  No longer adjust section addresses by VMA.
	* rs6000-tdep.c (find_toc_address):  Change type of tocbase
	to CORE_ADDR.
	* xcoffread.c (secnum_to_bfd_section):  New routine to get
	BFD section from CS section number.
	(scan_xcoff_symtab):  Make toc_offset section relative.

	* symtab.c (total_number_of_methods):  Avoid core dump if
	baseclass type is still undefined.
This commit is contained in:
Peter Schauer 1997-04-19 08:52:17 +00:00
parent 2717217130
commit 211b564e41
6 changed files with 267 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
gdb/ChangeLog
View File

@ -1,3 +1,27 @@
Sat Apr 19 01:49:37 1997 Peter Schauer (pes@regent.e-technik.tu-muenchen.de)
* config/powerpc/tm-ppc-aix4.h, config/rs6000/tm-rs6000-aix4.h
(DONT_RELOCATE_SYMFILE_OBJFILE): Removed.
* xcoffsolib.h (struct vmap): Add new members tvma, toffs and dvma,
remove tadj.
* exec.c (bfdsec_to_vmap): Initialize new vmap members, initialize
tstart and dstart with section VMA.
* rs6000-nat.c (vmap_symtab): Relocate relative to the VMA in the
object file.
(vmap_ldinfo, xcoff_relocate_core): Adjust tstart by section offset
of the text section, remove DONT_RELOCATE_SYMFILE_OBJFILE hack.
(vmap_exec): Relocate relative to the VMA in the object file,
relocate .bss section as well.
(xcoff_relocate_core): No longer adjust section addresses by VMA.
* rs6000-tdep.c (find_toc_address): Change type of tocbase
to CORE_ADDR.
* xcoffread.c (secnum_to_bfd_section): New routine to get
BFD section from CS section number.
(scan_xcoff_symtab): Make toc_offset section relative.
* symtab.c (total_number_of_methods): Avoid core dump if
baseclass type is still undefined.
Fri Apr 18 17:25:10 1997 Stu Grossman (grossman@critters.cygnus.com)
* Makefile.in (SUBDIRS): Add mswin so that make cleanup cleans up

86
gdb/rs6000-nat.c
View File

@ -1,5 +1,5 @@
/* IBM RS/6000 native-dependent code for GDB, the GNU debugger.
Copyright 1986, 1987, 1989, 1991, 1992, 1994, 1995, 1996
Copyright 1986, 1987, 1989, 1991, 1992, 1994, 1995, 1996, 1997
Free Software Foundation, Inc.
This file is part of GDB.
@ -316,9 +316,6 @@ vmap_symtab (vp)
register struct vmap *vp;
{
register struct objfile *objfile;
CORE_ADDR text_delta;
CORE_ADDR data_delta;
CORE_ADDR bss_delta;
struct section_offsets *new_offsets;
int i;
@ -340,17 +337,11 @@ vmap_symtab (vp)
for (i = 0; i < objfile->num_sections; ++i)
ANOFFSET (new_offsets, i) = ANOFFSET (objfile->section_offsets, i);
text_delta =
vp->tstart - ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT);
ANOFFSET (new_offsets, SECT_OFF_TEXT) = vp->tstart;
data_delta =
vp->dstart - ANOFFSET (objfile->section_offsets, SECT_OFF_DATA);
ANOFFSET (new_offsets, SECT_OFF_DATA) = vp->dstart;
bss_delta =
vp->dstart - ANOFFSET (objfile->section_offsets, SECT_OFF_BSS);
ANOFFSET (new_offsets, SECT_OFF_BSS) = vp->dstart;
/* The symbols in the object file are linked to the VMA of the section,
relocate them VMA relative. */
ANOFFSET (new_offsets, SECT_OFF_TEXT) = vp->tstart - vp->tvma;
ANOFFSET (new_offsets, SECT_OFF_DATA) = vp->dstart - vp->dvma;
ANOFFSET (new_offsets, SECT_OFF_BSS) = vp->dstart - vp->dvma;
objfile_relocate (objfile, new_offsets);
}
@ -520,26 +511,16 @@ vmap_ldinfo (ldi)
vp->dstart = (CORE_ADDR) ldi->ldinfo_dataorg;
vp->dend = vp->dstart + ldi->ldinfo_datasize;
if (vp->tadj)
{
vp->tstart += vp->tadj;
vp->tend += vp->tadj;
}
/* The run time loader maps the file header in addition to the text
section and returns a pointer to the header in ldinfo_textorg.
Adjust the text start address to point to the real start address
of the text section. */
vp->tstart += vp->toffs;
/* The objfile is only NULL for the exec file. */
if (vp->objfile == NULL)
got_exec_file = 1;
#ifdef DONT_RELOCATE_SYMFILE_OBJFILE
if (vp->objfile == symfile_objfile
|| vp->objfile == NULL)
{
ldi->ldinfo_dataorg = 0;
vp->dstart = (CORE_ADDR) 0;
vp->dend = ldi->ldinfo_datasize;
}
#endif
/* relocate symbol table(s). */
vmap_symtab (vp);
@ -604,13 +585,18 @@ vmap_exec ()
{
if (STREQ(".text", exec_ops.to_sections[i].the_bfd_section->name))
{
exec_ops.to_sections[i].addr += vmap->tstart;
exec_ops.to_sections[i].endaddr += vmap->tstart;
exec_ops.to_sections[i].addr += vmap->tstart - vmap->tvma;
exec_ops.to_sections[i].endaddr += vmap->tstart - vmap->tvma;
}
else if (STREQ(".data", exec_ops.to_sections[i].the_bfd_section->name))
{
exec_ops.to_sections[i].addr += vmap->dstart;
exec_ops.to_sections[i].endaddr += vmap->dstart;
exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
}
else if (STREQ(".bss", exec_ops.to_sections[i].the_bfd_section->name))
{
exec_ops.to_sections[i].addr += vmap->dstart - vmap->dvma;
exec_ops.to_sections[i].endaddr += vmap->dstart - vmap->dvma;
}
}
}
@ -747,19 +733,11 @@ xcoff_relocate_core (target)
vp->dstart = (CORE_ADDR) ldip->ldinfo_dataorg;
vp->dend = vp->dstart + ldip->ldinfo_datasize;
#ifdef DONT_RELOCATE_SYMFILE_OBJFILE
if (vp == vmap)
{
vp->dstart = (CORE_ADDR) 0;
vp->dend = ldip->ldinfo_datasize;
}
#endif
if (vp->tadj != 0)
{
vp->tstart += vp->tadj;
vp->tend += vp->tadj;
}
/* The run time loader maps the file header in addition to the text
section and returns a pointer to the header in ldinfo_textorg.
Adjust the text start address to point to the real start address
of the text section. */
vp->tstart += vp->toffs;
/* Unless this is the exec file,
add our sections to the section table for the core target. */
@ -789,22 +767,16 @@ xcoff_relocate_core (target)
}
stp = target->to_sections_end - 2;
/* "Why do we add bfd_section_vma?", I hear you cry.
Well, the start of the section in the file is actually
that far into the section as the struct vmap understands it.
So for text sections, bfd_section_vma tends to be 0x200,
and if vp->tstart is 0xd0002000, then the first byte of
the text section on disk corresponds to address 0xd0002200. */
stp->bfd = vp->bfd;
stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
stp->addr = bfd_section_vma (stp->bfd, stp->the_bfd_section) + vp->tstart;
stp->endaddr = bfd_section_vma (stp->bfd, stp->the_bfd_section) + vp->tend;
stp->addr = vp->tstart;
stp->endaddr = vp->tend;
stp++;
stp->bfd = vp->bfd;
stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
stp->addr = bfd_section_vma (stp->bfd, stp->the_bfd_section) + vp->dstart;
stp->endaddr = bfd_section_vma (stp->bfd, stp->the_bfd_section) + vp->dend;
stp->addr = vp->dstart;
stp->endaddr = vp->dend;
}
vmap_symtab (vp);

5
gdb/rs6000-tdep.c
View File

@ -1,5 +1,5 @@
/* Target-dependent code for GDB, the GNU debugger.
Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996
Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997
Free Software Foundation, Inc.
This file is part of GDB.
@ -1228,7 +1228,8 @@ static CORE_ADDR
find_toc_address (pc)
CORE_ADDR pc;
{
int ii, toc_entry, tocbase = 0;
int ii, toc_entry;
CORE_ADDR tocbase = 0;
toc_entry = -1;
for (ii=0; ii < loadinfotextindex; ++ii)

227
gdb/symtab.c
View File

@ -358,11 +358,19 @@ gdb_mangle_name (type, i, j)
}
/* Find which partial symtab on contains PC. Return 0 if none. */
struct symbol * fixup_symbol_section PARAMS ((struct symbol *,
struct objfile *));
struct partial_symbol * fixup_psymbol_section PARAMS ((struct partial_symbol *,
struct objfile *));
/* Find which partial symtab on contains PC and SECTION. Return 0 if none. */
struct partial_symtab *
find_pc_psymtab (pc)
register CORE_ADDR pc;
find_pc_sect_psymtab (pc, section)
CORE_ADDR pc;
asection *section;
{
register struct partial_symtab *pst;
register struct objfile *objfile;
@ -378,10 +386,11 @@ find_pc_psymtab (pc)
many partial symbol tables containing the PC, but
we want the partial symbol table that contains the
function containing the PC. */
if (!(objfile->flags & OBJF_REORDERED))
if (!(objfile->flags & OBJF_REORDERED) &&
section == 0) /* can't validate section this way */
return (pst);
msymbol = lookup_minimal_symbol_by_pc (pc);
msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
if (msymbol == NULL)
return (pst);
@ -391,7 +400,7 @@ find_pc_psymtab (pc)
{
struct partial_symbol *p;
p = find_pc_psymbol (tpst, pc);
p = find_pc_sect_psymbol (tpst, pc, section);
if (p != NULL
&& SYMBOL_VALUE_ADDRESS(p)
== SYMBOL_VALUE_ADDRESS (msymbol))
@ -404,18 +413,30 @@ find_pc_psymtab (pc)
return (NULL);
}
/* Find which partial symbol within a psymtab contains PC. Return 0
if none. Check all psymtabs if PSYMTAB is 0. */
/* Find which partial symtab contains PC. Return 0 if none.
Backward compatibility, no section */
struct partial_symtab *
find_pc_psymtab (pc)
CORE_ADDR pc;
{
return find_pc_sect_psymtab (pc, find_pc_mapped_section (pc));
}
/* Find which partial symbol within a psymtab matches PC and SECTION.
Return 0 if none. Check all psymtabs if PSYMTAB is 0. */
struct partial_symbol *
find_pc_psymbol (psymtab, pc)
find_pc_sect_psymbol (psymtab, pc, section)
struct partial_symtab *psymtab;
CORE_ADDR pc;
asection *section;
{
struct partial_symbol *best = NULL, *p, **pp;
CORE_ADDR best_pc;
if (!psymtab)
psymtab = find_pc_psymtab (pc);
psymtab = find_pc_sect_psymtab (pc, section);
if (!psymtab)
return 0;
@ -435,6 +456,12 @@ find_pc_psymbol (psymtab, pc)
&& pc >= SYMBOL_VALUE_ADDRESS (p)
&& SYMBOL_VALUE_ADDRESS (p) > best_pc)
{
if (section) /* match on a specific section */
{
fixup_psymbol_section (p, psymtab->objfile);
if (SYMBOL_BFD_SECTION (p) != section)
continue;
}
best_pc = SYMBOL_VALUE_ADDRESS (p);
best = p;
}
@ -450,6 +477,12 @@ find_pc_psymbol (psymtab, pc)
&& pc >= SYMBOL_VALUE_ADDRESS (p)
&& SYMBOL_VALUE_ADDRESS (p) > best_pc)
{
if (section) /* match on a specific section */
{
fixup_psymbol_section (p, psymtab->objfile);
if (SYMBOL_BFD_SECTION (p) != section)
continue;
}
best_pc = SYMBOL_VALUE_ADDRESS (p);
best = p;
}
@ -459,13 +492,33 @@ find_pc_psymbol (psymtab, pc)
return best;
}
/* Find which partial symbol within a psymtab matches PC. Return 0 if none.
Check all psymtabs if PSYMTAB is 0. Backwards compatibility, no section. */
struct partial_symbol *
find_pc_psymbol (psymtab, pc)
struct partial_symtab *psymtab;
CORE_ADDR pc;
{
return find_pc_sect_psymbol (psymtab, pc, find_pc_mapped_section (pc));
}
/* Debug symbols usually don't have section information. We need to dig that
out of the minimal symbols and stash that in the debug symbol. */
static
struct symbol * fixup_symbol_section PARAMS ((struct symbol *sym,
struct objfile *objfile));
static struct symbol *
static void
fixup_section (ginfo, objfile)
struct general_symbol_info *ginfo;
struct objfile *objfile;
{
struct minimal_symbol *msym;
msym = lookup_minimal_symbol (ginfo->name, NULL, objfile);
if (msym)
ginfo->bfd_section = SYMBOL_BFD_SECTION (msym);
}
struct symbol *
fixup_symbol_section (sym, objfile)
struct symbol *sym;
struct objfile *objfile;
@ -478,15 +531,29 @@ fixup_symbol_section (sym, objfile)
if (SYMBOL_BFD_SECTION (sym))
return sym;
msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, objfile);
if (msym)
SYMBOL_BFD_SECTION (sym) = SYMBOL_BFD_SECTION (msym);
fixup_section (&sym->ginfo, objfile);
return sym;
}
struct partial_symbol *
fixup_psymbol_section (psym, objfile)
struct partial_symbol *psym;
struct objfile *objfile;
{
struct minimal_symbol *msym;
if (!psym)
return NULL;
if (SYMBOL_BFD_SECTION (psym))
return psym;
fixup_section (&psym->ginfo, objfile);
return psym;
}
/* Find the definition for a specified symbol name NAME
in namespace NAMESPACE, visible from lexical block BLOCK.
Returns the struct symbol pointer, or zero if no symbol is found.
@ -626,7 +693,8 @@ found:
msymbol = lookup_minimal_symbol (name, NULL, NULL);
if (msymbol != NULL)
{
s = find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol));
s = find_pc_sect_symtab (SYMBOL_VALUE_ADDRESS (msymbol),
SYMBOL_BFD_SECTION (msymbol));
if (s != NULL)
{
/* This is a function which has a symtab for its address. */
@ -665,10 +733,8 @@ found:
{
/* This is a mangled variable, look it up by its
mangled name. */
return fixup_symbol_section
(lookup_symbol (SYMBOL_NAME (msymbol), block,
namespace, is_a_field_of_this, symtab),
NULL);
return lookup_symbol (SYMBOL_NAME (msymbol), block,
namespace, is_a_field_of_this, symtab);
}
/* There are no debug symbols for this file, or we are looking
for an unmangled variable.
@ -989,12 +1055,13 @@ block_function (bl)
return BLOCK_FUNCTION (bl);
}
/* Find the symtab associated with PC. Look through the psymtabs and read in
another symtab if necessary. */
/* Find the symtab associated with PC and SECTION. Look through the
psymtabs and read in another symtab if necessary. */
struct symtab *
find_pc_symtab (pc)
register CORE_ADDR pc;
find_pc_sect_symtab (pc, section)
CORE_ADDR pc;
asection *section;
{
register struct block *b;
struct blockvector *bv;
@ -1031,14 +1098,27 @@ find_pc_symtab (pc)
/* For an objfile that has its functions reordered,
find_pc_psymtab will find the proper partial symbol table
and we simply return its corresponding symtab. */
/* In order to better support objfiles that contain both
stabs and coff debugging info, we continue on if a psymtab
can't be found. */
if ((objfile->flags & OBJF_REORDERED) && objfile->psymtabs)
{
ps = find_pc_psymtab (pc);
ps = find_pc_sect_psymtab (pc, section);
if (ps)
s = PSYMTAB_TO_SYMTAB (ps);
else
s = NULL;
return (s);
return PSYMTAB_TO_SYMTAB (ps);
}
if (section != 0)
{
int i;
for (i = 0; i < b->nsyms; i++)
{
fixup_symbol_section (b->sym[i], objfile);
if (section == SYMBOL_BFD_SECTION (b->sym[i]))
break;
}
if (i >= b->nsyms)
continue; /* no symbol in this symtab matches section */
}
distance = BLOCK_END (b) - BLOCK_START (b);
best_s = s;
@ -1049,7 +1129,7 @@ find_pc_symtab (pc)
return(best_s);
s = NULL;
ps = find_pc_psymtab (pc);
ps = find_pc_sect_psymtab (pc, section);
if (ps)
{
if (ps->readin)
@ -1064,6 +1144,17 @@ find_pc_symtab (pc)
}
return (s);
}
/* Find the symtab associated with PC. Look through the psymtabs and
read in another symtab if necessary. Backward compatibility, no section */
struct symtab *
find_pc_symtab (pc)
CORE_ADDR pc;
{
return find_pc_sect_symtab (pc, find_pc_mapped_section (pc));
}
#if 0
@ -1145,7 +1236,7 @@ find_addr_symbol (addr, symtabp, symaddrp)
}
#endif /* 0 */
/* Find the source file and line number for a given PC value.
/* Find the source file and line number for a given PC value and section.
Return a structure containing a symtab pointer, a line number,
and a pc range for the entire source line.
The value's .pc field is NOT the specified pc.
@ -1163,8 +1254,9 @@ find_addr_symbol (addr, symtabp, symaddrp)
/* If it's worth the effort, we could be using a binary search. */
struct symtab_and_line
find_pc_line (pc, notcurrent)
find_pc_sect_line (pc, section, notcurrent)
CORE_ADDR pc;
struct sec *section;
int notcurrent;
{
struct symtab *s;
@ -1201,10 +1293,10 @@ find_pc_line (pc, notcurrent)
INIT_SAL (&val); /* initialize to zeroes */
if (notcurrent)
if (notcurrent)
pc -= 1;
s = find_pc_symtab (pc);
s = find_pc_sect_symtab (pc, section);
if (!s)
{
val.pc = pc;
@ -1304,8 +1396,25 @@ find_pc_line (pc, notcurrent)
else
val.end = BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK));
}
val.section = section;
return val;
}
/* Backward compatibility (no section) */
struct symtab_and_line
find_pc_line (pc, notcurrent)
CORE_ADDR pc;
int notcurrent;
{
asection *section;
section = find_pc_overlay (pc);
if (pc_in_unmapped_range (pc, section))
pc = overlay_mapped_address (pc, section);
return find_pc_sect_line (pc, section, notcurrent);
}
static int find_line_symtab PARAMS ((struct symtab *, int, struct linetable **,
int *, int *));
@ -1449,7 +1558,7 @@ find_line_pc_range (sal, startptr, endptr)
This also insures that we never give a range like "starts at 0x134
and ends at 0x12c". */
found_sal = find_pc_line (startaddr, 0);
found_sal = find_pc_sect_line (startaddr, sal.section, 0);
if (found_sal.line != sal.line)
{
/* The specified line (sal) has zero bytes. */
@ -1545,12 +1654,23 @@ find_function_start_sal (sym, funfirstline)
struct symtab_and_line sal;
pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
fixup_symbol_section (sym, NULL);
if (funfirstline)
{
{ /* skip "first line" of function (which is actually its prologue) */
asection *section = SYMBOL_BFD_SECTION (sym);
/* If function is in an unmapped overlay, use its unmapped LMA
address, so that SKIP_PROLOGUE has something unique to work on */
if (section_is_overlay (section) &&
!section_is_mapped (section))
pc = overlay_unmapped_address (pc, section);
pc += FUNCTION_START_OFFSET;
SKIP_PROLOGUE (pc);
/* For overlays, map pc back into its mapped VMA range */
pc = overlay_mapped_address (pc, section);
}
sal = find_pc_line (pc, 0);
sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0);
#ifdef PROLOGUE_FIRSTLINE_OVERLAP
/* Convex: no need to suppress code on first line, if any */
@ -1565,7 +1685,7 @@ find_function_start_sal (sym, funfirstline)
/* First pc of next line */
pc = sal.end;
/* Recalculate the line number (might not be N+1). */
sal = find_pc_line (pc, 0);
sal = find_pc_sect_line (pc, SYMBOL_BFD_SECTION (sym), 0);
}
sal.pc = pc;
#endif
@ -1673,6 +1793,8 @@ total_number_of_methods (type)
int count;
CHECK_TYPEDEF (type);
if (TYPE_CPLUS_SPECIFIC (type) == NULL)
return 0;
count = TYPE_NFN_FIELDS_TOTAL (type);
for (n = 0; n < TYPE_N_BASECLASSES (type); n++)
@ -1941,7 +2063,6 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical)
xmalloc (sizeof (struct symtab_and_line));
values.nelts = 1;
values.sals[0] = find_pc_line (pc, 0);
values.sals[0].pc = pc;
return values;
}
@ -2076,7 +2197,8 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical)
if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
{
values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
values.sals = (struct symtab_and_line *)
xmalloc (sizeof (struct symtab_and_line));
values.nelts = 1;
values.sals[0] = find_function_start_sal (sym,
funfirstline);
@ -2214,7 +2336,8 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical)
s = default_symtab;
val.symtab = s;
val.pc = 0;
values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
values.sals = (struct symtab_and_line *)
xmalloc (sizeof (struct symtab_and_line));
values.sals[0] = val;
values.nelts = 1;
if (need_canonical)
@ -2295,7 +2418,8 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical)
if (SYMBOL_CLASS (sym) == LOC_BLOCK)
{
/* Arg is the name of a function */
values.sals = (struct symtab_and_line *)xmalloc (sizeof (struct symtab_and_line));
values.sals = (struct symtab_and_line *)
xmalloc (sizeof (struct symtab_and_line));
values.sals[0] = find_function_start_sal (sym, funfirstline);
values.nelts = 1;
@ -2342,7 +2466,8 @@ decode_line_1 (argptr, funfirstline, default_symtab, default_line, canonical)
msymbol = lookup_minimal_symbol (copy, NULL, NULL);
if (msymbol != NULL)
{
val.pc = SYMBOL_VALUE_ADDRESS (msymbol);
val.pc = SYMBOL_VALUE_ADDRESS (msymbol);
val.section = SYMBOL_BFD_SECTION (msymbol);
if (funfirstline)
{
val.pc += FUNCTION_START_OFFSET;
@ -2399,8 +2524,10 @@ decode_line_2 (sym_arr, nelts, funfirstline, canonical)
struct cleanup *old_chain;
char **canonical_arr = (char **)NULL;
values.sals = (struct symtab_and_line *) alloca (nelts * sizeof(struct symtab_and_line));
return_values.sals = (struct symtab_and_line *) xmalloc (nelts * sizeof(struct symtab_and_line));
values.sals = (struct symtab_and_line *)
alloca (nelts * sizeof(struct symtab_and_line));
return_values.sals = (struct symtab_and_line *)
xmalloc (nelts * sizeof(struct symtab_and_line));
old_chain = make_cleanup (free, return_values.sals);
if (canonical)
@ -3292,7 +3419,7 @@ make_symbol_completion_list (text, word)
between the first instruction of a function, and the first executable line.
Returns 1 if PC *might* be in prologue, 0 if definately *not* in prologue.
If non-zero, func_start is where we thing the prologue starts, possibly
If non-zero, func_start is where we think the prologue starts, possibly
by previous examination of symbol table information.
*/

31
gdb/xcoffread.c
View File

@ -1,5 +1,5 @@
/* Read AIX xcoff symbol tables and convert to internal format, for GDB.
Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996
Copyright 1986, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 1997
Free Software Foundation, Inc.
Derived from coffread.c, dbxread.c, and a lot of hacking.
Contributed by IBM Corporation.
@ -272,10 +272,12 @@ process_linenos PARAMS ((CORE_ADDR, CORE_ADDR));
/* Translate from a COFF section number (target_index) to a SECT_OFF_*
code. */
static int secnum_to_section PARAMS ((int, struct objfile *));
static asection * secnum_to_bfd_section PARAMS ((int, struct objfile *));
struct find_targ_sec_arg {
int targ_index;
int *resultp;
asection **bfd_sect;
};
static void find_targ_sec PARAMS ((bfd *, asection *, void *));
@ -295,6 +297,7 @@ static void find_targ_sec (abfd, sect, obj)
*args->resultp = SECT_OFF_DATA;
else
*args->resultp = SECT_OFF_BSS;
*args->bfd_sect = sect;
}
}
@ -305,12 +308,30 @@ secnum_to_section (secnum, objfile)
struct objfile *objfile;
{
int off = SECT_OFF_TEXT;
asection *sect = NULL;
struct find_targ_sec_arg args;
args.targ_index = secnum;
args.resultp = &off;
args.bfd_sect = &sect;
bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
return off;
}
/* Return the BFD section that CS points to. */
static asection *
secnum_to_bfd_section (secnum, objfile)
int secnum;
struct objfile *objfile;
{
int off = SECT_OFF_TEXT;
asection *sect = NULL;
struct find_targ_sec_arg args;
args.targ_index = secnum;
args.resultp = &off;
args.bfd_sect = &sect;
bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
return sect;
}
/* add a given stab string into given stab vector. */
@ -2195,12 +2216,13 @@ scan_xcoff_symtab (section_offsets, objfile)
struct section_offsets *section_offsets;
struct objfile *objfile;
{
int toc_offset = 0; /* toc offset value in data section. */
CORE_ADDR toc_offset = 0; /* toc offset value in data section. */
char *filestring = NULL;
char *namestring;
int past_first_source_file = 0;
bfd *abfd;
asection *bfd_sect;
unsigned int nsyms;
/* Current partial symtab */
@ -2363,6 +2385,11 @@ scan_xcoff_symtab (section_offsets, objfile)
if (toc_offset)
warning ("More than one XMC_TC0 symbol found.");
toc_offset = symbol.n_value;
/* Make TOC offset relative to start address of section. */
bfd_sect = secnum_to_bfd_section (symbol.n_scnum, objfile);
if (bfd_sect)
toc_offset -= bfd_section_vma (objfile->obfd, bfd_sect);
break;
case XMC_TC:

8
gdb/xcoffsolib.h
View File

@ -1,5 +1,5 @@
/* Data structures for RS/6000 shared libraries, for GDB.
Copyright 1991, 1992, 1994 Free Software Foundation, Inc.
Copyright 1991, 1992, 1994, 1997 Free Software Foundation, Inc.
This file is part of GDB.
@ -32,9 +32,11 @@ struct vmap {
char *member; /* ptr to member name */
CORE_ADDR tstart; /* virtual addr where member is mapped */
CORE_ADDR tend; /* virtual upper bound of member */
CORE_ADDR tadj; /* heuristically derived adjustment */
CORE_ADDR tvma; /* virtual addr of text section in object file */
CORE_ADDR toffs; /* offset of text section in object file */
CORE_ADDR dstart; /* virtual address of data start */
CORE_ADDR dend; /* vitrual address of data end */
CORE_ADDR dend; /* virtual address of data end */
CORE_ADDR dvma; /* virtual addr of data section in object file */
/* This is NULL for the exec-file. */
struct objfile *objfile;