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., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "bfd-target.h"
#include "elf-bfd.h"
#include "exec.h"
+#include "auxv.h"
static struct link_map_offsets *svr4_fetch_link_map_offsets (void);
static int svr4_have_link_map_offsets (void);
"rtld_db_dlactivity",
"_rtld_debug_state",
- /* On the 64-bit PowerPC, the linker symbol with the same name as
- the C function points to a function descriptor, not to the entry
- point. The linker symbol whose name is the C function name
- prefixed with a '.' points to the function's entry point. So
- when we look through this table, we ignore symbols that point
- into the data section (thus skipping the descriptor's symbol),
- and eventually try this one, giving us the real entry point
- address. */
- "._dl_debug_state",
-
NULL
};
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) == 0 && ((dynaddr - l_dynaddr) & align) == 0)
+ if ((l_addr & align) == ((l_dynaddr - dynaddr) & align))
{
l_addr = l_dynaddr - dynaddr;
static int match_main (char *);
-static CORE_ADDR bfd_lookup_symbol (bfd *, char *, flagword);
+static CORE_ADDR bfd_lookup_symbol (bfd *, char *);
/*
SYNOPSIS
- CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname, flagword sect_flags)
+ CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
DESCRIPTION
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.
- If SECT_FLAGS is non-zero, only match symbols in sections whose
- flags include all those in SECT_FLAGS.
+ 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).
*/
static CORE_ADDR
-bfd_lookup_symbol (bfd *abfd, char *symname, flagword sect_flags)
+bfd_lookup_symbol (bfd *abfd, char *symname)
{
long storage_needed;
asymbol *sym;
{
sym = *symbol_table++;
if (strcmp (sym->name, symname) == 0
- && (sym->section->flags & sect_flags) == sect_flags)
+ && (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;
}
sym = *symbol_table++;
if (strcmp (sym->name, symname) == 0
- && (sym->section->flags & sect_flags) == sect_flags)
+ && (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;
}
int arch_size, step, sect_size;
long dyn_tag;
CORE_ADDR dyn_ptr, dyn_addr;
- gdb_byte *bufend, *buf;
+ gdb_byte *bufend, *bufstart, *buf;
Elf32_External_Dyn *x_dynp_32;
Elf64_External_Dyn *x_dynp_64;
struct bfd_section *sect;
return 0;
dyn_addr = bfd_section_vma (abfd, sect);
- /* Read in .dynamic section, silently ignore errors. */
+ /* Read in .dynamic from the BFD. We will get the actual value
+ from memory later. */
sect_size = bfd_section_size (abfd, sect);
- buf = alloca (sect_size);
- if (target_read_memory (dyn_addr, buf, sect_size))
- {
- /* If target_read_memory fails, try reading the BFD file. */
- if (!bfd_get_section_contents (abfd, sect,
- buf, 0, sect_size))
- return 0;
- }
+ 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)
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
+ else
{
x_dynp_64 = (Elf64_External_Dyn *) buf;
dyn_tag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
return 0;
if (dyn_tag == dyntag)
{
+ /* If requested, try to read the runtime value of this .dynamic
+ entry. */
if (ptr)
- *ptr = dyn_ptr;
- return 1;
+ {
+ gdb_byte ptr_buf[8];
+ CORE_ADDR ptr_addr;
+
+ 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,
+ builtin_type_void_data_ptr);
+ *ptr = dyn_ptr;
+ }
+ return 1;
}
}
struct minimal_symbol *msymbol;
CORE_ADDR dyn_ptr;
- /* Find DT_DEBUG. */
- if (scan_dyntag (DT_DEBUG, exec_bfd, &dyn_ptr))
- return dyn_ptr;
-
- /* Find DT_MIPS_RLD_MAP. */
+ /* 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))
{
gdb_byte *pbuf;
return extract_typed_address (pbuf, builtin_type_void_data_ptr);
}
+ /* Find DT_DEBUG. */
+ if (scan_dyntag (DT_DEBUG, exec_bfd, &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);
/* 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)
{
return 0;
}
- make_cleanup (xfree, filename);
/* Have a pathname: read the symbol file. */
symbol_file_add_main (filename, from_tty);
{
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. */
/* Is this the linkmap for the file we want? */
/* If the file is not a shared library and has no name,
we are sure it is the main executable, so we return that. */
- if ((buffer && strcmp (buffer, objfile->name) == 0)
- || (!(objfile->flags & OBJF_SHARED) && (strcmp (buffer, "") == 0)))
+
+ if (buffer
+ && ((strcmp (buffer, objfile->name) == 0)
+ || (!(objfile->flags & OBJF_SHARED)
+ && (strcmp (buffer, "") == 0))))
{
do_cleanups (old_chain);
return lm;
be trivial on GNU/Linux). Therefore, we have to try an alternate
mechanism to find the dynamic linker's base address. */
- /* TODO drow/2006-09-12: This is somewhat fragile, because it
- relies on read_pc. On both Solaris and GNU/Linux we can use
- the AT_BASE auxilliary entry, which GDB now knows how to
- access, to find the base address. */
-
tmp_fd = solib_open (buf, &tmp_pathname);
if (tmp_fd >= 0)
tmp_bfd = bfd_fopen (tmp_pathname, gnutarget, FOPEN_RB, tmp_fd);
/* On a running target, we can get the dynamic linker's base
address from the shared library table. */
- solib_add (NULL, 0, NULL, auto_solib_add);
+ solib_add (NULL, 0, ¤t_target, auto_solib_add);
so = master_so_list ();
while (so)
{
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 ()
debug_loader_name = xstrdup (buf);
debug_loader_offset_p = 1;
debug_loader_offset = load_addr;
- solib_add (NULL, 0, NULL, auto_solib_add);
+ solib_add (NULL, 0, ¤t_target, auto_solib_add);
}
/* Record the relocated start and end address of the dynamic linker
/* Now try to set a breakpoint in the dynamic linker. */
for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
{
- /* On ABI's that use function descriptors, there are usually
- two linker symbols associated with each C function: one
- pointing at the actual entry point of the machine code,
- and one pointing at the function's descriptor. The
- latter symbol has the same name as the C function.
-
- What we're looking for here is the machine code entry
- point, so we are only interested in symbols in code
- sections. */
- sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep, SEC_CODE);
+ sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep);
if (sym_addr != 0)
break;
}
+ 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 (current_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);
/* For whatever reason we couldn't set a breakpoint in the dynamic
linker. Warn and drop into the old code. */
bkpt_at_symbol:
+ xfree (tmp_pathname);
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_dyntag (DT_SYMBOLIC, objfile->obfd, NULL) != 1)
return NULL;
- return lookup_global_symbol_from_objfile
+ return lookup_global_symbol_from_objfile
(objfile, name, linkage_name, domain, symtab);
}
projects / deliverable / binutils-gdb.git / blobdiff