* 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.
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};
\f
int
hashname (name)
for (next = free_pendings; next; next = next1)
{
next1 = next->next;
- free (next);
+ free ((PTR)next);
}
free_pendings = 0;
for (bnext = pending_blocks; bnext; bnext = bnext1)
{
bnext1 = bnext->next;
- free (bnext);
+ free ((PTR)bnext);
}
#endif
pending_blocks = 0;
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;
}
name = link->name;
subfile_stack = link->next;
header_file_prev_index = link->prev_index;
- free (link);
+ free ((PTR)link);
return name;
}
if (global_stabs) {
patch_block_stabs (global_symbols, global_stabs, objfile);
- free (global_stabs);
+ free ((PTR)global_stabs);
global_stabs = 0;
}
#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
#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 (®_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 (®_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':
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. */
/* 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));
}
#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"
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 *));
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
*/
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)
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));
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");
}
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
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
while (msym_bunch != NULL)
{
next = msym_bunch -> next;
- free (msym_bunch);
+ free ((PTR)msym_bunch);
msym_bunch = next;
}
}
#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"
/* 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 PARAMS ((struct type **, int, union aux_ent *, int));
+
+static void
+parse_partial_symbols PARAMS ((int, struct objfile *));
static int
-upgrade_type ();
+cross_ref PARAMS ((union aux_ext *, struct type **, int, char **, int));
+
+static void
+fixup_sigtramp PARAMS ((void));
+
+static struct symbol *
+new_symbol PARAMS ((char *));
+
+static struct type *
+new_type PARAMS ((char *));
+
+static struct block *
+new_block PARAMS ((int));
+
+static struct symtab *
+new_symtab PARAMS ((char *, int, int, struct objfile *));
+
+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
-parse_partial_symbols();
+sort_blocks PARAMS ((struct symtab *));
static int
-cross_ref();
+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
-fixup_sigtramp();
-
-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 type *parse_type();
-static struct symbol *mylookup_symbol();
-static struct block *shrink_block();
-static void sort_blocks();
-
-static int compare_symtabs();
-static int compare_psymtabs();
-static int compare_blocks();
-
-static struct partial_symtab *new_psymtab();
-static struct partial_symtab *parse_fdr();
-static int compare_psymbols();
-
-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 ();
+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));
\f
/* Things we export to other modules */
CORE_ADDR sigtramp_address, sigtramp_end;
void
-mipscoff_new_init (objfile)
- struct objfile *objfile;
+mipscoff_new_init (ignore)
+ struct objfile *ignore;
{
}
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;
mipscoff_psymtab_to_symtab(pst)
struct partial_symtab *pst;
{
- struct symtab *ret;
- int i;
if (!pst)
return;
/* 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();
/* 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;
{
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 */
/* 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;
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
}
/* Throw away undef entries when done with file index F_IDX */
+/* FIXME -- storage leak. This is never called!!! --gnu */
static
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;
}
}
/* Release storage when done with this file */
+/* FIXME -- storage leak. This is never called! --gnu */
static void
free_numargs()
while (n) {
m = n->next;
- free(n);
+ free((PTR)n);
n = m;
}
numargs_list = 0;
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;
enum_sym = (struct symbol *)
obstack_alloc (¤t_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;
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;
TIR t[1];
struct type *tp = 0;
char *fmt;
- int i;
union aux_ext *tax;
int type_code;
/* Deal with range types */
if (t->bt == btRange) {
- struct field *f;
-
TYPE_NFIELDS (tp) = 2;
TYPE_FIELDS (tp) =
(struct field *) obstack_alloc (¤t_objfile -> type_obstack,
static int
upgrade_type(tpp, tq, ax, bigend)
struct type **tpp;
+ int tq;
union aux_ext *ax;
int 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++;
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;
}
struct linetable *lt;
{
unsigned char *base = (unsigned char*)fh->cbLineOffset;
- int i, j, k;
+ int j, k;
int delta, count, lineno = 0;
PDR *pr;
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;
HDRR *hdr = cur_hdr;
/* Running pointers */
FDR *fh;
- RFDT *rh;
register EXTR *esh;
register SYMR *sh;
struct partial_symtab *pst;
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);
}
char *filename;
{
int have_stabs;
- int i, f_max;
+ int i, f_max;
struct symtab *st;
FDR *fh;
int maxlines;
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)
{
: 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
return sym;
bot++;
}
- if (block = BLOCK_SUPERBLOCK (block))
+ block = BLOCK_SUPERBLOCK (block);
+ if (block)
return mylookup_symbol (name, block, namespace, class);
return 0;
}
{
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));
lt->item[lt->nitems++].pc = adr << 2;
return lineno;
}
-
-
\f
-/* 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;
return addr_diff;
}
-\f
-/* 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 */
}
-/* 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. */
static
struct blockvector *
new_bvect(nblocks)
+ int nblocks;
{
struct blockvector *bv;
int size;
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.
/* 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 */
struct symbol *s = (struct symbol *)
obstack_alloc (¤t_objfile->symbol_obstack, sizeof (struct symbol));
- memset (s, 0, sizeof (*s));
+ memset ((PTR)s, 0, sizeof (*s));
SYMBOL_NAME(s) = name;
return s;
}
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;
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
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
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
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) */
}
-#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;
{
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) {
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);
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. */
#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 */
projects / binutils-gdb.git / commitdiff