OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* minsyms.h (struct bound_minimal_symbol): New. 

(lookup_minimal_symbol_and_objfile): Return bound_minimal_symbol.
	Remove objfile argument.
	(lookup_minimal_symbol_by_pc_section, lookup_minimal_symbol_by_pc):
	Return bound_minimal_symbol.
	* minsyms.c (lookup_minimal_symbol_by_pc_1)
	(lookup_minimal_symbol_by_pc_section, lookup_minimal_symbol_by_pc):
	Return bound_minimal_symbol.
	(in_gnu_ifunc_stub): Update.
	(lookup_minimal_symbol_and_objfile): Return bound_minimal_symbol.
	Remove 'objfile_p' argument.
	(lookup_solib_trampoline_symbol_by_pc): Update.
	* ada-tasks.c, amd64-windows-tdep.c, arm-tdep.c,
	arm-wince-tdep.c, block.c, blockframe.c, breakpoint.c, btrace.c,
	c-valprint.c, dwarf2loc.c, elfread.c, frame.c, frv-tdep.c,
	glibc-tdep.c, gnu-v2-abi.c, gnu-v3-abi.c, hppa-hpux-tdep.c,
	i386-tdep.c, ia64-tdep.c, infcall.c, infcmd.c, jit.c,
	linux-fork.c, m32c-tdep.c, m68hc11-tdep.c, maint.c,
	mips-tdep.c, p-valprint.c, parse.c, ppc-linux-tdep.c,
	ppc-sysv-tdep.c, printcmd.c, rs6000-tdep.c, sh64-tdep.c,
	stack.c, symtab.c, tui/tui-disasm.c: Update.
This commit is contained in:
Tom Tromey 2013-04-08 19:59:09 +00:00
parent f85f34ede8
commit 7cbd4a934e
41 changed files with 344 additions and 258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
gdb/ChangeLog
View File

@ -1,3 +1,27 @@
2013-04-08 Tom Tromey <tromey@redhat.com>
* minsyms.h (struct bound_minimal_symbol): New.
(lookup_minimal_symbol_and_objfile): Return bound_minimal_symbol.
Remove objfile argument.
(lookup_minimal_symbol_by_pc_section, lookup_minimal_symbol_by_pc):
Return bound_minimal_symbol.
* minsyms.c (lookup_minimal_symbol_by_pc_1)
(lookup_minimal_symbol_by_pc_section, lookup_minimal_symbol_by_pc):
Return bound_minimal_symbol.
(in_gnu_ifunc_stub): Update.
(lookup_minimal_symbol_and_objfile): Return bound_minimal_symbol.
Remove 'objfile_p' argument.
(lookup_solib_trampoline_symbol_by_pc): Update.
* ada-tasks.c, amd64-windows-tdep.c, arm-tdep.c,
arm-wince-tdep.c, block.c, blockframe.c, breakpoint.c, btrace.c,
c-valprint.c, dwarf2loc.c, elfread.c, frame.c, frv-tdep.c,
glibc-tdep.c, gnu-v2-abi.c, gnu-v3-abi.c, hppa-hpux-tdep.c,
i386-tdep.c, ia64-tdep.c, infcall.c, infcmd.c, jit.c,
linux-fork.c, m32c-tdep.c, m68hc11-tdep.c, maint.c,
mips-tdep.c, p-valprint.c, parse.c, ppc-linux-tdep.c,
ppc-sysv-tdep.c, printcmd.c, rs6000-tdep.c, sh64-tdep.c,
stack.c, symtab.c, tui/tui-disasm.c: Update.
2013-04-08 Tom Tromey <tromey@redhat.com>
* ada-lang.c (ada_decode_symbol): Check and set 'ada_mangled'.

6
gdb/ada-tasks.c
View File

