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 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
= gdb_open_cloexec (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
= gdb_open_cloexec (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
= gdb_open_cloexec (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 the search in gdb_sysroot failed, and the path name is
305 absolute at this point, make it relative. (openp will try and open the
306 file according to its absolute path otherwise, which is not what we want.)
307 Affects subsequent searches for this solib. */
308 if (found_file
< 0 && IS_TARGET_ABSOLUTE_PATH (fskind
, in_pathname
))
310 /* First, get rid of any drive letters etc. */
311 while (!IS_TARGET_DIR_SEPARATOR (fskind
, *in_pathname
))
314 /* Next, get rid of all leading dir separators. */
315 while (IS_TARGET_DIR_SEPARATOR (fskind
, *in_pathname
))
319 /* If not found, search the solib_search_path (if any). */
320 if (found_file
< 0 && solib_search_path
!= NULL
)
321 found_file
= openp (solib_search_path
, OPF_TRY_CWD_FIRST
,
322 in_pathname
, O_RDONLY
| O_BINARY
, &temp_pathname
);
324 /* If not found, next search the solib_search_path (if any) for the basename
325 only (ignoring the path). This is to allow reading solibs from a path
326 that differs from the opened path. */
327 if (found_file
< 0 && solib_search_path
!= NULL
)
328 found_file
= openp (solib_search_path
, OPF_TRY_CWD_FIRST
,
329 target_lbasename (fskind
, in_pathname
),
330 O_RDONLY
| O_BINARY
, &temp_pathname
);
332 /* If not found, try to use target supplied solib search method. */
333 if (found_file
< 0 && ops
->find_and_open_solib
)
334 found_file
= ops
->find_and_open_solib (in_pathname
, O_RDONLY
| O_BINARY
,
337 /* If not found, next search the inferior's $PATH environment variable. */
338 if (found_file
< 0 && gdb_sysroot_is_empty
)
339 found_file
= openp (get_in_environ (current_inferior ()->environment
,
341 OPF_TRY_CWD_FIRST
, in_pathname
, O_RDONLY
| O_BINARY
,
344 /* If not found, next search the inferior's $LD_LIBRARY_PATH
345 environment variable. */
346 if (found_file
< 0 && gdb_sysroot_is_empty
)
347 found_file
= openp (get_in_environ (current_inferior ()->environment
,
349 OPF_TRY_CWD_FIRST
, in_pathname
, O_RDONLY
| O_BINARY
,
353 return temp_pathname
;
356 /* Open and return a BFD for the shared library PATHNAME. If FD is not -1,
357 it is used as file handle to open the file. Throws an error if the file
358 could not be opened. Handles both local and remote file access.
360 PATHNAME must be malloc'ed by the caller. It will be freed by this
361 function. If unsuccessful, the FD will be closed (unless FD was
365 solib_bfd_fopen (char *pathname
, int fd
)
369 if (remote_filename_p (pathname
))
371 gdb_assert (fd
== -1);
372 abfd
= remote_bfd_open (pathname
, gnutarget
);
376 abfd
= gdb_bfd_open (pathname
, gnutarget
, fd
);
379 bfd_set_cacheable (abfd
, 1);
384 make_cleanup (xfree
, pathname
);
385 error (_("Could not open `%s' as an executable file: %s"),
386 pathname
, bfd_errmsg (bfd_get_error ()));
394 /* Find shared library PATHNAME and open a BFD for it. */
397 solib_bfd_open (char *pathname
)
399 char *found_pathname
;
402 const struct bfd_arch_info
*b
;
404 /* Search for shared library file. */
405 found_pathname
= solib_find (pathname
, &found_file
);
406 if (found_pathname
== NULL
)
408 /* Return failure if the file could not be found, so that we can
409 accumulate messages about missing libraries. */
413 perror_with_name (pathname
);
416 /* Open bfd for shared library. */
417 abfd
= solib_bfd_fopen (found_pathname
, found_file
);
419 /* Check bfd format. */
420 if (!bfd_check_format (abfd
, bfd_object
))
422 make_cleanup_bfd_unref (abfd
);
423 error (_("`%s': not in executable format: %s"),
424 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
427 /* Check bfd arch. */
428 b
= gdbarch_bfd_arch_info (target_gdbarch ());
429 if (!b
->compatible (b
, bfd_get_arch_info (abfd
)))
430 warning (_("`%s': Shared library architecture %s is not compatible "
431 "with target architecture %s."), bfd_get_filename (abfd
),
432 bfd_get_arch_info (abfd
)->printable_name
, b
->printable_name
);
437 /* Given a pointer to one of the shared objects in our list of mapped
438 objects, use the recorded name to open a bfd descriptor for the
439 object, build a section table, relocate all the section addresses
440 by the base address at which the shared object was mapped, and then
441 add the sections to the target's section table.
443 FIXME: In most (all?) cases the shared object file name recorded in
444 the dynamic linkage tables will be a fully qualified pathname. For
445 cases where it isn't, do we really mimic the systems search
446 mechanism correctly in the below code (particularly the tilde
447 expansion stuff?). */
450 solib_map_sections (struct so_list
*so
)
452 struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
454 struct target_section
*p
;
455 struct cleanup
*old_chain
;
458 filename
= tilde_expand (so
->so_name
);
459 old_chain
= make_cleanup (xfree
, filename
);
460 abfd
= ops
->bfd_open (filename
);
461 do_cleanups (old_chain
);
466 /* Leave bfd open, core_xfer_memory and "info files" need it. */
469 if (build_section_table (abfd
, &so
->sections
, &so
->sections_end
))
471 error (_("Can't find the file sections in `%s': %s"),
472 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
475 for (p
= so
->sections
; p
< so
->sections_end
; p
++)
477 /* Relocate the section binding addresses as recorded in the shared
478 object's file by the base address to which the object was actually
480 ops
->relocate_section_addresses (so
, p
);
482 /* If the target didn't provide information about the address
483 range of the shared object, assume we want the location of
484 the .text section. */
485 if (so
->addr_low
== 0 && so
->addr_high
== 0
486 && strcmp (p
->the_bfd_section
->name
, ".text") == 0)
488 so
->addr_low
= p
->addr
;
489 so
->addr_high
= p
->endaddr
;
493 /* Add the shared object's sections to the current set of file
494 section tables. Do this immediately after mapping the object so
495 that later nodes in the list can query this object, as is needed
497 add_target_sections (so
, so
->sections
, so
->sections_end
);
502 /* Free symbol-file related contents of SO. If we have opened a BFD
503 for SO, close it. If we have placed SO's sections in some target's
504 section table, the caller is responsible for removing them.
506 This function doesn't mess with objfiles at all. If there is an
507 objfile associated with SO that needs to be removed, the caller is
508 responsible for taking care of that. */
511 free_so_symbols (struct so_list
*so
)
515 xfree (so
->sections
);
516 so
->sections
= so
->sections_end
= NULL
;
519 gdb_bfd_unref (so
->abfd
);
522 /* Our caller closed the objfile, possibly via objfile_purge_solibs. */
523 so
->symbols_loaded
= 0;
526 so
->addr_low
= so
->addr_high
= 0;
528 /* Restore the target-supplied file name. SO_NAME may be the path
529 of the symbol file. */
530 strcpy (so
->so_name
, so
->so_original_name
);
533 /* Free the storage associated with the `struct so_list' object SO.
534 If we have opened a BFD for SO, close it.
536 The caller is responsible for removing SO from whatever list it is
537 a member of. If we have placed SO's sections in some target's
538 section table, the caller is responsible for removing them.
540 This function doesn't mess with objfiles at all. If there is an
541 objfile associated with SO that needs to be removed, the caller is
542 responsible for taking care of that. */
545 free_so (struct so_list
*so
)
547 struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
549 free_so_symbols (so
);
556 /* Return address of first so_list entry in master shared object list. */
558 master_so_list (void)
563 /* Read in symbols for shared object SO. If SYMFILE_VERBOSE is set in FLAGS,
564 be chatty about it. Return non-zero if any symbols were actually
568 solib_read_symbols (struct so_list
*so
, int flags
)
570 const int from_tty
= flags
& SYMFILE_VERBOSE
;
572 if (so
->symbols_loaded
)
574 /* If needed, we've already warned in our caller. */
576 else if (so
->abfd
== NULL
)
578 /* We've already warned about this library, when trying to open
583 volatile struct gdb_exception e
;
585 flags
|= current_inferior ()->symfile_flags
;
587 TRY_CATCH (e
, RETURN_MASK_ERROR
)
589 struct section_addr_info
*sap
;
591 /* Have we already loaded this shared object? */
592 ALL_OBJFILES (so
->objfile
)
594 if (filename_cmp (so
->objfile
->name
, so
->so_name
) == 0
595 && so
->objfile
->addr_low
== so
->addr_low
)
598 if (so
->objfile
!= NULL
)
601 sap
= build_section_addr_info_from_section_table (so
->sections
,
603 so
->objfile
= symbol_file_add_from_bfd (so
->abfd
,
604 flags
, sap
, OBJF_SHARED
,
606 so
->objfile
->addr_low
= so
->addr_low
;
607 free_section_addr_info (sap
);
611 exception_fprintf (gdb_stderr
, e
, _("Error while reading shared"
612 " library symbols for %s:\n"),
616 if (from_tty
|| info_verbose
)
617 printf_unfiltered (_("Loaded symbols for %s\n"), so
->so_name
);
618 so
->symbols_loaded
= 1;
626 /* Return 1 if KNOWN->objfile is used by any other so_list object in the
627 SO_LIST_HEAD list. Return 0 otherwise. */
630 solib_used (const struct so_list
*const known
)
632 const struct so_list
*pivot
;
634 for (pivot
= so_list_head
; pivot
!= NULL
; pivot
= pivot
->next
)
635 if (pivot
!= known
&& pivot
->objfile
== known
->objfile
)
640 /* Synchronize GDB's shared object list with inferior's.
642 Extract the list of currently loaded shared objects from the
643 inferior, and compare it with the list of shared objects currently
644 in GDB's so_list_head list. Edit so_list_head to bring it in sync
645 with the inferior's new list.
647 If we notice that the inferior has unloaded some shared objects,
648 free any symbolic info GDB had read about those shared objects.
650 Don't load symbolic info for any new shared objects; just add them
651 to the list, and leave their symbols_loaded flag clear.
653 If FROM_TTY is non-null, feel free to print messages about what
656 If TARGET is non-null, add the sections of all new shared objects
657 to TARGET's section table. Note that this doesn't remove any
658 sections for shared objects that have been unloaded, and it
659 doesn't check to see if the new shared objects are already present in
660 the section table. But we only use this for core files and
661 processes we've just attached to, so that's okay. */
664 update_solib_list (int from_tty
, struct target_ops
*target
)
666 struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
667 struct so_list
*inferior
= ops
->current_sos();
668 struct so_list
*gdb
, **gdb_link
;
670 /* We can reach here due to changing solib-search-path or the
671 sysroot, before having any inferior. */
672 if (target_has_execution
&& !ptid_equal (inferior_ptid
, null_ptid
))
674 struct inferior
*inf
= current_inferior ();
676 /* If we are attaching to a running process for which we
677 have not opened a symbol file, we may be able to get its
679 if (inf
->attach_flag
&& symfile_objfile
== NULL
)
680 catch_errors (ops
->open_symbol_file_object
, &from_tty
,
681 "Error reading attached process's symbol file.\n",
685 /* GDB and the inferior's dynamic linker each maintain their own
686 list of currently loaded shared objects; we want to bring the
687 former in sync with the latter. Scan both lists, seeing which
688 shared objects appear where. There are three cases:
690 - A shared object appears on both lists. This means that GDB
691 knows about it already, and it's still loaded in the inferior.
692 Nothing needs to happen.
694 - A shared object appears only on GDB's list. This means that
695 the inferior has unloaded it. We should remove the shared
696 object from GDB's tables.
698 - A shared object appears only on the inferior's list. This
699 means that it's just been loaded. We should add it to GDB's
702 So we walk GDB's list, checking each entry to see if it appears
703 in the inferior's list too. If it does, no action is needed, and
704 we remove it from the inferior's list. If it doesn't, the
705 inferior has unloaded it, and we remove it from GDB's list. By
706 the time we're done walking GDB's list, the inferior's list
707 contains only the new shared objects, which we then add. */
710 gdb_link
= &so_list_head
;
713 struct so_list
*i
= inferior
;
714 struct so_list
**i_link
= &inferior
;
716 /* Check to see whether the shared object *gdb also appears in
717 the inferior's current list. */
722 if (ops
->same (gdb
, i
))
727 if (! filename_cmp (gdb
->so_original_name
, i
->so_original_name
))
735 /* If the shared object appears on the inferior's list too, then
736 it's still loaded, so we don't need to do anything. Delete
737 it from the inferior's list, and leave it on GDB's list. */
742 gdb_link
= &gdb
->next
;
746 /* If it's not on the inferior's list, remove it from GDB's tables. */
749 /* Notify any observer that the shared object has been
750 unloaded before we remove it from GDB's tables. */
751 observer_notify_solib_unloaded (gdb
);
753 VEC_safe_push (char_ptr
, current_program_space
->deleted_solibs
,
754 xstrdup (gdb
->so_name
));
756 *gdb_link
= gdb
->next
;
758 /* Unless the user loaded it explicitly, free SO's objfile. */
759 if (gdb
->objfile
&& ! (gdb
->objfile
->flags
& OBJF_USERLOADED
)
760 && !solib_used (gdb
))
761 free_objfile (gdb
->objfile
);
763 /* Some targets' section tables might be referring to
764 sections from so->abfd; remove them. */
765 remove_target_sections (gdb
, gdb
->abfd
);
772 /* Now the inferior's list contains only shared objects that don't
773 appear in GDB's list --- those that are newly loaded. Add them
774 to GDB's shared object list. */
778 const char *not_found_filename
= NULL
;
782 /* Add the new shared objects to GDB's list. */
783 *gdb_link
= inferior
;
785 /* Fill in the rest of each of the `struct so_list' nodes. */
786 for (i
= inferior
; i
; i
= i
->next
)
788 volatile struct gdb_exception e
;
790 i
->pspace
= current_program_space
;
791 VEC_safe_push (so_list_ptr
, current_program_space
->added_solibs
, i
);
793 TRY_CATCH (e
, RETURN_MASK_ERROR
)
795 /* Fill in the rest of the `struct so_list' node. */
796 if (!solib_map_sections (i
))
799 if (not_found_filename
== NULL
)
800 not_found_filename
= i
->so_original_name
;
805 exception_fprintf (gdb_stderr
, e
,
806 _("Error while mapping shared "
807 "library sections:\n"));
809 /* Notify any observer that the shared object has been
810 loaded now that we've added it to GDB's tables. */
811 observer_notify_solib_loaded (i
);
814 /* If a library was not found, issue an appropriate warning
815 message. We have to use a single call to warning in case the
816 front end does something special with warnings, e.g., pop up
817 a dialog box. It Would Be Nice if we could get a "warning: "
818 prefix on each line in the CLI front end, though - it doesn't
822 warning (_("Could not load shared library symbols for %s.\n"
823 "Do you need \"set solib-search-path\" "
824 "or \"set sysroot\"?"),
826 else if (not_found
> 1)
828 Could not load shared library symbols for %d libraries, e.g. %s.\n\
829 Use the \"info sharedlibrary\" command to see the complete listing.\n\
830 Do you need \"set solib-search-path\" or \"set sysroot\"?"),
831 not_found
, not_found_filename
);
836 /* Return non-zero if NAME is the libpthread shared library.
838 Uses a fairly simplistic heuristic approach where we check
839 the file name against "/libpthread". This can lead to false
840 positives, but this should be good enough in practice. */
843 libpthread_name_p (const char *name
)
845 return (strstr (name
, "/libpthread") != NULL
);
848 /* Return non-zero if SO is the libpthread shared library. */
851 libpthread_solib_p (struct so_list
*so
)
853 return libpthread_name_p (so
->so_name
);
856 /* Read in symbolic information for any shared objects whose names
857 match PATTERN. (If we've already read a shared object's symbol
858 info, leave it alone.) If PATTERN is zero, read them all.
860 If READSYMS is 0, defer reading symbolic information until later
861 but still do any needed low level processing.
863 FROM_TTY and TARGET are as described for update_solib_list, above. */
866 solib_add (char *pattern
, int from_tty
,
867 struct target_ops
*target
, int readsyms
)
871 current_program_space
->solib_add_generation
++;
875 char *re_err
= re_comp (pattern
);
878 error (_("Invalid regexp: %s"), re_err
);
881 update_solib_list (from_tty
, target
);
883 /* Walk the list of currently loaded shared libraries, and read
884 symbols for any that match the pattern --- or any whose symbols
885 aren't already loaded, if no pattern was given. */
888 int loaded_any_symbols
= 0;
890 SYMFILE_DEFER_BP_RESET
| (from_tty
? SYMFILE_VERBOSE
: 0);
892 for (gdb
= so_list_head
; gdb
; gdb
= gdb
->next
)
893 if (! pattern
|| re_exec (gdb
->so_name
))
895 /* Normally, we would read the symbols from that library
896 only if READSYMS is set. However, we're making a small
897 exception for the pthread library, because we sometimes
898 need the library symbols to be loaded in order to provide
899 thread support (x86-linux for instance). */
900 const int add_this_solib
=
901 (readsyms
|| libpthread_solib_p (gdb
));
906 if (gdb
->symbols_loaded
)
908 /* If no pattern was given, be quiet for shared
909 libraries we have already loaded. */
910 if (pattern
&& (from_tty
|| info_verbose
))
911 printf_unfiltered (_("Symbols already loaded for %s\n"),
914 else if (solib_read_symbols (gdb
, flags
))
915 loaded_any_symbols
= 1;
919 if (loaded_any_symbols
)
920 breakpoint_re_set ();
922 if (from_tty
&& pattern
&& ! any_matches
)
924 ("No loaded shared libraries match the pattern `%s'.\n", pattern
);
926 if (loaded_any_symbols
)
928 struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
930 /* Getting new symbols may change our opinion about what is
932 reinit_frame_cache ();
934 ops
->special_symbol_handling ();
939 /* Implement the "info sharedlibrary" command. Walk through the
940 shared library list and print information about each attached
941 library matching PATTERN. If PATTERN is elided, print them
945 info_sharedlibrary_command (char *pattern
, int from_tty
)
947 struct so_list
*so
= NULL
; /* link map state variable */
948 int so_missing_debug_info
= 0;
951 struct cleanup
*table_cleanup
;
952 struct gdbarch
*gdbarch
= target_gdbarch ();
953 struct ui_out
*uiout
= current_uiout
;
957 char *re_err
= re_comp (pattern
);
960 error (_("Invalid regexp: %s"), re_err
);
963 /* "0x", a little whitespace, and two hex digits per byte of pointers. */
964 addr_width
= 4 + (gdbarch_ptr_bit (gdbarch
) / 4);
966 update_solib_list (from_tty
, 0);
968 /* make_cleanup_ui_out_table_begin_end needs to know the number of
969 rows, so we need to make two passes over the libs. */
971 for (nr_libs
= 0, so
= so_list_head
; so
; so
= so
->next
)
975 if (pattern
&& ! re_exec (so
->so_name
))
982 make_cleanup_ui_out_table_begin_end (uiout
, 4, nr_libs
,
983 "SharedLibraryTable");
985 /* The "- 1" is because ui_out adds one space between columns. */
986 ui_out_table_header (uiout
, addr_width
- 1, ui_left
, "from", "From");
987 ui_out_table_header (uiout
, addr_width
- 1, ui_left
, "to", "To");
988 ui_out_table_header (uiout
, 12 - 1, ui_left
, "syms-read", "Syms Read");
989 ui_out_table_header (uiout
, 0, ui_noalign
,
990 "name", "Shared Object Library");
992 ui_out_table_body (uiout
);
994 for (so
= so_list_head
; so
; so
= so
->next
)
996 struct cleanup
*lib_cleanup
;
998 if (! so
->so_name
[0])
1000 if (pattern
&& ! re_exec (so
->so_name
))
1003 lib_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, "lib");
1005 if (so
->addr_high
!= 0)
1007 ui_out_field_core_addr (uiout
, "from", gdbarch
, so
->addr_low
);
1008 ui_out_field_core_addr (uiout
, "to", gdbarch
, so
->addr_high
);
1012 ui_out_field_skip (uiout
, "from");
1013 ui_out_field_skip (uiout
, "to");
1016 if (! ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1017 && so
->symbols_loaded
1018 && !objfile_has_symbols (so
->objfile
))
1020 so_missing_debug_info
= 1;
1021 ui_out_field_string (uiout
, "syms-read", "Yes (*)");
1024 ui_out_field_string (uiout
, "syms-read",
1025 so
->symbols_loaded
? "Yes" : "No");
1027 ui_out_field_string (uiout
, "name", so
->so_name
);
1029 ui_out_text (uiout
, "\n");
1031 do_cleanups (lib_cleanup
);
1034 do_cleanups (table_cleanup
);
1039 ui_out_message (uiout
, 0,
1040 _("No shared libraries matched.\n"));
1042 ui_out_message (uiout
, 0,
1043 _("No shared libraries loaded at this time.\n"));
1047 if (so_missing_debug_info
)
1048 ui_out_message (uiout
, 0,
1049 _("(*): Shared library is missing "
1050 "debugging information.\n"));
1054 /* Return 1 if ADDRESS lies within SOLIB. */
1057 solib_contains_address_p (const struct so_list
*const solib
,
1060 struct target_section
*p
;
1062 for (p
= solib
->sections
; p
< solib
->sections_end
; p
++)
1063 if (p
->addr
<= address
&& address
< p
->endaddr
)
1069 /* If ADDRESS is in a shared lib in program space PSPACE, return its
1072 Provides a hook for other gdb routines to discover whether or not a
1073 particular address is within the mapped address space of a shared
1076 For example, this routine is called at one point to disable
1077 breakpoints which are in shared libraries that are not currently
1081 solib_name_from_address (struct program_space
*pspace
, CORE_ADDR address
)
1083 struct so_list
*so
= NULL
;
1085 for (so
= pspace
->so_list
; so
; so
= so
->next
)
1086 if (solib_contains_address_p (so
, address
))
1087 return (so
->so_name
);
1092 /* Return whether the data starting at VADDR, size SIZE, must be kept
1093 in a core file for shared libraries loaded before "gcore" is used
1094 to be handled correctly when the core file is loaded. This only
1095 applies when the section would otherwise not be kept in the core
1096 file (in particular, for readonly sections). */
1099 solib_keep_data_in_core (CORE_ADDR vaddr
, unsigned long size
)
1101 struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1103 if (ops
->keep_data_in_core
)
1104 return ops
->keep_data_in_core (vaddr
, size
);
1109 /* Called by free_all_symtabs */
1114 struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1116 /* This function is expected to handle ELF shared libraries. It is
1117 also used on Solaris, which can run either ELF or a.out binaries
1118 (for compatibility with SunOS 4), both of which can use shared
1119 libraries. So we don't know whether we have an ELF executable or
1120 an a.out executable until the user chooses an executable file.
1122 ELF shared libraries don't get mapped into the address space
1123 until after the program starts, so we'd better not try to insert
1124 breakpoints in them immediately. We have to wait until the
1125 dynamic linker has loaded them; we'll hit a bp_shlib_event
1126 breakpoint (look for calls to create_solib_event_breakpoint) when
1129 SunOS shared libraries seem to be different --- they're present
1130 as soon as the process begins execution, so there's no need to
1131 put off inserting breakpoints. There's also nowhere to put a
1132 bp_shlib_event breakpoint, so if we put it off, we'll never get
1135 So: disable breakpoints only if we're using ELF shared libs. */
1136 if (exec_bfd
!= NULL
1137 && bfd_get_flavour (exec_bfd
) != bfd_target_aout_flavour
)
1138 disable_breakpoints_in_shlibs ();
1140 while (so_list_head
)
1142 struct so_list
*so
= so_list_head
;
1144 so_list_head
= so
->next
;
1145 observer_notify_solib_unloaded (so
);
1147 remove_target_sections (so
, so
->abfd
);
1151 ops
->clear_solib ();
1154 /* Shared library startup support. When GDB starts up the inferior,
1155 it nurses it along (through the shell) until it is ready to execute
1156 its first instruction. At this point, this function gets
1160 solib_create_inferior_hook (int from_tty
)
1162 struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1164 ops
->solib_create_inferior_hook (from_tty
);
1167 /* Check to see if an address is in the dynamic loader's dynamic
1168 symbol resolution code. Return 1 if so, 0 otherwise. */
1171 in_solib_dynsym_resolve_code (CORE_ADDR pc
)
1173 struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1175 return ops
->in_dynsym_resolve_code (pc
);
1178 /* Implements the "sharedlibrary" command. */
1181 sharedlibrary_command (char *args
, int from_tty
)
1184 solib_add (args
, from_tty
, (struct target_ops
*) 0, 1);
1187 /* Implements the command "nosharedlibrary", which discards symbols
1188 that have been auto-loaded from shared libraries. Symbols from
1189 shared libraries that were added by explicit request of the user
1190 are not discarded. Also called from remote.c. */
1193 no_shared_libraries (char *ignored
, int from_tty
)
1195 /* The order of the two routines below is important: clear_solib notifies
1196 the solib_unloaded observers, and some of these observers might need
1197 access to their associated objfiles. Therefore, we can not purge the
1198 solibs' objfiles before clear_solib has been called. */
1201 objfile_purge_solibs ();
1204 /* Reload shared libraries, but avoid reloading the same symbol file
1205 we already have loaded. */
1208 reload_shared_libraries_1 (int from_tty
)
1211 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1213 for (so
= so_list_head
; so
!= NULL
; so
= so
->next
)
1215 char *filename
, *found_pathname
= NULL
;
1217 int was_loaded
= so
->symbols_loaded
;
1219 SYMFILE_DEFER_BP_RESET
| (from_tty
? SYMFILE_VERBOSE
: 0);
1221 filename
= tilde_expand (so
->so_original_name
);
1222 make_cleanup (xfree
, filename
);
1223 abfd
= solib_bfd_open (filename
);
1226 found_pathname
= xstrdup (bfd_get_filename (abfd
));
1227 make_cleanup (xfree
, found_pathname
);
1228 gdb_bfd_unref (abfd
);
1231 /* If this shared library is no longer associated with its previous
1232 symbol file, close that. */
1233 if ((found_pathname
== NULL
&& was_loaded
)
1234 || (found_pathname
!= NULL
1235 && filename_cmp (found_pathname
, so
->so_name
) != 0))
1237 if (so
->objfile
&& ! (so
->objfile
->flags
& OBJF_USERLOADED
)
1238 && !solib_used (so
))
1239 free_objfile (so
->objfile
);
1240 remove_target_sections (so
, so
->abfd
);
1241 free_so_symbols (so
);
1244 /* If this shared library is now associated with a new symbol
1246 if (found_pathname
!= NULL
1248 || filename_cmp (found_pathname
, so
->so_name
) != 0))
1250 volatile struct gdb_exception e
;
1252 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1253 solib_map_sections (so
);
1256 exception_fprintf (gdb_stderr
, e
,
1257 _("Error while mapping "
1258 "shared library sections:\n"));
1259 else if (auto_solib_add
|| was_loaded
|| libpthread_solib_p (so
))
1260 solib_read_symbols (so
, flags
);
1264 do_cleanups (old_chain
);
1268 reload_shared_libraries (char *ignored
, int from_tty
,
1269 struct cmd_list_element
*e
)
1271 struct target_so_ops
*ops
;
1273 reload_shared_libraries_1 (from_tty
);
1275 ops
= solib_ops (target_gdbarch ());
1277 /* Creating inferior hooks here has two purposes. First, if we reload
1278 shared libraries then the address of solib breakpoint we've computed
1279 previously might be no longer valid. For example, if we forgot to set
1280 solib-absolute-prefix and are setting it right now, then the previous
1281 breakpoint address is plain wrong. Second, installing solib hooks
1282 also implicitly figures were ld.so is and loads symbols for it.
1283 Absent this call, if we've just connected to a target and set
1284 solib-absolute-prefix or solib-search-path, we'll lose all information
1286 if (target_has_execution
)
1288 /* Reset or free private data structures not associated with
1290 ops
->clear_solib ();
1292 /* Remove any previous solib event breakpoint. This is usually
1293 done in common code, at breakpoint_init_inferior time, but
1294 we're not really starting up the inferior here. */
1295 remove_solib_event_breakpoints ();
1297 #ifdef SOLIB_CREATE_INFERIOR_HOOK
1298 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid
));
1300 solib_create_inferior_hook (from_tty
);
1304 /* Sometimes the platform-specific hook loads initial shared
1305 libraries, and sometimes it doesn't. If it doesn't FROM_TTY will be
1306 incorrectly 0 but such solib targets should be fixed anyway. If we
1307 made all the inferior hook methods consistent, this call could be
1308 removed. Call it only after the solib target has been initialized by
1309 solib_create_inferior_hook. */
1311 solib_add (NULL
, 0, NULL
, auto_solib_add
);
1313 breakpoint_re_set ();
1315 /* We may have loaded or unloaded debug info for some (or all)
1316 shared libraries. However, frames may still reference them. For
1317 example, a frame's unwinder might still point at DWARF FDE
1318 structures that are now freed. Also, getting new symbols may
1319 change our opinion about what is frameless. */
1320 reinit_frame_cache ();
1322 ops
->special_symbol_handling ();
1326 show_auto_solib_add (struct ui_file
*file
, int from_tty
,
1327 struct cmd_list_element
*c
, const char *value
)
1329 fprintf_filtered (file
, _("Autoloading of shared library symbols is %s.\n"),
1334 /* Handler for library-specific lookup of global symbol NAME in OBJFILE. Call
1335 the library-specific handler if it is installed for the current target. */
1338 solib_global_lookup (const struct objfile
*objfile
,
1340 const domain_enum domain
)
1342 struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1344 if (ops
->lookup_lib_global_symbol
!= NULL
)
1345 return ops
->lookup_lib_global_symbol (objfile
, name
, domain
);
1349 /* Lookup the value for a specific symbol from dynamic symbol table. Look
1350 up symbol from ABFD. MATCH_SYM is a callback function to determine
1351 whether to pick up a symbol. DATA is the input of this callback
1352 function. Return NULL if symbol is not found. */
1355 gdb_bfd_lookup_symbol_from_symtab (bfd
*abfd
,
1356 int (*match_sym
) (asymbol
*, void *),
1359 long storage_needed
= bfd_get_symtab_upper_bound (abfd
);
1360 CORE_ADDR symaddr
= 0;
1362 if (storage_needed
> 0)
1366 asymbol
**symbol_table
= (asymbol
**) xmalloc (storage_needed
);
1367 struct cleanup
*back_to
= make_cleanup (xfree
, symbol_table
);
1368 unsigned int number_of_symbols
=
1369 bfd_canonicalize_symtab (abfd
, symbol_table
);
1371 for (i
= 0; i
< number_of_symbols
; i
++)
1373 asymbol
*sym
= *symbol_table
++;
1375 if (match_sym (sym
, data
))
1377 /* BFD symbols are section relative. */
1378 symaddr
= sym
->value
+ sym
->section
->vma
;
1382 do_cleanups (back_to
);
1388 /* Lookup the value for a specific symbol from symbol table. Look up symbol
1389 from ABFD. MATCH_SYM is a callback function to determine whether to pick
1390 up a symbol. DATA is the input of this callback function. Return NULL
1391 if symbol is not found. */
1394 bfd_lookup_symbol_from_dyn_symtab (bfd
*abfd
,
1395 int (*match_sym
) (asymbol
*, void *),
1398 long storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1399 CORE_ADDR symaddr
= 0;
1401 if (storage_needed
> 0)
1404 asymbol
**symbol_table
= (asymbol
**) xmalloc (storage_needed
);
1405 struct cleanup
*back_to
= make_cleanup (xfree
, symbol_table
);
1406 unsigned int number_of_symbols
=
1407 bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
1409 for (i
= 0; i
< number_of_symbols
; i
++)
1411 asymbol
*sym
= *symbol_table
++;
1413 if (match_sym (sym
, data
))
1415 /* BFD symbols are section relative. */
1416 symaddr
= sym
->value
+ sym
->section
->vma
;
1420 do_cleanups (back_to
);
1425 /* Lookup the value for a specific symbol from symbol table and dynamic
1426 symbol table. Look up symbol from ABFD. MATCH_SYM is a callback
1427 function to determine whether to pick up a symbol. DATA is the
1428 input of this callback function. Return NULL if symbol is not
1432 gdb_bfd_lookup_symbol (bfd
*abfd
,
1433 int (*match_sym
) (asymbol
*, void *),
1436 CORE_ADDR symaddr
= gdb_bfd_lookup_symbol_from_symtab (abfd
, match_sym
, data
);
1438 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
1439 have to check the dynamic string table too. */
1441 symaddr
= bfd_lookup_symbol_from_dyn_symtab (abfd
, match_sym
, data
);
1446 extern initialize_file_ftype _initialize_solib
; /* -Wmissing-prototypes */
1449 _initialize_solib (void)
1451 solib_data
= gdbarch_data_register_pre_init (solib_init
);
1453 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
1454 _("Load shared object library symbols for files matching REGEXP."));
1455 add_info ("sharedlibrary", info_sharedlibrary_command
,
1456 _("Status of loaded shared object libraries."));
1457 add_com ("nosharedlibrary", class_files
, no_shared_libraries
,
1458 _("Unload all shared object library symbols."));
1460 add_setshow_boolean_cmd ("auto-solib-add", class_support
,
1461 &auto_solib_add
, _("\
1462 Set autoloading of shared library symbols."), _("\
1463 Show autoloading of shared library symbols."), _("\
1464 If \"on\", symbols from all shared object libraries will be loaded\n\
1465 automatically when the inferior begins execution, when the dynamic linker\n\
1466 informs gdb that a new library has been loaded, or when attaching to the\n\
1467 inferior. Otherwise, symbols must be loaded manually, using \
1470 show_auto_solib_add
,
1471 &setlist
, &showlist
);
1473 add_setshow_filename_cmd ("sysroot", class_support
,
1475 Set an alternate system root."), _("\
1476 Show the current system root."), _("\
1477 The system root is used to load absolute shared library symbol files.\n\
1478 For other (relative) files, you can add directories using\n\
1479 `set solib-search-path'."),
1480 reload_shared_libraries
,
1482 &setlist
, &showlist
);
1484 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support
, 0,
1486 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support
, 0,
1489 add_setshow_optional_filename_cmd ("solib-search-path", class_support
,
1490 &solib_search_path
, _("\
1491 Set the search path for loading non-absolute shared library symbol files."),
1493 Show the search path for loading non-absolute shared library symbol files."),
1495 This takes precedence over the environment variables \
1496 PATH and LD_LIBRARY_PATH."),
1497 reload_shared_libraries
,
1498 show_solib_search_path
,
1499 &setlist
, &showlist
);