/* local data declarations */
+/* Macro to extract an address from a solib structure.
+ When GDB is configured for some 32-bit targets (e.g. Solaris 2.7
+ sparc), BFD is configured to handle 64-bit targets, so CORE_ADDR is
+ 64 bits. We have to extract only the significant bits of addresses
+ to get the right address when accessing the core file BFD. */
+
+#define SOLIB_EXTRACT_ADDRESS(member) \
+ extract_address (&member, sizeof (member))
+
#ifndef SVR4_SHARED_LIBS
-#define LM_ADDR(so) ((so) -> lm.lm_addr)
-#define LM_NEXT(so) ((so) -> lm.lm_next)
-#define LM_NAME(so) ((so) -> lm.lm_name)
+#define LM_ADDR(so) (SOLIB_EXTRACT_ADDRESS ((so) -> lm.lm_addr))
+#define LM_NEXT(so) (SOLIB_EXTRACT_ADDRESS ((so) -> lm.lm_next))
+#define LM_NAME(so) (SOLIB_EXTRACT_ADDRESS ((so) -> lm.lm_name))
/* Test for first link map entry; first entry is a shared library. */
-#define IGNORE_FIRST_LINK_MAP_ENTRY(x) (0)
+#define IGNORE_FIRST_LINK_MAP_ENTRY(so) (0)
static struct link_dynamic dynamic_copy;
static struct link_dynamic_2 ld_2_copy;
static struct ld_debug debug_copy;
#else /* SVR4_SHARED_LIBS */
-#define LM_ADDR(so) ((so) -> lm.l_addr)
-#define LM_NEXT(so) ((so) -> lm.l_next)
-#define LM_NAME(so) ((so) -> lm.l_name)
+#define LM_ADDR(so) (SOLIB_EXTRACT_ADDRESS ((so) -> lm.l_addr))
+#define LM_NEXT(so) (SOLIB_EXTRACT_ADDRESS ((so) -> lm.l_next))
+#define LM_NAME(so) (SOLIB_EXTRACT_ADDRESS ((so) -> lm.l_name))
/* Test for first link map entry; first entry is the exec-file. */
-#define IGNORE_FIRST_LINK_MAP_ENTRY(x) ((x).l_prev == NULL)
+#define IGNORE_FIRST_LINK_MAP_ENTRY(so) \
+ (SOLIB_EXTRACT_ADDRESS ((so) -> lm.l_prev) == 0)
static struct r_debug debug_copy;
char shadow_contents[BREAKPOINT_MAX]; /* Stash old bkpt addr contents */
struct so_list
{
+ /* The following fields of the structure come directly from the
+ dynamic linker's tables in the inferior, and are initialized by
+ current_sos. */
+
struct so_list *next; /* next structure in linked list */
struct link_map lm; /* copy of link map from inferior */
- struct link_map *lmaddr; /* addr in inferior lm was read from */
+ CORE_ADDR lmaddr; /* addr in inferior lm was read from */
+
+ /* Shared object file name, exactly as it appears in the
+ inferior's link map. This may be a relative path, or something
+ which needs to be looked up in LD_LIBRARY_PATH, etc. We use it
+ to tell which entries in the inferior's dynamic linker's link
+ map we've already loaded. */
+ char so_original_name[MAX_PATH_SIZE];
+
+ /* shared object file name, expanded to something GDB can open */
+ char so_name[MAX_PATH_SIZE];
+
+ /* The following fields of the structure are built from
+ information gathered from the shared object file itself, and
+ are initialized when we actually add it to our symbol tables. */
+
+ bfd *abfd;
CORE_ADDR lmend; /* upper addr bound of mapped object */
- char so_name[MAX_PATH_SIZE]; /* shared object lib name (FIXME) */
char symbols_loaded; /* flag: symbols read in yet? */
char from_tty; /* flag: print msgs? */
struct objfile *objfile; /* objfile for loaded lib */
struct section_table *sections;
struct section_table *sections_end;
struct section_table *textsection;
- bfd *abfd;
};
static struct so_list *so_list_head; /* List of known shared objects */
match_main PARAMS ((char *));
static void
-special_symbol_handling PARAMS ((struct so_list *));
+special_symbol_handling PARAMS ((void));
static void
sharedlibrary_command PARAMS ((char *, int));
static int symbol_add_stub PARAMS ((PTR));
-static struct so_list *
- find_solib PARAMS ((struct so_list *));
-
-static struct link_map *
+static CORE_ADDR
first_link_map_member PARAMS ((void));
static CORE_ADDR
#else
+static struct so_list *current_sos (void);
+static void free_so (struct so_list *node);
+
static int
disable_break PARAMS ((void));
allocate_rt_common_objfile PARAMS ((void));
static void
-solib_add_common_symbols PARAMS ((struct rtc_symb *));
+solib_add_common_symbols (CORE_ADDR);
#endif
/* Relocate the section binding addresses as recorded in the shared
object's file by the base address to which the object was actually
mapped. */
- p->addr += (CORE_ADDR) LM_ADDR (so);
- p->endaddr += (CORE_ADDR) LM_ADDR (so);
- so->lmend = (CORE_ADDR) max (p->endaddr, so->lmend);
+ p->addr += LM_ADDR (so);
+ p->endaddr += LM_ADDR (so);
+ so->lmend = max (p->endaddr, so->lmend);
if (STREQ (p->the_bfd_section->name, ".text"))
{
so->textsection = p;
static void
solib_add_common_symbols (rtc_symp)
- struct rtc_symb *rtc_symp;
+ CORE_ADDR rtc_symp;
{
struct rtc_symb inferior_rtc_symb;
struct nlist inferior_rtc_nlist;
while (rtc_symp)
{
- read_memory ((CORE_ADDR) rtc_symp,
+ read_memory (rtc_symp,
(char *) &inferior_rtc_symb,
sizeof (inferior_rtc_symb));
- read_memory ((CORE_ADDR) inferior_rtc_symb.rtc_sp,
+ read_memory (SOLIB_EXTRACT_ADDRESS (inferior_rtc_symb.rtc_sp),
(char *) &inferior_rtc_nlist,
sizeof (inferior_rtc_nlist));
if (inferior_rtc_nlist.n_type == N_COMM)
len = inferior_rtc_nlist.n_value - inferior_rtc_nlist.n_un.n_strx;
name = xmalloc (len);
- read_memory ((CORE_ADDR) inferior_rtc_nlist.n_un.n_name, name, len);
+ read_memory (SOLIB_EXTRACT_ADDRESS (inferior_rtc_nlist.n_un.n_name),
+ name, len);
/* Allocate the runtime common objfile if necessary. */
if (rt_common_objfile == NULL)
mst_bss, rt_common_objfile);
free (name);
}
- rtc_symp = inferior_rtc_symb.rtc_next;
+ rtc_symp = SOLIB_EXTRACT_ADDRESS (inferior_rtc_symb.rtc_next);
}
/* Install any minimal symbols that have been collected as the current
SYNOPSIS
- static struct link_map *first_link_map_member (void)
+ static CORE_ADDR first_link_map_member (void)
DESCRIPTION
- Read in a copy of the first member in the inferior's dynamic
- link map from the inferior's dynamic linker structures, and return
- a pointer to the copy in our address space.
- */
+ Find the first element in the inferior's dynamic link map, and
+ return its address in the inferior. This function doesn't copy the
+ link map entry itself into our address space; current_sos actually
+ does the reading. */
-static struct link_map *
+static CORE_ADDR
first_link_map_member ()
{
- struct link_map *lm = NULL;
+ CORE_ADDR lm = 0;
#ifndef SVR4_SHARED_LIBS
{
/* It is a version that we can deal with, so read in the secondary
structure and find the address of the link map list from it. */
- read_memory ((CORE_ADDR) dynamic_copy.ld_un.ld_2, (char *) &ld_2_copy,
- sizeof (struct link_dynamic_2));
- lm = ld_2_copy.ld_loaded;
+ read_memory (SOLIB_EXTRACT_ADDRESS (dynamic_copy.ld_un.ld_2),
+ (char *) &ld_2_copy, sizeof (struct link_dynamic_2));
+ lm = SOLIB_EXTRACT_ADDRESS (ld_2_copy.ld_loaded);
}
#else /* SVR4_SHARED_LIBS */
/* FIXME: Perhaps we should validate the info somehow, perhaps by
checking r_version for a known version number, or r_state for
RT_CONSISTENT. */
- lm = debug_copy.r_map;
+ lm = SOLIB_EXTRACT_ADDRESS (debug_copy.r_map);
#endif /* !SVR4_SHARED_LIBS */
PTR arg;
{
int from_tty = (int) arg; /* sneak past catch_errors */
- struct link_map *lm, lmcopy;
+ CORE_ADDR lm;
+ struct link_map lmcopy;
char *filename;
int errcode;
return 0; /* failed somehow... */
/* First link map member should be the executable. */
- if ((lm = first_link_map_member ()) == NULL)
+ if ((lm = first_link_map_member ()) == 0)
return 0; /* failed somehow... */
/* Read from target memory to GDB. */
- read_memory ((CORE_ADDR) lm, (void *) &lmcopy, sizeof (lmcopy));
+ read_memory (lm, (void *) &lmcopy, sizeof (lmcopy));
if (lmcopy.l_name == 0)
return 0; /* no filename. */
/* Now fetch the filename from target memory. */
- target_read_string ((CORE_ADDR) lmcopy.l_name, &filename,
+ target_read_string (SOLIB_EXTRACT_ADDRESS (lmcopy.l_name), &filename,
MAX_PATH_SIZE - 1, &errcode);
if (errcode)
{
}
#endif /* SVR4_SHARED_LIBS */
-/*
- LOCAL FUNCTION
+/* LOCAL FUNCTION
- find_solib -- step through list of shared objects
+ free_so --- free a `struct so_list' object
SYNOPSIS
- struct so_list *find_solib (struct so_list *so_list_ptr)
+ void free_so (struct so_list *so)
DESCRIPTION
- This module contains the routine which finds the names of any
- loaded "images" in the current process. The argument in must be
- NULL on the first call, and then the returned value must be passed
- in on subsequent calls. This provides the capability to "step" down
- the list of loaded objects. On the last object, a NULL value is
- returned.
+ Free the storage associated with the `struct so_list' object SO.
+ If we have opened a BFD for SO, close it.
- The arg and return value are "struct link_map" pointers, as defined
- in <link.h>.
- */
+ The caller is responsible for removing SO from whatever list it is
+ a member of. If we have placed SO's sections in some target's
+ section table, the caller is responsible for removing them.
-static struct so_list *
-find_solib (so_list_ptr)
- struct so_list *so_list_ptr; /* Last lm or NULL for first one */
+ This function doesn't mess with objfiles at all. If there is an
+ objfile associated with SO that needs to be removed, the caller is
+ responsible for taking care of that. */
+
+static void
+free_so (struct so_list *so)
{
- struct so_list *so_list_next = NULL;
- struct link_map *lm = NULL;
- struct so_list *new;
+ char *bfd_filename = 0;
- if (so_list_ptr == NULL)
+ if (so->sections)
+ free (so->sections);
+
+ if (so->abfd)
{
- /* We are setting up for a new scan through the loaded images. */
- if ((so_list_next = so_list_head) == NULL)
- {
- /* We have not already read in the dynamic linking structures
- from the inferior, lookup the address of the base structure. */
- debug_base = locate_base ();
- if (debug_base != 0)
- {
- /* Read the base structure in and find the address of the first
- link map list member. */
- lm = first_link_map_member ();
- }
- }
+ bfd_filename = bfd_get_filename (so->abfd);
+ if (! bfd_close (so->abfd))
+ warning ("cannot close \"%s\": %s",
+ bfd_filename, bfd_errmsg (bfd_get_error ()));
}
- else
+
+ if (bfd_filename)
+ free (bfd_filename);
+
+ free (so);
+}
+
+
+/* On some systems, the only way to recognize the link map entry for
+ the main executable file is by looking at its name. Return
+ non-zero iff SONAME matches one of the known main executable names. */
+
+static int
+match_main (soname)
+ char *soname;
+{
+ char **mainp;
+
+ for (mainp = main_name_list; *mainp != NULL; mainp++)
{
- /* We have been called before, and are in the process of walking
- the shared library list. Advance to the next shared object. */
- if ((lm = LM_NEXT (so_list_ptr)) == NULL)
- {
- /* We have hit the end of the list, so check to see if any were
- added, but be quiet if we can't read from the target any more. */
- int status = target_read_memory ((CORE_ADDR) so_list_ptr->lmaddr,
- (char *) &(so_list_ptr->lm),
- sizeof (struct link_map));
- if (status == 0)
- {
- lm = LM_NEXT (so_list_ptr);
- }
- else
- {
- lm = NULL;
- }
- }
- so_list_next = so_list_ptr->next;
+ if (strcmp (soname, *mainp) == 0)
+ return (1);
}
- if ((so_list_next == NULL) && (lm != NULL))
+
+ return (0);
+}
+
+
+/* LOCAL FUNCTION
+
+ current_sos -- build a list of currently loaded shared objects
+
+ SYNOPSIS
+
+ struct so_list *current_sos ()
+
+ DESCRIPTION
+
+ 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.
+
+ 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. */
+
+static struct so_list *
+current_sos ()
+{
+ CORE_ADDR lm;
+ struct so_list *head = 0;
+ struct so_list **link_ptr = &head;
+
+ /* Make sure we've looked up the inferior's dynamic linker's base
+ structure. */
+ if (! debug_base)
+ {
+ debug_base = locate_base ();
+
+ /* If we can't find the dynamic linker's base structure, this
+ must not be a dynamically linked executable. Hmm. */
+ if (! debug_base)
+ return 0;
+ }
+
+ /* Walk the inferior's link map list, and build our list of
+ `struct so_list' nodes. */
+ lm = first_link_map_member ();
+ while (lm)
{
- /* Get next link map structure from inferior image and build a local
- abbreviated load_map structure */
- new = (struct so_list *) xmalloc (sizeof (struct so_list));
- memset ((char *) new, 0, sizeof (struct so_list));
+ struct so_list *new
+ = (struct so_list *) xmalloc (sizeof (struct so_list));
+ memset (new, 0, sizeof (*new));
+
new->lmaddr = lm;
- /* Add the new node as the next node in the list, or as the root
- node if this is the first one. */
- if (so_list_ptr != NULL)
- {
- so_list_ptr->next = new;
- }
- else
- {
- so_list_head = new;
+ read_memory (lm, (char *) &(new->lm), sizeof (struct link_map));
- if (!solib_cleanup_queued)
- {
- make_run_cleanup (do_clear_solib, NULL);
- solib_cleanup_queued = 1;
- }
+ lm = LM_NEXT (new);
- }
- so_list_next = new;
- read_memory ((CORE_ADDR) lm, (char *) &(new->lm),
- sizeof (struct link_map));
/* 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. */
- if (!IGNORE_FIRST_LINK_MAP_ENTRY (new->lm))
+ if (IGNORE_FIRST_LINK_MAP_ENTRY (new))
+ {
+ free_so (new);
+ }
+ else
{
int errcode;
char *buffer;
- target_read_string ((CORE_ADDR) LM_NAME (new), &buffer,
+
+ /* Extract this shared object's name. */
+ target_read_string (LM_NAME (new), &buffer,
MAX_PATH_SIZE - 1, &errcode);
if (errcode != 0)
{
- warning ("find_solib: Can't read pathname for load map: %s\n",
+ warning ("current_sos: Can't read pathname for load map: %s\n",
safe_strerror (errcode));
- return (so_list_next);
}
- strncpy (new->so_name, buffer, MAX_PATH_SIZE - 1);
- new->so_name[MAX_PATH_SIZE - 1] = '\0';
- free (buffer);
- catch_errors (solib_map_sections, new,
- "Error while mapping shared library sections:\n",
- RETURN_MASK_ALL);
+ else
+ {
+ strncpy (new->so_name, buffer, MAX_PATH_SIZE - 1);
+ new->so_name[MAX_PATH_SIZE - 1] = '\0';
+ free (buffer);
+ strcpy (new->so_original_name, new->so_name);
+ }
+
+ /* 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;
+ }
}
}
- return (so_list_next);
+
+ return head;
}
+
/* A small stub to get us past the arg-passing pinhole of catch_errors. */
static int
symbol_add_stub (arg)
PTR arg;
{
- register struct so_list *so = (struct so_list *) arg; /* catch_errs bogon */
+ register struct so_list *so = (struct so_list *) arg; /* catch_errs bogon */
CORE_ADDR text_addr = 0;
- struct section_addr_info section_addrs;
- memset (§ion_addrs, 0, sizeof (section_addrs));
+ /* Have we already loaded this shared object? */
+ ALL_OBJFILES (so->objfile)
+ {
+ if (strcmp (so->objfile->name, so->so_name) == 0)
+ return 1;
+ }
+
+ /* Find the shared object's text segment. */
if (so->textsection)
text_addr = so->textsection->addr;
else if (so->abfd != NULL)
/* 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. */
-
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)
- + (CORE_ADDR) LM_ADDR (so);
+ + LM_ADDR (so);
}
- ALL_OBJFILES (so->objfile)
{
- if (strcmp (so->objfile->name, so->so_name) == 0)
- return 1;
- }
- section_addrs.text_addr = text_addr;
- so->objfile =
- symbol_file_add (so->so_name, so->from_tty,
- §ion_addrs,
- 0, 0, 0, 1);
- return (1);
-}
+ struct section_addr_info section_addrs;
-/* This function will check the so name to see if matches the main list.
- In some system the main object is in the list, which we want to exclude */
+ memset (§ion_addrs, 0, sizeof (section_addrs));
+ section_addrs.text_addr = text_addr;
-static int
-match_main (soname)
- char *soname;
-{
- char **mainp;
-
- for (mainp = main_name_list; *mainp != NULL; mainp++)
- {
- if (strcmp (soname, *mainp) == 0)
- return (1);
- }
+ so->objfile = symbol_file_add (so->so_name, so->from_tty,
+ §ion_addrs, 0, OBJF_SHARED);
+ }
- return (0);
+ return (1);
}
-/*
- GLOBAL FUNCTION
+/* LOCAL FUNCTION
- solib_add -- add a shared library file to the symtab and section list
+ solib_add -- synchronize GDB's shared object list with the inferior's
SYNOPSIS
- void solib_add (char *arg_string, int from_tty,
- struct target_ops *target)
+ void solib_add (char *pattern, int from_tty, struct target_ops *TARGET)
DESCRIPTION
- */
+ 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.
-void
-solib_add (arg_string, from_tty, target)
- char *arg_string;
- int from_tty;
- struct target_ops *target;
-{
- register struct so_list *so = NULL; /* link map state variable */
+ If PATTERN is non-null, read symbols only for shared objects
+ whose names match PATTERN.
+
+ If FROM_TTY is non-null, feel free to print messages about what
+ we're doing.
- /* Last shared library that we read. */
- struct so_list *so_last = NULL;
+ If TARGET is non-null, add the sections of all new shared objects
+ to TARGET's section table. Note that this doesn't remove any
+ sections for shared objects that have been unloaded, and it
+ doesn't check to see if the new shared objects are already present in
+ the section table. But we only use this for core files and
+ processes we've just attached to, so that's okay. */
- char *re_err;
- int count;
- int old;
+void
+solib_add (char *pattern, 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
#endif SVR4_SHARED_LIBS
- if ((re_err = re_comp (arg_string? arg_string : ".")) != NULL)
+ if (pattern)
{
- error ("Invalid regexp: %s", re_err);
+ 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. */
+ if (!solib_cleanup_queued)
+ {
+ make_run_cleanup (do_clear_solib, NULL);
+ solib_cleanup_queued = 1;
}
- /* Add the shared library sections to the section table of the
- specified target, if any. */
- if (target)
+ /* GDB and the inferior's dynamic linker each maintain their own
+ list of currently loaded shared objects; we want to bring the
+ former in sync with the latter. Scan both lists, seeing which
+ 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.
+
+ - 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.
+
+ - 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.
+
+ 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
+ we remove it from the inferior's list. If it doesn't, the
+ inferior has unloaded it, and we remove it from GDB's list. By
+ the time we're done walking GDB's list, the inferior's list
+ contains only the new shared objects, which we then add. */
+
+ gdb = so_list_head;
+ gdb_link = &so_list_head;
+ while (gdb)
{
- /* Count how many new section_table entries there are. */
- so = NULL;
- count = 0;
- while ((so = find_solib (so)) != NULL)
+ struct so_list *i = inferior;
+ struct so_list **i_link = &inferior;
+
+ /* Check to see whether the shared object *gdb also appears in
+ the inferior's current list. */
+ while (i)
{
- if (so->so_name[0] && !match_main (so->so_name))
- {
- count += so->sections_end - so->sections;
- }
+ if (! strcmp (gdb->so_original_name, i->so_original_name))
+ break;
+
+ i_link = &i->next;
+ i = *i_link;
}
- if (count)
+ /* If the shared object appears on the inferior's list too, then
+ it's still loaded, so we don't need to do anything. Delete
+ it from the inferior's list, and leave it on GDB's list. */
+ if (i)
{
-
- /* Add these section table entries to the target's table. */
- old = target_resize_to_sections (target, count);
- while ((so = find_solib (so)) != NULL)
- {
- if (so->so_name[0])
- {
- count = so->sections_end - so->sections;
- memcpy ((char *) (target->to_sections + old),
- so->sections,
- (sizeof (struct section_table)) * count);
- old += count;
- }
- }
+ *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;
+ }
+
+ /* If it's not on the inferior's list, remove it from GDB's tables. */
+ 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))
+ free_objfile (gdb->objfile);
+
+ /* Some targets' section tables might be referring to
+ sections from so->abfd; remove them. */
+ remove_target_sections (gdb->abfd);
+
+ free_so (gdb);
+ gdb = *gdb_link;
}
}
- /* Now add the symbol files. */
- while ((so = find_solib (so)) != NULL)
+ /* 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. */
+ if (inferior)
{
- if (so->so_name[0] && re_exec (so->so_name) &&
- !match_main (so->so_name))
+ 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. */
+ for (i = inferior; i; i = i->next)
{
- so->from_tty = from_tty;
- if (so->symbols_loaded)
+ i->from_tty = from_tty;
+
+ /* Fill in the rest of the `struct so_list' node. */
+ catch_errors (solib_map_sections, i,
+ "Error while mapping shared library sections:\n",
+ RETURN_MASK_ALL);
+
+ if (! pattern || re_exec (i->so_name))
{
- if (from_tty)
+ if (i->symbols_loaded)
{
- printf_unfiltered ("Symbols already loaded for %s\n", so->so_name);
+ 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;
+ }
}
}
- else if (catch_errors
- (symbol_add_stub, so,
- "Error while reading shared library symbols:\n",
- RETURN_MASK_ALL))
+ }
+
+ /* If requested, add the shared objects' sections to the the
+ TARGET's section table. */
+ if (target)
+ {
+ int new_sections;
+
+ /* Figure out how many sections we'll need to add in total. */
+ new_sections = 0;
+ for (i = inferior; i; i = i->next)
+ new_sections += (i->sections_end - i->sections);
+
+ if (new_sections > 0)
{
- so_last = so;
- so->symbols_loaded = 1;
+ int space = target_resize_to_sections (target, new_sections);
+
+ for (i = inferior; i; i = i->next)
+ {
+ int count = (i->sections_end - i->sections);
+ memcpy (target->to_sections + space,
+ i->sections,
+ count * sizeof (i->sections[0]));
+ space += count;
+ }
}
}
- }
- /* Getting new symbols may change our opinion about what is
- frameless. */
- if (so_last)
- reinit_frame_cache ();
+ /* Getting new symbols may change our opinion about what is
+ frameless. */
+ reinit_frame_cache ();
- if (so_last)
- special_symbol_handling (so_last);
+ special_symbol_handling ();
+ }
+
+#ifdef JIMB_DEBUG
+ putchar ('\n');
+#endif
}
+
/*
LOCAL FUNCTION
if (exec_bfd == NULL)
{
- printf_unfiltered ("No exec file.\n");
+ printf_unfiltered ("No executable file.\n");
return;
}
addr_fmt = "016l";
#endif
- while ((so = find_solib (so)) != NULL)
+ solib_add (0, 0, 0);
+
+ for (so = so_list_head; so; so = so->next)
{
if (so->so_name[0])
{
{
register struct so_list *so = 0; /* link map state variable */
- while ((so = find_solib (so)) != NULL)
+ for (so = so_list_head; so; so = so->next)
{
- if (so->so_name[0])
- {
- if ((address >= (CORE_ADDR) LM_ADDR (so)) &&
- (address < (CORE_ADDR) so->lmend))
- return (so->so_name);
- }
+ if (LM_ADDR (so) <= address && address < so->lmend)
+ return (so->so_name);
}
+
return (0);
}
void
clear_solib ()
{
- struct so_list *next;
- char *bfd_filename;
-
/* This function is expected to handle ELF shared libraries. It is
also used on Solaris, which can run either ELF or a.out binaries
(for compatibility with SunOS 4), both of which can use shared
while (so_list_head)
{
- if (so_list_head->sections)
- {
- free ((PTR) so_list_head->sections);
- }
- if (so_list_head->abfd)
- {
- bfd_filename = bfd_get_filename (so_list_head->abfd);
- if (!bfd_close (so_list_head->abfd))
- warning ("cannot close \"%s\": %s",
- bfd_filename, bfd_errmsg (bfd_get_error ()));
- }
- else
- /* This happens for the executable on SVR4. */
- bfd_filename = NULL;
-
- next = so_list_head->next;
- if (bfd_filename)
- free ((PTR) bfd_filename);
- free ((PTR) so_list_head);
- so_list_head = next;
+ struct so_list *so = so_list_head;
+ so_list_head = so->next;
+ free_so (so);
}
+
debug_base = 0;
}
write_memory (flag_addr, (char *) &in_debugger, sizeof (in_debugger));
- breakpoint_addr = (CORE_ADDR) debug_copy.ldd_bp_addr;
+ breakpoint_addr = SOLIB_EXTRACT_ADDRESS (debug_copy.ldd_bp_addr);
write_memory (breakpoint_addr, (char *) &debug_copy.ldd_bp_inst,
sizeof (debug_copy.ldd_bp_inst));
/* Calc address of debugger interface structure */
- debug_addr = (CORE_ADDR) dynamic_copy.ldd;
+ debug_addr = SOLIB_EXTRACT_ADDRESS (dynamic_copy.ldd);
/* Calc address of `in_debugger' member of debugger interface structure */
{
/* If we are using the BKPT_AT_SYMBOL code, then we don't need the base
yet. In fact, in the case of a SunOS4 executable being run on
- Solaris, we can't get it yet. find_solib will get it when it needs
+ Solaris, we can't get it yet. current_sos will get it when it needs
it. */
#if !(defined (SVR4_SHARED_LIBS) && defined (BKPT_AT_SYMBOL))
if ((debug_base = locate_base ()) == 0)
SYNOPSIS
- void special_symbol_handling (struct so_list *so)
+ void special_symbol_handling ()
DESCRIPTION
*/
static void
-special_symbol_handling (so)
- struct so_list *so;
+special_symbol_handling ()
{
#ifndef SVR4_SHARED_LIBS
int j;
/* FIXME, this needs work for cross-debugging of core files
(byteorder, size, alignment, etc). */
- debug_addr = (CORE_ADDR) dynamic_copy.ldd;
+ debug_addr = SOLIB_EXTRACT_ADDRESS (dynamic_copy.ldd);
}
/* Read the debugger structure from the inferior, just to make sure
if (debug_copy.ldd_cp)
{
- solib_add_common_symbols (debug_copy.ldd_cp);
+ solib_add_common_symbols (SOLIB_EXTRACT_ADDRESS (debug_copy.ldd_cp));
}
#endif /* !SVR4_SHARED_LIBS */
projects / deliverable / binutils-gdb.git / blobdiff