riscv
/
binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

* 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.
cygwin-64bit-premerge-branch
Tom Tromey 14 years ago
parent
f85f34ede8
commit
7cbd4a934e
41 changed files with 344 additions and 258 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 24
      gdb/ChangeLog
  2. 6
      gdb/ada-tasks.c
  3. 12
      gdb/amd64-windows-tdep.c
  4. 23
      gdb/arm-tdep.c
  5. 14
      gdb/arm-wince-tdep.c
  6. 5
      gdb/block.c
  7. 8
      gdb/blockframe.c
  8. 6
      gdb/breakpoint.c
  9. 8
      gdb/btrace.c
  10. 14
      gdb/c-valprint.c
  11. 17
      gdb/coff-pe-read.c
  12. 51
      gdb/dwarf2loc.c
  13. 10
      gdb/elfread.c
  14. 2
      gdb/frame.c
  15. 8
      gdb/frv-tdep.c
  16. 11
      gdb/glibc-tdep.c
  17. 6
      gdb/gnu-v2-abi.c
  18. 4
      gdb/gnu-v3-abi.c
  19. 37
      gdb/hppa-hpux-tdep.c
  20. 10
      gdb/i386-tdep.c
  21. 4
      gdb/ia64-tdep.c
  22. 6
      gdb/infcall.c
  23. 6
      gdb/infcmd.c
  24. 18
      gdb/jit.c
  25. 6
      gdb/linux-fork.c
  26. 15
      gdb/m32c-tdep.c
  27. 8
      gdb/m68hc11-tdep.c
  28. 10
      gdb/maint.c
  29. 57
      gdb/minsyms.c
  30. 32
      gdb/minsyms.h
  31. 48
      gdb/mips-tdep.c
  32. 13
      gdb/p-valprint.c
  33. 7
      gdb/parse.c
  34. 9
      gdb/ppc-linux-tdep.c
  35. 7
      gdb/ppc-sysv-tdep.c
  36. 5
      gdb/printcmd.c
  37. 16
      gdb/rs6000-tdep.c
  38. 6
      gdb/sh64-tdep.c
  39. 28
      gdb/stack.c
  40. 23
      gdb/symtab.c
  41. 2
      gdb/tui/tui-disasm.c

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);

Write Preview
Loading…
Cancel
Save