1 /* Handle shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 1990-2013 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>
24 #include "gdb_string.h"
29 #include "exceptions.h"
34 #include "gdb_regex.h"
39 #include "completer.h"
40 #include "filenames.h" /* for DOSish file names */
44 #include "readline/readline.h"
48 #include "filesystem.h"
50 #include "filestuff.h"
52 /* Architecture-specific operations. */
54 /* Per-architecture data key. */
55 static struct gdbarch_data
*solib_data
;
58 solib_init (struct obstack
*obstack
)
60 struct target_so_ops
**ops
;
62 ops
= OBSTACK_ZALLOC (obstack
, struct target_so_ops
*);
63 *ops
= current_target_so_ops
;
67 static const struct target_so_ops
*
68 solib_ops (struct gdbarch
*gdbarch
)
70 const struct target_so_ops
**ops
= gdbarch_data (gdbarch
, solib_data
);
75 /* Set the solib operations for GDBARCH to NEW_OPS. */
78 set_solib_ops (struct gdbarch
*gdbarch
, const struct target_so_ops
*new_ops
)
80 const struct target_so_ops
**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 /* Returns the full pathname of the shared library file, or NULL if
118 not found. (The pathname is malloc'ed; it needs to be freed by the
119 caller.) *FD is set to either -1 or an open file handle for the
122 Global variable GDB_SYSROOT is used as a prefix directory
123 to search for shared libraries if they have an absolute path.
125 Global variable SOLIB_SEARCH_PATH is used as a prefix directory
126 (or set of directories, as in LD_LIBRARY_PATH) to search for all
127 shared libraries if not found in GDB_SYSROOT.
130 * If there is a gdb_sysroot and path is absolute:
131 * Search for gdb_sysroot/path.
133 * Look for it literally (unmodified).
134 * Look in SOLIB_SEARCH_PATH.
135 * If available, use target defined search function.
136 * If gdb_sysroot is NOT set, perform the following two searches:
137 * Look in inferior's $PATH.
138 * Look in inferior's $LD_LIBRARY_PATH.
140 * The last check avoids doing this search when targetting remote
141 * machines since gdb_sysroot will almost always be set.
145 solib_find (char *in_pathname
, int *fd
)
147 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
149 char *temp_pathname
= NULL
;
150 int gdb_sysroot_is_empty
;
151 const char *solib_symbols_extension
152 = gdbarch_solib_symbols_extension (target_gdbarch ());
153 const char *fskind
= effective_target_file_system_kind ();
154 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
155 char *sysroot
= NULL
;
157 /* If solib_symbols_extension is set, replace the file's
159 if (solib_symbols_extension
)
161 char *p
= in_pathname
+ strlen (in_pathname
);
163 while (p
> in_pathname
&& *p
!= '.')
170 new_pathname
= alloca (p
- in_pathname
+ 1
171 + strlen (solib_symbols_extension
) + 1);
172 memcpy (new_pathname
, in_pathname
, p
- in_pathname
+ 1);
173 strcpy (new_pathname
+ (p
- in_pathname
) + 1,
174 solib_symbols_extension
);
176 in_pathname
= new_pathname
;
180 gdb_sysroot_is_empty
= (gdb_sysroot
== NULL
|| *gdb_sysroot
== 0);
182 if (!gdb_sysroot_is_empty
)
184 int prefix_len
= strlen (gdb_sysroot
);
186 /* Remove trailing slashes from absolute prefix. */
187 while (prefix_len
> 0
188 && IS_DIR_SEPARATOR (gdb_sysroot
[prefix_len
- 1]))
191 sysroot
= savestring (gdb_sysroot
, prefix_len
);
192 make_cleanup (xfree
, sysroot
);
195 /* If we're on a non-DOS-based system, backslashes won't be
196 understood as directory separator, so, convert them to forward
197 slashes, iff we're supposed to handle DOS-based file system
198 semantics for target paths. */
199 if (!DOS_BASED_FILE_SYSTEM
&& fskind
== file_system_kind_dos_based
)
203 /* Avoid clobbering our input. */
204 p
= alloca (strlen (in_pathname
) + 1);
205 strcpy (p
, in_pathname
);
215 /* Note, we're interested in IS_TARGET_ABSOLUTE_PATH, not
216 IS_ABSOLUTE_PATH. The latter is for host paths only, while
217 IN_PATHNAME is a target path. For example, if we're supposed to
218 be handling DOS-like semantics we want to consider a
219 'c:/foo/bar.dll' path as an absolute path, even on a Unix box.
220 With such a path, before giving up on the sysroot, we'll try:
222 1st attempt, c:/foo/bar.dll ==> /sysroot/c:/foo/bar.dll
223 2nd attempt, c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll
224 3rd attempt, c:/foo/bar.dll ==> /sysroot/foo/bar.dll
227 if (!IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
) || gdb_sysroot_is_empty
)
228 temp_pathname
= xstrdup (in_pathname
);
231 int need_dir_separator
;
233 need_dir_separator
= (!IS_DIR_SEPARATOR (in_pathname
[0])
234 && !HAS_TARGET_DRIVE_SPEC (fskind
, in_pathname
));
236 /* Cat the prefixed pathname together. */
237 temp_pathname
= concat (sysroot
,
238 need_dir_separator
? SLASH_STRING
: "",
239 in_pathname
, (char *) NULL
);
242 /* Handle remote files. */
243 if (remote_filename_p (temp_pathname
))
246 do_cleanups (old_chain
);
247 return temp_pathname
;
250 /* Now see if we can open it. */
251 found_file
= gdb_open_cloexec (temp_pathname
, O_RDONLY
| O_BINARY
, 0);
253 xfree (temp_pathname
);
255 /* If the search in gdb_sysroot failed, and the path name has a
256 drive spec (e.g, c:/foo), try stripping ':' from the drive spec,
257 and retrying in the sysroot:
258 c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll. */
261 && !gdb_sysroot_is_empty
262 && HAS_TARGET_DRIVE_SPEC (fskind
, in_pathname
))
264 int need_dir_separator
= !IS_DIR_SEPARATOR (in_pathname
[2]);
265 char *drive
= savestring (in_pathname
, 1);
267 temp_pathname
= concat (sysroot
,
270 need_dir_separator
? SLASH_STRING
: "",
271 in_pathname
+ 2, (char *) NULL
);
274 found_file
= gdb_open_cloexec (temp_pathname
, O_RDONLY
| O_BINARY
, 0);
277 xfree (temp_pathname
);
279 /* If the search in gdb_sysroot still failed, try fully
280 stripping the drive spec, and trying once more in the
281 sysroot before giving up.
283 c:/foo/bar.dll ==> /sysroot/foo/bar.dll. */
285 temp_pathname
= concat (sysroot
,
286 need_dir_separator
? SLASH_STRING
: "",
287 in_pathname
+ 2, (char *) NULL
);
289 found_file
= gdb_open_cloexec (temp_pathname
, O_RDONLY
| O_BINARY
, 0);
291 xfree (temp_pathname
);
295 do_cleanups (old_chain
);
297 /* We try to find the library in various ways. After each attempt,
298 either found_file >= 0 and temp_pathname is a malloc'd string, or
299 found_file < 0 and temp_pathname does not point to storage that
300 needs to be freed. */
303 temp_pathname
= NULL
;
305 /* If the search in gdb_sysroot failed, and the path name is
306 absolute at this point, make it relative. (openp will try and open the
307 file according to its absolute path otherwise, which is not what we want.)
308 Affects subsequent searches for this solib. */
309 if (found_file
< 0 && IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
))
311 /* First, get rid of any drive letters etc. */
312 while (!IS_TARGET_DIR_SEPARATOR (fskind
, *in_pathname
))
315 /* Next, get rid of all leading dir separators. */
316 while (IS_TARGET_DIR_SEPARATOR (fskind
, *in_pathname
))
320 /* If not found, search the solib_search_path (if any). */
321 if (found_file
< 0 && solib_search_path
!= NULL
)
322 found_file
= openp (solib_search_path
, OPF_TRY_CWD_FIRST
,
323 in_pathname
, O_RDONLY
| O_BINARY
, &temp_pathname
);
325 /* If not found, next search the solib_search_path (if any) for the basename
326 only (ignoring the path). This is to allow reading solibs from a path
327 that differs from the opened path. */
328 if (found_file
< 0 && solib_search_path
!= NULL
)
329 found_file
= openp (solib_search_path
, OPF_TRY_CWD_FIRST
,
330 target_lbasename (fskind
, in_pathname
),
331 O_RDONLY
| O_BINARY
, &temp_pathname
);
333 /* If not found, try to use target supplied solib search method. */
334 if (found_file
< 0 && ops
->find_and_open_solib
)
335 found_file
= ops
->find_and_open_solib (in_pathname
, O_RDONLY
| O_BINARY
,
338 /* If not found, next search the inferior's $PATH environment variable. */
339 if (found_file
< 0 && gdb_sysroot_is_empty
)
340 found_file
= openp (get_in_environ (current_inferior ()->environment
,
342 OPF_TRY_CWD_FIRST
, in_pathname
, O_RDONLY
| O_BINARY
,
345 /* If not found, next search the inferior's $LD_LIBRARY_PATH
346 environment variable. */
347 if (found_file
< 0 && gdb_sysroot_is_empty
)
348 found_file
= openp (get_in_environ (current_inferior ()->environment
,
350 OPF_TRY_CWD_FIRST
, in_pathname
, O_RDONLY
| O_BINARY
,
354 return temp_pathname
;
357 /* Open and return a BFD for the shared library PATHNAME. If FD is not -1,
358 it is used as file handle to open the file. Throws an error if the file
359 could not be opened. Handles both local and remote file access.
361 PATHNAME must be malloc'ed by the caller. It will be freed by this
362 function. If unsuccessful, the FD will be closed (unless FD was
366 solib_bfd_fopen (char *pathname
, int fd
)
370 if (remote_filename_p (pathname
))
372 gdb_assert (fd
== -1);
373 abfd
= remote_bfd_open (pathname
, gnutarget
);
377 abfd
= gdb_bfd_open (pathname
, gnutarget
, fd
);
380 bfd_set_cacheable (abfd
, 1);
385 make_cleanup (xfree
, pathname
);
386 error (_("Could not open `%s' as an executable file: %s"),
387 pathname
, bfd_errmsg (bfd_get_error ()));
395 /* Find shared library PATHNAME and open a BFD for it. */
398 solib_bfd_open (char *pathname
)
400 char *found_pathname
;
403 const struct bfd_arch_info
*b
;
405 /* Search for shared library file. */
406 found_pathname
= solib_find (pathname
, &found_file
);
407 if (found_pathname
== NULL
)
409 /* Return failure if the file could not be found, so that we can
410 accumulate messages about missing libraries. */
414 perror_with_name (pathname
);
417 /* Open bfd for shared library. */
418 abfd
= solib_bfd_fopen (found_pathname
, found_file
);
420 /* Check bfd format. */
421 if (!bfd_check_format (abfd
, bfd_object
))
423 make_cleanup_bfd_unref (abfd
);
424 error (_("`%s': not in executable format: %s"),
425 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
428 /* Check bfd arch. */
429 b
= gdbarch_bfd_arch_info (target_gdbarch ());
430 if (!b
->compatible (b
, bfd_get_arch_info (abfd
)))
431 warning (_("`%s': Shared library architecture %s is not compatible "
432 "with target architecture %s."), bfd_get_filename (abfd
),
433 bfd_get_arch_info (abfd
)->printable_name
, b
->printable_name
);
438 /* Given a pointer to one of the shared objects in our list of mapped
439 objects, use the recorded name to open a bfd descriptor for the
440 object, build a section table, relocate all the section addresses
441 by the base address at which the shared object was mapped, and then
442 add the sections to the target's section table.
444 FIXME: In most (all?) cases the shared object file name recorded in
445 the dynamic linkage tables will be a fully qualified pathname. For
446 cases where it isn't, do we really mimic the systems search
447 mechanism correctly in the below code (particularly the tilde
448 expansion stuff?). */
451 solib_map_sections (struct so_list
*so
)
453 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
455 struct target_section
*p
;
456 struct cleanup
*old_chain
;
459 filename
= tilde_expand (so
->so_name
);
460 old_chain
= make_cleanup (xfree
, filename
);
461 abfd
= ops
->bfd_open (filename
);
462 do_cleanups (old_chain
);
467 /* Leave bfd open, core_xfer_memory and "info files" need it. */
470 if (build_section_table (abfd
, &so
->sections
, &so
->sections_end
))
472 error (_("Can't find the file sections in `%s': %s"),
473 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
476 for (p
= so
->sections
; p
< so
->sections_end
; p
++)
478 /* Relocate the section binding addresses as recorded in the shared
479 object's file by the base address to which the object was actually
481 ops
->relocate_section_addresses (so
, p
);
483 /* If the target didn't provide information about the address
484 range of the shared object, assume we want the location of
485 the .text section. */
486 if (so
->addr_low
== 0 && so
->addr_high
== 0
487 && strcmp (p
->the_bfd_section
->name
, ".text") == 0)
489 so
->addr_low
= p
->addr
;
490 so
->addr_high
= p
->endaddr
;
494 /* Add the shared object's sections to the current set of file
495 section tables. Do this immediately after mapping the object so
496 that later nodes in the list can query this object, as is needed
498 add_target_sections (so
, so
->sections
, so
->sections_end
);
503 /* Free symbol-file related contents of SO and reset for possible reloading
504 of SO. If we have opened a BFD for SO, close it. If we have placed SO's
505 sections in some target's section table, the caller is responsible for
508 This function doesn't mess with objfiles at all. If there is an
509 objfile associated with SO that needs to be removed, the caller is
510 responsible for taking care of that. */
513 clear_so (struct so_list
*so
)
515 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
519 xfree (so
->sections
);
520 so
->sections
= so
->sections_end
= NULL
;
523 gdb_bfd_unref (so
->abfd
);
526 /* Our caller closed the objfile, possibly via objfile_purge_solibs. */
527 so
->symbols_loaded
= 0;
530 so
->addr_low
= so
->addr_high
= 0;
532 /* Restore the target-supplied file name. SO_NAME may be the path
533 of the symbol file. */
534 strcpy (so
->so_name
, so
->so_original_name
);
536 /* Do the same for target-specific data. */
537 if (ops
->clear_so
!= NULL
)
541 /* Free the storage associated with the `struct so_list' object SO.
542 If we have opened a BFD for SO, close it.
544 The caller is responsible for removing SO from whatever list it is
545 a member of. If we have placed SO's sections in some target's
546 section table, the caller is responsible for removing them.
548 This function doesn't mess with objfiles at all. If there is an
549 objfile associated with SO that needs to be removed, the caller is
550 responsible for taking care of that. */
553 free_so (struct so_list
*so
)
555 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
564 /* Return address of first so_list entry in master shared object list. */
566 master_so_list (void)
571 /* Read in symbols for shared object SO. If SYMFILE_VERBOSE is set in FLAGS,
572 be chatty about it. Return non-zero if any symbols were actually
576 solib_read_symbols (struct so_list
*so
, int flags
)
578 const int from_tty
= flags
& SYMFILE_VERBOSE
;
580 if (so
->symbols_loaded
)
582 /* If needed, we've already warned in our caller. */
584 else if (so
->abfd
== NULL
)
586 /* We've already warned about this library, when trying to open
591 volatile struct gdb_exception e
;
593 flags
|= current_inferior ()->symfile_flags
;
595 TRY_CATCH (e
, RETURN_MASK_ERROR
)
597 struct section_addr_info
*sap
;
599 /* Have we already loaded this shared object? */
600 ALL_OBJFILES (so
->objfile
)
602 if (filename_cmp (so
->objfile
->name
, so
->so_name
) == 0
603 && so
->objfile
->addr_low
== so
->addr_low
)
606 if (so
->objfile
!= NULL
)
609 sap
= build_section_addr_info_from_section_table (so
->sections
,
611 so
->objfile
= symbol_file_add_from_bfd (so
->abfd
,
612 flags
, sap
, OBJF_SHARED
,
614 so
->objfile
->addr_low
= so
->addr_low
;
615 free_section_addr_info (sap
);
619 exception_fprintf (gdb_stderr
, e
, _("Error while reading shared"
620 " library symbols for %s:\n"),
624 if (from_tty
|| info_verbose
)
625 printf_unfiltered (_("Loaded symbols for %s\n"), so
->so_name
);
626 so
->symbols_loaded
= 1;
634 /* Return 1 if KNOWN->objfile is used by any other so_list object in the
635 SO_LIST_HEAD list. Return 0 otherwise. */
638 solib_used (const struct so_list
*const known
)
640 const struct so_list
*pivot
;
642 for (pivot
= so_list_head
; pivot
!= NULL
; pivot
= pivot
->next
)
643 if (pivot
!= known
&& pivot
->objfile
== known
->objfile
)
648 /* Synchronize GDB's shared object list with inferior's.
650 Extract the list of currently loaded shared objects from the
651 inferior, and compare it with the list of shared objects currently
652 in GDB's so_list_head list. Edit so_list_head to bring it in sync
653 with the inferior's new list.
655 If we notice that the inferior has unloaded some shared objects,
656 free any symbolic info GDB had read about those shared objects.
658 Don't load symbolic info for any new shared objects; just add them
659 to the list, and leave their symbols_loaded flag clear.
661 If FROM_TTY is non-null, feel free to print messages about what
664 If TARGET is non-null, add the sections of all new shared objects
665 to TARGET's section table. Note that this doesn't remove any
666 sections for shared objects that have been unloaded, and it
667 doesn't check to see if the new shared objects are already present in
668 the section table. But we only use this for core files and
669 processes we've just attached to, so that's okay. */
672 update_solib_list (int from_tty
, struct target_ops
*target
)
674 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
675 struct so_list
*inferior
= ops
->current_sos();
676 struct so_list
*gdb
, **gdb_link
;
678 /* We can reach here due to changing solib-search-path or the
679 sysroot, before having any inferior. */
680 if (target_has_execution
&& !ptid_equal (inferior_ptid
, null_ptid
))
682 struct inferior
*inf
= current_inferior ();
684 /* If we are attaching to a running process for which we
685 have not opened a symbol file, we may be able to get its
687 if (inf
->attach_flag
&& symfile_objfile
== NULL
)
688 catch_errors (ops
->open_symbol_file_object
, &from_tty
,
689 "Error reading attached process's symbol file.\n",
693 /* GDB and the inferior's dynamic linker each maintain their own
694 list of currently loaded shared objects; we want to bring the
695 former in sync with the latter. Scan both lists, seeing which
696 shared objects appear where. There are three cases:
698 - A shared object appears on both lists. This means that GDB
699 knows about it already, and it's still loaded in the inferior.
700 Nothing needs to happen.
702 - A shared object appears only on GDB's list. This means that
703 the inferior has unloaded it. We should remove the shared
704 object from GDB's tables.
706 - A shared object appears only on the inferior's list. This
707 means that it's just been loaded. We should add it to GDB's
710 So we walk GDB's list, checking each entry to see if it appears
711 in the inferior's list too. If it does, no action is needed, and
712 we remove it from the inferior's list. If it doesn't, the
713 inferior has unloaded it, and we remove it from GDB's list. By
714 the time we're done walking GDB's list, the inferior's list
715 contains only the new shared objects, which we then add. */
718 gdb_link
= &so_list_head
;
721 struct so_list
*i
= inferior
;
722 struct so_list
**i_link
= &inferior
;
724 /* Check to see whether the shared object *gdb also appears in
725 the inferior's current list. */
730 if (ops
->same (gdb
, i
))
735 if (! filename_cmp (gdb
->so_original_name
, i
->so_original_name
))
743 /* If the shared object appears on the inferior's list too, then
744 it's still loaded, so we don't need to do anything. Delete
745 it from the inferior's list, and leave it on GDB's list. */
750 gdb_link
= &gdb
->next
;
754 /* If it's not on the inferior's list, remove it from GDB's tables. */
757 /* Notify any observer that the shared object has been
758 unloaded before we remove it from GDB's tables. */
759 observer_notify_solib_unloaded (gdb
);
761 VEC_safe_push (char_ptr
, current_program_space
->deleted_solibs
,
762 xstrdup (gdb
->so_name
));
764 *gdb_link
= gdb
->next
;
766 /* Unless the user loaded it explicitly, free SO's objfile. */
767 if (gdb
->objfile
&& ! (gdb
->objfile
->flags
& OBJF_USERLOADED
)
768 && !solib_used (gdb
))
769 free_objfile (gdb
->objfile
);
771 /* Some targets' section tables might be referring to
772 sections from so->abfd; remove them. */
773 remove_target_sections (gdb
, gdb
->abfd
);
780 /* Now the inferior's list contains only shared objects that don't
781 appear in GDB's list --- those that are newly loaded. Add them
782 to GDB's shared object list. */
786 const char *not_found_filename
= NULL
;
790 /* Add the new shared objects to GDB's list. */
791 *gdb_link
= inferior
;
793 /* Fill in the rest of each of the `struct so_list' nodes. */
794 for (i
= inferior
; i
; i
= i
->next
)
796 volatile struct gdb_exception e
;
798 i
->pspace
= current_program_space
;
799 VEC_safe_push (so_list_ptr
, current_program_space
->added_solibs
, i
);
801 TRY_CATCH (e
, RETURN_MASK_ERROR
)
803 /* Fill in the rest of the `struct so_list' node. */
804 if (!solib_map_sections (i
))
807 if (not_found_filename
== NULL
)
808 not_found_filename
= i
->so_original_name
;
813 exception_fprintf (gdb_stderr
, e
,
814 _("Error while mapping shared "
815 "library sections:\n"));
817 /* Notify any observer that the shared object has been
818 loaded now that we've added it to GDB's tables. */
819 observer_notify_solib_loaded (i
);
822 /* If a library was not found, issue an appropriate warning
823 message. We have to use a single call to warning in case the
824 front end does something special with warnings, e.g., pop up
825 a dialog box. It Would Be Nice if we could get a "warning: "
826 prefix on each line in the CLI front end, though - it doesn't
830 warning (_("Could not load shared library symbols for %s.\n"
831 "Do you need \"set solib-search-path\" "
832 "or \"set sysroot\"?"),
834 else if (not_found
> 1)
836 Could not load shared library symbols for %d libraries, e.g. %s.\n\
837 Use the \"info sharedlibrary\" command to see the complete listing.\n\
838 Do you need \"set solib-search-path\" or \"set sysroot\"?"),
839 not_found
, not_found_filename
);
844 /* Return non-zero if NAME is the libpthread shared library.
846 Uses a fairly simplistic heuristic approach where we check
847 the file name against "/libpthread". This can lead to false
848 positives, but this should be good enough in practice. */
851 libpthread_name_p (const char *name
)
853 return (strstr (name
, "/libpthread") != NULL
);
856 /* Return non-zero if SO is the libpthread shared library. */
859 libpthread_solib_p (struct so_list
*so
)
861 return libpthread_name_p (so
->so_name
);
864 /* Read in symbolic information for any shared objects whose names
865 match PATTERN. (If we've already read a shared object's symbol
866 info, leave it alone.) If PATTERN is zero, read them all.
868 If READSYMS is 0, defer reading symbolic information until later
869 but still do any needed low level processing.
871 FROM_TTY and TARGET are as described for update_solib_list, above. */
874 solib_add (char *pattern
, int from_tty
,
875 struct target_ops
*target
, int readsyms
)
879 current_program_space
->solib_add_generation
++;
883 char *re_err
= re_comp (pattern
);
886 error (_("Invalid regexp: %s"), re_err
);
889 update_solib_list (from_tty
, target
);
891 /* Walk the list of currently loaded shared libraries, and read
892 symbols for any that match the pattern --- or any whose symbols
893 aren't already loaded, if no pattern was given. */
896 int loaded_any_symbols
= 0;
898 SYMFILE_DEFER_BP_RESET
| (from_tty
? SYMFILE_VERBOSE
: 0);
900 for (gdb
= so_list_head
; gdb
; gdb
= gdb
->next
)
901 if (! pattern
|| re_exec (gdb
->so_name
))
903 /* Normally, we would read the symbols from that library
904 only if READSYMS is set. However, we're making a small
905 exception for the pthread library, because we sometimes
906 need the library symbols to be loaded in order to provide
907 thread support (x86-linux for instance). */
908 const int add_this_solib
=
909 (readsyms
|| libpthread_solib_p (gdb
));
914 if (gdb
->symbols_loaded
)
916 /* If no pattern was given, be quiet for shared
917 libraries we have already loaded. */
918 if (pattern
&& (from_tty
|| info_verbose
))
919 printf_unfiltered (_("Symbols already loaded for %s\n"),
922 else if (solib_read_symbols (gdb
, flags
))
923 loaded_any_symbols
= 1;
927 if (loaded_any_symbols
)
928 breakpoint_re_set ();
930 if (from_tty
&& pattern
&& ! any_matches
)
932 ("No loaded shared libraries match the pattern `%s'.\n", pattern
);
934 if (loaded_any_symbols
)
936 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
938 /* Getting new symbols may change our opinion about what is
940 reinit_frame_cache ();
942 ops
->special_symbol_handling ();
947 /* Implement the "info sharedlibrary" command. Walk through the
948 shared library list and print information about each attached
949 library matching PATTERN. If PATTERN is elided, print them
953 info_sharedlibrary_command (char *pattern
, int from_tty
)
955 struct so_list
*so
= NULL
; /* link map state variable */
956 int so_missing_debug_info
= 0;
959 struct cleanup
*table_cleanup
;
960 struct gdbarch
*gdbarch
= target_gdbarch ();
961 struct ui_out
*uiout
= current_uiout
;
965 char *re_err
= re_comp (pattern
);
968 error (_("Invalid regexp: %s"), re_err
);
971 /* "0x", a little whitespace, and two hex digits per byte of pointers. */
972 addr_width
= 4 + (gdbarch_ptr_bit (gdbarch
) / 4);
974 update_solib_list (from_tty
, 0);
976 /* make_cleanup_ui_out_table_begin_end needs to know the number of
977 rows, so we need to make two passes over the libs. */
979 for (nr_libs
= 0, so
= so_list_head
; so
; so
= so
->next
)
983 if (pattern
&& ! re_exec (so
->so_name
))
990 make_cleanup_ui_out_table_begin_end (uiout
, 4, nr_libs
,
991 "SharedLibraryTable");
993 /* The "- 1" is because ui_out adds one space between columns. */
994 ui_out_table_header (uiout
, addr_width
- 1, ui_left
, "from", "From");
995 ui_out_table_header (uiout
, addr_width
- 1, ui_left
, "to", "To");
996 ui_out_table_header (uiout
, 12 - 1, ui_left
, "syms-read", "Syms Read");
997 ui_out_table_header (uiout
, 0, ui_noalign
,
998 "name", "Shared Object Library");
1000 ui_out_table_body (uiout
);
1002 for (so
= so_list_head
; so
; so
= so
->next
)
1004 struct cleanup
*lib_cleanup
;
1006 if (! so
->so_name
[0])
1008 if (pattern
&& ! re_exec (so
->so_name
))
1011 lib_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, "lib");
1013 if (so
->addr_high
!= 0)
1015 ui_out_field_core_addr (uiout
, "from", gdbarch
, so
->addr_low
);
1016 ui_out_field_core_addr (uiout
, "to", gdbarch
, so
->addr_high
);
1020 ui_out_field_skip (uiout
, "from");
1021 ui_out_field_skip (uiout
, "to");
1024 if (! ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1025 && so
->symbols_loaded
1026 && !objfile_has_symbols (so
->objfile
))
1028 so_missing_debug_info
= 1;
1029 ui_out_field_string (uiout
, "syms-read", "Yes (*)");
1032 ui_out_field_string (uiout
, "syms-read",
1033 so
->symbols_loaded
? "Yes" : "No");
1035 ui_out_field_string (uiout
, "name", so
->so_name
);
1037 ui_out_text (uiout
, "\n");
1039 do_cleanups (lib_cleanup
);
1042 do_cleanups (table_cleanup
);
1047 ui_out_message (uiout
, 0,
1048 _("No shared libraries matched.\n"));
1050 ui_out_message (uiout
, 0,
1051 _("No shared libraries loaded at this time.\n"));
1055 if (so_missing_debug_info
)
1056 ui_out_message (uiout
, 0,
1057 _("(*): Shared library is missing "
1058 "debugging information.\n"));
1062 /* Return 1 if ADDRESS lies within SOLIB. */
1065 solib_contains_address_p (const struct so_list
*const solib
,
1068 struct target_section
*p
;
1070 for (p
= solib
->sections
; p
< solib
->sections_end
; p
++)
1071 if (p
->addr
<= address
&& address
< p
->endaddr
)
1077 /* If ADDRESS is in a shared lib in program space PSPACE, return its
1080 Provides a hook for other gdb routines to discover whether or not a
1081 particular address is within the mapped address space of a shared
1084 For example, this routine is called at one point to disable
1085 breakpoints which are in shared libraries that are not currently
1089 solib_name_from_address (struct program_space
*pspace
, CORE_ADDR address
)
1091 struct so_list
*so
= NULL
;
1093 for (so
= pspace
->so_list
; so
; so
= so
->next
)
1094 if (solib_contains_address_p (so
, address
))
1095 return (so
->so_name
);
1100 /* Return whether the data starting at VADDR, size SIZE, must be kept
1101 in a core file for shared libraries loaded before "gcore" is used
1102 to be handled correctly when the core file is loaded. This only
1103 applies when the section would otherwise not be kept in the core
1104 file (in particular, for readonly sections). */
1107 solib_keep_data_in_core (CORE_ADDR vaddr
, unsigned long size
)
1109 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1111 if (ops
->keep_data_in_core
)
1112 return ops
->keep_data_in_core (vaddr
, size
);
1117 /* Called by free_all_symtabs */
1122 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1124 /* This function is expected to handle ELF shared libraries. It is
1125 also used on Solaris, which can run either ELF or a.out binaries
1126 (for compatibility with SunOS 4), both of which can use shared
1127 libraries. So we don't know whether we have an ELF executable or
1128 an a.out executable until the user chooses an executable file.
1130 ELF shared libraries don't get mapped into the address space
1131 until after the program starts, so we'd better not try to insert
1132 breakpoints in them immediately. We have to wait until the
1133 dynamic linker has loaded them; we'll hit a bp_shlib_event
1134 breakpoint (look for calls to create_solib_event_breakpoint) when
1137 SunOS shared libraries seem to be different --- they're present
1138 as soon as the process begins execution, so there's no need to
1139 put off inserting breakpoints. There's also nowhere to put a
1140 bp_shlib_event breakpoint, so if we put it off, we'll never get
1143 So: disable breakpoints only if we're using ELF shared libs. */
1144 if (exec_bfd
!= NULL
1145 && bfd_get_flavour (exec_bfd
) != bfd_target_aout_flavour
)
1146 disable_breakpoints_in_shlibs ();
1148 while (so_list_head
)
1150 struct so_list
*so
= so_list_head
;
1152 so_list_head
= so
->next
;
1153 observer_notify_solib_unloaded (so
);
1155 remove_target_sections (so
, so
->abfd
);
1159 ops
->clear_solib ();
1162 /* Shared library startup support. When GDB starts up the inferior,
1163 it nurses it along (through the shell) until it is ready to execute
1164 its first instruction. At this point, this function gets
1168 solib_create_inferior_hook (int from_tty
)
1170 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1172 ops
->solib_create_inferior_hook (from_tty
);
1175 /* Check to see if an address is in the dynamic loader's dynamic
1176 symbol resolution code. Return 1 if so, 0 otherwise. */
1179 in_solib_dynsym_resolve_code (CORE_ADDR pc
)
1181 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1183 return ops
->in_dynsym_resolve_code (pc
);
1186 /* Implements the "sharedlibrary" command. */
1189 sharedlibrary_command (char *args
, int from_tty
)
1192 solib_add (args
, from_tty
, (struct target_ops
*) 0, 1);
1195 /* Implements the command "nosharedlibrary", which discards symbols
1196 that have been auto-loaded from shared libraries. Symbols from
1197 shared libraries that were added by explicit request of the user
1198 are not discarded. Also called from remote.c. */
1201 no_shared_libraries (char *ignored
, int from_tty
)
1203 /* The order of the two routines below is important: clear_solib notifies
1204 the solib_unloaded observers, and some of these observers might need
1205 access to their associated objfiles. Therefore, we can not purge the
1206 solibs' objfiles before clear_solib has been called. */
1209 objfile_purge_solibs ();
1215 update_solib_breakpoints (void)
1217 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1219 if (ops
->update_breakpoints
!= NULL
)
1220 ops
->update_breakpoints ();
1226 handle_solib_event (void)
1228 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1230 if (ops
->handle_event
!= NULL
)
1231 ops
->handle_event ();
1233 clear_program_space_solib_cache (current_inferior ()->pspace
);
1235 /* Check for any newly added shared libraries if we're supposed to
1236 be adding them automatically. Switch terminal for any messages
1237 produced by breakpoint_re_set. */
1238 target_terminal_ours_for_output ();
1239 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
1240 target_terminal_inferior ();
1243 /* Reload shared libraries, but avoid reloading the same symbol file
1244 we already have loaded. */
1247 reload_shared_libraries_1 (int from_tty
)
1250 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1252 for (so
= so_list_head
; so
!= NULL
; so
= so
->next
)
1254 char *filename
, *found_pathname
= NULL
;
1256 int was_loaded
= so
->symbols_loaded
;
1258 SYMFILE_DEFER_BP_RESET
| (from_tty
? SYMFILE_VERBOSE
: 0);
1260 filename
= tilde_expand (so
->so_original_name
);
1261 make_cleanup (xfree
, filename
);
1262 abfd
= solib_bfd_open (filename
);
1265 found_pathname
= xstrdup (bfd_get_filename (abfd
));
1266 make_cleanup (xfree
, found_pathname
);
1267 gdb_bfd_unref (abfd
);
1270 /* If this shared library is no longer associated with its previous
1271 symbol file, close that. */
1272 if ((found_pathname
== NULL
&& was_loaded
)
1273 || (found_pathname
!= NULL
1274 && filename_cmp (found_pathname
, so
->so_name
) != 0))
1276 if (so
->objfile
&& ! (so
->objfile
->flags
& OBJF_USERLOADED
)
1277 && !solib_used (so
))
1278 free_objfile (so
->objfile
);
1279 remove_target_sections (so
, so
->abfd
);
1283 /* If this shared library is now associated with a new symbol
1285 if (found_pathname
!= NULL
1287 || filename_cmp (found_pathname
, so
->so_name
) != 0))
1289 volatile struct gdb_exception e
;
1291 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1292 solib_map_sections (so
);
1295 exception_fprintf (gdb_stderr
, e
,
1296 _("Error while mapping "
1297 "shared library sections:\n"));
1298 else if (auto_solib_add
|| was_loaded
|| libpthread_solib_p (so
))
1299 solib_read_symbols (so
, flags
);
1303 do_cleanups (old_chain
);
1307 reload_shared_libraries (char *ignored
, int from_tty
,
1308 struct cmd_list_element
*e
)
1310 const struct target_so_ops
*ops
;
1312 reload_shared_libraries_1 (from_tty
);
1314 ops
= solib_ops (target_gdbarch ());
1316 /* Creating inferior hooks here has two purposes. First, if we reload
1317 shared libraries then the address of solib breakpoint we've computed
1318 previously might be no longer valid. For example, if we forgot to set
1319 solib-absolute-prefix and are setting it right now, then the previous
1320 breakpoint address is plain wrong. Second, installing solib hooks
1321 also implicitly figures were ld.so is and loads symbols for it.
1322 Absent this call, if we've just connected to a target and set
1323 solib-absolute-prefix or solib-search-path, we'll lose all information
1325 if (target_has_execution
)
1327 /* Reset or free private data structures not associated with
1329 ops
->clear_solib ();
1331 /* Remove any previous solib event breakpoint. This is usually
1332 done in common code, at breakpoint_init_inferior time, but
1333 we're not really starting up the inferior here. */
1334 remove_solib_event_breakpoints ();
1336 solib_create_inferior_hook (from_tty
);
1339 /* Sometimes the platform-specific hook loads initial shared
1340 libraries, and sometimes it doesn't. If it doesn't FROM_TTY will be
1341 incorrectly 0 but such solib targets should be fixed anyway. If we
1342 made all the inferior hook methods consistent, this call could be
1343 removed. Call it only after the solib target has been initialized by
1344 solib_create_inferior_hook. */
1346 solib_add (NULL
, 0, NULL
, auto_solib_add
);
1348 breakpoint_re_set ();
1350 /* We may have loaded or unloaded debug info for some (or all)
1351 shared libraries. However, frames may still reference them. For
1352 example, a frame's unwinder might still point at DWARF FDE
1353 structures that are now freed. Also, getting new symbols may
1354 change our opinion about what is frameless. */
1355 reinit_frame_cache ();
1357 ops
->special_symbol_handling ();
1361 show_auto_solib_add (struct ui_file
*file
, int from_tty
,
1362 struct cmd_list_element
*c
, const char *value
)
1364 fprintf_filtered (file
, _("Autoloading of shared library symbols is %s.\n"),
1369 /* Handler for library-specific lookup of global symbol NAME in OBJFILE. Call
1370 the library-specific handler if it is installed for the current target. */
1373 solib_global_lookup (const struct objfile
*objfile
,
1375 const domain_enum domain
)
1377 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1379 if (ops
->lookup_lib_global_symbol
!= NULL
)
1380 return ops
->lookup_lib_global_symbol (objfile
, name
, domain
);
1384 /* Lookup the value for a specific symbol from dynamic symbol table. Look
1385 up symbol from ABFD. MATCH_SYM is a callback function to determine
1386 whether to pick up a symbol. DATA is the input of this callback
1387 function. Return NULL if symbol is not found. */
1390 gdb_bfd_lookup_symbol_from_symtab (bfd
*abfd
,
1391 int (*match_sym
) (asymbol
*, void *),
1394 long storage_needed
= bfd_get_symtab_upper_bound (abfd
);
1395 CORE_ADDR symaddr
= 0;
1397 if (storage_needed
> 0)
1401 asymbol
**symbol_table
= (asymbol
**) xmalloc (storage_needed
);
1402 struct cleanup
*back_to
= make_cleanup (xfree
, symbol_table
);
1403 unsigned int number_of_symbols
=
1404 bfd_canonicalize_symtab (abfd
, symbol_table
);
1406 for (i
= 0; i
< number_of_symbols
; i
++)
1408 asymbol
*sym
= *symbol_table
++;
1410 if (match_sym (sym
, data
))
1412 /* BFD symbols are section relative. */
1413 symaddr
= sym
->value
+ sym
->section
->vma
;
1417 do_cleanups (back_to
);
1423 /* Lookup the value for a specific symbol from symbol table. Look up symbol
1424 from ABFD. MATCH_SYM is a callback function to determine whether to pick
1425 up a symbol. DATA is the input of this callback function. Return NULL
1426 if symbol is not found. */
1429 bfd_lookup_symbol_from_dyn_symtab (bfd
*abfd
,
1430 int (*match_sym
) (asymbol
*, void *),
1433 long storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1434 CORE_ADDR symaddr
= 0;
1436 if (storage_needed
> 0)
1439 asymbol
**symbol_table
= (asymbol
**) xmalloc (storage_needed
);
1440 struct cleanup
*back_to
= make_cleanup (xfree
, symbol_table
);
1441 unsigned int number_of_symbols
=
1442 bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
1444 for (i
= 0; i
< number_of_symbols
; i
++)
1446 asymbol
*sym
= *symbol_table
++;
1448 if (match_sym (sym
, data
))
1450 /* BFD symbols are section relative. */
1451 symaddr
= sym
->value
+ sym
->section
->vma
;
1455 do_cleanups (back_to
);
1460 /* Lookup the value for a specific symbol from symbol table and dynamic
1461 symbol table. Look up symbol from ABFD. MATCH_SYM is a callback
1462 function to determine whether to pick up a symbol. DATA is the
1463 input of this callback function. Return NULL if symbol is not
1467 gdb_bfd_lookup_symbol (bfd
*abfd
,
1468 int (*match_sym
) (asymbol
*, void *),
1471 CORE_ADDR symaddr
= gdb_bfd_lookup_symbol_from_symtab (abfd
, match_sym
, data
);
1473 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
1474 have to check the dynamic string table too. */
1476 symaddr
= bfd_lookup_symbol_from_dyn_symtab (abfd
, match_sym
, data
);
1481 extern initialize_file_ftype _initialize_solib
; /* -Wmissing-prototypes */
1484 _initialize_solib (void)
1486 solib_data
= gdbarch_data_register_pre_init (solib_init
);
1488 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
1489 _("Load shared object library symbols for files matching REGEXP."));
1490 add_info ("sharedlibrary", info_sharedlibrary_command
,
1491 _("Status of loaded shared object libraries."));
1492 add_com ("nosharedlibrary", class_files
, no_shared_libraries
,
1493 _("Unload all shared object library symbols."));
1495 add_setshow_boolean_cmd ("auto-solib-add", class_support
,
1496 &auto_solib_add
, _("\
1497 Set autoloading of shared library symbols."), _("\
1498 Show autoloading of shared library symbols."), _("\
1499 If \"on\", symbols from all shared object libraries will be loaded\n\
1500 automatically when the inferior begins execution, when the dynamic linker\n\
1501 informs gdb that a new library has been loaded, or when attaching to the\n\
1502 inferior. Otherwise, symbols must be loaded manually, using \
1505 show_auto_solib_add
,
1506 &setlist
, &showlist
);
1508 add_setshow_filename_cmd ("sysroot", class_support
,
1510 Set an alternate system root."), _("\
1511 Show the current system root."), _("\
1512 The system root is used to load absolute shared library symbol files.\n\
1513 For other (relative) files, you can add directories using\n\
1514 `set solib-search-path'."),
1515 reload_shared_libraries
,
1517 &setlist
, &showlist
);
1519 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support
, 0,
1521 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support
, 0,
1524 add_setshow_optional_filename_cmd ("solib-search-path", class_support
,
1525 &solib_search_path
, _("\
1526 Set the search path for loading non-absolute shared library symbol files."),
1528 Show the search path for loading non-absolute shared library symbol files."),
1530 This takes precedence over the environment variables \
1531 PATH and LD_LIBRARY_PATH."),
1532 reload_shared_libraries
,
1533 show_solib_search_path
,
1534 &setlist
, &showlist
);