1 /* Handle shared libraries for GDB, the GNU Debugger.
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
25 #include <sys/types.h>
27 #include "gdb_string.h"
32 #include "exceptions.h"
37 #include "gdb_regex.h"
42 #include "completer.h"
43 #include "filenames.h" /* for DOSish file names */
47 #include "readline/readline.h"
49 /* external data declarations */
51 /* FIXME: gdbarch needs to control this variable */
52 struct target_so_ops
*current_target_so_ops
;
54 /* local data declarations */
56 static struct so_list
*so_list_head
; /* List of known shared objects */
58 static int solib_cleanup_queued
= 0; /* make_run_cleanup called */
60 /* Local function prototypes */
62 static void do_clear_solib (void *);
64 /* If non-zero, this is a prefix that will be added to the front of the name
65 shared libraries with an absolute filename for loading. */
66 static char *solib_absolute_prefix
= NULL
;
68 /* If non-empty, this is a search path for loading non-absolute shared library
69 symbol files. This takes precedence over the environment variables PATH
70 and LD_LIBRARY_PATH. */
71 static char *solib_search_path
= NULL
;
77 solib_open -- Find a shared library file and open it.
81 int solib_open (char *in_patname, char **found_pathname);
85 Global variable SOLIB_ABSOLUTE_PREFIX is used as a prefix directory
86 to search for shared libraries if they have an absolute path.
88 Global variable SOLIB_SEARCH_PATH is used as a prefix directory
89 (or set of directories, as in LD_LIBRARY_PATH) to search for all
90 shared libraries if not found in SOLIB_ABSOLUTE_PREFIX.
93 * If there is a solib_absolute_prefix and path is absolute:
94 * Search for solib_absolute_prefix/path.
96 * Look for it literally (unmodified).
97 * Look in SOLIB_SEARCH_PATH.
98 * If available, use target defined search function.
99 * If solib_absolute_prefix is NOT set, perform the following two searches:
100 * Look in inferior's $PATH.
101 * Look in inferior's $LD_LIBRARY_PATH.
103 * The last check avoids doing this search when targetting remote
104 * machines since solib_absolute_prefix will almost always be set.
108 file handle for opened solib, or -1 for failure. */
111 solib_open (char *in_pathname
, char **found_pathname
)
114 char *temp_pathname
= NULL
;
115 char *p
= in_pathname
;
117 while (*p
&& !IS_DIR_SEPARATOR (*p
))
122 if (! IS_ABSOLUTE_PATH (in_pathname
) || solib_absolute_prefix
== NULL
)
123 temp_pathname
= in_pathname
;
126 int prefix_len
= strlen (solib_absolute_prefix
);
128 /* Remove trailing slashes from absolute prefix. */
129 while (prefix_len
> 0
130 && IS_DIR_SEPARATOR (solib_absolute_prefix
[prefix_len
- 1]))
133 /* Cat the prefixed pathname together. */
134 temp_pathname
= alloca (prefix_len
+ strlen (in_pathname
) + 1);
135 strncpy (temp_pathname
, solib_absolute_prefix
, prefix_len
);
136 temp_pathname
[prefix_len
] = '\0';
137 strcat (temp_pathname
, in_pathname
);
140 /* Now see if we can open it. */
141 found_file
= open (temp_pathname
, O_RDONLY
, 0);
144 /* If the search in solib_absolute_prefix failed, and the path name is
145 absolute at this point, make it relative. (openp will try and open the
146 file according to its absolute path otherwise, which is not what we want.)
147 Affects subsequent searches for this solib. */
148 if (found_file
< 0 && IS_ABSOLUTE_PATH (in_pathname
))
150 /* First, get rid of any drive letters etc. */
151 while (!IS_DIR_SEPARATOR (*in_pathname
))
154 /* Next, get rid of all leading dir separators. */
155 while (IS_DIR_SEPARATOR (*in_pathname
))
159 /* If not found, search the solib_search_path (if any). */
160 if (found_file
< 0 && solib_search_path
!= NULL
)
161 found_file
= openp (solib_search_path
, OPF_TRY_CWD_FIRST
,
162 in_pathname
, O_RDONLY
, 0, &temp_pathname
);
164 /* If not found, next search the solib_search_path (if any) for the basename
165 only (ignoring the path). This is to allow reading solibs from a path
166 that differs from the opened path. */
167 if (found_file
< 0 && solib_search_path
!= NULL
)
168 found_file
= openp (solib_search_path
, OPF_TRY_CWD_FIRST
,
169 lbasename (in_pathname
), O_RDONLY
, 0,
172 /* If not found, try to use target supplied solib search method */
173 if (found_file
< 0 && TARGET_SO_FIND_AND_OPEN_SOLIB
!= NULL
)
174 found_file
= TARGET_SO_FIND_AND_OPEN_SOLIB
175 (in_pathname
, O_RDONLY
, &temp_pathname
);
177 /* If not found, next search the inferior's $PATH environment variable. */
178 if (found_file
< 0 && solib_absolute_prefix
== NULL
)
179 found_file
= openp (get_in_environ (inferior_environ
, "PATH"),
180 OPF_TRY_CWD_FIRST
, in_pathname
, O_RDONLY
, 0,
183 /* If not found, next search the inferior's $LD_LIBRARY_PATH
184 environment variable. */
185 if (found_file
< 0 && solib_absolute_prefix
== NULL
)
186 found_file
= openp (get_in_environ (inferior_environ
, "LD_LIBRARY_PATH"),
187 OPF_TRY_CWD_FIRST
, in_pathname
, O_RDONLY
, 0,
190 /* Done. If not found, tough luck. Return found_file and
191 (optionally) found_pathname. */
192 if (found_pathname
!= NULL
&& temp_pathname
!= NULL
)
193 *found_pathname
= xstrdup (temp_pathname
);
202 solib_map_sections -- open bfd and build sections for shared lib
206 static int solib_map_sections (struct so_list *so)
210 Given a pointer to one of the shared objects in our list
211 of mapped objects, use the recorded name to open a bfd
212 descriptor for the object, build a section table, and then
213 relocate all the section addresses by the base address at
214 which the shared object was mapped.
218 In most (all?) cases the shared object file name recorded in the
219 dynamic linkage tables will be a fully qualified pathname. For
220 cases where it isn't, do we really mimic the systems search
221 mechanism correctly in the below code (particularly the tilde
226 solib_map_sections (void *arg
)
228 struct so_list
*so
= (struct so_list
*) arg
; /* catch_errors bogon */
230 char *scratch_pathname
;
232 struct section_table
*p
;
233 struct cleanup
*old_chain
;
236 filename
= tilde_expand (so
->so_name
);
238 old_chain
= make_cleanup (xfree
, filename
);
239 scratch_chan
= solib_open (filename
, &scratch_pathname
);
241 if (scratch_chan
< 0)
243 perror_with_name (filename
);
246 /* Leave scratch_pathname allocated. abfd->name will point to it. */
247 abfd
= bfd_fdopenr (scratch_pathname
, gnutarget
, scratch_chan
);
250 close (scratch_chan
);
251 error ("Could not open `%s' as an executable file: %s",
252 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
255 /* Leave bfd open, core_xfer_memory and "info files" need it. */
257 bfd_set_cacheable (abfd
, 1);
259 /* copy full path name into so_name, so that later symbol_file_add
261 if (strlen (scratch_pathname
) >= SO_NAME_MAX_PATH_SIZE
)
262 error ("Full path name length of shared library exceeds SO_NAME_MAX_PATH_SIZE in so_list structure.");
263 strcpy (so
->so_name
, scratch_pathname
);
265 if (!bfd_check_format (abfd
, bfd_object
))
267 error ("\"%s\": not in executable format: %s.",
268 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
270 if (build_section_table (abfd
, &so
->sections
, &so
->sections_end
))
272 error ("Can't find the file sections in `%s': %s",
273 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
276 for (p
= so
->sections
; p
< so
->sections_end
; p
++)
278 /* Relocate the section binding addresses as recorded in the shared
279 object's file by the base address to which the object was actually
281 TARGET_SO_RELOCATE_SECTION_ADDRESSES (so
, p
);
282 if (strcmp (p
->the_bfd_section
->name
, ".text") == 0)
288 /* Free the file names, close the file now. */
289 do_cleanups (old_chain
);
296 free_so --- free a `struct so_list' object
300 void free_so (struct so_list *so)
304 Free the storage associated with the `struct so_list' object SO.
305 If we have opened a BFD for SO, close it.
307 The caller is responsible for removing SO from whatever list it is
308 a member of. If we have placed SO's sections in some target's
309 section table, the caller is responsible for removing them.
311 This function doesn't mess with objfiles at all. If there is an
312 objfile associated with SO that needs to be removed, the caller is
313 responsible for taking care of that. */
316 free_so (struct so_list
*so
)
318 char *bfd_filename
= 0;
321 xfree (so
->sections
);
325 bfd_filename
= bfd_get_filename (so
->abfd
);
326 if (! bfd_close (so
->abfd
))
327 warning ("cannot close \"%s\": %s",
328 bfd_filename
, bfd_errmsg (bfd_get_error ()));
332 xfree (bfd_filename
);
334 TARGET_SO_FREE_SO (so
);
340 /* Return address of first so_list entry in master shared object list. */
342 master_so_list (void)
348 /* A small stub to get us past the arg-passing pinhole of catch_errors. */
351 symbol_add_stub (void *arg
)
353 struct so_list
*so
= (struct so_list
*) arg
; /* catch_errs bogon */
354 struct section_addr_info
*sap
;
356 /* Have we already loaded this shared object? */
357 ALL_OBJFILES (so
->objfile
)
359 if (strcmp (so
->objfile
->name
, so
->so_name
) == 0)
363 sap
= build_section_addr_info_from_section_table (so
->sections
,
366 so
->objfile
= symbol_file_add (so
->so_name
, so
->from_tty
,
367 sap
, 0, OBJF_SHARED
);
368 free_section_addr_info (sap
);
376 update_solib_list --- synchronize GDB's shared object list with inferior's
380 void update_solib_list (int from_tty, struct target_ops *TARGET)
382 Extract the list of currently loaded shared objects from the
383 inferior, and compare it with the list of shared objects currently
384 in GDB's so_list_head list. Edit so_list_head to bring it in sync
385 with the inferior's new list.
387 If we notice that the inferior has unloaded some shared objects,
388 free any symbolic info GDB had read about those shared objects.
390 Don't load symbolic info for any new shared objects; just add them
391 to the list, and leave their symbols_loaded flag clear.
393 If FROM_TTY is non-null, feel free to print messages about what
396 If TARGET is non-null, add the sections of all new shared objects
397 to TARGET's section table. Note that this doesn't remove any
398 sections for shared objects that have been unloaded, and it
399 doesn't check to see if the new shared objects are already present in
400 the section table. But we only use this for core files and
401 processes we've just attached to, so that's okay. */
404 update_solib_list (int from_tty
, struct target_ops
*target
)
406 struct so_list
*inferior
= TARGET_SO_CURRENT_SOS ();
407 struct so_list
*gdb
, **gdb_link
;
409 /* If we are attaching to a running process for which we
410 have not opened a symbol file, we may be able to get its
413 symfile_objfile
== NULL
)
414 catch_errors (TARGET_SO_OPEN_SYMBOL_FILE_OBJECT
, &from_tty
,
415 "Error reading attached process's symbol file.\n",
418 /* Since this function might actually add some elements to the
419 so_list_head list, arrange for it to be cleaned up when
421 if (!solib_cleanup_queued
)
423 make_run_cleanup (do_clear_solib
, NULL
);
424 solib_cleanup_queued
= 1;
427 /* GDB and the inferior's dynamic linker each maintain their own
428 list of currently loaded shared objects; we want to bring the
429 former in sync with the latter. Scan both lists, seeing which
430 shared objects appear where. There are three cases:
432 - A shared object appears on both lists. This means that GDB
433 knows about it already, and it's still loaded in the inferior.
434 Nothing needs to happen.
436 - A shared object appears only on GDB's list. This means that
437 the inferior has unloaded it. We should remove the shared
438 object from GDB's tables.
440 - A shared object appears only on the inferior's list. This
441 means that it's just been loaded. We should add it to GDB's
444 So we walk GDB's list, checking each entry to see if it appears
445 in the inferior's list too. If it does, no action is needed, and
446 we remove it from the inferior's list. If it doesn't, the
447 inferior has unloaded it, and we remove it from GDB's list. By
448 the time we're done walking GDB's list, the inferior's list
449 contains only the new shared objects, which we then add. */
452 gdb_link
= &so_list_head
;
455 struct so_list
*i
= inferior
;
456 struct so_list
**i_link
= &inferior
;
458 /* Check to see whether the shared object *gdb also appears in
459 the inferior's current list. */
462 if (! strcmp (gdb
->so_original_name
, i
->so_original_name
))
469 /* If the shared object appears on the inferior's list too, then
470 it's still loaded, so we don't need to do anything. Delete
471 it from the inferior's list, and leave it on GDB's list. */
476 gdb_link
= &gdb
->next
;
480 /* If it's not on the inferior's list, remove it from GDB's tables. */
483 /* Notify any observer that the SO has been unloaded
484 before we remove it from the gdb tables. */
485 observer_notify_solib_unloaded (gdb
);
487 *gdb_link
= gdb
->next
;
489 /* Unless the user loaded it explicitly, free SO's objfile. */
490 if (gdb
->objfile
&& ! (gdb
->objfile
->flags
& OBJF_USERLOADED
))
491 free_objfile (gdb
->objfile
);
493 /* Some targets' section tables might be referring to
494 sections from so->abfd; remove them. */
495 remove_target_sections (gdb
->abfd
);
502 /* Now the inferior's list contains only shared objects that don't
503 appear in GDB's list --- those that are newly loaded. Add them
504 to GDB's shared object list. */
509 /* Add the new shared objects to GDB's list. */
510 *gdb_link
= inferior
;
512 /* Fill in the rest of each of the `struct so_list' nodes. */
513 for (i
= inferior
; i
; i
= i
->next
)
515 i
->from_tty
= from_tty
;
517 /* Fill in the rest of the `struct so_list' node. */
518 catch_errors (solib_map_sections
, i
,
519 "Error while mapping shared library sections:\n",
522 /* If requested, add the shared object's sections to the TARGET's
523 section table. Do this immediately after mapping the object so
524 that later nodes in the list can query this object, as is needed
528 int count
= (i
->sections_end
- i
->sections
);
531 int space
= target_resize_to_sections (target
, count
);
532 memcpy (target
->to_sections
+ space
,
534 count
* sizeof (i
->sections
[0]));
544 solib_add -- read in symbol info for newly added shared libraries
548 void solib_add (char *pattern, int from_tty, struct target_ops
549 *TARGET, int readsyms)
553 Read in symbolic information for any shared objects whose names
554 match PATTERN. (If we've already read a shared object's symbol
555 info, leave it alone.) If PATTERN is zero, read them all.
557 If READSYMS is 0, defer reading symbolic information until later
558 but still do any needed low level processing.
560 FROM_TTY and TARGET are as described for update_solib_list, above. */
563 solib_add (char *pattern
, int from_tty
, struct target_ops
*target
, int readsyms
)
569 char *re_err
= re_comp (pattern
);
572 error ("Invalid regexp: %s", re_err
);
575 update_solib_list (from_tty
, target
);
577 /* Walk the list of currently loaded shared libraries, and read
578 symbols for any that match the pattern --- or any whose symbols
579 aren't already loaded, if no pattern was given. */
582 int loaded_any_symbols
= 0;
584 for (gdb
= so_list_head
; gdb
; gdb
= gdb
->next
)
585 if (! pattern
|| re_exec (gdb
->so_name
))
589 if (gdb
->symbols_loaded
)
592 printf_unfiltered ("Symbols already loaded for %s\n",
598 (symbol_add_stub
, gdb
,
599 "Error while reading shared library symbols:\n",
603 printf_unfiltered ("Loaded symbols for %s\n",
605 gdb
->symbols_loaded
= 1;
606 loaded_any_symbols
= 1;
611 if (from_tty
&& pattern
&& ! any_matches
)
613 ("No loaded shared libraries match the pattern `%s'.\n", pattern
);
615 if (loaded_any_symbols
)
617 /* Getting new symbols may change our opinion about what is
619 reinit_frame_cache ();
621 TARGET_SO_SPECIAL_SYMBOL_HANDLING ();
631 info_sharedlibrary_command -- code for "info sharedlibrary"
635 static void info_sharedlibrary_command ()
639 Walk through the shared library list and print information
640 about each attached library.
644 info_sharedlibrary_command (char *ignore
, int from_tty
)
646 struct so_list
*so
= NULL
; /* link map state variable */
650 if (TARGET_PTR_BIT
== 32)
652 else if (TARGET_PTR_BIT
== 64)
656 internal_error (__FILE__
, __LINE__
,
657 "TARGET_PTR_BIT returned unknown size %d",
661 update_solib_list (from_tty
, 0);
663 for (so
= so_list_head
; so
; so
= so
->next
)
669 printf_unfiltered ("%-*s%-*s%-12s%s\n", addr_width
, "From",
670 addr_width
, "To", "Syms Read",
671 "Shared Object Library");
675 printf_unfiltered ("%-*s", addr_width
,
676 so
->textsection
!= NULL
677 ? hex_string_custom (
678 (LONGEST
) so
->textsection
->addr
,
681 printf_unfiltered ("%-*s", addr_width
,
682 so
->textsection
!= NULL
683 ? hex_string_custom (
684 (LONGEST
) so
->textsection
->endaddr
,
687 printf_unfiltered ("%-12s", so
->symbols_loaded
? "Yes" : "No");
688 printf_unfiltered ("%s\n", so
->so_name
);
691 if (so_list_head
== NULL
)
693 printf_unfiltered ("No shared libraries loaded at this time.\n");
701 solib_address -- check to see if an address is in a shared lib
705 char * solib_address (CORE_ADDR address)
709 Provides a hook for other gdb routines to discover whether or
710 not a particular address is within the mapped address space of
713 For example, this routine is called at one point to disable
714 breakpoints which are in shared libraries that are not currently
719 solib_address (CORE_ADDR address
)
721 struct so_list
*so
= 0; /* link map state variable */
723 for (so
= so_list_head
; so
; so
= so
->next
)
725 struct section_table
*p
;
727 for (p
= so
->sections
; p
< so
->sections_end
; p
++)
729 if (p
->addr
<= address
&& address
< p
->endaddr
)
730 return (so
->so_name
);
737 /* Called by free_all_symtabs */
742 /* This function is expected to handle ELF shared libraries. It is
743 also used on Solaris, which can run either ELF or a.out binaries
744 (for compatibility with SunOS 4), both of which can use shared
745 libraries. So we don't know whether we have an ELF executable or
746 an a.out executable until the user chooses an executable file.
748 ELF shared libraries don't get mapped into the address space
749 until after the program starts, so we'd better not try to insert
750 breakpoints in them immediately. We have to wait until the
751 dynamic linker has loaded them; we'll hit a bp_shlib_event
752 breakpoint (look for calls to create_solib_event_breakpoint) when
755 SunOS shared libraries seem to be different --- they're present
756 as soon as the process begins execution, so there's no need to
757 put off inserting breakpoints. There's also nowhere to put a
758 bp_shlib_event breakpoint, so if we put it off, we'll never get
761 So: disable breakpoints only if we're using ELF shared libs. */
763 && bfd_get_flavour (exec_bfd
) != bfd_target_aout_flavour
)
764 disable_breakpoints_in_shlibs (1);
768 struct so_list
*so
= so_list_head
;
769 so_list_head
= so
->next
;
771 remove_target_sections (so
->abfd
);
775 TARGET_SO_CLEAR_SOLIB ();
779 do_clear_solib (void *dummy
)
781 solib_cleanup_queued
= 0;
787 solib_create_inferior_hook -- shared library startup support
791 void solib_create_inferior_hook()
795 When gdb starts up the inferior, it nurses it along (through the
796 shell) until it is ready to execute it's first instruction. At this
797 point, this function gets called via expansion of the macro
798 SOLIB_CREATE_INFERIOR_HOOK. */
801 solib_create_inferior_hook (void)
803 TARGET_SO_SOLIB_CREATE_INFERIOR_HOOK ();
808 in_solib_dynsym_resolve_code -- check to see if an address is in
809 dynamic loader's dynamic symbol
814 int in_solib_dynsym_resolve_code (CORE_ADDR pc)
818 Determine if PC is in the dynamic linker's symbol resolution
819 code. Return 1 if so, 0 otherwise.
823 in_solib_dynsym_resolve_code (CORE_ADDR pc
)
825 return TARGET_SO_IN_DYNSYM_RESOLVE_CODE (pc
);
832 sharedlibrary_command -- handle command to explicitly add library
836 static void sharedlibrary_command (char *args, int from_tty)
843 sharedlibrary_command (char *args
, int from_tty
)
846 solib_add (args
, from_tty
, (struct target_ops
*) 0, 1);
851 no_shared_libraries -- handle command to explicitly discard symbols
852 from shared libraries.
856 Implements the command "nosharedlibrary", which discards symbols
857 that have been auto-loaded from shared libraries. Symbols from
858 shared libraries that were added by explicit request of the user
859 are not discarded. Also called from remote.c. */
862 no_shared_libraries (char *ignored
, int from_tty
)
864 objfile_purge_solibs ();
865 do_clear_solib (NULL
);
869 reload_shared_libraries (char *ignored
, int from_tty
)
871 no_shared_libraries (NULL
, from_tty
);
872 solib_add (NULL
, from_tty
, NULL
, auto_solib_add
);
875 extern initialize_file_ftype _initialize_solib
; /* -Wmissing-prototypes */
878 _initialize_solib (void)
880 struct cmd_list_element
*c
;
882 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
883 "Load shared object library symbols for files matching REGEXP.");
884 add_info ("sharedlibrary", info_sharedlibrary_command
,
885 "Status of loaded shared object libraries.");
886 add_com ("nosharedlibrary", class_files
, no_shared_libraries
,
887 "Unload all shared object library symbols.");
889 deprecated_add_show_from_set
890 (add_set_cmd ("auto-solib-add", class_support
, var_boolean
,
891 (char *) &auto_solib_add
,
892 "Set autoloading of shared library symbols.\n\
893 If \"on\", symbols from all shared object libraries will be loaded\n\
894 automatically when the inferior begins execution, when the dynamic linker\n\
895 informs gdb that a new library has been loaded, or when attaching to the\n\
896 inferior. Otherwise, symbols must be loaded manually, using `sharedlibrary'.",
900 c
= add_set_cmd ("solib-absolute-prefix", class_support
, var_filename
,
901 (char *) &solib_absolute_prefix
,
902 "Set prefix for loading absolute shared library symbol files.\n\
903 For other (relative) files, you can add values using `set solib-search-path'.",
905 deprecated_add_show_from_set (c
, &showlist
);
906 set_cmd_cfunc (c
, reload_shared_libraries
);
907 set_cmd_completer (c
, filename_completer
);
909 /* Set the default value of "solib-absolute-prefix" from the sysroot, if
911 solib_absolute_prefix
= xstrdup (gdb_sysroot
);
913 c
= add_set_cmd ("solib-search-path", class_support
, var_string
,
914 (char *) &solib_search_path
,
915 "Set the search path for loading non-absolute shared library symbol files.\n\
916 This takes precedence over the environment variables PATH and LD_LIBRARY_PATH.",
918 deprecated_add_show_from_set (c
, &showlist
);
919 set_cmd_cfunc (c
, reload_shared_libraries
);
920 set_cmd_completer (c
, filename_completer
);