33#include "gdbsupport/gdb_regex.h"
35#include "gdbsupport/environ.h"
39#include "elf/external.h"
40#include "elf/common.h"
45#include "readline/tilde.h"
51#include "gdbsupport/filestuff.h"
52#include "gdbsupport/scoped_fd.h"
70 gdb_printf (file, _(
"The search path for loading non-absolute "
71 "shared library symbol files is %s.\n"),
76#if (HAVE_DOS_BASED_FILE_SYSTEM)
77# define DOS_BASED_FILE_SYSTEM 1
79# define DOS_BASED_FILE_SYSTEM 0
117static gdb::unique_xmalloc_ptr<char>
122 gdb::unique_xmalloc_ptr<char> temp_pathname;
125 int prefix_len, orig_prefix_len;
137 prefix_len = orig_prefix_len = strlen (sysroot);
139 while (prefix_len > 0 && IS_DIR_SEPARATOR (sysroot[prefix_len - 1]))
142 std::string sysroot_holder;
145 else if (prefix_len != orig_prefix_len)
147 sysroot_holder = std::string (sysroot, prefix_len);
148 sysroot = sysroot_holder.c_str ();
160 p = (
char *) alloca (strlen (in_pathname) + 1);
161 strcpy (p, in_pathname);
184 temp_pathname.reset (xstrdup (in_pathname));
187 bool need_dir_separator;
206 need_dir_separator = !(IS_DIR_SEPARATOR (in_pathname[0])
210 temp_pathname.reset (concat (sysroot,
211 need_dir_separator ? SLASH_STRING :
"",
212 in_pathname, (
char *) NULL));
220 return temp_pathname;
224 found_file = gdb_open_cloexec (temp_pathname.get (),
236 bool need_dir_separator = !IS_DIR_SEPARATOR (in_pathname[2]);
237 char drive[2] = { in_pathname[0],
'\0' };
239 temp_pathname.reset (concat (sysroot,
242 need_dir_separator ? SLASH_STRING :
"",
243 in_pathname + 2, (
char *) NULL));
245 found_file = gdb_open_cloexec (temp_pathname.get (),
255 temp_pathname.reset (concat (sysroot,
256 need_dir_separator ? SLASH_STRING :
"",
257 in_pathname + 2, (
char *) NULL));
259 found_file = gdb_open_cloexec (temp_pathname.get (),
270 temp_pathname.reset (NULL);
292 in_pathname, O_RDONLY |
O_BINARY, &temp_pathname);
302 O_RDONLY |
O_BINARY, &temp_pathname);
311 if (found_file < 0 && sysroot == NULL)
314 O_RDONLY |
O_BINARY, &temp_pathname);
318 if (is_solib && found_file < 0 && sysroot == NULL)
322 O_RDONLY |
O_BINARY, &temp_pathname);
332 return temp_pathname;
339gdb::unique_xmalloc_ptr<char>
342 gdb::unique_xmalloc_ptr<char> result;
345 if (in_pathname == NULL)
356 new_pathname = (
char *) alloca (strlen (in_pathname) + 5);
357 strcpy (new_pathname, in_pathname);
358 strcat (new_pathname,
".exe");
374 result.reset (xstrdup (in_pathname));
389gdb::unique_xmalloc_ptr<char>
392 const char *solib_symbols_extension
397 if (solib_symbols_extension != NULL)
399 const char *p = in_pathname + strlen (in_pathname);
401 while (p > in_pathname && *p !=
'.')
409 = (
char *) alloca (p - in_pathname + 1
410 + strlen (solib_symbols_extension) + 1);
411 memcpy (new_pathname, in_pathname, p - in_pathname + 1);
412 strcpy (new_pathname + (p - in_pathname) + 1,
413 solib_symbols_extension);
415 in_pathname = new_pathname;
434 bfd_set_cacheable (abfd.get (), 1);
439 error (_(
"Could not open `%s' as an executable file: %s"),
440 pathname, bfd_errmsg (bfd_get_error ()));
452 const struct bfd_arch_info *b;
455 gdb::unique_xmalloc_ptr<char> found_pathname
457 if (found_pathname == NULL)
471 if (!bfd_check_format (abfd.get (), bfd_object))
472 error (_(
"`%s': not in executable format: %s"),
473 bfd_get_filename (abfd.get ()), bfd_errmsg (bfd_get_error ()));
477 if (!b->compatible (b, bfd_get_arch_info (abfd.get ())))
478 error (_(
"`%s': Shared library architecture %s is not compatible "
479 "with target architecture %s."), bfd_get_filename (abfd.get ()),
480 bfd_get_arch_info (abfd.get ())->printable_name,
493static const struct registry<bfd>::key<soname_build_id_map>
501 const bfd_build_id *build_id)
503 gdb_assert (abfd.get () !=
nullptr);
504 gdb_assert (soname !=
nullptr);
505 gdb_assert (build_id !=
nullptr);
509 if (mapptr ==
nullptr)
517gdb::unique_xmalloc_ptr<char>
520 if (abfd.get () ==
nullptr || soname ==
nullptr)
526 if (mapptr ==
nullptr)
529 auto it = mapptr->find (lbasename (soname));
530 if (it == mapptr->end ())
533 return make_unique_xstrdup (it->second.c_str ());
553 gdb::unique_xmalloc_ptr<char> filename (tilde_expand (so->
so_name));
555 gdb::unique_xmalloc_ptr<char> build_id_hexstr
561 if (build_id_hexstr.get () !=
nullptr)
563 bool mismatch =
false;
565 if (abfd !=
nullptr && abfd->build_id !=
nullptr)
569 if (build_id != build_id_hexstr.get ())
572 if (abfd ==
nullptr || mismatch)
575 build_id_hexstr.get (),
579 abfd = ops->
bfd_open (filename.get ());
581 warning (_(
"Build-id of %ps does not match core file."),
590 so->
abfd = abfd.release ();
599 error (_(
"Shared library file name is too long."));
617 && strcmp (p.the_bfd_section->name,
".text") == 0)
701 else if (so->
abfd == NULL)
729 (gdb_bfd_ref_ptr::new_reference (so->
abfd));
738 catch (
const gdb_exception_error &e)
741 " library symbols for %s:\n"),
788 catch (
const gdb_exception &ex)
791 "Error reading attached "
792 "process's symbol file.\n");
854 gdb_link = &
gdb->next;
867 *gdb_link =
gdb->next;
872 gdb->objfile->unlink ();
889 const char *not_found_filename = NULL;
909 if (not_found_filename == NULL)
914 catch (
const gdb_exception_error &e)
917 _(
"Error while mapping shared "
918 "library sections:\n"));
934 warning (_(
"Could not load shared library symbols for %s.\n"
935 "Do you need \"set solib-search-path\" "
936 "or \"set sysroot\"?"),
938 else if (not_found > 1)
940Could not load shared library symbols for %d libraries, e.g. %s.\n\
941Use the \"info sharedlibrary\" command to see the complete listing.\n\
942Do you need \"set solib-search-path\" or \"set sysroot\"?"),
943 not_found, not_found_filename);
961 return (strstr (
name,
"/libpthread") != NULL
962 || strstr (
name,
"/libc.") != NULL );
983solib_add (
const char *pattern,
int from_tty,
int readsyms)
989 gdb_printf (_(
"Loading symbols for shared libraries: %s\n"),
993 gdb_printf (_(
"Loading symbols for shared libraries.\n"));
1000 char *re_err =
re_comp (pattern);
1003 error (_(
"Invalid regexp: %s"), re_err);
1012 bool any_matches =
false;
1013 bool loaded_any_symbols =
false;
1020 if (! pattern || re_exec (
gdb->so_name))
1027 const int add_this_solib =
1033 if (
gdb->symbols_loaded)
1038 gdb_printf (_(
"Symbols already loaded for %s\n"),
1042 loaded_any_symbols =
true;
1046 if (loaded_any_symbols)
1049 if (from_tty && pattern && ! any_matches)
1051 (
"No loaded shared libraries match the pattern `%s'.\n", pattern);
1053 if (loaded_any_symbols)
1070 bool so_missing_debug_info =
false;
1078 char *re_err =
re_comp (pattern);
1081 error (_(
"Invalid regexp: %s"), re_err);
1097 if (pattern && ! re_exec (so->so_name))
1116 if (! so->so_name[0])
1118 if (pattern && ! re_exec (so->so_name))
1123 if (so->addr_high != 0)
1135 && so->symbols_loaded
1138 so_missing_debug_info =
true;
1142 uiout->
field_string (
"syms-read", so->symbols_loaded ?
"Yes" :
"No");
1153 uiout->
message (_(
"No shared libraries matched.\n"));
1155 uiout->
message (_(
"No shared libraries loaded at this time.\n"));
1159 if (so_missing_debug_info)
1160 uiout->
message (_(
"(*): Shared library is missing "
1161 "debugging information.\n"));
1175 if (p.addr <= address && address < p.endaddr)
1326 gdb_printf (_(
"Loading symbols for shared libraries.\n"));
1330 const char *found_pathname = NULL;
1331 bool was_loaded = so->symbols_loaded != 0;
1337 gdb::unique_xmalloc_ptr<char> filename
1338 (tilde_expand (so->so_original_name));
1341 found_pathname = bfd_get_filename (abfd.get ());
1345 if ((found_pathname == NULL && was_loaded)
1346 || (found_pathname != NULL
1347 && filename_cmp (found_pathname, so->so_name) != 0))
1351 so->objfile->unlink ();
1358 if (found_pathname != NULL
1360 || filename_cmp (found_pathname, so->so_name) != 0))
1362 bool got_error =
false;
1369 catch (
const gdb_exception_error &e)
1372 _(
"Error while mapping "
1373 "shared library sections:\n"));
1443 const char *old_prefix =
"remote:";
1446 if (startswith (
gdb_sysroot.c_str (), old_prefix))
1448 static bool warning_issued =
false;
1450 gdb_assert (strlen (old_prefix) == strlen (new_prefix));
1453 if (!warning_issued)
1455 warning (_(
"\"%s\" is deprecated, use \"%s\" instead."),
1456 old_prefix, new_prefix);
1457 warning (_(
"sysroot set to \"%s\"."),
gdb_sysroot.c_str ());
1459 warning_issued =
true;
1470 gdb_printf (file, _(
"Autoloading of shared library symbols is %s.\n"),
1482 int (*match_sym) (
const asymbol *,
1486 long storage_needed = bfd_get_symtab_upper_bound (abfd);
1487 CORE_ADDR symaddr = 0;
1489 if (storage_needed > 0)
1493 gdb::def_vector<asymbol *> storage (storage_needed /
sizeof (asymbol *));
1494 asymbol **symbol_table = storage.data ();
1495 unsigned int number_of_symbols =
1496 bfd_canonicalize_symtab (abfd, symbol_table);
1498 for (i = 0; i < number_of_symbols; i++)
1500 asymbol *sym = *symbol_table++;
1502 if (match_sym (sym, data))
1505 symaddr = sym->value;
1513 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1524 symaddr += sym->section->vma;
1537 CORE_ADDR *ptr_addr)
1539 int arch_size, step, sect_size;
1540 long current_dyntag;
1541 CORE_ADDR dyn_ptr, dyn_addr;
1542 gdb_byte *bufend, *bufstart, *buf;
1543 Elf32_External_Dyn *x_dynp_32;
1544 Elf64_External_Dyn *x_dynp_64;
1545 struct bfd_section *sect;
1550 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1553 arch_size = bfd_get_arch_size (abfd);
1554 if (arch_size == -1)
1558 sect = bfd_get_section_by_name (abfd,
".dynamic");
1578 dyn_addr = bfd_section_vma (sect);
1583 sect_size = bfd_section_size (sect);
1584 buf = bufstart = (gdb_byte *) alloca (sect_size);
1585 if (!bfd_get_section_contents (abfd, sect,
1590 step = (arch_size == 32) ?
sizeof (Elf32_External_Dyn)
1591 :
sizeof (Elf64_External_Dyn);
1592 for (bufend = buf + sect_size;
1596 if (arch_size == 32)
1598 x_dynp_32 = (Elf32_External_Dyn *) buf;
1599 current_dyntag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);
1600 dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);
1604 x_dynp_64 = (Elf64_External_Dyn *) buf;
1605 current_dyntag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
1606 dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);
1608 if (current_dyntag == DT_NULL)
1610 if (current_dyntag == desired_dyntag)
1616 struct type *ptr_type;
1617 gdb_byte ptr_buf[8];
1618 CORE_ADDR ptr_addr_1;
1621 ptr_addr_1 = dyn_addr + (buf - bufstart) + arch_size / 8;
1626 *ptr_addr = dyn_addr + (buf - bufstart);
1637gdb::unique_xmalloc_ptr<char>
1642 if (abfd ==
nullptr)
1646 if (!bfd_check_format (abfd.get (), bfd_object)
1647 || !(bfd_get_file_flags (abfd.get ()) & DYNAMIC))
1654 struct bfd_section *dynstr = bfd_get_section_by_name (abfd.get (),
".dynstr");
1655 int sect_size = bfd_section_size (dynstr);
1656 if (dynstr ==
nullptr || sect_size <= idx)
1660 gdb::byte_vector dynstr_buf;
1665 char *soname = (
char *) dynstr_buf.data () + idx;
1666 if (strnlen (soname, sect_size - idx) == sect_size - idx)
1669 return make_unique_xstrdup (soname);
1679 int (*match_sym) (
const asymbol *,
1683 long storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
1684 CORE_ADDR symaddr = 0;
1686 if (storage_needed > 0)
1689 gdb::def_vector<asymbol *> storage (storage_needed /
sizeof (asymbol *));
1690 asymbol **symbol_table = storage.data ();
1691 unsigned int number_of_symbols =
1692 bfd_canonicalize_dynamic_symtab (abfd, symbol_table);
1694 for (i = 0; i < number_of_symbols; i++)
1696 asymbol *sym = *symbol_table++;
1698 if (match_sym (sym, data))
1701 symaddr = sym->value + sym->section->vma;
1717 int (*match_sym) (
const asymbol *,
const void *),
1758 _(
"Load shared object library symbols for files matching REGEXP."));
1761 _(
"Status of loaded shared object libraries."));
1764 _(
"Unload all shared object library symbols."));
1768Set autoloading of shared library symbols."), _(
"\
1769Show autoloading of shared library symbols."), _(
"\
1770If \"on\", symbols from all shared object libraries will be loaded\n\
1771automatically when the inferior begins execution, when the dynamic linker\n\
1772informs gdb that a new library has been loaded, or when attaching to the\n\
1773inferior. Otherwise, symbols must be loaded manually, using \
1782Set an alternate system root."), _(
"\
1783Show the current system root."), _(
"\
1784The system root is used to load absolute shared library symbol files.\n\
1785For other (relative) files, you can add directories using\n\
1786`set solib-search-path'."),
1798Set the search path for loading non-absolute shared library symbol files."),
1800Show the search path for loading non-absolute shared library symbol files."),
1802This takes precedence over the environment variables \
1803PATH and LD_LIBRARY_PATH."),
1810Set solib debugging."), _(
"\
1811Show solib debugging."), _(
"\
1812When 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 gdb_bfd_has_target_filename(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)
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)
struct interp * top_level_interpreter(void)
observable< struct so_list * > solib_loaded
observable< struct so_list * > solib_unloaded
observable< struct inferior * > inferior_execd
observable< struct objfile * > free_objfile
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)
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)
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)
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 show_auto_solib_add(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
CORE_ADDR gdb_bfd_lookup_symbol(bfd *abfd, int(*match_sym)(const asymbol *, const void *), const void *data)
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)
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)
CORE_ADDR gdb_bfd_lookup_symbol_from_symtab(bfd *abfd, int(*match_sym)(const asymbol *, const void *), const void *data)
static CORE_ADDR bfd_lookup_symbol_from_dyn_symtab(bfd *abfd, int(*match_sym)(const asymbol *, const void *), const void *data)
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)
CORE_ADDR value_raw_address() const
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]
struct program_space * pspace
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 perror_with_name(const char *string)
void gdb_printf(struct ui_file *stream, const char *format,...)