/* On xcoff, if a global is defined and never referenced,
ld will remove it from the executable. There is then
a N_GSYM stab for it, but no regular (C_EXT) symbol. */
- sym = allocate_symbol (objfile);
+ sym = new (&objfile->objfile_obstack) symbol;
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
sym->set_linkage_name
e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
nameless = (p == string || ((string[0] == ' ') && (string[1] == ':')));
- current_symbol = sym = allocate_symbol (objfile);
+ current_symbol = sym = new (&objfile->objfile_obstack) symbol;
if (processing_gcc_compilation)
{
/* This was an anonymous type that was never fixed up. */
goto normal;
- case 'X':
- /* SunPRO (3.0 at least) static variable encoding. */
- if (gdbarch_static_transform_name_p (gdbarch))
- goto normal;
- /* fall through */
-
default:
complaint (_("Unknown C++ symbol name `%s'"),
string);
/* Function result types are described as the result type in stabs.
We need to convert this to the function-returning-type-X type
in GDB. E.g. "int" is converted to "function returning int". */
- if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_FUNC)
+ if (SYMBOL_TYPE (sym)->code () != TYPE_CODE_FUNC)
SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym));
/* All functions in C++ have prototypes. Stabs does not offer an
}
/* Allocate parameter information fields and fill them in. */
- TYPE_FIELDS (ftype) = (struct field *)
- TYPE_ALLOC (ftype, nsemi * sizeof (struct field));
+ ftype->set_fields
+ ((struct field *)
+ TYPE_ALLOC (ftype, nsemi * sizeof (struct field)));
while (*p++ == ';')
{
struct type *ptype;
a TYPE_CODE_VOID type by read_type, and we have to turn
it back into builtin_int here.
FIXME: Do we need a new builtin_promoted_int_arg ? */
- if (TYPE_CODE (ptype) == TYPE_CODE_VOID)
+ if (ptype->code () == TYPE_CODE_VOID)
ptype = objfile_type (objfile)->builtin_int;
- TYPE_FIELD_TYPE (ftype, nparams) = ptype;
+ ftype->field (nparams).set_type (ptype);
TYPE_FIELD_ARTIFICIAL (ftype, nparams++) = 0;
}
- TYPE_NFIELDS (ftype) = nparams;
+ ftype->set_num_fields (nparams);
TYPE_PROTOTYPED (ftype) = 1;
}
break;
really an int. */
if (TYPE_LENGTH (SYMBOL_TYPE (sym))
< gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT
- && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT)
+ && SYMBOL_TYPE (sym)->code () == TYPE_CODE_INT)
{
SYMBOL_TYPE (sym) =
TYPE_UNSIGNED (SYMBOL_TYPE (sym))
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
SET_SYMBOL_VALUE_ADDRESS (sym, valu);
- if (gdbarch_static_transform_name_p (gdbarch)
- && gdbarch_static_transform_name (gdbarch, sym->linkage_name ())
- != sym->linkage_name ())
- {
- struct bound_minimal_symbol msym;
-
- msym = lookup_minimal_symbol (sym->linkage_name (), NULL, objfile);
- if (msym.minsym != NULL)
- {
- const char *new_name = gdbarch_static_transform_name
- (gdbarch, sym->linkage_name ());
-
- sym->set_linkage_name (new_name);
- SET_SYMBOL_VALUE_ADDRESS (sym,
- BMSYMBOL_VALUE_ADDRESS (msym));
- }
- }
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
add_symbol_to_list (sym, get_file_symbols ());
break;
a base type which did not have its name defined when the
derived class was output. We fill in the derived class's
base part member's name here in that case. */
- if (TYPE_NAME (SYMBOL_TYPE (sym)) != NULL)
- if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
- || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION)
+ if (SYMBOL_TYPE (sym)->name () != NULL)
+ if ((SYMBOL_TYPE (sym)->code () == TYPE_CODE_STRUCT
+ || SYMBOL_TYPE (sym)->code () == TYPE_CODE_UNION)
&& TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)))
{
int j;
for (j = TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)) - 1; j >= 0; j--)
if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) == 0)
TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) =
- TYPE_NAME (TYPE_BASECLASS (SYMBOL_TYPE (sym), j));
+ TYPE_BASECLASS (SYMBOL_TYPE (sym), j)->name ();
}
- if (TYPE_NAME (SYMBOL_TYPE (sym)) == NULL)
+ if (SYMBOL_TYPE (sym)->name () == NULL)
{
- if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
+ if ((SYMBOL_TYPE (sym)->code () == TYPE_CODE_PTR
&& strcmp (sym->linkage_name (), vtbl_ptr_name))
- || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
+ || 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 better not set
/* Pascal accepts names for pointer types. */
if (get_current_subfile ()->language == language_pascal)
- {
- TYPE_NAME (SYMBOL_TYPE (sym)) = sym->linkage_name ();
- }
+ SYMBOL_TYPE (sym)->set_name (sym->linkage_name ());
}
else
- TYPE_NAME (SYMBOL_TYPE (sym)) = sym->linkage_name ();
+ SYMBOL_TYPE (sym)->set_name (sym->linkage_name ());
}
add_symbol_to_list (sym, get_file_symbols ());
if (synonym)
{
/* Create the STRUCT_DOMAIN clone. */
- struct symbol *struct_sym = allocate_symbol (objfile);
+ struct symbol *struct_sym = new (&objfile->objfile_obstack) symbol;
*struct_sym = *sym;
SYMBOL_ACLASS_INDEX (struct_sym) = LOC_TYPEDEF;
SYMBOL_VALUE (struct_sym) = valu;
SYMBOL_DOMAIN (struct_sym) = STRUCT_DOMAIN;
- if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
- TYPE_NAME (SYMBOL_TYPE (sym))
- = obconcat (&objfile->objfile_obstack, sym->linkage_name (),
- (char *) NULL);
+ if (SYMBOL_TYPE (sym)->name () == 0)
+ SYMBOL_TYPE (sym)->set_name
+ (obconcat (&objfile->objfile_obstack, sym->linkage_name (),
+ (char *) NULL));
add_symbol_to_list (struct_sym, get_file_symbols ());
}
-
+
break;
case 'T':
SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
SYMBOL_VALUE (sym) = valu;
SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
- if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
- TYPE_NAME (SYMBOL_TYPE (sym))
- = obconcat (&objfile->objfile_obstack, sym->linkage_name (),
- (char *) NULL);
+ if (SYMBOL_TYPE (sym)->name () == 0)
+ SYMBOL_TYPE (sym)->set_name
+ (obconcat (&objfile->objfile_obstack, sym->linkage_name (),
+ (char *) NULL));
add_symbol_to_list (sym, get_file_symbols ());
if (synonym)
{
/* Clone the sym and then modify it. */
- struct symbol *typedef_sym = allocate_symbol (objfile);
+ struct symbol *typedef_sym = new (&objfile->objfile_obstack) symbol;
*typedef_sym = *sym;
SYMBOL_ACLASS_INDEX (typedef_sym) = LOC_TYPEDEF;
SYMBOL_VALUE (typedef_sym) = valu;
SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
- if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
- TYPE_NAME (SYMBOL_TYPE (sym))
- = obconcat (&objfile->objfile_obstack, sym->linkage_name (),
- (char *) NULL);
+ if (SYMBOL_TYPE (sym)->name () == 0)
+ SYMBOL_TYPE (sym)->set_name
+ (obconcat (&objfile->objfile_obstack, sym->linkage_name (),
+ (char *) NULL));
add_symbol_to_list (typedef_sym, get_file_symbols ());
}
break;
SYMBOL_TYPE (sym) = read_type (&p, objfile);
SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
SET_SYMBOL_VALUE_ADDRESS (sym, valu);
- if (gdbarch_static_transform_name_p (gdbarch)
- && gdbarch_static_transform_name (gdbarch, sym->linkage_name ())
- != sym->linkage_name ())
- {
- struct bound_minimal_symbol msym;
-
- msym = lookup_minimal_symbol (sym->linkage_name (), NULL, objfile);
- if (msym.minsym != NULL)
- {
- const char *new_name = gdbarch_static_transform_name
- (gdbarch, sym->linkage_name ());
-
- sym->set_linkage_name (new_name);
- SET_SYMBOL_VALUE_ADDRESS (sym, BMSYMBOL_VALUE_ADDRESS (msym));
- }
- }
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- add_symbol_to_list (sym, get_local_symbols ());
+ add_symbol_to_list (sym, get_local_symbols ());
break;
case 'v':
/* If this is a forward reference, arrange to complain if it
doesn't get patched up by the time we're done
reading. */
- if (TYPE_CODE (type) == TYPE_CODE_UNDEF)
+ if (type->code () == TYPE_CODE_UNDEF)
add_undefined_type (type, typenums);
return type;
if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
&& SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
- && (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
+ && (SYMBOL_TYPE (sym)->code () == code)
&& strcmp (sym->linkage_name (), type_name) == 0)
{
obstack_free (&objfile->objfile_obstack, type_name);
type. */
type = dbx_alloc_type (typenums, objfile);
type->set_code (code);
- TYPE_NAME (type) = type_name;
+ type->set_name (type_name);
INIT_CPLUS_SPECIFIC (type);
TYPE_STUB (type) = 1;
"complete_this_type" function, but never create unnecessary
copies of a type otherwise. */
replace_type (type, xtype);
- TYPE_NAME (type) = NULL;
+ type->set_name (NULL);
}
else
{
that's just an empty argument list. */
if (arg_types
&& ! arg_types->next
- && TYPE_CODE (arg_types->type) == TYPE_CODE_VOID)
+ && arg_types->type->code () == TYPE_CODE_VOID)
num_args = 0;
- TYPE_FIELDS (func_type)
- = (struct field *) TYPE_ALLOC (func_type,
- num_args * sizeof (struct field));
- memset (TYPE_FIELDS (func_type), 0, num_args * sizeof (struct field));
+ func_type->set_fields
+ ((struct field *) TYPE_ALLOC (func_type,
+ num_args * sizeof (struct field)));
+ memset (func_type->fields (), 0, num_args * sizeof (struct field));
{
int i;
struct type_list *t;
when we read it, so the list is reversed. Build the
fields array right-to-left. */
for (t = arg_types, i = num_args - 1; t; t = t->next, i--)
- TYPE_FIELD_TYPE (func_type, i) = t->type;
+ func_type->field (i).set_type (t->type);
}
- TYPE_NFIELDS (func_type) = num_args;
+ func_type->set_num_fields (num_args);
TYPE_PROTOTYPED (func_type) = 1;
type = func_type;
}
/* These are methods, not functions. */
- if (TYPE_CODE (new_sublist->fn_field.type) == TYPE_CODE_FUNC)
+ if (new_sublist->fn_field.type->code () == TYPE_CODE_FUNC)
new_sublist->fn_field.type->set_code (TYPE_CODE_METHOD);
else
- gdb_assert (TYPE_CODE (new_sublist->fn_field.type)
+ gdb_assert (new_sublist->fn_field.type->code ()
== TYPE_CODE_METHOD);
/* If this is just a stub, then we don't have the real name here. */
switch (cpp_abbrev)
{
case 'f': /* $vf -- a virtual function table pointer */
- name = TYPE_NAME (context);
+ name = context->name ();
if (name == NULL)
{
name = "";
break;
case 'b': /* $vb -- a virtual bsomethingorother */
- name = TYPE_NAME (context);
+ name = context->name ();
if (name == NULL)
{
complaint (_("C++ abbreviated type name "
invalid_cpp_abbrev_complaint (*pp);
return 0;
}
- fip->list->field.type = read_type (pp, objfile);
+ fip->list->field.set_type (read_type (pp, objfile));
if (**pp == ',')
(*pp)++; /* Skip the comma. */
else
fip->list->visibility = VISIBILITY_PUBLIC;
}
- fip->list->field.type = read_type (pp, objfile);
+ fip->list->field.set_type (read_type (pp, objfile));
if (**pp == ':')
{
p = ++(*pp);
Note that forward refs cannot be packed,
and treat enums as if they had the width of ints. */
- struct type *field_type = check_typedef (FIELD_TYPE (fip->list->field));
+ struct type *field_type = check_typedef (fip->list->field.type ());
- if (TYPE_CODE (field_type) != TYPE_CODE_INT
- && TYPE_CODE (field_type) != TYPE_CODE_RANGE
- && TYPE_CODE (field_type) != TYPE_CODE_BOOL
- && TYPE_CODE (field_type) != TYPE_CODE_ENUM)
+ if (field_type->code () != TYPE_CODE_INT
+ && field_type->code () != TYPE_CODE_RANGE
+ && field_type->code () != TYPE_CODE_BOOL
+ && field_type->code () != TYPE_CODE_ENUM)
{
FIELD_BITSIZE (fip->list->field) = 0;
}
if ((FIELD_BITSIZE (fip->list->field)
== TARGET_CHAR_BIT * TYPE_LENGTH (field_type)
- || (TYPE_CODE (field_type) == TYPE_CODE_ENUM
+ || (field_type->code () == TYPE_CODE_ENUM
&& FIELD_BITSIZE (fip->list->field)
== gdbarch_int_bit (gdbarch))
)
base class. Read it, and remember it's type name as this
field's name. */
- newobj->field.type = read_type (pp, objfile);
- newobj->field.name = TYPE_NAME (newobj->field.type);
+ newobj->field.set_type (read_type (pp, objfile));
+ newobj->field.name = newobj->field.type ()->name ();
/* Skip trailing ';' and bump count of number of fields seen. */
if (**pp == ';')
set_type_vptr_basetype (type, t);
if (type == t) /* Our own class provides vtbl ptr. */
{
- for (i = TYPE_NFIELDS (t) - 1;
+ for (i = t->num_fields () - 1;
i >= TYPE_N_BASECLASSES (t);
--i)
{
/* Virtual function table field not found. */
complaint (_("virtual function table pointer "
"not found when defining class `%s'"),
- TYPE_NAME (type));
+ type->name ());
return 0;
}
else
non-public fields. Record the field count, allocate space for the
array of fields, and create blank visibility bitfields if necessary. */
- TYPE_NFIELDS (type) = nfields;
- TYPE_FIELDS (type) = (struct field *)
- TYPE_ALLOC (type, sizeof (struct field) * nfields);
- memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields);
+ type->set_num_fields (nfields);
+ type->set_fields
+ ((struct field *)
+ TYPE_ALLOC (type, sizeof (struct field) * nfields));
+ memset (type->fields (), 0, sizeof (struct field) * nfields);
if (non_public_fields)
{
while (nfields-- > 0)
{
- TYPE_FIELD (type, nfields) = fip->list->field;
+ type->field (nfields) = fip->list->field;
switch (fip->list->visibility)
{
case VISIBILITY_PRIVATE:
const char *name = "";
const char *kind = "";
- if (TYPE_NAME (type))
+ if (type->name ())
{
- name = TYPE_NAME (type);
- switch (TYPE_CODE (type))
+ name = type->name ();
+ switch (type->code ())
{
case TYPE_CODE_STRUCT: kind = "struct "; break;
case TYPE_CODE_UNION: kind = "union "; break;
Obviously, GDB can't fix this by itself, but it can at least avoid
scribbling on existing structure type objects when new definitions
appear. */
- if (! (TYPE_CODE (type) == TYPE_CODE_UNDEF
+ if (! (type->code () == TYPE_CODE_UNDEF
|| TYPE_STUB (type)))
{
complain_about_struct_wipeout (type);
if (nbits != 0)
return error_type (pp, objfile);
- sym = allocate_symbol (objfile);
+ sym = new (&objfile->objfile_obstack) symbol;
sym->set_linkage_name (name);
sym->set_language (get_current_subfile ()->language,
&objfile->objfile_obstack);
TYPE_STUB (type) = 0;
if (unsigned_enum)
TYPE_UNSIGNED (type) = 1;
- TYPE_NFIELDS (type) = nsyms;
- TYPE_FIELDS (type) = (struct field *)
- TYPE_ALLOC (type, sizeof (struct field) * nsyms);
- memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nsyms);
+ type->set_num_fields (nsyms);
+ type->set_fields
+ ((struct field *)
+ TYPE_ALLOC (type, sizeof (struct field) * nsyms));
+ memset (type->fields (), 0, 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
SYMBOL_TYPE (xsym) = type;
TYPE_FIELD_NAME (type, n) = xsym->linkage_name ();
- SET_FIELD_ENUMVAL (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym));
+ SET_FIELD_ENUMVAL (type->field (n), SYMBOL_VALUE (xsym));
TYPE_FIELD_BITSIZE (type, n) = 0;
}
if (syms == osyms)
complaint (_("Invalid (empty) method arguments"));
*varargsp = 0;
}
- else if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID)
+ else if (types[n - 1]->code () != TYPE_CODE_VOID)
*varargsp = 1;
else
{
rval = XCNEWVEC (struct field, n);
for (i = 0; i < n; i++)
- rval[i].type = types[i];
+ rval[i].set_type (types[i]);
*nargsp = n;
return rval;
}
return;
}
- sym = allocate_symbol (objfile);
+ sym = new (&objfile->objfile_obstack) symbol;
/* Note: common_block_name already saved on objfile_obstack. */
sym->set_linkage_name (common_block_name);
SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
static void
add_undefined_type (struct type *type, int typenums[2])
{
- if (TYPE_NAME (type) == NULL)
+ if (type->name () == NULL)
add_undefined_type_noname (type, typenums);
else
add_undefined_type_1 (type);
struct type **type;
type = dbx_lookup_type (nat.typenums, objfile);
- if (nat.type != *type && TYPE_CODE (*type) != TYPE_CODE_UNDEF)
+ if (nat.type != *type && (*type)->code () != TYPE_CODE_UNDEF)
{
/* The instance flags of the undefined type are still unset,
and needs to be copied over from the reference type.
for (type = undef_types; type < undef_types + undef_types_length; type++)
{
- switch (TYPE_CODE (*type))
+ switch ((*type)->code ())
{
case TYPE_CODE_STRUCT:
struct pending *ppt;
int i;
/* Name of the type, without "struct" or "union". */
- const char *type_name = TYPE_NAME (*type);
+ const char *type_name = (*type)->name ();
if (type_name == NULL)
{
if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
&& SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
- && (TYPE_CODE (SYMBOL_TYPE (sym)) ==
- TYPE_CODE (*type))
+ && (SYMBOL_TYPE (sym)->code () ==
+ (*type)->code ())
&& (TYPE_INSTANCE_FLAGS (*type) ==
TYPE_INSTANCE_FLAGS (SYMBOL_TYPE (sym)))
&& strcmp (sym->linkage_name (), type_name) == 0)
{
complaint (_("forward-referenced types left unresolved, "
"type code %d."),
- TYPE_CODE (*type));
+ (*type)->code ());
}
break;
}