-/* Handle SunOS and SVR4 shared libraries for GDB, the GNU Debugger.
- Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
- 2001
+/* Handle SVR4 shared libraries for GDB, the GNU Debugger.
+
+ Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
+ 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009
Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "regcache.h"
-
-
-#include <sys/types.h>
-#include <signal.h>
-#include "gdb_string.h"
-#include <sys/param.h>
-#include <fcntl.h>
-#ifndef SVR4_SHARED_LIBS
- /* SunOS shared libs need the nlist structure. */
-#include <a.out.h>
-#include <link.h>
-#else
#include "elf/external.h"
#include "elf/common.h"
-#endif
+#include "elf/mips.h"
#include "symtab.h"
#include "bfd.h"
#include "symfile.h"
#include "objfiles.h"
#include "gdbcore.h"
-#include "command.h"
#include "target.h"
-#include "frame.h"
-#include "gdb_regex.h"
#include "inferior.h"
-#include "environ.h"
-#include "language.h"
-#include "gdbcmd.h"
+#include "regcache.h"
+#include "gdbthread.h"
+#include "observer.h"
+
+#include "gdb_assert.h"
#include "solist.h"
+#include "solib.h"
#include "solib-svr4.h"
-#ifndef SVR4_FETCH_LINK_MAP_OFFSETS
-#define SVR4_FETCH_LINK_MAP_OFFSETS() fetch_link_map_offsets ()
-#endif
-
-static struct link_map_offsets *default_svr4_fetch_link_map_offsets (void);
-static struct link_map_offsets *(*fetch_link_map_offsets)(void) =
- default_svr4_fetch_link_map_offsets;
+#include "bfd-target.h"
+#include "elf-bfd.h"
+#include "exec.h"
+#include "auxv.h"
+#include "exceptions.h"
-/* legacy_svr4_fetch_link_map_offsets_hook is a pointer to a function
- which is used to fetch link map offsets. It will only be set
- by solib-legacy.c, if at all. */
-struct link_map_offsets *(*legacy_svr4_fetch_link_map_offsets_hook)(void) = 0;
+static struct link_map_offsets *svr4_fetch_link_map_offsets (void);
+static int svr4_have_link_map_offsets (void);
/* Link map info to include in an allocated so_list entry */
/* Pointer to copy of link map from inferior. The type is char *
rather than void *, so that we may use byte offsets to find the
various fields without the need for a cast. */
- char *lm;
+ gdb_byte *lm;
+
+ /* Amount by which addresses in the binary should be relocated to
+ match the inferior. This could most often be taken directly
+ from lm, but when prelinking is involved and the prelink base
+ address changes, we may need a different offset, we want to
+ warn about the difference and compute it only once. */
+ CORE_ADDR l_addr;
+
+ /* The target location of lm. */
+ CORE_ADDR lm_addr;
};
/* On SVR4 systems, a list of symbols in the dynamic linker where
SVR4 systems will fall back to using a symbol as the "startup
mapping complete" breakpoint address. */
-#ifdef SVR4_SHARED_LIBS
static char *solib_break_names[] =
{
"r_debug_state",
"_dl_debug_state",
"rtld_db_dlactivity",
"_rtld_debug_state",
+
NULL
};
-#endif
-
-#define BKPT_AT_SYMBOL 1
-#if defined (BKPT_AT_SYMBOL) && defined (SVR4_SHARED_LIBS)
static char *bkpt_names[] =
{
-#ifdef SOLIB_BKPT_NAME
- SOLIB_BKPT_NAME, /* Prefer configured name if it exists. */
-#endif
"_start",
+ "__start",
"main",
NULL
};
-#endif
-
-/* Symbols which are used to locate the base of the link map structures. */
-
-#ifndef SVR4_SHARED_LIBS
-static char *debug_base_symbols[] =
-{
- "_DYNAMIC",
- "_DYNAMIC__MGC",
- NULL
-};
-#endif
static char *main_name_list[] =
{
NULL
};
+/* Return non-zero if GDB_SO_NAME and INFERIOR_SO_NAME represent
+ the same shared library. */
-/* Fetch (and possibly build) an appropriate link_map_offsets structure
- for native targets using struct definitions from link.h.
-
- Note: For non-native targets (i.e. cross-debugging situations),
- you need to define a target specific fetch_link_map_offsets()
- function and call set_solib_svr4_fetch_link_map_offsets () to
- register this function. */
-
-static struct link_map_offsets *
-default_svr4_fetch_link_map_offsets (void)
+static int
+svr4_same_1 (const char *gdb_so_name, const char *inferior_so_name)
{
- if (legacy_svr4_fetch_link_map_offsets_hook)
- return legacy_svr4_fetch_link_map_offsets_hook ();
- else
- {
- internal_error (__FILE__, __LINE__,
-"default_svr4_fetch_link_map_offsets called without legacy link_map support enabled.");
- return 0;
- }
+ if (strcmp (gdb_so_name, inferior_so_name) == 0)
+ return 1;
+
+ /* On Solaris, when starting inferior we think that dynamic linker is
+ /usr/lib/ld.so.1, but later on, the table of loaded shared libraries
+ contains /lib/ld.so.1. Sometimes one file is a link to another, but
+ sometimes they have identical content, but are not linked to each
+ other. We don't restrict this check for Solaris, but the chances
+ of running into this situation elsewhere are very low. */
+ if (strcmp (gdb_so_name, "/usr/lib/ld.so.1") == 0
+ && strcmp (inferior_so_name, "/lib/ld.so.1") == 0)
+ return 1;
+
+ /* Similarly, we observed the same issue with sparc64, but with
+ different locations. */
+ if (strcmp (gdb_so_name, "/usr/lib/sparcv9/ld.so.1") == 0
+ && strcmp (inferior_so_name, "/lib/sparcv9/ld.so.1") == 0)
+ return 1;
+
+ return 0;
}
-/* Macro to extract an address from a solib structure.
- When GDB is configured for some 32-bit targets (e.g. Solaris 2.7
- sparc), BFD is configured to handle 64-bit targets, so CORE_ADDR is
- 64 bits. We have to extract only the significant bits of addresses
- to get the right address when accessing the core file BFD. */
+static int
+svr4_same (struct so_list *gdb, struct so_list *inferior)
+{
+ return (svr4_same_1 (gdb->so_original_name, inferior->so_original_name));
+}
-#define SOLIB_EXTRACT_ADDRESS(MEMBER) \
- extract_address (&(MEMBER), sizeof (MEMBER))
+/* link map access functions */
-/* local data declarations */
+static CORE_ADDR
+LM_ADDR_FROM_LINK_MAP (struct so_list *so)
+{
+ struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
+ struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
-#ifndef SVR4_SHARED_LIBS
+ return extract_typed_address (so->lm_info->lm + lmo->l_addr_offset,
+ ptr_type);
+}
-/* NOTE: converted the macros LM_ADDR, LM_NEXT, LM_NAME and
- IGNORE_FIRST_LINK_MAP_ENTRY into functions (see below).
- MVS, June 2000 */
+static int
+HAS_LM_DYNAMIC_FROM_LINK_MAP (void)
+{
+ struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
-static struct link_dynamic dynamic_copy;
-static struct link_dynamic_2 ld_2_copy;
-static struct ld_debug debug_copy;
-static CORE_ADDR debug_addr;
-static CORE_ADDR flag_addr;
+ return lmo->l_ld_offset >= 0;
+}
-#endif /* !SVR4_SHARED_LIBS */
+static CORE_ADDR
+LM_DYNAMIC_FROM_LINK_MAP (struct so_list *so)
+{
+ struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
+ struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
-/* link map access functions */
+ return extract_typed_address (so->lm_info->lm + lmo->l_ld_offset,
+ ptr_type);
+}
static CORE_ADDR
-LM_ADDR (struct so_list *so)
+LM_ADDR_CHECK (struct so_list *so, bfd *abfd)
{
- struct link_map_offsets *lmo = SVR4_FETCH_LINK_MAP_OFFSETS ();
+ if (so->lm_info->l_addr == (CORE_ADDR)-1)
+ {
+ struct bfd_section *dyninfo_sect;
+ CORE_ADDR l_addr, l_dynaddr, dynaddr, align = 0x1000;
+
+ l_addr = LM_ADDR_FROM_LINK_MAP (so);
+
+ if (! abfd || ! HAS_LM_DYNAMIC_FROM_LINK_MAP ())
+ goto set_addr;
+
+ l_dynaddr = LM_DYNAMIC_FROM_LINK_MAP (so);
+
+ dyninfo_sect = bfd_get_section_by_name (abfd, ".dynamic");
+ if (dyninfo_sect == NULL)
+ goto set_addr;
+
+ dynaddr = bfd_section_vma (abfd, dyninfo_sect);
+
+ if (dynaddr + l_addr != l_dynaddr)
+ {
+ if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
+ {
+ Elf_Internal_Ehdr *ehdr = elf_tdata (abfd)->elf_header;
+ Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
+ int i;
+
+ align = 1;
+
+ for (i = 0; i < ehdr->e_phnum; i++)
+ if (phdr[i].p_type == PT_LOAD && phdr[i].p_align > align)
+ align = phdr[i].p_align;
+ }
+
+ /* Turn it into a mask. */
+ align--;
+
+ /* If the changes match the alignment requirements, we
+ assume we're using a core file that was generated by the
+ same binary, just prelinked with a different base offset.
+ If it doesn't match, we may have a different binary, the
+ same binary with the dynamic table loaded at an unrelated
+ location, or anything, really. To avoid regressions,
+ don't adjust the base offset in the latter case, although
+ odds are that, if things really changed, debugging won't
+ quite work. */
+ if ((l_addr & align) == ((l_dynaddr - dynaddr) & align))
+ {
+ l_addr = l_dynaddr - dynaddr;
+
+ warning (_(".dynamic section for \"%s\" "
+ "is not at the expected address"), so->so_name);
+ warning (_("difference appears to be caused by prelink, "
+ "adjusting expectations"));
+ }
+ else
+ warning (_(".dynamic section for \"%s\" "
+ "is not at the expected address "
+ "(wrong library or version mismatch?)"), so->so_name);
+ }
+
+ set_addr:
+ so->lm_info->l_addr = l_addr;
+ }
- return (CORE_ADDR) extract_signed_integer (so->lm_info->lm + lmo->l_addr_offset,
- lmo->l_addr_size);
+ return so->lm_info->l_addr;
}
static CORE_ADDR
LM_NEXT (struct so_list *so)
{
- struct link_map_offsets *lmo = SVR4_FETCH_LINK_MAP_OFFSETS ();
+ struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
+ struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
- return extract_address (so->lm_info->lm + lmo->l_next_offset, lmo->l_next_size);
+ return extract_typed_address (so->lm_info->lm + lmo->l_next_offset,
+ ptr_type);
}
static CORE_ADDR
LM_NAME (struct so_list *so)
{
- struct link_map_offsets *lmo = SVR4_FETCH_LINK_MAP_OFFSETS ();
+ struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
+ struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
- return extract_address (so->lm_info->lm + lmo->l_name_offset, lmo->l_name_size);
+ return extract_typed_address (so->lm_info->lm + lmo->l_name_offset,
+ ptr_type);
}
-#ifndef SVR4_SHARED_LIBS
-
-static int
+static int
IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list *so)
{
- return 0;
+ struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
+ struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+
+ /* Assume that everything is a library if the dynamic loader was loaded
+ late by a static executable. */
+ if (bfd_get_section_by_name (exec_bfd, ".dynamic") == NULL)
+ return 0;
+
+ return extract_typed_address (so->lm_info->lm + lmo->l_prev_offset,
+ ptr_type) == 0;
}
-#else /* SVR4_SHARED_LIBS */
+/* Per-inferior SVR4 specific data. */
-static int
-IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list *so)
+struct svr4_info
{
- struct link_map_offsets *lmo = SVR4_FETCH_LINK_MAP_OFFSETS ();
+ int pid;
- return extract_address (so->lm_info->lm + lmo->l_prev_offset,
- lmo->l_prev_size) == 0;
-}
+ CORE_ADDR debug_base; /* Base of dynamic linker structures */
-#endif /* !SVR4_SHARED_LIBS */
+ /* Validity flag for debug_loader_offset. */
+ int debug_loader_offset_p;
-static CORE_ADDR debug_base; /* Base of dynamic linker structures */
-static CORE_ADDR breakpoint_addr; /* Address where end bkpt is set */
+ /* Load address for the dynamic linker, inferred. */
+ CORE_ADDR debug_loader_offset;
-/* Local function prototypes */
+ /* Name of the dynamic linker, valid if debug_loader_offset_p. */
+ char *debug_loader_name;
-static int match_main (char *);
+ /* Load map address for the main executable. */
+ CORE_ADDR main_lm_addr;
+};
-#ifndef SVR4_SHARED_LIBS
+/* List of known processes using solib-svr4 shared libraries, storing
+ the required bookkeeping for each. */
-/* Allocate the runtime common object file. */
+typedef struct svr4_info *svr4_info_p;
+DEF_VEC_P(svr4_info_p);
+VEC(svr4_info_p) *svr4_info = NULL;
-static void
-allocate_rt_common_objfile (void)
+/* Get svr4 data for inferior PID (target id). If none is found yet,
+ add it now. This function always returns a valid object. */
+
+struct svr4_info *
+get_svr4_info (int pid)
{
- struct objfile *objfile;
- struct objfile *last_one;
-
- objfile = (struct objfile *) xmalloc (sizeof (struct objfile));
- memset (objfile, 0, sizeof (struct objfile));
- objfile->md = NULL;
- obstack_specify_allocation (&objfile->psymbol_cache.cache, 0, 0,
- xmalloc, xfree);
- obstack_specify_allocation (&objfile->psymbol_obstack, 0, 0, xmalloc,
- xfree);
- obstack_specify_allocation (&objfile->symbol_obstack, 0, 0, xmalloc,
- xfree);
- obstack_specify_allocation (&objfile->type_obstack, 0, 0, xmalloc,
- xfree);
- objfile->name = mstrsave (objfile->md, "rt_common");
-
- /* Add this file onto the tail of the linked list of other such files. */
-
- objfile->next = NULL;
- if (object_files == NULL)
- object_files = objfile;
- else
+ int ix;
+ struct svr4_info *it;
+
+ gdb_assert (pid != 0);
+
+ for (ix = 0; VEC_iterate (svr4_info_p, svr4_info, ix, it); ++ix)
{
- for (last_one = object_files;
- last_one->next;
- last_one = last_one->next);
- last_one->next = objfile;
+ if (it->pid == pid)
+ return it;
}
- rt_common_objfile = objfile;
+ it = XZALLOC (struct svr4_info);
+ it->pid = pid;
+
+ VEC_safe_push (svr4_info_p, svr4_info, it);
+
+ return it;
}
-/* Read all dynamically loaded common symbol definitions from the inferior
- and put them into the minimal symbol table for the runtime common
- objfile. */
+/* Get rid of any svr4 related bookkeeping for inferior PID (target
+ id). */
static void
-solib_add_common_symbols (CORE_ADDR rtc_symp)
+remove_svr4_info (int pid)
{
- struct rtc_symb inferior_rtc_symb;
- struct nlist inferior_rtc_nlist;
- int len;
- char *name;
-
- /* Remove any runtime common symbols from previous runs. */
-
- if (rt_common_objfile != NULL && rt_common_objfile->minimal_symbol_count)
- {
- obstack_free (&rt_common_objfile->symbol_obstack, 0);
- obstack_specify_allocation (&rt_common_objfile->symbol_obstack, 0, 0,
- xmalloc, xfree);
- rt_common_objfile->minimal_symbol_count = 0;
- rt_common_objfile->msymbols = NULL;
- }
-
- init_minimal_symbol_collection ();
- make_cleanup_discard_minimal_symbols ();
+ int ix;
+ struct svr4_info *it;
- while (rtc_symp)
+ for (ix = 0; VEC_iterate (svr4_info_p, svr4_info, ix, it); ++ix)
{
- read_memory (rtc_symp,
- (char *) &inferior_rtc_symb,
- sizeof (inferior_rtc_symb));
- read_memory (SOLIB_EXTRACT_ADDRESS (inferior_rtc_symb.rtc_sp),
- (char *) &inferior_rtc_nlist,
- sizeof (inferior_rtc_nlist));
- if (inferior_rtc_nlist.n_type == N_COMM)
+ if (it->pid == pid)
{
- /* FIXME: The length of the symbol name is not available, but in the
- current implementation the common symbol is allocated immediately
- behind the name of the symbol. */
- len = inferior_rtc_nlist.n_value - inferior_rtc_nlist.n_un.n_strx;
-
- name = xmalloc (len);
- read_memory (SOLIB_EXTRACT_ADDRESS (inferior_rtc_nlist.n_un.n_name),
- name, len);
-
- /* Allocate the runtime common objfile if necessary. */
- if (rt_common_objfile == NULL)
- allocate_rt_common_objfile ();
-
- prim_record_minimal_symbol (name, inferior_rtc_nlist.n_value,
- mst_bss, rt_common_objfile);
- xfree (name);
+ VEC_unordered_remove (svr4_info_p, svr4_info, ix);
+ return;
}
- rtc_symp = SOLIB_EXTRACT_ADDRESS (inferior_rtc_symb.rtc_next);
}
+}
- /* Install any minimal symbols that have been collected as the current
- minimal symbols for the runtime common objfile. */
+/* This is an "inferior_exit" observer. Inferior PID (target id) is
+ being removed from the inferior list, because it exited, was
+ killed, detached, or we just dropped the connection to the debug
+ interface --- discard any solib-svr4 related bookkeeping for this
+ inferior. */
- install_minimal_symbols (rt_common_objfile);
+static void
+solib_svr4_inferior_exit (int pid)
+{
+ remove_svr4_info (pid);
}
-#endif /* SVR4_SHARED_LIBS */
-
+/* Local function prototypes */
-#ifdef SVR4_SHARED_LIBS
+static int match_main (char *);
static CORE_ADDR bfd_lookup_symbol (bfd *, char *);
An expensive way to lookup the value of a single symbol for
bfd's that are only temporary anyway. This is used by the
shared library support to find the address of the debugger
- interface structures in the shared library.
+ notification routine in the shared library.
+
+ The returned symbol may be in a code or data section; functions
+ will normally be in a code section, but may be in a data section
+ if this architecture uses function descriptors.
Note that 0 is specifically allowed as an error return (no
such symbol).
if (storage_needed > 0)
{
symbol_table = (asymbol **) xmalloc (storage_needed);
- back_to = make_cleanup (xfree, (PTR) symbol_table);
+ back_to = make_cleanup (xfree, symbol_table);
number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
for (i = 0; i < number_of_symbols; i++)
{
sym = *symbol_table++;
- if (STREQ (sym->name, symname))
+ if (strcmp (sym->name, symname) == 0
+ && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)
{
- /* Bfd symbols are section relative. */
+ /* BFD symbols are section relative. */
symaddr = sym->value + sym->section->vma;
break;
}
if (storage_needed > 0)
{
symbol_table = (asymbol **) xmalloc (storage_needed);
- back_to = make_cleanup (xfree, (PTR) symbol_table);
+ back_to = make_cleanup (xfree, symbol_table);
number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, symbol_table);
for (i = 0; i < number_of_symbols; i++)
{
sym = *symbol_table++;
- if (STREQ (sym->name, symname))
+
+ if (strcmp (sym->name, symname) == 0
+ && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)
{
- /* Bfd symbols are section relative. */
+ /* BFD symbols are section relative. */
symaddr = sym->value + sym->section->vma;
break;
}
return symaddr;
}
-#ifdef HANDLE_SVR4_EXEC_EMULATORS
-/*
- Solaris BCP (the part of Solaris which allows it to run SunOS4
- a.out files) throws in another wrinkle. Solaris does not fill
- in the usual a.out link map structures when running BCP programs,
- the only way to get at them is via groping around in the dynamic
- linker.
- The dynamic linker and it's structures are located in the shared
- C library, which gets run as the executable's "interpreter" by
- the kernel.
-
- Note that we can assume nothing about the process state at the time
- we need to find these structures. We may be stopped on the first
- instruction of the interpreter (C shared library), the first
- instruction of the executable itself, or somewhere else entirely
- (if we attached to the process for example).
- */
+/* Read program header TYPE from inferior memory. The header is found
+ by scanning the OS auxillary vector.
-static char *debug_base_symbols[] =
-{
- "r_debug", /* Solaris 2.3 */
- "_r_debug", /* Solaris 2.1, 2.2 */
- NULL
-};
+ Return a pointer to allocated memory holding the program header contents,
+ or NULL on failure. If sucessful, and unless P_SECT_SIZE is NULL, the
+ size of those contents is returned to P_SECT_SIZE. Likewise, the target
+ architecture size (32-bit or 64-bit) is returned to P_ARCH_SIZE. */
-static int look_for_base (int, CORE_ADDR);
+static gdb_byte *
+read_program_header (int type, int *p_sect_size, int *p_arch_size)
+{
+ CORE_ADDR at_phdr, at_phent, at_phnum;
+ int arch_size, sect_size;
+ CORE_ADDR sect_addr;
+ gdb_byte *buf;
-/*
+ /* Get required auxv elements from target. */
+ if (target_auxv_search (¤t_target, AT_PHDR, &at_phdr) <= 0)
+ return 0;
+ if (target_auxv_search (¤t_target, AT_PHENT, &at_phent) <= 0)
+ return 0;
+ if (target_auxv_search (¤t_target, AT_PHNUM, &at_phnum) <= 0)
+ return 0;
+ if (!at_phdr || !at_phnum)
+ return 0;
- LOCAL FUNCTION
+ /* Determine ELF architecture type. */
+ if (at_phent == sizeof (Elf32_External_Phdr))
+ arch_size = 32;
+ else if (at_phent == sizeof (Elf64_External_Phdr))
+ arch_size = 64;
+ else
+ return 0;
- look_for_base -- examine file for each mapped address segment
+ /* Find .dynamic section via the PT_DYNAMIC PHDR. */
+ if (arch_size == 32)
+ {
+ Elf32_External_Phdr phdr;
+ int i;
- SYNOPSYS
+ /* Search for requested PHDR. */
+ for (i = 0; i < at_phnum; i++)
+ {
+ if (target_read_memory (at_phdr + i * sizeof (phdr),
+ (gdb_byte *)&phdr, sizeof (phdr)))
+ return 0;
- static int look_for_base (int fd, CORE_ADDR baseaddr)
+ if (extract_unsigned_integer ((gdb_byte *)phdr.p_type, 4) == type)
+ break;
+ }
- DESCRIPTION
+ if (i == at_phnum)
+ return 0;
- This function is passed to proc_iterate_over_mappings, which
- causes it to get called once for each mapped address space, with
- an open file descriptor for the file mapped to that space, and the
- base address of that mapped space.
+ /* Retrieve address and size. */
+ sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr, 4);
+ sect_size = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz, 4);
+ }
+ else
+ {
+ Elf64_External_Phdr phdr;
+ int i;
- Our job is to find the debug base symbol in the file that this
- fd is open on, if it exists, and if so, initialize the dynamic
- linker structure base address debug_base.
+ /* Search for requested PHDR. */
+ for (i = 0; i < at_phnum; i++)
+ {
+ if (target_read_memory (at_phdr + i * sizeof (phdr),
+ (gdb_byte *)&phdr, sizeof (phdr)))
+ return 0;
- Note that this is a computationally expensive proposition, since
- we basically have to open a bfd on every call, so we specifically
- avoid opening the exec file.
- */
+ if (extract_unsigned_integer ((gdb_byte *)phdr.p_type, 4) == type)
+ break;
+ }
-static int
-look_for_base (int fd, CORE_ADDR baseaddr)
-{
- bfd *interp_bfd;
- CORE_ADDR address = 0;
- char **symbolp;
+ if (i == at_phnum)
+ return 0;
- /* If the fd is -1, then there is no file that corresponds to this
- mapped memory segment, so skip it. Also, if the fd corresponds
- to the exec file, skip it as well. */
+ /* Retrieve address and size. */
+ sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr, 8);
+ sect_size = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz, 8);
+ }
- if (fd == -1
- || (exec_bfd != NULL
- && fdmatch (fileno ((FILE *) (exec_bfd->iostream)), fd)))
+ /* Read in requested program header. */
+ buf = xmalloc (sect_size);
+ if (target_read_memory (sect_addr, buf, sect_size))
{
- return (0);
+ xfree (buf);
+ return NULL;
}
- /* Try to open whatever random file this fd corresponds to. Note that
- we have no way currently to find the filename. Don't gripe about
- any problems we might have, just fail. */
+ if (p_arch_size)
+ *p_arch_size = arch_size;
+ if (p_sect_size)
+ *p_sect_size = sect_size;
- if ((interp_bfd = bfd_fdopenr ("unnamed", gnutarget, fd)) == NULL)
- {
- return (0);
- }
- if (!bfd_check_format (interp_bfd, bfd_object))
- {
- /* FIXME-leak: on failure, might not free all memory associated with
- interp_bfd. */
- bfd_close (interp_bfd);
- return (0);
- }
+ return buf;
+}
- /* Now try to find our debug base symbol in this file, which we at
- least know to be a valid ELF executable or shared library. */
- for (symbolp = debug_base_symbols; *symbolp != NULL; symbolp++)
- {
- address = bfd_lookup_symbol (interp_bfd, *symbolp);
- if (address != 0)
- {
- break;
- }
- }
- if (address == 0)
- {
- /* FIXME-leak: on failure, might not free all memory associated with
- interp_bfd. */
- bfd_close (interp_bfd);
- return (0);
- }
+/* Return program interpreter string. */
+static gdb_byte *
+find_program_interpreter (void)
+{
+ gdb_byte *buf = NULL;
+
+ /* If we have an exec_bfd, use its section table. */
+ if (exec_bfd
+ && bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
+ {
+ struct bfd_section *interp_sect;
+
+ interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
+ if (interp_sect != NULL)
+ {
+ CORE_ADDR sect_addr = bfd_section_vma (exec_bfd, interp_sect);
+ int sect_size = bfd_section_size (exec_bfd, interp_sect);
+
+ buf = xmalloc (sect_size);
+ bfd_get_section_contents (exec_bfd, interp_sect, buf, 0, sect_size);
+ }
+ }
+
+ /* If we didn't find it, use the target auxillary vector. */
+ if (!buf)
+ buf = read_program_header (PT_INTERP, NULL, NULL);
+
+ return buf;
+}
- /* Eureka! We found the symbol. But now we may need to relocate it
- by the base address. If the symbol's value is less than the base
- address of the shared library, then it hasn't yet been relocated
- by the dynamic linker, and we have to do it ourself. FIXME: Note
- that we make the assumption that the first segment that corresponds
- to the shared library has the base address to which the library
- was relocated. */
- if (address < baseaddr)
- {
- address += baseaddr;
- }
- debug_base = address;
- /* FIXME-leak: on failure, might not free all memory associated with
- interp_bfd. */
- bfd_close (interp_bfd);
- return (1);
+/* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
+ returned and the corresponding PTR is set. */
+
+static int
+scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
+{
+ int arch_size, step, sect_size;
+ long dyn_tag;
+ CORE_ADDR dyn_ptr, dyn_addr;
+ gdb_byte *bufend, *bufstart, *buf;
+ Elf32_External_Dyn *x_dynp_32;
+ Elf64_External_Dyn *x_dynp_64;
+ struct bfd_section *sect;
+
+ if (abfd == NULL)
+ return 0;
+ arch_size = bfd_get_arch_size (abfd);
+ if (arch_size == -1)
+ return 0;
+
+ /* Find the start address of the .dynamic section. */
+ sect = bfd_get_section_by_name (abfd, ".dynamic");
+ if (sect == NULL)
+ return 0;
+ dyn_addr = bfd_section_vma (abfd, sect);
+
+ /* Read in .dynamic from the BFD. We will get the actual value
+ from memory later. */
+ sect_size = bfd_section_size (abfd, sect);
+ buf = bufstart = alloca (sect_size);
+ if (!bfd_get_section_contents (abfd, sect,
+ buf, 0, sect_size))
+ return 0;
+
+ /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
+ step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
+ : sizeof (Elf64_External_Dyn);
+ for (bufend = buf + sect_size;
+ buf < bufend;
+ buf += step)
+ {
+ if (arch_size == 32)
+ {
+ x_dynp_32 = (Elf32_External_Dyn *) buf;
+ dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);
+ dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);
+ }
+ else
+ {
+ x_dynp_64 = (Elf64_External_Dyn *) buf;
+ dyn_tag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
+ dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);
+ }
+ if (dyn_tag == DT_NULL)
+ return 0;
+ if (dyn_tag == dyntag)
+ {
+ /* If requested, try to read the runtime value of this .dynamic
+ entry. */
+ if (ptr)
+ {
+ struct type *ptr_type;
+ gdb_byte ptr_buf[8];
+ CORE_ADDR ptr_addr;
+
+ ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+ ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
+ if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)
+ dyn_ptr = extract_typed_address (ptr_buf, ptr_type);
+ *ptr = dyn_ptr;
+ }
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+/* Scan for DYNTAG in .dynamic section of the target's main executable,
+ found by consulting the OS auxillary vector. If DYNTAG is found 1 is
+ returned and the corresponding PTR is set. */
+
+static int
+scan_dyntag_auxv (int dyntag, CORE_ADDR *ptr)
+{
+ int sect_size, arch_size, step;
+ long dyn_tag;
+ CORE_ADDR dyn_ptr;
+ gdb_byte *bufend, *bufstart, *buf;
+
+ /* Read in .dynamic section. */
+ buf = bufstart = read_program_header (PT_DYNAMIC, §_size, &arch_size);
+ if (!buf)
+ return 0;
+
+ /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
+ step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
+ : sizeof (Elf64_External_Dyn);
+ for (bufend = buf + sect_size;
+ buf < bufend;
+ buf += step)
+ {
+ if (arch_size == 32)
+ {
+ Elf32_External_Dyn *dynp = (Elf32_External_Dyn *) buf;
+ dyn_tag = extract_unsigned_integer ((gdb_byte *) dynp->d_tag, 4);
+ dyn_ptr = extract_unsigned_integer ((gdb_byte *) dynp->d_un.d_ptr, 4);
+ }
+ else
+ {
+ Elf64_External_Dyn *dynp = (Elf64_External_Dyn *) buf;
+ dyn_tag = extract_unsigned_integer ((gdb_byte *) dynp->d_tag, 8);
+ dyn_ptr = extract_unsigned_integer ((gdb_byte *) dynp->d_un.d_ptr, 8);
+ }
+ if (dyn_tag == DT_NULL)
+ break;
+
+ if (dyn_tag == dyntag)
+ {
+ if (ptr)
+ *ptr = dyn_ptr;
+
+ xfree (bufstart);
+ return 1;
+ }
+ }
+
+ xfree (bufstart);
+ return 0;
}
-#endif /* HANDLE_SVR4_EXEC_EMULATORS */
+
/*
static CORE_ADDR
elf_locate_base (void)
{
- sec_ptr dyninfo_sect;
- int dyninfo_sect_size;
- CORE_ADDR dyninfo_addr;
- char *buf;
- char *bufend;
- int arch_size;
-
- /* Find the start address of the .dynamic section. */
- dyninfo_sect = bfd_get_section_by_name (exec_bfd, ".dynamic");
- if (dyninfo_sect == NULL)
- return 0;
- dyninfo_addr = bfd_section_vma (exec_bfd, dyninfo_sect);
-
- /* Read in .dynamic section, silently ignore errors. */
- dyninfo_sect_size = bfd_section_size (exec_bfd, dyninfo_sect);
- buf = alloca (dyninfo_sect_size);
- if (target_read_memory (dyninfo_addr, buf, dyninfo_sect_size))
- return 0;
-
- /* Find the DT_DEBUG entry in the the .dynamic section.
- For mips elf we look for DT_MIPS_RLD_MAP, mips elf apparently has
- no DT_DEBUG entries. */
-
- arch_size = bfd_get_arch_size (exec_bfd);
- if (arch_size == -1) /* failure */
- return 0;
-
- if (arch_size == 32)
- { /* 32-bit elf */
- for (bufend = buf + dyninfo_sect_size;
- buf < bufend;
- buf += sizeof (Elf32_External_Dyn))
- {
- Elf32_External_Dyn *x_dynp = (Elf32_External_Dyn *) buf;
- long dyn_tag;
- CORE_ADDR dyn_ptr;
+ struct minimal_symbol *msymbol;
+ CORE_ADDR dyn_ptr;
- dyn_tag = bfd_h_get_32 (exec_bfd, (bfd_byte *) x_dynp->d_tag);
- if (dyn_tag == DT_NULL)
- break;
- else if (dyn_tag == DT_DEBUG)
- {
- dyn_ptr = bfd_h_get_32 (exec_bfd,
- (bfd_byte *) x_dynp->d_un.d_ptr);
- return dyn_ptr;
- }
-#ifdef DT_MIPS_RLD_MAP
- else if (dyn_tag == DT_MIPS_RLD_MAP)
- {
- char *pbuf;
-
- pbuf = alloca (TARGET_PTR_BIT / HOST_CHAR_BIT);
- /* DT_MIPS_RLD_MAP contains a pointer to the address
- of the dynamic link structure. */
- dyn_ptr = bfd_h_get_32 (exec_bfd,
- (bfd_byte *) x_dynp->d_un.d_ptr);
- if (target_read_memory (dyn_ptr, pbuf, sizeof (pbuf)))
- return 0;
- return extract_unsigned_integer (pbuf, sizeof (pbuf));
- }
-#endif
- }
- }
- else /* 64-bit elf */
+ /* Look for DT_MIPS_RLD_MAP first. MIPS executables use this
+ instead of DT_DEBUG, although they sometimes contain an unused
+ DT_DEBUG. */
+ if (scan_dyntag (DT_MIPS_RLD_MAP, exec_bfd, &dyn_ptr)
+ || scan_dyntag_auxv (DT_MIPS_RLD_MAP, &dyn_ptr))
{
- for (bufend = buf + dyninfo_sect_size;
- buf < bufend;
- buf += sizeof (Elf64_External_Dyn))
- {
- Elf64_External_Dyn *x_dynp = (Elf64_External_Dyn *) buf;
- long dyn_tag;
- CORE_ADDR dyn_ptr;
-
- dyn_tag = bfd_h_get_64 (exec_bfd, (bfd_byte *) x_dynp->d_tag);
- if (dyn_tag == DT_NULL)
- break;
- else if (dyn_tag == DT_DEBUG)
- {
- dyn_ptr = bfd_h_get_64 (exec_bfd,
- (bfd_byte *) x_dynp->d_un.d_ptr);
- return dyn_ptr;
- }
- }
+ struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+ gdb_byte *pbuf;
+ int pbuf_size = TYPE_LENGTH (ptr_type);
+ pbuf = alloca (pbuf_size);
+ /* DT_MIPS_RLD_MAP contains a pointer to the address
+ of the dynamic link structure. */
+ if (target_read_memory (dyn_ptr, pbuf, pbuf_size))
+ return 0;
+ return extract_typed_address (pbuf, ptr_type);
}
+ /* Find DT_DEBUG. */
+ if (scan_dyntag (DT_DEBUG, exec_bfd, &dyn_ptr)
+ || scan_dyntag_auxv (DT_DEBUG, &dyn_ptr))
+ return dyn_ptr;
+
+ /* This may be a static executable. Look for the symbol
+ conventionally named _r_debug, as a last resort. */
+ msymbol = lookup_minimal_symbol ("_r_debug", NULL, symfile_objfile);
+ if (msymbol != NULL)
+ return SYMBOL_VALUE_ADDRESS (msymbol);
+
/* DT_DEBUG entry not found. */
return 0;
}
-#endif /* SVR4_SHARED_LIBS */
-
/*
LOCAL FUNCTION
SYNOPSIS
- CORE_ADDR locate_base (void)
+ CORE_ADDR locate_base (struct svr4_info *)
DESCRIPTION
*/
static CORE_ADDR
-locate_base (void)
+locate_base (struct svr4_info *info)
{
-
-#ifndef SVR4_SHARED_LIBS
-
- struct minimal_symbol *msymbol;
- CORE_ADDR address = 0;
- char **symbolp;
-
- /* For SunOS, we want to limit the search for the debug base symbol to the
- executable being debugged, since there is a duplicate named symbol in the
- shared library. We don't want the shared library versions. */
-
- for (symbolp = debug_base_symbols; *symbolp != NULL; symbolp++)
- {
- msymbol = lookup_minimal_symbol (*symbolp, NULL, symfile_objfile);
- if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
- {
- address = SYMBOL_VALUE_ADDRESS (msymbol);
- return (address);
- }
- }
- return (0);
-
-#else /* SVR4_SHARED_LIBS */
-
/* Check to see if we have a currently valid address, and if so, avoid
doing all this work again and just return the cached address. If
we have no cached address, try to locate it in the dynamic info
- section for ELF executables. */
+ section for ELF executables. There's no point in doing any of this
+ though if we don't have some link map offsets to work with. */
- if (debug_base == 0)
+ if (info->debug_base == 0 && svr4_have_link_map_offsets ())
{
if (exec_bfd != NULL
&& bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
- debug_base = elf_locate_base ();
-#ifdef HANDLE_SVR4_EXEC_EMULATORS
- /* Try it the hard way for emulated executables. */
- else if (inferior_pid != 0 && target_has_execution)
- proc_iterate_over_mappings (look_for_base);
-#endif
+ info->debug_base = elf_locate_base ();
}
- return (debug_base);
-
-#endif /* !SVR4_SHARED_LIBS */
-
+ return info->debug_base;
}
-/*
-
- LOCAL FUNCTION
-
- first_link_map_member -- locate first member in dynamic linker's map
+/* Find the first element in the inferior's dynamic link map, and
+ return its address in the inferior.
- SYNOPSIS
-
- static CORE_ADDR first_link_map_member (void)
-
- DESCRIPTION
-
- Find the first element in the inferior's dynamic link map, and
- return its address in the inferior. This function doesn't copy the
- link map entry itself into our address space; current_sos actually
- does the reading. */
+ FIXME: Perhaps we should validate the info somehow, perhaps by
+ checking r_version for a known version number, or r_state for
+ RT_CONSISTENT. */
static CORE_ADDR
-first_link_map_member (void)
+solib_svr4_r_map (struct svr4_info *info)
{
- CORE_ADDR lm = 0;
-
-#ifndef SVR4_SHARED_LIBS
-
- read_memory (debug_base, (char *) &dynamic_copy, sizeof (dynamic_copy));
- if (dynamic_copy.ld_version >= 2)
- {
- /* It is a version that we can deal with, so read in the secondary
- structure and find the address of the link map list from it. */
- read_memory (SOLIB_EXTRACT_ADDRESS (dynamic_copy.ld_un.ld_2),
- (char *) &ld_2_copy, sizeof (struct link_dynamic_2));
- lm = SOLIB_EXTRACT_ADDRESS (ld_2_copy.ld_loaded);
- }
+ struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
+ struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
-#else /* SVR4_SHARED_LIBS */
- struct link_map_offsets *lmo = SVR4_FETCH_LINK_MAP_OFFSETS ();
- char *r_map_buf = xmalloc (lmo->r_map_size);
- struct cleanup *cleanups = make_cleanup (xfree, r_map_buf);
+ return read_memory_typed_address (info->debug_base + lmo->r_map_offset,
+ ptr_type);
+}
- read_memory (debug_base + lmo->r_map_offset, r_map_buf, lmo->r_map_size);
+/* Find r_brk from the inferior's debug base. */
- lm = extract_address (r_map_buf, lmo->r_map_size);
+static CORE_ADDR
+solib_svr4_r_brk (struct svr4_info *info)
+{
+ struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
+ struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
- /* FIXME: Perhaps we should validate the info somehow, perhaps by
- checking r_version for a known version number, or r_state for
- RT_CONSISTENT. */
+ return read_memory_typed_address (info->debug_base + lmo->r_brk_offset,
+ ptr_type);
+}
- do_cleanups (cleanups);
+/* Find the link map for the dynamic linker (if it is not in the
+ normal list of loaded shared objects). */
-#endif /* !SVR4_SHARED_LIBS */
+static CORE_ADDR
+solib_svr4_r_ldsomap (struct svr4_info *info)
+{
+ struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
+ struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+ ULONGEST version;
+
+ /* Check version, and return zero if `struct r_debug' doesn't have
+ the r_ldsomap member. */
+ version
+ = read_memory_unsigned_integer (info->debug_base + lmo->r_version_offset,
+ lmo->r_version_size);
+ if (version < 2 || lmo->r_ldsomap_offset == -1)
+ return 0;
- return (lm);
+ return read_memory_typed_address (info->debug_base + lmo->r_ldsomap_offset,
+ ptr_type);
}
-#ifdef SVR4_SHARED_LIBS
/*
LOCAL FUNCTION
char *filename;
int errcode;
int from_tty = *(int *)from_ttyp;
- struct link_map_offsets *lmo = SVR4_FETCH_LINK_MAP_OFFSETS ();
- char *l_name_buf = xmalloc (lmo->l_name_size);
+ struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
+ struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+ int l_name_size = TYPE_LENGTH (ptr_type);
+ gdb_byte *l_name_buf = xmalloc (l_name_size);
struct cleanup *cleanups = make_cleanup (xfree, l_name_buf);
+ struct svr4_info *info = get_svr4_info (PIDGET (inferior_ptid));
if (symfile_objfile)
- if (!query ("Attempt to reload symbols from process? "))
+ if (!query (_("Attempt to reload symbols from process? ")))
return 0;
- if ((debug_base = locate_base ()) == 0)
+ /* Always locate the debug struct, in case it has moved. */
+ info->debug_base = 0;
+ if (locate_base (info) == 0)
return 0; /* failed somehow... */
/* First link map member should be the executable. */
- if ((lm = first_link_map_member ()) == 0)
+ lm = solib_svr4_r_map (info);
+ if (lm == 0)
return 0; /* failed somehow... */
/* Read address of name from target memory to GDB. */
- read_memory (lm + lmo->l_name_offset, l_name_buf, lmo->l_name_size);
+ read_memory (lm + lmo->l_name_offset, l_name_buf, l_name_size);
/* Convert the address to host format. */
- l_name = extract_address (l_name_buf, lmo->l_name_size);
+ l_name = extract_typed_address (l_name_buf, ptr_type);
/* Free l_name_buf. */
do_cleanups (cleanups);
/* Now fetch the filename from target memory. */
target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
+ make_cleanup (xfree, filename);
if (errcode)
{
- warning ("failed to read exec filename from attached file: %s",
+ warning (_("failed to read exec filename from attached file: %s"),
safe_strerror (errcode));
return 0;
}
- make_cleanup (xfree, filename);
/* Have a pathname: read the symbol file. */
symbol_file_add_main (filename, from_tty);
return 1;
}
-#else
-static int
-open_symbol_file_object (void *from_ttyp)
+/* If no shared library information is available from the dynamic
+ linker, build a fallback list from other sources. */
+
+static struct so_list *
+svr4_default_sos (void)
{
- return 1;
-}
+ struct inferior *inf = current_inferior ();
+ struct svr4_info *info = get_svr4_info (inf->pid);
+
+ struct so_list *head = NULL;
+ struct so_list **link_ptr = &head;
+
+ if (info->debug_loader_offset_p)
+ {
+ struct so_list *new = XZALLOC (struct so_list);
+
+ new->lm_info = xmalloc (sizeof (struct lm_info));
+
+ /* Nothing will ever check the cached copy of the link
+ map if we set l_addr. */
+ new->lm_info->l_addr = info->debug_loader_offset;
+ new->lm_info->lm_addr = 0;
+ new->lm_info->lm = NULL;
-#endif /* SVR4_SHARED_LIBS */
+ strncpy (new->so_name, info->debug_loader_name,
+ SO_NAME_MAX_PATH_SIZE - 1);
+ new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
+ strcpy (new->so_original_name, new->so_name);
+ *link_ptr = new;
+ link_ptr = &new->next;
+ }
+
+ return head;
+}
/* LOCAL FUNCTION
CORE_ADDR lm;
struct so_list *head = 0;
struct so_list **link_ptr = &head;
+ CORE_ADDR ldsomap = 0;
+ struct inferior *inf;
+ struct svr4_info *info;
- /* Make sure we've looked up the inferior's dynamic linker's base
- structure. */
- if (! debug_base)
- {
- debug_base = locate_base ();
+ if (ptid_equal (inferior_ptid, null_ptid))
+ return NULL;
- /* If we can't find the dynamic linker's base structure, this
- must not be a dynamically linked executable. Hmm. */
- if (! debug_base)
- return 0;
- }
+ inf = current_inferior ();
+ info = get_svr4_info (inf->pid);
+
+ /* Always locate the debug struct, in case it has moved. */
+ info->debug_base = 0;
+ locate_base (info);
+
+ /* If we can't find the dynamic linker's base structure, this
+ must not be a dynamically linked executable. Hmm. */
+ if (! info->debug_base)
+ return svr4_default_sos ();
/* Walk the inferior's link map list, and build our list of
`struct so_list' nodes. */
- lm = first_link_map_member ();
+ lm = solib_svr4_r_map (info);
+
while (lm)
{
- struct link_map_offsets *lmo = SVR4_FETCH_LINK_MAP_OFFSETS ();
- struct so_list *new
- = (struct so_list *) xmalloc (sizeof (struct so_list));
+ struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
+ struct so_list *new = XZALLOC (struct so_list);
struct cleanup *old_chain = make_cleanup (xfree, new);
- memset (new, 0, sizeof (*new));
-
new->lm_info = xmalloc (sizeof (struct lm_info));
make_cleanup (xfree, new->lm_info);
- new->lm_info->lm = xmalloc (lmo->link_map_size);
+ new->lm_info->l_addr = (CORE_ADDR)-1;
+ new->lm_info->lm_addr = lm;
+ new->lm_info->lm = xzalloc (lmo->link_map_size);
make_cleanup (xfree, new->lm_info->lm);
- memset (new->lm_info->lm, 0, lmo->link_map_size);
read_memory (lm, new->lm_info->lm, lmo->link_map_size);
SVR4, it has no name. For others (Solaris 2.3 for example), it
does have a name, so we can no longer use a missing name to
decide when to ignore it. */
- if (IGNORE_FIRST_LINK_MAP_ENTRY (new))
- free_so (new);
+ if (IGNORE_FIRST_LINK_MAP_ENTRY (new) && ldsomap == 0)
+ {
+ info->main_lm_addr = new->lm_info->lm_addr;
+ free_so (new);
+ }
else
{
int errcode;
target_read_string (LM_NAME (new), &buffer,
SO_NAME_MAX_PATH_SIZE - 1, &errcode);
if (errcode != 0)
- {
- warning ("current_sos: Can't read pathname for load map: %s\n",
- safe_strerror (errcode));
- }
+ warning (_("Can't read pathname for load map: %s."),
+ safe_strerror (errcode));
else
{
strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);
new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
- xfree (buffer);
strcpy (new->so_original_name, new->so_name);
}
+ xfree (buffer);
/* If this entry has no name, or its name matches the name
for the main executable, don't include it in the list. */
}
}
+ /* On Solaris, the dynamic linker is not in the normal list of
+ shared objects, so make sure we pick it up too. Having
+ symbol information for the dynamic linker is quite crucial
+ for skipping dynamic linker resolver code. */
+ if (lm == 0 && ldsomap == 0)
+ lm = ldsomap = solib_svr4_r_ldsomap (info);
+
discard_cleanups (old_chain);
}
+ if (head == NULL)
+ return svr4_default_sos ();
+
return head;
}
+/* Get the address of the link_map for a given OBJFILE. */
+
+CORE_ADDR
+svr4_fetch_objfile_link_map (struct objfile *objfile)
+{
+ struct so_list *so;
+ struct svr4_info *info = get_svr4_info (PIDGET (inferior_ptid));
+
+ /* Cause svr4_current_sos() to be run if it hasn't been already. */
+ if (info->main_lm_addr == 0)
+ solib_add (NULL, 0, ¤t_target, auto_solib_add);
+
+ /* svr4_current_sos() will set main_lm_addr for the main executable. */
+ if (objfile == symfile_objfile)
+ return info->main_lm_addr;
+
+ /* The other link map addresses may be found by examining the list
+ of shared libraries. */
+ for (so = master_so_list (); so; so = so->next)
+ if (so->objfile == objfile)
+ return so->lm_info->lm_addr;
+
+ /* Not found! */
+ return 0;
+}
/* On some systems, the only way to recognize the link map entry for
the main executable file is by looking at its name. Return
return (0);
}
-
/* Return 1 if PC lies in the dynamic symbol resolution code of the
SVR4 run time loader. */
-#ifdef SVR4_SHARED_LIBS
static CORE_ADDR interp_text_sect_low;
static CORE_ADDR interp_text_sect_high;
static CORE_ADDR interp_plt_sect_low;
static CORE_ADDR interp_plt_sect_high;
-static int
+int
svr4_in_dynsym_resolve_code (CORE_ADDR pc)
{
return ((pc >= interp_text_sect_low && pc < interp_text_sect_high)
|| (pc >= interp_plt_sect_low && pc < interp_plt_sect_high)
|| in_plt_section (pc, NULL));
}
-#else /* !SVR4_SHARED_LIBS */
-static int
-svr4_in_dynsym_resolve_code (CORE_ADDR pc)
-{
- return 0;
-}
-#endif /* SVR4_SHARED_LIBS */
-
-/*
-
- LOCAL FUNCTION
-
- disable_break -- remove the "mapping changed" breakpoint
-
- SYNOPSIS
-
- static int disable_break ()
-
- DESCRIPTION
-
- Removes the breakpoint that gets hit when the dynamic linker
- completes a mapping change.
-
- */
-#ifndef SVR4_SHARED_LIBS
+/* Given an executable's ABFD and target, compute the entry-point
+ address. */
-static int
-disable_break (void)
+static CORE_ADDR
+exec_entry_point (struct bfd *abfd, struct target_ops *targ)
{
- int status = 1;
-
- int in_debugger = 0;
-
- /* Read the debugger structure from the inferior to retrieve the
- address of the breakpoint and the original contents of the
- breakpoint address. Remove the breakpoint by writing the original
- contents back. */
-
- read_memory (debug_addr, (char *) &debug_copy, sizeof (debug_copy));
-
- /* Set `in_debugger' to zero now. */
-
- write_memory (flag_addr, (char *) &in_debugger, sizeof (in_debugger));
-
- breakpoint_addr = SOLIB_EXTRACT_ADDRESS (debug_copy.ldd_bp_addr);
- write_memory (breakpoint_addr, (char *) &debug_copy.ldd_bp_inst,
- sizeof (debug_copy.ldd_bp_inst));
-
- /* For the SVR4 version, we always know the breakpoint address. For the
- SunOS version we don't know it until the above code is executed.
- Grumble if we are stopped anywhere besides the breakpoint address. */
-
- if (stop_pc != breakpoint_addr)
- {
- warning ("stopped at unknown breakpoint while handling shared libraries");
- }
-
- return (status);
+ /* KevinB wrote ... for most targets, the address returned by
+ bfd_get_start_address() is the entry point for the start
+ function. But, for some targets, bfd_get_start_address() returns
+ the address of a function descriptor from which the entry point
+ address may be extracted. This address is extracted by
+ gdbarch_convert_from_func_ptr_addr(). The method
+ gdbarch_convert_from_func_ptr_addr() is the merely the identify
+ function for targets which don't use function descriptors. */
+ return gdbarch_convert_from_func_ptr_addr (target_gdbarch,
+ bfd_get_start_address (abfd),
+ targ);
}
-#endif /* #ifdef SVR4_SHARED_LIBS */
-
/*
LOCAL FUNCTION
*/
static int
-enable_break (void)
+enable_break (struct svr4_info *info)
{
- int success = 0;
-
-#ifndef SVR4_SHARED_LIBS
-
- int j;
- int in_debugger;
-
- /* Get link_dynamic structure */
-
- j = target_read_memory (debug_base, (char *) &dynamic_copy,
- sizeof (dynamic_copy));
- if (j)
- {
- /* unreadable */
- return (0);
- }
-
- /* Calc address of debugger interface structure */
-
- debug_addr = SOLIB_EXTRACT_ADDRESS (dynamic_copy.ldd);
-
- /* Calc address of `in_debugger' member of debugger interface structure */
-
- flag_addr = debug_addr + (CORE_ADDR) ((char *) &debug_copy.ldd_in_debugger -
- (char *) &debug_copy);
-
- /* Write a value of 1 to this member. */
-
- in_debugger = 1;
- write_memory (flag_addr, (char *) &in_debugger, sizeof (in_debugger));
- success = 1;
-
-#else /* SVR4_SHARED_LIBS */
-
-#ifdef BKPT_AT_SYMBOL
-
struct minimal_symbol *msymbol;
char **bkpt_namep;
asection *interp_sect;
+ gdb_byte *interp_name;
+ CORE_ADDR sym_addr;
+ struct inferior *inf = current_inferior ();
/* First, remove all the solib event breakpoints. Their addresses
may have changed since the last time we ran the program. */
remove_solib_event_breakpoints ();
-#ifdef SVR4_SHARED_LIBS
interp_text_sect_low = interp_text_sect_high = 0;
interp_plt_sect_low = interp_plt_sect_high = 0;
- /* Find the .interp section; if not found, warn the user and drop
+ /* If we already have a shared library list in the target, and
+ r_debug contains r_brk, set the breakpoint there - this should
+ mean r_brk has already been relocated. Assume the dynamic linker
+ is the object containing r_brk. */
+
+ solib_add (NULL, 0, ¤t_target, auto_solib_add);
+ sym_addr = 0;
+ if (info->debug_base && solib_svr4_r_map (info) != 0)
+ sym_addr = solib_svr4_r_brk (info);
+
+ if (sym_addr != 0)
+ {
+ struct obj_section *os;
+
+ sym_addr = gdbarch_addr_bits_remove
+ (target_gdbarch, gdbarch_convert_from_func_ptr_addr (target_gdbarch,
+ sym_addr,
+ ¤t_target));
+
+ os = find_pc_section (sym_addr);
+ if (os != NULL)
+ {
+ /* Record the relocated start and end address of the dynamic linker
+ text and plt section for svr4_in_dynsym_resolve_code. */
+ bfd *tmp_bfd;
+ CORE_ADDR load_addr;
+
+ tmp_bfd = os->objfile->obfd;
+ load_addr = ANOFFSET (os->objfile->section_offsets,
+ os->objfile->sect_index_text);
+
+ interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
+ if (interp_sect)
+ {
+ interp_text_sect_low =
+ bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
+ interp_text_sect_high =
+ interp_text_sect_low + bfd_section_size (tmp_bfd, interp_sect);
+ }
+ interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
+ if (interp_sect)
+ {
+ interp_plt_sect_low =
+ bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
+ interp_plt_sect_high =
+ interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
+ }
+
+ create_solib_event_breakpoint (sym_addr);
+ return 1;
+ }
+ }
+
+ /* Find the program interpreter; if not found, warn the user and drop
into the old breakpoint at symbol code. */
- interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
- if (interp_sect)
+ interp_name = find_program_interpreter ();
+ if (interp_name)
{
- unsigned int interp_sect_size;
- char *buf;
- CORE_ADDR load_addr;
+ CORE_ADDR load_addr = 0;
+ int load_addr_found = 0;
+ int loader_found_in_list = 0;
+ struct so_list *so;
bfd *tmp_bfd = NULL;
- int tmp_fd = -1;
- char *tmp_pathname = NULL;
- CORE_ADDR sym_addr = 0;
+ struct target_ops *tmp_bfd_target;
+ volatile struct gdb_exception ex;
- /* Read the contents of the .interp section into a local buffer;
- the contents specify the dynamic linker this program uses. */
- interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
- buf = alloca (interp_sect_size);
- bfd_get_section_contents (exec_bfd, interp_sect,
- buf, 0, interp_sect_size);
+ sym_addr = 0;
/* Now we need to figure out where the dynamic linker was
loaded so that we can load its symbols and place a breakpoint
be trivial on GNU/Linux). Therefore, we have to try an alternate
mechanism to find the dynamic linker's base address. */
- tmp_fd = solib_open (buf, &tmp_pathname);
- if (tmp_fd >= 0)
- tmp_bfd = bfd_fdopenr (tmp_pathname, gnutarget, tmp_fd);
-
+ TRY_CATCH (ex, RETURN_MASK_ALL)
+ {
+ tmp_bfd = solib_bfd_open (interp_name);
+ }
if (tmp_bfd == NULL)
goto bkpt_at_symbol;
- /* Make sure the dynamic linker's really a useful object. */
- if (!bfd_check_format (tmp_bfd, bfd_object))
+ /* Now convert the TMP_BFD into a target. That way target, as
+ well as BFD operations can be used. Note that closing the
+ target will also close the underlying bfd. */
+ tmp_bfd_target = target_bfd_reopen (tmp_bfd);
+
+ /* On a running target, we can get the dynamic linker's base
+ address from the shared library table. */
+ so = master_so_list ();
+ while (so)
+ {
+ if (svr4_same_1 (interp_name, so->so_original_name))
+ {
+ load_addr_found = 1;
+ loader_found_in_list = 1;
+ load_addr = LM_ADDR_CHECK (so, tmp_bfd);
+ break;
+ }
+ so = so->next;
+ }
+
+ /* If we were not able to find the base address of the loader
+ from our so_list, then try using the AT_BASE auxilliary entry. */
+ if (!load_addr_found)
+ if (target_auxv_search (¤t_target, AT_BASE, &load_addr) > 0)
+ load_addr_found = 1;
+
+ /* Otherwise we find the dynamic linker's base address by examining
+ the current pc (which should point at the entry point for the
+ dynamic linker) and subtracting the offset of the entry point.
+
+ This is more fragile than the previous approaches, but is a good
+ fallback method because it has actually been working well in
+ most cases. */
+ if (!load_addr_found)
{
- warning ("Unable to grok dynamic linker %s as an object file", buf);
- bfd_close (tmp_bfd);
- goto bkpt_at_symbol;
+ struct regcache *regcache = get_thread_regcache (inferior_ptid);
+ load_addr = (regcache_read_pc (regcache)
+ - exec_entry_point (tmp_bfd, tmp_bfd_target));
}
- /* We find the dynamic linker's base address by examining the
- current pc (which point at the entry point for the dynamic
- linker) and subtracting the offset of the entry point. */
- load_addr = read_pc () - tmp_bfd->start_address;
+ if (!loader_found_in_list)
+ {
+ info->debug_loader_name = xstrdup (interp_name);
+ info->debug_loader_offset_p = 1;
+ info->debug_loader_offset = load_addr;
+ solib_add (NULL, 0, ¤t_target, auto_solib_add);
+ }
/* Record the relocated start and end address of the dynamic linker
text and plt section for svr4_in_dynsym_resolve_code. */
break;
}
- /* We're done with the temporary bfd. */
- bfd_close (tmp_bfd);
+ if (sym_addr != 0)
+ /* Convert 'sym_addr' from a function pointer to an address.
+ Because we pass tmp_bfd_target instead of the current
+ target, this will always produce an unrelocated value. */
+ sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch,
+ sym_addr,
+ tmp_bfd_target);
+
+ /* We're done with both the temporary bfd and target. Remember,
+ closing the target closes the underlying bfd. */
+ target_close (tmp_bfd_target, 0);
if (sym_addr != 0)
{
create_solib_event_breakpoint (load_addr + sym_addr);
+ xfree (interp_name);
return 1;
}
/* For whatever reason we couldn't set a breakpoint in the dynamic
linker. Warn and drop into the old code. */
bkpt_at_symbol:
- warning ("Unable to find dynamic linker breakpoint function.\nGDB will be unable to debug shared library initializers\nand track explicitly loaded dynamic code.");
+ xfree (interp_name);
+ warning (_("Unable to find dynamic linker breakpoint function.\n"
+ "GDB will be unable to debug shared library initializers\n"
+ "and track explicitly loaded dynamic code."));
}
-#endif
- /* Scan through the list of symbols, trying to look up the symbol and
- set a breakpoint there. Terminate loop when we/if we succeed. */
+ /* Scan through the lists of symbols, trying to look up the symbol and
+ set a breakpoint there. Terminate loop when we/if we succeed. */
- breakpoint_addr = 0;
- for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
+ for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
{
msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
}
}
- /* Nothing good happened. */
- success = 0;
-
-#endif /* BKPT_AT_SYMBOL */
-
-#endif /* !SVR4_SHARED_LIBS */
-
- return (success);
+ for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
+ {
+ msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
+ if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
+ {
+ create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol));
+ return 1;
+ }
+ }
+ return 0;
}
/*
way, we are called to do any system specific symbol handling that
is needed.
- For SunOS4, this consists of grunging around in the dynamic
+ For SunOS4, this consisted of grunging around in the dynamic
linkers structures to find symbol definitions for "common" symbols
and adding them to the minimal symbol table for the runtime common
objfile.
+ However, for SVR4, there's nothing to do.
+
*/
static void
svr4_special_symbol_handling (void)
{
-#ifndef SVR4_SHARED_LIBS
- int j;
-
- if (debug_addr == 0)
- {
- /* Get link_dynamic structure */
-
- j = target_read_memory (debug_base, (char *) &dynamic_copy,
- sizeof (dynamic_copy));
- if (j)
- {
- /* unreadable */
- return;
- }
-
- /* Calc address of debugger interface structure */
- /* FIXME, this needs work for cross-debugging of core files
- (byteorder, size, alignment, etc). */
-
- debug_addr = SOLIB_EXTRACT_ADDRESS (dynamic_copy.ldd);
- }
-
- /* Read the debugger structure from the inferior, just to make sure
- we have a current copy. */
-
- j = target_read_memory (debug_addr, (char *) &debug_copy,
- sizeof (debug_copy));
- if (j)
- return; /* unreadable */
-
- /* Get common symbol definitions for the loaded object. */
-
- if (debug_copy.ldd_cp)
- {
- solib_add_common_symbols (SOLIB_EXTRACT_ADDRESS (debug_copy.ldd_cp));
- }
-
-#endif /* !SVR4_SHARED_LIBS */
}
/* Relocate the main executable. This function should be called upon
svr4_relocate_main_executable (void)
{
asection *interp_sect;
- CORE_ADDR pc = read_pc ();
+ struct regcache *regcache = get_thread_regcache (inferior_ptid);
+ CORE_ADDR pc = regcache_read_pc (regcache);
/* Decide if the objfile needs to be relocated. As indicated above,
we will only be here when execution is stopped at the beginning
interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
if (interp_sect == NULL
&& (bfd_get_file_flags (exec_bfd) & DYNAMIC) != 0
- && bfd_get_start_address (exec_bfd) != pc)
+ && (exec_entry_point (exec_bfd, &exec_ops) != pc))
{
struct cleanup *old_chain;
struct section_offsets *new_offsets;
The same language also appears in Edition 4.0 of the System V
ABI and is left unspecified in some of the earlier editions. */
- displacement = pc - bfd_get_start_address (exec_bfd);
+ displacement = pc - exec_entry_point (exec_bfd, &exec_ops);
changed = 0;
- new_offsets = xcalloc (sizeof (struct section_offsets),
- symfile_objfile->num_sections);
+ new_offsets = xcalloc (symfile_objfile->num_sections,
+ sizeof (struct section_offsets));
old_chain = make_cleanup (xfree, new_offsets);
for (i = 0; i < symfile_objfile->num_sections; i++)
SYNOPSIS
- void svr4_solib_create_inferior_hook()
+ void svr4_solib_create_inferior_hook ()
DESCRIPTION
static void
svr4_solib_create_inferior_hook (void)
{
+ struct inferior *inf;
+ struct thread_info *tp;
+ struct svr4_info *info;
+
+ info = get_svr4_info (PIDGET (inferior_ptid));
+
/* Relocate the main executable if necessary. */
svr4_relocate_main_executable ();
- /* If we are using the BKPT_AT_SYMBOL code, then we don't need the base
- yet. In fact, in the case of a SunOS4 executable being run on
- Solaris, we can't get it yet. current_sos will get it when it needs
- it. */
-#if !(defined (SVR4_SHARED_LIBS) && defined (BKPT_AT_SYMBOL))
- if ((debug_base = locate_base ()) == 0)
- {
- /* Can't find the symbol or the executable is statically linked. */
- return;
- }
-#endif
+ if (!svr4_have_link_map_offsets ())
+ return;
- if (!enable_break ())
- {
- warning ("shared library handler failed to enable breakpoint");
- return;
- }
+ if (!enable_break (info))
+ return;
-#if !defined(SVR4_SHARED_LIBS) || defined(_SCO_DS)
- /* SCO and SunOS need the loop below, other systems should be using the
+#if defined(_SCO_DS)
+ /* SCO needs the loop below, other systems should be using the
special shared library breakpoints and the shared library breakpoint
service routine.
can go groveling around in the dynamic linker structures to find
out what we need to know about them. */
+ inf = current_inferior ();
+ tp = inferior_thread ();
+
clear_proceed_status ();
- stop_soon_quietly = 1;
- stop_signal = TARGET_SIGNAL_0;
+ inf->stop_soon = STOP_QUIETLY;
+ tp->stop_signal = TARGET_SIGNAL_0;
do
{
- target_resume (-1, 0, stop_signal);
- wait_for_inferior ();
+ target_resume (pid_to_ptid (-1), 0, tp->stop_signal);
+ wait_for_inferior (0);
}
- while (stop_signal != TARGET_SIGNAL_TRAP);
- stop_soon_quietly = 0;
-
-#if !defined(_SCO_DS)
- /* We are now either at the "mapping complete" breakpoint (or somewhere
- else, a condition we aren't prepared to deal with anyway), so adjust
- the PC as necessary after a breakpoint, disable the breakpoint, and
- add any shared libraries that were mapped in. */
-
- if (DECR_PC_AFTER_BREAK)
- {
- stop_pc -= DECR_PC_AFTER_BREAK;
- write_register (PC_REGNUM, stop_pc);
- }
-
- if (!disable_break ())
- {
- warning ("shared library handler failed to disable breakpoint");
- }
-
- if (auto_solib_add)
- solib_add ((char *) 0, 0, (struct target_ops *) 0);
-#endif /* ! _SCO_DS */
-#endif
+ while (tp->stop_signal != TARGET_SIGNAL_TRAP);
+ inf->stop_soon = NO_STOP_QUIETLY;
+#endif /* defined(_SCO_DS) */
}
static void
svr4_clear_solib (void)
{
- debug_base = 0;
+ remove_svr4_info (PIDGET (inferior_ptid));
}
static void
xfree (so->lm_info);
}
+
+/* Clear any bits of ADDR that wouldn't fit in a target-format
+ data pointer. "Data pointer" here refers to whatever sort of
+ address the dynamic linker uses to manage its sections. At the
+ moment, we don't support shared libraries on any processors where
+ code and data pointers are different sizes.
+
+ This isn't really the right solution. What we really need here is
+ a way to do arithmetic on CORE_ADDR values that respects the
+ natural pointer/address correspondence. (For example, on the MIPS,
+ converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
+ sign-extend the value. There, simply truncating the bits above
+ gdbarch_ptr_bit, as we do below, is no good.) This should probably
+ be a new gdbarch method or something. */
+static CORE_ADDR
+svr4_truncate_ptr (CORE_ADDR addr)
+{
+ if (gdbarch_ptr_bit (target_gdbarch) == sizeof (CORE_ADDR) * 8)
+ /* We don't need to truncate anything, and the bit twiddling below
+ will fail due to overflow problems. */
+ return addr;
+ else
+ return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch)) - 1);
+}
+
+
static void
svr4_relocate_section_addresses (struct so_list *so,
- struct section_table *sec)
+ struct target_section *sec)
+{
+ sec->addr = svr4_truncate_ptr (sec->addr + LM_ADDR_CHECK (so,
+ sec->bfd));
+ sec->endaddr = svr4_truncate_ptr (sec->endaddr + LM_ADDR_CHECK (so,
+ sec->bfd));
+}
+\f
+
+/* Architecture-specific operations. */
+
+/* Per-architecture data key. */
+static struct gdbarch_data *solib_svr4_data;
+
+struct solib_svr4_ops
{
- sec->addr += LM_ADDR (so);
- sec->endaddr += LM_ADDR (so);
+ /* Return a description of the layout of `struct link_map'. */
+ struct link_map_offsets *(*fetch_link_map_offsets)(void);
+};
+
+/* Return a default for the architecture-specific operations. */
+
+static void *
+solib_svr4_init (struct obstack *obstack)
+{
+ struct solib_svr4_ops *ops;
+
+ ops = OBSTACK_ZALLOC (obstack, struct solib_svr4_ops);
+ ops->fetch_link_map_offsets = NULL;
+ return ops;
}
+/* Set the architecture-specific `struct link_map_offsets' fetcher for
+ GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */
+
void
-set_solib_svr4_fetch_link_map_offsets (struct link_map_offsets *(*flmo) (void))
+set_solib_svr4_fetch_link_map_offsets (struct gdbarch *gdbarch,
+ struct link_map_offsets *(*flmo) (void))
{
- fetch_link_map_offsets = flmo;
+ struct solib_svr4_ops *ops = gdbarch_data (gdbarch, solib_svr4_data);
+
+ ops->fetch_link_map_offsets = flmo;
+
+ set_solib_ops (gdbarch, &svr4_so_ops);
}
-static void
-init_fetch_link_map_offsets (void)
+/* Fetch a link_map_offsets structure using the architecture-specific
+ `struct link_map_offsets' fetcher. */
+
+static struct link_map_offsets *
+svr4_fetch_link_map_offsets (void)
{
- set_solib_svr4_fetch_link_map_offsets (default_svr4_fetch_link_map_offsets);
+ struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch, solib_svr4_data);
+
+ gdb_assert (ops->fetch_link_map_offsets);
+ return ops->fetch_link_map_offsets ();
}
-static struct target_so_ops svr4_so_ops;
+/* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
+
+static int
+svr4_have_link_map_offsets (void)
+{
+ struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch, solib_svr4_data);
+ return (ops->fetch_link_map_offsets != NULL);
+}
+\f
+
+/* Most OS'es that have SVR4-style ELF dynamic libraries define a
+ `struct r_debug' and a `struct link_map' that are binary compatible
+ with the origional SVR4 implementation. */
+
+/* Fetch (and possibly build) an appropriate `struct link_map_offsets'
+ for an ILP32 SVR4 system. */
+
+struct link_map_offsets *
+svr4_ilp32_fetch_link_map_offsets (void)
+{
+ static struct link_map_offsets lmo;
+ static struct link_map_offsets *lmp = NULL;
+
+ if (lmp == NULL)
+ {
+ lmp = &lmo;
+
+ lmo.r_version_offset = 0;
+ lmo.r_version_size = 4;
+ lmo.r_map_offset = 4;
+ lmo.r_brk_offset = 8;
+ lmo.r_ldsomap_offset = 20;
+
+ /* Everything we need is in the first 20 bytes. */
+ lmo.link_map_size = 20;
+ lmo.l_addr_offset = 0;
+ lmo.l_name_offset = 4;
+ lmo.l_ld_offset = 8;
+ lmo.l_next_offset = 12;
+ lmo.l_prev_offset = 16;
+ }
+
+ return lmp;
+}
+
+/* Fetch (and possibly build) an appropriate `struct link_map_offsets'
+ for an LP64 SVR4 system. */
+
+struct link_map_offsets *
+svr4_lp64_fetch_link_map_offsets (void)
+{
+ static struct link_map_offsets lmo;
+ static struct link_map_offsets *lmp = NULL;
+
+ if (lmp == NULL)
+ {
+ lmp = &lmo;
+
+ lmo.r_version_offset = 0;
+ lmo.r_version_size = 4;
+ lmo.r_map_offset = 8;
+ lmo.r_brk_offset = 16;
+ lmo.r_ldsomap_offset = 40;
+
+ /* Everything we need is in the first 40 bytes. */
+ lmo.link_map_size = 40;
+ lmo.l_addr_offset = 0;
+ lmo.l_name_offset = 8;
+ lmo.l_ld_offset = 16;
+ lmo.l_next_offset = 24;
+ lmo.l_prev_offset = 32;
+ }
+
+ return lmp;
+}
+\f
+
+struct target_so_ops svr4_so_ops;
+
+/* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a
+ different rule for symbol lookup. The lookup begins here in the DSO, not in
+ the main executable. */
+
+static struct symbol *
+elf_lookup_lib_symbol (const struct objfile *objfile,
+ const char *name,
+ const char *linkage_name,
+ const domain_enum domain)
+{
+ if (objfile->obfd == NULL
+ || scan_dyntag (DT_SYMBOLIC, objfile->obfd, NULL) != 1)
+ return NULL;
+
+ return lookup_global_symbol_from_objfile
+ (objfile, name, linkage_name, domain);
+}
+
+extern initialize_file_ftype _initialize_svr4_solib; /* -Wmissing-prototypes */
void
_initialize_svr4_solib (void)
{
- register_gdbarch_swap (&fetch_link_map_offsets,
- sizeof (fetch_link_map_offsets),
- init_fetch_link_map_offsets);
+ solib_svr4_data = gdbarch_data_register_pre_init (solib_svr4_init);
svr4_so_ops.relocate_section_addresses = svr4_relocate_section_addresses;
svr4_so_ops.free_so = svr4_free_so;
svr4_so_ops.current_sos = svr4_current_sos;
svr4_so_ops.open_symbol_file_object = open_symbol_file_object;
svr4_so_ops.in_dynsym_resolve_code = svr4_in_dynsym_resolve_code;
+ svr4_so_ops.lookup_lib_global_symbol = elf_lookup_lib_symbol;
+ svr4_so_ops.same = svr4_same;
- /* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */
- current_target_so_ops = &svr4_so_ops;
+ observer_attach_inferior_exit (solib_svr4_inferior_exit);
}
-
projects / deliverable / binutils-gdb.git / blobdiff