/* Read a symbol table in ECOFF format (Third-Eye).
- Copyright (C) 1986-2016 Free Software Foundation, Inc.
+ Copyright (C) 1986-2021 Free Software Foundation, Inc.
Original version contributed by Alessandro Forin (af@cs.cmu.edu) at
CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor
#include "filenames.h"
#include "objfiles.h"
#include "gdb_obstack.h"
-#include "buildsym.h"
+#include "buildsym-legacy.h"
#include "stabsread.h"
#include "complaints.h"
#include "demangle.h"
#include "expression.h"
-extern void _initialize_mdebugread (void);
+#include <algorithm>
/* Provide a way to test if we have both ECOFF and ELF symbol tables.
We use this define in order to know whether we should override a
#define SC_IS_TEXT(sc) ((sc) == scText \
|| (sc) == scRConst \
- || (sc) == scInit \
- || (sc) == scFini)
+ || (sc) == scInit \
+ || (sc) == scFini)
#define SC_IS_DATA(sc) ((sc) == scData \
|| (sc) == scSData \
|| (sc) == scRData \
static void
index_complaint (const char *arg1)
{
- complaint (&symfile_complaints, _("bad aux index at symbol %s"), arg1);
+ complaint (_("bad aux index at symbol %s"), arg1);
}
static void
unknown_ext_complaint (const char *arg1)
{
- complaint (&symfile_complaints, _("unknown external symbol %s"), arg1);
+ complaint (_("unknown external symbol %s"), arg1);
}
static void
basic_type_complaint (int arg1, const char *arg2)
{
- complaint (&symfile_complaints, _("cannot map ECOFF basic type 0x%x for %s"),
+ complaint (_("cannot map ECOFF basic type 0x%x for %s"),
arg1, arg2);
}
static void
bad_tag_guess_complaint (const char *arg1)
{
- complaint (&symfile_complaints,
- _("guessed tag type of %s incorrectly"), arg1);
+ complaint (_("guessed tag type of %s incorrectly"), arg1);
}
static void
bad_rfd_entry_complaint (const char *arg1, int arg2, int arg3)
{
- complaint (&symfile_complaints, _("bad rfd entry for %s: file %d, index %d"),
+ complaint (_("bad rfd entry for %s: file %d, index %d"),
arg1, arg2, arg3);
}
static void
unexpected_type_code_complaint (const char *arg1)
{
- complaint (&symfile_complaints, _("unexpected type code for %s"), arg1);
+ complaint (_("unexpected type code for %s"), arg1);
}
/* Macros and extra defs. */
static struct ecoff_debug_info *debug_info;
-/* Pointer to current file decriptor record, and its index. */
+/* Pointer to current file descriptor record, and its index. */
static FDR *cur_fdr;
static int cur_fd;
/* Forward declarations. */
static int upgrade_type (int, struct type **, int, union aux_ext *,
- int, char *);
+ int, const char *);
-static void parse_partial_symbols (struct objfile *);
+static void parse_partial_symbols (minimal_symbol_reader &,
+ psymtab_storage *,
+ struct objfile *);
static int has_opaque_xref (FDR *, SYMR *);
static int cross_ref (int, union aux_ext *, struct type **, enum type_code,
- char **, int, char *);
+ const char **, int, const char *);
-static struct symbol *new_symbol (char *);
+static struct symbol *new_symbol (const char *);
static struct type *new_type (char *);
enum block_type { FUNCTION_BLOCK, NON_FUNCTION_BLOCK };
-static struct block *new_block (enum block_type);
+static struct block *new_block (enum block_type, enum language);
static struct compunit_symtab *new_symtab (const char *, int, struct objfile *);
static struct blockvector *new_bvect (int);
static struct type *parse_type (int, union aux_ext *, unsigned int, int *,
- int, char *);
+ int, const char *);
-static struct symbol *mylookup_symbol (char *, const struct block *,
+static struct symbol *mylookup_symbol (const char *, const struct block *,
domain_enum, enum address_class);
static void sort_blocks (struct symtab *);
-static struct partial_symtab *new_psymtab (char *, struct objfile *);
+static legacy_psymtab *new_psymtab (const char *, psymtab_storage *,
+ struct objfile *);
-static void psymtab_to_symtab_1 (struct objfile *objfile,
- struct partial_symtab *, const char *);
+static void mdebug_expand_psymtab (legacy_psymtab *pst,
+ struct objfile *objfile);
static void add_block (struct block *, struct symtab *);
static struct linetable *shrink_linetable (struct linetable *);
-static void handle_psymbol_enumerators (struct objfile *, FDR *, int,
- CORE_ADDR);
+static void handle_psymbol_enumerators (struct objfile *, psymtab_storage *,
+ partial_symtab *,
+ FDR *, int, CORE_ADDR);
-static char *mdebug_next_symbol_text (struct objfile *);
+static const char *mdebug_next_symbol_text (struct objfile *);
\f
/* Exported procedure: Builds a symtab from the partial symtab SELF.
Restores the environment in effect when SELF was created, delegates
and reorders the symtab list at the end. SELF is not NULL. */
static void
-mdebug_read_symtab (struct partial_symtab *self, struct objfile *objfile)
+mdebug_read_symtab (legacy_psymtab *self, struct objfile *objfile)
{
- if (info_verbose)
- {
- printf_filtered (_("Reading in symbols for %s..."), self->filename);
- gdb_flush (gdb_stdout);
- }
-
next_symbol_text_func = mdebug_next_symbol_text;
- psymtab_to_symtab_1 (objfile, self, self->filename);
+ self->expand_psymtab (objfile);
/* Match with global symbols. This only needs to be done once,
after all of the symtabs and dependencies have been read in. */
scan_file_globals (objfile);
-
- if (info_verbose)
- printf_filtered (_("done.\n"));
}
\f
/* File-level interface functions. */
/* Return a safer print NAME for a file descriptor. */
-static char *
+static const char *
fdr_name (FDR *f)
{
if (f->rss == -1)
different sections are relocated via the SECTION_OFFSETS. */
void
-mdebug_build_psymtabs (struct objfile *objfile,
+mdebug_build_psymtabs (minimal_symbol_reader &reader,
+ struct objfile *objfile,
const struct ecoff_debug_swap *swap,
struct ecoff_debug_info *info)
{
debug_info = info;
stabsread_new_init ();
- buildsym_new_init ();
free_header_files ();
init_header_files ();
-
+
/* Make sure all the FDR information is swapped in. */
- if (info->fdr == (FDR *) NULL)
+ if (info->fdr == NULL)
{
char *fdr_src;
char *fdr_end;
FDR *fdr_ptr;
- info->fdr = (FDR *) obstack_alloc (&objfile->objfile_obstack,
- (info->symbolic_header.ifdMax
- * sizeof (FDR)));
+ info->fdr = (FDR *) XOBNEWVEC (&objfile->objfile_obstack, FDR,
+ info->symbolic_header.ifdMax);
fdr_src = (char *) info->external_fdr;
fdr_end = (fdr_src
+ info->symbolic_header.ifdMax * swap->external_fdr_size);
(*swap->swap_fdr_in) (objfile->obfd, fdr_src, fdr_ptr);
}
- parse_partial_symbols (objfile);
+ psymbol_functions *psf = new psymbol_functions ();
+ psymtab_storage *partial_symtabs = psf->get_partial_symtabs ().get ();
+ objfile->qf.emplace_front (psf);
+ parse_partial_symbols (reader, partial_symtabs, objfile);
#if 0
/* Check to make sure file was compiled with -g. If not, warn the
objfile->name);
printf_unfiltered (_("You should compile with -g2 or "
"-g3 for best debugging support.\n"));
- gdb_flush (gdb_stdout);
}
#endif
}
struct pst_map
{
- struct partial_symtab *pst; /* the psymtab proper */
+ legacy_psymtab *pst; /* the psymtab proper */
long n_globals; /* exported globals (external symbols) */
long globals_offset; /* cumulative */
};
/* Make sure we do not make duplicates. */
if (!p)
{
- p = ((struct mdebug_pending *)
- obstack_alloc (&mdebugread_objfile->objfile_obstack,
- sizeof (struct mdebug_pending)));
+ p = XOBNEW (&mdebugread_objfile->objfile_obstack, mdebug_pending);
p->s = sh;
p->t = t;
p->next = pending_list[f_idx];
static void
reg_value_complaint (int regnum, int num_regs, const char *sym)
{
- complaint (&symfile_complaints,
- _("bad register number %d (max %d) in symbol %s"),
- regnum, num_regs - 1, sym);
+ complaint (_("bad register number %d (max %d) in symbol %s"),
+ regnum, num_regs - 1, sym);
}
/* Parse a single symbol. Mostly just make up a GDB symbol for it.
{
int regno = gdbarch_ecoff_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
- if (regno < 0
- || regno >= (gdbarch_num_regs (gdbarch)
- + gdbarch_num_pseudo_regs (gdbarch)))
+ if (regno < 0 || regno >= gdbarch_num_cooked_regs (gdbarch))
{
- reg_value_complaint (regno,
- gdbarch_num_regs (gdbarch)
- + gdbarch_num_pseudo_regs (gdbarch),
- SYMBOL_PRINT_NAME (sym));
+ reg_value_complaint (regno, gdbarch_num_cooked_regs (gdbarch),
+ sym->print_name ());
regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless. */
}
static void
add_data_symbol (SYMR *sh, union aux_ext *ax, int bigend,
struct symbol *s, int aclass_index, struct block *b,
- struct objfile *objfile, char *name)
+ struct objfile *objfile, const char *name)
{
SYMBOL_DOMAIN (s) = VAR_DOMAIN;
SYMBOL_ACLASS_INDEX (s) = aclass_index;
static int
parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
- struct section_offsets *section_offsets, struct objfile *objfile)
+ const section_offsets §ion_offsets, struct objfile *objfile)
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
const bfd_size_type external_sym_size = debug_swap->external_sym_size;
void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
- char *name;
+ const char *name;
struct symbol *s;
struct block *b;
struct mdebug_pending *pend;
struct type *t;
- struct field *f;
int count = 1;
TIR tir;
long svalue = sh->value;
int bitsize;
- if (ext_sh == (char *) NULL)
+ if (ext_sh == NULL)
name = debug_info->ssext + sh->iss;
else
name = debug_info->ss + cur_fdr->issBase + sh->iss;
case scText:
case scRConst:
/* Do not relocate relative values.
- The value of a stEnd symbol is the displacement from the
- corresponding start symbol value.
- The value of a stBlock symbol is the displacement from the
- procedure address. */
+ The value of a stEnd symbol is the displacement from the
+ corresponding start symbol value.
+ The value of a stBlock symbol is the displacement from the
+ procedure address. */
if (sh->st != stEnd && sh->st != stBlock)
- sh->value += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
+ sh->value += section_offsets[SECT_OFF_TEXT (objfile)];
break;
case scData:
case scSData:
case scRData:
case scPData:
case scXData:
- sh->value += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
+ sh->value += section_offsets[SECT_OFF_DATA (objfile)];
break;
case scBss:
case scSBss:
- sh->value += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile));
+ sh->value += section_offsets[SECT_OFF_BSS (objfile)];
break;
}
b = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (top_stack->cur_st),
GLOBAL_BLOCK);
s = new_symbol (name);
- SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
+ SET_SYMBOL_VALUE_ADDRESS (s, (CORE_ADDR) sh->value);
add_data_symbol (sh, ax, bigend, s, LOC_STATIC, b, objfile, name);
break;
/* 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_LINKAGE_NAME (s));
+ int bucket = hashname (s->linkage_name ());
SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket];
global_sym_chain[bucket] = s;
}
else
- SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
+ SET_SYMBOL_VALUE_ADDRESS (s, (CORE_ADDR) sh->value);
add_data_symbol (sh, ax, bigend, s, LOC_STATIC, b, objfile, name);
break;
s = new_symbol (name);
SYMBOL_DOMAIN (s) = VAR_DOMAIN; /* So that it can be used */
SYMBOL_ACLASS_INDEX (s) = LOC_LABEL; /* but not misused. */
- SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value;
+ SET_SYMBOL_VALUE_ADDRESS (s, (CORE_ADDR) sh->value);
SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_int;
add_symbol (s, top_stack->cur_st, top_stack->cur_block);
break;
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. */
+ 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;
- }
+ {
+ 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 (_("unknown symbol type 0x%x"), sh->st);
+ break;
+ }
+ }
+ break;
+ }
s = new_symbol (name);
SYMBOL_DOMAIN (s) = VAR_DOMAIN;
SYMBOL_ACLASS_INDEX (s) = LOC_BLOCK;
{
t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name);
if (strcmp (name, "malloc") == 0
- && TYPE_CODE (t) == TYPE_CODE_VOID)
+ && t->code () == TYPE_CODE_VOID)
{
/* I don't know why, but, at least under Alpha GNU/Linux,
- when linking against a malloc without debugging
- symbols, its read as a function returning void---this
- is bad because it means we cannot call functions with
- string arguments interactively; i.e., "call
- printf("howdy\n")" would fail with the error message
- "program has no memory available". To avoid this, we
- patch up the type and make it void*
- instead. (davidm@azstarnet.com). */
+ when linking against a malloc without debugging
+ symbols, its read as a function returning void---this
+ is bad because it means we cannot call functions with
+ string arguments interactively; i.e., "call
+ printf("howdy\n")" would fail with the error message
+ "program has no memory available". To avoid this, we
+ patch up the type and make it void*
+ instead. (davidm@azstarnet.com). */
t = make_pointer_type (t, NULL);
}
}
SYMBOL_TYPE (s) = lookup_function_type (t);
/* All functions in C++ have prototypes. For C we don't have enough
- information in the debug info. */
- if (SYMBOL_LANGUAGE (s) == language_cplus)
- TYPE_PROTOTYPED (SYMBOL_TYPE (s)) = 1;
+ information in the debug info. */
+ if (s->language () == language_cplus)
+ SYMBOL_TYPE (s)->set_is_prototyped (true);
/* Create and enter a new lexical context. */
- b = new_block (FUNCTION_BLOCK);
+ b = new_block (FUNCTION_BLOCK, s->language ());
SYMBOL_BLOCK_VALUE (s) = b;
BLOCK_FUNCTION (b) = s;
BLOCK_START (b) = BLOCK_END (b) = sh->value;
break;
/* Beginning of code for structure, union, and enum definitions.
- They all share a common set of local variables, defined here. */
+ They all share a common set of local variables, defined here. */
{
enum type_code type_code;
char *ext_tsym;
switch (tsym.st)
{
case stEnd:
- /* C++ encodes class types as structures where there the
- methods are encoded as stProc. The scope of stProc
- symbols also ends with stEnd, thus creating a risk of
- taking the wrong stEnd symbol record as the end of
- the current struct, which would cause GDB to undercount
- the real number of fields in this struct. To make sure
- we really reached the right stEnd symbol record, we
- check the associated name, and match it against the
- struct name. Since method names are mangled while
- the class name is not, there is no risk of having a
- 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.
+ /* C++ encodes class types as structures where there the
+ methods are encoded as stProc. The scope of stProc
+ symbols also ends with stEnd, thus creating a risk of
+ taking the wrong stEnd symbol record as the end of
+ the current struct, which would cause GDB to undercount
+ the real number of fields in this struct. To make sure
+ we really reached the right stEnd symbol record, we
+ check the associated name, and match it against the
+ struct name. Since method names are mangled while
+ the class name is not, there is no risk of having a
+ 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.
Also, assume that we're really at the end when tsym.iss
is 0 (issNull). */
- if (tsym.iss == issNull
+ if (tsym.iss == issNull
|| strcmp (debug_info->ss + cur_fdr->issBase + tsym.iss,
- name) == 0)
- goto end_of_fields;
- break;
+ name) == 0)
+ goto end_of_fields;
+ break;
case stMember:
if (nfields == 0 && type_code == TYPE_CODE_UNDEF)
if (tsym.index != 0)
{
/* This is something like a struct within a
- struct. Skip over the fields of the inner
- struct. The -1 is because the for loop will
- increment ext_tsym. */
+ struct. Skip over the fields of the inner
+ struct. The -1 is because the for loop will
+ increment ext_tsym. */
ext_tsym = ((char *) debug_info->external_sym
+ ((cur_fdr->isymBase + tsym.index - 1)
* external_sym_size));
break;
default:
- complaint (&symfile_complaints,
- _("declaration block contains "
+ complaint (_("declaration block contains "
"unhandled symbol type %d"),
tsym.st);
}
/* Create a new type or use the pending type. */
pend = is_pending_symbol (cur_fdr, ext_sh);
- if (pend == (struct mdebug_pending *) NULL)
+ if (pend == NULL)
{
t = new_type (NULL);
add_pending (cur_fdr, ext_sh, t);
(.Fxx or .xxfake or empty) for unnamed struct/union/enums.
Alpha cc puts out an sh->iss of zero for those. */
if (sh->iss == 0 || name[0] == '.' || name[0] == '\0')
- TYPE_TAG_NAME (t) = NULL;
+ t->set_name (NULL);
else
- TYPE_TAG_NAME (t) = obconcat (&mdebugread_objfile->objfile_obstack,
- name, (char *) NULL);
+ t->set_name (obconcat (&mdebugread_objfile->objfile_obstack,
+ name, (char *) NULL));
- TYPE_CODE (t) = type_code;
+ t->set_code (type_code);
TYPE_LENGTH (t) = sh->value;
- TYPE_NFIELDS (t) = nfields;
- TYPE_FIELDS (t) = f = ((struct field *)
- TYPE_ALLOC (t,
- nfields * sizeof (struct field)));
+ t->set_num_fields (nfields);
+ f = ((struct field *) TYPE_ALLOC (t, nfields * sizeof (struct field)));
+ t->set_fields (f);
if (type_code == TYPE_CODE_ENUM)
{
are hopefully rare enough.
Alpha cc -migrate has a sh.value field of zero, we adjust
that too. */
- if (TYPE_LENGTH (t) == TYPE_NFIELDS (t)
+ if (TYPE_LENGTH (t) == t->num_fields ()
|| TYPE_LENGTH (t) == 0)
TYPE_LENGTH (t) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
for (ext_tsym = ext_sh + external_sym_size;
break;
SET_FIELD_ENUMVAL (*f, tsym.value);
- FIELD_TYPE (*f) = t;
+ f->set_type (t);
FIELD_NAME (*f) = debug_info->ss + cur_fdr->issBase + tsym.iss;
FIELD_BITSIZE (*f) = 0;
- enum_sym = allocate_symbol (mdebugread_objfile);
- SYMBOL_SET_LINKAGE_NAME
- (enum_sym,
- (char *) obstack_copy0 (&mdebugread_objfile->objfile_obstack,
- f->name, strlen (f->name)));
+ enum_sym = new (&mdebugread_objfile->objfile_obstack) symbol;
+ enum_sym->set_linkage_name
+ (obstack_strdup (&mdebugread_objfile->objfile_obstack,
+ f->name));
SYMBOL_ACLASS_INDEX (enum_sym) = LOC_CONST;
SYMBOL_TYPE (enum_sym) = t;
SYMBOL_DOMAIN (enum_sym) = VAR_DOMAIN;
f++;
}
if (unsigned_enum)
- TYPE_UNSIGNED (t) = 1;
+ t->set_is_unsigned (true);
}
/* Make this the current type. */
top_stack->cur_type = t;
/* gcc puts out an empty struct for an opaque struct definitions,
do not create a symbol for it either. */
- if (TYPE_NFIELDS (t) == 0)
+ if (t->num_fields () == 0)
{
- TYPE_STUB (t) = 1;
+ t->set_is_stub (true);
break;
}
case_stBlock_code:
found_ecoff_debugging_info = 1;
/* Beginnning of (code) block. Value of symbol
- is the displacement from procedure start. */
+ is the displacement from procedure start. */
push_parse_stack ();
/* Do not start a new block if this is the outermost block of a
- procedure. This allows the LOC_BLOCK symbol to point to the
- block with the local variables, so funcname::var works. */
+ procedure. This allows the LOC_BLOCK symbol to point to the
+ block with the local variables, so funcname::var works. */
if (top_stack->blocktype == stProc
|| top_stack->blocktype == stStaticProc)
{
}
top_stack->blocktype = stBlock;
- b = new_block (NON_FUNCTION_BLOCK);
+ b = new_block (NON_FUNCTION_BLOCK, psymtab_language);
BLOCK_START (b) = sh->value + top_stack->procadr;
BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
top_stack->cur_block = b;
const struct blockvector *bv
= SYMTAB_BLOCKVECTOR (top_stack->cur_st);
struct mdebug_extra_func_info *e;
- struct block *b = top_stack->cur_block;
+ struct block *cblock = top_stack->cur_block;
struct type *ftype = top_stack->cur_type;
int i;
SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
SYMBOL_ACLASS_INDEX (s) = LOC_CONST;
SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->builtin_void;
- e = ((struct mdebug_extra_func_info *)
- obstack_alloc (&mdebugread_objfile->objfile_obstack,
- sizeof (struct mdebug_extra_func_info)));
- memset (e, 0, sizeof (struct mdebug_extra_func_info));
+ e = OBSTACK_ZALLOC (&mdebugread_objfile->objfile_obstack,
+ mdebug_extra_func_info);
SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
e->numargs = top_stack->numargs;
e->pdr.framereg = -1;
{
struct block *b_bad = BLOCKVECTOR_BLOCK (bv, i);
- if (BLOCK_SUPERBLOCK (b_bad) == b
+ if (BLOCK_SUPERBLOCK (b_bad) == cblock
&& BLOCK_START (b_bad) == top_stack->procadr
&& BLOCK_END (b_bad) == top_stack->procadr)
{
- BLOCK_START (b_bad) = BLOCK_START (b);
- BLOCK_END (b_bad) = BLOCK_END (b);
+ BLOCK_START (b_bad) = BLOCK_START (cblock);
+ BLOCK_END (b_bad) = BLOCK_END (cblock);
}
}
- if (TYPE_NFIELDS (ftype) <= 0)
+ if (ftype->num_fields () <= 0)
{
/* No parameter type information is recorded with the function's
- type. Set that from the type of the parameter symbols. */
+ type. Set that from the type of the parameter symbols. */
int nparams = top_stack->numargs;
int iparams;
struct symbol *sym;
{
struct block_iterator iter;
- TYPE_NFIELDS (ftype) = nparams;
- TYPE_FIELDS (ftype) = (struct field *)
- TYPE_ALLOC (ftype, nparams * sizeof (struct field));
+ ftype->set_num_fields (nparams);
+ ftype->set_fields
+ ((struct field *)
+ TYPE_ALLOC (ftype, nparams * sizeof (struct field)));
iparams = 0;
- ALL_BLOCK_SYMBOLS (b, iter, sym)
+ ALL_BLOCK_SYMBOLS (cblock, iter, sym)
{
if (iparams == nparams)
break;
if (SYMBOL_IS_ARGUMENT (sym))
{
- TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym);
+ ftype->field (iparams).set_type (SYMBOL_TYPE (sym));
TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0;
iparams++;
}
;
}
else
- complaint (&symfile_complaints,
- _("stEnd with storage class %d not handled"), sh->sc);
+ complaint (_("stEnd with storage class %d not handled"), sh->sc);
pop_parse_stack (); /* Restore previous lexical context. */
break;
case stMember: /* member of struct or union */
- f = &TYPE_FIELDS (top_stack->cur_type)[top_stack->cur_field++];
- FIELD_NAME (*f) = name;
- SET_FIELD_BITPOS (*f, sh->value);
- bitsize = 0;
- FIELD_TYPE (*f) = parse_type (cur_fd, ax, sh->index,
- &bitsize, bigend, name);
- FIELD_BITSIZE (*f) = bitsize;
+ {
+ struct field *f = &top_stack->cur_type->field (top_stack->cur_field);
+ top_stack->cur_field++;
+ FIELD_NAME (*f) = name;
+ SET_FIELD_BITPOS (*f, sh->value);
+ bitsize = 0;
+ f->set_type (parse_type (cur_fd, ax, sh->index, &bitsize, bigend,
+ name));
+ FIELD_BITSIZE (*f) = bitsize;
+ }
break;
case stIndirect: /* forward declaration on Irix5 */
/* Forward declarations from Irix5 cc are handled by cross_ref,
- skip them. */
+ skip them. */
break;
case stTypedef: /* type definition */
found_ecoff_debugging_info = 1;
/* Typedefs for forward declarations and opaque structs from alpha cc
- are handled by cross_ref, skip them. */
+ are handled by cross_ref, skip them. */
if (sh->iss == 0)
break;
/* Parse the type or use the pending type. */
pend = is_pending_symbol (cur_fdr, ext_sh);
- if (pend == (struct mdebug_pending *) NULL)
+ if (pend == NULL)
{
- t = parse_type (cur_fd, ax, sh->index, (int *) NULL, bigend, name);
+ t = parse_type (cur_fd, ax, sh->index, NULL, bigend, name);
add_pending (cur_fdr, ext_sh, t);
}
else
t = pend->t;
/* Mips cc puts out a typedef with the name of the struct for forward
- declarations. These should not go into the symbol table and
- TYPE_NAME should not be set for them.
- They can't be distinguished from an intentional typedef to
- the same name however:
- x.h:
- struct x { int ix; int jx; };
- struct xx;
- x.c:
- typedef struct x x;
- struct xx {int ixx; int jxx; };
- generates a cross referencing stTypedef for x and xx.
- The user visible effect of this is that the type of a pointer
- to struct foo sometimes is given as `foo *' instead of `struct foo *'.
- The problem is fixed with alpha cc and Irix5 cc. */
+ declarations. These should not go into the symbol table and
+ TYPE_NAME should not be set for them.
+ They can't be distinguished from an intentional typedef to
+ the same name however:
+ x.h:
+ struct x { int ix; int jx; };
+ struct xx;
+ x.c:
+ typedef struct x x;
+ struct xx {int ixx; int jxx; };
+ generates a cross referencing stTypedef for x and xx.
+ The user visible effect of this is that the type of a pointer
+ to struct foo sometimes is given as `foo *' instead of `struct foo *'.
+ The problem is fixed with alpha cc and Irix5 cc. */
/* However if the typedef cross references to an opaque aggregate, it
- is safe to omit it from the symbol table. */
+ is safe to omit it from the symbol table. */
if (has_opaque_xref (cur_fdr, sh))
break;
add_symbol (s, top_stack->cur_st, top_stack->cur_block);
/* Incomplete definitions of structs should not get a name. */
- if (TYPE_NAME (SYMBOL_TYPE (s)) == NULL
- && (TYPE_NFIELDS (SYMBOL_TYPE (s)) != 0
- || (TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_STRUCT
- && TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_UNION)))
+ if (SYMBOL_TYPE (s)->name () == NULL
+ && (SYMBOL_TYPE (s)->num_fields () != 0
+ || (SYMBOL_TYPE (s)->code () != TYPE_CODE_STRUCT
+ && SYMBOL_TYPE (s)->code () != TYPE_CODE_UNION)))
{
- if (TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_PTR
- || TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_FUNC)
+ if (SYMBOL_TYPE (s)->code () == TYPE_CODE_PTR
+ || SYMBOL_TYPE (s)->code () == TYPE_CODE_FUNC)
{
/* If we are giving a name to a type such as "pointer to
- foo" or "function returning foo", we better not set
- the TYPE_NAME. If the program contains "typedef char
- *caddr_t;", we don't want all variables of type char
- * to print as caddr_t. This is not just a
- consequence of GDB's type management; CC and GCC (at
- least through version 2.4) both output variables of
- either type char * or caddr_t with the type
- refering to the stTypedef symbol for caddr_t. If a future
- compiler cleans this up it GDB is not ready for it
- yet, but if it becomes ready we somehow need to
- disable this check (without breaking the PCC/GCC2.4
- case).
-
- Sigh.
-
- Fortunately, this check seems not to be necessary
- for anything except pointers or functions. */
+ foo" or "function returning foo", we better not set
+ the TYPE_NAME. If the program contains "typedef char
+ *caddr_t;", we don't want all variables of type char
+ * to print as caddr_t. This is not just a
+ consequence of GDB's type management; CC and GCC (at
+ least through version 2.4) both output variables of
+ either type char * or caddr_t with the type
+ refering to the stTypedef symbol for caddr_t. If a future
+ compiler cleans this up it GDB is not ready for it
+ yet, but if it becomes ready we somehow need to
+ disable this check (without breaking the PCC/GCC2.4
+ case).
+
+ Sigh.
+
+ Fortunately, this check seems not to be necessary
+ for anything except pointers or functions. */
}
else
- TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_LINKAGE_NAME (s);
+ SYMBOL_TYPE (s)->set_name (s->linkage_name ());
}
break;
case stConstant:
break; /* constant */
default:
- complaint (&symfile_complaints, _("unknown symbol type 0x%x"), sh->st);
+ complaint (_("unknown symbol type 0x%x"), sh->st);
break;
}
/* Basic types. */
-static const struct objfile_data *basic_type_data;
+static const struct objfile_key<struct type *,
+ gdb::noop_deleter<struct type *>>
+ basic_type_data;
static struct type *
basic_type (int bt, struct objfile *objfile)
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
- struct type **map_bt
- = (struct type **) objfile_data (objfile, basic_type_data);
+ struct gdbarch *gdbarch = objfile->arch ();
+ struct type **map_bt = basic_type_data.get (objfile);
struct type *tp;
if (bt >= btMax)
{
map_bt = OBSTACK_CALLOC (&objfile->objfile_obstack,
btMax, struct type *);
- set_objfile_data (objfile, basic_type_data, map_bt);
+ basic_type_data.set (objfile, map_bt);
}
if (map_bt[bt])
case btChar:
tp = init_integer_type (objfile, 8, 0, "char");
+ tp->set_has_no_signedness (true);
break;
case btUChar:
case btFloat:
tp = init_float_type (objfile, gdbarch_float_bit (gdbarch),
- "float", NULL);
+ "float", gdbarch_float_format (gdbarch));
break;
case btDouble:
tp = init_float_type (objfile, gdbarch_double_bit (gdbarch),
- "double", NULL);
+ "double", gdbarch_double_format (gdbarch));
break;
case btComplex:
- tp = init_complex_type (objfile, "complex",
- basic_type (btFloat, objfile));
+ tp = init_complex_type ("complex", basic_type (btFloat, objfile));
break;
case btDComplex:
- tp = init_complex_type (objfile, "double complex",
- basic_type (btFloat, objfile));
+ tp = init_complex_type ("double complex", basic_type (btFloat, objfile));
break;
case btFixedDec:
case btFloatDec:
tp = init_type (objfile, TYPE_CODE_ERROR,
- gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT,
- "floating decimal");
+ gdbarch_double_bit (gdbarch), "floating decimal");
break;
case btString:
/* Is a "string" the way btString means it the same as TYPE_CODE_STRING?
FIXME. */
- tp = init_type (objfile, TYPE_CODE_STRING, 1, "string");
+ tp = init_type (objfile, TYPE_CODE_STRING, TARGET_CHAR_BIT, "string");
break;
case btVoid:
static struct type *
parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
- int bigend, char *sym_name)
+ int bigend, const char *sym_name)
{
TIR t[1];
struct type *tp = 0;
int width = AUX_GET_WIDTH (bigend, ax);
/* Inhibit core dumps if TIR is corrupted. */
- if (bs == (int *) NULL)
+ if (bs == NULL)
{
/* Alpha cc -migrate encodes char and unsigned char types
as short and unsigned short types with a field width of 8.
else if (t->bt == btEnum)
;
else
- complaint (&symfile_complaints,
- _("can't handle TIR fBitfield for %s"),
+ complaint (_("can't handle TIR fBitfield for %s"),
sym_name);
}
else
if (rf == -1)
{
- complaint (&symfile_complaints,
- _("unable to cross ref btIndirect for %s"), sym_name);
+ complaint (_("unable to cross ref btIndirect for %s"), sym_name);
return basic_type (btInt, mdebugread_objfile);
}
xref_fh = get_rfd (fd, rf);
xref_fd = xref_fh - debug_info->fdr;
tp = parse_type (xref_fd, debug_info->external_aux + xref_fh->iauxBase,
- rn->index, (int *) NULL, xref_fh->fBigendian, sym_name);
+ rn->index, NULL, xref_fh->fBigendian, sym_name);
}
/* All these types really point to some (common) MIPS type
name. This apparently is a MIPS extension for C sets. */
t->bt == btSet)
{
- char *name;
+ const char *name;
/* Try to cross reference this type, build new type on failure. */
ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
- if (tp == (struct type *) NULL)
+ if (tp == NULL)
tp = init_type (mdebugread_objfile, type_code, 0, NULL);
/* DEC c89 produces cross references to qualified aggregate types,
- dereference them. */
- while (TYPE_CODE (tp) == TYPE_CODE_PTR
- || TYPE_CODE (tp) == TYPE_CODE_ARRAY)
+ dereference them. */
+ while (tp->code () == TYPE_CODE_PTR
+ || tp->code () == TYPE_CODE_ARRAY)
tp = TYPE_TARGET_TYPE (tp);
/* Make sure that TYPE_CODE(tp) has an expected type code.
- Any type may be returned from cross_ref if file indirect entries
- are corrupted. */
- if (TYPE_CODE (tp) != TYPE_CODE_STRUCT
- && TYPE_CODE (tp) != TYPE_CODE_UNION
- && TYPE_CODE (tp) != TYPE_CODE_ENUM)
+ Any type may be returned from cross_ref if file indirect entries
+ are corrupted. */
+ if (tp->code () != TYPE_CODE_STRUCT
+ && tp->code () != TYPE_CODE_UNION
+ && tp->code () != TYPE_CODE_ENUM)
{
unexpected_type_code_complaint (sym_name);
}
exception is if we guessed wrong re struct/union/enum.
But for struct vs. union a wrong guess is harmless, so
don't complain(). */
- if ((TYPE_CODE (tp) == TYPE_CODE_ENUM
+ if ((tp->code () == TYPE_CODE_ENUM
&& type_code != TYPE_CODE_ENUM)
- || (TYPE_CODE (tp) != TYPE_CODE_ENUM
+ || (tp->code () != TYPE_CODE_ENUM
&& type_code == TYPE_CODE_ENUM))
{
bad_tag_guess_complaint (sym_name);
}
- if (TYPE_CODE (tp) != type_code)
+ if (tp->code () != type_code)
{
- TYPE_CODE (tp) = type_code;
+ tp->set_code (type_code);
}
/* Do not set the tag name if it is a compiler generated tag name
(.Fxx or .xxfake or empty) for unnamed struct/union/enums. */
if (name[0] == '.' || name[0] == '\0')
- TYPE_TAG_NAME (tp) = NULL;
- else if (TYPE_TAG_NAME (tp) == NULL
- || strcmp (TYPE_TAG_NAME (tp), name) != 0)
- TYPE_TAG_NAME (tp)
- = ((const char *)
- obstack_copy0 (&mdebugread_objfile->objfile_obstack,
- name, strlen (name)));
+ tp->set_name (NULL);
+ else if (tp->name () == NULL
+ || strcmp (tp->name (), name) != 0)
+ tp->set_name (obstack_strdup (&mdebugread_objfile->objfile_obstack,
+ name));
}
}
FIXME: We are not doing any guessing on range types. */
if (t->bt == btRange)
{
- char *name;
+ const char *name;
/* Try to cross reference this type, build new type on failure. */
ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
- if (tp == (struct type *) NULL)
+ if (tp == NULL)
tp = init_type (mdebugread_objfile, type_code, 0, NULL);
/* Make sure that TYPE_CODE(tp) has an expected type code.
- Any type may be returned from cross_ref if file indirect entries
- are corrupted. */
- if (TYPE_CODE (tp) != TYPE_CODE_RANGE)
+ Any type may be returned from cross_ref if file indirect entries
+ are corrupted. */
+ if (tp->code () != TYPE_CODE_RANGE)
{
unexpected_type_code_complaint (sym_name);
}
{
/* Usually, TYPE_CODE(tp) is already type_code. The main
exception is if we guessed wrong re struct/union/enum. */
- if (TYPE_CODE (tp) != type_code)
+ if (tp->code () != type_code)
{
bad_tag_guess_complaint (sym_name);
- TYPE_CODE (tp) = type_code;
+ tp->set_code (type_code);
}
- if (TYPE_NAME (tp) == NULL
- || strcmp (TYPE_NAME (tp), name) != 0)
- TYPE_NAME (tp)
- = ((const char *)
- obstack_copy0 (&mdebugread_objfile->objfile_obstack,
- name, strlen (name)));
+ if (tp->name () == NULL
+ || strcmp (tp->name (), name) != 0)
+ tp->set_name (obstack_strdup (&mdebugread_objfile->objfile_obstack,
+ name));
}
}
if (t->bt == btTypedef)
{
- char *name;
+ const char *name;
/* Try to cross reference this type, it should succeed. */
ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name);
- if (tp == (struct type *) NULL)
+ if (tp == NULL)
{
- complaint (&symfile_complaints,
- _("unable to cross ref btTypedef for %s"), sym_name);
+ complaint (_("unable to cross ref btTypedef for %s"), sym_name);
tp = basic_type (btInt, mdebugread_objfile);
}
}
/* Deal with range types. */
if (t->bt == btRange)
{
- TYPE_NFIELDS (tp) = 0;
- TYPE_RANGE_DATA (tp) = ((struct range_bounds *)
- TYPE_ZALLOC (tp, sizeof (struct range_bounds)));
- TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax);
+ tp->set_num_fields (0);
+ tp->set_bounds (((struct range_bounds *)
+ TYPE_ZALLOC (tp, sizeof (struct range_bounds))));
+ tp->bounds ()->low.set_const_val (AUX_GET_DNLOW (bigend, ax));
ax++;
- TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax);
+ tp->bounds ()->high.set_const_val (AUX_GET_DNHIGH (bigend, ax));
ax++;
}
/* Complain for illegal continuations due to corrupt aux entries. */
if (t->continued)
- complaint (&symfile_complaints,
- _("illegal TIR continued for %s"), sym_name);
+ complaint (_("illegal TIR continued for %s"), sym_name);
return tp;
}
static int
upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend,
- char *sym_name)
+ const char *sym_name)
{
int off;
struct type *t;
indx = parse_type (fh - debug_info->fdr,
debug_info->external_aux + fh->iauxBase,
- id, (int *) NULL, bigend, sym_name);
+ id, NULL, bigend, sym_name);
/* The bounds type should be an integer type, but might be anything
- else due to corrupt aux entries. */
- if (TYPE_CODE (indx) != TYPE_CODE_INT)
+ else due to corrupt aux entries. */
+ if (indx->code () != TYPE_CODE_INT)
{
- complaint (&symfile_complaints,
- _("illegal array index type for %s, assuming int"),
+ complaint (_("illegal array index type for %s, assuming int"),
sym_name);
indx = objfile_type (mdebugread_objfile)->builtin_int;
}
ax++;
rf = AUX_GET_WIDTH (bigend, ax); /* bit size of array element */
- range = create_static_range_type ((struct type *) NULL, indx,
- lower, upper);
+ range = create_static_range_type (NULL, indx, lower, upper);
- t = create_array_type ((struct type *) NULL, *tpp, range);
+ t = create_array_type (NULL, *tpp, range);
/* We used to fill in the supplied array element bitsize
- here if the TYPE_LENGTH of the target type was zero.
- This happens for a `pointer to an array of anonymous structs',
- but in this case the array element bitsize is also zero,
- so nothing is gained.
- And we used to check the TYPE_LENGTH of the target type against
- the supplied array element bitsize.
- gcc causes a mismatch for `pointer to array of object',
- since the sdb directives it uses do not have a way of
- specifying the bitsize, but it does no harm (the
- TYPE_LENGTH should be correct) and we should be able to
- ignore the erroneous bitsize from the auxiliary entry safely.
- dbx seems to ignore it too. */
+ here if the TYPE_LENGTH of the target type was zero.
+ This happens for a `pointer to an array of anonymous structs',
+ but in this case the array element bitsize is also zero,
+ so nothing is gained.
+ And we used to check the TYPE_LENGTH of the target type against
+ the supplied array element bitsize.
+ gcc causes a mismatch for `pointer to array of object',
+ since the sdb directives it uses do not have a way of
+ specifying the bitsize, but it does no harm (the
+ TYPE_LENGTH should be correct) and we should be able to
+ ignore the erroneous bitsize from the auxiliary entry safely.
+ dbx seems to ignore it too. */
/* TYPE_TARGET_STUB now takes care of the zero TYPE_LENGTH problem. */
if (TYPE_LENGTH (*tpp) == 0)
- TYPE_TARGET_STUB (t) = 1;
+ t->set_target_is_stub (true);
*tpp = t;
return 4 + off;
return 0;
default:
- complaint (&symfile_complaints, _("unknown type qualifier 0x%x"), tq);
+ complaint (_("unknown type qualifier 0x%x"), tq);
return 0;
}
}
static void
parse_procedure (PDR *pr, struct compunit_symtab *search_symtab,
- struct partial_symtab *pst)
+ legacy_psymtab *pst)
{
struct symbol *s, *i;
const struct block *b;
{
/* Static procedure at address pr->adr. Sigh. */
/* FIXME-32x64. assuming pr->adr fits in long. */
- complaint (&symfile_complaints,
- _("can't handle PDR for static proc at 0x%lx"),
+ complaint (_("can't handle PDR for static proc at 0x%lx"),
(unsigned long) pr->adr);
return;
}
{
#if 0
/* This loses both in the case mentioned (want a static, find a global),
- but also if we are looking up a non-mangled name which happens to
- match the name of a mangled function. */
+ but also if we are looking up a non-mangled name which happens to
+ match the name of a mangled function. */
/* We have to save the cur_fdr across the call to lookup_symbol.
- If the pdr is for a static function and if a global function with
- the same name exists, lookup_symbol will eventually read in the symtab
- for the global function and clobber cur_fdr. */
+ If the pdr is for a static function and if a global function with
+ 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_DOMAIN, 0);
}
else
{
- complaint (&symfile_complaints, _("PDR for %s, but no symbol"), sh_name);
+ complaint (_("PDR for %s, but no symbol"), sh_name);
#if 1
return;
#else
s = new_symbol (sh_name);
SYMBOL_DOMAIN (s) = VAR_DOMAIN;
SYMBOL_CLASS (s) = LOC_BLOCK;
- /* Donno its type, hope int is ok. */
+ /* Don't know its type, hope int is ok. */
SYMBOL_TYPE (s)
= lookup_function_type (objfile_type (pst->objfile)->builtin_int);
add_symbol (s, top_stack->cur_st, top_stack->cur_block);
BLOCK_FUNCTION (b) = s;
BLOCK_START (b) = pr->adr;
/* BOUND used to be the end of procedure's text, but the
- argument is no longer passed in. */
+ argument is no longer passed in. */
BLOCK_END (b) = bound;
BLOCK_SUPERBLOCK (b) = top_stack->cur_block;
add_block (b, top_stack->cur_st);
e->pdr = *pr;
/* GDB expects the absolute function start address for the
- procedure descriptor in e->pdr.adr.
- As the address in the procedure descriptor is usually relative,
- we would have to relocate e->pdr.adr with cur_fdr->adr and
- ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)).
- Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
- in shared libraries on some systems, and on other systems
- e->pdr.adr is sometimes offset by a bogus value.
- To work around these problems, we replace e->pdr.adr with
- the start address of the function. */
+ procedure descriptor in e->pdr.adr.
+ As the address in the procedure descriptor is usually relative,
+ we would have to relocate e->pdr.adr with cur_fdr->adr.
+ Unfortunately cur_fdr->adr and e->pdr.adr are both absolute
+ in shared libraries on some systems, and on other systems
+ e->pdr.adr is sometimes offset by a bogus value.
+ To work around these problems, we replace e->pdr.adr with
+ the start address of the function. */
e->pdr.adr = BLOCK_START (b);
}
if (processing_gcc_compilation == 0
&& found_ecoff_debugging_info == 0
- && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID)
+ && TYPE_TARGET_TYPE (SYMBOL_TYPE (s))->code () == TYPE_CODE_VOID)
SYMBOL_TYPE (s) = objfile_type (mdebugread_objfile)->nodebug_text_symbol;
}
This routine clobbers top_stack->cur_block and ->cur_st. */
-static void parse_external (EXTR *, int, struct section_offsets *,
- struct objfile *);
-
static void
-parse_external (EXTR *es, int bigend, struct section_offsets *section_offsets,
+parse_external (EXTR *es, int bigend, const section_offsets §ion_offsets,
struct objfile *objfile)
{
union aux_ext *ax;
/* Reading .o files */
if (SC_IS_UNDEF (es->asym.sc) || es->asym.sc == scNil)
{
- char *what;
+ const char *what;
switch (es->asym.st)
{
case stNil:
case stProc:
case stStaticProc:
/* There is no need to parse the external procedure symbols.
- If they are from objects compiled without -g, their index will
- be indexNil, and the symbol definition from the minimal symbol
- is preferrable (yielding a function returning int instead of int).
- If the index points to a local procedure symbol, the local
- symbol already provides the correct type.
- Note that the index of the external procedure symbol points
- to the local procedure symbol in the local symbol table, and
- _not_ to the auxiliary symbol info. */
+ If they are from objects compiled without -g, their index will
+ be indexNil, and the symbol definition from the minimal symbol
+ is preferrable (yielding a function returning int instead of int).
+ If the index points to a local procedure symbol, the local
+ symbol already provides the correct type.
+ Note that the index of the external procedure symbol points
+ to the local procedure symbol in the local symbol table, and
+ _not_ to the auxiliary symbol info. */
break;
case stGlobal:
case stLabel:
/* Global common symbols are resolved by the runtime loader,
- ignore them. */
+ ignore them. */
if (SC_IS_COMMON (es->asym.sc))
break;
/* Note that the case of a symbol with indexNil must be handled
- anyways by parse_symbol(). */
- parse_symbol (&es->asym, ax, (char *) NULL,
+ anyways by parse_symbol(). */
+ parse_symbol (&es->asym, ax, NULL,
bigend, section_offsets, objfile);
break;
default:
numbers can go back and forth, apparently we can live
with that and do not need to reorder our linetables. */
-static void parse_lines (FDR *, PDR *, struct linetable *, int,
- struct partial_symtab *, CORE_ADDR);
-
static void
parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines,
- struct partial_symtab *pst, CORE_ADDR lowest_pdr_addr)
+ CORE_ADDR textlow, CORE_ADDR lowest_pdr_addr)
{
unsigned char *base;
int j, k;
continue;
/* Determine start and end address of compressed line bytes for
- this procedure. */
+ this procedure. */
base = debug_info->line + fh->cbLineOffset;
if (j != (fh->cpd - 1))
halt = base + pr[1].cbLineOffset;
halt = base + fh->cbLine;
base += pr->cbLineOffset;
- adr = pst->textlow + pr->adr - lowest_pdr_addr;
+ adr = textlow + pr->adr - lowest_pdr_addr;
l = adr >> 2; /* in words */
for (lineno = pr->lnLow; base < halt;)
with corrupt binaries. */
if (lt->nitems >= maxlines)
{
- complaint (&symfile_complaints,
- _("guessed size of linetable for %s incorrectly"),
+ complaint (_("guessed size of linetable for %s incorrectly"),
fdr_name (fh));
break;
}
static void
function_outside_compilation_unit_complaint (const char *arg1)
{
- complaint (&symfile_complaints,
- _("function `%s' appears to be defined "
+ complaint (_("function `%s' appears to be defined "
"outside of all compilation units"),
arg1);
}
belongs to, and then records this new minimal symbol. */
static void
-record_minimal_symbol (const char *name, const CORE_ADDR address,
- enum minimal_symbol_type ms_type, int storage_class,
- struct objfile *objfile)
+record_minimal_symbol (minimal_symbol_reader &reader,
+ const char *name, const CORE_ADDR address,
+ enum minimal_symbol_type ms_type, int storage_class,
+ struct objfile *objfile)
{
int section;
switch (storage_class)
{
case scText:
- section = SECT_OFF_TEXT (objfile);
- break;
+ section = SECT_OFF_TEXT (objfile);
+ break;
case scData:
- section = SECT_OFF_DATA (objfile);
- break;
+ section = SECT_OFF_DATA (objfile);
+ break;
case scBss:
- section = SECT_OFF_BSS (objfile);
- break;
+ section = SECT_OFF_BSS (objfile);
+ break;
case scSData:
- section = get_section_index (objfile, ".sdata");
- break;
+ section = get_section_index (objfile, ".sdata");
+ break;
case scSBss:
- section = get_section_index (objfile, ".sbss");
- break;
+ section = get_section_index (objfile, ".sbss");
+ break;
case scRData:
- section = get_section_index (objfile, ".rdata");
- break;
+ section = get_section_index (objfile, ".rdata");
+ break;
case scInit:
- section = get_section_index (objfile, ".init");
- break;
+ section = get_section_index (objfile, ".init");
+ break;
case scXData:
- section = get_section_index (objfile, ".xdata");
- break;
+ section = get_section_index (objfile, ".xdata");
+ break;
case scPData:
- section = get_section_index (objfile, ".pdata");
- break;
+ section = get_section_index (objfile, ".pdata");
+ break;
case scFini:
- section = get_section_index (objfile, ".fini");
- break;
+ section = get_section_index (objfile, ".fini");
+ break;
case scRConst:
- section = get_section_index (objfile, ".rconst");
- break;
+ section = get_section_index (objfile, ".rconst");
+ break;
#ifdef scTlsData
case scTlsData:
- section = get_section_index (objfile, ".tlsdata");
- break;
+ section = get_section_index (objfile, ".tlsdata");
+ break;
#endif
#ifdef scTlsBss
case scTlsBss:
- section = get_section_index (objfile, ".tlsbss");
- break;
+ section = get_section_index (objfile, ".tlsbss");
+ break;
#endif
default:
- /* This kind of symbol is not associated to a section. */
- section = -1;
+ /* This kind of symbol is not associated to a section. */
+ section = -1;
}
- prim_record_minimal_symbol_and_info (name, address, ms_type,
- section, objfile);
+ reader.record_with_info (name, address, ms_type, section);
}
/* Master parsing procedure for first-pass reading of file symbols
into a partial_symtab. */
static void
-parse_partial_symbols (struct objfile *objfile)
+parse_partial_symbols (minimal_symbol_reader &reader,
+ psymtab_storage *partial_symtabs,
+ struct objfile *objfile)
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
const bfd_size_type external_sym_size = debug_swap->external_sym_size;
const bfd_size_type external_rfd_size = debug_swap->external_rfd_size;
const bfd_size_type external_ext_size = debug_swap->external_ext_size;
FDR *fh;
char *ext_out;
char *ext_out_end;
- EXTR *ext_block;
EXTR *ext_in;
EXTR *ext_in_end;
SYMR sh;
- struct partial_symtab *pst;
+ legacy_psymtab *pst;
int textlow_not_set = 1;
/* List of current psymtab's include files. */
EXTR *extern_tab;
struct pst_map *fdr_to_pst;
/* Index within current psymtab dependency list. */
- struct partial_symtab **dependency_list;
+ legacy_psymtab **dependency_list;
int dependencies_used, dependencies_allocated;
- struct cleanup *old_chain;
char *name;
enum language prev_language;
asection *text_sect;
the text section (and fh->adr) really starts at zero. */
text_sect = bfd_get_section_by_name (cur_bfd, ".text");
if (text_sect != NULL
- && (bfd_get_section_flags (cur_bfd, text_sect) & SEC_RELOC))
+ && (bfd_section_flags (text_sect) & SEC_RELOC))
relocatable = 1;
- extern_tab = (EXTR *) obstack_alloc (&objfile->objfile_obstack,
- sizeof (EXTR) * hdr->iextMax);
+ extern_tab = XOBNEWVEC (&objfile->objfile_obstack, EXTR, hdr->iextMax);
includes_allocated = 30;
includes_used = 0;
dependencies_allocated = 30;
dependencies_used = 0;
dependency_list =
- (struct partial_symtab **) alloca (dependencies_allocated *
- sizeof (struct partial_symtab *));
+ (legacy_psymtab **) alloca (dependencies_allocated *
+ sizeof (legacy_psymtab *));
set_last_source_file (NULL);
/* Allocate the map FDR -> PST.
Minor hack: -O3 images might claim some global data belongs
to FDR -1. We`ll go along with that. */
- fdr_to_pst = XCNEWVEC (struct pst_map, hdr->ifdMax + 1);
- old_chain = make_cleanup (xfree, fdr_to_pst);
+ gdb::def_vector<struct pst_map> fdr_to_pst_holder (hdr->ifdMax + 1);
+ fdr_to_pst = fdr_to_pst_holder.data ();
fdr_to_pst++;
{
- struct partial_symtab *pst = new_psymtab ("", objfile);
+ legacy_psymtab *new_pst = new_psymtab ("", partial_symtabs, objfile);
- fdr_to_pst[-1].pst = pst;
- FDR_IDX (pst) = -1;
+ fdr_to_pst[-1].pst = new_pst;
+ FDR_IDX (new_pst) = -1;
}
/* Allocate the global pending list. */
- pending_list =
- ((struct mdebug_pending **)
- obstack_alloc (&objfile->objfile_obstack,
- hdr->ifdMax * sizeof (struct mdebug_pending *)));
+ pending_list = XOBNEWVEC (&objfile->objfile_obstack, mdebug_pending *,
+ hdr->ifdMax);
memset (pending_list, 0,
hdr->ifdMax * sizeof (struct mdebug_pending *));
/* Pass 0 over external syms: swap them in. */
- ext_block = XNEWVEC (EXTR, hdr->iextMax);
- make_cleanup (xfree, ext_block);
+ gdb::def_vector<EXTR> ext_block (hdr->iextMax);
ext_out = (char *) debug_info->external_ext;
ext_out_end = ext_out + hdr->iextMax * external_ext_size;
- ext_in = ext_block;
+ ext_in = ext_block.data ();
for (; ext_out < ext_out_end; ext_out += external_ext_size, ext_in++)
(*swap_ext_in) (cur_bfd, ext_out, ext_in);
/* Pass 1 over external syms: Presize and partition the list. */
- ext_in = ext_block;
+ ext_in = ext_block.data ();
ext_in_end = ext_in + hdr->iextMax;
for (; ext_in < ext_in_end; ext_in++)
{
(inefficient;
assumes no side-effects result from ignoring ECOFF symbol)
3) create it, but lookup ELF's minimal symbol and use it's section
- during relocation, then modify "uniqify" phase to merge and
+ during relocation, then modify "uniquify" phase to merge and
eliminate the duplicate symbol
(highly inefficient)
symbol table. */
/* Pass 2 over external syms: fill in external symbols. */
- ext_in = ext_block;
+ ext_in = ext_block.data ();
ext_in_end = ext_in + hdr->iextMax;
for (; ext_in < ext_in_end; ext_in++)
{
CORE_ADDR svalue = ext_in->asym.value;
/* The Irix 5 native tools seem to sometimes generate bogus
- external symbols. */
+ external symbols. */
if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax)
{
- complaint (&symfile_complaints,
- _("bad ifd for external symbol: %d (max %ld)"),
+ complaint (_("bad ifd for external symbol: %d (max %ld)"),
ext_in->ifd, hdr->ifdMax);
continue;
}
if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax)
{
- complaint (&symfile_complaints,
- _("bad iss for external symbol: %ld (max %ld)"),
+ complaint (_("bad iss for external symbol: %ld (max %ld)"),
ext_in->asym.iss, hdr->issExtMax);
continue;
}
if (SC_IS_COMMON (ext_in->asym.sc))
{
/* The value of a common symbol is its size, not its address.
- Ignore it. */
+ Ignore it. */
continue;
}
else if (SC_IS_DATA (ext_in->asym.sc))
{
ms_type = mst_bss;
}
- else if (SC_IS_SBSS (ext_in->asym.sc))
- {
- ms_type = mst_bss;
- }
+ else if (SC_IS_SBSS (ext_in->asym.sc))
+ {
+ ms_type = mst_bss;
+ }
else
ms_type = mst_abs;
break;
case stLabel:
/* Label */
- /* On certain platforms, some extra label symbols can be
- generated by the linker. One possible usage for this kind
- of symbols is to represent the address of the begining of a
- given section. For instance, on Tru64 5.1, the address of
- the _ftext label is the start address of the .text section.
-
- The storage class of these symbols is usually directly
- related to the section to which the symbol refers. For
- instance, on Tru64 5.1, the storage class for the _fdata
- label is scData, refering to the .data section.
-
- It is actually possible that the section associated to the
- storage class of the label does not exist. On True64 5.1
- for instance, the libm.so shared library does not contain
- any .data section, although it contains a _fpdata label
- which storage class is scData... Since these symbols are
- usually useless for the debugger user anyway, we just
- discard these symbols. */
-
+ /* On certain platforms, some extra label symbols can be
+ generated by the linker. One possible usage for this kind
+ of symbols is to represent the address of the begining of a
+ given section. For instance, on Tru64 5.1, the address of
+ the _ftext label is the start address of the .text section.
+
+ The storage class of these symbols is usually directly
+ related to the section to which the symbol refers. For
+ instance, on Tru64 5.1, the storage class for the _fdata
+ label is scData, refering to the .data section.
+
+ It is actually possible that the section associated to the
+ storage class of the label does not exist. On True64 5.1
+ for instance, the libm.so shared library does not contain
+ any .data section, although it contains a _fpdata label
+ which storage class is scData... Since these symbols are
+ usually useless for the debugger user anyway, we just
+ discard these symbols. */
+
if (SC_IS_TEXT (ext_in->asym.sc))
{
- if (objfile->sect_index_text == -1)
- continue;
-
+ if (objfile->sect_index_text == -1)
+ continue;
+
ms_type = mst_file_text;
}
else if (SC_IS_DATA (ext_in->asym.sc))
{
- if (objfile->sect_index_data == -1)
- continue;
+ if (objfile->sect_index_data == -1)
+ continue;
ms_type = mst_file_data;
}
else if (SC_IS_BSS (ext_in->asym.sc))
{
- if (objfile->sect_index_bss == -1)
- continue;
+ if (objfile->sect_index_bss == -1)
+ continue;
ms_type = mst_file_bss;
}
- else if (SC_IS_SBSS (ext_in->asym.sc))
- {
- const int sbss_sect_index = get_section_index (objfile, ".sbss");
+ else if (SC_IS_SBSS (ext_in->asym.sc))
+ {
+ const int sbss_sect_index = get_section_index (objfile, ".sbss");
- if (sbss_sect_index == -1)
- continue;
+ if (sbss_sect_index == -1)
+ continue;
- ms_type = mst_file_bss;
- }
+ ms_type = mst_file_bss;
+ }
else
ms_type = mst_abs;
break;
unknown_ext_complaint (name);
}
if (!ECOFF_IN_ELF (cur_bfd))
- record_minimal_symbol (name, svalue, ms_type, ext_in->asym.sc,
- objfile);
+ record_minimal_symbol (reader, name, svalue, ms_type, ext_in->asym.sc,
+ objfile);
}
/* Pass 3 over files, over local syms: fill in static symbols. */
for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++)
{
- struct partial_symtab *save_pst;
+ legacy_psymtab *save_pst;
EXTR *ext_ptr;
CORE_ADDR textlow;
}
/* Determine the start address for this object file from the
- file header and relocate it, except for Irix 5.2 zero fh->adr. */
+ file header and relocate it, except for Irix 5.2 zero fh->adr. */
if (fh->cpd)
- {
- textlow = fh->adr;
- if (relocatable || textlow != 0)
- textlow += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
- }
+ textlow = fh->adr;
else
textlow = 0;
- pst = start_psymtab_common (objfile,
- fdr_name (fh),
- textlow,
- objfile->global_psymbols.next,
- objfile->static_psymbols.next);
- pst->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct symloc));
+ pst = new legacy_psymtab (fdr_name (fh), partial_symtabs,
+ objfile->per_bfd, textlow);
+ pst->read_symtab_private = XOBNEW (&objfile->objfile_obstack, symloc);
memset (pst->read_symtab_private, 0, sizeof (struct symloc));
save_pst = pst;
PENDING_LIST (pst) = pending_list;
/* The way to turn this into a symtab is to call... */
- pst->read_symtab = mdebug_read_symtab;
+ pst->legacy_read_symtab = mdebug_read_symtab;
+ pst->legacy_expand_psymtab = mdebug_expand_psymtab;
/* Set up language for the pst.
- The language from the FDR is used if it is unambigious (e.g. cfront
- with native cc and g++ will set the language to C).
- Otherwise we have to deduce the language from the filename.
- Native ecoff has every header file in a separate FDR, so
- deduce_language_from_filename will return language_unknown for
- a header file, which is not what we want.
- But the FDRs for the header files are after the FDR for the source
- file, so we can assign the language of the source file to the
- following header files. Then we save the language in the private
- pst data so that we can reuse it when building symtabs. */
+ The language from the FDR is used if it is unambigious (e.g. cfront
+ with native cc and g++ will set the language to C).
+ Otherwise we have to deduce the language from the filename.
+ Native ecoff has every header file in a separate FDR, so
+ deduce_language_from_filename will return language_unknown for
+ a header file, which is not what we want.
+ But the FDRs for the header files are after the FDR for the source
+ file, so we can assign the language of the source file to the
+ following header files. Then we save the language in the private
+ pst data so that we can reuse it when building symtabs. */
prev_language = psymtab_language;
switch (fh->lang)
psymtab_language = prev_language;
PST_PRIVATE (pst)->pst_language = psymtab_language;
- pst->texthigh = pst->textlow;
+ pst->set_text_high (pst->raw_text_low ());
/* For stabs-in-ecoff files, the second symbol must be @stab.
- This symbol is emitted by mips-tfile to signal that the
- current object file uses encapsulated stabs instead of mips
- ecoff for local symbols. (It is the second symbol because
- the first symbol is the stFile used to signal the start of a
- file). */
+ This symbol is emitted by mips-tfile to signal that the
+ current object file uses encapsulated stabs instead of mips
+ ecoff for local symbols. (It is the second symbol because
+ the first symbol is the stFile used to signal the start of a
+ file). */
processing_gcc_compilation = 0;
if (fh->csym >= 2)
{
if (sh.st == stStaticProc)
{
namestring = debug_info->ss + fh->issBase + sh.iss;
- record_minimal_symbol (namestring, sh.value,
- mst_file_text, sh.sc,
- objfile);
+ record_minimal_symbol (reader, namestring, sh.value,
+ mst_file_text, sh.sc,
+ objfile);
}
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
procaddr = sh.value;
isym = AUX_GET_ISYM (fh->fBigendian,
/* Kludge for Irix 5.2 zero fh->adr. */
if (!relocatable
- && (pst->textlow == 0 || procaddr < pst->textlow))
- pst->textlow = procaddr;
- if (high > pst->texthigh)
- pst->texthigh = high;
+ && (!pst->text_low_valid
+ || procaddr < pst->raw_text_low ()))
+ pst->set_text_low (procaddr);
+ if (high > pst->raw_text_high ())
+ pst->set_text_high (high);
}
}
else if (sh.st == stStatic)
case scPData:
case scXData:
namestring = debug_info->ss + fh->issBase + sh.iss;
- record_minimal_symbol (namestring, sh.value,
- mst_file_data, sh.sc,
- objfile);
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
+ record_minimal_symbol (reader, namestring, sh.value,
+ mst_file_data, sh.sc,
+ objfile);
break;
default:
/* FIXME! Shouldn't this use cases for bss,
then have the default be abs? */
namestring = debug_info->ss + fh->issBase + sh.iss;
- record_minimal_symbol (namestring, sh.value,
- mst_file_bss, sh.sc,
- objfile);
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_BSS (objfile));
+ record_minimal_symbol (reader, namestring, sh.value,
+ mst_file_bss, sh.sc,
+ objfile);
break;
}
}
/* Handle stabs continuation. */
{
char *stabstring = debug_info->ss + fh->issBase + sh.iss;
+ /* If we need to heap-allocate STABSTRING, this owns
+ it. */
+ gdb::unique_xmalloc_ptr<char> stabstring_storage;
int len = strlen (stabstring);
while (stabstring[len - 1] == '\\')
stabstring2 = debug_info->ss + fh->issBase + sh2.iss;
len2 = strlen (stabstring2);
- /* Concatinate stabstring2 with stabstring1. */
- if (stabstring
- && stabstring != debug_info->ss + fh->issBase + sh.iss)
- stabstring
- = (char *) xrealloc (stabstring, len + len2 + 1);
+ /* Concatenate stabstring2 with stabstring1. */
+ if (stabstring_storage != nullptr)
+ {
+ stabstring_storage.reset
+ ((char *) xrealloc (stabstring_storage.release (),
+ len + len2 + 1));
+ stabstring = stabstring_storage.get ();
+ }
else
{
- stabstring = (char *) xmalloc (len + len2 + 1);
+ stabstring_storage.reset
+ ((char *) xmalloc (len + len2 + 1));
+ stabstring = stabstring_storage.get ();
strcpy (stabstring, stabstring1);
}
strcpy (stabstring + len, stabstring2);
switch (type_code)
{
- char *p;
+ const char *p;
/* Standard, external, non-debugger, symbols. */
case N_TEXT | N_EXT:
case N_NBTEXT | N_EXT:
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
goto record_it;
case N_DATA | N_EXT:
case N_NBDATA | N_EXT:
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
goto record_it;
case N_BSS:
case N_BSS | N_EXT:
case N_NBBSS | N_EXT:
case N_SETV | N_EXT: /* FIXME, is this in BSS? */
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_BSS (objfile));
goto record_it;
case N_ABS | N_EXT:
continue;
case N_DATA:
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
goto record_it;
case N_UNDF | N_EXT:
case N_SO:
{
static int prev_so_symnum = -10;
- const char *p;
+ const char *basename;
/* A zero value is probably an indication for the
SunPRO 3.0 compiler. dbx_end_psymtab explicitly tests
{ /* Here if prev stab wasn't N_SO. */
if (pst)
{
- pst = (struct partial_symtab *) 0;
+ pst = (legacy_psymtab *) 0;
includes_used = 0;
dependencies_used = 0;
}
the second the file name. If pst exists, is
empty, and has a filename ending in '/', we assume
the previous N_SO was a directory name. */
- p = lbasename (namestring);
- if (p != namestring && *p == '\000')
+ basename = lbasename (namestring);
+ if (basename != namestring && *basename == '\000')
continue; /* Simply ignore directory
name SOs. */
switch (p[1])
{
case 'S':
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
-
- if (gdbarch_static_transform_name_p (gdbarch))
- namestring = gdbarch_static_transform_name
- (gdbarch, namestring);
-
- add_psymbol_to_list (namestring, p - namestring, 1,
- VAR_DOMAIN, LOC_STATIC,
- &objfile->static_psymbols,
- sh.value,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_STATIC,
+ SECT_OFF_DATA (objfile),
+ psymbol_placement::STATIC,
+ sh.value,
+ psymtab_language,
+ partial_symtabs, objfile);
continue;
case 'G':
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (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, 1,
- VAR_DOMAIN, LOC_STATIC,
- &objfile->global_psymbols,
- sh.value,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_STATIC,
+ SECT_OFF_DATA (objfile),
+ psymbol_placement::GLOBAL,
+ sh.value,
+ psymtab_language,
+ partial_symtabs, objfile);
continue;
case 'T':
|| (p == namestring + 1
&& namestring[0] != ' '))
{
- add_psymbol_to_list (namestring, p - namestring, 1,
- STRUCT_DOMAIN, LOC_TYPEDEF,
- &objfile->static_psymbols,
- 0, psymtab_language, objfile);
+ pst->add_psymbol
+ (gdb::string_view (namestring, p - namestring),
+ true, STRUCT_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC, 0, psymtab_language,
+ partial_symtabs, objfile);
if (p[2] == 't')
{
/* Also a typedef with the same name. */
- add_psymbol_to_list (namestring,
- p - namestring, 1,
- VAR_DOMAIN, LOC_TYPEDEF,
- &objfile->static_psymbols,
- 0, psymtab_language,
- objfile);
+ pst->add_psymbol
+ (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC, 0,
+ psymtab_language,
+ partial_symtabs, objfile);
p += 1;
}
}
if (p != namestring) /* a name is there, not
just :T... */
{
- add_psymbol_to_list (namestring, p - namestring, 1,
- VAR_DOMAIN, LOC_TYPEDEF,
- &objfile->static_psymbols,
- 0, psymtab_language, objfile);
+ pst->add_psymbol
+ (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC, 0, psymtab_language,
+ partial_symtabs, objfile);
}
check_enum:
/* If this is an enumerated type, we need to add
Accept either. */
while (*p && *p != ';' && *p != ',')
{
- char *q;
+ const char *q;
/* Check for and handle cretinous dbx
symbol name continuation! */
/* Note that the value doesn't matter for
enum constants in psymtabs, just in
symtabs. */
- add_psymbol_to_list (p, q - p, 1,
- VAR_DOMAIN, LOC_CONST,
- &objfile->static_psymbols,
- 0, psymtab_language,
- objfile);
+ pst->add_psymbol (gdb::string_view (p,
+ q - p),
+ true, VAR_DOMAIN,
+ LOC_CONST, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language,
+ partial_symtabs, objfile);
/* Point past the name. */
p = q;
/* Skip over the value. */
continue;
case 'c':
/* Constant, e.g. from "const" in Pascal. */
- add_psymbol_to_list (namestring, p - namestring, 1,
- VAR_DOMAIN, LOC_CONST,
- &objfile->static_psymbols,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_CONST, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language,
+ partial_symtabs, objfile);
continue;
case 'f':
if (! pst)
{
- int name_len = p - namestring;
- char *name = (char *) xmalloc (name_len + 1);
-
- memcpy (name, namestring, name_len);
- name[name_len] = '\0';
- function_outside_compilation_unit_complaint (name);
- xfree (name);
+ std::string copy (namestring, p);
+ function_outside_compilation_unit_complaint
+ (copy.c_str ());
}
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
- add_psymbol_to_list (namestring, p - namestring, 1,
- VAR_DOMAIN, LOC_BLOCK,
- &objfile->static_psymbols,
- sh.value,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_BLOCK,
+ SECT_OFF_TEXT (objfile),
+ psymbol_placement::STATIC,
+ sh.value,
+ psymtab_language,
+ partial_symtabs, objfile);
continue;
/* Global functions were ignored here, but now they
case 'F':
if (! pst)
{
- int name_len = p - namestring;
- char *name = (char *) xmalloc (name_len + 1);
-
- memcpy (name, namestring, name_len);
- name[name_len] = '\0';
- function_outside_compilation_unit_complaint (name);
- xfree (name);
+ std::string copy (namestring, p);
+ function_outside_compilation_unit_complaint
+ (copy.c_str ());
}
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
- add_psymbol_to_list (namestring, p - namestring, 1,
- VAR_DOMAIN, LOC_BLOCK,
- &objfile->global_psymbols,
- sh.value,
- psymtab_language, objfile);
+ pst->add_psymbol (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_BLOCK,
+ SECT_OFF_TEXT (objfile),
+ psymbol_placement::GLOBAL,
+ sh.value,
+ psymtab_language,
+ partial_symtabs, objfile);
continue;
/* Two things show up here (hopefully); static
searching to the end of every string looking for
a backslash. */
- complaint (&symfile_complaints,
- _("unknown symbol descriptor `%c'"), p[1]);
+ complaint (_("unknown symbol descriptor `%c'"), p[1]);
/* Ignore it; perhaps it is an extension that we don't
know about. */
case N_ENDM:
/* Solaris 2 end of module, finish current partial
- symbol table. dbx_end_psymtab will set
- pst->texthigh to the proper value, which is
- necessary if a module compiled without
+ symbol table. dbx_end_psymtab will set the
+ high text address of PST to the proper value,
+ which is necessary if a module compiled without
debugging info follows this module. */
if (pst
&& gdbarch_sofun_address_maybe_missing (gdbarch))
{
- pst = (struct partial_symtab *) 0;
+ pst = (legacy_psymtab *) 0;
includes_used = 0;
dependencies_used = 0;
}
continue;
case N_RBRAC:
- if (sh.value > save_pst->texthigh)
- save_pst->texthigh = sh.value;
+ if (sh.value > save_pst->raw_text_high ())
+ save_pst->set_text_high (sh.value);
continue;
case N_EINCL:
case N_DSLINE:
default:
/* If we haven't found it yet, ignore it. It's
probably some new type we don't know about yet. */
- complaint (&symfile_complaints,
- _("unknown symbol type %s"),
+ complaint (_("unknown symbol type %s"),
hex_string (type_code)); /* CUR_SYMBOL_TYPE */
continue;
}
- if (stabstring
- && stabstring != debug_info->ss + fh->issBase + sh.iss)
- xfree (stabstring);
}
/* end - Handle continuation */
}
{
for (cur_sdx = 0; cur_sdx < fh->csym;)
{
- char *name;
+ char *sym_name;
enum address_class theclass;
CORE_ADDR minsym_value;
+ short section = -1;
(*swap_sym_in) (cur_bfd,
((char *) debug_info->external_sym
continue;
}
- name = debug_info->ss + fh->issBase + sh.iss;
+ sym_name = debug_info->ss + fh->issBase + sh.iss;
minsym_value = sh.value;
/* The value of a stEnd symbol is the displacement from the
corresponding start symbol value, do not relocate it. */
if (sh.st != stEnd)
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
+ section = SECT_OFF_TEXT (objfile);
break;
case scData:
case scSData:
case scRData:
case scPData:
case scXData:
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
+ section = SECT_OFF_DATA (objfile);
break;
case scBss:
case scSBss:
- sh.value += ANOFFSET (objfile->section_offsets,
- SECT_OFF_BSS (objfile));
+ section = SECT_OFF_BSS (objfile);
break;
}
int new_sdx;
case stStaticProc:
- prim_record_minimal_symbol_and_info (name, minsym_value,
- mst_file_text,
- SECT_OFF_TEXT (objfile),
- objfile);
+ reader.record_with_info (sym_name, minsym_value,
+ mst_file_text,
+ SECT_OFF_TEXT (objfile));
/* FALLTHROUGH */
if (sh.index >= hdr->iauxMax)
{
/* Should not happen, but does when cross-compiling
- with the MIPS compiler. FIXME -- pull later. */
- index_complaint (name);
+ with the MIPS compiler. FIXME -- pull later. */
+ index_complaint (sym_name);
new_sdx = cur_sdx + 1; /* Don't skip at all. */
}
else
if (new_sdx <= cur_sdx)
{
/* This should not happen either... FIXME. */
- complaint (&symfile_complaints,
- _("bad proc end in aux found from symbol %s"),
- name);
+ complaint (_("bad proc end in aux found from symbol %s"),
+ sym_name);
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;
+ /* 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
+ has already been entered into the minimal 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
symbol table, and the MAIN__ symbol via the minimal
symbol table. */
if (sh.st == stProc)
- add_psymbol_to_list (name, strlen (name), 1,
- VAR_DOMAIN, LOC_BLOCK,
- &objfile->global_psymbols,
- sh.value, psymtab_language, objfile);
+ pst->add_psymbol (sym_name, true,
+ VAR_DOMAIN, LOC_BLOCK,
+ section,
+ psymbol_placement::GLOBAL,
+ sh.value, psymtab_language,
+ partial_symtabs, objfile);
else
- add_psymbol_to_list (name, strlen (name), 1,
- VAR_DOMAIN, LOC_BLOCK,
- &objfile->static_psymbols,
- sh.value, psymtab_language, objfile);
+ pst->add_psymbol (sym_name, true,
+ VAR_DOMAIN, LOC_BLOCK,
+ section,
+ psymbol_placement::STATIC,
+ sh.value, psymtab_language,
+ partial_symtabs, objfile);
procaddr = sh.value;
/* Kludge for Irix 5.2 zero fh->adr. */
if (!relocatable
- && (pst->textlow == 0 || procaddr < pst->textlow))
- pst->textlow = procaddr;
+ && (!pst->text_low_valid
+ || procaddr < pst->raw_text_low ()))
+ pst->set_text_low (procaddr);
high = procaddr + sh.value;
- if (high > pst->texthigh)
- pst->texthigh = high;
+ if (high > pst->raw_text_high ())
+ pst->set_text_high (high);
continue;
case stStatic: /* Variable */
if (SC_IS_DATA (sh.sc))
- prim_record_minimal_symbol_and_info (name, minsym_value,
- mst_file_data,
- SECT_OFF_DATA (objfile),
- objfile);
+ reader.record_with_info (sym_name, minsym_value,
+ mst_file_data,
+ SECT_OFF_DATA (objfile));
else
- prim_record_minimal_symbol_and_info (name, minsym_value,
- mst_file_bss,
- SECT_OFF_BSS (objfile),
- objfile);
+ reader.record_with_info (sym_name, minsym_value,
+ mst_file_bss,
+ SECT_OFF_BSS (objfile));
theclass = LOC_STATIC;
break;
&& sh.iss != 0
&& sh.index != cur_sdx + 2)
{
- add_psymbol_to_list (name, strlen (name), 1,
- STRUCT_DOMAIN, LOC_TYPEDEF,
- &objfile->static_psymbols,
- 0, psymtab_language, objfile);
+ pst->add_psymbol (sym_name, true,
+ STRUCT_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC,
+ 0, psymtab_language,
+ partial_symtabs, objfile);
}
- handle_psymbol_enumerators (objfile, fh, sh.st, sh.value);
+ handle_psymbol_enumerators (objfile, partial_symtabs,
+ pst, fh, sh.st, sh.value);
/* Skip over the block. */
new_sdx = sh.index;
if (new_sdx <= cur_sdx)
{
/* This happens with the Ultrix kernel. */
- complaint (&symfile_complaints,
- _("bad aux index at block symbol %s"), name);
+ complaint (_("bad aux index at block symbol %s"),
+ sym_name);
new_sdx = cur_sdx + 1; /* Don't skip backward. */
}
cur_sdx = new_sdx;
goto skip;
default:
- /* Both complaints are valid: one gives symbol name,
+ /* Both complaints are valid: one gives symbol sym_name,
the other the offending symbol type. */
- complaint (&symfile_complaints, _("unknown local symbol %s"),
- name);
- complaint (&symfile_complaints, _("with type %d"), sh.st);
+ complaint (_("unknown local symbol %s"),
+ sym_name);
+ complaint (_("with type %d"), sh.st);
cur_sdx++;
continue;
}
/* Use this gdb symbol. */
- add_psymbol_to_list (name, strlen (name), 1,
- VAR_DOMAIN, theclass,
- &objfile->static_psymbols,
- sh.value, psymtab_language, objfile);
+ pst->add_psymbol (sym_name, true,
+ VAR_DOMAIN, theclass, section,
+ psymbol_placement::STATIC,
+ sh.value, psymtab_language,
+ partial_symtabs, objfile);
skip:
cur_sdx++; /* Go to next file symbol. */
}
{
enum address_class theclass;
SYMR *psh;
- char *name;
CORE_ADDR svalue;
+ short section;
+
+ gdb_assert (ext_ptr->ifd == f_idx);
- if (ext_ptr->ifd != f_idx)
- internal_error (__FILE__, __LINE__,
- _("failed internal consistency check"));
psh = &ext_ptr->asym;
/* Do not add undefined symbols to the partial symbol table. */
svalue = psh->value;
switch (psh->sc)
{
+ default:
case scText:
case scRConst:
- svalue += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
+ section = SECT_OFF_TEXT (objfile);
break;
case scData:
case scSData:
case scRData:
case scPData:
case scXData:
- svalue += ANOFFSET (objfile->section_offsets,
- SECT_OFF_DATA (objfile));
+ section = SECT_OFF_DATA (objfile);
break;
case scBss:
case scSBss:
- svalue += ANOFFSET (objfile->section_offsets,
- SECT_OFF_BSS (objfile));
+ section = SECT_OFF_BSS (objfile);
break;
}
break;
default:
unknown_ext_complaint (debug_info->ssext + psh->iss);
- /* Fall through, pretend it's global. */
+ /* Pretend it's global. */
+ /* Fall through. */
case stGlobal:
/* Global common symbols are resolved by the runtime loader,
ignore them. */
theclass = LOC_STATIC;
break;
}
- name = debug_info->ssext + psh->iss;
- add_psymbol_to_list (name, strlen (name), 1,
- VAR_DOMAIN, theclass,
- &objfile->global_psymbols,
- svalue, psymtab_language, objfile);
+ char *sym_name = debug_info->ssext + psh->iss;
+ pst->add_psymbol (sym_name, true,
+ VAR_DOMAIN, theclass,
+ section,
+ psymbol_placement::GLOBAL,
+ svalue, psymtab_language,
+ partial_symtabs, objfile);
}
}
/* Link pst to FDR. dbx_end_psymtab returns NULL if the psymtab was
- empty and put on the free list. */
+ empty and put on the free list. */
fdr_to_pst[f_idx].pst
- = dbx_end_psymtab (objfile, save_pst,
+ = dbx_end_psymtab (objfile, partial_symtabs, save_pst,
psymtab_include_list, includes_used,
- -1, save_pst->texthigh,
+ -1, save_pst->raw_text_high (),
dependency_list, dependencies_used,
textlow_not_set);
includes_used = 0;
dependencies_used = 0;
/* The objfile has its functions reordered if this partial symbol
- table overlaps any other partial symbol table.
- We cannot assume a reordered objfile if a partial symbol table
- is contained within another partial symbol table, as partial symbol
- tables for include files with executable code are contained
- within the partial symbol table for the including source file,
- and we do not want to flag the objfile reordered for these cases.
-
- This strategy works well for Irix-5.2 shared libraries, but we
- might have to use a more elaborate (and slower) algorithm for
- other cases. */
+ table overlaps any other partial symbol table.
+ We cannot assume a reordered objfile if a partial symbol table
+ is contained within another partial symbol table, as partial symbol
+ tables for include files with executable code are contained
+ within the partial symbol table for the including source file,
+ and we do not want to flag the objfile reordered for these cases.
+
+ This strategy works well for Irix-5.2 shared libraries, but we
+ might have to use a more elaborate (and slower) algorithm for
+ other cases. */
save_pst = fdr_to_pst[f_idx].pst;
if (save_pst != NULL
- && save_pst->textlow != 0
+ && save_pst->text_low_valid
&& !(objfile->flags & OBJF_REORDERED))
{
- ALL_OBJFILE_PSYMTABS (objfile, pst)
- {
- if (save_pst != pst
- && save_pst->textlow >= pst->textlow
- && save_pst->textlow < pst->texthigh
- && save_pst->texthigh > pst->texthigh)
- {
- objfile->flags |= OBJF_REORDERED;
- break;
- }
- }
+ for (partial_symtab *iter : partial_symtabs->range ())
+ {
+ if (save_pst != iter
+ && save_pst->raw_text_low () >= iter->raw_text_low ()
+ && save_pst->raw_text_low () < iter->raw_text_high ()
+ && save_pst->raw_text_high () > iter->raw_text_high ())
+ {
+ objfile->flags |= OBJF_REORDERED;
+ break;
+ }
+ }
}
}
fh = f_idx + debug_info->fdr;
pst = fdr_to_pst[f_idx].pst;
- if (pst == (struct partial_symtab *) NULL)
+ if (pst == NULL)
continue;
/* This should catch stabs-in-ecoff. */
continue;
/* Skip the first file indirect entry as it is a self dependency for
- source files or a reverse .h -> .c dependency for header files. */
+ source files or a reverse .h -> .c dependency for header files. */
pst->number_of_dependencies = 0;
- pst->dependencies =
- ((struct partial_symtab **)
- obstack_alloc (&objfile->objfile_obstack,
- ((fh->crfd - 1)
- * sizeof (struct partial_symtab *))));
+ pst->dependencies
+ = partial_symtabs->allocate_dependencies (fh->crfd - 1);
for (s_idx = 1; s_idx < fh->crfd; s_idx++)
{
RFDT rh;
&rh);
if (rh < 0 || rh >= hdr->ifdMax)
{
- complaint (&symfile_complaints, _("bad file number %ld"), rh);
+ complaint (_("bad file number %ld"), rh);
continue;
}
if (rh == f_idx)
continue;
- /* Do not add to dependeny list if psymtab was empty. */
- if (fdr_to_pst[rh].pst == (struct partial_symtab *) NULL)
+ /* Do not add to dependency list if psymtab was empty. */
+ if (fdr_to_pst[rh].pst == NULL)
continue;
pst->dependencies[pst->number_of_dependencies++]
= fdr_to_pst[rh].pst;
/* Remove the dummy psymtab created for -O3 images above, if it is
still empty, to enable the detection of stripped executables. */
- if (objfile->psymtabs->next == NULL
- && objfile->psymtabs->number_of_dependencies == 0
- && objfile->psymtabs->n_global_syms == 0
- && objfile->psymtabs->n_static_syms == 0)
- objfile->psymtabs = NULL;
- do_cleanups (old_chain);
+ partial_symtab *pst_del = partial_symtabs->psymtabs;
+ if (pst_del->next == NULL
+ && pst_del->number_of_dependencies == 0
+ && pst_del->empty ())
+ partial_symtabs->discard_psymtab (pst_del);
}
/* If the current psymbol has an enumerated type, we need to add
all the enum constants to the partial symbol table. */
static void
-handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype,
- CORE_ADDR svalue)
+handle_psymbol_enumerators (struct objfile *objfile,
+ psymtab_storage *partial_symtabs,
+ partial_symtab *pst,
+ FDR *fh, int stype, CORE_ADDR svalue)
{
const bfd_size_type external_sym_size = debug_swap->external_sym_size;
void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in;
case stBlock:
/* It is an enumerated type if the next symbol entry is a stMember
- and its auxiliary index is indexNil or its auxiliary entry
- is a plain btNil or btVoid.
- Alpha cc -migrate enums are recognized by a zero index and
- a zero symbol value.
- DU 4.0 cc enums are recognized by a member type of btEnum without
- qualifiers and a zero symbol value. */
+ and its auxiliary index is indexNil or its auxiliary entry
+ is a plain btNil or btVoid.
+ Alpha cc -migrate enums are recognized by a zero index and
+ a zero symbol value.
+ DU 4.0 cc enums are recognized by a member type of btEnum without
+ qualifiers and a zero symbol value. */
(*swap_sym_in) (cur_bfd, ext_sym, &sh);
if (sh.st != stMember)
return;
name = debug_info->ss + cur_fdr->issBase + sh.iss;
/* Note that the value doesn't matter for enum constants
- in psymtabs, just in symtabs. */
- add_psymbol_to_list (name, strlen (name), 1,
- VAR_DOMAIN, LOC_CONST,
- &objfile->static_psymbols,
- 0, psymtab_language, objfile);
+ in psymtabs, just in symtabs. */
+ pst->add_psymbol (name, true,
+ VAR_DOMAIN, LOC_CONST, -1,
+ psymbol_placement::STATIC, 0,
+ psymtab_language, partial_symtabs, objfile);
ext_sym += external_sym_size;
}
}
/* Get the next symbol. OBJFILE is unused. */
-static char *
+static const char *
mdebug_next_symbol_text (struct objfile *objfile)
{
SYMR sh;
The flow of control and even the memory allocation differs. FIXME. */
static void
-psymtab_to_symtab_1 (struct objfile *objfile,
- struct partial_symtab *pst, const char *filename)
+mdebug_expand_psymtab (legacy_psymtab *pst, struct objfile *objfile)
{
bfd_size_type external_sym_size;
bfd_size_type external_pdr_size;
struct linetable *lines;
CORE_ADDR lowest_pdr_addr = 0;
int last_symtab_ended = 0;
- struct section_offsets *section_offsets = objfile->section_offsets;
+ const section_offsets §ion_offsets = objfile->section_offsets;
if (pst->readin)
return;
- pst->readin = 1;
+ pst->readin = true;
- /* Read in all partial symbtabs on which this one is dependent.
+ /* Read in all partial symtabs on which this one is dependent.
NOTE that we do have circular dependencies, sigh. We solved
that by setting pst->readin before this point. */
-
- for (i = 0; i < pst->number_of_dependencies; i++)
- if (!pst->dependencies[i]->readin)
- {
- /* Inform about additional files to be read in. */
- if (info_verbose)
- {
- fputs_filtered (" ", gdb_stdout);
- wrap_here ("");
- fputs_filtered ("and ", gdb_stdout);
- wrap_here ("");
- printf_filtered ("%s...",
- pst->dependencies[i]->filename);
- wrap_here (""); /* Flush output */
- gdb_flush (gdb_stdout);
- }
- /* We only pass the filename for debug purposes. */
- psymtab_to_symtab_1 (objfile, pst->dependencies[i],
- pst->dependencies[i]->filename);
- }
+ pst->expand_dependencies (objfile);
/* Do nothing if this is a dummy psymtab. */
- if (pst->n_global_syms == 0 && pst->n_static_syms == 0
- && pst->textlow == 0 && pst->texthigh == 0)
+ if (pst->empty () && !pst->text_low_valid && !pst->text_high_valid)
return;
/* Now read the symbols for this symtab. */
mdebugread_objfile = objfile;
cur_fd = FDR_IDX (pst);
fh = ((cur_fd == -1)
- ? (FDR *) NULL
+ ? NULL
: debug_info->fdr + cur_fd);
cur_fdr = fh;
/* See comment in parse_partial_symbols about the @stabs sentinel. */
processing_gcc_compilation = 0;
- if (fh != (FDR *) NULL && fh->csym >= 2)
+ if (fh != NULL && fh->csym >= 2)
{
SYMR sh;
if (processing_gcc_compilation != 0)
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
/* This symbol table contains stabs-in-ecoff entries. */
if (ECOFF_IS_STAB (&sh) || (name[0] == '#'))
{
int type_code = ECOFF_UNMARK_STAB (sh.index);
+ enum language language = PST_PRIVATE (pst)->pst_language;
/* We should never get non N_STAB symbols here, but they
- should be harmless, so keep process_one_symbol from
- complaining about them. */
+ should be harmless, so keep process_one_symbol from
+ complaining about them. */
if (type_code & N_STAB)
{
/* If we found a trailing N_SO with no name, process
- it here instead of in process_one_symbol, so we
- can keep a handle to its symtab. The symtab
- would otherwise be ended twice, once in
- process_one_symbol, and once after this loop. */
+ it here instead of in process_one_symbol, so we
+ can keep a handle to its symtab. The symtab
+ would otherwise be ended twice, once in
+ process_one_symbol, and once after this loop. */
if (type_code == N_SO
&& get_last_source_file ()
&& previous_stab_code != (unsigned char) N_SO
&& *name == '\000')
{
- valu += ANOFFSET (section_offsets,
- SECT_OFF_TEXT (objfile));
+ valu += section_offsets[SECT_OFF_TEXT (objfile)];
previous_stab_code = N_SO;
cust = end_symtab (valu, SECT_OFF_TEXT (objfile));
end_stabs ();
{
last_symtab_ended = 0;
process_one_symbol (type_code, 0, valu, name,
- section_offsets, objfile);
+ section_offsets, objfile, language);
}
}
/* Similarly a hack. */
else if (name[0] == '#')
{
process_one_symbol (N_SLINE, 0, valu, name,
- section_offsets, objfile);
+ section_offsets, objfile, language);
}
if (type_code == N_FUN)
{
/* Make up special symbol to contain
procedure specific info. */
- struct mdebug_extra_func_info *e =
- ((struct mdebug_extra_func_info *)
- obstack_alloc (&mdebugread_objfile->objfile_obstack,
- sizeof (struct mdebug_extra_func_info)));
+ mdebug_extra_func_info *e
+ = OBSTACK_ZALLOC (&mdebugread_objfile->objfile_obstack,
+ mdebug_extra_func_info);
struct symbol *s = new_symbol (MDEBUG_EFI_SYMBOL_NAME);
- memset (e, 0, sizeof (struct mdebug_extra_func_info));
SYMBOL_DOMAIN (s) = LABEL_DOMAIN;
SYMBOL_ACLASS_INDEX (s) = LOC_CONST;
SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_void;
SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e;
e->pdr.framereg = -1;
- add_symbol_to_list (s, &local_symbols);
+ add_symbol_to_list (s, get_local_symbols ());
}
}
else if (sh.st == stLabel)
else
{
/* Handle encoded stab line number. */
- valu += ANOFFSET (section_offsets,
- SECT_OFF_TEXT (objfile));
- record_line (current_subfile, sh.index,
+ valu += section_offsets[SECT_OFF_TEXT (objfile)];
+ record_line (get_current_subfile (), sh.index,
gdbarch_addr_bits_remove (gdbarch, valu));
}
}
/* These are generated by gcc-2.x, do not complain. */
;
else
- complaint (&symfile_complaints,
- _("unknown stabs symbol %s"), name);
+ complaint (_("unknown stabs symbol %s"), name);
}
if (! last_symtab_ended)
{
- cust = end_symtab (pst->texthigh, SECT_OFF_TEXT (objfile));
+ cust = end_symtab (pst->raw_text_high (), SECT_OFF_TEXT (objfile));
end_stabs ();
}
/* 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,
- it did the wrong thing if the first procedure in a file was
- generated via asm statements. */
+ be necessary for stabs symtabs. And as sort_blocks modifies the
+ start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK,
+ it did the wrong thing if the first procedure in a file was
+ generated via asm statements. */
/* Fill in procedure info next. */
if (fh->cpd > 0)
{
- PDR *pr_block;
- struct cleanup *old_chain;
char *pdr_ptr;
char *pdr_end;
PDR *pdr_in;
PDR *pdr_in_end;
- pr_block = XNEWVEC (PDR, fh->cpd);
- old_chain = make_cleanup (xfree, pr_block);
+ gdb::def_vector<PDR> pr_block (fh->cpd);
pdr_ptr = ((char *) debug_info->external_pdr
+ fh->ipdFirst * external_pdr_size);
pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
- pdr_in = pr_block;
+ pdr_in = pr_block.data ();
for (;
pdr_ptr < pdr_end;
pdr_ptr += external_pdr_size, pdr_in++)
(*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in);
/* Determine lowest PDR address, the PDRs are not always
- sorted. */
- if (pdr_in == pr_block)
+ sorted. */
+ if (pdr_in == pr_block.data ())
lowest_pdr_addr = pdr_in->adr;
else if (pdr_in->adr < lowest_pdr_addr)
lowest_pdr_addr = pdr_in->adr;
}
- pdr_in = pr_block;
+ pdr_in = pr_block.data ();
pdr_in_end = pdr_in + fh->cpd;
for (; pdr_in < pdr_in_end; pdr_in++)
parse_procedure (pdr_in, cust, pst);
-
- do_cleanups (old_chain);
}
}
else
top_stack->cur_st = COMPUNIT_FILETABS (cust);
top_stack->cur_block
= BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust), STATIC_BLOCK);
- BLOCK_START (top_stack->cur_block) = pst->textlow;
+ BLOCK_START (top_stack->cur_block) = pst->text_low (objfile);
BLOCK_END (top_stack->cur_block) = 0;
top_stack->blocktype = stFile;
top_stack->cur_type = 0;
structures, so we swap them all first. */
if (fh->cpd > 0)
{
- PDR *pr_block;
- struct cleanup *old_chain;
char *pdr_ptr;
char *pdr_end;
PDR *pdr_in;
PDR *pdr_in_end;
- pr_block = XNEWVEC (PDR, fh->cpd);
-
- old_chain = make_cleanup (xfree, pr_block);
+ gdb::def_vector<PDR> pr_block (fh->cpd);
pdr_ptr = ((char *) debug_info->external_pdr
+ fh->ipdFirst * external_pdr_size);
pdr_end = pdr_ptr + fh->cpd * external_pdr_size;
- pdr_in = pr_block;
+ pdr_in = pr_block.data ();
for (;
pdr_ptr < pdr_end;
pdr_ptr += external_pdr_size, pdr_in++)
/* Determine lowest PDR address, the PDRs are not always
sorted. */
- if (pdr_in == pr_block)
+ if (pdr_in == pr_block.data ())
lowest_pdr_addr = pdr_in->adr;
else if (pdr_in->adr < lowest_pdr_addr)
lowest_pdr_addr = pdr_in->adr;
}
- parse_lines (fh, pr_block, lines, maxlines,
- pst, lowest_pdr_addr);
+ parse_lines (fh, pr_block.data (), lines, maxlines,
+ pst->text_low (objfile), lowest_pdr_addr);
if (lines->nitems < fh->cline)
lines = shrink_linetable (lines);
/* Fill in procedure info next. */
- pdr_in = pr_block;
+ pdr_in = pr_block.data ();
pdr_in_end = pdr_in + fh->cpd;
for (; pdr_in < pdr_in_end; pdr_in++)
parse_procedure (pdr_in, NULL, pst);
-
- do_cleanups (old_chain);
}
}
xfree (lines);
/* .. and our share of externals.
- XXX use the global list to speed up things here. How?
- FIXME, Maybe quit once we have found the right number of ext's? */
+ XXX use the global list to speed up things here. How?
+ FIXME, Maybe quit once we have found the right number of ext's? */
top_stack->cur_st = COMPUNIT_FILETABS (cust);
top_stack->cur_block
= BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (top_stack->cur_st),
section_offsets, objfile);
/* If there are undefined symbols, tell the user.
- The alpha has an undefined symbol for every symbol that is
- from a shared library, so tell the user only if verbose is on. */
+ The alpha has an undefined symbol for every symbol that is
+ from a shared library, so tell the user only if verbose is on. */
if (info_verbose && n_undef_symbols)
{
printf_filtered (_("File %s contains %d unresolved references:"),
cross_ref (int fd, union aux_ext *ax, struct type **tpp,
enum type_code type_code,
/* Use to alloc new type if none is found. */
- char **pname, int bigend, char *sym_name)
+ const char **pname, int bigend, const char *sym_name)
{
RNDXR rn[1];
unsigned int rf;
{
*pname = "<undefined>";
*tpp = init_type (mdebugread_objfile, type_code, 0, NULL);
- TYPE_STUB (*tpp) = 1;
+ (*tpp)->set_is_stub (true);
return result;
}
+ fh->iauxBase + sh.index)->a_ti,
&tir);
if (tir.tq0 != tqNil)
- complaint (&symfile_complaints,
- _("illegal tq0 in forward typedef for %s"), sym_name);
+ complaint (_("illegal tq0 in forward typedef for %s"), sym_name);
switch (tir.bt)
{
case btVoid:
case btTypedef:
/* Follow a forward typedef. This might recursively
- call cross_ref till we get a non typedef'ed type.
- FIXME: This is not correct behaviour, but gdb currently
- cannot handle typedefs without type copying. Type
- copying is impossible as we might have mutual forward
- references between two files and the copied type would not
- get filled in when we later parse its definition. */
+ call cross_ref till we get a non typedef'ed type.
+ FIXME: This is not correct behaviour, but gdb currently
+ cannot handle typedefs without type copying. Type
+ copying is impossible as we might have mutual forward
+ references between two files and the copied type would not
+ get filled in when we later parse its definition. */
*tpp = parse_type (xref_fd,
debug_info->external_aux + fh->iauxBase,
sh.index,
- (int *) NULL,
+ NULL,
fh->fBigendian,
debug_info->ss + fh->issBase + sh.iss);
add_pending (fh, esh, *tpp);
break;
default:
- complaint (&symfile_complaints,
- _("illegal bt %d in forward typedef for %s"), tir.bt,
+ complaint (_("illegal bt %d in forward typedef for %s"), tir.bt,
sym_name);
*tpp = init_type (mdebugread_objfile, type_code, 0, NULL);
break;
*tpp = parse_type (xref_fd,
debug_info->external_aux + fh->iauxBase,
sh.index,
- (int *) NULL,
+ NULL,
fh->fBigendian,
debug_info->ss + fh->issBase + sh.iss);
}
keeping the symtab sorted. */
static struct symbol *
-mylookup_symbol (char *name, const struct block *block,
+mylookup_symbol (const char *name, const struct block *block,
domain_enum domain, enum address_class theclass)
{
struct block_iterator iter;
inc = name[0];
ALL_BLOCK_SYMBOLS (block, iter, sym)
{
- if (SYMBOL_LINKAGE_NAME (sym)[0] == inc
+ if (sym->linkage_name ()[0] == inc
&& SYMBOL_DOMAIN (sym) == domain
&& SYMBOL_CLASS (sym) == theclass
- && strcmp (SYMBOL_LINKAGE_NAME (sym), name) == 0)
+ && strcmp (sym->linkage_name (), name) == 0)
return sym;
}
add_symbol (struct symbol *s, struct symtab *symtab, struct block *b)
{
symbol_set_symtab (s, symtab);
- dict_add_symbol (BLOCK_DICT (b), s);
+ mdict_add_symbol (BLOCK_MULTIDICT (b), s);
}
/* Add a new block B to a symtab S. */
/* Blocks with a smaller low bound should come first. */
-static int
-compare_blocks (const void *arg1, const void *arg2)
+static bool
+block_is_less_than (const struct block *b1, const struct block *b2)
{
- LONGEST addr_diff;
- struct block **b1 = (struct block **) arg1;
- struct block **b2 = (struct block **) arg2;
-
- addr_diff = (BLOCK_START ((*b1))) - (BLOCK_START ((*b2)));
- if (addr_diff == 0)
- return (BLOCK_END ((*b2))) - (BLOCK_END ((*b1)));
- return addr_diff;
+ CORE_ADDR start1 = BLOCK_START (b1);
+ CORE_ADDR start2 = BLOCK_START (b2);
+
+ if (start1 != start2)
+ return start1 < start2;
+
+ return (BLOCK_END (b2)) < (BLOCK_END (b1));
}
/* Sort the blocks of a symtab S.
* to detect -O3 images in advance.
*/
if (BLOCKVECTOR_NBLOCKS (bv) > FIRST_LOCAL_BLOCK + 1)
- qsort (&BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK),
- BLOCKVECTOR_NBLOCKS (bv) - FIRST_LOCAL_BLOCK,
- sizeof (struct block *),
- compare_blocks);
+ std::sort (&BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK),
+ &BLOCKVECTOR_BLOCK (bv, BLOCKVECTOR_NBLOCKS (bv)),
+ block_is_less_than);
{
CORE_ADDR high = 0;
struct compunit_symtab *cust = allocate_compunit_symtab (objfile, name);
struct symtab *symtab;
struct blockvector *bv;
+ enum language lang;
add_compunit_symtab_to_objfile (cust);
symtab = allocate_symtab (cust, name);
SYMTAB_LINETABLE (symtab) = new_linetable (maxlines);
+ lang = compunit_language (cust);
/* All symtabs must have at least two blocks. */
bv = new_bvect (2);
- BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = new_block (NON_FUNCTION_BLOCK);
- BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = new_block (NON_FUNCTION_BLOCK);
+ BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = new_block (NON_FUNCTION_BLOCK, lang);
+ BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = new_block (NON_FUNCTION_BLOCK, lang);
BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) =
BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
COMPUNIT_BLOCKVECTOR (cust) = bv;
/* Allocate a new partial_symtab NAME. */
-static struct partial_symtab *
-new_psymtab (char *name, struct objfile *objfile)
+static legacy_psymtab *
+new_psymtab (const char *name, psymtab_storage *partial_symtabs,
+ struct objfile *objfile)
{
- struct partial_symtab *psymtab;
+ legacy_psymtab *psymtab;
- psymtab = allocate_psymtab (name, objfile);
+ psymtab = new legacy_psymtab (name, partial_symtabs, objfile->per_bfd);
/* Keep a backpointer to the file's symbols. */
- psymtab->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct symloc));
- memset (psymtab->read_symtab_private, 0, sizeof (struct symloc));
+ psymtab->read_symtab_private
+ = OBSTACK_ZALLOC (&objfile->objfile_obstack, symloc);
CUR_BFD (psymtab) = cur_bfd;
DEBUG_SWAP (psymtab) = debug_swap;
DEBUG_INFO (psymtab) = debug_info;
PENDING_LIST (psymtab) = pending_list;
/* The way to turn this into a symtab is to call... */
- psymtab->read_symtab = mdebug_read_symtab;
+ psymtab->legacy_read_symtab = mdebug_read_symtab;
+ psymtab->legacy_expand_psymtab = mdebug_expand_psymtab;
return (psymtab);
}
return bv;
}
-/* 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. */
+/* Allocate and zero a new block of language LANGUAGE, and set its
+ BLOCK_MULTIDICT. 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 (enum block_type type)
+new_block (enum block_type type, enum language language)
{
/* FIXME: carlton/2003-09-11: This should use allocate_block to
allocate the block. Which, in turn, suggests that the block
struct block *retval = XCNEW (struct block);
if (type == FUNCTION_BLOCK)
- BLOCK_DICT (retval) = dict_create_linear_expandable ();
+ BLOCK_MULTIDICT (retval) = mdict_create_linear_expandable (language);
else
- BLOCK_DICT (retval) = dict_create_hashed_expandable ();
+ BLOCK_MULTIDICT (retval) = mdict_create_hashed_expandable (language);
return retval;
}
/* Create a new symbol with printname NAME. */
static struct symbol *
-new_symbol (char *name)
+new_symbol (const char *name)
{
- struct symbol *s = allocate_symbol (mdebugread_objfile);
+ struct symbol *s = new (&mdebugread_objfile->objfile_obstack) symbol;
- SYMBOL_SET_LANGUAGE (s, psymtab_language,
- &mdebugread_objfile->objfile_obstack);
- SYMBOL_SET_NAMES (s, name, strlen (name), 1, mdebugread_objfile);
+ s->set_language (psymtab_language, &mdebugread_objfile->objfile_obstack);
+ s->compute_and_set_names (name, true, mdebugread_objfile->per_bfd);
return s;
}
struct type *t;
t = alloc_type (mdebugread_objfile);
- TYPE_NAME (t) = name;
+ t->set_name (name);
INIT_CPLUS_SPECIFIC (t);
return t;
}
{
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 ();
+ minimal_symbol_reader reader (objfile);
- info = ((struct ecoff_debug_info *)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct ecoff_debug_info)));
+ info = XOBNEW (&objfile->objfile_obstack, ecoff_debug_info);
if (!(*swap->read_debug_info) (abfd, sec, info))
error (_("Error reading ECOFF debugging information: %s"),
bfd_errmsg (bfd_get_error ()));
- mdebug_build_psymtabs (objfile, swap, info);
+ mdebug_build_psymtabs (reader, objfile, swap, info);
- install_minimal_symbols (objfile);
- do_cleanups (back_to);
+ reader.install ();
}
+void _initialize_mdebugread ();
void
-_initialize_mdebugread (void)
+_initialize_mdebugread ()
{
- basic_type_data = register_objfile_data ();
-
mdebug_register_index
= register_symbol_register_impl (LOC_REGISTER, &mdebug_register_funcs);
mdebug_regparm_index
projects / deliverable / binutils-gdb.git / blobdiff