+2014-12-23 Doug Evans <xdje42@gmail.com>
+
+ * symtab.h (SYMBOL_SYMTAB): Delete
+ (SYMBOL_OBJFILE): Delete.
+ (symbol_symtab, symbol_set_symtab): Declare.
+ (symbol_objfile, symbol_arch): Declare.
+ * symtab.c (symbol_symtab): Replaces SYMBOL_SYMTAB. All uses updated.
+ All references to symbol->symtab redirected through here.
+ (symbol_set_symtab): New function. All assignments to SYMBOL_SYMTAB
+ redirected through here.
+ (symbol_arch): New function.
+ (symbol_objfile): New function. Replaces SYMBOL_OBJFILE.
+ All uses updated.
+ * cp-namespace.c (cp_lookup_symbol_imports_or_template): Call
+ symbol_arch.
+ * findvar.c (default_read_var_value): Call symbol_arch.
+ * guile/scm-frame.c (gdbscm_frame_block): Call symbol_objfile.
+ * jv-lang.c (add_class_symtab_symbol): Call symbol_arch.
+ * printcmd.c (address_info): Call symbol_arch.
+ * tracepoint.c (scope_info): Call symbol_arch.
+
2014-12-22 Doug Evans <xdje42@gmail.com>
* cp-namespace.c (cp_lookup_symbol_via_all_imports): New function.
(SYMBOL_CLASS (syms[i].sym) == LOC_CONST
&& SYMBOL_TYPE (syms[i].sym) != NULL
&& TYPE_CODE (SYMBOL_TYPE (syms[i].sym)) == TYPE_CODE_ENUM);
- struct symtab *symtab = SYMBOL_SYMTAB (syms[i].sym);
+ struct symtab *symtab = symbol_symtab (syms[i].sym);
if (SYMBOL_LINE (syms[i].sym) != 0 && symtab != NULL)
printf_unfiltered (_("[%d] %s at %s:%d\n"),
the symbol is local or not, we check the block where we found it
against the global and static blocks of its associated symtab. */
if (sym
- && BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (sym->symtab),
+ && BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symbol_symtab (sym)),
GLOBAL_BLOCK) != block
- && BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (sym->symtab),
+ && BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (symbol_symtab (sym)),
STATIC_BLOCK) != block)
return;
sym = bfun->sym;
if (sym != NULL)
- filename = symtab_to_filename_for_display (sym->symtab);
+ filename = symtab_to_filename_for_display (symbol_symtab (sym));
else
filename = "<unknown>";
return 1;
/* Check the location of those functions, as well. */
- bfname = symtab_to_fullname (sym->symtab);
- fname = symtab_to_fullname (fun->symtab);
+ bfname = symtab_to_fullname (symbol_symtab (sym));
+ fname = symtab_to_fullname (symbol_symtab (fun));
if (filename_cmp (fname, bfname) != 0)
return 1;
}
if (sym == NULL)
return 1;
- bfile = symtab_to_fullname (sym->symtab);
+ bfile = symtab_to_fullname (symbol_symtab (sym));
return (filename_cmp (bfile, fullname) != 0);
}
/* Inlined functions may have symbols not in the global or
static symbol lists. */
if (BLOCK_FUNCTION (block) != NULL)
- if (SYMBOL_SYMTAB (BLOCK_FUNCTION (block)) == NULL)
- SYMBOL_SYMTAB (BLOCK_FUNCTION (block)) = symtab;
+ if (symbol_symtab (BLOCK_FUNCTION (block)) == NULL)
+ symbol_set_symtab (BLOCK_FUNCTION (block), symtab);
/* Note that we only want to fix up symbols from the local
blocks, not blocks coming from included symtabs. That is why
we use ALL_DICT_SYMBOLS here and not ALL_BLOCK_SYMBOLS. */
ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
- if (SYMBOL_SYMTAB (sym) == NULL)
- SYMBOL_SYMTAB (sym) = symtab;
+ if (symbol_symtab (sym) == NULL)
+ symbol_set_symtab (sym, symtab);
}
}
{
for (i = 0; i < pending->nsyms; ++i)
{
- if (SYMBOL_SYMTAB (pending->symbol[i]) == NULL)
- SYMBOL_SYMTAB (pending->symbol[i]) = COMPUNIT_FILETABS (cu);
+ if (symbol_symtab (pending->symbol[i]) == NULL)
+ symbol_set_symtab (pending->symbol[i], COMPUNIT_FILETABS (cu));
}
}
}
int is_local)
{
gcc_type sym_type;
- const char *filename = SYMBOL_SYMTAB (sym)->filename;
+ const char *filename = symbol_symtab (sym)->filename;
unsigned short line = SYMBOL_LINE (sym);
error_symbol_once (context, sym);
char *name_copy = xstrdup (SYMBOL_NATURAL_NAME (function));
struct cleanup *cleanups = make_cleanup (xfree, name_copy);
const struct language_defn *lang = language_def (language_cplus);
- struct gdbarch *arch
- = get_objfile_arch (SYMBOL_OBJFILE (function));
+ struct gdbarch *arch = symbol_arch (function);
const struct block *parent = BLOCK_SUPERBLOCK (block);
while (1)
if (strcmp (package_name, this_package_name) != 0)
complaint (&symfile_complaints,
_("Symtab %s has objects from two different Go packages: %s and %s"),
- (SYMBOL_SYMTAB (sym)
- ? symtab_to_filename_for_display (SYMBOL_SYMTAB (sym))
+ (symbol_symtab (sym) != NULL
+ ? symtab_to_filename_for_display
+ (symbol_symtab (sym))
: objfile_name (cu->objfile)),
this_package_name, package_name);
xfree (this_package_name);
struct file_entry *fe;
fe = &cu->line_header->file_names[file_index - 1];
- SYMBOL_SYMTAB (sym) = fe->symtab;
+ symbol_set_symtab (sym, fe->symtab);
}
}
{
CORE_ADDR addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
- SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
+ SYMBOL_OBJ_SECTION (symbol_objfile (var),
var));
store_typed_address (value_contents_raw (v), type, addr);
case LOC_STATIC:
if (overlay_debugging)
addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
- SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
+ SYMBOL_OBJ_SECTION (symbol_objfile (var),
var));
else
addr = SYMBOL_VALUE_ADDRESS (var);
case LOC_BLOCK:
if (overlay_debugging)
addr = symbol_overlayed_address
- (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
- var));
+ (BLOCK_START (SYMBOL_BLOCK_VALUE (var)),
+ SYMBOL_OBJ_SECTION (symbol_objfile (var), var));
else
addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
break;
lookup_data.name = SYMBOL_LINKAGE_NAME (var);
gdbarch_iterate_over_objfiles_in_search_order
- (get_objfile_arch (SYMBOL_OBJFILE (var)),
+ (symbol_arch (var),
minsym_lookup_iterator_cb, &lookup_data,
- SYMBOL_OBJFILE (var));
+ symbol_objfile (var));
msym = lookup_data.result.minsym;
if (msym == NULL)
init_sal (sal);
if (SYMBOL_LINE (sym) != 0)
{
- sal->symtab = SYMBOL_SYMTAB (sym);
+ sal->symtab = symbol_symtab (sym);
sal->line = SYMBOL_LINE (sym);
}
else
if (block != NULL)
{
- struct symtab *st;
- SCM block_scm;
-
- st = SYMBOL_SYMTAB (BLOCK_FUNCTION (fn_block));
- return bkscm_scm_from_block (block, SYMTAB_OBJFILE (st));
+ return bkscm_scm_from_block
+ (block, symbol_objfile (BLOCK_FUNCTION (fn_block)));
}
return SCM_BOOL_F;
static htab_t
syscm_objfile_symbol_map (struct symbol *symbol)
{
- struct objfile *objfile = SYMBOL_OBJFILE (symbol);
+ struct objfile *objfile = symbol_objfile (symbol);
htab_t htab = objfile_data (objfile, syscm_objfile_data_key);
if (htab == NULL)
= syscm_get_valid_symbol_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME);
const struct symbol *symbol = s_smob->symbol;
- return stscm_scm_from_symtab (SYMBOL_SYMTAB (symbol));
+ return stscm_scm_from_symtab (symbol_symtab (symbol));
}
/* (symbol-name <gdb:symbol>) -> string */
struct obj_section *section;
fixup_symbol_section (sfn, 0);
- section = SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sfn), sfn);
+ section = SYMBOL_OBJ_SECTION (symbol_objfile (sfn), sfn);
if (section_is_overlay (section)
&& !section_is_mapped (section))
{
/* The name. */
SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
SYMBOL_ACLASS_INDEX (block_name) = LOC_BLOCK;
- SYMBOL_SYMTAB (block_name) = COMPUNIT_FILETABS (cust);
+ symbol_set_symtab (block_name, COMPUNIT_FILETABS (cust));
SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
SYMBOL_BLOCK_VALUE (block_name) = new_block;
static void
add_class_symtab_symbol (struct symbol *sym)
{
- struct compunit_symtab *cust
- = get_java_class_symtab (get_objfile_arch (SYMBOL_OBJFILE (sym)));
+ struct compunit_symtab *cust = get_java_class_symtab (symbol_arch (sym));
const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (cust);
dict_add_symbol (BLOCK_DICT (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)), sym);
for (i = 0; VEC_iterate (symbolp, ls->labels.label_symbols, i, sym); ++i)
{
- struct program_space *pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
+ struct program_space *pspace = SYMTAB_PSPACE (symbol_symtab (sym));
if (symbol_to_sal (&sal, state->funfirstline, sym)
&& maybe_add_address (state->addr_set, pspace, sal.pc))
for (i = 0; VEC_iterate (symbolp, ls->function_symbols, i, sym); ++i)
{
- pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
+ pspace = SYMTAB_PSPACE (symbol_symtab (sym));
set_current_program_space (pspace);
if (symbol_to_sal (&sal, state->funfirstline, sym)
&& maybe_add_address (state->addr_set, pspace, sal.pc))
struct symbol * const *sb = b;
uintptr_t uia, uib;
- uia = (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sa));
- uib = (uintptr_t) SYMTAB_PSPACE (SYMBOL_SYMTAB (*sb));
+ uia = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (*sa));
+ uib = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (*sb));
if (uia < uib)
return -1;
/* Program spaces that are executing startup should have
been filtered out earlier. */
- gdb_assert (!SYMTAB_PSPACE (SYMBOL_SYMTAB (sym))->executing_startup);
- pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
+ pspace = SYMTAB_PSPACE (symbol_symtab (sym));
+ gdb_assert (!pspace->executing_startup);
set_current_program_space (pspace);
t = check_typedef (SYMBOL_TYPE (sym));
find_methods (t, method_name, &result_names, &superclass_vec);
sure not to miss the last batch. */
if (ix == VEC_length (symbolp, sym_classes) - 1
|| (pspace
- != SYMTAB_PSPACE (SYMBOL_SYMTAB (VEC_index (symbolp, sym_classes,
+ != SYMTAB_PSPACE (symbol_symtab (VEC_index (symbolp, sym_classes,
ix + 1)))))
{
/* If we did not find a direct implementation anywhere in
for (ix = 0;
VEC_iterate (symbolp, function_symbols, ix, fn_sym); ++ix)
{
- set_current_program_space (SYMTAB_PSPACE (SYMBOL_SYMTAB (fn_sym)));
+ set_current_program_space (SYMTAB_PSPACE (symbol_symtab (fn_sym)));
block = SYMBOL_BLOCK_VALUE (fn_sym);
sym = lookup_symbol (name, block, LABEL_DOMAIN, 0);
if (SYMBOL_CLASS (sym) == LOC_LABEL && SYMBOL_VALUE_ADDRESS (sym) != 0)
{
init_sal (result);
- result->symtab = SYMBOL_SYMTAB (sym);
+ result->symtab = symbol_symtab (sym);
result->line = SYMBOL_LINE (sym);
result->pc = SYMBOL_VALUE_ADDRESS (sym);
- result->pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
+ result->pspace = SYMTAB_PSPACE (result->symtab);
result->explicit_pc = 1;
return 1;
}
{
/* We know its line number. */
init_sal (result);
- result->symtab = SYMBOL_SYMTAB (sym);
+ result->symtab = symbol_symtab (sym);
result->line = SYMBOL_LINE (sym);
- result->pspace = SYMTAB_PSPACE (SYMBOL_SYMTAB (sym));
+ result->pspace = SYMTAB_PSPACE (result->symtab);
return 1;
}
}
static void
add_symbol (struct symbol *s, struct symtab *symtab, struct block *b)
{
- SYMBOL_SYMTAB (s) = symtab;
+ symbol_set_symtab (s, symtab);
dict_add_symbol (BLOCK_DICT (b), s);
}
/* Check objfile where the variable itself is placed.
SYMBOL_OBJ_SECTION (symbol) may be NULL. */
- if ((*objfile_func) (SYMBOL_OBJFILE (symbol), data))
+ if ((*objfile_func) (symbol_objfile (symbol), data))
return 1;
/* Check objfile where is placed the code touching the variable. */
current_language->la_language, DMGL_ANSI);
printf_filtered ("\" is ");
val = SYMBOL_VALUE (sym);
- section = SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym), sym);
- gdbarch = get_objfile_arch (SYMBOL_OBJFILE (sym));
+ section = SYMBOL_OBJ_SECTION (symbol_objfile (sym), sym);
+ gdbarch = symbol_arch (sym);
if (SYMBOL_COMPUTED_OPS (sym) != NULL)
{
if (block)
{
- struct symtab *symt;
-
- symt = SYMBOL_SYMTAB (BLOCK_FUNCTION (fn_block));
- return block_to_block_object (block, SYMTAB_OBJFILE (symt));
+ return block_to_block_object
+ (block, symbol_objfile (BLOCK_FUNCTION (fn_block)));
}
Py_RETURN_NONE;
SYMPY_REQUIRE_VALID (self, symbol);
- return symtab_to_symtab_object (SYMBOL_SYMTAB (symbol));
+ return symtab_to_symtab_object (symbol_symtab (symbol));
}
static PyObject *
{
obj->symbol = symbol;
obj->prev = NULL;
- if (SYMBOL_SYMTAB (symbol))
+ if (symbol_symtab (symbol) != NULL)
{
- obj->next = objfile_data (SYMBOL_OBJFILE (symbol),
- sympy_objfile_data_key);
+ struct objfile *objfile = symbol_objfile (symbol);
+ obj->next = objfile_data (objfile, sympy_objfile_data_key);
if (obj->next)
obj->next->prev = obj;
- set_objfile_data (SYMBOL_OBJFILE (symbol),
- sympy_objfile_data_key, obj);
+ set_objfile_data (objfile, sympy_objfile_data_key, obj);
}
else
obj->next = NULL;
if (sym_obj->prev)
sym_obj->prev->next = sym_obj->next;
- else if (sym_obj->symbol && SYMBOL_SYMTAB (sym_obj->symbol))
+ else if (sym_obj->symbol != NULL
+ && symbol_symtab (sym_obj->symbol) != NULL)
{
- set_objfile_data (SYMBOL_OBJFILE (sym_obj->symbol),
+ set_objfile_data (symbol_objfile (sym_obj->symbol),
sympy_objfile_data_key, sym_obj->next);
}
if (sym_obj->next)
return;
ui_out_field_string (uiout, "file",
- symtab_to_filename_for_display (sym->symtab));
+ symtab_to_filename_for_display (symbol_symtab (sym)));
begin = bfun->lbegin;
end = bfun->lend;
struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
int depth = ((struct print_symbol_args *) args)->depth;
struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
- struct obj_section *section = SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (symbol),
+ struct obj_section *section = SYMBOL_OBJ_SECTION (symbol_objfile (symbol),
symbol);
print_spaces (depth, outfile);
/* We either have an OBJFILE, or we can get at it from the sym's
symtab. Anything else is a bug. */
- gdb_assert (objfile || SYMBOL_SYMTAB (sym));
+ gdb_assert (objfile || symbol_symtab (sym));
if (objfile == NULL)
- objfile = SYMBOL_OBJFILE (sym);
+ objfile = symbol_objfile (sym);
if (SYMBOL_OBJ_SECTION (objfile, sym))
return sym;
find_function_start_sal (struct symbol *sym, int funfirstline)
{
struct symtab_and_line sal;
+ struct obj_section *section;
fixup_symbol_section (sym, NULL);
- sal = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
- SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym), sym), 0);
+ section = SYMBOL_OBJ_SECTION (symbol_objfile (sym), sym);
+ sal = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), section, 0);
/* We always should have a line for the function start address.
If we don't, something is odd. Create a plain SAL refering
init_sal (&sal);
sal.pspace = current_program_space;
sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
- sal.section = SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym), sym);
+ sal.section = section;
}
if (funfirstline)
{
fixup_symbol_section (sym, NULL);
+ objfile = symbol_objfile (sym);
pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
- section = SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (sym), sym);
+ section = SYMBOL_OBJ_SECTION (objfile, sym);
name = SYMBOL_LINKAGE_NAME (sym);
- objfile = SYMBOL_OBJFILE (sym);
}
else
{
/* Be conservative - allow direct PC (without skipping prologue) only if we
have proven the CU (Compilation Unit) supports it. sal->SYMTAB does not
have to be set by the caller so we use SYM instead. */
- if (sym && COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (SYMBOL_SYMTAB (sym))))
+ if (sym != NULL
+ && COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (symbol_symtab (sym))))
force_skip = 0;
saved_pc = pc;
is aligned. */
if (!force_skip && sym && start_sal.symtab == NULL)
{
- pc = skip_prologue_using_lineinfo (pc, SYMBOL_SYMTAB (sym));
+ pc = skip_prologue_using_lineinfo (pc, symbol_symtab (sym));
/* Recalculate the line number. */
start_sal = find_pc_sect_line (pc, section, 0);
}
&& SYMBOL_LINE (BLOCK_FUNCTION (function_block)) != 0)
{
sal->line = SYMBOL_LINE (BLOCK_FUNCTION (function_block));
- sal->symtab = SYMBOL_SYMTAB (BLOCK_FUNCTION (function_block));
+ sal->symtab = symbol_symtab (BLOCK_FUNCTION (function_block));
}
}
struct symbol_search *sym_b = *(struct symbol_search **) sb;
int c;
- c = FILENAME_CMP (SYMBOL_SYMTAB (sym_a->symbol)->filename,
- SYMBOL_SYMTAB (sym_b->symbol)->filename);
+ c = FILENAME_CMP (symbol_symtab (sym_a->symbol)->filename,
+ symbol_symtab (sym_b->symbol)->filename);
if (c != 0)
return c;
b = BLOCKVECTOR_BLOCK (bv, i);
ALL_BLOCK_SYMBOLS (b, iter, sym)
{
- struct symtab *real_symtab = SYMBOL_SYMTAB (sym);
+ struct symtab *real_symtab = symbol_symtab (sym);
QUIT;
struct symbol *sym,
int block, const char *last)
{
- struct symtab *s = SYMBOL_SYMTAB (sym);
+ struct symtab *s = symbol_symtab (sym);
const char *s_filename = symtab_to_filename_for_display (s);
if (last == NULL || filename_cmp (last, s_filename) != 0)
p->block,
last_filename);
last_filename
- = symtab_to_filename_for_display (SYMBOL_SYMTAB (p->symbol));
+ = symtab_to_filename_for_display (symbol_symtab (p->symbol));
}
}
{
if (p->msymbol.minsym == NULL)
{
- struct symtab *symtab = SYMBOL_SYMTAB (p->symbol);
+ struct symtab *symtab = symbol_symtab (p->symbol);
const char *fullname = symtab_to_fullname (symtab);
int newlen = (strlen (fullname)
return result;
}
+/* See symtab.h. */
+
+struct objfile *
+symbol_objfile (const struct symbol *symbol)
+{
+ return SYMTAB_OBJFILE (symbol->symtab);
+}
+
+/* See symtab.h. */
+
+struct gdbarch *
+symbol_arch (const struct symbol *symbol)
+{
+ return get_objfile_arch (symbol_objfile (symbol));
+}
+
+/* See symtab.h. */
+
+struct symtab *
+symbol_symtab (const struct symbol *symbol)
+{
+ return symbol->symtab;
+}
+
+/* See symtab.h. */
+
+void
+symbol_set_symtab (struct symbol *symbol, struct symtab *symtab)
+{
+ symbol->symtab = symtab;
+}
+
\f
void
(symbol)->is_cplus_template_function
#define SYMBOL_TYPE(symbol) (symbol)->type
#define SYMBOL_LINE(symbol) (symbol)->line
-#define SYMBOL_SYMTAB(symbol) (symbol)->symtab
#define SYMBOL_COMPUTED_OPS(symbol) (SYMBOL_IMPL (symbol).ops_computed)
#define SYMBOL_BLOCK_OPS(symbol) (SYMBOL_IMPL (symbol).ops_block)
#define SYMBOL_REGISTER_OPS(symbol) (SYMBOL_IMPL (symbol).ops_register)
#define SYMBOL_LOCATION_BATON(symbol) (symbol)->aux_value
-#define SYMBOL_OBJFILE(symbol) SYMTAB_OBJFILE (SYMBOL_SYMTAB (symbol))
extern int register_symbol_computed_impl (enum address_class,
const struct symbol_computed_ops *);
extern int register_symbol_register_impl (enum address_class,
const struct symbol_register_ops *);
+/* Return the OBJFILE of SYMBOL.
+ It is an error to call this if symbol.is_objfile_owned is false, which
+ only happens for architecture-provided types. */
+
+extern struct objfile *symbol_objfile (const struct symbol *symbol);
+
+/* Return the ARCH of SYMBOL. */
+
+extern struct gdbarch *symbol_arch (const struct symbol *symbol);
+
+/* Return the SYMTAB of SYMBOL.
+ It is an error to call this if symbol.is_objfile_owned is false, which
+ only happens for architecture-provided types. */
+
+extern struct symtab *symbol_symtab (const struct symbol *symbol);
+
+/* Set the symtab of SYMBOL to SYMTAB.
+ It is an error to call this if symbol.is_objfile_owned is false, which
+ only happens for architecture-provided types. */
+
+extern void symbol_set_symtab (struct symbol *symbol, struct symtab *symtab);
+
/* An instance of this type is used to represent a C++ template
function. It includes a "struct symbol" as a kind of base class;
users downcast to "struct template_symbol *" when needed. A symbol
if (symname == NULL || *symname == '\0')
continue; /* Probably botched, certainly useless. */
- gdbarch = get_objfile_arch (SYMBOL_OBJFILE (sym));
+ gdbarch = symbol_arch (sym);
printf_filtered ("Symbol %s is ", symname);
}
if (objf_p)
- *objf_p = SYMBOL_OBJFILE (sym);
+ *objf_p = symbol_objfile (sym);
return value_of_variable (sym, NULL);
}
projects / binutils-gdb.git / commitdiff