33#include "gdbsupport/environ.h"
35#include "elf/external.h"
36#include "elf/common.h"
41#include "readline/tilde.h"
46#include "gdbsupport/filestuff.h"
47#include "gdbsupport/scoped_fd.h"
64 gdb_printf (file, _(
"The search path for loading non-absolute "
65 "shared library symbol files is %s.\n"),
70#if (HAVE_DOS_BASED_FILE_SYSTEM)
71# define DOS_BASED_FILE_SYSTEM 1
73# define DOS_BASED_FILE_SYSTEM 0
111static gdb::unique_xmalloc_ptr<char>
116 gdb::unique_xmalloc_ptr<char> temp_pathname;
119 int prefix_len, orig_prefix_len;
131 prefix_len = orig_prefix_len = strlen (sysroot);
133 while (prefix_len > 0 && IS_DIR_SEPARATOR (sysroot[prefix_len - 1]))
136 std::string sysroot_holder;
139 else if (prefix_len != orig_prefix_len)
141 sysroot_holder = std::string (sysroot, prefix_len);
142 sysroot = sysroot_holder.c_str ();
154 p = (
char *) alloca (strlen (in_pathname) + 1);
155 strcpy (p, in_pathname);
178 temp_pathname.reset (xstrdup (in_pathname));
181 bool need_dir_separator;
200 need_dir_separator = !(IS_DIR_SEPARATOR (in_pathname[0])
204 temp_pathname.reset (concat (sysroot,
205 need_dir_separator ? SLASH_STRING :
"",
206 in_pathname, (
char *) NULL));
214 return temp_pathname;
218 found_file = gdb_open_cloexec (temp_pathname.get (),
230 bool need_dir_separator = !IS_DIR_SEPARATOR (in_pathname[2]);
231 char drive[2] = { in_pathname[0],
'\0' };
233 temp_pathname.reset (concat (sysroot,
236 need_dir_separator ? SLASH_STRING :
"",
237 in_pathname + 2, (
char *) NULL));
239 found_file = gdb_open_cloexec (temp_pathname.get (),
249 temp_pathname.reset (concat (sysroot,
250 need_dir_separator ? SLASH_STRING :
"",
251 in_pathname + 2, (
char *) NULL));
253 found_file = gdb_open_cloexec (temp_pathname.get (),
264 temp_pathname.reset (NULL);
286 in_pathname, O_RDONLY |
O_BINARY, &temp_pathname);
296 O_RDONLY |
O_BINARY, &temp_pathname);
305 if (found_file < 0 && sysroot == NULL)
308 O_RDONLY |
O_BINARY, &temp_pathname);
312 if (is_solib && found_file < 0 && sysroot == NULL)
316 O_RDONLY |
O_BINARY, &temp_pathname);
326 return temp_pathname;
333gdb::unique_xmalloc_ptr<char>
336 gdb::unique_xmalloc_ptr<char> result;
339 if (in_pathname == NULL)
350 new_pathname = (
char *) alloca (strlen (in_pathname) + 5);
351 strcpy (new_pathname, in_pathname);
352 strcat (new_pathname,
".exe");
368 result.reset (xstrdup (in_pathname));
383gdb::unique_xmalloc_ptr<char>
386 const char *solib_symbols_extension
391 if (solib_symbols_extension != NULL)
393 const char *p = in_pathname + strlen (in_pathname);
395 while (p > in_pathname && *p !=
'.')
403 = (
char *) alloca (p - in_pathname + 1
404 + strlen (solib_symbols_extension) + 1);
405 memcpy (new_pathname, in_pathname, p - in_pathname + 1);
406 strcpy (new_pathname + (p - in_pathname) + 1,
407 solib_symbols_extension);
409 in_pathname = new_pathname;
430 error (_(
"Could not open `%s' as an executable file: %s"),
431 pathname, bfd_errmsg (bfd_get_error ()));
443 const struct bfd_arch_info *b;
446 gdb::unique_xmalloc_ptr<char> found_pathname
448 if (found_pathname == NULL)
455 perror_with_name (pathname);
462 if (!bfd_check_format (abfd.get (), bfd_object))
463 error (_(
"`%s': not in executable format: %s"),
464 bfd_get_filename (abfd.get ()), bfd_errmsg (bfd_get_error ()));
468 if (!b->compatible (b, bfd_get_arch_info (abfd.get ())))
469 error (_(
"`%s': Shared library architecture %s is not compatible "
470 "with target architecture %s."), bfd_get_filename (abfd.get ()),
471 bfd_get_arch_info (abfd.get ())->printable_name,
484static const struct registry<bfd>::key<soname_build_id_map>
492 const bfd_build_id *build_id)
494 gdb_assert (abfd.get () !=
nullptr);
495 gdb_assert (soname !=
nullptr);
496 gdb_assert (build_id !=
nullptr);
500 if (mapptr ==
nullptr)
508gdb::unique_xmalloc_ptr<char>
511 if (abfd.get () ==
nullptr || soname ==
nullptr)
517 if (mapptr ==
nullptr)
520 auto it = mapptr->find (lbasename (soname));
521 if (it == mapptr->end ())
524 return make_unique_xstrdup (it->second.c_str ());
544 gdb::unique_xmalloc_ptr<char> filename (tilde_expand (so->
so_name));
546 gdb::unique_xmalloc_ptr<char> build_id_hexstr
552 if (build_id_hexstr.get () !=
nullptr)
554 bool mismatch =
false;
556 if (abfd !=
nullptr && abfd->build_id !=
nullptr)
560 if (build_id != build_id_hexstr.get ())
563 if (abfd ==
nullptr || mismatch)
566 build_id_hexstr.get (),
570 abfd = ops->
bfd_open (filename.get ());
572 warning (_(
"Build-id of %ps does not match core file."),
581 so->
abfd = abfd.release ();
590 error (_(
"Shared library file name is too long."));
608 && strcmp (p.the_bfd_section->name,
".text") == 0)
692 else if (so->
abfd == NULL)
720 (gdb_bfd_ref_ptr::new_reference (so->
abfd));
729 catch (
const gdb_exception_error &e)
732 " library symbols for %s:\n"),
797 catch (
const gdb_exception_error &ex)
800 "Error reading attached "
801 "process's symbol file.\n");
863 gdb_link = &
gdb->next;
876 *gdb_link =
gdb->next;
881 gdb->objfile->unlink ();
898 const char *not_found_filename = NULL;
916 if (not_found_filename == NULL)
921 catch (
const gdb_exception_error &e)
924 _(
"Error while mapping shared "
925 "library sections:\n"));
941 warning (_(
"Could not load shared library symbols for %s.\n"
942 "Do you need \"set solib-search-path\" "
943 "or \"set sysroot\"?"),
945 else if (not_found > 1)
947Could not load shared library symbols for %d libraries, e.g. %s.\n\
948Use the \"info sharedlibrary\" command to see the complete listing.\n\
949Do you need \"set solib-search-path\" or \"set sysroot\"?"),
950 not_found, not_found_filename);
968 return (strstr (
name,
"/libpthread") != NULL
969 || strstr (
name,
"/libc.") != NULL );
990solib_add (
const char *pattern,
int from_tty,
int readsyms)
996 gdb_printf (_(
"Loading symbols for shared libraries: %s\n"),
1000 gdb_printf (_(
"Loading symbols for shared libraries.\n"));
1007 char *re_err =
re_comp (pattern);
1010 error (_(
"Invalid regexp: %s"), re_err);
1019 bool any_matches =
false;
1020 bool loaded_any_symbols =
false;
1027 if (! pattern || re_exec (
gdb->so_name))
1034 const int add_this_solib =
1040 if (
gdb->symbols_loaded)
1045 gdb_printf (_(
"Symbols already loaded for %s\n"),
1049 loaded_any_symbols =
true;
1053 if (loaded_any_symbols)
1056 if (from_tty && pattern && ! any_matches)
1058 (
"No loaded shared libraries match the pattern `%s'.\n", pattern);
1060 if (loaded_any_symbols)
1077 bool so_missing_debug_info =
false;
1085 char *re_err =
re_comp (pattern);
1088 error (_(
"Invalid regexp: %s"), re_err);
1104 if (pattern && ! re_exec (so->so_name))
1123 if (! so->so_name[0])
1125 if (pattern && ! re_exec (so->so_name))
1130 if (so->addr_high != 0)
1142 && so->symbols_loaded
1145 so_missing_debug_info =
true;
1149 uiout->
field_string (
"syms-read", so->symbols_loaded ?
"Yes" :
"No");
1160 uiout->
message (_(
"No shared libraries matched.\n"));
1162 uiout->
message (_(
"No shared libraries loaded at this time.\n"));
1166 if (so_missing_debug_info)
1167 uiout->
message (_(
"(*): Shared library is missing "
1168 "debugging information.\n"));
1182 if (p.addr <= address && address < p.endaddr)
1333 gdb_printf (_(
"Loading symbols for shared libraries.\n"));
1337 const char *found_pathname = NULL;
1338 bool was_loaded = so->symbols_loaded != 0;
1344 gdb::unique_xmalloc_ptr<char> filename
1345 (tilde_expand (so->so_original_name));
1348 found_pathname = bfd_get_filename (abfd.get ());
1352 if ((found_pathname == NULL && was_loaded)
1353 || (found_pathname != NULL
1354 && filename_cmp (found_pathname, so->so_name) != 0))
1358 so->objfile->unlink ();
1365 if (found_pathname != NULL
1367 || filename_cmp (found_pathname, so->so_name) != 0))
1369 bool got_error =
false;
1376 catch (
const gdb_exception_error &e)
1379 _(
"Error while mapping "
1380 "shared library sections:\n"));
1450 const char *old_prefix =
"remote:";
1453 if (startswith (
gdb_sysroot.c_str (), old_prefix))
1455 static bool warning_issued =
false;
1457 gdb_assert (strlen (old_prefix) == strlen (new_prefix));
1460 if (!warning_issued)
1462 warning (_(
"\"%s\" is deprecated, use \"%s\" instead."),
1463 old_prefix, new_prefix);
1464 warning (_(
"sysroot set to \"%s\"."),
gdb_sysroot.c_str ());
1466 warning_issued =
true;
1477 gdb_printf (file, _(
"Autoloading of shared library symbols is %s.\n"),
1489 (bfd *abfd, gdb::function_view<
bool (
const asymbol *)> match_sym)
1491 long storage_needed = bfd_get_symtab_upper_bound (abfd);
1492 CORE_ADDR symaddr = 0;
1494 if (storage_needed > 0)
1498 gdb::def_vector<asymbol *> storage (storage_needed /
sizeof (asymbol *));
1499 asymbol **symbol_table = storage.data ();
1500 unsigned int number_of_symbols =
1501 bfd_canonicalize_symtab (abfd, symbol_table);
1503 for (i = 0; i < number_of_symbols; i++)
1505 asymbol *sym = *symbol_table++;
1507 if (match_sym (sym))
1510 symaddr = sym->value;
1518 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1529 symaddr += sym->section->vma;
1542 CORE_ADDR *ptr_addr)
1544 int arch_size, step, sect_size;
1545 long current_dyntag;
1546 CORE_ADDR dyn_ptr, dyn_addr;
1547 gdb_byte *bufend, *bufstart, *buf;
1548 Elf32_External_Dyn *x_dynp_32;
1549 Elf64_External_Dyn *x_dynp_64;
1550 struct bfd_section *sect;
1555 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1558 arch_size = bfd_get_arch_size (abfd);
1559 if (arch_size == -1)
1563 sect = bfd_get_section_by_name (abfd,
".dynamic");
1583 dyn_addr = bfd_section_vma (sect);
1588 sect_size = bfd_section_size (sect);
1589 buf = bufstart = (gdb_byte *) alloca (sect_size);
1590 if (!bfd_get_section_contents (abfd, sect,
1595 step = (arch_size == 32) ?
sizeof (Elf32_External_Dyn)
1596 :
sizeof (Elf64_External_Dyn);
1597 for (bufend = buf + sect_size;
1601 if (arch_size == 32)
1603 x_dynp_32 = (Elf32_External_Dyn *) buf;
1604 current_dyntag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);
1605 dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);
1609 x_dynp_64 = (Elf64_External_Dyn *) buf;
1610 current_dyntag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
1611 dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);
1613 if (current_dyntag == DT_NULL)
1615 if (current_dyntag == desired_dyntag)
1621 struct type *ptr_type;
1622 gdb_byte ptr_buf[8];
1623 CORE_ADDR ptr_addr_1;
1626 ptr_addr_1 = dyn_addr + (buf - bufstart) + arch_size / 8;
1631 *ptr_addr = dyn_addr + (buf - bufstart);
1642gdb::unique_xmalloc_ptr<char>
1647 if (abfd ==
nullptr)
1651 if (!bfd_check_format (abfd.get (), bfd_object)
1652 || !(bfd_get_file_flags (abfd.get ()) & DYNAMIC))
1659 struct bfd_section *dynstr = bfd_get_section_by_name (abfd.get (),
".dynstr");
1660 int sect_size = bfd_section_size (dynstr);
1661 if (dynstr ==
nullptr || sect_size <= idx)
1665 gdb::byte_vector dynstr_buf;
1670 char *soname = (
char *) dynstr_buf.data () + idx;
1671 if (strnlen (soname, sect_size - idx) == sect_size - idx)
1674 return make_unique_xstrdup (soname);
1684 (bfd *abfd, gdb::function_view<
bool (
const asymbol *)> match_sym)
1686 long storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
1687 CORE_ADDR symaddr = 0;
1689 if (storage_needed > 0)
1692 gdb::def_vector<asymbol *> storage (storage_needed /
sizeof (asymbol *));
1693 asymbol **symbol_table = storage.data ();
1694 unsigned int number_of_symbols =
1695 bfd_canonicalize_dynamic_symtab (abfd, symbol_table);
1697 for (i = 0; i < number_of_symbols; i++)
1699 asymbol *sym = *symbol_table++;
1701 if (match_sym (sym))
1704 symaddr = sym->value + sym->section->vma;
1720 (bfd *abfd, gdb::function_view<
bool (
const asymbol *)> match_sym)
1761 _(
"Load shared object library symbols for files matching REGEXP."));
1764 _(
"Status of loaded shared object libraries."));
1767 _(
"Unload all shared object library symbols."));
1771Set autoloading of shared library symbols."), _(
"\
1772Show autoloading of shared library symbols."), _(
"\
1773If \"on\", symbols from all shared object libraries will be loaded\n\
1774automatically when the inferior begins execution, when the dynamic linker\n\
1775informs gdb that a new library has been loaded, or when attaching to the\n\
1776inferior. Otherwise, symbols must be loaded manually, using \
1785Set an alternate system root."), _(
"\
1786Show the current system root."), _(
"\
1787The system root is used to load absolute shared library symbol files.\n\
1788For other (relative) files, you can add directories using\n\
1789`set solib-search-path'."),
1801Set the search path for loading non-absolute shared library symbol files."),
1803Show the search path for loading non-absolute shared library symbol files."),
1805This takes precedence over the environment variables \
1806PATH and LD_LIBRARY_PATH."),
1813Set solib debugging."), _(
"\
1814Show solib debugging."), _(
"\
1815When true, solib-related debugging output is enabled."),
struct gdbarch * target_gdbarch(void)
void breakpoint_re_set(void)
void remove_solib_event_breakpoints(void)
void disable_breakpoints_in_shlibs(void)
static std::string build_id_to_string(const bfd_build_id *build_id)
ui_file_style style() const
symfile_add_flags symfile_flags
struct program_space * pspace
static void ours_for_output()
void field_core_addr(const char *fldname, struct gdbarch *gdbarch, CORE_ADDR address)
void field_string(const char *fldname, const char *string, const ui_file_style &style=ui_file_style())
void field_skip(const char *fldname)
void text(const char *string)
void table_header(int width, ui_align align, const std::string &col_name, const std::string &col_hdr)
bool is_mi_like_p() const
void message(const char *format,...) ATTRIBUTE_PRINTF(2
struct cmd_list_element * showlist
struct cmd_list_element * setlist
struct cmd_list_element * showdebuglist
struct cmd_list_element * setdebuglist
struct cmd_list_element * add_alias_cmd(const char *name, cmd_list_element *target, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
set_show_commands add_setshow_optional_filename_cmd(const char *name, enum command_class theclass, std::string *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc)
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
cmd_list_element * add_info_alias(const char *name, cmd_list_element *target, int abbrev_flag)
struct cmd_list_element * add_info(const char *name, cmd_simple_func_ftype *fun, const char *doc)
cli_style_option file_name_style
scoped_fd debuginfod_exec_query(const unsigned char *build_id, int build_id_len, const char *filename, gdb::unique_xmalloc_ptr< char > *destname)
EXTERN_C char * re_comp(const char *)
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
void exception_fprintf(struct ui_file *file, const struct gdb_exception &e, const char *prefix,...)
target_section_table build_section_table(struct bfd *some_bfd)
const char * target_lbasename(const char *kind, const char *name)
const char file_system_kind_dos_based[]
const char * effective_target_file_system_kind(void)
#define IS_TARGET_ABSOLUTE_PATH(kind, p)
#define HAS_TARGET_DRIVE_SPEC(kind, p)
#define IS_TARGET_DIR_SEPARATOR(kind, c)
void reinit_frame_cache(void)
void gdb_bfd_unref(struct bfd *abfd)
int is_target_filename(const char *name)
gdb_bfd_ref_ptr gdb_bfd_open(const char *name, const char *target, int fd, bool warn_if_slow)
bool gdb_bfd_get_full_section_contents(bfd *abfd, asection *section, gdb::byte_vector *contents)
#define TARGET_SYSROOT_PREFIX
gdb::ref_ptr< struct bfd, gdb_bfd_ref_policy > gdb_bfd_ref_ptr
const struct target_so_ops * gdbarch_so_ops(struct gdbarch *gdbarch)
void gdbarch_elf_make_msymbol_special(struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
bool gdbarch_elf_make_msymbol_special_p(struct gdbarch *gdbarch)
const char * gdbarch_solib_symbols_extension(struct gdbarch *gdbarch)
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
struct inferior * current_inferior(void)
void interps_notify_solib_loaded(so_list *so)
struct interp * top_level_interpreter(void)
void interps_notify_solib_unloaded(so_list *so)
observable< struct so_list * > solib_loaded
observable< struct objfile * > free_objfile
observable< inferior *, inferior * > inferior_execd
observable< struct program_space *, struct so_list * > solib_unloaded
int objfile_has_symbols(struct objfile *objfile)
void objfile_purge_solibs(void)
const char * objfile_name(const struct objfile *objfile)
struct program_space * current_program_space
static void clear_so(struct so_list *so)
bool libpthread_name_p(const char *name)
CORE_ADDR gdb_bfd_lookup_symbol_from_symtab(bfd *abfd, gdb::function_view< bool(const asymbol *)> match_sym)
static void info_sharedlibrary_command(const char *pattern, int from_tty)
void set_cbfd_soname_build_id(gdb_bfd_ref_ptr abfd, const char *soname, const bfd_build_id *build_id)
static void notify_solib_unloaded(program_space *pspace, so_list *so)
gdb::unique_xmalloc_ptr< char > get_cbfd_soname_build_id(gdb_bfd_ref_ptr abfd, const char *soname)
bool solib_read_symbols(struct so_list *so, symfile_add_flags flags)
std::unordered_map< std::string, std::string > soname_build_id_map
static void gdb_sysroot_changed(const char *ignored, int from_tty, struct cmd_list_element *e)
static void reload_shared_libraries_1(int from_tty)
static CORE_ADDR bfd_lookup_symbol_from_dyn_symtab(bfd *abfd, gdb::function_view< bool(const asymbol *)> match_sym)
void solib_create_inferior_hook(int from_tty)
static gdb::unique_xmalloc_ptr< char > solib_find_1(const char *in_pathname, int *fd, bool is_solib)
gdb::unique_xmalloc_ptr< char > exec_file_find(const char *in_pathname, int *fd)
void free_so(struct so_list *so)
static int solib_map_sections(struct so_list *so)
#define DOS_BASED_FILE_SYSTEM
gdb::unique_xmalloc_ptr< char > gdb_bfd_read_elf_soname(const char *filename)
static std::string solib_search_path
bool solib_contains_address_p(const struct so_list *const solib, CORE_ADDR address)
void update_solib_list(int from_tty)
static bool solib_used(const struct so_list *const known)
static void notify_solib_loaded(so_list *so)
static void show_auto_solib_add(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
void solib_add(const char *pattern, int from_tty, int readsyms)
const char * solib_name_from_address(struct program_space *pspace, CORE_ADDR address)
gdb_bfd_ref_ptr solib_bfd_fopen(const char *pathname, int fd)
gdb_bfd_ref_ptr solib_bfd_open(const char *pathname)
void no_shared_libraries(const char *ignored, int from_tty)
gdb::unique_xmalloc_ptr< char > solib_find(const char *in_pathname, int *fd)
CORE_ADDR gdb_bfd_lookup_symbol(bfd *abfd, gdb::function_view< bool(const asymbol *)> match_sym)
int gdb_bfd_scan_elf_dyntag(const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr, CORE_ADDR *ptr_addr)
static bool libpthread_solib_p(struct so_list *so)
bool in_solib_dynsym_resolve_code(CORE_ADDR pc)
static void reload_shared_libraries(const char *ignored, int from_tty, struct cmd_list_element *e)
void update_solib_breakpoints(void)
static const struct registry< bfd >::key< soname_build_id_map > cbfd_soname_build_id_data_key
bool solib_keep_data_in_core(CORE_ADDR vaddr, unsigned long size)
static void show_solib_search_path(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
static void sharedlibrary_command(const char *args, int from_tty)
void handle_solib_event(void)
static void remove_user_added_objfile(struct objfile *objfile)
#define SO_NAME_MAX_PATH_SIZE
int openp(const char *path, openp_flags opts, const char *string, int mode, gdb::unique_xmalloc_ptr< char > *filename_opened)
int source_full_path_of(const char *filename, gdb::unique_xmalloc_ptr< char > *full_pathname)
struct type * builtin_data_ptr
void set_value_address(CORE_ADDR address)
unrelocated_addr unrelocated_address() const
struct program_space * pspace
void remove_target_sections(void *owner)
void add_target_sections(void *owner, const target_section_table §ions)
objfiles_range objfiles()
std::vector< std::string > deleted_solibs
std::vector< struct so_list * > added_solibs
unsigned int solib_add_generation
target_section_table & target_sections()
struct objfile * symfile_object_file
so_list_range solibs() const
char so_name[SO_NAME_MAX_PATH_SIZE]
char so_original_name[SO_NAME_MAX_PATH_SIZE]
target_section_table * sections
struct bfd_section * the_bfd_section
void(* solib_create_inferior_hook)(int from_tty)
int(* in_dynsym_resolve_code)(CORE_ADDR pc)
int(* same)(struct so_list *gdb, struct so_list *inferior)
void(* free_so)(struct so_list *so)
void(* clear_solib)(void)
void(* handle_event)(void)
int(* find_and_open_solib)(const char *soname, unsigned o_flags, gdb::unique_xmalloc_ptr< char > *temp_pathname)
void(* clear_so)(struct so_list *so)
int(* open_symbol_file_object)(int from_ttyp)
struct so_list *(* current_sos)(void)
int(* keep_data_in_core)(CORE_ADDR vaddr, unsigned long size)
gdb_bfd_ref_ptr(* bfd_open)(const char *pathname)
void(* relocate_section_addresses)(struct so_list *so, struct target_section *)
void(* update_breakpoints)(void)
section_addr_info build_section_addr_info_from_section_table(const target_section_table &table)
int print_symbol_loading_p(int from_tty, int exec, int full)
struct objfile * symbol_file_add_from_bfd(const gdb_bfd_ref_ptr &abfd, const char *name, symfile_add_flags add_flags, section_addr_info *addrs, objfile_flags flags, struct objfile *parent)
std::vector< other_sections > section_addr_info
std::vector< target_section > target_section_table
bool target_filesystem_is_local()
bool target_has_execution(inferior *inf)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
static styled_string_s * styled_string(const ui_file_style &style, const char *str, styled_string_s &&tmp={})
void gdb_printf(struct ui_file *stream, const char *format,...)