1 /* Handle shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 1990-2003, 2005-2012 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 /* 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 struct target_so_ops
*
66 solib_ops (struct gdbarch
*gdbarch
)
68 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
, struct target_so_ops
*new_ops
)
78 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 /* Returns the full pathname of the shared library file, or NULL if
116 not found. (The pathname is malloc'ed; it needs to be freed by the
117 caller.) *FD is set to either -1 or an open file handle for the
120 Global variable GDB_SYSROOT is used as a prefix directory
121 to search for shared libraries if they have an absolute path.
123 Global variable SOLIB_SEARCH_PATH is used as a prefix directory
124 (or set of directories, as in LD_LIBRARY_PATH) to search for all
125 shared libraries if not found in GDB_SYSROOT.
128 * If there is a gdb_sysroot and path is absolute:
129 * Search for gdb_sysroot/path.
131 * Look for it literally (unmodified).
132 * Look in SOLIB_SEARCH_PATH.
133 * If available, use target defined search function.
134 * If gdb_sysroot is NOT set, perform the following two searches:
135 * Look in inferior's $PATH.
136 * Look in inferior's $LD_LIBRARY_PATH.
138 * The last check avoids doing this search when targetting remote
139 * machines since gdb_sysroot will almost always be set.
143 solib_find (char *in_pathname
, int *fd
)
145 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
147 char *temp_pathname
= NULL
;
148 int gdb_sysroot_is_empty
;
149 const char *solib_symbols_extension
150 = gdbarch_solib_symbols_extension (target_gdbarch
);
151 const char *fskind
= effective_target_file_system_kind ();
152 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
153 char *sysroot
= NULL
;
155 /* If solib_symbols_extension is set, replace the file's
157 if (solib_symbols_extension
)
159 char *p
= in_pathname
+ strlen (in_pathname
);
161 while (p
> in_pathname
&& *p
!= '.')
168 new_pathname
= alloca (p
- in_pathname
+ 1
169 + strlen (solib_symbols_extension
) + 1);
170 memcpy (new_pathname
, in_pathname
, p
- in_pathname
+ 1);
171 strcpy (new_pathname
+ (p
- in_pathname
) + 1,
172 solib_symbols_extension
);
174 in_pathname
= new_pathname
;
178 gdb_sysroot_is_empty
= (gdb_sysroot
== NULL
|| *gdb_sysroot
== 0);
180 if (!gdb_sysroot_is_empty
)
182 int prefix_len
= strlen (gdb_sysroot
);
184 /* Remove trailing slashes from absolute prefix. */
185 while (prefix_len
> 0
186 && IS_DIR_SEPARATOR (gdb_sysroot
[prefix_len
- 1]))
189 sysroot
= savestring (gdb_sysroot
, prefix_len
);
190 make_cleanup (xfree
, sysroot
);
193 /* If we're on a non-DOS-based system, backslashes won't be
194 understood as directory separator, so, convert them to forward
195 slashes, iff we're supposed to handle DOS-based file system
196 semantics for target paths. */
197 if (!DOS_BASED_FILE_SYSTEM
&& fskind
== file_system_kind_dos_based
)
201 /* Avoid clobbering our input. */
202 p
= alloca (strlen (in_pathname
) + 1);
203 strcpy (p
, in_pathname
);
213 /* Note, we're interested in IS_TARGET_ABSOLUTE_PATH, not
214 IS_ABSOLUTE_PATH. The latter is for host paths only, while
215 IN_PATHNAME is a target path. For example, if we're supposed to
216 be handling DOS-like semantics we want to consider a
217 'c:/foo/bar.dll' path as an absolute path, even on a Unix box.
218 With such a path, before giving up on the sysroot, we'll try:
220 1st attempt, c:/foo/bar.dll ==> /sysroot/c:/foo/bar.dll
221 2nd attempt, c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll
222 3rd attempt, c:/foo/bar.dll ==> /sysroot/foo/bar.dll
225 if (!IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
) || gdb_sysroot_is_empty
)
226 temp_pathname
= xstrdup (in_pathname
);
229 int need_dir_separator
;
231 need_dir_separator
= !IS_DIR_SEPARATOR (in_pathname
[0]);
233 /* Cat the prefixed pathname together. */
234 temp_pathname
= concat (sysroot
,
235 need_dir_separator
? SLASH_STRING
: "",
236 in_pathname
, (char *) NULL
);
239 /* Handle remote files. */
240 if (remote_filename_p (temp_pathname
))
243 do_cleanups (old_chain
);
244 return temp_pathname
;
247 /* Now see if we can open it. */
248 found_file
= open (temp_pathname
, O_RDONLY
| O_BINARY
, 0);
250 xfree (temp_pathname
);
252 /* If the search in gdb_sysroot failed, and the path name has a
253 drive spec (e.g, c:/foo), try stripping ':' from the drive spec,
254 and retrying in the sysroot:
255 c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll. */
258 && !gdb_sysroot_is_empty
259 && HAS_TARGET_DRIVE_SPEC (fskind
, in_pathname
))
261 int need_dir_separator
= !IS_DIR_SEPARATOR (in_pathname
[2]);
262 char *drive
= savestring (in_pathname
, 1);
264 temp_pathname
= concat (sysroot
,
267 need_dir_separator
? SLASH_STRING
: "",
268 in_pathname
+ 2, (char *) NULL
);
271 found_file
= open (temp_pathname
, O_RDONLY
| O_BINARY
, 0);
274 xfree (temp_pathname
);
276 /* If the search in gdb_sysroot still failed, try fully
277 stripping the drive spec, and trying once more in the
278 sysroot before giving up.
280 c:/foo/bar.dll ==> /sysroot/foo/bar.dll. */
282 temp_pathname
= concat (sysroot
,
283 need_dir_separator
? SLASH_STRING
: "",
284 in_pathname
+ 2, (char *) NULL
);
286 found_file
= open (temp_pathname
, O_RDONLY
| O_BINARY
, 0);
288 xfree (temp_pathname
);
292 do_cleanups (old_chain
);
294 /* We try to find the library in various ways. After each attempt,
295 either found_file >= 0 and temp_pathname is a malloc'd string, or
296 found_file < 0 and temp_pathname does not point to storage that
297 needs to be freed. */
300 temp_pathname
= NULL
;
302 /* If not found, search the solib_search_path (if any). */
303 if (found_file
< 0 && solib_search_path
!= NULL
)
304 found_file
= openp (solib_search_path
, OPF_TRY_CWD_FIRST
,
305 in_pathname
, O_RDONLY
| O_BINARY
, &temp_pathname
);
307 /* If the search in gdb_sysroot failed, and the path name is
308 absolute at this point, make it relative. (openp will try and open the
309 file according to its absolute path otherwise, which is not what we want.)
310 Affects subsequent searches for this solib. */
311 if (found_file
< 0 && IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
))
313 /* First, get rid of any drive letters etc. */
314 while (!IS_TARGET_DIR_SEPARATOR (fskind
, *in_pathname
))
317 /* Next, get rid of all leading dir separators. */
318 while (IS_TARGET_DIR_SEPARATOR (fskind
, *in_pathname
))
322 /* If not found, search the solib_search_path (if any). */
323 if (found_file
< 0 && solib_search_path
!= NULL
)
324 found_file
= openp (solib_search_path
, OPF_TRY_CWD_FIRST
,
325 in_pathname
, O_RDONLY
| O_BINARY
, &temp_pathname
);
327 /* If not found, next search the solib_search_path (if any) for the basename
328 only (ignoring the path). This is to allow reading solibs from a path
329 that differs from the opened path. */
330 if (found_file
< 0 && solib_search_path
!= NULL
)
331 found_file
= openp (solib_search_path
, OPF_TRY_CWD_FIRST
,
332 target_lbasename (fskind
, in_pathname
),
333 O_RDONLY
| O_BINARY
, &temp_pathname
);
335 /* If not found, try to use target supplied solib search method. */
336 if (found_file
< 0 && ops
->find_and_open_solib
)
337 found_file
= ops
->find_and_open_solib (in_pathname
, O_RDONLY
| O_BINARY
,
340 /* If not found, next search the inferior's $PATH environment variable. */
341 if (found_file
< 0 && gdb_sysroot_is_empty
)
342 found_file
= openp (get_in_environ (current_inferior ()->environment
,
344 OPF_TRY_CWD_FIRST
, in_pathname
, O_RDONLY
| O_BINARY
,
347 /* If not found, next search the inferior's $LD_LIBRARY_PATH
348 environment variable. */
349 if (found_file
< 0 && gdb_sysroot_is_empty
)
350 found_file
= openp (get_in_environ (current_inferior ()->environment
,
352 OPF_TRY_CWD_FIRST
, in_pathname
, O_RDONLY
| O_BINARY
,
356 return temp_pathname
;
359 /* Open and return a BFD for the shared library PATHNAME. If FD is not -1,
360 it is used as file handle to open the file. Throws an error if the file
361 could not be opened. Handles both local and remote file access.
363 PATHNAME must be malloc'ed by the caller. If successful, the new BFD's
364 name will point to it. If unsuccessful, PATHNAME will be freed and the
365 FD will be closed (unless FD was -1). */
368 solib_bfd_fopen (char *pathname
, int fd
)
372 if (remote_filename_p (pathname
))
374 gdb_assert (fd
== -1);
375 abfd
= remote_bfd_open (pathname
, gnutarget
);
379 abfd
= bfd_fopen (pathname
, gnutarget
, FOPEN_RB
, fd
);
382 bfd_set_cacheable (abfd
, 1);
389 make_cleanup (xfree
, pathname
);
390 error (_("Could not open `%s' as an executable file: %s"),
391 pathname
, bfd_errmsg (bfd_get_error ()));
397 /* Find shared library PATHNAME and open a BFD for it. */
400 solib_bfd_open (char *pathname
)
402 char *found_pathname
;
405 const struct bfd_arch_info
*b
;
407 /* Search for shared library file. */
408 found_pathname
= solib_find (pathname
, &found_file
);
409 if (found_pathname
== NULL
)
411 /* Return failure if the file could not be found, so that we can
412 accumulate messages about missing libraries. */
416 perror_with_name (pathname
);
419 /* Open bfd for shared library. */
420 abfd
= solib_bfd_fopen (found_pathname
, found_file
);
422 /* Check bfd format. */
423 if (!bfd_check_format (abfd
, bfd_object
))
426 make_cleanup (xfree
, found_pathname
);
427 error (_("`%s': not in executable format: %s"),
428 found_pathname
, bfd_errmsg (bfd_get_error ()));
431 /* Check bfd arch. */
432 b
= gdbarch_bfd_arch_info (target_gdbarch
);
433 if (!b
->compatible (b
, bfd_get_arch_info (abfd
)))
434 warning (_("`%s': Shared library architecture %s is not compatible "
435 "with target architecture %s."), found_pathname
,
436 bfd_get_arch_info (abfd
)->printable_name
, b
->printable_name
);
441 /* Given a pointer to one of the shared objects in our list of mapped
442 objects, use the recorded name to open a bfd descriptor for the
443 object, build a section table, relocate all the section addresses
444 by the base address at which the shared object was mapped, and then
445 add the sections to the target's section table.
447 FIXME: In most (all?) cases the shared object file name recorded in
448 the dynamic linkage tables will be a fully qualified pathname. For
449 cases where it isn't, do we really mimic the systems search
450 mechanism correctly in the below code (particularly the tilde
451 expansion stuff?). */
454 solib_map_sections (struct so_list
*so
)
456 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
458 struct target_section
*p
;
459 struct cleanup
*old_chain
;
462 filename
= tilde_expand (so
->so_name
);
463 old_chain
= make_cleanup (xfree
, filename
);
464 abfd
= ops
->bfd_open (filename
);
465 do_cleanups (old_chain
);
470 /* Leave bfd open, core_xfer_memory and "info files" need it. */
471 so
->abfd
= gdb_bfd_ref (abfd
);
473 /* copy full path name into so_name, so that later symbol_file_add
475 if (strlen (bfd_get_filename (abfd
)) >= SO_NAME_MAX_PATH_SIZE
)
476 error (_("Shared library file name is too long."));
477 strcpy (so
->so_name
, bfd_get_filename (abfd
));
479 if (build_section_table (abfd
, &so
->sections
, &so
->sections_end
))
481 error (_("Can't find the file sections in `%s': %s"),
482 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
485 for (p
= so
->sections
; p
< so
->sections_end
; p
++)
487 /* Relocate the section binding addresses as recorded in the shared
488 object's file by the base address to which the object was actually
490 ops
->relocate_section_addresses (so
, p
);
492 /* If the target didn't provide information about the address
493 range of the shared object, assume we want the location of
494 the .text section. */
495 if (so
->addr_low
== 0 && so
->addr_high
== 0
496 && strcmp (p
->the_bfd_section
->name
, ".text") == 0)
498 so
->addr_low
= p
->addr
;
499 so
->addr_high
= p
->endaddr
;
503 /* Add the shared object's sections to the current set of file
504 section tables. Do this immediately after mapping the object so
505 that later nodes in the list can query this object, as is needed
507 add_target_sections (so
->sections
, so
->sections_end
);
512 /* Free symbol-file related contents of SO. If we have opened a BFD
513 for SO, close it. If we have placed SO's sections in some target's
514 section table, the caller is responsible for removing them.
516 This function doesn't mess with objfiles at all. If there is an
517 objfile associated with SO that needs to be removed, the caller is
518 responsible for taking care of that. */
521 free_so_symbols (struct so_list
*so
)
525 xfree (so
->sections
);
526 so
->sections
= so
->sections_end
= NULL
;
529 gdb_bfd_unref (so
->abfd
);
532 /* Our caller closed the objfile, possibly via objfile_purge_solibs. */
533 so
->symbols_loaded
= 0;
536 so
->addr_low
= so
->addr_high
= 0;
538 /* Restore the target-supplied file name. SO_NAME may be the path
539 of the symbol file. */
540 strcpy (so
->so_name
, so
->so_original_name
);
543 /* Free the storage associated with the `struct so_list' object SO.
544 If we have opened a BFD for SO, close it.
546 The caller is responsible for removing SO from whatever list it is
547 a member of. If we have placed SO's sections in some target's
548 section table, the caller is responsible for removing them.
550 This function doesn't mess with objfiles at all. If there is an
551 objfile associated with SO that needs to be removed, the caller is
552 responsible for taking care of that. */
555 free_so (struct so_list
*so
)
557 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
559 free_so_symbols (so
);
566 /* Return address of first so_list entry in master shared object list. */
568 master_so_list (void)
573 /* Read in symbols for shared object SO. If SYMFILE_VERBOSE is set in FLAGS,
574 be chatty about it. Return non-zero if any symbols were actually
578 solib_read_symbols (struct so_list
*so
, int flags
)
580 const int from_tty
= flags
& SYMFILE_VERBOSE
;
582 if (so
->symbols_loaded
)
584 /* If needed, we've already warned in our caller. */
586 else if (so
->abfd
== NULL
)
588 /* We've already warned about this library, when trying to open
593 volatile struct gdb_exception e
;
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 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 *gdb_link
= gdb
->next
;
763 /* Unless the user loaded it explicitly, free SO's objfile. */
764 if (gdb
->objfile
&& ! (gdb
->objfile
->flags
& OBJF_USERLOADED
)
765 && !solib_used (gdb
))
766 free_objfile (gdb
->objfile
);
768 /* Some targets' section tables might be referring to
769 sections from so->abfd; remove them. */
770 remove_target_sections (gdb
->abfd
);
777 /* Now the inferior's list contains only shared objects that don't
778 appear in GDB's list --- those that are newly loaded. Add them
779 to GDB's shared object list. */
783 const char *not_found_filename
= NULL
;
787 /* Add the new shared objects to GDB's list. */
788 *gdb_link
= inferior
;
790 /* Fill in the rest of each of the `struct so_list' nodes. */
791 for (i
= inferior
; i
; i
= i
->next
)
793 volatile struct gdb_exception e
;
795 i
->pspace
= current_program_space
;
797 TRY_CATCH (e
, RETURN_MASK_ERROR
)
799 /* Fill in the rest of the `struct so_list' node. */
800 if (!solib_map_sections (i
))
803 if (not_found_filename
== NULL
)
804 not_found_filename
= i
->so_original_name
;
809 exception_fprintf (gdb_stderr
, e
,
810 _("Error while mapping shared "
811 "library sections:\n"));
813 /* Notify any observer that the shared object has been
814 loaded now that we've added it to GDB's tables. */
815 observer_notify_solib_loaded (i
);
818 /* If a library was not found, issue an appropriate warning
819 message. We have to use a single call to warning in case the
820 front end does something special with warnings, e.g., pop up
821 a dialog box. It Would Be Nice if we could get a "warning: "
822 prefix on each line in the CLI front end, though - it doesn't
826 warning (_("Could not load shared library symbols for %s.\n"
827 "Do you need \"set solib-search-path\" "
828 "or \"set sysroot\"?"),
830 else if (not_found
> 1)
832 Could not load shared library symbols for %d libraries, e.g. %s.\n\
833 Use the \"info sharedlibrary\" command to see the complete listing.\n\
834 Do you need \"set solib-search-path\" or \"set sysroot\"?"),
835 not_found
, not_found_filename
);
840 /* Return non-zero if NAME is the libpthread shared library.
842 Uses a fairly simplistic heuristic approach where we check
843 the file name against "/libpthread". This can lead to false
844 positives, but this should be good enough in practice. */
847 libpthread_name_p (const char *name
)
849 return (strstr (name
, "/libpthread") != NULL
);
852 /* Return non-zero if SO is the libpthread shared library. */
855 libpthread_solib_p (struct so_list
*so
)
857 return libpthread_name_p (so
->so_name
);
860 /* Read in symbolic information for any shared objects whose names
861 match PATTERN. (If we've already read a shared object's symbol
862 info, leave it alone.) If PATTERN is zero, read them all.
864 If READSYMS is 0, defer reading symbolic information until later
865 but still do any needed low level processing.
867 FROM_TTY and TARGET are as described for update_solib_list, above. */
870 solib_add (char *pattern
, int from_tty
,
871 struct target_ops
*target
, int readsyms
)
875 current_program_space
->solib_add_generation
++;
879 char *re_err
= re_comp (pattern
);
882 error (_("Invalid regexp: %s"), re_err
);
885 update_solib_list (from_tty
, target
);
887 /* Walk the list of currently loaded shared libraries, and read
888 symbols for any that match the pattern --- or any whose symbols
889 aren't already loaded, if no pattern was given. */
892 int loaded_any_symbols
= 0;
894 SYMFILE_DEFER_BP_RESET
| (from_tty
? SYMFILE_VERBOSE
: 0);
896 for (gdb
= so_list_head
; gdb
; gdb
= gdb
->next
)
897 if (! pattern
|| re_exec (gdb
->so_name
))
899 /* Normally, we would read the symbols from that library
900 only if READSYMS is set. However, we're making a small
901 exception for the pthread library, because we sometimes
902 need the library symbols to be loaded in order to provide
903 thread support (x86-linux for instance). */
904 const int add_this_solib
=
905 (readsyms
|| libpthread_solib_p (gdb
));
910 if (gdb
->symbols_loaded
)
912 /* If no pattern was given, be quiet for shared
913 libraries we have already loaded. */
914 if (pattern
&& (from_tty
|| info_verbose
))
915 printf_unfiltered (_("Symbols already loaded for %s\n"),
918 else if (solib_read_symbols (gdb
, flags
))
919 loaded_any_symbols
= 1;
923 if (loaded_any_symbols
)
924 breakpoint_re_set ();
926 if (from_tty
&& pattern
&& ! any_matches
)
928 ("No loaded shared libraries match the pattern `%s'.\n", pattern
);
930 if (loaded_any_symbols
)
932 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
934 /* Getting new symbols may change our opinion about what is
936 reinit_frame_cache ();
938 ops
->special_symbol_handling ();
943 /* Implement the "info sharedlibrary" command. Walk through the
944 shared library list and print information about each attached
945 library matching PATTERN. If PATTERN is elided, print them
949 info_sharedlibrary_command (char *pattern
, int from_tty
)
951 struct so_list
*so
= NULL
; /* link map state variable */
952 int so_missing_debug_info
= 0;
955 struct cleanup
*table_cleanup
;
956 struct gdbarch
*gdbarch
= target_gdbarch
;
957 struct ui_out
*uiout
= current_uiout
;
961 char *re_err
= re_comp (pattern
);
964 error (_("Invalid regexp: %s"), re_err
);
967 /* "0x", a little whitespace, and two hex digits per byte of pointers. */
968 addr_width
= 4 + (gdbarch_ptr_bit (gdbarch
) / 4);
970 update_solib_list (from_tty
, 0);
972 /* make_cleanup_ui_out_table_begin_end needs to know the number of
973 rows, so we need to make two passes over the libs. */
975 for (nr_libs
= 0, so
= so_list_head
; so
; so
= so
->next
)
979 if (pattern
&& ! re_exec (so
->so_name
))
986 make_cleanup_ui_out_table_begin_end (uiout
, 4, nr_libs
,
987 "SharedLibraryTable");
989 /* The "- 1" is because ui_out adds one space between columns. */
990 ui_out_table_header (uiout
, addr_width
- 1, ui_left
, "from", "From");
991 ui_out_table_header (uiout
, addr_width
- 1, ui_left
, "to", "To");
992 ui_out_table_header (uiout
, 12 - 1, ui_left
, "syms-read", "Syms Read");
993 ui_out_table_header (uiout
, 0, ui_noalign
,
994 "name", "Shared Object Library");
996 ui_out_table_body (uiout
);
998 for (so
= so_list_head
; so
; so
= so
->next
)
1000 struct cleanup
*lib_cleanup
;
1002 if (! so
->so_name
[0])
1004 if (pattern
&& ! re_exec (so
->so_name
))
1007 lib_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, "lib");
1009 if (so
->addr_high
!= 0)
1011 ui_out_field_core_addr (uiout
, "from", gdbarch
, so
->addr_low
);
1012 ui_out_field_core_addr (uiout
, "to", gdbarch
, so
->addr_high
);
1016 ui_out_field_skip (uiout
, "from");
1017 ui_out_field_skip (uiout
, "to");
1020 if (! ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1021 && so
->symbols_loaded
1022 && !objfile_has_symbols (so
->objfile
))
1024 so_missing_debug_info
= 1;
1025 ui_out_field_string (uiout
, "syms-read", "Yes (*)");
1028 ui_out_field_string (uiout
, "syms-read",
1029 so
->symbols_loaded
? "Yes" : "No");
1031 ui_out_field_string (uiout
, "name", so
->so_name
);
1033 ui_out_text (uiout
, "\n");
1035 do_cleanups (lib_cleanup
);
1038 do_cleanups (table_cleanup
);
1043 ui_out_message (uiout
, 0,
1044 _("No shared libraries matched.\n"));
1046 ui_out_message (uiout
, 0,
1047 _("No shared libraries loaded at this time.\n"));
1051 if (so_missing_debug_info
)
1052 ui_out_message (uiout
, 0,
1053 _("(*): Shared library is missing "
1054 "debugging information.\n"));
1058 /* Return 1 if ADDRESS lies within SOLIB. */
1061 solib_contains_address_p (const struct so_list
*const solib
,
1064 struct target_section
*p
;
1066 for (p
= solib
->sections
; p
< solib
->sections_end
; p
++)
1067 if (p
->addr
<= address
&& address
< p
->endaddr
)
1073 /* If ADDRESS is in a shared lib in program space PSPACE, return its
1076 Provides a hook for other gdb routines to discover whether or not a
1077 particular address is within the mapped address space of a shared
1080 For example, this routine is called at one point to disable
1081 breakpoints which are in shared libraries that are not currently
1085 solib_name_from_address (struct program_space
*pspace
, CORE_ADDR address
)
1087 struct so_list
*so
= NULL
;
1089 for (so
= pspace
->so_list
; so
; so
= so
->next
)
1090 if (solib_contains_address_p (so
, address
))
1091 return (so
->so_name
);
1096 /* Return whether the data starting at VADDR, size SIZE, must be kept
1097 in a core file for shared libraries loaded before "gcore" is used
1098 to be handled correctly when the core file is loaded. This only
1099 applies when the section would otherwise not be kept in the core
1100 file (in particular, for readonly sections). */
1103 solib_keep_data_in_core (CORE_ADDR vaddr
, unsigned long size
)
1105 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
1107 if (ops
->keep_data_in_core
)
1108 return ops
->keep_data_in_core (vaddr
, size
);
1113 /* Called by free_all_symtabs */
1118 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
1120 /* This function is expected to handle ELF shared libraries. It is
1121 also used on Solaris, which can run either ELF or a.out binaries
1122 (for compatibility with SunOS 4), both of which can use shared
1123 libraries. So we don't know whether we have an ELF executable or
1124 an a.out executable until the user chooses an executable file.
1126 ELF shared libraries don't get mapped into the address space
1127 until after the program starts, so we'd better not try to insert
1128 breakpoints in them immediately. We have to wait until the
1129 dynamic linker has loaded them; we'll hit a bp_shlib_event
1130 breakpoint (look for calls to create_solib_event_breakpoint) when
1133 SunOS shared libraries seem to be different --- they're present
1134 as soon as the process begins execution, so there's no need to
1135 put off inserting breakpoints. There's also nowhere to put a
1136 bp_shlib_event breakpoint, so if we put it off, we'll never get
1139 So: disable breakpoints only if we're using ELF shared libs. */
1140 if (exec_bfd
!= NULL
1141 && bfd_get_flavour (exec_bfd
) != bfd_target_aout_flavour
)
1142 disable_breakpoints_in_shlibs ();
1144 while (so_list_head
)
1146 struct so_list
*so
= so_list_head
;
1148 so_list_head
= so
->next
;
1149 observer_notify_solib_unloaded (so
);
1151 remove_target_sections (so
->abfd
);
1155 ops
->clear_solib ();
1158 /* Shared library startup support. When GDB starts up the inferior,
1159 it nurses it along (through the shell) until it is ready to execute
1160 its first instruction. At this point, this function gets
1164 solib_create_inferior_hook (int from_tty
)
1166 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
1168 ops
->solib_create_inferior_hook (from_tty
);
1171 /* Check to see if an address is in the dynamic loader's dynamic
1172 symbol resolution code. Return 1 if so, 0 otherwise. */
1175 in_solib_dynsym_resolve_code (CORE_ADDR pc
)
1177 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
1179 return ops
->in_dynsym_resolve_code (pc
);
1182 /* Implements the "sharedlibrary" command. */
1185 sharedlibrary_command (char *args
, int from_tty
)
1188 solib_add (args
, from_tty
, (struct target_ops
*) 0, 1);
1191 /* Implements the command "nosharedlibrary", which discards symbols
1192 that have been auto-loaded from shared libraries. Symbols from
1193 shared libraries that were added by explicit request of the user
1194 are not discarded. Also called from remote.c. */
1197 no_shared_libraries (char *ignored
, int from_tty
)
1199 /* The order of the two routines below is important: clear_solib notifies
1200 the solib_unloaded observers, and some of these observers might need
1201 access to their associated objfiles. Therefore, we can not purge the
1202 solibs' objfiles before clear_solib has been called. */
1205 objfile_purge_solibs ();
1208 /* Reload shared libraries, but avoid reloading the same symbol file
1209 we already have loaded. */
1212 reload_shared_libraries_1 (int from_tty
)
1215 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1217 for (so
= so_list_head
; so
!= NULL
; so
= so
->next
)
1219 char *filename
, *found_pathname
= NULL
;
1221 int was_loaded
= so
->symbols_loaded
;
1223 SYMFILE_DEFER_BP_RESET
| (from_tty
? SYMFILE_VERBOSE
: 0);
1225 filename
= tilde_expand (so
->so_original_name
);
1226 make_cleanup (xfree
, filename
);
1227 abfd
= solib_bfd_open (filename
);
1230 found_pathname
= xstrdup (bfd_get_filename (abfd
));
1231 make_cleanup (xfree
, found_pathname
);
1232 gdb_bfd_close_or_warn (abfd
);
1235 /* If this shared library is no longer associated with its previous
1236 symbol file, close that. */
1237 if ((found_pathname
== NULL
&& was_loaded
)
1238 || (found_pathname
!= NULL
1239 && filename_cmp (found_pathname
, so
->so_name
) != 0))
1241 if (so
->objfile
&& ! (so
->objfile
->flags
& OBJF_USERLOADED
)
1242 && !solib_used (so
))
1243 free_objfile (so
->objfile
);
1244 remove_target_sections (so
->abfd
);
1245 free_so_symbols (so
);
1248 /* If this shared library is now associated with a new symbol
1250 if (found_pathname
!= NULL
1252 || filename_cmp (found_pathname
, so
->so_name
) != 0))
1254 volatile struct gdb_exception e
;
1256 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1257 solib_map_sections (so
);
1260 exception_fprintf (gdb_stderr
, e
,
1261 _("Error while mapping "
1262 "shared library sections:\n"));
1263 else if (auto_solib_add
|| was_loaded
|| libpthread_solib_p (so
))
1264 solib_read_symbols (so
, flags
);
1268 do_cleanups (old_chain
);
1272 reload_shared_libraries (char *ignored
, int from_tty
,
1273 struct cmd_list_element
*e
)
1275 struct target_so_ops
*ops
;
1277 reload_shared_libraries_1 (from_tty
);
1279 ops
= solib_ops (target_gdbarch
);
1281 /* Creating inferior hooks here has two purposes. First, if we reload
1282 shared libraries then the address of solib breakpoint we've computed
1283 previously might be no longer valid. For example, if we forgot to set
1284 solib-absolute-prefix and are setting it right now, then the previous
1285 breakpoint address is plain wrong. Second, installing solib hooks
1286 also implicitly figures were ld.so is and loads symbols for it.
1287 Absent this call, if we've just connected to a target and set
1288 solib-absolute-prefix or solib-search-path, we'll lose all information
1290 if (target_has_execution
)
1292 /* Reset or free private data structures not associated with
1294 ops
->clear_solib ();
1296 /* Remove any previous solib event breakpoint. This is usually
1297 done in common code, at breakpoint_init_inferior time, but
1298 we're not really starting up the inferior here. */
1299 remove_solib_event_breakpoints ();
1301 #ifdef SOLIB_CREATE_INFERIOR_HOOK
1302 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
1304 solib_create_inferior_hook (from_tty
);
1308 /* Sometimes the platform-specific hook loads initial shared
1309 libraries, and sometimes it doesn't. If it doesn't FROM_TTY will be
1310 incorrectly 0 but such solib targets should be fixed anyway. If we
1311 made all the inferior hook methods consistent, this call could be
1312 removed. Call it only after the solib target has been initialized by
1313 solib_create_inferior_hook. */
1315 solib_add (NULL
, 0, NULL
, auto_solib_add
);
1317 breakpoint_re_set ();
1319 /* We may have loaded or unloaded debug info for some (or all)
1320 shared libraries. However, frames may still reference them. For
1321 example, a frame's unwinder might still point at DWARF FDE
1322 structures that are now freed. Also, getting new symbols may
1323 change our opinion about what is frameless. */
1324 reinit_frame_cache ();
1326 ops
->special_symbol_handling ();
1330 show_auto_solib_add (struct ui_file
*file
, int from_tty
,
1331 struct cmd_list_element
*c
, const char *value
)
1333 fprintf_filtered (file
, _("Autoloading of shared library symbols is %s.\n"),
1338 /* Handler for library-specific lookup of global symbol NAME in OBJFILE. Call
1339 the library-specific handler if it is installed for the current target. */
1342 solib_global_lookup (const struct objfile
*objfile
,
1344 const domain_enum domain
)
1346 struct target_so_ops
*ops
= solib_ops (target_gdbarch
);
1348 if (ops
->lookup_lib_global_symbol
!= NULL
)
1349 return ops
->lookup_lib_global_symbol (objfile
, name
, domain
);
1353 /* Lookup the value for a specific symbol from dynamic symbol table. Look
1354 up symbol from ABFD. MATCH_SYM is a callback function to determine
1355 whether to pick up a symbol. DATA is the input of this callback
1356 function. Return NULL if symbol is not found. */
1359 gdb_bfd_lookup_symbol_from_symtab (bfd
*abfd
,
1360 int (*match_sym
) (asymbol
*, void *),
1363 long storage_needed
= bfd_get_symtab_upper_bound (abfd
);
1364 CORE_ADDR symaddr
= 0;
1366 if (storage_needed
> 0)
1370 asymbol
**symbol_table
= (asymbol
**) xmalloc (storage_needed
);
1371 struct cleanup
*back_to
= make_cleanup (xfree
, symbol_table
);
1372 unsigned int number_of_symbols
=
1373 bfd_canonicalize_symtab (abfd
, symbol_table
);
1375 for (i
= 0; i
< number_of_symbols
; i
++)
1377 asymbol
*sym
= *symbol_table
++;
1379 if (match_sym (sym
, data
))
1381 /* BFD symbols are section relative. */
1382 symaddr
= sym
->value
+ sym
->section
->vma
;
1386 do_cleanups (back_to
);
1392 /* Lookup the value for a specific symbol from symbol table. Look up symbol
1393 from ABFD. MATCH_SYM is a callback function to determine whether to pick
1394 up a symbol. DATA is the input of this callback function. Return NULL
1395 if symbol is not found. */
1398 bfd_lookup_symbol_from_dyn_symtab (bfd
*abfd
,
1399 int (*match_sym
) (asymbol
*, void *),
1402 long storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1403 CORE_ADDR symaddr
= 0;
1405 if (storage_needed
> 0)
1408 asymbol
**symbol_table
= (asymbol
**) xmalloc (storage_needed
);
1409 struct cleanup
*back_to
= make_cleanup (xfree
, symbol_table
);
1410 unsigned int number_of_symbols
=
1411 bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
1413 for (i
= 0; i
< number_of_symbols
; i
++)
1415 asymbol
*sym
= *symbol_table
++;
1417 if (match_sym (sym
, data
))
1419 /* BFD symbols are section relative. */
1420 symaddr
= sym
->value
+ sym
->section
->vma
;
1424 do_cleanups (back_to
);
1429 /* Lookup the value for a specific symbol from symbol table and dynamic
1430 symbol table. Look up symbol from ABFD. MATCH_SYM is a callback
1431 function to determine whether to pick up a symbol. DATA is the
1432 input of this callback function. Return NULL if symbol is not
1436 gdb_bfd_lookup_symbol (bfd
*abfd
,
1437 int (*match_sym
) (asymbol
*, void *),
1440 CORE_ADDR symaddr
= gdb_bfd_lookup_symbol_from_symtab (abfd
, match_sym
, data
);
1442 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
1443 have to check the dynamic string table too. */
1445 symaddr
= bfd_lookup_symbol_from_dyn_symtab (abfd
, match_sym
, data
);
1450 extern initialize_file_ftype _initialize_solib
; /* -Wmissing-prototypes */
1453 _initialize_solib (void)
1455 solib_data
= gdbarch_data_register_pre_init (solib_init
);
1457 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
1458 _("Load shared object library symbols for files matching REGEXP."));
1459 add_info ("sharedlibrary", info_sharedlibrary_command
,
1460 _("Status of loaded shared object libraries."));
1461 add_com ("nosharedlibrary", class_files
, no_shared_libraries
,
1462 _("Unload all shared object library symbols."));
1464 add_setshow_boolean_cmd ("auto-solib-add", class_support
,
1465 &auto_solib_add
, _("\
1466 Set autoloading of shared library symbols."), _("\
1467 Show autoloading of shared library symbols."), _("\
1468 If \"on\", symbols from all shared object libraries will be loaded\n\
1469 automatically when the inferior begins execution, when the dynamic linker\n\
1470 informs gdb that a new library has been loaded, or when attaching to the\n\
1471 inferior. Otherwise, symbols must be loaded manually, using \
1474 show_auto_solib_add
,
1475 &setlist
, &showlist
);
1477 add_setshow_filename_cmd ("sysroot", class_support
,
1479 Set an alternate system root."), _("\
1480 Show the current system root."), _("\
1481 The system root is used to load absolute shared library symbol files.\n\
1482 For other (relative) files, you can add directories using\n\
1483 `set solib-search-path'."),
1484 reload_shared_libraries
,
1486 &setlist
, &showlist
);
1488 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support
, 0,
1490 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support
, 0,
1493 add_setshow_optional_filename_cmd ("solib-search-path", class_support
,
1494 &solib_search_path
, _("\
1495 Set the search path for loading non-absolute shared library symbol files."),
1497 Show the search path for loading non-absolute shared library symbol files."),
1499 This takes precedence over the environment variables \
1500 PATH and LD_LIBRARY_PATH."),
1501 reload_shared_libraries
,
1502 show_solib_search_path
,
1503 &setlist
, &showlist
);