* minsyms.h (struct bound_minimal_symbol): New.
authorTom Tromey <tromey@redhat.com>
Mon, 8 Apr 2013 19:59:09 +0000 (19:59 +0000)
committerTom Tromey <tromey@redhat.com>
Mon, 8 Apr 2013 19:59:09 +0000 (19:59 +0000)
(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.

41 files changed:
gdb/ChangeLog
gdb/ada-tasks.c
gdb/amd64-windows-tdep.c
gdb/arm-tdep.c
gdb/arm-wince-tdep.c
gdb/block.c
gdb/blockframe.c
gdb/breakpoint.c
gdb/btrace.c
gdb/c-valprint.c
gdb/coff-pe-read.c
gdb/dwarf2loc.c
gdb/elfread.c
gdb/frame.c
gdb/frv-tdep.c
gdb/glibc-tdep.c
gdb/gnu-v2-abi.c
gdb/gnu-v3-abi.c
gdb/hppa-hpux-tdep.c
gdb/i386-tdep.c
gdb/ia64-tdep.c
gdb/infcall.c
gdb/infcmd.c
gdb/jit.c
gdb/linux-fork.c
gdb/m32c-tdep.c
gdb/m68hc11-tdep.c
gdb/maint.c
gdb/minsyms.c
gdb/minsyms.h
gdb/mips-tdep.c
gdb/p-valprint.c
gdb/parse.c
gdb/ppc-linux-tdep.c
gdb/ppc-sysv-tdep.c
gdb/printcmd.c
gdb/rs6000-tdep.c
gdb/sh64-tdep.c
gdb/stack.c
gdb/symtab.c
gdb/tui/tui-disasm.c

index 3764fc943f2b30644050fdd2748cf3bd4ae1822c..793aa91e779027fefdd4bc43e39e69bca36118a7 100644 (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'.
index 25a86f61fc576d1f8ab90d100e6e2f63a1bdca7f..b0835f6615387538d4b97baadc2970044797ff06 100644 (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;
 
index e7addfcc3b6a69630a3adcd9df0ffda63b92ed3e..a0fd074a77c4bfc5bbfab3925c8cda427d2428d0 100644 (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)
index 17246860a5a26b9e60475c19586d46cd6a6686b0..2a11890abfb15c516cf7843afc5414e7732d53c3 100644 (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;
 
index 9282bf954ed17c65d4c543754bb4da38e755d253..e00640cc03a67e03399ea62b9b4d2393292cd116 100644 (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;
     }
 
index 2638de8f9a6e3c1b5c6ae109f43bc2c15e94a8a9..643e1449950bd3cda3103e6e31f7938e332a4382 100644 (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;
index d5787f1e2fee2fe4fcb13b176f4c3a7c96440f81..aedad3e63572e30544a5bba57a95cae611de7e39 100644 (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)
index 667bedd665f201bcb292a02ca9af37cd7aa8ef34..758a7a9e27d3add64135852620821e0b84c08f9f 100644 (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);
            }
index c39a32d7632be411f6206dc4216810532a1f3e17..3230a3ee6e4aff9a4bbc4aebc8cc107b800985f2 100644 (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");
        }
 
index cf7f5b750a258aa7cf689edd894fc1015e073440..646aed72f7551058de0d183d4de01f37137be9bd 100644 (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);
 
index 3f06f681d094e66076acebd9c79df8516cbe10db..8961c7816217d21ef7e87b8a3d3a08a4439d7ac0 100644 (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
index 18699e0d2ce6e363c71877cb394e30a9d76cd5f3..71220c6251389607eae0c821b32b813f1f9d8d50 100644 (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.  */
index 14952b80bcf2ebb5bd5bb003238deb080d266eb4..866e496da542e1316b9bb137e3e344b361f7b851 100644 (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
index 4b8ab60b7cf68e3075ac2172c935d4a66821a612..a4d18bbadebbd06e46b4cd543ed75ca07a66b64f 100644 (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)
index 61997093174e6447e25953e7819b5706c20ec2f6..3770667dcf20240bbbdb20dfeb26ac06090c227c 100644 (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;
index e023df1d151b4cddafbefc6df028202d9ff939f7..64938b52129708ff18c86332496f19218037630b 100644 (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 ());
index c17955a8c70bdda172875c69c6b96cdfc783d3c2..e7f0166ef18242ca875502f6fa3bd65a10b24971 100644 (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;
 
index 32656633c5952945056534e6a6118c1db3e0d25a..ee01f52acdd36242ea152d900ed44cc51324950f 100644 (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;
index 9948e9bacba604c47be6c4188c6f55b239def29d..ad9b4fad41dc897067d53d651abde3f827bb380a 100644 (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)
        {
index e76dcbe82a5a26f92888827cf6e5bbc4c6eb4d8e..930d6fc96859be2c551c2807679d0a6f243fdc1d 100644 (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)
index 29714a8e7a7c8375cdc34b3c7bd22c4b9239ff79..97972172e6eb5a1a736c8d52ffdea2320db120b6 100644 (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);
     }
 
index 777f2491fe3e4d452bb3f291a12c8ce8624d842c..19af04421ddc2a34002d41a7e6ed144179e3b05b 100644 (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);
   }
 
   {
index 0b40f22e7b5d3df44fa2dacd3237e96f750bd6f1..53e2168fffc13165cd0f579746060476d03f04e8 100644 (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
index 8225540c2d54f90a12d41d477a77364be2d356cb..33d3d612d06fe5b399322ca20fcdd14d0b85fe56 100644 (file)
--- a/gdb/jit.c
+++ b/gdb/jit.c
@@ -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);
index 7ed1803fc767e1eded83fc5d1ed2c88a10bbaa09..cb5705032b6152cc47087475818acb17997d575c 100644 (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');
index 1d773773a740cb56333b49be6942984deaddc429..3a0267b66e0307cd827a53bc877b433e10d3ade7 100644 (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;
            }
        }
index 882f37f5afc623fba7fa06dc9d18c37cf2be8b0c..078be7014740e0f4171b46f157b1a4e3e1459f73 100644 (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;
index db3e63dfcf813b5f8d8fbdaeb73d59059205462d..ee947bd410c6b9d83e2376bd0ff2079231c4df9f 100644 (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;
index 900364aa524d41847a6b7ac4f32501e59a6aed38..6a94e112411b332ca10b7bd16aa8cba3eab16950 100644 (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;
 }
 \f
 
@@ -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;
 }
 
index e3980ea6c44e90a2c9daab76a3131fb9994b4c18..71670e38e74d1d0513fcba2cbb4bea240cb3faf9 100644 (file)
 #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
index f83bc99295ed3436d4d79c1fa2af13c3c54ad0c3..9d9451c786219882319dbf70ee44ca1c4c350826 100644 (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;
index bcc055ee8afdb1542efcffdcb3fa97682680db66..d326dbac8baec74a5984e0d64d90830ea49daee1 100644 (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)
index 095d63d15b2e6a9cfae42465e4fa31361e7a3464..ff4ed6c749b956683e2f3755baa31cb42087239c 100644 (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
index 0fc6fe03b9c891657a78cfd2d52fd0223ebfd406..6895562a782a43333c25cfd8f07afdbce05d8bfd 100644 (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;
index 7568aadcc4b400ff442fbd3b3ac7e28ef035de13..0cddf6477c6057a819514e001eb8ab00ca80fd42 100644 (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;
index 7decc397a7a6790633343a659391dcd8188ab5d0..6ac0ba5668b534448d87cc79691c2ce017afd937 100644 (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;
index 5bc11055dca4418deb3af4343e3330eab69baa63..bebbdb5b1a8422fb10678a2c2cbe4e8b7562e2df 100644 (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);
index cb035274d435d74e0012d2d3ad007369f22759b3..8a81fcb8d25e12f1f5568065f82d4215792e5f9b 100644 (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;
 }
index 9ac3123f7610e6a89689618e98dd45496d6ff885..c072a2ef4cc503a3932101d56063746fe0ee867e 100644 (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);
index 8ef3966fc16a338675a79c6e0b0eb074134d321f..1922d9bf539c9701fcaaf0e15b5624886eabcad6 100644 (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;
index 42204ee4bc1f85f541ad58e44dce612cb5669884..7f0039568f899fdb4028467d83a1e190bf1249f2 100644 (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);
This page took 0.083044 seconds and 4 git commands to generate.