/* Handle shared libraries for GDB, the GNU Debugger.
- Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011
- Free Software Foundation, Inc.
+ Copyright (C) 1990-2014 Free Software Foundation, Inc.
This file is part of GDB.
#include <sys/types.h>
#include <fcntl.h>
-#include "gdb_string.h"
#include "symtab.h"
#include "bfd.h"
#include "symfile.h"
#include "objfiles.h"
-#include "exceptions.h"
#include "gdbcore.h"
#include "command.h"
#include "target.h"
#include "solib.h"
#include "interps.h"
#include "filesystem.h"
+#include "gdb_bfd.h"
+#include "filestuff.h"
/* Architecture-specific operations. */
return ops;
}
-static struct target_so_ops *
+static const struct target_so_ops *
solib_ops (struct gdbarch *gdbarch)
{
- struct target_so_ops **ops = gdbarch_data (gdbarch, solib_data);
+ const 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)
+set_solib_ops (struct gdbarch *gdbarch, const struct target_so_ops *new_ops)
{
- struct target_so_ops **ops = gdbarch_data (gdbarch, solib_data);
+ const struct target_so_ops **ops = gdbarch_data (gdbarch, solib_data);
*ops = new_ops;
}
# define DOS_BASED_FILE_SYSTEM 0
#endif
-/*
-
- GLOBAL FUNCTION
-
- solib_find -- Find a shared library file.
-
- SYNOPSIS
-
- char *solib_find (char *in_pathname, int *fd);
-
- DESCRIPTION
+/* Returns the 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.
Global variable GDB_SYSROOT is used as a prefix directory
to search for shared libraries if they have an absolute path.
*
* The last check avoids doing this search when targetting remote
* machines since gdb_sysroot will almost always be set.
-
- RETURNS
-
- 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. */
+*/
char *
solib_find (char *in_pathname, int *fd)
{
- struct target_so_ops *ops = solib_ops (target_gdbarch);
+ const struct target_so_ops *ops = solib_ops (target_gdbarch ());
int found_file = -1;
char *temp_pathname = NULL;
int gdb_sysroot_is_empty;
const char *solib_symbols_extension
- = gdbarch_solib_symbols_extension (target_gdbarch);
+ = gdbarch_solib_symbols_extension (target_gdbarch ());
const char *fskind = effective_target_file_system_kind ();
struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
char *sysroot = NULL;
{
int need_dir_separator;
- need_dir_separator = !IS_DIR_SEPARATOR (in_pathname[0]);
+ /* Concatenate the sysroot and the target reported filename. We
+ may need to glue them with a directory separator. Cases to
+ consider:
+
+ | sysroot | separator | in_pathname |
+ |-----------------+-----------+----------------|
+ | /some/dir | / | c:/foo/bar.dll |
+ | /some/dir | | /foo/bar.dll |
+ | remote: | | c:/foo/bar.dll |
+ | remote: | | /foo/bar.dll |
+ | remote:some/dir | / | c:/foo/bar.dll |
+ | remote:some/dir | | /foo/bar.dll |
+
+ IOW, we don't need to add a separator if IN_PATHNAME already
+ has one, or when the the sysroot is exactly "remote:".
+ There's no need to check for drive spec explicitly, as we only
+ get here if IN_PATHNAME is considered an absolute path. */
+ need_dir_separator = !(IS_DIR_SEPARATOR (in_pathname[0])
+ || strcmp (REMOTE_SYSROOT_PREFIX, sysroot) == 0);
/* Cat the prefixed pathname together. */
temp_pathname = concat (sysroot,
if (remote_filename_p (temp_pathname))
{
*fd = -1;
+ do_cleanups (old_chain);
return temp_pathname;
}
/* Now see if we can open it. */
- found_file = open (temp_pathname, O_RDONLY | O_BINARY, 0);
+ found_file = gdb_open_cloexec (temp_pathname, O_RDONLY | O_BINARY, 0);
if (found_file < 0)
xfree (temp_pathname);
in_pathname + 2, (char *) NULL);
xfree (drive);
- found_file = open (temp_pathname, O_RDONLY | O_BINARY, 0);
+ found_file = gdb_open_cloexec (temp_pathname, O_RDONLY | O_BINARY, 0);
if (found_file < 0)
{
xfree (temp_pathname);
need_dir_separator ? SLASH_STRING : "",
in_pathname + 2, (char *) NULL);
- found_file = open (temp_pathname, O_RDONLY | O_BINARY, 0);
+ found_file = gdb_open_cloexec (temp_pathname, O_RDONLY | O_BINARY, 0);
if (found_file < 0)
xfree (temp_pathname);
}
if (found_file < 0)
temp_pathname = NULL;
- /* 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, &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.)
/* 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,
+ found_file = openp (solib_search_path,
+ OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH,
in_pathname, O_RDONLY | O_BINARY, &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, OPF_TRY_CWD_FIRST,
+ found_file = openp (solib_search_path,
+ OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH,
target_lbasename (fskind, in_pathname),
O_RDONLY | O_BINARY, &temp_pathname);
if (found_file < 0 && gdb_sysroot_is_empty)
found_file = openp (get_in_environ (current_inferior ()->environment,
"PATH"),
- OPF_TRY_CWD_FIRST, in_pathname, O_RDONLY | O_BINARY,
- &temp_pathname);
+ OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH, in_pathname,
+ O_RDONLY | O_BINARY, &temp_pathname);
/* If not found, next search the inferior's $LD_LIBRARY_PATH
environment variable. */
if (found_file < 0 && gdb_sysroot_is_empty)
found_file = openp (get_in_environ (current_inferior ()->environment,
"LD_LIBRARY_PATH"),
- OPF_TRY_CWD_FIRST, in_pathname, O_RDONLY | O_BINARY,
- &temp_pathname);
+ OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH, in_pathname,
+ O_RDONLY | O_BINARY, &temp_pathname);
*fd = found_file;
return temp_pathname;
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). */
+ PATHNAME must be malloc'ed by the caller. It will be freed by this
+ function. If unsuccessful, the FD will be closed (unless FD was
+ -1). */
bfd *
solib_bfd_fopen (char *pathname, int fd)
}
else
{
- abfd = bfd_fopen (pathname, gnutarget, FOPEN_RB, fd);
+ abfd = gdb_bfd_open (pathname, gnutarget, fd);
if (abfd)
bfd_set_cacheable (abfd, 1);
- else if (fd != -1)
- close (fd);
}
if (!abfd)
pathname, bfd_errmsg (bfd_get_error ()));
}
+ xfree (pathname);
+
return abfd;
}
/* Check bfd format. */
if (!bfd_check_format (abfd, bfd_object))
{
- bfd_close (abfd);
- make_cleanup (xfree, found_pathname);
+ make_cleanup_bfd_unref (abfd);
error (_("`%s': not in executable format: %s"),
- found_pathname, bfd_errmsg (bfd_get_error ()));
+ bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
}
/* Check bfd arch. */
- b = gdbarch_bfd_arch_info (target_gdbarch);
+ b = gdbarch_bfd_arch_info (target_gdbarch ());
if (!b->compatible (b, bfd_get_arch_info (abfd)))
warning (_("`%s': Shared library architecture %s is not compatible "
- "with target architecture %s."), found_pathname,
+ "with target architecture %s."), bfd_get_filename (abfd),
bfd_get_arch_info (abfd)->printable_name, b->printable_name);
return abfd;
}
+/* Given a pointer to one of the shared objects in our list of mapped
+ objects, use the recorded name to open a bfd descriptor for the
+ object, build a section table, relocate all the section addresses
+ by the base address at which the shared object was mapped, and then
+ add the sections to the target's section table.
-/*
-
- LOCAL FUNCTION
-
- solib_map_sections -- open bfd and build sections for shared lib
-
- SYNOPSIS
-
- static int solib_map_sections (struct so_list *so)
-
- DESCRIPTION
-
- Given a pointer to one of the shared objects in our list
- of mapped objects, use the recorded name to open a bfd
- descriptor for the object, build a section table, and then
- relocate all the section addresses by the base address at
- which the shared object was mapped.
-
- FIXMES
-
- In most (all?) cases the shared object file name recorded in the
- dynamic linkage tables will be a fully qualified pathname. For
+ FIXME: In most (all?) cases the shared object file name recorded in
+ the dynamic linkage tables will be a fully qualified pathname. For
cases where it isn't, do we really mimic the systems search
mechanism correctly in the below code (particularly the tilde
- expansion stuff?).
- */
+ expansion stuff?). */
static int
solib_map_sections (struct so_list *so)
{
- struct target_so_ops *ops = solib_ops (target_gdbarch);
+ const struct target_so_ops *ops = solib_ops (target_gdbarch ());
char *filename;
struct target_section *p;
struct cleanup *old_chain;
return 0;
/* Leave bfd open, core_xfer_memory and "info files" need it. */
- so->abfd = gdb_bfd_ref (abfd);
-
- /* copy full path name into so_name, so that later symbol_file_add
- can find it. */
+ so->abfd = abfd;
+
+ /* Copy the full path name into so_name, allowing symbol_file_add
+ to find it later. This also affects the =library-loaded GDB/MI
+ event, and in particular the part of that notification providing
+ the library's host-side path. If we let the target dictate
+ that objfile's path, and the target is different from the host,
+ GDB/MI will not provide the correct host-side path. */
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));
section tables. 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. */
- add_target_sections (so->sections, so->sections_end);
+ add_target_sections (so, so->sections, so->sections_end);
return 1;
}
-/* Free symbol-file related contents of SO. If we have opened a BFD
- for SO, close it. If we have placed SO's sections in some target's
- section table, the caller is responsible for removing them.
+/* Free symbol-file related contents of SO and reset for possible reloading
+ of SO. If we have opened a BFD for SO, close it. If we have placed SO's
+ sections in some target's section table, the caller is responsible for
+ removing them.
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_symbols (struct so_list *so)
+clear_so (struct so_list *so)
{
+ const struct target_so_ops *ops = solib_ops (target_gdbarch ());
+
if (so->sections)
{
xfree (so->sections);
/* Restore the target-supplied file name. SO_NAME may be the path
of the symbol file. */
strcpy (so->so_name, so->so_original_name);
-}
-/* LOCAL FUNCTION
-
- free_so --- free a `struct so_list' object
-
- SYNOPSIS
-
- void free_so (struct so_list *so)
-
- DESCRIPTION
+ /* Do the same for target-specific data. */
+ if (ops->clear_so != NULL)
+ ops->clear_so (so);
+}
- Free the storage associated with the `struct so_list' object SO.
+/* Free the storage associated with the `struct so_list' object SO.
If we have opened a BFD for SO, close it.
The caller is responsible for removing SO from whatever list it is
void
free_so (struct so_list *so)
{
- struct target_so_ops *ops = solib_ops (target_gdbarch);
+ const struct target_so_ops *ops = solib_ops (target_gdbarch ());
- free_so_symbols (so);
+ clear_so (so);
ops->free_so (so);
xfree (so);
int
solib_read_symbols (struct so_list *so, int flags)
{
- const int from_tty = flags & SYMFILE_VERBOSE;
-
if (so->symbols_loaded)
{
/* If needed, we've already warned in our caller. */
{
volatile struct gdb_exception e;
+ flags |= current_inferior ()->symfile_flags;
+
TRY_CATCH (e, RETURN_MASK_ERROR)
{
struct section_addr_info *sap;
/* Have we already loaded this shared object? */
ALL_OBJFILES (so->objfile)
{
- if (strcmp (so->objfile->name, so->so_name) == 0)
+ if (filename_cmp (objfile_name (so->objfile), so->so_name) == 0
+ && so->objfile->addr_low == so->addr_low)
break;
}
if (so->objfile != NULL)
sap = build_section_addr_info_from_section_table (so->sections,
so->sections_end);
- so->objfile = symbol_file_add_from_bfd (so->abfd,
- flags, sap, OBJF_SHARED);
+ so->objfile = symbol_file_add_from_bfd (so->abfd, so->so_name,
+ flags, sap, OBJF_SHARED,
+ NULL);
+ so->objfile->addr_low = so->addr_low;
free_section_addr_info (sap);
}
" library symbols for %s:\n"),
so->so_name);
else
- {
- if (from_tty || info_verbose)
- printf_unfiltered (_("Loaded symbols for %s\n"), so->so_name);
- so->symbols_loaded = 1;
- }
+ so->symbols_loaded = 1;
return 1;
}
return 0;
}
-/* LOCAL FUNCTION
+/* Return 1 if KNOWN->objfile is used by any other so_list object in the
+ SO_LIST_HEAD list. Return 0 otherwise. */
- update_solib_list --- synchronize GDB's shared object list with inferior's
+static int
+solib_used (const struct so_list *const known)
+{
+ const struct so_list *pivot;
- SYNOPSIS
+ for (pivot = so_list_head; pivot != NULL; pivot = pivot->next)
+ if (pivot != known && pivot->objfile == known->objfile)
+ return 1;
+ return 0;
+}
- void update_solib_list (int from_tty, struct target_ops *TARGET)
+/* Synchronize GDB's shared object list with inferior's.
Extract the list of currently loaded shared objects from the
inferior, and compare it with the list of shared objects currently
static void
update_solib_list (int from_tty, struct target_ops *target)
{
- struct target_so_ops *ops = solib_ops (target_gdbarch);
+ const struct target_so_ops *ops = solib_ops (target_gdbarch ());
struct so_list *inferior = ops->current_sos();
struct so_list *gdb, **gdb_link;
}
else
{
- if (! strcmp (gdb->so_original_name, i->so_original_name))
+ if (! filename_cmp (gdb->so_original_name, i->so_original_name))
break;
}
unloaded before we remove it from GDB's tables. */
observer_notify_solib_unloaded (gdb);
+ VEC_safe_push (char_ptr, current_program_space->deleted_solibs,
+ xstrdup (gdb->so_name));
+
*gdb_link = gdb->next;
/* Unless the user loaded it explicitly, free SO's objfile. */
- if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED))
+ if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED)
+ && !solib_used (gdb))
free_objfile (gdb->objfile);
/* Some targets' section tables might be referring to
sections from so->abfd; remove them. */
- remove_target_sections (gdb->abfd);
+ remove_target_sections (gdb);
free_so (gdb);
gdb = *gdb_link;
volatile struct gdb_exception e;
i->pspace = current_program_space;
+ VEC_safe_push (so_list_ptr, current_program_space->added_solibs, i);
TRY_CATCH (e, RETURN_MASK_ERROR)
{
return libpthread_name_p (so->so_name);
}
-/* 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, int readsyms)
-
- DESCRIPTION
-
- Read in symbolic information for any shared objects whose names
+/* 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,
+solib_add (const char *pattern, int from_tty,
struct target_ops *target, int readsyms)
{
struct so_list *gdb;
+ if (print_symbol_loading_p (from_tty, 0, 0))
+ {
+ if (pattern != NULL)
+ {
+ printf_unfiltered (_("Loading symbols for shared libraries: %s\n"),
+ pattern);
+ }
+ else
+ printf_unfiltered (_("Loading symbols for shared libraries.\n"));
+ }
+
+ current_program_space->solib_add_generation++;
+
if (pattern)
{
char *re_err = re_comp (pattern);
if (loaded_any_symbols)
{
- struct target_so_ops *ops = solib_ops (target_gdbarch);
+ const struct target_so_ops *ops = solib_ops (target_gdbarch ());
/* Getting new symbols may change our opinion about what is
frameless. */
}
}
-
-/*
-
- LOCAL FUNCTION
-
- info_sharedlibrary_command -- code for "info sharedlibrary"
-
- SYNOPSIS
-
- static void info_sharedlibrary_command ()
-
- DESCRIPTION
-
- Walk through the shared library list and print information
- about each attached library matching PATTERN. If PATTERN is elided,
- print them all.
- */
+/* Implement the "info sharedlibrary" command. Walk through the
+ shared library list and print information about each attached
+ library matching PATTERN. If PATTERN is elided, print them
+ all. */
static void
info_sharedlibrary_command (char *pattern, int from_tty)
int addr_width;
int nr_libs;
struct cleanup *table_cleanup;
- struct gdbarch *gdbarch = target_gdbarch;
+ struct gdbarch *gdbarch = target_gdbarch ();
+ struct ui_out *uiout = current_uiout;
if (pattern)
{
return 0;
}
-/*
-
- GLOBAL FUNCTION
-
- solib_name_from_address -- if an address is in a shared lib, return
- its name.
-
- SYNOPSIS
+/* If ADDRESS is in a shared lib in program space PSPACE, return its
+ name.
- char * solib_name_from_address (CORE_ADDR address)
-
- DESCRIPTION
-
- Provides a hook for other gdb routines to discover whether or
- not a particular address is within the mapped address space of
- a shared library.
+ Provides a hook for other gdb routines to discover whether or not a
+ particular address is within the mapped address space of a shared
+ library.
For example, this routine is called at one point to disable
breakpoints which are in shared libraries that are not currently
- mapped in.
- */
+ mapped in. */
char *
solib_name_from_address (struct program_space *pspace, CORE_ADDR address)
int
solib_keep_data_in_core (CORE_ADDR vaddr, unsigned long size)
{
- struct target_so_ops *ops = solib_ops (target_gdbarch);
+ const struct target_so_ops *ops = solib_ops (target_gdbarch ());
if (ops->keep_data_in_core)
return ops->keep_data_in_core (vaddr, size);
void
clear_solib (void)
{
- struct target_so_ops *ops = solib_ops (target_gdbarch);
+ const 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
so_list_head = so->next;
observer_notify_solib_unloaded (so);
- if (so->abfd)
- remove_target_sections (so->abfd);
+ remove_target_sections (so);
free_so (so);
}
ops->clear_solib ();
}
-/* GLOBAL FUNCTION
-
- solib_create_inferior_hook -- shared library startup support
-
- SYNOPSIS
-
- void solib_create_inferior_hook (int from_tty)
-
- DESCRIPTION
-
- When gdb starts up the inferior, it nurses it along (through the
- shell) until it is ready to execute it's first instruction. At this
- point, this function gets called via expansion of the macro
- SOLIB_CREATE_INFERIOR_HOOK. */
+/* Shared library startup support. When GDB starts up the inferior,
+ it nurses it along (through the shell) until it is ready to execute
+ its first instruction. At this point, this function gets
+ called. */
void
solib_create_inferior_hook (int from_tty)
{
- struct target_so_ops *ops = solib_ops (target_gdbarch);
+ const struct target_so_ops *ops = solib_ops (target_gdbarch ());
ops->solib_create_inferior_hook (from_tty);
}
-/* 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.
-*/
+/* Check to see if an address is in the dynamic loader's dynamic
+ 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);
+ const struct target_so_ops *ops = solib_ops (target_gdbarch ());
return ops->in_dynsym_resolve_code (pc);
}
-/*
-
- LOCAL FUNCTION
-
- sharedlibrary_command -- handle command to explicitly add library
-
- SYNOPSIS
-
- static void sharedlibrary_command (char *args, int from_tty)
-
- DESCRIPTION
-
- */
+/* Implements the "sharedlibrary" command. */
static void
sharedlibrary_command (char *args, int from_tty)
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
+/* 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. */
objfile_purge_solibs ();
}
+/* See solib.h. */
+
+void
+update_solib_breakpoints (void)
+{
+ const struct target_so_ops *ops = solib_ops (target_gdbarch ());
+
+ if (ops->update_breakpoints != NULL)
+ ops->update_breakpoints ();
+}
+
+/* See solib.h. */
+
+void
+handle_solib_event (void)
+{
+ const struct target_so_ops *ops = solib_ops (target_gdbarch ());
+
+ if (ops->handle_event != NULL)
+ ops->handle_event ();
+
+ clear_program_space_solib_cache (current_inferior ()->pspace);
+
+ /* Check for any newly added shared libraries if we're supposed to
+ be adding them automatically. Switch terminal for any messages
+ produced by breakpoint_re_set. */
+ target_terminal_ours_for_output ();
+ solib_add (NULL, 0, ¤t_target, auto_solib_add);
+ target_terminal_inferior ();
+}
+
/* Reload shared libraries, but avoid reloading the same symbol file
we already have loaded. */
struct so_list *so;
struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
+ if (print_symbol_loading_p (from_tty, 0, 0))
+ printf_unfiltered (_("Loading symbols for shared libraries.\n"));
+
for (so = so_list_head; so != NULL; so = so->next)
{
char *filename, *found_pathname = NULL;
SYMFILE_DEFER_BP_RESET | (from_tty ? SYMFILE_VERBOSE : 0);
filename = tilde_expand (so->so_original_name);
+ make_cleanup (xfree, filename);
abfd = solib_bfd_open (filename);
if (abfd != NULL)
{
found_pathname = xstrdup (bfd_get_filename (abfd));
make_cleanup (xfree, found_pathname);
- gdb_bfd_close_or_warn (abfd);
+ gdb_bfd_unref (abfd);
}
/* If this shared library is no longer associated with its previous
symbol file, close that. */
if ((found_pathname == NULL && was_loaded)
|| (found_pathname != NULL
- && strcmp (found_pathname, so->so_name) != 0))
+ && filename_cmp (found_pathname, so->so_name) != 0))
{
- if (so->objfile && ! (so->objfile->flags & OBJF_USERLOADED))
+ if (so->objfile && ! (so->objfile->flags & OBJF_USERLOADED)
+ && !solib_used (so))
free_objfile (so->objfile);
- remove_target_sections (so->abfd);
- free_so_symbols (so);
+ remove_target_sections (so);
+ clear_so (so);
}
/* If this shared library is now associated with a new symbol
file, open it. */
if (found_pathname != NULL
&& (!was_loaded
- || strcmp (found_pathname, so->so_name) != 0))
+ || filename_cmp (found_pathname, so->so_name) != 0))
{
volatile struct gdb_exception e;
reload_shared_libraries (char *ignored, int from_tty,
struct cmd_list_element *e)
{
- struct target_so_ops *ops;
+ const struct target_so_ops *ops;
reload_shared_libraries_1 (from_tty);
- ops = solib_ops (target_gdbarch);
+ ops = solib_ops (target_gdbarch ());
/* Creating inferior hooks here has two purposes. First, if we reload
shared libraries then the address of solib breakpoint we've computed
we're not really starting up the inferior here. */
remove_solib_event_breakpoints ();
-#ifdef SOLIB_CREATE_INFERIOR_HOOK
- SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid));
-#else
solib_create_inferior_hook (from_tty);
-#endif
}
/* Sometimes the platform-specific hook loads initial shared
const char *name,
const domain_enum domain)
{
- struct target_so_ops *ops = solib_ops (target_gdbarch);
+ const struct target_so_ops *ops = solib_ops (target_gdbarch ());
if (ops->lookup_lib_global_symbol != NULL)
return ops->lookup_lib_global_symbol (objfile, name, domain);
return NULL;
}
+/* Lookup the value for a specific symbol from dynamic symbol table. Look
+ up symbol from ABFD. MATCH_SYM is a callback function to determine
+ whether to pick up a symbol. DATA is the input of this callback
+ function. Return NULL if symbol is not found. */
+
+CORE_ADDR
+gdb_bfd_lookup_symbol_from_symtab (bfd *abfd,
+ int (*match_sym) (asymbol *, void *),
+ void *data)
+{
+ long storage_needed = bfd_get_symtab_upper_bound (abfd);
+ CORE_ADDR symaddr = 0;
+
+ if (storage_needed > 0)
+ {
+ unsigned int i;
+
+ asymbol **symbol_table = (asymbol **) xmalloc (storage_needed);
+ struct cleanup *back_to = make_cleanup (xfree, symbol_table);
+ unsigned int number_of_symbols =
+ bfd_canonicalize_symtab (abfd, symbol_table);
+
+ for (i = 0; i < number_of_symbols; i++)
+ {
+ asymbol *sym = *symbol_table++;
+
+ if (match_sym (sym, data))
+ {
+ /* BFD symbols are section relative. */
+ symaddr = sym->value + sym->section->vma;
+ break;
+ }
+ }
+ do_cleanups (back_to);
+ }
+
+ return symaddr;
+}
+
+/* Lookup the value for a specific symbol from symbol table. Look up symbol
+ from ABFD. MATCH_SYM is a callback function to determine whether to pick
+ up a symbol. DATA is the input of this callback function. Return NULL
+ if symbol is not found. */
+
+static CORE_ADDR
+bfd_lookup_symbol_from_dyn_symtab (bfd *abfd,
+ int (*match_sym) (asymbol *, void *),
+ void *data)
+{
+ long storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
+ CORE_ADDR symaddr = 0;
+
+ if (storage_needed > 0)
+ {
+ unsigned int i;
+ asymbol **symbol_table = (asymbol **) xmalloc (storage_needed);
+ struct cleanup *back_to = make_cleanup (xfree, symbol_table);
+ unsigned int number_of_symbols =
+ bfd_canonicalize_dynamic_symtab (abfd, symbol_table);
+
+ for (i = 0; i < number_of_symbols; i++)
+ {
+ asymbol *sym = *symbol_table++;
+
+ if (match_sym (sym, data))
+ {
+ /* BFD symbols are section relative. */
+ symaddr = sym->value + sym->section->vma;
+ break;
+ }
+ }
+ do_cleanups (back_to);
+ }
+ return symaddr;
+}
+
+/* Lookup the value for a specific symbol from symbol table and dynamic
+ symbol table. Look up symbol from ABFD. MATCH_SYM is a callback
+ function to determine whether to pick up a symbol. DATA is the
+ input of this callback function. Return NULL if symbol is not
+ found. */
+
+CORE_ADDR
+gdb_bfd_lookup_symbol (bfd *abfd,
+ int (*match_sym) (asymbol *, void *),
+ void *data)
+{
+ CORE_ADDR symaddr = gdb_bfd_lookup_symbol_from_symtab (abfd, match_sym, data);
+
+ /* On FreeBSD, the dynamic linker is stripped by default. So we'll
+ have to check the dynamic string table too. */
+ if (symaddr == 0)
+ symaddr = bfd_lookup_symbol_from_dyn_symtab (abfd, match_sym, data);
+
+ return symaddr;
+}
+
+/* SO_LIST_HEAD may contain user-loaded object files that can be removed
+ out-of-band by the user. So upon notification of free_objfile remove
+ all references to any user-loaded file that is about to be freed. */
+
+static void
+remove_user_added_objfile (struct objfile *objfile)
+{
+ struct so_list *so;
+
+ if (objfile != 0 && objfile->flags & OBJF_USERLOADED)
+ {
+ for (so = so_list_head; so != NULL; so = so->next)
+ if (so->objfile == objfile)
+ so->objfile = NULL;
+ }
+}
extern initialize_file_ftype _initialize_solib; /* -Wmissing-prototypes */
{
solib_data = gdbarch_data_register_pre_init (solib_init);
+ observer_attach_free_objfile (remove_user_added_objfile);
+
add_com ("sharedlibrary", class_files, sharedlibrary_command,
_("Load shared object library symbols for files matching REGEXP."));
add_info ("sharedlibrary", info_sharedlibrary_command,
projects / platform / upstream / binutils.git / blobdiff