@ -635,12 +635,12 @@ read_atcb (CORE_ADDR task_id, struct ada_task_info *task_info)
sizeof (task_info->name) - 1);
else
{
struct minimal_symbol *msym;
struct bound_minimal_symbol msym;
msym = lookup_minimal_symbol_by_pc (task_id);
if (msym)
if (msym.minsym)
{
const char *full_name = SYMBOL_LINKAGE_NAME (msym);
const char *full_name = SYMBOL_LINKAGE_NAME (msym.minsym);
const char *task_name = full_name;
const char *p;

12
gdb/amd64-windows-tdep.c
View File

@ -140,14 +140,14 @@ amd64_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
if (target_read_memory (pc + 1, buf, sizeof buf) == 0)
{
struct minimal_symbol *s;
struct bound_minimal_symbol s;
CORE_ADDR call_dest;
call_dest = pc + 5 + extract_signed_integer (buf, 4, byte_order);
s = lookup_minimal_symbol_by_pc (call_dest);
if (s != NULL
&& SYMBOL_LINKAGE_NAME (s) != NULL
&& strcmp (SYMBOL_LINKAGE_NAME (s), "__main") == 0)
if (s.minsym != NULL
&& SYMBOL_LINKAGE_NAME (s.minsym) != NULL
&& strcmp (SYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
pc += 5;
}
}
@ -175,7 +175,9 @@ amd64_windows_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
CORE_ADDR indirect_addr = pc + offset + 6;
struct minimal_symbol *indsym
= indirect_addr ? lookup_minimal_symbol_by_pc (indirect_addr) : NULL;
= (indirect_addr
? lookup_minimal_symbol_by_pc (indirect_addr).minsym
: NULL);
const char *symname = indsym ? SYMBOL_LINKAGE_NAME (indsym) : NULL;
if (symname)

23
gdb/arm-tdep.c
View File

@ -381,7 +381,7 @@ arm_find_mapping_symbol (CORE_ADDR memaddr, CORE_ADDR *start)
int
arm_pc_is_thumb (struct gdbarch *gdbarch, CORE_ADDR memaddr)
{
struct minimal_symbol *sym;
struct bound_minimal_symbol sym;
char type;
struct displaced_step_closure* dsc
= get_displaced_step_closure_by_addr(memaddr);
@ -423,8 +423,8 @@ arm_pc_is_thumb (struct gdbarch *gdbarch, CORE_ADDR memaddr)
/* Thumb functions have a "special" bit set in minimal symbols. */
sym = lookup_minimal_symbol_by_pc (memaddr);
if (sym)
return (MSYMBOL_IS_SPECIAL (sym));
if (sym.minsym)
return (MSYMBOL_IS_SPECIAL (sym.minsym));
/* If the user wants to override the fallback mode, let them. */
if (strcmp (arm_fallback_mode_string, "arm") == 0)
@ -468,14 +468,14 @@ static int
skip_prologue_function (struct gdbarch *gdbarch, CORE_ADDR pc, int is_thumb)
{
enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
struct minimal_symbol *msym;
struct bound_minimal_symbol msym;
msym = lookup_minimal_symbol_by_pc (pc);
if (msym != NULL
&& SYMBOL_VALUE_ADDRESS (msym) == pc
&& SYMBOL_LINKAGE_NAME (msym) != NULL)
if (msym.minsym != NULL
&& SYMBOL_VALUE_ADDRESS (msym.minsym) == pc
&& SYMBOL_LINKAGE_NAME (msym.minsym) != NULL)
{
const char *name = SYMBOL_LINKAGE_NAME (msym);
const char *name = SYMBOL_LINKAGE_NAME (msym.minsym);
/* The GNU linker's Thumb call stub to foo is named
__foo_from_thumb. */
@ -1284,7 +1284,7 @@ arm_skip_stack_protector(CORE_ADDR pc, struct gdbarch *gdbarch)
{
enum bfd_endian byte_order_for_code = gdbarch_byte_order_for_code (gdbarch);
unsigned int basereg;
struct minimal_symbol *stack_chk_guard;
struct bound_minimal_symbol stack_chk_guard;
int offset;
int is_thumb = arm_pc_is_thumb (gdbarch, pc);
CORE_ADDR addr;
@ -1299,8 +1299,9 @@ arm_skip_stack_protector(CORE_ADDR pc, struct gdbarch *gdbarch)
/* If name of symbol doesn't start with '__stack_chk_guard', this
instruction sequence is not for stack protector. If symbol is
removed, we conservatively think this sequence is for stack protector. */
if (stack_chk_guard
&& strncmp (SYMBOL_LINKAGE_NAME (stack_chk_guard), "__stack_chk_guard",
if (stack_chk_guard.minsym
&& strncmp (SYMBOL_LINKAGE_NAME (stack_chk_guard.minsym),
"__stack_chk_guard",
strlen ("__stack_chk_guard")) != 0)
return pc;

14
gdb/arm-wince-tdep.c
View File

@ -43,7 +43,7 @@ arm_pe_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
struct gdbarch *gdbarch = get_frame_arch (frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
ULONGEST indirect;
struct minimal_symbol *indsym;
struct bound_minimal_symbol indsym;
const char *symname;
CORE_ADDR next_pc;
@ -62,10 +62,10 @@ arm_pe_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
return 0;
indsym = lookup_minimal_symbol_by_pc (indirect);
if (indsym == NULL)
if (indsym.minsym == NULL)
return 0;
symname = SYMBOL_LINKAGE_NAME (indsym);
symname = SYMBOL_LINKAGE_NAME (indsym.minsym);
if (symname == NULL || strncmp (symname, "__imp_", 6) != 0)
return 0;
@ -100,11 +100,11 @@ arm_wince_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
long offset = sign_extend (this_instr & 0x000fffff, 23) << 2;
CORE_ADDR call_dest = (pc + 8 + offset) & 0xffffffffU;
struct minimal_symbol *s = lookup_minimal_symbol_by_pc (call_dest);
struct bound_minimal_symbol s = lookup_minimal_symbol_by_pc (call_dest);
if (s != NULL
&& SYMBOL_LINKAGE_NAME (s) != NULL
&& strcmp (SYMBOL_LINKAGE_NAME (s), "__gccmain") == 0)
if (s.minsym != NULL
&& SYMBOL_LINKAGE_NAME (s.minsym) != NULL
&& strcmp (SYMBOL_LINKAGE_NAME (s.minsym), "__gccmain") == 0)
pc += 4;
}

5
gdb/block.c
View File

@ -208,7 +208,7 @@ call_site_for_pc (struct gdbarch *gdbarch, CORE_ADDR pc)
if (slot == NULL)
{
struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (pc);
struct bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (pc);
/* DW_TAG_gnu_call_site will be missing just if GCC could not determine
the call target. */
@ -216,7 +216,8 @@ call_site_for_pc (struct gdbarch *gdbarch, CORE_ADDR pc)
_("DW_OP_GNU_entry_value resolving cannot find "
"DW_TAG_GNU_call_site %s in %s"),
paddress (gdbarch, pc),
msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
(msym.minsym == NULL ? "???"
: SYMBOL_PRINT_NAME (msym.minsym)));
}
return *slot;

8
gdb/blockframe.c
View File

@ -88,7 +88,7 @@ CORE_ADDR
get_pc_function_start (CORE_ADDR pc)
{
struct block *bl;
struct minimal_symbol *msymbol;
struct bound_minimal_symbol msymbol;
bl = block_for_pc (pc);
if (bl)
@ -103,9 +103,9 @@ get_pc_function_start (CORE_ADDR pc)
}
msymbol = lookup_minimal_symbol_by_pc (pc);
if (msymbol)
if (msymbol.minsym)
{
CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol);
CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol.minsym);
if (find_pc_section (fstart))
return fstart;
@ -218,7 +218,7 @@ find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, const char **name,
&& section == cache_pc_function_section)
goto return_cached_value;
msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section).minsym;
ALL_OBJFILES (objfile)
{
if (objfile->sf)

6
gdb/breakpoint.c
View File

@ -9823,14 +9823,14 @@ resolve_sal_pc (struct symtab_and_line *sal)
if we have line numbers but no functions (as can
happen in assembly source). */
struct minimal_symbol *msym;
struct bound_minimal_symbol msym;
struct cleanup *old_chain = save_current_space_and_thread ();
switch_to_program_space_and_thread (sal->pspace);
msym = lookup_minimal_symbol_by_pc (sal->pc);
if (msym)
sal->section = SYMBOL_OBJ_SECTION (msym);
if (msym.minsym)
sal->section = SYMBOL_OBJ_SECTION (msym.minsym);
do_cleanups (old_chain);
}

8
gdb/btrace.c
View File

@ -272,7 +272,7 @@ compute_ftrace (VEC (btrace_inst_s) *itrace)
for (idx = 0; VEC_iterate (btrace_inst_s, itrace, idx, binst); ++idx)
{
struct symtab_and_line sal;
struct minimal_symbol *mfun;
struct bound_minimal_symbol mfun;
struct symbol *fun;
const char *filename;
CORE_ADDR pc;
@ -285,7 +285,7 @@ compute_ftrace (VEC (btrace_inst_s) *itrace)
fun = find_pc_function (pc);
mfun = lookup_minimal_symbol_by_pc (pc);
if (fun == NULL && mfun == NULL)
if (fun == NULL && mfun.minsym == NULL)
{
DEBUG_FTRACE ("no symbol at %u, pc=%s", idx,
core_addr_to_string_nz (pc));
@ -293,11 +293,11 @@ compute_ftrace (VEC (btrace_inst_s) *itrace)
}
/* If we're switching functions, we start over. */
if (ftrace_function_switched (bfun, mfun, fun))
if (ftrace_function_switched (bfun, mfun.minsym, fun))
{
bfun = VEC_safe_push (btrace_func_s, ftrace, NULL);
ftrace_init_func (bfun, mfun, fun, idx);
ftrace_init_func (bfun, mfun.minsym, fun, idx);
ftrace_debug (bfun, "init");
}

14
gdb/c-valprint.c
View File

@ -310,18 +310,18 @@ c_val_print (struct type *type, const gdb_byte *valaddr,
CORE_ADDR vt_address = unpack_pointer (type,
valaddr
+ embedded_offset);
struct minimal_symbol *msymbol =
lookup_minimal_symbol_by_pc (vt_address);
struct bound_minimal_symbol msymbol =
lookup_minimal_symbol_by_pc (vt_address);
/* If 'symbol_print' is set, we did the work above. */
if (!options->symbol_print
&& (msymbol != NULL)
&& (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
&& (msymbol.minsym != NULL)
&& (vt_address == SYMBOL_VALUE_ADDRESS (msymbol.minsym)))
{
if (want_space)
fputs_filtered (" ", stream);
fputs_filtered (" <", stream);
fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
fputs_filtered (SYMBOL_PRINT_NAME (msymbol.minsym), stream);
fputs_filtered (">", stream);
want_space = 1;
}
@ -337,8 +337,8 @@ c_val_print (struct type *type, const gdb_byte *valaddr,
if (want_space)
fputs_filtered (" ", stream);
if (msymbol != NULL)
wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol),
if (msymbol.minsym != NULL)
wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol.minsym),
block, VAR_DOMAIN,
&is_this_fld);

17
gdb/coff-pe-read.c
View File

@ -202,8 +202,7 @@ add_pe_forwarded_sym (const char *sym_name, const char *forward_dll_name,
const char *dll_name, struct objfile *objfile)
{
CORE_ADDR vma;
struct objfile *forward_objfile;
struct minimal_symbol *msymbol;
struct bound_minimal_symbol msymbol;
enum minimal_symbol_type msymtype;
char *qualified_name, *bare_name;
int forward_dll_name_len = strlen (forward_dll_name);
@ -215,20 +214,18 @@ add_pe_forwarded_sym (const char *sym_name, const char *forward_dll_name,
forward_func_name);
msymbol = lookup_minimal_symbol_and_objfile (forward_qualified_name,
&forward_objfile);
msymbol = lookup_minimal_symbol_and_objfile (forward_qualified_name);
if (!msymbol)
if (!msymbol.minsym)
{
int i;
for (i = 0; i < forward_dll_name_len; i++)
forward_qualified_name[i] = tolower (forward_qualified_name[i]);
msymbol = lookup_minimal_symbol_and_objfile (forward_qualified_name,
&forward_objfile);
msymbol = lookup_minimal_symbol_and_objfile (forward_qualified_name);
}
if (!msymbol)
if (!msymbol.minsym)
{
if (debug_coff_pe_read)
fprintf_unfiltered (gdb_stdlog, _("Unable to find function \"%s\" in"
@ -243,8 +240,8 @@ add_pe_forwarded_sym (const char *sym_name, const char *forward_dll_name,
" \"%s\" in dll \"%s\", pointing to \"%s\"\n"),
sym_name, dll_name, forward_qualified_name);
vma = SYMBOL_VALUE_ADDRESS (msymbol);
msymtype = MSYMBOL_TYPE (msymbol);
vma = SYMBOL_VALUE_ADDRESS (msymbol.minsym);
msymtype = MSYMBOL_TYPE (msymbol.minsym);
/* Generate a (hopefully unique) qualified name using the first part
of the dll name, e.g. KERNEL32!AddAtomA. This matches the style

51
gdb/dwarf2loc.c
View File

@ -527,19 +527,20 @@ call_site_to_target_addr (struct gdbarch *call_site_gdbarch,
dwarf_block = FIELD_DWARF_BLOCK (call_site->target);
if (dwarf_block == NULL)
{
struct minimal_symbol *msym;
struct bound_minimal_symbol msym;
msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
throw_error (NO_ENTRY_VALUE_ERROR,
_("DW_AT_GNU_call_site_target is not specified "
"at %s in %s"),
paddress (call_site_gdbarch, call_site->pc),
msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
(msym.minsym == NULL ? "???"
: SYMBOL_PRINT_NAME (msym.minsym)));
}
if (caller_frame == NULL)
{
struct minimal_symbol *msym;
struct bound_minimal_symbol msym;
msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
throw_error (NO_ENTRY_VALUE_ERROR,
@ -547,7 +548,8 @@ call_site_to_target_addr (struct gdbarch *call_site_gdbarch,
"requires known frame which is currently not "
"available at %s in %s"),
paddress (call_site_gdbarch, call_site->pc),
msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
(msym.minsym == NULL ? "???"
: SYMBOL_PRINT_NAME (msym.minsym)));
}
caller_arch = get_frame_arch (caller_frame);
@ -574,7 +576,7 @@ call_site_to_target_addr (struct gdbarch *call_site_gdbarch,
msym = lookup_minimal_symbol (physname, NULL, NULL);
if (msym == NULL)
{
msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
msym = lookup_minimal_symbol_by_pc (call_site->pc - 1).minsym;
throw_error (NO_ENTRY_VALUE_ERROR,
_("Cannot find function \"%s\" for a call site target "
"at %s in %s"),
@ -670,14 +672,15 @@ func_verify_no_selftailcall (struct gdbarch *gdbarch, CORE_ADDR verify_addr)
if (target_addr == verify_addr)
{
struct minimal_symbol *msym;
struct bound_minimal_symbol msym;
msym = lookup_minimal_symbol_by_pc (verify_addr);
throw_error (NO_ENTRY_VALUE_ERROR,
_("DW_OP_GNU_entry_value resolving has found "
"function \"%s\" at %s can call itself via tail "
"calls"),
msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym),
(msym.minsym == NULL ? "???"
: SYMBOL_PRINT_NAME (msym.minsym)),
paddress (gdbarch, verify_addr));
}
@ -701,10 +704,11 @@ static void
tailcall_dump (struct gdbarch *gdbarch, const struct call_site *call_site)
{
CORE_ADDR addr = call_site->pc;
struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (addr - 1);
struct bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (addr - 1);
fprintf_unfiltered (gdb_stdlog, " %s(%s)", paddress (gdbarch, addr),
msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
(msym.minsym == NULL ? "???"
: SYMBOL_PRINT_NAME (msym.minsym)));
}
@ -934,7 +938,7 @@ call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
if (retval == NULL)
{
struct minimal_symbol *msym_caller, *msym_callee;
struct bound_minimal_symbol msym_caller, msym_callee;
msym_caller = lookup_minimal_symbol_by_pc (caller_pc);
msym_callee = lookup_minimal_symbol_by_pc (callee_pc);
@ -942,11 +946,11 @@ call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
_("There are no unambiguously determinable intermediate "
"callers or callees between caller function \"%s\" at %s "
"and callee function \"%s\" at %s"),
(msym_caller == NULL
? "???" : SYMBOL_PRINT_NAME (msym_caller)),
(msym_caller.minsym == NULL
? "???" : SYMBOL_PRINT_NAME (msym_caller.minsym)),
paddress (gdbarch, caller_pc),
(msym_callee == NULL
? "???" : SYMBOL_PRINT_NAME (msym_callee)),
(msym_callee.minsym == NULL
? "???" : SYMBOL_PRINT_NAME (msym_callee.minsym)),
paddress (gdbarch, callee_pc));
}
@ -1038,7 +1042,8 @@ dwarf_expr_reg_to_entry_parameter (struct frame_info *frame,
caller_frame = get_prev_frame (frame);
if (gdbarch != frame_unwind_arch (frame))
{
struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (func_addr);
struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (func_addr);
struct gdbarch *caller_gdbarch = frame_unwind_arch (frame);
throw_error (NO_ENTRY_VALUE_ERROR,
@ -1046,18 +1051,21 @@ dwarf_expr_reg_to_entry_parameter (struct frame_info *frame,
"(of %s (%s)) does not match caller gdbarch %s"),
gdbarch_bfd_arch_info (gdbarch)->printable_name,
paddress (gdbarch, func_addr),
msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym),
(msym.minsym == NULL ? "???"
: SYMBOL_PRINT_NAME (msym.minsym)),
gdbarch_bfd_arch_info (caller_gdbarch)->printable_name);
}
if (caller_frame == NULL)
{
struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (func_addr);
struct bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (func_addr);
throw_error (NO_ENTRY_VALUE_ERROR, _("DW_OP_GNU_entry_value resolving "
"requires caller of %s (%s)"),
paddress (gdbarch, func_addr),
msym == NULL ? "???" : SYMBOL_PRINT_NAME (msym));
(msym.minsym == NULL ? "???"
: SYMBOL_PRINT_NAME (msym.minsym)));
}
caller_pc = get_frame_pc (caller_frame);
call_site = call_site_for_pc (gdbarch, caller_pc);
@ -1067,8 +1075,8 @@ dwarf_expr_reg_to_entry_parameter (struct frame_info *frame,
{
struct minimal_symbol *target_msym, *func_msym;
target_msym = lookup_minimal_symbol_by_pc (target_addr);
func_msym = lookup_minimal_symbol_by_pc (func_addr);
target_msym = lookup_minimal_symbol_by_pc (target_addr).minsym;
func_msym = lookup_minimal_symbol_by_pc (func_addr).minsym;
throw_error (NO_ENTRY_VALUE_ERROR,
_("DW_OP_GNU_entry_value resolving expects callee %s at %s "
"but the called frame is for %s at %s"),
@ -1091,7 +1099,8 @@ dwarf_expr_reg_to_entry_parameter (struct frame_info *frame,
}
if (iparams == call_site->parameter_count)
{
struct minimal_symbol *msym = lookup_minimal_symbol_by_pc (caller_pc);
struct minimal_symbol *msym
= lookup_minimal_symbol_by_pc (caller_pc).minsym;
/* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
determine its value. */

10
gdb/elfread.c
View File

@ -735,7 +735,7 @@ elf_gnu_ifunc_cache_eq (const void *a_voidp, const void *b_voidp)
static int
elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr)
{
struct minimal_symbol *msym;
struct bound_minimal_symbol msym;
asection *sect;
struct objfile *objfile;
htab_t htab;
@ -743,13 +743,13 @@ elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr)
void **slot;
msym = lookup_minimal_symbol_by_pc (addr);
if (msym == NULL)
if (msym.minsym == NULL)
return 0;
if (SYMBOL_VALUE_ADDRESS (msym) != addr)
if (SYMBOL_VALUE_ADDRESS (msym.minsym) != addr)
return 0;
/* minimal symbols have always SYMBOL_OBJ_SECTION non-NULL. */
sect = SYMBOL_OBJ_SECTION (msym)->the_bfd_section;
objfile = SYMBOL_OBJ_SECTION (msym)->objfile;
sect = SYMBOL_OBJ_SECTION (msym.minsym)->the_bfd_section;
objfile = SYMBOL_OBJ_SECTION (msym.minsym)->objfile;
/* If .plt jumps back to .plt the symbol is still deferred for later
resolution and it has no use for GDB. Besides ".text" this symbol can

2
gdb/frame.c
View File

@ -1678,7 +1678,7 @@ get_prev_frame_1 (struct frame_info *this_frame)
/* gcc -fsplit-stack __morestack can continue the stack anywhere. */
this_pc_in_block = get_frame_address_in_block (this_frame);
morestack_msym = lookup_minimal_symbol_by_pc (this_pc_in_block);
morestack_msym = lookup_minimal_symbol_by_pc (this_pc_in_block).minsym;
if (morestack_msym)
morestack_name = SYMBOL_LINKAGE_NAME (morestack_msym);
if (!morestack_name || strcmp (morestack_name, "__morestack") != 0)

8
gdb/frv-tdep.c
View File

@ -1072,7 +1072,7 @@ frv_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
{
LONGEST displ;
CORE_ADDR call_dest;
struct minimal_symbol *s;
struct bound_minimal_symbol s;
displ = ((op & 0xfe000000) >> 7) | (op & 0x0003ffff);
if ((displ & 0x00800000) != 0)
@ -1081,9 +1081,9 @@ frv_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
call_dest = pc + 4 * displ;
s = lookup_minimal_symbol_by_pc (call_dest);
if (s != NULL
&& SYMBOL_LINKAGE_NAME (s) != NULL
&& strcmp (SYMBOL_LINKAGE_NAME (s), "__main") == 0)
if (s.minsym != NULL
&& SYMBOL_LINKAGE_NAME (s.minsym) != NULL
&& strcmp (SYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
{
pc += 4;
return pc;

11
gdb/glibc-tdep.c
View File

@ -53,19 +53,18 @@ glibc_skip_solib_resolver (struct gdbarch *gdbarch, CORE_ADDR pc)
of GNU/Linux will provide a portable, efficient interface for
debugging programs that use shared libraries. */
struct objfile *objfile;
struct minimal_symbol *resolver
= lookup_minimal_symbol_and_objfile ("_dl_runtime_resolve", &objfile);
struct bound_minimal_symbol resolver
= lookup_minimal_symbol_and_objfile ("_dl_runtime_resolve");
if (resolver)
if (resolver.minsym)
{
/* The dynamic linker began using this name in early 2005. */
struct minimal_symbol *fixup
= lookup_minimal_symbol ("_dl_fixup", NULL, objfile);
= lookup_minimal_symbol ("_dl_fixup", NULL, resolver.objfile);
/* This is the name used in older versions. */
if (! fixup)
fixup = lookup_minimal_symbol ("fixup", NULL, objfile);
fixup = lookup_minimal_symbol ("fixup", NULL, resolver.objfile);
if (fixup && SYMBOL_VALUE_ADDRESS (fixup) == pc)
return frame_unwind_caller_pc (get_current_frame ());

6
gdb/gnu-v2-abi.c
View File

@ -191,7 +191,7 @@ gnuv2_value_rtti_type (struct value *v, int *full, int *top, int *using_enc)
struct type *known_type;
struct type *rtti_type;
CORE_ADDR vtbl;
struct minimal_symbol *minsym;
struct bound_minimal_symbol minsym;
char *demangled_name, *p;
const char *linkage_name;
struct type *btype;
@ -245,8 +245,8 @@ gnuv2_value_rtti_type (struct value *v, int *full, int *top, int *using_enc)
/* Try to find a symbol that is the vtable. */
minsym=lookup_minimal_symbol_by_pc(vtbl);
if (minsym==NULL
|| (linkage_name=SYMBOL_LINKAGE_NAME (minsym))==NULL
if (minsym.minsym==NULL
|| (linkage_name=SYMBOL_LINKAGE_NAME (minsym.minsym))==NULL
|| !is_vtable_name (linkage_name))
return NULL;

4
gdb/gnu-v3-abi.c
View File

@ -306,7 +306,7 @@ gnuv3_rtti_type (struct value *value,
/* Find the linker symbol for this vtable. */
vtable_symbol
= lookup_minimal_symbol_by_pc (value_address (vtable)
+ value_embedded_offset (vtable));
+ value_embedded_offset (vtable)).minsym;
if (! vtable_symbol)
return NULL;
@ -988,7 +988,7 @@ gnuv3_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
real_stop_pc = stop_pc;
/* Find the linker symbol for this potential thunk. */
thunk_sym = lookup_minimal_symbol_by_pc (real_stop_pc);
thunk_sym = lookup_minimal_symbol_by_pc (real_stop_pc).minsym;
section = find_pc_section (real_stop_pc);
if (thunk_sym == NULL || section == NULL)
return 0;

37
gdb/hppa-hpux-tdep.c
View File

@ -89,7 +89,7 @@ hppa32_hpux_in_solib_call_trampoline (struct gdbarch *gdbarch,
CORE_ADDR pc, char *name)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
struct minimal_symbol *minsym;
struct bound_minimal_symbol minsym;
struct unwind_table_entry *u;
/* First see if PC is in one of the two C-library trampolines. */
@ -98,7 +98,8 @@ hppa32_hpux_in_solib_call_trampoline (struct gdbarch *gdbarch,
return 1;
minsym = lookup_minimal_symbol_by_pc (pc);
if (minsym && strcmp (SYMBOL_LINKAGE_NAME (minsym), ".stub") == 0)
if (minsym.minsym
&& strcmp (SYMBOL_LINKAGE_NAME (minsym.minsym), ".stub") == 0)
return 1;
/* Get the unwind descriptor corresponding to PC, return zero
@ -174,16 +175,16 @@ hppa64_hpux_in_solib_call_trampoline (struct gdbarch *gdbarch,
step. If it does, then assume we are not in a stub and return.
Finally peek at the instructions to see if they look like a stub. */
struct minimal_symbol *minsym;
struct bound_minimal_symbol minsym;
asection *sec;
CORE_ADDR addr;
int insn;
minsym = lookup_minimal_symbol_by_pc (pc);
if (! minsym)
if (! minsym.minsym)
return 0;
sec = SYMBOL_OBJ_SECTION (minsym)->the_bfd_section;
sec = SYMBOL_OBJ_SECTION (minsym.minsym)->the_bfd_section;
if (bfd_get_section_vma (sec->owner, sec) <= pc
&& pc < (bfd_get_section_vma (sec->owner, sec)
@ -311,7 +312,7 @@ hppa_hpux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
int word_size = gdbarch_ptr_bit (gdbarch) / 8;
long orig_pc = pc;
long prev_inst, curr_inst, loc;
struct minimal_symbol *msym;
struct bound_minimal_symbol msym;
struct unwind_table_entry *u;
/* Addresses passed to dyncall may *NOT* be the actual address
@ -366,10 +367,12 @@ hppa_hpux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
/*--------------------------------------------------------------------------*/
msym = lookup_minimal_symbol_by_pc (pc);
if (msym == NULL || MSYMBOL_TYPE (msym) != mst_solib_trampoline)
if (msym.minsym == NULL
|| MSYMBOL_TYPE (msym.minsym) != mst_solib_trampoline)
return orig_pc == pc ? 0 : pc & ~0x3;
else if (msym != NULL && MSYMBOL_TYPE (msym) == mst_solib_trampoline)
else if (msym.minsym != NULL
&& MSYMBOL_TYPE (msym.minsym) == mst_solib_trampoline)
{
struct objfile *objfile;
struct minimal_symbol *msymbol;
@ -384,7 +387,7 @@ hppa_hpux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{
if (MSYMBOL_TYPE (msymbol) == mst_text
&& strcmp (SYMBOL_LINKAGE_NAME (msymbol),
SYMBOL_LINKAGE_NAME (msym)) == 0)
SYMBOL_LINKAGE_NAME (msym.minsym)) == 0)
{
function_found = 1;
break;
@ -401,7 +404,7 @@ hppa_hpux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
should be mst_text. So we need to fix the msym, and also
get out of this function. */
{
MSYMBOL_TYPE (msym) = mst_text;
MSYMBOL_TYPE (msym.minsym) = mst_text;
return orig_pc == pc ? 0 : pc & ~0x3;
}
}
@ -472,21 +475,22 @@ hppa_hpux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
(curr_inst == 0xeaa0d000) ||
(curr_inst == 0xeaa0d002))
{
struct minimal_symbol *stubsym, *libsym;
struct bound_minimal_symbol stubsym;
struct minimal_symbol *libsym;
stubsym = lookup_minimal_symbol_by_pc (loc);
if (stubsym == NULL)
if (stubsym.minsym == NULL)
{
warning (_("Unable to find symbol for 0x%lx"), loc);
return orig_pc == pc ? 0 : pc & ~0x3;
}
libsym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (stubsym),
libsym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (stubsym.minsym),
NULL, NULL);
if (libsym == NULL)
{
warning (_("Unable to find library symbol for %s."),
SYMBOL_PRINT_NAME (stubsym));
SYMBOL_PRINT_NAME (stubsym.minsym));
return orig_pc == pc ? 0 : pc & ~0x3;
}
@ -1025,7 +1029,8 @@ static CORE_ADDR
hppa_hpux_find_import_stub_for_addr (CORE_ADDR funcaddr)
{
struct objfile *objfile;
struct minimal_symbol *funsym, *stubsym;
struct bound_minimal_symbol funsym;
struct minimal_symbol *stubsym;
CORE_ADDR stubaddr;
funsym = lookup_minimal_symbol_by_pc (funcaddr);
@ -1034,7 +1039,7 @@ hppa_hpux_find_import_stub_for_addr (CORE_ADDR funcaddr)
ALL_OBJFILES (objfile)
{
stubsym = lookup_minimal_symbol_solib_trampoline
(SYMBOL_LINKAGE_NAME (funsym), objfile);
(SYMBOL_LINKAGE_NAME (funsym.minsym), objfile);
if (stubsym)
{

10
gdb/i386-tdep.c
View File

@ -1687,15 +1687,15 @@ i386_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
{
/* Make sure address is computed correctly as a 32bit
integer even if CORE_ADDR is 64 bit wide. */
struct minimal_symbol *s;
struct bound_minimal_symbol s;
CORE_ADDR call_dest;
call_dest = pc + 5 + extract_signed_integer (buf, 4, byte_order);
call_dest = call_dest & 0xffffffffU;
s = lookup_minimal_symbol_by_pc (call_dest);
if (s != NULL
&& SYMBOL_LINKAGE_NAME (s) != NULL
&& strcmp (SYMBOL_LINKAGE_NAME (s), "__main") == 0)
if (s.minsym != NULL
&& SYMBOL_LINKAGE_NAME (s.minsym) != NULL
&& strcmp (SYMBOL_LINKAGE_NAME (s.minsym), "__main") == 0)
pc += 5;
}
}
@ -3352,7 +3352,7 @@ i386_pe_skip_trampoline_code (struct frame_info *frame,
unsigned long indirect =
read_memory_unsigned_integer (pc + 2, 4, byte_order);
struct minimal_symbol *indsym =
indirect ? lookup_minimal_symbol_by_pc (indirect) : 0;
indirect ? lookup_minimal_symbol_by_pc (indirect).minsym : 0;
const char *symname = indsym ? SYMBOL_LINKAGE_NAME (indsym) : 0;
if (symname)

4
gdb/ia64-tdep.c
View File

@ -3651,11 +3651,11 @@ ia64_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
/* There are also descriptors embedded in vtables. */
if (s)
{
struct minimal_symbol *minsym;
struct bound_minimal_symbol minsym;
minsym = lookup_minimal_symbol_by_pc (addr);
if (minsym && is_vtable_name (SYMBOL_LINKAGE_NAME (minsym)))
if (minsym.minsym && is_vtable_name (SYMBOL_LINKAGE_NAME (minsym.minsym)))
return read_memory_unsigned_integer (addr, 8, byte_order);
}

6
gdb/infcall.c
View File

@ -355,10 +355,10 @@ get_function_name (CORE_ADDR funaddr, char *buf, int buf_size)
{
/* Try the minimal symbols. */
struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (funaddr);
if (msymbol)
return SYMBOL_PRINT_NAME (msymbol);
if (msymbol.minsym)
return SYMBOL_PRINT_NAME (msymbol.minsym);
}
{

6
gdb/infcmd.c
View File

@ -1332,12 +1332,12 @@ until_next_command (int from_tty)
if (!func)
{
struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (pc);
struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (pc);
if (msymbol == NULL)
if (msymbol.minsym == NULL)
error (_("Execution is not within a known function."));
tp->control.step_range_start = SYMBOL_VALUE_ADDRESS (msymbol);
tp->control.step_range_start = SYMBOL_VALUE_ADDRESS (msymbol.minsym);
tp->control.step_range_end = pc;
}
else

18
gdb/jit.c
View File

@ -1013,8 +1013,8 @@ static int
jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
struct jit_program_space_data *ps_data)
{
struct minimal_symbol *reg_symbol, *desc_symbol;
struct objfile *objf;
struct bound_minimal_symbol reg_symbol;
struct minimal_symbol *desc_symbol;
struct jit_objfile_data *objf_data;
CORE_ADDR addr;
@ -1022,19 +1022,21 @@ jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
{
/* Lookup the registration symbol. If it is missing, then we
assume we are not attached to a JIT. */
reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name, &objf);
if (reg_symbol == NULL || SYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name);
if (reg_symbol.minsym == NULL
|| SYMBOL_VALUE_ADDRESS (reg_symbol.minsym) == 0)
return 1;
desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL, objf);
desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL,
reg_symbol.objfile);
if (desc_symbol == NULL || SYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
return 1;
objf_data = get_jit_objfile_data (objf);
objf_data->register_code = reg_symbol;
objf_data = get_jit_objfile_data (reg_symbol.objfile);
objf_data->register_code = reg_symbol.minsym;
objf_data->descriptor = desc_symbol;
ps_data->objfile = objf;
ps_data->objfile = reg_symbol.objfile;
}
else
objf_data = get_jit_objfile_data (ps_data->objfile);

6
gdb/linux-fork.c
View File

@ -592,11 +592,11 @@ info_checkpoints_command (char *arg, int from_tty)
printf_filtered (_(", line %d"), sal.line);
if (!sal.symtab && !sal.line)
{
struct minimal_symbol *msym;
struct bound_minimal_symbol msym;
msym = lookup_minimal_symbol_by_pc (pc);
if (msym)
printf_filtered (", <%s>", SYMBOL_LINKAGE_NAME (msym));
if (msym.minsym)
printf_filtered (", <%s>", SYMBOL_LINKAGE_NAME (msym.minsym));
}
putchar_filtered ('\n');

15
gdb/m32c-tdep.c
View File

@ -2457,14 +2457,15 @@ m32c_m16c_address_to_pointer (struct gdbarch *gdbarch,
struct minimal_symbol *tramp_msym;
/* Try to find a linker symbol at this address. */
struct minimal_symbol *func_msym = lookup_minimal_symbol_by_pc (addr);
struct bound_minimal_symbol func_msym
= lookup_minimal_symbol_by_pc (addr);
if (! func_msym)
if (! func_msym.minsym)
error (_("Cannot convert code address %s to function pointer:\n"
"couldn't find a symbol at that address, to find trampoline."),
paddress (gdbarch, addr));
func_name = SYMBOL_LINKAGE_NAME (func_msym);
func_name = SYMBOL_LINKAGE_NAME (func_msym.minsym);
tramp_name = xmalloc (strlen (func_name) + 5);
strcpy (tramp_name, func_name);
strcat (tramp_name, ".plt");
@ -2535,11 +2536,11 @@ m32c_m16c_pointer_to_address (struct gdbarch *gdbarch,
{
/* See if there is a minimal symbol at that address whose name is
"NAME.plt". */
struct minimal_symbol *ptr_msym = lookup_minimal_symbol_by_pc (ptr);
struct bound_minimal_symbol ptr_msym = lookup_minimal_symbol_by_pc (ptr);
if (ptr_msym)
if (ptr_msym.minsym)
{
const char *ptr_msym_name = SYMBOL_LINKAGE_NAME (ptr_msym);
const char *ptr_msym_name = SYMBOL_LINKAGE_NAME (ptr_msym.minsym);
int len = strlen (ptr_msym_name);
if (len > 4
@ -2572,7 +2573,7 @@ m32c_m16c_pointer_to_address (struct gdbarch *gdbarch,
{
ptr_msym = lookup_minimal_symbol_by_pc ((aspace << 16) | ptr);
if (ptr_msym)
if (ptr_msym.minsym)
ptr |= aspace << 16;
}
}

8
gdb/m68hc11-tdep.c
View File

@ -587,18 +587,18 @@ m68hc11_analyze_instruction (struct gdbarch *gdbarch,
static enum insn_return_kind
m68hc11_get_return_insn (CORE_ADDR pc)
{
struct minimal_symbol *sym;
struct bound_minimal_symbol sym;
/* A flag indicating that this is a STO_M68HC12_FAR or STO_M68HC12_INTERRUPT
function is stored by elfread.c in the high bit of the info field.
Use this to decide which instruction the function uses to return. */
sym = lookup_minimal_symbol_by_pc (pc);
if (sym == 0)
if (sym.minsym == 0)
return RETURN_RTS;
if (MSYMBOL_IS_RTC (sym))
if (MSYMBOL_IS_RTC (sym.minsym))
return RETURN_RTC;
else if (MSYMBOL_IS_RTI (sym))
else if (MSYMBOL_IS_RTI (sym.minsym))
return RETURN_RTI;
else
return RETURN_RTS;

10
gdb/maint.c
View File

@ -452,7 +452,7 @@ maintenance_translate_address (char *arg, int from_tty)
CORE_ADDR address;
struct obj_section *sect;
char *p;
struct minimal_symbol *sym;
struct bound_minimal_symbol sym;
struct objfile *objfile;
if (arg == NULL || *arg == 0)
@ -487,13 +487,13 @@ maintenance_translate_address (char *arg, int from_tty)
else
sym = lookup_minimal_symbol_by_pc (address);
if (sym)
if (sym.minsym)
{
const char *symbol_name = SYMBOL_PRINT_NAME (sym);
const char *symbol_name = SYMBOL_PRINT_NAME (sym.minsym);
const char *symbol_offset
= pulongest (address - SYMBOL_VALUE_ADDRESS (sym));
= pulongest (address - SYMBOL_VALUE_ADDRESS (sym.minsym));
sect = SYMBOL_OBJ_SECTION(sym);
sect = SYMBOL_OBJ_SECTION(sym.minsym);
if (sect != NULL)
{
const char *section_name;

57
gdb/minsyms.c
View File

@ -474,7 +474,7 @@ lookup_minimal_symbol_solib_trampoline (const char *name,
there are text and trampoline symbols at the same address.
Otherwise prefer mst_text symbols. */
static struct minimal_symbol *
static struct bound_minimal_symbol
lookup_minimal_symbol_by_pc_section_1 (CORE_ADDR pc,
struct obj_section *section,
int want_trampoline)
@ -485,6 +485,8 @@ lookup_minimal_symbol_by_pc_section_1 (CORE_ADDR pc,
struct objfile *objfile;
struct minimal_symbol *msymbol;
struct minimal_symbol *best_symbol = NULL;
struct objfile *best_objfile = NULL;
struct bound_minimal_symbol result;
enum minimal_symbol_type want_type, other_type;
want_type = want_trampoline ? mst_solib_trampoline : mst_text;
@ -690,14 +692,18 @@ lookup_minimal_symbol_by_pc_section_1 (CORE_ADDR pc,
SYMBOL_VALUE_ADDRESS (&msymbol[hi]))))
{
best_symbol = &msymbol[hi];
best_objfile = objfile;
}
}
}
}
return (best_symbol);
result.minsym = best_symbol;
result.objfile = best_objfile;
return result;
}
struct minimal_symbol *
struct bound_minimal_symbol
lookup_minimal_symbol_by_pc_section (CORE_ADDR pc, struct obj_section *section)
{
if (section == NULL)
@ -707,17 +713,31 @@ lookup_minimal_symbol_by_pc_section (CORE_ADDR pc, struct obj_section *section)
debugging) always returns NULL making the call somewhat useless. */
section = find_pc_section (pc);
if (section == NULL)
return NULL;
{
struct bound_minimal_symbol result;
memset (&result, 0, sizeof (result));
return result;
}
}
return lookup_minimal_symbol_by_pc_section_1 (pc, section, 0);
}
/* See minsyms.h. */
struct minimal_symbol *
struct bound_minimal_symbol
lookup_minimal_symbol_by_pc (CORE_ADDR pc)
{
return lookup_minimal_symbol_by_pc_section (pc, NULL);
struct obj_section *section = find_pc_section (pc);
if (section == NULL)
{
struct bound_minimal_symbol result;
memset (&result, 0, sizeof (result));
return result;
}
return lookup_minimal_symbol_by_pc_section_1 (pc, section, 0);
}
/* Return non-zero iff PC is in an STT_GNU_IFUNC function resolver. */
@ -725,9 +745,9 @@ lookup_minimal_symbol_by_pc (CORE_ADDR pc)
int
in_gnu_ifunc_stub (CORE_ADDR pc)
{
struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (pc);
struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (pc);
return msymbol && MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc;
return msymbol.minsym && MSYMBOL_TYPE (msymbol.minsym) == mst_text_gnu_ifunc;
}
/* See elf_gnu_ifunc_resolve_addr for its real implementation. */
@ -785,10 +805,10 @@ const struct gnu_ifunc_fns *gnu_ifunc_fns_p = &stub_gnu_ifunc_fns;
/* See minsyms.h. */
struct minimal_symbol *
lookup_minimal_symbol_and_objfile (const char *name,
struct objfile **objfile_p)
struct bound_minimal_symbol
lookup_minimal_symbol_and_objfile (const char *name)
{
struct bound_minimal_symbol result;
struct objfile *objfile;
unsigned int hash = msymbol_hash (name) % MINIMAL_SYMBOL_HASH_SIZE;
@ -802,13 +822,15 @@ lookup_minimal_symbol_and_objfile (const char *name,
{
if (strcmp (SYMBOL_LINKAGE_NAME (msym), name) == 0)
{
*objfile_p = objfile;
return msym;
result.minsym = msym;
result.objfile = objfile;
return result;
}
}
}
return 0;
memset (&result, 0, sizeof (result));
return result;
}
@ -1287,14 +1309,15 @@ static struct minimal_symbol *
lookup_solib_trampoline_symbol_by_pc (CORE_ADDR pc)
{
struct obj_section *section = find_pc_section (pc);
struct minimal_symbol *msymbol;
struct bound_minimal_symbol msymbol;
if (section == NULL)
return NULL;
msymbol = lookup_minimal_symbol_by_pc_section_1 (pc, section, 1);
if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
return msymbol;
if (msymbol.minsym != NULL
&& MSYMBOL_TYPE (msymbol.minsym) == mst_solib_trampoline)
return msymbol.minsym;
return NULL;
}

32
gdb/minsyms.h
View File

@ -20,6 +20,23 @@
#ifndef MINSYMS_H
#define MINSYMS_H
/* Several lookup functions return both a minimal symbol and the
objfile in which it is found. This structure is used in these
cases. */
struct bound_minimal_symbol
{
/* The minimal symbol that was found, or NULL if no minimal symbol
was found. */
struct minimal_symbol *minsym;
/* If MINSYM is not NULL, then this is the objfile in which the
symbol is defined. */
struct objfile *objfile;
};
/* This header declares most of the API for dealing with minimal
symbols and minimal symbol tables. A few things are declared
elsewhere; see below.
@ -169,12 +186,9 @@ struct minimal_symbol *lookup_minimal_symbol (const char *,
struct objfile *);
/* Find the minimal symbol named NAME, and return both the minsym
struct and its objfile. This only checks the linkage name. Sets
*OBJFILE_P and returns the minimal symbol, if it is found. If it
is not found, returns NULL. */
struct and its objfile. This only checks the linkage name. */
struct minimal_symbol *lookup_minimal_symbol_and_objfile (const char *,
struct objfile **);
struct bound_minimal_symbol lookup_minimal_symbol_and_objfile (const char *);
/* Look through all the current minimal symbol tables and find the
first minimal symbol that matches NAME and has text type. If OBJF
@ -213,10 +227,10 @@ struct minimal_symbol *lookup_minimal_symbol_by_pc_name
If SECTION is NULL, this uses the result of find_pc_section
instead.
Returns a pointer to the minimal symbol if such a symbol is found,
or NULL if PC is not in a suitable range. */
The result has a non-NULL 'minsym' member if such a symbol is
found, or NULL if PC is not in a suitable range. */
struct minimal_symbol *lookup_minimal_symbol_by_pc_section
struct bound_minimal_symbol lookup_minimal_symbol_by_pc_section
(CORE_ADDR,
struct obj_section *);
@ -226,7 +240,7 @@ struct minimal_symbol *lookup_minimal_symbol_by_pc_section
This is a wrapper that calls lookup_minimal_symbol_by_pc_section
with a NULL section argument. */
struct minimal_symbol *lookup_minimal_symbol_by_pc (CORE_ADDR);
struct bound_minimal_symbol lookup_minimal_symbol_by_pc (CORE_ADDR);
/* Iterate over all the minimal symbols in the objfile OBJF which
match NAME. Both the ordinary and demangled names of each symbol

48
gdb/mips-tdep.c
View File

@ -1115,15 +1115,15 @@ show_mask_address (struct ui_file *file, int from_tty,
int
mips_pc_is_mips (CORE_ADDR memaddr)
{
struct minimal_symbol *sym;
struct bound_minimal_symbol sym;
/* Flags indicating that this is a MIPS16 or microMIPS function is
stored by elfread.c in the high bit of the info field. Use this
to decide if the function is standard MIPS. Otherwise if bit 0
of the address is clear, then this is a standard MIPS function. */
sym = lookup_minimal_symbol_by_pc (memaddr);
if (sym)
return msymbol_is_mips (sym);
if (sym.minsym)
return msymbol_is_mips (sym.minsym);
else
return is_mips_addr (memaddr);
}
@ -1133,15 +1133,15 @@ mips_pc_is_mips (CORE_ADDR memaddr)
int
mips_pc_is_mips16 (struct gdbarch *gdbarch, CORE_ADDR memaddr)
{
struct minimal_symbol *sym;
struct bound_minimal_symbol sym;
/* A flag indicating that this is a MIPS16 function is stored by
elfread.c in the high bit of the info field. Use this to decide
if the function is MIPS16. Otherwise if bit 0 of the address is
set, then ELF file flags will tell if this is a MIPS16 function. */
sym = lookup_minimal_symbol_by_pc (memaddr);
if (sym)
return msymbol_is_mips16 (sym);
if (sym.minsym)
return msymbol_is_mips16 (sym.minsym);
else
return is_mips16_addr (gdbarch, memaddr);
}
@ -1151,7 +1151,7 @@ mips_pc_is_mips16 (struct gdbarch *gdbarch, CORE_ADDR memaddr)
int
mips_pc_is_micromips (struct gdbarch *gdbarch, CORE_ADDR memaddr)
{
struct minimal_symbol *sym;
struct bound_minimal_symbol sym;
/* A flag indicating that this is a microMIPS function is stored by
elfread.c in the high bit of the info field. Use this to decide
@ -1159,8 +1159,8 @@ mips_pc_is_micromips (struct gdbarch *gdbarch, CORE_ADDR memaddr)
is set, then ELF file flags will tell if this is a microMIPS
function. */
sym = lookup_minimal_symbol_by_pc (memaddr);
if (sym)
return msymbol_is_micromips (sym);
if (sym.minsym)
return msymbol_is_micromips (sym.minsym);
else
return is_micromips_addr (gdbarch, memaddr);
}
@ -1171,7 +1171,7 @@ mips_pc_is_micromips (struct gdbarch *gdbarch, CORE_ADDR memaddr)
static enum mips_isa
mips_pc_isa (struct gdbarch *gdbarch, CORE_ADDR memaddr)
{
struct minimal_symbol *sym;
struct bound_minimal_symbol sym;
/* A flag indicating that this is a MIPS16 or a microMIPS function
is stored by elfread.c in the high bit of the info field. Use
@ -1179,11 +1179,11 @@ mips_pc_isa (struct gdbarch *gdbarch, CORE_ADDR memaddr)
MIPS. Otherwise if bit 0 of the address is set, then ELF file
flags will tell if this is a MIPS16 or a microMIPS function. */
sym = lookup_minimal_symbol_by_pc (memaddr);
if (sym)
if (sym.minsym)
{
if (msymbol_is_micromips (sym))
if (msymbol_is_micromips (sym.minsym))
return ISA_MICROMIPS;
else if (msymbol_is_mips16 (sym))
else if (msymbol_is_mips16 (sym.minsym))
return ISA_MIPS16;
else
return ISA_MIPS;
@ -3582,7 +3582,7 @@ mips_stub_frame_sniffer (const struct frame_unwind *self,
gdb_byte dummy[4];
struct obj_section *s;
CORE_ADDR pc = get_frame_address_in_block (this_frame);
struct minimal_symbol *msym;
struct bound_minimal_symbol msym;
/* Use the stub unwinder for unreadable code. */
if (target_read_memory (get_frame_pc (this_frame), dummy, 4) != 0)
@ -3602,9 +3602,9 @@ mips_stub_frame_sniffer (const struct frame_unwind *self,
/* Calling a PIC function from a non-PIC function passes through a
stub. The stub for foo is named ".pic.foo". */
msym = lookup_minimal_symbol_by_pc (pc);
if (msym != NULL
&& SYMBOL_LINKAGE_NAME (msym) != NULL
&& strncmp (SYMBOL_LINKAGE_NAME (msym), ".pic.", 5) == 0)
if (msym.minsym != NULL
&& SYMBOL_LINKAGE_NAME (msym.minsym) != NULL
&& strncmp (SYMBOL_LINKAGE_NAME (msym.minsym), ".pic.", 5) == 0)
return 1;
return 0;
@ -7626,7 +7626,7 @@ mips_skip_pic_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
struct minimal_symbol *msym;
struct bound_minimal_symbol msym;
int i;
gdb_byte stub_code[16];
int32_t stub_words[4];
@ -7635,18 +7635,18 @@ mips_skip_pic_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
instructions inserted before foo or a three instruction sequence
which jumps to foo. */
msym = lookup_minimal_symbol_by_pc (pc);
if (msym == NULL
|| SYMBOL_VALUE_ADDRESS (msym) != pc
|| SYMBOL_LINKAGE_NAME (msym) == NULL
|| strncmp (SYMBOL_LINKAGE_NAME (msym), ".pic.", 5) != 0)
if (msym.minsym == NULL
|| SYMBOL_VALUE_ADDRESS (msym.minsym) != pc
|| SYMBOL_LINKAGE_NAME (msym.minsym) == NULL
|| strncmp (SYMBOL_LINKAGE_NAME (msym.minsym), ".pic.", 5) != 0)
return 0;
/* A two-instruction header. */
if (MSYMBOL_SIZE (msym) == 8)
if (MSYMBOL_SIZE (msym.minsym) == 8)
return pc + 8;
/* A three-instruction (plus delay slot) trampoline. */
if (MSYMBOL_SIZE (msym) == 16)
if (MSYMBOL_SIZE (msym.minsym) == 16)
{
if (target_read_memory (pc, stub_code, 16) != 0)
return 0;

13
gdb/p-valprint.c
View File

@ -221,18 +221,18 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr,
/* Print vtbl's nicely. */
CORE_ADDR vt_address = unpack_pointer (type,
valaddr + embedded_offset);
struct minimal_symbol *msymbol =
struct bound_minimal_symbol msymbol =
lookup_minimal_symbol_by_pc (vt_address);
/* If 'symbol_print' is set, we did the work above. */
if (!options->symbol_print
&& (msymbol != NULL)
&& (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
&& (msymbol.minsym != NULL)
&& (vt_address == SYMBOL_VALUE_ADDRESS (msymbol.minsym)))
{
if (want_space)
fputs_filtered (" ", stream);
fputs_filtered ("<", stream);
fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
fputs_filtered (SYMBOL_PRINT_NAME (msymbol.minsym), stream);
fputs_filtered (">", stream);
want_space = 1;
}
@ -247,8 +247,9 @@ pascal_val_print (struct type *type, const gdb_byte *valaddr,
if (want_space)
fputs_filtered (" ", stream);
if (msymbol != NULL)
wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol), block,
if (msymbol.minsym != NULL)
wsym = lookup_symbol (SYMBOL_LINKAGE_NAME (msymbol.minsym),
block,
VAR_DOMAIN, &is_this_fld);
if (wsym)

7
gdb/parse.c
View File

@ -511,13 +511,14 @@ write_exp_msymbol (struct minimal_symbol *msymbol)
pc = gdbarch_convert_from_func_ptr_addr (gdbarch, addr, &current_target);
if (pc != addr)
{
struct minimal_symbol *ifunc_msym = lookup_minimal_symbol_by_pc (pc);
struct bound_minimal_symbol ifunc_msym = lookup_minimal_symbol_by_pc (pc);
/* In this case, assume we have a code symbol instead of
a data symbol. */
if (ifunc_msym != NULL && MSYMBOL_TYPE (ifunc_msym) == mst_text_gnu_ifunc
&& SYMBOL_VALUE_ADDRESS (ifunc_msym) == pc)
if (ifunc_msym.minsym != NULL
&& MSYMBOL_TYPE (ifunc_msym.minsym) == mst_text_gnu_ifunc
&& SYMBOL_VALUE_ADDRESS (ifunc_msym.minsym) == pc)
{
/* A function descriptor has been resolved but PC is still in the
STT_GNU_IFUNC resolver body (such as because inferior does not

9
gdb/ppc-linux-tdep.c
View File

@ -332,7 +332,7 @@ static struct ppc_insn_pattern powerpc32_plt_stub_so[] =
static int
powerpc_linux_in_dynsym_resolve_code (CORE_ADDR pc)
{
struct minimal_symbol *sym;
struct bound_minimal_symbol sym;
/* Check whether PC is in the dynamic linker. This also checks
whether it is in the .plt section, used by non-PIC executables. */
@ -341,9 +341,10 @@ powerpc_linux_in_dynsym_resolve_code (CORE_ADDR pc)
/* Check if we are in the resolver. */
sym = lookup_minimal_symbol_by_pc (pc);
if (sym != NULL
&& (strcmp (SYMBOL_LINKAGE_NAME (sym), "__glink") == 0
|| strcmp (SYMBOL_LINKAGE_NAME (sym), "__glink_PLTresolve") == 0))
if (sym.minsym != NULL
&& (strcmp (SYMBOL_LINKAGE_NAME (sym.minsym), "__glink") == 0
|| strcmp (SYMBOL_LINKAGE_NAME (sym.minsym),
"__glink_PLTresolve") == 0))
return 1;
return 0;

7
gdb/ppc-sysv-tdep.c
View File

@ -1076,12 +1076,13 @@ static int
convert_code_addr_to_desc_addr (CORE_ADDR code_addr, CORE_ADDR *desc_addr)
{
struct obj_section *dot_fn_section;
struct minimal_symbol *dot_fn;
struct bound_minimal_symbol dot_fn;
struct minimal_symbol *fn;
/* Find the minimal symbol that corresponds to CODE_ADDR (should
have a name of the form ".FN"). */
dot_fn = lookup_minimal_symbol_by_pc (code_addr);
if (dot_fn == NULL || SYMBOL_LINKAGE_NAME (dot_fn)[0] != '.')
if (dot_fn.minsym == NULL || SYMBOL_LINKAGE_NAME (dot_fn.minsym)[0] != '.')
return 0;
/* Get the section that contains CODE_ADDR. Need this for the
"objfile" that it contains. */
@ -1092,7 +1093,7 @@ convert_code_addr_to_desc_addr (CORE_ADDR code_addr, CORE_ADDR *desc_addr)
address. Only look for the minimal symbol in ".FN"'s object file
- avoids problems when two object files (i.e., shared libraries)
contain a minimal symbol with the same name. */
fn = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (dot_fn) + 1, NULL,
fn = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (dot_fn.minsym) + 1, NULL,
dot_fn_section->objfile);
if (fn == NULL)
return 0;

5
gdb/printcmd.c
View File

@ -658,7 +658,7 @@ build_address_symbolic (struct gdbarch *gdbarch,
save some memory, but for many debug format--ELF/DWARF or
anything/stabs--it would be inconvenient to eliminate those minimal
symbols anyway). */
msymbol = lookup_minimal_symbol_by_pc_section (addr, section);
msymbol = lookup_minimal_symbol_by_pc_section (addr, section).minsym;
symbol = find_pc_sect_function (addr, section);
if (symbol)
@ -1115,7 +1115,8 @@ sym_info (char *arg, int from_tty)
if (obj_section_addr (osect) <= sect_addr
&& sect_addr < obj_section_endaddr (osect)
&& (msymbol = lookup_minimal_symbol_by_pc_section (sect_addr, osect)))
&& (msymbol
= lookup_minimal_symbol_by_pc_section (sect_addr, osect).minsym))
{
const char *obj_name, *mapped, *sec_name, *msym_name;
char *loc_string;

16
gdb/rs6000-tdep.c
View File

@ -2152,15 +2152,15 @@ rs6000_skip_main_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
{
CORE_ADDR displ = op & BL_DISPLACEMENT_MASK;
CORE_ADDR call_dest = pc + 4 + displ;
struct minimal_symbol *s = lookup_minimal_symbol_by_pc (call_dest);
struct bound_minimal_symbol s = lookup_minimal_symbol_by_pc (call_dest);
/* We check for ___eabi (three leading underscores) in addition
to __eabi in case the GCC option "-fleading-underscore" was
used to compile the program. */
if (s != NULL
&& SYMBOL_LINKAGE_NAME (s) != NULL
&& (strcmp (SYMBOL_LINKAGE_NAME (s), "__eabi") == 0
|| strcmp (SYMBOL_LINKAGE_NAME (s), "___eabi") == 0))
if (s.minsym != NULL
&& SYMBOL_LINKAGE_NAME (s.minsym) != NULL
&& (strcmp (SYMBOL_LINKAGE_NAME (s.minsym), "__eabi") == 0
|| strcmp (SYMBOL_LINKAGE_NAME (s.minsym), "___eabi") == 0))
pc += 4;
}
return pc;
@ -2226,7 +2226,7 @@ rs6000_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
unsigned int ii, op;
int rel;
CORE_ADDR solib_target_pc;
struct minimal_symbol *msymbol;
struct bound_minimal_symbol msymbol;
static unsigned trampoline_code[] =
{
@ -2242,9 +2242,9 @@ rs6000_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
/* Check for bigtoc fixup code. */
msymbol = lookup_minimal_symbol_by_pc (pc);
if (msymbol
if (msymbol.minsym
&& rs6000_in_solib_return_trampoline (gdbarch, pc,
SYMBOL_LINKAGE_NAME (msymbol)))
SYMBOL_LINKAGE_NAME (msymbol.minsym)))
{
/* Double-check that the third instruction from PC is relative "b". */
op = read_memory_integer (pc + 8, 4, byte_order);

6
gdb/sh64-tdep.c
View File

@ -237,7 +237,7 @@ sh64_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
static int
pc_is_isa32 (bfd_vma memaddr)
{
struct minimal_symbol *sym;
struct bound_minimal_symbol sym;
/* If bit 0 of the address is set, assume this is a
ISA32 (shmedia) address. */
@ -248,8 +248,8 @@ pc_is_isa32 (bfd_vma memaddr)
the high bit of the info field. Use this to decide if the function is
ISA16 or ISA32. */
sym = lookup_minimal_symbol_by_pc (memaddr);
if (sym)
return MSYMBOL_IS_SPECIAL (sym);
if (sym.minsym)
return MSYMBOL_IS_SPECIAL (sym.minsym);
else
return 0;
}

28
gdb/stack.c
View File

@ -1037,23 +1037,25 @@ find_frame_funname (struct frame_info *frame, const char **funname,
changed (and we'll create a find_pc_minimal_function or some
such). */
struct minimal_symbol *msymbol = NULL;
struct bound_minimal_symbol msymbol;
/* Don't attempt to do this for inlined functions, which do not
have a corresponding minimal symbol. */
if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func)))
msymbol
= lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
else
memset (&msymbol, 0, sizeof (msymbol));
if (msymbol != NULL
&& (SYMBOL_VALUE_ADDRESS (msymbol)
if (msymbol.minsym != NULL
&& (SYMBOL_VALUE_ADDRESS (msymbol.minsym)
> BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
{
/* We also don't know anything about the function besides
its address and name. */
func = 0;
*funname = SYMBOL_PRINT_NAME (msymbol);
*funlang = SYMBOL_LANGUAGE (msymbol);
*funname = SYMBOL_PRINT_NAME (msymbol.minsym);
*funlang = SYMBOL_LANGUAGE (msymbol.minsym);
}
else
{
@ -1080,17 +1082,17 @@ find_frame_funname (struct frame_info *frame, const char **funname,
}
else
{
struct minimal_symbol *msymbol;
struct bound_minimal_symbol msymbol;
CORE_ADDR pc;
if (!get_frame_address_in_block_if_available (frame, &pc))
return;
msymbol = lookup_minimal_symbol_by_pc (pc);
if (msymbol != NULL)
if (msymbol.minsym != NULL)
{
*funname = SYMBOL_PRINT_NAME (msymbol);
*funlang = SYMBOL_LANGUAGE (msymbol);
*funname = SYMBOL_PRINT_NAME (msymbol.minsym);
*funlang = SYMBOL_LANGUAGE (msymbol.minsym);
}
}
}
@ -1424,13 +1426,13 @@ frame_info (char *addr_exp, int from_tty)
}
else if (frame_pc_p)
{
struct minimal_symbol *msymbol;
struct bound_minimal_symbol msymbol;
msymbol = lookup_minimal_symbol_by_pc (frame_pc);
if (msymbol != NULL)
if (msymbol.minsym != NULL)
{
funname = SYMBOL_PRINT_NAME (msymbol);
funlang = SYMBOL_LANGUAGE (msymbol);
funname = SYMBOL_PRINT_NAME (msymbol.minsym);
funlang = SYMBOL_LANGUAGE (msymbol.minsym);
}
}
calling_frame_info = get_prev_frame (fi);

23
gdb/symtab.c
View File

@ -979,7 +979,7 @@ find_pc_sect_symtab_via_partial (CORE_ADDR pc, struct obj_section *section)
/* If we know that this is not a text address, return failure. This is
necessary because we loop based on texthigh and textlow, which do
not include the data ranges. */
msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
msymbol = lookup_minimal_symbol_by_pc_section (pc, section).minsym;
if (msymbol
&& (MSYMBOL_TYPE (msymbol) == mst_data
|| MSYMBOL_TYPE (msymbol) == mst_bss
@ -2071,7 +2071,7 @@ find_pc_sect_symtab (CORE_ADDR pc, struct obj_section *section)
addresses, which do not include the data ranges, and because
we call find_pc_sect_psymtab which has a similar restriction based
on the partial_symtab's texthigh and textlow. */
msymbol = lookup_minimal_symbol_by_pc_section (pc, section);
msymbol = lookup_minimal_symbol_by_pc_section (pc, section).minsym;
if (msymbol
&& (MSYMBOL_TYPE (msymbol) == mst_data
|| MSYMBOL_TYPE (msymbol) == mst_bss
@ -2202,7 +2202,7 @@ find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
struct linetable_entry *item;
struct symtab_and_line val;
struct blockvector *bv;
struct minimal_symbol *msymbol;
struct bound_minimal_symbol msymbol;
struct minimal_symbol *mfunsym;
struct objfile *objfile;
@ -2288,11 +2288,12 @@ find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
* infinite recursion.
*/
msymbol = lookup_minimal_symbol_by_pc (pc);
if (msymbol != NULL)
if (MSYMBOL_TYPE (msymbol) == mst_solib_trampoline)
if (msymbol.minsym != NULL)
if (MSYMBOL_TYPE (msymbol.minsym) == mst_solib_trampoline)
{
mfunsym = lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol),
NULL);
mfunsym
= lookup_minimal_symbol_text (SYMBOL_LINKAGE_NAME (msymbol.minsym),
NULL);
if (mfunsym == NULL)
/* I eliminated this warning since it is coming out
* in the following situation:
@ -2308,7 +2309,7 @@ find_pc_sect_line (CORE_ADDR pc, struct obj_section *section, int notcurrent)
;
/* fall through */
else if (SYMBOL_VALUE_ADDRESS (mfunsym)
== SYMBOL_VALUE_ADDRESS (msymbol))
== SYMBOL_VALUE_ADDRESS (msymbol.minsym))
/* Avoid infinite recursion */
/* See above comment about why warning is commented out. */
/* warning ("In stub for %s; unable to find real function/line info",
@ -2821,7 +2822,7 @@ skip_prologue_sal (struct symtab_and_line *sal)
else
{
struct minimal_symbol *msymbol
= lookup_minimal_symbol_by_pc_section (sal->pc, sal->section);
= lookup_minimal_symbol_by_pc_section (sal->pc, sal->section).minsym;
if (msymbol == NULL)
{
@ -2877,8 +2878,8 @@ skip_prologue_sal (struct symtab_and_line *sal)
if (skip && start_sal.pc != pc
&& (sym ? (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) <= start_sal.end
&& start_sal.end < BLOCK_END (SYMBOL_BLOCK_VALUE (sym)))
: (lookup_minimal_symbol_by_pc_section (start_sal.end, section)
== lookup_minimal_symbol_by_pc_section (pc, section))))
: (lookup_minimal_symbol_by_pc_section (start_sal.end, section).minsym
== lookup_minimal_symbol_by_pc_section (pc, section).minsym)))
{
/* First pc of next line */
pc = start_sal.end;

2
gdb/tui/tui-disasm.c
View File

@ -121,7 +121,7 @@ tui_find_disassembly_address (struct gdbarch *gdbarch, CORE_ADDR pc, int from)
pos = max_lines - 1;
do {
new_low -= 1 * max_lines;
msymbol = lookup_minimal_symbol_by_pc_section (new_low, 0);
msymbol = lookup_minimal_symbol_by_pc_section (new_low, 0).minsym;
if (msymbol)
new_low = SYMBOL_VALUE_ADDRESS (msymbol);