1 /* Handle shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 1990-2014 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>
28 #include "exceptions.h"
33 #include "gdb_regex.h"
38 #include "completer.h"
39 #include "filenames.h" /* for DOSish file names */
43 #include "readline/readline.h"
47 #include "filesystem.h"
49 #include "filestuff.h"
51 /* Architecture-specific operations. */
53 /* Per-architecture data key. */
54 static struct gdbarch_data *solib_data;
57 solib_init (struct obstack *obstack)
59 struct target_so_ops **ops;
61 ops = OBSTACK_ZALLOC (obstack, struct target_so_ops *);
62 *ops = current_target_so_ops;
66 static const struct target_so_ops *
67 solib_ops (struct gdbarch *gdbarch)
69 const struct target_so_ops **ops = gdbarch_data (gdbarch, solib_data);
74 /* Set the solib operations for GDBARCH to NEW_OPS. */
77 set_solib_ops (struct gdbarch *gdbarch, const struct target_so_ops *new_ops)
79 const struct target_so_ops **ops = gdbarch_data (gdbarch, solib_data);
85 /* external data declarations */
87 /* FIXME: gdbarch needs to control this variable, or else every
88 configuration needs to call set_solib_ops. */
89 struct target_so_ops *current_target_so_ops;
91 /* List of known shared objects */
92 #define so_list_head current_program_space->so_list
94 /* Local function prototypes */
96 /* If non-empty, this is a search path for loading non-absolute shared library
97 symbol files. This takes precedence over the environment variables PATH
98 and LD_LIBRARY_PATH. */
99 static char *solib_search_path = NULL;
101 show_solib_search_path (struct ui_file *file, int from_tty,
102 struct cmd_list_element *c, const char *value)
104 fprintf_filtered (file, _("The search path for loading non-absolute "
105 "shared library symbol files is %s.\n"),
109 /* Same as HAVE_DOS_BASED_FILE_SYSTEM, but useable as an rvalue. */
110 #if (HAVE_DOS_BASED_FILE_SYSTEM)
111 # define DOS_BASED_FILE_SYSTEM 1
113 # define DOS_BASED_FILE_SYSTEM 0
116 /* Returns the full pathname of the shared library file, or NULL if
117 not found. (The pathname is malloc'ed; it needs to be freed by the
118 caller.) *FD is set to either -1 or an open file handle for the
121 Global variable GDB_SYSROOT is used as a prefix directory
122 to search for shared libraries if they have an absolute path.
124 Global variable SOLIB_SEARCH_PATH is used as a prefix directory
125 (or set of directories, as in LD_LIBRARY_PATH) to search for all
126 shared libraries if not found in GDB_SYSROOT.
129 * If there is a gdb_sysroot and path is absolute:
130 * Search for gdb_sysroot/path.
132 * Look for it literally (unmodified).
133 * Look in SOLIB_SEARCH_PATH.
134 * If available, use target defined search function.
135 * If gdb_sysroot is NOT set, perform the following two searches:
136 * Look in inferior's $PATH.
137 * Look in inferior's $LD_LIBRARY_PATH.
139 * The last check avoids doing this search when targetting remote
140 * machines since gdb_sysroot will almost always be set.
144 solib_find (char *in_pathname, int *fd)
146 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
148 char *temp_pathname = NULL;
149 int gdb_sysroot_is_empty;
150 const char *solib_symbols_extension
151 = gdbarch_solib_symbols_extension (target_gdbarch ());
152 const char *fskind = effective_target_file_system_kind ();
153 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
154 char *sysroot = NULL;
156 /* If solib_symbols_extension is set, replace the file's
158 if (solib_symbols_extension)
160 char *p = in_pathname + strlen (in_pathname);
162 while (p > in_pathname && *p != '.')
169 new_pathname = alloca (p - in_pathname + 1
170 + strlen (solib_symbols_extension) + 1);
171 memcpy (new_pathname, in_pathname, p - in_pathname + 1);
172 strcpy (new_pathname + (p - in_pathname) + 1,
173 solib_symbols_extension);
175 in_pathname = new_pathname;
179 gdb_sysroot_is_empty = (gdb_sysroot == NULL || *gdb_sysroot == 0);
181 if (!gdb_sysroot_is_empty)
183 int prefix_len = strlen (gdb_sysroot);
185 /* Remove trailing slashes from absolute prefix. */
186 while (prefix_len > 0
187 && IS_DIR_SEPARATOR (gdb_sysroot[prefix_len - 1]))
190 sysroot = savestring (gdb_sysroot, prefix_len);
191 make_cleanup (xfree, sysroot);
194 /* If we're on a non-DOS-based system, backslashes won't be
195 understood as directory separator, so, convert them to forward
196 slashes, iff we're supposed to handle DOS-based file system
197 semantics for target paths. */
198 if (!DOS_BASED_FILE_SYSTEM && fskind == file_system_kind_dos_based)
202 /* Avoid clobbering our input. */
203 p = alloca (strlen (in_pathname) + 1);
204 strcpy (p, in_pathname);
214 /* Note, we're interested in IS_TARGET_ABSOLUTE_PATH, not
215 IS_ABSOLUTE_PATH. The latter is for host paths only, while
216 IN_PATHNAME is a target path. For example, if we're supposed to
217 be handling DOS-like semantics we want to consider a
218 'c:/foo/bar.dll' path as an absolute path, even on a Unix box.
219 With such a path, before giving up on the sysroot, we'll try:
221 1st attempt, c:/foo/bar.dll ==> /sysroot/c:/foo/bar.dll
222 2nd attempt, c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll
223 3rd attempt, c:/foo/bar.dll ==> /sysroot/foo/bar.dll
226 if (!IS_TARGET_ABSOLUTE_PATH (fskind, in_pathname) || gdb_sysroot_is_empty)
227 temp_pathname = xstrdup (in_pathname);
230 int need_dir_separator;
232 /* Concatenate the sysroot and the target reported filename. We
233 may need to glue them with a directory separator. Cases to
236 | sysroot | separator | in_pathname |
237 |-----------------+-----------+----------------|
238 | /some/dir | / | c:/foo/bar.dll |
239 | /some/dir | | /foo/bar.dll |
240 | remote: | | c:/foo/bar.dll |
241 | remote: | | /foo/bar.dll |
242 | remote:some/dir | / | c:/foo/bar.dll |
243 | remote:some/dir | | /foo/bar.dll |
245 IOW, we don't need to add a separator if IN_PATHNAME already
246 has one, or when the the sysroot is exactly "remote:".
247 There's no need to check for drive spec explicitly, as we only
248 get here if IN_PATHNAME is considered an absolute path. */
249 need_dir_separator = !(IS_DIR_SEPARATOR (in_pathname[0])
250 || strcmp (REMOTE_SYSROOT_PREFIX, sysroot) == 0);
252 /* Cat the prefixed pathname together. */
253 temp_pathname = concat (sysroot,
254 need_dir_separator ? SLASH_STRING : "",
255 in_pathname, (char *) NULL);
258 /* Handle remote files. */
259 if (remote_filename_p (temp_pathname))
262 do_cleanups (old_chain);
263 return temp_pathname;
266 /* Now see if we can open it. */
267 found_file = gdb_open_cloexec (temp_pathname, O_RDONLY | O_BINARY, 0);
269 xfree (temp_pathname);
271 /* If the search in gdb_sysroot failed, and the path name has a
272 drive spec (e.g, c:/foo), try stripping ':' from the drive spec,
273 and retrying in the sysroot:
274 c:/foo/bar.dll ==> /sysroot/c/foo/bar.dll. */
277 && !gdb_sysroot_is_empty
278 && HAS_TARGET_DRIVE_SPEC (fskind, in_pathname))
280 int need_dir_separator = !IS_DIR_SEPARATOR (in_pathname[2]);
281 char *drive = savestring (in_pathname, 1);
283 temp_pathname = concat (sysroot,
286 need_dir_separator ? SLASH_STRING : "",
287 in_pathname + 2, (char *) NULL);
290 found_file = gdb_open_cloexec (temp_pathname, O_RDONLY | O_BINARY, 0);
293 xfree (temp_pathname);
295 /* If the search in gdb_sysroot still failed, try fully
296 stripping the drive spec, and trying once more in the
297 sysroot before giving up.
299 c:/foo/bar.dll ==> /sysroot/foo/bar.dll. */
301 temp_pathname = concat (sysroot,
302 need_dir_separator ? SLASH_STRING : "",
303 in_pathname + 2, (char *) NULL);
305 found_file = gdb_open_cloexec (temp_pathname, O_RDONLY | O_BINARY, 0);
307 xfree (temp_pathname);
311 do_cleanups (old_chain);
313 /* We try to find the library in various ways. After each attempt,
314 either found_file >= 0 and temp_pathname is a malloc'd string, or
315 found_file < 0 and temp_pathname does not point to storage that
316 needs to be freed. */
319 temp_pathname = NULL;
321 /* If the search in gdb_sysroot failed, and the path name is
322 absolute at this point, make it relative. (openp will try and open the
323 file according to its absolute path otherwise, which is not what we want.)
324 Affects subsequent searches for this solib. */
325 if (found_file < 0 && IS_TARGET_ABSOLUTE_PATH (fskind, in_pathname))
327 /* First, get rid of any drive letters etc. */
328 while (!IS_TARGET_DIR_SEPARATOR (fskind, *in_pathname))
331 /* Next, get rid of all leading dir separators. */
332 while (IS_TARGET_DIR_SEPARATOR (fskind, *in_pathname))
336 /* If not found, search the solib_search_path (if any). */
337 if (found_file < 0 && solib_search_path != NULL)
338 found_file = openp (solib_search_path,
339 OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH,
340 in_pathname, O_RDONLY | O_BINARY, &temp_pathname);
342 /* If not found, next search the solib_search_path (if any) for the basename
343 only (ignoring the path). This is to allow reading solibs from a path
344 that differs from the opened path. */
345 if (found_file < 0 && solib_search_path != NULL)
346 found_file = openp (solib_search_path,
347 OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH,
348 target_lbasename (fskind, in_pathname),
349 O_RDONLY | O_BINARY, &temp_pathname);
351 /* If not found, try to use target supplied solib search method. */
352 if (found_file < 0 && ops->find_and_open_solib)
353 found_file = ops->find_and_open_solib (in_pathname, O_RDONLY | O_BINARY,
356 /* If not found, next search the inferior's $PATH environment variable. */
357 if (found_file < 0 && gdb_sysroot_is_empty)
358 found_file = openp (get_in_environ (current_inferior ()->environment,
360 OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH, in_pathname,
361 O_RDONLY | O_BINARY, &temp_pathname);
363 /* If not found, next search the inferior's $LD_LIBRARY_PATH
364 environment variable. */
365 if (found_file < 0 && gdb_sysroot_is_empty)
366 found_file = openp (get_in_environ (current_inferior ()->environment,
368 OPF_TRY_CWD_FIRST | OPF_RETURN_REALPATH, in_pathname,
369 O_RDONLY | O_BINARY, &temp_pathname);
372 return temp_pathname;
375 /* Open and return a BFD for the shared library PATHNAME. If FD is not -1,
376 it is used as file handle to open the file. Throws an error if the file
377 could not be opened. Handles both local and remote file access.
379 PATHNAME must be malloc'ed by the caller. It will be freed by this
380 function. If unsuccessful, the FD will be closed (unless FD was
384 solib_bfd_fopen (char *pathname, int fd)
388 if (remote_filename_p (pathname))
390 gdb_assert (fd == -1);
391 abfd = remote_bfd_open (pathname, gnutarget);
395 abfd = gdb_bfd_open (pathname, gnutarget, fd);
398 bfd_set_cacheable (abfd, 1);
403 make_cleanup (xfree, pathname);
404 error (_("Could not open `%s' as an executable file: %s"),
405 pathname, bfd_errmsg (bfd_get_error ()));
413 /* Find shared library PATHNAME and open a BFD for it. */
416 solib_bfd_open (char *pathname)
418 char *found_pathname;
421 const struct bfd_arch_info *b;
423 /* Search for shared library file. */
424 found_pathname = solib_find (pathname, &found_file);
425 if (found_pathname == NULL)
427 /* Return failure if the file could not be found, so that we can
428 accumulate messages about missing libraries. */
432 perror_with_name (pathname);
435 /* Open bfd for shared library. */
436 abfd = solib_bfd_fopen (found_pathname, found_file);
438 /* Check bfd format. */
439 if (!bfd_check_format (abfd, bfd_object))
441 make_cleanup_bfd_unref (abfd);
442 error (_("`%s': not in executable format: %s"),
443 bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
446 /* Check bfd arch. */
447 b = gdbarch_bfd_arch_info (target_gdbarch ());
448 if (!b->compatible (b, bfd_get_arch_info (abfd)))
449 warning (_("`%s': Shared library architecture %s is not compatible "
450 "with target architecture %s."), bfd_get_filename (abfd),
451 bfd_get_arch_info (abfd)->printable_name, b->printable_name);
456 /* Given a pointer to one of the shared objects in our list of mapped
457 objects, use the recorded name to open a bfd descriptor for the
458 object, build a section table, relocate all the section addresses
459 by the base address at which the shared object was mapped, and then
460 add the sections to the target's section table.
462 FIXME: In most (all?) cases the shared object file name recorded in
463 the dynamic linkage tables will be a fully qualified pathname. For
464 cases where it isn't, do we really mimic the systems search
465 mechanism correctly in the below code (particularly the tilde
466 expansion stuff?). */
469 solib_map_sections (struct so_list *so)
471 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
473 struct target_section *p;
474 struct cleanup *old_chain;
477 filename = tilde_expand (so->so_name);
478 old_chain = make_cleanup (xfree, filename);
479 abfd = ops->bfd_open (filename);
480 do_cleanups (old_chain);
485 /* Leave bfd open, core_xfer_memory and "info files" need it. */
488 /* Copy the full path name into so_name, allowing symbol_file_add
489 to find it later. This also affects the =library-loaded GDB/MI
490 event, and in particular the part of that notification providing
491 the library's host-side path. If we let the target dictate
492 that objfile's path, and the target is different from the host,
493 GDB/MI will not provide the correct host-side path. */
494 if (strlen (bfd_get_filename (abfd)) >= SO_NAME_MAX_PATH_SIZE)
495 error (_("Shared library file name is too long."));
496 strcpy (so->so_name, bfd_get_filename (abfd));
498 if (build_section_table (abfd, &so->sections, &so->sections_end))
500 error (_("Can't find the file sections in `%s': %s"),
501 bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
504 for (p = so->sections; p < so->sections_end; p++)
506 /* Relocate the section binding addresses as recorded in the shared
507 object's file by the base address to which the object was actually
509 ops->relocate_section_addresses (so, p);
511 /* If the target didn't provide information about the address
512 range of the shared object, assume we want the location of
513 the .text section. */
514 if (so->addr_low == 0 && so->addr_high == 0
515 && strcmp (p->the_bfd_section->name, ".text") == 0)
517 so->addr_low = p->addr;
518 so->addr_high = p->endaddr;
522 /* Add the shared object's sections to the current set of file
523 section tables. Do this immediately after mapping the object so
524 that later nodes in the list can query this object, as is needed
526 add_target_sections (so, so->sections, so->sections_end);
531 /* Free symbol-file related contents of SO and reset for possible reloading
532 of SO. If we have opened a BFD for SO, close it. If we have placed SO's
533 sections in some target's section table, the caller is responsible for
536 This function doesn't mess with objfiles at all. If there is an
537 objfile associated with SO that needs to be removed, the caller is
538 responsible for taking care of that. */
541 clear_so (struct so_list *so)
543 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
547 xfree (so->sections);
548 so->sections = so->sections_end = NULL;
551 gdb_bfd_unref (so->abfd);
554 /* Our caller closed the objfile, possibly via objfile_purge_solibs. */
555 so->symbols_loaded = 0;
558 so->addr_low = so->addr_high = 0;
560 /* Restore the target-supplied file name. SO_NAME may be the path
561 of the symbol file. */
562 strcpy (so->so_name, so->so_original_name);
564 /* Do the same for target-specific data. */
565 if (ops->clear_so != NULL)
569 /* Free the storage associated with the `struct so_list' object SO.
570 If we have opened a BFD for SO, close it.
572 The caller is responsible for removing SO from whatever list it is
573 a member of. If we have placed SO's sections in some target's
574 section table, the caller is responsible for removing them.
576 This function doesn't mess with objfiles at all. If there is an
577 objfile associated with SO that needs to be removed, the caller is
578 responsible for taking care of that. */
581 free_so (struct so_list *so)
583 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
592 /* Return address of first so_list entry in master shared object list. */
594 master_so_list (void)
599 /* Read in symbols for shared object SO. If SYMFILE_VERBOSE is set in FLAGS,
600 be chatty about it. Return non-zero if any symbols were actually
604 solib_read_symbols (struct so_list *so, int flags)
606 const int from_tty = flags & SYMFILE_VERBOSE;
608 if (so->symbols_loaded)
610 /* If needed, we've already warned in our caller. */
612 else if (so->abfd == NULL)
614 /* We've already warned about this library, when trying to open
619 volatile struct gdb_exception e;
621 flags |= current_inferior ()->symfile_flags;
623 TRY_CATCH (e, RETURN_MASK_ERROR)
625 struct section_addr_info *sap;
627 /* Have we already loaded this shared object? */
628 ALL_OBJFILES (so->objfile)
630 if (filename_cmp (objfile_name (so->objfile), so->so_name) == 0
631 && so->objfile->addr_low == so->addr_low)
634 if (so->objfile != NULL)
637 sap = build_section_addr_info_from_section_table (so->sections,
639 so->objfile = symbol_file_add_from_bfd (so->abfd, so->so_name,
640 flags, sap, OBJF_SHARED,
642 so->objfile->addr_low = so->addr_low;
643 free_section_addr_info (sap);
647 exception_fprintf (gdb_stderr, e, _("Error while reading shared"
648 " library symbols for %s:\n"),
652 if (print_symbol_loading_p (from_tty, 0, 1))
653 printf_unfiltered (_("Loaded symbols for %s\n"), so->so_name);
654 so->symbols_loaded = 1;
662 /* Return 1 if KNOWN->objfile is used by any other so_list object in the
663 SO_LIST_HEAD list. Return 0 otherwise. */
666 solib_used (const struct so_list *const known)
668 const struct so_list *pivot;
670 for (pivot = so_list_head; pivot != NULL; pivot = pivot->next)
671 if (pivot != known && pivot->objfile == known->objfile)
676 /* Synchronize GDB's shared object list with inferior's.
678 Extract the list of currently loaded shared objects from the
679 inferior, and compare it with the list of shared objects currently
680 in GDB's so_list_head list. Edit so_list_head to bring it in sync
681 with the inferior's new list.
683 If we notice that the inferior has unloaded some shared objects,
684 free any symbolic info GDB had read about those shared objects.
686 Don't load symbolic info for any new shared objects; just add them
687 to the list, and leave their symbols_loaded flag clear.
689 If FROM_TTY is non-null, feel free to print messages about what
692 If TARGET is non-null, add the sections of all new shared objects
693 to TARGET's section table. Note that this doesn't remove any
694 sections for shared objects that have been unloaded, and it
695 doesn't check to see if the new shared objects are already present in
696 the section table. But we only use this for core files and
697 processes we've just attached to, so that's okay. */
700 update_solib_list (int from_tty, struct target_ops *target)
702 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
703 struct so_list *inferior = ops->current_sos();
704 struct so_list *gdb, **gdb_link;
706 /* We can reach here due to changing solib-search-path or the
707 sysroot, before having any inferior. */
708 if (target_has_execution && !ptid_equal (inferior_ptid, null_ptid))
710 struct inferior *inf = current_inferior ();
712 /* If we are attaching to a running process for which we
713 have not opened a symbol file, we may be able to get its
715 if (inf->attach_flag && symfile_objfile == NULL)
716 catch_errors (ops->open_symbol_file_object, &from_tty,
717 "Error reading attached process's symbol file.\n",
721 /* GDB and the inferior's dynamic linker each maintain their own
722 list of currently loaded shared objects; we want to bring the
723 former in sync with the latter. Scan both lists, seeing which
724 shared objects appear where. There are three cases:
726 - A shared object appears on both lists. This means that GDB
727 knows about it already, and it's still loaded in the inferior.
728 Nothing needs to happen.
730 - A shared object appears only on GDB's list. This means that
731 the inferior has unloaded it. We should remove the shared
732 object from GDB's tables.
734 - A shared object appears only on the inferior's list. This
735 means that it's just been loaded. We should add it to GDB's
738 So we walk GDB's list, checking each entry to see if it appears
739 in the inferior's list too. If it does, no action is needed, and
740 we remove it from the inferior's list. If it doesn't, the
741 inferior has unloaded it, and we remove it from GDB's list. By
742 the time we're done walking GDB's list, the inferior's list
743 contains only the new shared objects, which we then add. */
746 gdb_link = &so_list_head;
749 struct so_list *i = inferior;
750 struct so_list **i_link = &inferior;
752 /* Check to see whether the shared object *gdb also appears in
753 the inferior's current list. */
758 if (ops->same (gdb, i))
763 if (! filename_cmp (gdb->so_original_name, i->so_original_name))
771 /* If the shared object appears on the inferior's list too, then
772 it's still loaded, so we don't need to do anything. Delete
773 it from the inferior's list, and leave it on GDB's list. */
778 gdb_link = &gdb->next;
782 /* If it's not on the inferior's list, remove it from GDB's tables. */
785 /* Notify any observer that the shared object has been
786 unloaded before we remove it from GDB's tables. */
787 observer_notify_solib_unloaded (gdb);
789 VEC_safe_push (char_ptr, current_program_space->deleted_solibs,
790 xstrdup (gdb->so_name));
792 *gdb_link = gdb->next;
794 /* Unless the user loaded it explicitly, free SO's objfile. */
795 if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED)
796 && !solib_used (gdb))
797 free_objfile (gdb->objfile);
799 /* Some targets' section tables might be referring to
800 sections from so->abfd; remove them. */
801 remove_target_sections (gdb);
808 /* Now the inferior's list contains only shared objects that don't
809 appear in GDB's list --- those that are newly loaded. Add them
810 to GDB's shared object list. */
814 const char *not_found_filename = NULL;
818 /* Add the new shared objects to GDB's list. */
819 *gdb_link = inferior;
821 /* Fill in the rest of each of the `struct so_list' nodes. */
822 for (i = inferior; i; i = i->next)
824 volatile struct gdb_exception e;
826 i->pspace = current_program_space;
827 VEC_safe_push (so_list_ptr, current_program_space->added_solibs, i);
829 TRY_CATCH (e, RETURN_MASK_ERROR)
831 /* Fill in the rest of the `struct so_list' node. */
832 if (!solib_map_sections (i))
835 if (not_found_filename == NULL)
836 not_found_filename = i->so_original_name;
841 exception_fprintf (gdb_stderr, e,
842 _("Error while mapping shared "
843 "library sections:\n"));
845 /* Notify any observer that the shared object has been
846 loaded now that we've added it to GDB's tables. */
847 observer_notify_solib_loaded (i);
850 /* If a library was not found, issue an appropriate warning
851 message. We have to use a single call to warning in case the
852 front end does something special with warnings, e.g., pop up
853 a dialog box. It Would Be Nice if we could get a "warning: "
854 prefix on each line in the CLI front end, though - it doesn't
858 warning (_("Could not load shared library symbols for %s.\n"
859 "Do you need \"set solib-search-path\" "
860 "or \"set sysroot\"?"),
862 else if (not_found > 1)
864 Could not load shared library symbols for %d libraries, e.g. %s.\n\
865 Use the \"info sharedlibrary\" command to see the complete listing.\n\
866 Do you need \"set solib-search-path\" or \"set sysroot\"?"),
867 not_found, not_found_filename);
872 /* Return non-zero if NAME is the libpthread shared library.
874 Uses a fairly simplistic heuristic approach where we check
875 the file name against "/libpthread". This can lead to false
876 positives, but this should be good enough in practice. */
879 libpthread_name_p (const char *name)
881 return (strstr (name, "/libpthread") != NULL);
884 /* Return non-zero if SO is the libpthread shared library. */
887 libpthread_solib_p (struct so_list *so)
889 return libpthread_name_p (so->so_name);
892 /* Read in symbolic information for any shared objects whose names
893 match PATTERN. (If we've already read a shared object's symbol
894 info, leave it alone.) If PATTERN is zero, read them all.
896 If READSYMS is 0, defer reading symbolic information until later
897 but still do any needed low level processing.
899 FROM_TTY and TARGET are as described for update_solib_list, above. */
902 solib_add (const char *pattern, int from_tty,
903 struct target_ops *target, int readsyms)
907 if (print_symbol_loading_p (from_tty, 0, 0))
911 printf_unfiltered (_("Loading symbols for shared libraries: %s\n"),
915 printf_unfiltered (_("Loading symbols for shared libraries.\n"));
918 current_program_space->solib_add_generation++;
922 char *re_err = re_comp (pattern);
925 error (_("Invalid regexp: %s"), re_err);
928 update_solib_list (from_tty, target);
930 /* Walk the list of currently loaded shared libraries, and read
931 symbols for any that match the pattern --- or any whose symbols
932 aren't already loaded, if no pattern was given. */
935 int loaded_any_symbols = 0;
937 SYMFILE_DEFER_BP_RESET | (from_tty ? SYMFILE_VERBOSE : 0);
939 for (gdb = so_list_head; gdb; gdb = gdb->next)
940 if (! pattern || re_exec (gdb->so_name))
942 /* Normally, we would read the symbols from that library
943 only if READSYMS is set. However, we're making a small
944 exception for the pthread library, because we sometimes
945 need the library symbols to be loaded in order to provide
946 thread support (x86-linux for instance). */
947 const int add_this_solib =
948 (readsyms || libpthread_solib_p (gdb));
953 if (gdb->symbols_loaded)
955 /* If no pattern was given, be quiet for shared
956 libraries we have already loaded. */
957 if (pattern && (from_tty || info_verbose))
958 printf_unfiltered (_("Symbols already loaded for %s\n"),
961 else if (solib_read_symbols (gdb, flags))
962 loaded_any_symbols = 1;
966 if (loaded_any_symbols)
967 breakpoint_re_set ();
969 if (from_tty && pattern && ! any_matches)
971 ("No loaded shared libraries match the pattern `%s'.\n", pattern);
973 if (loaded_any_symbols)
975 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
977 /* Getting new symbols may change our opinion about what is
979 reinit_frame_cache ();
981 ops->special_symbol_handling ();
986 /* Implement the "info sharedlibrary" command. Walk through the
987 shared library list and print information about each attached
988 library matching PATTERN. If PATTERN is elided, print them
992 info_sharedlibrary_command (char *pattern, int from_tty)
994 struct so_list *so = NULL; /* link map state variable */
995 int so_missing_debug_info = 0;
998 struct cleanup *table_cleanup;
999 struct gdbarch *gdbarch = target_gdbarch ();
1000 struct ui_out *uiout = current_uiout;
1004 char *re_err = re_comp (pattern);
1007 error (_("Invalid regexp: %s"), re_err);
1010 /* "0x", a little whitespace, and two hex digits per byte of pointers. */
1011 addr_width = 4 + (gdbarch_ptr_bit (gdbarch) / 4);
1013 update_solib_list (from_tty, 0);
1015 /* make_cleanup_ui_out_table_begin_end needs to know the number of
1016 rows, so we need to make two passes over the libs. */
1018 for (nr_libs = 0, so = so_list_head; so; so = so->next)
1022 if (pattern && ! re_exec (so->so_name))
1029 make_cleanup_ui_out_table_begin_end (uiout, 4, nr_libs,
1030 "SharedLibraryTable");
1032 /* The "- 1" is because ui_out adds one space between columns. */
1033 ui_out_table_header (uiout, addr_width - 1, ui_left, "from", "From");
1034 ui_out_table_header (uiout, addr_width - 1, ui_left, "to", "To");
1035 ui_out_table_header (uiout, 12 - 1, ui_left, "syms-read", "Syms Read");
1036 ui_out_table_header (uiout, 0, ui_noalign,
1037 "name", "Shared Object Library");
1039 ui_out_table_body (uiout);
1041 for (so = so_list_head; so; so = so->next)
1043 struct cleanup *lib_cleanup;
1045 if (! so->so_name[0])
1047 if (pattern && ! re_exec (so->so_name))
1050 lib_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, "lib");
1052 if (so->addr_high != 0)
1054 ui_out_field_core_addr (uiout, "from", gdbarch, so->addr_low);
1055 ui_out_field_core_addr (uiout, "to", gdbarch, so->addr_high);
1059 ui_out_field_skip (uiout, "from");
1060 ui_out_field_skip (uiout, "to");
1063 if (! ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1064 && so->symbols_loaded
1065 && !objfile_has_symbols (so->objfile))
1067 so_missing_debug_info = 1;
1068 ui_out_field_string (uiout, "syms-read", "Yes (*)");
1071 ui_out_field_string (uiout, "syms-read",
1072 so->symbols_loaded ? "Yes" : "No");
1074 ui_out_field_string (uiout, "name", so->so_name);
1076 ui_out_text (uiout, "\n");
1078 do_cleanups (lib_cleanup);
1081 do_cleanups (table_cleanup);
1086 ui_out_message (uiout, 0,
1087 _("No shared libraries matched.\n"));
1089 ui_out_message (uiout, 0,
1090 _("No shared libraries loaded at this time.\n"));
1094 if (so_missing_debug_info)
1095 ui_out_message (uiout, 0,
1096 _("(*): Shared library is missing "
1097 "debugging information.\n"));
1101 /* Return 1 if ADDRESS lies within SOLIB. */
1104 solib_contains_address_p (const struct so_list *const solib,
1107 struct target_section *p;
1109 for (p = solib->sections; p < solib->sections_end; p++)
1110 if (p->addr <= address && address < p->endaddr)
1116 /* If ADDRESS is in a shared lib in program space PSPACE, return its
1119 Provides a hook for other gdb routines to discover whether or not a
1120 particular address is within the mapped address space of a shared
1123 For example, this routine is called at one point to disable
1124 breakpoints which are in shared libraries that are not currently
1128 solib_name_from_address (struct program_space *pspace, CORE_ADDR address)
1130 struct so_list *so = NULL;
1132 for (so = pspace->so_list; so; so = so->next)
1133 if (solib_contains_address_p (so, address))
1134 return (so->so_name);
1139 /* Return whether the data starting at VADDR, size SIZE, must be kept
1140 in a core file for shared libraries loaded before "gcore" is used
1141 to be handled correctly when the core file is loaded. This only
1142 applies when the section would otherwise not be kept in the core
1143 file (in particular, for readonly sections). */
1146 solib_keep_data_in_core (CORE_ADDR vaddr, unsigned long size)
1148 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1150 if (ops->keep_data_in_core)
1151 return ops->keep_data_in_core (vaddr, size);
1156 /* Called by free_all_symtabs */
1161 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1163 /* This function is expected to handle ELF shared libraries. It is
1164 also used on Solaris, which can run either ELF or a.out binaries
1165 (for compatibility with SunOS 4), both of which can use shared
1166 libraries. So we don't know whether we have an ELF executable or
1167 an a.out executable until the user chooses an executable file.
1169 ELF shared libraries don't get mapped into the address space
1170 until after the program starts, so we'd better not try to insert
1171 breakpoints in them immediately. We have to wait until the
1172 dynamic linker has loaded them; we'll hit a bp_shlib_event
1173 breakpoint (look for calls to create_solib_event_breakpoint) when
1176 SunOS shared libraries seem to be different --- they're present
1177 as soon as the process begins execution, so there's no need to
1178 put off inserting breakpoints. There's also nowhere to put a
1179 bp_shlib_event breakpoint, so if we put it off, we'll never get
1182 So: disable breakpoints only if we're using ELF shared libs. */
1183 if (exec_bfd != NULL
1184 && bfd_get_flavour (exec_bfd) != bfd_target_aout_flavour)
1185 disable_breakpoints_in_shlibs ();
1187 while (so_list_head)
1189 struct so_list *so = so_list_head;
1191 so_list_head = so->next;
1192 observer_notify_solib_unloaded (so);
1193 remove_target_sections (so);
1197 ops->clear_solib ();
1200 /* Shared library startup support. When GDB starts up the inferior,
1201 it nurses it along (through the shell) until it is ready to execute
1202 its first instruction. At this point, this function gets
1206 solib_create_inferior_hook (int from_tty)
1208 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1210 ops->solib_create_inferior_hook (from_tty);
1213 /* Check to see if an address is in the dynamic loader's dynamic
1214 symbol resolution code. Return 1 if so, 0 otherwise. */
1217 in_solib_dynsym_resolve_code (CORE_ADDR pc)
1219 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1221 return ops->in_dynsym_resolve_code (pc);
1224 /* Implements the "sharedlibrary" command. */
1227 sharedlibrary_command (char *args, int from_tty)
1230 solib_add (args, from_tty, (struct target_ops *) 0, 1);
1233 /* Implements the command "nosharedlibrary", which discards symbols
1234 that have been auto-loaded from shared libraries. Symbols from
1235 shared libraries that were added by explicit request of the user
1236 are not discarded. Also called from remote.c. */
1239 no_shared_libraries (char *ignored, int from_tty)
1241 /* The order of the two routines below is important: clear_solib notifies
1242 the solib_unloaded observers, and some of these observers might need
1243 access to their associated objfiles. Therefore, we can not purge the
1244 solibs' objfiles before clear_solib has been called. */
1247 objfile_purge_solibs ();
1253 update_solib_breakpoints (void)
1255 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1257 if (ops->update_breakpoints != NULL)
1258 ops->update_breakpoints ();
1264 handle_solib_event (void)
1266 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1268 if (ops->handle_event != NULL)
1269 ops->handle_event ();
1271 clear_program_space_solib_cache (current_inferior ()->pspace);
1273 /* Check for any newly added shared libraries if we're supposed to
1274 be adding them automatically. Switch terminal for any messages
1275 produced by breakpoint_re_set. */
1276 target_terminal_ours_for_output ();
1277 solib_add (NULL, 0, ¤t_target, auto_solib_add);
1278 target_terminal_inferior ();
1281 /* Reload shared libraries, but avoid reloading the same symbol file
1282 we already have loaded. */
1285 reload_shared_libraries_1 (int from_tty)
1288 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
1290 if (print_symbol_loading_p (from_tty, 0, 0))
1291 printf_unfiltered (_("Loading symbols for shared libraries.\n"));
1293 for (so = so_list_head; so != NULL; so = so->next)
1295 char *filename, *found_pathname = NULL;
1297 int was_loaded = so->symbols_loaded;
1299 SYMFILE_DEFER_BP_RESET | (from_tty ? SYMFILE_VERBOSE : 0);
1301 filename = tilde_expand (so->so_original_name);
1302 make_cleanup (xfree, filename);
1303 abfd = solib_bfd_open (filename);
1306 found_pathname = xstrdup (bfd_get_filename (abfd));
1307 make_cleanup (xfree, found_pathname);
1308 gdb_bfd_unref (abfd);
1311 /* If this shared library is no longer associated with its previous
1312 symbol file, close that. */
1313 if ((found_pathname == NULL && was_loaded)
1314 || (found_pathname != NULL
1315 && filename_cmp (found_pathname, so->so_name) != 0))
1317 if (so->objfile && ! (so->objfile->flags & OBJF_USERLOADED)
1318 && !solib_used (so))
1319 free_objfile (so->objfile);
1320 remove_target_sections (so);
1324 /* If this shared library is now associated with a new symbol
1326 if (found_pathname != NULL
1328 || filename_cmp (found_pathname, so->so_name) != 0))
1330 volatile struct gdb_exception e;
1332 TRY_CATCH (e, RETURN_MASK_ERROR)
1333 solib_map_sections (so);
1336 exception_fprintf (gdb_stderr, e,
1337 _("Error while mapping "
1338 "shared library sections:\n"));
1339 else if (auto_solib_add || was_loaded || libpthread_solib_p (so))
1340 solib_read_symbols (so, flags);
1344 do_cleanups (old_chain);
1348 reload_shared_libraries (char *ignored, int from_tty,
1349 struct cmd_list_element *e)
1351 const struct target_so_ops *ops;
1353 reload_shared_libraries_1 (from_tty);
1355 ops = solib_ops (target_gdbarch ());
1357 /* Creating inferior hooks here has two purposes. First, if we reload
1358 shared libraries then the address of solib breakpoint we've computed
1359 previously might be no longer valid. For example, if we forgot to set
1360 solib-absolute-prefix and are setting it right now, then the previous
1361 breakpoint address is plain wrong. Second, installing solib hooks
1362 also implicitly figures were ld.so is and loads symbols for it.
1363 Absent this call, if we've just connected to a target and set
1364 solib-absolute-prefix or solib-search-path, we'll lose all information
1366 if (target_has_execution)
1368 /* Reset or free private data structures not associated with
1370 ops->clear_solib ();
1372 /* Remove any previous solib event breakpoint. This is usually
1373 done in common code, at breakpoint_init_inferior time, but
1374 we're not really starting up the inferior here. */
1375 remove_solib_event_breakpoints ();
1377 solib_create_inferior_hook (from_tty);
1380 /* Sometimes the platform-specific hook loads initial shared
1381 libraries, and sometimes it doesn't. If it doesn't FROM_TTY will be
1382 incorrectly 0 but such solib targets should be fixed anyway. If we
1383 made all the inferior hook methods consistent, this call could be
1384 removed. Call it only after the solib target has been initialized by
1385 solib_create_inferior_hook. */
1387 solib_add (NULL, 0, NULL, auto_solib_add);
1389 breakpoint_re_set ();
1391 /* We may have loaded or unloaded debug info for some (or all)
1392 shared libraries. However, frames may still reference them. For
1393 example, a frame's unwinder might still point at DWARF FDE
1394 structures that are now freed. Also, getting new symbols may
1395 change our opinion about what is frameless. */
1396 reinit_frame_cache ();
1398 ops->special_symbol_handling ();
1402 show_auto_solib_add (struct ui_file *file, int from_tty,
1403 struct cmd_list_element *c, const char *value)
1405 fprintf_filtered (file, _("Autoloading of shared library symbols is %s.\n"),
1410 /* Handler for library-specific lookup of global symbol NAME in OBJFILE. Call
1411 the library-specific handler if it is installed for the current target. */
1414 solib_global_lookup (const struct objfile *objfile,
1416 const domain_enum domain)
1418 const struct target_so_ops *ops = solib_ops (target_gdbarch ());
1420 if (ops->lookup_lib_global_symbol != NULL)
1421 return ops->lookup_lib_global_symbol (objfile, name, domain);
1425 /* Lookup the value for a specific symbol from dynamic symbol table. Look
1426 up symbol from ABFD. MATCH_SYM is a callback function to determine
1427 whether to pick up a symbol. DATA is the input of this callback
1428 function. Return NULL if symbol is not found. */
1431 gdb_bfd_lookup_symbol_from_symtab (bfd *abfd,
1432 int (*match_sym) (asymbol *, void *),
1435 long storage_needed = bfd_get_symtab_upper_bound (abfd);
1436 CORE_ADDR symaddr = 0;
1438 if (storage_needed > 0)
1442 asymbol **symbol_table = (asymbol **) xmalloc (storage_needed);
1443 struct cleanup *back_to = make_cleanup (xfree, symbol_table);
1444 unsigned int number_of_symbols =
1445 bfd_canonicalize_symtab (abfd, symbol_table);
1447 for (i = 0; i < number_of_symbols; i++)
1449 asymbol *sym = *symbol_table++;
1451 if (match_sym (sym, data))
1453 /* BFD symbols are section relative. */
1454 symaddr = sym->value + sym->section->vma;
1458 do_cleanups (back_to);
1464 /* Lookup the value for a specific symbol from symbol table. Look up symbol
1465 from ABFD. MATCH_SYM is a callback function to determine whether to pick
1466 up a symbol. DATA is the input of this callback function. Return NULL
1467 if symbol is not found. */
1470 bfd_lookup_symbol_from_dyn_symtab (bfd *abfd,
1471 int (*match_sym) (asymbol *, void *),
1474 long storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
1475 CORE_ADDR symaddr = 0;
1477 if (storage_needed > 0)
1480 asymbol **symbol_table = (asymbol **) xmalloc (storage_needed);
1481 struct cleanup *back_to = make_cleanup (xfree, symbol_table);
1482 unsigned int number_of_symbols =
1483 bfd_canonicalize_dynamic_symtab (abfd, symbol_table);
1485 for (i = 0; i < number_of_symbols; i++)
1487 asymbol *sym = *symbol_table++;
1489 if (match_sym (sym, data))
1491 /* BFD symbols are section relative. */
1492 symaddr = sym->value + sym->section->vma;
1496 do_cleanups (back_to);
1501 /* Lookup the value for a specific symbol from symbol table and dynamic
1502 symbol table. Look up symbol from ABFD. MATCH_SYM is a callback
1503 function to determine whether to pick up a symbol. DATA is the
1504 input of this callback function. Return NULL if symbol is not
1508 gdb_bfd_lookup_symbol (bfd *abfd,
1509 int (*match_sym) (asymbol *, void *),
1512 CORE_ADDR symaddr = gdb_bfd_lookup_symbol_from_symtab (abfd, match_sym, data);
1514 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
1515 have to check the dynamic string table too. */
1517 symaddr = bfd_lookup_symbol_from_dyn_symtab (abfd, match_sym, data);
1522 /* SO_LIST_HEAD may contain user-loaded object files that can be removed
1523 out-of-band by the user. So upon notification of free_objfile remove
1524 all references to any user-loaded file that is about to be freed. */
1527 remove_user_added_objfile (struct objfile *objfile)
1531 if (objfile != 0 && objfile->flags & OBJF_USERLOADED)
1533 for (so = so_list_head; so != NULL; so = so->next)
1534 if (so->objfile == objfile)
1539 extern initialize_file_ftype _initialize_solib; /* -Wmissing-prototypes */
1542 _initialize_solib (void)
1544 solib_data = gdbarch_data_register_pre_init (solib_init);
1546 observer_attach_free_objfile (remove_user_added_objfile);
1548 add_com ("sharedlibrary", class_files, sharedlibrary_command,
1549 _("Load shared object library symbols for files matching REGEXP."));
1550 add_info ("sharedlibrary", info_sharedlibrary_command,
1551 _("Status of loaded shared object libraries."));
1552 add_com ("nosharedlibrary", class_files, no_shared_libraries,
1553 _("Unload all shared object library symbols."));
1555 add_setshow_boolean_cmd ("auto-solib-add", class_support,
1556 &auto_solib_add, _("\
1557 Set autoloading of shared library symbols."), _("\
1558 Show autoloading of shared library symbols."), _("\
1559 If \"on\", symbols from all shared object libraries will be loaded\n\
1560 automatically when the inferior begins execution, when the dynamic linker\n\
1561 informs gdb that a new library has been loaded, or when attaching to the\n\
1562 inferior. Otherwise, symbols must be loaded manually, using \
1565 show_auto_solib_add,
1566 &setlist, &showlist);
1568 add_setshow_filename_cmd ("sysroot", class_support,
1570 Set an alternate system root."), _("\
1571 Show the current system root."), _("\
1572 The system root is used to load absolute shared library symbol files.\n\
1573 For other (relative) files, you can add directories using\n\
1574 `set solib-search-path'."),
1575 reload_shared_libraries,
1577 &setlist, &showlist);
1579 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support, 0,
1581 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support, 0,
1584 add_setshow_optional_filename_cmd ("solib-search-path", class_support,
1585 &solib_search_path, _("\
1586 Set the search path for loading non-absolute shared library symbol files."),
1588 Show the search path for loading non-absolute shared library symbol files."),
1590 This takes precedence over the environment variables \
1591 PATH and LD_LIBRARY_PATH."),
1592 reload_shared_libraries,
1593 show_solib_search_path,
1594 &setlist, &showlist);