/* Read a symbol table in ECOFF format (Third-Eye).
- Copyright (C) 1986-2019 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 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 "expression.h"
+#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
symbol's ECOFF section with its ELF section. This is necessary in
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;
static void sort_blocks (struct symtab *);
-static struct partial_symtab *new_psymtab (const char *, struct objfile *);
+static legacy_psymtab *new_psymtab (const char *, 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 *);
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. */
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 */
};
if (regno < 0 || regno >= gdbarch_num_cooked_regs (gdbarch))
{
reg_value_complaint (regno, gdbarch_num_cooked_regs (gdbarch),
- SYMBOL_PRINT_NAME (sym));
+ sym->print_name ());
regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless. */
}
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;
const char *name;
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;
{
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
/* All functions in C++ have prototypes. For C we don't have enough
information in the debug info. */
- if (SYMBOL_LANGUAGE (s) == language_cplus)
+ if (s->language () == language_cplus)
TYPE_PROTOTYPED (SYMBOL_TYPE (s)) = 1;
/* Create and enter a new lexical context. */
- b = new_block (FUNCTION_BLOCK, SYMBOL_LANGUAGE (s));
+ b = new_block (FUNCTION_BLOCK, s->language ());
SYMBOL_BLOCK_VALUE (s) = b;
BLOCK_FUNCTION (b) = s;
BLOCK_START (b) = BLOCK_END (b) = sh->value;
(.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_NAME (t) = NULL;
+ t->set_name (NULL);
else
- TYPE_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;
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,
- obstack_strdup (&mdebugread_objfile->objfile_obstack,
+ 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;
/* 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;
break;
}
}
- 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. */
{
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 (cblock, iter, sym)
case stMember: /* member of struct or union */
{
- struct field *f
- = &TYPE_FIELDS (top_stack->cur_type)[top_stack->cur_field++];
+ 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;
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
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;
static struct type *
basic_type (int bt, struct objfile *objfile)
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
struct type **map_bt = basic_type_data.get (objfile);
struct type *tp;
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:
/* DEC c89 produces cross references to qualified aggregate types,
dereference them. */
- while (TYPE_CODE (tp) == TYPE_CODE_PTR
- || TYPE_CODE (tp) == TYPE_CODE_ARRAY)
+ 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)
+ 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_NAME (tp) = NULL;
- else if (TYPE_NAME (tp) == NULL
- || strcmp (TYPE_NAME (tp), name) != 0)
- TYPE_NAME (tp)
- = obstack_strdup (&mdebugread_objfile->objfile_obstack, 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));
}
}
/* 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)
+ 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)
- = obstack_strdup (&mdebugread_objfile->objfile_obstack, name);
+ if (tp->name () == NULL
+ || strcmp (tp->name (), name) != 0)
+ tp->set_name (obstack_strdup (&mdebugread_objfile->objfile_obstack,
+ name));
}
}
if (t->bt == btTypedef)
/* Deal with range types. */
if (t->bt == btRange)
{
- TYPE_NFIELDS (tp) = 0;
+ tp->set_num_fields (0);
TYPE_RANGE_DATA (tp) = ((struct range_bounds *)
TYPE_ZALLOC (tp, sizeof (struct range_bounds)));
TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax);
/* 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)
+ if (indx->code () != TYPE_CODE_INT)
{
complaint (_("illegal array index type for %s, assuming int"),
sym_name);
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;
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);
/* 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)).
+ 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.
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;
parse_partial_symbols (minimal_symbol_reader &reader,
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;
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;
char *name;
enum language prev_language;
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 = XOBNEWVEC (&objfile->objfile_obstack, EXTR, hdr->iextMax);
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);
fdr_to_pst = fdr_to_pst_holder.data ();
fdr_to_pst++;
{
- struct partial_symtab *new_pst = new_psymtab ("", objfile);
+ legacy_psymtab *new_pst = new_psymtab ("", objfile);
fdr_to_pst[-1].pst = new_pst;
FDR_IDX (new_pst) = -1;
(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)
/* 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;
textlow = fh->adr;
else
textlow = 0;
- pst = start_psymtab_common (objfile,
- fdr_name (fh),
- textlow);
+ pst = new legacy_psymtab (fdr_name (fh), objfile, textlow);
pst->read_symtab_private = XOBNEW (&objfile->objfile_obstack, symloc);
memset (pst->read_symtab_private, 0, sizeof (struct symloc));
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
{ /* 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;
}
namestring = gdbarch_static_transform_name
(gdbarch, namestring);
- add_psymbol_to_list (namestring, p - namestring, 1,
- VAR_DOMAIN, LOC_STATIC,
+ add_psymbol_to_list (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_STATIC,
SECT_OFF_DATA (objfile),
psymbol_placement::STATIC,
sh.value,
/* 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,
+ add_psymbol_to_list (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_STATIC,
SECT_OFF_DATA (objfile),
psymbol_placement::GLOBAL,
sh.value,
|| (p == namestring + 1
&& namestring[0] != ' '))
{
- add_psymbol_to_list (namestring, p - namestring, 1,
- STRUCT_DOMAIN, LOC_TYPEDEF,
- -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ add_psymbol_to_list
+ (gdb::string_view (namestring, p - namestring),
+ true, STRUCT_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC, 0, psymtab_language,
+ objfile);
if (p[2] == 't')
{
/* Also a typedef with the same name. */
- add_psymbol_to_list (namestring,
- p - namestring, 1,
- VAR_DOMAIN, LOC_TYPEDEF,
- -1,
- psymbol_placement::STATIC,
- 0, psymtab_language,
- objfile);
+ add_psymbol_to_list
+ (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC, 0,
+ psymtab_language, 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,
- -1,
- psymbol_placement::STATIC,
- 0, psymtab_language, objfile);
+ add_psymbol_to_list
+ (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_TYPEDEF, -1,
+ psymbol_placement::STATIC, 0, psymtab_language,
+ objfile);
}
check_enum:
/* If this is an enumerated type, we need to add
/* 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,
- -1,
+ add_psymbol_to_list (gdb::string_view (p,
+ q - p),
+ true, VAR_DOMAIN,
+ LOC_CONST, -1,
psymbol_placement::STATIC,
0, psymtab_language,
objfile);
continue;
case 'c':
/* Constant, e.g. from "const" in Pascal. */
- add_psymbol_to_list (namestring, p - namestring, 1,
- VAR_DOMAIN, LOC_CONST, -1,
+ add_psymbol_to_list (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_CONST, -1,
psymbol_placement::STATIC,
0, psymtab_language, objfile);
continue;
function_outside_compilation_unit_complaint
(copy.c_str ());
}
- add_psymbol_to_list (namestring, p - namestring, 1,
- VAR_DOMAIN, LOC_BLOCK,
+ add_psymbol_to_list (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_BLOCK,
SECT_OFF_TEXT (objfile),
psymbol_placement::STATIC,
sh.value,
function_outside_compilation_unit_complaint
(copy.c_str ());
}
- add_psymbol_to_list (namestring, p - namestring, 1,
- VAR_DOMAIN, LOC_BLOCK,
+ add_psymbol_to_list (gdb::string_view (namestring,
+ p - namestring),
+ true, VAR_DOMAIN, LOC_BLOCK,
SECT_OFF_TEXT (objfile),
psymbol_placement::GLOBAL,
sh.value,
if (pst
&& gdbarch_sofun_address_maybe_missing (gdbarch))
{
- pst = (struct partial_symtab *) 0;
+ pst = (legacy_psymtab *) 0;
includes_used = 0;
dependencies_used = 0;
}
/* 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 (sym_name, strlen (sym_name), 1,
+ add_psymbol_to_list (sym_name, true,
VAR_DOMAIN, LOC_BLOCK,
section,
psymbol_placement::GLOBAL,
sh.value, psymtab_language, objfile);
else
- add_psymbol_to_list (sym_name, strlen (sym_name), 1,
+ add_psymbol_to_list (sym_name, true,
VAR_DOMAIN, LOC_BLOCK,
section,
psymbol_placement::STATIC,
&& sh.iss != 0
&& sh.index != cur_sdx + 2)
{
- add_psymbol_to_list (sym_name, strlen (sym_name), 1,
+ add_psymbol_to_list (sym_name, true,
STRUCT_DOMAIN, LOC_TYPEDEF, -1,
psymbol_placement::STATIC,
0, psymtab_language, objfile);
continue;
}
/* Use this gdb symbol. */
- add_psymbol_to_list (sym_name, strlen (sym_name), 1,
+ add_psymbol_to_list (sym_name, true,
VAR_DOMAIN, theclass, section,
psymbol_placement::STATIC,
sh.value, psymtab_language, objfile);
CORE_ADDR svalue;
short section;
- if (ext_ptr->ifd != f_idx)
- internal_error (__FILE__, __LINE__,
- _("failed internal consistency check"));
+ gdb_assert (ext_ptr->ifd == f_idx);
+
psh = &ext_ptr->asym;
/* Do not add undefined symbols to the partial symbol table. */
break;
}
char *sym_name = debug_info->ssext + psh->iss;
- add_psymbol_to_list (sym_name, strlen (sym_name), 1,
+ add_psymbol_to_list (sym_name, true,
VAR_DOMAIN, theclass,
section,
psymbol_placement::GLOBAL,
if (rh == f_idx)
continue;
- /* Do not add to dependeny list if psymtab was empty. */
+ /* Do not add to dependency list if psymtab was empty. */
if (fdr_to_pst[rh].pst == NULL)
continue;
pst->dependencies[pst->number_of_dependencies++]
/* Remove the dummy psymtab created for -O3 images above, if it is
still empty, to enable the detection of stripped executables. */
- pst = objfile->partial_symtabs->psymtabs;
- if (pst->next == NULL
- && pst->number_of_dependencies == 0
- && pst->n_global_syms == 0
- && pst->n_static_syms == 0)
- objfile->partial_symtabs->psymtabs = NULL;
+ partial_symtab *pst_del = objfile->partial_symtabs->psymtabs;
+ if (pst_del->next == NULL
+ && pst_del->number_of_dependencies == 0
+ && pst_del->n_global_syms == 0
+ && pst_del->n_static_syms == 0)
+ objfile->partial_symtabs->discard_psymtab (pst_del);
}
/* If the current psymbol has an enumerated type, we need to add
/* Note that the value doesn't matter for enum constants
in psymtabs, just in symtabs. */
- add_psymbol_to_list (name, strlen (name), 1,
+ add_psymbol_to_list (name, true,
VAR_DOMAIN, LOC_CONST, -1,
psymbol_placement::STATIC, 0,
psymtab_language, objfile);
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 (processing_gcc_compilation != 0)
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
/* This symbol table contains stabs-in-ecoff entries. */
&& 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 ();
else
{
/* Handle encoded stab line number. */
- valu += ANOFFSET (section_offsets,
- SECT_OFF_TEXT (objfile));
+ valu += section_offsets[SECT_OFF_TEXT (objfile)];
record_line (get_current_subfile (), sh.index,
gdbarch_addr_bits_remove (gdbarch, valu));
}
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;
}
/* 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;
/* Allocate a new partial_symtab NAME. */
-static struct partial_symtab *
+static legacy_psymtab *
new_psymtab (const char *name, struct objfile *objfile)
{
- struct partial_symtab *psymtab;
+ legacy_psymtab *psymtab;
- psymtab = allocate_psymtab (name, objfile);
+ psymtab = new legacy_psymtab (name, objfile);
/* Keep a backpointer to the file's symbols. */
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);
}
static struct symbol *
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;
}
reader.install ();
}
+void _initialize_mdebugread ();
void
-_initialize_mdebugread (void)
+_initialize_mdebugread ()
{
mdebug_register_index
= register_symbol_register_impl (LOC_REGISTER, &mdebug_register_funcs);
projects / deliverable / binutils-gdb.git / blobdiff