/* Read coff symbol tables and convert to internal format, for GDB.
- Copyright (C) 1987-2019 Free Software Foundation, Inc.
+ Copyright (C) 1987-2020 Free Software Foundation, Inc.
Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
This file is part of GDB.
{
for (minimal_symbol *msym : objfile->msymbols ())
{
- const char *name = MSYMBOL_LINKAGE_NAME (msym);
+ const char *name = msym->linkage_name ();
/* If the minimal symbols whose name are prefixed by "__imp_"
or "_imp_", get rid of the prefix, and search the minimal
long symtab_offset, unsigned int nsyms,
struct objfile *objfile)
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
struct context_stack *newobj = nullptr;
struct coff_symbol coff_symbol;
struct coff_symbol *cs = &coff_symbol;
file with no symbols. */
if (in_source_file)
complete_symtab (filestring,
- cs->c_value + ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile)),
+ (cs->c_value
+ + objfile->text_section_offset ()),
main_aux.x_scn.x_scnlen);
in_source_file = 0;
}
|| cs->c_sclass == C_THUMBEXTFUNC
|| cs->c_sclass == C_THUMBEXT
|| (pe_file && (cs->c_sclass == C_STAT)))
- offset = ANOFFSET (objfile->section_offsets, sec);
+ offset = objfile->section_offsets[sec];
if (bfd_section->flags & SEC_CODE)
{
NULL, cstk.start_addr,
fcn_cs_saved.c_value
+ fcn_aux_saved.x_sym.x_misc.x_fsize
- + ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile)));
+ + objfile->text_section_offset ());
within_function = 0;
}
break;
if (strcmp (cs->c_name, ".bb") == 0)
{
tmpaddr = cs->c_value;
- tmpaddr += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
+ tmpaddr += objfile->text_section_offset ();
push_context (++depth, tmpaddr);
}
else if (strcmp (cs->c_name, ".eb") == 0)
}
if (*get_local_symbols () && !outermost_context_p ())
{
- tmpaddr =
- cs->c_value + ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
+ tmpaddr = cs->c_value + objfile->text_section_offset ();
/* Make a block for the local symbols within. */
finish_block (0, cstk.old_blocks, NULL,
cstk.start_addr, tmpaddr);
enter_linenos (long file_offset, int first_line,
int last_line, struct objfile *objfile)
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
char *rawptr;
struct internal_lineno lptr;
if (L_LNNO32 (&lptr) && L_LNNO32 (&lptr) <= last_line)
{
CORE_ADDR addr = lptr.l_addr.l_paddr;
- addr += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
+ addr += objfile->text_section_offset ();
record_line (get_current_subfile (),
first_line + L_LNNO32 (&lptr),
gdbarch_addr_bits_remove (gdbarch, addr));
{
struct type *target = TYPE_TARGET_TYPE (type);
struct type *real_target = TYPE_TARGET_TYPE (real_type);
- int field_size = TYPE_NFIELDS (real_target) * sizeof (struct field);
+ int field_size = real_target->num_fields () * sizeof (struct field);
TYPE_LENGTH (target) = TYPE_LENGTH (real_target);
- TYPE_NFIELDS (target) = TYPE_NFIELDS (real_target);
- TYPE_FIELDS (target) = (struct field *) TYPE_ALLOC (target,
- field_size);
+ target->set_num_fields (real_target->num_fields ());
- memcpy (TYPE_FIELDS (target),
- TYPE_FIELDS (real_target),
- field_size);
+ field *fields = (struct field *) TYPE_ALLOC (target, field_size);
+ memcpy (fields, real_target->fields (), field_size);
+ target->set_fields (fields);
- if (TYPE_NAME (real_target))
+ if (real_target->name ())
{
/* The previous copy of TYPE_NAME is allocated by
process_coff_symbol. */
- if (TYPE_NAME (target))
- xfree ((char*) TYPE_NAME (target));
- TYPE_NAME (target) = xstrdup (TYPE_NAME (real_target));
+ xfree ((char *) target->name ());
+ target->set_name (xstrdup (real_target->name ()));
}
}
from different files with the same name. */
if (SYMBOL_CLASS (real_sym) == LOC_TYPEDEF
&& SYMBOL_DOMAIN (real_sym) == VAR_DOMAIN
- && TYPE_CODE (SYMBOL_TYPE (real_sym)) == TYPE_CODE_PTR
+ && SYMBOL_TYPE (real_sym)->code () == TYPE_CODE_PTR
&& TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym))) != 0)
{
- const char *name = SYMBOL_LINKAGE_NAME (real_sym);
+ const char *name = real_sym->linkage_name ();
int hash = hashname (name);
struct symbol *sym, *prev;
prev = 0;
for (sym = opaque_type_chain[hash]; sym;)
{
- if (name[0] == SYMBOL_LINKAGE_NAME (sym)[0]
- && strcmp (name + 1, SYMBOL_LINKAGE_NAME (sym) + 1) == 0)
+ if (name[0] == sym->linkage_name ()[0]
+ && strcmp (name + 1, sym->linkage_name () + 1) == 0)
{
if (prev)
{
union internal_auxent *aux,
struct objfile *objfile)
{
- struct symbol *sym = allocate_symbol (objfile);
+ struct symbol *sym = new (&objfile->objfile_obstack) symbol;
char *name;
name = cs->c_name;
name = EXTERNAL_NAME (name, objfile->obfd);
- SYMBOL_SET_LANGUAGE (sym, get_current_subfile ()->language,
- &objfile->objfile_obstack);
- SYMBOL_SET_NAMES (sym, name, true, objfile);
+ sym->set_language (get_current_subfile ()->language,
+ &objfile->objfile_obstack);
+ sym->compute_and_set_names (name, true, objfile->per_bfd);
/* default assumptions */
SYMBOL_VALUE (sym) = cs->c_value;
if (ISFCN (cs->c_type))
{
- SYMBOL_VALUE (sym) += ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile));
+ SYMBOL_VALUE (sym) += objfile->text_section_offset ();
SYMBOL_TYPE (sym) =
lookup_function_type (decode_function_type (cs, cs->c_type,
aux, objfile));
SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
SET_SYMBOL_VALUE_ADDRESS (sym,
(CORE_ADDR) cs->c_value
- + ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile)));
+ + objfile->section_offsets[SECT_OFF_TEXT (objfile)]);
add_symbol_to_list (sym, get_global_symbols ());
break;
SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
SET_SYMBOL_VALUE_ADDRESS (sym,
(CORE_ADDR) cs->c_value
- + ANOFFSET (objfile->section_offsets,
- SECT_OFF_TEXT (objfile)));
+ + objfile->section_offsets[SECT_OFF_TEXT (objfile)]);
if (within_function)
{
/* Static symbol of local scope. */
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
/* If type has no name, give it one. */
- if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
+ if (SYMBOL_TYPE (sym)->name () == 0)
{
- if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
- || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
+ if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_PTR
+ || SYMBOL_TYPE (sym)->code () == TYPE_CODE_FUNC)
{
/* If we are giving a name to a type such as
"pointer to foo" or "function returning foo", we
;
}
else
- TYPE_NAME (SYMBOL_TYPE (sym)) =
- xstrdup (SYMBOL_LINKAGE_NAME (sym));
+ SYMBOL_TYPE (sym)->set_name (xstrdup (sym->linkage_name ()));
}
/* Keep track of any type which points to empty structured
not an empty structured type, though; the forward
references work themselves out via the magic of
coff_lookup_type. */
- if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
+ if (SYMBOL_TYPE (sym)->code () == TYPE_CODE_PTR
&& TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0
- && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym)))
- != TYPE_CODE_UNDEF)
+ && TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))->code ()
+ != TYPE_CODE_UNDEF)
{
- int i = hashname (SYMBOL_LINKAGE_NAME (sym));
+ int i = hashname (sym->linkage_name ());
SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
opaque_type_chain[i] = sym;
/* Some compilers try to be helpful by inventing "fake"
names for anonymous enums, structures, and unions, like
"~0fake" or ".0fake". Thanks, but no thanks... */
- if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
- if (SYMBOL_LINKAGE_NAME (sym) != NULL
- && *SYMBOL_LINKAGE_NAME (sym) != '~'
- && *SYMBOL_LINKAGE_NAME (sym) != '.')
- TYPE_NAME (SYMBOL_TYPE (sym)) =
- xstrdup (SYMBOL_LINKAGE_NAME (sym));
+ if (SYMBOL_TYPE (sym)->name () == 0)
+ if (sym->linkage_name () != NULL
+ && *sym->linkage_name () != '~'
+ && *sym->linkage_name () != '.')
+ SYMBOL_TYPE (sym)->set_name (xstrdup (sym->linkage_name ()));
add_symbol_to_list (sym, get_file_symbols ());
break;
union internal_auxent *aux,
struct objfile *objfile)
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
struct type *type;
switch (c_type)
{
/* Anonymous structure type. */
type = coff_alloc_type (cs->c_symnum);
- TYPE_CODE (type) = TYPE_CODE_STRUCT;
- TYPE_NAME (type) = NULL;
+ type->set_code (TYPE_CODE_STRUCT);
+ type->set_name (NULL);
INIT_CPLUS_SPECIFIC (type);
TYPE_LENGTH (type) = 0;
- TYPE_FIELDS (type) = 0;
- TYPE_NFIELDS (type) = 0;
+ type->set_fields (nullptr);
+ type->set_num_fields (0);
}
else
{
{
/* Anonymous union type. */
type = coff_alloc_type (cs->c_symnum);
- TYPE_NAME (type) = NULL;
+ type->set_name (NULL);
INIT_CPLUS_SPECIFIC (type);
TYPE_LENGTH (type) = 0;
- TYPE_FIELDS (type) = 0;
- TYPE_NFIELDS (type) = 0;
+ type->set_fields (nullptr);
+ type->set_num_fields (0);
}
else
{
aux->x_sym.x_fcnary.x_fcn.x_endndx.l,
objfile);
}
- TYPE_CODE (type) = TYPE_CODE_UNION;
+ type->set_code (TYPE_CODE_UNION);
return type;
case T_ENUM:
{
/* Anonymous enum type. */
type = coff_alloc_type (cs->c_symnum);
- TYPE_CODE (type) = TYPE_CODE_ENUM;
- TYPE_NAME (type) = NULL;
+ type->set_code (TYPE_CODE_ENUM);
+ type->set_name (NULL);
TYPE_LENGTH (type) = 0;
- TYPE_FIELDS (type) = 0;
- TYPE_NFIELDS (type) = 0;
+ type->set_fields (nullptr);
+ type->set_num_fields (0);
}
else
{
int done = 0;
type = coff_alloc_type (index);
- TYPE_CODE (type) = TYPE_CODE_STRUCT;
+ type->set_code (TYPE_CODE_STRUCT);
INIT_CPLUS_SPECIFIC (type);
TYPE_LENGTH (type) = length;
}
/* Now create the vector of fields, and record how big it is. */
- TYPE_NFIELDS (type) = nfields;
- TYPE_FIELDS (type) = (struct field *)
- TYPE_ALLOC (type, sizeof (struct field) * nfields);
+ type->set_num_fields (nfields);
+ type->set_fields
+ ((struct field *) TYPE_ALLOC (type, sizeof (struct field) * nfields));
/* Copy the saved-up fields into the field vector. */
for (n = nfields; list; list = list->next)
- TYPE_FIELD (type, --n) = list->field;
+ type->field (--n) = list->field;
return type;
}
coff_read_enum_type (int index, int length, int lastsym,
struct objfile *objfile)
{
- struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ struct gdbarch *gdbarch = objfile->arch ();
struct symbol *sym;
struct type *type;
int nsyms = 0;
switch (ms->c_sclass)
{
case C_MOE:
- sym = allocate_symbol (objfile);
+ sym = new (&objfile->objfile_obstack) symbol;
name = obstack_strdup (&objfile->objfile_obstack, name);
- SYMBOL_SET_LINKAGE_NAME (sym, name);
+ sym->set_linkage_name (name);
SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_VALUE (sym) = ms->c_value;
TYPE_LENGTH (type) = length;
else /* Assume ints. */
TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
- TYPE_CODE (type) = TYPE_CODE_ENUM;
- TYPE_NFIELDS (type) = nsyms;
- TYPE_FIELDS (type) = (struct field *)
- TYPE_ALLOC (type, sizeof (struct field) * nsyms);
+ type->set_code (TYPE_CODE_ENUM);
+ type->set_num_fields (nsyms);
+ type->set_fields
+ ((struct field *) TYPE_ALLOC (type, sizeof (struct field) * nsyms));
/* Find the symbols for the values and put them into the type.
The symbols can be found in the symlist that we put them on
struct symbol *xsym = syms->symbol[j];
SYMBOL_TYPE (xsym) = type;
- TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym);
- SET_FIELD_ENUMVAL (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym));
+ TYPE_FIELD_NAME (type, n) = xsym->linkage_name ();
+ SET_FIELD_ENUMVAL (type->field (n), SYMBOL_VALUE (xsym));
if (SYMBOL_VALUE (xsym) < 0)
unsigned_enum = 0;
TYPE_FIELD_BITSIZE (type, n) = 0;
&psym_functions
};
+void _initialize_coffread ();
void
-_initialize_coffread (void)
+_initialize_coffread ()
{
add_symtab_fns (bfd_target_coff_flavour, &coff_sym_fns);
projects / deliverable / binutils-gdb.git / blobdiff