1 /* Handle shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 1990-2023 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
33 #include "gdbsupport/environ.h"
34 #include "cli/cli-cmds.h"
35 #include "elf/external.h"
36 #include "elf/common.h"
37 #include "filenames.h"
40 #include "observable.h"
41 #include "readline/tilde.h"
44 #include "filesystem.h"
46 #include "gdbsupport/filestuff.h"
47 #include "gdbsupport/scoped_fd.h"
48 #include "debuginfod-support.h"
50 #include "cli/cli-style.h"
56 /* If non-empty, this is a search path for loading non-absolute shared library
57 symbol files. This takes precedence over the environment variables PATH
58 and LD_LIBRARY_PATH. */
59 static std::string solib_search_path
;
61 show_solib_search_path (struct ui_file
*file
, int from_tty
,
62 struct cmd_list_element
*c
, const char *value
)
64 gdb_printf (file
, _("The search path for loading non-absolute "
65 "shared library symbol files is %s.\n"),
69 /* Same as HAVE_DOS_BASED_FILE_SYSTEM, but useable as an rvalue. */
70 #if (HAVE_DOS_BASED_FILE_SYSTEM)
71 # define DOS_BASED_FILE_SYSTEM 1
73 # define DOS_BASED_FILE_SYSTEM 0
76 /* Return the full pathname of a binary file (the main executable or a
77 shared library file), or NULL if not found. If FD is non-NULL, *FD
78 is set to either -1 or an open file handle for the binary file.
80 Global variable GDB_SYSROOT is used as a prefix directory
81 to search for binary files if they have an absolute path.
82 If GDB_SYSROOT starts with "target:" and target filesystem
83 is the local filesystem then the "target:" prefix will be
84 stripped before the search starts. This ensures that the
85 same search algorithm is used for local files regardless of
86 whether a "target:" prefix was used.
88 Global variable SOLIB_SEARCH_PATH is used as a prefix directory
89 (or set of directories, as in LD_LIBRARY_PATH) to search for all
90 shared libraries if not found in either the sysroot (if set) or
91 the local filesystem. SOLIB_SEARCH_PATH is not used when searching
92 for the main executable.
95 * If a sysroot is set and path is absolute:
96 * Search for sysroot/path.
98 * Look for it literally (unmodified).
99 * If IS_SOLIB is non-zero:
100 * Look in SOLIB_SEARCH_PATH.
101 * If available, use target defined search function.
102 * If NO sysroot is set, perform the following two searches:
103 * Look in inferior's $PATH.
104 * If IS_SOLIB is non-zero:
105 * Look in inferior's $LD_LIBRARY_PATH.
107 * The last check avoids doing this search when targeting remote
108 * machines since a sysroot will almost always be set.
111 static gdb::unique_xmalloc_ptr
<char>
112 solib_find_1 (const char *in_pathname
, int *fd
, bool is_solib
)
114 const target_so_ops
*ops
= gdbarch_so_ops (current_inferior ()->arch ());
116 gdb::unique_xmalloc_ptr
<char> temp_pathname
;
117 const char *fskind
= effective_target_file_system_kind ();
118 const char *sysroot
= gdb_sysroot
.c_str ();
119 int prefix_len
, orig_prefix_len
;
121 /* If the absolute prefix starts with "target:" but the filesystem
122 accessed by the target_fileio_* methods is the local filesystem
123 then we strip the "target:" prefix now and work with the local
124 filesystem. This ensures that the same search algorithm is used
125 for all local files regardless of whether a "target:" prefix was
127 if (is_target_filename (sysroot
) && target_filesystem_is_local ())
128 sysroot
+= strlen (TARGET_SYSROOT_PREFIX
);
130 /* Strip any trailing slashes from the absolute prefix. */
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 ();
145 /* If we're on a non-DOS-based system, backslashes won't be
146 understood as directory separator, so, convert them to forward
147 slashes, iff we're supposed to handle DOS-based file system
148 semantics for target paths. */
149 if (!DOS_BASED_FILE_SYSTEM
&& fskind
== file_system_kind_dos_based
)
153 /* Avoid clobbering our input. */
154 p
= (char *) alloca (strlen (in_pathname
) + 1);
155 strcpy (p
, in_pathname
);
165 /* Note, we're interested in IS_TARGET_ABSOLUTE_PATH, not
166 IS_ABSOLUTE_PATH. The latter is for host paths only, while
167 IN_PATHNAME is a target path. For example, if we're supposed to
168 be handling DOS-like semantics we want to consider a
169 'c:/foo/bar.dll' path as an absolute path, even on a Unix box.
170 With such a path, before giving up on the sysroot, we'll try:
172 1st attempt, c:/foo/bar.dll ==> /sysroot/c:/foo/bar.dll
173 2nd attempt, c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll
174 3rd attempt, c:/foo/bar.dll ==> /sysroot/foo/bar.dll
177 if (!IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
) || sysroot
== NULL
)
178 temp_pathname
.reset (xstrdup (in_pathname
));
181 bool need_dir_separator
;
183 /* Concatenate the sysroot and the target reported filename. We
184 may need to glue them with a directory separator. Cases to
187 | sysroot | separator | in_pathname |
188 |-----------------+-----------+----------------|
189 | /some/dir | / | c:/foo/bar.dll |
190 | /some/dir | | /foo/bar.dll |
191 | target: | | c:/foo/bar.dll |
192 | target: | | /foo/bar.dll |
193 | target:some/dir | / | c:/foo/bar.dll |
194 | target:some/dir | | /foo/bar.dll |
196 IOW, we don't need to add a separator if IN_PATHNAME already
197 has one, or when the sysroot is exactly "target:".
198 There's no need to check for drive spec explicitly, as we only
199 get here if IN_PATHNAME is considered an absolute path. */
200 need_dir_separator
= !(IS_DIR_SEPARATOR (in_pathname
[0])
201 || strcmp (TARGET_SYSROOT_PREFIX
, sysroot
) == 0);
203 /* Cat the prefixed pathname together. */
204 temp_pathname
.reset (concat (sysroot
,
205 need_dir_separator
? SLASH_STRING
: "",
206 in_pathname
, (char *) NULL
));
209 /* Handle files to be accessed via the target. */
210 if (is_target_filename (temp_pathname
.get ()))
214 return temp_pathname
;
217 /* Now see if we can open it. */
218 found_file
= gdb_open_cloexec (temp_pathname
.get (),
219 O_RDONLY
| O_BINARY
, 0).release ();
221 /* If the search in gdb_sysroot failed, and the path name has a
222 drive spec (e.g, c:/foo), try stripping ':' from the drive spec,
223 and retrying in the sysroot:
224 c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll. */
228 && HAS_TARGET_DRIVE_SPEC (fskind
, in_pathname
))
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 (),
240 O_RDONLY
| O_BINARY
, 0).release ();
243 /* If the search in gdb_sysroot still failed, try fully
244 stripping the drive spec, and trying once more in the
245 sysroot before giving up.
247 c:/foo/bar.dll ==> /sysroot/foo/bar.dll. */
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 (),
254 O_RDONLY
| O_BINARY
, 0).release ();
258 /* We try to find the library in various ways. After each attempt,
259 either found_file >= 0 and temp_pathname is a malloc'd string, or
260 found_file < 0 and temp_pathname does not point to storage that
261 needs to be freed. */
264 temp_pathname
.reset (NULL
);
266 /* If the search in gdb_sysroot failed, and the path name is
267 absolute at this point, make it relative. (openp will try and open the
268 file according to its absolute path otherwise, which is not what we want.)
269 Affects subsequent searches for this solib. */
270 if (found_file
< 0 && IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
))
272 /* First, get rid of any drive letters etc. */
273 while (!IS_TARGET_DIR_SEPARATOR (fskind
, *in_pathname
))
276 /* Next, get rid of all leading dir separators. */
277 while (IS_TARGET_DIR_SEPARATOR (fskind
, *in_pathname
))
281 /* If not found, and we're looking for a solib, search the
282 solib_search_path (if any). */
283 if (is_solib
&& found_file
< 0 && !solib_search_path
.empty ())
284 found_file
= openp (solib_search_path
.c_str (),
285 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
286 in_pathname
, O_RDONLY
| O_BINARY
, &temp_pathname
);
288 /* If not found, and we're looking for a solib, next search the
289 solib_search_path (if any) for the basename only (ignoring the
290 path). This is to allow reading solibs from a path that differs
291 from the opened path. */
292 if (is_solib
&& found_file
< 0 && !solib_search_path
.empty ())
293 found_file
= openp (solib_search_path
.c_str (),
294 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
295 target_lbasename (fskind
, in_pathname
),
296 O_RDONLY
| O_BINARY
, &temp_pathname
);
298 /* If not found, and we're looking for a solib, try to use target
299 supplied solib search method. */
300 if (is_solib
&& found_file
< 0 && ops
->find_and_open_solib
)
301 found_file
= ops
->find_and_open_solib (in_pathname
, O_RDONLY
| O_BINARY
,
304 /* If not found, next search the inferior's $PATH environment variable. */
305 if (found_file
< 0 && sysroot
== NULL
)
306 found_file
= openp (current_inferior ()->environment
.get ("PATH"),
307 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
, in_pathname
,
308 O_RDONLY
| O_BINARY
, &temp_pathname
);
310 /* If not found, and we're looking for a solib, next search the
311 inferior's $LD_LIBRARY_PATH environment variable. */
312 if (is_solib
&& found_file
< 0 && sysroot
== NULL
)
313 found_file
= openp (current_inferior ()->environment
.get
315 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
, in_pathname
,
316 O_RDONLY
| O_BINARY
, &temp_pathname
);
326 return temp_pathname
;
329 /* Return the full pathname of the main executable, or NULL if not
330 found. If FD is non-NULL, *FD is set to either -1 or an open file
331 handle for the main executable. */
333 gdb::unique_xmalloc_ptr
<char>
334 exec_file_find (const char *in_pathname
, int *fd
)
336 gdb::unique_xmalloc_ptr
<char> result
;
337 const char *fskind
= effective_target_file_system_kind ();
339 if (in_pathname
== NULL
)
342 if (!gdb_sysroot
.empty () && IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
))
344 result
= solib_find_1 (in_pathname
, fd
, false);
346 if (result
== NULL
&& fskind
== file_system_kind_dos_based
)
350 new_pathname
= (char *) alloca (strlen (in_pathname
) + 5);
351 strcpy (new_pathname
, in_pathname
);
352 strcat (new_pathname
, ".exe");
354 result
= solib_find_1 (new_pathname
, fd
, false);
359 /* It's possible we don't have a full path, but rather just a
360 filename. Some targets, such as HP-UX, don't provide the
363 Attempt to qualify the filename against the source path.
364 (If that fails, we'll just fall back on the original
365 filename. Not much more we can do...) */
367 if (!source_full_path_of (in_pathname
, &result
))
368 result
.reset (xstrdup (in_pathname
));
376 /* Return the full pathname of a shared library file, or NULL if not
377 found. If FD is non-NULL, *FD is set to either -1 or an open file
378 handle for the shared library.
380 The search algorithm used is described in solib_find_1's comment
383 gdb::unique_xmalloc_ptr
<char>
384 solib_find (const char *in_pathname
, int *fd
)
386 const char *solib_symbols_extension
387 = gdbarch_solib_symbols_extension (current_inferior ()->arch ());
389 /* If solib_symbols_extension is set, replace the file's
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
;
413 return solib_find_1 (in_pathname
, fd
, true);
416 /* Open and return a BFD for the shared library PATHNAME. If FD is not -1,
417 it is used as file handle to open the file. Throws an error if the file
418 could not be opened. Handles both local and remote file access.
420 If unsuccessful, the FD will be closed (unless FD was -1). */
423 solib_bfd_fopen (const char *pathname
, int fd
)
425 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (pathname
, gnutarget
, fd
));
429 /* Arrange to free PATHNAME when the error is thrown. */
430 error (_("Could not open `%s' as an executable file: %s"),
431 pathname
, bfd_errmsg (bfd_get_error ()));
437 /* Find shared library PATHNAME and open a BFD for it. */
440 solib_bfd_open (const char *pathname
)
443 const struct bfd_arch_info
*b
;
445 /* Search for shared library file. */
446 gdb::unique_xmalloc_ptr
<char> found_pathname
447 = solib_find (pathname
, &found_file
);
448 if (found_pathname
== NULL
)
450 /* Return failure if the file could not be found, so that we can
451 accumulate messages about missing libraries. */
455 perror_with_name (pathname
);
458 /* Open bfd for shared library. */
459 gdb_bfd_ref_ptr
abfd (solib_bfd_fopen (found_pathname
.get (), found_file
));
461 /* Check bfd format. */
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 ()));
466 /* Check bfd arch. */
467 b
= gdbarch_bfd_arch_info (current_inferior ()->arch ());
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
,
477 /* Mapping of a core file's shared library sonames to their respective
478 build-ids. Added to the registries of core file bfds. */
480 typedef std::unordered_map
<std::string
, std::string
> soname_build_id_map
;
482 /* Key used to associate a soname_build_id_map to a core file bfd. */
484 static const struct registry
<bfd
>::key
<soname_build_id_map
>
485 cbfd_soname_build_id_data_key
;
490 set_cbfd_soname_build_id (gdb_bfd_ref_ptr abfd
,
492 const bfd_build_id
*build_id
)
494 gdb_assert (abfd
.get () != nullptr);
495 gdb_assert (soname
!= nullptr);
496 gdb_assert (build_id
!= nullptr);
498 soname_build_id_map
*mapptr
= cbfd_soname_build_id_data_key
.get (abfd
.get ());
500 if (mapptr
== nullptr)
501 mapptr
= cbfd_soname_build_id_data_key
.emplace (abfd
.get ());
503 (*mapptr
)[soname
] = build_id_to_string (build_id
);
506 /* If SONAME had a build-id associated with it in ABFD's registry by a
507 previous call to set_cbfd_soname_build_id then return the build-id
508 as a NULL-terminated hex string. */
510 static gdb::unique_xmalloc_ptr
<char>
511 get_cbfd_soname_build_id (gdb_bfd_ref_ptr abfd
, const char *soname
)
513 if (abfd
.get () == nullptr || soname
== nullptr)
516 soname_build_id_map
*mapptr
517 = cbfd_soname_build_id_data_key
.get (abfd
.get ());
519 if (mapptr
== nullptr)
522 auto it
= mapptr
->find (lbasename (soname
));
523 if (it
== mapptr
->end ())
526 return make_unique_xstrdup (it
->second
.c_str ());
529 /* Given a pointer to one of the shared objects in our list of mapped
530 objects, use the recorded name to open a bfd descriptor for the
531 object, build a section table, relocate all the section addresses
532 by the base address at which the shared object was mapped, and then
533 add the sections to the target's section table.
535 FIXME: In most (all?) cases the shared object file name recorded in
536 the dynamic linkage tables will be a fully qualified pathname. For
537 cases where it isn't, do we really mimic the systems search
538 mechanism correctly in the below code (particularly the tilde
539 expansion stuff?). */
542 solib_map_sections (shobj
&so
)
544 const target_so_ops
*ops
= gdbarch_so_ops (current_inferior ()->arch ());
546 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (so
.so_name
.c_str ()));
547 gdb_bfd_ref_ptr
abfd (ops
->bfd_open (filename
.get ()));
548 gdb::unique_xmalloc_ptr
<char> build_id_hexstr
549 = get_cbfd_soname_build_id (current_program_space
->cbfd
,
550 so
.so_name
.c_str ());
552 /* If we already know the build-id of this solib from a core file, verify
553 it matches ABFD's build-id. If there is a mismatch or the solib wasn't
554 found, attempt to query debuginfod for the correct solib. */
555 if (build_id_hexstr
.get () != nullptr)
557 bool mismatch
= false;
559 if (abfd
!= nullptr && abfd
->build_id
!= nullptr)
561 std::string build_id
= build_id_to_string (abfd
->build_id
);
563 if (build_id
!= build_id_hexstr
.get ())
566 if (abfd
== nullptr || mismatch
)
568 scoped_fd fd
= debuginfod_exec_query ((const unsigned char*)
569 build_id_hexstr
.get (),
570 0, so
.so_name
.c_str (),
574 abfd
= ops
->bfd_open (filename
.get ());
576 warning (_("Build-id of %ps does not match core file."),
577 styled_string (file_name_style
.style (), filename
.get ()));
584 /* Leave bfd open, core_xfer_memory and "info files" need it. */
585 so
.abfd
= std::move (abfd
);
587 /* Copy the full path name into so_name, allowing symbol_file_add
588 to find it later. This also affects the =library-loaded GDB/MI
589 event, and in particular the part of that notification providing
590 the library's host-side path. If we let the target dictate
591 that objfile's path, and the target is different from the host,
592 GDB/MI will not provide the correct host-side path. */
593 if (strlen (bfd_get_filename (so
.abfd
.get ())) >= SO_NAME_MAX_PATH_SIZE
)
594 error (_("Shared library file name is too long."));
596 so
.so_name
= bfd_get_filename (so
.abfd
.get ());
597 so
.sections
= build_section_table (so
.abfd
.get ());
599 for (target_section
&p
: so
.sections
)
601 /* Relocate the section binding addresses as recorded in the shared
602 object's file by the base address to which the object was actually
604 ops
->relocate_section_addresses (so
, &p
);
606 /* If the target didn't provide information about the address
607 range of the shared object, assume we want the location of
608 the .text section. */
609 if (so
.addr_low
== 0 && so
.addr_high
== 0
610 && strcmp (p
.the_bfd_section
->name
, ".text") == 0)
612 so
.addr_low
= p
.addr
;
613 so
.addr_high
= p
.endaddr
;
617 /* Add the shared object's sections to the current set of file
618 section tables. Do this immediately after mapping the object so
619 that later nodes in the list can query this object, as is needed
621 current_program_space
->add_target_sections (&so
, so
.sections
);
631 const target_so_ops
*ops
= gdbarch_so_ops (current_inferior ()->arch ());
633 this->sections
.clear ();
634 this->abfd
= nullptr;
636 /* Our caller closed the objfile, possibly via objfile_purge_solibs. */
637 this->symbols_loaded
= 0;
638 this->objfile
= nullptr;
640 this->addr_low
= this->addr_high
= 0;
642 /* Restore the target-supplied file name. SO_NAME may be the path
643 of the symbol file. */
644 this->so_name
= this->so_original_name
;
646 /* Do the same for target-specific data. */
647 if (ops
->clear_so
!= NULL
)
648 ops
->clear_so (*this);
651 lm_info::~lm_info () = default;
653 /* Read in symbols for shared object SO. If SYMFILE_VERBOSE is set in FLAGS,
654 be chatty about it. Return true if any symbols were actually loaded. */
657 solib_read_symbols (shobj
&so
, symfile_add_flags flags
)
659 if (so
.symbols_loaded
)
661 /* If needed, we've already warned in our caller. */
663 else if (so
.abfd
== NULL
)
665 /* We've already warned about this library, when trying to open
671 flags
|= current_inferior ()->symfile_flags
;
675 /* Have we already loaded this shared object? */
676 so
.objfile
= nullptr;
677 for (objfile
*objfile
: current_program_space
->objfiles ())
679 if (filename_cmp (objfile_name (objfile
),
680 so
.so_name
.c_str ()) == 0
681 && objfile
->addr_low
== so
.addr_low
)
683 so
.objfile
= objfile
;
687 if (so
.objfile
== NULL
)
689 section_addr_info sap
690 = build_section_addr_info_from_section_table (so
.sections
);
691 gdb_bfd_ref_ptr tmp_bfd
= so
.abfd
;
692 so
.objfile
= symbol_file_add_from_bfd (tmp_bfd
,
695 OBJF_SHARED
, nullptr);
696 so
.objfile
->addr_low
= so
.addr_low
;
699 so
.symbols_loaded
= 1;
701 catch (const gdb_exception_error
&e
)
703 exception_fprintf (gdb_stderr
, e
, _("Error while reading shared"
704 " library symbols for %s:\n"),
705 so
.so_name
.c_str ());
714 /* Return true if KNOWN->objfile is used by any other so_list object
715 in the list of shared libraries. Return false otherwise. */
718 solib_used (const shobj
&known
)
720 for (const shobj
&pivot
: current_program_space
->solibs ())
721 if (&pivot
!= &known
&& pivot
.objfile
== known
.objfile
)
726 /* Notify interpreters and observers that solib SO has been loaded. */
729 notify_solib_loaded (shobj
&so
)
731 interps_notify_solib_loaded (so
);
732 gdb::observers::solib_loaded
.notify (so
);
735 /* Notify interpreters and observers that solib SO has been unloaded. */
738 notify_solib_unloaded (program_space
*pspace
, const shobj
&so
)
740 interps_notify_solib_unloaded (so
);
741 gdb::observers::solib_unloaded
.notify (pspace
, so
);
747 update_solib_list (int from_tty
)
749 const target_so_ops
*ops
= gdbarch_so_ops (current_inferior ()->arch ());
751 /* We can reach here due to changing solib-search-path or the
752 sysroot, before having any inferior. */
753 if (target_has_execution () && inferior_ptid
!= null_ptid
)
755 struct inferior
*inf
= current_inferior ();
757 /* If we are attaching to a running process for which we
758 have not opened a symbol file, we may be able to get its
761 && current_program_space
->symfile_object_file
== NULL
)
765 ops
->open_symbol_file_object (from_tty
);
767 catch (const gdb_exception_error
&ex
)
769 exception_fprintf (gdb_stderr
, ex
,
770 "Error reading attached "
771 "process's symbol file.\n");
776 /* GDB and the inferior's dynamic linker each maintain their own
777 list of currently loaded shared objects; we want to bring the
778 former in sync with the latter. Scan both lists, seeing which
779 shared objects appear where. There are three cases:
781 - A shared object appears on both lists. This means that GDB
782 knows about it already, and it's still loaded in the inferior.
783 Nothing needs to happen.
785 - A shared object appears only on GDB's list. This means that
786 the inferior has unloaded it. We should remove the shared
787 object from GDB's tables.
789 - A shared object appears only on the inferior's list. This
790 means that it's just been loaded. We should add it to GDB's
793 So we walk GDB's list, checking each entry to see if it appears
794 in the inferior's list too. If it does, no action is needed, and
795 we remove it from the inferior's list. If it doesn't, the
796 inferior has unloaded it, and we remove it from GDB's list. By
797 the time we're done walking GDB's list, the inferior's list
798 contains only the new shared objects, which we then add. */
800 intrusive_list
<shobj
> inferior
= ops
->current_sos ();
801 intrusive_list
<shobj
>::iterator gdb_iter
802 = current_program_space
->so_list
.begin ();
803 while (gdb_iter
!= current_program_space
->so_list
.end ())
805 intrusive_list
<shobj
>::iterator inferior_iter
= inferior
.begin ();
807 /* Check to see whether the shared object *gdb also appears in
808 the inferior's current list. */
809 for (; inferior_iter
!= inferior
.end (); ++inferior_iter
)
813 if (ops
->same (*gdb_iter
, *inferior_iter
))
818 if (!filename_cmp (gdb_iter
->so_original_name
.c_str (),
819 inferior_iter
->so_original_name
.c_str ()))
824 /* If the shared object appears on the inferior's list too, then
825 it's still loaded, so we don't need to do anything. Delete
826 it from the inferior's list, and leave it on GDB's list. */
827 if (inferior_iter
!= inferior
.end ())
829 inferior
.erase (inferior_iter
);
830 delete &*inferior_iter
;
834 /* If it's not on the inferior's list, remove it from GDB's tables. */
837 /* Notify any observer that the shared object has been
838 unloaded before we remove it from GDB's tables. */
839 notify_solib_unloaded (current_program_space
, *gdb_iter
);
841 current_program_space
->deleted_solibs
.push_back (gdb_iter
->so_name
);
843 intrusive_list
<shobj
>::iterator gdb_iter_next
844 = current_program_space
->so_list
.erase (gdb_iter
);
846 /* Unless the user loaded it explicitly, free SO's objfile. */
847 if (gdb_iter
->objfile
!= nullptr
848 && !(gdb_iter
->objfile
->flags
& OBJF_USERLOADED
)
849 && !solib_used (*gdb_iter
))
850 gdb_iter
->objfile
->unlink ();
852 /* Some targets' section tables might be referring to
853 sections from so.abfd; remove them. */
854 current_program_space
->remove_target_sections (&*gdb_iter
);
857 gdb_iter
= gdb_iter_next
;
861 /* Now the inferior's list contains only shared objects that don't
862 appear in GDB's list --- those that are newly loaded. Add them
863 to GDB's shared object list. */
864 if (!inferior
.empty ())
867 const char *not_found_filename
= NULL
;
869 /* Fill in the rest of each of the `so' nodes. */
870 for (shobj
&new_so
: inferior
)
872 current_program_space
->added_solibs
.push_back (&new_so
);
876 /* Fill in the rest of the `struct shobj' node. */
877 if (!solib_map_sections (new_so
))
880 if (not_found_filename
== NULL
)
881 not_found_filename
= new_so
.so_original_name
.c_str ();
885 catch (const gdb_exception_error
&e
)
887 exception_fprintf (gdb_stderr
, e
,
888 _("Error while mapping shared "
889 "library sections:\n"));
892 /* Notify any observer that the shared object has been
893 loaded now that we've added it to GDB's tables. */
894 notify_solib_loaded (new_so
);
897 /* Add the new shared objects to GDB's list. */
898 current_program_space
->so_list
.splice (std::move (inferior
));
900 /* If a library was not found, issue an appropriate warning
901 message. We have to use a single call to warning in case the
902 front end does something special with warnings, e.g., pop up
903 a dialog box. It Would Be Nice if we could get a "warning: "
904 prefix on each line in the CLI front end, though - it doesn't
908 warning (_("Could not load shared library symbols for %s.\n"
909 "Do you need \"set solib-search-path\" "
910 "or \"set sysroot\"?"),
912 else if (not_found
> 1)
914 Could not load shared library symbols for %d libraries, e.g. %s.\n\
915 Use the \"info sharedlibrary\" command to see the complete listing.\n\
916 Do you need \"set solib-search-path\" or \"set sysroot\"?"),
917 not_found
, not_found_filename
);
922 /* Return non-zero if NAME is the libpthread shared library.
924 Uses a fairly simplistic heuristic approach where we check
925 the file name against "/libpthread". This can lead to false
926 positives, but this should be good enough in practice.
928 As of glibc-2.34, functions formerly residing in libpthread have
929 been moved to libc, so "/libc." needs to be checked too. (Matching
930 the "." will avoid matching libraries such as libcrypt.) */
933 libpthread_name_p (const char *name
)
935 return (strstr (name
, "/libpthread") != NULL
936 || strstr (name
, "/libc.") != NULL
);
939 /* Return non-zero if SO is the libpthread shared library. */
942 libpthread_solib_p (const shobj
&so
)
944 return libpthread_name_p (so
.so_name
.c_str ());
947 /* Read in symbolic information for any shared objects whose names
948 match PATTERN. (If we've already read a shared object's symbol
949 info, leave it alone.) If PATTERN is zero, read them all.
951 If READSYMS is 0, defer reading symbolic information until later
952 but still do any needed low level processing.
954 FROM_TTY is described for update_solib_list, above. */
957 solib_add (const char *pattern
, int from_tty
, int readsyms
)
959 if (print_symbol_loading_p (from_tty
, 0, 0))
963 gdb_printf (_("Loading symbols for shared libraries: %s\n"),
967 gdb_printf (_("Loading symbols for shared libraries.\n"));
970 current_program_space
->solib_add_generation
++;
974 char *re_err
= re_comp (pattern
);
977 error (_("Invalid regexp: %s"), re_err
);
980 update_solib_list (from_tty
);
982 /* Walk the list of currently loaded shared libraries, and read
983 symbols for any that match the pattern --- or any whose symbols
984 aren't already loaded, if no pattern was given. */
986 bool any_matches
= false;
987 bool loaded_any_symbols
= false;
988 symfile_add_flags add_flags
= SYMFILE_DEFER_BP_RESET
;
991 add_flags
|= SYMFILE_VERBOSE
;
993 for (shobj
&gdb
: current_program_space
->solibs ())
994 if (! pattern
|| re_exec (gdb
.so_name
.c_str ()))
996 /* Normally, we would read the symbols from that library
997 only if READSYMS is set. However, we're making a small
998 exception for the pthread library, because we sometimes
999 need the library symbols to be loaded in order to provide
1000 thread support (x86-linux for instance). */
1001 const int add_this_solib
=
1002 (readsyms
|| libpthread_solib_p (gdb
));
1007 if (gdb
.symbols_loaded
)
1009 /* If no pattern was given, be quiet for shared
1010 libraries we have already loaded. */
1011 if (pattern
&& (from_tty
|| info_verbose
))
1012 gdb_printf (_("Symbols already loaded for %s\n"),
1013 gdb
.so_name
.c_str ());
1015 else if (solib_read_symbols (gdb
, add_flags
))
1016 loaded_any_symbols
= true;
1020 if (loaded_any_symbols
)
1021 breakpoint_re_set ();
1023 if (from_tty
&& pattern
&& ! any_matches
)
1025 ("No loaded shared libraries match the pattern `%s'.\n", pattern
);
1027 if (loaded_any_symbols
)
1029 /* Getting new symbols may change our opinion about what is
1031 reinit_frame_cache ();
1036 /* Implement the "info sharedlibrary" command. Walk through the
1037 shared library list and print information about each attached
1038 library matching PATTERN. If PATTERN is elided, print them
1042 info_sharedlibrary_command (const char *pattern
, int from_tty
)
1044 bool so_missing_debug_info
= false;
1047 gdbarch
*gdbarch
= current_inferior ()->arch ();
1048 struct ui_out
*uiout
= current_uiout
;
1052 char *re_err
= re_comp (pattern
);
1055 error (_("Invalid regexp: %s"), re_err
);
1058 /* "0x", a little whitespace, and two hex digits per byte of pointers. */
1059 addr_width
= 4 + (gdbarch_ptr_bit (gdbarch
) / 4);
1061 update_solib_list (from_tty
);
1063 /* ui_out_emit_table table_emitter needs to know the number of rows,
1064 so we need to make two passes over the libs. */
1067 for (const shobj
&so
: current_program_space
->solibs ())
1069 if (!so
.so_name
.empty ())
1071 if (pattern
&& ! re_exec (so
.so_name
.c_str ()))
1078 ui_out_emit_table
table_emitter (uiout
, 4, nr_libs
, "SharedLibraryTable");
1080 /* The "- 1" is because ui_out adds one space between columns. */
1081 uiout
->table_header (addr_width
- 1, ui_left
, "from", "From");
1082 uiout
->table_header (addr_width
- 1, ui_left
, "to", "To");
1083 uiout
->table_header (12 - 1, ui_left
, "syms-read", "Syms Read");
1084 uiout
->table_header (0, ui_noalign
, "name", "Shared Object Library");
1086 uiout
->table_body ();
1088 for (const shobj
&so
: current_program_space
->solibs ())
1090 if (so
.so_name
.empty ())
1093 if (pattern
&& ! re_exec (so
.so_name
.c_str ()))
1096 ui_out_emit_tuple
tuple_emitter (uiout
, "lib");
1098 if (so
.addr_high
!= 0)
1100 uiout
->field_core_addr ("from", gdbarch
, so
.addr_low
);
1101 uiout
->field_core_addr ("to", gdbarch
, so
.addr_high
);
1105 uiout
->field_skip ("from");
1106 uiout
->field_skip ("to");
1109 if (! top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ()
1110 && so
.symbols_loaded
1111 && !objfile_has_symbols (so
.objfile
))
1113 so_missing_debug_info
= true;
1114 uiout
->field_string ("syms-read", "Yes (*)");
1117 uiout
->field_string ("syms-read", so
.symbols_loaded
? "Yes" : "No");
1119 uiout
->field_string ("name", so
.so_name
, file_name_style
.style ());
1128 uiout
->message (_("No shared libraries matched.\n"));
1130 uiout
->message (_("No shared libraries loaded at this time.\n"));
1134 if (so_missing_debug_info
)
1135 uiout
->message (_("(*): Shared library is missing "
1136 "debugging information.\n"));
1143 solib_contains_address_p (const shobj
&solib
, CORE_ADDR address
)
1145 for (const target_section
&p
: solib
.sections
)
1146 if (p
.addr
<= address
&& address
< p
.endaddr
)
1152 /* If ADDRESS is in a shared lib in program space PSPACE, return its
1155 Provides a hook for other gdb routines to discover whether or not a
1156 particular address is within the mapped address space of a shared
1159 For example, this routine is called at one point to disable
1160 breakpoints which are in shared libraries that are not currently
1164 solib_name_from_address (struct program_space
*pspace
, CORE_ADDR address
)
1166 for (const shobj
&so
: pspace
->so_list
)
1167 if (solib_contains_address_p (so
, address
))
1168 return so
.so_name
.c_str ();
1176 solib_keep_data_in_core (CORE_ADDR vaddr
, unsigned long size
)
1178 const target_so_ops
*ops
= gdbarch_so_ops (current_inferior ()->arch ());
1180 if (ops
->keep_data_in_core
)
1181 return ops
->keep_data_in_core (vaddr
, size
) != 0;
1186 /* Called by free_all_symtabs */
1191 const target_so_ops
*ops
= gdbarch_so_ops (current_inferior ()->arch ());
1193 disable_breakpoints_in_shlibs ();
1195 current_program_space
->so_list
.clear_and_dispose ([] (shobj
*so
)
1197 notify_solib_unloaded (current_program_space
, *so
);
1198 current_program_space
->remove_target_sections (so
);
1203 if (ops
->clear_solib
!= nullptr)
1204 ops
->clear_solib (current_program_space
);
1207 /* Shared library startup support. When GDB starts up the inferior,
1208 it nurses it along (through the shell) until it is ready to execute
1209 its first instruction. At this point, this function gets
1213 solib_create_inferior_hook (int from_tty
)
1215 const target_so_ops
*ops
= gdbarch_so_ops (current_inferior ()->arch ());
1217 ops
->solib_create_inferior_hook (from_tty
);
1223 in_solib_dynsym_resolve_code (CORE_ADDR pc
)
1225 const target_so_ops
*ops
= gdbarch_so_ops (current_inferior ()->arch ());
1227 return ops
->in_dynsym_resolve_code (pc
) != 0;
1230 /* Implements the "sharedlibrary" command. */
1233 sharedlibrary_command (const char *args
, int from_tty
)
1236 solib_add (args
, from_tty
, 1);
1239 /* Implements the command "nosharedlibrary", which discards symbols
1240 that have been auto-loaded from shared libraries. Symbols from
1241 shared libraries that were added by explicit request of the user
1242 are not discarded. Also called from remote.c. */
1245 no_shared_libraries (const char *ignored
, int from_tty
)
1247 /* The order of the two routines below is important: clear_solib notifies
1248 the solib_unloaded observers, and some of these observers might need
1249 access to their associated objfiles. Therefore, we can not purge the
1250 solibs' objfiles before clear_solib has been called. */
1253 objfile_purge_solibs ();
1259 update_solib_breakpoints (void)
1261 const target_so_ops
*ops
= gdbarch_so_ops (current_inferior ()->arch ());
1263 if (ops
->update_breakpoints
!= NULL
)
1264 ops
->update_breakpoints ();
1270 handle_solib_event (void)
1272 const target_so_ops
*ops
= gdbarch_so_ops (current_inferior ()->arch ());
1274 if (ops
->handle_event
!= NULL
)
1275 ops
->handle_event ();
1277 current_inferior ()->pspace
->clear_solib_cache ();
1279 /* Check for any newly added shared libraries if we're supposed to
1280 be adding them automatically. Switch terminal for any messages
1281 produced by breakpoint_re_set. */
1282 target_terminal::ours_for_output ();
1283 solib_add (NULL
, 0, auto_solib_add
);
1284 target_terminal::inferior ();
1287 /* Reload shared libraries, but avoid reloading the same symbol file
1288 we already have loaded. */
1291 reload_shared_libraries_1 (int from_tty
)
1293 if (print_symbol_loading_p (from_tty
, 0, 0))
1294 gdb_printf (_("Loading symbols for shared libraries.\n"));
1296 for (shobj
&so
: current_program_space
->solibs ())
1298 const char *found_pathname
= NULL
;
1299 bool was_loaded
= so
.symbols_loaded
!= 0;
1300 symfile_add_flags add_flags
= SYMFILE_DEFER_BP_RESET
;
1303 add_flags
|= SYMFILE_VERBOSE
;
1305 gdb::unique_xmalloc_ptr
<char> filename
1306 (tilde_expand (so
.so_original_name
.c_str ()));
1307 gdb_bfd_ref_ptr
abfd (solib_bfd_open (filename
.get ()));
1309 found_pathname
= bfd_get_filename (abfd
.get ());
1311 /* If this shared library is no longer associated with its previous
1312 symbol file, close that. */
1313 if ((found_pathname
== NULL
&& was_loaded
)
1314 || (found_pathname
!= NULL
1315 && filename_cmp (found_pathname
, so
.so_name
.c_str ()) != 0))
1317 if (so
.objfile
&& ! (so
.objfile
->flags
& OBJF_USERLOADED
)
1318 && !solib_used (so
))
1319 so
.objfile
->unlink ();
1320 current_program_space
->remove_target_sections (&so
);
1324 /* If this shared library is now associated with a new symbol
1326 if (found_pathname
!= NULL
1328 || filename_cmp (found_pathname
, so
.so_name
.c_str ()) != 0))
1330 bool got_error
= false;
1334 solib_map_sections (so
);
1337 catch (const gdb_exception_error
&e
)
1339 exception_fprintf (gdb_stderr
, e
,
1340 _("Error while mapping "
1341 "shared library sections:\n"));
1346 && (auto_solib_add
|| was_loaded
|| libpthread_solib_p (so
)))
1347 solib_read_symbols (so
, add_flags
);
1353 reload_shared_libraries (const char *ignored
, int from_tty
,
1354 struct cmd_list_element
*e
)
1356 reload_shared_libraries_1 (from_tty
);
1358 const target_so_ops
*ops
= gdbarch_so_ops (current_inferior ()->arch ());
1360 /* Creating inferior hooks here has two purposes. First, if we reload
1361 shared libraries then the address of solib breakpoint we've computed
1362 previously might be no longer valid. For example, if we forgot to set
1363 solib-absolute-prefix and are setting it right now, then the previous
1364 breakpoint address is plain wrong. Second, installing solib hooks
1365 also implicitly figures were ld.so is and loads symbols for it.
1366 Absent this call, if we've just connected to a target and set
1367 solib-absolute-prefix or solib-search-path, we'll lose all information
1369 if (target_has_execution ())
1371 /* Reset or free private data structures not associated with
1373 if (ops
->clear_solib
!= nullptr)
1374 ops
->clear_solib (current_program_space
);
1376 /* Remove any previous solib event breakpoint. This is usually
1377 done in common code, at breakpoint_init_inferior time, but
1378 we're not really starting up the inferior here. */
1379 remove_solib_event_breakpoints ();
1381 solib_create_inferior_hook (from_tty
);
1384 /* Sometimes the platform-specific hook loads initial shared
1385 libraries, and sometimes it doesn't. If it doesn't FROM_TTY will be
1386 incorrectly 0 but such solib targets should be fixed anyway. If we
1387 made all the inferior hook methods consistent, this call could be
1388 removed. Call it only after the solib target has been initialized by
1389 solib_create_inferior_hook. */
1391 solib_add (NULL
, 0, auto_solib_add
);
1393 breakpoint_re_set ();
1395 /* We may have loaded or unloaded debug info for some (or all)
1396 shared libraries. However, frames may still reference them. For
1397 example, a frame's unwinder might still point at DWARF FDE
1398 structures that are now freed. Also, getting new symbols may
1399 change our opinion about what is frameless. */
1400 reinit_frame_cache ();
1403 /* Wrapper for reload_shared_libraries that replaces "remote:"
1404 at the start of gdb_sysroot with "target:". */
1407 gdb_sysroot_changed (const char *ignored
, int from_tty
,
1408 struct cmd_list_element
*e
)
1410 const char *old_prefix
= "remote:";
1411 const char *new_prefix
= TARGET_SYSROOT_PREFIX
;
1413 if (startswith (gdb_sysroot
.c_str (), old_prefix
))
1415 static bool warning_issued
= false;
1417 gdb_assert (strlen (old_prefix
) == strlen (new_prefix
));
1418 gdb_sysroot
= new_prefix
+ gdb_sysroot
.substr (strlen (old_prefix
));
1420 if (!warning_issued
)
1422 warning (_("\"%s\" is deprecated, use \"%s\" instead."),
1423 old_prefix
, new_prefix
);
1424 warning (_("sysroot set to \"%s\"."), gdb_sysroot
.c_str ());
1426 warning_issued
= true;
1430 reload_shared_libraries (ignored
, from_tty
, e
);
1434 show_auto_solib_add (struct ui_file
*file
, int from_tty
,
1435 struct cmd_list_element
*c
, const char *value
)
1437 gdb_printf (file
, _("Autoloading of shared library symbols is %s.\n"),
1442 /* Lookup the value for a specific symbol from dynamic symbol table. Look
1443 up symbol from ABFD. MATCH_SYM is a callback function to determine
1444 whether to pick up a symbol. DATA is the input of this callback
1445 function. Return 0 if symbol is not found. */
1448 gdb_bfd_lookup_symbol_from_symtab
1449 (bfd
*abfd
, gdb::function_view
<bool (const asymbol
*)> match_sym
)
1451 long storage_needed
= bfd_get_symtab_upper_bound (abfd
);
1452 CORE_ADDR symaddr
= 0;
1454 if (storage_needed
> 0)
1458 gdb::def_vector
<asymbol
*> storage (storage_needed
/ sizeof (asymbol
*));
1459 asymbol
**symbol_table
= storage
.data ();
1460 unsigned int number_of_symbols
=
1461 bfd_canonicalize_symtab (abfd
, symbol_table
);
1463 for (i
= 0; i
< number_of_symbols
; i
++)
1465 asymbol
*sym
= *symbol_table
++;
1467 if (match_sym (sym
))
1469 gdbarch
*gdbarch
= current_inferior ()->arch ();
1470 symaddr
= sym
->value
;
1472 /* Some ELF targets fiddle with addresses of symbols they
1473 consider special. They use minimal symbols to do that
1474 and this is needed for correct breakpoint placement,
1475 but we do not have full data here to build a complete
1476 minimal symbol, so just set the address and let the
1477 targets cope with that. */
1478 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1479 && gdbarch_elf_make_msymbol_special_p (gdbarch
))
1481 struct minimal_symbol msym
{};
1483 msym
.set_value_address (symaddr
);
1484 gdbarch_elf_make_msymbol_special (gdbarch
, sym
, &msym
);
1485 symaddr
= CORE_ADDR (msym
.unrelocated_address ());
1488 /* BFD symbols are section relative. */
1489 symaddr
+= sym
->section
->vma
;
1501 gdb_bfd_scan_elf_dyntag (const int desired_dyntag
, bfd
*abfd
, CORE_ADDR
*ptr
,
1502 CORE_ADDR
*ptr_addr
)
1504 int arch_size
, step
, sect_size
;
1505 long current_dyntag
;
1506 CORE_ADDR dyn_ptr
, dyn_addr
;
1507 gdb_byte
*bufend
, *bufstart
, *buf
;
1508 Elf32_External_Dyn
*x_dynp_32
;
1509 Elf64_External_Dyn
*x_dynp_64
;
1510 struct bfd_section
*sect
;
1515 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
1518 arch_size
= bfd_get_arch_size (abfd
);
1519 if (arch_size
== -1)
1522 /* Find the start address of the .dynamic section. */
1523 sect
= bfd_get_section_by_name (abfd
, ".dynamic");
1528 for (const target_section
&target_section
1529 : current_program_space
->target_sections ())
1530 if (sect
== target_section
.the_bfd_section
)
1532 dyn_addr
= target_section
.addr
;
1538 /* ABFD may come from OBJFILE acting only as a symbol file without being
1539 loaded into the target (see add_symbol_file_command). This case is
1540 such fallback to the file VMA address without the possibility of
1541 having the section relocated to its actual in-memory address. */
1543 dyn_addr
= bfd_section_vma (sect
);
1546 /* Read in .dynamic from the BFD. We will get the actual value
1547 from memory later. */
1548 sect_size
= bfd_section_size (sect
);
1549 buf
= bufstart
= (gdb_byte
*) alloca (sect_size
);
1550 if (!bfd_get_section_contents (abfd
, sect
,
1554 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
1555 step
= (arch_size
== 32) ? sizeof (Elf32_External_Dyn
)
1556 : sizeof (Elf64_External_Dyn
);
1557 for (bufend
= buf
+ sect_size
;
1561 if (arch_size
== 32)
1563 x_dynp_32
= (Elf32_External_Dyn
*) buf
;
1564 current_dyntag
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_tag
);
1565 dyn_ptr
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_un
.d_ptr
);
1569 x_dynp_64
= (Elf64_External_Dyn
*) buf
;
1570 current_dyntag
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_tag
);
1571 dyn_ptr
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_un
.d_ptr
);
1573 if (current_dyntag
== DT_NULL
)
1575 if (current_dyntag
== desired_dyntag
)
1577 /* If requested, try to read the runtime value of this .dynamic
1581 struct type
*ptr_type
;
1582 gdb_byte ptr_buf
[8];
1583 CORE_ADDR ptr_addr_1
;
1586 = builtin_type (current_inferior ()->arch ())->builtin_data_ptr
;
1587 ptr_addr_1
= dyn_addr
+ (buf
- bufstart
) + arch_size
/ 8;
1588 if (target_read_memory (ptr_addr_1
, ptr_buf
, arch_size
/ 8) == 0)
1589 dyn_ptr
= extract_typed_address (ptr_buf
, ptr_type
);
1592 *ptr_addr
= dyn_addr
+ (buf
- bufstart
);
1603 gdb::unique_xmalloc_ptr
<char>
1604 gdb_bfd_read_elf_soname (const char *filename
)
1606 gdb_bfd_ref_ptr abfd
= gdb_bfd_open (filename
, gnutarget
);
1608 if (abfd
== nullptr)
1611 /* Check that ABFD is an ET_DYN ELF file. */
1612 if (!bfd_check_format (abfd
.get (), bfd_object
)
1613 || !(bfd_get_file_flags (abfd
.get ()) & DYNAMIC
))
1617 if (!gdb_bfd_scan_elf_dyntag (DT_SONAME
, abfd
.get (), &idx
, nullptr))
1620 struct bfd_section
*dynstr
= bfd_get_section_by_name (abfd
.get (), ".dynstr");
1621 int sect_size
= bfd_section_size (dynstr
);
1622 if (dynstr
== nullptr || sect_size
<= idx
)
1625 /* Read soname from the string table. */
1626 gdb::byte_vector dynstr_buf
;
1627 if (!gdb_bfd_get_full_section_contents (abfd
.get (), dynstr
, &dynstr_buf
))
1630 /* Ensure soname is null-terminated before returning a copy. */
1631 char *soname
= (char *) dynstr_buf
.data () + idx
;
1632 if (strnlen (soname
, sect_size
- idx
) == sect_size
- idx
)
1635 return make_unique_xstrdup (soname
);
1638 /* Lookup the value for a specific symbol from symbol table. Look up symbol
1639 from ABFD. MATCH_SYM is a callback function to determine whether to pick
1640 up a symbol. DATA is the input of this callback function. Return 0
1641 if symbol is not found. */
1644 bfd_lookup_symbol_from_dyn_symtab
1645 (bfd
*abfd
, gdb::function_view
<bool (const asymbol
*)> match_sym
)
1647 long storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1648 CORE_ADDR symaddr
= 0;
1650 if (storage_needed
> 0)
1653 gdb::def_vector
<asymbol
*> storage (storage_needed
/ sizeof (asymbol
*));
1654 asymbol
**symbol_table
= storage
.data ();
1655 unsigned int number_of_symbols
=
1656 bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
1658 for (i
= 0; i
< number_of_symbols
; i
++)
1660 asymbol
*sym
= *symbol_table
++;
1662 if (match_sym (sym
))
1664 /* BFD symbols are section relative. */
1665 symaddr
= sym
->value
+ sym
->section
->vma
;
1673 /* Lookup the value for a specific symbol from symbol table and dynamic
1674 symbol table. Look up symbol from ABFD. MATCH_SYM is a callback
1675 function to determine whether to pick up a symbol. DATA is the
1676 input of this callback function. Return 0 if symbol is not
1680 gdb_bfd_lookup_symbol
1681 (bfd
*abfd
, gdb::function_view
<bool (const asymbol
*)> match_sym
)
1683 CORE_ADDR symaddr
= gdb_bfd_lookup_symbol_from_symtab (abfd
, match_sym
);
1685 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
1686 have to check the dynamic string table too. */
1688 symaddr
= bfd_lookup_symbol_from_dyn_symtab (abfd
, match_sym
);
1693 /* The shared library list may contain user-loaded object files that
1694 can be removed out-of-band by the user. So upon notification of
1695 free_objfile remove all references to any user-loaded file that is
1696 about to be freed. */
1699 remove_user_added_objfile (struct objfile
*objfile
)
1701 if (objfile
!= 0 && objfile
->flags
& OBJF_USERLOADED
)
1703 for (shobj
&so
: objfile
->pspace
->solibs ())
1704 if (so
.objfile
== objfile
)
1705 so
.objfile
= nullptr;
1709 void _initialize_solib ();
1711 _initialize_solib ()
1713 gdb::observers::free_objfile
.attach (remove_user_added_objfile
,
1715 gdb::observers::inferior_execd
.attach ([] (inferior
*exec_inf
,
1716 inferior
*follow_inf
)
1718 solib_create_inferior_hook (0);
1721 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
1722 _("Load shared object library symbols for files matching REGEXP."));
1723 cmd_list_element
*info_sharedlibrary_cmd
1724 = add_info ("sharedlibrary", info_sharedlibrary_command
,
1725 _("Status of loaded shared object libraries."));
1726 add_info_alias ("dll", info_sharedlibrary_cmd
, 1);
1727 add_com ("nosharedlibrary", class_files
, no_shared_libraries
,
1728 _("Unload all shared object library symbols."));
1730 add_setshow_boolean_cmd ("auto-solib-add", class_support
,
1731 &auto_solib_add
, _("\
1732 Set autoloading of shared library symbols."), _("\
1733 Show autoloading of shared library symbols."), _("\
1734 If \"on\", symbols from all shared object libraries will be loaded\n\
1735 automatically when the inferior begins execution, when the dynamic linker\n\
1736 informs gdb that a new library has been loaded, or when attaching to the\n\
1737 inferior. Otherwise, symbols must be loaded manually, using \
1740 show_auto_solib_add
,
1741 &setlist
, &showlist
);
1743 set_show_commands sysroot_cmds
1744 = add_setshow_optional_filename_cmd ("sysroot", class_support
,
1746 Set an alternate system root."), _("\
1747 Show the current system root."), _("\
1748 The system root is used to load absolute shared library symbol files.\n\
1749 For other (relative) files, you can add directories using\n\
1750 `set solib-search-path'."),
1751 gdb_sysroot_changed
,
1753 &setlist
, &showlist
);
1755 add_alias_cmd ("solib-absolute-prefix", sysroot_cmds
.set
, class_support
, 0,
1757 add_alias_cmd ("solib-absolute-prefix", sysroot_cmds
.show
, class_support
, 0,
1760 add_setshow_optional_filename_cmd ("solib-search-path", class_support
,
1761 &solib_search_path
, _("\
1762 Set the search path for loading non-absolute shared library symbol files."),
1764 Show the search path for loading non-absolute shared library symbol files."),
1766 This takes precedence over the environment variables \
1767 PATH and LD_LIBRARY_PATH."),
1768 reload_shared_libraries
,
1769 show_solib_search_path
,
1770 &setlist
, &showlist
);
1772 add_setshow_boolean_cmd ("solib", class_maintenance
,
1774 Set solib debugging."), _("\
1775 Show solib debugging."), _("\
1776 When true, solib-related debugging output is enabled."),
1778 &setdebuglist
, &showdebuglist
);