+2002-12-20 David Carlton <carlton@math.stanford.edu>
+
+ * symtab.c (lookup_symbol_aux_minsyms): Don't call
+ lookup_symbol_aux from within this.
+ * values.c (value_static_field): lookup_symbol_linkage.
+ (value_fn_field): lookup_symbol_linkage.
+ * valops.c (value_struct_elt_for_reference): lookup_symbol_linkage.
+ * blockframe.c (inside_main_func): lookup_symbol_linkage.
+ * source.c (select_source_symtab): lookup_symbol_linkage.
+ * nlmread.c (nlm_symfile_read): Call lookup_symbol_linkage.
+ * nindy-tdep.c (nindy_frame_chain_valid): Call
+ lookup_symbol_linkage.
+ * linespec.c (count_methods): Call lookup_symbol_linkage.
+ (add_matching_methods): Ditto.
+ (add_constructors): Ditto.
+ * hppa-tdep.c (find_stub_with_shl_get): Call
+ lookup_symbol_linkage. Delete symbol2.
+ (initialize_hp_cxx_exception_support): Call lookup_symbol_linkage.
+ * cli/cli-cmds.c (edit_command): SYMBOL_PRINT_NAME.
+ (list_command): SYMBOL_PRINT_NAME.
+ * valops.c (value_of_variable): SYMBOL_PRINT_NAME
+ (hand_function_call): SYMBOL_PRINT_NAME.
+ * typeprint.c (typedef_print): SYMBOL_PRINT_NAME.
+ * tracepoint.c (tracepoints_info): SYMBOL_PRINT_NAME.
+ * symtab.c (lookup_partial_symbol): SYMBOL_BEST_NAME.
+ (compare_search_syms): SYMBOL_BEST_NAME.
+ (print_symbol_info): SYMBOL_PRINT_NAME.
+ (print_msymbol_info): SYMBOL_PRINT_NAME.
+ (rbreak_command): SYMBOL_PRINT_NAME.
+ * symmisc.c (print_symbol): SYMBOL_PRINT_NAME.
+ * stack.c (print_frame): SYMBOL_PRINT_NAME.
+ (frame_info): SYMBOL_PRINT_NAME.
+ (print_block_frame_locals): SYMBOL_PRINT_NAME.
+ (print_block_frame_labels): SYMBOL_PRINT_NAME.
+ (print_frame_arg_vars): SYMBOL_PRINT_NAME.
+ (return_command): SYMBOL_PRINT_NAME.
+ * stabsread.c (define_symbol): SYMBOL_PRINT_NAME.
+ * p-valprint.c (pascal_val_print): SYMBOL_PRINT_NAME.
+ * printcmd.c (build_address_symbolic): SYMBOL_PRINT_NAME.
+ (sym_info): SYMBOL_PRINT_NAME.
+ (print_frame_args): SYMBOL_PRINT_NAME.
+ * objc-lang.c (compare_selectors): SYMBOL_BEST_NAME.
+ (compare_classes): SYMBOL_BEST_NAME.
+ * maint.c (maintenance_translate_address): SYMBOL_PRINT_NAME.
+ * linespec.c (find_method): SYMBOL_PRINT_NAME.
+ (select_symbols): SYMBOL_PRINT_NAME.
+ * infcmd.c (jump_command): SYMBOL_PRINT_NAME.
+ * findvar.c (locate_var_value): SYMBOL_PRINT_NAME.
+ * expprint.c (print_subexp): SYMBOL_PRINT_NAME.
+ * c-valprint.c (c_val_print): SYMBOL_PRINT_NAME.
+ * buildsym.c (finish_block): SYMBOL_PRINT_NAME.
+ * breakpoint.c (print_one_breakpoint): SYMBOL_PRINT_NAME.
+ * ax-gdb.c (gen_var_ref): SYMBOL_PRINT_NAME.
+ * ada-typeprint.c (ada_typedef_print): SYMBOL_PRINT_NAME.
+ * ada-lang.c (user_select_syms): Use SYMBOL_PRINT_NAME instead of
+ SYMBOL_SOURCE_NAME.
+ (user_select_syms):
+ (ada_finish_decode_line_1): Use SYMBOL_BEST_NAME instead of
+ SYMBOL_SOURCE_NAME.
+ * symtab.h (SYMBOL_PRINT_NAME): Rename from SYMBOL_SOURCE_NAME.
+ * symfile.c (compare_symbols): Use SYMBOL_BEST_NAME, not
+ SYMBOL_SOURCE_NAME.
+ (compare_psymbols): Ditto.
+ * symtab.c (lookup_symbol_linkage): New function.
+ * symtab.h: Declare lookup_symbol_linkage.
+ * c-valprint.c (c_val_print): Call lookup_symbol_minsym.
+ * symtab.c (lookup_symbol_aux_minsyms): Call minsym_static.
+ * minsyms.c (minsym_static): New function.
+ * symtab.h: Declare minsym_static.
+ * symtab.c (lookup_symbol_minsym): New function.
+ (search_symbols): Call lookup_symbol_minsym instead of
+ lookup_symbol.
+ (lookup_symbol_namespace): Don't take apart NAME.
+ * symtab.h: Declare lookup_symbol_minsym.
+ * printcmd.c (build_address_symbolic): Don't use old version of
+ SYMBOL_LINKAGE_NAME.
+ * symtab.c (lookup_block_symbol): Change mangled names to linkage
+ name, and use SYMBOL_LINKAGE_NAME as appropriate.
+ * symtab.h (SYMBOL_LINKAGE_NAME): New macro, with a different
+ meaning from the old macro of the same name. Also, add comments
+ about proper uses of names.
+
2002-12-18 David Carlton <carlton@math.stanford.edu>
* symtab.c (lookup_symbol_aux_file): Call
struct symtab_and_line sal = find_function_start_sal (syms[i], 1);
printf_unfiltered ("[%d] %s at %s:%d\n",
i + first_choice,
- SYMBOL_SOURCE_NAME (syms[i]),
+ SYMBOL_PRINT_NAME (syms[i]),
sal.symtab == NULL
? "<no source file available>"
: sal.symtab->filename, sal.line);
if (SYMBOL_LINE (syms[i]) != 0 && symtab != NULL)
printf_unfiltered ("[%d] %s at %s:%d\n",
i + first_choice,
- SYMBOL_SOURCE_NAME (syms[i]),
+ SYMBOL_PRINT_NAME (syms[i]),
symtab->filename, SYMBOL_LINE (syms[i]));
else if (is_enumeral && TYPE_NAME (SYMBOL_TYPE (syms[i])) != NULL)
{
printf_unfiltered ("[%d] ", i + first_choice);
ada_print_type (SYMBOL_TYPE (syms[i]), NULL, gdb_stdout, -1, 0);
printf_unfiltered ("'(%s) (enumeral)\n",
- SYMBOL_SOURCE_NAME (syms[i]));
+ SYMBOL_PRINT_NAME (syms[i]));
}
else if (symtab != NULL)
printf_unfiltered (is_enumeral
? "[%d] %s in %s (enumeral)\n"
: "[%d] %s at %s:?\n",
i + first_choice,
- SYMBOL_SOURCE_NAME (syms[i]),
+ SYMBOL_PRINT_NAME (syms[i]),
symtab->filename);
else
printf_unfiltered (is_enumeral
? "[%d] %s (enumeral)\n"
: "[%d] %s at ?\n",
i + first_choice,
- SYMBOL_SOURCE_NAME (syms[i]));
+ SYMBOL_PRINT_NAME (syms[i]));
}
}
for (i = 0; i < selected.nelts; i += 1)
(*canonical)[i] =
extended_canonical_line_spec (selected.sals[i],
- SYMBOL_SOURCE_NAME (symbols[i]));
+ SYMBOL_BEST_NAME (symbols[i]));
}
discard_cleanups (old_chain);
struct ui_file *stream)
{
fprintf_filtered (stream, "type %.*s is ",
- ada_name_prefix_len (SYMBOL_SOURCE_NAME (new)),
- SYMBOL_SOURCE_NAME (new));
+ ada_name_prefix_len (SYMBOL_PRINT_NAME (new)),
+ SYMBOL_PRINT_NAME (new));
type_print (type, "", stream, 1);
}
symbol reading. */
sym = NULL;
else
+
sym = lookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_NAMESPACE,
0, NULL);
}
case LOC_TYPEDEF:
error ("Cannot compute value of typedef `%s'.",
- SYMBOL_SOURCE_NAME (var));
+ SYMBOL_PRINT_NAME (var));
break;
case LOC_BLOCK:
struct minimal_symbol *msym
= lookup_minimal_symbol (SYMBOL_NAME (var), NULL, NULL);
if (!msym)
- error ("Couldn't resolve symbol `%s'.", SYMBOL_SOURCE_NAME (var));
+ error ("Couldn't resolve symbol `%s'.", SYMBOL_PRINT_NAME (var));
/* Push the address of the variable. */
ax_const_l (ax, SYMBOL_VALUE_ADDRESS (msym));
case LOC_OPTIMIZED_OUT:
error ("The variable `%s' has been optimized out.",
- SYMBOL_SOURCE_NAME (var));
+ SYMBOL_PRINT_NAME (var));
break;
default:
error ("Cannot find value of botched symbol `%s'.",
- SYMBOL_SOURCE_NAME (var));
+ SYMBOL_PRINT_NAME (var));
break;
}
}
{
struct symbol *mainsym;
- mainsym = lookup_symbol (main_name (), NULL, VAR_NAMESPACE, NULL, NULL);
+ mainsym = lookup_symbol_linkage (main_name ());
if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK)
{
symfile_objfile->ei.main_func_lowpc =
{
ui_out_text (uiout, "in ");
ui_out_field_string (uiout, "func",
- SYMBOL_SOURCE_NAME (sym));
+ SYMBOL_PRINT_NAME (sym));
ui_out_wrap_hint (uiout, wrap_indent);
ui_out_text (uiout, " at ");
}
{
if (symbol)
{
- complain (&block_end_complaint, SYMBOL_SOURCE_NAME (symbol));
+ complain (&block_end_complaint, SYMBOL_PRINT_NAME (symbol));
}
else
{
if (symbol)
{
complain (&innerblock_complaint,
- SYMBOL_SOURCE_NAME (symbol));
+ SYMBOL_PRINT_NAME (symbol));
}
else
{
(vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
{
fputs_filtered (" <", stream);
- fputs_filtered (SYMBOL_SOURCE_NAME (msymbol), stream);
+ fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
fputs_filtered (">", stream);
}
if (vt_address && vtblprint)
struct value *vt_val;
struct symbol *wsym = (struct symbol *) NULL;
struct type *wtype;
- struct block *block = (struct block *) NULL;
- int is_this_fld;
if (msymbol != NULL)
- wsym = lookup_symbol (SYMBOL_NAME (msymbol), block,
- VAR_NAMESPACE, &is_this_fld, NULL);
+ wsym = lookup_symbol_minsym (msymbol);
if (wsym)
{
{
print_address_numeric (sal.pc, 1, gdb_stdout);
printf_filtered (" is in ");
- fputs_filtered (SYMBOL_SOURCE_NAME (sym), gdb_stdout);
+ fputs_filtered (SYMBOL_PRINT_NAME (sym), gdb_stdout);
printf_filtered (" (%s:%d).\n", sal.symtab->filename, sal.line);
}
else
{
print_address_numeric (sal.pc, 1, gdb_stdout);
printf_filtered (" is in ");
- fputs_filtered (SYMBOL_SOURCE_NAME (sym), gdb_stdout);
+ fputs_filtered (SYMBOL_PRINT_NAME (sym), gdb_stdout);
printf_filtered (" (%s:%d).\n", sal.symtab->filename, sal.line);
}
else
b = exp->elts[pc + 1].block;
if (b != NULL
&& BLOCK_FUNCTION (b) != NULL
- && SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)) != NULL)
+ && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)) != NULL)
{
- fputs_filtered (SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)), stream);
+ fputs_filtered (SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)), stream);
fputs_filtered ("::", stream);
}
- fputs_filtered (SYMBOL_SOURCE_NAME (exp->elts[pc + 2].symbol), stream);
+ fputs_filtered (SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol), stream);
}
return;
lazy_value = read_var_value (var, frame);
if (lazy_value == 0)
- error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
+ error ("Address of \"%s\" is unknown.", SYMBOL_PRINT_NAME (var));
if (VALUE_LAZY (lazy_value)
|| TYPE_CODE (type) == TYPE_CODE_FUNC)
&& *REGISTER_NAME (VALUE_REGNO (lazy_value)) != '\0');
error("Address requested for identifier "
"\"%s\" which is in register $%s",
- SYMBOL_SOURCE_NAME (var),
+ SYMBOL_PRINT_NAME (var),
REGISTER_NAME (VALUE_REGNO (lazy_value)));
break;
&& *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != '\0');
error("Address requested for identifier "
"\"%s\" which is in frame register $%s",
- SYMBOL_SOURCE_NAME (var),
+ SYMBOL_PRINT_NAME (var),
REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)));
break;
default:
error ("Can't take address of \"%s\" which isn't an lvalue.",
- SYMBOL_SOURCE_NAME (var));
+ SYMBOL_PRINT_NAME (var));
break;
}
return 0; /* For lint -- never reached */
CORE_ADDR
find_stub_with_shl_get (struct minimal_symbol *function, CORE_ADDR handle)
{
- struct symbol *get_sym, *symbol2;
+ struct symbol *get_sym;
struct minimal_symbol *buff_minsym, *msymbol;
struct type *ftype;
struct value **args;
args = alloca (sizeof (struct value *) * 8); /* 6 for the arguments and one null one??? */
funcval = find_function_in_inferior ("__d_shl_get");
- get_sym = lookup_symbol ("__d_shl_get", NULL, VAR_NAMESPACE, NULL, NULL);
+ get_sym = lookup_symbol_linkage ("__d_shl_get");
buff_minsym = lookup_minimal_symbol ("__buffer", NULL, NULL);
msymbol = lookup_minimal_symbol ("__shldp", NULL, NULL);
- symbol2 = lookup_symbol ("__shldp", NULL, VAR_NAMESPACE, NULL, NULL);
endo_buff_addr = SYMBOL_VALUE_ADDRESS (buff_minsym);
namelen = strlen (SYMBOL_NAME (function));
value_return_addr = endo_buff_addr + namelen;
}
/* Next look for the catch enable flag provided in end.o */
- sym = lookup_symbol (HP_ACC_EH_catch_catch, (struct block *) NULL,
- VAR_NAMESPACE, 0, (struct symtab **) NULL);
+ sym = lookup_symbol_linkage (HP_ACC_EH_catch_catch);
if (sym) /* sometimes present in debug info */
{
eh_catch_catch_addr = SYMBOL_VALUE_ADDRESS (sym);
}
/* Next look for the catch enable flag provided end.o */
- sym = lookup_symbol (HP_ACC_EH_catch_catch, (struct block *) NULL,
- VAR_NAMESPACE, 0, (struct symtab **) NULL);
+ sym = lookup_symbol (HP_ACC_EH_catch_catch);
if (sym) /* sometimes present in debug info */
{
eh_catch_throw_addr = SYMBOL_VALUE_ADDRESS (sym);
if (fn != NULL && sfn != fn)
{
if (!query ("Line %d is not in `%s'. Jump anyway? ", sal.line,
- SYMBOL_SOURCE_NAME (fn)))
+ SYMBOL_PRINT_NAME (fn)))
{
error ("Not confirmed.");
/* NOTREACHED */
if (tmp[0] == '~')
cplusplus_error (saved_arg,
"the class `%s' does not have destructor defined\n",
- SYMBOL_SOURCE_NAME (class_sym));
+ SYMBOL_PRINT_NAME (class_sym));
else
cplusplus_error (saved_arg,
"the class %s does not have any method named %s\n",
- SYMBOL_SOURCE_NAME (class_sym), tmp);
+ SYMBOL_PRINT_NAME (class_sym), tmp);
}
return values;
struct fn_field *f = TYPE_FN_FIELDLIST1 (class_type, m_index);
sym_arr[count] =
- lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, f_index),
- NULL, VAR_NAMESPACE, NULL, NULL);
+ lookup_symbol_linkage (TYPE_FN_FIELD_PHYSNAME (f, f_index));
if (sym_arr[count])
count++;
}
if (is_destructor_name (phys_name) != 0)
continue;
- sym_arr[count] = lookup_symbol (phys_name, NULL, VAR_NAMESPACE,
- NULL, NULL);
+ sym_arr[count] = lookup_symbol_linkage (phys_name);
if (sym_arr[count])
count++;
else
/* If this method is actually defined, include it in the
list. */
- sym_arr[count] = lookup_symbol (phys_name, NULL, VAR_NAMESPACE,
- NULL, NULL);
+ sym_arr[count] = lookup_symbol_linkage (phys_name);
if (sym_arr[count])
count++;
}
values.sals[i] = find_function_start_sal (sym_arr[i], funfirstline);
printf_unfiltered ("[%d] %s at %s:%d\n",
(i + 2),
- SYMBOL_SOURCE_NAME (sym_arr[i]),
+ SYMBOL_PRINT_NAME (sym_arr[i]),
values.sals[i].symtab->filename,
values.sals[i].line);
}
if (sym)
printf_filtered ("%s+%s\n",
- SYMBOL_SOURCE_NAME (sym),
+ SYMBOL_PRINT_NAME (sym),
paddr_u (address - SYMBOL_VALUE_ADDRESS (sym)));
else if (sect)
printf_filtered ("no symbol at %s:0x%s\n", sect->name, paddr (address));
/* We have to handle the following cases here:
a) The Mips library has a sigtramp label within sigvec.
b) Irix has a _sigtramp which we want to use, but it also has sigvec. */
- s = lookup_symbol ("sigvec", 0, VAR_NAMESPACE, 0, NULL);
+ s = lookup_symbol_linkage ("sigvec");
if (s != 0)
{
b0 = SYMBOL_BLOCK_VALUE (s);
- s = lookup_symbol ("sigtramp", b0, VAR_NAMESPACE, 0, NULL);
+ s = lookup_symbol_linkage ("sigtramp");
}
if (s == 0)
{
/* No sigvec or no sigtramp inside sigvec, try _sigtramp. */
- s = lookup_symbol ("_sigtramp", 0, VAR_NAMESPACE, 0, NULL);
+ s = lookup_symbol_linkage ("_sigtramp");
}
/* But maybe this program uses its own version of sigvec */
}
return 0;
}
+
+/* Test whether or not MINSYM corresponnds to a static symbol (i.e. is
+ file-local) or not. */
+int
+minsym_static (const struct minimal_symbol *minsym)
+{
+ switch (MSYMBOL_TYPE (minsym))
+ {
+ case mst_file_text:
+ case mst_file_data:
+ case mst_file_bss:
+ return 1;
+ default:
+ return 0;
+ }
+}
return 0;
}
- sym = lookup_symbol (sf, 0, VAR_NAMESPACE, (int *) NULL,
- (struct symtab **) NULL);
+ sym = lookup_symbol_linkage (sf);
if (sym != 0)
{
a = SYMBOL_VALUE (sym);
stabsect_build_psymtabs (objfile, mainline, ".stab",
".stabstr", ".text");
- mainsym = lookup_symbol (main_name (), NULL, VAR_NAMESPACE, NULL, NULL);
+ mainsym = lookup_symbol_linkage (main_name ());
if (mainsym
&& SYMBOL_CLASS (mainsym) == LOC_BLOCK)
{
char *aname, *bname;
- aname = SYMBOL_SOURCE_NAME (*(struct symbol **) a);
- bname = SYMBOL_SOURCE_NAME (*(struct symbol **) b);
+ aname = SYMBOL_BEST_NAME (*(struct symbol **) a);
+ bname = SYMBOL_BEST_NAME (*(struct symbol **) b);
if (aname == NULL || bname == NULL)
error ("internal: compare_selectors(1)");
{
char *aname, *bname;
- aname = SYMBOL_SOURCE_NAME (*(struct symbol **) a);
- bname = SYMBOL_SOURCE_NAME (*(struct symbol **) b);
+ aname = SYMBOL_BEST_NAME (*(struct symbol **) a);
+ bname = SYMBOL_BEST_NAME (*(struct symbol **) b);
if (aname == NULL || bname == NULL)
error ("internal: compare_classes(1)");
&& (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
{
fputs_filtered (" <", stream);
- fputs_filtered (SYMBOL_SOURCE_NAME (msymbol), stream);
+ fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
fputs_filtered (">", stream);
}
if (vt_address && vtblprint)
/* This code is not enabled on non HP-UX systems, since worst case
symbol table lookup performance is awful, to put it mildly. */
- sym = lookup_symbol (copy_name (str), (struct block *) NULL,
- VAR_NAMESPACE, (int *) NULL, (struct symtab **) NULL);
+ sym = lookup_symbol_linkage (copy_name (str));
if (sym)
{
write_exp_elt_opcode (OP_VAR_VALUE);
if (symbol)
{
name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
- if (do_demangle)
- name_temp = SYMBOL_SOURCE_NAME (symbol);
+ if (do_demangle || asm_demangle)
+ name_temp = SYMBOL_PRINT_NAME (symbol);
else
name_temp = SYMBOL_LINKAGE_NAME (symbol);
}
symbol = 0;
symtab = 0;
name_location = SYMBOL_VALUE_ADDRESS (msymbol);
- if (do_demangle)
- name_temp = SYMBOL_SOURCE_NAME (msymbol);
+ if (do_demangle || asm_demangle)
+ name_temp = SYMBOL_PRINT_NAME (msymbol);
else
name_temp = SYMBOL_LINKAGE_NAME (msymbol);
}
offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol);
if (offset)
printf_filtered ("%s + %u in ",
- SYMBOL_SOURCE_NAME (msymbol), offset);
+ SYMBOL_PRINT_NAME (msymbol), offset);
else
printf_filtered ("%s in ",
- SYMBOL_SOURCE_NAME (msymbol));
+ SYMBOL_PRINT_NAME (msymbol));
if (pc_in_unmapped_range (addr, sect))
printf_filtered ("load address range of ");
if (section_is_overlay (sect))
annotate_arg_begin ();
list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
- fprintf_symbol_filtered (stb->stream, SYMBOL_SOURCE_NAME (sym),
+ fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (sym),
SYMBOL_LANGUAGE (sym), DMGL_PARAMS | DMGL_ANSI);
ui_out_field_stream (uiout, "name", stb);
annotate_arg_name_end ();
/* Make the default place to list be the function `main'
if one exists. */
- if (lookup_symbol (main_name (), 0, VAR_NAMESPACE, 0, NULL))
+ if (lookup_symbol_linkage (main_name ()))
{
sals = decode_line_spec (main_name (), 1);
sal = sals.sals[0];
{
complain (®_value_complaint, SYMBOL_VALUE (sym),
NUM_REGS + NUM_PSEUDO_REGS,
- SYMBOL_SOURCE_NAME (sym));
+ SYMBOL_PRINT_NAME (sym));
SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */
}
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
{
complain (®_value_complaint, SYMBOL_VALUE (sym),
NUM_REGS + NUM_PSEUDO_REGS,
- SYMBOL_SOURCE_NAME (sym));
+ SYMBOL_PRINT_NAME (sym));
SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */
}
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
{
complain (®_value_complaint, SYMBOL_VALUE (sym),
NUM_REGS + NUM_PSEUDO_REGS,
- SYMBOL_SOURCE_NAME (sym));
+ SYMBOL_PRINT_NAME (sym));
SYMBOL_VALUE (sym) = SP_REGNUM; /* Known safe, though useless */
}
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
}
else
{
- /* I'd like to use SYMBOL_SOURCE_NAME() here, to display the
+ /* I'd like to use SYMBOL_PRINT_NAME() here, to display the
demangled name that we already have stored in the symbol
table, but we stored a version with DMGL_PARAMS turned
on, and here we don't want to display parameters. So call
/* If the demangler fails, try the demangled name from
the symbol table. This'll have parameters, but
that's preferable to diplaying a mangled name. */
- funname = SYMBOL_SOURCE_NAME (func);
+ funname = SYMBOL_PRINT_NAME (func);
}
}
}
s = find_pc_symtab (fi->pc);
if (func)
{
- /* I'd like to use SYMBOL_SOURCE_NAME() here, to display
+ /* I'd like to use SYMBOL_PRINT_NAME() here, to display
* the demangled name that we already have stored in
* the symbol table, but we stored a version with
* DMGL_PARAMS turned on, and here we don't want
* but that's preferable to diplaying a mangled name.
*/
if (demangled == NULL)
- funname = SYMBOL_SOURCE_NAME (func);
+ funname = SYMBOL_PRINT_NAME (func);
}
}
else
values_printed = 1;
for (j = 0; j < num_tabs; j++)
fputs_filtered ("\t", stream);
- fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream);
+ fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
fputs_filtered (" = ", stream);
print_variable_value (sym, fi, stream);
fprintf_filtered (stream, "\n");
struct symtab_and_line sal;
sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
values_printed = 1;
- fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream);
+ fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
if (addressprint)
{
fprintf_filtered (stream, " ");
case LOC_REGPARM_ADDR:
case LOC_BASEREG_ARG:
values_printed = 1;
- fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream);
+ fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
fputs_filtered (" = ", stream);
/* We have to look up the symbol because arguments can have
{
if (thisfun != 0)
{
- if (!query ("Make %s return now? ", SYMBOL_SOURCE_NAME (thisfun)))
+ if (!query ("Make %s return now? ", SYMBOL_PRINT_NAME (thisfun)))
{
error ("Not confirmed.");
/* NOTREACHED */
s1 = (struct symbol **) s1p;
s2 = (struct symbol **) s2p;
- return (strcmp (SYMBOL_SOURCE_NAME (*s1), SYMBOL_SOURCE_NAME (*s2)));
+ return (strcmp (SYMBOL_BEST_NAME (*s1), SYMBOL_BEST_NAME (*s2)));
}
/*
s1 = (struct partial_symbol **) s1p;
s2 = (struct partial_symbol **) s2p;
- st1 = SYMBOL_SOURCE_NAME (*s1);
- st2 = SYMBOL_SOURCE_NAME (*s2);
+ st1 = SYMBOL_BEST_NAME (*s1);
+ st2 = SYMBOL_BEST_NAME (*s2);
if ((st1[0] - st2[0]) || !st1[0])
print_spaces (depth, outfile);
if (SYMBOL_NAMESPACE (symbol) == LABEL_NAMESPACE)
{
- fprintf_filtered (outfile, "label %s at ", SYMBOL_SOURCE_NAME (symbol));
+ fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
if (SYMBOL_BFD_SECTION (symbol))
fprintf_filtered (outfile, " section %s\n",
if (SYMBOL_TYPE (symbol))
{
/* Print details of types, except for enums where it's clutter. */
- LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_SOURCE_NAME (symbol),
+ LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
outfile,
TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
depth);
fprintf_filtered (outfile, "; ");
}
else
- fprintf_filtered (outfile, "%s ", SYMBOL_SOURCE_NAME (symbol));
+ fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
switch (SYMBOL_CLASS (symbol))
{
/* This tries to look up NAME in the namespace given by the initial
substring of NAMESPACE_NAME of length NAMESPACE_LEN. It applies
- the using directives that are active in BLOCK.
-
- For example, assume that we have using directives adding A to the
- global namespace, adding A::inner to namespace A, and adding B to
- the global namespace. Then, when looking up a symbol "foo", we
- want to recurse by looking up stuff in A::foo and seeing which
- using directives still apply. The only one that still applies
- converts that to A::inner::foo: we _don't_ want to then look at
- B::A::foo (let alone A::A::foo!). So we end up just looking at
- A::foo, A::inner::foo, and B::foo. (Though if the original caller
- to lookup_symbol had specified A::foo, we would want to look up
- stuff in A::A::foo, A::inner::A::foo, A::inner::foo, and
- B::A::foo). */
+ the using directives that are active in BLOCK. It doesn't look
+ into NAME at all, so if NAME happens to contain some namespaces, it
+ won't apply using directives to those namespaces. */
/* FIXME: carlton/2002-11-27: Currently, there's no way to specify
that additional using directives are active. When we get around to
const struct using_direct *current;
struct symbol *sym;
+ /* First, go through the using directives. If any of them add new
+ names to the namespace we're searching in, see if we can find a
+ match by applying them. */
+
for (current = block_using_iterator_first (block, &iter);
current != NULL;
current = block_using_iterator_next (&iter))
{
- /* First, see if the namespace matches the start of this using
- directive. */
- if (namespace_len <= current->outer_length
+ if (namespace_len == current->outer_length
&& strncmp (namespace_name, current->name, namespace_len) == 0)
{
- /* Great, it matches: now does the rest of the using
- directive match the rest of the name? */
-
- const char *rest_of_outer = current->name + namespace_len;
- int rest_of_outer_len
- = current->outer_length - namespace_len;
- /* Should we skip some colons? Should be true unless
- NAMESPACE_LEN is zero (and hence we're in the global
- namespace) or we've finished all of outer. */
- if (rest_of_outer_len != 0 && *rest_of_outer == ':')
- {
- rest_of_outer += 2;
- rest_of_outer_len -= 2;
- }
- if (strncmp (rest_of_outer, name, rest_of_outer_len) == 0)
- {
- /* Everything matches! Yippee! So apply the using
- directive and recurse. */
- const char *new_name = name + rest_of_outer_len;
- if (*new_name == ':')
- new_name += 2;
-
- sym = lookup_symbol_namespace (current->name,
- current->inner_length,
- new_name,
- mangled_name,
- block,
- name_space,
- symtab);
- if (sym != NULL)
- return sym;
- }
+ sym = lookup_symbol_namespace (current->name,
+ current->inner_length,
+ name,
+ mangled_name,
+ block,
+ name_space,
+ symtab);
+ if (sym != NULL)
+ return sym;
}
}
/* We didn't find anything by applying any of the using directives
that are still applicable; so let's see if we've got a match
- using the current name. */
+ using the current namespace. */
if (namespace_len == 0)
{
}
}
-/* Check for the possibility of the symbol being a function or a
- mangled variable that is stored in one of the minimal symbol
- tables. Eventually, all global symbols might be resolved in this
- way. */
+/* Check for the possibility of the symbol being a function that is
+ stored in one of the minimal symbol tables. */
static struct symbol *
lookup_symbol_aux_minsyms (int block_index, const char *name,
that's okay: this is only called with block_index equal
to STATIC_BLOCK if a global search has failed. */
- switch (MSYMBOL_TYPE (msymbol))
+ if (minsym_static (msymbol))
{
- case mst_file_text:
- case mst_file_data:
- case mst_file_bss:
if (block_index == GLOBAL_BLOCK)
return NULL;
- default:
+ }
+ else
+ {
if (block_index == STATIC_BLOCK)
return NULL;
}
sym =
lookup_block_symbol (block, name, mangled_name, namespace);
- /* FIXME: carlton/2002-10-28: this next comment dates
- from when this code was part of lookup_symbol_aux, so
- this return could return NULL from lookup_symbol_aux.
- Are there really situations where we want a minimal
- symbol lookup to be able to force a NULL return from
- lookup_symbol? If so, maybe the thing to do would be
- to have lookup_symbol_aux_minsym to set a
- minsym_found flag, and to have lookup_symbol_aux only
- do the psymtab search if that flag is zero. */
-
/* sym == 0 if symbol was found in the minimal symbol table
but not in the symtab.
Return 0 to use the msymbol definition of "foo_".
*symtab = s;
return fixup_symbol_section (sym, s->objfile);
}
- else if (MSYMBOL_TYPE (msymbol) != mst_text
- && MSYMBOL_TYPE (msymbol) != mst_file_text
- && strcmp (name, SYMBOL_NAME (msymbol)) != 0)
- {
- /* This is a mangled variable, look it up by its
- mangled name. */
- return lookup_symbol_aux_nonlocal (block_index,
- SYMBOL_NAME (msymbol),
- mangled_name,
- namespace,
- symtab);
- }
}
}
return NULL;
}
+/* Lookup the symbol associated to a minimal symbol, if there is one. */
+
+/* FIXME: carlton/2002-12-20: This is now implemented in a way that
+ doesn't work very well and that may, in fact return the wrong
+ symbol. For now, we're in a transition period where I want to
+ replace some calls to lookup_symbol by calls to
+ lookup_symbol_minsym, so it's okay for lookup_symbol_minsym to get
+ the answer wrong in circumstances where lookup_symbol would have
+ screwed it up, too; later, I'll fix lookup_symbol_minsym to get it
+ right as quickly and easily as possible. */
+
+struct symbol *
+lookup_symbol_minsym (const struct minimal_symbol *minsym)
+{
+ int block_index = minsym_static (minsym) ? STATIC_BLOCK : GLOBAL_BLOCK;
+
+ return lookup_symbol_aux_nonlocal (block_index,
+ SYMBOL_BEST_NAME (minsym),
+ SYMBOL_LINKAGE_NAME (minsym),
+ VAR_NAMESPACE,
+ NULL);
+}
+
+/* Lookup the symbol with a given linkage name. */
+
+struct symbol *
+lookup_symbol_linkage (const char *linkage_name)
+{
+ const char *name;
+ char *demangled_name = NULL;
+ struct symbol *sym;
+
+ name = linkage_name;
+
+ /* If we are using C++, then the linkage name might be a mangled C++
+ name; lookup_symbol_aux_nonlocal expects the name to be
+ demangled. */
+
+ if (current_language->la_language == language_cplus)
+ {
+ demangled_name = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
+ if (demangled_name != NULL)
+ {
+ name = demangled_name;
+ }
+ }
+
+ sym = lookup_symbol_aux_nonlocal (GLOBAL_BLOCK, name, linkage_name,
+ VAR_NAMESPACE, NULL);
+
+ if (sym != NULL)
+ {
+ xfree (demangled_name);
+ return sym;
+ }
+
+ sym = lookup_symbol_aux_nonlocal (STATIC_BLOCK, name, linkage_name,
+ VAR_NAMESPACE, NULL);
+
+ xfree (demangled_name);
+ return sym;
+}
+
+
/* Look up a type named NESTED_NAME that is nested inside the C++
class or namespace given by PARENT_TYPE, from within the context
given by BLOCK. */
{
do_linear_search = 1;
}
- if (strcmp (SYMBOL_SOURCE_NAME (*center), name) >= 0)
+ if (strcmp (SYMBOL_BEST_NAME (*center), name) >= 0)
{
top = center;
}
symbol (language_cplus set) has both the encoded and non-encoded names
tested for a match.
- If MANGLED_NAME is non-NULL, verify that any symbol we find has this
- particular mangled name.
+ If LINKAGE_NAME is non-NULL, verify that any symbol we find has
+ this particular linkage name.
*/
/* FIXME: carlton/2002-09-26: I've slightly changed the semantics: I
struct symbol *
lookup_block_symbol (register const struct block *block, const char *name,
- const char *mangled_name, const namespace_enum namespace)
+ const char *linkage_name, const namespace_enum namespace)
{
struct dict_iterator iter;
struct symbol *sym;
sym; sym = dict_iter_name_next (name, &iter))
{
if (SYMBOL_NAMESPACE (sym) == namespace
- && (mangled_name
- ? strcmp (SYMBOL_NAME (sym), mangled_name) == 0 : 1))
+ && (linkage_name
+ ? strcmp (SYMBOL_LINKAGE_NAME (sym), linkage_name) == 0 : 1))
return sym;
}
return NULL;
sym; sym = dict_iter_name_next (name, &iter))
{
if (SYMBOL_NAMESPACE (sym) == namespace
- && (mangled_name
- ? strcmp (SYMBOL_NAME (sym), mangled_name) == 0 : 1))
+ && (linkage_name
+ ? strcmp (SYMBOL_LINKAGE_NAME (sym), linkage_name) == 0 : 1))
{
/* If SYM has aliases, then use any alias that is active
at the current PC. If no alias is active at the current
struct symbol_search **sym_a = (struct symbol_search **) sa;
struct symbol_search **sym_b = (struct symbol_search **) sb;
- return strcmp (SYMBOL_SOURCE_NAME ((*sym_a)->symbol),
- SYMBOL_SOURCE_NAME ((*sym_b)->symbol));
+ return strcmp (SYMBOL_BEST_NAME ((*sym_a)->symbol),
+ SYMBOL_BEST_NAME ((*sym_b)->symbol));
}
/* Sort the ``nfound'' symbols in the list after prevtail. Leave
The symbol will then be found during the scan of symtabs below.
For functions, find_pc_symtab should succeed if we have debug info
- for the function, for variables we have to call lookup_symbol
+ for the function, for variables we have to call lookup_symbol_minsym
to determine if the variable has debug info.
If the lookup fails, set found_misc so that we will rescan to print
any matching symbols without debug info.
if (0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol)))
{
if (kind == FUNCTIONS_NAMESPACE
- || lookup_symbol (SYMBOL_NAME (msymbol),
- (struct block *) NULL,
- VAR_NAMESPACE,
- 0, (struct symtab **) NULL) == NULL)
+ || lookup_symbol_minsym (msymbol) == NULL)
found_misc = 1;
}
}
(0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol))))
{
/* Variables/Absolutes: Look up by name */
- if (lookup_symbol (SYMBOL_NAME (msymbol),
- (struct block *) NULL, VAR_NAMESPACE,
- 0, (struct symtab **) NULL) == NULL)
+ if (lookup_symbol_minsym (msymbol) == NULL)
{
/* match */
psr =
{
type_print (SYMBOL_TYPE (sym),
(SYMBOL_CLASS (sym) == LOC_TYPEDEF
- ? "" : SYMBOL_SOURCE_NAME (sym)), gdb_stdout, 0);
+ ? "" : SYMBOL_PRINT_NAME (sym)), gdb_stdout, 0);
printf_filtered (";\n");
}
& (CORE_ADDR) 0xffffffff, "08l");
else
tmp = local_hex_string_custom (SYMBOL_VALUE_ADDRESS (msymbol), "016l");
- printf_filtered ("%s %s\n", tmp, SYMBOL_SOURCE_NAME (msymbol));
+ printf_filtered ("%s %s\n", tmp, SYMBOL_PRINT_NAME (msymbol));
}
/* This is the guts of the commands "info functions", "info types", and
{
break_command (SYMBOL_NAME (p->msymbol), from_tty);
printf_filtered ("<function, no debug info> %s;\n",
- SYMBOL_SOURCE_NAME (p->msymbol));
+ SYMBOL_PRINT_NAME (p->msymbol));
}
}
functions, unless the callers are changed to pass in the ginfo
field only, instead of the SYMBOL parameter. */
-#define SYMBOL_NAME(symbol) (symbol)->ginfo.name
#define SYMBOL_VALUE(symbol) (symbol)->ginfo.value.ivalue
#define SYMBOL_VALUE_ADDRESS(symbol) (symbol)->ginfo.value.address
#define SYMBOL_VALUE_BYTES(symbol) (symbol)->ginfo.value.bytes
#define SYMBOL_SECTION(symbol) (symbol)->ginfo.section
#define SYMBOL_BFD_SECTION(symbol) (symbol)->ginfo.bfd_section
+/* FIXME: carlton/2002-12-20: The situation with all of these names is
+ a mess. As a first step, try to avoid using SYMBOL_NAME to access
+ the name of a symbol: use SYMBOL_BEST_NAME or SYMBOL_LINKAGE_NAME
+ instead, depending on which one you want. I'll try to add some
+ initialization functions later, too. */
+
+#define SYMBOL_NAME(symbol) (symbol)->ginfo.name
+
#define SYMBOL_CPLUS_DEMANGLED_NAME(symbol) \
(symbol)->ginfo.language_specific.cplus_specific.demangled_name
*symbol);
/* Macro that returns the demangled name of the symbol if if possible
- and the symbol name if not possible. This is like
- SYMBOL_SOURCE_NAME except that it doesn't depend on the value of
- 'demangle' (and is hence more suitable for internal usage). The
- result should never be NULL. */
-
-/* FIXME: carlton/2002-09-26: Probably the situation with this and
- SYMBOL_SOURCE_NAME should be rethought. */
+ and the symbol name if not possible. The result should never be
+ NULL. */
#define SYMBOL_BEST_NAME(symbol) \
(SYMBOL_DEMANGLED_NAME (symbol) != NULL \
? SYMBOL_DEMANGLED_NAME (symbol) \
: SYMBOL_NAME (symbol))
+/* Use this if you want to get at the linkage name of a symbol (which
+ might be mangled). */
+
+#define SYMBOL_LINKAGE_NAME(symbol) SYMBOL_NAME (symbol)
+
/* OBSOLETE #define SYMBOL_CHILL_DEMANGLED_NAME(symbol) */
/* OBSOLETE (symbol)->ginfo.language_specific.chill_specific.demangled_name */
#define SYMBOL_OBJC_DEMANGLED_NAME(symbol) \
(symbol)->ginfo.language_specific.objc_specific.demangled_name
-/* Macro that returns the "natural source name" of a symbol. In C++ this is
- the "demangled" form of the name if demangle is on and the "mangled" form
- of the name if demangle is off. In other languages this is just the
- symbol name. The result should never be NULL. */
+/* Macro that returns the name of a name of a symbol that we want to
+ print. In C++ this is the "demangled" form of the name if demangle
+ is on and the "mangled" form of the name if demangle is off. In
+ other languages this is just the symbol name. The result should
+ never be NULL. */
/* NOTE: carlton/2002-09-26: For external use only; in many
situations, SYMBOL_BEST_NAME is more appropriate. */
-#define SYMBOL_SOURCE_NAME(symbol) \
- (demangle ? SYMBOL_BEST_NAME (symbol) : SYMBOL_NAME (symbol))
-
-/* Macro that returns the "natural assembly name" of a symbol. In C++ this is
- the "mangled" form of the name if demangle is off, or if demangle is on and
- asm_demangle is off. Otherwise if asm_demangle is on it is the "demangled"
- form. In other languages this is just the symbol name. The result should
- never be NULL. */
-
-#define SYMBOL_LINKAGE_NAME(symbol) \
- (demangle && asm_demangle ? SYMBOL_BEST_NAME (symbol) \
- : SYMBOL_NAME (symbol))
+#define SYMBOL_PRINT_NAME(symbol) \
+ (demangle ? SYMBOL_BEST_NAME (symbol) : SYMBOL_LINKAGE_NAME (symbol))
/* Macro that tests a symbol for a match against a specified name string.
First test the unencoded name, then looks for and test a C++ encoded
namespace_enum name_space,
struct symtab **symtab);
+/* Lookup the symbol associated to a minimal symbol. */
+
+extern struct symbol *lookup_symbol_minsym (const struct minimal_symbol
+ *minsym);
+
+/* Lookup the symbol with a given linkage name. */
+
+extern struct symbol *lookup_symbol_linkage (const char *linkage_name);
+
/* Lookup a type within a class or a namespace. */
extern struct type *lookup_nested_type (struct type *parent_type,
extern void msymbols_sort (struct objfile *objfile);
+int minsym_static (const struct minimal_symbol *minsym);
+
struct symtab_and_line
{
struct symtab *symtab;
+2002-12-20 David Carlton <carlton@math.stanford.edu>
+
+ * gdb.c++/namespace.exp: Delete tests that try to apply using
+ directives to quoted namespaces.
+
2002-12-17 David Carlton <carlton@math.stanford.edu>
* gdb.c++/m-data.cc: Whitespace cleanup, to match mainline patch.
gdb_test "print cX" "\\$\[0-9\].* = 6"
gdb_test "print 'F::cXf'" "\\$\[0-9\].* = 7"
gdb_test "print F::cXf" "\\$\[0-9\].* = 7"
-gdb_test "print 'F::cXfX'" "\\$\[0-9\].* = 8"
gdb_test "print F::cXfX" "\\$\[0-9\].* = 8"
gdb_test "print X" "\\$\[0-9\].* = 9"
gdb_test "print 'G::Xg'" "\\$\[0-9\].* = 10"
gdb_test "print G::Xg" "\\$\[0-9\].* = 10"
-gdb_test "print 'G::XgX'" "\\$\[0-9\].* = 11"
gdb_test "print G::XgX" "\\$\[0-9\].* = 11"
# Test namespace renaming.
if (sym)
{
fputs_filtered ("in ", gdb_stdout);
- fputs_filtered (SYMBOL_SOURCE_NAME (sym), gdb_stdout);
+ fputs_filtered (SYMBOL_PRINT_NAME (sym), gdb_stdout);
wrap_here (wrap_indent);
fputs_filtered (" at ", gdb_stdout);
}
type_print (type, "", stream, 0);
if (TYPE_NAME ((SYMBOL_TYPE (new))) == 0
|| !STREQ (TYPE_NAME ((SYMBOL_TYPE (new))), SYMBOL_NAME (new)))
- fprintf_filtered (stream, " %s", SYMBOL_SOURCE_NAME (new));
+ fprintf_filtered (stream, " %s", SYMBOL_PRINT_NAME (new));
break;
#endif
#ifdef _LANG_m2
fprintf_filtered (stream, "TYPE ");
if (!TYPE_NAME (SYMBOL_TYPE (new)) ||
!STREQ (TYPE_NAME (SYMBOL_TYPE (new)), SYMBOL_NAME (new)))
- fprintf_filtered (stream, "%s = ", SYMBOL_SOURCE_NAME (new));
+ fprintf_filtered (stream, "%s = ", SYMBOL_PRINT_NAME (new));
else
fprintf_filtered (stream, "<builtin> = ");
type_print (type, "", stream, 0);
#ifdef _LANG_pascal
case language_pascal:
fprintf_filtered (stream, "type ");
- fprintf_filtered (stream, "%s = ", SYMBOL_SOURCE_NAME (new));
+ fprintf_filtered (stream, "%s = ", SYMBOL_PRINT_NAME (new));
type_print (type, "", stream, 0);
break;
#endif
/* OBSOLETE fprintf_filtered (stream, "SYNMODE "); */
/* OBSOLETE if (!TYPE_NAME (SYMBOL_TYPE (new)) || */
/* OBSOLETE !STREQ (TYPE_NAME (SYMBOL_TYPE (new)), SYMBOL_NAME (new))) */
- /* OBSOLETE fprintf_filtered (stream, "%s = ", SYMBOL_SOURCE_NAME (new)); */
+ /* OBSOLETE fprintf_filtered (stream, "%s = ", SYMBOL_PRINT_NAME (new)); */
/* OBSOLETE else */
/* OBSOLETE fprintf_filtered (stream, "<builtin> = "); */
/* OBSOLETE type_print (type, "", stream, 0); */
if (!frame)
{
if (BLOCK_FUNCTION (b)
- && SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)))
+ && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)))
error ("No frame is currently executing in block %s.",
- SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)));
+ SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)));
else
error ("No frame is currently executing in specified block");
}
val = read_var_value (var, frame);
if (!val)
- error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
+ error ("Address of symbol \"%s\" is unknown.", SYMBOL_PRINT_NAME (var));
return val;
}
symbol = find_pc_function (funaddr);
if (symbol)
{
- name = SYMBOL_SOURCE_NAME (symbol);
+ name = SYMBOL_PRINT_NAME (symbol);
}
else
{
if (msymbol)
{
- name = SYMBOL_SOURCE_NAME (msymbol);
+ name = SYMBOL_PRINT_NAME (msymbol);
}
}
if (name == NULL)
}
else
{
- struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
- 0, VAR_NAMESPACE, 0, NULL);
+ struct symbol *s
+ = lookup_symbol_linkage (TYPE_FN_FIELD_PHYSNAME (f, j));
if (s == NULL)
{
v = 0;
else
{
char *phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
- struct symbol *sym = lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL);
+ struct symbol *sym = lookup_symbol_linkage (phys_name);
if (sym == NULL)
{
/* With some compilers, e.g. HP aCC, static data members are reported
struct symbol *sym;
struct minimal_symbol *msym;
- sym = lookup_symbol (physname, 0, VAR_NAMESPACE, 0, NULL);
+ sym = lookup_symbol_linkage (physname);
if (sym != NULL)
{
msym = NULL;
projects / thirdparty / binutils-gdb.git / commitdiff
