1 /* Handle shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include <sys/types.h>
26 #include "gdb_string.h"
31 #include "exceptions.h"
36 #include "gdb_regex.h"
41 #include "completer.h"
42 #include "filenames.h" /* for DOSish file names */
46 #include "readline/readline.h"
50 #include "filesystem.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 struct target_so_ops
*
68 solib_ops (struct gdbarch
*gdbarch
)
70 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
, struct target_so_ops
*new_ops
)
80 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 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]);
235 /* Cat the prefixed pathname together. */
236 temp_pathname
= concat (sysroot
,
237 need_dir_separator
? SLASH_STRING
: "",
238 in_pathname
, (char *) NULL
);
241 /* Handle remote files. */
242 if (remote_filename_p (temp_pathname
))
245 do_cleanups (old_chain
);
246 return temp_pathname
;
249 /* Now see if we can open it. */
250 found_file
= open (temp_pathname
, O_RDONLY
| O_BINARY
, 0);
252 xfree (temp_pathname
);
254 /* If the search in gdb_sysroot failed, and the path name has a
255 drive spec (e.g, c:/foo), try stripping ':' from the drive spec,
256 and retrying in the sysroot:
257 c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll. */
260 && !gdb_sysroot_is_empty
261 && HAS_TARGET_DRIVE_SPEC (fskind
, in_pathname
))
263 int need_dir_separator
= !IS_DIR_SEPARATOR (in_pathname
[2]);
264 char *drive
= savestring (in_pathname
, 1);
266 temp_pathname
= concat (sysroot
,
269 need_dir_separator
? SLASH_STRING
: "",
270 in_pathname
+ 2, (char *) NULL
);
273 found_file
= open (temp_pathname
, O_RDONLY
| O_BINARY
, 0);
276 xfree (temp_pathname
);
278 /* If the search in gdb_sysroot still failed, try fully
279 stripping the drive spec, and trying once more in the
280 sysroot before giving up.
282 c:/foo/bar.dll ==> /sysroot/foo/bar.dll. */
284 temp_pathname
= concat (sysroot
,
285 need_dir_separator
? SLASH_STRING
: "",
286 in_pathname
+ 2, (char *) NULL
);
288 found_file
= open (temp_pathname
, O_RDONLY
| O_BINARY
, 0);
290 xfree (temp_pathname
);
294 do_cleanups (old_chain
);
296 /* We try to find the library in various ways. After each attempt,
297 either found_file >= 0 and temp_pathname is a malloc'd string, or
298 found_file < 0 and temp_pathname does not point to storage that
299 needs to be freed. */
302 temp_pathname
= NULL
;
304 /* If not found, search the solib_search_path (if any). */
305 if (found_file
< 0 && solib_search_path
!= NULL
)
306 found_file
= openp (solib_search_path
, OPF_TRY_CWD_FIRST
,
307 in_pathname
, O_RDONLY
| O_BINARY
, &temp_pathname
);
309 /* If the search in gdb_sysroot failed, and the path name is
310 absolute at this point, make it relative. (openp will try and open the
311 file according to its absolute path otherwise, which is not what we want.)
312 Affects subsequent searches for this solib. */
313 if (found_file
< 0 && IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
))
315 /* First, get rid of any drive letters etc. */
316 while (!IS_TARGET_DIR_SEPARATOR (fskind
, *in_pathname
))
319 /* Next, get rid of all leading dir separators. */
320 while (IS_TARGET_DIR_SEPARATOR (fskind
, *in_pathname
))
324 /* If not found, search the solib_search_path (if any). */
325 if (found_file
< 0 && solib_search_path
!= NULL
)
326 found_file
= openp (solib_search_path
, OPF_TRY_CWD_FIRST
,
327 in_pathname
, O_RDONLY
| O_BINARY
, &temp_pathname
);
329 /* If not found, next search the solib_search_path (if any) for the basename
330 only (ignoring the path). This is to allow reading solibs from a path
331 that differs from the opened path. */
332 if (found_file
< 0 && solib_search_path
!= NULL
)
333 found_file
= openp (solib_search_path
, OPF_TRY_CWD_FIRST
,
334 target_lbasename (fskind
, in_pathname
),
335 O_RDONLY
| O_BINARY
, &temp_pathname
);
337 /* If not found, try to use target supplied solib search method. */
338 if (found_file
< 0 && ops
->find_and_open_solib
)
339 found_file
= ops
->find_and_open_solib (in_pathname
, O_RDONLY
| O_BINARY
,
342 /* If not found, next search the inferior's $PATH environment variable. */
343 if (found_file
< 0 && gdb_sysroot_is_empty
)
344 found_file
= openp (get_in_environ (current_inferior ()->environment
,
346 OPF_TRY_CWD_FIRST
, in_pathname
, O_RDONLY
| O_BINARY
,
349 /* If not found, next search the inferior's $LD_LIBRARY_PATH
350 environment variable. */
351 if (found_file
< 0 && gdb_sysroot_is_empty
)
352 found_file
= openp (get_in_environ (current_inferior ()->environment
,
354 OPF_TRY_CWD_FIRST
, in_pathname
, O_RDONLY
| O_BINARY
,
358 return temp_pathname
;
361 /* Open and return a BFD for the shared library PATHNAME. If FD is not -1,
362 it is used as file handle to open the file. Throws an error if the file
363 could not be opened. Handles both local and remote file access.
365 PATHNAME must be malloc'ed by the caller. If successful, the new BFD's
366 name will point to it. If unsuccessful, PATHNAME will be freed and the
367 FD will be closed (unless FD was -1). */
370 solib_bfd_fopen (char *pathname
, int fd
)
374 if (remote_filename_p (pathname
))
376 gdb_assert (fd
== -1);
377 abfd
= remote_bfd_open (pathname
, gnutarget
);
381 abfd
= bfd_fopen (pathname
, gnutarget
, FOPEN_RB
, fd
);
384 bfd_set_cacheable (abfd
, 1);
391 make_cleanup (xfree
, pathname
);
392 error (_("Could not open `%s' as an executable file: %s"),
393 pathname
, bfd_errmsg (bfd_get_error ()));
399 /* Find shared library PATHNAME and open a BFD for it. */
402 solib_bfd_open (char *pathname
)
404 char *found_pathname
;
407 const struct bfd_arch_info
*b
;
409 /* Search for shared library file. */
410 found_pathname
= solib_find (pathname
, &found_file
);
411 if (found_pathname
== NULL
)
413 /* Return failure if the file could not be found, so that we can
414 accumulate messages about missing libraries. */
418 perror_with_name (pathname
);
421 /* Open bfd for shared library. */
422 abfd
= solib_bfd_fopen (found_pathname
, found_file
);
424 /* Check bfd format. */
425 if (!bfd_check_format (abfd
, bfd_object
))
428 make_cleanup (xfree
, found_pathname
);
429 error (_("`%s': not in executable format: %s"),
430 found_pathname
, bfd_errmsg (bfd_get_error ()));
433 /* Check bfd arch. */
434 b
= gdbarch_bfd_arch_info (target_gdbarch
);
435 if (!b
->compatible (b
, bfd_get_arch_info (abfd
)))
436 warning (_("`%s': Shared library architecture %s is not compatible "
437 "with target architecture %s."), found_pathname
,
438 bfd_get_arch_info (abfd
)->printable_name
, b
->printable_name
);
443 /* Given a pointer to one of the shared objects in our list of mapped
444 objects, use the recorded name to open a bfd descriptor for the
445 object, build a section table, relocate all the section addresses
446 by the base address at which the shared object was mapped, and then
447 add the sections to the target's section table.
449 FIXME: In most (all?) cases the shared object file name recorded in
450 the dynamic linkage tables will be a fully qualified pathname. For
451 cases where it isn't, do we really mimic the systems search
452 mechanism correctly in the below code (particularly the tilde
453 expansion stuff?). */
456 solib_map_sections (struct so_list
*so
)
458 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
460 struct target_section
*p
;
461 struct cleanup
*old_chain
;
464 filename
= tilde_expand (so
->so_name
);
465 old_chain
= make_cleanup (xfree
, filename
);
466 abfd
= ops
->bfd_open (filename
);
467 do_cleanups (old_chain
);
472 /* Leave bfd open, core_xfer_memory and "info files" need it. */
473 so
->abfd
= gdb_bfd_ref (abfd
);
475 /* copy full path name into so_name, so that later symbol_file_add
477 if (strlen (bfd_get_filename (abfd
)) >= SO_NAME_MAX_PATH_SIZE
)
478 error (_("Shared library file name is too long."));
479 strcpy (so
->so_name
, bfd_get_filename (abfd
));
481 if (build_section_table (abfd
, &so
->sections
, &so
->sections_end
))
483 error (_("Can't find the file sections in `%s': %s"),
484 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
487 for (p
= so
->sections
; p
< so
->sections_end
; p
++)
489 /* Relocate the section binding addresses as recorded in the shared
490 object's file by the base address to which the object was actually
492 ops
->relocate_section_addresses (so
, p
);
494 /* If the target didn't provide information about the address
495 range of the shared object, assume we want the location of
496 the .text section. */
497 if (so
->addr_low
== 0 && so
->addr_high
== 0
498 && strcmp (p
->the_bfd_section
->name
, ".text") == 0)
500 so
->addr_low
= p
->addr
;
501 so
->addr_high
= p
->endaddr
;
505 /* Add the shared object's sections to the current set of file
506 section tables. Do this immediately after mapping the object so
507 that later nodes in the list can query this object, as is needed
509 add_target_sections (so
->sections
, so
->sections_end
);
514 /* Free symbol-file related contents of SO. If we have opened a BFD
515 for SO, close it. If we have placed SO's sections in some target's
516 section table, the caller is responsible for removing them.
518 This function doesn't mess with objfiles at all. If there is an
519 objfile associated with SO that needs to be removed, the caller is
520 responsible for taking care of that. */
523 free_so_symbols (struct so_list
*so
)
527 xfree (so
->sections
);
528 so
->sections
= so
->sections_end
= NULL
;
531 gdb_bfd_unref (so
->abfd
);
534 /* Our caller closed the objfile, possibly via objfile_purge_solibs. */
535 so
->symbols_loaded
= 0;
538 so
->addr_low
= so
->addr_high
= 0;
540 /* Restore the target-supplied file name. SO_NAME may be the path
541 of the symbol file. */
542 strcpy (so
->so_name
, so
->so_original_name
);
545 /* Free the storage associated with the `struct so_list' object SO.
546 If we have opened a BFD for SO, close it.
548 The caller is responsible for removing SO from whatever list it is
549 a member of. If we have placed SO's sections in some target's
550 section table, the caller is responsible for removing them.
552 This function doesn't mess with objfiles at all. If there is an
553 objfile associated with SO that needs to be removed, the caller is
554 responsible for taking care of that. */
557 free_so (struct so_list
*so
)
559 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
561 free_so_symbols (so
);
568 /* Return address of first so_list entry in master shared object list. */
570 master_so_list (void)
575 /* Read in symbols for shared object SO. If SYMFILE_VERBOSE is set in FLAGS,
576 be chatty about it. Return non-zero if any symbols were actually
580 solib_read_symbols (struct so_list
*so
, int flags
)
582 const int from_tty
= flags
& SYMFILE_VERBOSE
;
584 if (so
->symbols_loaded
)
586 /* If needed, we've already warned in our caller. */
588 else if (so
->abfd
== NULL
)
590 /* We've already warned about this library, when trying to open
595 volatile struct gdb_exception e
;
597 TRY_CATCH (e
, RETURN_MASK_ERROR
)
599 struct section_addr_info
*sap
;
601 /* Have we already loaded this shared object? */
602 ALL_OBJFILES (so
->objfile
)
604 if (filename_cmp (so
->objfile
->name
, so
->so_name
) == 0
605 && so
->objfile
->addr_low
== so
->addr_low
)
608 if (so
->objfile
!= NULL
)
611 sap
= build_section_addr_info_from_section_table (so
->sections
,
613 so
->objfile
= symbol_file_add_from_bfd (so
->abfd
,
614 flags
, sap
, OBJF_SHARED
,
616 so
->objfile
->addr_low
= so
->addr_low
;
617 free_section_addr_info (sap
);
621 exception_fprintf (gdb_stderr
, e
, _("Error while reading shared"
622 " library symbols for %s:\n"),
626 if (from_tty
|| info_verbose
)
627 printf_unfiltered (_("Loaded symbols for %s\n"), so
->so_name
);
628 so
->symbols_loaded
= 1;
636 /* Return 1 if KNOWN->objfile is used by any other so_list object in the
637 SO_LIST_HEAD list. Return 0 otherwise. */
640 solib_used (const struct so_list
*const known
)
642 const struct so_list
*pivot
;
644 for (pivot
= so_list_head
; pivot
!= NULL
; pivot
= pivot
->next
)
645 if (pivot
!= known
&& pivot
->objfile
== known
->objfile
)
650 /* Synchronize GDB's shared object list with inferior's.
652 Extract the list of currently loaded shared objects from the
653 inferior, and compare it with the list of shared objects currently
654 in GDB's so_list_head list. Edit so_list_head to bring it in sync
655 with the inferior's new list.
657 If we notice that the inferior has unloaded some shared objects,
658 free any symbolic info GDB had read about those shared objects.
660 Don't load symbolic info for any new shared objects; just add them
661 to the list, and leave their symbols_loaded flag clear.
663 If FROM_TTY is non-null, feel free to print messages about what
666 If TARGET is non-null, add the sections of all new shared objects
667 to TARGET's section table. Note that this doesn't remove any
668 sections for shared objects that have been unloaded, and it
669 doesn't check to see if the new shared objects are already present in
670 the section table. But we only use this for core files and
671 processes we've just attached to, so that's okay. */
674 update_solib_list (int from_tty
, struct target_ops
*target
)
676 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
677 struct so_list
*inferior
= ops
->current_sos();
678 struct so_list
*gdb
, **gdb_link
;
680 /* We can reach here due to changing solib-search-path or the
681 sysroot, before having any inferior. */
682 if (target_has_execution
&& !ptid_equal (inferior_ptid
, null_ptid
))
684 struct inferior
*inf
= current_inferior ();
686 /* If we are attaching to a running process for which we
687 have not opened a symbol file, we may be able to get its
689 if (inf
->attach_flag
&& symfile_objfile
== NULL
)
690 catch_errors (ops
->open_symbol_file_object
, &from_tty
,
691 "Error reading attached process's symbol file.\n",
695 /* GDB and the inferior's dynamic linker each maintain their own
696 list of currently loaded shared objects; we want to bring the
697 former in sync with the latter. Scan both lists, seeing which
698 shared objects appear where. There are three cases:
700 - A shared object appears on both lists. This means that GDB
701 knows about it already, and it's still loaded in the inferior.
702 Nothing needs to happen.
704 - A shared object appears only on GDB's list. This means that
705 the inferior has unloaded it. We should remove the shared
706 object from GDB's tables.
708 - A shared object appears only on the inferior's list. This
709 means that it's just been loaded. We should add it to GDB's
712 So we walk GDB's list, checking each entry to see if it appears
713 in the inferior's list too. If it does, no action is needed, and
714 we remove it from the inferior's list. If it doesn't, the
715 inferior has unloaded it, and we remove it from GDB's list. By
716 the time we're done walking GDB's list, the inferior's list
717 contains only the new shared objects, which we then add. */
720 gdb_link
= &so_list_head
;
723 struct so_list
*i
= inferior
;
724 struct so_list
**i_link
= &inferior
;
726 /* Check to see whether the shared object *gdb also appears in
727 the inferior's current list. */
732 if (ops
->same (gdb
, i
))
737 if (! filename_cmp (gdb
->so_original_name
, i
->so_original_name
))
745 /* If the shared object appears on the inferior's list too, then
746 it's still loaded, so we don't need to do anything. Delete
747 it from the inferior's list, and leave it on GDB's list. */
752 gdb_link
= &gdb
->next
;
756 /* If it's not on the inferior's list, remove it from GDB's tables. */
759 /* Notify any observer that the shared object has been
760 unloaded before we remove it from GDB's tables. */
761 observer_notify_solib_unloaded (gdb
);
763 *gdb_link
= gdb
->next
;
765 /* Unless the user loaded it explicitly, free SO's objfile. */
766 if (gdb
->objfile
&& ! (gdb
->objfile
->flags
& OBJF_USERLOADED
)
767 && !solib_used (gdb
))
768 free_objfile (gdb
->objfile
);
770 /* Some targets' section tables might be referring to
771 sections from so->abfd; remove them. */
772 remove_target_sections (gdb
->abfd
);
779 /* Now the inferior's list contains only shared objects that don't
780 appear in GDB's list --- those that are newly loaded. Add them
781 to GDB's shared object list. */
785 const char *not_found_filename
= NULL
;
789 /* Add the new shared objects to GDB's list. */
790 *gdb_link
= inferior
;
792 /* Fill in the rest of each of the `struct so_list' nodes. */
793 for (i
= inferior
; i
; i
= i
->next
)
795 volatile struct gdb_exception e
;
797 i
->pspace
= current_program_space
;
799 TRY_CATCH (e
, RETURN_MASK_ERROR
)
801 /* Fill in the rest of the `struct so_list' node. */
802 if (!solib_map_sections (i
))
805 if (not_found_filename
== NULL
)
806 not_found_filename
= i
->so_original_name
;
811 exception_fprintf (gdb_stderr
, e
,
812 _("Error while mapping shared "
813 "library sections:\n"));
815 /* Notify any observer that the shared object has been
816 loaded now that we've added it to GDB's tables. */
817 observer_notify_solib_loaded (i
);
820 /* If a library was not found, issue an appropriate warning
821 message. We have to use a single call to warning in case the
822 front end does something special with warnings, e.g., pop up
823 a dialog box. It Would Be Nice if we could get a "warning: "
824 prefix on each line in the CLI front end, though - it doesn't
828 warning (_("Could not load shared library symbols for %s.\n"
829 "Do you need \"set solib-search-path\" "
830 "or \"set sysroot\"?"),
832 else if (not_found
> 1)
834 Could not load shared library symbols for %d libraries, e.g. %s.\n\
835 Use the \"info sharedlibrary\" command to see the complete listing.\n\
836 Do you need \"set solib-search-path\" or \"set sysroot\"?"),
837 not_found
, not_found_filename
);
842 /* Return non-zero if NAME is the libpthread shared library.
844 Uses a fairly simplistic heuristic approach where we check
845 the file name against "/libpthread". This can lead to false
846 positives, but this should be good enough in practice. */
849 libpthread_name_p (const char *name
)
851 return (strstr (name
, "/libpthread") != NULL
);
854 /* Return non-zero if SO is the libpthread shared library. */
857 libpthread_solib_p (struct so_list
*so
)
859 return libpthread_name_p (so
->so_name
);
862 /* Read in symbolic information for any shared objects whose names
863 match PATTERN. (If we've already read a shared object's symbol
864 info, leave it alone.) If PATTERN is zero, read them all.
866 If READSYMS is 0, defer reading symbolic information until later
867 but still do any needed low level processing.
869 FROM_TTY and TARGET are as described for update_solib_list, above. */
872 solib_add (char *pattern
, int from_tty
,
873 struct target_ops
*target
, int readsyms
)
877 current_program_space
->solib_add_generation
++;
881 char *re_err
= re_comp (pattern
);
884 error (_("Invalid regexp: %s"), re_err
);
887 update_solib_list (from_tty
, target
);
889 /* Walk the list of currently loaded shared libraries, and read
890 symbols for any that match the pattern --- or any whose symbols
891 aren't already loaded, if no pattern was given. */
894 int loaded_any_symbols
= 0;
896 SYMFILE_DEFER_BP_RESET
| (from_tty
? SYMFILE_VERBOSE
: 0);
898 for (gdb
= so_list_head
; gdb
; gdb
= gdb
->next
)
899 if (! pattern
|| re_exec (gdb
->so_name
))
901 /* Normally, we would read the symbols from that library
902 only if READSYMS is set. However, we're making a small
903 exception for the pthread library, because we sometimes
904 need the library symbols to be loaded in order to provide
905 thread support (x86-linux for instance). */
906 const int add_this_solib
=
907 (readsyms
|| libpthread_solib_p (gdb
));
912 if (gdb
->symbols_loaded
)
914 /* If no pattern was given, be quiet for shared
915 libraries we have already loaded. */
916 if (pattern
&& (from_tty
|| info_verbose
))
917 printf_unfiltered (_("Symbols already loaded for %s\n"),
920 else if (solib_read_symbols (gdb
, flags
))
921 loaded_any_symbols
= 1;
925 if (loaded_any_symbols
)
926 breakpoint_re_set ();
928 if (from_tty
&& pattern
&& ! any_matches
)
930 ("No loaded shared libraries match the pattern `%s'.\n", pattern
);
932 if (loaded_any_symbols
)
934 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
936 /* Getting new symbols may change our opinion about what is
938 reinit_frame_cache ();
940 ops
->special_symbol_handling ();
945 /* Implement the "info sharedlibrary" command. Walk through the
946 shared library list and print information about each attached
947 library matching PATTERN. If PATTERN is elided, print them
951 info_sharedlibrary_command (char *pattern
, int from_tty
)
953 struct so_list
*so
= NULL
; /* link map state variable */
954 int so_missing_debug_info
= 0;
957 struct cleanup
*table_cleanup
;
958 struct gdbarch
*gdbarch
= target_gdbarch
;
959 struct ui_out
*uiout
= current_uiout
;
963 char *re_err
= re_comp (pattern
);
966 error (_("Invalid regexp: %s"), re_err
);
969 /* "0x", a little whitespace, and two hex digits per byte of pointers. */
970 addr_width
= 4 + (gdbarch_ptr_bit (gdbarch
) / 4);
972 update_solib_list (from_tty
, 0);
974 /* make_cleanup_ui_out_table_begin_end needs to know the number of
975 rows, so we need to make two passes over the libs. */
977 for (nr_libs
= 0, so
= so_list_head
; so
; so
= so
->next
)
981 if (pattern
&& ! re_exec (so
->so_name
))
988 make_cleanup_ui_out_table_begin_end (uiout
, 4, nr_libs
,
989 "SharedLibraryTable");
991 /* The "- 1" is because ui_out adds one space between columns. */
992 ui_out_table_header (uiout
, addr_width
- 1, ui_left
, "from", "From");
993 ui_out_table_header (uiout
, addr_width
- 1, ui_left
, "to", "To");
994 ui_out_table_header (uiout
, 12 - 1, ui_left
, "syms-read", "Syms Read");
995 ui_out_table_header (uiout
, 0, ui_noalign
,
996 "name", "Shared Object Library");
998 ui_out_table_body (uiout
);
1000 for (so
= so_list_head
; so
; so
= so
->next
)
1002 struct cleanup
*lib_cleanup
;
1004 if (! so
->so_name
[0])
1006 if (pattern
&& ! re_exec (so
->so_name
))
1009 lib_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, "lib");
1011 if (so
->addr_high
!= 0)
1013 ui_out_field_core_addr (uiout
, "from", gdbarch
, so
->addr_low
);
1014 ui_out_field_core_addr (uiout
, "to", gdbarch
, so
->addr_high
);
1018 ui_out_field_skip (uiout
, "from");
1019 ui_out_field_skip (uiout
, "to");
1022 if (! ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1023 && so
->symbols_loaded
1024 && !objfile_has_symbols (so
->objfile
))
1026 so_missing_debug_info
= 1;
1027 ui_out_field_string (uiout
, "syms-read", "Yes (*)");
1030 ui_out_field_string (uiout
, "syms-read",
1031 so
->symbols_loaded
? "Yes" : "No");
1033 ui_out_field_string (uiout
, "name", so
->so_name
);
1035 ui_out_text (uiout
, "\n");
1037 do_cleanups (lib_cleanup
);
1040 do_cleanups (table_cleanup
);
1045 ui_out_message (uiout
, 0,
1046 _("No shared libraries matched.\n"));
1048 ui_out_message (uiout
, 0,
1049 _("No shared libraries loaded at this time.\n"));
1053 if (so_missing_debug_info
)
1054 ui_out_message (uiout
, 0,
1055 _("(*): Shared library is missing "
1056 "debugging information.\n"));
1060 /* Return 1 if ADDRESS lies within SOLIB. */
1063 solib_contains_address_p (const struct so_list
*const solib
,
1066 struct target_section
*p
;
1068 for (p
= solib
->sections
; p
< solib
->sections_end
; p
++)
1069 if (p
->addr
<= address
&& address
< p
->endaddr
)
1075 /* If ADDRESS is in a shared lib in program space PSPACE, return its
1078 Provides a hook for other gdb routines to discover whether or not a
1079 particular address is within the mapped address space of a shared
1082 For example, this routine is called at one point to disable
1083 breakpoints which are in shared libraries that are not currently
1087 solib_name_from_address (struct program_space
*pspace
, CORE_ADDR address
)
1089 struct so_list
*so
= NULL
;
1091 for (so
= pspace
->so_list
; so
; so
= so
->next
)
1092 if (solib_contains_address_p (so
, address
))
1093 return (so
->so_name
);
1098 /* Return whether the data starting at VADDR, size SIZE, must be kept
1099 in a core file for shared libraries loaded before "gcore" is used
1100 to be handled correctly when the core file is loaded. This only
1101 applies when the section would otherwise not be kept in the core
1102 file (in particular, for readonly sections). */
1105 solib_keep_data_in_core (CORE_ADDR vaddr
, unsigned long size
)
1107 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
1109 if (ops
->keep_data_in_core
)
1110 return ops
->keep_data_in_core (vaddr
, size
);
1115 /* Called by free_all_symtabs */
1120 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
1122 /* This function is expected to handle ELF shared libraries. It is
1123 also used on Solaris, which can run either ELF or a.out binaries
1124 (for compatibility with SunOS 4), both of which can use shared
1125 libraries. So we don't know whether we have an ELF executable or
1126 an a.out executable until the user chooses an executable file.
1128 ELF shared libraries don't get mapped into the address space
1129 until after the program starts, so we'd better not try to insert
1130 breakpoints in them immediately. We have to wait until the
1131 dynamic linker has loaded them; we'll hit a bp_shlib_event
1132 breakpoint (look for calls to create_solib_event_breakpoint) when
1135 SunOS shared libraries seem to be different --- they're present
1136 as soon as the process begins execution, so there's no need to
1137 put off inserting breakpoints. There's also nowhere to put a
1138 bp_shlib_event breakpoint, so if we put it off, we'll never get
1141 So: disable breakpoints only if we're using ELF shared libs. */
1142 if (exec_bfd
!= NULL
1143 && bfd_get_flavour (exec_bfd
) != bfd_target_aout_flavour
)
1144 disable_breakpoints_in_shlibs ();
1146 while (so_list_head
)
1148 struct so_list
*so
= so_list_head
;
1150 so_list_head
= so
->next
;
1151 observer_notify_solib_unloaded (so
);
1153 remove_target_sections (so
->abfd
);
1157 ops
->clear_solib ();
1160 /* Shared library startup support. When GDB starts up the inferior,
1161 it nurses it along (through the shell) until it is ready to execute
1162 its first instruction. At this point, this function gets
1166 solib_create_inferior_hook (int from_tty
)
1168 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
1170 ops
->solib_create_inferior_hook (from_tty
);
1173 /* Check to see if an address is in the dynamic loader's dynamic
1174 symbol resolution code. Return 1 if so, 0 otherwise. */
1177 in_solib_dynsym_resolve_code (CORE_ADDR pc
)
1179 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
1181 return ops
->in_dynsym_resolve_code (pc
);
1184 /* Implements the "sharedlibrary" command. */
1187 sharedlibrary_command (char *args
, int from_tty
)
1190 solib_add (args
, from_tty
, (struct target_ops
*) 0, 1);
1193 /* Implements the command "nosharedlibrary", which discards symbols
1194 that have been auto-loaded from shared libraries. Symbols from
1195 shared libraries that were added by explicit request of the user
1196 are not discarded. Also called from remote.c. */
1199 no_shared_libraries (char *ignored
, int from_tty
)
1201 /* The order of the two routines below is important: clear_solib notifies
1202 the solib_unloaded observers, and some of these observers might need
1203 access to their associated objfiles. Therefore, we can not purge the
1204 solibs' objfiles before clear_solib has been called. */
1207 objfile_purge_solibs ();
1210 /* Reload shared libraries, but avoid reloading the same symbol file
1211 we already have loaded. */
1214 reload_shared_libraries_1 (int from_tty
)
1217 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1219 for (so
= so_list_head
; so
!= NULL
; so
= so
->next
)
1221 char *filename
, *found_pathname
= NULL
;
1223 int was_loaded
= so
->symbols_loaded
;
1225 SYMFILE_DEFER_BP_RESET
| (from_tty
? SYMFILE_VERBOSE
: 0);
1227 filename
= tilde_expand (so
->so_original_name
);
1228 make_cleanup (xfree
, filename
);
1229 abfd
= solib_bfd_open (filename
);
1232 found_pathname
= xstrdup (bfd_get_filename (abfd
));
1233 make_cleanup (xfree
, found_pathname
);
1234 gdb_bfd_close_or_warn (abfd
);
1237 /* If this shared library is no longer associated with its previous
1238 symbol file, close that. */
1239 if ((found_pathname
== NULL
&& was_loaded
)
1240 || (found_pathname
!= NULL
1241 && filename_cmp (found_pathname
, so
->so_name
) != 0))
1243 if (so
->objfile
&& ! (so
->objfile
->flags
& OBJF_USERLOADED
)
1244 && !solib_used (so
))
1245 free_objfile (so
->objfile
);
1246 remove_target_sections (so
->abfd
);
1247 free_so_symbols (so
);
1250 /* If this shared library is now associated with a new symbol
1252 if (found_pathname
!= NULL
1254 || filename_cmp (found_pathname
, so
->so_name
) != 0))
1256 volatile struct gdb_exception e
;
1258 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1259 solib_map_sections (so
);
1262 exception_fprintf (gdb_stderr
, e
,
1263 _("Error while mapping "
1264 "shared library sections:\n"));
1265 else if (auto_solib_add
|| was_loaded
|| libpthread_solib_p (so
))
1266 solib_read_symbols (so
, flags
);
1270 do_cleanups (old_chain
);
1274 reload_shared_libraries (char *ignored
, int from_tty
,
1275 struct cmd_list_element
*e
)
1277 struct target_so_ops
*ops
;
1279 reload_shared_libraries_1 (from_tty
);
1281 ops
= solib_ops (target_gdbarch
);
1283 /* Creating inferior hooks here has two purposes. First, if we reload
1284 shared libraries then the address of solib breakpoint we've computed
1285 previously might be no longer valid. For example, if we forgot to set
1286 solib-absolute-prefix and are setting it right now, then the previous
1287 breakpoint address is plain wrong. Second, installing solib hooks
1288 also implicitly figures were ld.so is and loads symbols for it.
1289 Absent this call, if we've just connected to a target and set
1290 solib-absolute-prefix or solib-search-path, we'll lose all information
1292 if (target_has_execution
)
1294 /* Reset or free private data structures not associated with
1296 ops
->clear_solib ();
1298 /* Remove any previous solib event breakpoint. This is usually
1299 done in common code, at breakpoint_init_inferior time, but
1300 we're not really starting up the inferior here. */
1301 remove_solib_event_breakpoints ();
1303 #ifdef SOLIB_CREATE_INFERIOR_HOOK
1304 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
1306 solib_create_inferior_hook (from_tty
);
1310 /* Sometimes the platform-specific hook loads initial shared
1311 libraries, and sometimes it doesn't. If it doesn't FROM_TTY will be
1312 incorrectly 0 but such solib targets should be fixed anyway. If we
1313 made all the inferior hook methods consistent, this call could be
1314 removed. Call it only after the solib target has been initialized by
1315 solib_create_inferior_hook. */
1317 solib_add (NULL
, 0, NULL
, auto_solib_add
);
1319 breakpoint_re_set ();
1321 /* We may have loaded or unloaded debug info for some (or all)
1322 shared libraries. However, frames may still reference them. For
1323 example, a frame's unwinder might still point at DWARF FDE
1324 structures that are now freed. Also, getting new symbols may
1325 change our opinion about what is frameless. */
1326 reinit_frame_cache ();
1328 ops
->special_symbol_handling ();
1332 show_auto_solib_add (struct ui_file
*file
, int from_tty
,
1333 struct cmd_list_element
*c
, const char *value
)
1335 fprintf_filtered (file
, _("Autoloading of shared library symbols is %s.\n"),
1340 /* Handler for library-specific lookup of global symbol NAME in OBJFILE. Call
1341 the library-specific handler if it is installed for the current target. */
1344 solib_global_lookup (const struct objfile
*objfile
,
1346 const domain_enum domain
)
1348 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
1350 if (ops
->lookup_lib_global_symbol
!= NULL
)
1351 return ops
->lookup_lib_global_symbol (objfile
, name
, domain
);
1355 /* Lookup the value for a specific symbol from dynamic symbol table. Look
1356 up symbol from ABFD. MATCH_SYM is a callback function to determine
1357 whether to pick up a symbol. DATA is the input of this callback
1358 function. Return NULL if symbol is not found. */
1361 gdb_bfd_lookup_symbol_from_symtab (bfd
*abfd
,
1362 int (*match_sym
) (asymbol
*, void *),
1365 long storage_needed
= bfd_get_symtab_upper_bound (abfd
);
1366 CORE_ADDR symaddr
= 0;
1368 if (storage_needed
> 0)
1372 asymbol
**symbol_table
= (asymbol
**) xmalloc (storage_needed
);
1373 struct cleanup
*back_to
= make_cleanup (xfree
, symbol_table
);
1374 unsigned int number_of_symbols
=
1375 bfd_canonicalize_symtab (abfd
, symbol_table
);
1377 for (i
= 0; i
< number_of_symbols
; i
++)
1379 asymbol
*sym
= *symbol_table
++;
1381 if (match_sym (sym
, data
))
1383 /* BFD symbols are section relative. */
1384 symaddr
= sym
->value
+ sym
->section
->vma
;
1388 do_cleanups (back_to
);
1394 /* Lookup the value for a specific symbol from symbol table. Look up symbol
1395 from ABFD. MATCH_SYM is a callback function to determine whether to pick
1396 up a symbol. DATA is the input of this callback function. Return NULL
1397 if symbol is not found. */
1400 bfd_lookup_symbol_from_dyn_symtab (bfd
*abfd
,
1401 int (*match_sym
) (asymbol
*, void *),
1404 long storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1405 CORE_ADDR symaddr
= 0;
1407 if (storage_needed
> 0)
1410 asymbol
**symbol_table
= (asymbol
**) xmalloc (storage_needed
);
1411 struct cleanup
*back_to
= make_cleanup (xfree
, symbol_table
);
1412 unsigned int number_of_symbols
=
1413 bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
1415 for (i
= 0; i
< number_of_symbols
; i
++)
1417 asymbol
*sym
= *symbol_table
++;
1419 if (match_sym (sym
, data
))
1421 /* BFD symbols are section relative. */
1422 symaddr
= sym
->value
+ sym
->section
->vma
;
1426 do_cleanups (back_to
);
1431 /* Lookup the value for a specific symbol from symbol table and dynamic
1432 symbol table. Look up symbol from ABFD. MATCH_SYM is a callback
1433 function to determine whether to pick up a symbol. DATA is the
1434 input of this callback function. Return NULL if symbol is not
1438 gdb_bfd_lookup_symbol (bfd
*abfd
,
1439 int (*match_sym
) (asymbol
*, void *),
1442 CORE_ADDR symaddr
= gdb_bfd_lookup_symbol_from_symtab (abfd
, match_sym
, data
);
1444 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
1445 have to check the dynamic string table too. */
1447 symaddr
= bfd_lookup_symbol_from_dyn_symtab (abfd
, match_sym
, data
);
1452 extern initialize_file_ftype _initialize_solib
; /* -Wmissing-prototypes */
1455 _initialize_solib (void)
1457 solib_data
= gdbarch_data_register_pre_init (solib_init
);
1459 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
1460 _("Load shared object library symbols for files matching REGEXP."));
1461 add_info ("sharedlibrary", info_sharedlibrary_command
,
1462 _("Status of loaded shared object libraries."));
1463 add_com ("nosharedlibrary", class_files
, no_shared_libraries
,
1464 _("Unload all shared object library symbols."));
1466 add_setshow_boolean_cmd ("auto-solib-add", class_support
,
1467 &auto_solib_add
, _("\
1468 Set autoloading of shared library symbols."), _("\
1469 Show autoloading of shared library symbols."), _("\
1470 If \"on\", symbols from all shared object libraries will be loaded\n\
1471 automatically when the inferior begins execution, when the dynamic linker\n\
1472 informs gdb that a new library has been loaded, or when attaching to the\n\
1473 inferior. Otherwise, symbols must be loaded manually, using \
1476 show_auto_solib_add
,
1477 &setlist
, &showlist
);
1479 add_setshow_filename_cmd ("sysroot", class_support
,
1481 Set an alternate system root."), _("\
1482 Show the current system root."), _("\
1483 The system root is used to load absolute shared library symbol files.\n\
1484 For other (relative) files, you can add directories using\n\
1485 `set solib-search-path'."),
1486 reload_shared_libraries
,
1488 &setlist
, &showlist
);
1490 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support
, 0,
1492 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support
, 0,
1495 add_setshow_optional_filename_cmd ("solib-search-path", class_support
,
1496 &solib_search_path
, _("\
1497 Set the search path for loading non-absolute shared library symbol files."),
1499 Show the search path for loading non-absolute shared library symbol files."),
1501 This takes precedence over the environment variables \
1502 PATH and LD_LIBRARY_PATH."),
1503 reload_shared_libraries
,
1504 show_solib_search_path
,
1505 &setlist
, &showlist
);