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 if (so
->symbols_loaded
)
608 /* If needed, we've already warned in our caller. */
610 else if (so
->abfd
== NULL
)
612 /* We've already warned about this library, when trying to open
617 volatile struct gdb_exception e
;
619 flags
|= current_inferior ()->symfile_flags
;
621 TRY_CATCH (e
, RETURN_MASK_ERROR
)
623 struct section_addr_info
*sap
;
625 /* Have we already loaded this shared object? */
626 ALL_OBJFILES (so
->objfile
)
628 if (filename_cmp (objfile_name (so
->objfile
), so
->so_name
) == 0
629 && so
->objfile
->addr_low
== so
->addr_low
)
632 if (so
->objfile
!= NULL
)
635 sap
= build_section_addr_info_from_section_table (so
->sections
,
637 so
->objfile
= symbol_file_add_from_bfd (so
->abfd
, so
->so_name
,
638 flags
, sap
, OBJF_SHARED
,
640 so
->objfile
->addr_low
= so
->addr_low
;
641 free_section_addr_info (sap
);
645 exception_fprintf (gdb_stderr
, e
, _("Error while reading shared"
646 " library symbols for %s:\n"),
649 so
->symbols_loaded
= 1;
656 /* Return 1 if KNOWN->objfile is used by any other so_list object in the
657 SO_LIST_HEAD list. Return 0 otherwise. */
660 solib_used (const struct so_list
*const known
)
662 const struct so_list
*pivot
;
664 for (pivot
= so_list_head
; pivot
!= NULL
; pivot
= pivot
->next
)
665 if (pivot
!= known
&& pivot
->objfile
== known
->objfile
)
670 /* Synchronize GDB's shared object list with inferior's.
672 Extract the list of currently loaded shared objects from the
673 inferior, and compare it with the list of shared objects currently
674 in GDB's so_list_head list. Edit so_list_head to bring it in sync
675 with the inferior's new list.
677 If we notice that the inferior has unloaded some shared objects,
678 free any symbolic info GDB had read about those shared objects.
680 Don't load symbolic info for any new shared objects; just add them
681 to the list, and leave their symbols_loaded flag clear.
683 If FROM_TTY is non-null, feel free to print messages about what
686 If TARGET is non-null, add the sections of all new shared objects
687 to TARGET's section table. Note that this doesn't remove any
688 sections for shared objects that have been unloaded, and it
689 doesn't check to see if the new shared objects are already present in
690 the section table. But we only use this for core files and
691 processes we've just attached to, so that's okay. */
694 update_solib_list (int from_tty
, struct target_ops
*target
)
696 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
697 struct so_list
*inferior
= ops
->current_sos();
698 struct so_list
*gdb
, **gdb_link
;
700 /* We can reach here due to changing solib-search-path or the
701 sysroot, before having any inferior. */
702 if (target_has_execution
&& !ptid_equal (inferior_ptid
, null_ptid
))
704 struct inferior
*inf
= current_inferior ();
706 /* If we are attaching to a running process for which we
707 have not opened a symbol file, we may be able to get its
709 if (inf
->attach_flag
&& symfile_objfile
== NULL
)
710 catch_errors (ops
->open_symbol_file_object
, &from_tty
,
711 "Error reading attached process's symbol file.\n",
715 /* GDB and the inferior's dynamic linker each maintain their own
716 list of currently loaded shared objects; we want to bring the
717 former in sync with the latter. Scan both lists, seeing which
718 shared objects appear where. There are three cases:
720 - A shared object appears on both lists. This means that GDB
721 knows about it already, and it's still loaded in the inferior.
722 Nothing needs to happen.
724 - A shared object appears only on GDB's list. This means that
725 the inferior has unloaded it. We should remove the shared
726 object from GDB's tables.
728 - A shared object appears only on the inferior's list. This
729 means that it's just been loaded. We should add it to GDB's
732 So we walk GDB's list, checking each entry to see if it appears
733 in the inferior's list too. If it does, no action is needed, and
734 we remove it from the inferior's list. If it doesn't, the
735 inferior has unloaded it, and we remove it from GDB's list. By
736 the time we're done walking GDB's list, the inferior's list
737 contains only the new shared objects, which we then add. */
740 gdb_link
= &so_list_head
;
743 struct so_list
*i
= inferior
;
744 struct so_list
**i_link
= &inferior
;
746 /* Check to see whether the shared object *gdb also appears in
747 the inferior's current list. */
752 if (ops
->same (gdb
, i
))
757 if (! filename_cmp (gdb
->so_original_name
, i
->so_original_name
))
765 /* If the shared object appears on the inferior's list too, then
766 it's still loaded, so we don't need to do anything. Delete
767 it from the inferior's list, and leave it on GDB's list. */
772 gdb_link
= &gdb
->next
;
776 /* If it's not on the inferior's list, remove it from GDB's tables. */
779 /* Notify any observer that the shared object has been
780 unloaded before we remove it from GDB's tables. */
781 observer_notify_solib_unloaded (gdb
);
783 VEC_safe_push (char_ptr
, current_program_space
->deleted_solibs
,
784 xstrdup (gdb
->so_name
));
786 *gdb_link
= gdb
->next
;
788 /* Unless the user loaded it explicitly, free SO's objfile. */
789 if (gdb
->objfile
&& ! (gdb
->objfile
->flags
& OBJF_USERLOADED
)
790 && !solib_used (gdb
))
791 free_objfile (gdb
->objfile
);
793 /* Some targets' section tables might be referring to
794 sections from so->abfd; remove them. */
795 remove_target_sections (gdb
);
802 /* Now the inferior's list contains only shared objects that don't
803 appear in GDB's list --- those that are newly loaded. Add them
804 to GDB's shared object list. */
808 const char *not_found_filename
= NULL
;
812 /* Add the new shared objects to GDB's list. */
813 *gdb_link
= inferior
;
815 /* Fill in the rest of each of the `struct so_list' nodes. */
816 for (i
= inferior
; i
; i
= i
->next
)
818 volatile struct gdb_exception e
;
820 i
->pspace
= current_program_space
;
821 VEC_safe_push (so_list_ptr
, current_program_space
->added_solibs
, i
);
823 TRY_CATCH (e
, RETURN_MASK_ERROR
)
825 /* Fill in the rest of the `struct so_list' node. */
826 if (!solib_map_sections (i
))
829 if (not_found_filename
== NULL
)
830 not_found_filename
= i
->so_original_name
;
835 exception_fprintf (gdb_stderr
, e
,
836 _("Error while mapping shared "
837 "library sections:\n"));
839 /* Notify any observer that the shared object has been
840 loaded now that we've added it to GDB's tables. */
841 observer_notify_solib_loaded (i
);
844 /* If a library was not found, issue an appropriate warning
845 message. We have to use a single call to warning in case the
846 front end does something special with warnings, e.g., pop up
847 a dialog box. It Would Be Nice if we could get a "warning: "
848 prefix on each line in the CLI front end, though - it doesn't
852 warning (_("Could not load shared library symbols for %s.\n"
853 "Do you need \"set solib-search-path\" "
854 "or \"set sysroot\"?"),
856 else if (not_found
> 1)
858 Could not load shared library symbols for %d libraries, e.g. %s.\n\
859 Use the \"info sharedlibrary\" command to see the complete listing.\n\
860 Do you need \"set solib-search-path\" or \"set sysroot\"?"),
861 not_found
, not_found_filename
);
866 /* Return non-zero if NAME is the libpthread shared library.
868 Uses a fairly simplistic heuristic approach where we check
869 the file name against "/libpthread". This can lead to false
870 positives, but this should be good enough in practice. */
873 libpthread_name_p (const char *name
)
875 return (strstr (name
, "/libpthread") != NULL
);
878 /* Return non-zero if SO is the libpthread shared library. */
881 libpthread_solib_p (struct so_list
*so
)
883 return libpthread_name_p (so
->so_name
);
886 /* Read in symbolic information for any shared objects whose names
887 match PATTERN. (If we've already read a shared object's symbol
888 info, leave it alone.) If PATTERN is zero, read them all.
890 If READSYMS is 0, defer reading symbolic information until later
891 but still do any needed low level processing.
893 FROM_TTY and TARGET are as described for update_solib_list, above. */
896 solib_add (const char *pattern
, int from_tty
,
897 struct target_ops
*target
, int readsyms
)
901 if (print_symbol_loading_p (from_tty
, 0, 0))
905 printf_unfiltered (_("Loading symbols for shared libraries: %s\n"),
909 printf_unfiltered (_("Loading symbols for shared libraries.\n"));
912 current_program_space
->solib_add_generation
++;
916 char *re_err
= re_comp (pattern
);
919 error (_("Invalid regexp: %s"), re_err
);
922 update_solib_list (from_tty
, target
);
924 /* Walk the list of currently loaded shared libraries, and read
925 symbols for any that match the pattern --- or any whose symbols
926 aren't already loaded, if no pattern was given. */
929 int loaded_any_symbols
= 0;
931 SYMFILE_DEFER_BP_RESET
| (from_tty
? SYMFILE_VERBOSE
: 0);
933 for (gdb
= so_list_head
; gdb
; gdb
= gdb
->next
)
934 if (! pattern
|| re_exec (gdb
->so_name
))
936 /* Normally, we would read the symbols from that library
937 only if READSYMS is set. However, we're making a small
938 exception for the pthread library, because we sometimes
939 need the library symbols to be loaded in order to provide
940 thread support (x86-linux for instance). */
941 const int add_this_solib
=
942 (readsyms
|| libpthread_solib_p (gdb
));
947 if (gdb
->symbols_loaded
)
949 /* If no pattern was given, be quiet for shared
950 libraries we have already loaded. */
951 if (pattern
&& (from_tty
|| info_verbose
))
952 printf_unfiltered (_("Symbols already loaded for %s\n"),
955 else if (solib_read_symbols (gdb
, flags
))
956 loaded_any_symbols
= 1;
960 if (loaded_any_symbols
)
961 breakpoint_re_set ();
963 if (from_tty
&& pattern
&& ! any_matches
)
965 ("No loaded shared libraries match the pattern `%s'.\n", pattern
);
967 if (loaded_any_symbols
)
969 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
971 /* Getting new symbols may change our opinion about what is
973 reinit_frame_cache ();
975 ops
->special_symbol_handling ();
980 /* Implement the "info sharedlibrary" command. Walk through the
981 shared library list and print information about each attached
982 library matching PATTERN. If PATTERN is elided, print them
986 info_sharedlibrary_command (char *pattern
, int from_tty
)
988 struct so_list
*so
= NULL
; /* link map state variable */
989 int so_missing_debug_info
= 0;
992 struct cleanup
*table_cleanup
;
993 struct gdbarch
*gdbarch
= target_gdbarch ();
994 struct ui_out
*uiout
= current_uiout
;
998 char *re_err
= re_comp (pattern
);
1001 error (_("Invalid regexp: %s"), re_err
);
1004 /* "0x", a little whitespace, and two hex digits per byte of pointers. */
1005 addr_width
= 4 + (gdbarch_ptr_bit (gdbarch
) / 4);
1007 update_solib_list (from_tty
, 0);
1009 /* make_cleanup_ui_out_table_begin_end needs to know the number of
1010 rows, so we need to make two passes over the libs. */
1012 for (nr_libs
= 0, so
= so_list_head
; so
; so
= so
->next
)
1016 if (pattern
&& ! re_exec (so
->so_name
))
1023 make_cleanup_ui_out_table_begin_end (uiout
, 4, nr_libs
,
1024 "SharedLibraryTable");
1026 /* The "- 1" is because ui_out adds one space between columns. */
1027 ui_out_table_header (uiout
, addr_width
- 1, ui_left
, "from", "From");
1028 ui_out_table_header (uiout
, addr_width
- 1, ui_left
, "to", "To");
1029 ui_out_table_header (uiout
, 12 - 1, ui_left
, "syms-read", "Syms Read");
1030 ui_out_table_header (uiout
, 0, ui_noalign
,
1031 "name", "Shared Object Library");
1033 ui_out_table_body (uiout
);
1035 for (so
= so_list_head
; so
; so
= so
->next
)
1037 struct cleanup
*lib_cleanup
;
1039 if (! so
->so_name
[0])
1041 if (pattern
&& ! re_exec (so
->so_name
))
1044 lib_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, "lib");
1046 if (so
->addr_high
!= 0)
1048 ui_out_field_core_addr (uiout
, "from", gdbarch
, so
->addr_low
);
1049 ui_out_field_core_addr (uiout
, "to", gdbarch
, so
->addr_high
);
1053 ui_out_field_skip (uiout
, "from");
1054 ui_out_field_skip (uiout
, "to");
1057 if (! ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1058 && so
->symbols_loaded
1059 && !objfile_has_symbols (so
->objfile
))
1061 so_missing_debug_info
= 1;
1062 ui_out_field_string (uiout
, "syms-read", "Yes (*)");
1065 ui_out_field_string (uiout
, "syms-read",
1066 so
->symbols_loaded
? "Yes" : "No");
1068 ui_out_field_string (uiout
, "name", so
->so_name
);
1070 ui_out_text (uiout
, "\n");
1072 do_cleanups (lib_cleanup
);
1075 do_cleanups (table_cleanup
);
1080 ui_out_message (uiout
, 0,
1081 _("No shared libraries matched.\n"));
1083 ui_out_message (uiout
, 0,
1084 _("No shared libraries loaded at this time.\n"));
1088 if (so_missing_debug_info
)
1089 ui_out_message (uiout
, 0,
1090 _("(*): Shared library is missing "
1091 "debugging information.\n"));
1095 /* Return 1 if ADDRESS lies within SOLIB. */
1098 solib_contains_address_p (const struct so_list
*const solib
,
1101 struct target_section
*p
;
1103 for (p
= solib
->sections
; p
< solib
->sections_end
; p
++)
1104 if (p
->addr
<= address
&& address
< p
->endaddr
)
1110 /* If ADDRESS is in a shared lib in program space PSPACE, return its
1113 Provides a hook for other gdb routines to discover whether or not a
1114 particular address is within the mapped address space of a shared
1117 For example, this routine is called at one point to disable
1118 breakpoints which are in shared libraries that are not currently
1122 solib_name_from_address (struct program_space
*pspace
, CORE_ADDR address
)
1124 struct so_list
*so
= NULL
;
1126 for (so
= pspace
->so_list
; so
; so
= so
->next
)
1127 if (solib_contains_address_p (so
, address
))
1128 return (so
->so_name
);
1133 /* Return whether the data starting at VADDR, size SIZE, must be kept
1134 in a core file for shared libraries loaded before "gcore" is used
1135 to be handled correctly when the core file is loaded. This only
1136 applies when the section would otherwise not be kept in the core
1137 file (in particular, for readonly sections). */
1140 solib_keep_data_in_core (CORE_ADDR vaddr
, unsigned long size
)
1142 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1144 if (ops
->keep_data_in_core
)
1145 return ops
->keep_data_in_core (vaddr
, size
);
1150 /* Called by free_all_symtabs */
1155 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1157 /* This function is expected to handle ELF shared libraries. It is
1158 also used on Solaris, which can run either ELF or a.out binaries
1159 (for compatibility with SunOS 4), both of which can use shared
1160 libraries. So we don't know whether we have an ELF executable or
1161 an a.out executable until the user chooses an executable file.
1163 ELF shared libraries don't get mapped into the address space
1164 until after the program starts, so we'd better not try to insert
1165 breakpoints in them immediately. We have to wait until the
1166 dynamic linker has loaded them; we'll hit a bp_shlib_event
1167 breakpoint (look for calls to create_solib_event_breakpoint) when
1170 SunOS shared libraries seem to be different --- they're present
1171 as soon as the process begins execution, so there's no need to
1172 put off inserting breakpoints. There's also nowhere to put a
1173 bp_shlib_event breakpoint, so if we put it off, we'll never get
1176 So: disable breakpoints only if we're using ELF shared libs. */
1177 if (exec_bfd
!= NULL
1178 && bfd_get_flavour (exec_bfd
) != bfd_target_aout_flavour
)
1179 disable_breakpoints_in_shlibs ();
1181 while (so_list_head
)
1183 struct so_list
*so
= so_list_head
;
1185 so_list_head
= so
->next
;
1186 observer_notify_solib_unloaded (so
);
1187 remove_target_sections (so
);
1191 ops
->clear_solib ();
1194 /* Shared library startup support. When GDB starts up the inferior,
1195 it nurses it along (through the shell) until it is ready to execute
1196 its first instruction. At this point, this function gets
1200 solib_create_inferior_hook (int from_tty
)
1202 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1204 ops
->solib_create_inferior_hook (from_tty
);
1207 /* Check to see if an address is in the dynamic loader's dynamic
1208 symbol resolution code. Return 1 if so, 0 otherwise. */
1211 in_solib_dynsym_resolve_code (CORE_ADDR pc
)
1213 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1215 return ops
->in_dynsym_resolve_code (pc
);
1218 /* Implements the "sharedlibrary" command. */
1221 sharedlibrary_command (char *args
, int from_tty
)
1224 solib_add (args
, from_tty
, (struct target_ops
*) 0, 1);
1227 /* Implements the command "nosharedlibrary", which discards symbols
1228 that have been auto-loaded from shared libraries. Symbols from
1229 shared libraries that were added by explicit request of the user
1230 are not discarded. Also called from remote.c. */
1233 no_shared_libraries (char *ignored
, int from_tty
)
1235 /* The order of the two routines below is important: clear_solib notifies
1236 the solib_unloaded observers, and some of these observers might need
1237 access to their associated objfiles. Therefore, we can not purge the
1238 solibs' objfiles before clear_solib has been called. */
1241 objfile_purge_solibs ();
1247 update_solib_breakpoints (void)
1249 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1251 if (ops
->update_breakpoints
!= NULL
)
1252 ops
->update_breakpoints ();
1258 handle_solib_event (void)
1260 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1262 if (ops
->handle_event
!= NULL
)
1263 ops
->handle_event ();
1265 clear_program_space_solib_cache (current_inferior ()->pspace
);
1267 /* Check for any newly added shared libraries if we're supposed to
1268 be adding them automatically. Switch terminal for any messages
1269 produced by breakpoint_re_set. */
1270 target_terminal_ours_for_output ();
1271 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
1272 target_terminal_inferior ();
1275 /* Reload shared libraries, but avoid reloading the same symbol file
1276 we already have loaded. */
1279 reload_shared_libraries_1 (int from_tty
)
1282 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1284 if (print_symbol_loading_p (from_tty
, 0, 0))
1285 printf_unfiltered (_("Loading symbols for shared libraries.\n"));
1287 for (so
= so_list_head
; so
!= NULL
; so
= so
->next
)
1289 char *filename
, *found_pathname
= NULL
;
1291 int was_loaded
= so
->symbols_loaded
;
1293 SYMFILE_DEFER_BP_RESET
| (from_tty
? SYMFILE_VERBOSE
: 0);
1295 filename
= tilde_expand (so
->so_original_name
);
1296 make_cleanup (xfree
, filename
);
1297 abfd
= solib_bfd_open (filename
);
1300 found_pathname
= xstrdup (bfd_get_filename (abfd
));
1301 make_cleanup (xfree
, found_pathname
);
1302 gdb_bfd_unref (abfd
);
1305 /* If this shared library is no longer associated with its previous
1306 symbol file, close that. */
1307 if ((found_pathname
== NULL
&& was_loaded
)
1308 || (found_pathname
!= NULL
1309 && filename_cmp (found_pathname
, so
->so_name
) != 0))
1311 if (so
->objfile
&& ! (so
->objfile
->flags
& OBJF_USERLOADED
)
1312 && !solib_used (so
))
1313 free_objfile (so
->objfile
);
1314 remove_target_sections (so
);
1318 /* If this shared library is now associated with a new symbol
1320 if (found_pathname
!= NULL
1322 || filename_cmp (found_pathname
, so
->so_name
) != 0))
1324 volatile struct gdb_exception e
;
1326 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1327 solib_map_sections (so
);
1330 exception_fprintf (gdb_stderr
, e
,
1331 _("Error while mapping "
1332 "shared library sections:\n"));
1333 else if (auto_solib_add
|| was_loaded
|| libpthread_solib_p (so
))
1334 solib_read_symbols (so
, flags
);
1338 do_cleanups (old_chain
);
1342 reload_shared_libraries (char *ignored
, int from_tty
,
1343 struct cmd_list_element
*e
)
1345 const struct target_so_ops
*ops
;
1347 reload_shared_libraries_1 (from_tty
);
1349 ops
= solib_ops (target_gdbarch ());
1351 /* Creating inferior hooks here has two purposes. First, if we reload
1352 shared libraries then the address of solib breakpoint we've computed
1353 previously might be no longer valid. For example, if we forgot to set
1354 solib-absolute-prefix and are setting it right now, then the previous
1355 breakpoint address is plain wrong. Second, installing solib hooks
1356 also implicitly figures were ld.so is and loads symbols for it.
1357 Absent this call, if we've just connected to a target and set
1358 solib-absolute-prefix or solib-search-path, we'll lose all information
1360 if (target_has_execution
)
1362 /* Reset or free private data structures not associated with
1364 ops
->clear_solib ();
1366 /* Remove any previous solib event breakpoint. This is usually
1367 done in common code, at breakpoint_init_inferior time, but
1368 we're not really starting up the inferior here. */
1369 remove_solib_event_breakpoints ();
1371 solib_create_inferior_hook (from_tty
);
1374 /* Sometimes the platform-specific hook loads initial shared
1375 libraries, and sometimes it doesn't. If it doesn't FROM_TTY will be
1376 incorrectly 0 but such solib targets should be fixed anyway. If we
1377 made all the inferior hook methods consistent, this call could be
1378 removed. Call it only after the solib target has been initialized by
1379 solib_create_inferior_hook. */
1381 solib_add (NULL
, 0, NULL
, auto_solib_add
);
1383 breakpoint_re_set ();
1385 /* We may have loaded or unloaded debug info for some (or all)
1386 shared libraries. However, frames may still reference them. For
1387 example, a frame's unwinder might still point at DWARF FDE
1388 structures that are now freed. Also, getting new symbols may
1389 change our opinion about what is frameless. */
1390 reinit_frame_cache ();
1392 ops
->special_symbol_handling ();
1396 show_auto_solib_add (struct ui_file
*file
, int from_tty
,
1397 struct cmd_list_element
*c
, const char *value
)
1399 fprintf_filtered (file
, _("Autoloading of shared library symbols is %s.\n"),
1404 /* Handler for library-specific lookup of global symbol NAME in OBJFILE. Call
1405 the library-specific handler if it is installed for the current target. */
1408 solib_global_lookup (const struct objfile
*objfile
,
1410 const domain_enum domain
)
1412 const struct target_so_ops
*ops
= solib_ops (target_gdbarch ());
1414 if (ops
->lookup_lib_global_symbol
!= NULL
)
1415 return ops
->lookup_lib_global_symbol (objfile
, name
, domain
);
1419 /* Lookup the value for a specific symbol from dynamic symbol table. Look
1420 up symbol from ABFD. MATCH_SYM is a callback function to determine
1421 whether to pick up a symbol. DATA is the input of this callback
1422 function. Return NULL if symbol is not found. */
1425 gdb_bfd_lookup_symbol_from_symtab (bfd
*abfd
,
1426 int (*match_sym
) (asymbol
*, void *),
1429 long storage_needed
= bfd_get_symtab_upper_bound (abfd
);
1430 CORE_ADDR symaddr
= 0;
1432 if (storage_needed
> 0)
1436 asymbol
**symbol_table
= (asymbol
**) xmalloc (storage_needed
);
1437 struct cleanup
*back_to
= make_cleanup (xfree
, symbol_table
);
1438 unsigned int number_of_symbols
=
1439 bfd_canonicalize_symtab (abfd
, symbol_table
);
1441 for (i
= 0; i
< number_of_symbols
; i
++)
1443 asymbol
*sym
= *symbol_table
++;
1445 if (match_sym (sym
, data
))
1447 /* BFD symbols are section relative. */
1448 symaddr
= sym
->value
+ sym
->section
->vma
;
1452 do_cleanups (back_to
);
1458 /* Lookup the value for a specific symbol from symbol table. Look up symbol
1459 from ABFD. MATCH_SYM is a callback function to determine whether to pick
1460 up a symbol. DATA is the input of this callback function. Return NULL
1461 if symbol is not found. */
1464 bfd_lookup_symbol_from_dyn_symtab (bfd
*abfd
,
1465 int (*match_sym
) (asymbol
*, void *),
1468 long storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1469 CORE_ADDR symaddr
= 0;
1471 if (storage_needed
> 0)
1474 asymbol
**symbol_table
= (asymbol
**) xmalloc (storage_needed
);
1475 struct cleanup
*back_to
= make_cleanup (xfree
, symbol_table
);
1476 unsigned int number_of_symbols
=
1477 bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
1479 for (i
= 0; i
< number_of_symbols
; i
++)
1481 asymbol
*sym
= *symbol_table
++;
1483 if (match_sym (sym
, data
))
1485 /* BFD symbols are section relative. */
1486 symaddr
= sym
->value
+ sym
->section
->vma
;
1490 do_cleanups (back_to
);
1495 /* Lookup the value for a specific symbol from symbol table and dynamic
1496 symbol table. Look up symbol from ABFD. MATCH_SYM is a callback
1497 function to determine whether to pick up a symbol. DATA is the
1498 input of this callback function. Return NULL if symbol is not
1502 gdb_bfd_lookup_symbol (bfd
*abfd
,
1503 int (*match_sym
) (asymbol
*, void *),
1506 CORE_ADDR symaddr
= gdb_bfd_lookup_symbol_from_symtab (abfd
, match_sym
, data
);
1508 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
1509 have to check the dynamic string table too. */
1511 symaddr
= bfd_lookup_symbol_from_dyn_symtab (abfd
, match_sym
, data
);
1516 /* SO_LIST_HEAD may contain user-loaded object files that can be removed
1517 out-of-band by the user. So upon notification of free_objfile remove
1518 all references to any user-loaded file that is about to be freed. */
1521 remove_user_added_objfile (struct objfile
*objfile
)
1525 if (objfile
!= 0 && objfile
->flags
& OBJF_USERLOADED
)
1527 for (so
= so_list_head
; so
!= NULL
; so
= so
->next
)
1528 if (so
->objfile
== objfile
)
1533 extern initialize_file_ftype _initialize_solib
; /* -Wmissing-prototypes */
1536 _initialize_solib (void)
1538 solib_data
= gdbarch_data_register_pre_init (solib_init
);
1540 observer_attach_free_objfile (remove_user_added_objfile
);
1542 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
1543 _("Load shared object library symbols for files matching REGEXP."));
1544 add_info ("sharedlibrary", info_sharedlibrary_command
,
1545 _("Status of loaded shared object libraries."));
1546 add_com ("nosharedlibrary", class_files
, no_shared_libraries
,
1547 _("Unload all shared object library symbols."));
1549 add_setshow_boolean_cmd ("auto-solib-add", class_support
,
1550 &auto_solib_add
, _("\
1551 Set autoloading of shared library symbols."), _("\
1552 Show autoloading of shared library symbols."), _("\
1553 If \"on\", symbols from all shared object libraries will be loaded\n\
1554 automatically when the inferior begins execution, when the dynamic linker\n\
1555 informs gdb that a new library has been loaded, or when attaching to the\n\
1556 inferior. Otherwise, symbols must be loaded manually, using \
1559 show_auto_solib_add
,
1560 &setlist
, &showlist
);
1562 add_setshow_filename_cmd ("sysroot", class_support
,
1564 Set an alternate system root."), _("\
1565 Show the current system root."), _("\
1566 The system root is used to load absolute shared library symbol files.\n\
1567 For other (relative) files, you can add directories using\n\
1568 `set solib-search-path'."),
1569 reload_shared_libraries
,
1571 &setlist
, &showlist
);
1573 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support
, 0,
1575 add_alias_cmd ("solib-absolute-prefix", "sysroot", class_support
, 0,
1578 add_setshow_optional_filename_cmd ("solib-search-path", class_support
,
1579 &solib_search_path
, _("\
1580 Set the search path for loading non-absolute shared library symbol files."),
1582 Show the search path for loading non-absolute shared library symbol files."),
1584 This takes precedence over the environment variables \
1585 PATH and LD_LIBRARY_PATH."),
1586 reload_shared_libraries
,
1587 show_solib_search_path
,
1588 &setlist
, &showlist
);