This is the mail archive of the
gdb@sourceware.cygnus.com
mailing list for the GDB project.
unloading shared objects
- To: gdb at sourceware dot cygnus dot com
- Subject: unloading shared objects
- From: Jim Blandy <jimb at zwingli dot cygnus dot com>
- Date: Fri, 10 Mar 2000 16:15:55 -0500 (EST)
I think I've got some code mostly working for this, but free_objfile
is tangled up with CLEAR_SOLIB in a way that is causing problems.
It'll take a little more work, but I think I'll have something ready
soon.
Unfortunately, it's not done right now, and I'll be gone for the
entire weekend, so the earliest I could possibly have anything working
would be Monday. I don't know how that interacts with our hopes for
GDB 5.0.
In case some enterprising soul wants to take it the rest of the way
while I'm gone, I've enclosed my patches below. I think the basic
logic is okay; known issues are:
- free_objfile calls CLEAR_SOLIB, which isn't what we want, I think.
- Selecting a core file and attaching to a process both add the shared
libraries' sections to the target_ops structure. When we unload a
shared library, we close the BFD those sections refer to. We
need to remove those sections from the target_ops structure.
And finally:
- Should solib.c be maintaining its own list of shared objects at all,
or should it always retrieve the full link map from the inferior,
and use the objfile list itself as our record of what we know about?
In other words, what does so_list_head offer that object_files doesn't
do better?
Anyway, I'll finish these when I get back, if nobody else does. I'd
love comments on the changes.
Index: solib.c
===================================================================
RCS file: /cvs/src/src/gdb/solib.c,v
retrieving revision 1.2
diff -c -r1.2 solib.c
*** solib.c 2000/03/06 18:04:56 1.2
--- solib.c 2000/03/10 21:09:51
***************
*** 136,153 ****
struct so_list
{
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 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 */
--- 136,171 ----
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 */
+
+ /* 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 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;
};
static struct so_list *so_list_head; /* List of known shared objects */
***************
*** 168,174 ****
match_main PARAMS ((char *));
static void
! special_symbol_handling PARAMS ((struct so_list *));
static void
sharedlibrary_command PARAMS ((char *, int));
--- 186,192 ----
match_main PARAMS ((char *));
static void
! special_symbol_handling PARAMS ((void));
static void
sharedlibrary_command PARAMS ((char *, int));
***************
*** 181,189 ****
static int symbol_add_stub PARAMS ((PTR));
- static struct so_list *
- find_solib PARAMS ((struct so_list *));
-
static struct link_map *
first_link_map_member PARAMS ((void));
--- 199,204 ----
***************
*** 199,204 ****
--- 214,223 ----
#else
+ static struct so_list *current_sos (void);
+ static void free_so (struct so_list *node);
+ static void sync_solibs (struct target_ops *target);
+
static int
disable_break PARAMS ((void));
***************
*** 854,860 ****
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; find_solib actually
does the reading. */
static struct link_map *
--- 873,879 ----
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 *
***************
*** 951,1091 ****
}
#endif /* SVR4_SHARED_LIBS */
- /*
! LOCAL FUNCTION
! find_solib -- step through list of shared objects
SYNOPSIS
! struct so_list *find_solib (struct so_list *so_list_ptr)
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.
! The arg and return value are "struct link_map" pointers, as defined
! in <link.h>.
! */
!
! static struct so_list *
! find_solib (so_list_ptr)
! struct so_list *so_list_ptr; /* Last lm or NULL for first one */
{
! struct so_list *so_list_next = NULL;
! struct link_map *lm = NULL;
! struct so_list *new;
! if (so_list_ptr == NULL)
{
! /* 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 ();
! }
! }
}
! else
{
! /* 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 ((so_list_next == NULL) && (lm != NULL))
{
! /* 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));
! 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;
! if (!solib_cleanup_queued)
! {
! make_run_cleanup (do_clear_solib, NULL);
! solib_cleanup_queued = 1;
! }
! }
! 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))
{
int errcode;
char *buffer;
target_read_string ((CORE_ADDR) LM_NAME (new), &buffer,
MAX_PATH_SIZE - 1, &errcode);
if (errcode != 0)
{
! warning ("find_solib: 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);
}
}
! return (so_list_next);
}
/* 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 */
CORE_ADDR text_addr = 0;
- struct section_addr_info section_addrs;
! memset (§ion_addrs, 0, sizeof (section_addrs));
if (so->textsection)
text_addr = so->textsection->addr;
else if (so->abfd != NULL)
--- 970,1160 ----
}
#endif /* SVR4_SHARED_LIBS */
! /* LOCAL FUNCTION
! free_so --- free a `struct so_list' object
SYNOPSIS
! void free_so (struct so_list *so)
DESCRIPTION
! Free the storage associated with the `struct so_list' object *SO,
! and remove it from GDB's symbol tables, if it was there. Don't
! worry about unlinking it from the shared object list; the caller
! must handle that.
!
! This can be applied to both shared objects in GDB's list, or
! objects just obtained from current_sos, which don't have BFD's or
! objfiles created for them. */
! static void
! free_so (struct so_list *so)
{
! char *bfd_filename = 0;
!
! if (so->objfile)
! free_objfile (so->objfile);
! if (so->sections)
! free (so->sections);
!
! if (so->abfd)
{
! bfd_filename = bfd_get_filename (so->abfd);
! if (! bfd_close (so->abfd))
! warning ("cannot close \"%s\": %s",
! bfd_filename, bfd_errmsg (bfd_get_error ()));
}
!
! 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++)
{
! if (strcmp (soname, *mainp) == 0)
! return (1);
}
!
! 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 ()
! {
! struct link_map *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)
! {
! struct so_list *new
! = (struct so_list *) xmalloc (sizeof (struct so_list));
! memset (new, 0, sizeof (*new));
!
! new->lmaddr = lm;
read_memory ((CORE_ADDR) lm, (char *) &(new->lm),
sizeof (struct link_map));
+
+ lm = LM_NEXT (new);
+
/* 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))
{
+ free_so (new);
+ }
+ else
+ {
int errcode;
char *buffer;
+
+ /* Extract this shared object's name. */
target_read_string ((CORE_ADDR) LM_NAME (new), &buffer,
MAX_PATH_SIZE - 1, &errcode);
if (errcode != 0)
{
! warning ("current_sos: Can't read pathname for load map: %s\n",
safe_strerror (errcode));
}
! 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 head;
}
+
/* A small stub to get us past the arg-passing pinhole of catch_errors. */
static int
symbol_add_stub (arg)
PTR arg;
{
! /* catch_errs bogon */
! register struct so_list *so = (struct so_list *) arg;
CORE_ADDR text_addr = 0;
! /* 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)
***************
*** 1094,1100 ****
/* 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,
--- 1163,1168 ----
***************
*** 1104,1168 ****
+ (CORE_ADDR) 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, OBJF_SHARED);
! return (1);
! }
! /* 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 */
!
! static int
! match_main (soname)
! char *soname;
! {
! char **mainp;
! for (mainp = main_name_list; *mainp != NULL; mainp++)
! {
! if (strcmp (soname, *mainp) == 0)
! return (1);
! }
! return (0);
}
- /*
! GLOBAL FUNCTION
! solib_add -- add a shared library file to the symtab and section list
SYNOPSIS
! void solib_add (char *arg_string, int from_tty,
! struct target_ops *target)
DESCRIPTION
! */
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 */
!
! /* Last shared library that we read. */
! struct so_list *so_last = NULL;
! char *re_err;
! int count;
! int old;
#ifdef SVR4_SHARED_LIBS
/* If we are attaching to a running process for which we
--- 1172,1235 ----
+ (CORE_ADDR) LM_ADDR (so);
}
{
! struct section_addr_info section_addrs;
! memset (§ion_addrs, 0, sizeof (section_addrs));
! section_addrs.text_addr = text_addr;
! so->objfile = symbol_file_add (so->so_name, so->from_tty,
! §ion_addrs, 0, OBJF_SHARED);
! }
! return (1);
}
! /* LOCAL FUNCTION
! solib_add -- synchronize GDB's shared object list with the inferior's
SYNOPSIS
! 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.
!
! 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.
!
! 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. */
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
***************
*** 1176,1254 ****
#endif SVR4_SHARED_LIBS
! if ((re_err = re_comp (arg_string? arg_string : ".")) != NULL)
{
! error ("Invalid regexp: %s", re_err);
}
! /* Add the shared library sections to the section table of the
! specified target, if any. */
! if (target)
{
! /* Count how many new section_table entries there are. */
! so = NULL;
! count = 0;
! while ((so = find_solib (so)) != NULL)
{
! if (so->so_name[0] && !match_main (so->so_name))
! {
! count += so->sections_end - so->sections;
! }
}
! if (count)
{
!
! /* 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;
! }
! }
}
}
! /* Now add the symbol files. */
! while ((so = find_solib (so)) != NULL)
{
! if (so->so_name[0] && re_exec (so->so_name) &&
! !match_main (so->so_name))
{
! so->from_tty = from_tty;
! if (so->symbols_loaded)
{
! if (from_tty)
{
! printf_unfiltered ("Symbols already loaded for %s\n", so->so_name);
}
}
! else if (catch_errors
! (symbol_add_stub, so,
! "Error while reading shared library symbols:\n",
! RETURN_MASK_ALL))
{
! so_last = so;
! so->symbols_loaded = 1;
}
}
- }
! /* Getting new symbols may change our opinion about what is
! frameless. */
! if (so_last)
! reinit_frame_cache ();
! if (so_last)
! special_symbol_handling (so_last);
}
/*
LOCAL FUNCTION
--- 1243,1417 ----
#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. */
! if (!solib_cleanup_queued)
{
! make_run_cleanup (do_clear_solib, NULL);
! solib_cleanup_queued = 1;
! }
!
! /* 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)
! {
! 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 (! strcmp (gdb->so_original_name, i->so_original_name))
! break;
!
! i_link = &i->next;
! i = *i_link;
! }
!
! /* 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)
! {
! *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 ("unloaded: %s\n", gdb->so_name);
! #endif
! free_so (gdb);
! gdb = *gdb_link;
}
}
! /* 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)
{
! 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)
{
! 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 (i->symbols_loaded)
! {
! if (from_tty)
! printf_unfiltered ("Symbols already loaded for %s\n",
! i->so_name);
! }
! else
{
! #ifdef JIMB_DEBUG
! printf ("loaded: %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
! 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)
{
! 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. */
! reinit_frame_cache ();
! special_symbol_handling ();
! }
}
+
/*
LOCAL FUNCTION
***************
*** 1289,1295 ****
addr_fmt = "016l";
#endif
! while ((so = find_solib (so)) != NULL)
{
if (so->so_name[0])
{
--- 1452,1460 ----
addr_fmt = "016l";
#endif
! solib_add (0, 0, 0);
!
! for (so = so_list_head; so; so = so->next)
{
if (so->so_name[0])
{
***************
*** 1347,1361 ****
{
register struct so_list *so = 0; /* link map state variable */
! while ((so = find_solib (so)) != NULL)
{
! if (so->so_name[0])
! {
! if ((address >= (CORE_ADDR) LM_ADDR (so)) &&
! (address < (CORE_ADDR) so->lmend))
! return (so->so_name);
! }
}
return (0);
}
--- 1512,1524 ----
{
register struct so_list *so = 0; /* link map state variable */
! for (so = so_list_head; so; so = so->next)
{
! if ((address >= (CORE_ADDR) LM_ADDR (so)) &&
! (address < (CORE_ADDR) so->lmend))
! return (so->so_name);
}
+
return (0);
}
***************
*** 1775,1781 ****
{
/* 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
it. */
#if !(defined (SVR4_SHARED_LIBS) && defined (BKPT_AT_SYMBOL))
if ((debug_base = locate_base ()) == 0)
--- 1938,1944 ----
{
/* 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. current_sos will get it when it needs
it. */
#if !(defined (SVR4_SHARED_LIBS) && defined (BKPT_AT_SYMBOL))
if ((debug_base = locate_base ()) == 0)
***************
*** 1843,1849 ****
SYNOPSIS
! void special_symbol_handling (struct so_list *so)
DESCRIPTION
--- 2006,2012 ----
SYNOPSIS
! void special_symbol_handling ()
DESCRIPTION
***************
*** 1859,1866 ****
*/
static void
! special_symbol_handling (so)
! struct so_list *so;
{
#ifndef SVR4_SHARED_LIBS
int j;
--- 2022,2028 ----
*/
static void
! special_symbol_handling ()
{
#ifndef SVR4_SHARED_LIBS
int j;