/* Handle shared libraries for GDB, the GNU Debugger.
- Copyright (C) 1990-2019 Free Software Foundation, Inc.
+ Copyright (C) 1990-2020 Free Software Foundation, Inc.
This file is part of GDB.
#include "exec.h"
#include "solist.h"
#include "observable.h"
-#include "readline/readline.h"
+#include "readline/tilde.h"
#include "remote.h"
#include "solib.h"
#include "interps.h"
* If IS_SOLIB is non-zero:
* Look in inferior's $LD_LIBRARY_PATH.
*
- * The last check avoids doing this search when targetting remote
+ * The last check avoids doing this search when targeting remote
* machines since a sysroot will almost always be set.
*/
static gdb::unique_xmalloc_ptr<char>
-solib_find_1 (const char *in_pathname, int *fd, int is_solib)
+solib_find_1 (const char *in_pathname, int *fd, bool is_solib)
{
const struct target_so_ops *ops = solib_ops (target_gdbarch ());
int found_file = -1;
temp_pathname.reset (xstrdup (in_pathname));
else
{
- int need_dir_separator;
+ bool need_dir_separator;
/* Concatenate the sysroot and the target reported filename. We
may need to glue them with a directory separator. Cases to
&& sysroot != NULL
&& HAS_TARGET_DRIVE_SPEC (fskind, in_pathname))
{
- int need_dir_separator = !IS_DIR_SEPARATOR (in_pathname[2]);
+ bool need_dir_separator = !IS_DIR_SEPARATOR (in_pathname[2]);
char drive[2] = { in_pathname[0], '\0' };
temp_pathname.reset (concat (sysroot,
if (*gdb_sysroot != '\0' && IS_TARGET_ABSOLUTE_PATH (fskind, in_pathname))
{
- result = solib_find_1 (in_pathname, fd, 0);
+ result = solib_find_1 (in_pathname, fd, false);
if (result == NULL && fskind == file_system_kind_dos_based)
{
strcpy (new_pathname, in_pathname);
strcat (new_pathname, ".exe");
- result = solib_find_1 (new_pathname, fd, 0);
+ result = solib_find_1 (new_pathname, fd, false);
}
}
else
}
}
- return solib_find_1 (in_pathname, fd, 1);
+ return solib_find_1 (in_pathname, fd, true);
}
/* Open and return a BFD for the shared library PATHNAME. If FD is not -1,
}
-/* Return address of first so_list entry in master shared object list. */
-struct so_list *
-master_so_list (void)
-{
- return so_list_head;
-}
-
/* Read in symbols for shared object SO. If SYMFILE_VERBOSE is set in FLAGS,
- be chatty about it. Return non-zero if any symbols were actually
- loaded. */
+ be chatty about it. Return true if any symbols were actually loaded. */
-int
+bool
solib_read_symbols (struct so_list *so, symfile_add_flags flags)
{
if (so->symbols_loaded)
so->so_name);
}
- return 1;
+ return true;
}
- return 0;
+ return false;
}
-/* Return 1 if KNOWN->objfile is used by any other so_list object in the
- SO_LIST_HEAD list. Return 0 otherwise. */
+/* Return true if KNOWN->objfile is used by any other so_list object
+ in the list of shared libraries. Return false otherwise. */
-static int
+static bool
solib_used (const struct so_list *const known)
{
- const struct so_list *pivot;
-
- for (pivot = so_list_head; pivot != NULL; pivot = pivot->next)
+ for (const struct so_list *pivot : current_program_space->solibs ())
if (pivot != known && pivot->objfile == known->objfile)
- return 1;
- return 0;
+ return true;
+ return false;
}
/* See solib.h. */
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;
+ gdb = current_program_space->so_list;
+ gdb_link = ¤t_program_space->so_list;
while (gdb)
{
struct so_list *i = inferior;
/* Unless the user loaded it explicitly, free SO's objfile. */
if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED)
&& !solib_used (gdb))
- delete gdb->objfile;
+ gdb->objfile->unlink ();
/* Some targets' section tables might be referring to
sections from so->abfd; remove them. */
the file name against "/libpthread". This can lead to false
positives, but this should be good enough in practice. */
-int
+bool
libpthread_name_p (const char *name)
{
return (strstr (name, "/libpthread") != NULL);
/* Return non-zero if SO is the libpthread shared library. */
-static int
+static bool
libpthread_solib_p (struct so_list *so)
{
return libpthread_name_p (so->so_name);
void
solib_add (const char *pattern, int from_tty, int readsyms)
{
- struct so_list *gdb;
-
if (print_symbol_loading_p (from_tty, 0, 0))
{
if (pattern != NULL)
symbols for any that match the pattern --- or any whose symbols
aren't already loaded, if no pattern was given. */
{
- int any_matches = 0;
- int loaded_any_symbols = 0;
+ bool any_matches = false;
+ bool loaded_any_symbols = false;
symfile_add_flags add_flags = SYMFILE_DEFER_BP_RESET;
if (from_tty)
add_flags |= SYMFILE_VERBOSE;
- for (gdb = so_list_head; gdb; gdb = gdb->next)
+ for (struct so_list *gdb : current_program_space->solibs ())
if (! pattern || re_exec (gdb->so_name))
{
/* Normally, we would read the symbols from that library
const int add_this_solib =
(readsyms || libpthread_solib_p (gdb));
- any_matches = 1;
+ any_matches = true;
if (add_this_solib)
{
if (gdb->symbols_loaded)
gdb->so_name);
}
else if (solib_read_symbols (gdb, add_flags))
- loaded_any_symbols = 1;
+ loaded_any_symbols = true;
}
}
static void
info_sharedlibrary_command (const char *pattern, int from_tty)
{
- struct so_list *so = NULL; /* link map state variable */
- int so_missing_debug_info = 0;
+ bool so_missing_debug_info = false;
int addr_width;
int nr_libs;
struct gdbarch *gdbarch = target_gdbarch ();
/* ui_out_emit_table table_emitter needs to know the number of rows,
so we need to make two passes over the libs. */
- for (nr_libs = 0, so = so_list_head; so; so = so->next)
+ nr_libs = 0;
+ for (struct so_list *so : current_program_space->solibs ())
{
if (so->so_name[0])
{
uiout->table_body ();
- ALL_SO_LIBS (so)
+ for (struct so_list *so : current_program_space->solibs ())
{
if (! so->so_name[0])
continue;
&& so->symbols_loaded
&& !objfile_has_symbols (so->objfile))
{
- so_missing_debug_info = 1;
+ so_missing_debug_info = true;
uiout->field_string ("syms-read", "Yes (*)");
}
else
}
}
-/* Return 1 if ADDRESS lies within SOLIB. */
+/* See solib.h. */
-int
+bool
solib_contains_address_p (const struct so_list *const solib,
CORE_ADDR address)
{
for (p = solib->sections; p < solib->sections_end; p++)
if (p->addr <= address && address < p->endaddr)
- return 1;
+ return true;
- return 0;
+ return false;
}
/* If ADDRESS is in a shared lib in program space PSPACE, return its
return (0);
}
-/* Return whether the data starting at VADDR, size SIZE, must be kept
- in a core file for shared libraries loaded before "gcore" is used
- to be handled correctly when the core file is loaded. This only
- applies when the section would otherwise not be kept in the core
- file (in particular, for readonly sections). */
+/* See solib.h. */
-int
+bool
solib_keep_data_in_core (CORE_ADDR vaddr, unsigned long size)
{
const struct target_so_ops *ops = solib_ops (target_gdbarch ());
if (ops->keep_data_in_core)
- return ops->keep_data_in_core (vaddr, size);
+ return ops->keep_data_in_core (vaddr, size) != 0;
else
- return 0;
+ return false;
}
/* Called by free_all_symtabs */
disable_breakpoints_in_shlibs ();
- while (so_list_head)
+ while (current_program_space->so_list)
{
- struct so_list *so = so_list_head;
+ struct so_list *so = current_program_space->so_list;
- so_list_head = so->next;
+ current_program_space->so_list = so->next;
gdb::observers::solib_unloaded.notify (so);
remove_target_sections (so);
free_so (so);
ops->solib_create_inferior_hook (from_tty);
}
-/* Check to see if an address is in the dynamic loader's dynamic
- symbol resolution code. Return 1 if so, 0 otherwise. */
+/* See solib.h. */
-int
+bool
in_solib_dynsym_resolve_code (CORE_ADDR pc)
{
const struct target_so_ops *ops = solib_ops (target_gdbarch ());
- return ops->in_dynsym_resolve_code (pc);
+ return ops->in_dynsym_resolve_code (pc) != 0;
}
/* Implements the "sharedlibrary" command. */
static void
reload_shared_libraries_1 (int from_tty)
{
- struct so_list *so;
-
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)
+ for (struct so_list *so : current_program_space->solibs ())
{
const char *found_pathname = NULL;
- int was_loaded = so->symbols_loaded;
+ bool was_loaded = so->symbols_loaded != 0;
symfile_add_flags add_flags = SYMFILE_DEFER_BP_RESET;
if (from_tty)
{
if (so->objfile && ! (so->objfile->flags & OBJF_USERLOADED)
&& !solib_used (so))
- delete so->objfile;
+ so->objfile->unlink ();
remove_target_sections (so);
clear_so (so);
}
&& (!was_loaded
|| filename_cmp (found_pathname, so->so_name) != 0))
{
- int got_error = 0;
+ bool got_error = false;
try
{
exception_fprintf (gdb_stderr, e,
_("Error while mapping "
"shared library sections:\n"));
- got_error = 1;
+ got_error = true;
}
if (!got_error
if (startswith (gdb_sysroot, old_prefix))
{
- static int warning_issued = 0;
+ static bool warning_issued = false;
gdb_assert (strlen (old_prefix) == strlen (new_prefix));
memcpy (gdb_sysroot, new_prefix, strlen (new_prefix));
old_prefix, new_prefix);
warning (_("sysroot set to \"%s\"."), gdb_sysroot);
- warning_issued = 1;
+ warning_issued = true;
}
}
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. */
+/* The shared library list 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)
+ for (struct so_list *so : current_program_space->solibs ())
if (so->objfile == objfile)
so->objfile = NULL;
}
}
+void _initialize_solib ();
void
-_initialize_solib (void)
+_initialize_solib ()
{
solib_data = gdbarch_data_register_pre_init (solib_init);
projects / deliverable / binutils-gdb.git / blobdiff