1 /* Handle shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 1990-2022 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/>. */
22 #include <sys/types.h>
33 #include "gdbsupport/gdb_regex.h"
35 #include "gdbsupport/environ.h"
38 #include "completer.h"
39 #include "elf/external.h"
40 #include "elf/common.h"
41 #include "filenames.h" /* for DOSish file names */
44 #include "observable.h"
45 #include "readline/tilde.h"
49 #include "filesystem.h"
51 #include "gdbsupport/filestuff.h"
52 #include "gdbsupport/scoped_fd.h"
53 #include "debuginfod-support.h"
55 #include "cli/cli-style.h"
57 /* Architecture-specific operations. */
59 /* Per-architecture data key. */
60 static const registry
<gdbarch
>::key
<const struct target_so_ops
,
61 gdb::noop_deleter
<const struct target_so_ops
>>
64 static const struct target_so_ops
*
65 solib_ops (struct gdbarch
*gdbarch
)
67 return solib_data
.get (gdbarch
);
70 /* Set the solib operations for GDBARCH to NEW_OPS. */
73 set_solib_ops (struct gdbarch
*gdbarch
, const struct target_so_ops
*new_ops
)
75 solib_data
.set (gdbarch
, new_ops
);
79 /* external data declarations */
81 /* FIXME: gdbarch needs to control this variable, or else every
82 configuration needs to call set_solib_ops. */
83 struct target_so_ops
*current_target_so_ops
;
85 /* Local function prototypes */
87 /* If non-empty, this is a search path for loading non-absolute shared library
88 symbol files. This takes precedence over the environment variables PATH
89 and LD_LIBRARY_PATH. */
90 static std::string solib_search_path
;
92 show_solib_search_path (struct ui_file
*file
, int from_tty
,
93 struct cmd_list_element
*c
, const char *value
)
95 gdb_printf (file
, _("The search path for loading non-absolute "
96 "shared library symbol files is %s.\n"),
100 /* Same as HAVE_DOS_BASED_FILE_SYSTEM, but useable as an rvalue. */
101 #if (HAVE_DOS_BASED_FILE_SYSTEM)
102 # define DOS_BASED_FILE_SYSTEM 1
104 # define DOS_BASED_FILE_SYSTEM 0
107 /* Return the full pathname of a binary file (the main executable or a
108 shared library file), or NULL if not found. If FD is non-NULL, *FD
109 is set to either -1 or an open file handle for the binary file.
111 Global variable GDB_SYSROOT is used as a prefix directory
112 to search for binary files if they have an absolute path.
113 If GDB_SYSROOT starts with "target:" and target filesystem
114 is the local filesystem then the "target:" prefix will be
115 stripped before the search starts. This ensures that the
116 same search algorithm is used for local files regardless of
117 whether a "target:" prefix was used.
119 Global variable SOLIB_SEARCH_PATH is used as a prefix directory
120 (or set of directories, as in LD_LIBRARY_PATH) to search for all
121 shared libraries if not found in either the sysroot (if set) or
122 the local filesystem. SOLIB_SEARCH_PATH is not used when searching
123 for the main executable.
126 * If a sysroot is set and path is absolute:
127 * Search for sysroot/path.
129 * Look for it literally (unmodified).
130 * If IS_SOLIB is non-zero:
131 * Look in SOLIB_SEARCH_PATH.
132 * If available, use target defined search function.
133 * If NO sysroot is set, perform the following two searches:
134 * Look in inferior's $PATH.
135 * If IS_SOLIB is non-zero:
136 * Look in inferior's $LD_LIBRARY_PATH.
138 * The last check avoids doing this search when targeting remote
139 * machines since a sysroot will almost always be set.
142 static gdb::unique_xmalloc_ptr
<char>
143 solib_find_1 (const char *in_pathname
, int *fd
, bool is_solib
)
145 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
147 gdb::unique_xmalloc_ptr
<char> temp_pathname
;
148 const char *fskind
= effective_target_file_system_kind ();
149 const char *sysroot
= gdb_sysroot
.c_str ();
150 int prefix_len
, orig_prefix_len
;
152 /* If the absolute prefix starts with "target:" but the filesystem
153 accessed by the target_fileio_* methods is the local filesystem
154 then we strip the "target:" prefix now and work with the local
155 filesystem. This ensures that the same search algorithm is used
156 for all local files regardless of whether a "target:" prefix was
158 if (is_target_filename (sysroot
) && target_filesystem_is_local ())
159 sysroot
+= strlen (TARGET_SYSROOT_PREFIX
);
161 /* Strip any trailing slashes from the absolute prefix. */
162 prefix_len
= orig_prefix_len
= strlen (sysroot
);
164 while (prefix_len
> 0 && IS_DIR_SEPARATOR (sysroot
[prefix_len
- 1]))
167 std::string sysroot_holder
;
170 else if (prefix_len
!= orig_prefix_len
)
172 sysroot_holder
= std::string (sysroot
, prefix_len
);
173 sysroot
= sysroot_holder
.c_str ();
176 /* If we're on a non-DOS-based system, backslashes won't be
177 understood as directory separator, so, convert them to forward
178 slashes, iff we're supposed to handle DOS-based file system
179 semantics for target paths. */
180 if (!DOS_BASED_FILE_SYSTEM
&& fskind
== file_system_kind_dos_based
)
184 /* Avoid clobbering our input. */
185 p
= (char *) alloca (strlen (in_pathname
) + 1);
186 strcpy (p
, in_pathname
);
196 /* Note, we're interested in IS_TARGET_ABSOLUTE_PATH, not
197 IS_ABSOLUTE_PATH. The latter is for host paths only, while
198 IN_PATHNAME is a target path. For example, if we're supposed to
199 be handling DOS-like semantics we want to consider a
200 'c:/foo/bar.dll' path as an absolute path, even on a Unix box.
201 With such a path, before giving up on the sysroot, we'll try:
203 1st attempt, c:/foo/bar.dll ==> /sysroot/c:/foo/bar.dll
204 2nd attempt, c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll
205 3rd attempt, c:/foo/bar.dll ==> /sysroot/foo/bar.dll
208 if (!IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
) || sysroot
== NULL
)
209 temp_pathname
.reset (xstrdup (in_pathname
));
212 bool need_dir_separator
;
214 /* Concatenate the sysroot and the target reported filename. We
215 may need to glue them with a directory separator. Cases to
218 | sysroot | separator | in_pathname |
219 |-----------------+-----------+----------------|
220 | /some/dir | / | c:/foo/bar.dll |
221 | /some/dir | | /foo/bar.dll |
222 | target: | | c:/foo/bar.dll |
223 | target: | | /foo/bar.dll |
224 | target:some/dir | / | c:/foo/bar.dll |
225 | target:some/dir | | /foo/bar.dll |
227 IOW, we don't need to add a separator if IN_PATHNAME already
228 has one, or when the sysroot is exactly "target:".
229 There's no need to check for drive spec explicitly, as we only
230 get here if IN_PATHNAME is considered an absolute path. */
231 need_dir_separator
= !(IS_DIR_SEPARATOR (in_pathname
[0])
232 || strcmp (TARGET_SYSROOT_PREFIX
, sysroot
) == 0);
234 /* Cat the prefixed pathname together. */
235 temp_pathname
.reset (concat (sysroot
,
236 need_dir_separator
? SLASH_STRING
: "",
237 in_pathname
, (char *) NULL
));
240 /* Handle files to be accessed via the target. */
241 if (is_target_filename (temp_pathname
.get ()))
245 return temp_pathname
;
248 /* Now see if we can open it. */
249 found_file
= gdb_open_cloexec (temp_pathname
.get (),
250 O_RDONLY
| O_BINARY
, 0).release ();
252 /* If the search in gdb_sysroot failed, and the path name has a
253 drive spec (e.g, c:/foo), try stripping ':' from the drive spec,
254 and retrying in the sysroot:
255 c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll. */
259 && HAS_TARGET_DRIVE_SPEC (fskind
, in_pathname
))
261 bool need_dir_separator
= !IS_DIR_SEPARATOR (in_pathname
[2]);
262 char drive
[2] = { in_pathname
[0], '\0' };
264 temp_pathname
.reset (concat (sysroot
,
267 need_dir_separator
? SLASH_STRING
: "",
268 in_pathname
+ 2, (char *) NULL
));
270 found_file
= gdb_open_cloexec (temp_pathname
.get (),
271 O_RDONLY
| O_BINARY
, 0).release ();
274 /* If the search in gdb_sysroot still failed, try fully
275 stripping the drive spec, and trying once more in the
276 sysroot before giving up.
278 c:/foo/bar.dll ==> /sysroot/foo/bar.dll. */
280 temp_pathname
.reset (concat (sysroot
,
281 need_dir_separator
? SLASH_STRING
: "",
282 in_pathname
+ 2, (char *) NULL
));
284 found_file
= gdb_open_cloexec (temp_pathname
.get (),
285 O_RDONLY
| O_BINARY
, 0).release ();
289 /* We try to find the library in various ways. After each attempt,
290 either found_file >= 0 and temp_pathname is a malloc'd string, or
291 found_file < 0 and temp_pathname does not point to storage that
292 needs to be freed. */
295 temp_pathname
.reset (NULL
);
297 /* If the search in gdb_sysroot failed, and the path name is
298 absolute at this point, make it relative. (openp will try and open the
299 file according to its absolute path otherwise, which is not what we want.)
300 Affects subsequent searches for this solib. */
301 if (found_file
< 0 && IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
))
303 /* First, get rid of any drive letters etc. */
304 while (!IS_TARGET_DIR_SEPARATOR (fskind
, *in_pathname
))
307 /* Next, get rid of all leading dir separators. */
308 while (IS_TARGET_DIR_SEPARATOR (fskind
, *in_pathname
))
312 /* If not found, and we're looking for a solib, search the
313 solib_search_path (if any). */
314 if (is_solib
&& found_file
< 0 && !solib_search_path
.empty ())
315 found_file
= openp (solib_search_path
.c_str (),
316 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
317 in_pathname
, O_RDONLY
| O_BINARY
, &temp_pathname
);
319 /* If not found, and we're looking for a solib, next search the
320 solib_search_path (if any) for the basename only (ignoring the
321 path). This is to allow reading solibs from a path that differs
322 from the opened path. */
323 if (is_solib
&& found_file
< 0 && !solib_search_path
.empty ())
324 found_file
= openp (solib_search_path
.c_str (),
325 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
326 target_lbasename (fskind
, in_pathname
),
327 O_RDONLY
| O_BINARY
, &temp_pathname
);
329 /* If not found, and we're looking for a solib, try to use target
330 supplied solib search method. */
331 if (is_solib
&& found_file
< 0 && ops
->find_and_open_solib
)
332 found_file
= ops
->find_and_open_solib (in_pathname
, O_RDONLY
| O_BINARY
,
335 /* If not found, next search the inferior's $PATH environment variable. */
336 if (found_file
< 0 && sysroot
== NULL
)
337 found_file
= openp (current_inferior ()->environment
.get ("PATH"),
338 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
, in_pathname
,
339 O_RDONLY
| O_BINARY
, &temp_pathname
);
341 /* If not found, and we're looking for a solib, next search the
342 inferior's $LD_LIBRARY_PATH environment variable. */
343 if (is_solib
&& found_file
< 0 && sysroot
== NULL
)
344 found_file
= openp (current_inferior ()->environment
.get
346 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
, in_pathname
,
347 O_RDONLY
| O_BINARY
, &temp_pathname
);
357 return temp_pathname
;
360 /* Return the full pathname of the main executable, or NULL if not
361 found. If FD is non-NULL, *FD is set to either -1 or an open file
362 handle for the main executable. */
364 gdb::unique_xmalloc_ptr
<char>
365 exec_file_find (const char *in_pathname
, int *fd
)
367 gdb::unique_xmalloc_ptr
<char> result
;
368 const char *fskind
= effective_target_file_system_kind ();
370 if (in_pathname
== NULL
)
373 if (!gdb_sysroot
.empty () && IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
))
375 result
= solib_find_1 (in_pathname
, fd
, false);
377 if (result
== NULL
&& fskind
== file_system_kind_dos_based
)
381 new_pathname
= (char *) alloca (strlen (in_pathname
) + 5);
382 strcpy (new_pathname
, in_pathname
);
383 strcat (new_pathname
, ".exe");
385 result
= solib_find_1 (new_pathname
, fd
, false);
390 /* It's possible we don't have a full path, but rather just a
391 filename. Some targets, such as HP-UX, don't provide the
394 Attempt to qualify the filename against the source path.
395 (If that fails, we'll just fall back on the original
396 filename. Not much more we can do...) */
398 if (!source_full_path_of (in_pathname
, &result
))
399 result
.reset (xstrdup (in_pathname
));
407 /* Return the full pathname of a shared library file, or NULL if not
408 found. If FD is non-NULL, *FD is set to either -1 or an open file
409 handle for the shared library.
411 The search algorithm used is described in solib_find_1's comment
414 gdb::unique_xmalloc_ptr
<char>
415 solib_find (const char *in_pathname
, int *fd
)
417 const char *solib_symbols_extension
418 = gdbarch_solib_symbols_extension (target_gdbarch ());
420 /* If solib_symbols_extension is set, replace the file's
422 if (solib_symbols_extension
!= NULL
)
424 const char *p
= in_pathname
+ strlen (in_pathname
);
426 while (p
> in_pathname
&& *p
!= '.')
434 = (char *) alloca (p
- in_pathname
+ 1
435 + strlen (solib_symbols_extension
) + 1);
436 memcpy (new_pathname
, in_pathname
, p
- in_pathname
+ 1);
437 strcpy (new_pathname
+ (p
- in_pathname
) + 1,
438 solib_symbols_extension
);
440 in_pathname
= new_pathname
;
444 return solib_find_1 (in_pathname
, fd
, true);
447 /* Open and return a BFD for the shared library PATHNAME. If FD is not -1,
448 it is used as file handle to open the file. Throws an error if the file
449 could not be opened. Handles both local and remote file access.
451 If unsuccessful, the FD will be closed (unless FD was -1). */
454 solib_bfd_fopen (const char *pathname
, int fd
)
456 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (pathname
, gnutarget
, fd
));
458 if (abfd
!= NULL
&& !gdb_bfd_has_target_filename (abfd
.get ()))
459 bfd_set_cacheable (abfd
.get (), 1);
463 /* Arrange to free PATHNAME when the error is thrown. */
464 error (_("Could not open `%s' as an executable file: %s"),
465 pathname
, bfd_errmsg (bfd_get_error ()));
471 /* Find shared library PATHNAME and open a BFD for it. */
474 solib_bfd_open (const char *pathname
)
477 const struct bfd_arch_info
*b
;
479 /* Search for shared library file. */
480 gdb::unique_xmalloc_ptr
<char> found_pathname
481 = solib_find (pathname
, &found_file
);
482 if (found_pathname
== NULL
)
484 /* Return failure if the file could not be found, so that we can
485 accumulate messages about missing libraries. */
489 perror_with_name (pathname
);
492 /* Open bfd for shared library. */
493 gdb_bfd_ref_ptr
abfd (solib_bfd_fopen (found_pathname
.get (), found_file
));
495 /* Check bfd format. */
496 if (!bfd_check_format (abfd
.get (), bfd_object
))
497 error (_("`%s': not in executable format: %s"),
498 bfd_get_filename (abfd
.get ()), bfd_errmsg (bfd_get_error ()));
500 /* Check bfd arch. */
501 b
= gdbarch_bfd_arch_info (target_gdbarch ());
502 if (!b
->compatible (b
, bfd_get_arch_info (abfd
.get ())))
503 error (_("`%s': Shared library architecture %s is not compatible "
504 "with target architecture %s."), bfd_get_filename (abfd
.get ()),
505 bfd_get_arch_info (abfd
.get ())->printable_name
,
511 /* Mapping of a core file's shared library sonames to their respective
512 build-ids. Added to the registries of core file bfds. */
514 typedef std::unordered_map
<std::string
, std::string
> soname_build_id_map
;
516 /* Key used to associate a soname_build_id_map to a core file bfd. */
518 static const struct registry
<bfd
>::key
<soname_build_id_map
>
519 cbfd_soname_build_id_data_key
;
524 set_cbfd_soname_build_id (gdb_bfd_ref_ptr abfd
,
526 const bfd_build_id
*build_id
)
528 gdb_assert (abfd
.get () != nullptr);
529 gdb_assert (soname
!= nullptr);
530 gdb_assert (build_id
!= nullptr);
532 soname_build_id_map
*mapptr
= cbfd_soname_build_id_data_key
.get (abfd
.get ());
534 if (mapptr
== nullptr)
535 mapptr
= cbfd_soname_build_id_data_key
.emplace (abfd
.get ());
537 (*mapptr
)[soname
] = build_id_to_string (build_id
);
542 gdb::unique_xmalloc_ptr
<char>
543 get_cbfd_soname_build_id (gdb_bfd_ref_ptr abfd
, const char *soname
)
545 if (abfd
.get () == nullptr || soname
== nullptr)
548 soname_build_id_map
*mapptr
549 = cbfd_soname_build_id_data_key
.get (abfd
.get ());
551 if (mapptr
== nullptr)
554 auto it
= mapptr
->find (lbasename (soname
));
555 if (it
== mapptr
->end ())
558 return make_unique_xstrdup (it
->second
.c_str ());
561 /* Given a pointer to one of the shared objects in our list of mapped
562 objects, use the recorded name to open a bfd descriptor for the
563 object, build a section table, relocate all the section addresses
564 by the base address at which the shared object was mapped, and then
565 add the sections to the target's section table.
567 FIXME: In most (all?) cases the shared object file name recorded in
568 the dynamic linkage tables will be a fully qualified pathname. For
569 cases where it isn't, do we really mimic the systems search
570 mechanism correctly in the below code (particularly the tilde
571 expansion stuff?). */
574 solib_map_sections (struct so_list
*so
)
576 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
578 gdb::unique_xmalloc_ptr
<char> filename (tilde_expand (so
->so_name
));
579 gdb_bfd_ref_ptr
abfd (ops
->bfd_open (filename
.get ()));
580 gdb::unique_xmalloc_ptr
<char> build_id_hexstr
581 = get_cbfd_soname_build_id (current_program_space
->cbfd
, so
->so_name
);
583 /* If we already know the build-id of this solib from a core file, verify
584 it matches ABFD's build-id. If there is a mismatch or the solib wasn't
585 found, attempt to query debuginfod for the correct solib. */
586 if (build_id_hexstr
.get () != nullptr)
588 bool mismatch
= false;
590 if (abfd
!= nullptr && abfd
->build_id
!= nullptr)
592 std::string build_id
= build_id_to_string (abfd
->build_id
);
594 if (build_id
!= build_id_hexstr
.get ())
597 if (abfd
== nullptr || mismatch
)
599 scoped_fd fd
= debuginfod_exec_query ((const unsigned char*)
600 build_id_hexstr
.get (),
601 0, so
->so_name
, &filename
);
604 abfd
= ops
->bfd_open (filename
.get ());
606 warning (_("Build-id of %ps does not match core file."),
607 styled_string (file_name_style
.style (), filename
.get ()));
614 /* Leave bfd open, core_xfer_memory and "info files" need it. */
615 so
->abfd
= abfd
.release ();
617 /* Copy the full path name into so_name, allowing symbol_file_add
618 to find it later. This also affects the =library-loaded GDB/MI
619 event, and in particular the part of that notification providing
620 the library's host-side path. If we let the target dictate
621 that objfile's path, and the target is different from the host,
622 GDB/MI will not provide the correct host-side path. */
623 if (strlen (bfd_get_filename (so
->abfd
)) >= SO_NAME_MAX_PATH_SIZE
)
624 error (_("Shared library file name is too long."));
625 strcpy (so
->so_name
, bfd_get_filename (so
->abfd
));
627 if (so
->sections
== nullptr)
628 so
->sections
= new target_section_table
;
629 *so
->sections
= build_section_table (so
->abfd
);
631 for (target_section
&p
: *so
->sections
)
633 /* Relocate the section binding addresses as recorded in the shared
634 object's file by the base address to which the object was actually
636 ops
->relocate_section_addresses (so
, &p
);
638 /* If the target didn't provide information about the address
639 range of the shared object, assume we want the location of
640 the .text section. */
641 if (so
->addr_low
== 0 && so
->addr_high
== 0
642 && strcmp (p
.the_bfd_section
->name
, ".text") == 0)
644 so
->addr_low
= p
.addr
;
645 so
->addr_high
= p
.endaddr
;
649 /* Add the shared object's sections to the current set of file
650 section tables. Do this immediately after mapping the object so
651 that later nodes in the list can query this object, as is needed
653 current_program_space
->add_target_sections (so
, *so
->sections
);
658 /* Free symbol-file related contents of SO and reset for possible reloading
659 of SO. If we have opened a BFD for SO, close it. If we have placed SO's
660 sections in some target's section table, the caller is responsible for
663 This function doesn't mess with objfiles at all. If there is an
664 objfile associated with SO that needs to be removed, the caller is
665 responsible for taking care of that. */
668 clear_so (struct so_list
*so
)
670 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
675 gdb_bfd_unref (so
->abfd
);
678 /* Our caller closed the objfile, possibly via objfile_purge_solibs. */
679 so
->symbols_loaded
= 0;
682 so
->addr_low
= so
->addr_high
= 0;
684 /* Restore the target-supplied file name. SO_NAME may be the path
685 of the symbol file. */
686 strcpy (so
->so_name
, so
->so_original_name
);
688 /* Do the same for target-specific data. */
689 if (ops
->clear_so
!= NULL
)
693 /* Free the storage associated with the `struct so_list' object SO.
694 If we have opened a BFD for SO, close it.
696 The caller is responsible for removing SO from whatever list it is
697 a member of. If we have placed SO's sections in some target's
698 section table, the caller is responsible for removing them.
700 This function doesn't mess with objfiles at all. If there is an
701 objfile associated with SO that needs to be removed, the caller is
702 responsible for taking care of that. */
705 free_so (struct so_list
*so
)
707 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
716 /* Read in symbols for shared object SO. If SYMFILE_VERBOSE is set in FLAGS,
717 be chatty about it. Return true if any symbols were actually loaded. */
720 solib_read_symbols (struct so_list
*so
, symfile_add_flags flags
)
722 if (so
->symbols_loaded
)
724 /* If needed, we've already warned in our caller. */
726 else if (so
->abfd
== NULL
)
728 /* We've already warned about this library, when trying to open
734 flags
|= current_inferior ()->symfile_flags
;
738 /* Have we already loaded this shared object? */
739 so
->objfile
= nullptr;
740 for (objfile
*objfile
: current_program_space
->objfiles ())
742 if (filename_cmp (objfile_name (objfile
), so
->so_name
) == 0
743 && objfile
->addr_low
== so
->addr_low
)
745 so
->objfile
= objfile
;
749 if (so
->objfile
== NULL
)
751 section_addr_info sap
752 = build_section_addr_info_from_section_table (*so
->sections
);
753 gdb_bfd_ref_ptr tmp_bfd
754 (gdb_bfd_ref_ptr::new_reference (so
->abfd
));
755 so
->objfile
= symbol_file_add_from_bfd (tmp_bfd
, so
->so_name
,
758 so
->objfile
->addr_low
= so
->addr_low
;
761 so
->symbols_loaded
= 1;
763 catch (const gdb_exception_error
&e
)
765 exception_fprintf (gdb_stderr
, e
, _("Error while reading shared"
766 " library symbols for %s:\n"),
776 /* Return true if KNOWN->objfile is used by any other so_list object
777 in the list of shared libraries. Return false otherwise. */
780 solib_used (const struct so_list
*const known
)
782 for (const struct so_list
*pivot
: current_program_space
->solibs ())
783 if (pivot
!= known
&& pivot
->objfile
== known
->objfile
)
791 update_solib_list (int from_tty
)
793 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
794 struct so_list
*inferior
= ops
->current_sos();
795 struct so_list
*gdb
, **gdb_link
;
797 /* We can reach here due to changing solib-search-path or the
798 sysroot, before having any inferior. */
799 if (target_has_execution () && inferior_ptid
!= null_ptid
)
801 struct inferior
*inf
= current_inferior ();
803 /* If we are attaching to a running process for which we
804 have not opened a symbol file, we may be able to get its
807 && current_program_space
->symfile_object_file
== NULL
)
811 ops
->open_symbol_file_object (from_tty
);
813 catch (const gdb_exception
&ex
)
815 exception_fprintf (gdb_stderr
, ex
,
816 "Error reading attached "
817 "process's symbol file.\n");
822 /* GDB and the inferior's dynamic linker each maintain their own
823 list of currently loaded shared objects; we want to bring the
824 former in sync with the latter. Scan both lists, seeing which
825 shared objects appear where. There are three cases:
827 - A shared object appears on both lists. This means that GDB
828 knows about it already, and it's still loaded in the inferior.
829 Nothing needs to happen.
831 - A shared object appears only on GDB's list. This means that
832 the inferior has unloaded it. We should remove the shared
833 object from GDB's tables.
835 - A shared object appears only on the inferior's list. This
836 means that it's just been loaded. We should add it to GDB's
839 So we walk GDB's list, checking each entry to see if it appears
840 in the inferior's list too. If it does, no action is needed, and
841 we remove it from the inferior's list. If it doesn't, the
842 inferior has unloaded it, and we remove it from GDB's list. By
843 the time we're done walking GDB's list, the inferior's list
844 contains only the new shared objects, which we then add. */
846 gdb
= current_program_space
->so_list
;
847 gdb_link
= ¤t_program_space
->so_list
;
850 struct so_list
*i
= inferior
;
851 struct so_list
**i_link
= &inferior
;
853 /* Check to see whether the shared object *gdb also appears in
854 the inferior's current list. */
859 if (ops
->same (gdb
, i
))
864 if (! filename_cmp (gdb
->so_original_name
, i
->so_original_name
))
872 /* If the shared object appears on the inferior's list too, then
873 it's still loaded, so we don't need to do anything. Delete
874 it from the inferior's list, and leave it on GDB's list. */
879 gdb_link
= &gdb
->next
;
883 /* If it's not on the inferior's list, remove it from GDB's tables. */
886 /* Notify any observer that the shared object has been
887 unloaded before we remove it from GDB's tables. */
888 gdb::observers::solib_unloaded
.notify (gdb
);
890 current_program_space
->deleted_solibs
.push_back (gdb
->so_name
);
892 *gdb_link
= gdb
->next
;
894 /* Unless the user loaded it explicitly, free SO's objfile. */
895 if (gdb
->objfile
&& ! (gdb
->objfile
->flags
& OBJF_USERLOADED
)
896 && !solib_used (gdb
))
897 gdb
->objfile
->unlink ();
899 /* Some targets' section tables might be referring to
900 sections from so->abfd; remove them. */
901 current_program_space
->remove_target_sections (gdb
);
908 /* Now the inferior's list contains only shared objects that don't
909 appear in GDB's list --- those that are newly loaded. Add them
910 to GDB's shared object list. */
914 const char *not_found_filename
= NULL
;
918 /* Add the new shared objects to GDB's list. */
919 *gdb_link
= inferior
;
921 /* Fill in the rest of each of the `struct so_list' nodes. */
922 for (i
= inferior
; i
; i
= i
->next
)
925 i
->pspace
= current_program_space
;
926 current_program_space
->added_solibs
.push_back (i
);
930 /* Fill in the rest of the `struct so_list' node. */
931 if (!solib_map_sections (i
))
934 if (not_found_filename
== NULL
)
935 not_found_filename
= i
->so_original_name
;
939 catch (const gdb_exception_error
&e
)
941 exception_fprintf (gdb_stderr
, e
,
942 _("Error while mapping shared "
943 "library sections:\n"));
946 /* Notify any observer that the shared object has been
947 loaded now that we've added it to GDB's tables. */
948 gdb::observers::solib_loaded
.notify (i
);
951 /* If a library was not found, issue an appropriate warning
952 message. We have to use a single call to warning in case the
953 front end does something special with warnings, e.g., pop up
954 a dialog box. It Would Be Nice if we could get a "warning: "
955 prefix on each line in the CLI front end, though - it doesn't
959 warning (_("Could not load shared library symbols for %s.\n"
960 "Do you need \"set solib-search-path\" "
961 "or \"set sysroot\"?"),
963 else if (not_found
> 1)
965 Could not load shared library symbols for %d libraries, e.g. %s.\n\
966 Use the \"info sharedlibrary\" command to see the complete listing.\n\
967 Do you need \"set solib-search-path\" or \"set sysroot\"?"),
968 not_found
, not_found_filename
);
973 /* Return non-zero if NAME is the libpthread shared library.
975 Uses a fairly simplistic heuristic approach where we check
976 the file name against "/libpthread". This can lead to false
977 positives, but this should be good enough in practice.
979 As of glibc-2.34, functions formerly residing in libpthread have
980 been moved to libc, so "/libc." needs to be checked too. (Matching
981 the "." will avoid matching libraries such as libcrypt.) */
984 libpthread_name_p (const char *name
)
986 return (strstr (name
, "/libpthread") != NULL
987 || strstr (name
, "/libc.") != NULL
);
990 /* Return non-zero if SO is the libpthread shared library. */
993 libpthread_solib_p (struct so_list
*so
)
995 return libpthread_name_p (so
->so_name
);
998 /* Read in symbolic information for any shared objects whose names
999 match PATTERN. (If we've already read a shared object's symbol
1000 info, leave it alone.) If PATTERN is zero, read them all.
1002 If READSYMS is 0, defer reading symbolic information until later
1003 but still do any needed low level processing.
1005 FROM_TTY is described for update_solib_list, above. */
1008 solib_add (const char *pattern
, int from_tty
, int readsyms
)
1010 if (print_symbol_loading_p (from_tty
, 0, 0))
1012 if (pattern
!= NULL
)
1014 gdb_printf (_("Loading symbols for shared libraries: %s\n"),
1018 gdb_printf (_("Loading symbols for shared libraries.\n"));
1021 current_program_space
->solib_add_generation
++;
1025 char *re_err
= re_comp (pattern
);
1028 error (_("Invalid regexp: %s"), re_err
);
1031 update_solib_list (from_tty
);
1033 /* Walk the list of currently loaded shared libraries, and read
1034 symbols for any that match the pattern --- or any whose symbols
1035 aren't already loaded, if no pattern was given. */
1037 bool any_matches
= false;
1038 bool loaded_any_symbols
= false;
1039 symfile_add_flags add_flags
= SYMFILE_DEFER_BP_RESET
;
1042 add_flags
|= SYMFILE_VERBOSE
;
1044 for (struct so_list
*gdb
: current_program_space
->solibs ())
1045 if (! pattern
|| re_exec (gdb
->so_name
))
1047 /* Normally, we would read the symbols from that library
1048 only if READSYMS is set. However, we're making a small
1049 exception for the pthread library, because we sometimes
1050 need the library symbols to be loaded in order to provide
1051 thread support (x86-linux for instance). */
1052 const int add_this_solib
=
1053 (readsyms
|| libpthread_solib_p (gdb
));
1058 if (gdb
->symbols_loaded
)
1060 /* If no pattern was given, be quiet for shared
1061 libraries we have already loaded. */
1062 if (pattern
&& (from_tty
|| info_verbose
))
1063 gdb_printf (_("Symbols already loaded for %s\n"),
1066 else if (solib_read_symbols (gdb
, add_flags
))
1067 loaded_any_symbols
= true;
1071 if (loaded_any_symbols
)
1072 breakpoint_re_set ();
1074 if (from_tty
&& pattern
&& ! any_matches
)
1076 ("No loaded shared libraries match the pattern `%s'.\n", pattern
);
1078 if (loaded_any_symbols
)
1080 /* Getting new symbols may change our opinion about what is
1082 reinit_frame_cache ();
1087 /* Implement the "info sharedlibrary" command. Walk through the
1088 shared library list and print information about each attached
1089 library matching PATTERN. If PATTERN is elided, print them
1093 info_sharedlibrary_command (const char *pattern
, int from_tty
)
1095 bool so_missing_debug_info
= false;
1098 struct gdbarch
*gdbarch
= target_gdbarch ();
1099 struct ui_out
*uiout
= current_uiout
;
1103 char *re_err
= re_comp (pattern
);
1106 error (_("Invalid regexp: %s"), re_err
);
1109 /* "0x", a little whitespace, and two hex digits per byte of pointers. */
1110 addr_width
= 4 + (gdbarch_ptr_bit (gdbarch
) / 4);
1112 update_solib_list (from_tty
);
1114 /* ui_out_emit_table table_emitter needs to know the number of rows,
1115 so we need to make two passes over the libs. */
1118 for (struct so_list
*so
: current_program_space
->solibs ())
1122 if (pattern
&& ! re_exec (so
->so_name
))
1129 ui_out_emit_table
table_emitter (uiout
, 4, nr_libs
, "SharedLibraryTable");
1131 /* The "- 1" is because ui_out adds one space between columns. */
1132 uiout
->table_header (addr_width
- 1, ui_left
, "from", "From");
1133 uiout
->table_header (addr_width
- 1, ui_left
, "to", "To");
1134 uiout
->table_header (12 - 1, ui_left
, "syms-read", "Syms Read");
1135 uiout
->table_header (0, ui_noalign
, "name", "Shared Object Library");
1137 uiout
->table_body ();
1139 for (struct so_list
*so
: current_program_space
->solibs ())
1141 if (! so
->so_name
[0])
1143 if (pattern
&& ! re_exec (so
->so_name
))
1146 ui_out_emit_tuple
tuple_emitter (uiout
, "lib");
1148 if (so
->addr_high
!= 0)
1150 uiout
->field_core_addr ("from", gdbarch
, so
->addr_low
);
1151 uiout
->field_core_addr ("to", gdbarch
, so
->addr_high
);
1155 uiout
->field_skip ("from");
1156 uiout
->field_skip ("to");
1159 if (! top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ()
1160 && so
->symbols_loaded
1161 && !objfile_has_symbols (so
->objfile
))
1163 so_missing_debug_info
= true;
1164 uiout
->field_string ("syms-read", "Yes (*)");
1167 uiout
->field_string ("syms-read", so
->symbols_loaded
? "Yes" : "No");
1169 uiout
->field_string ("name", so
->so_name
, file_name_style
.style ());
1178 uiout
->message (_("No shared libraries matched.\n"));
1180 uiout
->message (_("No shared libraries loaded at this time.\n"));
1184 if (so_missing_debug_info
)
1185 uiout
->message (_("(*): Shared library is missing "
1186 "debugging information.\n"));
1193 solib_contains_address_p (const struct so_list
*const solib
,
1196 if (solib
->sections
== nullptr)
1199 for (target_section
&p
: *solib
->sections
)
1200 if (p
.addr
<= address
&& address
< p
.endaddr
)
1206 /* If ADDRESS is in a shared lib in program space PSPACE, return its
1209 Provides a hook for other gdb routines to discover whether or not a
1210 particular address is within the mapped address space of a shared
1213 For example, this routine is called at one point to disable
1214 breakpoints which are in shared libraries that are not currently
1218 solib_name_from_address (struct program_space
*pspace
, CORE_ADDR address
)
1220 struct so_list
*so
= NULL
;
1222 for (so
= pspace
->so_list
; so
; so
= so
->next
)
1223 if (solib_contains_address_p (so
, address
))
1224 return (so
->so_name
);
1232 solib_keep_data_in_core (CORE_ADDR vaddr
, unsigned long size
)
1234 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1236 if (ops
->keep_data_in_core
)
1237 return ops
->keep_data_in_core (vaddr
, size
) != 0;
1242 /* Called by free_all_symtabs */
1247 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1249 disable_breakpoints_in_shlibs ();
1251 while (current_program_space
->so_list
)
1253 struct so_list
*so
= current_program_space
->so_list
;
1255 current_program_space
->so_list
= so
->next
;
1256 gdb::observers::solib_unloaded
.notify (so
);
1257 current_program_space
->remove_target_sections (so
);
1261 ops
->clear_solib ();
1264 /* Shared library startup support. When GDB starts up the inferior,
1265 it nurses it along (through the shell) until it is ready to execute
1266 its first instruction. At this point, this function gets
1270 solib_create_inferior_hook (int from_tty
)
1272 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1274 ops
->solib_create_inferior_hook (from_tty
);
1280 in_solib_dynsym_resolve_code (CORE_ADDR pc
)
1282 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1284 return ops
->in_dynsym_resolve_code (pc
) != 0;
1287 /* Implements the "sharedlibrary" command. */
1290 sharedlibrary_command (const char *args
, int from_tty
)
1293 solib_add (args
, from_tty
, 1);
1296 /* Implements the command "nosharedlibrary", which discards symbols
1297 that have been auto-loaded from shared libraries. Symbols from
1298 shared libraries that were added by explicit request of the user
1299 are not discarded. Also called from remote.c. */
1302 no_shared_libraries (const char *ignored
, int from_tty
)
1304 /* The order of the two routines below is important: clear_solib notifies
1305 the solib_unloaded observers, and some of these observers might need
1306 access to their associated objfiles. Therefore, we can not purge the
1307 solibs' objfiles before clear_solib has been called. */
1310 objfile_purge_solibs ();
1316 update_solib_breakpoints (void)
1318 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1320 if (ops
->update_breakpoints
!= NULL
)
1321 ops
->update_breakpoints ();
1327 handle_solib_event (void)
1329 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1331 if (ops
->handle_event
!= NULL
)
1332 ops
->handle_event ();
1334 current_inferior ()->pspace
->clear_solib_cache ();
1336 /* Check for any newly added shared libraries if we're supposed to
1337 be adding them automatically. Switch terminal for any messages
1338 produced by breakpoint_re_set. */
1339 target_terminal::ours_for_output ();
1340 solib_add (NULL
, 0, auto_solib_add
);
1341 target_terminal::inferior ();
1344 /* Reload shared libraries, but avoid reloading the same symbol file
1345 we already have loaded. */
1348 reload_shared_libraries_1 (int from_tty
)
1350 if (print_symbol_loading_p (from_tty
, 0, 0))
1351 gdb_printf (_("Loading symbols for shared libraries.\n"));
1353 for (struct so_list
*so
: current_program_space
->solibs ())
1355 const char *found_pathname
= NULL
;
1356 bool was_loaded
= so
->symbols_loaded
!= 0;
1357 symfile_add_flags add_flags
= SYMFILE_DEFER_BP_RESET
;
1360 add_flags
|= SYMFILE_VERBOSE
;
1362 gdb::unique_xmalloc_ptr
<char> filename
1363 (tilde_expand (so
->so_original_name
));
1364 gdb_bfd_ref_ptr
abfd (solib_bfd_open (filename
.get ()));
1366 found_pathname
= bfd_get_filename (abfd
.get ());
1368 /* If this shared library is no longer associated with its previous
1369 symbol file, close that. */
1370 if ((found_pathname
== NULL
&& was_loaded
)
1371 || (found_pathname
!= NULL
1372 && filename_cmp (found_pathname
, so
->so_name
) != 0))
1374 if (so
->objfile
&& ! (so
->objfile
->flags
& OBJF_USERLOADED
)
1375 && !solib_used (so
))
1376 so
->objfile
->unlink ();
1377 current_program_space
->remove_target_sections (so
);
1381 /* If this shared library is now associated with a new symbol
1383 if (found_pathname
!= NULL
1385 || filename_cmp (found_pathname
, so
->so_name
) != 0))
1387 bool got_error
= false;
1391 solib_map_sections (so
);
1394 catch (const gdb_exception_error
&e
)
1396 exception_fprintf (gdb_stderr
, e
,
1397 _("Error while mapping "
1398 "shared library sections:\n"));
1403 && (auto_solib_add
|| was_loaded
|| libpthread_solib_p (so
)))
1404 solib_read_symbols (so
, add_flags
);
1410 reload_shared_libraries (const char *ignored
, int from_tty
,
1411 struct cmd_list_element
*e
)
1413 const struct target_so_ops
*ops
;
1415 reload_shared_libraries_1 (from_tty
);
1417 ops
= solib_ops (target_gdbarch ());
1419 /* Creating inferior hooks here has two purposes. First, if we reload
1420 shared libraries then the address of solib breakpoint we've computed
1421 previously might be no longer valid. For example, if we forgot to set
1422 solib-absolute-prefix and are setting it right now, then the previous
1423 breakpoint address is plain wrong. Second, installing solib hooks
1424 also implicitly figures were ld.so is and loads symbols for it.
1425 Absent this call, if we've just connected to a target and set
1426 solib-absolute-prefix or solib-search-path, we'll lose all information
1428 if (target_has_execution ())
1430 /* Reset or free private data structures not associated with
1432 ops
->clear_solib ();
1434 /* Remove any previous solib event breakpoint. This is usually
1435 done in common code, at breakpoint_init_inferior time, but
1436 we're not really starting up the inferior here. */
1437 remove_solib_event_breakpoints ();
1439 solib_create_inferior_hook (from_tty
);
1442 /* Sometimes the platform-specific hook loads initial shared
1443 libraries, and sometimes it doesn't. If it doesn't FROM_TTY will be
1444 incorrectly 0 but such solib targets should be fixed anyway. If we
1445 made all the inferior hook methods consistent, this call could be
1446 removed. Call it only after the solib target has been initialized by
1447 solib_create_inferior_hook. */
1449 solib_add (NULL
, 0, auto_solib_add
);
1451 breakpoint_re_set ();
1453 /* We may have loaded or unloaded debug info for some (or all)
1454 shared libraries. However, frames may still reference them. For
1455 example, a frame's unwinder might still point at DWARF FDE
1456 structures that are now freed. Also, getting new symbols may
1457 change our opinion about what is frameless. */
1458 reinit_frame_cache ();
1461 /* Wrapper for reload_shared_libraries that replaces "remote:"
1462 at the start of gdb_sysroot with "target:". */
1465 gdb_sysroot_changed (const char *ignored
, int from_tty
,
1466 struct cmd_list_element
*e
)
1468 const char *old_prefix
= "remote:";
1469 const char *new_prefix
= TARGET_SYSROOT_PREFIX
;
1471 if (startswith (gdb_sysroot
.c_str (), old_prefix
))
1473 static bool warning_issued
= false;
1475 gdb_assert (strlen (old_prefix
) == strlen (new_prefix
));
1476 gdb_sysroot
= new_prefix
+ gdb_sysroot
.substr (strlen (old_prefix
));
1478 if (!warning_issued
)
1480 warning (_("\"%s\" is deprecated, use \"%s\" instead."),
1481 old_prefix
, new_prefix
);
1482 warning (_("sysroot set to \"%s\"."), gdb_sysroot
.c_str ());
1484 warning_issued
= true;
1488 reload_shared_libraries (ignored
, from_tty
, e
);
1492 show_auto_solib_add (struct ui_file
*file
, int from_tty
,
1493 struct cmd_list_element
*c
, const char *value
)
1495 gdb_printf (file
, _("Autoloading of shared library symbols is %s.\n"),
1500 /* Lookup the value for a specific symbol from dynamic symbol table. Look
1501 up symbol from ABFD. MATCH_SYM is a callback function to determine
1502 whether to pick up a symbol. DATA is the input of this callback
1503 function. Return NULL if symbol is not found. */
1506 gdb_bfd_lookup_symbol_from_symtab (bfd
*abfd
,
1507 int (*match_sym
) (const asymbol
*,
1511 long storage_needed
= bfd_get_symtab_upper_bound (abfd
);
1512 CORE_ADDR symaddr
= 0;
1514 if (storage_needed
> 0)
1518 gdb::def_vector
<asymbol
*> storage (storage_needed
/ sizeof (asymbol
*));
1519 asymbol
**symbol_table
= storage
.data ();
1520 unsigned int number_of_symbols
=
1521 bfd_canonicalize_symtab (abfd
, symbol_table
);
1523 for (i
= 0; i
< number_of_symbols
; i
++)
1525 asymbol
*sym
= *symbol_table
++;
1527 if (match_sym (sym
, data
))
1529 struct gdbarch
*gdbarch
= target_gdbarch ();
1530 symaddr
= sym
->value
;
1532 /* Some ELF targets fiddle with addresses of symbols they
1533 consider special. They use minimal symbols to do that
1534 and this is needed for correct breakpoint placement,
1535 but we do not have full data here to build a complete
1536 minimal symbol, so just set the address and let the
1537 targets cope with that. */
1538 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1539 && gdbarch_elf_make_msymbol_special_p (gdbarch
))
1541 struct minimal_symbol msym
{};
1543 msym
.set_value_address (symaddr
);
1544 gdbarch_elf_make_msymbol_special (gdbarch
, sym
, &msym
);
1545 symaddr
= msym
.value_raw_address ();
1548 /* BFD symbols are section relative. */
1549 symaddr
+= sym
->section
->vma
;
1561 gdb_bfd_scan_elf_dyntag (const int desired_dyntag
, bfd
*abfd
, CORE_ADDR
*ptr
,
1562 CORE_ADDR
*ptr_addr
)
1564 int arch_size
, step
, sect_size
;
1565 long current_dyntag
;
1566 CORE_ADDR dyn_ptr
, dyn_addr
;
1567 gdb_byte
*bufend
, *bufstart
, *buf
;
1568 Elf32_External_Dyn
*x_dynp_32
;
1569 Elf64_External_Dyn
*x_dynp_64
;
1570 struct bfd_section
*sect
;
1575 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
1578 arch_size
= bfd_get_arch_size (abfd
);
1579 if (arch_size
== -1)
1582 /* Find the start address of the .dynamic section. */
1583 sect
= bfd_get_section_by_name (abfd
, ".dynamic");
1588 for (const target_section
&target_section
1589 : current_program_space
->target_sections ())
1590 if (sect
== target_section
.the_bfd_section
)
1592 dyn_addr
= target_section
.addr
;
1598 /* ABFD may come from OBJFILE acting only as a symbol file without being
1599 loaded into the target (see add_symbol_file_command). This case is
1600 such fallback to the file VMA address without the possibility of
1601 having the section relocated to its actual in-memory address. */
1603 dyn_addr
= bfd_section_vma (sect
);
1606 /* Read in .dynamic from the BFD. We will get the actual value
1607 from memory later. */
1608 sect_size
= bfd_section_size (sect
);
1609 buf
= bufstart
= (gdb_byte
*) alloca (sect_size
);
1610 if (!bfd_get_section_contents (abfd
, sect
,
1614 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
1615 step
= (arch_size
== 32) ? sizeof (Elf32_External_Dyn
)
1616 : sizeof (Elf64_External_Dyn
);
1617 for (bufend
= buf
+ sect_size
;
1621 if (arch_size
== 32)
1623 x_dynp_32
= (Elf32_External_Dyn
*) buf
;
1624 current_dyntag
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_tag
);
1625 dyn_ptr
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_un
.d_ptr
);
1629 x_dynp_64
= (Elf64_External_Dyn
*) buf
;
1630 current_dyntag
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_tag
);
1631 dyn_ptr
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_un
.d_ptr
);
1633 if (current_dyntag
== DT_NULL
)
1635 if (current_dyntag
== desired_dyntag
)
1637 /* If requested, try to read the runtime value of this .dynamic
1641 struct type
*ptr_type
;
1642 gdb_byte ptr_buf
[8];
1643 CORE_ADDR ptr_addr_1
;
1645 ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
1646 ptr_addr_1
= dyn_addr
+ (buf
- bufstart
) + arch_size
/ 8;
1647 if (target_read_memory (ptr_addr_1
, ptr_buf
, arch_size
/ 8) == 0)
1648 dyn_ptr
= extract_typed_address (ptr_buf
, ptr_type
);
1651 *ptr_addr
= dyn_addr
+ (buf
- bufstart
);
1662 gdb::unique_xmalloc_ptr
<char>
1663 gdb_bfd_read_elf_soname (const char *filename
)
1665 gdb_bfd_ref_ptr abfd
= gdb_bfd_open (filename
, gnutarget
);
1667 if (abfd
== nullptr)
1670 /* Check that ABFD is an ET_DYN ELF file. */
1671 if (!bfd_check_format (abfd
.get (), bfd_object
)
1672 || !(bfd_get_file_flags (abfd
.get ()) & DYNAMIC
))
1676 if (!gdb_bfd_scan_elf_dyntag (DT_SONAME
, abfd
.get (), &idx
, nullptr))
1679 struct bfd_section
*dynstr
= bfd_get_section_by_name (abfd
.get (), ".dynstr");
1680 int sect_size
= bfd_section_size (dynstr
);
1681 if (dynstr
== nullptr || sect_size
<= idx
)
1684 /* Read soname from the string table. */
1685 gdb::byte_vector dynstr_buf
;
1686 if (!gdb_bfd_get_full_section_contents (abfd
.get (), dynstr
, &dynstr_buf
))
1689 /* Ensure soname is null-terminated before returning a copy. */
1690 char *soname
= (char *) dynstr_buf
.data () + idx
;
1691 if (strnlen (soname
, sect_size
- idx
) == sect_size
- idx
)
1694 return make_unique_xstrdup (soname
);
1697 /* Lookup the value for a specific symbol from symbol table. Look up symbol
1698 from ABFD. MATCH_SYM is a callback function to determine whether to pick
1699 up a symbol. DATA is the input of this callback function. Return NULL
1700 if symbol is not found. */
1703 bfd_lookup_symbol_from_dyn_symtab (bfd
*abfd
,
1704 int (*match_sym
) (const asymbol
*,
1708 long storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1709 CORE_ADDR symaddr
= 0;
1711 if (storage_needed
> 0)
1714 gdb::def_vector
<asymbol
*> storage (storage_needed
/ sizeof (asymbol
*));
1715 asymbol
**symbol_table
= storage
.data ();
1716 unsigned int number_of_symbols
=
1717 bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
1719 for (i
= 0; i
< number_of_symbols
; i
++)
1721 asymbol
*sym
= *symbol_table
++;
1723 if (match_sym (sym
, data
))
1725 /* BFD symbols are section relative. */
1726 symaddr
= sym
->value
+ sym
->section
->vma
;
1734 /* Lookup the value for a specific symbol from symbol table and dynamic
1735 symbol table. Look up symbol from ABFD. MATCH_SYM is a callback
1736 function to determine whether to pick up a symbol. DATA is the
1737 input of this callback function. Return NULL if symbol is not
1741 gdb_bfd_lookup_symbol (bfd
*abfd
,
1742 int (*match_sym
) (const asymbol
*, const void *),
1745 CORE_ADDR symaddr
= gdb_bfd_lookup_symbol_from_symtab (abfd
, match_sym
, data
);
1747 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
1748 have to check the dynamic string table too. */
1750 symaddr
= bfd_lookup_symbol_from_dyn_symtab (abfd
, match_sym
, data
);
1755 /* The shared library list may contain user-loaded object files that
1756 can be removed out-of-band by the user. So upon notification of
1757 free_objfile remove all references to any user-loaded file that is
1758 about to be freed. */
1761 remove_user_added_objfile (struct objfile
*objfile
)
1763 if (objfile
!= 0 && objfile
->flags
& OBJF_USERLOADED
)
1765 for (struct so_list
*so
: current_program_space
->solibs ())
1766 if (so
->objfile
== objfile
)
1771 void _initialize_solib ();
1773 _initialize_solib ()
1775 gdb::observers::free_objfile
.attach (remove_user_added_objfile
,
1777 gdb::observers::inferior_execd
.attach ([] (inferior
*inf
)
1779 solib_create_inferior_hook (0);
1782 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
1783 _("Load shared object library symbols for files matching REGEXP."));
1784 cmd_list_element
*info_sharedlibrary_cmd
1785 = add_info ("sharedlibrary", info_sharedlibrary_command
,
1786 _("Status of loaded shared object libraries."));
1787 add_info_alias ("dll", info_sharedlibrary_cmd
, 1);
1788 add_com ("nosharedlibrary", class_files
, no_shared_libraries
,
1789 _("Unload all shared object library symbols."));
1791 add_setshow_boolean_cmd ("auto-solib-add", class_support
,
1792 &auto_solib_add
, _("\
1793 Set autoloading of shared library symbols."), _("\
1794 Show autoloading of shared library symbols."), _("\
1795 If \"on\", symbols from all shared object libraries will be loaded\n\
1796 automatically when the inferior begins execution, when the dynamic linker\n\
1797 informs gdb that a new library has been loaded, or when attaching to the\n\
1798 inferior. Otherwise, symbols must be loaded manually, using \
1801 show_auto_solib_add
,
1802 &setlist
, &showlist
);
1804 set_show_commands sysroot_cmds
1805 = add_setshow_optional_filename_cmd ("sysroot", class_support
,
1807 Set an alternate system root."), _("\
1808 Show the current system root."), _("\
1809 The system root is used to load absolute shared library symbol files.\n\
1810 For other (relative) files, you can add directories using\n\
1811 `set solib-search-path'."),
1812 gdb_sysroot_changed
,
1814 &setlist
, &showlist
);
1816 add_alias_cmd ("solib-absolute-prefix", sysroot_cmds
.set
, class_support
, 0,
1818 add_alias_cmd ("solib-absolute-prefix", sysroot_cmds
.show
, class_support
, 0,
1821 add_setshow_optional_filename_cmd ("solib-search-path", class_support
,
1822 &solib_search_path
, _("\
1823 Set the search path for loading non-absolute shared library symbol files."),
1825 Show the search path for loading non-absolute shared library symbol files."),
1827 This takes precedence over the environment variables \
1828 PATH and LD_LIBRARY_PATH."),
1829 reload_shared_libraries
,
1830 show_solib_search_path
,
1831 &setlist
, &showlist
);