#include "command.h"
#include "target.h"
#include "frame.h"
-#include "gnu-regex.h"
+#include "gdb_regex.h"
#include "inferior.h"
#include "environ.h"
#include "language.h"
static int solib_cleanup_queued = 0; /* make_run_cleanup called */
-extern int
-fdmatch PARAMS ((int, int)); /* In libiberty */
+extern int fdmatch (int, int); /* In libiberty */
/* Local function prototypes */
-static void
-do_clear_solib PARAMS ((PTR));
+static void do_clear_solib (PTR);
-static int
-match_main PARAMS ((char *));
+static int match_main (char *);
-static void
-special_symbol_handling PARAMS ((void));
+static void special_symbol_handling (void);
-static void
-sharedlibrary_command PARAMS ((char *, int));
+static void sharedlibrary_command (char *, int);
-static int
-enable_break PARAMS ((void));
+static int enable_break (void);
-static void
-info_sharedlibrary_command PARAMS ((char *, int));
+static void info_sharedlibrary_command (char *, int);
-static int symbol_add_stub PARAMS ((PTR));
+static int symbol_add_stub (PTR);
-static CORE_ADDR
- first_link_map_member PARAMS ((void));
+static CORE_ADDR first_link_map_member (void);
-static CORE_ADDR
- locate_base PARAMS ((void));
+static CORE_ADDR locate_base (void);
-static int solib_map_sections PARAMS ((PTR));
+static int solib_map_sections (PTR);
#ifdef SVR4_SHARED_LIBS
-static CORE_ADDR
- elf_locate_base PARAMS ((void));
+static CORE_ADDR elf_locate_base (void);
#else
static struct so_list *current_sos (void);
static void free_so (struct so_list *node);
-static int
-disable_break PARAMS ((void));
+static int disable_break (void);
-static void
-allocate_rt_common_objfile PARAMS ((void));
+static void allocate_rt_common_objfile (void);
static void
solib_add_common_symbols (CORE_ADDR);
#endif
-void _initialize_solib PARAMS ((void));
+void _initialize_solib (void);
/* If non-zero, this is a prefix that will be added to the front of the name
shared libraries with an absolute filename for loading. */
}
init_minimal_symbol_collection ();
- make_cleanup ((make_cleanup_func) discard_minimal_symbols, 0);
+ make_cleanup_discard_minimal_symbols ();
while (rtc_symp)
{
#ifdef SVR4_SHARED_LIBS
-static CORE_ADDR
- bfd_lookup_symbol PARAMS ((bfd *, char *));
+static CORE_ADDR bfd_lookup_symbol (bfd *, char *);
/*
NULL
};
-static int
-look_for_base PARAMS ((int, CORE_ADDR));
+static int look_for_base (int, CORE_ADDR);
/*
CORE_ADDR dyninfo_addr;
char *buf;
char *bufend;
+ int arch_size;
/* Find the start address of the .dynamic section. */
dyninfo_sect = bfd_get_section_by_name (exec_bfd, ".dynamic");
/* Find the DT_DEBUG entry in the the .dynamic section.
For mips elf we look for DT_MIPS_RLD_MAP, mips elf apparently has
no DT_DEBUG entries. */
-#ifndef TARGET_ELF64
- for (bufend = buf + dyninfo_sect_size;
- buf < bufend;
- buf += sizeof (Elf32_External_Dyn))
- {
- Elf32_External_Dyn *x_dynp = (Elf32_External_Dyn *) buf;
- long dyn_tag;
- CORE_ADDR dyn_ptr;
-
- dyn_tag = bfd_h_get_32 (exec_bfd, (bfd_byte *) x_dynp->d_tag);
- if (dyn_tag == DT_NULL)
- break;
- else if (dyn_tag == DT_DEBUG)
+
+ arch_size = bfd_elf_get_arch_size (exec_bfd);
+ if (arch_size == -1) /* failure */
+ return 0;
+
+ if (arch_size == 32)
+ { /* 32-bit elf */
+ for (bufend = buf + dyninfo_sect_size;
+ buf < bufend;
+ buf += sizeof (Elf32_External_Dyn))
{
- dyn_ptr = bfd_h_get_32 (exec_bfd, (bfd_byte *) x_dynp->d_un.d_ptr);
- return dyn_ptr;
- }
+ Elf32_External_Dyn *x_dynp = (Elf32_External_Dyn *) buf;
+ long dyn_tag;
+ CORE_ADDR dyn_ptr;
+
+ dyn_tag = bfd_h_get_32 (exec_bfd, (bfd_byte *) x_dynp->d_tag);
+ if (dyn_tag == DT_NULL)
+ break;
+ else if (dyn_tag == DT_DEBUG)
+ {
+ dyn_ptr = bfd_h_get_32 (exec_bfd,
+ (bfd_byte *) x_dynp->d_un.d_ptr);
+ return dyn_ptr;
+ }
#ifdef DT_MIPS_RLD_MAP
- else if (dyn_tag == DT_MIPS_RLD_MAP)
- {
- char pbuf[TARGET_PTR_BIT / HOST_CHAR_BIT];
-
- /* DT_MIPS_RLD_MAP contains a pointer to the address
- of the dynamic link structure. */
- dyn_ptr = bfd_h_get_32 (exec_bfd, (bfd_byte *) x_dynp->d_un.d_ptr);
- if (target_read_memory (dyn_ptr, pbuf, sizeof (pbuf)))
- return 0;
- return extract_unsigned_integer (pbuf, sizeof (pbuf));
- }
+ else if (dyn_tag == DT_MIPS_RLD_MAP)
+ {
+ char pbuf[TARGET_PTR_BIT / HOST_CHAR_BIT];
+
+ /* DT_MIPS_RLD_MAP contains a pointer to the address
+ of the dynamic link structure. */
+ dyn_ptr = bfd_h_get_32 (exec_bfd,
+ (bfd_byte *) x_dynp->d_un.d_ptr);
+ if (target_read_memory (dyn_ptr, pbuf, sizeof (pbuf)))
+ return 0;
+ return extract_unsigned_integer (pbuf, sizeof (pbuf));
+ }
#endif
+ }
}
-#else /* ELF64 */
- for (bufend = buf + dyninfo_sect_size;
- buf < bufend;
- buf += sizeof (Elf64_External_Dyn))
+ else /* 64-bit elf */
{
- Elf64_External_Dyn *x_dynp = (Elf64_External_Dyn *) buf;
- long dyn_tag;
- CORE_ADDR dyn_ptr;
-
- dyn_tag = bfd_h_get_64 (exec_bfd, (bfd_byte *) x_dynp->d_tag);
- if (dyn_tag == DT_NULL)
- break;
- else if (dyn_tag == DT_DEBUG)
+ for (bufend = buf + dyninfo_sect_size;
+ buf < bufend;
+ buf += sizeof (Elf64_External_Dyn))
{
- dyn_ptr = bfd_h_get_64 (exec_bfd, (bfd_byte *) x_dynp->d_un.d_ptr);
- return dyn_ptr;
+ Elf64_External_Dyn *x_dynp = (Elf64_External_Dyn *) buf;
+ long dyn_tag;
+ CORE_ADDR dyn_ptr;
+
+ dyn_tag = bfd_h_get_64 (exec_bfd, (bfd_byte *) x_dynp->d_tag);
+ if (dyn_tag == DT_NULL)
+ break;
+ else if (dyn_tag == DT_DEBUG)
+ {
+ dyn_ptr = bfd_h_get_64 (exec_bfd,
+ (bfd_byte *) x_dynp->d_un.d_ptr);
+ return dyn_ptr;
+ }
}
}
-#endif
/* DT_DEBUG entry not found. */
return 0;
LOCAL FUNCTION
- open_exec_file_object
+ open_symbol_file_object
SYNOPSIS
*/
-int
-open_symbol_file_object (arg)
- PTR arg;
+static int
+open_symbol_file_object (from_ttyp)
+ int *from_ttyp; /* sneak past catch_errors */
{
- int from_tty = (int) arg; /* sneak past catch_errors */
CORE_ADDR lm;
struct link_map lmcopy;
char *filename;
return 0;
}
- make_cleanup ((make_cleanup_func) free, (void *) filename);
+ make_cleanup (free, filename);
/* Have a pathname: read the symbol file. */
- symbol_file_command (filename, from_tty);
+ symbol_file_command (filename, *from_ttyp);
return 1;
}
{
struct so_list *new
= (struct so_list *) xmalloc (sizeof (struct so_list));
+ struct cleanup *old_chain = make_cleanup (free, new);
memset (new, 0, sizeof (*new));
new->lmaddr = lm;
does have a name, so we can no longer use a missing name to
decide when to ignore it. */
if (IGNORE_FIRST_LINK_MAP_ENTRY (new))
- {
- free_so (new);
- }
+ free_so (new);
else
{
int errcode;
link_ptr = &new->next;
}
}
+
+ discard_cleanups (old_chain);
}
return head;
PTR arg;
{
register struct so_list *so = (struct so_list *) arg; /* catch_errs bogon */
- CORE_ADDR text_addr = 0;
+ struct section_addr_info *sap;
+ CORE_ADDR lowest_addr = 0;
+ int lowest_index;
+ asection *lowest_sect = NULL;
/* Have we already loaded this shared object? */
ALL_OBJFILES (so->objfile)
/* Find the shared object's text segment. */
if (so->textsection)
- text_addr = so->textsection->addr;
+ {
+ lowest_addr = so->textsection->addr;
+ lowest_sect = bfd_get_section_by_name (so->abfd, ".text");
+ lowest_index = lowest_sect->index;
+ }
else if (so->abfd != NULL)
{
- asection *lowest_sect;
-
- /* If we didn't find a mapped non zero sized .text section, set up
- text_addr so that the relocation in symbol_file_add does no harm. */
+ /* If we didn't find a mapped non zero sized .text section, set
+ up lowest_addr so that the relocation in symbol_file_add does
+ no harm. */
lowest_sect = bfd_get_section_by_name (so->abfd, ".text");
if (lowest_sect == NULL)
bfd_map_over_sections (so->abfd, find_lowest_section,
(PTR) &lowest_sect);
if (lowest_sect)
- text_addr = bfd_section_vma (so->abfd, lowest_sect)
- + LM_ADDR (so);
+ {
+ lowest_addr = bfd_section_vma (so->abfd, lowest_sect)
+ + LM_ADDR (so);
+ lowest_index = lowest_sect->index;
+ }
}
- {
- struct section_addr_info section_addrs;
+ sap = build_section_addr_info_from_section_table (so->sections,
+ so->sections_end);
- memset (§ion_addrs, 0, sizeof (section_addrs));
- section_addrs.text_addr = text_addr;
+ sap->other[lowest_index].addr = lowest_addr;
- so->objfile = symbol_file_add (so->so_name, so->from_tty,
- §ion_addrs, 0, OBJF_SHARED);
- }
+ so->objfile = symbol_file_add (so->so_name, so->from_tty,
+ sap, 0, OBJF_SHARED);
+ free_section_addr_info (sap);
return (1);
}
/* LOCAL FUNCTION
- solib_add -- synchronize GDB's shared object list with the inferior's
+ update_solib_list --- synchronize GDB's shared object list with inferior's
SYNOPSIS
- void solib_add (char *pattern, int from_tty, struct target_ops *TARGET)
-
- DESCRIPTION
+ void update_solib_list (int from_tty, struct target_ops *TARGET)
Extract the list of currently loaded shared objects from the
- inferior, and compare it with the list of shared objects for which
- GDB has currently loaded symbolic information. If new shared
- objects have been loaded, or old shared objects have disappeared,
- make the appropriate changes to GDB's tables.
+ inferior, and compare it with the list of shared objects currently
+ in GDB's so_list_head list. Edit so_list_head to bring it in sync
+ with the inferior's new list.
- If PATTERN is non-null, read symbols only for shared objects
- whose names match PATTERN.
+ If we notice that the inferior has unloaded some shared objects,
+ free any symbolic info GDB had read about those shared objects.
+
+ Don't load symbolic info for any new shared objects; just add them
+ to the list, and leave their symbols_loaded flag clear.
If FROM_TTY is non-null, feel free to print messages about what
we're doing.
processes we've just attached to, so that's okay. */
void
-solib_add (char *pattern, int from_tty, struct target_ops *target)
+update_solib_list (int from_tty, struct target_ops *target)
{
struct so_list *inferior = current_sos ();
struct so_list *gdb, **gdb_link;
- /* #define JIMB_DEBUG */
-#ifdef JIMB_DEBUG
- printf ("GDB's shared library list:\n");
- for (gdb = so_list_head; gdb; gdb = gdb->next)
- printf (" %s\n", gdb->so_original_name);
- printf ("inferior's shared library list:\n");
- for (gdb = inferior; gdb; gdb = gdb->next)
- printf (" %s\n", gdb->so_original_name);
-#endif
-
#ifdef SVR4_SHARED_LIBS
/* If we are attaching to a running process for which we
have not opened a symbol file, we may be able to get its
symbols now! */
if (attach_flag &&
symfile_objfile == NULL)
- catch_errors (open_symbol_file_object, (PTR) from_tty,
+ catch_errors (open_symbol_file_object, (PTR) &from_tty,
"Error reading attached process's symbol file.\n",
RETURN_MASK_ALL);
#endif SVR4_SHARED_LIBS
- if (pattern)
- {
- char *re_err = re_comp (pattern);
-
- if (re_err)
- error ("Invalid regexp: %s", re_err);
- }
-
/* Since this function might actually add some elements to the
so_list_head list, arrange for it to be cleaned up when
appropriate. */
shared objects appear where. There are three cases:
- A shared object appears on both lists. This means that GDB
- knows about it already, and it's still loaded in the inferior.
- Nothing needs to happen.
+ knows about it already, and it's still loaded in the inferior.
+ Nothing needs to happen.
- A shared object appears only on GDB's list. This means that
- the inferior has unloaded it. We should remove the shared
- object from GDB's tables.
+ the inferior has unloaded it. We should remove the shared
+ object from GDB's tables.
- A shared object appears only on the inferior's list. This
- means that it's just been loaded. We should add it to GDB's
- tables.
+ means that it's just been loaded. We should add it to GDB's
+ tables.
So we walk GDB's list, checking each entry to see if it appears
in the inferior's list too. If it does, no action is needed, and
if (i)
{
*i_link = i->next;
-#ifdef JIMB_DEBUG
- printf ("unchanged: %s\n", i->so_name);
-#endif
free_so (i);
gdb_link = &gdb->next;
gdb = *gdb_link;
else
{
*gdb_link = gdb->next;
-#ifdef JIMB_DEBUG
- printf ("removed: %s\n", gdb->so_name);
-#endif
/* Unless the user loaded it explicitly, free SO's objfile. */
- if (! (gdb->objfile->flags & OBJF_USERLOADED))
+ if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED))
free_objfile (gdb->objfile);
/* Some targets' section tables might be referring to
/* Now the inferior's list contains only shared objects that don't
appear in GDB's list --- those that are newly loaded. Add them
- to GDB's shared object list, and read in their symbols, if
- appropriate. */
+ to GDB's shared object list. */
if (inferior)
{
struct so_list *i;
/* Add the new shared objects to GDB's list. */
*gdb_link = inferior;
- /* Fill in the rest of each of the `struct so_list' nodes, and
- read symbols for those files whose names match PATTERN. */
+ /* Fill in the rest of each of the `struct so_list' nodes. */
for (i = inferior; i; i = i->next)
{
i->from_tty = from_tty;
catch_errors (solib_map_sections, i,
"Error while mapping shared library sections:\n",
RETURN_MASK_ALL);
-
- if (! pattern || re_exec (i->so_name))
- {
- if (i->symbols_loaded)
- {
- if (from_tty)
- printf_unfiltered ("Symbols already loaded for %s\n",
- i->so_name);
- }
- else
- {
-#ifdef JIMB_DEBUG
- printf ("added: %s\n", i->so_name);
-#endif
- if (catch_errors
- (symbol_add_stub, i,
- "Error while reading shared library symbols:\n",
- RETURN_MASK_ALL))
- {
- if (from_tty)
- printf_unfiltered ("Loaded symbols for %s\n",
- i->so_name);
- i->symbols_loaded = 1;
- }
- }
- }
}
/* If requested, add the shared objects' sections to the the
}
}
}
+ }
+}
+
+
+/* GLOBAL FUNCTION
+
+ solib_add -- read in symbol info for newly added shared libraries
+
+ SYNOPSIS
+
+ void solib_add (char *pattern, int from_tty, struct target_ops *TARGET)
+
+ DESCRIPTION
+
+ Read in symbolic information for any shared objects whose names
+ match PATTERN. (If we've already read a shared object's symbol
+ info, leave it alone.) If PATTERN is zero, read them all.
+
+ FROM_TTY and TARGET are as described for update_solib_list, above. */
+
+void
+solib_add (char *pattern, int from_tty, struct target_ops *target)
+{
+ struct so_list *gdb;
- /* Getting new symbols may change our opinion about what is
- frameless. */
- reinit_frame_cache ();
+ if (pattern)
+ {
+ char *re_err = re_comp (pattern);
- special_symbol_handling ();
+ if (re_err)
+ error ("Invalid regexp: %s", re_err);
}
-#ifdef JIMB_DEBUG
- putchar ('\n');
-#endif
+ update_solib_list (from_tty, target);
+
+ /* Walk the list of currently loaded shared libraries, and read
+ symbols for any that match the pattern --- or any whose symbols
+ aren't already loaded, if no pattern was given. */
+ {
+ int any_matches = 0;
+ int loaded_any_symbols = 0;
+
+ for (gdb = so_list_head; gdb; gdb = gdb->next)
+ if (! pattern || re_exec (gdb->so_name))
+ {
+ any_matches = 1;
+
+ if (gdb->symbols_loaded)
+ {
+ if (from_tty)
+ printf_unfiltered ("Symbols already loaded for %s\n",
+ gdb->so_name);
+ }
+ else
+ {
+ if (catch_errors
+ (symbol_add_stub, gdb,
+ "Error while reading shared library symbols:\n",
+ RETURN_MASK_ALL))
+ {
+ if (from_tty)
+ printf_unfiltered ("Loaded symbols for %s\n",
+ gdb->so_name);
+ gdb->symbols_loaded = 1;
+ loaded_any_symbols = 1;
+ }
+ }
+ }
+
+ if (from_tty && pattern && ! any_matches)
+ printf_unfiltered
+ ("No loaded shared libraries match the pattern `%s'.\n", pattern);
+
+ if (loaded_any_symbols)
+ {
+ /* Getting new symbols may change our opinion about what is
+ frameless. */
+ reinit_frame_cache ();
+
+ special_symbol_handling ();
+ }
+ }
}
int header_done = 0;
int addr_width;
char *addr_fmt;
+ int arch_size;
if (exec_bfd == NULL)
{
return;
}
-#ifndef TARGET_ELF64
- addr_width = 8 + 4;
- addr_fmt = "08l";
-#else
- addr_width = 16 + 4;
- addr_fmt = "016l";
-#endif
+ arch_size = bfd_elf_get_arch_size (exec_bfd);
+ /* Default to 32-bit in case of failure (non-elf). */
+ if (arch_size == 32 || arch_size == -1)
+ {
+ addr_width = 8 + 4;
+ addr_fmt = "08l";
+ }
+ else if (arch_size == 64)
+ {
+ addr_width = 16 + 4;
+ addr_fmt = "016l";
+ }
- solib_add (0, 0, 0);
+ update_solib_list (from_tty, 0);
for (so = so_list_head; so; so = so->next)
{