/* Handle SVR4 shared libraries for GDB, the GNU Debugger.
- Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
- 2001
+
+ Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
+ 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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 "gdbcore.h"
#include "target.h"
#include "inferior.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() svr4_fetch_link_map_offsets ()
-#endif
+#include "bfd-target.h"
+#include "elf-bfd.h"
+#include "exec.h"
+#include "auxv.h"
+#include "exceptions.h"
static struct link_map_offsets *svr4_fetch_link_map_offsets (void);
-static struct link_map_offsets *legacy_fetch_link_map_offsets (void);
-
-/* fetch_link_map_offsets_gdbarch_data is a handle used to obtain the
- architecture specific link map offsets fetching function. */
-
-static struct gdbarch_data *fetch_link_map_offsets_gdbarch_data;
-
-/* 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 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
"_dl_debug_state",
"rtld_db_dlactivity",
"_rtld_debug_state",
+
NULL
};
-#define BKPT_AT_SYMBOL 1
-
-#if defined (BKPT_AT_SYMBOL)
static char *bkpt_names[] =
{
-#ifdef SOLIB_BKPT_NAME
- SOLIB_BKPT_NAME, /* Prefer configured name if it exists. */
-#endif
"_start",
+ "__start",
"main",
NULL
};
-#endif
static char *main_name_list[] =
{
NULL
};
-/* 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. */
+/* Return non-zero if GDB_SO_NAME and INFERIOR_SO_NAME represent
+ the same shared library. */
+
+static int
+svr4_same_1 (const char *gdb_so_name, const char *inferior_so_name)
+{
+ 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;
-#define SOLIB_EXTRACT_ADDRESS(MEMBER) \
- extract_address (&(MEMBER), sizeof (MEMBER))
+ return 0;
+}
-/* local data declarations */
+static int
+svr4_same (struct so_list *gdb, struct so_list *inferior)
+{
+ return (svr4_same_1 (gdb->so_original_name, inferior->so_original_name));
+}
/* link map access functions */
static CORE_ADDR
-LM_ADDR (struct so_list *so)
+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;
+
+ return extract_typed_address (so->lm_info->lm + lmo->l_addr_offset,
+ ptr_type);
+}
+
+static int
+HAS_LM_DYNAMIC_FROM_LINK_MAP (void)
+{
+ struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
+
+ return lmo->l_ld_offset >= 0;
+}
+
+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;
+
+ return extract_typed_address (so->lm_info->lm + lmo->l_ld_offset,
+ ptr_type);
+}
+
+static CORE_ADDR
+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;
- return (CORE_ADDR) extract_signed_integer (so->lm_info->lm + lmo->l_addr_offset,
- lmo->l_addr_size);
+ 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 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);
}
static int
IGNORE_FIRST_LINK_MAP_ENTRY (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;
+
+ /* Assume that everything is a library if the dynamic loader was loaded
+ late by a static executable. */
+ if (exec_bfd && 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;
+}
+
+/* Per pspace SVR4 specific data. */
+
+struct svr4_info
+{
+ CORE_ADDR debug_base; /* Base of dynamic linker structures */
+
+ /* Validity flag for debug_loader_offset. */
+ int debug_loader_offset_p;
+
+ /* Load address for the dynamic linker, inferred. */
+ CORE_ADDR debug_loader_offset;
+
+ /* Name of the dynamic linker, valid if debug_loader_offset_p. */
+ char *debug_loader_name;
+
+ /* Load map address for the main executable. */
+ CORE_ADDR main_lm_addr;
+
+ CORE_ADDR interp_text_sect_low;
+ CORE_ADDR interp_text_sect_high;
+ CORE_ADDR interp_plt_sect_low;
+ CORE_ADDR interp_plt_sect_high;
+};
+
+/* Per-program-space data key. */
+static const struct program_space_data *solib_svr4_pspace_data;
+
+static void
+svr4_pspace_data_cleanup (struct program_space *pspace, void *arg)
+{
+ struct svr4_info *info;
- return extract_address (so->lm_info->lm + lmo->l_prev_offset,
- lmo->l_prev_size) == 0;
+ info = program_space_data (pspace, solib_svr4_pspace_data);
+ xfree (info);
}
-static CORE_ADDR debug_base; /* Base of dynamic linker structures */
-static CORE_ADDR breakpoint_addr; /* Address where end bkpt is set */
+/* Get the current svr4 data. If none is found yet, add it now. This
+ function always returns a valid object. */
+
+static struct svr4_info *
+get_svr4_info (void)
+{
+ struct svr4_info *info;
+
+ info = program_space_data (current_program_space, solib_svr4_pspace_data);
+ if (info != NULL)
+ return info;
+
+ info = XZALLOC (struct svr4_info);
+ set_program_space_data (current_program_space, solib_svr4_pspace_data, info);
+ return info;
+}
/* Local function prototypes */
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.
+
+ 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 char *debug_base_symbols[] =
+static gdb_byte *
+read_program_header (int type, int *p_sect_size, int *p_arch_size)
{
- "r_debug", /* Solaris 2.3 */
- "_r_debug", /* Solaris 2.1, 2.2 */
- NULL
-};
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+ 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;
-static int look_for_base (int, CORE_ADDR);
+ /* 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;
-/*
+ /* Find .dynamic section via the PT_DYNAMIC PHDR. */
+ if (arch_size == 32)
+ {
+ Elf32_External_Phdr phdr;
+ int i;
- LOCAL FUNCTION
+ /* 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;
- look_for_base -- examine file for each mapped address segment
+ if (extract_unsigned_integer ((gdb_byte *)phdr.p_type,
+ 4, byte_order) == type)
+ break;
+ }
+
+ if (i == at_phnum)
+ return 0;
+
+ /* Retrieve address and size. */
+ sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr,
+ 4, byte_order);
+ sect_size = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz,
+ 4, byte_order);
+ }
+ else
+ {
+ Elf64_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, byte_order) == 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,
+ 8, byte_order);
+ sect_size = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz,
+ 8, byte_order);
+ }
- 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.
+ /* Read in requested program header. */
+ buf = xmalloc (sect_size);
+ if (target_read_memory (sect_addr, buf, sect_size))
+ {
+ xfree (buf);
+ return NULL;
+ }
- 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 (p_arch_size)
+ *p_arch_size = arch_size;
+ if (p_sect_size)
+ *p_sect_size = sect_size;
+
+ return buf;
+}
+
+
+/* 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;
+}
+
+
+/* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
+ returned and the corresponding PTR is set. */
static int
-look_for_base (int fd, CORE_ADDR baseaddr)
+scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
{
- bfd *interp_bfd;
- CORE_ADDR address = 0;
- char **symbolp;
+ 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;
- /* 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. */
+ if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
+ return 0;
- if (fd == -1
- || (exec_bfd != NULL
- && fdmatch (fileno ((FILE *) (exec_bfd->iostream)), fd)))
- {
- return (0);
- }
+ arch_size = bfd_get_arch_size (abfd);
+ if (arch_size == -1)
+ return 0;
- /* 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. */
+ /* 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;
- 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);
- }
+ /* 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;
+ }
+ }
- /* 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. */
+ return 0;
+}
- 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);
- }
+/* 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. */
- /* 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. */
+static int
+scan_dyntag_auxv (int dyntag, CORE_ADDR *ptr)
+{
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+ 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;
- 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);
+ /* 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, byte_order);
+ dyn_ptr = extract_unsigned_integer ((gdb_byte *) dynp->d_un.d_ptr,
+ 4, byte_order);
+ }
+ else
+ {
+ Elf64_External_Dyn *dynp = (Elf64_External_Dyn *) buf;
+ dyn_tag = extract_unsigned_integer ((gdb_byte *) dynp->d_tag,
+ 8, byte_order);
+ dyn_ptr = extract_unsigned_integer ((gdb_byte *) dynp->d_un.d_ptr,
+ 8, byte_order);
+ }
+ 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;
- }
- 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));
- }
- }
- }
- 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;
}
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)
{
/* 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 (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 (!ptid_equal (inferior_ptid, null_ptid) && target_has_execution)
- proc_iterate_over_mappings (look_for_base);
-#endif
- }
- return (debug_base);
+ if (info->debug_base == 0 && svr4_have_link_map_offsets ())
+ info->debug_base = elf_locate_base ();
+ return info->debug_base;
}
-/*
+/* Find the first element in the inferior's dynamic link map, and
+ return its address in the inferior.
- LOCAL FUNCTION
+ FIXME: Perhaps we should validate the info somehow, perhaps by
+ checking r_version for a known version number, or r_state for
+ RT_CONSISTENT. */
- first_link_map_member -- locate first member in dynamic linker's map
+static CORE_ADDR
+solib_svr4_r_map (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;
- SYNOPSIS
+ return read_memory_typed_address (info->debug_base + lmo->r_map_offset,
+ ptr_type);
+}
- static CORE_ADDR first_link_map_member (void)
+/* Find r_brk from the inferior's debug base. */
- DESCRIPTION
+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;
- 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. */
+ return read_memory_typed_address (info->debug_base + lmo->r_brk_offset,
+ ptr_type);
+}
+
+/* Find the link map for the dynamic linker (if it is not in the
+ normal list of loaded shared objects). */
static CORE_ADDR
-first_link_map_member (void)
+solib_svr4_r_ldsomap (struct svr4_info *info)
{
- CORE_ADDR lm = 0;
- 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);
+ struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
+ struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
+ 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, byte_order);
+ if (version < 2 || lmo->r_ldsomap_offset == -1)
+ return 0;
- read_memory (debug_base + lmo->r_map_offset, r_map_buf, lmo->r_map_size);
+ return read_memory_typed_address (info->debug_base + lmo->r_ldsomap_offset,
+ ptr_type);
+}
- lm = extract_address (r_map_buf, lmo->r_map_size);
+/* On Solaris systems with some versions of the dynamic linker,
+ ld.so's l_name pointer points to the SONAME in the string table
+ rather than into writable memory. So that GDB can find shared
+ libraries when loading a core file generated by gcore, ensure that
+ memory areas containing the l_name string are saved in the core
+ file. */
- /* 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 int
+svr4_keep_data_in_core (CORE_ADDR vaddr, unsigned long size)
+{
+ struct svr4_info *info;
+ CORE_ADDR ldsomap;
+ struct so_list *new;
+ struct cleanup *old_chain;
+ struct link_map_offsets *lmo;
+ CORE_ADDR lm_name;
+
+ info = get_svr4_info ();
+
+ info->debug_base = 0;
+ locate_base (info);
+ if (!info->debug_base)
+ return 0;
- do_cleanups (cleanups);
+ ldsomap = solib_svr4_r_ldsomap (info);
+ if (!ldsomap)
+ return 0;
- return (lm);
+ lmo = svr4_fetch_link_map_offsets ();
+ new = XZALLOC (struct so_list);
+ old_chain = make_cleanup (xfree, new);
+ new->lm_info = xmalloc (sizeof (struct lm_info));
+ make_cleanup (xfree, new->lm_info);
+ new->lm_info->l_addr = (CORE_ADDR)-1;
+ new->lm_info->lm_addr = ldsomap;
+ new->lm_info->lm = xzalloc (lmo->link_map_size);
+ make_cleanup (xfree, new->lm_info->lm);
+ read_memory (ldsomap, new->lm_info->lm, lmo->link_map_size);
+ lm_name = LM_NAME (new);
+ do_cleanups (old_chain);
+
+ return (lm_name >= vaddr && lm_name < vaddr + size);
}
/*
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 ();
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;
}
+/* 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)
+{
+ struct svr4_info *info = get_svr4_info ();
+
+ 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;
+
+ 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
current_sos -- build a list of currently loaded shared objects
CORE_ADDR lm;
struct so_list *head = 0;
struct so_list **link_ptr = &head;
+ CORE_ADDR ldsomap = 0;
+ 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 ();
+ info = get_svr4_info ();
- /* 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;
- }
+ /* 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 ();
+
+ /* 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 1 if PC lies in the dynamic symbol resolution code of the
SVR4 run time loader. */
-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)
+ struct svr4_info *info = get_svr4_info ();
+
+ return ((pc >= info->interp_text_sect_low
+ && pc < info->interp_text_sect_high)
+ || (pc >= info->interp_plt_sect_low
+ && pc < info->interp_plt_sect_high)
|| in_plt_section (pc, NULL));
}
+/* Given an executable's ABFD and target, compute the entry-point
+ address. */
+
+static CORE_ADDR
+exec_entry_point (struct bfd *abfd, struct target_ops *targ)
+{
+ /* 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);
+}
/*
*/
static int
-enable_break (void)
+enable_break (struct svr4_info *info, int from_tty)
{
- int success = 0;
-
-#ifdef BKPT_AT_SYMBOL
-
struct minimal_symbol *msymbol;
char **bkpt_namep;
asection *interp_sect;
+ gdb_byte *interp_name;
+ CORE_ADDR sym_addr;
/* First, remove all the solib event breakpoints. Their addresses
may have changed since the last time we ran the program. */
remove_solib_event_breakpoints ();
- interp_text_sect_low = interp_text_sect_high = 0;
- interp_plt_sect_low = interp_plt_sect_high = 0;
+ info->interp_text_sect_low = info->interp_text_sect_high = 0;
+ info->interp_plt_sect_low = info->interp_plt_sect_high = 0;
+
+ /* 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, from_tty, ¤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));
- /* Find the .interp section; if not found, warn the user and drop
+ 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)
+ {
+ info->interp_text_sect_low =
+ bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
+ info->interp_text_sect_high =
+ info->interp_text_sect_low
+ + bfd_section_size (tmp_bfd, interp_sect);
+ }
+ interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
+ if (interp_sect)
+ {
+ info->interp_plt_sect_low =
+ bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
+ info->interp_plt_sect_high =
+ info->interp_plt_sect_low
+ + bfd_section_size (tmp_bfd, interp_sect);
+ }
+
+ create_solib_event_breakpoint (target_gdbarch, 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 = 0;
int load_addr_found = 0;
- struct so_list *inferior_sos;
+ 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))
- {
- warning ("Unable to grok dynamic linker %s as an object file", buf);
- bfd_close (tmp_bfd);
- goto bkpt_at_symbol;
- }
+ /* 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);
- /* If the entry in _DYNAMIC for the dynamic linker has already
- been filled in, we can read its base address from there. */
- inferior_sos = svr4_current_sos ();
- if (inferior_sos)
- {
- /* Connected to a running target. Update our shared library table. */
- solib_add (NULL, 0, NULL, auto_solib_add);
- }
- while (inferior_sos)
+ /* 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 (strcmp (buf, inferior_sos->so_original_name) == 0)
+ if (svr4_same_1 (interp_name, so->so_original_name))
{
load_addr_found = 1;
- load_addr = LM_ADDR (inferior_sos);
+ loader_found_in_list = 1;
+ load_addr = LM_ADDR_CHECK (so, tmp_bfd);
break;
}
- inferior_sos = inferior_sos->next;
+ 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. */
+ 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)
- load_addr = read_pc () - tmp_bfd->start_address;
+ {
+ struct regcache *regcache
+ = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
+ load_addr = (regcache_read_pc (regcache)
+ - exec_entry_point (tmp_bfd, tmp_bfd_target));
+ }
+
+ 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, from_tty, ¤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. */
interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
if (interp_sect)
{
- interp_text_sect_low =
+ info->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);
+ info->interp_text_sect_high =
+ info->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 =
+ info->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);
+ info->interp_plt_sect_high =
+ info->interp_plt_sect_low
+ + bfd_section_size (tmp_bfd, interp_sect);
}
/* Now try to set a breakpoint in the dynamic linker. */
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);
+ create_solib_event_breakpoint (target_gdbarch, 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."));
}
- /* 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))
{
- create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol));
+ sym_addr = SYMBOL_VALUE_ADDRESS (msymbol);
+ sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch,
+ sym_addr,
+ ¤t_target);
+ create_solib_event_breakpoint (target_gdbarch, sym_addr);
return 1;
}
}
- /* Nothing good happened. */
- success = 0;
-
-#endif /* BKPT_AT_SYMBOL */
-
- 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))
+ {
+ sym_addr = SYMBOL_VALUE_ADDRESS (msymbol);
+ sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch,
+ sym_addr,
+ ¤t_target);
+ create_solib_event_breakpoint (target_gdbarch, sym_addr);
+ return 1;
+ }
+ }
+ return 0;
}
/*
svr4_relocate_main_executable (void)
{
asection *interp_sect;
- CORE_ADDR pc = read_pc ();
+ struct regcache *regcache
+ = get_thread_arch_regcache (inferior_ptid, target_gdbarch);
+ 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 (symfile_objfile->num_sections,
SYNOPSIS
- void svr4_solib_create_inferior_hook()
+ void svr4_solib_create_inferior_hook (int from_tty)
DESCRIPTION
*/
static void
-svr4_solib_create_inferior_hook (void)
+svr4_solib_create_inferior_hook (int from_tty)
{
+ struct inferior *inf;
+ struct thread_info *tp;
+ struct svr4_info *info;
+
+ info = get_svr4_info ();
+
/* Relocate the main executable if necessary. */
svr4_relocate_main_executable ();
- if (!enable_break ())
- {
- warning ("shared library handler failed to enable breakpoint");
- return;
- }
+ if (!svr4_have_link_map_offsets ())
+ return;
+
+ if (!enable_break (info, from_tty))
+ return;
#if defined(_SCO_DS)
/* SCO needs the loop below, other systems should be using the
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 (pid_to_ptid (-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;
+ 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;
+ struct svr4_info *info;
+
+ info = get_svr4_info ();
+ info->debug_base = 0;
+ info->debug_loader_offset_p = 0;
+ info->debug_loader_offset = 0;
+ xfree (info->debug_loader_name);
+ info->debug_loader_name = NULL;
}
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 += LM_ADDR (so);
- sec->endaddr += LM_ADDR (so);
+ 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
-/* Fetch a link_map_offsets structure for native targets using struct
- definitions from link.h. See solib-legacy.c for the function
- which does the actual work.
-
- Note: For non-native targets (i.e. cross-debugging situations),
- a target specific fetch_link_map_offsets() function should be
- defined and registered via set_solib_svr4_fetch_link_map_offsets(). */
+/* Architecture-specific operations. */
-static struct link_map_offsets *
-legacy_fetch_link_map_offsets (void)
+/* Per-architecture data key. */
+static struct gdbarch_data *solib_svr4_data;
+
+struct solib_svr4_ops
{
- if (legacy_svr4_fetch_link_map_offsets_hook)
- return legacy_svr4_fetch_link_map_offsets_hook ();
- else
- {
- internal_error (__FILE__, __LINE__,
- "legacy_fetch_link_map_offsets called without legacy "
- "link_map support enabled.");
- return 0;
- }
+ /* 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 gdbarch *gdbarch,
+ struct link_map_offsets *(*flmo) (void))
+{
+ struct solib_svr4_ops *ops = gdbarch_data (gdbarch, solib_svr4_data);
+
+ ops->fetch_link_map_offsets = flmo;
+
+ set_solib_ops (gdbarch, &svr4_so_ops);
}
-/* Fetch a link_map_offsets structure using the method registered in the
- architecture vector. */
+/* 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)
{
- struct link_map_offsets *(*flmo)(void) =
- gdbarch_data (fetch_link_map_offsets_gdbarch_data);
+ 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 ();
+}
- if (flmo == NULL)
+/* 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)
{
- internal_error (__FILE__, __LINE__,
- "svr4_fetch_link_map_offsets: fetch_link_map_offsets "
- "method not defined for this architecture.");
- return 0;
+ 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;
}
- else
- return (flmo ());
-}
-/* set_solib_svr4_fetch_link_map_offsets() is intended to be called by
- a <arch>_gdbarch_init() function. It is used to establish an
- architecture specific link_map_offsets fetcher for the architecture
- being defined. */
+ return lmp;
+}
-void
-set_solib_svr4_fetch_link_map_offsets (struct gdbarch *gdbarch,
- struct link_map_offsets *(*flmo) (void))
+/* 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)
{
- set_gdbarch_data (gdbarch, fetch_link_map_offsets_gdbarch_data, flmo);
+ 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
-/* Initialize the architecture specific link_map_offsets fetcher.
- This is called after <arch>_gdbarch_init() has set up its struct
- gdbarch for the new architecture, so care must be taken to use the
- value set by set_solib_svr4_fetch_link_map_offsets(), above. We
- do, however, attempt to provide a reasonable alternative (for
- native targets anyway) if the <arch>_gdbarch_init() fails to call
- set_solib_svr4_fetch_link_map_offsets(). */
+struct target_so_ops svr4_so_ops;
-static void *
-init_fetch_link_map_offsets (struct gdbarch *gdbarch)
+/* 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)
{
- struct link_map_offsets *(*flmo) =
- gdbarch_data (fetch_link_map_offsets_gdbarch_data);
+ if (objfile->obfd == NULL
+ || scan_dyntag (DT_SYMBOLIC, objfile->obfd, NULL) != 1)
+ return NULL;
- if (flmo == NULL)
- return legacy_fetch_link_map_offsets;
- else
- return flmo;
+ return lookup_global_symbol_from_objfile
+ (objfile, name, linkage_name, domain);
}
-static struct target_so_ops svr4_so_ops;
+extern initialize_file_ftype _initialize_svr4_solib; /* -Wmissing-prototypes */
void
_initialize_svr4_solib (void)
{
- fetch_link_map_offsets_gdbarch_data =
- register_gdbarch_data (init_fetch_link_map_offsets, 0);
+ solib_svr4_data = gdbarch_data_register_pre_init (solib_svr4_init);
+ solib_svr4_pspace_data
+ = register_program_space_data_with_cleanup (svr4_pspace_data_cleanup);
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;
-
- /* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */
- current_target_so_ops = &svr4_so_ops;
+ svr4_so_ops.bfd_open = solib_bfd_open;
+ svr4_so_ops.lookup_lib_global_symbol = elf_lookup_lib_symbol;
+ svr4_so_ops.same = svr4_same;
+ svr4_so_ops.keep_data_in_core = svr4_keep_data_in_core;
}