/* Handle shared libraries for GDB, the GNU Debugger.
- Copyright 1990, 91, 92, 93, 94, 95, 96, 98, 1999, 2000, 2001
+
+ Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+ 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009
Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "bfd.h"
#include "symfile.h"
#include "objfiles.h"
+#include "exceptions.h"
#include "gdbcore.h"
#include "command.h"
#include "target.h"
#include "language.h"
#include "gdbcmd.h"
#include "completer.h"
-
+#include "filenames.h" /* for DOSish file names */
+#include "exec.h"
#include "solist.h"
+#include "observer.h"
+#include "readline/readline.h"
+#include "remote.h"
+
+/* Architecture-specific operations. */
+
+/* Per-architecture data key. */
+static struct gdbarch_data *solib_data;
+
+static void *
+solib_init (struct obstack *obstack)
+{
+ struct target_so_ops **ops;
+
+ ops = OBSTACK_ZALLOC (obstack, struct target_so_ops *);
+ *ops = current_target_so_ops;
+ return ops;
+}
+
+static struct target_so_ops *
+solib_ops (struct gdbarch *gdbarch)
+{
+ struct target_so_ops **ops = gdbarch_data (gdbarch, solib_data);
+ return *ops;
+}
+
+/* Set the solib operations for GDBARCH to NEW_OPS. */
+
+void
+set_solib_ops (struct gdbarch *gdbarch, struct target_so_ops *new_ops)
+{
+ struct target_so_ops **ops = gdbarch_data (gdbarch, solib_data);
+ *ops = new_ops;
+}
+\f
/* external data declarations */
-/* FIXME: gdbarch needs to control this variable */
+/* FIXME: gdbarch needs to control this variable, or else every
+ configuration needs to call set_solib_ops. */
struct target_so_ops *current_target_so_ops;
/* local data declarations */
static struct so_list *so_list_head; /* List of known shared objects */
-static int solib_cleanup_queued = 0; /* make_run_cleanup called */
-
/* Local function prototypes */
-static void do_clear_solib (PTR);
-
-/* 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. */
-static char *solib_absolute_prefix = NULL;
-
/* If non-empty, this is a search path for loading non-absolute shared library
symbol files. This takes precedence over the environment variables PATH
and LD_LIBRARY_PATH. */
static char *solib_search_path = NULL;
+static void
+show_solib_search_path (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("\
+The search path for loading non-absolute shared library symbol files is %s.\n"),
+ value);
+}
/*
GLOBAL FUNCTION
- solib_open -- Find a shared library file and open it.
+ solib_find -- Find a shared library file.
SYNOPSIS
- int solib_open (char *in_patname, char **found_pathname);
+ char *solib_find (char *in_pathname, int *fd);
DESCRIPTION
- Global variable SOLIB_ABSOLUTE_PREFIX is used as a prefix directory
+ Global variable GDB_SYSROOT is used as a prefix directory
to search for shared libraries if they have an absolute path.
Global variable SOLIB_SEARCH_PATH is used as a prefix directory
(or set of directories, as in LD_LIBRARY_PATH) to search for all
- shared libraries if not found in SOLIB_ABSOLUTE_PREFIX.
+ shared libraries if not found in GDB_SYSROOT.
- Search order:
- * If path is absolute, look in SOLIB_ABSOLUTE_PREFIX.
- * If path is absolute or relative, look for it literally (unmodified).
+ Search algorithm:
+ * If there is a gdb_sysroot and path is absolute:
+ * Search for gdb_sysroot/path.
+ * else
+ * Look for it literally (unmodified).
* Look in SOLIB_SEARCH_PATH.
- * Look in inferior's $PATH.
- * Look in inferior's $LD_LIBRARY_PATH.
+ * If available, use target defined search function.
+ * If gdb_sysroot is NOT set, perform the following two searches:
+ * Look in inferior's $PATH.
+ * Look in inferior's $LD_LIBRARY_PATH.
+ *
+ * The last check avoids doing this search when targetting remote
+ * machines since gdb_sysroot will almost always be set.
RETURNS
- file handle for opened solib, or -1 for failure. */
+ Full pathname of the shared library file, or NULL if not found.
+ (The pathname is malloc'ed; it needs to be freed by the caller.)
+ *FD is set to either -1 or an open file handle for the library. */
-int
-solib_open (char *in_pathname, char **found_pathname)
+char *
+solib_find (char *in_pathname, int *fd)
{
+ struct target_so_ops *ops = solib_ops (target_gdbarch);
int found_file = -1;
char *temp_pathname = NULL;
+ int gdb_sysroot_is_empty;
- if (strchr (in_pathname, SLASH_CHAR))
+ gdb_sysroot_is_empty = (gdb_sysroot == NULL || *gdb_sysroot == 0);
+
+ if (! IS_ABSOLUTE_PATH (in_pathname) || gdb_sysroot_is_empty)
+ temp_pathname = in_pathname;
+ else
{
- if (! ROOTED_P (in_pathname) || solib_absolute_prefix == NULL)
- temp_pathname = in_pathname;
- else
- {
- int prefix_len = strlen (solib_absolute_prefix);
-
- /* Remove trailing slashes from absolute prefix. */
- while (prefix_len > 0
- && SLASH_P (solib_absolute_prefix[prefix_len - 1]))
- prefix_len--;
-
- /* Cat the prefixed pathname together. */
- temp_pathname = alloca (prefix_len + strlen (in_pathname) + 1);
- strncpy (temp_pathname, solib_absolute_prefix, prefix_len);
- temp_pathname[prefix_len] = '\0';
- strcat (temp_pathname, in_pathname);
- }
+ int prefix_len = strlen (gdb_sysroot);
+
+ /* Remove trailing slashes from absolute prefix. */
+ while (prefix_len > 0
+ && IS_DIR_SEPARATOR (gdb_sysroot[prefix_len - 1]))
+ prefix_len--;
+
+ /* Cat the prefixed pathname together. */
+ temp_pathname = alloca (prefix_len + strlen (in_pathname) + 1);
+ strncpy (temp_pathname, gdb_sysroot, prefix_len);
+ temp_pathname[prefix_len] = '\0';
+ strcat (temp_pathname, in_pathname);
+ }
- /* Now see if we can open it. */
- found_file = open (temp_pathname, O_RDONLY, 0);
+ /* Handle remote files. */
+ if (remote_filename_p (temp_pathname))
+ {
+ *fd = -1;
+ return xstrdup (temp_pathname);
}
- /* If not found, next search the solib_search_path (if any). */
+ /* Now see if we can open it. */
+ found_file = open (temp_pathname, O_RDONLY | O_BINARY, 0);
+
+ /* We try to find the library in various ways. After each attempt
+ (except for the one above), either found_file >= 0 and
+ temp_pathname is a malloc'd string, or found_file < 0 and
+ temp_pathname does not point to storage that needs to be
+ freed. */
+
+ if (found_file < 0)
+ temp_pathname = NULL;
+ else
+ temp_pathname = xstrdup (temp_pathname);
+
+ /* If the search in gdb_sysroot failed, and the path name is
+ absolute at this point, make it relative. (openp will try and open the
+ file according to its absolute path otherwise, which is not what we want.)
+ Affects subsequent searches for this solib. */
+ if (found_file < 0 && IS_ABSOLUTE_PATH (in_pathname))
+ {
+ /* First, get rid of any drive letters etc. */
+ while (!IS_DIR_SEPARATOR (*in_pathname))
+ in_pathname++;
+
+ /* Next, get rid of all leading dir separators. */
+ while (IS_DIR_SEPARATOR (*in_pathname))
+ in_pathname++;
+ }
+
+ /* If not found, search the solib_search_path (if any). */
+ if (found_file < 0 && solib_search_path != NULL)
+ found_file = openp (solib_search_path, OPF_TRY_CWD_FIRST,
+ in_pathname, O_RDONLY | O_BINARY, 0, &temp_pathname);
+
+ /* If not found, next search the solib_search_path (if any) for the basename
+ only (ignoring the path). This is to allow reading solibs from a path
+ that differs from the opened path. */
if (found_file < 0 && solib_search_path != NULL)
- found_file = openp (solib_search_path,
- 1, in_pathname, O_RDONLY, 0, &temp_pathname);
+ found_file = openp (solib_search_path, OPF_TRY_CWD_FIRST,
+ lbasename (in_pathname), O_RDONLY | O_BINARY, 0,
+ &temp_pathname);
+
+ /* If not found, try to use target supplied solib search method */
+ if (found_file < 0 && ops->find_and_open_solib)
+ found_file = ops->find_and_open_solib (in_pathname, O_RDONLY | O_BINARY,
+ &temp_pathname);
/* If not found, next search the inferior's $PATH environment variable. */
- if (found_file < 0 && solib_search_path != NULL)
+ if (found_file < 0 && gdb_sysroot_is_empty)
found_file = openp (get_in_environ (inferior_environ, "PATH"),
- 1, in_pathname, O_RDONLY, 0, &temp_pathname);
+ OPF_TRY_CWD_FIRST, in_pathname, O_RDONLY | O_BINARY, 0,
+ &temp_pathname);
/* If not found, next search the inferior's $LD_LIBRARY_PATH
environment variable. */
- if (found_file < 0 && solib_search_path != NULL)
+ if (found_file < 0 && gdb_sysroot_is_empty)
found_file = openp (get_in_environ (inferior_environ, "LD_LIBRARY_PATH"),
- 1, in_pathname, O_RDONLY, 0, &temp_pathname);
+ OPF_TRY_CWD_FIRST, in_pathname, O_RDONLY | O_BINARY, 0,
+ &temp_pathname);
+
+ *fd = found_file;
+ return temp_pathname;
+}
+
+/* Open and return a BFD for the shared library PATHNAME. If FD is not -1,
+ it is used as file handle to open the file. Throws an error if the file
+ could not be opened. Handles both local and remote file access.
+
+ PATHNAME must be malloc'ed by the caller. If successful, the new BFD's
+ name will point to it. If unsuccessful, PATHNAME will be freed and the
+ FD will be closed (unless FD was -1). */
+
+bfd *
+solib_bfd_fopen (char *pathname, int fd)
+{
+ bfd *abfd;
+
+ if (remote_filename_p (pathname))
+ {
+ gdb_assert (fd == -1);
+ abfd = remote_bfd_open (pathname, gnutarget);
+ }
+ else
+ {
+ abfd = bfd_fopen (pathname, gnutarget, FOPEN_RB, fd);
+
+ if (abfd)
+ bfd_set_cacheable (abfd, 1);
+ else if (fd != -1)
+ close (fd);
+ }
+
+ if (!abfd)
+ {
+ make_cleanup (xfree, pathname);
+ error (_("Could not open `%s' as an executable file: %s"),
+ pathname, bfd_errmsg (bfd_get_error ()));
+ }
+
+ return abfd;
+}
+
+/* Find shared library PATHNAME and open a BFD for it. */
- /* Done. If not found, tough luck. Return found_file and
- (optionally) found_pathname. */
- if (found_pathname != NULL && temp_pathname != NULL)
- *found_pathname = xstrdup (temp_pathname);
- return found_file;
+bfd *
+solib_bfd_open (char *pathname)
+{
+ struct target_so_ops *ops = solib_ops (target_gdbarch);
+ char *found_pathname;
+ int found_file;
+ bfd *abfd;
+
+ /* Use target-specific override if present. */
+ if (ops->bfd_open)
+ return ops->bfd_open (pathname);
+
+ /* Search for shared library file. */
+ found_pathname = solib_find (pathname, &found_file);
+ if (found_pathname == NULL)
+ perror_with_name (pathname);
+
+ /* Open bfd for shared library. */
+ abfd = solib_bfd_fopen (found_pathname, found_file);
+
+ /* Check bfd format. */
+ if (!bfd_check_format (abfd, bfd_object))
+ {
+ bfd_close (abfd);
+ make_cleanup (xfree, found_pathname);
+ error (_("`%s': not in executable format: %s"),
+ found_pathname, bfd_errmsg (bfd_get_error ()));
+ }
+
+ return abfd;
}
*/
static int
-solib_map_sections (PTR arg)
+solib_map_sections (void *arg)
{
struct so_list *so = (struct so_list *) arg; /* catch_errors bogon */
char *filename;
- char *scratch_pathname;
- int scratch_chan;
struct section_table *p;
struct cleanup *old_chain;
bfd *abfd;
filename = tilde_expand (so->so_name);
-
old_chain = make_cleanup (xfree, filename);
- scratch_chan = solib_open (filename, &scratch_pathname);
-
- if (scratch_chan < 0)
- {
- perror_with_name (filename);
- }
-
- /* Leave scratch_pathname allocated. abfd->name will point to it. */
- abfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
- if (!abfd)
- {
- close (scratch_chan);
- error ("Could not open `%s' as an executable file: %s",
- scratch_pathname, bfd_errmsg (bfd_get_error ()));
- }
+ abfd = solib_bfd_open (filename);
+ do_cleanups (old_chain);
/* Leave bfd open, core_xfer_memory and "info files" need it. */
so->abfd = abfd;
- abfd->cacheable = true;
/* copy full path name into so_name, so that later symbol_file_add
can find it */
- if (strlen (scratch_pathname) >= SO_NAME_MAX_PATH_SIZE)
- error ("Full path name length of shared library exceeds SO_NAME_MAX_PATH_SIZE in so_list structure.");
- strcpy (so->so_name, scratch_pathname);
+ if (strlen (bfd_get_filename (abfd)) >= SO_NAME_MAX_PATH_SIZE)
+ error (_("Shared library file name is too long."));
+ strcpy (so->so_name, bfd_get_filename (abfd));
- if (!bfd_check_format (abfd, bfd_object))
- {
- error ("\"%s\": not in executable format: %s.",
- scratch_pathname, bfd_errmsg (bfd_get_error ()));
- }
if (build_section_table (abfd, &so->sections, &so->sections_end))
{
- error ("Can't find the file sections in `%s': %s",
+ error (_("Can't find the file sections in `%s': %s"),
bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
}
for (p = so->sections; p < so->sections_end; p++)
{
+ struct target_so_ops *ops = solib_ops (target_gdbarch);
+
/* Relocate the section binding addresses as recorded in the shared
object's file by the base address to which the object was actually
mapped. */
- TARGET_SO_RELOCATE_SECTION_ADDRESSES (so, p);
- if (STREQ (p->the_bfd_section->name, ".text"))
+ ops->relocate_section_addresses (so, p);
+
+ /* If the target didn't provide information about the address
+ range of the shared object, assume we want the location of
+ the .text section. */
+ if (so->addr_low == 0 && so->addr_high == 0
+ && strcmp (p->the_bfd_section->name, ".text") == 0)
{
- so->textsection = p;
+ so->addr_low = p->addr;
+ so->addr_high = p->endaddr;
}
}
- /* Free the file names, close the file now. */
- do_cleanups (old_chain);
-
return (1);
}
void
free_so (struct so_list *so)
{
+ struct target_so_ops *ops = solib_ops (target_gdbarch);
char *bfd_filename = 0;
if (so->sections)
{
bfd_filename = bfd_get_filename (so->abfd);
if (! bfd_close (so->abfd))
- warning ("cannot close \"%s\": %s",
+ warning (_("cannot close \"%s\": %s"),
bfd_filename, bfd_errmsg (bfd_get_error ()));
}
if (bfd_filename)
xfree (bfd_filename);
- TARGET_SO_FREE_SO (so);
+ ops->free_so (so);
xfree (so);
}
+/* Return address of first so_list entry in master shared object list. */
+struct so_list *
+master_so_list (void)
+{
+ return so_list_head;
+}
+
+
/* A small stub to get us past the arg-passing pinhole of catch_errors. */
static int
-symbol_add_stub (PTR arg)
+symbol_add_stub (void *arg)
{
- register struct so_list *so = (struct so_list *) arg; /* catch_errs bogon */
+ struct so_list *so = (struct so_list *) arg; /* catch_errs bogon */
struct section_addr_info *sap;
/* Have we already loaded this shared object? */
sap = build_section_addr_info_from_section_table (so->sections,
so->sections_end);
- so->objfile = symbol_file_add (so->so_name, so->from_tty,
- sap, 0, OBJF_SHARED);
+ so->objfile = symbol_file_add_from_bfd (so->abfd, so->from_tty,
+ sap, 0, OBJF_SHARED | OBJF_KEEPBFD);
free_section_addr_info (sap);
return (1);
}
+/* Read in symbols for shared object SO. If FROM_TTY is non-zero, be
+ chatty about it. Return non-zero if any symbols were actually
+ loaded. */
+
+int
+solib_read_symbols (struct so_list *so, int from_tty)
+{
+ if (so->symbols_loaded)
+ {
+ if (from_tty)
+ printf_unfiltered (_("Symbols already loaded for %s\n"), so->so_name);
+ }
+ else if (so->abfd == NULL)
+ {
+ if (from_tty)
+ printf_unfiltered (_("Symbol file not found for %s\n"), so->so_name);
+ }
+ else
+ {
+ if (catch_errors (symbol_add_stub, so,
+ "Error while reading shared library symbols:\n",
+ RETURN_MASK_ALL))
+ {
+ if (from_tty && print_symbol_loading)
+ printf_unfiltered (_("Loaded symbols for %s\n"), so->so_name);
+ so->symbols_loaded = 1;
+ return 1;
+ }
+ }
+
+ return 0;
+}
/* LOCAL FUNCTION
the section table. But we only use this for core files and
processes we've just attached to, so that's okay. */
-void
+static void
update_solib_list (int from_tty, struct target_ops *target)
{
- struct so_list *inferior = TARGET_SO_CURRENT_SOS ();
+ struct target_so_ops *ops = solib_ops (target_gdbarch);
+ struct so_list *inferior = ops->current_sos();
struct so_list *gdb, **gdb_link;
- /* 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 (TARGET_SO_OPEN_SYMBOL_FILE_OBJECT, (PTR) &from_tty,
- "Error reading attached process's symbol file.\n",
- RETURN_MASK_ALL);
-
- /* 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)
+ /* We can reach here due to changing solib-search-path or the
+ sysroot, before having any inferior. */
+ if (target_has_execution && !ptid_equal (inferior_ptid, null_ptid))
{
- make_run_cleanup (do_clear_solib, NULL);
- solib_cleanup_queued = 1;
+ struct inferior *inf = current_inferior ();
+
+ /* 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 (inf->attach_flag && symfile_objfile == NULL)
+ catch_errors (ops->open_symbol_file_object, &from_tty,
+ "Error reading attached process's symbol file.\n",
+ RETURN_MASK_ALL);
}
/* GDB and the inferior's dynamic linker each maintain their own
the inferior's current list. */
while (i)
{
- if (! strcmp (gdb->so_original_name, i->so_original_name))
- break;
+ if (ops->same)
+ {
+ if (ops->same (gdb, i))
+ break;
+ }
+ else
+ {
+ if (! strcmp (gdb->so_original_name, i->so_original_name))
+ break;
+ }
i_link = &i->next;
i = *i_link;
/* If it's not on the inferior's list, remove it from GDB's tables. */
else
{
+ /* Notify any observer that the shared object has been
+ unloaded before we remove it from GDB's tables. */
+ observer_notify_solib_unloaded (gdb);
+
*gdb_link = gdb->next;
/* Unless the user loaded it explicitly, free SO's objfile. */
catch_errors (solib_map_sections, i,
"Error while mapping shared library sections:\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)
+ /* If requested, add the shared object's sections to the TARGET's
+ section table. Do this immediately after mapping the object so
+ that later nodes in the list can query this object, as is needed
+ in solib-osf.c. */
+ if (target)
{
- int space = target_resize_to_sections (target, new_sections);
-
- for (i = inferior; i; i = i->next)
+ int count = (i->sections_end - i->sections);
+ if (count > 0)
{
- int count = (i->sections_end - i->sections);
+ int space = target_resize_to_sections (target, count);
memcpy (target->to_sections + space,
i->sections,
count * sizeof (i->sections[0]));
- space += count;
}
}
+
+ /* Notify any observer that the shared object has been
+ loaded now that we've added it to GDB's tables. */
+ observer_notify_solib_loaded (i);
}
}
}
+/* Return non-zero if SO is the libpthread shared library.
+
+ Uses a fairly simplistic heuristic approach where we check
+ the file name against "/libpthread". This can lead to false
+ positives, but this should be good enough in practice. */
+
+static int
+libpthread_solib_p (struct so_list *so)
+{
+ return (strstr (so->so_name, "/libpthread") != NULL);
+}
/* GLOBAL FUNCTION
SYNOPSIS
- void solib_add (char *pattern, int from_tty, struct target_ops *TARGET)
+ void solib_add (char *pattern, int from_tty, struct target_ops
+ *TARGET, int readsyms)
DESCRIPTION
match PATTERN. (If we've already read a shared object's symbol
info, leave it alone.) If PATTERN is zero, read them all.
+ If READSYMS is 0, defer reading symbolic information until later
+ but still do any needed low level processing.
+
FROM_TTY and TARGET are as described for update_solib_list, above. */
void
-solib_add (char *pattern, int from_tty, struct target_ops *target)
+solib_add (char *pattern, int from_tty, struct target_ops *target, int readsyms)
{
struct so_list *gdb;
char *re_err = re_comp (pattern);
if (re_err)
- error ("Invalid regexp: %s", re_err);
+ error (_("Invalid regexp: %s"), re_err);
}
update_solib_list (from_tty, target);
for (gdb = so_list_head; gdb; gdb = gdb->next)
if (! pattern || re_exec (gdb->so_name))
{
- any_matches = 1;
+ /* Normally, we would read the symbols from that library
+ only if READSYMS is set. However, we're making a small
+ exception for the pthread library, because we sometimes
+ need the library symbols to be loaded in order to provide
+ thread support (x86-linux for instance). */
+ const int add_this_solib =
+ (readsyms || libpthread_solib_p (gdb));
- 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;
- }
- }
+ any_matches = 1;
+ if (add_this_solib && solib_read_symbols (gdb, from_tty))
+ loaded_any_symbols = 1;
}
if (from_tty && pattern && ! any_matches)
if (loaded_any_symbols)
{
+ struct target_so_ops *ops = solib_ops (target_gdbarch);
+
/* Getting new symbols may change our opinion about what is
frameless. */
reinit_frame_cache ();
- TARGET_SO_SPECIAL_SYMBOL_HANDLING ();
+ ops->special_symbol_handling ();
}
}
}
static void
info_sharedlibrary_command (char *ignore, int from_tty)
{
- register struct so_list *so = NULL; /* link map state variable */
+ struct so_list *so = NULL; /* link map state variable */
int header_done = 0;
int addr_width;
- char *addr_fmt;
- int arch_size;
-
- if (exec_bfd == NULL)
- {
- printf_unfiltered ("No executable file.\n");
- return;
- }
- arch_size = bfd_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";
- }
- else
- {
- internal_error (__FILE__, __LINE__,
- "bfd_get_arch_size() returned unknown size %d",
- arch_size);
- }
+ /* "0x", a little whitespace, and two hex digits per byte of pointers. */
+ addr_width = 4 + (gdbarch_ptr_bit (target_gdbarch) / 4);
update_solib_list (from_tty, 0);
}
printf_unfiltered ("%-*s", addr_width,
- so->textsection != NULL
- ? local_hex_string_custom (
- (unsigned long) so->textsection->addr,
- addr_fmt)
+ so->addr_high != 0
+ ? hex_string_custom (
+ (LONGEST) so->addr_low,
+ addr_width - 4)
: "");
printf_unfiltered ("%-*s", addr_width,
- so->textsection != NULL
- ? local_hex_string_custom (
- (unsigned long) so->textsection->endaddr,
- addr_fmt)
+ so->addr_high != 0
+ ? hex_string_custom (
+ (LONGEST) so->addr_high,
+ addr_width - 4)
: "");
printf_unfiltered ("%-12s", so->symbols_loaded ? "Yes" : "No");
printf_unfiltered ("%s\n", so->so_name);
}
if (so_list_head == NULL)
{
- printf_unfiltered ("No shared libraries loaded at this time.\n");
+ printf_unfiltered (_("No shared libraries loaded at this time.\n"));
}
}
char *
solib_address (CORE_ADDR address)
{
- register struct so_list *so = 0; /* link map state variable */
+ struct so_list *so = 0; /* link map state variable */
for (so = so_list_head; so; so = so->next)
{
void
clear_solib (void)
{
+ struct target_so_ops *ops = solib_ops (target_gdbarch);
+
/* 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
So: disable breakpoints only if we're using ELF shared libs. */
if (exec_bfd != NULL
&& bfd_get_flavour (exec_bfd) != bfd_target_aout_flavour)
- disable_breakpoints_in_shlibs (1);
+ disable_breakpoints_in_shlibs ();
while (so_list_head)
{
struct so_list *so = so_list_head;
so_list_head = so->next;
+ if (so->abfd)
+ remove_target_sections (so->abfd);
free_so (so);
}
- TARGET_SO_CLEAR_SOLIB ();
-}
-
-static void
-do_clear_solib (PTR dummy)
-{
- solib_cleanup_queued = 0;
- clear_solib ();
+ ops->clear_solib ();
}
/* GLOBAL FUNCTION
SYNOPSIS
- void solib_create_inferior_hook()
+ void solib_create_inferior_hook ()
DESCRIPTION
void
solib_create_inferior_hook (void)
{
- TARGET_SO_SOLIB_CREATE_INFERIOR_HOOK ();
+ struct target_so_ops *ops = solib_ops (target_gdbarch);
+ ops->solib_create_inferior_hook();
}
+/* GLOBAL FUNCTION
+
+ in_solib_dynsym_resolve_code -- check to see if an address is in
+ dynamic loader's dynamic symbol
+ resolution code
+
+ SYNOPSIS
+
+ int in_solib_dynsym_resolve_code (CORE_ADDR pc)
+
+ DESCRIPTION
+
+ Determine if PC is in the dynamic linker's symbol resolution
+ code. Return 1 if so, 0 otherwise.
+*/
+
+int
+in_solib_dynsym_resolve_code (CORE_ADDR pc)
+{
+ struct target_so_ops *ops = solib_ops (target_gdbarch);
+ return ops->in_dynsym_resolve_code (pc);
+}
/*
sharedlibrary_command (char *args, int from_tty)
{
dont_repeat ();
- solib_add (args, from_tty, (struct target_ops *) 0);
+ solib_add (args, from_tty, (struct target_ops *) 0, 1);
}
+/* LOCAL FUNCTION
+
+ no_shared_libraries -- handle command to explicitly discard symbols
+ from shared libraries.
+
+ DESCRIPTION
+
+ Implements the command "nosharedlibrary", which discards symbols
+ that have been auto-loaded from shared libraries. Symbols from
+ shared libraries that were added by explicit request of the user
+ are not discarded. Also called from remote.c. */
+
+void
+no_shared_libraries (char *ignored, int from_tty)
+{
+ objfile_purge_solibs ();
+ clear_solib ();
+}
+
+static void
+reload_shared_libraries (char *ignored, int from_tty,
+ struct cmd_list_element *e)
+{
+ no_shared_libraries (NULL, from_tty);
+ solib_add (NULL, from_tty, NULL, auto_solib_add);
+}
+
+static void
+show_auto_solib_add (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Autoloading of shared library symbols is %s.\n"),
+ value);
+}
+
+
+/* Handler for library-specific lookup of global symbol NAME in OBJFILE. Call
+ the library-specific handler if it is installed for the current target. */
+
+struct symbol *
+solib_global_lookup (const struct objfile *objfile,
+ const char *name,
+ const char *linkage_name,
+ const domain_enum domain)
+{
+ struct target_so_ops *ops = solib_ops (target_gdbarch);
+
+ if (ops->lookup_lib_global_symbol != NULL)
+ return ops->lookup_lib_global_symbol (objfile, name, linkage_name, domain);
+ return NULL;
+}
+
+
+extern initialize_file_ftype _initialize_solib; /* -Wmissing-prototypes */
void
_initialize_solib (void)
{
struct cmd_list_element *c;
+ solib_data = gdbarch_data_register_pre_init (solib_init);
+
add_com ("sharedlibrary", class_files, sharedlibrary_command,
- "Load shared object library symbols for files matching REGEXP.");
+ _("Load shared object library symbols for files matching REGEXP."));
add_info ("sharedlibrary", info_sharedlibrary_command,
- "Status of loaded shared object libraries.");
-
- add_show_from_set
- (add_set_cmd ("auto-solib-add", class_support, var_zinteger,
- (char *) &auto_solib_add,
- "Set autoloading of shared library symbols.\n\
-If nonzero, symbols from all shared object libraries will be loaded\n\
-automatically when the inferior begins execution or when the dynamic linker\n\
-informs gdb that a new library has been loaded. Otherwise, symbols\n\
-must be loaded manually, using `sharedlibrary'.",
- &setlist),
- &showlist);
-
- c = add_set_cmd ("solib-absolute-prefix", class_support, var_filename,
- (char *) &solib_absolute_prefix,
- "Set prefix for loading absolute shared library symbol files.\n\
-For other (relative) files, you can add values using `set solib-search-path'.",
- &setlist);
- add_show_from_set (c, &showlist);
- c->completer = filename_completer;
-
- c = add_set_cmd ("solib-search-path", class_support, var_string,
- (char *) &solib_search_path,
- "Set the search path for loading non-absolute shared library symbol files.\n\
-This takes precedence over the environment variables PATH and LD_LIBRARY_PATH.",
- &setlist);
- add_show_from_set (c, &showlist);
- c->completer = filename_completer;
+ _("Status of loaded shared object libraries."));
+ add_com ("nosharedlibrary", class_files, no_shared_libraries,
+ _("Unload all shared object library symbols."));
+
+ add_setshow_boolean_cmd ("auto-solib-add", class_support,
+ &auto_solib_add, _("\
+Set autoloading of shared library symbols."), _("\
+Show autoloading of shared library symbols."), _("\
+If \"on\", symbols from all shared object libraries will be loaded\n\
+automatically when the inferior begins execution, when the dynamic linker\n\
+informs gdb that a new library has been loaded, or when attaching to the\n\
+inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'."),
+ NULL,
+ show_auto_solib_add,
+ &setlist, &showlist);
+
+ add_setshow_filename_cmd ("sysroot", class_support,
+ &gdb_sysroot, _("\
+Set an alternate system root."), _("\
+Show the current system root."), _("\
+The system root is used to load absolute shared library symbol files.\n\
+For other (relative) files, you can add directories using\n\
+`set solib-search-path'."),
+ reload_shared_libraries,
+ NULL,
+ &setlist, &showlist);
+
+ add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support, 0,
+ &setlist);
+ add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support, 0,
+ &showlist);
+
+ add_setshow_optional_filename_cmd ("solib-search-path", class_support,
+ &solib_search_path, _("\
+Set the search path for loading non-absolute shared library symbol files."), _("\
+Show the search path for loading non-absolute shared library symbol files."), _("\
+This takes precedence over the environment variables PATH and LD_LIBRARY_PATH."),
+ reload_shared_libraries,
+ show_solib_search_path,
+ &setlist, &showlist);
}