/* 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
- Free Software Foundation, Inc.
+ Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
+ 2001, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
This file is part of GDB.
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.
-
- Assume that the address is unsigned. */
-
-#define SOLIB_EXTRACT_ADDRESS(MEMBER) \
- extract_unsigned_integer (&(MEMBER), sizeof (MEMBER))
-
-/* local data declarations */
-
/* link map access functions */
static CORE_ADDR
{
struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
- return (CORE_ADDR) extract_signed_integer (so->lm_info->lm
- + lmo->l_addr_offset,
- lmo->l_addr_size);
+ return extract_typed_address (so->lm_info->lm + lmo->l_addr_offset,
+ builtin_type_void_data_ptr);
}
static int
{
struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
- return (lmo->l_ld_size != 0);
+ return lmo->l_ld_offset >= 0;
}
static CORE_ADDR
{
struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
- gdb_assert (lmo->l_ld_size != 0);
-
- return (CORE_ADDR) extract_signed_integer (so->lm_info->lm
- + lmo->l_ld_offset,
- lmo->l_ld_size);
+ return extract_typed_address (so->lm_info->lm + lmo->l_ld_offset,
+ builtin_type_void_data_ptr);
}
static CORE_ADDR
if (dynaddr + l_addr != l_dynaddr)
{
- warning (_(".dynamic section for \"%s\" "
- "is not at the expected address"), so->so_name);
-
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
{
Elf_Internal_Ehdr *ehdr = elf_tdata (abfd)->elf_header;
if ((l_addr & align) == 0 && ((dynaddr - l_dynaddr) & align) == 0)
{
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:
{
struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
- /* Assume that the address is unsigned. */
- return extract_unsigned_integer (so->lm_info->lm + lmo->l_next_offset,
- lmo->l_next_size);
+ return extract_typed_address (so->lm_info->lm + lmo->l_next_offset,
+ builtin_type_void_data_ptr);
}
static CORE_ADDR
{
struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
- /* Assume that the address is unsigned. */
- return extract_unsigned_integer (so->lm_info->lm + lmo->l_name_offset,
- lmo->l_name_size);
+ return extract_typed_address (so->lm_info->lm + lmo->l_name_offset,
+ builtin_type_void_data_ptr);
}
static int
{
struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
- /* Assume that the address is unsigned. */
- return extract_unsigned_integer (so->lm_info->lm + lmo->l_prev_offset,
- lmo->l_prev_size) == 0;
+ /* 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,
+ builtin_type_void_data_ptr) == 0;
}
static CORE_ADDR debug_base; /* Base of dynamic linker structures */
-static CORE_ADDR breakpoint_addr; /* Address where end bkpt is set */
+
+/* Validity flag for debug_loader_offset. */
+static int debug_loader_offset_p;
+
+/* Load address for the dynamic linker, inferred. */
+static CORE_ADDR debug_loader_offset;
+
+/* Name of the dynamic linker, valid if debug_loader_offset_p. */
+static char *debug_loader_name;
/* Local function prototypes */
/* Find the start address of the .dynamic section. */
dyninfo_sect = bfd_get_section_by_name (exec_bfd, ".dynamic");
if (dyninfo_sect == NULL)
- return 0;
+ {
+ /* This may be a static executable. Look for the symbol
+ conventionally named _r_debug, as a last resort. */
+ struct minimal_symbol *msymbol;
+
+ msymbol = lookup_minimal_symbol ("_r_debug", NULL, symfile_objfile);
+ if (msymbol != NULL)
+ return SYMBOL_VALUE_ADDRESS (msymbol);
+ else
+ return 0;
+ }
+
dyninfo_addr = bfd_section_vma (exec_bfd, dyninfo_sect);
/* Read in .dynamic section, silently ignore errors. */
else if (dyn_tag == DT_MIPS_RLD_MAP)
{
gdb_byte *pbuf;
- int pbuf_size = TARGET_PTR_BIT / HOST_CHAR_BIT;
+ int pbuf_size = TYPE_LENGTH (builtin_type_void_data_ptr);
pbuf = alloca (pbuf_size);
/* DT_MIPS_RLD_MAP contains a pointer to the address
(bfd_byte *) x_dynp->d_un.d_ptr);
if (target_read_memory (dyn_ptr, pbuf, pbuf_size))
return 0;
- return extract_unsigned_integer (pbuf, pbuf_size);
+ return extract_typed_address (pbuf, builtin_type_void_data_ptr);
}
}
}
else if (dyn_tag == DT_MIPS_RLD_MAP)
{
gdb_byte *pbuf;
- int pbuf_size = TARGET_PTR_BIT / HOST_CHAR_BIT;
+ int pbuf_size = TYPE_LENGTH (builtin_type_void_data_ptr);
pbuf = alloca (pbuf_size);
/* DT_MIPS_RLD_MAP contains a pointer to the address
(bfd_byte *) x_dynp->d_un.d_ptr);
if (target_read_memory (dyn_ptr, pbuf, pbuf_size))
return 0;
- return extract_unsigned_integer (pbuf, pbuf_size);
+ return extract_typed_address (pbuf, builtin_type_void_data_ptr);
}
}
}
int errcode;
int from_tty = *(int *)from_ttyp;
struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
- gdb_byte *l_name_buf = xmalloc (lmo->l_name_size);
+ int l_name_size = TYPE_LENGTH (builtin_type_void_data_ptr);
+ gdb_byte *l_name_buf = xmalloc (l_name_size);
struct cleanup *cleanups = make_cleanup (xfree, l_name_buf);
if (symfile_objfile)
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. Assume that the address is
- unsigned. */
- l_name = extract_unsigned_integer (l_name_buf, lmo->l_name_size);
+ /* Convert the address to host format. */
+ l_name = extract_typed_address (l_name_buf, builtin_type_void_data_ptr);
/* Free l_name_buf. */
do_cleanups (cleanups);
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 so_list *head = NULL;
+ struct so_list **link_ptr = &head;
+
+ if (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 = debug_loader_offset;
+ new->lm_info->lm = NULL;
+
+ strncpy (new->so_name, 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
/* 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;
+ return svr4_default_sos ();
}
/* Walk the inferior's link map list, and build our list of
`struct so_list' nodes. */
lm = solib_svr4_r_map ();
+
while (lm)
{
struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
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 = xzalloc (lmo->link_map_size);
make_cleanup (xfree, new->lm_info->lm);
free_so (new);
else
{
- new->lm_info->l_addr = (CORE_ADDR)-1;
-
new->next = 0;
*link_ptr = new;
link_ptr = &new->next;
discard_cleanups (old_chain);
}
+ if (head == NULL)
+ return svr4_default_sos ();
+
return head;
}
struct lm_info objfile_lm_info;
struct cleanup *old_chain;
CORE_ADDR name_address;
- gdb_byte *l_name_buf = xmalloc (lmo->l_name_size);
+ int l_name_size = TYPE_LENGTH (builtin_type_void_data_ptr);
+ gdb_byte *l_name_buf = xmalloc (l_name_size);
old_chain = make_cleanup (xfree, l_name_buf);
/* Set up the buffer to contain the portion of the link_map
read_memory (lm, objfile_lm_info.lm, lmo->link_map_size);
/* 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);
- /* Extract this object's name. Assume that the address is
- unsigned. */
- name_address = extract_unsigned_integer (l_name_buf, lmo->l_name_size);
+ /* Extract this object's name. */
+ name_address = extract_typed_address (l_name_buf,
+ builtin_type_void_data_ptr);
target_read_string (name_address, &buffer,
SO_NAME_MAX_PATH_SIZE - 1, &errcode);
make_cleanup (xfree, buffer);
return lm;
}
}
- /* Not the file we wanted, continue checking. Assume that the
- address is unsigned. */
- lm = extract_unsigned_integer (objfile_lm_info.lm + lmo->l_next_offset,
- lmo->l_next_size);
+ /* Not the file we wanted, continue checking. */
+ lm = extract_typed_address (objfile_lm_info.lm + lmo->l_next_offset,
+ builtin_type_void_data_ptr);
do_cleanups (old_chain);
}
return 0;
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)
static int
enable_break (void)
{
- int success = 0;
-
#ifdef BKPT_AT_SYMBOL
struct minimal_symbol *msymbol;
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);
+ /* 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);
the current pc (which should point at the entry point for the
dynamic linker) and subtracting the offset of the entry point. */
if (!load_addr_found)
- load_addr = (read_pc ()
- - exec_entry_point (tmp_bfd, tmp_bfd_target));
+ {
+ load_addr = (read_pc ()
+ - exec_entry_point (tmp_bfd, tmp_bfd_target));
+ debug_loader_name = xstrdup (buf);
+ debug_loader_offset_p = 1;
+ debug_loader_offset = load_addr;
+ solib_add (NULL, 0, NULL, auto_solib_add);
+ }
/* Record the relocated start and end address of the dynamic linker
text and plt section for svr4_in_dynsym_resolve_code. */
/* 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."));
+ 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))
}
}
- /* Nothing good happened. */
- success = 0;
-
+ 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;
+ }
+ }
#endif /* BKPT_AT_SYMBOL */
- return (success);
+ return 0;
}
/*
svr4_relocate_main_executable ();
if (!svr4_have_link_map_offsets ())
- {
- warning (_("no shared library support for this OS / ABI"));
- return;
-
- }
+ return;
if (!enable_break ())
- {
- warning (_("shared library handler failed to enable breakpoint"));
- return;
- }
+ return;
#if defined(_SCO_DS)
/* SCO needs the loop below, other systems should be using the
svr4_clear_solib (void)
{
debug_base = 0;
+ debug_loader_offset_p = 0;
+ debug_loader_offset = 0;
+ xfree (debug_loader_name);
+ debug_loader_name = NULL;
}
static void
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
- TARGET_PTR_BIT, as we do below, is no good.) This should probably
+ 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 (TARGET_PTR_BIT == sizeof (CORE_ADDR) * 8)
+ if (gdbarch_ptr_bit (current_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 << TARGET_PTR_BIT) - 1);
+ return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (current_gdbarch)) - 1);
}
/* Everything we need is in the first 20 bytes. */
lmo.link_map_size = 20;
lmo.l_addr_offset = 0;
- lmo.l_addr_size = 4;
lmo.l_name_offset = 4;
- lmo.l_name_size = 4;
lmo.l_ld_offset = 8;
- lmo.l_ld_size = 4;
lmo.l_next_offset = 12;
- lmo.l_next_size = 4;
lmo.l_prev_offset = 16;
- lmo.l_prev_size = 4;
}
return lmp;
/* Everything we need is in the first 40 bytes. */
lmo.link_map_size = 40;
lmo.l_addr_offset = 0;
- lmo.l_addr_size = 8;
lmo.l_name_offset = 8;
- lmo.l_name_size = 8;
lmo.l_ld_offset = 16;
- lmo.l_ld_size = 8;
lmo.l_next_offset = 24;
- lmo.l_next_size = 8;
lmo.l_prev_offset = 32;
- lmo.l_prev_size = 8;
}
return lmp;
}
\f
-static struct target_so_ops svr4_so_ops;
+struct target_so_ops svr4_so_ops;
extern initialize_file_ftype _initialize_svr4_solib; /* -Wmissing-prototypes */