mirror/binutils-gdb
2
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2025-01-30 12:44:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

Create and use macros for iterating on symtabs, psymtabs, msymbols.

Browse Source 
* minsyms.c (iterate_over_msymbols):  Remove; clunky and slow.
* symfile.h, symtab.h (iterate_over_msymbols):  Remove prototype
* coffread.c (coff_symfile_read):  iterate_over_symtabs => ALL_SYMTABS.
(patch_opaque_types):  Avoid dummy args and result.
* objfiles.c (have_partial_symbols, have_full_symbols,
have_minimal_symbols):  explicit iteration => ALL_OBJFILES; simplify.
(iterate_over_objfiles, iterate_over_symtabs,
iterate_over_psymtabs):  Remove, clunky and slow.
* objfiles.h:  Replace iterate_over_* prototypes with ALL_SYMTABS,
ALL_PSYMTABS, and ALL_MSYMBOLS macros.
* symmisc.c (dump_symtab, dump_psymtab, dump_msymbols,
dump_objfile):  Remove dummy args and results.  Move filename
comparisons to callers.
(printsyms_command, printpsyms_command, printmsyms_command,
printobjfiles_command):  iterate_over_* => ALL_*.  Compare filenames.
* symtab.c (lookup_symtab_1, lookup_symtab, lookup_partial_symtab,
lookup_symbol, find_main_psymtab, find_pc_symtab, sources_info,
list_symbols, make_symbol_completion_list):  Replace explicit
iteration with ALL_SYMTABS, ALL_PSYMTABS, or ALL_MSYMBOLS.
Eliminate Dijkstra flag crap, break out of loops with gotos.
(lookup_symtab_1):  Protect '/' tests from short filenames.
(cplus_mangled_symbol):  Move inline into lookup_symbol.
* xcoffexec.c (relocate_objfile_msymbols):  Remove poor hack.
(relocate_minimal_symbol):  Move inline to vmap_symtab.
(vmap_symtab):  Replace iteration with ALL_OBJFILES,
iterate_over_msymbols with ALL_MSYMBOLS.

Misc cleanup prior to release.

* dwarfread.c (dwarf_build_psymtabs):  Remove mainline test.
* mipsread.c (compare_symtabs, compare_psymtabs):  Remove, unused.
* mipsread.c:  Add prototypes for all static functions.

* symmisc.c (dump_symtab_lines, dump_symtabs, dump_last_symtab,
dump_blockvector, dump_block, dump_addrchass, dump_namespace,
dump_symbol, dump_type, dump_linetable, dump_strtbl):  Remove, unused.
* xcoffread.c (dump_symtab_lines, dump_symtabs, dump_last_symtab,
dump_blockvector, dump_block, dump_addrchass, dump_namespace,
dump_symbol, dump_type, dump_linetable, dump_strtbl):  Remove 2nd
unused copy!

* buildsym.c (define_symbol):  Handle global register variables
(from Pierre Willard).  Complain if register numbers are too large.
This commit is contained in:
John Gilmore 1992-03-29 23:17:36 +00:00
parent f9e3b3ccc2
commit 84ffdec2cb
8 changed files with 210 additions and 568 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
gdb/buildsym.c
View File

@ -147,6 +147,9 @@ struct complaint invalid_member_complaint =
struct complaint range_type_base_complaint =
{"base type %d of range type is not defined", 0, 0};
struct complaint reg_value_complaint =
{"register number too large in symbol %s", 0, 0};
int
hashname (name)
@ -340,7 +343,7 @@ really_free_pendings (foo)
for (next = free_pendings; next; next = next1)
{
next1 = next->next;
free (next);
free ((PTR)next);
}
free_pendings = 0;
@ -348,7 +351,7 @@ really_free_pendings (foo)
for (bnext = pending_blocks; bnext; bnext = bnext1)
{
bnext1 = bnext->next;
free (bnext);
free ((PTR)bnext);
}
#endif
pending_blocks = 0;
@ -356,14 +359,14 @@ really_free_pendings (foo)
for (next = file_symbols; next; next = next1)
{
next1 = next->next;
free (next);
free ((PTR)next);
}
file_symbols = 0;
for (next = global_symbols; next; next = next1)
{
next1 = next->next;
free (next);
free ((PTR)next);
}
global_symbols = 0;
}
@ -607,7 +610,7 @@ pop_subfile ()
name = link->name;
subfile_stack = link->next;
header_file_prev_index = link->prev_index;
free (link);
free ((PTR)link);
return name;
}
@ -820,7 +823,7 @@ end_symtab (end_addr, sort_pending, sort_linevec, objfile)
if (global_stabs) {
patch_block_stabs (global_symbols, global_stabs, objfile);
free (global_stabs);
free ((PTR)global_stabs);
global_stabs = 0;
}
@ -892,10 +895,10 @@ end_symtab (end_addr, sort_pending, sort_linevec, objfile)
#endif
}
if (subfile->line_vector)
free (subfile->line_vector);
free ((PTR)subfile->line_vector);
nextsub = subfile->next;
free (subfile);
free ((PTR)subfile);
}
#ifdef IBM6000_TARGET
@ -1393,17 +1396,32 @@ define_symbol (valu, string, desc, type, objfile)
#endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
case 'P':
/* Parameter which is in a register. */
SYMBOL_CLASS (sym) = LOC_REGPARM;
SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu);
if (SYMBOL_VALUE (sym) >= NUM_REGS)
{
complain (&reg_value_complaint, SYMBOL_NAME (sym));
SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */
}
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
add_symbol_to_list (sym, &local_symbols);
break;
case 'r':
/* Register variable (either global or local). */
SYMBOL_CLASS (sym) = LOC_REGISTER;
SYMBOL_VALUE (sym) = STAB_REG_TO_REGNUM (valu);
if (SYMBOL_VALUE (sym) >= NUM_REGS)
{
complain (&reg_value_complaint, SYMBOL_NAME (sym));
SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */
}
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
add_symbol_to_list (sym, &local_symbols);
if (within_function)
add_symbol_to_list (sym, &local_symbols);
else
add_symbol_to_list (sym, &file_symbols);
break;
case 'S':
@ -2631,7 +2649,9 @@ read_struct_type (pp, type, objfile)
for the derived classes, but for the fact that by then,
we don't remember who needs what. */
#if 0
int predicted_fieldno = -1;
#endif
/* Now we must record the virtual function table pointer's
field information. */
@ -3164,14 +3184,14 @@ read_range_type (pp, typenums, objfile)
/* a signed type */
/* FIXME -- the only way to distinguish `int' from `long' is to look
at its name! */
if ((n3 == (1 << (8 * sizeof (long) - 1)) - 1) &&
if ((n3 ==(long)(((unsigned long)1 << (8 * sizeof (long) - 1)) - 1)) &&
long_kludge_name && long_kludge_name[0] == 'l' /* long */)
return (lookup_fundamental_type (objfile, FT_LONG));
if (n3 == (1 << (8 * sizeof (int) - 1)) - 1)
if (n3 == (long)(((unsigned long)1 << (8 * sizeof (int) - 1)) - 1))
return (lookup_fundamental_type (objfile, FT_INTEGER));
if (n3 == (1 << (8 * sizeof (short) - 1)) - 1)
if (n3 == ( 1 << (8 * sizeof (short) - 1)) - 1)
return (lookup_fundamental_type (objfile, FT_SHORT));
if (n3 == (1 << (8 * sizeof (char) - 1)) - 1)
if (n3 == ( 1 << (8 * sizeof (char) - 1)) - 1)
return (lookup_fundamental_type (objfile, FT_CHAR));
}

