#include "complaints.h"
#include "demangle.h"
#include "gdb_assert.h"
+#include "block.h"
+#include "dictionary.h"
/* These are needed if the tm.h file does not contain the necessary
mips specific definitions. */
static struct type *new_type (char *);
-static struct block *new_block (int);
+enum block_type { FUNCTION_BLOCK, NON_FUNCTION_BLOCK };
-static struct symtab *new_symtab (char *, int, int, struct objfile *);
+static struct block *new_block (enum block_type);
+
+static struct symtab *new_symtab (char *, int, struct objfile *);
static struct linetable *new_linetable (int);
static struct type *parse_type (int, union aux_ext *, unsigned int, int *,
int, char *);
-static struct symbol *mylookup_symbol (char *, struct block *, namespace_enum,
+static struct symbol *mylookup_symbol (char *, struct block *, domain_enum,
enum address_class);
-static struct block *shrink_block (struct block *, struct symtab *);
-
static void sort_blocks (struct symtab *);
static struct partial_symtab *new_psymtab (char *, struct objfile *);
int blocktype;
- int maxsyms; /* Max symbols in this block. */
struct type *cur_type; /* Type we parse fields for. */
int cur_field; /* Field number in cur_type. */
CORE_ADDR procadr; /* Start addres of this procedure */
/* It is a FORTRAN common block. At least for SGI Fortran the
address is not in the symbol; we need to fix it later in
scan_file_globals. */
- int bucket = hashname (SYMBOL_NAME (s));
+ int bucket = hashname (DEPRECATED_SYMBOL_NAME (s));
SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket];
global_sym_chain[bucket] = s;
}
SYMBOL_VALUE (s) = svalue;
data: /* Common code for symbols describing data */
- SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (s) = VAR_DOMAIN;
SYMBOL_CLASS (s) = class;
add_symbol (s, b);
name = "this"; /* FIXME, not alloc'd in obstack */
s = new_symbol (name);
- SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (s) = VAR_DOMAIN;
switch (sh->sc)
{
case scRegister:
case stLabel: /* label, goes into current block */
s = new_symbol (name);
- SYMBOL_NAMESPACE (s) = VAR_NAMESPACE; /* so that it can be used */
+ SYMBOL_DOMAIN (s) = VAR_DOMAIN; /* so that it can be used */
SYMBOL_CLASS (s) = LOC_LABEL; /* but not misused */
SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
SYMBOL_TYPE (s) = mdebug_type_int;
case stProc: /* Procedure, usually goes into global block */
case stStaticProc: /* Static procedure, goes into current block */
+ /* For stProc symbol records, we need to check the storage class
+ as well, as only (stProc, scText) entries represent "real"
+ procedures - See the Compaq document titled "Object File /
+ Symbol Table Format Specification" for more information.
+ If the storage class is not scText, we discard the whole block
+ of symbol records for this stProc. */
+ if (sh->st == stProc && sh->sc != scText)
+ {
+ char *ext_tsym = ext_sh;
+ int keep_counting = 1;
+ SYMR tsym;
+
+ while (keep_counting)
+ {
+ ext_tsym += external_sym_size;
+ (*swap_sym_in) (cur_bfd, ext_tsym, &tsym);
+ count++;
+ switch (tsym.st)
+ {
+ case stParam:
+ break;
+ case stEnd:
+ keep_counting = 0;
+ break;
+ default:
+ complaint (&symfile_complaints,
+ "unknown symbol type 0x%x", sh->st);
+ break;
+ }
+ }
+ break;
+ }
s = new_symbol (name);
- SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (s) = VAR_DOMAIN;
SYMBOL_CLASS (s) = LOC_BLOCK;
/* Type of the return value */
if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil)
TYPE_FLAGS (SYMBOL_TYPE (s)) |= TYPE_FLAG_PROTOTYPED;
/* Create and enter a new lexical context */
- b = new_block (top_stack->maxsyms);
+ b = new_block (FUNCTION_BLOCK);
SYMBOL_BLOCK_VALUE (s) = b;
BLOCK_FUNCTION (b) = s;
BLOCK_START (b) = BLOCK_END (b) = sh->value;
method whose name is identical to the class name
(in particular constructor method names are different
from the class name). There is therefore no risk that
- this check stops the count on the StEnd of a method. */
- if (strcmp (debug_info->ss + cur_fdr->issBase + tsym.iss,
- name) == 0)
+ this check stops the count on the StEnd of a method.
+
+ Also, assume that we're really at the end when tsym.iss
+ is 0 (issNull). */
+ if (tsym.iss == issNull
+ || strcmp (debug_info->ss + cur_fdr->issBase + tsym.iss,
+ name) == 0)
goto end_of_fields;
break;
obstack_alloc (¤t_objfile->symbol_obstack,
sizeof (struct symbol)));
memset (enum_sym, 0, sizeof (struct symbol));
- SYMBOL_NAME (enum_sym) =
+ DEPRECATED_SYMBOL_NAME (enum_sym) =
obsavestring (f->name, strlen (f->name),
¤t_objfile->symbol_obstack);
SYMBOL_CLASS (enum_sym) = LOC_CONST;
SYMBOL_TYPE (enum_sym) = t;
- SYMBOL_NAMESPACE (enum_sym) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (enum_sym) = VAR_DOMAIN;
SYMBOL_VALUE (enum_sym) = tsym.value;
if (SYMBOL_VALUE (enum_sym) < 0)
unsigned_enum = 0;
}
s = new_symbol (name);
- SYMBOL_NAMESPACE (s) = STRUCT_NAMESPACE;
+ SYMBOL_DOMAIN (s) = STRUCT_DOMAIN;
SYMBOL_CLASS (s) = LOC_TYPEDEF;
SYMBOL_VALUE (s) = 0;
SYMBOL_TYPE (s) = t;
}
top_stack->blocktype = stBlock;
- b = new_block (top_stack->maxsyms);
+ b = new_block (NON_FUNCTION_BLOCK);
BLOCK_START (b) = sh->value + top_stack->procadr;
BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
top_stack->cur_block = b;
/* Finished with procedure */
struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st);
struct mips_extra_func_info *e;
- struct block *b;
+ struct block *b = top_stack->cur_block;
struct type *ftype = top_stack->cur_type;
int i;
/* Make up special symbol to contain procedure specific info */
s = new_symbol (MIPS_EFI_SYMBOL_NAME);
- SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
+ SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
SYMBOL_CLASS (s) = LOC_CONST;
SYMBOL_TYPE (s) = mdebug_type_void;
e = ((struct mips_extra_func_info *)
e->pdr.framereg = -1;
add_symbol (s, top_stack->cur_block);
- /* Reallocate symbols, saving memory */
- b = shrink_block (top_stack->cur_block, top_stack->cur_st);
-
/* f77 emits proc-level with address bounds==[0,0],
So look for such child blocks, and patch them. */
for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++)
if (nparams > 0)
{
+ struct dict_iterator iter;
TYPE_NFIELDS (ftype) = nparams;
TYPE_FIELDS (ftype) = (struct field *)
TYPE_ALLOC (ftype, nparams * sizeof (struct field));
- for (i = iparams = 0; iparams < nparams; i++)
+ iparams = 0;
+ ALL_BLOCK_SYMBOLS (b, iter, sym)
{
- sym = BLOCK_SYM (b, i);
+ if (iparams == nparams)
+ break;
+
switch (SYMBOL_CLASS (sym))
{
case LOC_ARG:
displacement from the procedure`s start address of the
end of this block. */
BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr;
- shrink_block (top_stack->cur_block, top_stack->cur_st);
}
else if (sh->sc == scText && top_stack->blocktype == stNil)
{
if (has_opaque_xref (cur_fdr, sh))
break;
s = new_symbol (name);
- SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (s) = VAR_DOMAIN;
SYMBOL_CLASS (s) = LOC_TYPEDEF;
SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block;
SYMBOL_TYPE (s) = t;
for anything except pointers or functions. */
}
else
- TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_NAME (s);
+ TYPE_NAME (SYMBOL_TYPE (s)) = DEPRECATED_SYMBOL_NAME (s);
}
break;
if (t->fBitfield)
{
int width = AUX_GET_WIDTH (bigend, ax);
-
- /* Inhibit core dumps with some cfront generated objects that
- corrupt the TIR. */
+#if 0 /* OBSOLETE CFront */
+// OBSOLETE /* Inhibit core dumps with some cfront generated objects that
+// OBSOLETE corrupt the TIR. */
+#endif /* OBSOLETE CFront */
+ /* Inhibit core dumps if TIR is corrupted. */
if (bs == (int *) NULL)
{
/* Alpha cc -migrate encodes char and unsigned char types
the same name exists, lookup_symbol will eventually read in the symtab
for the global function and clobber cur_fdr. */
FDR *save_cur_fdr = cur_fdr;
- s = lookup_symbol (sh_name, NULL, VAR_NAMESPACE, 0, NULL);
+ s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0, NULL);
cur_fdr = save_cur_fdr;
#else
s = mylookup_symbol
(sh_name,
BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab), STATIC_BLOCK),
- VAR_NAMESPACE,
+ VAR_DOMAIN,
LOC_BLOCK);
#endif
}
else
s = mylookup_symbol (sh_name, top_stack->cur_block,
- VAR_NAMESPACE, LOC_BLOCK);
+ VAR_DOMAIN, LOC_BLOCK);
if (s != 0)
{
#else
/* FIXME -- delete. We can't do symbol allocation now; it's all done. */
s = new_symbol (sh_name);
- SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (s) = VAR_DOMAIN;
SYMBOL_CLASS (s) = LOC_BLOCK;
/* Donno its type, hope int is ok */
SYMBOL_TYPE (s) = lookup_function_type (mdebug_type_int);
#endif
}
- i = mylookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_NAMESPACE, LOC_CONST);
+ i = mylookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, LOC_CONST);
if (i)
{
psymtab_include_list = (char **)
alloca ((includes_allocated *= 2) *
sizeof (char *));
- memcpy ((PTR) psymtab_include_list, (PTR) orig,
+ memcpy (psymtab_include_list, orig,
includes_used * sizeof (char *));
}
continue;
namestring = STATIC_TRANSFORM_NAME (namestring);
#endif
add_psymbol_to_list (namestring, p - namestring,
- VAR_NAMESPACE, LOC_STATIC,
+ VAR_DOMAIN, LOC_STATIC,
&objfile->static_psymbols,
0, sh.value,
psymtab_language, objfile);
/* The addresses in these entries are reported to be
wrong. See the code that reads 'G's for symtabs. */
add_psymbol_to_list (namestring, p - namestring,
- VAR_NAMESPACE, LOC_STATIC,
+ VAR_DOMAIN, LOC_STATIC,
&objfile->global_psymbols,
0, sh.value,
psymtab_language, objfile);
&& namestring[0] != ' '))
{
add_psymbol_to_list (namestring, p - namestring,
- STRUCT_NAMESPACE, LOC_TYPEDEF,
+ STRUCT_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
sh.value, 0,
psymtab_language, objfile);
{
/* Also a typedef with the same name. */
add_psymbol_to_list (namestring, p - namestring,
- VAR_NAMESPACE, LOC_TYPEDEF,
+ VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
sh.value, 0,
psymtab_language, objfile);
p += 1;
}
- /* The semantics of C++ state that "struct foo { ... }"
- also defines a typedef for "foo". Unfortuantely, cfront
- never makes the typedef when translating from C++ to C.
- We make the typedef here so that "ptype foo" works as
- expected for cfront translated code. */
- else if (psymtab_language == language_cplus)
- {
- /* Also a typedef with the same name. */
- add_psymbol_to_list (namestring, p - namestring,
- VAR_NAMESPACE, LOC_TYPEDEF,
- &objfile->static_psymbols,
- sh.value, 0,
- psymtab_language, objfile);
- }
+#if 0 /* OBSOLETE CFront */
+// OBSOLETE /* The semantics of C++ state that "struct foo { ... }"
+// OBSOLETE also defines a typedef for "foo". Unfortuantely, cfront
+// OBSOLETE never makes the typedef when translating from C++ to C.
+// OBSOLETE We make the typedef here so that "ptype foo" works as
+// OBSOLETE expected for cfront translated code. */
+// OBSOLETE else if (psymtab_language == language_cplus)
+// OBSOLETE {
+// OBSOLETE /* Also a typedef with the same name. */
+// OBSOLETE add_psymbol_to_list (namestring, p - namestring,
+// OBSOLETE VAR_DOMAIN, LOC_TYPEDEF,
+// OBSOLETE &objfile->static_psymbols,
+// OBSOLETE sh.value, 0,
+// OBSOLETE psymtab_language, objfile);
+// OBSOLETE }
+#endif /* OBSOLETE CFront */
}
goto check_enum;
case 't':
if (p != namestring) /* a name is there, not just :T... */
{
add_psymbol_to_list (namestring, p - namestring,
- VAR_NAMESPACE, LOC_TYPEDEF,
+ VAR_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
sh.value, 0,
psymtab_language, objfile);
/* Note that the value doesn't matter for
enum constants in psymtabs, just in symtabs. */
add_psymbol_to_list (p, q - p,
- VAR_NAMESPACE, LOC_CONST,
+ VAR_DOMAIN, LOC_CONST,
&objfile->static_psymbols, 0,
0, psymtab_language, objfile);
/* Point past the name. */
case 'c':
/* Constant, e.g. from "const" in Pascal. */
add_psymbol_to_list (namestring, p - namestring,
- VAR_NAMESPACE, LOC_CONST,
+ VAR_DOMAIN, LOC_CONST,
&objfile->static_psymbols, sh.value,
0, psymtab_language, objfile);
continue;
}
sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
add_psymbol_to_list (namestring, p - namestring,
- VAR_NAMESPACE, LOC_BLOCK,
+ VAR_DOMAIN, LOC_BLOCK,
&objfile->static_psymbols,
0, sh.value,
psymtab_language, objfile);
}
sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
add_psymbol_to_list (namestring, p - namestring,
- VAR_NAMESPACE, LOC_BLOCK,
+ VAR_DOMAIN, LOC_BLOCK,
&objfile->global_psymbols,
0, sh.value,
psymtab_language, objfile);
case '9':
case '-':
case '#': /* for symbol identification (used in live ranges) */
- /* added to support cfront stabs strings */
- case 'Z': /* for definition continuations */
- case 'P': /* for prototypes */
+#if 0 /* OBSOLETE CFront */
+// OBSOLETE /* added to support cfront stabs strings */
+// OBSOLETE case 'Z': /* for definition continuations */
+// OBSOLETE case 'P': /* for prototypes */
+#endif /* OBSOLETE CFront */
continue;
case ':':
/* FALLTHROUGH */
case stProc:
- /* Usually there is a local and a global stProc symbol
- for a function. This means that the function name
- has already been entered into the mimimal symbol table
- while processing the global symbols in pass 2 above.
- One notable exception is the PROGRAM name from
- f77 compiled executables, it is only put out as
- local stProc symbol, and a global MAIN__ stProc symbol
- points to it. It doesn't matter though, as gdb is
- still able to find the PROGRAM name via the partial
- symbol table, and the MAIN__ symbol via the minimal
- symbol table. */
- if (sh.st == stProc)
- add_psymbol_to_list (name, strlen (name),
- VAR_NAMESPACE, LOC_BLOCK,
- &objfile->global_psymbols,
- 0, sh.value, psymtab_language, objfile);
- else
- add_psymbol_to_list (name, strlen (name),
- VAR_NAMESPACE, LOC_BLOCK,
- &objfile->static_psymbols,
- 0, sh.value, psymtab_language, objfile);
-
- /* Skip over procedure to next one. */
+ /* Ignore all parameter symbol records. */
if (sh.index >= hdr->iauxMax)
{
/* Should not happen, but does when cross-compiling
(debug_info->external_aux
+ fh->iauxBase
+ sh.index));
- procaddr = sh.value;
if (new_sdx <= cur_sdx)
{
new_sdx = cur_sdx + 1; /* Don't skip backward */
}
+ /* For stProc symbol records, we need to check the
+ storage class as well, as only (stProc, scText)
+ entries represent "real" procedures - See the
+ Compaq document titled "Object File / Symbol Table
+ Format Specification" for more information. If the
+ storage class is not scText, we discard the whole
+ block of symbol records for this stProc. */
+ if (sh.st == stProc && sh.sc != scText)
+ goto skip;
+
+ /* Usually there is a local and a global stProc symbol
+ for a function. This means that the function name
+ has already been entered into the mimimal symbol table
+ while processing the global symbols in pass 2 above.
+ One notable exception is the PROGRAM name from
+ f77 compiled executables, it is only put out as
+ local stProc symbol, and a global MAIN__ stProc symbol
+ points to it. It doesn't matter though, as gdb is
+ still able to find the PROGRAM name via the partial
+ symbol table, and the MAIN__ symbol via the minimal
+ symbol table. */
+ if (sh.st == stProc)
+ add_psymbol_to_list (name, strlen (name),
+ VAR_DOMAIN, LOC_BLOCK,
+ &objfile->global_psymbols,
+ 0, sh.value, psymtab_language, objfile);
+ else
+ add_psymbol_to_list (name, strlen (name),
+ VAR_DOMAIN, LOC_BLOCK,
+ &objfile->static_psymbols,
+ 0, sh.value, psymtab_language, objfile);
+
+ procaddr = sh.value;
+
cur_sdx = new_sdx;
(*swap_sym_in) (cur_bfd,
((char *) debug_info->external_sym
&& sh.index != cur_sdx + 2)
{
add_psymbol_to_list (name, strlen (name),
- STRUCT_NAMESPACE, LOC_TYPEDEF,
+ STRUCT_DOMAIN, LOC_TYPEDEF,
&objfile->static_psymbols,
0, (CORE_ADDR) 0,
psymtab_language, objfile);
}
/* Use this gdb symbol */
add_psymbol_to_list (name, strlen (name),
- VAR_NAMESPACE, class,
+ VAR_DOMAIN, class,
&objfile->static_psymbols,
0, sh.value, psymtab_language, objfile);
skip:
}
name = debug_info->ssext + psh->iss;
add_psymbol_to_list (name, strlen (name),
- VAR_NAMESPACE, class,
+ VAR_DOMAIN, class,
&objfile->global_psymbols,
0, svalue,
psymtab_language, objfile);
if (objfile->ei.entry_point >= save_pst->textlow &&
objfile->ei.entry_point < save_pst->texthigh)
{
- objfile->ei.entry_file_lowpc = save_pst->textlow;
- objfile->ei.entry_file_highpc = save_pst->texthigh;
+ objfile->ei.deprecated_entry_file_lowpc = save_pst->textlow;
+ objfile->ei.deprecated_entry_file_highpc = save_pst->texthigh;
}
/* The objfile has its functions reordered if this partial symbol
/* Note that the value doesn't matter for enum constants
in psymtabs, just in symtabs. */
add_psymbol_to_list (name, strlen (name),
- VAR_NAMESPACE, LOC_CONST,
+ VAR_DOMAIN, LOC_CONST,
&objfile->static_psymbols, 0,
(CORE_ADDR) 0, psymtab_language, objfile);
ext_sym += external_sym_size;
struct symbol *s = new_symbol (MIPS_EFI_SYMBOL_NAME);
memset (e, 0, sizeof (struct mips_extra_func_info));
- SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
+ SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
SYMBOL_CLASS (s) = LOC_CONST;
SYMBOL_TYPE (s) = mdebug_type_void;
SYMBOL_VALUE (s) = (long) e;
end_stabs ();
}
- /* Sort the symbol table now, we are done adding symbols to it.
- We must do this before parse_procedure calls lookup_symbol. */
- sort_symtab_syms (st);
-
/* There used to be a call to sort_blocks here, but this should not
be necessary for stabs symtabs. And as sort_blocks modifies the
start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
int maxlines;
EXTR *ext_ptr;
- /* How many symbols will we need */
- /* FIXME, this does not count enum values. */
- f_max = pst->n_global_syms + pst->n_static_syms;
if (fh == 0)
{
maxlines = 0;
- st = new_symtab ("unknown", f_max, 0, pst->objfile);
+ st = new_symtab ("unknown", 0, pst->objfile);
}
else
{
- f_max += fh->csym + fh->cpd;
maxlines = 2 * fh->cline;
- st = new_symtab (pst->filename, 2 * f_max, maxlines, pst->objfile);
+ st = new_symtab (pst->filename, maxlines, pst->objfile);
/* The proper language was already determined when building
the psymtab, use it. */
BLOCK_START (top_stack->cur_block) = pst->textlow;
BLOCK_END (top_stack->cur_block) = 0;
top_stack->blocktype = stFile;
- top_stack->maxsyms = 2 * f_max;
top_stack->cur_type = 0;
top_stack->procadr = 0;
top_stack->numargs = 0;
top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st),
GLOBAL_BLOCK);
top_stack->blocktype = stFile;
- top_stack->maxsyms
- = (debug_info->symbolic_header.isymMax
- + debug_info->symbolic_header.ipdMax
- + debug_info->symbolic_header.iextMax);
ext_ptr = PST_PRIVATE (pst)->extern_tab;
for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++)
st->primary = 1;
- /* Sort the symbol table now, we are done adding symbols to it. */
- sort_symtab_syms (st);
-
sort_blocks (st);
}
static struct symbol *
mylookup_symbol (char *name, register struct block *block,
- namespace_enum namespace, enum address_class class)
+ domain_enum domain, enum address_class class)
{
- int i, inc;
+ struct dict_iterator iter;
+ int inc;
struct symbol *sym;
inc = name[0];
- ALL_BLOCK_SYMBOLS (block, i, sym)
+ ALL_BLOCK_SYMBOLS (block, iter, sym)
{
- if (SYMBOL_NAME (sym)[0] == inc
- && SYMBOL_NAMESPACE (sym) == namespace
+ if (DEPRECATED_SYMBOL_NAME (sym)[0] == inc
+ && SYMBOL_DOMAIN (sym) == domain
&& SYMBOL_CLASS (sym) == class
- && strcmp (SYMBOL_NAME (sym), name) == 0)
+ && strcmp (DEPRECATED_SYMBOL_NAME (sym), name) == 0)
return sym;
}
block = BLOCK_SUPERBLOCK (block);
if (block)
- return mylookup_symbol (name, block, namespace, class);
+ return mylookup_symbol (name, block, domain, class);
return 0;
}
-/* Add a new symbol S to a block B.
- Infrequently, we will need to reallocate the block to make it bigger.
- We only detect this case when adding to top_stack->cur_block, since
- that's the only time we know how big the block is. FIXME. */
+/* Add a new symbol S to a block B. */
static void
add_symbol (struct symbol *s, struct block *b)
{
- int nsyms = BLOCK_NSYMS (b)++;
- struct block *origb;
- struct parse_stack *stackp;
-
- if (b == top_stack->cur_block &&
- nsyms >= top_stack->maxsyms)
- {
- complaint (&symfile_complaints, "block containing %s overfilled",
- SYMBOL_NAME (s));
- /* In this case shrink_block is actually grow_block, since
- BLOCK_NSYMS(b) is larger than its current size. */
- origb = b;
- b = shrink_block (top_stack->cur_block, top_stack->cur_st);
-
- /* Now run through the stack replacing pointers to the
- original block. shrink_block has already done this
- for the blockvector and BLOCK_FUNCTION. */
- for (stackp = top_stack; stackp; stackp = stackp->next)
- {
- if (stackp->cur_block == origb)
- {
- stackp->cur_block = b;
- stackp->maxsyms = BLOCK_NSYMS (b);
- }
- }
- }
- BLOCK_SYM (b, nsyms) = s;
+ dict_add_symbol (BLOCK_DICT (b), s);
}
/* Add a new block B to a symtab S */
/* Constructor/restructor/destructor procedures */
-/* Allocate a new symtab for NAME. Needs an estimate of how many symbols
- MAXSYMS and linenumbers MAXLINES we'll put in it */
+/* Allocate a new symtab for NAME. Needs an estimate of how many
+ linenumbers MAXLINES we'll put in it */
static struct symtab *
-new_symtab (char *name, int maxsyms, int maxlines, struct objfile *objfile)
+new_symtab (char *name, int maxlines, struct objfile *objfile)
{
struct symtab *s = allocate_symtab (name, objfile);
/* All symtabs must have at least two blocks */
BLOCKVECTOR (s) = new_bvect (2);
- BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK) = new_block (maxsyms);
- BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK) = new_block (maxsyms);
+ BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK)
+ = new_block (NON_FUNCTION_BLOCK);
+ BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)
+ = new_block (NON_FUNCTION_BLOCK);
BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)) =
BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
return bv;
}
-/* Allocate and zero a new block of MAXSYMS symbols */
+/* Allocate and zero a new block, and set its BLOCK_DICT. If function
+ is non-zero, assume the block is associated to a function, and make
+ sure that the symbols are stored linearly; otherwise, store them
+ hashed. */
static struct block *
-new_block (int maxsyms)
+new_block (enum block_type type)
{
- int size = sizeof (struct block) + (maxsyms - 1) * sizeof (struct symbol *);
-
- return (struct block *) xzalloc (size);
-}
+ /* FIXME: carlton/2003-09-11: This should use allocate_block to
+ allocate the block. Which, in turn, suggests that the block
+ should be allocated on an obstack. */
+ struct block *retval = xzalloc (sizeof (struct block));
-/* Ooops, too big. Shrink block B in symtab S to its minimal size.
- Shrink_block can also be used by add_symbol to grow a block. */
-
-static struct block *
-shrink_block (struct block *b, struct symtab *s)
-{
- struct block *new;
- struct blockvector *bv = BLOCKVECTOR (s);
- int i;
+ if (type == FUNCTION_BLOCK)
+ BLOCK_DICT (retval) = dict_create_linear_expandable ();
+ else
+ BLOCK_DICT (retval) = dict_create_hashed_expandable ();
- /* Just reallocate it and fix references to the old one */
-
- new = (struct block *) xrealloc ((void *) b,
- (sizeof (struct block)
- + ((BLOCK_NSYMS (b) - 1)
- * sizeof (struct symbol *))));
-
- /* FIXME: Not worth hashing this block as it's built. */
- /* All callers should have created the block with new_block (), which
- would mean it was not previously hashed. Make sure. */
- gdb_assert (BLOCK_HASHTABLE (new) == 0);
-
- /* Should chase pointers to old one. Fortunately, that`s just
- the block`s function and inferior blocks */
- if (BLOCK_FUNCTION (new) && SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) == b)
- SYMBOL_BLOCK_VALUE (BLOCK_FUNCTION (new)) = new;
- for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++)
- if (BLOCKVECTOR_BLOCK (bv, i) == b)
- BLOCKVECTOR_BLOCK (bv, i) = new;
- else if (BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, i)) == b)
- BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, i)) = new;
- return new;
+ return retval;
}
/* Create a new symbol with printname NAME */
sizeof (struct symbol)));
memset (s, 0, sizeof (*s));
- SYMBOL_NAME (s) = obsavestring (name, strlen (name),
- ¤t_objfile->symbol_obstack);
SYMBOL_LANGUAGE (s) = psymtab_language;
- SYMBOL_INIT_DEMANGLED_NAME (s, ¤t_objfile->symbol_obstack);
+ SYMBOL_SET_NAMES (s, name, strlen (name), current_objfile);
return s;
}
{
bfd *abfd = objfile->obfd;
struct ecoff_debug_info *info;
+ struct cleanup *back_to;
+
+ /* FIXME: It's not clear whether we should be getting minimal symbol
+ information from .mdebug in an ELF file, or whether we will.
+ Re-initialize the minimal symbol reader in case we do. */
+
+ init_minimal_symbol_collection ();
+ back_to = make_cleanup_discard_minimal_symbols ();
info = ((struct ecoff_debug_info *)
obstack_alloc (&objfile->psymbol_obstack,
bfd_errmsg (bfd_get_error ()));
mdebug_build_psymtabs (objfile, swap, info);
+
+ install_minimal_symbols (objfile);
+ do_cleanups (back_to);
}
\f
/* We have to handle the following cases here:
a) The Mips library has a sigtramp label within sigvec.
b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
- s = lookup_symbol ("sigvec", 0, VAR_NAMESPACE, 0, NULL);
+ s = lookup_symbol ("sigvec", 0, VAR_DOMAIN, 0, NULL);
if (s != 0)
{
b0 = SYMBOL_BLOCK_VALUE (s);
- s = lookup_symbol ("sigtramp", b0, VAR_NAMESPACE, 0, NULL);
+ s = lookup_symbol ("sigtramp", b0, VAR_DOMAIN, 0, NULL);
}
if (s == 0)
{
/* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
- s = lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE, 0, NULL);
+ s = lookup_symbol ("_sigtramp", 0, VAR_DOMAIN, 0, NULL);
}
/* But maybe this program uses its own version of sigvec */
* needed info. Note we make it a nested procedure of sigvec,
* which is the way the (assembly) code is actually written.
*/
- SYMBOL_NAMESPACE (s) = VAR_NAMESPACE;
+ SYMBOL_DOMAIN (s) = VAR_DOMAIN;
SYMBOL_CLASS (s) = LOC_BLOCK;
SYMBOL_TYPE (s) = init_type (TYPE_CODE_FUNC, 4, 0, (char *) NULL,
st->objfile);
TYPE_TARGET_TYPE (SYMBOL_TYPE (s)) = mdebug_type_void;
/* Need a block to allocate MIPS_EFI_SYMBOL_NAME in */
- b = new_block (1);
+ b = new_block (NON_FUNCTION_BLOCK);
SYMBOL_BLOCK_VALUE (s) = b;
BLOCK_START (b) = sigtramp_address;
BLOCK_END (b) = sigtramp_end;
current_objfile = st->objfile; /* Keep new_symbol happy */
s = new_symbol (MIPS_EFI_SYMBOL_NAME);
SYMBOL_VALUE (s) = (long) e;
- SYMBOL_NAMESPACE (s) = LABEL_NAMESPACE;
+ SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
SYMBOL_CLASS (s) = LOC_CONST;
SYMBOL_TYPE (s) = mdebug_type_void;
current_objfile = NULL;
}
- BLOCK_SYM (b, BLOCK_NSYMS (b)++) = s;
+ dict_add_symbol (BLOCK_DICT (b), s);
}
#endif /* TM_MIPS_H */
projects / deliverable / binutils-gdb.git / blobdiff