GDB (xrefs)
Loading...
Searching...
No Matches
solib.c
Go to the documentation of this file.
1/* Handle shared libraries for GDB, the GNU Debugger.
2
3 Copyright (C) 1990-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21
22#include <fcntl.h>
23#include "symtab.h"
24#include "bfd.h"
25#include "build-id.h"
26#include "symfile.h"
27#include "objfiles.h"
28#include "gdbcore.h"
29#include "command.h"
30#include "target.h"
31#include "frame.h"
32#include "inferior.h"
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"
38#include "exec.h"
39#include "solist.h"
40#include "observable.h"
41#include "readline/tilde.h"
42#include "solib.h"
43#include "interps.h"
44#include "filesystem.h"
45#include "gdb_bfd.h"
46#include "gdbsupport/filestuff.h"
47#include "gdbsupport/scoped_fd.h"
48#include "debuginfod-support.h"
49#include "source.h"
50#include "cli/cli-style.h"
51
52/* See solib.h. */
53
55
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. */
59static std::string solib_search_path;
60static void
61show_solib_search_path (struct ui_file *file, int from_tty,
62 struct cmd_list_element *c, const char *value)
63{
64 gdb_printf (file, _("The search path for loading non-absolute "
65 "shared library symbol files is %s.\n"),
66 value);
67}
68
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
72#else
73# define DOS_BASED_FILE_SYSTEM 0
74#endif
75
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.
79
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.
87
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.
93
94 Search algorithm:
95 * If a sysroot is set and path is absolute:
96 * Search for sysroot/path.
97 * else
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.
106 *
107 * The last check avoids doing this search when targeting remote
108 * machines since a sysroot will almost always be set.
109*/
110
111static gdb::unique_xmalloc_ptr<char>
112solib_find_1 (const char *in_pathname, int *fd, bool is_solib)
113{
114 const struct target_so_ops *ops = gdbarch_so_ops (target_gdbarch ());
115 int found_file = -1;
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;
120
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
126 used. */
128 sysroot += strlen (TARGET_SYSROOT_PREFIX);
129
130 /* Strip any trailing slashes from the absolute prefix. */
131 prefix_len = orig_prefix_len = strlen (sysroot);
132
133 while (prefix_len > 0 && IS_DIR_SEPARATOR (sysroot[prefix_len - 1]))
134 prefix_len--;
135
136 std::string sysroot_holder;
137 if (prefix_len == 0)
138 sysroot = NULL;
139 else if (prefix_len != orig_prefix_len)
140 {
141 sysroot_holder = std::string (sysroot, prefix_len);
142 sysroot = sysroot_holder.c_str ();
143 }
144
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. */
150 {
151 char *p;
152
153 /* Avoid clobbering our input. */
154 p = (char *) alloca (strlen (in_pathname) + 1);
155 strcpy (p, in_pathname);
156 in_pathname = p;
157
158 for (; *p; p++)
159 {
160 if (*p == '\\')
161 *p = '/';
162 }
163 }
164
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:
171
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
175 */
176
177 if (!IS_TARGET_ABSOLUTE_PATH (fskind, in_pathname) || sysroot == NULL)
178 temp_pathname.reset (xstrdup (in_pathname));
179 else
180 {
181 bool need_dir_separator;
182
183 /* Concatenate the sysroot and the target reported filename. We
184 may need to glue them with a directory separator. Cases to
185 consider:
186
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 |
195
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);
202
203 /* Cat the prefixed pathname together. */
204 temp_pathname.reset (concat (sysroot,
205 need_dir_separator ? SLASH_STRING : "",
206 in_pathname, (char *) NULL));
207 }
208
209 /* Handle files to be accessed via the target. */
210 if (is_target_filename (temp_pathname.get ()))
211 {
212 if (fd != NULL)
213 *fd = -1;
214 return temp_pathname;
215 }
216
217 /* Now see if we can open it. */
218 found_file = gdb_open_cloexec (temp_pathname.get (),
219 O_RDONLY | O_BINARY, 0).release ();
220
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. */
225
226 if (found_file < 0
227 && sysroot != NULL
228 && HAS_TARGET_DRIVE_SPEC (fskind, in_pathname))
229 {
230 bool need_dir_separator = !IS_DIR_SEPARATOR (in_pathname[2]);
231 char drive[2] = { in_pathname[0], '\0' };
232
233 temp_pathname.reset (concat (sysroot,
234 SLASH_STRING,
235 drive,
236 need_dir_separator ? SLASH_STRING : "",
237 in_pathname + 2, (char *) NULL));
238
239 found_file = gdb_open_cloexec (temp_pathname.get (),
240 O_RDONLY | O_BINARY, 0).release ();
241 if (found_file < 0)
242 {
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.
246
247 c:/foo/bar.dll ==> /sysroot/foo/bar.dll. */
248
249 temp_pathname.reset (concat (sysroot,
250 need_dir_separator ? SLASH_STRING : "",
251 in_pathname + 2, (char *) NULL));
252
253 found_file = gdb_open_cloexec (temp_pathname.get (),
254 O_RDONLY | O_BINARY, 0).release ();
255 }
256 }
257
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. */
262
263 if (found_file < 0)
264 temp_pathname.reset (NULL);
265
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))
271 {
272 /* First, get rid of any drive letters etc. */
273 while (!IS_TARGET_DIR_SEPARATOR (fskind, *in_pathname))
274 in_pathname++;
275
276 /* Next, get rid of all leading dir separators. */
277 while (IS_TARGET_DIR_SEPARATOR (fskind, *in_pathname))
278 in_pathname++;
279 }
280
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 (),
286 in_pathname, O_RDONLY | O_BINARY, &temp_pathname);
287
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 (),
295 target_lbasename (fskind, in_pathname),
296 O_RDONLY | O_BINARY, &temp_pathname);
297
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,
302 &temp_pathname);
303
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"),
308 O_RDONLY | O_BINARY, &temp_pathname);
309
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
314 ("LD_LIBRARY_PATH"),
316 O_RDONLY | O_BINARY, &temp_pathname);
317
318 if (fd == NULL)
319 {
320 if (found_file >= 0)
321 close (found_file);
322 }
323 else
324 *fd = found_file;
325
326 return temp_pathname;
327}
328
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. */
332
333gdb::unique_xmalloc_ptr<char>
334exec_file_find (const char *in_pathname, int *fd)
335{
336 gdb::unique_xmalloc_ptr<char> result;
337 const char *fskind = effective_target_file_system_kind ();
338
339 if (in_pathname == NULL)
340 return NULL;
341
342 if (!gdb_sysroot.empty () && IS_TARGET_ABSOLUTE_PATH (fskind, in_pathname))
343 {
344 result = solib_find_1 (in_pathname, fd, false);
345
346 if (result == NULL && fskind == file_system_kind_dos_based)
347 {
348 char *new_pathname;
349
350 new_pathname = (char *) alloca (strlen (in_pathname) + 5);
351 strcpy (new_pathname, in_pathname);
352 strcat (new_pathname, ".exe");
353
354 result = solib_find_1 (new_pathname, fd, false);
355 }
356 }
357 else
358 {
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
361 full path, sigh.
362
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...) */
366
367 if (!source_full_path_of (in_pathname, &result))
368 result.reset (xstrdup (in_pathname));
369 if (fd != NULL)
370 *fd = -1;
371 }
372
373 return result;
374}
375
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.
379
380 The search algorithm used is described in solib_find_1's comment
381 above. */
382
383gdb::unique_xmalloc_ptr<char>
384solib_find (const char *in_pathname, int *fd)
385{
386 const char *solib_symbols_extension
388
389 /* If solib_symbols_extension is set, replace the file's
390 extension. */
391 if (solib_symbols_extension != NULL)
392 {
393 const char *p = in_pathname + strlen (in_pathname);
394
395 while (p > in_pathname && *p != '.')
396 p--;
397
398 if (*p == '.')
399 {
400 char *new_pathname;
401
402 new_pathname
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);
408
409 in_pathname = new_pathname;
410 }
411 }
412
413 return solib_find_1 (in_pathname, fd, true);
414}
415
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.
419
420 If unsuccessful, the FD will be closed (unless FD was -1). */
421
423solib_bfd_fopen (const char *pathname, int fd)
424{
425 gdb_bfd_ref_ptr abfd (gdb_bfd_open (pathname, gnutarget, fd));
426
427 if (abfd == NULL)
428 {
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 ()));
432 }
433
434 return abfd;
435}
436
437/* Find shared library PATHNAME and open a BFD for it. */
438
440solib_bfd_open (const char *pathname)
441{
442 int found_file;
443 const struct bfd_arch_info *b;
444
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)
449 {
450 /* Return failure if the file could not be found, so that we can
451 accumulate messages about missing libraries. */
452 if (errno == ENOENT)
453 return NULL;
454
455 perror_with_name (pathname);
456 }
457
458 /* Open bfd for shared library. */
459 gdb_bfd_ref_ptr abfd (solib_bfd_fopen (found_pathname.get (), found_file));
460
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 ()));
465
466 /* Check bfd 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,
472 b->printable_name);
473
474 return abfd;
475}
476
477/* Mapping of a core file's shared library sonames to their respective
478 build-ids. Added to the registries of core file bfds. */
479
480typedef std::unordered_map<std::string, std::string> soname_build_id_map;
481
482/* Key used to associate a soname_build_id_map to a core file bfd. */
483
484static const struct registry<bfd>::key<soname_build_id_map>
486
487/* See solib.h. */
488
489void
490set_cbfd_soname_build_id (gdb_bfd_ref_ptr abfd,
491 const char *soname,
492 const bfd_build_id *build_id)
493{
494 gdb_assert (abfd.get () != nullptr);
495 gdb_assert (soname != nullptr);
496 gdb_assert (build_id != nullptr);
497
499
500 if (mapptr == nullptr)
501 mapptr = cbfd_soname_build_id_data_key.emplace (abfd.get ());
502
503 (*mapptr)[soname] = build_id_to_string (build_id);
504}
505
506/* See solib.h. */
507
508gdb::unique_xmalloc_ptr<char>
510{
511 if (abfd.get () == nullptr || soname == nullptr)
512 return {};
513
514 soname_build_id_map *mapptr
515 = cbfd_soname_build_id_data_key.get (abfd.get ());
516
517 if (mapptr == nullptr)
518 return {};
519
520 auto it = mapptr->find (lbasename (soname));
521 if (it == mapptr->end ())
522 return {};
523
524 return make_unique_xstrdup (it->second.c_str ());
525}
526
527/* Given a pointer to one of the shared objects in our list of mapped
528 objects, use the recorded name to open a bfd descriptor for the
529 object, build a section table, relocate all the section addresses
530 by the base address at which the shared object was mapped, and then
531 add the sections to the target's section table.
532
533 FIXME: In most (all?) cases the shared object file name recorded in
534 the dynamic linkage tables will be a fully qualified pathname. For
535 cases where it isn't, do we really mimic the systems search
536 mechanism correctly in the below code (particularly the tilde
537 expansion stuff?). */
538
539static int
541{
542 const struct target_so_ops *ops = gdbarch_so_ops (target_gdbarch ());
543
544 gdb::unique_xmalloc_ptr<char> filename (tilde_expand (so->so_name));
545 gdb_bfd_ref_ptr abfd (ops->bfd_open (filename.get ()));
546 gdb::unique_xmalloc_ptr<char> build_id_hexstr
548
549 /* If we already know the build-id of this solib from a core file, verify
550 it matches ABFD's build-id. If there is a mismatch or the solib wasn't
551 found, attempt to query debuginfod for the correct solib. */
552 if (build_id_hexstr.get () != nullptr)
553 {
554 bool mismatch = false;
555
556 if (abfd != nullptr && abfd->build_id != nullptr)
557 {
558 std::string build_id = build_id_to_string (abfd->build_id);
559
560 if (build_id != build_id_hexstr.get ())
561 mismatch = true;
562 }
563 if (abfd == nullptr || mismatch)
564 {
565 scoped_fd fd = debuginfod_exec_query ((const unsigned char*)
566 build_id_hexstr.get (),
567 0, so->so_name, &filename);
568
569 if (fd.get () >= 0)
570 abfd = ops->bfd_open (filename.get ());
571 else if (mismatch)
572 warning (_("Build-id of %ps does not match core file."),
573 styled_string (file_name_style.style (), filename.get ()));
574 }
575 }
576
577 if (abfd == NULL)
578 return 0;
579
580 /* Leave bfd open, core_xfer_memory and "info files" need it. */
581 so->abfd = abfd.release ();
582
583 /* Copy the full path name into so_name, allowing symbol_file_add
584 to find it later. This also affects the =library-loaded GDB/MI
585 event, and in particular the part of that notification providing
586 the library's host-side path. If we let the target dictate
587 that objfile's path, and the target is different from the host,
588 GDB/MI will not provide the correct host-side path. */
589 if (strlen (bfd_get_filename (so->abfd)) >= SO_NAME_MAX_PATH_SIZE)
590 error (_("Shared library file name is too long."));
591 strcpy (so->so_name, bfd_get_filename (so->abfd));
592
593 if (so->sections == nullptr)
595 *so->sections = build_section_table (so->abfd);
596
597 for (target_section &p : *so->sections)
598 {
599 /* Relocate the section binding addresses as recorded in the shared
600 object's file by the base address to which the object was actually
601 mapped. */
602 ops->relocate_section_addresses (so, &p);
603
604 /* If the target didn't provide information about the address
605 range of the shared object, assume we want the location of
606 the .text section. */
607 if (so->addr_low == 0 && so->addr_high == 0
608 && strcmp (p.the_bfd_section->name, ".text") == 0)
609 {
610 so->addr_low = p.addr;
611 so->addr_high = p.endaddr;
612 }
613 }
614
615 /* Add the shared object's sections to the current set of file
616 section tables. Do this immediately after mapping the object so
617 that later nodes in the list can query this object, as is needed
618 in solib-osf.c. */
620
621 return 1;
622}
623
624/* Free symbol-file related contents of SO and reset for possible reloading
625 of SO. If we have opened a BFD for SO, close it. If we have placed SO's
626 sections in some target's section table, the caller is responsible for
627 removing them.
628
629 This function doesn't mess with objfiles at all. If there is an
630 objfile associated with SO that needs to be removed, the caller is
631 responsible for taking care of that. */
632
633static void
634clear_so (struct so_list *so)
635{
636 const struct target_so_ops *ops = gdbarch_so_ops (target_gdbarch ());
637
638 delete so->sections;
639 so->sections = NULL;
640
641 gdb_bfd_unref (so->abfd);
642 so->abfd = NULL;
643
644 /* Our caller closed the objfile, possibly via objfile_purge_solibs. */
645 so->symbols_loaded = 0;
646 so->objfile = NULL;
647
648 so->addr_low = so->addr_high = 0;
649
650 /* Restore the target-supplied file name. SO_NAME may be the path
651 of the symbol file. */
652 strcpy (so->so_name, so->so_original_name);
653
654 /* Do the same for target-specific data. */
655 if (ops->clear_so != NULL)
656 ops->clear_so (so);
657}
658
659/* Free the storage associated with the `struct so_list' object SO.
660 If we have opened a BFD for SO, close it.
661
662 The caller is responsible for removing SO from whatever list it is
663 a member of. If we have placed SO's sections in some target's
664 section table, the caller is responsible for removing them.
665
666 This function doesn't mess with objfiles at all. If there is an
667 objfile associated with SO that needs to be removed, the caller is
668 responsible for taking care of that. */
669
670void
671free_so (struct so_list *so)
672{
673 const struct target_so_ops *ops = gdbarch_so_ops (target_gdbarch ());
674
675 clear_so (so);
676 ops->free_so (so);
677
678 xfree (so);
679}
680
681
682/* Read in symbols for shared object SO. If SYMFILE_VERBOSE is set in FLAGS,
683 be chatty about it. Return true if any symbols were actually loaded. */
684
685bool
686solib_read_symbols (struct so_list *so, symfile_add_flags flags)
687{
688 if (so->symbols_loaded)
689 {
690 /* If needed, we've already warned in our caller. */
691 }
692 else if (so->abfd == NULL)
693 {
694 /* We've already warned about this library, when trying to open
695 it. */
696 }
697 else
698 {
699
701
702 try
703 {
704 /* Have we already loaded this shared object? */
705 so->objfile = nullptr;
707 {
708 if (filename_cmp (objfile_name (objfile), so->so_name) == 0
709 && objfile->addr_low == so->addr_low)
710 {
711 so->objfile = objfile;
712 break;
713 }
714 }
715 if (so->objfile == NULL)
716 {
719 gdb_bfd_ref_ptr tmp_bfd
720 (gdb_bfd_ref_ptr::new_reference (so->abfd));
721 so->objfile = symbol_file_add_from_bfd (tmp_bfd, so->so_name,
722 flags, &sap,
723 OBJF_SHARED, NULL);
724 so->objfile->addr_low = so->addr_low;
725 }
726
727 so->symbols_loaded = 1;
728 }
729 catch (const gdb_exception_error &e)
730 {
731 exception_fprintf (gdb_stderr, e, _("Error while reading shared"
732 " library symbols for %s:\n"),
733 so->so_name);
734 }
735
736 return true;
737 }
738
739 return false;
740}
741
742/* Return true if KNOWN->objfile is used by any other so_list object
743 in the list of shared libraries. Return false otherwise. */
744
745static bool
746solib_used (const struct so_list *const known)
747{
748 for (const struct so_list *pivot : current_program_space->solibs ())
749 if (pivot != known && pivot->objfile == known->objfile)
750 return true;
751 return false;
752}
753
754/* Notify interpreters and observers that solib SO has been loaded. */
755
756static void
762
763/* Notify interpreters and observers that solib SO has been unloaded. */
764
765static void
771
772/* See solib.h. */
773
774void
775update_solib_list (int from_tty)
776{
777 const struct target_so_ops *ops = gdbarch_so_ops (target_gdbarch ());
778 struct so_list *inferior = ops->current_sos();
779 struct so_list *gdb, **gdb_link;
780
781 /* We can reach here due to changing solib-search-path or the
782 sysroot, before having any inferior. */
783 if (target_has_execution () && inferior_ptid != null_ptid)
784 {
785 struct inferior *inf = current_inferior ();
786
787 /* If we are attaching to a running process for which we
788 have not opened a symbol file, we may be able to get its
789 symbols now! */
790 if (inf->attach_flag
792 {
793 try
794 {
795 ops->open_symbol_file_object (from_tty);
796 }
797 catch (const gdb_exception_error &ex)
798 {
800 "Error reading attached "
801 "process's symbol file.\n");
802 }
803 }
804 }
805
806 /* GDB and the inferior's dynamic linker each maintain their own
807 list of currently loaded shared objects; we want to bring the
808 former in sync with the latter. Scan both lists, seeing which
809 shared objects appear where. There are three cases:
810
811 - A shared object appears on both lists. This means that GDB
812 knows about it already, and it's still loaded in the inferior.
813 Nothing needs to happen.
814
815 - A shared object appears only on GDB's list. This means that
816 the inferior has unloaded it. We should remove the shared
817 object from GDB's tables.
818
819 - A shared object appears only on the inferior's list. This
820 means that it's just been loaded. We should add it to GDB's
821 tables.
822
823 So we walk GDB's list, checking each entry to see if it appears
824 in the inferior's list too. If it does, no action is needed, and
825 we remove it from the inferior's list. If it doesn't, the
826 inferior has unloaded it, and we remove it from GDB's list. By
827 the time we're done walking GDB's list, the inferior's list
828 contains only the new shared objects, which we then add. */
829
831 gdb_link = &current_program_space->so_list;
832 while (gdb)
833 {
834 struct so_list *i = inferior;
835 struct so_list **i_link = &inferior;
836
837 /* Check to see whether the shared object *gdb also appears in
838 the inferior's current list. */
839 while (i)
840 {
841 if (ops->same)
842 {
843 if (ops->same (gdb, i))
844 break;
845 }
846 else
847 {
848 if (! filename_cmp (gdb->so_original_name, i->so_original_name))
849 break;
850 }
851
852 i_link = &i->next;
853 i = *i_link;
854 }
855
856 /* If the shared object appears on the inferior's list too, then
857 it's still loaded, so we don't need to do anything. Delete
858 it from the inferior's list, and leave it on GDB's list. */
859 if (i)
860 {
861 *i_link = i->next;
862 free_so (i);
863 gdb_link = &gdb->next;
864 gdb = *gdb_link;
865 }
866
867 /* If it's not on the inferior's list, remove it from GDB's tables. */
868 else
869 {
870 /* Notify any observer that the shared object has been
871 unloaded before we remove it from GDB's tables. */
873
874 current_program_space->deleted_solibs.push_back (gdb->so_name);
875
876 *gdb_link = gdb->next;
877
878 /* Unless the user loaded it explicitly, free SO's objfile. */
879 if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED)
880 && !solib_used (gdb))
881 gdb->objfile->unlink ();
882
883 /* Some targets' section tables might be referring to
884 sections from so->abfd; remove them. */
886
887 free_so (gdb);
888 gdb = *gdb_link;
889 }
890 }
891
892 /* Now the inferior's list contains only shared objects that don't
893 appear in GDB's list --- those that are newly loaded. Add them
894 to GDB's shared object list. */
895 if (inferior)
896 {
897 int not_found = 0;
898 const char *not_found_filename = NULL;
899
900 struct so_list *i;
901
902 /* Add the new shared objects to GDB's list. */
903 *gdb_link = inferior;
904
905 /* Fill in the rest of each of the `struct so_list' nodes. */
906 for (i = inferior; i; i = i->next)
907 {
908 current_program_space->added_solibs.push_back (i);
909
910 try
911 {
912 /* Fill in the rest of the `struct so_list' node. */
913 if (!solib_map_sections (i))
914 {
915 not_found++;
916 if (not_found_filename == NULL)
917 not_found_filename = i->so_original_name;
918 }
919 }
920
921 catch (const gdb_exception_error &e)
922 {
924 _("Error while mapping shared "
925 "library sections:\n"));
926 }
927
928 /* Notify any observer that the shared object has been
929 loaded now that we've added it to GDB's tables. */
931 }
932
933 /* If a library was not found, issue an appropriate warning
934 message. We have to use a single call to warning in case the
935 front end does something special with warnings, e.g., pop up
936 a dialog box. It Would Be Nice if we could get a "warning: "
937 prefix on each line in the CLI front end, though - it doesn't
938 stand out well. */
939
940 if (not_found == 1)
941 warning (_("Could not load shared library symbols for %s.\n"
942 "Do you need \"set solib-search-path\" "
943 "or \"set sysroot\"?"),
944 not_found_filename);
945 else if (not_found > 1)
946 warning (_("\
947Could not load shared library symbols for %d libraries, e.g. %s.\n\
948Use the \"info sharedlibrary\" command to see the complete listing.\n\
949Do you need \"set solib-search-path\" or \"set sysroot\"?"),
950 not_found, not_found_filename);
951 }
952}
953
954
955/* Return non-zero if NAME is the libpthread shared library.
956
957 Uses a fairly simplistic heuristic approach where we check
958 the file name against "/libpthread". This can lead to false
959 positives, but this should be good enough in practice.
960
961 As of glibc-2.34, functions formerly residing in libpthread have
962 been moved to libc, so "/libc." needs to be checked too. (Matching
963 the "." will avoid matching libraries such as libcrypt.) */
964
965bool
967{
968 return (strstr (name, "/libpthread") != NULL
969 || strstr (name, "/libc.") != NULL );
970}
971
972/* Return non-zero if SO is the libpthread shared library. */
973
974static bool
976{
977 return libpthread_name_p (so->so_name);
978}
979
980/* Read in symbolic information for any shared objects whose names
981 match PATTERN. (If we've already read a shared object's symbol
982 info, leave it alone.) If PATTERN is zero, read them all.
983
984 If READSYMS is 0, defer reading symbolic information until later
985 but still do any needed low level processing.
986
987 FROM_TTY is described for update_solib_list, above. */
988
989void
990solib_add (const char *pattern, int from_tty, int readsyms)
991{
992 if (print_symbol_loading_p (from_tty, 0, 0))
993 {
994 if (pattern != NULL)
995 {
996 gdb_printf (_("Loading symbols for shared libraries: %s\n"),
997 pattern);
998 }
999 else
1000 gdb_printf (_("Loading symbols for shared libraries.\n"));
1001 }
1002
1004
1005 if (pattern)
1006 {
1007 char *re_err = re_comp (pattern);
1008
1009 if (re_err)
1010 error (_("Invalid regexp: %s"), re_err);
1011 }
1012
1013 update_solib_list (from_tty);
1014
1015 /* Walk the list of currently loaded shared libraries, and read
1016 symbols for any that match the pattern --- or any whose symbols
1017 aren't already loaded, if no pattern was given. */
1018 {
1019 bool any_matches = false;
1020 bool loaded_any_symbols = false;
1021 symfile_add_flags add_flags = SYMFILE_DEFER_BP_RESET;
1022
1023 if (from_tty)
1024 add_flags |= SYMFILE_VERBOSE;
1025
1026 for (struct so_list *gdb : current_program_space->solibs ())
1027 if (! pattern || re_exec (gdb->so_name))
1028 {
1029 /* Normally, we would read the symbols from that library
1030 only if READSYMS is set. However, we're making a small
1031 exception for the pthread library, because we sometimes
1032 need the library symbols to be loaded in order to provide
1033 thread support (x86-linux for instance). */
1034 const int add_this_solib =
1035 (readsyms || libpthread_solib_p (gdb));
1036
1037 any_matches = true;
1038 if (add_this_solib)
1039 {
1040 if (gdb->symbols_loaded)
1041 {
1042 /* If no pattern was given, be quiet for shared
1043 libraries we have already loaded. */
1044 if (pattern && (from_tty || info_verbose))
1045 gdb_printf (_("Symbols already loaded for %s\n"),
1046 gdb->so_name);
1047 }
1048 else if (solib_read_symbols (gdb, add_flags))
1049 loaded_any_symbols = true;
1050 }
1051 }
1052
1053 if (loaded_any_symbols)
1055
1056 if (from_tty && pattern && ! any_matches)
1058 ("No loaded shared libraries match the pattern `%s'.\n", pattern);
1059
1060 if (loaded_any_symbols)
1061 {
1062 /* Getting new symbols may change our opinion about what is
1063 frameless. */
1065 }
1066 }
1067}
1068
1069/* Implement the "info sharedlibrary" command. Walk through the
1070 shared library list and print information about each attached
1071 library matching PATTERN. If PATTERN is elided, print them
1072 all. */
1073
1074static void
1075info_sharedlibrary_command (const char *pattern, int from_tty)
1076{
1077 bool so_missing_debug_info = false;
1078 int addr_width;
1079 int nr_libs;
1080 struct gdbarch *gdbarch = target_gdbarch ();
1081 struct ui_out *uiout = current_uiout;
1082
1083 if (pattern)
1084 {
1085 char *re_err = re_comp (pattern);
1086
1087 if (re_err)
1088 error (_("Invalid regexp: %s"), re_err);
1089 }
1090
1091 /* "0x", a little whitespace, and two hex digits per byte of pointers. */
1092 addr_width = 4 + (gdbarch_ptr_bit (gdbarch) / 4);
1093
1094 update_solib_list (from_tty);
1095
1096 /* ui_out_emit_table table_emitter needs to know the number of rows,
1097 so we need to make two passes over the libs. */
1098
1099 nr_libs = 0;
1100 for (struct so_list *so : current_program_space->solibs ())
1101 {
1102 if (so->so_name[0])
1103 {
1104 if (pattern && ! re_exec (so->so_name))
1105 continue;
1106 ++nr_libs;
1107 }
1108 }
1109
1110 {
1111 ui_out_emit_table table_emitter (uiout, 4, nr_libs, "SharedLibraryTable");
1112
1113 /* The "- 1" is because ui_out adds one space between columns. */
1114 uiout->table_header (addr_width - 1, ui_left, "from", "From");
1115 uiout->table_header (addr_width - 1, ui_left, "to", "To");
1116 uiout->table_header (12 - 1, ui_left, "syms-read", "Syms Read");
1117 uiout->table_header (0, ui_noalign, "name", "Shared Object Library");
1118
1119 uiout->table_body ();
1120
1121 for (struct so_list *so : current_program_space->solibs ())
1122 {
1123 if (! so->so_name[0])
1124 continue;
1125 if (pattern && ! re_exec (so->so_name))
1126 continue;
1127
1128 ui_out_emit_tuple tuple_emitter (uiout, "lib");
1129
1130 if (so->addr_high != 0)
1131 {
1132 uiout->field_core_addr ("from", gdbarch, so->addr_low);
1133 uiout->field_core_addr ("to", gdbarch, so->addr_high);
1134 }
1135 else
1136 {
1137 uiout->field_skip ("from");
1138 uiout->field_skip ("to");
1139 }
1140
1141 if (! top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ()
1142 && so->symbols_loaded
1143 && !objfile_has_symbols (so->objfile))
1144 {
1145 so_missing_debug_info = true;
1146 uiout->field_string ("syms-read", "Yes (*)");
1147 }
1148 else
1149 uiout->field_string ("syms-read", so->symbols_loaded ? "Yes" : "No");
1150
1151 uiout->field_string ("name", so->so_name, file_name_style.style ());
1152
1153 uiout->text ("\n");
1154 }
1155 }
1156
1157 if (nr_libs == 0)
1158 {
1159 if (pattern)
1160 uiout->message (_("No shared libraries matched.\n"));
1161 else
1162 uiout->message (_("No shared libraries loaded at this time.\n"));
1163 }
1164 else
1165 {
1166 if (so_missing_debug_info)
1167 uiout->message (_("(*): Shared library is missing "
1168 "debugging information.\n"));
1169 }
1170}
1171
1172/* See solib.h. */
1173
1174bool
1175solib_contains_address_p (const struct so_list *const solib,
1176 CORE_ADDR address)
1177{
1178 if (solib->sections == nullptr)
1179 return false;
1180
1181 for (target_section &p : *solib->sections)
1182 if (p.addr <= address && address < p.endaddr)
1183 return true;
1184
1185 return false;
1186}
1187
1188/* If ADDRESS is in a shared lib in program space PSPACE, return its
1189 name.
1190
1191 Provides a hook for other gdb routines to discover whether or not a
1192 particular address is within the mapped address space of a shared
1193 library.
1194
1195 For example, this routine is called at one point to disable
1196 breakpoints which are in shared libraries that are not currently
1197 mapped in. */
1198
1199const char *
1200solib_name_from_address (struct program_space *pspace, CORE_ADDR address)
1201{
1202 struct so_list *so = NULL;
1203
1204 for (so = pspace->so_list; so; so = so->next)
1205 if (solib_contains_address_p (so, address))
1206 return (so->so_name);
1207
1208 return (0);
1209}
1210
1211/* See solib.h. */
1212
1213bool
1214solib_keep_data_in_core (CORE_ADDR vaddr, unsigned long size)
1215{
1216 const struct target_so_ops *ops = gdbarch_so_ops (target_gdbarch ());
1217
1218 if (ops->keep_data_in_core)
1219 return ops->keep_data_in_core (vaddr, size) != 0;
1220 else
1221 return false;
1222}
1223
1224/* Called by free_all_symtabs */
1225
1226void
1228{
1229 const struct target_so_ops *ops = gdbarch_so_ops (target_gdbarch ());
1230
1232
1234 {
1236
1240 free_so (so);
1241 }
1242
1243 ops->clear_solib ();
1244}
1245
1246/* Shared library startup support. When GDB starts up the inferior,
1247 it nurses it along (through the shell) until it is ready to execute
1248 its first instruction. At this point, this function gets
1249 called. */
1250
1251void
1253{
1254 const struct target_so_ops *ops = gdbarch_so_ops (target_gdbarch ());
1255
1256 ops->solib_create_inferior_hook (from_tty);
1257}
1258
1259/* See solib.h. */
1260
1261bool
1263{
1264 const struct target_so_ops *ops = gdbarch_so_ops (target_gdbarch ());
1265
1266 return ops->in_dynsym_resolve_code (pc) != 0;
1267}
1268
1269/* Implements the "sharedlibrary" command. */
1270
1271static void
1272sharedlibrary_command (const char *args, int from_tty)
1273{
1274 dont_repeat ();
1275 solib_add (args, from_tty, 1);
1276}
1277
1278/* Implements the command "nosharedlibrary", which discards symbols
1279 that have been auto-loaded from shared libraries. Symbols from
1280 shared libraries that were added by explicit request of the user
1281 are not discarded. Also called from remote.c. */
1282
1283void
1284no_shared_libraries (const char *ignored, int from_tty)
1285{
1286 /* The order of the two routines below is important: clear_solib notifies
1287 the solib_unloaded observers, and some of these observers might need
1288 access to their associated objfiles. Therefore, we can not purge the
1289 solibs' objfiles before clear_solib has been called. */
1290
1291 clear_solib ();
1293}
1294
1295/* See solib.h. */
1296
1297void
1299{
1300 const struct target_so_ops *ops = gdbarch_so_ops (target_gdbarch ());
1301
1302 if (ops->update_breakpoints != NULL)
1303 ops->update_breakpoints ();
1304}
1305
1306/* See solib.h. */
1307
1308void
1310{
1311 const struct target_so_ops *ops = gdbarch_so_ops (target_gdbarch ());
1312
1313 if (ops->handle_event != NULL)
1314 ops->handle_event ();
1315
1317
1318 /* Check for any newly added shared libraries if we're supposed to
1319 be adding them automatically. Switch terminal for any messages
1320 produced by breakpoint_re_set. */
1322 solib_add (NULL, 0, auto_solib_add);
1324}
1325
1326/* Reload shared libraries, but avoid reloading the same symbol file
1327 we already have loaded. */
1328
1329static void
1331{
1332 if (print_symbol_loading_p (from_tty, 0, 0))
1333 gdb_printf (_("Loading symbols for shared libraries.\n"));
1334
1335 for (struct so_list *so : current_program_space->solibs ())
1336 {
1337 const char *found_pathname = NULL;
1338 bool was_loaded = so->symbols_loaded != 0;
1339 symfile_add_flags add_flags = SYMFILE_DEFER_BP_RESET;
1340
1341 if (from_tty)
1342 add_flags |= SYMFILE_VERBOSE;
1343
1344 gdb::unique_xmalloc_ptr<char> filename
1345 (tilde_expand (so->so_original_name));
1346 gdb_bfd_ref_ptr abfd (solib_bfd_open (filename.get ()));
1347 if (abfd != NULL)
1348 found_pathname = bfd_get_filename (abfd.get ());
1349
1350 /* If this shared library is no longer associated with its previous
1351 symbol file, close that. */
1352 if ((found_pathname == NULL && was_loaded)
1353 || (found_pathname != NULL
1354 && filename_cmp (found_pathname, so->so_name) != 0))
1355 {
1356 if (so->objfile && ! (so->objfile->flags & OBJF_USERLOADED)
1357 && !solib_used (so))
1358 so->objfile->unlink ();
1360 clear_so (so);
1361 }
1362
1363 /* If this shared library is now associated with a new symbol
1364 file, open it. */
1365 if (found_pathname != NULL
1366 && (!was_loaded
1367 || filename_cmp (found_pathname, so->so_name) != 0))
1368 {
1369 bool got_error = false;
1370
1371 try
1372 {
1373 solib_map_sections (so);
1374 }
1375
1376 catch (const gdb_exception_error &e)
1377 {
1379 _("Error while mapping "
1380 "shared library sections:\n"));
1381 got_error = true;
1382 }
1383
1384 if (!got_error
1385 && (auto_solib_add || was_loaded || libpthread_solib_p (so)))
1386 solib_read_symbols (so, add_flags);
1387 }
1388 }
1389}
1390
1391static void
1392reload_shared_libraries (const char *ignored, int from_tty,
1393 struct cmd_list_element *e)
1394{
1395 const struct target_so_ops *ops;
1396
1397 reload_shared_libraries_1 (from_tty);
1398
1399 ops = gdbarch_so_ops (target_gdbarch ());
1400
1401 /* Creating inferior hooks here has two purposes. First, if we reload
1402 shared libraries then the address of solib breakpoint we've computed
1403 previously might be no longer valid. For example, if we forgot to set
1404 solib-absolute-prefix and are setting it right now, then the previous
1405 breakpoint address is plain wrong. Second, installing solib hooks
1406 also implicitly figures were ld.so is and loads symbols for it.
1407 Absent this call, if we've just connected to a target and set
1408 solib-absolute-prefix or solib-search-path, we'll lose all information
1409 about ld.so. */
1410 if (target_has_execution ())
1411 {
1412 /* Reset or free private data structures not associated with
1413 so_list entries. */
1414 ops->clear_solib ();
1415
1416 /* Remove any previous solib event breakpoint. This is usually
1417 done in common code, at breakpoint_init_inferior time, but
1418 we're not really starting up the inferior here. */
1420
1421 solib_create_inferior_hook (from_tty);
1422 }
1423
1424 /* Sometimes the platform-specific hook loads initial shared
1425 libraries, and sometimes it doesn't. If it doesn't FROM_TTY will be
1426 incorrectly 0 but such solib targets should be fixed anyway. If we
1427 made all the inferior hook methods consistent, this call could be
1428 removed. Call it only after the solib target has been initialized by
1429 solib_create_inferior_hook. */
1430
1431 solib_add (NULL, 0, auto_solib_add);
1432
1434
1435 /* We may have loaded or unloaded debug info for some (or all)
1436 shared libraries. However, frames may still reference them. For
1437 example, a frame's unwinder might still point at DWARF FDE
1438 structures that are now freed. Also, getting new symbols may
1439 change our opinion about what is frameless. */
1441}
1442
1443/* Wrapper for reload_shared_libraries that replaces "remote:"
1444 at the start of gdb_sysroot with "target:". */
1445
1446static void
1447gdb_sysroot_changed (const char *ignored, int from_tty,
1448 struct cmd_list_element *e)
1449{
1450 const char *old_prefix = "remote:";
1451 const char *new_prefix = TARGET_SYSROOT_PREFIX;
1452
1453 if (startswith (gdb_sysroot.c_str (), old_prefix))
1454 {
1455 static bool warning_issued = false;
1456
1457 gdb_assert (strlen (old_prefix) == strlen (new_prefix));
1458 gdb_sysroot = new_prefix + gdb_sysroot.substr (strlen (old_prefix));
1459
1460 if (!warning_issued)
1461 {
1462 warning (_("\"%s\" is deprecated, use \"%s\" instead."),
1463 old_prefix, new_prefix);
1464 warning (_("sysroot set to \"%s\"."), gdb_sysroot.c_str ());
1465
1466 warning_issued = true;
1467 }
1468 }
1469
1470 reload_shared_libraries (ignored, from_tty, e);
1471}
1472
1473static void
1474show_auto_solib_add (struct ui_file *file, int from_tty,
1475 struct cmd_list_element *c, const char *value)
1476{
1477 gdb_printf (file, _("Autoloading of shared library symbols is %s.\n"),
1478 value);
1479}
1480
1481
1482/* Lookup the value for a specific symbol from dynamic symbol table. Look
1483 up symbol from ABFD. MATCH_SYM is a callback function to determine
1484 whether to pick up a symbol. DATA is the input of this callback
1485 function. Return 0 if symbol is not found. */
1486
1487CORE_ADDR
1489 (bfd *abfd, gdb::function_view<bool (const asymbol *)> match_sym)
1490{
1491 long storage_needed = bfd_get_symtab_upper_bound (abfd);
1492 CORE_ADDR symaddr = 0;
1493
1494 if (storage_needed > 0)
1495 {
1496 unsigned int i;
1497
1498 gdb::def_vector<asymbol *> storage (storage_needed / sizeof (asymbol *));
1499 asymbol **symbol_table = storage.data ();
1500 unsigned int number_of_symbols =
1501 bfd_canonicalize_symtab (abfd, symbol_table);
1502
1503 for (i = 0; i < number_of_symbols; i++)
1504 {
1505 asymbol *sym = *symbol_table++;
1506
1507 if (match_sym (sym))
1508 {
1509 struct gdbarch *gdbarch = target_gdbarch ();
1510 symaddr = sym->value;
1511
1512 /* Some ELF targets fiddle with addresses of symbols they
1513 consider special. They use minimal symbols to do that
1514 and this is needed for correct breakpoint placement,
1515 but we do not have full data here to build a complete
1516 minimal symbol, so just set the address and let the
1517 targets cope with that. */
1518 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1520 {
1521 struct minimal_symbol msym {};
1522
1523 msym.set_value_address (symaddr);
1525 symaddr = CORE_ADDR (msym.unrelocated_address ());
1526 }
1527
1528 /* BFD symbols are section relative. */
1529 symaddr += sym->section->vma;
1530 break;
1531 }
1532 }
1533 }
1534
1535 return symaddr;
1536}
1537
1538/* See solib.h. */
1539
1540int
1541gdb_bfd_scan_elf_dyntag (const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr,
1542 CORE_ADDR *ptr_addr)
1543{
1544 int arch_size, step, sect_size;
1545 long current_dyntag;
1546 CORE_ADDR dyn_ptr, dyn_addr;
1547 gdb_byte *bufend, *bufstart, *buf;
1548 Elf32_External_Dyn *x_dynp_32;
1549 Elf64_External_Dyn *x_dynp_64;
1550 struct bfd_section *sect;
1551
1552 if (abfd == NULL)
1553 return 0;
1554
1555 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1556 return 0;
1557
1558 arch_size = bfd_get_arch_size (abfd);
1559 if (arch_size == -1)
1560 return 0;
1561
1562 /* Find the start address of the .dynamic section. */
1563 sect = bfd_get_section_by_name (abfd, ".dynamic");
1564 if (sect == NULL)
1565 return 0;
1566
1567 bool found = false;
1568 for (const target_section &target_section
1570 if (sect == target_section.the_bfd_section)
1571 {
1572 dyn_addr = target_section.addr;
1573 found = true;
1574 break;
1575 }
1576 if (!found)
1577 {
1578 /* ABFD may come from OBJFILE acting only as a symbol file without being
1579 loaded into the target (see add_symbol_file_command). This case is
1580 such fallback to the file VMA address without the possibility of
1581 having the section relocated to its actual in-memory address. */
1582
1583 dyn_addr = bfd_section_vma (sect);
1584 }
1585
1586 /* Read in .dynamic from the BFD. We will get the actual value
1587 from memory later. */
1588 sect_size = bfd_section_size (sect);
1589 buf = bufstart = (gdb_byte *) alloca (sect_size);
1590 if (!bfd_get_section_contents (abfd, sect,
1591 buf, 0, sect_size))
1592 return 0;
1593
1594 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
1595 step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
1596 : sizeof (Elf64_External_Dyn);
1597 for (bufend = buf + sect_size;
1598 buf < bufend;
1599 buf += step)
1600 {
1601 if (arch_size == 32)
1602 {
1603 x_dynp_32 = (Elf32_External_Dyn *) buf;
1604 current_dyntag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);
1605 dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);
1606 }
1607 else
1608 {
1609 x_dynp_64 = (Elf64_External_Dyn *) buf;
1610 current_dyntag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
1611 dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);
1612 }
1613 if (current_dyntag == DT_NULL)
1614 return 0;
1615 if (current_dyntag == desired_dyntag)
1616 {
1617 /* If requested, try to read the runtime value of this .dynamic
1618 entry. */
1619 if (ptr)
1620 {
1621 struct type *ptr_type;
1622 gdb_byte ptr_buf[8];
1623 CORE_ADDR ptr_addr_1;
1624
1626 ptr_addr_1 = dyn_addr + (buf - bufstart) + arch_size / 8;
1627 if (target_read_memory (ptr_addr_1, ptr_buf, arch_size / 8) == 0)
1628 dyn_ptr = extract_typed_address (ptr_buf, ptr_type);
1629 *ptr = dyn_ptr;
1630 if (ptr_addr)
1631 *ptr_addr = dyn_addr + (buf - bufstart);
1632 }
1633 return 1;
1634 }
1635 }
1636
1637 return 0;
1638}
1639
1640/* See solib.h. */
1641
1642gdb::unique_xmalloc_ptr<char>
1643gdb_bfd_read_elf_soname (const char *filename)
1644{
1645 gdb_bfd_ref_ptr abfd = gdb_bfd_open (filename, gnutarget);
1646
1647 if (abfd == nullptr)
1648 return {};
1649
1650 /* Check that ABFD is an ET_DYN ELF file. */
1651 if (!bfd_check_format (abfd.get (), bfd_object)
1652 || !(bfd_get_file_flags (abfd.get ()) & DYNAMIC))
1653 return {};
1654
1655 CORE_ADDR idx;
1656 if (!gdb_bfd_scan_elf_dyntag (DT_SONAME, abfd.get (), &idx, nullptr))
1657 return {};
1658
1659 struct bfd_section *dynstr = bfd_get_section_by_name (abfd.get (), ".dynstr");
1660 int sect_size = bfd_section_size (dynstr);
1661 if (dynstr == nullptr || sect_size <= idx)
1662 return {};
1663
1664 /* Read soname from the string table. */
1665 gdb::byte_vector dynstr_buf;
1666 if (!gdb_bfd_get_full_section_contents (abfd.get (), dynstr, &dynstr_buf))
1667 return {};
1668
1669 /* Ensure soname is null-terminated before returning a copy. */
1670 char *soname = (char *) dynstr_buf.data () + idx;
1671 if (strnlen (soname, sect_size - idx) == sect_size - idx)
1672 return {};
1673
1674 return make_unique_xstrdup (soname);
1675}
1676
1677/* Lookup the value for a specific symbol from symbol table. Look up symbol
1678 from ABFD. MATCH_SYM is a callback function to determine whether to pick
1679 up a symbol. DATA is the input of this callback function. Return 0
1680 if symbol is not found. */
1681
1682static CORE_ADDR
1684 (bfd *abfd, gdb::function_view<bool (const asymbol *)> match_sym)
1685{
1686 long storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
1687 CORE_ADDR symaddr = 0;
1688
1689 if (storage_needed > 0)
1690 {
1691 unsigned int i;
1692 gdb::def_vector<asymbol *> storage (storage_needed / sizeof (asymbol *));
1693 asymbol **symbol_table = storage.data ();
1694 unsigned int number_of_symbols =
1695 bfd_canonicalize_dynamic_symtab (abfd, symbol_table);
1696
1697 for (i = 0; i < number_of_symbols; i++)
1698 {
1699 asymbol *sym = *symbol_table++;
1700
1701 if (match_sym (sym))
1702 {
1703 /* BFD symbols are section relative. */
1704 symaddr = sym->value + sym->section->vma;
1705 break;
1706 }
1707 }
1708 }
1709 return symaddr;
1710}
1711
1712/* Lookup the value for a specific symbol from symbol table and dynamic
1713 symbol table. Look up symbol from ABFD. MATCH_SYM is a callback
1714 function to determine whether to pick up a symbol. DATA is the
1715 input of this callback function. Return 0 if symbol is not
1716 found. */
1717
1718CORE_ADDR
1720 (bfd *abfd, gdb::function_view<bool (const asymbol *)> match_sym)
1721{
1722 CORE_ADDR symaddr = gdb_bfd_lookup_symbol_from_symtab (abfd, match_sym);
1723
1724 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
1725 have to check the dynamic string table too. */
1726 if (symaddr == 0)
1727 symaddr = bfd_lookup_symbol_from_dyn_symtab (abfd, match_sym);
1728
1729 return symaddr;
1730}
1731
1732/* The shared library list may contain user-loaded object files that
1733 can be removed out-of-band by the user. So upon notification of
1734 free_objfile remove all references to any user-loaded file that is
1735 about to be freed. */
1736
1737static void
1739{
1740 if (objfile != 0 && objfile->flags & OBJF_USERLOADED)
1741 {
1742 for (struct so_list *so : objfile->pspace->solibs ())
1743 if (so->objfile == objfile)
1744 so->objfile = NULL;
1745 }
1746}
1747
1748void _initialize_solib ();
1749void
1751{
1753 "solib");
1754 gdb::observers::inferior_execd.attach ([] (inferior *exec_inf,
1755 inferior *follow_inf)
1756 {
1758 }, "solib");
1759
1760 add_com ("sharedlibrary", class_files, sharedlibrary_command,
1761 _("Load shared object library symbols for files matching REGEXP."));
1762 cmd_list_element *info_sharedlibrary_cmd
1763 = add_info ("sharedlibrary", info_sharedlibrary_command,
1764 _("Status of loaded shared object libraries."));
1765 add_info_alias ("dll", info_sharedlibrary_cmd, 1);
1766 add_com ("nosharedlibrary", class_files, no_shared_libraries,
1767 _("Unload all shared object library symbols."));
1768
1769 add_setshow_boolean_cmd ("auto-solib-add", class_support,
1770 &auto_solib_add, _("\
1771Set autoloading of shared library symbols."), _("\
1772Show autoloading of shared library symbols."), _("\
1773If \"on\", symbols from all shared object libraries will be loaded\n\
1774automatically when the inferior begins execution, when the dynamic linker\n\
1775informs gdb that a new library has been loaded, or when attaching to the\n\
1776inferior. Otherwise, symbols must be loaded manually, using \
1777`sharedlibrary'."),
1778 NULL,
1780 &setlist, &showlist);
1781
1782 set_show_commands sysroot_cmds
1784 &gdb_sysroot, _("\
1785Set an alternate system root."), _("\
1786Show the current system root."), _("\
1787The system root is used to load absolute shared library symbol files.\n\
1788For other (relative) files, you can add directories using\n\
1789`set solib-search-path'."),
1791 NULL,
1792 &setlist, &showlist);
1793
1794 add_alias_cmd ("solib-absolute-prefix", sysroot_cmds.set, class_support, 0,
1795 &setlist);
1796 add_alias_cmd ("solib-absolute-prefix", sysroot_cmds.show, class_support, 0,
1797 &showlist);
1798
1800 &solib_search_path, _("\
1801Set the search path for loading non-absolute shared library symbol files."),
1802 _("\
1803Show the search path for loading non-absolute shared library symbol files."),
1804 _("\
1805This takes precedence over the environment variables \
1806PATH and LD_LIBRARY_PATH."),
1809 &setlist, &showlist);
1810
1812 &debug_solib, _("\
1813Set solib debugging."), _("\
1814Show solib debugging."), _("\
1815When true, solib-related debugging output is enabled."),
1816 nullptr, nullptr,
1818}
const char *const name
void xfree(void *)
struct gdbarch * target_gdbarch(void)
void breakpoint_re_set(void)
void remove_solib_event_breakpoints(void)
void disable_breakpoints_in_shlibs(void)
static std::string build_id_to_string(const bfd_build_id *build_id)
Definition build-id.h:66
ui_file_style style() const
Definition cli-style.c:169
symfile_add_flags symfile_flags
Definition inferior.h:644
struct program_space * pspace
Definition inferior.h:582
void * get(unsigned key)
Definition registry.h:211
static void inferior()
Definition target.c:952
static void ours_for_output()
Definition target.c:1088
void field_core_addr(const char *fldname, struct gdbarch *gdbarch, CORE_ADDR address)
Definition ui-out.c:478
void field_string(const char *fldname, const char *string, const ui_file_style &style=ui_file_style())
Definition ui-out.c:511
void field_skip(const char *fldname)
Definition ui-out.c:499
void text(const char *string)
Definition ui-out.c:566
void table_header(int width, ui_align align, const std::string &col_name, const std::string &col_hdr)
Definition ui-out.c:363
bool is_mi_like_p() const
Definition ui-out.c:810
void table_body()
Definition ui-out.c:376
void message(const char *format,...) ATTRIBUTE_PRINTF(2
Definition ui-out.c:774
struct cmd_list_element * showlist
Definition cli-cmds.c:127
struct cmd_list_element * setlist
Definition cli-cmds.c:119
struct cmd_list_element * showdebuglist
Definition cli-cmds.c:167
struct cmd_list_element * setdebuglist
Definition cli-cmds.c:165
struct cmd_list_element * add_alias_cmd(const char *name, cmd_list_element *target, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition cli-decode.c:294
set_show_commands add_setshow_optional_filename_cmd(const char *name, enum command_class theclass, std::string *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc)
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:809
cmd_list_element * add_info_alias(const char *name, cmd_list_element *target, int abbrev_flag)
struct cmd_list_element * add_info(const char *name, cmd_simple_func_ftype *fun, const char *doc)
cli_style_option file_name_style
void dont_repeat()
Definition top.c:696
@ class_maintenance
Definition command.h:65
@ class_support
Definition command.h:58
@ class_files
Definition command.h:57
const char * gnutarget
Definition corefile.c:405
scoped_fd debuginfod_exec_query(const unsigned char *build_id, int build_id_len, const char *filename, gdb::unique_xmalloc_ptr< char > *destname)
#define O_BINARY
Definition defs.h:114
EXTERN_C char * re_comp(const char *)
bool info_verbose
Definition top.c:1941
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition findvar.c:152
std::string gdb_sysroot
Definition main.c:64
void exception_fprintf(struct ui_file *file, const struct gdb_exception &e, const char *prefix,...)
Definition exceptions.c:116
target_section_table build_section_table(struct bfd *some_bfd)
Definition exec.c:572
const char * target_lbasename(const char *kind, const char *name)
Definition filesystem.c:52
const char file_system_kind_dos_based[]
Definition filesystem.c:27
const char * effective_target_file_system_kind(void)
Definition filesystem.c:38
#define IS_TARGET_ABSOLUTE_PATH(kind, p)
Definition filesystem.h:38
#define HAS_TARGET_DRIVE_SPEC(kind, p)
Definition filesystem.h:45
#define IS_TARGET_DIR_SEPARATOR(kind, c)
Definition filesystem.h:31
void reinit_frame_cache(void)
Definition frame.c:2107
void gdb_bfd_unref(struct bfd *abfd)
Definition gdb_bfd.c:647
int is_target_filename(const char *name)
Definition gdb_bfd.c:207
gdb_bfd_ref_ptr gdb_bfd_open(const char *name, const char *target, int fd, bool warn_if_slow)
Definition gdb_bfd.c:473
bool gdb_bfd_get_full_section_contents(bfd *abfd, asection *section, gdb::byte_vector *contents)
Definition gdb_bfd.c:1034
#define TARGET_SYSROOT_PREFIX
Definition gdb_bfd.h:41
gdb::ref_ptr< struct bfd, gdb_bfd_ref_policy > gdb_bfd_ref_ptr
Definition gdb_bfd.h:79
const struct target_so_ops * gdbarch_so_ops(struct gdbarch *gdbarch)
Definition gdbarch.c:3370
void gdbarch_elf_make_msymbol_special(struct gdbarch *gdbarch, asymbol *sym, struct minimal_symbol *msym)
Definition gdbarch.c:3462
bool gdbarch_elf_make_msymbol_special_p(struct gdbarch *gdbarch)
Definition gdbarch.c:3455
const char * gdbarch_solib_symbols_extension(struct gdbarch *gdbarch)
Definition gdbarch.c:4973
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition gdbarch.c:1387
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1722
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition gdbtypes.c:6168
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition gnu-nat.c:1861
size_t size
Definition go32-nat.c:239
ptid_t inferior_ptid
Definition infcmd.c:74
struct inferior * current_inferior(void)
Definition inferior.c:55
void interps_notify_solib_loaded(so_list *so)
Definition interps.c:491
struct interp * top_level_interpreter(void)
Definition interps.c:345
void interps_notify_solib_unloaded(so_list *so)
Definition interps.c:499
observable< struct so_list * > solib_loaded
observable< struct objfile * > free_objfile
observable< inferior *, inferior * > inferior_execd
observable< struct program_space *, struct so_list * > solib_unloaded
@ OBJF_USERLOADED
@ OBJF_SHARED
int objfile_has_symbols(struct objfile *objfile)
Definition objfiles.c:749
void objfile_purge_solibs(void)
Definition objfiles.c:794
const char * objfile_name(const struct objfile *objfile)
Definition objfiles.c:1259
struct program_space * current_program_space
Definition progspace.c:40
static void clear_so(struct so_list *so)
Definition solib.c:634
bool libpthread_name_p(const char *name)
Definition solib.c:966
CORE_ADDR gdb_bfd_lookup_symbol_from_symtab(bfd *abfd, gdb::function_view< bool(const asymbol *)> match_sym)
Definition solib.c:1489
static void info_sharedlibrary_command(const char *pattern, int from_tty)
Definition solib.c:1075
void set_cbfd_soname_build_id(gdb_bfd_ref_ptr abfd, const char *soname, const bfd_build_id *build_id)
Definition solib.c:490
static void notify_solib_unloaded(program_space *pspace, so_list *so)
Definition solib.c:766
gdb::unique_xmalloc_ptr< char > get_cbfd_soname_build_id(gdb_bfd_ref_ptr abfd, const char *soname)
Definition solib.c:509
bool solib_read_symbols(struct so_list *so, symfile_add_flags flags)
Definition solib.c:686
std::unordered_map< std::string, std::string > soname_build_id_map
Definition solib.c:480
static void gdb_sysroot_changed(const char *ignored, int from_tty, struct cmd_list_element *e)
Definition solib.c:1447
static void reload_shared_libraries_1(int from_tty)
Definition solib.c:1330
static CORE_ADDR bfd_lookup_symbol_from_dyn_symtab(bfd *abfd, gdb::function_view< bool(const asymbol *)> match_sym)
Definition solib.c:1684
void solib_create_inferior_hook(int from_tty)
Definition solib.c:1252
static gdb::unique_xmalloc_ptr< char > solib_find_1(const char *in_pathname, int *fd, bool is_solib)
Definition solib.c:112
gdb::unique_xmalloc_ptr< char > exec_file_find(const char *in_pathname, int *fd)
Definition solib.c:334
void free_so(struct so_list *so)
Definition solib.c:671
void clear_solib(void)
Definition solib.c:1227
static int solib_map_sections(struct so_list *so)
Definition solib.c:540
#define DOS_BASED_FILE_SYSTEM
Definition solib.c:73
gdb::unique_xmalloc_ptr< char > gdb_bfd_read_elf_soname(const char *filename)
Definition solib.c:1643
static std::string solib_search_path
Definition solib.c:59
bool solib_contains_address_p(const struct so_list *const solib, CORE_ADDR address)
Definition solib.c:1175
void update_solib_list(int from_tty)
Definition solib.c:775
static bool solib_used(const struct so_list *const known)
Definition solib.c:746
static void notify_solib_loaded(so_list *so)
Definition solib.c:757
static void show_auto_solib_add(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition solib.c:1474
void solib_add(const char *pattern, int from_tty, int readsyms)
Definition solib.c:990
bool debug_solib
Definition solib.c:54
const char * solib_name_from_address(struct program_space *pspace, CORE_ADDR address)
Definition solib.c:1200
gdb_bfd_ref_ptr solib_bfd_fopen(const char *pathname, int fd)
Definition solib.c:423
gdb_bfd_ref_ptr solib_bfd_open(const char *pathname)
Definition solib.c:440
void no_shared_libraries(const char *ignored, int from_tty)
Definition solib.c:1284
gdb::unique_xmalloc_ptr< char > solib_find(const char *in_pathname, int *fd)
Definition solib.c:384
CORE_ADDR gdb_bfd_lookup_symbol(bfd *abfd, gdb::function_view< bool(const asymbol *)> match_sym)
Definition solib.c:1720
int gdb_bfd_scan_elf_dyntag(const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr, CORE_ADDR *ptr_addr)
Definition solib.c:1541
static bool libpthread_solib_p(struct so_list *so)
Definition solib.c:975
bool in_solib_dynsym_resolve_code(CORE_ADDR pc)
Definition solib.c:1262
static void reload_shared_libraries(const char *ignored, int from_tty, struct cmd_list_element *e)
Definition solib.c:1392
void update_solib_breakpoints(void)
Definition solib.c:1298
static const struct registry< bfd >::key< soname_build_id_map > cbfd_soname_build_id_data_key
Definition solib.c:484
bool solib_keep_data_in_core(CORE_ADDR vaddr, unsigned long size)
Definition solib.c:1214
static void show_solib_search_path(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition solib.c:61
static void sharedlibrary_command(const char *args, int from_tty)
Definition solib.c:1272
void handle_solib_event(void)
Definition solib.c:1309
void _initialize_solib()
Definition solib.c:1750
static void remove_user_added_objfile(struct objfile *objfile)
Definition solib.c:1738
#define SO_NAME_MAX_PATH_SIZE
Definition solist.h:22
int openp(const char *path, openp_flags opts, const char *string, int mode, gdb::unique_xmalloc_ptr< char > *filename_opened)
Definition source.c:772
int source_full_path_of(const char *filename, gdb::unique_xmalloc_ptr< char > *full_pathname)
Definition source.c:944
@ OPF_TRY_CWD_FIRST
Definition source.h:30
@ OPF_RETURN_REALPATH
Definition source.h:32
struct type * builtin_data_ptr
Definition gdbtypes.h:2135
void set_value_address(CORE_ADDR address)
Definition symtab.h:522
Definition gnu-nat.c:153
unrelocated_addr unrelocated_address() const
Definition symtab.h:756
struct program_space * pspace
Definition objfiles.h:728
CORE_ADDR addr_low
Definition objfiles.h:720
objfile_flags flags
Definition objfiles.h:724
void remove_target_sections(void *owner)
Definition exec.c:654
void add_target_sections(void *owner, const target_section_table &sections)
Definition exec.c:602
objfiles_range objfiles()
Definition progspace.h:209
std::vector< std::string > deleted_solibs
Definition progspace.h:375
std::vector< struct so_list * > added_solibs
Definition progspace.h:371
unsigned int solib_add_generation
Definition progspace.h:367
target_section_table & target_sections()
Definition progspace.h:307
struct objfile * symfile_object_file
Definition progspace.h:357
gdb_bfd_ref_ptr cbfd
Definition progspace.h:328
struct so_list * so_list
Definition progspace.h:364
void clear_solib_cache()
Definition progspace.c:436
so_list_range solibs() const
Definition progspace.h:260
cmd_list_element * set
Definition command.h:422
cmd_list_element * show
Definition command.h:422
bfd * abfd
Definition solist.h:64
char so_name[SO_NAME_MAX_PATH_SIZE]
Definition solist.h:56
CORE_ADDR addr_high
Definition solist.h:80
struct so_list * next
Definition solist.h:40
char so_original_name[SO_NAME_MAX_PATH_SIZE]
Definition solist.h:53
target_section_table * sections
Definition solist.h:72
struct objfile * objfile
Definition solist.h:70
char symbols_loaded
Definition solist.h:65
CORE_ADDR addr_low
Definition solist.h:80
struct bfd_section * the_bfd_section
void(* solib_create_inferior_hook)(int from_tty)
Definition solist.h:104
int(* in_dynsym_resolve_code)(CORE_ADDR pc)
Definition solist.h:121
int(* same)(struct so_list *gdb, struct so_list *inferior)
Definition solist.h:139
void(* free_so)(struct so_list *so)
Definition solist.h:92
void(* clear_solib)(void)
Definition solist.h:101
void(* handle_event)(void)
Definition solist.h:160
int(* find_and_open_solib)(const char *soname, unsigned o_flags, gdb::unique_xmalloc_ptr< char > *temp_pathname)
Definition solist.h:130
void(* clear_so)(struct so_list *so)
Definition solist.h:97
int(* open_symbol_file_object)(int from_ttyp)
Definition solist.h:117
struct so_list *(* current_sos)(void)
Definition solist.h:113
int(* keep_data_in_core)(CORE_ADDR vaddr, unsigned long size)
Definition solist.h:146
gdb_bfd_ref_ptr(* bfd_open)(const char *pathname)
Definition solist.h:124
void(* relocate_section_addresses)(struct so_list *so, struct target_section *)
Definition solist.h:87
void(* update_breakpoints)(void)
Definition solist.h:154
Definition value.h:130
@ SYMFILE_VERBOSE
@ SYMFILE_DEFER_BP_RESET
bool auto_solib_add
Definition symfile.c:149
section_addr_info build_section_addr_info_from_section_table(const target_section_table &table)
Definition symfile.c:218
int print_symbol_loading_p(int from_tty, int exec, int full)
Definition symfile.c:161
struct objfile * symbol_file_add_from_bfd(const gdb_bfd_ref_ptr &abfd, const char *name, symfile_add_flags add_flags, section_addr_info *addrs, objfile_flags flags, struct objfile *parent)
Definition symfile.c:1155
std::vector< other_sections > section_addr_info
Definition symfile.h:74
std::vector< target_section > target_section_table
bool target_filesystem_is_local()
Definition target.c:608
bool target_has_execution(inferior *inf)
Definition target.c:201
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1785
static styled_string_s * styled_string(const ui_file_style &style, const char *str, styled_string_s &&tmp={})
Definition ui-out.h:151
@ ui_noalign
Definition ui-out.h:48
@ ui_left
Definition ui-out.h:45
#define current_uiout
Definition ui-out.h:40
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
#define gdb_stderr
Definition utils.h:187