1 /* Handle shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 1990-2015 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
= gdbarch_data (gdbarch
, solib_data
);
73 /* Set the solib operations for GDBARCH to NEW_OPS. */
76 set_solib_ops (struct gdbarch
*gdbarch
, const struct target_so_ops
*new_ops
)
78 const struct target_so_ops
**ops
= gdbarch_data (gdbarch
, solib_data
);
84 /* external data declarations */
86 /* FIXME: gdbarch needs to control this variable, or else every
87 configuration needs to call set_solib_ops. */
88 struct target_so_ops
*current_target_so_ops
;
90 /* List of known shared objects */
91 #define so_list_head current_program_space->so_list
93 /* Local function prototypes */
95 /* If non-empty, this is a search path for loading non-absolute shared library
96 symbol files. This takes precedence over the environment variables PATH
97 and LD_LIBRARY_PATH. */
98 static char *solib_search_path
= NULL
;
100 show_solib_search_path (struct ui_file
*file
, int from_tty
,
101 struct cmd_list_element
*c
, const char *value
)
103 fprintf_filtered (file
, _("The search path for loading non-absolute "
104 "shared library symbol files is %s.\n"),
108 /* Same as HAVE_DOS_BASED_FILE_SYSTEM, but useable as an rvalue. */
109 #if (HAVE_DOS_BASED_FILE_SYSTEM)
110 # define DOS_BASED_FILE_SYSTEM 1
112 # define DOS_BASED_FILE_SYSTEM 0
115 /* Return the full pathname of a binary file (the main executable
116 or a shared library file), or NULL if not found. The returned
117 pathname is malloc'ed and must be freed by the caller. *FD is
118 set to either -1 or an open file handle for the binary file.
120 Global variable GDB_SYSROOT is used as a prefix directory
121 to search for binary files if they have an absolute path.
122 If GDB_SYSROOT starts with "target:" and target filesystem
123 is the local filesystem then the "target:" prefix will be
124 stripped before the search starts. This ensures that the
125 same search algorithm is used for local files regardless of
126 whether a "target:" prefix was used.
128 Global variable SOLIB_SEARCH_PATH is used as a prefix directory
129 (or set of directories, as in LD_LIBRARY_PATH) to search for all
130 shared libraries if not found in either the sysroot (if set) or
131 the local filesystem. SOLIB_SEARCH_PATH is not used when searching
132 for the main executable.
135 * If a sysroot is set and path is absolute:
136 * Search for sysroot/path.
138 * Look for it literally (unmodified).
139 * If IS_SOLIB is non-zero:
140 * Look in SOLIB_SEARCH_PATH.
141 * If available, use target defined search function.
142 * If NO sysroot is set, perform the following two searches:
143 * Look in inferior's $PATH.
144 * If IS_SOLIB is non-zero:
145 * Look in inferior's $LD_LIBRARY_PATH.
147 * The last check avoids doing this search when targetting remote
148 * machines since a sysroot will almost always be set.
152 solib_find_1 (char *in_pathname
, int *fd
, int is_solib
)
154 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
156 char *temp_pathname
= NULL
;
157 const char *fskind
= effective_target_file_system_kind ();
158 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
159 char *sysroot
= gdb_sysroot
;
163 /* If the absolute prefix starts with "target:" but the
164 filesystem accessed by the target_fileio_* methods
165 is the local filesystem then we strip the "target:"
166 prefix now and work with the local filesystem. This
167 ensures that the same search algorithm is used for
168 all local files regardless of whether a "target:"
170 if (is_target_filename (sysroot
) && target_filesystem_is_local ())
171 sysroot
+= strlen (TARGET_SYSROOT_PREFIX
);
173 if (*sysroot
== '\0')
179 int prefix_len
= strlen (sysroot
);
181 /* Remove trailing slashes from absolute prefix. */
182 while (prefix_len
> 0
183 && IS_DIR_SEPARATOR (sysroot
[prefix_len
- 1]))
186 sysroot
= savestring (sysroot
, prefix_len
);
187 make_cleanup (xfree
, sysroot
);
190 /* If we're on a non-DOS-based system, backslashes won't be
191 understood as directory separator, so, convert them to forward
192 slashes, iff we're supposed to handle DOS-based file system
193 semantics for target paths. */
194 if (!DOS_BASED_FILE_SYSTEM
&& fskind
== file_system_kind_dos_based
)
198 /* Avoid clobbering our input. */
199 p
= alloca (strlen (in_pathname
) + 1);
200 strcpy (p
, in_pathname
);
210 /* Note, we're interested in IS_TARGET_ABSOLUTE_PATH, not
211 IS_ABSOLUTE_PATH. The latter is for host paths only, while
212 IN_PATHNAME is a target path. For example, if we're supposed to
213 be handling DOS-like semantics we want to consider a
214 'c:/foo/bar.dll' path as an absolute path, even on a Unix box.
215 With such a path, before giving up on the sysroot, we'll try:
217 1st attempt, c:/foo/bar.dll ==> /sysroot/c:/foo/bar.dll
218 2nd attempt, c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll
219 3rd attempt, c:/foo/bar.dll ==> /sysroot/foo/bar.dll
222 if (!IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
) || sysroot
== NULL
)
223 temp_pathname
= xstrdup (in_pathname
);
226 int need_dir_separator
;
228 /* Concatenate the sysroot and the target reported filename. We
229 may need to glue them with a directory separator. Cases to
232 | sysroot | separator | in_pathname |
233 |-----------------+-----------+----------------|
234 | /some/dir | / | c:/foo/bar.dll |
235 | /some/dir | | /foo/bar.dll |
236 | target: | | c:/foo/bar.dll |
237 | target: | | /foo/bar.dll |
238 | target:some/dir | / | c:/foo/bar.dll |
239 | target:some/dir | | /foo/bar.dll |
241 IOW, we don't need to add a separator if IN_PATHNAME already
242 has one, or when the the sysroot is exactly "target:".
243 There's no need to check for drive spec explicitly, as we only
244 get here if IN_PATHNAME is considered an absolute path. */
245 need_dir_separator
= !(IS_DIR_SEPARATOR (in_pathname
[0])
246 || strcmp (TARGET_SYSROOT_PREFIX
, sysroot
) == 0);
248 /* Cat the prefixed pathname together. */
249 temp_pathname
= concat (sysroot
,
250 need_dir_separator
? SLASH_STRING
: "",
251 in_pathname
, (char *) NULL
);
254 /* Handle files to be accessed via the target. */
255 if (is_target_filename (temp_pathname
))
258 do_cleanups (old_chain
);
259 return temp_pathname
;
262 /* Now see if we can open it. */
263 found_file
= gdb_open_cloexec (temp_pathname
, O_RDONLY
| O_BINARY
, 0);
265 xfree (temp_pathname
);
267 /* If the search in gdb_sysroot failed, and the path name has a
268 drive spec (e.g, c:/foo), try stripping ':' from the drive spec,
269 and retrying in the sysroot:
270 c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll. */
274 && HAS_TARGET_DRIVE_SPEC (fskind
, in_pathname
))
276 int need_dir_separator
= !IS_DIR_SEPARATOR (in_pathname
[2]);
277 char *drive
= savestring (in_pathname
, 1);
279 temp_pathname
= concat (sysroot
,
282 need_dir_separator
? SLASH_STRING
: "",
283 in_pathname
+ 2, (char *) NULL
);
286 found_file
= gdb_open_cloexec (temp_pathname
, O_RDONLY
| O_BINARY
, 0);
289 xfree (temp_pathname
);
291 /* If the search in gdb_sysroot still failed, try fully
292 stripping the drive spec, and trying once more in the
293 sysroot before giving up.
295 c:/foo/bar.dll ==> /sysroot/foo/bar.dll. */
297 temp_pathname
= concat (sysroot
,
298 need_dir_separator
? SLASH_STRING
: "",
299 in_pathname
+ 2, (char *) NULL
);
301 found_file
= gdb_open_cloexec (temp_pathname
, O_RDONLY
| O_BINARY
, 0);
303 xfree (temp_pathname
);
307 do_cleanups (old_chain
);
309 /* We try to find the library in various ways. After each attempt,
310 either found_file >= 0 and temp_pathname is a malloc'd string, or
311 found_file < 0 and temp_pathname does not point to storage that
312 needs to be freed. */
315 temp_pathname
= NULL
;
317 /* If the search in gdb_sysroot failed, and the path name is
318 absolute at this point, make it relative. (openp will try and open the
319 file according to its absolute path otherwise, which is not what we want.)
320 Affects subsequent searches for this solib. */
321 if (found_file
< 0 && IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
))
323 /* First, get rid of any drive letters etc. */
324 while (!IS_TARGET_DIR_SEPARATOR (fskind
, *in_pathname
))
327 /* Next, get rid of all leading dir separators. */
328 while (IS_TARGET_DIR_SEPARATOR (fskind
, *in_pathname
))
332 /* If not found, and we're looking for a solib, search the
333 solib_search_path (if any). */
334 if (is_solib
&& found_file
< 0 && solib_search_path
!= NULL
)
335 found_file
= openp (solib_search_path
,
336 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
337 in_pathname
, O_RDONLY
| O_BINARY
, &temp_pathname
);
339 /* If not found, and we're looking for a solib, next search the
340 solib_search_path (if any) for the basename only (ignoring the
341 path). This is to allow reading solibs from a path that differs
342 from the opened path. */
343 if (is_solib
&& found_file
< 0 && solib_search_path
!= NULL
)
344 found_file
= openp (solib_search_path
,
345 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
,
346 target_lbasename (fskind
, in_pathname
),
347 O_RDONLY
| O_BINARY
, &temp_pathname
);
349 /* If not found, and we're looking for a solib, try to use target
350 supplied solib search method. */
351 if (is_solib
&& found_file
< 0 && ops
->find_and_open_solib
)
352 found_file
= ops
->find_and_open_solib (in_pathname
, O_RDONLY
| O_BINARY
,
355 /* If not found, next search the inferior's $PATH environment variable. */
356 if (found_file
< 0 && sysroot
== NULL
)
357 found_file
= openp (get_in_environ (current_inferior ()->environment
,
359 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
, in_pathname
,
360 O_RDONLY
| O_BINARY
, &temp_pathname
);
362 /* If not found, and we're looking for a solib, next search the
363 inferior's $LD_LIBRARY_PATH environment variable. */
364 if (is_solib
&& found_file
< 0 && sysroot
== NULL
)
365 found_file
= openp (get_in_environ (current_inferior ()->environment
,
367 OPF_TRY_CWD_FIRST
| OPF_RETURN_REALPATH
, in_pathname
,
368 O_RDONLY
| O_BINARY
, &temp_pathname
);
371 return temp_pathname
;
374 /* Return the full pathname of the main executable, or NULL if not
375 found. The returned pathname is malloc'ed and must be freed by
376 the caller. *FD is set to either -1 or an open file handle for
379 The search algorithm used is described in solib_find_1's comment
383 exec_file_find (char *in_pathname
, int *fd
)
385 char *result
= solib_find_1 (in_pathname
, fd
, 0);
389 const char *fskind
= effective_target_file_system_kind ();
391 if (fskind
== file_system_kind_dos_based
)
395 new_pathname
= alloca (strlen (in_pathname
) + 5);
396 strcpy (new_pathname
, in_pathname
);
397 strcat (new_pathname
, ".exe");
399 result
= solib_find_1 (new_pathname
, fd
, 0);
406 /* Return the full pathname of a shared library file, or NULL if not
407 found. The returned pathname is malloc'ed and must be freed by
408 the caller. *FD is set to either -1 or an open file handle for
411 The search algorithm used is described in solib_find_1's comment
415 solib_find (char *in_pathname
, int *fd
)
417 const char *solib_symbols_extension
418 = gdbarch_solib_symbols_extension (target_gdbarch ());
420 /* If solib_symbols_extension is set, replace the file's
422 if (solib_symbols_extension
!= NULL
)
424 char *p
= in_pathname
+ strlen (in_pathname
);
426 while (p
> in_pathname
&& *p
!= '.')
433 new_pathname
= alloca (p
- in_pathname
+ 1
434 + strlen (solib_symbols_extension
) + 1);
435 memcpy (new_pathname
, in_pathname
, p
- in_pathname
+ 1);
436 strcpy (new_pathname
+ (p
- in_pathname
) + 1,
437 solib_symbols_extension
);
439 in_pathname
= new_pathname
;
443 return solib_find_1 (in_pathname
, fd
, 1);
446 /* Open and return a BFD for the shared library PATHNAME. If FD is not -1,
447 it is used as file handle to open the file. Throws an error if the file
448 could not be opened. Handles both local and remote file access.
450 PATHNAME must be malloc'ed by the caller. It will be freed by this
451 function. If unsuccessful, the FD will be closed (unless FD was
455 solib_bfd_fopen (char *pathname
, int fd
)
457 bfd
*abfd
= gdb_bfd_open (pathname
, gnutarget
, fd
);
459 if (abfd
!= NULL
&& !gdb_bfd_has_target_filename (abfd
))
460 bfd_set_cacheable (abfd
, 1);
464 make_cleanup (xfree
, pathname
);
465 error (_("Could not open `%s' as an executable file: %s"),
466 pathname
, bfd_errmsg (bfd_get_error ()));
474 /* Find shared library PATHNAME and open a BFD for it. */
477 solib_bfd_open (char *pathname
)
479 char *found_pathname
;
482 const struct bfd_arch_info
*b
;
484 /* Search for shared library file. */
485 found_pathname
= solib_find (pathname
, &found_file
);
486 if (found_pathname
== NULL
)
488 /* Return failure if the file could not be found, so that we can
489 accumulate messages about missing libraries. */
493 perror_with_name (pathname
);
496 /* Open bfd for shared library. */
497 abfd
= solib_bfd_fopen (found_pathname
, found_file
);
499 /* Check bfd format. */
500 if (!bfd_check_format (abfd
, bfd_object
))
502 make_cleanup_bfd_unref (abfd
);
503 error (_("`%s': not in executable format: %s"),
504 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
507 /* Check bfd arch. */
508 b
= gdbarch_bfd_arch_info (target_gdbarch ());
509 if (!b
->compatible (b
, bfd_get_arch_info (abfd
)))
510 warning (_("`%s': Shared library architecture %s is not compatible "
511 "with target architecture %s."), bfd_get_filename (abfd
),
512 bfd_get_arch_info (abfd
)->printable_name
, b
->printable_name
);
517 /* Given a pointer to one of the shared objects in our list of mapped
518 objects, use the recorded name to open a bfd descriptor for the
519 object, build a section table, relocate all the section addresses
520 by the base address at which the shared object was mapped, and then
521 add the sections to the target's section table.
523 FIXME: In most (all?) cases the shared object file name recorded in
524 the dynamic linkage tables will be a fully qualified pathname. For
525 cases where it isn't, do we really mimic the systems search
526 mechanism correctly in the below code (particularly the tilde
527 expansion stuff?). */
530 solib_map_sections (struct so_list
*so
)
532 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
534 struct target_section
*p
;
535 struct cleanup
*old_chain
;
538 filename
= tilde_expand (so
->so_name
);
539 old_chain
= make_cleanup (xfree
, filename
);
540 abfd
= ops
->bfd_open (filename
);
541 do_cleanups (old_chain
);
546 /* Leave bfd open, core_xfer_memory and "info files" need it. */
549 /* Copy the full path name into so_name, allowing symbol_file_add
550 to find it later. This also affects the =library-loaded GDB/MI
551 event, and in particular the part of that notification providing
552 the library's host-side path. If we let the target dictate
553 that objfile's path, and the target is different from the host,
554 GDB/MI will not provide the correct host-side path. */
555 if (strlen (bfd_get_filename (abfd
)) >= SO_NAME_MAX_PATH_SIZE
)
556 error (_("Shared library file name is too long."));
557 strcpy (so
->so_name
, bfd_get_filename (abfd
));
559 if (build_section_table (abfd
, &so
->sections
, &so
->sections_end
))
561 error (_("Can't find the file sections in `%s': %s"),
562 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
565 for (p
= so
->sections
; p
< so
->sections_end
; p
++)
567 /* Relocate the section binding addresses as recorded in the shared
568 object's file by the base address to which the object was actually
570 ops
->relocate_section_addresses (so
, p
);
572 /* If the target didn't provide information about the address
573 range of the shared object, assume we want the location of
574 the .text section. */
575 if (so
->addr_low
== 0 && so
->addr_high
== 0
576 && strcmp (p
->the_bfd_section
->name
, ".text") == 0)
578 so
->addr_low
= p
->addr
;
579 so
->addr_high
= p
->endaddr
;
583 /* Add the shared object's sections to the current set of file
584 section tables. Do this immediately after mapping the object so
585 that later nodes in the list can query this object, as is needed
587 add_target_sections (so
, so
->sections
, so
->sections_end
);
592 /* Free symbol-file related contents of SO and reset for possible reloading
593 of SO. If we have opened a BFD for SO, close it. If we have placed SO's
594 sections in some target's section table, the caller is responsible for
597 This function doesn't mess with objfiles at all. If there is an
598 objfile associated with SO that needs to be removed, the caller is
599 responsible for taking care of that. */
602 clear_so (struct so_list
*so
)
604 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
608 xfree (so
->sections
);
609 so
->sections
= so
->sections_end
= NULL
;
612 gdb_bfd_unref (so
->abfd
);
615 /* Our caller closed the objfile, possibly via objfile_purge_solibs. */
616 so
->symbols_loaded
= 0;
619 so
->addr_low
= so
->addr_high
= 0;
621 /* Restore the target-supplied file name. SO_NAME may be the path
622 of the symbol file. */
623 strcpy (so
->so_name
, so
->so_original_name
);
625 /* Do the same for target-specific data. */
626 if (ops
->clear_so
!= NULL
)
630 /* Free the storage associated with the `struct so_list' object SO.
631 If we have opened a BFD for SO, close it.
633 The caller is responsible for removing SO from whatever list it is
634 a member of. If we have placed SO's sections in some target's
635 section table, the caller is responsible for removing them.
637 This function doesn't mess with objfiles at all. If there is an
638 objfile associated with SO that needs to be removed, the caller is
639 responsible for taking care of that. */
642 free_so (struct so_list
*so
)
644 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
653 /* Return address of first so_list entry in master shared object list. */
655 master_so_list (void)
660 /* Read in symbols for shared object SO. If SYMFILE_VERBOSE is set in FLAGS,
661 be chatty about it. Return non-zero if any symbols were actually
665 solib_read_symbols (struct so_list
*so
, int flags
)
667 if (so
->symbols_loaded
)
669 /* If needed, we've already warned in our caller. */
671 else if (so
->abfd
== NULL
)
673 /* We've already warned about this library, when trying to open
679 flags
|= current_inferior ()->symfile_flags
;
683 struct section_addr_info
*sap
;
685 /* Have we already loaded this shared object? */
686 ALL_OBJFILES (so
->objfile
)
688 if (filename_cmp (objfile_name (so
->objfile
), so
->so_name
) == 0
689 && so
->objfile
->addr_low
== so
->addr_low
)
692 if (so
->objfile
!= NULL
)
695 sap
= build_section_addr_info_from_section_table (so
->sections
,
697 so
->objfile
= symbol_file_add_from_bfd (so
->abfd
, so
->so_name
,
698 flags
, sap
, OBJF_SHARED
,
700 so
->objfile
->addr_low
= so
->addr_low
;
701 free_section_addr_info (sap
);
703 so
->symbols_loaded
= 1;
705 CATCH (e
, RETURN_MASK_ERROR
)
707 exception_fprintf (gdb_stderr
, e
, _("Error while reading shared"
708 " library symbols for %s:\n"),
719 /* Return 1 if KNOWN->objfile is used by any other so_list object in the
720 SO_LIST_HEAD list. Return 0 otherwise. */
723 solib_used (const struct so_list
*const known
)
725 const struct so_list
*pivot
;
727 for (pivot
= so_list_head
; pivot
!= NULL
; pivot
= pivot
->next
)
728 if (pivot
!= known
&& pivot
->objfile
== known
->objfile
)
733 /* Synchronize GDB's shared object list with inferior's.
735 Extract the list of currently loaded shared objects from the
736 inferior, and compare it with the list of shared objects currently
737 in GDB's so_list_head list. Edit so_list_head to bring it in sync
738 with the inferior's new list.
740 If we notice that the inferior has unloaded some shared objects,
741 free any symbolic info GDB had read about those shared objects.
743 Don't load symbolic info for any new shared objects; just add them
744 to the list, and leave their symbols_loaded flag clear.
746 If FROM_TTY is non-null, feel free to print messages about what
749 If TARGET is non-null, add the sections of all new shared objects
750 to TARGET's section table. Note that this doesn't remove any
751 sections for shared objects that have been unloaded, and it
752 doesn't check to see if the new shared objects are already present in
753 the section table. But we only use this for core files and
754 processes we've just attached to, so that's okay. */
757 update_solib_list (int from_tty
, struct target_ops
*target
)
759 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
760 struct so_list
*inferior
= ops
->current_sos();
761 struct so_list
*gdb
, **gdb_link
;
763 /* We can reach here due to changing solib-search-path or the
764 sysroot, before having any inferior. */
765 if (target_has_execution
&& !ptid_equal (inferior_ptid
, null_ptid
))
767 struct inferior
*inf
= current_inferior ();
769 /* If we are attaching to a running process for which we
770 have not opened a symbol file, we may be able to get its
772 if (inf
->attach_flag
&& symfile_objfile
== NULL
)
773 catch_errors (ops
->open_symbol_file_object
, &from_tty
,
774 "Error reading attached process's symbol file.\n",
778 /* GDB and the inferior's dynamic linker each maintain their own
779 list of currently loaded shared objects; we want to bring the
780 former in sync with the latter. Scan both lists, seeing which
781 shared objects appear where. There are three cases:
783 - A shared object appears on both lists. This means that GDB
784 knows about it already, and it's still loaded in the inferior.
785 Nothing needs to happen.
787 - A shared object appears only on GDB's list. This means that
788 the inferior has unloaded it. We should remove the shared
789 object from GDB's tables.
791 - A shared object appears only on the inferior's list. This
792 means that it's just been loaded. We should add it to GDB's
795 So we walk GDB's list, checking each entry to see if it appears
796 in the inferior's list too. If it does, no action is needed, and
797 we remove it from the inferior's list. If it doesn't, the
798 inferior has unloaded it, and we remove it from GDB's list. By
799 the time we're done walking GDB's list, the inferior's list
800 contains only the new shared objects, which we then add. */
803 gdb_link
= &so_list_head
;
806 struct so_list
*i
= inferior
;
807 struct so_list
**i_link
= &inferior
;
809 /* Check to see whether the shared object *gdb also appears in
810 the inferior's current list. */
815 if (ops
->same (gdb
, i
))
820 if (! filename_cmp (gdb
->so_original_name
, i
->so_original_name
))
828 /* If the shared object appears on the inferior's list too, then
829 it's still loaded, so we don't need to do anything. Delete
830 it from the inferior's list, and leave it on GDB's list. */
835 gdb_link
= &gdb
->next
;
839 /* If it's not on the inferior's list, remove it from GDB's tables. */
842 /* Notify any observer that the shared object has been
843 unloaded before we remove it from GDB's tables. */
844 observer_notify_solib_unloaded (gdb
);
846 VEC_safe_push (char_ptr
, current_program_space
->deleted_solibs
,
847 xstrdup (gdb
->so_name
));
849 *gdb_link
= gdb
->next
;
851 /* Unless the user loaded it explicitly, free SO's objfile. */
852 if (gdb
->objfile
&& ! (gdb
->objfile
->flags
& OBJF_USERLOADED
)
853 && !solib_used (gdb
))
854 free_objfile (gdb
->objfile
);
856 /* Some targets' section tables might be referring to
857 sections from so->abfd; remove them. */
858 remove_target_sections (gdb
);
865 /* Now the inferior's list contains only shared objects that don't
866 appear in GDB's list --- those that are newly loaded. Add them
867 to GDB's shared object list. */
871 const char *not_found_filename
= NULL
;
875 /* Add the new shared objects to GDB's list. */
876 *gdb_link
= inferior
;
878 /* Fill in the rest of each of the `struct so_list' nodes. */
879 for (i
= inferior
; i
; i
= i
->next
)
882 i
->pspace
= current_program_space
;
883 VEC_safe_push (so_list_ptr
, current_program_space
->added_solibs
, i
);
887 /* Fill in the rest of the `struct so_list' node. */
888 if (!solib_map_sections (i
))
891 if (not_found_filename
== NULL
)
892 not_found_filename
= i
->so_original_name
;
896 CATCH (e
, RETURN_MASK_ERROR
)
898 exception_fprintf (gdb_stderr
, e
,
899 _("Error while mapping shared "
900 "library sections:\n"));
904 /* Notify any observer that the shared object has been
905 loaded now that we've added it to GDB's tables. */
906 observer_notify_solib_loaded (i
);
909 /* If a library was not found, issue an appropriate warning
910 message. We have to use a single call to warning in case the
911 front end does something special with warnings, e.g., pop up
912 a dialog box. It Would Be Nice if we could get a "warning: "
913 prefix on each line in the CLI front end, though - it doesn't
917 warning (_("Could not load shared library symbols for %s.\n"
918 "Do you need \"set solib-search-path\" "
919 "or \"set sysroot\"?"),
921 else if (not_found
> 1)
923 Could not load shared library symbols for %d libraries, e.g. %s.\n\
924 Use the \"info sharedlibrary\" command to see the complete listing.\n\
925 Do you need \"set solib-search-path\" or \"set sysroot\"?"),
926 not_found
, not_found_filename
);
931 /* Return non-zero if NAME is the libpthread shared library.
933 Uses a fairly simplistic heuristic approach where we check
934 the file name against "/libpthread". This can lead to false
935 positives, but this should be good enough in practice. */
938 libpthread_name_p (const char *name
)
940 return (strstr (name
, "/libpthread") != NULL
);
943 /* Return non-zero if SO is the libpthread shared library. */
946 libpthread_solib_p (struct so_list
*so
)
948 return libpthread_name_p (so
->so_name
);
951 /* Read in symbolic information for any shared objects whose names
952 match PATTERN. (If we've already read a shared object's symbol
953 info, leave it alone.) If PATTERN is zero, read them all.
955 If READSYMS is 0, defer reading symbolic information until later
956 but still do any needed low level processing.
958 FROM_TTY and TARGET are as described for update_solib_list, above. */
961 solib_add (const char *pattern
, int from_tty
,
962 struct target_ops
*target
, int readsyms
)
966 if (print_symbol_loading_p (from_tty
, 0, 0))
970 printf_unfiltered (_("Loading symbols for shared libraries: %s\n"),
974 printf_unfiltered (_("Loading symbols for shared libraries.\n"));
977 current_program_space
->solib_add_generation
++;
981 char *re_err
= re_comp (pattern
);
984 error (_("Invalid regexp: %s"), re_err
);
987 update_solib_list (from_tty
, target
);
989 /* Walk the list of currently loaded shared libraries, and read
990 symbols for any that match the pattern --- or any whose symbols
991 aren't already loaded, if no pattern was given. */
994 int loaded_any_symbols
= 0;
996 SYMFILE_DEFER_BP_RESET
| (from_tty
? SYMFILE_VERBOSE
: 0);
998 for (gdb
= so_list_head
; gdb
; gdb
= gdb
->next
)
999 if (! pattern
|| re_exec (gdb
->so_name
))
1001 /* Normally, we would read the symbols from that library
1002 only if READSYMS is set. However, we're making a small
1003 exception for the pthread library, because we sometimes
1004 need the library symbols to be loaded in order to provide
1005 thread support (x86-linux for instance). */
1006 const int add_this_solib
=
1007 (readsyms
|| libpthread_solib_p (gdb
));
1012 if (gdb
->symbols_loaded
)
1014 /* If no pattern was given, be quiet for shared
1015 libraries we have already loaded. */
1016 if (pattern
&& (from_tty
|| info_verbose
))
1017 printf_unfiltered (_("Symbols already loaded for %s\n"),
1020 else if (solib_read_symbols (gdb
, flags
))
1021 loaded_any_symbols
= 1;
1025 if (loaded_any_symbols
)
1026 breakpoint_re_set ();
1028 if (from_tty
&& pattern
&& ! any_matches
)
1030 ("No loaded shared libraries match the pattern `%s'.\n", pattern
);
1032 if (loaded_any_symbols
)
1034 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1036 /* Getting new symbols may change our opinion about what is
1038 reinit_frame_cache ();
1040 ops
->special_symbol_handling ();
1045 /* Implement the "info sharedlibrary" command. Walk through the
1046 shared library list and print information about each attached
1047 library matching PATTERN. If PATTERN is elided, print them
1051 info_sharedlibrary_command (char *pattern
, int from_tty
)
1053 struct so_list
*so
= NULL
; /* link map state variable */
1054 int so_missing_debug_info
= 0;
1057 struct cleanup
*table_cleanup
;
1058 struct gdbarch
*gdbarch
= target_gdbarch ();
1059 struct ui_out
*uiout
= current_uiout
;
1063 char *re_err
= re_comp (pattern
);
1066 error (_("Invalid regexp: %s"), re_err
);
1069 /* "0x", a little whitespace, and two hex digits per byte of pointers. */
1070 addr_width
= 4 + (gdbarch_ptr_bit (gdbarch
) / 4);
1072 update_solib_list (from_tty
, 0);
1074 /* make_cleanup_ui_out_table_begin_end needs to know the number of
1075 rows, so we need to make two passes over the libs. */
1077 for (nr_libs
= 0, so
= so_list_head
; so
; so
= so
->next
)
1081 if (pattern
&& ! re_exec (so
->so_name
))
1088 make_cleanup_ui_out_table_begin_end (uiout
, 4, nr_libs
,
1089 "SharedLibraryTable");
1091 /* The "- 1" is because ui_out adds one space between columns. */
1092 ui_out_table_header (uiout
, addr_width
- 1, ui_left
, "from", "From");
1093 ui_out_table_header (uiout
, addr_width
- 1, ui_left
, "to", "To");
1094 ui_out_table_header (uiout
, 12 - 1, ui_left
, "syms-read", "Syms Read");
1095 ui_out_table_header (uiout
, 0, ui_noalign
,
1096 "name", "Shared Object Library");
1098 ui_out_table_body (uiout
);
1100 for (so
= so_list_head
; so
; so
= so
->next
)
1102 struct cleanup
*lib_cleanup
;
1104 if (! so
->so_name
[0])
1106 if (pattern
&& ! re_exec (so
->so_name
))
1109 lib_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, "lib");
1111 if (so
->addr_high
!= 0)
1113 ui_out_field_core_addr (uiout
, "from", gdbarch
, so
->addr_low
);
1114 ui_out_field_core_addr (uiout
, "to", gdbarch
, so
->addr_high
);
1118 ui_out_field_skip (uiout
, "from");
1119 ui_out_field_skip (uiout
, "to");
1122 if (! ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1123 && so
->symbols_loaded
1124 && !objfile_has_symbols (so
->objfile
))
1126 so_missing_debug_info
= 1;
1127 ui_out_field_string (uiout
, "syms-read", "Yes (*)");
1130 ui_out_field_string (uiout
, "syms-read",
1131 so
->symbols_loaded
? "Yes" : "No");
1133 ui_out_field_string (uiout
, "name", so
->so_name
);
1135 ui_out_text (uiout
, "\n");
1137 do_cleanups (lib_cleanup
);
1140 do_cleanups (table_cleanup
);
1145 ui_out_message (uiout
, 0,
1146 _("No shared libraries matched.\n"));
1148 ui_out_message (uiout
, 0,
1149 _("No shared libraries loaded at this time.\n"));
1153 if (so_missing_debug_info
)
1154 ui_out_message (uiout
, 0,
1155 _("(*): Shared library is missing "
1156 "debugging information.\n"));
1160 /* Return 1 if ADDRESS lies within SOLIB. */
1163 solib_contains_address_p (const struct so_list
*const solib
,
1166 struct target_section
*p
;
1168 for (p
= solib
->sections
; p
< solib
->sections_end
; p
++)
1169 if (p
->addr
<= address
&& address
< p
->endaddr
)
1175 /* If ADDRESS is in a shared lib in program space PSPACE, return its
1178 Provides a hook for other gdb routines to discover whether or not a
1179 particular address is within the mapped address space of a shared
1182 For example, this routine is called at one point to disable
1183 breakpoints which are in shared libraries that are not currently
1187 solib_name_from_address (struct program_space
*pspace
, CORE_ADDR address
)
1189 struct so_list
*so
= NULL
;
1191 for (so
= pspace
->so_list
; so
; so
= so
->next
)
1192 if (solib_contains_address_p (so
, address
))
1193 return (so
->so_name
);
1198 /* Return whether the data starting at VADDR, size SIZE, must be kept
1199 in a core file for shared libraries loaded before "gcore" is used
1200 to be handled correctly when the core file is loaded. This only
1201 applies when the section would otherwise not be kept in the core
1202 file (in particular, for readonly sections). */
1205 solib_keep_data_in_core (CORE_ADDR vaddr
, unsigned long size
)
1207 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1209 if (ops
->keep_data_in_core
)
1210 return ops
->keep_data_in_core (vaddr
, size
);
1215 /* Called by free_all_symtabs */
1220 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1222 /* This function is expected to handle ELF shared libraries. It is
1223 also used on Solaris, which can run either ELF or a.out binaries
1224 (for compatibility with SunOS 4), both of which can use shared
1225 libraries. So we don't know whether we have an ELF executable or
1226 an a.out executable until the user chooses an executable file.
1228 ELF shared libraries don't get mapped into the address space
1229 until after the program starts, so we'd better not try to insert
1230 breakpoints in them immediately. We have to wait until the
1231 dynamic linker has loaded them; we'll hit a bp_shlib_event
1232 breakpoint (look for calls to create_solib_event_breakpoint) when
1235 SunOS shared libraries seem to be different --- they're present
1236 as soon as the process begins execution, so there's no need to
1237 put off inserting breakpoints. There's also nowhere to put a
1238 bp_shlib_event breakpoint, so if we put it off, we'll never get
1241 So: disable breakpoints only if we're using ELF shared libs. */
1242 if (exec_bfd
!= NULL
1243 && bfd_get_flavour (exec_bfd
) != bfd_target_aout_flavour
)
1244 disable_breakpoints_in_shlibs ();
1246 while (so_list_head
)
1248 struct so_list
*so
= so_list_head
;
1250 so_list_head
= so
->next
;
1251 observer_notify_solib_unloaded (so
);
1252 remove_target_sections (so
);
1256 ops
->clear_solib ();
1259 /* Shared library startup support. When GDB starts up the inferior,
1260 it nurses it along (through the shell) until it is ready to execute
1261 its first instruction. At this point, this function gets
1265 solib_create_inferior_hook (int from_tty
)
1267 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1269 ops
->solib_create_inferior_hook (from_tty
);
1272 /* Check to see if an address is in the dynamic loader's dynamic
1273 symbol resolution code. Return 1 if so, 0 otherwise. */
1276 in_solib_dynsym_resolve_code (CORE_ADDR pc
)
1278 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1280 return ops
->in_dynsym_resolve_code (pc
);
1283 /* Implements the "sharedlibrary" command. */
1286 sharedlibrary_command (char *args
, int from_tty
)
1289 solib_add (args
, from_tty
, (struct target_ops
*) 0, 1);
1292 /* Implements the command "nosharedlibrary", which discards symbols
1293 that have been auto-loaded from shared libraries. Symbols from
1294 shared libraries that were added by explicit request of the user
1295 are not discarded. Also called from remote.c. */
1298 no_shared_libraries (char *ignored
, int from_tty
)
1300 /* The order of the two routines below is important: clear_solib notifies
1301 the solib_unloaded observers, and some of these observers might need
1302 access to their associated objfiles. Therefore, we can not purge the
1303 solibs' objfiles before clear_solib has been called. */
1306 objfile_purge_solibs ();
1312 update_solib_breakpoints (void)
1314 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1316 if (ops
->update_breakpoints
!= NULL
)
1317 ops
->update_breakpoints ();
1323 handle_solib_event (void)
1325 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1327 if (ops
->handle_event
!= NULL
)
1328 ops
->handle_event ();
1330 clear_program_space_solib_cache (current_inferior ()->pspace
);
1332 /* Check for any newly added shared libraries if we're supposed to
1333 be adding them automatically. Switch terminal for any messages
1334 produced by breakpoint_re_set. */
1335 target_terminal_ours_for_output ();
1336 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
1337 target_terminal_inferior ();
1340 /* Reload shared libraries, but avoid reloading the same symbol file
1341 we already have loaded. */
1344 reload_shared_libraries_1 (int from_tty
)
1347 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1349 if (print_symbol_loading_p (from_tty
, 0, 0))
1350 printf_unfiltered (_("Loading symbols for shared libraries.\n"));
1352 for (so
= so_list_head
; so
!= NULL
; so
= so
->next
)
1354 char *filename
, *found_pathname
= NULL
;
1356 int was_loaded
= so
->symbols_loaded
;
1358 SYMFILE_DEFER_BP_RESET
| (from_tty
? SYMFILE_VERBOSE
: 0);
1360 filename
= tilde_expand (so
->so_original_name
);
1361 make_cleanup (xfree
, filename
);
1362 abfd
= solib_bfd_open (filename
);
1365 found_pathname
= xstrdup (bfd_get_filename (abfd
));
1366 make_cleanup (xfree
, found_pathname
);
1367 gdb_bfd_unref (abfd
);
1370 /* If this shared library is no longer associated with its previous
1371 symbol file, close that. */
1372 if ((found_pathname
== NULL
&& was_loaded
)
1373 || (found_pathname
!= NULL
1374 && filename_cmp (found_pathname
, so
->so_name
) != 0))
1376 if (so
->objfile
&& ! (so
->objfile
->flags
& OBJF_USERLOADED
)
1377 && !solib_used (so
))
1378 free_objfile (so
->objfile
);
1379 remove_target_sections (so
);
1383 /* If this shared library is now associated with a new symbol
1385 if (found_pathname
!= NULL
1387 || filename_cmp (found_pathname
, so
->so_name
) != 0))
1393 solib_map_sections (so
);
1396 CATCH (e
, RETURN_MASK_ERROR
)
1398 exception_fprintf (gdb_stderr
, e
,
1399 _("Error while mapping "
1400 "shared library sections:\n"));
1406 && (auto_solib_add
|| was_loaded
|| libpthread_solib_p (so
)))
1407 solib_read_symbols (so
, flags
);
1411 do_cleanups (old_chain
);
1415 reload_shared_libraries (char *ignored
, int from_tty
,
1416 struct cmd_list_element
*e
)
1418 const struct target_so_ops
*ops
;
1420 reload_shared_libraries_1 (from_tty
);
1422 ops
= solib_ops (target_gdbarch ());
1424 /* Creating inferior hooks here has two purposes. First, if we reload
1425 shared libraries then the address of solib breakpoint we've computed
1426 previously might be no longer valid. For example, if we forgot to set
1427 solib-absolute-prefix and are setting it right now, then the previous
1428 breakpoint address is plain wrong. Second, installing solib hooks
1429 also implicitly figures were ld.so is and loads symbols for it.
1430 Absent this call, if we've just connected to a target and set
1431 solib-absolute-prefix or solib-search-path, we'll lose all information
1433 if (target_has_execution
)
1435 /* Reset or free private data structures not associated with
1437 ops
->clear_solib ();
1439 /* Remove any previous solib event breakpoint. This is usually
1440 done in common code, at breakpoint_init_inferior time, but
1441 we're not really starting up the inferior here. */
1442 remove_solib_event_breakpoints ();
1444 solib_create_inferior_hook (from_tty
);
1447 /* Sometimes the platform-specific hook loads initial shared
1448 libraries, and sometimes it doesn't. If it doesn't FROM_TTY will be
1449 incorrectly 0 but such solib targets should be fixed anyway. If we
1450 made all the inferior hook methods consistent, this call could be
1451 removed. Call it only after the solib target has been initialized by
1452 solib_create_inferior_hook. */
1454 solib_add (NULL
, 0, NULL
, auto_solib_add
);
1456 breakpoint_re_set ();
1458 /* We may have loaded or unloaded debug info for some (or all)
1459 shared libraries. However, frames may still reference them. For
1460 example, a frame's unwinder might still point at DWARF FDE
1461 structures that are now freed. Also, getting new symbols may
1462 change our opinion about what is frameless. */
1463 reinit_frame_cache ();
1465 ops
->special_symbol_handling ();
1468 /* Wrapper for reload_shared_libraries that replaces "remote:"
1469 at the start of gdb_sysroot with "target:". */
1472 gdb_sysroot_changed (char *ignored
, int from_tty
,
1473 struct cmd_list_element
*e
)
1475 const char *old_prefix
= "remote:";
1476 const char *new_prefix
= TARGET_SYSROOT_PREFIX
;
1478 if (startswith (gdb_sysroot
, old_prefix
))
1480 static int warning_issued
= 0;
1482 gdb_assert (strlen (old_prefix
) == strlen (new_prefix
));
1483 memcpy (gdb_sysroot
, new_prefix
, strlen (new_prefix
));
1485 if (!warning_issued
)
1487 warning (_("\"%s\" is deprecated, use \"%s\" instead."),
1488 old_prefix
, new_prefix
);
1489 warning (_("sysroot set to \"%s\"."), gdb_sysroot
);
1495 reload_shared_libraries (ignored
, from_tty
, e
);
1499 show_auto_solib_add (struct ui_file
*file
, int from_tty
,
1500 struct cmd_list_element
*c
, const char *value
)
1502 fprintf_filtered (file
, _("Autoloading of shared library symbols is %s.\n"),
1507 /* Handler for library-specific lookup of global symbol NAME in OBJFILE. Call
1508 the library-specific handler if it is installed for the current target. */
1511 solib_global_lookup (struct objfile
*objfile
,
1513 const domain_enum domain
)
1515 const struct target_so_ops
*ops
= solib_ops (get_objfile_arch (objfile
));
1517 if (ops
->lookup_lib_global_symbol
!= NULL
)
1518 return ops
->lookup_lib_global_symbol (objfile
, name
, domain
);
1522 /* Lookup the value for a specific symbol from dynamic symbol table. Look
1523 up symbol from ABFD. MATCH_SYM is a callback function to determine
1524 whether to pick up a symbol. DATA is the input of this callback
1525 function. Return NULL if symbol is not found. */
1528 gdb_bfd_lookup_symbol_from_symtab (bfd
*abfd
,
1529 int (*match_sym
) (asymbol
*, void *),
1532 long storage_needed
= bfd_get_symtab_upper_bound (abfd
);
1533 CORE_ADDR symaddr
= 0;
1535 if (storage_needed
> 0)
1539 asymbol
**symbol_table
= (asymbol
**) xmalloc (storage_needed
);
1540 struct cleanup
*back_to
= make_cleanup (xfree
, symbol_table
);
1541 unsigned int number_of_symbols
=
1542 bfd_canonicalize_symtab (abfd
, symbol_table
);
1544 for (i
= 0; i
< number_of_symbols
; i
++)
1546 asymbol
*sym
= *symbol_table
++;
1548 if (match_sym (sym
, data
))
1550 struct gdbarch
*gdbarch
= target_gdbarch ();
1551 symaddr
= sym
->value
;
1553 /* Some ELF targets fiddle with addresses of symbols they
1554 consider special. They use minimal symbols to do that
1555 and this is needed for correct breakpoint placement,
1556 but we do not have full data here to build a complete
1557 minimal symbol, so just set the address and let the
1558 targets cope with that. */
1559 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
1560 && gdbarch_elf_make_msymbol_special_p (gdbarch
))
1562 struct minimal_symbol msym
;
1564 memset (&msym
, 0, sizeof (msym
));
1565 SET_MSYMBOL_VALUE_ADDRESS (&msym
, symaddr
);
1566 gdbarch_elf_make_msymbol_special (gdbarch
, sym
, &msym
);
1567 symaddr
= MSYMBOL_VALUE_RAW_ADDRESS (&msym
);
1570 /* BFD symbols are section relative. */
1571 symaddr
+= sym
->section
->vma
;
1575 do_cleanups (back_to
);
1581 /* Lookup the value for a specific symbol from symbol table. Look up symbol
1582 from ABFD. MATCH_SYM is a callback function to determine whether to pick
1583 up a symbol. DATA is the input of this callback function. Return NULL
1584 if symbol is not found. */
1587 bfd_lookup_symbol_from_dyn_symtab (bfd
*abfd
,
1588 int (*match_sym
) (asymbol
*, void *),
1591 long storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1592 CORE_ADDR symaddr
= 0;
1594 if (storage_needed
> 0)
1597 asymbol
**symbol_table
= (asymbol
**) xmalloc (storage_needed
);
1598 struct cleanup
*back_to
= make_cleanup (xfree
, symbol_table
);
1599 unsigned int number_of_symbols
=
1600 bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
1602 for (i
= 0; i
< number_of_symbols
; i
++)
1604 asymbol
*sym
= *symbol_table
++;
1606 if (match_sym (sym
, data
))
1608 /* BFD symbols are section relative. */
1609 symaddr
= sym
->value
+ sym
->section
->vma
;
1613 do_cleanups (back_to
);
1618 /* Lookup the value for a specific symbol from symbol table and dynamic
1619 symbol table. Look up symbol from ABFD. MATCH_SYM is a callback
1620 function to determine whether to pick up a symbol. DATA is the
1621 input of this callback function. Return NULL if symbol is not
1625 gdb_bfd_lookup_symbol (bfd
*abfd
,
1626 int (*match_sym
) (asymbol
*, void *),
1629 CORE_ADDR symaddr
= gdb_bfd_lookup_symbol_from_symtab (abfd
, match_sym
, data
);
1631 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
1632 have to check the dynamic string table too. */
1634 symaddr
= bfd_lookup_symbol_from_dyn_symtab (abfd
, match_sym
, data
);
1639 /* SO_LIST_HEAD may contain user-loaded object files that can be removed
1640 out-of-band by the user. So upon notification of free_objfile remove
1641 all references to any user-loaded file that is about to be freed. */
1644 remove_user_added_objfile (struct objfile
*objfile
)
1648 if (objfile
!= 0 && objfile
->flags
& OBJF_USERLOADED
)
1650 for (so
= so_list_head
; so
!= NULL
; so
= so
->next
)
1651 if (so
->objfile
== objfile
)
1656 extern initialize_file_ftype _initialize_solib
; /* -Wmissing-prototypes */
1659 _initialize_solib (void)
1661 solib_data
= gdbarch_data_register_pre_init (solib_init
);
1663 observer_attach_free_objfile (remove_user_added_objfile
);
1665 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
1666 _("Load shared object library symbols for files matching REGEXP."));
1667 add_info ("sharedlibrary", info_sharedlibrary_command
,
1668 _("Status of loaded shared object libraries."));
1669 add_com ("nosharedlibrary", class_files
, no_shared_libraries
,
1670 _("Unload all shared object library symbols."));
1672 add_setshow_boolean_cmd ("auto-solib-add", class_support
,
1673 &auto_solib_add
, _("\
1674 Set autoloading of shared library symbols."), _("\
1675 Show autoloading of shared library symbols."), _("\
1676 If \"on\", symbols from all shared object libraries will be loaded\n\
1677 automatically when the inferior begins execution, when the dynamic linker\n\
1678 informs gdb that a new library has been loaded, or when attaching to the\n\
1679 inferior. Otherwise, symbols must be loaded manually, using \
1682 show_auto_solib_add
,
1683 &setlist
, &showlist
);
1685 add_setshow_optional_filename_cmd ("sysroot", class_support
,
1687 Set an alternate system root."), _("\
1688 Show the current system root."), _("\
1689 The system root is used to load absolute shared library symbol files.\n\
1690 For other (relative) files, you can add directories using\n\
1691 `set solib-search-path'."),
1692 gdb_sysroot_changed
,
1694 &setlist
, &showlist
);
1696 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support
, 0,
1698 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support
, 0,
1701 add_setshow_optional_filename_cmd ("solib-search-path", class_support
,
1702 &solib_search_path
, _("\
1703 Set the search path for loading non-absolute shared library symbol files."),
1705 Show the search path for loading non-absolute shared library symbol files."),
1707 This takes precedence over the environment variables \
1708 PATH and LD_LIBRARY_PATH."),
1709 reload_shared_libraries
,
1710 show_solib_search_path
,
1711 &setlist
, &showlist
);