/* 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
+ 2001, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
This file is part of GDB.
static int svr4_have_link_map_offsets (void);
static void svr4_relocate_main_executable (void);
-/* Link map info to include in an allocated so_list entry */
+/* Link map info to include in an allocated so_list entry. */
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);
-static int
-HAS_LM_DYNAMIC_FROM_LINK_MAP (void)
-{
- struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
+ 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;
- return lmo->l_ld_offset >= 0;
+ 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 CORE_ADDR
-LM_DYNAMIC_FROM_LINK_MAP (struct so_list *so)
+static int
+has_lm_dynamic_from_link_map (void)
{
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);
+ return lmo->l_ld_offset >= 0;
}
static CORE_ADDR
-LM_ADDR_CHECK (struct so_list *so, bfd *abfd)
+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 ())
+ 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)
Even on PPC it must be zero-aligned at least for MINPAGESIZE. */
+ l_addr = l_dynaddr - dynaddr;
+
if ((l_addr & (minpagesize - 1)) == 0
&& (l_addr & align) == ((l_dynaddr - dynaddr) & align))
{
- l_addr = l_dynaddr - dynaddr;
-
if (info_verbose)
printf_unfiltered (_("Using PIC (Position Independent Code) "
"prelink displacement %s for \"%s\".\n"),
so->so_name);
}
else
- warning (_(".dynamic section for \"%s\" "
- "is not at the expected address "
- "(wrong library or version mismatch?)"), so->so_name);
+ {
+ /* There is no way to verify the library file matches. prelink
+ can during prelinking of an unprelinked file (or unprelinking
+ of a prelinked file) shift the DYNAMIC segment by arbitrary
+ offset without any page size alignment. There is no way to
+ find out the ELF header and/or Program Headers for a limited
+ verification if it they match. One could do a verification
+ of the DYNAMIC segment. Still the found address is the best
+ one GDB could find. */
+
+ 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;
+ 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
{
- CORE_ADDR debug_base; /* Base of dynamic linker structures */
+ CORE_ADDR debug_base; /* Base of dynamic linker structures. */
/* Validity flag for debug_loader_offset. */
int debug_loader_offset_p;
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))
}
-/* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
+/* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
returned and the corresponding PTR is set. */
static int
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. */
+/* Implementation for target_so_ops.free_so. */
-static struct so_list *
-svr4_default_sos (void)
+static void
+svr4_free_so (struct so_list *so)
{
- 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);
+ xfree (so->lm_info);
+}
- new->lm_info = xmalloc (sizeof (struct lm_info));
+/* Free so_list built so far (called via cleanup). */
- /* 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;
+static void
+svr4_free_library_list (void *p_list)
+{
+ struct so_list *list = *(struct so_list **) p_list;
- 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);
+ while (list != NULL)
+ {
+ struct so_list *next = list->next;
- *link_ptr = new;
- link_ptr = &new->next;
+ svr4_free_so (list);
+ list = next;
}
-
- return head;
}
-/* LOCAL FUNCTION
-
- current_sos -- build a list of currently loaded shared objects
-
- SYNOPSIS
+/* If no shared library information is available from the dynamic
+ linker, build a fallback list from other sources. */
- struct so_list *current_sos ()
+static struct so_list *
+svr4_default_sos (void)
+{
+ struct svr4_info *info = get_svr4_info ();
+ struct so_list *new;
- DESCRIPTION
+ if (!info->debug_loader_offset_p)
+ return NULL;
- 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.
+ new = XZALLOC (struct so_list);
- 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. */
+ new->lm_info = xzalloc (sizeof (struct lm_info));
-static struct so_list *
-svr4_current_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;
+ /* 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;
- info = get_svr4_info ();
+ 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);
- /* Always locate the debug struct, in case it has moved. */
- info->debug_base = 0;
- locate_base (info);
+ return new;
+}
- /* 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 ();
+/* 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. */
- /* 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);
+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;
+ do_cleanups (old_chain);
+ break;
}
/* For SVR4 versions, the first entry in the link map is for the
inferior executable, so we must ignore it. For some versions of
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)
+ decide when to ignore it. */
+ 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;
+
+ 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 ();
&& pc < info->interp_text_sect_high)
|| (pc >= info->interp_plt_sect_low
&& pc < info->interp_plt_sect_high)
- || in_plt_section (pc, NULL));
+ || in_plt_section (pc, NULL)
+ || in_gnu_ifunc_stub (pc));
}
/* Given an executable's ABFD and target, compute the entry-point
targ);
}
-/*
-
- LOCAL FUNCTION
-
- enable_break -- arrange for dynamic linker to hit breakpoint
+/* Helper function for gdb_bfd_lookup_symbol. */
- 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)
sym_addr = gdbarch_addr_bits_remove
(target_gdbarch, gdbarch_convert_from_func_ptr_addr (target_gdbarch,
- sym_addr,
- ¤t_target));
+ sym_addr,
+ ¤t_target));
/* On at least some versions of Solaris there's a dynamic relocation
on _r_debug.r_brk and SYM_ADDR may not be relocated yet, e.g., if
{
load_addr_found = 1;
loader_found_in_list = 1;
- load_addr = LM_ADDR_CHECK (so, tmp_bfd);
+ load_addr = lm_addr_check (so, tmp_bfd);
break;
}
so = so->next;
/* 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;
}
}
}
- for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
+ if (!current_inferior ()->attach_flag)
{
- msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
- if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
+ for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
{
- 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;
+ 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;
}
-/*
-
- 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
exec_bfd. Otherwise return 0.
We relocate all of the sections by the same amount. This
- behavior is mandated by recent editions of the System V ABI.
+ behavior is mandated by recent editions of the System V ABI.
According to the System V Application Binary Interface,
Edition 4.1, page 5-5:
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
may be different from EXEC_BFD as the file may have been prelinked
to a different address after the executable has been loaded.
Moreover the address of placement in target memory can be
- different from what the program headers in target memory say - this
- is the goal of PIE.
+ different from what the program headers in target memory say -
+ this is the goal of PIE.
Detected DISPLACEMENT covers both the offsets of PIE placement and
possible new prelink performed after start of the program. Here
if (phdrs_size != phdrs2_size
|| bfd_get_arch_size (exec_bfd) != arch_size)
ok = 0;
- else if (arch_size == 32 && phdrs_size >= sizeof (Elf32_External_Phdr)
+ else if (arch_size == 32
+ && phdrs_size >= sizeof (Elf32_External_Phdr)
&& phdrs_size % sizeof (Elf32_External_Phdr) == 0)
{
Elf_Internal_Ehdr *ehdr2 = elf_tdata (exec_bfd)->elf_header;
Elf32_External_Phdr *phdr2p;
gdb_byte *buf_vaddr_p, *buf_paddr_p;
CORE_ADDR vaddr, paddr;
+ asection *plt2_asect;
phdrp = &((Elf32_External_Phdr *) buf)[i];
buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
/* Check also other adjustment combinations - PR 11786. */
- vaddr = extract_unsigned_integer (buf_vaddr_p, 4, byte_order);
+ vaddr = extract_unsigned_integer (buf_vaddr_p, 4,
+ byte_order);
vaddr -= displacement;
store_unsigned_integer (buf_vaddr_p, 4, byte_order, vaddr);
- paddr = extract_unsigned_integer (buf_paddr_p, 4, byte_order);
+ paddr = extract_unsigned_integer (buf_paddr_p, 4,
+ byte_order);
paddr -= displacement;
store_unsigned_integer (buf_paddr_p, 4, byte_order, paddr);
if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
continue;
+ /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
+ plt2_asect = bfd_get_section_by_name (exec_bfd, ".plt");
+ if (plt2_asect)
+ {
+ int content2;
+ gdb_byte *buf_filesz_p = (gdb_byte *) &phdrp->p_filesz;
+ CORE_ADDR filesz;
+
+ content2 = (bfd_get_section_flags (exec_bfd, plt2_asect)
+ & SEC_HAS_CONTENTS) != 0;
+
+ filesz = extract_unsigned_integer (buf_filesz_p, 4,
+ byte_order);
+
+ /* PLT2_ASECT is from on-disk file (exec_bfd) while
+ FILESZ is from the in-memory image. */
+ if (content2)
+ filesz += bfd_get_section_size (plt2_asect);
+ else
+ filesz -= bfd_get_section_size (plt2_asect);
+
+ store_unsigned_integer (buf_filesz_p, 4, byte_order,
+ filesz);
+
+ if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
+ continue;
+ }
+
ok = 0;
break;
}
}
- else if (arch_size == 64 && phdrs_size >= sizeof (Elf64_External_Phdr)
+ else if (arch_size == 64
+ && phdrs_size >= sizeof (Elf64_External_Phdr)
&& phdrs_size % sizeof (Elf64_External_Phdr) == 0)
{
Elf_Internal_Ehdr *ehdr2 = elf_tdata (exec_bfd)->elf_header;
Elf64_External_Phdr *phdr2p;
gdb_byte *buf_vaddr_p, *buf_paddr_p;
CORE_ADDR vaddr, paddr;
+ asection *plt2_asect;
phdrp = &((Elf64_External_Phdr *) buf)[i];
buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
/* Check also other adjustment combinations - PR 11786. */
- vaddr = extract_unsigned_integer (buf_vaddr_p, 8, byte_order);
+ vaddr = extract_unsigned_integer (buf_vaddr_p, 8,
+ byte_order);
vaddr -= displacement;
store_unsigned_integer (buf_vaddr_p, 8, byte_order, vaddr);
- paddr = extract_unsigned_integer (buf_paddr_p, 8, byte_order);
+ paddr = extract_unsigned_integer (buf_paddr_p, 8,
+ byte_order);
paddr -= displacement;
store_unsigned_integer (buf_paddr_p, 8, byte_order, paddr);
if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
continue;
+ /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
+ plt2_asect = bfd_get_section_by_name (exec_bfd, ".plt");
+ if (plt2_asect)
+ {
+ int content2;
+ gdb_byte *buf_filesz_p = (gdb_byte *) &phdrp->p_filesz;
+ CORE_ADDR filesz;
+
+ content2 = (bfd_get_section_flags (exec_bfd, plt2_asect)
+ & SEC_HAS_CONTENTS) != 0;
+
+ filesz = extract_unsigned_integer (buf_filesz_p, 8,
+ byte_order);
+
+ /* PLT2_ASECT is from on-disk file (exec_bfd) while
+ FILESZ is from the in-memory image. */
+ if (content2)
+ filesz += bfd_get_section_size (plt2_asect);
+ else
+ filesz -= bfd_get_section_size (plt2_asect);
+
+ store_unsigned_integer (buf_filesz_p, 8, byte_order,
+ filesz);
+
+ if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
+ continue;
+ }
+
ok = 0;
break;
}
}
/* Relocate the main executable. This function should be called upon
- stopping the inferior process at the entry point to the program.
+ stopping the inferior process at the entry point to the program.
The entry point from BFD is compared to the AT_ENTRY of AUXV and if they are
different, the main executable is relocated by the proper amount. */
the `qOffsets' packet.
- The section offsets were not reset earlier, and the best we can
- hope is that the old offsets are still applicable to the new run.
- */
+ hope is that the old offsets are still applicable to the new run. */
if (! svr4_exec_displacement (&displacement))
return;
}
}
-/*
-
- 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;
Now run the target. It will eventually hit the breakpoint, at
which point all of the libraries will have been mapped in and we
can go groveling around in the dynamic linker structures to find
- out what we need to know about them. */
+ out what we need to know about them. */
inf = current_inferior ();
tp = inferior_thread ();
clear_proceed_status ();
- inf->stop_soon = STOP_QUIETLY;
- tp->stop_signal = TARGET_SIGNAL_0;
+ inf->control.stop_soon = STOP_QUIETLY;
+ tp->suspend.stop_signal = TARGET_SIGNAL_0;
do
{
- target_resume (pid_to_ptid (-1), 0, tp->stop_signal);
- wait_for_inferior (0);
+ target_resume (pid_to_ptid (-1), 0, tp->suspend.stop_signal);
+ wait_for_inferior ();
}
- while (tp->stop_signal != TARGET_SIGNAL_TRAP);
- inf->stop_soon = NO_STOP_QUIETLY;
+ while (tp->suspend.stop_signal != TARGET_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
svr4_relocate_section_addresses (struct so_list *so,
struct target_section *sec)
{
- sec->addr = svr4_truncate_ptr (sec->addr + LM_ADDR_CHECK (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->endaddr = svr4_truncate_ptr (sec->endaddr + lm_addr_check (so,
sec->bfd));
}
\f
/* 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)
{
struct target_so_ops svr4_so_ops;
-/* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a
+/* 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. */
projects / deliverable / binutils-gdb.git / blobdiff