28
gdb/dwarfread.c
View File

@ -57,12 +57,14 @@ other things to work on, if you get bored. :-)
#include "defs.h"
#include <varargs.h>
#include <fcntl.h>
#include <string.h>
#include "bfd.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "symfile.h"
#include "objfiles.h"
#include "libbfd.h" /* FIXME Secret Internal BFD stuff (bfd_read) */
#include "elf/dwarf.h"
#include "buildsym.h"
@ -310,7 +312,7 @@ read_structure_scope PARAMS ((struct dieinfo *, char *, char *,
struct objfile *));
static struct type *
decode_array_element_type PARAMS ((char *, char *));
decode_array_element_type PARAMS ((char *));
static struct type *
decode_subscr_data PARAMS ((char *, char *));
@ -436,17 +438,9 @@ dwarf_build_psymtabs (desc, filename, addr, mainline, dbfoff, dbsize,
init_psymbol_list (objfile, 1024);
}
/* From this point on, we don't need to pass mainline around, so zap
baseaddr to zero if we don't need relocation. */
/* Save the relocation factor where everybody can see it. */
if (mainline)
{
baseaddr = 0;
}
else
{
baseaddr = addr;
}
baseaddr = addr;
/* Follow the compilation unit sibling chain, building a partial symbol
table entry for each one. Save enough information about each compilation
@ -934,15 +928,15 @@ DESCRIPTION
*/
static struct type *
decode_array_element_type (scan, end)
decode_array_element_type (scan)
char *scan;
char *end;
{
struct type *typep;
short attribute;
DIEREF dieref;
unsigned short fundtype;
/* FIXME, does this confuse the host and target sizeof's? --gnu */
(void) memcpy (&attribute, scan, sizeof (short));
scan += sizeof (short);
switch (attribute)
@ -1020,7 +1014,7 @@ decode_subscr_data (scan, end)
switch (format)
{
case FMT_ET:
typep = decode_array_element_type (scan, end);
typep = decode_array_element_type (scan);
break;
case FMT_FT_C_C:
(void) memcpy (&fundtype, scan, sizeof (short));
@ -1865,7 +1859,7 @@ read_ofile_symtab (pst)
if (LNFOFF (pst))
{
if (bfd_seek (abfd, LNFOFF (pst), 0) ||
(bfd_read (&lnsize, sizeof(long), 1, abfd) != sizeof(long)))
(bfd_read ((PTR)&lnsize, sizeof(long), 1, abfd) != sizeof(long)))
{
error ("can't read DWARF line number table size");
}
@ -2043,11 +2037,11 @@ init_psymbol_list (objfile, total_symbols)
if (objfile -> global_psymbols.list)
{
mfree (objfile -> md, objfile -> global_psymbols.list);
mfree (objfile -> md, (PTR)objfile -> global_psymbols.list);
}
if (objfile -> static_psymbols.list)
{
mfree (objfile -> md, objfile -> static_psymbols.list);
mfree (objfile -> md, (PTR)objfile -> static_psymbols.list);
}
/* Current best guess is that there are approximately a twentieth

38
gdb/minsyms.c
View File

@ -76,42 +76,6 @@ compare_minimal_symbols PARAMS ((const void *, const void *));
static int
compact_minimal_symbols PARAMS ((struct minimal_symbol *, int));
/* Call the function specified by FUNC for each currently available minimal
symbol, for as long as this function continues to return NULL. If the
function ever returns non-NULL, then the iteration over the minimal
symbols is terminated and the result is returned to the caller.
The function called has full control over the form and content of the
information returned via the non-NULL result, which may be as simple as a
pointer to the minimal symbol that the iteration terminated on, or as
complex as a pointer to a private structure containing multiple results. */
PTR
iterate_over_msymbols (func, arg1, arg2, arg3)
PTR (*func) PARAMS ((struct objfile *, struct minimal_symbol *,
PTR, PTR, PTR));
PTR arg1;
PTR arg2;
PTR arg3;
{
register struct objfile *objfile;
register struct minimal_symbol *msymbol;
char *result = NULL;
for (objfile = object_files;
objfile != NULL && result == NULL;
objfile = objfile -> next)
{
for (msymbol = objfile -> msymbols;
msymbol != NULL && msymbol -> name != NULL && result == NULL;
msymbol++)
{
result = (*func)(objfile, msymbol, arg1, arg2, arg3);
}
}
return (result);
}
/* Look through all the current minimal symbol tables and find the first
minimal symbol that matches NAME. If OBJF is non-NULL, it specifies a
particular objfile and the search is limited to that objfile. Returns
@ -345,7 +309,7 @@ discard_minimal_symbols (foo)
while (msym_bunch != NULL)
{
next = msym_bunch -> next;
free (msym_bunch);
free ((PTR)msym_bunch);
msym_bunch = next;
}
}

260
gdb/mipsread.c
View File

@ -71,7 +71,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#endif /* not CMUCS */
#include "coff/mips.h"
#include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
#include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
#include "aout/aout64.h"
#include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
#include "coff/ecoff-ext.h"
@ -209,50 +209,88 @@ struct type *builtin_type_string;
/* Forward declarations */
static void
fixup_symtab ();
fixup_symtab PARAMS ((HDRR *, char *, int, bfd *));
static void
read_mips_symtab ();
read_mips_symtab PARAMS ((struct objfile *, int));
static void
read_the_mips_symtab PARAMS ((bfd *, int, CORE_ADDR));
static int
upgrade_type ();
upgrade_type PARAMS ((struct type **, int, union aux_ent *, int));
static void
parse_partial_symbols();
parse_partial_symbols PARAMS ((int, struct objfile *));
static int
cross_ref();
cross_ref PARAMS ((union aux_ext *, struct type **, int, char **, int));
static void
fixup_sigtramp();
fixup_sigtramp PARAMS ((void));
static struct symbol *new_symbol();
static struct type *new_type();
static struct block *new_block();
static struct symtab *new_symtab();
static struct linetable *new_linetable();
static struct blockvector *new_bvect();
static struct symbol *
new_symbol PARAMS ((char *));
static struct type *parse_type();
static struct symbol *mylookup_symbol();
static struct block *shrink_block();
static void sort_blocks();
static struct type *
new_type PARAMS ((char *));
static int compare_symtabs();
static int compare_psymtabs();
static int compare_blocks();
static struct block *
new_block PARAMS ((int));
static struct partial_symtab *new_psymtab();
static struct partial_symtab *parse_fdr();
static int compare_psymbols();
static struct symtab *
new_symtab PARAMS ((char *, int, int, struct objfile *));
static void psymtab_to_symtab_1();
static void add_block();
static void add_symbol();
static int add_line();
static struct linetable *shrink_linetable();
static char* mips_next_symbol_text ();
static struct linetable *
new_linetable PARAMS ((int));
static struct blockvector *
new_bvect PARAMS ((int));
static struct type *
parse_type PARAMS ((union aux_ext *, int *, int));
static struct symbol *
mylookup_symbol PARAMS ((char *, struct block *, enum namespace,
enum address_class));
static struct block *
shrink_block PARAMS ((struct block *, struct symtab *));
static PTR
xzalloc PARAMS ((unsigned int));
static void
sort_blocks PARAMS ((struct symtab *));
static int
compare_blocks PARAMS ((struct block **, struct block **));
static struct partial_symtab *
new_psymtab PARAMS ((char *, struct objfile *));
#if 0
static struct partial_symtab *
parse_fdr PARAMS ((int, int, struct objfile *));
#endif
static void
psymtab_to_symtab_1 PARAMS ((struct partial_symtab *, char *));
static void
add_block PARAMS ((struct block *, struct symtab *));
static void
add_symbol PARAMS ((struct symbol *, struct block *));
static int
add_line PARAMS ((struct linetable *, int, CORE_ADDR, int));
static struct linetable *
shrink_linetable PARAMS ((struct linetable *));
static char *
mips_next_symbol_text PARAMS ((void));
/* Things we export to other modules */
@ -262,8 +300,8 @@ static char* mips_next_symbol_text ();
CORE_ADDR sigtramp_address, sigtramp_end;
void
mipscoff_new_init (objfile)
struct objfile *objfile;
mipscoff_new_init (ignore)
struct objfile *ignore;
{
}
@ -323,17 +361,18 @@ mipscoff_symfile_finish (objfile)
if (cur_hdr)
{
free ((char *)cur_hdr);
free ((PTR)cur_hdr);
}
cur_hdr = 0;
}
/* Allocate zeroed memory */
static char *
static PTR
xzalloc(size)
int size;
{
char *p = xmalloc(size);
PTR p = xmalloc(size);
memset(p, 0, size);
return p;
@ -348,8 +387,6 @@ static void
mipscoff_psymtab_to_symtab(pst)
struct partial_symtab *pst;
{
struct symtab *ret;
int i;
if (!pst)
return;
@ -376,9 +413,9 @@ mipscoff_psymtab_to_symtab(pst)
/* Exported procedure: Is PC in the signal trampoline code */
int
in_sigtramp(pc, name)
in_sigtramp(pc, ignore)
CORE_ADDR pc;
char *name;
char *ignore; /* function name */
{
if (sigtramp_address == 0)
fixup_sigtramp();
@ -390,9 +427,9 @@ in_sigtramp(pc, name)
/* Read the symtab information from file FSYM into memory. Also,
return address just past end of our text segment in *END_OF_TEXT_SEGP. */
static
static void
read_the_mips_symtab(abfd, fsym, end_of_text_segp)
bfd *abfd;
bfd *abfd;
int fsym;
CORE_ADDR *end_of_text_segp;
{
@ -416,7 +453,7 @@ read_the_mips_symtab(abfd, fsym, end_of_text_segp)
st_hdrsize = bfd_h_get_32 (abfd, filhdr.f.f_nsyms);
st_filptr = bfd_h_get_32 (abfd, filhdr.f.f_symptr);
if (st_filptr == 0)
return 0;
return;
lseek(fsym, st_filptr, L_SET);
if (st_hdrsize != sizeof (hdr_ext)) { /* Profanity check */
@ -434,7 +471,7 @@ read_the_mips_symtab(abfd, fsym, end_of_text_segp)
/* Allocate space for the symbol table. Read it in. */
cur_hdr = (HDRR *) xmalloc(stsize + st_hdrsize);
memcpy(cur_hdr, &hdr_ext, st_hdrsize);
memcpy((PTR)cur_hdr, (PTR)&hdr_ext, st_hdrsize);
if (read(fsym, (char *) cur_hdr + st_hdrsize, stsize) != stsize)
goto readerr;
@ -769,22 +806,6 @@ struct mips_pending *is_pending_symbol(fh, sh)
return p;
}
/* Check whether we already saw type T in file FH as undefined */
static
struct mips_pending *is_pending_type(fh, t)
FDR *fh;
struct type *t;
{
int f_idx = fh - (FDR *) cur_hdr->cbFdOffset;
register struct mips_pending *p;
for (p = pending_list[f_idx]; p; p = p->next)
if (p->t == t)
break;
return p;
}
/* Add a new undef symbol SH of type T */
static
@ -808,6 +829,7 @@ add_pending(fh, sh, t)
}
/* Throw away undef entries when done with file index F_IDX */
/* FIXME -- storage leak. This is never called!!! --gnu */
static
free_pending(f_idx)
@ -816,7 +838,7 @@ free_pending(f_idx)
for (p = pending_list[f_idx]; p; p = q) {
q = p->next;
free(p);
free((PTR)p);
}
pending_list[f_idx] = 0;
}
@ -857,6 +879,7 @@ lookup_numargs(adr)
}
/* Release storage when done with this file */
/* FIXME -- storage leak. This is never called! --gnu */
static void
free_numargs()
@ -865,7 +888,7 @@ free_numargs()
while (n) {
m = n->next;
free(n);
free((PTR)n);
n = m;
}
numargs_list = 0;
@ -1172,7 +1195,8 @@ parse_symbol(sh, ax, bigend)
if (pend)
t = is_pending_symbol(cur_fdr, sh)->t;
else
t = new_type(prepend_tag_kind(sh->iss, type_code));
t = new_type(prepend_tag_kind((char *)sh->iss,
type_code));
TYPE_CODE(t) = type_code;
TYPE_LENGTH(t) = sh->value;
@ -1193,7 +1217,7 @@ parse_symbol(sh, ax, bigend)
enum_sym = (struct symbol *)
obstack_alloc (&current_objfile->symbol_obstack,
sizeof (struct symbol));
memset (enum_sym, 0, sizeof (struct symbol));
memset ((PTR)enum_sym, 0, sizeof (struct symbol));
SYMBOL_NAME (enum_sym) = f->name;
SYMBOL_CLASS (enum_sym) = LOC_CONST;
SYMBOL_TYPE (enum_sym) = t;
@ -1303,7 +1327,8 @@ parse_symbol(sh, ax, bigend)
We must byte-swap the AX entries before we use them; BIGEND says whether
they are big-endian or little-endian (from fh->fBigendian). */
static struct type *parse_type(ax, bs, bigend)
static struct type *
parse_type(ax, bs, bigend)
union aux_ext *ax;
int *bs;
int bigend;
@ -1343,7 +1368,6 @@ static struct type *parse_type(ax, bs, bigend)
TIR t[1];
struct type *tp = 0;
char *fmt;
int i;
union aux_ext *tax;
int type_code;
@ -1443,8 +1467,6 @@ static struct type *parse_type(ax, bs, bigend)
/* Deal with range types */
if (t->bt == btRange) {
struct field *f;
TYPE_NFIELDS (tp) = 2;
TYPE_FIELDS (tp) =
(struct field *) obstack_alloc (&current_objfile -> type_obstack,
@ -1491,6 +1513,7 @@ again: PARSE_TQ(tq0);
static int
upgrade_type(tpp, tq, ax, bigend)
struct type **tpp;
int tq;
union aux_ext *ax;
int bigend;
{
@ -1535,16 +1558,16 @@ upgrade_type(tpp, tq, ax, bigend)
/* FIXME - Memory leak! */
if (TYPE_NFIELDS(t))
TYPE_FIELDS(t) = (struct field*)
xrealloc((char *) TYPE_FIELDS(t),
xrealloc((PTR) TYPE_FIELDS(t),
(TYPE_NFIELDS(t)+1) * sizeof(struct field));
else
TYPE_FIELDS(t) = (struct field*)
xzalloc(sizeof(struct field));
f = &(TYPE_FIELD(t,TYPE_NFIELDS(t)));
TYPE_NFIELDS(t)++;
memset(f, 0, sizeof(struct field));
memset((PTR)f, 0, sizeof(struct field));
/* XXX */ f->type = parse_type(fh->iauxBase + id * sizeof(union aux_ext),
/* XXX */ f->type = parse_type(id + (union aux_ext *)fh->iauxBase,
&f->bitsize, bigend);
ax++;
@ -1689,7 +1712,7 @@ parse_external(es, skip_procedures, bigend)
n_undef_symbols++;
if (info_verbose)
printf_filtered("Warning: %s `%s' is undefined (in %s)\n", what,
es->asym.iss, fdr_name(cur_fdr->rss));
es->asym.iss, fdr_name((char *)cur_fdr->rss));
return;
}
@ -1727,7 +1750,7 @@ parse_lines(fh, lt)
struct linetable *lt;
{
unsigned char *base = (unsigned char*)fh->cbLineOffset;
int i, j, k;
int j, k;
int delta, count, lineno = 0;
PDR *pr;
@ -1735,7 +1758,7 @@ parse_lines(fh, lt)
return;
/* Scan by procedure descriptors */
i = 0; j = 0, k = 0;
j = 0, k = 0;
for (pr = (PDR*)IPDFIRST(cur_hdr,fh); j < fh->cpd; j++, pr++) {
int l, halt;
@ -1799,7 +1822,6 @@ parse_partial_symbols(end_of_text_seg, objfile)
HDRR *hdr = cur_hdr;
/* Running pointers */
FDR *fh;
RFDT *rh;
register EXTR *esh;
register SYMR *sh;
struct partial_symtab *pst;
@ -1896,7 +1918,7 @@ parse_partial_symbols(end_of_text_seg, objfile)
complain (&unknown_ext_complaint,
(char *)(esh->asym.iss));
}
prim_record_minimal_symbol ((char *)(esh->asym.iss),
prim_record_minimal_symbol ((char *)esh->asym.iss,
esh->asym.value,
ms_type);
}
@ -2234,7 +2256,7 @@ psymtab_to_symtab_1(pst, filename)
char *filename;
{
int have_stabs;
int i, f_max;
int i, f_max;
struct symtab *st;
FDR *fh;
int maxlines;
@ -2327,12 +2349,9 @@ psymtab_to_symtab_1(pst, filename)
if (fh) {
SYMR *sh;
PDR *pr;
int f_idx = cur_fd;
char *fh_name = (char*)fh->rss;
/* Parse local symbols first */
if (have_stabs) {
if (fh->csym <= 2)
{
@ -2360,7 +2379,8 @@ psymtab_to_symtab_1(pst, filename)
: fh[1].adr;
for (cur_sdx = 0; cur_sdx < fh->csym; ) {
sh = (SYMR *) (fh->isymBase) + cur_sdx;
cur_sdx += parse_symbol(sh, fh->iauxBase, fh->fBigendian);
cur_sdx += parse_symbol(sh, (union aux_ent *)fh->iauxBase,
fh->fBigendian);
}
/* Procedures next, note we need to look-ahead to
@ -2521,7 +2541,8 @@ mylookup_symbol (name, block, namespace, class)
return sym;
bot++;
}
if (block = BLOCK_SUPERBLOCK (block))
block = BLOCK_SUPERBLOCK (block);
if (block)
return mylookup_symbol (name, block, namespace, class);
return 0;
}
@ -2571,7 +2592,7 @@ add_block(b,s)
{
struct blockvector *bv = BLOCKVECTOR(s);
bv = (struct blockvector *)xrealloc((char *) bv,
bv = (struct blockvector *)xrealloc((PTR) bv,
sizeof(struct blockvector) +
BLOCKVECTOR_NBLOCKS(bv)
* sizeof(bv->block));
@ -2602,49 +2623,13 @@ add_line(lt, lineno, adr, last)
lt->item[lt->nitems++].pc = adr << 2;
return lineno;
}
/* Comparison functions, used when sorting things */
/* Symtabs must be ordered viz the code segments they cover */
static int
compare_symtabs( s1, s2)
struct symtab **s1, **s2;
{
/* "most specific" first */
register struct block *b1, *b2;
b1 = BLOCKVECTOR_BLOCK(BLOCKVECTOR(*s1),GLOBAL_BLOCK);
b2 = BLOCKVECTOR_BLOCK(BLOCKVECTOR(*s2),GLOBAL_BLOCK);
if (BLOCK_END(b1) == BLOCK_END(b2))
return BLOCK_START(b1) - BLOCK_START(b2);
return BLOCK_END(b1) - BLOCK_END(b2);
}
/* Partial Symtabs, same */
static int
compare_psymtabs( s1, s2)
struct partial_symtab **s1, **s2;
{
/* Perf twist: put the ones with no code at the end */
register int a = (*s1)->textlow;
register int b = (*s2)->textlow;
if (a == 0)
return b;
if (b == 0)
return -a;
return a - b;
}
/* Sorting and reordering procedures */
/* Blocks with a smaller low bound should come first */
static int compare_blocks(b1,b2)
static int
compare_blocks(b1, b2)
struct block **b1, **b2;
{
register int addr_diff;
@ -2655,9 +2640,6 @@ static int compare_blocks(b1,b2)
return addr_diff;
}
/* Sorting and reordering procedures */
/* Sort the blocks of a symtab S.
Reorder the blocks in the blockvector by code-address,
as required by some MI search routines */
@ -2762,31 +2744,36 @@ new_psymtab(name, objfile)
}
/* Allocate a linetable array of the given SIZE */
/* Allocate a linetable array of the given SIZE. Since the struct
already includes one item, we subtract one when calculating the
proper size to allocate. */
static struct linetable *
new_linetable(size)
int size;
{
struct linetable *l;
size = size * sizeof(l->item) + sizeof(struct linetable);
size = (size-1) * sizeof(l->item) + sizeof(struct linetable);
l = (struct linetable *)xmalloc(size);
l->nitems = 0;
return l;
}
/* Oops, too big. Shrink it. This was important with the 2.4 linetables,
I am not so sure about the 3.4 ones */
I am not so sure about the 3.4 ones.
Since the struct linetable already includes one item, we subtract one when
calculating the proper size to allocate. */
static struct linetable *
shrink_linetable(lt)
struct linetable * lt;
{
struct linetable *l = new_linetable(lt->nitems);
memcpy(l, lt, lt->nitems * sizeof(l->item) + sizeof(struct linetable));
free (lt);
return l;
return (struct linetable *) xrealloc ((PTR)lt,
sizeof(struct linetable)
+ (lt->nitems - 1) * sizeof(lt->item));
}
/* Allocate and zero a new blockvector of NBLOCKS blocks. */
@ -2794,6 +2781,7 @@ shrink_linetable(lt)
static
struct blockvector *
new_bvect(nblocks)
int nblocks;
{
struct blockvector *bv;
int size;
@ -2811,11 +2799,11 @@ new_bvect(nblocks)
static
struct block *
new_block(maxsyms)
int maxsyms;
{
int size = sizeof(struct block) + (maxsyms-1) * sizeof(struct symbol *);
struct block *b = (struct block *)xzalloc(size);
return b;
return (struct block *)xzalloc (size);
}
/* Ooops, too big. Shrink block B in symtab S to its minimal size.
@ -2832,8 +2820,8 @@ shrink_block(b, s)
/* Just reallocate it and fix references to the old one */
new = (struct block *) xrealloc ((char *)b, sizeof(struct block) +
(BLOCK_NSYMS(b)-1) * sizeof(struct symbol *));
new = (struct block *) xrealloc ((PTR)b, sizeof(struct block) +
(BLOCK_NSYMS(b)-1) * sizeof(struct symbol *));
/* Should chase pointers to old one. Fortunately, that`s just
the block`s function and inferior blocks */
@ -2857,7 +2845,7 @@ new_symbol(name)
struct symbol *s = (struct symbol *)
obstack_alloc (&current_objfile->symbol_obstack, sizeof (struct symbol));
memset (s, 0, sizeof (*s));
memset ((PTR)s, 0, sizeof (*s));
SYMBOL_NAME(s) = name;
return s;
}
@ -2961,11 +2949,13 @@ fixup_sigtramp()
e->fregoffset = -(37 * sizeof(int));
e->isym = (long)s;
current_objfile = st->objfile; /* Keep new_symbol happy */
s = new_symbol(".gdbinfo.");
SYMBOL_VALUE(s) = (int) e;
SYMBOL_NAMESPACE(s) = LABEL_NAMESPACE;
SYMBOL_CLASS(s) = LOC_CONST;
SYMBOL_TYPE(s) = builtin_type_void;
current_objfile = NULL;
}
BLOCK_SYM(b,BLOCK_NSYMS(b)++) = s;

124
gdb/objfiles.c
View File

@ -272,17 +272,15 @@ int
have_partial_symbols ()
{
struct objfile *ofp;
int havethem = 0;
for (ofp = object_files; ofp; ofp = ofp -> next)
ALL_OBJFILES (ofp)
{
if (ofp -> psymtabs != NULL)
{
havethem++;
break;
return 1;
}
}
return (havethem);
return 0;
}
/* Many places in gdb want to test just to see if we have any full
@ -293,17 +291,15 @@ int
have_full_symbols ()
{
struct objfile *ofp;
int havethem = 0;
for (ofp = object_files; ofp; ofp = ofp -> next)
ALL_OBJFILES (ofp)
{
if (ofp -> symtabs != NULL)
{
havethem++;
break;
return 1;
}
}
return (havethem);
return 0;
}
/* Many places in gdb want to test just to see if we have any minimal
@ -314,119 +310,17 @@ int
have_minimal_symbols ()
{
struct objfile *ofp;
int havethem = 0;
for (ofp = object_files; ofp; ofp = ofp -> next)
ALL_OBJFILES (ofp)
{
if (ofp -> msymbols != NULL)
{
havethem++;
break;
return 1;
}
}
return (havethem);
return 0;
}
/* Call the function specified by FUNC for each currently available objfile,
for as long as this function continues to return NULL. If the function
ever returns non-NULL, then the iteration over the objfiles is terminated,
and the result is returned to the caller. The function called has full
control over the form and content of the information returned via the
non-NULL result, which may be as simple as a pointer to the objfile that
the iteration terminated on, or as complex as a pointer to a private
structure containing multiple results. */
PTR
iterate_over_objfiles (func, arg1, arg2, arg3)
PTR (*func) PARAMS ((struct objfile *, PTR, PTR, PTR));
PTR arg1;
PTR arg2;
PTR arg3;
{
register struct objfile *objfile;
PTR result = NULL;
for (objfile = object_files;
objfile != NULL && result == NULL;
objfile = objfile -> next)
{
result = (*func)(objfile, arg1, arg2, arg3);
}
return (result);
}
/* Call the function specified by FUNC for each currently available symbol
table, for as long as this function continues to return NULL. If the
function ever returns non-NULL, then the iteration over the symbol tables
is terminated, and the result is returned to the caller. The function
called has full control over the form and content of the information
returned via the non-NULL result, which may be as simple as a pointer
to the symtab that the iteration terminated on, or as complex as a
pointer to a private structure containing multiple results. */
PTR
iterate_over_symtabs (func, arg1, arg2, arg3)
PTR (*func) PARAMS ((struct objfile *, struct symtab *, PTR, PTR, PTR));
PTR arg1;
PTR arg2;
PTR arg3;
{
register struct objfile *objfile;
register struct symtab *symtab;
PTR result = NULL;
for (objfile = object_files;
objfile != NULL && result == NULL;
objfile = objfile -> next)
{
for (symtab = objfile -> symtabs;
symtab != NULL && result == NULL;
symtab = symtab -> next)
{
result = (*func)(objfile, symtab, arg1, arg2, arg3);
}
}
return (result);
}
/* Call the function specified by FUNC for each currently available partial
symbol table, for as long as this function continues to return NULL. If
the function ever returns non-NULL, then the iteration over the partial
symbol tables is terminated, and the result is returned to the caller.
The function called has full control over the form and content of the
information returned via the non-NULL result, which may be as simple as a
pointer to the partial symbol table that the iteration terminated on, or
as complex as a pointer to a private structure containing multiple
results. */
PTR
iterate_over_psymtabs (func, arg1, arg2, arg3)
PTR (*func) PARAMS ((struct objfile *, struct partial_symtab *,
PTR, PTR, PTR));
PTR arg1;
PTR arg2;
PTR arg3;
{
register struct objfile *objfile;
register struct partial_symtab *psymtab;
PTR result = NULL;
for (objfile = object_files;
objfile != NULL && result == NULL;
objfile = objfile -> next)
{
for (psymtab = objfile -> psymtabs;
psymtab != NULL && result == NULL;
psymtab = psymtab -> next)
{
result = (*func)(objfile, psymtab, arg1, arg2, arg3);
}
}
return (result);
}
/* Look for a mapped symbol file that corresponds to FILENAME and is more
recent than MTIME. If MAPPED is nonzero, the user has asked that gdb
use a mapped symbol file for this file, so create a new one if one does

40
gdb/objfiles.h
View File

@ -293,30 +293,34 @@ have_full_symbols PARAMS ((void));
extern int
have_minimal_symbols PARAMS ((void));
extern PTR
iterate_over_objfiles PARAMS ((PTR (*func) (struct objfile *,
PTR arg1, PTR arg2, PTR arg3),
PTR arg1, PTR arg2, PTR arg3));
extern PTR
iterate_over_symtabs PARAMS ((PTR (*func) (struct objfile *, struct symtab *,
PTR arg1, PTR arg2, PTR arg3),
PTR arg1, PTR arg2, PTR arg3));
extern PTR
iterate_over_psymtabs PARAMS ((PTR (*func) (struct objfile *,
struct partial_symtab *,
PTR arg1, PTR arg2, PTR arg3),
PTR arg1, PTR arg2, PTR arg3));
/* Traverse all object files. ALL_OBJFILES_SAFE works even if you delete
the objfile during the traversal. */
#define ALL_OBJFILES(obj) \
for ((obj)=object_files; (obj)!=NULL; (obj)=(obj)->next)
for ((obj) = object_files; (obj) != NULL; (obj) = (obj)->next)
#define ALL_OBJFILES_SAFE(obj,nxt) \
for ((obj)=object_files; (obj)!=NULL?((nxt)=(obj)->next,1):0; (obj)=(nxt))
for ((obj) = object_files; \
(obj) != NULL? ((nxt)=(obj)->next,1) :0; \
(obj) = (nxt))
/* Traverse all symtabs in all objfiles. */
#define ALL_SYMTABS(objfile, s) \
ALL_OBJFILES (objfile) \
for ((s) = (objfile) -> symtabs; (s) != NULL; (s) = (s) -> next)
/* Traverse all psymtabs in all objfiles. */
#define ALL_PSYMTABS(objfile, p) \
ALL_OBJFILES (objfile) \
for ((p) = (objfile) -> psymtabs; (p) != NULL; (p) = (p) -> next)
/* Traverse all minimal symbols in all objfiles. */
#define ALL_MSYMBOLS(objfile, m) \
ALL_OBJFILES (objfile) \
for ((m) = (objfile) -> msymbols; (m)->name != NULL; (m)++)
#endif /* !defined (OBJFILES_H) */

61
gdb/xcoffexec.c
View File

@ -355,48 +355,6 @@ map_vmap (bfd *bf, bfd *arch)
}
#define FASTER_MSYMBOL_RELOCATION 1
#ifdef FASTER_MSYMBOL_RELOCATION
/* Used to relocate an object file's minimal symbols. */
static void
reloc_objfile_msymbols (objf, addr)
struct objfile *objf;
CORE_ADDR addr;
{
register struct minimal_symbol *msymbol;
int ii;
for (msymbol = objf->msymbols, ii=0;
msymbol && ii < objf->minimal_symbol_count; ++msymbol, ++ii)
if (msymbol->address < TEXT_SEGMENT_BASE)
msymbol->address += addr;
}
#else /* !FASTER_MSYMBOL_RELOCATION */
/* Called via iterate_over_msymbols to relocate minimal symbols */
static int
relocate_minimal_symbol (objfile, msymbol, arg1, arg2, arg3)
struct objfile *objfile;
struct minimal_symbol *msymbol;
PTR arg1;
PTR arg2;
PTR arg3;
{
if (msymbol->address < TEXT_SEGMENT_BASE)
msymbol -> address += (int) arg1;
/* return 0, otherwise `iterate_over_msymbols()' will stop at the
first iteration. */
return 0;
}
#endif /* FASTER_MSYMBOL_RELOCATION */
/* true, if symbol table and minimal symbol table are relocated. */
int symtab_relocated = 0;
@ -411,11 +369,12 @@ struct stat *vip;
{
register struct symtab *s;
register struct objfile *objfile;
register struct minimal_symbol *msymbol;
/*
* for each symbol table generated from the vp->bfd
*/
for (objfile = object_files; objfile != NULL; objfile = objfile -> next)
ALL_OBJFILES (objfile)
{
for (s = objfile -> symtabs; s != NULL; s = s -> next) {
@ -463,25 +422,15 @@ struct stat *vip;
for (; s; s = s->next)
if (!s->nonreloc || LINETABLE(s))
vmap_symtab_1(s, vp, old_start);
#ifdef FASTER_MSYMBOL_RELOCATION
/* we can rely on the fact that at least one symtab in this objfile
will get relocated. Thus, we can be sure that minimal symbol
vector is guaranteed for relocation. */
reloc_objfile_msymbols (objfile, vp->tstart - old_start);
#endif
break;
}
}
}
if (vp->tstart != old_start) {
#ifndef FASTER_MSYMBOL_RELOCATION
(void) iterate_over_msymbols (relocate_minimal_symbol,
(PTR) (vp->tstart - old_start),
(PTR) NULL, (PTR) NULL);
#endif
ALL_MSYMBOLS (objfile, msymbol)
if (msymbol->address < TEXT_SEGMENT_BASE)
msymbol -> address += vp->tstart - old_start;
/* breakpoints need to be relocated as well. */
fixup_breakpoints (0, TEXT_SEGMENT_BASE, vp->tstart - old_start);

181
gdb/xcoffread.c
View File

@ -313,7 +313,7 @@ struct pending_stabs *stabs;
struct symbol *sym = find_symbol_in_list (symbols, name, pp-name);
if (!sym) {
;
/* printf ("ERROR! stab symbol not found!\n"); /* FIXME */
/* printf ("ERROR! stab symbol not found!\n"); */ /* FIXME */
/* The above is a false alarm. There are cases the we can have
a stab, without its symbol. xlc generates this for the extern
definitions in inner blocks. */
@ -2387,182 +2387,9 @@ smash_to_pointer_type (type, to_type)
#else /* IBM6000_HOST */
struct type *
builtin_type (pp)
char **pp;
builtin_type (ignore)
char **ignore;
{
fatal ("internals eror: builtin_type called!");
fatal ("GDB internal eror: builtin_type called on non-RS/6000!");
}
#endif /* IBM6000_HOST */
#define DEBUG 1
#if defined (DEBUG) && defined (IBM6000_HOST) /* Needs both defined */
void
dump_strtbl ()
{
int ii;
printf ("===STRING TABLE DUMP...\n\n");
for ( ii=0; ii < strtbl_len; ++ii )
printf ("%c", isprint (*(strtbl+ii)) ? *(strtbl+ii) : ' ');
printf ("\n");
}
void
dump_linetable (ltb)
struct linetable *ltb;
{
int ii;
for (ii=0; ii < ltb->nitems; ++ii)
printf ("line: %d, addr: 0x%x\n", ltb->item[ii].line, ltb->item[ii].pc);
}
void
dump_type (typeP)
struct type *typeP;
{
printf ("0x%x: name: %s\n", typeP, typeP->name ? typeP->name : "(nil)");
}
char *dump_namespace ();
char *dump_addrclass ();
void
dump_symbol (pp)
struct symbol *pp;
{
printf (" sym: %s\t%s,\t%s\ttype: 0x%x, val: 0x%x end: 0x%x\n",
pp->name, dump_namespace (pp->namespace),
dump_addrclass (pp->class), pp->type,
SYMBOL_CLASS(pp) == LOC_BLOCK ? BLOCK_START(SYMBOL_BLOCK_VALUE(pp))
: pp->value.value,
SYMBOL_CLASS(pp) == LOC_BLOCK ? BLOCK_END(SYMBOL_BLOCK_VALUE(pp)) : 0);
}
char *
dump_namespace (ns)
int ns;
{
static char *ns_name [] = {
"UNDEF_NS", "VAR_NS", "STRUCT_NS", "LABEL_NS"};
switch (ns) {
case UNDEF_NAMESPACE:
case VAR_NAMESPACE:
case STRUCT_NAMESPACE:
case LABEL_NAMESPACE:
return ns_name[ns];
}
return "***ERROR***";
}
char *
dump_addrclass (ac)
int ac; /* address class */
{
static char *ac_name [] = {
"LOC_UNDEF",
"LOC_CONST",
"LOC_STATIC",
"LOC_REGISTER",
"LOC_ARG",
"LOC_REF_ARG",
"LOC_REGPARM",
"LOC_LOCAL",
"LOC_TYPEDEF",
"LOC_LABEL",
"LOC_BLOCK",
"LOC_CONST_BYTES",
"LOC_LOCAL_ARG",
};
switch (ac) {
case LOC_UNDEF:
case LOC_CONST:
case LOC_STATIC:
case LOC_REGISTER:
case LOC_ARG:
case LOC_REF_ARG:
case LOC_REGPARM:
case LOC_LOCAL:
case LOC_TYPEDEF:
case LOC_LABEL:
case LOC_BLOCK:
case LOC_CONST_BYTES:
case LOC_LOCAL_ARG:
return ac_name [ac];
}
return "***ERROR***";
}
void
dump_block (pp)
struct block *pp;
{
int ii;
printf ("BLOCK..: start: 0x%x, end: 0x%x\n", pp->startaddr, pp->endaddr);
for (ii=0; ii < pp->nsyms; ++ii)
dump_symbol (pp->sym[ii]);
}
void
dump_blockvector (pp)
struct blockvector *pp;
{
int ii;
for (ii=0; ii < pp->nblocks; ++ii)
dump_block (pp->block [ii]);
}
void
dump_last_symtab (pp)
struct symtab *pp;
{
for ( ; pp; pp = pp->next) {
if ( pp->next == 0 ) {
printf ("SYMTAB NAME: %s\n", pp->filename);
dump_blockvector (pp->blockvector);
}
}
}
void
dump_symtabs (pp)
struct symtab *pp;
{
for ( ; pp; pp = pp->next) {
printf ("SYMTAB NAME: %s\n", pp->filename ? pp->filename : "(nil)");
/* if (pp->linetable)
dump_linetable (pp->linetable); */
dump_blockvector (pp->blockvector);
}
}
void
dump_symtab_lines (pp)
struct symtab *pp;
{
for ( ; pp; pp = pp->next) {
printf ("SYMTAB NAME: %s\n", pp->filename ? pp->filename : "(nil)");
if (pp->linetable)
dump_linetable (pp->linetable);
/* dump_blockvector (pp->blockvector); */
}
}
void
dump_msymbols (of)
struct objfile *of;
{
int ii;
for (ii=0; ii < of->minimal_symbol_count; ++ii)
printf ("name: %s, addr: 0x%x, info: 0x%x\n",
of->msymbols[ii].name,
of->msymbols[ii].address,
of->msymbols[ii].info );
}
#endif /* DEBUG */