/* Handle SunOS and SVR4 shared libraries for GDB, the GNU Debugger.
- Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
+ Copyright 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
This file is part of GDB.
#ifndef SVR4_SHARED_LIBS
/* SunOS shared libs need the nlist structure. */
#include <a.out.h>
+#else
+#include "libelf.h"
+#ifndef DT_MIPS_RLD_MAP
+#include "elf/mips.h"
+#endif
#endif
#include "symtab.h"
/* Symbols which are used to locate the base of the link map structures. */
+#ifndef SVR4_SHARED_LIBS
static char *debug_base_symbols[] = {
-#ifdef SVR4_SHARED_LIBS
- "_r_debug", /* Most SVR4 systems, Solaris 2.1, 2.2 */
- "r_debug", /* Solaris 2.3 */
-#else
- "_DYNAMIC", /* SunOS */
-#endif
+ "_DYNAMIC",
NULL
};
+#endif
/* local data declarations */
#ifdef SVR4_SHARED_LIBS
-static int
-look_for_base PARAMS ((int, CORE_ADDR));
-
static CORE_ADDR
-bfd_lookup_symbol PARAMS ((bfd *, char *));
+elf_locate_base PARAMS ((void));
#else
if (build_section_table (abfd, &so -> sections, &so -> sections_end))
{
error ("Can't find the file sections in `%s': %s",
- bfd_get_filename (exec_bfd), bfd_errmsg (bfd_get_error ()));
+ bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
}
for (p = so -> sections; p < so -> sections_end; p++)
p -> addr += (CORE_ADDR) LM_ADDR (so);
p -> endaddr += (CORE_ADDR) LM_ADDR (so);
so -> lmend = (CORE_ADDR) max (p -> endaddr, so -> lmend);
- if (STREQ (p -> sec_ptr -> name, ".text"))
+ if (STREQ (p -> the_bfd_section -> name, ".text"))
{
so -> textsection = p;
}
#endif /* SVR4_SHARED_LIBS */
+
#ifdef SVR4_SHARED_LIBS
+#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).
+*/
+
+static char *debug_base_symbols[] = {
+ "r_debug", /* Solaris 2.3 */
+ "_r_debug", /* Solaris 2.1, 2.2 */
+ NULL
+};
+
+static int
+look_for_base PARAMS ((int, CORE_ADDR));
+
+static CORE_ADDR
+bfd_lookup_symbol PARAMS ((bfd *, char *));
+
/*
LOCAL FUNCTION
Note that 0 is specifically allowed as an error return (no
such symbol).
-
- FIXME: See if there is a less "expensive" way of doing this.
- Also see if there is already another bfd or gdb function
- that specifically does this, and if so, use it.
*/
static CORE_ADDR
struct cleanup *back_to;
CORE_ADDR symaddr = 0;
- storage_needed = get_symtab_upper_bound (abfd);
+ storage_needed = bfd_get_symtab_upper_bound (abfd);
if (storage_needed > 0)
{
CORE_ADDR baseaddr;
{
bfd *interp_bfd;
- CORE_ADDR address;
+ CORE_ADDR address = 0;
char **symbolp;
/* 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 ((fd == -1) || fdmatch (fileno ((GDB_FILE *)(exec_bfd -> iostream)), fd))
+ if (fd == -1
+ || (exec_bfd != NULL
+ && fdmatch (fileno ((GDB_FILE *)(exec_bfd -> iostream)), fd)))
{
return (0);
}
bfd_close (interp_bfd);
return (1);
}
+#endif /* HANDLE_SVR4_EXEC_EMULATORS */
-#endif
+/*
+
+LOCAL FUNCTION
+
+ elf_locate_base -- locate the base address of dynamic linker structs
+ for SVR4 elf targets.
+
+SYNOPSIS
+
+ CORE_ADDR elf_locate_base (void)
+
+DESCRIPTION
+
+ For SVR4 elf targets the address of the dynamic linker's runtime
+ structure is contained within the dynamic info section in the
+ executable file. The dynamic section is also mapped into the
+ inferior address space. Because the runtime loader fills in the
+ real address before starting the inferior, we have to read in the
+ dynamic info section from the inferior address space.
+ If there are any errors while trying to find the address, we
+ silently return 0, otherwise the found address is returned.
+
+ */
+
+static CORE_ADDR
+elf_locate_base ()
+{
+ struct elf_internal_shdr *dyninfo_sect;
+ int dyninfo_sect_size;
+ CORE_ADDR dyninfo_addr;
+ char *buf;
+ char *bufend;
+
+ /* Find the start address of the .dynamic section. */
+ dyninfo_sect = bfd_elf_find_section (exec_bfd, ".dynamic");
+ if (dyninfo_sect == NULL)
+ return 0;
+ dyninfo_addr = dyninfo_sect->sh_addr;
+
+ /* Read in .dynamic section, silently ignore errors. */
+ dyninfo_sect_size = dyninfo_sect->sh_size;
+ 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. */
+ /* FIXME: In lack of a 64 bit ELF ABI the following code assumes
+ a 32 bit ELF ABI target. */
+ 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;
+
+ 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[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));
+ }
+ }
+
+ /* DT_DEBUG entry not found. */
+ return 0;
+}
+
+#endif /* SVR4_SHARED_LIBS */
/*
have to do is look it up there. Note that we explicitly do NOT want
to find the copies in the shared library.
- The SVR4 version is much more complicated because 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. We have to go
+ The SVR4 version is a bit more complicated because the address
+ is contained somewhere in the dynamic info section. We have to go
to a lot more work to discover the address of the debug base symbol.
Because of this complexity, we cache the value we find and return that
value on subsequent invocations. Note there is no copy in the
executable symbol tables.
- Note that we can assume nothing about the process state at the time
- we need to find this address. We may be stopped on the first instruc-
- tion 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).
-
*/
static CORE_ADDR
/* 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, ask the /proc support interface to iterate
- over the list of mapped address segments, calling look_for_base() for
- each segment. When we are done, we will have either found the base
- address or not. */
+ we have no cached address, try to locate it in the dynamic info
+ section for ELF executables. */
if (debug_base == 0)
{
- proc_iterate_over_mappings (look_for_base);
+ 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)
+ proc_iterate_over_mappings (look_for_base);
+#endif
}
return (debug_base);
{
register struct so_list *so = (struct so_list *) arg; /* catch_errs bogon */
- so -> objfile = symbol_file_add (so -> so_name, so -> from_tty,
- (unsigned int) so -> textsection -> addr,
- 0, 0, 0);
+ so -> objfile =
+ symbol_file_add (so -> so_name, so -> from_tty,
+ (so->textsection == NULL
+ ? 0
+ : (unsigned int) so -> textsection -> addr),
+ 0, 0, 0);
return (1);
}
error ("Invalid regexp: %s", re_err);
}
- /* Getting new symbols may change our opinion about what is
- frameless. */
- reinit_frame_cache ();
-
- while ((so = find_solib (so)) != NULL)
- {
- if (so -> so_name[0] && re_exec (so -> so_name))
- {
- so -> from_tty = from_tty;
- if (so -> symbols_loaded)
- {
- if (from_tty)
- {
- printf_unfiltered ("Symbols already loaded for %s\n", so -> so_name);
- }
- }
- else if (catch_errors
- (symbol_add_stub, (char *) so,
- "Error while reading shared library symbols:\n",
- RETURN_MASK_ALL))
- {
- so_last = so;
- so -> symbols_loaded = 1;
- }
- }
- }
-
- /* Now add the shared library sections to the section table of the
+ /* Add the shared library sections to the section table of the
specified target, if any. */
if (target)
{
}
}
}
+
+ /* Now add the symbol files. */
+ while ((so = find_solib (so)) != NULL)
+ {
+ if (so -> so_name[0] && re_exec (so -> so_name))
+ {
+ so -> from_tty = from_tty;
+ if (so -> symbols_loaded)
+ {
+ if (from_tty)
+ {
+ printf_unfiltered ("Symbols already loaded for %s\n", so -> so_name);
+ }
+ }
+ else if (catch_errors
+ (symbol_add_stub, (char *) so,
+ "Error while reading shared library symbols:\n",
+ RETURN_MASK_ALL))
+ {
+ so_last = so;
+ so -> symbols_loaded = 1;
+ }
+ }
+ }
+
+ /* Getting new symbols may change our opinion about what is
+ frameless. */
+ if (so_last)
+ reinit_frame_cache ();
/* Calling this once at the end means that we put all the minimal
symbols for commons into the objfile for the last shared library.
projects / deliverable / binutils-gdb.git / blobdiff