/* Support routines for decoding "stabs" debugging information format.
- Copyright (C) 1986-2020 Free Software Foundation, Inc.
+ Copyright (C) 1986-2023 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "bfd.h"
-#include "gdb_obstack.h"
+#include "gdbsupport/gdb_obstack.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "expression.h"
int n_this_object_header_files;
int n_allocated_this_object_header_files;
-struct nextfield
+struct stabs_nextfield
{
- struct nextfield *next;
+ struct stabs_nextfield *next;
/* This is the raw visibility from the stab. It is not checked
for being one of the visibilities we recognize, so code which
struct stab_field_info
{
- struct nextfield *list = nullptr;
+ struct stabs_nextfield *list = nullptr;
struct next_fnfieldlist *fnlist = nullptr;
auto_obstack obstack;
patch_block_stabs (struct pending *, struct pending_stabs *,
struct objfile *);
-static void fix_common_block (struct symbol *, CORE_ADDR);
-
static int read_type_number (const char **, int *);
static struct type *read_type (const char **, struct objfile *);
warning (_("GDB internal error: bad real_filenum"));
error_return:
- temp_type = objfile_type (objfile)->builtin_error;
+ temp_type = builtin_type (objfile)->builtin_error;
return &temp_type;
}
if (typenums[0] == -1)
{
- return (alloc_type (objfile));
+ return type_allocator (objfile).new_type ();
}
type_addr = dbx_lookup_type (typenums, objfile);
We will fill it in later if we find out how. */
if (*type_addr == 0)
{
- *type_addr = alloc_type (objfile);
+ *type_addr = type_allocator (objfile).new_type ();
}
return (*type_addr);
struct type *type;
format = gdbarch_floatformat_for_type (gdbarch, NULL, bits);
+ type_allocator alloc (objfile);
if (format)
- type = init_float_type (objfile, bits, NULL, format);
+ type = init_float_type (alloc, bits, NULL, format);
else
- type = init_type (objfile, TYPE_CODE_ERROR, bits, NULL);
+ type = alloc.new_type (TYPE_CODE_ERROR, bits, NULL);
return type;
}
ld will remove it from the executable. There is then
a N_GSYM stab for it, but no regular (C_EXT) symbol. */
sym = new (&objfile->objfile_obstack) symbol;
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
+ sym->set_domain (VAR_DOMAIN);
+ sym->set_aclass_index (LOC_OPTIMIZED_OUT);
sym->set_linkage_name
(obstack_strndup (&objfile->objfile_obstack, name, pp - name));
pp += 2;
/* I don't think the linker does this with functions,
so as far as I know this is never executed.
But it doesn't hurt to check. */
- SYMBOL_TYPE (sym) =
- lookup_function_type (read_type (&pp, objfile));
+ sym->set_type
+ (lookup_function_type (read_type (&pp, objfile)));
}
else
{
- SYMBOL_TYPE (sym) = read_type (&pp, objfile);
+ sym->set_type (read_type (&pp, objfile));
}
add_symbol_to_list (sym, get_global_symbols ());
}
pp += 2;
if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
{
- SYMBOL_TYPE (sym) =
- lookup_function_type (read_type (&pp, objfile));
+ sym->set_type
+ (lookup_function_type (read_type (&pp, objfile)));
}
else
{
- SYMBOL_TYPE (sym) = read_type (&pp, objfile);
+ sym->set_type (read_type (&pp, objfile));
}
}
}
static int
stab_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
{
- int regno = gdbarch_stab_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
+ int regno = gdbarch_stab_reg_to_regnum (gdbarch, sym->value_longest ());
if (regno < 0 || regno >= gdbarch_num_cooked_regs (gdbarch))
{
{
/* GCC 2.x puts the line number in desc. SunOS apparently puts in the
number of bytes occupied by a type or object, which we ignore. */
- SYMBOL_LINE (sym) = desc;
+ sym->set_line (desc);
}
else
{
- SYMBOL_LINE (sym) = 0; /* unknown */
+ sym->set_line (0); /* unknown */
}
sym->set_language (get_current_subfile ()->language,
if (sym->language () == language_cplus)
{
- char *name = (char *) alloca (p - string + 1);
-
- memcpy (name, string, p - string);
- name[p - string] = '\0';
- new_name = cp_canonicalize_string (name);
+ std::string name (string, p - string);
+ new_name = cp_canonicalize_string (name.c_str ());
+ }
+ else if (sym->language () == language_c)
+ {
+ std::string name (string, p - string);
+ new_name = c_canonicalize_name (name.c_str ());
}
if (new_name != nullptr)
sym->compute_and_set_names (new_name.get (), true, objfile->per_bfd);
(where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
if (*p != '=')
{
- SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
- SYMBOL_TYPE (sym) = error_type (&p, objfile);
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_aclass_index (LOC_CONST);
+ sym->set_type (error_type (&p, objfile));
+ sym->set_domain (VAR_DOMAIN);
add_symbol_to_list (sym, get_file_symbols ());
return sym;
}
gdb_byte *dbl_valu;
struct type *dbl_type;
- dbl_type = objfile_type (objfile)->builtin_double;
+ dbl_type = builtin_type (objfile)->builtin_double;
dbl_valu
= (gdb_byte *) obstack_alloc (&objfile->objfile_obstack,
- TYPE_LENGTH (dbl_type));
+ dbl_type->length ());
target_float_from_string (dbl_valu, dbl_type, std::string (p));
- SYMBOL_TYPE (sym) = dbl_type;
- SYMBOL_VALUE_BYTES (sym) = dbl_valu;
- SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
+ sym->set_type (dbl_type);
+ sym->set_value_bytes (dbl_valu);
+ sym->set_aclass_index (LOC_CONST_BYTES);
}
break;
case 'i':
types; other languages probably should have at least
unsigned as well as signed constants. */
- SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_long;
- SYMBOL_VALUE (sym) = atoi (p);
- SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
+ sym->set_type (builtin_type (objfile)->builtin_long);
+ sym->set_value_longest (atoi (p));
+ sym->set_aclass_index (LOC_CONST);
}
break;
case 'c':
{
- SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_char;
- SYMBOL_VALUE (sym) = atoi (p);
- SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
+ sym->set_type (builtin_type (objfile)->builtin_char);
+ sym->set_value_longest (atoi (p));
+ sym->set_aclass_index (LOC_CONST);
}
break;
if (quote != '\'' && quote != '"')
{
- SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
- SYMBOL_TYPE (sym) = error_type (&p, objfile);
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_aclass_index (LOC_CONST);
+ sym->set_type (error_type (&p, objfile));
+ sym->set_domain (VAR_DOMAIN);
add_symbol_to_list (sym, get_file_symbols ());
return sym;
}
}
if (*p != quote)
{
- SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
- SYMBOL_TYPE (sym) = error_type (&p, objfile);
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_aclass_index (LOC_CONST);
+ sym->set_type (error_type (&p, objfile));
+ sym->set_domain (VAR_DOMAIN);
add_symbol_to_list (sym, get_file_symbols ());
return sym;
}
/* NULL terminate the string. */
string_local[ind] = 0;
+ type_allocator alloc (objfile);
range_type
- = create_static_range_type (NULL,
- objfile_type (objfile)->builtin_int,
+ = create_static_range_type (alloc,
+ builtin_type (objfile)->builtin_int,
0, ind);
- SYMBOL_TYPE (sym) = create_array_type (NULL,
- objfile_type (objfile)->builtin_char,
- range_type);
+ sym->set_type
+ (create_array_type (alloc, builtin_type (objfile)->builtin_char,
+ range_type));
string_value
= (gdb_byte *) obstack_alloc (&objfile->objfile_obstack, ind + 1);
memcpy (string_value, string_local, ind + 1);
p++;
- SYMBOL_VALUE_BYTES (sym) = string_value;
- SYMBOL_ACLASS_INDEX (sym) = LOC_CONST_BYTES;
+ sym->set_value_bytes (string_value);
+ sym->set_aclass_index (LOC_CONST_BYTES);
}
break;
e.g. "b:c=e6,0" for "const b = blob1"
(where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
{
- SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
+ sym->set_aclass_index (LOC_CONST);
+ sym->set_type (read_type (&p, objfile));
if (*p != ',')
{
- SYMBOL_TYPE (sym) = error_type (&p, objfile);
+ sym->set_type (error_type (&p, objfile));
break;
}
++p;
correct. Ideally, we should be using whatever we have
available for parsing unsigned and long long values,
however. */
- SYMBOL_VALUE (sym) = atoi (p);
+ sym->set_value_longest (atoi (p));
}
break;
default:
{
- SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
- SYMBOL_TYPE (sym) = error_type (&p, objfile);
+ sym->set_aclass_index (LOC_CONST);
+ sym->set_type (error_type (&p, objfile));
}
}
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_domain (VAR_DOMAIN);
add_symbol_to_list (sym, get_file_symbols ());
return sym;
case 'C':
/* The name of a caught exception. */
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_ACLASS_INDEX (sym) = LOC_LABEL;
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- SET_SYMBOL_VALUE_ADDRESS (sym, valu);
+ sym->set_type (read_type (&p, objfile));
+ sym->set_aclass_index (LOC_LABEL);
+ sym->set_domain (VAR_DOMAIN);
+ sym->set_value_address (valu);
add_symbol_to_list (sym, get_local_symbols ());
break;
case 'f':
/* A static function definition. */
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_type (read_type (&p, objfile));
+ sym->set_aclass_index (LOC_BLOCK);
+ sym->set_domain (VAR_DOMAIN);
add_symbol_to_list (sym, get_file_symbols ());
/* fall into process_function_types. */
/* 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 (SYMBOL_TYPE (sym)->code () != TYPE_CODE_FUNC)
- SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym));
+ if (sym->type ()->code () != TYPE_CODE_FUNC)
+ sym->set_type (lookup_function_type (sym->type ()));
/* All functions in C++ have prototypes. Stabs does not offer an
explicit way to identify prototyped or unprototyped functions,
than the "declared-as" type for unprototyped functions, so
we treat all functions as if they were prototyped. This is used
primarily for promotion when calling the function from GDB. */
- SYMBOL_TYPE (sym)->set_is_prototyped (true);
+ sym->type ()->set_is_prototyped (true);
/* fall into process_prototype_types. */
/* Sun acc puts declared types of arguments here. */
if (*p == ';')
{
- struct type *ftype = SYMBOL_TYPE (sym);
+ struct type *ftype = sym->type ();
int nsemi = 0;
int nparams = 0;
const char *p1 = p;
it back into builtin_int here.
FIXME: Do we need a new builtin_promoted_int_arg ? */
if (ptype->code () == TYPE_CODE_VOID)
- ptype = objfile_type (objfile)->builtin_int;
+ ptype = builtin_type (objfile)->builtin_int;
ftype->field (nparams).set_type (ptype);
TYPE_FIELD_ARTIFICIAL (ftype, nparams++) = 0;
}
case 'F':
/* A global function definition. */
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_type (read_type (&p, objfile));
+ sym->set_aclass_index (LOC_BLOCK);
+ sym->set_domain (VAR_DOMAIN);
add_symbol_to_list (sym, get_global_symbols ());
goto process_function_types;
value is not correct. It is necessary to search for the
corresponding linker definition to find the value.
These definitions appear at the end of the namelist. */
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_type (read_type (&p, objfile));
+ sym->set_aclass_index (LOC_STATIC);
+ sym->set_domain (VAR_DOMAIN);
/* Don't add symbol references to global_sym_chain.
Symbol references don't have valid names and wont't match up with
minimal symbols when the global_sym_chain is relocated.
if (sym->linkage_name () && sym->linkage_name ()[0] != '#')
{
i = hashname (sym->linkage_name ());
- SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
+ sym->set_value_chain (global_sym_chain[i]);
global_sym_chain[i] = sym;
}
add_symbol_to_list (sym, get_global_symbols ());
Dbx data never actually contains 'l'. */
case 's':
case 'l':
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_ACLASS_INDEX (sym) = LOC_LOCAL;
- SYMBOL_VALUE (sym) = valu;
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_type (read_type (&p, objfile));
+ sym->set_aclass_index (LOC_LOCAL);
+ sym->set_value_longest (valu);
+ sym->set_domain (VAR_DOMAIN);
add_symbol_to_list (sym, get_local_symbols ());
break;
Translate it into a pointer-to-function type. */
{
p++;
- SYMBOL_TYPE (sym)
- = lookup_pointer_type
- (lookup_function_type (read_type (&p, objfile)));
+ sym->set_type
+ (lookup_pointer_type
+ (lookup_function_type (read_type (&p, objfile))));
}
else
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
+ sym->set_type (read_type (&p, objfile));
- SYMBOL_ACLASS_INDEX (sym) = LOC_ARG;
- SYMBOL_VALUE (sym) = valu;
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- SYMBOL_IS_ARGUMENT (sym) = 1;
+ sym->set_aclass_index (LOC_ARG);
+ sym->set_value_longest (valu);
+ sym->set_domain (VAR_DOMAIN);
+ sym->set_is_argument (1);
add_symbol_to_list (sym, get_local_symbols ());
if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_BIG)
{
/* If PCC says a parameter is a short or a char, it is
really an int. */
- if (TYPE_LENGTH (SYMBOL_TYPE (sym))
+ if (sym->type ()->length ()
< gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT
- && SYMBOL_TYPE (sym)->code () == TYPE_CODE_INT)
+ && sym->type ()->code () == TYPE_CODE_INT)
{
- SYMBOL_TYPE (sym) =
- (SYMBOL_TYPE (sym)->is_unsigned ()
- ? objfile_type (objfile)->builtin_unsigned_int
- : objfile_type (objfile)->builtin_int);
+ sym->set_type
+ (sym->type ()->is_unsigned ()
+ ? builtin_type (objfile)->builtin_unsigned_int
+ : builtin_type (objfile)->builtin_int);
}
break;
}
with this extra information. FIXME, it ought to. */
if (type == N_FUN)
{
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
+ sym->set_type (read_type (&p, objfile));
goto process_prototype_types;
}
/*FALLTHROUGH */
case 'R':
/* Parameter which is in a register. */
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_ACLASS_INDEX (sym) = stab_register_index;
- SYMBOL_IS_ARGUMENT (sym) = 1;
- SYMBOL_VALUE (sym) = valu;
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_type (read_type (&p, objfile));
+ sym->set_aclass_index (stab_register_index);
+ sym->set_is_argument (1);
+ sym->set_value_longest (valu);
+ sym->set_domain (VAR_DOMAIN);
add_symbol_to_list (sym, get_local_symbols ());
break;
case 'r':
/* Register variable (either global or local). */
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_ACLASS_INDEX (sym) = stab_register_index;
- SYMBOL_VALUE (sym) = valu;
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_type (read_type (&p, objfile));
+ sym->set_aclass_index (stab_register_index);
+ sym->set_value_longest (valu);
+ sym->set_domain (VAR_DOMAIN);
if (within_function)
{
/* Sun cc uses a pair of symbols, one 'p' and one 'r', with
struct pending *local_symbols = *get_local_symbols ();
if (local_symbols
&& local_symbols->nsyms > 0
- && gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym)))
+ && gdbarch_stabs_argument_has_addr (gdbarch, sym->type ()))
{
struct symbol *prev_sym;
prev_sym = local_symbols->symbol[local_symbols->nsyms - 1];
- if ((SYMBOL_CLASS (prev_sym) == LOC_REF_ARG
- || SYMBOL_CLASS (prev_sym) == LOC_ARG)
+ if ((prev_sym->aclass () == LOC_REF_ARG
+ || prev_sym->aclass () == LOC_ARG)
&& strcmp (prev_sym->linkage_name (),
sym->linkage_name ()) == 0)
{
- SYMBOL_ACLASS_INDEX (prev_sym) = stab_register_index;
+ prev_sym->set_aclass_index (stab_register_index);
/* Use the type from the LOC_REGISTER; that is the type
that is actually in that register. */
- SYMBOL_TYPE (prev_sym) = SYMBOL_TYPE (sym);
- SYMBOL_VALUE (prev_sym) = SYMBOL_VALUE (sym);
+ prev_sym->set_type (sym->type ());
+ prev_sym->set_value_longest (sym->value_longest ());
sym = prev_sym;
break;
}
case 'S':
/* Static symbol at top level of file. */
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
- SET_SYMBOL_VALUE_ADDRESS (sym, valu);
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_type (read_type (&p, objfile));
+ sym->set_aclass_index (LOC_STATIC);
+ sym->set_value_address (valu);
+ sym->set_domain (VAR_DOMAIN);
add_symbol_to_list (sym, get_file_symbols ());
break;
synonym = (sym->language () == language_ada && p[-2] != 'T');
/* Typedef */
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
+ sym->set_type (read_type (&p, objfile));
/* For a nameless type, we don't want a create a symbol, thus we
did not use `sym'. Return without further processing. */
if (nameless)
return NULL;
- SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
- SYMBOL_VALUE (sym) = valu;
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_aclass_index (LOC_TYPEDEF);
+ sym->set_value_longest (valu);
+ sym->set_domain (VAR_DOMAIN);
/* C++ vagaries: we may have a type which is derived from
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 (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)))
+ if (sym->type ()->name () != NULL)
+ if ((sym->type ()->code () == TYPE_CODE_STRUCT
+ || sym->type ()->code () == TYPE_CODE_UNION)
+ && TYPE_N_BASECLASSES (sym->type ()))
{
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_BASECLASS (SYMBOL_TYPE (sym), j)->name ();
+ for (j = TYPE_N_BASECLASSES (sym->type ()) - 1; j >= 0; j--)
+ if (TYPE_BASECLASS_NAME (sym->type (), j) == 0)
+ sym->type ()->field (j).set_name
+ (TYPE_BASECLASS (sym->type (), j)->name ());
}
- if (SYMBOL_TYPE (sym)->name () == NULL)
+ if (sym->type ()->name () == NULL)
{
- if ((SYMBOL_TYPE (sym)->code () == TYPE_CODE_PTR
+ if ((sym->type ()->code () == TYPE_CODE_PTR
&& strcmp (sym->linkage_name (), vtbl_ptr_name))
- || SYMBOL_TYPE (sym)->code () == TYPE_CODE_FUNC)
+ || sym->type ()->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)
- SYMBOL_TYPE (sym)->set_name (sym->linkage_name ());
+ sym->type ()->set_name (sym->linkage_name ());
}
else
- SYMBOL_TYPE (sym)->set_name (sym->linkage_name ());
+ sym->type ()->set_name (sym->linkage_name ());
}
add_symbol_to_list (sym, get_file_symbols ());
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 (SYMBOL_TYPE (sym)->name () == 0)
- SYMBOL_TYPE (sym)->set_name
+ struct_sym->set_aclass_index (LOC_TYPEDEF);
+ struct_sym->set_value_longest (valu);
+ struct_sym->set_domain (STRUCT_DOMAIN);
+ if (sym->type ()->name () == 0)
+ sym->type ()->set_name
(obconcat (&objfile->objfile_obstack, sym->linkage_name (),
(char *) NULL));
add_symbol_to_list (struct_sym, get_file_symbols ());
if (synonym)
p++;
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
+ sym->set_type (read_type (&p, objfile));
/* For a nameless type, we don't want a create a symbol, thus we
did not use `sym'. Return without further processing. */
if (nameless)
return NULL;
- SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
- SYMBOL_VALUE (sym) = valu;
- SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
- if (SYMBOL_TYPE (sym)->name () == 0)
- SYMBOL_TYPE (sym)->set_name
+ sym->set_aclass_index (LOC_TYPEDEF);
+ sym->set_value_longest (valu);
+ sym->set_domain (STRUCT_DOMAIN);
+ if (sym->type ()->name () == 0)
+ sym->type ()->set_name
(obconcat (&objfile->objfile_obstack, sym->linkage_name (),
(char *) NULL));
add_symbol_to_list (sym, get_file_symbols ());
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 (SYMBOL_TYPE (sym)->name () == 0)
- SYMBOL_TYPE (sym)->set_name
+ typedef_sym->set_aclass_index (LOC_TYPEDEF);
+ typedef_sym->set_value_longest (valu);
+ typedef_sym->set_domain (VAR_DOMAIN);
+ if (sym->type ()->name () == 0)
+ sym->type ()->set_name
(obconcat (&objfile->objfile_obstack, sym->linkage_name (),
(char *) NULL));
add_symbol_to_list (typedef_sym, get_file_symbols ());
case 'V':
/* Static symbol of local scope. */
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
- SET_SYMBOL_VALUE_ADDRESS (sym, valu);
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_type (read_type (&p, objfile));
+ sym->set_aclass_index (LOC_STATIC);
+ sym->set_value_address (valu);
+ sym->set_domain (VAR_DOMAIN);
add_symbol_to_list (sym, get_local_symbols ());
break;
case 'v':
/* Reference parameter */
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_ACLASS_INDEX (sym) = LOC_REF_ARG;
- SYMBOL_IS_ARGUMENT (sym) = 1;
- SYMBOL_VALUE (sym) = valu;
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_type (read_type (&p, objfile));
+ sym->set_aclass_index (LOC_REF_ARG);
+ sym->set_is_argument (1);
+ sym->set_value_longest (valu);
+ sym->set_domain (VAR_DOMAIN);
add_symbol_to_list (sym, get_local_symbols ());
break;
case 'a':
/* Reference parameter which is in a register. */
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_ACLASS_INDEX (sym) = stab_regparm_index;
- SYMBOL_IS_ARGUMENT (sym) = 1;
- SYMBOL_VALUE (sym) = valu;
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_type (read_type (&p, objfile));
+ sym->set_aclass_index (stab_regparm_index);
+ sym->set_is_argument (1);
+ sym->set_value_longest (valu);
+ sym->set_domain (VAR_DOMAIN);
add_symbol_to_list (sym, get_local_symbols ());
break;
Sun claims ("dbx and dbxtool interfaces", 2nd ed)
that Pascal uses it too, but when I tried it Pascal used
"x:3" (local symbol) instead. */
- SYMBOL_TYPE (sym) = read_type (&p, objfile);
- SYMBOL_ACLASS_INDEX (sym) = LOC_LOCAL;
- SYMBOL_VALUE (sym) = valu;
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_type (read_type (&p, objfile));
+ sym->set_aclass_index (LOC_LOCAL);
+ sym->set_value_longest (valu);
+ sym->set_domain (VAR_DOMAIN);
add_symbol_to_list (sym, get_local_symbols ());
break;
default:
- SYMBOL_TYPE (sym) = error_type (&p, objfile);
- SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
- SYMBOL_VALUE (sym) = 0;
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
+ sym->set_type (error_type (&p, objfile));
+ sym->set_aclass_index (LOC_CONST);
+ sym->set_value_longest (0);
+ sym->set_domain (VAR_DOMAIN);
add_symbol_to_list (sym, get_file_symbols ());
break;
}
of by value, i.e. they will pass the address of a structure (in a
register or on the stack) instead of the structure itself. */
- if (gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym))
- && SYMBOL_IS_ARGUMENT (sym))
+ if (gdbarch_stabs_argument_has_addr (gdbarch, sym->type ())
+ && sym->is_argument ())
{
/* We have to convert LOC_REGISTER to LOC_REGPARM_ADDR (for
variables passed in a register). */
- if (SYMBOL_CLASS (sym) == LOC_REGISTER)
- SYMBOL_ACLASS_INDEX (sym) = LOC_REGPARM_ADDR;
+ if (sym->aclass () == LOC_REGISTER)
+ sym->set_aclass_index (LOC_REGPARM_ADDR);
/* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th
and subsequent arguments on SPARC, for example). */
- else if (SYMBOL_CLASS (sym) == LOC_ARG)
- SYMBOL_ACLASS_INDEX (sym) = LOC_REF_ARG;
+ else if (sym->aclass () == LOC_ARG)
+ sym->set_aclass_index (LOC_REF_ARG);
}
return sym;
break;
}
}
- return objfile_type (objfile)->builtin_error;
+ return builtin_type (objfile)->builtin_error;
}
\f
+/* Allocate a stub method whose return type is TYPE. This apparently
+ happens for speed of symbol reading, since parsing out the
+ arguments to the method is cpu-intensive, the way we are doing it.
+ So, we will fill in arguments later. This always returns a fresh
+ type. */
+
+static struct type *
+allocate_stub_method (struct type *type)
+{
+ struct type *mtype;
+
+ mtype = type_allocator (type).new_type ();
+ mtype->set_code (TYPE_CODE_METHOD);
+ mtype->set_length (1);
+ mtype->set_is_stub (true);
+ mtype->set_target_type (type);
+ /* TYPE_SELF_TYPE (mtype) = unknown yet */
+ return mtype;
+}
+
/* Read type information or a type definition; return the type. Even
though this routine accepts either type information or a type
definition, the distinction is relevant--some parts of stabsread.c
type_name = NULL;
if (get_current_subfile ()->language == language_cplus)
{
- char *name = (char *) alloca (p - *pp + 1);
-
- memcpy (name, *pp, p - *pp);
- name[p - *pp] = '\0';
-
- gdb::unique_xmalloc_ptr<char> new_name = cp_canonicalize_string (name);
+ std::string name (*pp, p - *pp);
+ gdb::unique_xmalloc_ptr<char> new_name
+ = cp_canonicalize_string (name.c_str ());
+ if (new_name != nullptr)
+ type_name = obstack_strdup (&objfile->objfile_obstack,
+ new_name.get ());
+ }
+ else if (get_current_subfile ()->language == language_c)
+ {
+ std::string name (*pp, p - *pp);
+ gdb::unique_xmalloc_ptr<char> new_name
+ = c_canonicalize_name (name.c_str ());
if (new_name != nullptr)
type_name = obstack_strdup (&objfile->objfile_obstack,
new_name.get ());
{
struct symbol *sym = ppt->symbol[i];
- if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
- && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
- && (SYMBOL_TYPE (sym)->code () == code)
+ if (sym->aclass () == LOC_TYPEDEF
+ && sym->domain () == STRUCT_DOMAIN
+ && (sym->type ()->code () == code)
&& strcmp (sym->linkage_name (), type_name) == 0)
{
obstack_free (&objfile->objfile_obstack, type_name);
- type = SYMBOL_TYPE (sym);
+ type = sym->type ();
if (typenums[0] != -1)
*dbx_lookup_type (typenums, objfile) = type;
return type;
{
/* It's being defined as itself. That means it is "void". */
type->set_code (TYPE_CODE_VOID);
- TYPE_LENGTH (type) = 1;
+ type->set_length (1);
}
else if (type_size >= 0 || is_string)
{
else
{
type->set_target_is_stub (true);
- TYPE_TARGET_TYPE (type) = xtype;
+ type->set_target_type (xtype);
}
}
break;
break;
case 'S': /* Set type */
- type1 = read_type (pp, objfile);
- type = create_set_type (NULL, type1);
- if (typenums[0] != -1)
- *dbx_lookup_type (typenums, objfile) = type;
+ {
+ type1 = read_type (pp, objfile);
+ type_allocator alloc (objfile);
+ type = create_set_type (alloc, type1);
+ if (typenums[0] != -1)
+ *dbx_lookup_type (typenums, objfile) = type;
+ }
break;
default:
/* Size specified in a type attribute overrides any other size. */
if (type_size != -1)
- TYPE_LENGTH (type) = (type_size + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT;
+ type->set_length ((type_size + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT);
return type;
}
/* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
Return the proper type node for a given builtin type number. */
-static const struct objfile_key<struct type *,
- gdb::noop_deleter<struct type *>>
+static const registry<objfile>::key<struct type *,
+ gdb::noop_deleter<struct type *>>
rs6000_builtin_type_data;
static struct type *
if (typenum >= 0 || typenum < -NUMBER_RECOGNIZED)
{
complaint (_("Unknown builtin type %d"), typenum);
- return objfile_type (objfile)->builtin_error;
+ return builtin_type (objfile)->builtin_error;
}
if (!negative_types)
TARGET_CHAR_BIT. */
#endif
+ type_allocator alloc (objfile);
switch (-typenum)
{
case 1:
is other than 32 bits, then it should use a new negative type
number (or avoid negative type numbers for that case).
See stabs.texinfo. */
- rettype = init_integer_type (objfile, 32, 0, "int");
+ rettype = init_integer_type (alloc, 32, 0, "int");
break;
case 2:
- rettype = init_integer_type (objfile, 8, 0, "char");
+ rettype = init_integer_type (alloc, 8, 0, "char");
rettype->set_has_no_signedness (true);
break;
case 3:
- rettype = init_integer_type (objfile, 16, 0, "short");
+ rettype = init_integer_type (alloc, 16, 0, "short");
break;
case 4:
- rettype = init_integer_type (objfile, 32, 0, "long");
+ rettype = init_integer_type (alloc, 32, 0, "long");
break;
case 5:
- rettype = init_integer_type (objfile, 8, 1, "unsigned char");
+ rettype = init_integer_type (alloc, 8, 1, "unsigned char");
break;
case 6:
- rettype = init_integer_type (objfile, 8, 0, "signed char");
+ rettype = init_integer_type (alloc, 8, 0, "signed char");
break;
case 7:
- rettype = init_integer_type (objfile, 16, 1, "unsigned short");
+ rettype = init_integer_type (alloc, 16, 1, "unsigned short");
break;
case 8:
- rettype = init_integer_type (objfile, 32, 1, "unsigned int");
+ rettype = init_integer_type (alloc, 32, 1, "unsigned int");
break;
case 9:
- rettype = init_integer_type (objfile, 32, 1, "unsigned");
+ rettype = init_integer_type (alloc, 32, 1, "unsigned");
break;
case 10:
- rettype = init_integer_type (objfile, 32, 1, "unsigned long");
+ rettype = init_integer_type (alloc, 32, 1, "unsigned long");
break;
case 11:
- rettype = init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
+ rettype = alloc.new_type (TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
break;
case 12:
/* IEEE single precision (32 bit). */
- rettype = init_float_type (objfile, 32, "float",
+ rettype = init_float_type (alloc, 32, "float",
floatformats_ieee_single);
break;
case 13:
/* IEEE double precision (64 bit). */
- rettype = init_float_type (objfile, 64, "double",
+ rettype = init_float_type (alloc, 64, "double",
floatformats_ieee_double);
break;
case 14:
/* This is an IEEE double on the RS/6000, and different machines with
different sizes for "long double" should use different negative
type numbers. See stabs.texinfo. */
- rettype = init_float_type (objfile, 64, "long double",
+ rettype = init_float_type (alloc, 64, "long double",
floatformats_ieee_double);
break;
case 15:
- rettype = init_integer_type (objfile, 32, 0, "integer");
+ rettype = init_integer_type (alloc, 32, 0, "integer");
break;
case 16:
- rettype = init_boolean_type (objfile, 32, 1, "boolean");
+ rettype = init_boolean_type (alloc, 32, 1, "boolean");
break;
case 17:
- rettype = init_float_type (objfile, 32, "short real",
+ rettype = init_float_type (alloc, 32, "short real",
floatformats_ieee_single);
break;
case 18:
- rettype = init_float_type (objfile, 64, "real",
+ rettype = init_float_type (alloc, 64, "real",
floatformats_ieee_double);
break;
case 19:
- rettype = init_type (objfile, TYPE_CODE_ERROR, 0, "stringptr");
+ rettype = alloc.new_type (TYPE_CODE_ERROR, 0, "stringptr");
break;
case 20:
- rettype = init_character_type (objfile, 8, 1, "character");
+ rettype = init_character_type (alloc, 8, 1, "character");
break;
case 21:
- rettype = init_boolean_type (objfile, 8, 1, "logical*1");
+ rettype = init_boolean_type (alloc, 8, 1, "logical*1");
break;
case 22:
- rettype = init_boolean_type (objfile, 16, 1, "logical*2");
+ rettype = init_boolean_type (alloc, 16, 1, "logical*2");
break;
case 23:
- rettype = init_boolean_type (objfile, 32, 1, "logical*4");
+ rettype = init_boolean_type (alloc, 32, 1, "logical*4");
break;
case 24:
- rettype = init_boolean_type (objfile, 32, 1, "logical");
+ rettype = init_boolean_type (alloc, 32, 1, "logical");
break;
case 25:
/* Complex type consisting of two IEEE single precision values. */
rs6000_builtin_type (13, objfile));
break;
case 27:
- rettype = init_integer_type (objfile, 8, 0, "integer*1");
+ rettype = init_integer_type (alloc, 8, 0, "integer*1");
break;
case 28:
- rettype = init_integer_type (objfile, 16, 0, "integer*2");
+ rettype = init_integer_type (alloc, 16, 0, "integer*2");
break;
case 29:
- rettype = init_integer_type (objfile, 32, 0, "integer*4");
+ rettype = init_integer_type (alloc, 32, 0, "integer*4");
break;
case 30:
- rettype = init_character_type (objfile, 16, 0, "wchar");
+ rettype = init_character_type (alloc, 16, 0, "wchar");
break;
case 31:
- rettype = init_integer_type (objfile, 64, 0, "long long");
+ rettype = init_integer_type (alloc, 64, 0, "long long");
break;
case 32:
- rettype = init_integer_type (objfile, 64, 1, "unsigned long long");
+ rettype = init_integer_type (alloc, 64, 1, "unsigned long long");
break;
case 33:
- rettype = init_integer_type (objfile, 64, 1, "logical*8");
+ rettype = init_integer_type (alloc, 64, 1, "logical*8");
break;
case 34:
- rettype = init_integer_type (objfile, 64, 0, "integer*8");
+ rettype = init_integer_type (alloc, 64, 0, "integer*8");
break;
}
negative_types[-typenum] = rettype;
{
name = "";
}
- fip->list->field.name = obconcat (&objfile->objfile_obstack,
- vptr_name, name, (char *) NULL);
+ fip->list->field.set_name (obconcat (&objfile->objfile_obstack,
+ vptr_name, name, (char *) NULL));
break;
case 'b': /* $vb -- a virtual bsomethingorother */
symnum);
name = "FOO";
}
- fip->list->field.name = obconcat (&objfile->objfile_obstack, vb_name,
- name, (char *) NULL);
+ fip->list->field.set_name (obconcat (&objfile->objfile_obstack,
+ vb_name, name, (char *) NULL));
break;
default:
invalid_cpp_abbrev_complaint (*pp);
- fip->list->field.name = obconcat (&objfile->objfile_obstack,
- "INVALID_CPLUSPLUS_ABBREV",
- (char *) NULL);
+ fip->list->field.set_name (obconcat (&objfile->objfile_obstack,
+ "INVALID_CPLUSPLUS_ABBREV",
+ (char *) NULL));
break;
}
{
int nbits;
- SET_FIELD_BITPOS (fip->list->field,
- read_huge_number (pp, ';', &nbits, 0));
+ fip->list->field.set_loc_bitpos (read_huge_number (pp, ';', &nbits, 0));
if (nbits != 0)
return 0;
}
{
struct gdbarch *gdbarch = objfile->arch ();
- fip->list->field.name
- = obstack_strndup (&objfile->objfile_obstack, *pp, p - *pp);
+ fip->list->field.set_name
+ (obstack_strndup (&objfile->objfile_obstack, *pp, p - *pp));
*pp = p + 1;
/* This means we have a visibility for a field coming. */
p++;
}
/* Static class member. */
- SET_FIELD_PHYSNAME (fip->list->field, savestring (*pp, p - *pp));
+ fip->list->field.set_loc_physname (savestring (*pp, p - *pp));
*pp = p + 1;
return;
}
{
int nbits;
- SET_FIELD_BITPOS (fip->list->field,
- read_huge_number (pp, ',', &nbits, 0));
+ fip->list->field.set_loc_bitpos (read_huge_number (pp, ',', &nbits, 0));
if (nbits != 0)
{
stabs_general_complaint ("bad structure-type format");
}
}
- if (FIELD_BITPOS (fip->list->field) == 0
+ if (fip->list->field.loc_bitpos () == 0
&& FIELD_BITSIZE (fip->list->field) == 0)
{
/* This can happen in two cases: (1) at least for gcc 2.4.5 or so,
FIELD_BITSIZE (fip->list->field) = 0;
}
if ((FIELD_BITSIZE (fip->list->field)
- == TARGET_CHAR_BIT * TYPE_LENGTH (field_type)
+ == TARGET_CHAR_BIT * field_type->length ()
|| (field_type->code () == TYPE_CODE_ENUM
&& FIELD_BITSIZE (fip->list->field)
== gdbarch_int_bit (gdbarch))
)
&&
- FIELD_BITPOS (fip->list->field) % 8 == 0)
+ fip->list->field.loc_bitpos () % 8 == 0)
{
FIELD_BITSIZE (fip->list->field) = 0;
}
struct type *type, struct objfile *objfile)
{
const char *p;
- struct nextfield *newobj;
+ struct stabs_nextfield *newobj;
/* We better set p right now, in case there are no fields at all... */
{
STABS_CONTINUE (pp, objfile);
/* Get space to record the next field's data. */
- newobj = OBSTACK_ZALLOC (&fip->obstack, struct nextfield);
+ newobj = OBSTACK_ZALLOC (&fip->obstack, struct stabs_nextfield);
newobj->next = fip->list;
fip->list = newobj;
}
return 1;
}
-/* *INDENT-OFF* */
/* The stabs for C++ derived classes contain baseclass information which
is marked by a '!' character after the total size. This function is
called when we encounter the baseclass marker, and slurps up all the
the type for the base class, and a terminating semicolon.
A typical example, with two base classes, would be "!2,020,19;0264,21;".
- ^^ ^ ^ ^ ^ ^ ^
+ ^^ ^ ^ ^ ^ ^ ^
Baseclass information marker __________________|| | | | | | |
Number of baseclasses __________________________| | | | | | |
Visibility specifiers (2) ________________________| | | | | |
Type number of base class ____________________________________|
Return 1 for success, 0 for (error-type-inducing) failure. */
-/* *INDENT-ON* */
struct type *type, struct objfile *objfile)
{
int i;
- struct nextfield *newobj;
+ struct stabs_nextfield *newobj;
if (**pp != '!')
{
for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
{
- newobj = OBSTACK_ZALLOC (&fip->obstack, struct nextfield);
+ newobj = OBSTACK_ZALLOC (&fip->obstack, struct stabs_nextfield);
newobj->next = fip->list;
fip->list = newobj;
corresponding to this baseclass. Always zero in the absence of
multiple inheritance. */
- SET_FIELD_BITPOS (newobj->field, read_huge_number (pp, ',', &nbits, 0));
+ newobj->field.set_loc_bitpos (read_huge_number (pp, ',', &nbits, 0));
if (nbits != 0)
return 0;
}
field's name. */
newobj->field.set_type (read_type (pp, objfile));
- newobj->field.name = newobj->field.type ()->name ();
+ newobj->field.set_name (newobj->field.type ()->name ());
/* Skip trailing ';' and bump count of number of fields seen. */
if (**pp == ';')
i >= TYPE_N_BASECLASSES (t);
--i)
{
- const char *name = TYPE_FIELD_NAME (t, i);
+ const char *name = t->field (i).name ();
if (!strncmp (name, vptr_name, sizeof (vptr_name) - 2)
&& is_cplus_marker (name[sizeof (vptr_name) - 2]))
{
int nfields = 0;
int non_public_fields = 0;
- struct nextfield *scan;
+ struct stabs_nextfield *scan;
/* Count up the number of fields that we have, as well as taking note of
whether or not there are any non-public fields, which requires us to
while (ntype != type)
{
- if (TYPE_LENGTH(ntype) == 0)
- TYPE_LENGTH (ntype) = TYPE_LENGTH (type);
+ if (ntype->length () == 0)
+ ntype->set_length (type->length ());
else
complain_about_struct_wipeout (ntype);
ntype = TYPE_CHAIN (ntype);
{
int nbits;
- TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits, 0);
+ type->set_length (read_huge_number (pp, 0, &nbits, 0));
if (nbits != 0)
return error_type (pp, objfile);
set_length_in_type_chain (type);
upper = -1;
}
+ type_allocator alloc (objfile);
range_type =
- create_static_range_type (NULL, index_type, lower, upper);
- type = create_array_type (type, element_type, range_type);
+ create_static_range_type (alloc, index_type, lower, upper);
+ type_allocator smash_alloc (type, type_allocator::SMASH);
+ type = create_array_type (smash_alloc, element_type, range_type);
return type;
}
sym->set_linkage_name (name);
sym->set_language (get_current_subfile ()->language,
&objfile->objfile_obstack);
- SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
- SYMBOL_VALUE (sym) = n;
+ sym->set_aclass_index (LOC_CONST);
+ sym->set_domain (VAR_DOMAIN);
+ sym->set_value_longest (n);
if (n < 0)
unsigned_enum = 0;
add_symbol_to_list (sym, symlist);
/* Now fill in the fields of the type-structure. */
- TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT;
+ type->set_length (gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT);
set_length_in_type_chain (type);
type->set_code (TYPE_CODE_ENUM);
type->set_is_stub (false);
{
struct symbol *xsym = syms->symbol[j];
- SYMBOL_TYPE (xsym) = type;
- TYPE_FIELD_NAME (type, n) = xsym->linkage_name ();
- SET_FIELD_ENUMVAL (type->field (n), SYMBOL_VALUE (xsym));
+ xsym->set_type (type);
+ type->field (n).set_name (xsym->linkage_name ());
+ type->field (n).set_loc_enumval (xsym->value_longest ());
TYPE_FIELD_BITSIZE (type, n) = 0;
}
if (syms == osyms)
if (**pp == ';')
++(*pp);
+ type_allocator alloc (objfile);
if (type_bits == 0)
{
- struct type *type = init_type (objfile, TYPE_CODE_VOID,
- TARGET_CHAR_BIT, NULL);
+ struct type *type = alloc.new_type (TYPE_CODE_VOID,
+ TARGET_CHAR_BIT, nullptr);
if (unsigned_type)
type->set_is_unsigned (true);
}
if (boolean_type)
- return init_boolean_type (objfile, type_bits, unsigned_type, NULL);
+ return init_boolean_type (alloc, type_bits, unsigned_type, NULL);
else
- return init_integer_type (objfile, type_bits, unsigned_type, NULL);
+ return init_integer_type (alloc, type_bits, unsigned_type, NULL);
}
static struct type *
if (n2bits == -1 || n3bits == -1)
return error_type (pp, objfile);
+ type_allocator alloc (objfile);
+
if (index_type)
goto handle_true_range;
}
if (got_signed || got_unsigned)
- return init_integer_type (objfile, nbits, got_unsigned, NULL);
+ return init_integer_type (alloc, nbits, got_unsigned, NULL);
else
return error_type (pp, objfile);
}
/* A type defined as a subrange of itself, with bounds both 0, is void. */
if (self_subrange && n2 == 0 && n3 == 0)
- return init_type (objfile, TYPE_CODE_VOID, TARGET_CHAR_BIT, NULL);
+ return alloc.new_type (TYPE_CODE_VOID, TARGET_CHAR_BIT, nullptr);
/* If n3 is zero and n2 is positive, we want a floating type, and n2
is the width in bytes.
bits = gdbarch_int_bit (gdbarch);
}
- return init_integer_type (objfile, bits, 1, NULL);
+ return init_integer_type (alloc, bits, 1, NULL);
}
/* Special case: char is defined (Who knows why) as a subrange of
itself with range 0-127. */
else if (self_subrange && n2 == 0 && n3 == 127)
{
- struct type *type = init_integer_type (objfile, TARGET_CHAR_BIT,
+ struct type *type = init_integer_type (alloc, TARGET_CHAR_BIT,
0, NULL);
type->set_has_no_signedness (true);
return type;
if (n3 < 0)
/* n3 actually gives the size. */
- return init_integer_type (objfile, -n3 * TARGET_CHAR_BIT, 1, NULL);
+ return init_integer_type (alloc, -n3 * TARGET_CHAR_BIT, 1, NULL);
/* Is n3 == 2**(8n)-1 for some integer n? Then it's an
unsigned n-byte integer. But do require n to be a power of
bits >>= 8;
if (bits == 0
&& ((bytes - 1) & bytes) == 0) /* "bytes is a power of two" */
- return init_integer_type (objfile, bytes * TARGET_CHAR_BIT, 1, NULL);
+ return init_integer_type (alloc, bytes * TARGET_CHAR_BIT, 1, NULL);
}
}
/* I think this is for Convex "long long". Since I don't know whether
&& (self_subrange
|| n2 == -gdbarch_long_long_bit
(gdbarch) / TARGET_CHAR_BIT))
- return init_integer_type (objfile, -n2 * TARGET_CHAR_BIT, 0, NULL);
+ return init_integer_type (alloc, -n2 * TARGET_CHAR_BIT, 0, NULL);
else if (n2 == -n3 - 1)
{
if (n3 == 0x7f)
- return init_integer_type (objfile, 8, 0, NULL);
+ return init_integer_type (alloc, 8, 0, NULL);
if (n3 == 0x7fff)
- return init_integer_type (objfile, 16, 0, NULL);
+ return init_integer_type (alloc, 16, 0, NULL);
if (n3 == 0x7fffffff)
- return init_integer_type (objfile, 32, 0, NULL);
+ return init_integer_type (alloc, 32, 0, NULL);
}
/* We have a real range type on our hands. Allocate space and
handle_true_range:
if (self_subrange)
- index_type = objfile_type (objfile)->builtin_int;
+ index_type = builtin_type (objfile)->builtin_int;
else
index_type = *dbx_lookup_type (rangenums, objfile);
if (index_type == NULL)
complaint (_("base type %d of range type is not defined"), rangenums[1]);
- index_type = objfile_type (objfile)->builtin_int;
+ index_type = builtin_type (objfile)->builtin_int;
}
result_type
- = create_static_range_type (NULL, index_type, n2, n3);
+ = create_static_range_type (alloc, index_type, n2, n3);
return (result_type);
}
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;
+ sym->set_aclass_index (LOC_BLOCK);
/* Now we copy all the symbols which have been defined since the BCOMM. */
for (j = common_block_i; j < common_block->nsyms; j++)
add_symbol_to_list (common_block->symbol[j], &newobj);
- SYMBOL_TYPE (sym) = (struct type *) newobj;
+ sym->set_type ((struct type *) newobj);
/* Should we be putting local_symbols back to what it was?
Does it matter? */
i = hashname (sym->linkage_name ());
- SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
+ sym->set_value_chain (global_sym_chain[i]);
global_sym_chain[i] = sym;
common_block_name = NULL;
}
the common block name). */
static void
-fix_common_block (struct symbol *sym, CORE_ADDR valu)
+fix_common_block (struct symbol *sym, CORE_ADDR valu, int section_index)
{
- struct pending *next = (struct pending *) SYMBOL_TYPE (sym);
+ struct pending *next = (struct pending *) sym->type ();
for (; next; next = next->next)
{
int j;
for (j = next->nsyms - 1; j >= 0; j--)
- SET_SYMBOL_VALUE_ADDRESS (next->symbol[j],
- SYMBOL_VALUE_ADDRESS (next->symbol[j])
- + valu);
+ {
+ next->symbol[j]->set_value_address
+ (next->symbol[j]->value_address () + valu);
+ next->symbol[j]->set_section_index (section_index);
+ }
}
}
\f
{
struct symbol *sym = ppt->symbol[i];
- if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
- && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
- && (SYMBOL_TYPE (sym)->code () == (*type)->code ())
+ if (sym->aclass () == LOC_TYPEDEF
+ && sym->domain () == STRUCT_DOMAIN
+ && (sym->type ()->code () == (*type)->code ())
&& ((*type)->instance_flags ()
- == SYMBOL_TYPE (sym)->instance_flags ())
+ == sym->type ()->instance_flags ())
&& strcmp (sym->linkage_name (), type_name) == 0)
- replace_type (*type, SYMBOL_TYPE (sym));
+ replace_type (*type, sym->type ());
}
}
}
QUIT;
/* Skip static symbols. */
- switch (MSYMBOL_TYPE (msymbol))
+ switch (msymbol->type ())
{
case mst_file_text:
case mst_file_data:
assign the value we have to it. */
if (prev)
{
- SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
+ prev->set_value_chain (sym->value_chain ());
}
else
{
- global_sym_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
+ global_sym_chain[hash] = sym->value_chain ();
}
/* Check to see whether we need to fix up a common block. */
the same symbol if there are multiple references. */
if (sym)
{
- if (SYMBOL_CLASS (sym) == LOC_BLOCK)
- {
- fix_common_block (sym,
- MSYMBOL_VALUE_ADDRESS (resolve_objfile,
- msymbol));
- }
+ if (sym->aclass () == LOC_BLOCK)
+ fix_common_block
+ (sym, msymbol->value_address (resolve_objfile),
+ msymbol->section_index ());
else
- {
- SET_SYMBOL_VALUE_ADDRESS
- (sym, MSYMBOL_VALUE_ADDRESS (resolve_objfile,
- msymbol));
- }
- SYMBOL_SECTION (sym) = MSYMBOL_SECTION (msymbol);
+ sym->set_value_address
+ (msymbol->value_address (resolve_objfile));
+ sym->set_section_index (msymbol->section_index ());
}
if (prev)
{
- sym = SYMBOL_VALUE_CHAIN (prev);
+ sym = prev->value_chain ();
}
else
{
else
{
prev = sym;
- sym = SYMBOL_VALUE_CHAIN (sym);
+ sym = sym->value_chain ();
}
}
}
while (sym)
{
prev = sym;
- sym = SYMBOL_VALUE_CHAIN (sym);
+ sym = sym->value_chain ();
/* Change the symbol address from the misleading chain value
to address zero. */
- SET_SYMBOL_VALUE_ADDRESS (prev, 0);
+ prev->set_value_address (0);
/* Complain about unresolved common block symbols. */
- if (SYMBOL_CLASS (prev) == LOC_STATIC)
- SYMBOL_ACLASS_INDEX (prev) = LOC_UNRESOLVED;
+ if (prev->aclass () == LOC_STATIC)
+ prev->set_aclass_index (LOC_UNRESOLVED);
else
complaint (_("%s: common block `%s' from "
"global_sym_chain unresolved"),
}
/* Initialize anything that needs initializing at the same time as
- start_symtab() is called. */
+ start_compunit_symtab() is called. */
void
start_stabs (void)
common_block_name = NULL;
}
-/* Call after end_symtab(). */
+/* Call after end_compunit_symtab(). */
void
end_stabs (void)
projects / binutils-gdb.git / blobdiff