1 /* Handle shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 1990-2017 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>
32 #include "gdb_regex.h"
37 #include "completer.h"
38 #include "filenames.h" /* for DOSish file names */
42 #include "readline/readline.h"
46 #include "filesystem.h"
48 #include "filestuff.h"
50 /* Architecture-specific operations. */
52 /* Per-architecture data key. */
53 static struct gdbarch_data
*solib_data
;
56 solib_init (struct obstack
*obstack
)
58 struct target_so_ops
**ops
;
60 ops
= OBSTACK_ZALLOC (obstack
, struct target_so_ops
*);
61 *ops
= current_target_so_ops
;
65 static const struct target_so_ops
*
66 solib_ops (struct gdbarch
*gdbarch
)
68 const struct target_so_ops
**ops
69 = (const struct target_so_ops
**) gdbarch_data (gdbarch
, solib_data
);
74 /* Set the solib operations for GDBARCH to NEW_OPS. */
77 set_solib_ops (struct gdbarch
*gdbarch
, const struct target_so_ops
*new_ops
)
79 const struct target_so_ops
**ops
80 = (const struct target_so_ops
**) gdbarch_data (gdbarch
, solib_data
);
86 /* external data declarations */
88 /* FIXME: gdbarch needs to control this variable, or else every
89 configuration needs to call set_solib_ops. */
90 struct target_so_ops
*current_target_so_ops
;
92 /* List of known shared objects */
93 #define so_list_head current_program_space->so_list
95 /* Local function prototypes */
97 /* If non-empty, this is a search path for loading non-absolute shared library
98 symbol files. This takes precedence over the environment variables PATH
99 and LD_LIBRARY_PATH. */
100 static char *solib_search_path
= NULL
;
102 show_solib_search_path (struct ui_file
*file
, int from_tty
,
103 struct cmd_list_element
*c
, const char *value
)
105 fprintf_filtered (file
, _("The search path for loading non-absolute "
106 "shared library symbol files is %s.\n"),
110 /* Same as HAVE_DOS_BASED_FILE_SYSTEM, but useable as an rvalue. */
111 #if (HAVE_DOS_BASED_FILE_SYSTEM)
112 # define DOS_BASED_FILE_SYSTEM 1
114 # define DOS_BASED_FILE_SYSTEM 0
117 /* Return the full pathname of a binary file (the main executable
118 or a shared library file), or NULL if not found. The returned
119 pathname is malloc'ed and must be freed by the caller. If FD
120 is non-NULL, *FD is set to either -1 or an open file handle for
123 Global variable GDB_SYSROOT is used as a prefix directory
124 to search for binary files if they have an absolute path.
125 If GDB_SYSROOT starts with "target:" and target filesystem
126 is the local filesystem then the "target:" prefix will be
127 stripped before the search starts. This ensures that the
128 same search algorithm is used for local files regardless of
129 whether a "target:" prefix was used.
131 Global variable SOLIB_SEARCH_PATH is used as a prefix directory
132 (or set of directories, as in LD_LIBRARY_PATH) to search for all
133 shared libraries if not found in either the sysroot (if set) or
134 the local filesystem. SOLIB_SEARCH_PATH is not used when searching
135 for the main executable.
138 * If a sysroot is set and path is absolute:
139 * Search for sysroot/path.
141 * Look for it literally (unmodified).
142 * If IS_SOLIB is non-zero:
143 * Look in SOLIB_SEARCH_PATH.
144 * If available, use target defined search function.
145 * If NO sysroot is set, perform the following two searches:
146 * Look in inferior's $PATH.
147 * If IS_SOLIB is non-zero:
148 * Look in inferior's $LD_LIBRARY_PATH.
150 * The last check avoids doing this search when targetting remote
151 * machines since a sysroot will almost always be set.
155 solib_find_1 (const char *in_pathname
, int *fd
, int is_solib
)
157 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
159 char *temp_pathname
= NULL
;
160 const char *fskind
= effective_target_file_system_kind ();
161 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
162 char *sysroot
= gdb_sysroot
;
163 int prefix_len
, orig_prefix_len
;
165 /* If the absolute prefix starts with "target:" but the filesystem
166 accessed by the target_fileio_* methods is the local filesystem
167 then we strip the "target:" prefix now and work with the local
168 filesystem. This ensures that the same search algorithm is used
169 for all local files regardless of whether a "target:" prefix was
171 if (is_target_filename (sysroot
) && target_filesystem_is_local ())
172 sysroot
+= strlen (TARGET_SYSROOT_PREFIX
);
174 /* Strip any trailing slashes from the absolute prefix. */
175 prefix_len
= orig_prefix_len
= strlen (sysroot
);
177 while (prefix_len
> 0 && IS_DIR_SEPARATOR (sysroot
[prefix_len
- 1]))
182 else if (prefix_len
!= orig_prefix_len
)
184 sysroot
= savestring (sysroot
, prefix_len
);
185 make_cleanup (xfree
, sysroot
);
188 /* If we're on a non-DOS-based system, backslashes won't be
189 understood as directory separator, so, convert them to forward
190 slashes, iff we're supposed to handle DOS-based file system
191 semantics for target paths. */
192 if (!DOS_BASED_FILE_SYSTEM
&& fskind
== file_system_kind_dos_based
)
196 /* Avoid clobbering our input. */
197 p
= (char *) alloca (strlen (in_pathname
) + 1);
198 strcpy (p
, in_pathname
);
208 /* Note, we're interested in IS_TARGET_ABSOLUTE_PATH, not
209 IS_ABSOLUTE_PATH. The latter is for host paths only, while
210 IN_PATHNAME is a target path. For example, if we're supposed to
211 be handling DOS-like semantics we want to consider a
212 'c:/foo/bar.dll' path as an absolute path, even on a Unix box.
213 With such a path, before giving up on the sysroot, we'll try:
215 1st attempt, c:/foo/bar.dll ==> /sysroot/c:/foo/bar.dll
216 2nd attempt, c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll
217 3rd attempt, c:/foo/bar.dll ==> /sysroot/foo/bar.dll
220 if (!IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
) || sysroot
== NULL
)
221 temp_pathname
= xstrdup (in_pathname
);
224 int need_dir_separator
;
226 /* Concatenate the sysroot and the target reported filename. We
227 may need to glue them with a directory separator. Cases to
230 | sysroot | separator | in_pathname |
231 |-----------------+-----------+----------------|
232 | /some/dir | / | c:/foo/bar.dll |
233 | /some/dir | | /foo/bar.dll |
234 | target: | | c:/foo/bar.dll |
235 | target: | | /foo/bar.dll |
236 | target:some/dir | / | c:/foo/bar.dll |
237 | target:some/dir | | /foo/bar.dll |
239 IOW, we don't need to add a separator if IN_PATHNAME already
240 has one, or when the the sysroot is exactly "target:".
241 There's no need to check for drive spec explicitly, as we only
242 get here if IN_PATHNAME is considered an absolute path. */
243 need_dir_separator
= !(IS_DIR_SEPARATOR (in_pathname
[0])
244 || strcmp (TARGET_SYSROOT_PREFIX
, sysroot
) == 0);
246 /* Cat the prefixed pathname together. */
247 temp_pathname
= concat (sysroot
,
248 need_dir_separator
? SLASH_STRING
: "",
249 in_pathname
, (char *) NULL
);
252 /* Handle files to be accessed via the target. */
253 if (is_target_filename (temp_pathname
))
257 do_cleanups (old_chain
);
258 return temp_pathname
;
261 /* Now see if we can open it. */
262 found_file
= gdb_open_cloexec (temp_pathname
, O_RDONLY
| O_BINARY
, 0);
264 xfree (temp_pathname
);
266 /* If the search in gdb_sysroot failed, and the path name has a
267 drive spec (e.g, c:/foo), try stripping ':' from the drive spec,
268 and retrying in the sysroot:
269 c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll. */
273 && HAS_TARGET_DRIVE_SPEC (fskind
, in_pathname
))
275 int need_dir_separator
= !IS_DIR_SEPARATOR (in_pathname
[2]);
276 char *drive
= savestring (in_pathname
, 1);
278 temp_pathname
= concat (sysroot
,
281 need_dir_separator
? SLASH_STRING
: "",
282 in_pathname
+ 2, (char *) NULL
);
285 found_file
= gdb_open_cloexec (temp_pathname
, O_RDONLY
| O_BINARY
, 0);
288 xfree (temp_pathname
);
290 /* If the search in gdb_sysroot still failed, try fully
291 stripping the drive spec, and trying once more in the
292 sysroot before giving up.
294 c:/foo/bar.dll ==> /sysroot/foo/bar.dll. */
296 temp_pathname
= concat (sysroot
,
297 need_dir_separator
? SLASH_STRING
: "",
298 in_pathname
+ 2, (char *) NULL
);
300 found_file
= gdb_open_cloexec (temp_pathname
, O_RDONLY
| O_BINARY
, 0);
302 xfree (temp_pathname
);
306 do_cleanups (old_chain
);
308 /* We try to find the library in various ways. After each attempt,
309 either found_file >= 0 and temp_pathname is a malloc'd string, or
310 found_file < 0 and temp_pathname does not point to storage that
311 needs to be freed. */
314 temp_pathname
= NULL
;
316 /* If the search in gdb_sysroot failed, and the path name is
317 absolute at this point, make it relative. (openp will try and open the
318 file according to its absolute path otherwise, which is not what we want.)
319 Affects subsequent searches for this solib. */
320 if (found_file
< 0 && IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
))
322 /* First, get rid of any drive letters etc. */
323 while (!IS_TARGET_DIR_SEPARATOR (fskind
, *in_pathname
))
326 /* Next, get rid of all leading dir separators. */
327 while (IS_TARGET_DIR_SEPARATOR (fskind
, *in_pathname
))
331 /* If not found, and we're looking for a solib, search the
332 solib_search_path (if any). */
333 if (is_solib
&& found_file
< 0 && solib_search_path
!= NULL
)
334 found_file
= openp (solib_search_path
,
335 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
336 in_pathname
, O_RDONLY
| O_BINARY
, &temp_pathname
);
338 /* If not found, and we're looking for a solib, next search the
339 solib_search_path (if any) for the basename only (ignoring the
340 path). This is to allow reading solibs from a path that differs
341 from the opened path. */
342 if (is_solib
&& found_file
< 0 && solib_search_path
!= NULL
)
343 found_file
= openp (solib_search_path
,
344 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
345 target_lbasename (fskind
, in_pathname
),
346 O_RDONLY
| O_BINARY
, &temp_pathname
);
348 /* If not found, and we're looking for a solib, try to use target
349 supplied solib search method. */
350 if (is_solib
&& found_file
< 0 && ops
->find_and_open_solib
)
351 found_file
= ops
->find_and_open_solib (in_pathname
, O_RDONLY
| O_BINARY
,
354 /* If not found, next search the inferior's $PATH environment variable. */
355 if (found_file
< 0 && sysroot
== NULL
)
356 found_file
= openp (get_in_environ (current_inferior ()->environment
,
358 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
, in_pathname
,
359 O_RDONLY
| O_BINARY
, &temp_pathname
);
361 /* If not found, and we're looking for a solib, next search the
362 inferior's $LD_LIBRARY_PATH environment variable. */
363 if (is_solib
&& found_file
< 0 && sysroot
== NULL
)
364 found_file
= openp (get_in_environ (current_inferior ()->environment
,
366 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
, in_pathname
,
367 O_RDONLY
| O_BINARY
, &temp_pathname
);
377 return temp_pathname
;
380 /* Return the full pathname of the main executable, or NULL if not
381 found. The returned pathname is malloc'ed and must be freed by
382 the caller. If FD is non-NULL, *FD is set to either -1 or an open
383 file handle for the main executable. */
386 exec_file_find (const char *in_pathname
, int *fd
)
389 const char *fskind
= effective_target_file_system_kind ();
391 if (in_pathname
== NULL
)
394 if (*gdb_sysroot
!= '\0' && IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
))
396 result
= solib_find_1 (in_pathname
, fd
, 0);
398 if (result
== NULL
&& fskind
== file_system_kind_dos_based
)
402 new_pathname
= (char *) alloca (strlen (in_pathname
) + 5);
403 strcpy (new_pathname
, in_pathname
);
404 strcat (new_pathname
, ".exe");
406 result
= solib_find_1 (new_pathname
, fd
, 0);
411 /* It's possible we don't have a full path, but rather just a
412 filename. Some targets, such as HP-UX, don't provide the
415 Attempt to qualify the filename against the source path.
416 (If that fails, we'll just fall back on the original
417 filename. Not much more we can do...) */
419 if (!source_full_path_of (in_pathname
, &result
))
420 result
= xstrdup (in_pathname
);
428 /* Return the full pathname of a shared library file, or NULL if not
429 found. The returned pathname is malloc'ed and must be freed by
430 the caller. If FD is non-NULL, *FD is set to either -1 or an open
431 file handle for the shared library.
433 The search algorithm used is described in solib_find_1's comment
437 solib_find (const char *in_pathname
, int *fd
)
439 const char *solib_symbols_extension
440 = gdbarch_solib_symbols_extension (target_gdbarch ());
442 /* If solib_symbols_extension is set, replace the file's
444 if (solib_symbols_extension
!= NULL
)
446 const char *p
= in_pathname
+ strlen (in_pathname
);
448 while (p
> in_pathname
&& *p
!= '.')
456 = (char *) alloca (p
- in_pathname
+ 1
457 + strlen (solib_symbols_extension
) + 1);
458 memcpy (new_pathname
, in_pathname
, p
- in_pathname
+ 1);
459 strcpy (new_pathname
+ (p
- in_pathname
) + 1,
460 solib_symbols_extension
);
462 in_pathname
= new_pathname
;
466 return solib_find_1 (in_pathname
, fd
, 1);
469 /* Open and return a BFD for the shared library PATHNAME. If FD is not -1,
470 it is used as file handle to open the file. Throws an error if the file
471 could not be opened. Handles both local and remote file access.
473 PATHNAME must be malloc'ed by the caller. It will be freed by this
474 function. If unsuccessful, the FD will be closed (unless FD was
478 solib_bfd_fopen (char *pathname
, int fd
)
480 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (pathname
, gnutarget
, fd
));
482 if (abfd
!= NULL
&& !gdb_bfd_has_target_filename (abfd
.get ()))
483 bfd_set_cacheable (abfd
.get (), 1);
487 make_cleanup (xfree
, pathname
);
488 error (_("Could not open `%s' as an executable file: %s"),
489 pathname
, bfd_errmsg (bfd_get_error ()));
497 /* Find shared library PATHNAME and open a BFD for it. */
500 solib_bfd_open (char *pathname
)
502 char *found_pathname
;
504 const struct bfd_arch_info
*b
;
506 /* Search for shared library file. */
507 found_pathname
= solib_find (pathname
, &found_file
);
508 if (found_pathname
== NULL
)
510 /* Return failure if the file could not be found, so that we can
511 accumulate messages about missing libraries. */
515 perror_with_name (pathname
);
518 /* Open bfd for shared library. */
519 gdb_bfd_ref_ptr
abfd (solib_bfd_fopen (found_pathname
, found_file
));
521 /* Check bfd format. */
522 if (!bfd_check_format (abfd
.get (), bfd_object
))
523 error (_("`%s': not in executable format: %s"),
524 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
526 /* Check bfd arch. */
527 b
= gdbarch_bfd_arch_info (target_gdbarch ());
528 if (!b
->compatible (b
, bfd_get_arch_info (abfd
.get ())))
529 warning (_("`%s': Shared library architecture %s is not compatible "
530 "with target architecture %s."), bfd_get_filename (abfd
),
531 bfd_get_arch_info (abfd
.get ())->printable_name
,
537 /* Given a pointer to one of the shared objects in our list of mapped
538 objects, use the recorded name to open a bfd descriptor for the
539 object, build a section table, relocate all the section addresses
540 by the base address at which the shared object was mapped, and then
541 add the sections to the target's section table.
543 FIXME: In most (all?) cases the shared object file name recorded in
544 the dynamic linkage tables will be a fully qualified pathname. For
545 cases where it isn't, do we really mimic the systems search
546 mechanism correctly in the below code (particularly the tilde
547 expansion stuff?). */
550 solib_map_sections (struct so_list
*so
)
552 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
554 struct target_section
*p
;
555 struct cleanup
*old_chain
;
557 filename
= tilde_expand (so
->so_name
);
558 old_chain
= make_cleanup (xfree
, filename
);
559 gdb_bfd_ref_ptr
abfd (ops
->bfd_open (filename
));
560 do_cleanups (old_chain
);
565 /* Leave bfd open, core_xfer_memory and "info files" need it. */
566 so
->abfd
= abfd
.release ();
568 /* Copy the full path name into so_name, allowing symbol_file_add
569 to find it later. This also affects the =library-loaded GDB/MI
570 event, and in particular the part of that notification providing
571 the library's host-side path. If we let the target dictate
572 that objfile's path, and the target is different from the host,
573 GDB/MI will not provide the correct host-side path. */
574 if (strlen (bfd_get_filename (so
->abfd
)) >= SO_NAME_MAX_PATH_SIZE
)
575 error (_("Shared library file name is too long."));
576 strcpy (so
->so_name
, bfd_get_filename (so
->abfd
));
578 if (build_section_table (so
->abfd
, &so
->sections
, &so
->sections_end
))
580 error (_("Can't find the file sections in `%s': %s"),
581 bfd_get_filename (so
->abfd
), bfd_errmsg (bfd_get_error ()));
584 for (p
= so
->sections
; p
< so
->sections_end
; p
++)
586 /* Relocate the section binding addresses as recorded in the shared
587 object's file by the base address to which the object was actually
589 ops
->relocate_section_addresses (so
, p
);
591 /* If the target didn't provide information about the address
592 range of the shared object, assume we want the location of
593 the .text section. */
594 if (so
->addr_low
== 0 && so
->addr_high
== 0
595 && strcmp (p
->the_bfd_section
->name
, ".text") == 0)
597 so
->addr_low
= p
->addr
;
598 so
->addr_high
= p
->endaddr
;
602 /* Add the shared object's sections to the current set of file
603 section tables. Do this immediately after mapping the object so
604 that later nodes in the list can query this object, as is needed
606 add_target_sections (so
, so
->sections
, so
->sections_end
);
611 /* Free symbol-file related contents of SO and reset for possible reloading
612 of SO. If we have opened a BFD for SO, close it. If we have placed SO's
613 sections in some target's section table, the caller is responsible for
616 This function doesn't mess with objfiles at all. If there is an
617 objfile associated with SO that needs to be removed, the caller is
618 responsible for taking care of that. */
621 clear_so (struct so_list
*so
)
623 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
627 xfree (so
->sections
);
628 so
->sections
= so
->sections_end
= NULL
;
631 gdb_bfd_unref (so
->abfd
);
634 /* Our caller closed the objfile, possibly via objfile_purge_solibs. */
635 so
->symbols_loaded
= 0;
638 so
->addr_low
= so
->addr_high
= 0;
640 /* Restore the target-supplied file name. SO_NAME may be the path
641 of the symbol file. */
642 strcpy (so
->so_name
, so
->so_original_name
);
644 /* Do the same for target-specific data. */
645 if (ops
->clear_so
!= NULL
)
649 /* Free the storage associated with the `struct so_list' object SO.
650 If we have opened a BFD for SO, close it.
652 The caller is responsible for removing SO from whatever list it is
653 a member of. If we have placed SO's sections in some target's
654 section table, the caller is responsible for removing them.
656 This function doesn't mess with objfiles at all. If there is an
657 objfile associated with SO that needs to be removed, the caller is
658 responsible for taking care of that. */
661 free_so (struct so_list
*so
)
663 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
672 /* Return address of first so_list entry in master shared object list. */
674 master_so_list (void)
679 /* Read in symbols for shared object SO. If SYMFILE_VERBOSE is set in FLAGS,
680 be chatty about it. Return non-zero if any symbols were actually
684 solib_read_symbols (struct so_list
*so
, symfile_add_flags flags
)
686 if (so
->symbols_loaded
)
688 /* If needed, we've already warned in our caller. */
690 else if (so
->abfd
== NULL
)
692 /* We've already warned about this library, when trying to open
698 flags
|= current_inferior ()->symfile_flags
;
702 struct section_addr_info
*sap
;
704 /* Have we already loaded this shared object? */
705 ALL_OBJFILES (so
->objfile
)
707 if (filename_cmp (objfile_name (so
->objfile
), so
->so_name
) == 0
708 && so
->objfile
->addr_low
== so
->addr_low
)
711 if (so
->objfile
== NULL
)
713 sap
= build_section_addr_info_from_section_table (so
->sections
,
715 so
->objfile
= symbol_file_add_from_bfd (so
->abfd
, so
->so_name
,
716 flags
, sap
, OBJF_SHARED
,
718 so
->objfile
->addr_low
= so
->addr_low
;
719 free_section_addr_info (sap
);
722 so
->symbols_loaded
= 1;
724 CATCH (e
, RETURN_MASK_ERROR
)
726 exception_fprintf (gdb_stderr
, e
, _("Error while reading shared"
727 " library symbols for %s:\n"),
738 /* Return 1 if KNOWN->objfile is used by any other so_list object in the
739 SO_LIST_HEAD list. Return 0 otherwise. */
742 solib_used (const struct so_list
*const known
)
744 const struct so_list
*pivot
;
746 for (pivot
= so_list_head
; pivot
!= NULL
; pivot
= pivot
->next
)
747 if (pivot
!= known
&& pivot
->objfile
== known
->objfile
)
752 /* Synchronize GDB's shared object list with inferior's.
754 Extract the list of currently loaded shared objects from the
755 inferior, and compare it with the list of shared objects currently
756 in GDB's so_list_head list. Edit so_list_head to bring it in sync
757 with the inferior's new list.
759 If we notice that the inferior has unloaded some shared objects,
760 free any symbolic info GDB had read about those shared objects.
762 Don't load symbolic info for any new shared objects; just add them
763 to the list, and leave their symbols_loaded flag clear.
765 If FROM_TTY is non-null, feel free to print messages about what
768 If TARGET is non-null, add the sections of all new shared objects
769 to TARGET's section table. Note that this doesn't remove any
770 sections for shared objects that have been unloaded, and it
771 doesn't check to see if the new shared objects are already present in
772 the section table. But we only use this for core files and
773 processes we've just attached to, so that's okay. */
776 update_solib_list (int from_tty
, struct target_ops
*target
)
778 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
779 struct so_list
*inferior
= ops
->current_sos();
780 struct so_list
*gdb
, **gdb_link
;
782 /* We can reach here due to changing solib-search-path or the
783 sysroot, before having any inferior. */
784 if (target_has_execution
&& !ptid_equal (inferior_ptid
, null_ptid
))
786 struct inferior
*inf
= current_inferior ();
788 /* If we are attaching to a running process for which we
789 have not opened a symbol file, we may be able to get its
791 if (inf
->attach_flag
&& symfile_objfile
== NULL
)
792 catch_errors (ops
->open_symbol_file_object
, &from_tty
,
793 "Error reading attached process's symbol file.\n",
797 /* GDB and the inferior's dynamic linker each maintain their own
798 list of currently loaded shared objects; we want to bring the
799 former in sync with the latter. Scan both lists, seeing which
800 shared objects appear where. There are three cases:
802 - A shared object appears on both lists. This means that GDB
803 knows about it already, and it's still loaded in the inferior.
804 Nothing needs to happen.
806 - A shared object appears only on GDB's list. This means that
807 the inferior has unloaded it. We should remove the shared
808 object from GDB's tables.
810 - A shared object appears only on the inferior's list. This
811 means that it's just been loaded. We should add it to GDB's
814 So we walk GDB's list, checking each entry to see if it appears
815 in the inferior's list too. If it does, no action is needed, and
816 we remove it from the inferior's list. If it doesn't, the
817 inferior has unloaded it, and we remove it from GDB's list. By
818 the time we're done walking GDB's list, the inferior's list
819 contains only the new shared objects, which we then add. */
822 gdb_link
= &so_list_head
;
825 struct so_list
*i
= inferior
;
826 struct so_list
**i_link
= &inferior
;
828 /* Check to see whether the shared object *gdb also appears in
829 the inferior's current list. */
834 if (ops
->same (gdb
, i
))
839 if (! filename_cmp (gdb
->so_original_name
, i
->so_original_name
))
847 /* If the shared object appears on the inferior's list too, then
848 it's still loaded, so we don't need to do anything. Delete
849 it from the inferior's list, and leave it on GDB's list. */
854 gdb_link
= &gdb
->next
;
858 /* If it's not on the inferior's list, remove it from GDB's tables. */
861 /* Notify any observer that the shared object has been
862 unloaded before we remove it from GDB's tables. */
863 observer_notify_solib_unloaded (gdb
);
865 VEC_safe_push (char_ptr
, current_program_space
->deleted_solibs
,
866 xstrdup (gdb
->so_name
));
868 *gdb_link
= gdb
->next
;
870 /* Unless the user loaded it explicitly, free SO's objfile. */
871 if (gdb
->objfile
&& ! (gdb
->objfile
->flags
& OBJF_USERLOADED
)
872 && !solib_used (gdb
))
873 free_objfile (gdb
->objfile
);
875 /* Some targets' section tables might be referring to
876 sections from so->abfd; remove them. */
877 remove_target_sections (gdb
);
884 /* Now the inferior's list contains only shared objects that don't
885 appear in GDB's list --- those that are newly loaded. Add them
886 to GDB's shared object list. */
890 const char *not_found_filename
= NULL
;
894 /* Add the new shared objects to GDB's list. */
895 *gdb_link
= inferior
;
897 /* Fill in the rest of each of the `struct so_list' nodes. */
898 for (i
= inferior
; i
; i
= i
->next
)
901 i
->pspace
= current_program_space
;
902 VEC_safe_push (so_list_ptr
, current_program_space
->added_solibs
, i
);
906 /* Fill in the rest of the `struct so_list' node. */
907 if (!solib_map_sections (i
))
910 if (not_found_filename
== NULL
)
911 not_found_filename
= i
->so_original_name
;
915 CATCH (e
, RETURN_MASK_ERROR
)
917 exception_fprintf (gdb_stderr
, e
,
918 _("Error while mapping shared "
919 "library sections:\n"));
923 /* Notify any observer that the shared object has been
924 loaded now that we've added it to GDB's tables. */
925 observer_notify_solib_loaded (i
);
928 /* If a library was not found, issue an appropriate warning
929 message. We have to use a single call to warning in case the
930 front end does something special with warnings, e.g., pop up
931 a dialog box. It Would Be Nice if we could get a "warning: "
932 prefix on each line in the CLI front end, though - it doesn't
936 warning (_("Could not load shared library symbols for %s.\n"
937 "Do you need \"set solib-search-path\" "
938 "or \"set sysroot\"?"),
940 else if (not_found
> 1)
942 Could not load shared library symbols for %d libraries, e.g. %s.\n\
943 Use the \"info sharedlibrary\" command to see the complete listing.\n\
944 Do you need \"set solib-search-path\" or \"set sysroot\"?"),
945 not_found
, not_found_filename
);
950 /* Return non-zero if NAME is the libpthread shared library.
952 Uses a fairly simplistic heuristic approach where we check
953 the file name against "/libpthread". This can lead to false
954 positives, but this should be good enough in practice. */
957 libpthread_name_p (const char *name
)
959 return (strstr (name
, "/libpthread") != NULL
);
962 /* Return non-zero if SO is the libpthread shared library. */
965 libpthread_solib_p (struct so_list
*so
)
967 return libpthread_name_p (so
->so_name
);
970 /* Read in symbolic information for any shared objects whose names
971 match PATTERN. (If we've already read a shared object's symbol
972 info, leave it alone.) If PATTERN is zero, read them all.
974 If READSYMS is 0, defer reading symbolic information until later
975 but still do any needed low level processing.
977 FROM_TTY and TARGET are as described for update_solib_list, above. */
980 solib_add (const char *pattern
, int from_tty
,
981 struct target_ops
*target
, int readsyms
)
985 if (print_symbol_loading_p (from_tty
, 0, 0))
989 printf_unfiltered (_("Loading symbols for shared libraries: %s\n"),
993 printf_unfiltered (_("Loading symbols for shared libraries.\n"));
996 current_program_space
->solib_add_generation
++;
1000 char *re_err
= re_comp (pattern
);
1003 error (_("Invalid regexp: %s"), re_err
);
1006 update_solib_list (from_tty
, target
);
1008 /* Walk the list of currently loaded shared libraries, and read
1009 symbols for any that match the pattern --- or any whose symbols
1010 aren't already loaded, if no pattern was given. */
1012 int any_matches
= 0;
1013 int loaded_any_symbols
= 0;
1014 symfile_add_flags add_flags
= SYMFILE_DEFER_BP_RESET
;
1017 add_flags
|= SYMFILE_VERBOSE
;
1019 for (gdb
= so_list_head
; gdb
; gdb
= gdb
->next
)
1020 if (! pattern
|| re_exec (gdb
->so_name
))
1022 /* Normally, we would read the symbols from that library
1023 only if READSYMS is set. However, we're making a small
1024 exception for the pthread library, because we sometimes
1025 need the library symbols to be loaded in order to provide
1026 thread support (x86-linux for instance). */
1027 const int add_this_solib
=
1028 (readsyms
|| libpthread_solib_p (gdb
));
1033 if (gdb
->symbols_loaded
)
1035 /* If no pattern was given, be quiet for shared
1036 libraries we have already loaded. */
1037 if (pattern
&& (from_tty
|| info_verbose
))
1038 printf_unfiltered (_("Symbols already loaded for %s\n"),
1041 else if (solib_read_symbols (gdb
, add_flags
))
1042 loaded_any_symbols
= 1;
1046 if (loaded_any_symbols
)
1047 breakpoint_re_set ();
1049 if (from_tty
&& pattern
&& ! any_matches
)
1051 ("No loaded shared libraries match the pattern `%s'.\n", pattern
);
1053 if (loaded_any_symbols
)
1055 /* Getting new symbols may change our opinion about what is
1057 reinit_frame_cache ();
1062 /* Implement the "info sharedlibrary" command. Walk through the
1063 shared library list and print information about each attached
1064 library matching PATTERN. If PATTERN is elided, print them
1068 info_sharedlibrary_command (char *pattern
, int from_tty
)
1070 struct so_list
*so
= NULL
; /* link map state variable */
1071 int so_missing_debug_info
= 0;
1074 struct cleanup
*table_cleanup
;
1075 struct gdbarch
*gdbarch
= target_gdbarch ();
1076 struct ui_out
*uiout
= current_uiout
;
1080 char *re_err
= re_comp (pattern
);
1083 error (_("Invalid regexp: %s"), re_err
);
1086 /* "0x", a little whitespace, and two hex digits per byte of pointers. */
1087 addr_width
= 4 + (gdbarch_ptr_bit (gdbarch
) / 4);
1089 update_solib_list (from_tty
, 0);
1091 /* make_cleanup_ui_out_table_begin_end needs to know the number of
1092 rows, so we need to make two passes over the libs. */
1094 for (nr_libs
= 0, so
= so_list_head
; so
; so
= so
->next
)
1098 if (pattern
&& ! re_exec (so
->so_name
))
1105 make_cleanup_ui_out_table_begin_end (uiout
, 4, nr_libs
,
1106 "SharedLibraryTable");
1108 /* The "- 1" is because ui_out adds one space between columns. */
1109 uiout
->table_header (addr_width
- 1, ui_left
, "from", "From");
1110 uiout
->table_header (addr_width
- 1, ui_left
, "to", "To");
1111 uiout
->table_header (12 - 1, ui_left
, "syms-read", "Syms Read");
1112 uiout
->table_header (0, ui_noalign
, "name", "Shared Object Library");
1114 uiout
->table_body ();
1116 for (so
= so_list_head
; so
; so
= so
->next
)
1118 struct cleanup
*lib_cleanup
;
1120 if (! so
->so_name
[0])
1122 if (pattern
&& ! re_exec (so
->so_name
))
1125 lib_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, "lib");
1127 if (so
->addr_high
!= 0)
1129 uiout
->field_core_addr ("from", gdbarch
, so
->addr_low
);
1130 uiout
->field_core_addr ("to", gdbarch
, so
->addr_high
);
1134 uiout
->field_skip ("from");
1135 uiout
->field_skip ("to");
1138 if (! interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
1139 && so
->symbols_loaded
1140 && !objfile_has_symbols (so
->objfile
))
1142 so_missing_debug_info
= 1;
1143 uiout
->field_string ("syms-read", "Yes (*)");
1146 uiout
->field_string ("syms-read", so
->symbols_loaded
? "Yes" : "No");
1148 uiout
->field_string ("name", so
->so_name
);
1152 do_cleanups (lib_cleanup
);
1155 do_cleanups (table_cleanup
);
1160 uiout
->message (_("No shared libraries matched.\n"));
1162 uiout
->message (_("No shared libraries loaded at this time.\n"));
1166 if (so_missing_debug_info
)
1167 uiout
->message (_("(*): Shared library is missing "
1168 "debugging information.\n"));
1172 /* Return 1 if ADDRESS lies within SOLIB. */
1175 solib_contains_address_p (const struct so_list
*const solib
,
1178 struct target_section
*p
;
1180 for (p
= solib
->sections
; p
< solib
->sections_end
; p
++)
1181 if (p
->addr
<= address
&& address
< p
->endaddr
)
1187 /* If ADDRESS is in a shared lib in program space PSPACE, return its
1190 Provides a hook for other gdb routines to discover whether or not a
1191 particular address is within the mapped address space of a shared
1194 For example, this routine is called at one point to disable
1195 breakpoints which are in shared libraries that are not currently
1199 solib_name_from_address (struct program_space
*pspace
, CORE_ADDR address
)
1201 struct so_list
*so
= NULL
;
1203 for (so
= pspace
->so_list
; so
; so
= so
->next
)
1204 if (solib_contains_address_p (so
, address
))
1205 return (so
->so_name
);
1210 /* Return whether the data starting at VADDR, size SIZE, must be kept
1211 in a core file for shared libraries loaded before "gcore" is used
1212 to be handled correctly when the core file is loaded. This only
1213 applies when the section would otherwise not be kept in the core
1214 file (in particular, for readonly sections). */
1217 solib_keep_data_in_core (CORE_ADDR vaddr
, unsigned long size
)
1219 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1221 if (ops
->keep_data_in_core
)
1222 return ops
->keep_data_in_core (vaddr
, size
);
1227 /* Called by free_all_symtabs */
1232 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1234 disable_breakpoints_in_shlibs ();
1236 while (so_list_head
)
1238 struct so_list
*so
= so_list_head
;
1240 so_list_head
= so
->next
;
1241 observer_notify_solib_unloaded (so
);
1242 remove_target_sections (so
);
1246 ops
->clear_solib ();
1249 /* Shared library startup support. When GDB starts up the inferior,
1250 it nurses it along (through the shell) until it is ready to execute
1251 its first instruction. At this point, this function gets
1255 solib_create_inferior_hook (int from_tty
)
1257 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1259 ops
->solib_create_inferior_hook (from_tty
);
1262 /* Check to see if an address is in the dynamic loader's dynamic
1263 symbol resolution code. Return 1 if so, 0 otherwise. */
1266 in_solib_dynsym_resolve_code (CORE_ADDR pc
)
1268 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1270 return ops
->in_dynsym_resolve_code (pc
);
1273 /* Implements the "sharedlibrary" command. */
1276 sharedlibrary_command (char *args
, int from_tty
)
1279 solib_add (args
, from_tty
, (struct target_ops
*) 0, 1);
1282 /* Implements the command "nosharedlibrary", which discards symbols
1283 that have been auto-loaded from shared libraries. Symbols from
1284 shared libraries that were added by explicit request of the user
1285 are not discarded. Also called from remote.c. */
1288 no_shared_libraries (char *ignored
, int from_tty
)
1290 /* The order of the two routines below is important: clear_solib notifies
1291 the solib_unloaded observers, and some of these observers might need
1292 access to their associated objfiles. Therefore, we can not purge the
1293 solibs' objfiles before clear_solib has been called. */
1296 objfile_purge_solibs ();
1302 update_solib_breakpoints (void)
1304 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1306 if (ops
->update_breakpoints
!= NULL
)
1307 ops
->update_breakpoints ();
1313 handle_solib_event (void)
1315 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1317 if (ops
->handle_event
!= NULL
)
1318 ops
->handle_event ();
1320 clear_program_space_solib_cache (current_inferior ()->pspace
);
1322 /* Check for any newly added shared libraries if we're supposed to
1323 be adding them automatically. Switch terminal for any messages
1324 produced by breakpoint_re_set. */
1325 target_terminal_ours_for_output ();
1326 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
1327 target_terminal_inferior ();
1330 /* Reload shared libraries, but avoid reloading the same symbol file
1331 we already have loaded. */
1334 reload_shared_libraries_1 (int from_tty
)
1337 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1339 if (print_symbol_loading_p (from_tty
, 0, 0))
1340 printf_unfiltered (_("Loading symbols for shared libraries.\n"));
1342 for (so
= so_list_head
; so
!= NULL
; so
= so
->next
)
1344 char *filename
, *found_pathname
= NULL
;
1345 int was_loaded
= so
->symbols_loaded
;
1346 symfile_add_flags add_flags
= SYMFILE_DEFER_BP_RESET
;
1349 add_flags
|= SYMFILE_VERBOSE
;
1351 filename
= tilde_expand (so
->so_original_name
);
1352 make_cleanup (xfree
, filename
);
1353 gdb_bfd_ref_ptr
abfd (solib_bfd_open (filename
));
1356 found_pathname
= xstrdup (bfd_get_filename (abfd
.get ()));
1357 make_cleanup (xfree
, found_pathname
);
1360 /* If this shared library is no longer associated with its previous
1361 symbol file, close that. */
1362 if ((found_pathname
== NULL
&& was_loaded
)
1363 || (found_pathname
!= NULL
1364 && filename_cmp (found_pathname
, so
->so_name
) != 0))
1366 if (so
->objfile
&& ! (so
->objfile
->flags
& OBJF_USERLOADED
)
1367 && !solib_used (so
))
1368 free_objfile (so
->objfile
);
1369 remove_target_sections (so
);
1373 /* If this shared library is now associated with a new symbol
1375 if (found_pathname
!= NULL
1377 || filename_cmp (found_pathname
, so
->so_name
) != 0))
1383 solib_map_sections (so
);
1386 CATCH (e
, RETURN_MASK_ERROR
)
1388 exception_fprintf (gdb_stderr
, e
,
1389 _("Error while mapping "
1390 "shared library sections:\n"));
1396 && (auto_solib_add
|| was_loaded
|| libpthread_solib_p (so
)))
1397 solib_read_symbols (so
, add_flags
);
1401 do_cleanups (old_chain
);
1405 reload_shared_libraries (char *ignored
, int from_tty
,
1406 struct cmd_list_element
*e
)
1408 const struct target_so_ops
*ops
;
1410 reload_shared_libraries_1 (from_tty
);
1412 ops
= solib_ops (target_gdbarch ());
1414 /* Creating inferior hooks here has two purposes. First, if we reload
1415 shared libraries then the address of solib breakpoint we've computed
1416 previously might be no longer valid. For example, if we forgot to set
1417 solib-absolute-prefix and are setting it right now, then the previous
1418 breakpoint address is plain wrong. Second, installing solib hooks
1419 also implicitly figures were ld.so is and loads symbols for it.
1420 Absent this call, if we've just connected to a target and set
1421 solib-absolute-prefix or solib-search-path, we'll lose all information
1423 if (target_has_execution
)
1425 /* Reset or free private data structures not associated with
1427 ops
->clear_solib ();
1429 /* Remove any previous solib event breakpoint. This is usually
1430 done in common code, at breakpoint_init_inferior time, but
1431 we're not really starting up the inferior here. */
1432 remove_solib_event_breakpoints ();
1434 solib_create_inferior_hook (from_tty
);
1437 /* Sometimes the platform-specific hook loads initial shared
1438 libraries, and sometimes it doesn't. If it doesn't FROM_TTY will be
1439 incorrectly 0 but such solib targets should be fixed anyway. If we
1440 made all the inferior hook methods consistent, this call could be
1441 removed. Call it only after the solib target has been initialized by
1442 solib_create_inferior_hook. */
1444 solib_add (NULL
, 0, NULL
, auto_solib_add
);
1446 breakpoint_re_set ();
1448 /* We may have loaded or unloaded debug info for some (or all)
1449 shared libraries. However, frames may still reference them. For
1450 example, a frame's unwinder might still point at DWARF FDE
1451 structures that are now freed. Also, getting new symbols may
1452 change our opinion about what is frameless. */
1453 reinit_frame_cache ();
1456 /* Wrapper for reload_shared_libraries that replaces "remote:"
1457 at the start of gdb_sysroot with "target:". */
1460 gdb_sysroot_changed (char *ignored
, int from_tty
,
1461 struct cmd_list_element
*e
)
1463 const char *old_prefix
= "remote:";
1464 const char *new_prefix
= TARGET_SYSROOT_PREFIX
;
1466 if (startswith (gdb_sysroot
, old_prefix
))
1468 static int warning_issued
= 0;
1470 gdb_assert (strlen (old_prefix
) == strlen (new_prefix
));
1471 memcpy (gdb_sysroot
, new_prefix
, strlen (new_prefix
));
1473 if (!warning_issued
)
1475 warning (_("\"%s\" is deprecated, use \"%s\" instead."),
1476 old_prefix
, new_prefix
);
1477 warning (_("sysroot set to \"%s\"."), gdb_sysroot
);
1483 reload_shared_libraries (ignored
, from_tty
, e
);
1487 show_auto_solib_add (struct ui_file
*file
, int from_tty
,
1488 struct cmd_list_element
*c
, const char *value
)
1490 fprintf_filtered (file
, _("Autoloading of shared library symbols is %s.\n"),
1495 /* Handler for library-specific lookup of global symbol NAME in OBJFILE. Call
1496 the library-specific handler if it is installed for the current target. */
1499 solib_global_lookup (struct objfile
*objfile
,
1501 const domain_enum domain
)
1503 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1505 if (ops
->lookup_lib_global_symbol
!= NULL
)
1506 return ops
->lookup_lib_global_symbol (objfile
, name
, domain
);
1507 return (struct block_symbol
) {NULL
, NULL
};
1510 /* Lookup the value for a specific symbol from dynamic symbol table. Look
1511 up symbol from ABFD. MATCH_SYM is a callback function to determine
1512 whether to pick up a symbol. DATA is the input of this callback
1513 function. Return NULL if symbol is not found. */
1516 gdb_bfd_lookup_symbol_from_symtab (bfd
*abfd
,
1517 int (*match_sym
) (const asymbol
*,
1521 long storage_needed
= bfd_get_symtab_upper_bound (abfd
);
1522 CORE_ADDR symaddr
= 0;
1524 if (storage_needed
> 0)
1528 asymbol
**symbol_table
= (asymbol
**) xmalloc (storage_needed
);
1529 struct cleanup
*back_to
= make_cleanup (xfree
, symbol_table
);
1530 unsigned int number_of_symbols
=
1531 bfd_canonicalize_symtab (abfd
, symbol_table
);
1533 for (i
= 0; i
< number_of_symbols
; i
++)
1535 asymbol
*sym
= *symbol_table
++;
1537 if (match_sym (sym
, data
))
1539 struct gdbarch
*gdbarch
= target_gdbarch ();
1540 symaddr
= sym
->value
;
1542 /* Some ELF targets fiddle with addresses of symbols they
1543 consider special. They use minimal symbols to do that
1544 and this is needed for correct breakpoint placement,
1545 but we do not have full data here to build a complete
1546 minimal symbol, so just set the address and let the
1547 targets cope with that. */
1548 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1549 && gdbarch_elf_make_msymbol_special_p (gdbarch
))
1551 struct minimal_symbol msym
;
1553 memset (&msym
, 0, sizeof (msym
));
1554 SET_MSYMBOL_VALUE_ADDRESS (&msym
, symaddr
);
1555 gdbarch_elf_make_msymbol_special (gdbarch
, sym
, &msym
);
1556 symaddr
= MSYMBOL_VALUE_RAW_ADDRESS (&msym
);
1559 /* BFD symbols are section relative. */
1560 symaddr
+= sym
->section
->vma
;
1564 do_cleanups (back_to
);
1570 /* Lookup the value for a specific symbol from symbol table. Look up symbol
1571 from ABFD. MATCH_SYM is a callback function to determine whether to pick
1572 up a symbol. DATA is the input of this callback function. Return NULL
1573 if symbol is not found. */
1576 bfd_lookup_symbol_from_dyn_symtab (bfd
*abfd
,
1577 int (*match_sym
) (const asymbol
*,
1581 long storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1582 CORE_ADDR symaddr
= 0;
1584 if (storage_needed
> 0)
1587 asymbol
**symbol_table
= (asymbol
**) xmalloc (storage_needed
);
1588 struct cleanup
*back_to
= make_cleanup (xfree
, symbol_table
);
1589 unsigned int number_of_symbols
=
1590 bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
1592 for (i
= 0; i
< number_of_symbols
; i
++)
1594 asymbol
*sym
= *symbol_table
++;
1596 if (match_sym (sym
, data
))
1598 /* BFD symbols are section relative. */
1599 symaddr
= sym
->value
+ sym
->section
->vma
;
1603 do_cleanups (back_to
);
1608 /* Lookup the value for a specific symbol from symbol table and dynamic
1609 symbol table. Look up symbol from ABFD. MATCH_SYM is a callback
1610 function to determine whether to pick up a symbol. DATA is the
1611 input of this callback function. Return NULL if symbol is not
1615 gdb_bfd_lookup_symbol (bfd
*abfd
,
1616 int (*match_sym
) (const asymbol
*, const void *),
1619 CORE_ADDR symaddr
= gdb_bfd_lookup_symbol_from_symtab (abfd
, match_sym
, data
);
1621 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
1622 have to check the dynamic string table too. */
1624 symaddr
= bfd_lookup_symbol_from_dyn_symtab (abfd
, match_sym
, data
);
1629 /* SO_LIST_HEAD may contain user-loaded object files that can be removed
1630 out-of-band by the user. So upon notification of free_objfile remove
1631 all references to any user-loaded file that is about to be freed. */
1634 remove_user_added_objfile (struct objfile
*objfile
)
1638 if (objfile
!= 0 && objfile
->flags
& OBJF_USERLOADED
)
1640 for (so
= so_list_head
; so
!= NULL
; so
= so
->next
)
1641 if (so
->objfile
== objfile
)
1646 extern initialize_file_ftype _initialize_solib
; /* -Wmissing-prototypes */
1649 _initialize_solib (void)
1651 solib_data
= gdbarch_data_register_pre_init (solib_init
);
1653 observer_attach_free_objfile (remove_user_added_objfile
);
1655 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
1656 _("Load shared object library symbols for files matching REGEXP."));
1657 add_info ("sharedlibrary", info_sharedlibrary_command
,
1658 _("Status of loaded shared object libraries."));
1659 add_info_alias ("dll", "sharedlibrary", 1);
1660 add_com ("nosharedlibrary", class_files
, no_shared_libraries
,
1661 _("Unload all shared object library symbols."));
1663 add_setshow_boolean_cmd ("auto-solib-add", class_support
,
1664 &auto_solib_add
, _("\
1665 Set autoloading of shared library symbols."), _("\
1666 Show autoloading of shared library symbols."), _("\
1667 If \"on\", symbols from all shared object libraries will be loaded\n\
1668 automatically when the inferior begins execution, when the dynamic linker\n\
1669 informs gdb that a new library has been loaded, or when attaching to the\n\
1670 inferior. Otherwise, symbols must be loaded manually, using \
1673 show_auto_solib_add
,
1674 &setlist
, &showlist
);
1676 add_setshow_optional_filename_cmd ("sysroot", class_support
,
1678 Set an alternate system root."), _("\
1679 Show the current system root."), _("\
1680 The system root is used to load absolute shared library symbol files.\n\
1681 For other (relative) files, you can add directories using\n\
1682 `set solib-search-path'."),
1683 gdb_sysroot_changed
,
1685 &setlist
, &showlist
);
1687 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support
, 0,
1689 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support
, 0,
1692 add_setshow_optional_filename_cmd ("solib-search-path", class_support
,
1693 &solib_search_path
, _("\
1694 Set the search path for loading non-absolute shared library symbol files."),
1696 Show the search path for loading non-absolute shared library symbol files."),
1698 This takes precedence over the environment variables \
1699 PATH and LD_LIBRARY_PATH."),
1700 reload_shared_libraries
,
1701 show_solib_search_path
,
1702 &setlist
, &showlist
);