/* Handle SVR4 shared libraries for GDB, the GNU Debugger.
- Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
- 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
- Free Software Foundation, Inc.
+ Copyright (C) 1990-1996, 1998-2001, 2003-2012 Free Software
+ Foundation, Inc.
This file is part of GDB.
struct lm_info
{
- /* 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. */
- 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;
+ match the inferior. The direct inferior value is L_ADDR_INFERIOR.
+ When prelinking is involved and the prelink base address changes,
+ we may need a different offset - the recomputed offset is in L_ADDR.
+ It is commonly the same value. It is cached as we want to warn about
+ the difference and compute it only once. L_ADDR is valid
+ iff L_ADDR_P. */
+ CORE_ADDR l_addr, l_addr_inferior;
+ unsigned int l_addr_p : 1;
/* The target location of lm. */
CORE_ADDR lm_addr;
+
+ /* Values read in from inferior's fields of the same name. */
+ CORE_ADDR l_ld, l_next, l_prev, l_name;
};
/* On SVR4 systems, a list of symbols in the dynamic linker where
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
+ /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. */
return (svr4_same_1 (gdb->so_original_name, inferior->so_original_name));
}
-/* link map access functions. */
-
-static CORE_ADDR
-lm_addr_from_link_map (struct so_list *so)
+static struct lm_info *
+lm_info_read (CORE_ADDR lm_addr)
{
struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
- struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+ gdb_byte *lm;
+ struct lm_info *lm_info;
+ struct cleanup *back_to;
- return extract_typed_address (so->lm_info->lm + lmo->l_addr_offset,
- ptr_type);
+ lm = xmalloc (lmo->link_map_size);
+ back_to = make_cleanup (xfree, lm);
+
+ if (target_read_memory (lm_addr, lm, lmo->link_map_size) != 0)
+ {
+ warning (_("Error reading shared library list entry at %s"),
+ paddress (target_gdbarch, lm_addr)),
+ lm_info = NULL;
+ }
+ else
+ {
+ struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+
+ lm_info = xzalloc (sizeof (*lm_info));
+ lm_info->lm_addr = lm_addr;
+
+ lm_info->l_addr_inferior = extract_typed_address (&lm[lmo->l_addr_offset],
+ ptr_type);
+ lm_info->l_ld = extract_typed_address (&lm[lmo->l_ld_offset], ptr_type);
+ lm_info->l_next = extract_typed_address (&lm[lmo->l_next_offset],
+ ptr_type);
+ lm_info->l_prev = extract_typed_address (&lm[lmo->l_prev_offset],
+ ptr_type);
+ lm_info->l_name = extract_typed_address (&lm[lmo->l_name_offset],
+ ptr_type);
+ }
+
+ do_cleanups (back_to);
+
+ return lm_info;
}
static int
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)
{
- if (so->lm_info->l_addr == (CORE_ADDR)-1)
+ if (!so->lm_info->l_addr_p)
{
struct bfd_section *dyninfo_sect;
CORE_ADDR l_addr, l_dynaddr, dynaddr;
- l_addr = lm_addr_from_link_map (so);
+ l_addr = so->lm_info->l_addr_inferior;
if (! abfd || ! has_lm_dynamic_from_link_map ())
goto set_addr;
- l_dynaddr = lm_dynamic_from_link_map (so);
+ l_dynaddr = so->lm_info->l_ld;
dyninfo_sect = bfd_get_section_by_name (abfd, ".dynamic");
if (dyninfo_sect == NULL)
set_addr:
so->lm_info->l_addr = l_addr;
+ so->lm_info->l_addr_p = 1;
}
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 type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
-
- return extract_typed_address (so->lm_info->lm + lmo->l_next_offset,
- ptr_type);
-}
-
-static CORE_ADDR
-lm_prev (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_prev_offset,
- ptr_type);
-}
-
-static CORE_ADDR
-lm_name (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_name_offset,
- ptr_type);
-}
-
-static int
-ignore_first_link_map_entry (struct so_list *so)
-{
- /* 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 lm_prev (so) == 0;
-}
-
/* Per pspace SVR4 specific data. */
struct svr4_info
static int match_main (const char *);
-/*
-
- LOCAL FUNCTION
-
- bfd_lookup_symbol -- lookup the value for a specific symbol
-
- SYNOPSIS
-
- 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
- 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).
- */
-
-static CORE_ADDR
-bfd_lookup_symbol (bfd *abfd, const char *symname)
-{
- long storage_needed;
- asymbol *sym;
- asymbol **symbol_table;
- unsigned int number_of_symbols;
- unsigned int i;
- struct cleanup *back_to;
- CORE_ADDR symaddr = 0;
-
- storage_needed = bfd_get_symtab_upper_bound (abfd);
-
- if (storage_needed > 0)
- {
- symbol_table = (asymbol **) xmalloc (storage_needed);
- 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 (strcmp (sym->name, symname) == 0
- && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)
- {
- /* BFD symbols are section relative. */
- symaddr = sym->value + sym->section->vma;
- break;
- }
- }
- do_cleanups (back_to);
- }
-
- if (symaddr)
- return symaddr;
-
- /* On FreeBSD, the dynamic linker is stripped by default. So we'll
- have to check the dynamic string table too. */
-
- storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
-
- if (storage_needed > 0)
- {
- symbol_table = (asymbol **) xmalloc (storage_needed);
- 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 (strcmp (sym->name, symname) == 0
- && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)
- {
- /* BFD symbols are section relative. */
- symaddr = sym->value + sym->section->vma;
- break;
- }
- }
- do_cleanups (back_to);
- }
-
- return symaddr;
-}
-
-
/* Read program header TYPE from inferior memory. The header is found
by scanning the OS auxillary vector.
read_program_header (int type, int *p_sect_size, int *p_arch_size)
{
enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
- CORE_ADDR at_phdr, at_phent, at_phnum;
+ CORE_ADDR at_phdr, at_phent, at_phnum, pt_phdr = 0;
int arch_size, sect_size;
CORE_ADDR sect_addr;
gdb_byte *buf;
+ int pt_phdr_p = 0;
/* Get required auxv elements from target. */
if (target_auxv_search (¤t_target, AT_PHDR, &at_phdr) <= 0)
/* Search for requested PHDR. */
for (i = 0; i < at_phnum; i++)
{
+ int p_type;
+
if (target_read_memory (at_phdr + i * sizeof (phdr),
(gdb_byte *)&phdr, sizeof (phdr)))
return 0;
- if (extract_unsigned_integer ((gdb_byte *)phdr.p_type,
- 4, byte_order) == type)
+ p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type,
+ 4, byte_order);
+
+ if (p_type == PT_PHDR)
+ {
+ pt_phdr_p = 1;
+ pt_phdr = extract_unsigned_integer ((gdb_byte *) phdr.p_vaddr,
+ 4, byte_order);
+ }
+
+ if (p_type == type)
break;
}
/* Search for requested PHDR. */
for (i = 0; i < at_phnum; i++)
{
+ int p_type;
+
if (target_read_memory (at_phdr + i * sizeof (phdr),
(gdb_byte *)&phdr, sizeof (phdr)))
return 0;
- if (extract_unsigned_integer ((gdb_byte *)phdr.p_type,
- 4, byte_order) == type)
+ p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type,
+ 4, byte_order);
+
+ if (p_type == PT_PHDR)
+ {
+ pt_phdr_p = 1;
+ pt_phdr = extract_unsigned_integer ((gdb_byte *) phdr.p_vaddr,
+ 8, byte_order);
+ }
+
+ if (p_type == type)
break;
}
8, byte_order);
}
+ /* PT_PHDR is optional, but we really need it
+ for PIE to make this work in general. */
+
+ if (pt_phdr_p)
+ {
+ /* at_phdr is real address in memory. pt_phdr is what pheader says it is.
+ Relocation offset is the difference between the two. */
+ sect_addr = sect_addr + (at_phdr - pt_phdr);
+ }
+
/* Read in requested program header. */
buf = xmalloc (sect_size);
if (target_read_memory (sect_addr, buf, sect_size))
return 0;
}
-
-/*
-
- 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
+/* Locate the base address of dynamic linker structs for SVR4 elf
+ targets.
For SVR4 elf targets the address of the dynamic linker's runtime
structure is contained within the dynamic info section 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.
-
- */
+ silently return 0, otherwise the found address is returned. */
static CORE_ADDR
elf_locate_base (void)
return 0;
}
-/*
-
- LOCAL FUNCTION
-
- locate_base -- locate the base address of dynamic linker structs
-
- SYNOPSIS
-
- CORE_ADDR locate_base (struct svr4_info *)
-
- DESCRIPTION
+/* Locate the base address of dynamic linker structs.
For both the SunOS and SVR4 shared library implementations, if the
inferior executable has been linked dynamically, there is a single
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.
-
- */
+ executable symbol tables. */
static CORE_ADDR
locate_base (struct svr4_info *info)
struct so_list *new;
struct cleanup *old_chain;
struct link_map_offsets *lmo;
- CORE_ADDR lm_name;
+ CORE_ADDR name_lm;
info = get_svr4_info ();
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));
+ new->lm_info = lm_info_read (ldsomap);
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);
+ name_lm = new->lm_info ? new->lm_info->l_name : 0;
do_cleanups (old_chain);
- return (lm_name >= vaddr && lm_name < vaddr + size);
+ return (name_lm >= vaddr && name_lm < vaddr + size);
}
-/*
-
- LOCAL FUNCTION
-
- open_symbol_file_object
-
- SYNOPSIS
-
- void open_symbol_file_object (void *from_tty)
+/* Implement the "open_symbol_file_object" target_so_ops method.
- DESCRIPTION
-
- If no open symbol file, attempt to locate and open the main symbol
- file. On SVR4 systems, this is the first link map entry. If its
- name is here, we can open it. Useful when attaching to a process
- without first loading its symbol file.
-
- If FROM_TTYP dereferences to a non-zero integer, allow messages to
- be printed. This parameter is a pointer rather than an int because
- open_symbol_file_object() is called via catch_errors() and
- catch_errors() requires a pointer argument. */
+ If no open symbol file, attempt to locate and open the main symbol
+ file. On SVR4 systems, this is the first link map entry. If its
+ name is here, we can open it. Useful when attaching to a process
+ without first loading its symbol file. */
static int
open_symbol_file_object (void *from_ttyp)
if (symfile_objfile)
if (!query (_("Attempt to reload symbols from process? ")))
- return 0;
+ {
+ do_cleanups (cleanups);
+ return 0;
+ }
/* Always locate the debug struct, in case it has moved. */
info->debug_base = 0;
if (locate_base (info) == 0)
- return 0; /* failed somehow... */
+ {
+ do_cleanups (cleanups);
+ return 0; /* failed somehow... */
+ }
/* First link map member should be the executable. */
lm = solib_svr4_r_map (info);
if (lm == 0)
- return 0; /* failed somehow... */
+ {
+ do_cleanups (cleanups);
+ return 0; /* failed somehow... */
+ }
/* Read address of name from target memory to GDB. */
read_memory (lm + lmo->l_name_offset, l_name_buf, l_name_size);
/* Convert the address to host format. */
l_name = extract_typed_address (l_name_buf, ptr_type);
- /* Free l_name_buf. */
- do_cleanups (cleanups);
-
if (l_name == 0)
- return 0; /* No filename. */
+ {
+ do_cleanups (cleanups);
+ return 0; /* No filename. */
+ }
/* Now fetch the filename from target memory. */
target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
{
warning (_("failed to read exec filename from attached file: %s"),
safe_strerror (errcode));
+ do_cleanups (cleanups);
return 0;
}
/* Have a pathname: read the symbol file. */
symbol_file_add_main (filename, from_tty);
+ do_cleanups (cleanups);
return 1;
}
-/* If no shared library information is available from the dynamic
- linker, build a fallback list from other sources. */
+/* Data exchange structure for the XML parser as returned by
+ svr4_current_sos_via_xfer_libraries. */
-static struct so_list *
-svr4_default_sos (void)
+struct svr4_library_list
{
- struct svr4_info *info = get_svr4_info ();
+ struct so_list *head, **tailp;
- struct so_list *head = NULL;
- struct so_list **link_ptr = &head;
+ /* Inferior address of struct link_map used for the main executable. It is
+ NULL if not known. */
+ CORE_ADDR main_lm;
+};
+
+/* Implementation for target_so_ops.free_so. */
+
+static void
+svr4_free_so (struct so_list *so)
+{
+ xfree (so->lm_info);
+}
- if (info->debug_loader_offset_p)
+/* Free so_list built so far (called via cleanup). */
+
+static void
+svr4_free_library_list (void *p_list)
+{
+ struct so_list *list = *(struct so_list **) p_list;
+
+ while (list != NULL)
{
- struct so_list *new = XZALLOC (struct so_list);
+ struct so_list *next = list->next;
+
+ svr4_free_so (list);
+ list = next;
+ }
+}
- new->lm_info = xmalloc (sizeof (struct lm_info));
+#ifdef HAVE_LIBEXPAT
- /* 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;
+#include "xml-support.h"
- 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);
+/* Handle the start of a <library> element. Note: new elements are added
+ at the tail of the list, keeping the list in order. */
- *link_ptr = new;
- link_ptr = &new->next;
+static void
+library_list_start_library (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data, VEC(gdb_xml_value_s) *attributes)
+{
+ struct svr4_library_list *list = user_data;
+ const char *name = xml_find_attribute (attributes, "name")->value;
+ ULONGEST *lmp = xml_find_attribute (attributes, "lm")->value;
+ ULONGEST *l_addrp = xml_find_attribute (attributes, "l_addr")->value;
+ ULONGEST *l_ldp = xml_find_attribute (attributes, "l_ld")->value;
+ struct so_list *new_elem;
+
+ new_elem = XZALLOC (struct so_list);
+ new_elem->lm_info = XZALLOC (struct lm_info);
+ new_elem->lm_info->lm_addr = *lmp;
+ new_elem->lm_info->l_addr_inferior = *l_addrp;
+ new_elem->lm_info->l_ld = *l_ldp;
+
+ strncpy (new_elem->so_name, name, sizeof (new_elem->so_name) - 1);
+ new_elem->so_name[sizeof (new_elem->so_name) - 1] = 0;
+ strcpy (new_elem->so_original_name, new_elem->so_name);
+
+ *list->tailp = new_elem;
+ list->tailp = &new_elem->next;
+}
+
+/* Handle the start of a <library-list-svr4> element. */
+
+static void
+svr4_library_list_start_list (struct gdb_xml_parser *parser,
+ const struct gdb_xml_element *element,
+ void *user_data, VEC(gdb_xml_value_s) *attributes)
+{
+ struct svr4_library_list *list = user_data;
+ const char *version = xml_find_attribute (attributes, "version")->value;
+ struct gdb_xml_value *main_lm = xml_find_attribute (attributes, "main-lm");
+
+ if (strcmp (version, "1.0") != 0)
+ gdb_xml_error (parser,
+ _("SVR4 Library list has unsupported version \"%s\""),
+ version);
+
+ if (main_lm)
+ list->main_lm = *(ULONGEST *) main_lm->value;
+}
+
+/* The allowed elements and attributes for an XML library list.
+ The root element is a <library-list>. */
+
+static const struct gdb_xml_attribute svr4_library_attributes[] =
+{
+ { "name", GDB_XML_AF_NONE, NULL, NULL },
+ { "lm", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
+ { "l_addr", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
+ { "l_ld", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_element svr4_library_list_children[] =
+{
+ {
+ "library", svr4_library_attributes, NULL,
+ GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
+ library_list_start_library, NULL
+ },
+ { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_attribute svr4_library_list_attributes[] =
+{
+ { "version", GDB_XML_AF_NONE, NULL, NULL },
+ { "main-lm", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
+ { NULL, GDB_XML_AF_NONE, NULL, NULL }
+};
+
+static const struct gdb_xml_element svr4_library_list_elements[] =
+{
+ { "library-list-svr4", svr4_library_list_attributes, svr4_library_list_children,
+ GDB_XML_EF_NONE, svr4_library_list_start_list, NULL },
+ { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
+};
+
+/* Parse qXfer:libraries:read packet into *SO_LIST_RETURN. Return 1 if
+
+ Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
+ case. Return 1 if *SO_LIST_RETURN contains the library list, it may be
+ empty, caller is responsible for freeing all its entries. */
+
+static int
+svr4_parse_libraries (const char *document, struct svr4_library_list *list)
+{
+ struct cleanup *back_to = make_cleanup (svr4_free_library_list,
+ &list->head);
+
+ memset (list, 0, sizeof (*list));
+ list->tailp = &list->head;
+ if (gdb_xml_parse_quick (_("target library list"), "library-list.dtd",
+ svr4_library_list_elements, document, list) == 0)
+ {
+ /* Parsed successfully, keep the result. */
+ discard_cleanups (back_to);
+ return 1;
}
- return head;
+ do_cleanups (back_to);
+ return 0;
}
-/* LOCAL FUNCTION
+/* Attempt to get so_list from target via qXfer:libraries:read packet.
- current_sos -- build a list of currently loaded shared objects
+ Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
+ case. Return 1 if *SO_LIST_RETURN contains the library list, it may be
+ empty, caller is responsible for freeing all its entries. */
- SYNOPSIS
+static int
+svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list)
+{
+ char *svr4_library_document;
+ int result;
+ struct cleanup *back_to;
- struct so_list *current_sos ()
+ /* Fetch the list of shared libraries. */
+ svr4_library_document = target_read_stralloc (¤t_target,
+ TARGET_OBJECT_LIBRARIES_SVR4,
+ NULL);
+ if (svr4_library_document == NULL)
+ return 0;
- DESCRIPTION
+ back_to = make_cleanup (xfree, svr4_library_document);
+ result = svr4_parse_libraries (svr4_library_document, list);
+ do_cleanups (back_to);
- Build a list of `struct so_list' objects describing the shared
- objects currently loaded in the inferior. This list does not
- include an entry for the main executable file.
+ return result;
+}
- Note that we only gather information directly available from the
- inferior --- we don't examine any of the shared library files
- themselves. The declaration of `struct so_list' says which fields
- we provide values for. */
+#else
+
+static int
+svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list)
+{
+ return 0;
+}
+
+#endif
+
+/* If no shared library information is available from the dynamic
+ linker, build a fallback list from other sources. */
static struct so_list *
-svr4_current_sos (void)
+svr4_default_sos (void)
{
- CORE_ADDR lm, prev_lm;
- struct so_list *head = 0;
- struct so_list **link_ptr = &head;
- CORE_ADDR ldsomap = 0;
- struct svr4_info *info;
+ struct svr4_info *info = get_svr4_info ();
+ struct so_list *new;
- info = get_svr4_info ();
+ if (!info->debug_loader_offset_p)
+ return NULL;
- /* Always locate the debug struct, in case it has moved. */
- info->debug_base = 0;
- locate_base (info);
+ new = XZALLOC (struct so_list);
- /* 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 ();
+ new->lm_info = xzalloc (sizeof (struct lm_info));
- /* Walk the inferior's link map list, and build our list of
- `struct so_list' nodes. */
- prev_lm = 0;
- lm = solib_svr4_r_map (info);
+ /* Nothing will ever check the other fields if we set l_addr_p. */
+ new->lm_info->l_addr = info->debug_loader_offset;
+ new->lm_info->l_addr_p = 1;
+
+ 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);
+
+ return new;
+}
+
+/* Read the whole inferior libraries chain starting at address LM. Add the
+ entries to the tail referenced by LINK_PTR_PTR. Ignore the first entry if
+ IGNORE_FIRST and set global MAIN_LM_ADDR according to it. */
+
+static void
+svr4_read_so_list (CORE_ADDR lm, struct so_list ***link_ptr_ptr,
+ int ignore_first)
+{
+ CORE_ADDR prev_lm = 0, next_lm;
- while (lm)
+ for (; lm != 0; prev_lm = lm, lm = next_lm)
{
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);
- CORE_ADDR next_lm;
-
- new->lm_info = xmalloc (sizeof (struct lm_info));
- make_cleanup (xfree, new->lm_info);
+ struct so_list *new;
+ struct cleanup *old_chain;
+ int errcode;
+ char *buffer;
- 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);
+ new = XZALLOC (struct so_list);
+ old_chain = make_cleanup_free_so (new);
- read_memory (lm, new->lm_info->lm, lmo->link_map_size);
+ new->lm_info = lm_info_read (lm);
+ if (new->lm_info == NULL)
+ {
+ do_cleanups (old_chain);
+ break;
+ }
- next_lm = lm_next (new);
+ next_lm = new->lm_info->l_next;
- if (lm_prev (new) != prev_lm)
+ if (new->lm_info->l_prev != prev_lm)
{
- warning (_("Corrupted shared library list"));
- free_so (new);
- next_lm = 0;
+ warning (_("Corrupted shared library list: %s != %s"),
+ paddress (target_gdbarch, prev_lm),
+ paddress (target_gdbarch, new->lm_info->l_prev));
+ do_cleanups (old_chain);
+ break;
}
/* For SVR4 versions, the first entry in the link map is for the
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. */
- else if (ignore_first_link_map_entry (new) && ldsomap == 0)
+ if (ignore_first && new->lm_info->l_prev == 0)
{
+ struct svr4_info *info = get_svr4_info ();
+
info->main_lm_addr = new->lm_info->lm_addr;
- free_so (new);
+ do_cleanups (old_chain);
+ continue;
}
- else
- {
- int errcode;
- char *buffer;
-
- /* Extract this shared object's name. */
- target_read_string (lm_name (new), &buffer,
- SO_NAME_MAX_PATH_SIZE - 1, &errcode);
- if (errcode != 0)
- 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';
- 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. */
- if (! new->so_name[0]
- || match_main (new->so_name))
- free_so (new);
- else
- {
- new->next = 0;
- *link_ptr = new;
- link_ptr = &new->next;
- }
+ /* Extract this shared object's name. */
+ target_read_string (new->lm_info->l_name, &buffer,
+ SO_NAME_MAX_PATH_SIZE - 1, &errcode);
+ if (errcode != 0)
+ {
+ warning (_("Can't read pathname for load map: %s."),
+ safe_strerror (errcode));
+ do_cleanups (old_chain);
+ continue;
}
- prev_lm = lm;
- lm = next_lm;
+ strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);
+ new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
+ strcpy (new->so_original_name, new->so_name);
+ xfree (buffer);
- /* 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)
+ /* If this entry has no name, or its name matches the name
+ for the main executable, don't include it in the list. */
+ if (! new->so_name[0] || match_main (new->so_name))
{
- lm = ldsomap = solib_svr4_r_ldsomap (info);
- prev_lm = 0;
+ do_cleanups (old_chain);
+ continue;
}
discard_cleanups (old_chain);
+ new->next = 0;
+ **link_ptr_ptr = new;
+ *link_ptr_ptr = &new->next;
}
+}
+
+/* Implement the "current_sos" target_so_ops method. */
+
+static struct so_list *
+svr4_current_sos (void)
+{
+ CORE_ADDR lm;
+ struct so_list *head = NULL;
+ struct so_list **link_ptr = &head;
+ struct svr4_info *info;
+ struct cleanup *back_to;
+ int ignore_first;
+ struct svr4_library_list library_list;
+
+ /* Fall back to manual examination of the target if the packet is not
+ supported or gdbserver failed to find DT_DEBUG. gdb.server/solib-list.exp
+ tests a case where gdbserver cannot find the shared libraries list while
+ GDB itself is able to find it via SYMFILE_OBJFILE.
+
+ Unfortunately statically linked inferiors will also fall back through this
+ suboptimal code path. */
+
+ if (svr4_current_sos_via_xfer_libraries (&library_list))
+ {
+ if (library_list.main_lm)
+ {
+ info = get_svr4_info ();
+ info->main_lm_addr = library_list.main_lm;
+ }
+
+ return library_list.head ? library_list.head : svr4_default_sos ();
+ }
+
+ info = get_svr4_info ();
+
+ /* 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 ();
+
+ /* 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)
+ ignore_first = 0;
+ else
+ ignore_first = 1;
+
+ back_to = make_cleanup (svr4_free_library_list, &head);
+
+ /* Walk the inferior's link map list, and build our list of
+ `struct so_list' nodes. */
+ lm = solib_svr4_r_map (info);
+ if (lm)
+ svr4_read_so_list (lm, &link_ptr, ignore_first);
+
+ /* 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. */
+ lm = solib_svr4_r_ldsomap (info);
+ if (lm)
+ svr4_read_so_list (lm, &link_ptr, 0);
+
+ discard_cleanups (back_to);
if (head == NULL)
return svr4_default_sos ();
targ);
}
-/*
+/* Helper function for gdb_bfd_lookup_symbol. */
- LOCAL FUNCTION
-
- enable_break -- arrange for dynamic linker to hit breakpoint
-
- SYNOPSIS
-
- int enable_break (void)
-
- DESCRIPTION
+static int
+cmp_name_and_sec_flags (asymbol *sym, void *data)
+{
+ return (strcmp (sym->name, (const char *) data) == 0
+ && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0);
+}
+/* Arrange for dynamic linker to hit breakpoint.
Both the SunOS and the SVR4 dynamic linkers have, as part of their
debugger interface, support for arranging for the inferior to hit
The debugger interface structure also contains an enumeration which
is set to either RT_ADD or RT_DELETE prior to changing the mapping,
depending upon whether or not the library is being mapped or unmapped,
- and then set to RT_CONSISTENT after the library is mapped/unmapped.
- */
+ and then set to RT_CONSISTENT after the library is mapped/unmapped. */
static int
enable_break (struct svr4_info *info, int from_tty)
/* Now try to set a breakpoint in the dynamic linker. */
for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
{
- sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep);
+ sym_addr = gdb_bfd_lookup_symbol (tmp_bfd, cmp_name_and_sec_flags,
+ (void *) *bkpt_namep);
if (sym_addr != 0)
break;
}
}
}
- if (!current_inferior ()->attach_flag)
+ if (interp_name != NULL && !current_inferior ()->attach_flag)
{
for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
{
return 0;
}
-/*
-
- LOCAL FUNCTION
-
- special_symbol_handling -- additional shared library symbol handling
-
- SYNOPSIS
-
- void special_symbol_handling ()
-
- DESCRIPTION
-
- Once the symbols from a shared object have been loaded in the usual
- way, we are called to do any system specific symbol handling that
- is needed.
-
- For SunOS4, this consisted of grunging around in the dynamic
- linkers structures to find symbol definitions for "common" symbols
- and adding them to the minimal symbol table for the runtime common
- objfile.
-
- However, for SVR4, there's nothing to do.
-
- */
+/* Implement the "special_symbol_handling" target_so_ops method. */
static void
svr4_special_symbol_handling (void)
{
+ /* Nothing to do. */
}
/* Read the ELF program headers from ABFD. Return the contents and
So, to summarize, relocations are necessary when the start address obtained
from the executable is different from the address in auxv AT_ENTRY entry.
-
+
[ The astute reader will note that we also test to make sure that
the executable in question has the DYNAMIC flag set. It is my
opinion that this test is unnecessary (undesirable even). It
}
}
-/*
-
- GLOBAL FUNCTION
-
- svr4_solib_create_inferior_hook -- shared library startup support
-
- SYNOPSIS
-
- void svr4_solib_create_inferior_hook (int from_tty)
-
- DESCRIPTION
-
- When gdb starts up the inferior, it nurses it along (through the
- shell) until it is ready to execute it's first instruction. At this
- point, this function gets called via expansion of the macro
- SOLIB_CREATE_INFERIOR_HOOK.
-
- For SunOS executables, this first instruction is typically the
- one at "_start", or a similar text label, regardless of whether
- the executable is statically or dynamically linked. The runtime
- startup code takes care of dynamically linking in any shared
- libraries, once gdb allows the inferior to continue.
+/* Implement the "create_inferior_hook" target_solib_ops method.
For SVR4 executables, this first instruction is either the first
instruction in the dynamic linker (for dynamically linked
shared libraries, maps in the actual user executable, and then
jumps to "start" in the user executable.
- For both SunOS shared libraries, and SVR4 shared libraries, we
- can arrange to cooperate with the dynamic linker to discover the
- names of shared libraries that are dynamically linked, and the
- base addresses to which they are linked.
+ We can arrange to cooperate with the dynamic linker to discover the
+ names of shared libraries that are dynamically linked, and the base
+ addresses to which they are linked.
This function is responsible for discovering those names and
addresses, and saving sufficient information about them to allow
handling will probably have to wait until the implementation is
changed to use the "breakpoint handler function" method.
- Also, what if child has exit()ed? Must exit loop somehow.
- */
+ Also, what if child has exit()ed? Must exit loop somehow. */
static void
svr4_solib_create_inferior_hook (int from_tty)
/* Relocate the main executable if necessary. */
svr4_relocate_main_executable ();
+ /* No point setting a breakpoint in the dynamic linker if we can't
+ hit it (e.g., a core file, or a trace file). */
+ if (!target_has_execution)
+ return;
+
if (!svr4_have_link_map_offsets ())
return;
clear_proceed_status ();
inf->control.stop_soon = STOP_QUIETLY;
- tp->suspend.stop_signal = TARGET_SIGNAL_0;
+ tp->suspend.stop_signal = GDB_SIGNAL_0;
do
{
target_resume (pid_to_ptid (-1), 0, tp->suspend.stop_signal);
- wait_for_inferior (0);
+ wait_for_inferior ();
}
- while (tp->suspend.stop_signal != TARGET_SIGNAL_TRAP);
+ while (tp->suspend.stop_signal != GDB_SIGNAL_TRAP);
inf->control.stop_soon = NO_STOP_QUIETLY;
#endif /* defined(_SCO_DS) */
}
info->debug_loader_name = NULL;
}
-static void
-svr4_free_so (struct so_list *so)
-{
- xfree (so->lm_info->lm);
- 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
/* 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)
{
/* 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)
{
projects / deliverable / binutils-gdb.git / blobdiff