static legacy_psymtab *new_psymtab (const char *, struct objfile *);
-static void psymtab_to_symtab_1 (legacy_psymtab *pst,
- struct objfile *objfile);
+static void mdebug_expand_psymtab (legacy_psymtab *pst,
+ struct objfile *objfile);
static void add_block (struct block *, struct symtab *);
parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend,
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;
{
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
TYPE_NAME (t) = 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 *)
/* 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)))
+ || (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
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
/* 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)
/* 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);
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;
}
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;
/* The way to turn this into a symtab is to call... */
pst->legacy_read_symtab = mdebug_read_symtab;
- pst->legacy_expand_psymtab = psymtab_to_symtab_1;
+ 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
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. */
The flow of control and even the memory allocation differs. FIXME. */
static void
-psymtab_to_symtab_1 (legacy_psymtab *pst, struct objfile *objfile)
+mdebug_expand_psymtab (legacy_psymtab *pst, struct objfile *objfile)
{
bfd_size_type external_sym_size;
bfd_size_type external_pdr_size;
/* 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. */
- pst->read_dependencies (objfile);
+ 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. */
/* The way to turn this into a symtab is to call... */
psymtab->legacy_read_symtab = mdebug_read_symtab;
- psymtab->legacy_expand_psymtab = psymtab_to_symtab_1;
+ psymtab->legacy_expand_psymtab = mdebug_expand_psymtab;
return (psymtab);
}
projects / deliverable / binutils-gdb.git / blobdiff