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;
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_ttyp);
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;
+ }
}
sap = build_section_addr_info_from_section_table (so->sections,
so->sections_end);
- sap->text_addr = text_addr;
+
+ sap->other[lowest_index].addr = lowest_addr;
+
so->objfile = symbol_file_add (so->so_name, so->from_tty,
sap, 0, OBJF_SHARED);
free_section_addr_info (sap);
/* 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 we notice that the inferior has unloaded some shared objects,
+ free any symbolic info GDB had read about those shared objects.
- If PATTERN is non-null, read symbols only for shared objects
- whose names match PATTERN.
+ 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;
#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
}
}
}
+}
+
+
+/* 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;
+
+ if (pattern)
+ {
+ char *re_err = re_comp (pattern);
+
+ if (re_err)
+ error ("Invalid regexp: %s", re_err);
+ }
- /* Finally, read the symbols as requested. 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. */
+ 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;
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)
{