sym = allocate_symbol (objfile);
SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
SYMBOL_ACLASS_INDEX (sym) = LOC_OPTIMIZED_OUT;
- SYMBOL_SET_LINKAGE_NAME
- (sym, obstack_strndup (&objfile->objfile_obstack,
- name, pp - name));
+ sym->set_linkage_name
+ (obstack_strndup (&objfile->objfile_obstack, name, pp - name));
pp += 2;
if (*(pp - 1) == 'F' || *(pp - 1) == 'f')
{
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. */
}
SYMBOL_LINE (sym) = 0; /* unknown */
}
- SYMBOL_SET_LANGUAGE (sym, get_current_subfile ()->language,
- &objfile->objfile_obstack);
+ sym->set_language (get_current_subfile ()->language,
+ &objfile->objfile_obstack);
if (is_cplus_marker (string[0]))
{
switch (string[1])
{
case 't':
- SYMBOL_SET_LINKAGE_NAME (sym, "this");
+ sym->set_linkage_name ("this");
break;
case 'v': /* $vtbl_ptr_type */
goto normal;
case 'e':
- SYMBOL_SET_LINKAGE_NAME (sym, "eh_throw");
+ sym->set_linkage_name ("eh_throw");
break;
case '_':
normal:
std::string new_name;
- if (SYMBOL_LANGUAGE (sym) == language_cplus)
+ if (sym->language () == language_cplus)
{
char *name = (char *) alloca (p - string + 1);
SYMBOL_SET_NAMES (sym, gdb::string_view (string, p - string), true,
objfile);
- if (SYMBOL_LANGUAGE (sym) == language_cplus)
+ if (sym->language () == language_cplus)
cp_scan_for_anonymous_namespaces (get_buildsym_compunit (), sym,
objfile);
Symbol references don't have valid names and wont't match up with
minimal symbols when the global_sym_chain is relocated.
We'll fixup symbol references when we fixup the defining symbol. */
- if (SYMBOL_LINKAGE_NAME (sym) && SYMBOL_LINKAGE_NAME (sym)[0] != '#')
+ if (sym->linkage_name () && sym->linkage_name ()[0] != '#')
{
- i = hashname (SYMBOL_LINKAGE_NAME (sym));
+ i = hashname (sym->linkage_name ());
SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
global_sym_chain[i] = sym;
}
the same name to represent an argument passed in a
register. GCC uses 'P' for the same case. So if we find
such a symbol pair we combine it into one 'P' symbol.
- For Sun cc we need to do this regardless of
- stabs_argument_has_addr, because the compiler puts out
+ For Sun cc we need to do this regardless of stabs_argument_has_addr, because the compiler puts out
the 'p' symbol even if it never saves the argument onto
the stack.
prev_sym = local_symbols->symbol[local_symbols->nsyms - 1];
if ((SYMBOL_CLASS (prev_sym) == LOC_REF_ARG
|| SYMBOL_CLASS (prev_sym) == LOC_ARG)
- && strcmp (SYMBOL_LINKAGE_NAME (prev_sym),
- SYMBOL_LINKAGE_NAME (sym)) == 0)
+ && strcmp (prev_sym->linkage_name (),
+ sym->linkage_name ()) == 0)
{
SYMBOL_ACLASS_INDEX (prev_sym) = stab_register_index;
/* Use the type from the LOC_REGISTER; that is the type
SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
SET_SYMBOL_VALUE_ADDRESS (sym, valu);
if (gdbarch_static_transform_name_p (gdbarch)
- && gdbarch_static_transform_name (gdbarch,
- SYMBOL_LINKAGE_NAME (sym))
- != SYMBOL_LINKAGE_NAME (sym))
+ && gdbarch_static_transform_name (gdbarch, sym->linkage_name ())
+ != sym->linkage_name ())
{
struct bound_minimal_symbol msym;
- msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
- NULL, objfile);
+ msym = lookup_minimal_symbol (sym->linkage_name (), NULL, objfile);
if (msym.minsym != NULL)
{
const char *new_name = gdbarch_static_transform_name
- (gdbarch, SYMBOL_LINKAGE_NAME (sym));
+ (gdbarch, sym->linkage_name ());
- SYMBOL_SET_LINKAGE_NAME (sym, new_name);
+ sym->set_linkage_name (new_name);
SET_SYMBOL_VALUE_ADDRESS (sym,
BMSYMBOL_VALUE_ADDRESS (msym));
}
This is important to do, because of forward references:
The cleanup of undefined types stored in undef_types only uses
STRUCT_DOMAIN symbols to perform the replacement. */
- synonym = (SYMBOL_LANGUAGE (sym) == language_ada && p[-2] != 'T');
+ synonym = (sym->language () == language_ada && p[-2] != 'T');
/* Typedef */
SYMBOL_TYPE (sym) = read_type (&p, objfile);
if (TYPE_NAME (SYMBOL_TYPE (sym)) == NULL)
{
if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
- && strcmp (SYMBOL_LINKAGE_NAME (sym), vtbl_ptr_name))
+ && strcmp (sym->linkage_name (), vtbl_ptr_name))
|| TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
{
/* If we are giving a name to a type such as "pointer to
/* Pascal accepts names for pointer types. */
if (get_current_subfile ()->language == language_pascal)
{
- TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
+ TYPE_NAME (SYMBOL_TYPE (sym)) = sym->linkage_name ();
}
}
else
- TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym);
+ TYPE_NAME (SYMBOL_TYPE (sym)) = sym->linkage_name ();
}
add_symbol_to_list (sym, get_file_symbols ());
SYMBOL_DOMAIN (struct_sym) = STRUCT_DOMAIN;
if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
TYPE_NAME (SYMBOL_TYPE (sym))
- = obconcat (&objfile->objfile_obstack,
- SYMBOL_LINKAGE_NAME (sym),
+ = obconcat (&objfile->objfile_obstack, sym->linkage_name (),
(char *) NULL);
add_symbol_to_list (struct_sym, get_file_symbols ());
}
SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
TYPE_NAME (SYMBOL_TYPE (sym))
- = obconcat (&objfile->objfile_obstack,
- SYMBOL_LINKAGE_NAME (sym),
+ = obconcat (&objfile->objfile_obstack, sym->linkage_name (),
(char *) NULL);
add_symbol_to_list (sym, get_file_symbols ());
SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN;
if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
TYPE_NAME (SYMBOL_TYPE (sym))
- = obconcat (&objfile->objfile_obstack,
- SYMBOL_LINKAGE_NAME (sym),
+ = obconcat (&objfile->objfile_obstack, sym->linkage_name (),
(char *) NULL);
add_symbol_to_list (typedef_sym, get_file_symbols ());
}
SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
SET_SYMBOL_VALUE_ADDRESS (sym, valu);
if (gdbarch_static_transform_name_p (gdbarch)
- && gdbarch_static_transform_name (gdbarch,
- SYMBOL_LINKAGE_NAME (sym))
- != SYMBOL_LINKAGE_NAME (sym))
+ && gdbarch_static_transform_name (gdbarch, sym->linkage_name ())
+ != sym->linkage_name ())
{
struct bound_minimal_symbol msym;
- msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
- NULL, objfile);
+ msym = lookup_minimal_symbol (sym->linkage_name (), NULL, objfile);
if (msym.minsym != NULL)
{
const char *new_name = gdbarch_static_transform_name
- (gdbarch, SYMBOL_LINKAGE_NAME (sym));
+ (gdbarch, sym->linkage_name ());
- SYMBOL_SET_LINKAGE_NAME (sym, new_name);
+ sym->set_linkage_name (new_name);
SET_SYMBOL_VALUE_ADDRESS (sym, BMSYMBOL_VALUE_ADDRESS (msym));
}
}
if (SYMBOL_CLASS (sym) == LOC_TYPEDEF
&& SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
&& (TYPE_CODE (SYMBOL_TYPE (sym)) == code)
- && strcmp (SYMBOL_LINKAGE_NAME (sym), type_name) == 0)
+ && strcmp (sym->linkage_name (), type_name) == 0)
{
obstack_free (&objfile->objfile_obstack, type_name);
type = SYMBOL_TYPE (sym);
return error_type (pp, objfile);
sym = allocate_symbol (objfile);
- SYMBOL_SET_LINKAGE_NAME (sym, name);
- SYMBOL_SET_LANGUAGE (sym, get_current_subfile ()->language,
- &objfile->objfile_obstack);
+ 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;
struct symbol *xsym = syms->symbol[j];
SYMBOL_TYPE (xsym) = type;
- TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym);
+ TYPE_FIELD_NAME (type, n) = xsym->linkage_name ();
SET_FIELD_ENUMVAL (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym));
TYPE_FIELD_BITSIZE (type, n) = 0;
}
sym = allocate_symbol (objfile);
/* Note: common_block_name already saved on objfile_obstack. */
- SYMBOL_SET_LINKAGE_NAME (sym, common_block_name);
+ sym->set_linkage_name (common_block_name);
SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
/* Now we copy all the symbols which have been defined since the BCOMM. */
/* Should we be putting local_symbols back to what it was?
Does it matter? */
- i = hashname (SYMBOL_LINKAGE_NAME (sym));
+ i = hashname (sym->linkage_name ());
SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
global_sym_chain[i] = sym;
common_block_name = NULL;
TYPE_CODE (*type))
&& (TYPE_INSTANCE_FLAGS (*type) ==
TYPE_INSTANCE_FLAGS (SYMBOL_TYPE (sym)))
- && strcmp (SYMBOL_LINKAGE_NAME (sym),
- type_name) == 0)
+ && strcmp (sym->linkage_name (), type_name) == 0)
replace_type (*type, SYMBOL_TYPE (sym));
}
}
for (sym = global_sym_chain[hash]; sym;)
{
- if (strcmp (msymbol->linkage_name (),
- SYMBOL_LINKAGE_NAME (sym)) == 0)
+ if (strcmp (msymbol->linkage_name (), sym->linkage_name ()) == 0)
{
/* Splice this symbol out of the hash chain and
assign the value we have to it. */
else
complaint (_("%s: common block `%s' from "
"global_sym_chain unresolved"),
- objfile_name (objfile), SYMBOL_PRINT_NAME (prev));
+ objfile_name (objfile), prev->print_name ());
}
}
memset (global_sym_chain, 0, sizeof (global_sym_chain));
int
hashname (const char *name)
{
- return hash (name, strlen (name)) % HASHSIZE;
+ return fast_hash (name, strlen (name)) % HASHSIZE;
}
/* Initializer for this module. */