1 /* Handle SunOS and SVR4 shared libraries for GDB, the GNU Debugger.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998
3 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 2 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, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 /* This file is only compilable if link.h is available. */
28 #include <sys/types.h>
30 #include "gdb_string.h"
31 #include <sys/param.h>
35 #ifndef SVR4_SHARED_LIBS
36 /* SunOS shared libs need the nlist structure. */
39 #include "elf/external.h"
52 #include "gnu-regex.h"
58 #define MAX_PATH_SIZE 512 /* FIXME: Should be dynamic */
60 /* On SVR4 systems, a list of symbols in the dynamic linker where
61 GDB can try to place a breakpoint to monitor shared library
64 If none of these symbols are found, or other errors occur, then
65 SVR4 systems will fall back to using a symbol as the "startup
66 mapping complete" breakpoint address. */
68 #ifdef SVR4_SHARED_LIBS
69 static char *solib_break_names
[] = {
78 #define BKPT_AT_SYMBOL 1
80 #if defined (BKPT_AT_SYMBOL) && defined (SVR4_SHARED_LIBS)
81 static char *bkpt_names
[] = {
82 #ifdef SOLIB_BKPT_NAME
83 SOLIB_BKPT_NAME
, /* Prefer configured name if it exists. */
91 /* Symbols which are used to locate the base of the link map structures. */
93 #ifndef SVR4_SHARED_LIBS
94 static char *debug_base_symbols
[] = {
101 static char *main_name_list
[] = {
106 /* local data declarations */
108 #ifndef SVR4_SHARED_LIBS
110 #define LM_ADDR(so) ((so) -> lm.lm_addr)
111 #define LM_NEXT(so) ((so) -> lm.lm_next)
112 #define LM_NAME(so) ((so) -> lm.lm_name)
113 /* Test for first link map entry; first entry is a shared library. */
114 #define IGNORE_FIRST_LINK_MAP_ENTRY(x) (0)
115 static struct link_dynamic dynamic_copy
;
116 static struct link_dynamic_2 ld_2_copy
;
117 static struct ld_debug debug_copy
;
118 static CORE_ADDR debug_addr
;
119 static CORE_ADDR flag_addr
;
121 #else /* SVR4_SHARED_LIBS */
123 #define LM_ADDR(so) ((so) -> lm.l_addr)
124 #define LM_NEXT(so) ((so) -> lm.l_next)
125 #define LM_NAME(so) ((so) -> lm.l_name)
126 /* Test for first link map entry; first entry is the exec-file. */
127 #define IGNORE_FIRST_LINK_MAP_ENTRY(x) ((x).l_prev == NULL)
128 static struct r_debug debug_copy
;
129 char shadow_contents
[BREAKPOINT_MAX
]; /* Stash old bkpt addr contents */
131 #endif /* !SVR4_SHARED_LIBS */
134 struct so_list
*next
; /* next structure in linked list */
135 struct link_map lm
; /* copy of link map from inferior */
136 struct link_map
*lmaddr
; /* addr in inferior lm was read from */
137 CORE_ADDR lmend
; /* upper addr bound of mapped object */
138 char so_name
[MAX_PATH_SIZE
]; /* shared object lib name (FIXME) */
139 char symbols_loaded
; /* flag: symbols read in yet? */
140 char from_tty
; /* flag: print msgs? */
141 struct objfile
*objfile
; /* objfile for loaded lib */
142 struct section_table
*sections
;
143 struct section_table
*sections_end
;
144 struct section_table
*textsection
;
148 static struct so_list
*so_list_head
; /* List of known shared objects */
149 static CORE_ADDR debug_base
; /* Base of dynamic linker structures */
150 static CORE_ADDR breakpoint_addr
; /* Address where end bkpt is set */
152 static int solib_cleanup_queued
= 0; /* make_run_cleanup called */
155 fdmatch
PARAMS ((int, int)); /* In libiberty */
157 /* Local function prototypes */
160 do_clear_solib
PARAMS ((PTR
));
163 match_main
PARAMS ((char *));
166 special_symbol_handling
PARAMS ((struct so_list
*));
169 sharedlibrary_command
PARAMS ((char *, int));
172 enable_break
PARAMS ((void));
175 info_sharedlibrary_command
PARAMS ((char *, int));
178 symbol_add_stub
PARAMS ((char *));
180 static struct so_list
*
181 find_solib
PARAMS ((struct so_list
*));
183 static struct link_map
*
184 first_link_map_member
PARAMS ((void));
187 locate_base
PARAMS ((void));
190 solib_map_sections
PARAMS ((struct so_list
*));
192 #ifdef SVR4_SHARED_LIBS
195 elf_locate_base
PARAMS ((void));
200 disable_break
PARAMS ((void));
203 allocate_rt_common_objfile
PARAMS ((void));
206 solib_add_common_symbols
PARAMS ((struct rtc_symb
*));
210 /* If non-zero, this is a prefix that will be added to the front of the name
211 shared libraries with an absolute filename for loading. */
212 static char *solib_absolute_prefix
= NULL
;
214 /* If non-empty, this is a search path for loading non-absolute shared library
215 symbol files. This takes precedence over the environment variables PATH
216 and LD_LIBRARY_PATH. */
217 static char *solib_search_path
= NULL
;
223 solib_map_sections -- open bfd and build sections for shared lib
227 static void solib_map_sections (struct so_list *so)
231 Given a pointer to one of the shared objects in our list
232 of mapped objects, use the recorded name to open a bfd
233 descriptor for the object, build a section table, and then
234 relocate all the section addresses by the base address at
235 which the shared object was mapped.
239 In most (all?) cases the shared object file name recorded in the
240 dynamic linkage tables will be a fully qualified pathname. For
241 cases where it isn't, do we really mimic the systems search
242 mechanism correctly in the below code (particularly the tilde
247 solib_map_sections (so
)
251 char *scratch_pathname
;
253 struct section_table
*p
;
254 struct cleanup
*old_chain
;
257 filename
= tilde_expand (so
-> so_name
);
259 if (solib_absolute_prefix
&& ROOTED_P (filename
))
260 /* Prefix shared libraries with absolute filenames with
261 SOLIB_ABSOLUTE_PREFIX. */
266 pfx_len
= strlen (solib_absolute_prefix
);
268 /* Remove trailing slashes. */
269 while (pfx_len
> 0 && SLASH_P (solib_absolute_prefix
[pfx_len
- 1]))
272 pfxed_fn
= xmalloc (pfx_len
+ strlen (filename
) + 1);
273 strcpy (pfxed_fn
, solib_absolute_prefix
);
274 strcat (pfxed_fn
, filename
);
280 old_chain
= make_cleanup (free
, filename
);
284 if (solib_search_path
)
285 scratch_chan
= openp (solib_search_path
,
286 1, filename
, O_RDONLY
, 0, &scratch_pathname
);
287 if (scratch_chan
< 0)
288 scratch_chan
= openp (get_in_environ (inferior_environ
, "PATH"),
289 1, filename
, O_RDONLY
, 0, &scratch_pathname
);
290 if (scratch_chan
< 0)
292 scratch_chan
= openp (get_in_environ
293 (inferior_environ
, "LD_LIBRARY_PATH"),
294 1, filename
, O_RDONLY
, 0, &scratch_pathname
);
296 if (scratch_chan
< 0)
298 perror_with_name (filename
);
300 /* Leave scratch_pathname allocated. abfd->name will point to it. */
302 abfd
= bfd_fdopenr (scratch_pathname
, gnutarget
, scratch_chan
);
305 close (scratch_chan
);
306 error ("Could not open `%s' as an executable file: %s",
307 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
309 /* Leave bfd open, core_xfer_memory and "info files" need it. */
311 abfd
-> cacheable
= true;
313 /* copy full path name into so_name, so that later symbol_file_add can find
315 if (strlen (scratch_pathname
) >= MAX_PATH_SIZE
)
316 error ("Full path name length of shared library exceeds MAX_PATH_SIZE in so_list structure.");
317 strcpy (so
->so_name
, scratch_pathname
);
319 if (!bfd_check_format (abfd
, bfd_object
))
321 error ("\"%s\": not in executable format: %s.",
322 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
324 if (build_section_table (abfd
, &so
-> sections
, &so
-> sections_end
))
326 error ("Can't find the file sections in `%s': %s",
327 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
330 for (p
= so
-> sections
; p
< so
-> sections_end
; p
++)
332 /* Relocate the section binding addresses as recorded in the shared
333 object's file by the base address to which the object was actually
335 p
-> addr
+= (CORE_ADDR
) LM_ADDR (so
);
336 p
-> endaddr
+= (CORE_ADDR
) LM_ADDR (so
);
337 so
-> lmend
= (CORE_ADDR
) max (p
-> endaddr
, so
-> lmend
);
338 if (STREQ (p
-> the_bfd_section
-> name
, ".text"))
340 so
-> textsection
= p
;
344 /* Free the file names, close the file now. */
345 do_cleanups (old_chain
);
348 #ifndef SVR4_SHARED_LIBS
350 /* Allocate the runtime common object file. */
353 allocate_rt_common_objfile ()
355 struct objfile
*objfile
;
356 struct objfile
*last_one
;
358 objfile
= (struct objfile
*) xmalloc (sizeof (struct objfile
));
359 memset (objfile
, 0, sizeof (struct objfile
));
360 objfile
-> md
= NULL
;
361 obstack_specify_allocation (&objfile
-> psymbol_cache
.cache
, 0, 0,
363 obstack_specify_allocation (&objfile
-> psymbol_obstack
, 0, 0, xmalloc
,
365 obstack_specify_allocation (&objfile
-> symbol_obstack
, 0, 0, xmalloc
,
367 obstack_specify_allocation (&objfile
-> type_obstack
, 0, 0, xmalloc
,
369 objfile
-> name
= mstrsave (objfile
-> md
, "rt_common");
371 /* Add this file onto the tail of the linked list of other such files. */
373 objfile
-> next
= NULL
;
374 if (object_files
== NULL
)
375 object_files
= objfile
;
378 for (last_one
= object_files
;
380 last_one
= last_one
-> next
);
381 last_one
-> next
= objfile
;
384 rt_common_objfile
= objfile
;
387 /* Read all dynamically loaded common symbol definitions from the inferior
388 and put them into the minimal symbol table for the runtime common
392 solib_add_common_symbols (rtc_symp
)
393 struct rtc_symb
*rtc_symp
;
395 struct rtc_symb inferior_rtc_symb
;
396 struct nlist inferior_rtc_nlist
;
400 /* Remove any runtime common symbols from previous runs. */
402 if (rt_common_objfile
!= NULL
&& rt_common_objfile
-> minimal_symbol_count
)
404 obstack_free (&rt_common_objfile
-> symbol_obstack
, 0);
405 obstack_specify_allocation (&rt_common_objfile
-> symbol_obstack
, 0, 0,
407 rt_common_objfile
-> minimal_symbol_count
= 0;
408 rt_common_objfile
-> msymbols
= NULL
;
411 init_minimal_symbol_collection ();
412 make_cleanup (discard_minimal_symbols
, 0);
416 read_memory ((CORE_ADDR
) rtc_symp
,
417 (char *) &inferior_rtc_symb
,
418 sizeof (inferior_rtc_symb
));
419 read_memory ((CORE_ADDR
) inferior_rtc_symb
.rtc_sp
,
420 (char *) &inferior_rtc_nlist
,
421 sizeof(inferior_rtc_nlist
));
422 if (inferior_rtc_nlist
.n_type
== N_COMM
)
424 /* FIXME: The length of the symbol name is not available, but in the
425 current implementation the common symbol is allocated immediately
426 behind the name of the symbol. */
427 len
= inferior_rtc_nlist
.n_value
- inferior_rtc_nlist
.n_un
.n_strx
;
429 name
= xmalloc (len
);
430 read_memory ((CORE_ADDR
) inferior_rtc_nlist
.n_un
.n_name
, name
, len
);
432 /* Allocate the runtime common objfile if necessary. */
433 if (rt_common_objfile
== NULL
)
434 allocate_rt_common_objfile ();
436 prim_record_minimal_symbol (name
, inferior_rtc_nlist
.n_value
,
437 mst_bss
, rt_common_objfile
);
440 rtc_symp
= inferior_rtc_symb
.rtc_next
;
443 /* Install any minimal symbols that have been collected as the current
444 minimal symbols for the runtime common objfile. */
446 install_minimal_symbols (rt_common_objfile
);
449 #endif /* SVR4_SHARED_LIBS */
452 #ifdef SVR4_SHARED_LIBS
455 bfd_lookup_symbol
PARAMS ((bfd
*, char *));
461 bfd_lookup_symbol -- lookup the value for a specific symbol
465 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
469 An expensive way to lookup the value of a single symbol for
470 bfd's that are only temporary anyway. This is used by the
471 shared library support to find the address of the debugger
472 interface structures in the shared library.
474 Note that 0 is specifically allowed as an error return (no
479 bfd_lookup_symbol (abfd
, symname
)
483 unsigned int storage_needed
;
485 asymbol
**symbol_table
;
486 unsigned int number_of_symbols
;
488 struct cleanup
*back_to
;
489 CORE_ADDR symaddr
= 0;
491 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
493 if (storage_needed
> 0)
495 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
496 back_to
= make_cleanup (free
, (PTR
)symbol_table
);
497 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
499 for (i
= 0; i
< number_of_symbols
; i
++)
501 sym
= *symbol_table
++;
502 if (STREQ (sym
-> name
, symname
))
504 /* Bfd symbols are section relative. */
505 symaddr
= sym
-> value
+ sym
-> section
-> vma
;
509 do_cleanups (back_to
);
514 #ifdef HANDLE_SVR4_EXEC_EMULATORS
517 Solaris BCP (the part of Solaris which allows it to run SunOS4
518 a.out files) throws in another wrinkle. Solaris does not fill
519 in the usual a.out link map structures when running BCP programs,
520 the only way to get at them is via groping around in the dynamic
522 The dynamic linker and it's structures are located in the shared
523 C library, which gets run as the executable's "interpreter" by
526 Note that we can assume nothing about the process state at the time
527 we need to find these structures. We may be stopped on the first
528 instruction of the interpreter (C shared library), the first
529 instruction of the executable itself, or somewhere else entirely
530 (if we attached to the process for example).
533 static char *debug_base_symbols
[] = {
534 "r_debug", /* Solaris 2.3 */
535 "_r_debug", /* Solaris 2.1, 2.2 */
540 look_for_base
PARAMS ((int, CORE_ADDR
));
546 look_for_base -- examine file for each mapped address segment
550 static int look_for_base (int fd, CORE_ADDR baseaddr)
554 This function is passed to proc_iterate_over_mappings, which
555 causes it to get called once for each mapped address space, with
556 an open file descriptor for the file mapped to that space, and the
557 base address of that mapped space.
559 Our job is to find the debug base symbol in the file that this
560 fd is open on, if it exists, and if so, initialize the dynamic
561 linker structure base address debug_base.
563 Note that this is a computationally expensive proposition, since
564 we basically have to open a bfd on every call, so we specifically
565 avoid opening the exec file.
569 look_for_base (fd
, baseaddr
)
574 CORE_ADDR address
= 0;
577 /* If the fd is -1, then there is no file that corresponds to this
578 mapped memory segment, so skip it. Also, if the fd corresponds
579 to the exec file, skip it as well. */
583 && fdmatch (fileno ((GDB_FILE
*)(exec_bfd
-> iostream
)), fd
)))
588 /* Try to open whatever random file this fd corresponds to. Note that
589 we have no way currently to find the filename. Don't gripe about
590 any problems we might have, just fail. */
592 if ((interp_bfd
= bfd_fdopenr ("unnamed", gnutarget
, fd
)) == NULL
)
596 if (!bfd_check_format (interp_bfd
, bfd_object
))
598 /* FIXME-leak: on failure, might not free all memory associated with
600 bfd_close (interp_bfd
);
604 /* Now try to find our debug base symbol in this file, which we at
605 least know to be a valid ELF executable or shared library. */
607 for (symbolp
= debug_base_symbols
; *symbolp
!= NULL
; symbolp
++)
609 address
= bfd_lookup_symbol (interp_bfd
, *symbolp
);
617 /* FIXME-leak: on failure, might not free all memory associated with
619 bfd_close (interp_bfd
);
623 /* Eureka! We found the symbol. But now we may need to relocate it
624 by the base address. If the symbol's value is less than the base
625 address of the shared library, then it hasn't yet been relocated
626 by the dynamic linker, and we have to do it ourself. FIXME: Note
627 that we make the assumption that the first segment that corresponds
628 to the shared library has the base address to which the library
631 if (address
< baseaddr
)
635 debug_base
= address
;
636 /* FIXME-leak: on failure, might not free all memory associated with
638 bfd_close (interp_bfd
);
641 #endif /* HANDLE_SVR4_EXEC_EMULATORS */
647 elf_locate_base -- locate the base address of dynamic linker structs
648 for SVR4 elf targets.
652 CORE_ADDR elf_locate_base (void)
656 For SVR4 elf targets the address of the dynamic linker's runtime
657 structure is contained within the dynamic info section in the
658 executable file. The dynamic section is also mapped into the
659 inferior address space. Because the runtime loader fills in the
660 real address before starting the inferior, we have to read in the
661 dynamic info section from the inferior address space.
662 If there are any errors while trying to find the address, we
663 silently return 0, otherwise the found address is returned.
670 sec_ptr dyninfo_sect
;
671 int dyninfo_sect_size
;
672 CORE_ADDR dyninfo_addr
;
676 /* Find the start address of the .dynamic section. */
677 dyninfo_sect
= bfd_get_section_by_name (exec_bfd
, ".dynamic");
678 if (dyninfo_sect
== NULL
)
680 dyninfo_addr
= bfd_section_vma (exec_bfd
, dyninfo_sect
);
682 /* Read in .dynamic section, silently ignore errors. */
683 dyninfo_sect_size
= bfd_section_size (exec_bfd
, dyninfo_sect
);
684 buf
= alloca (dyninfo_sect_size
);
685 if (target_read_memory (dyninfo_addr
, buf
, dyninfo_sect_size
))
688 /* Find the DT_DEBUG entry in the the .dynamic section.
689 For mips elf we look for DT_MIPS_RLD_MAP, mips elf apparently has
690 no DT_DEBUG entries. */
692 for (bufend
= buf
+ dyninfo_sect_size
;
694 buf
+= sizeof (Elf32_External_Dyn
))
696 Elf32_External_Dyn
*x_dynp
= (Elf32_External_Dyn
*)buf
;
700 dyn_tag
= bfd_h_get_32 (exec_bfd
, (bfd_byte
*) x_dynp
->d_tag
);
701 if (dyn_tag
== DT_NULL
)
703 else if (dyn_tag
== DT_DEBUG
)
705 dyn_ptr
= bfd_h_get_32 (exec_bfd
, (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
708 #ifdef DT_MIPS_RLD_MAP
709 else if (dyn_tag
== DT_MIPS_RLD_MAP
)
711 char pbuf
[TARGET_PTR_BIT
/ HOST_CHAR_BIT
];
713 /* DT_MIPS_RLD_MAP contains a pointer to the address
714 of the dynamic link structure. */
715 dyn_ptr
= bfd_h_get_32 (exec_bfd
, (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
716 if (target_read_memory (dyn_ptr
, pbuf
, sizeof (pbuf
)))
718 return extract_unsigned_integer (pbuf
, sizeof (pbuf
));
723 for (bufend
= buf
+ dyninfo_sect_size
;
725 buf
+= sizeof (Elf64_External_Dyn
))
727 Elf64_External_Dyn
*x_dynp
= (Elf64_External_Dyn
*)buf
;
731 dyn_tag
= bfd_h_get_64 (exec_bfd
, (bfd_byte
*) x_dynp
->d_tag
);
732 if (dyn_tag
== DT_NULL
)
734 else if (dyn_tag
== DT_DEBUG
)
736 dyn_ptr
= bfd_h_get_64 (exec_bfd
, (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
742 /* DT_DEBUG entry not found. */
746 #endif /* SVR4_SHARED_LIBS */
752 locate_base -- locate the base address of dynamic linker structs
756 CORE_ADDR locate_base (void)
760 For both the SunOS and SVR4 shared library implementations, if the
761 inferior executable has been linked dynamically, there is a single
762 address somewhere in the inferior's data space which is the key to
763 locating all of the dynamic linker's runtime structures. This
764 address is the value of the debug base symbol. The job of this
765 function is to find and return that address, or to return 0 if there
766 is no such address (the executable is statically linked for example).
768 For SunOS, the job is almost trivial, since the dynamic linker and
769 all of it's structures are statically linked to the executable at
770 link time. Thus the symbol for the address we are looking for has
771 already been added to the minimal symbol table for the executable's
772 objfile at the time the symbol file's symbols were read, and all we
773 have to do is look it up there. Note that we explicitly do NOT want
774 to find the copies in the shared library.
776 The SVR4 version is a bit more complicated because the address
777 is contained somewhere in the dynamic info section. We have to go
778 to a lot more work to discover the address of the debug base symbol.
779 Because of this complexity, we cache the value we find and return that
780 value on subsequent invocations. Note there is no copy in the
781 executable symbol tables.
789 #ifndef SVR4_SHARED_LIBS
791 struct minimal_symbol
*msymbol
;
792 CORE_ADDR address
= 0;
795 /* For SunOS, we want to limit the search for the debug base symbol to the
796 executable being debugged, since there is a duplicate named symbol in the
797 shared library. We don't want the shared library versions. */
799 for (symbolp
= debug_base_symbols
; *symbolp
!= NULL
; symbolp
++)
801 msymbol
= lookup_minimal_symbol (*symbolp
, NULL
, symfile_objfile
);
802 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
804 address
= SYMBOL_VALUE_ADDRESS (msymbol
);
810 #else /* SVR4_SHARED_LIBS */
812 /* Check to see if we have a currently valid address, and if so, avoid
813 doing all this work again and just return the cached address. If
814 we have no cached address, try to locate it in the dynamic info
815 section for ELF executables. */
820 && bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
821 debug_base
= elf_locate_base ();
822 #ifdef HANDLE_SVR4_EXEC_EMULATORS
823 /* Try it the hard way for emulated executables. */
824 else if (inferior_pid
!= 0 && target_has_execution
)
825 proc_iterate_over_mappings (look_for_base
);
830 #endif /* !SVR4_SHARED_LIBS */
838 first_link_map_member -- locate first member in dynamic linker's map
842 static struct link_map *first_link_map_member (void)
846 Read in a copy of the first member in the inferior's dynamic
847 link map from the inferior's dynamic linker structures, and return
848 a pointer to the copy in our address space.
851 static struct link_map
*
852 first_link_map_member ()
854 struct link_map
*lm
= NULL
;
856 #ifndef SVR4_SHARED_LIBS
858 read_memory (debug_base
, (char *) &dynamic_copy
, sizeof (dynamic_copy
));
859 if (dynamic_copy
.ld_version
>= 2)
861 /* It is a version that we can deal with, so read in the secondary
862 structure and find the address of the link map list from it. */
863 read_memory ((CORE_ADDR
) dynamic_copy
.ld_un
.ld_2
, (char *) &ld_2_copy
,
864 sizeof (struct link_dynamic_2
));
865 lm
= ld_2_copy
.ld_loaded
;
868 #else /* SVR4_SHARED_LIBS */
870 read_memory (debug_base
, (char *) &debug_copy
, sizeof (struct r_debug
));
871 /* FIXME: Perhaps we should validate the info somehow, perhaps by
872 checking r_version for a known version number, or r_state for
874 lm
= debug_copy
.r_map
;
876 #endif /* !SVR4_SHARED_LIBS */
885 find_solib -- step through list of shared objects
889 struct so_list *find_solib (struct so_list *so_list_ptr)
893 This module contains the routine which finds the names of any
894 loaded "images" in the current process. The argument in must be
895 NULL on the first call, and then the returned value must be passed
896 in on subsequent calls. This provides the capability to "step" down
897 the list of loaded objects. On the last object, a NULL value is
900 The arg and return value are "struct link_map" pointers, as defined
904 static struct so_list
*
905 find_solib (so_list_ptr
)
906 struct so_list
*so_list_ptr
; /* Last lm or NULL for first one */
908 struct so_list
*so_list_next
= NULL
;
909 struct link_map
*lm
= NULL
;
912 if (so_list_ptr
== NULL
)
914 /* We are setting up for a new scan through the loaded images. */
915 if ((so_list_next
= so_list_head
) == NULL
)
917 /* We have not already read in the dynamic linking structures
918 from the inferior, lookup the address of the base structure. */
919 debug_base
= locate_base ();
922 /* Read the base structure in and find the address of the first
923 link map list member. */
924 lm
= first_link_map_member ();
930 /* We have been called before, and are in the process of walking
931 the shared library list. Advance to the next shared object. */
932 if ((lm
= LM_NEXT (so_list_ptr
)) == NULL
)
934 /* We have hit the end of the list, so check to see if any were
935 added, but be quiet if we can't read from the target any more. */
936 int status
= target_read_memory ((CORE_ADDR
) so_list_ptr
-> lmaddr
,
937 (char *) &(so_list_ptr
-> lm
),
938 sizeof (struct link_map
));
941 lm
= LM_NEXT (so_list_ptr
);
948 so_list_next
= so_list_ptr
-> next
;
950 if ((so_list_next
== NULL
) && (lm
!= NULL
))
952 /* Get next link map structure from inferior image and build a local
953 abbreviated load_map structure */
954 new = (struct so_list
*) xmalloc (sizeof (struct so_list
));
955 memset ((char *) new, 0, sizeof (struct so_list
));
957 /* Add the new node as the next node in the list, or as the root
958 node if this is the first one. */
959 if (so_list_ptr
!= NULL
)
961 so_list_ptr
-> next
= new;
967 if (! solib_cleanup_queued
)
969 make_run_cleanup (do_clear_solib
);
970 solib_cleanup_queued
= 1;
975 read_memory ((CORE_ADDR
) lm
, (char *) &(new -> lm
),
976 sizeof (struct link_map
));
977 /* For SVR4 versions, the first entry in the link map is for the
978 inferior executable, so we must ignore it. For some versions of
979 SVR4, it has no name. For others (Solaris 2.3 for example), it
980 does have a name, so we can no longer use a missing name to
981 decide when to ignore it. */
982 if (!IGNORE_FIRST_LINK_MAP_ENTRY (new -> lm
))
986 target_read_string ((CORE_ADDR
) LM_NAME (new), &buffer
,
987 MAX_PATH_SIZE
- 1, &errcode
);
989 error ("find_solib: Can't read pathname for load map: %s\n",
990 safe_strerror (errcode
));
991 strncpy (new -> so_name
, buffer
, MAX_PATH_SIZE
- 1);
992 new -> so_name
[MAX_PATH_SIZE
- 1] = '\0';
994 solib_map_sections (new);
997 return (so_list_next
);
1000 /* A small stub to get us past the arg-passing pinhole of catch_errors. */
1003 symbol_add_stub (arg
)
1006 register struct so_list
*so
= (struct so_list
*) arg
; /* catch_errs bogon */
1007 CORE_ADDR text_addr
= 0;
1009 if (so
-> textsection
)
1010 text_addr
= so
-> textsection
-> addr
;
1013 asection
*lowest_sect
;
1015 /* If we didn't find a mapped non zero sized .text section, set up
1016 text_addr so that the relocation in symbol_file_add does no harm. */
1018 lowest_sect
= bfd_get_section_by_name (so
-> abfd
, ".text");
1019 if (lowest_sect
== NULL
)
1020 bfd_map_over_sections (so
-> abfd
, find_lowest_section
,
1021 (PTR
) &lowest_sect
);
1023 text_addr
= bfd_section_vma (so
-> abfd
, lowest_sect
)
1024 + (CORE_ADDR
) LM_ADDR (so
);
1027 ALL_OBJFILES (so
-> objfile
)
1029 if (strcmp (so
-> objfile
-> name
, so
-> so_name
) == 0)
1033 symbol_file_add (so
-> so_name
, so
-> from_tty
,
1039 /* This function will check the so name to see if matches the main list.
1040 In some system the main object is in the list, which we want to exclude */
1042 static int match_main (soname
)
1047 for (mainp
= main_name_list
; *mainp
!= NULL
; mainp
++)
1049 if (strcmp (soname
, *mainp
) == 0)
1060 solib_add -- add a shared library file to the symtab and section list
1064 void solib_add (char *arg_string, int from_tty,
1065 struct target_ops *target)
1072 solib_add (arg_string
, from_tty
, target
)
1075 struct target_ops
*target
;
1077 register struct so_list
*so
= NULL
; /* link map state variable */
1079 /* Last shared library that we read. */
1080 struct so_list
*so_last
= NULL
;
1086 if ((re_err
= re_comp (arg_string
? arg_string
: ".")) != NULL
)
1088 error ("Invalid regexp: %s", re_err
);
1091 /* Add the shared library sections to the section table of the
1092 specified target, if any. */
1095 /* Count how many new section_table entries there are. */
1098 while ((so
= find_solib (so
)) != NULL
)
1100 if (so
-> so_name
[0] && !match_main (so
-> so_name
))
1102 count
+= so
-> sections_end
- so
-> sections
;
1110 /* We must update the to_sections field in the core_ops structure
1111 here, otherwise we dereference a potential dangling pointer
1112 for each call to target_read/write_memory within this routine. */
1113 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
1115 /* Reallocate the target's section table including the new size. */
1116 if (target
-> to_sections
)
1118 old
= target
-> to_sections_end
- target
-> to_sections
;
1119 target
-> to_sections
= (struct section_table
*)
1120 xrealloc ((char *)target
-> to_sections
,
1121 (sizeof (struct section_table
)) * (count
+ old
));
1126 target
-> to_sections
= (struct section_table
*)
1127 xmalloc ((sizeof (struct section_table
)) * count
);
1129 target
-> to_sections_end
= target
-> to_sections
+ (count
+ old
);
1131 /* Update the to_sections field in the core_ops structure
1135 core_ops
.to_sections
= target
->to_sections
;
1136 core_ops
.to_sections_end
= target
->to_sections_end
;
1139 /* Add these section table entries to the target's table. */
1140 while ((so
= find_solib (so
)) != NULL
)
1142 if (so
-> so_name
[0])
1144 count
= so
-> sections_end
- so
-> sections
;
1145 memcpy ((char *) (target
-> to_sections
+ old
),
1147 (sizeof (struct section_table
)) * count
);
1154 /* Now add the symbol files. */
1155 while ((so
= find_solib (so
)) != NULL
)
1157 if (so
-> so_name
[0] && re_exec (so
-> so_name
) &&
1158 !match_main (so
-> so_name
))
1160 so
-> from_tty
= from_tty
;
1161 if (so
-> symbols_loaded
)
1165 printf_unfiltered ("Symbols already loaded for %s\n", so
-> so_name
);
1168 else if (catch_errors
1169 (symbol_add_stub
, (char *) so
,
1170 "Error while reading shared library symbols:\n",
1174 so
-> symbols_loaded
= 1;
1179 /* Getting new symbols may change our opinion about what is
1182 reinit_frame_cache ();
1185 special_symbol_handling (so_last
);
1192 info_sharedlibrary_command -- code for "info sharedlibrary"
1196 static void info_sharedlibrary_command ()
1200 Walk through the shared library list and print information
1201 about each attached library.
1205 info_sharedlibrary_command (ignore
, from_tty
)
1209 register struct so_list
*so
= NULL
; /* link map state variable */
1210 int header_done
= 0;
1214 if (exec_bfd
== NULL
)
1216 printf_unfiltered ("No exec file.\n");
1220 #ifndef TARGET_ELF64
1228 while ((so
= find_solib (so
)) != NULL
)
1230 if (so
-> so_name
[0])
1234 printf_unfiltered("%-*s%-*s%-12s%s\n", addr_width
, "From",
1235 addr_width
, "To", "Syms Read",
1236 "Shared Object Library");
1240 printf_unfiltered ("%-*s", addr_width
,
1241 local_hex_string_custom ((unsigned long) LM_ADDR (so
),
1243 printf_unfiltered ("%-*s", addr_width
,
1244 local_hex_string_custom ((unsigned long) so
-> lmend
,
1246 printf_unfiltered ("%-12s", so
-> symbols_loaded
? "Yes" : "No");
1247 printf_unfiltered ("%s\n", so
-> so_name
);
1250 if (so_list_head
== NULL
)
1252 printf_unfiltered ("No shared libraries loaded at this time.\n");
1260 solib_address -- check to see if an address is in a shared lib
1264 char * solib_address (CORE_ADDR address)
1268 Provides a hook for other gdb routines to discover whether or
1269 not a particular address is within the mapped address space of
1270 a shared library. Any address between the base mapping address
1271 and the first address beyond the end of the last mapping, is
1272 considered to be within the shared library address space, for
1275 For example, this routine is called at one point to disable
1276 breakpoints which are in shared libraries that are not currently
1281 solib_address (address
)
1284 register struct so_list
*so
= 0; /* link map state variable */
1286 while ((so
= find_solib (so
)) != NULL
)
1288 if (so
-> so_name
[0])
1290 if ((address
>= (CORE_ADDR
) LM_ADDR (so
)) &&
1291 (address
< (CORE_ADDR
) so
-> lmend
))
1292 return (so
->so_name
);
1298 /* Called by free_all_symtabs */
1303 struct so_list
*next
;
1306 while (so_list_head
)
1308 if (so_list_head
-> sections
)
1310 free ((PTR
)so_list_head
-> sections
);
1312 if (so_list_head
-> abfd
)
1314 bfd_filename
= bfd_get_filename (so_list_head
-> abfd
);
1315 if (!bfd_close (so_list_head
-> abfd
))
1316 warning ("cannot close \"%s\": %s",
1317 bfd_filename
, bfd_errmsg (bfd_get_error ()));
1320 /* This happens for the executable on SVR4. */
1321 bfd_filename
= NULL
;
1323 next
= so_list_head
-> next
;
1325 free ((PTR
)bfd_filename
);
1326 free ((PTR
)so_list_head
);
1327 so_list_head
= next
;
1333 do_clear_solib (dummy
)
1336 solib_cleanup_queued
= 0;
1340 #ifdef SVR4_SHARED_LIBS
1342 /* Return 1 if PC lies in the dynamic symbol resolution code of the
1343 SVR4 run time loader. */
1345 static CORE_ADDR interp_text_sect_low
;
1346 static CORE_ADDR interp_text_sect_high
;
1347 static CORE_ADDR interp_plt_sect_low
;
1348 static CORE_ADDR interp_plt_sect_high
;
1351 in_svr4_dynsym_resolve_code (pc
)
1354 return ((pc
>= interp_text_sect_low
&& pc
< interp_text_sect_high
)
1355 || (pc
>= interp_plt_sect_low
&& pc
< interp_plt_sect_high
)
1356 || in_plt_section (pc
, NULL
));
1364 disable_break -- remove the "mapping changed" breakpoint
1368 static int disable_break ()
1372 Removes the breakpoint that gets hit when the dynamic linker
1373 completes a mapping change.
1377 #ifndef SVR4_SHARED_LIBS
1384 #ifndef SVR4_SHARED_LIBS
1386 int in_debugger
= 0;
1388 /* Read the debugger structure from the inferior to retrieve the
1389 address of the breakpoint and the original contents of the
1390 breakpoint address. Remove the breakpoint by writing the original
1393 read_memory (debug_addr
, (char *) &debug_copy
, sizeof (debug_copy
));
1395 /* Set `in_debugger' to zero now. */
1397 write_memory (flag_addr
, (char *) &in_debugger
, sizeof (in_debugger
));
1399 breakpoint_addr
= (CORE_ADDR
) debug_copy
.ldd_bp_addr
;
1400 write_memory (breakpoint_addr
, (char *) &debug_copy
.ldd_bp_inst
,
1401 sizeof (debug_copy
.ldd_bp_inst
));
1403 #else /* SVR4_SHARED_LIBS */
1405 /* Note that breakpoint address and original contents are in our address
1406 space, so we just need to write the original contents back. */
1408 if (memory_remove_breakpoint (breakpoint_addr
, shadow_contents
) != 0)
1413 #endif /* !SVR4_SHARED_LIBS */
1415 /* For the SVR4 version, we always know the breakpoint address. For the
1416 SunOS version we don't know it until the above code is executed.
1417 Grumble if we are stopped anywhere besides the breakpoint address. */
1419 if (stop_pc
!= breakpoint_addr
)
1421 warning ("stopped at unknown breakpoint while handling shared libraries");
1427 #endif /* #ifdef SVR4_SHARED_LIBS */
1433 enable_break -- arrange for dynamic linker to hit breakpoint
1437 int enable_break (void)
1441 Both the SunOS and the SVR4 dynamic linkers have, as part of their
1442 debugger interface, support for arranging for the inferior to hit
1443 a breakpoint after mapping in the shared libraries. This function
1444 enables that breakpoint.
1446 For SunOS, there is a special flag location (in_debugger) which we
1447 set to 1. When the dynamic linker sees this flag set, it will set
1448 a breakpoint at a location known only to itself, after saving the
1449 original contents of that place and the breakpoint address itself,
1450 in it's own internal structures. When we resume the inferior, it
1451 will eventually take a SIGTRAP when it runs into the breakpoint.
1452 We handle this (in a different place) by restoring the contents of
1453 the breakpointed location (which is only known after it stops),
1454 chasing around to locate the shared libraries that have been
1455 loaded, then resuming.
1457 For SVR4, the debugger interface structure contains a member (r_brk)
1458 which is statically initialized at the time the shared library is
1459 built, to the offset of a function (_r_debug_state) which is guaran-
1460 teed to be called once before mapping in a library, and again when
1461 the mapping is complete. At the time we are examining this member,
1462 it contains only the unrelocated offset of the function, so we have
1463 to do our own relocation. Later, when the dynamic linker actually
1464 runs, it relocates r_brk to be the actual address of _r_debug_state().
1466 The debugger interface structure also contains an enumeration which
1467 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
1468 depending upon whether or not the library is being mapped or unmapped,
1469 and then set to RT_CONSISTENT after the library is mapped/unmapped.
1477 #ifndef SVR4_SHARED_LIBS
1482 /* Get link_dynamic structure */
1484 j
= target_read_memory (debug_base
, (char *) &dynamic_copy
,
1485 sizeof (dynamic_copy
));
1492 /* Calc address of debugger interface structure */
1494 debug_addr
= (CORE_ADDR
) dynamic_copy
.ldd
;
1496 /* Calc address of `in_debugger' member of debugger interface structure */
1498 flag_addr
= debug_addr
+ (CORE_ADDR
) ((char *) &debug_copy
.ldd_in_debugger
-
1499 (char *) &debug_copy
);
1501 /* Write a value of 1 to this member. */
1504 write_memory (flag_addr
, (char *) &in_debugger
, sizeof (in_debugger
));
1507 #else /* SVR4_SHARED_LIBS */
1509 #ifdef BKPT_AT_SYMBOL
1511 struct minimal_symbol
*msymbol
;
1513 asection
*interp_sect
;
1515 /* First, remove all the solib event breakpoints. Their addresses
1516 may have changed since the last time we ran the program. */
1517 remove_solib_event_breakpoints ();
1519 #ifdef SVR4_SHARED_LIBS
1520 interp_text_sect_low
= interp_text_sect_high
= 0;
1521 interp_plt_sect_low
= interp_plt_sect_high
= 0;
1523 /* Find the .interp section; if not found, warn the user and drop
1524 into the old breakpoint at symbol code. */
1525 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
1528 unsigned int interp_sect_size
;
1530 CORE_ADDR load_addr
;
1532 CORE_ADDR sym_addr
= 0;
1534 /* Read the contents of the .interp section into a local buffer;
1535 the contents specify the dynamic linker this program uses. */
1536 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
1537 buf
= alloca (interp_sect_size
);
1538 bfd_get_section_contents (exec_bfd
, interp_sect
,
1539 buf
, 0, interp_sect_size
);
1541 /* Now we need to figure out where the dynamic linker was
1542 loaded so that we can load its symbols and place a breakpoint
1543 in the dynamic linker itself.
1545 This address is stored on the stack. However, I've been unable
1546 to find any magic formula to find it for Solaris (appears to
1547 be trivial on Linux). Therefore, we have to try an alternate
1548 mechanism to find the dynamic linker's base address. */
1549 tmp_bfd
= bfd_openr (buf
, gnutarget
);
1550 if (tmp_bfd
== NULL
)
1551 goto bkpt_at_symbol
;
1553 /* Make sure the dynamic linker's really a useful object. */
1554 if (!bfd_check_format (tmp_bfd
, bfd_object
))
1556 warning ("Unable to grok dynamic linker %s as an object file", buf
);
1557 bfd_close (tmp_bfd
);
1558 goto bkpt_at_symbol
;
1561 /* We find the dynamic linker's base address by examining the
1562 current pc (which point at the entry point for the dynamic
1563 linker) and subtracting the offset of the entry point. */
1564 load_addr
= read_pc () - tmp_bfd
->start_address
;
1566 /* Record the relocated start and end address of the dynamic linker
1567 text and plt section for in_svr4_dynsym_resolve_code. */
1568 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
1571 interp_text_sect_low
=
1572 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1573 interp_text_sect_high
=
1574 interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1576 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
1579 interp_plt_sect_low
=
1580 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1581 interp_plt_sect_high
=
1582 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1585 /* Now try to set a breakpoint in the dynamic linker. */
1586 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1588 sym_addr
= bfd_lookup_symbol (tmp_bfd
, *bkpt_namep
);
1593 /* We're done with the temporary bfd. */
1594 bfd_close (tmp_bfd
);
1598 create_solib_event_breakpoint (load_addr
+ sym_addr
);
1602 /* For whatever reason we couldn't set a breakpoint in the dynamic
1603 linker. Warn and drop into the old code. */
1605 warning ("Unable to find dynamic linker breakpoint function.");
1606 warning ("GDB will be unable to debug shared library initializers");
1607 warning ("and track explicitly loaded dynamic code.");
1611 /* Scan through the list of symbols, trying to look up the symbol and
1612 set a breakpoint there. Terminate loop when we/if we succeed. */
1614 breakpoint_addr
= 0;
1615 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1617 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
1618 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
1620 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol
));
1625 /* Nothing good happened. */
1628 #endif /* BKPT_AT_SYMBOL */
1630 #endif /* !SVR4_SHARED_LIBS */
1639 solib_create_inferior_hook -- shared library startup support
1643 void solib_create_inferior_hook()
1647 When gdb starts up the inferior, it nurses it along (through the
1648 shell) until it is ready to execute it's first instruction. At this
1649 point, this function gets called via expansion of the macro
1650 SOLIB_CREATE_INFERIOR_HOOK.
1652 For SunOS executables, this first instruction is typically the
1653 one at "_start", or a similar text label, regardless of whether
1654 the executable is statically or dynamically linked. The runtime
1655 startup code takes care of dynamically linking in any shared
1656 libraries, once gdb allows the inferior to continue.
1658 For SVR4 executables, this first instruction is either the first
1659 instruction in the dynamic linker (for dynamically linked
1660 executables) or the instruction at "start" for statically linked
1661 executables. For dynamically linked executables, the system
1662 first exec's /lib/libc.so.N, which contains the dynamic linker,
1663 and starts it running. The dynamic linker maps in any needed
1664 shared libraries, maps in the actual user executable, and then
1665 jumps to "start" in the user executable.
1667 For both SunOS shared libraries, and SVR4 shared libraries, we
1668 can arrange to cooperate with the dynamic linker to discover the
1669 names of shared libraries that are dynamically linked, and the
1670 base addresses to which they are linked.
1672 This function is responsible for discovering those names and
1673 addresses, and saving sufficient information about them to allow
1674 their symbols to be read at a later time.
1678 Between enable_break() and disable_break(), this code does not
1679 properly handle hitting breakpoints which the user might have
1680 set in the startup code or in the dynamic linker itself. Proper
1681 handling will probably have to wait until the implementation is
1682 changed to use the "breakpoint handler function" method.
1684 Also, what if child has exit()ed? Must exit loop somehow.
1688 solib_create_inferior_hook()
1690 static int dyn_relocated
;
1692 /* If we are using the BKPT_AT_SYMBOL code, then we don't need the base
1693 yet. In fact, in the case of a SunOS4 executable being run on
1694 Solaris, we can't get it yet. find_solib will get it when it needs
1696 #if !(defined (SVR4_SHARED_LIBS) && defined (BKPT_AT_SYMBOL))
1697 if ((debug_base
= locate_base ()) == 0)
1699 /* Can't find the symbol or the executable is statically linked. */
1704 if (!enable_break ())
1706 warning ("shared library handler failed to enable breakpoint");
1710 if (!dyn_relocated
&& exec_bfd
->start_address
!= stop_pc
)
1712 /* We have to relocate the debug information. */
1713 CORE_ADDR displacement
= stop_pc
- exec_bfd
->start_address
;
1714 struct section_offsets
*new_offsets
;
1717 new_offsets
= alloca (symfile_objfile
->num_sections
1718 * sizeof (*new_offsets
));
1720 for (i
= 0; i
< symfile_objfile
->num_sections
; ++i
)
1721 ANOFFSET (new_offsets
, i
) =
1722 ANOFFSET (symfile_objfile
->section_offsets
, i
);
1724 ANOFFSET (new_offsets
, SECT_OFF_TEXT
) += displacement
;
1725 ANOFFSET (new_offsets
, SECT_OFF_DATA
) += displacement
;
1726 ANOFFSET (new_offsets
, SECT_OFF_BSS
) += displacement
;
1727 ANOFFSET (new_offsets
, SECT_OFF_RODATA
) += displacement
;
1729 objfile_relocate (symfile_objfile
, new_offsets
);
1730 breakpoint_re_set ();
1732 /* Make sure this relocation is done only once. */
1736 #ifndef SVR4_SHARED_LIBS
1737 /* Only SunOS needs the loop below, other systems should be using the
1738 special shared library breakpoints and the shared library breakpoint
1741 Now run the target. It will eventually hit the breakpoint, at
1742 which point all of the libraries will have been mapped in and we
1743 can go groveling around in the dynamic linker structures to find
1744 out what we need to know about them. */
1746 clear_proceed_status ();
1747 stop_soon_quietly
= 1;
1748 stop_signal
= TARGET_SIGNAL_0
;
1751 target_resume (-1, 0, stop_signal
);
1752 wait_for_inferior ();
1754 while (stop_signal
!= TARGET_SIGNAL_TRAP
);
1755 stop_soon_quietly
= 0;
1757 /* We are now either at the "mapping complete" breakpoint (or somewhere
1758 else, a condition we aren't prepared to deal with anyway), so adjust
1759 the PC as necessary after a breakpoint, disable the breakpoint, and
1760 add any shared libraries that were mapped in. */
1762 if (DECR_PC_AFTER_BREAK
)
1764 stop_pc
-= DECR_PC_AFTER_BREAK
;
1765 write_register (PC_REGNUM
, stop_pc
);
1768 if (!disable_break ())
1770 warning ("shared library handler failed to disable breakpoint");
1774 solib_add ((char *) 0, 0, (struct target_ops
*) 0);
1782 special_symbol_handling -- additional shared library symbol handling
1786 void special_symbol_handling (struct so_list *so)
1790 Once the symbols from a shared object have been loaded in the usual
1791 way, we are called to do any system specific symbol handling that
1794 For SunOS4, this consists of grunging around in the dynamic
1795 linkers structures to find symbol definitions for "common" symbols
1796 and adding them to the minimal symbol table for the runtime common
1802 special_symbol_handling (so
)
1805 #ifndef SVR4_SHARED_LIBS
1808 if (debug_addr
== 0)
1810 /* Get link_dynamic structure */
1812 j
= target_read_memory (debug_base
, (char *) &dynamic_copy
,
1813 sizeof (dynamic_copy
));
1820 /* Calc address of debugger interface structure */
1821 /* FIXME, this needs work for cross-debugging of core files
1822 (byteorder, size, alignment, etc). */
1824 debug_addr
= (CORE_ADDR
) dynamic_copy
.ldd
;
1827 /* Read the debugger structure from the inferior, just to make sure
1828 we have a current copy. */
1830 j
= target_read_memory (debug_addr
, (char *) &debug_copy
,
1831 sizeof (debug_copy
));
1833 return; /* unreadable */
1835 /* Get common symbol definitions for the loaded object. */
1837 if (debug_copy
.ldd_cp
)
1839 solib_add_common_symbols (debug_copy
.ldd_cp
);
1842 #endif /* !SVR4_SHARED_LIBS */
1850 sharedlibrary_command -- handle command to explicitly add library
1854 static void sharedlibrary_command (char *args, int from_tty)
1861 sharedlibrary_command (args
, from_tty
)
1866 solib_add (args
, from_tty
, (struct target_ops
*) 0);
1869 #endif /* HAVE_LINK_H */
1876 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
1877 "Load shared object library symbols for files matching REGEXP.");
1878 add_info ("sharedlibrary", info_sharedlibrary_command
,
1879 "Status of loaded shared object libraries.");
1882 (add_set_cmd ("auto-solib-add", class_support
, var_zinteger
,
1883 (char *) &auto_solib_add
,
1884 "Set autoloading of shared library symbols.\n\
1885 If nonzero, symbols from all shared object libraries will be loaded\n\
1886 automatically when the inferior begins execution or when the dynamic linker\n\
1887 informs gdb that a new library has been loaded. Otherwise, symbols\n\
1888 must be loaded manually, using `sharedlibrary'.",
1893 (add_set_cmd ("solib-absolute-prefix", class_support
, var_filename
,
1894 (char *) &solib_absolute_prefix
,
1895 "Set prefix for loading absolute shared library symbol files.\n\
1896 For other (relative) files, you can add values using `set solib-search-path'.",
1900 (add_set_cmd ("solib-search-path", class_support
, var_string
,
1901 (char *) &solib_search_path
,
1902 "Set the search path for loading non-absolute shared library symbol files.\n\
1903 This takes precedence over the environment variables PATH and LD_LIBRARY_PATH.",
1907 #endif /* HAVE_LINK_H */