1 /* Handle SunOS and SVR4 shared libraries for GDB, the GNU Debugger.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996
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
[] = {
77 #define BKPT_AT_SYMBOL 1
79 #if defined (BKPT_AT_SYMBOL) && defined (SVR4_SHARED_LIBS)
80 static char *bkpt_names
[] = {
81 #ifdef SOLIB_BKPT_NAME
82 SOLIB_BKPT_NAME
, /* Prefer configured name if it exists. */
90 /* Symbols which are used to locate the base of the link map structures. */
92 #ifndef SVR4_SHARED_LIBS
93 static char *debug_base_symbols
[] = {
100 static char *main_name_list
[] = {
105 /* local data declarations */
107 #ifndef SVR4_SHARED_LIBS
109 #define LM_ADDR(so) ((so) -> lm.lm_addr)
110 #define LM_NEXT(so) ((so) -> lm.lm_next)
111 #define LM_NAME(so) ((so) -> lm.lm_name)
112 /* Test for first link map entry; first entry is a shared library. */
113 #define IGNORE_FIRST_LINK_MAP_ENTRY(x) (0)
114 static struct link_dynamic dynamic_copy
;
115 static struct link_dynamic_2 ld_2_copy
;
116 static struct ld_debug debug_copy
;
117 static CORE_ADDR debug_addr
;
118 static CORE_ADDR flag_addr
;
120 #else /* SVR4_SHARED_LIBS */
122 #define LM_ADDR(so) ((so) -> lm.l_addr)
123 #define LM_NEXT(so) ((so) -> lm.l_next)
124 #define LM_NAME(so) ((so) -> lm.l_name)
125 /* Test for first link map entry; first entry is the exec-file. */
126 #define IGNORE_FIRST_LINK_MAP_ENTRY(x) ((x).l_prev == NULL)
127 static struct r_debug debug_copy
;
128 char shadow_contents
[BREAKPOINT_MAX
]; /* Stash old bkpt addr contents */
130 #endif /* !SVR4_SHARED_LIBS */
133 struct so_list
*next
; /* next structure in linked list */
134 struct link_map lm
; /* copy of link map from inferior */
135 struct link_map
*lmaddr
; /* addr in inferior lm was read from */
136 CORE_ADDR lmend
; /* upper addr bound of mapped object */
137 char so_name
[MAX_PATH_SIZE
]; /* shared object lib name (FIXME) */
138 char symbols_loaded
; /* flag: symbols read in yet? */
139 char from_tty
; /* flag: print msgs? */
140 struct objfile
*objfile
; /* objfile for loaded lib */
141 struct section_table
*sections
;
142 struct section_table
*sections_end
;
143 struct section_table
*textsection
;
147 static struct so_list
*so_list_head
; /* List of known shared objects */
148 static CORE_ADDR debug_base
; /* Base of dynamic linker structures */
149 static CORE_ADDR breakpoint_addr
; /* Address where end bkpt is set */
152 fdmatch
PARAMS ((int, int)); /* In libiberty */
154 /* Local function prototypes */
157 special_symbol_handling
PARAMS ((struct so_list
*));
160 sharedlibrary_command
PARAMS ((char *, int));
163 enable_break
PARAMS ((void));
166 info_sharedlibrary_command
PARAMS ((char *, int));
169 symbol_add_stub
PARAMS ((char *));
171 static struct so_list
*
172 find_solib
PARAMS ((struct so_list
*));
174 static struct link_map
*
175 first_link_map_member
PARAMS ((void));
178 locate_base
PARAMS ((void));
181 solib_map_sections
PARAMS ((struct so_list
*));
183 #ifdef SVR4_SHARED_LIBS
186 elf_locate_base
PARAMS ((void));
191 disable_break
PARAMS ((void));
194 allocate_rt_common_objfile
PARAMS ((void));
197 solib_add_common_symbols
PARAMS ((struct rtc_symb
*));
205 solib_map_sections -- open bfd and build sections for shared lib
209 static void solib_map_sections (struct so_list *so)
213 Given a pointer to one of the shared objects in our list
214 of mapped objects, use the recorded name to open a bfd
215 descriptor for the object, build a section table, and then
216 relocate all the section addresses by the base address at
217 which the shared object was mapped.
221 In most (all?) cases the shared object file name recorded in the
222 dynamic linkage tables will be a fully qualified pathname. For
223 cases where it isn't, do we really mimic the systems search
224 mechanism correctly in the below code (particularly the tilde
229 solib_map_sections (so
)
233 char *scratch_pathname
;
235 struct section_table
*p
;
236 struct cleanup
*old_chain
;
239 filename
= tilde_expand (so
-> so_name
);
240 old_chain
= make_cleanup (free
, filename
);
242 scratch_chan
= openp (get_in_environ (inferior_environ
, "PATH"),
243 1, filename
, O_RDONLY
, 0, &scratch_pathname
);
244 if (scratch_chan
< 0)
246 scratch_chan
= openp (get_in_environ
247 (inferior_environ
, "LD_LIBRARY_PATH"),
248 1, filename
, O_RDONLY
, 0, &scratch_pathname
);
250 if (scratch_chan
< 0)
252 perror_with_name (filename
);
254 /* Leave scratch_pathname allocated. abfd->name will point to it. */
256 abfd
= bfd_fdopenr (scratch_pathname
, gnutarget
, scratch_chan
);
259 close (scratch_chan
);
260 error ("Could not open `%s' as an executable file: %s",
261 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
263 /* Leave bfd open, core_xfer_memory and "info files" need it. */
265 abfd
-> cacheable
= true;
267 /* copy full path name into so_name, so that later symbol_file_add can find
269 if (strlen (scratch_pathname
) >= MAX_PATH_SIZE
)
270 error ("Full path name length of shared library exceeds MAX_PATH_SIZE in so_list structure.");
271 strcpy (so
->so_name
, scratch_pathname
);
273 if (!bfd_check_format (abfd
, bfd_object
))
275 error ("\"%s\": not in executable format: %s.",
276 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
278 if (build_section_table (abfd
, &so
-> sections
, &so
-> sections_end
))
280 error ("Can't find the file sections in `%s': %s",
281 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
284 for (p
= so
-> sections
; p
< so
-> sections_end
; p
++)
286 /* Relocate the section binding addresses as recorded in the shared
287 object's file by the base address to which the object was actually
289 p
-> addr
+= (CORE_ADDR
) LM_ADDR (so
);
290 p
-> endaddr
+= (CORE_ADDR
) LM_ADDR (so
);
291 so
-> lmend
= (CORE_ADDR
) max (p
-> endaddr
, so
-> lmend
);
292 if (STREQ (p
-> the_bfd_section
-> name
, ".text"))
294 so
-> textsection
= p
;
298 /* Free the file names, close the file now. */
299 do_cleanups (old_chain
);
302 #ifndef SVR4_SHARED_LIBS
304 /* Allocate the runtime common object file. */
307 allocate_rt_common_objfile ()
309 struct objfile
*objfile
;
310 struct objfile
*last_one
;
312 objfile
= (struct objfile
*) xmalloc (sizeof (struct objfile
));
313 memset (objfile
, 0, sizeof (struct objfile
));
314 objfile
-> md
= NULL
;
315 obstack_specify_allocation (&objfile
-> psymbol_cache
.cache
, 0, 0,
317 obstack_specify_allocation (&objfile
-> psymbol_obstack
, 0, 0, xmalloc
,
319 obstack_specify_allocation (&objfile
-> symbol_obstack
, 0, 0, xmalloc
,
321 obstack_specify_allocation (&objfile
-> type_obstack
, 0, 0, xmalloc
,
323 objfile
-> name
= mstrsave (objfile
-> md
, "rt_common");
325 /* Add this file onto the tail of the linked list of other such files. */
327 objfile
-> next
= NULL
;
328 if (object_files
== NULL
)
329 object_files
= objfile
;
332 for (last_one
= object_files
;
334 last_one
= last_one
-> next
);
335 last_one
-> next
= objfile
;
338 rt_common_objfile
= objfile
;
341 /* Read all dynamically loaded common symbol definitions from the inferior
342 and put them into the minimal symbol table for the runtime common
346 solib_add_common_symbols (rtc_symp
)
347 struct rtc_symb
*rtc_symp
;
349 struct rtc_symb inferior_rtc_symb
;
350 struct nlist inferior_rtc_nlist
;
354 /* Remove any runtime common symbols from previous runs. */
356 if (rt_common_objfile
!= NULL
&& rt_common_objfile
-> minimal_symbol_count
)
358 obstack_free (&rt_common_objfile
-> symbol_obstack
, 0);
359 obstack_specify_allocation (&rt_common_objfile
-> symbol_obstack
, 0, 0,
361 rt_common_objfile
-> minimal_symbol_count
= 0;
362 rt_common_objfile
-> msymbols
= NULL
;
365 init_minimal_symbol_collection ();
366 make_cleanup (discard_minimal_symbols
, 0);
370 read_memory ((CORE_ADDR
) rtc_symp
,
371 (char *) &inferior_rtc_symb
,
372 sizeof (inferior_rtc_symb
));
373 read_memory ((CORE_ADDR
) inferior_rtc_symb
.rtc_sp
,
374 (char *) &inferior_rtc_nlist
,
375 sizeof(inferior_rtc_nlist
));
376 if (inferior_rtc_nlist
.n_type
== N_COMM
)
378 /* FIXME: The length of the symbol name is not available, but in the
379 current implementation the common symbol is allocated immediately
380 behind the name of the symbol. */
381 len
= inferior_rtc_nlist
.n_value
- inferior_rtc_nlist
.n_un
.n_strx
;
383 name
= xmalloc (len
);
384 read_memory ((CORE_ADDR
) inferior_rtc_nlist
.n_un
.n_name
, name
, len
);
386 /* Allocate the runtime common objfile if necessary. */
387 if (rt_common_objfile
== NULL
)
388 allocate_rt_common_objfile ();
390 prim_record_minimal_symbol (name
, inferior_rtc_nlist
.n_value
,
391 mst_bss
, rt_common_objfile
);
394 rtc_symp
= inferior_rtc_symb
.rtc_next
;
397 /* Install any minimal symbols that have been collected as the current
398 minimal symbols for the runtime common objfile. */
400 install_minimal_symbols (rt_common_objfile
);
403 #endif /* SVR4_SHARED_LIBS */
406 #ifdef SVR4_SHARED_LIBS
409 bfd_lookup_symbol
PARAMS ((bfd
*, char *));
415 bfd_lookup_symbol -- lookup the value for a specific symbol
419 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
423 An expensive way to lookup the value of a single symbol for
424 bfd's that are only temporary anyway. This is used by the
425 shared library support to find the address of the debugger
426 interface structures in the shared library.
428 Note that 0 is specifically allowed as an error return (no
433 bfd_lookup_symbol (abfd
, symname
)
437 unsigned int storage_needed
;
439 asymbol
**symbol_table
;
440 unsigned int number_of_symbols
;
442 struct cleanup
*back_to
;
443 CORE_ADDR symaddr
= 0;
445 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
447 if (storage_needed
> 0)
449 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
450 back_to
= make_cleanup (free
, (PTR
)symbol_table
);
451 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
453 for (i
= 0; i
< number_of_symbols
; i
++)
455 sym
= *symbol_table
++;
456 if (STREQ (sym
-> name
, symname
))
458 /* Bfd symbols are section relative. */
459 symaddr
= sym
-> value
+ sym
-> section
-> vma
;
463 do_cleanups (back_to
);
468 #ifdef HANDLE_SVR4_EXEC_EMULATORS
471 Solaris BCP (the part of Solaris which allows it to run SunOS4
472 a.out files) throws in another wrinkle. Solaris does not fill
473 in the usual a.out link map structures when running BCP programs,
474 the only way to get at them is via groping around in the dynamic
476 The dynamic linker and it's structures are located in the shared
477 C library, which gets run as the executable's "interpreter" by
480 Note that we can assume nothing about the process state at the time
481 we need to find these structures. We may be stopped on the first
482 instruction of the interpreter (C shared library), the first
483 instruction of the executable itself, or somewhere else entirely
484 (if we attached to the process for example).
487 static char *debug_base_symbols
[] = {
488 "r_debug", /* Solaris 2.3 */
489 "_r_debug", /* Solaris 2.1, 2.2 */
494 look_for_base
PARAMS ((int, CORE_ADDR
));
500 look_for_base -- examine file for each mapped address segment
504 static int look_for_base (int fd, CORE_ADDR baseaddr)
508 This function is passed to proc_iterate_over_mappings, which
509 causes it to get called once for each mapped address space, with
510 an open file descriptor for the file mapped to that space, and the
511 base address of that mapped space.
513 Our job is to find the debug base symbol in the file that this
514 fd is open on, if it exists, and if so, initialize the dynamic
515 linker structure base address debug_base.
517 Note that this is a computationally expensive proposition, since
518 we basically have to open a bfd on every call, so we specifically
519 avoid opening the exec file.
523 look_for_base (fd
, baseaddr
)
528 CORE_ADDR address
= 0;
531 /* If the fd is -1, then there is no file that corresponds to this
532 mapped memory segment, so skip it. Also, if the fd corresponds
533 to the exec file, skip it as well. */
537 && fdmatch (fileno ((GDB_FILE
*)(exec_bfd
-> iostream
)), fd
)))
542 /* Try to open whatever random file this fd corresponds to. Note that
543 we have no way currently to find the filename. Don't gripe about
544 any problems we might have, just fail. */
546 if ((interp_bfd
= bfd_fdopenr ("unnamed", gnutarget
, fd
)) == NULL
)
550 if (!bfd_check_format (interp_bfd
, bfd_object
))
552 /* FIXME-leak: on failure, might not free all memory associated with
554 bfd_close (interp_bfd
);
558 /* Now try to find our debug base symbol in this file, which we at
559 least know to be a valid ELF executable or shared library. */
561 for (symbolp
= debug_base_symbols
; *symbolp
!= NULL
; symbolp
++)
563 address
= bfd_lookup_symbol (interp_bfd
, *symbolp
);
571 /* FIXME-leak: on failure, might not free all memory associated with
573 bfd_close (interp_bfd
);
577 /* Eureka! We found the symbol. But now we may need to relocate it
578 by the base address. If the symbol's value is less than the base
579 address of the shared library, then it hasn't yet been relocated
580 by the dynamic linker, and we have to do it ourself. FIXME: Note
581 that we make the assumption that the first segment that corresponds
582 to the shared library has the base address to which the library
585 if (address
< baseaddr
)
589 debug_base
= address
;
590 /* FIXME-leak: on failure, might not free all memory associated with
592 bfd_close (interp_bfd
);
595 #endif /* HANDLE_SVR4_EXEC_EMULATORS */
601 elf_locate_base -- locate the base address of dynamic linker structs
602 for SVR4 elf targets.
606 CORE_ADDR elf_locate_base (void)
610 For SVR4 elf targets the address of the dynamic linker's runtime
611 structure is contained within the dynamic info section in the
612 executable file. The dynamic section is also mapped into the
613 inferior address space. Because the runtime loader fills in the
614 real address before starting the inferior, we have to read in the
615 dynamic info section from the inferior address space.
616 If there are any errors while trying to find the address, we
617 silently return 0, otherwise the found address is returned.
624 sec_ptr dyninfo_sect
;
625 int dyninfo_sect_size
;
626 CORE_ADDR dyninfo_addr
;
630 /* Find the start address of the .dynamic section. */
631 dyninfo_sect
= bfd_get_section_by_name (exec_bfd
, ".dynamic");
632 if (dyninfo_sect
== NULL
)
634 dyninfo_addr
= bfd_section_vma (exec_bfd
, dyninfo_sect
);
636 /* Read in .dynamic section, silently ignore errors. */
637 dyninfo_sect_size
= bfd_section_size (exec_bfd
, dyninfo_sect
);
638 buf
= alloca (dyninfo_sect_size
);
639 if (target_read_memory (dyninfo_addr
, buf
, dyninfo_sect_size
))
642 /* Find the DT_DEBUG entry in the the .dynamic section.
643 For mips elf we look for DT_MIPS_RLD_MAP, mips elf apparently has
644 no DT_DEBUG entries. */
645 /* FIXME: In lack of a 64 bit ELF ABI the following code assumes
646 a 32 bit ELF ABI target. */
647 for (bufend
= buf
+ dyninfo_sect_size
;
649 buf
+= sizeof (Elf32_External_Dyn
))
651 Elf32_External_Dyn
*x_dynp
= (Elf32_External_Dyn
*)buf
;
655 dyn_tag
= bfd_h_get_32 (exec_bfd
, (bfd_byte
*) x_dynp
->d_tag
);
656 if (dyn_tag
== DT_NULL
)
658 else if (dyn_tag
== DT_DEBUG
)
660 dyn_ptr
= bfd_h_get_32 (exec_bfd
, (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
663 #ifdef DT_MIPS_RLD_MAP
664 else if (dyn_tag
== DT_MIPS_RLD_MAP
)
666 char pbuf
[TARGET_PTR_BIT
/ HOST_CHAR_BIT
];
668 /* DT_MIPS_RLD_MAP contains a pointer to the address
669 of the dynamic link structure. */
670 dyn_ptr
= bfd_h_get_32 (exec_bfd
, (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
671 if (target_read_memory (dyn_ptr
, pbuf
, sizeof (pbuf
)))
673 return extract_unsigned_integer (pbuf
, sizeof (pbuf
));
678 /* DT_DEBUG entry not found. */
682 #endif /* SVR4_SHARED_LIBS */
688 locate_base -- locate the base address of dynamic linker structs
692 CORE_ADDR locate_base (void)
696 For both the SunOS and SVR4 shared library implementations, if the
697 inferior executable has been linked dynamically, there is a single
698 address somewhere in the inferior's data space which is the key to
699 locating all of the dynamic linker's runtime structures. This
700 address is the value of the debug base symbol. The job of this
701 function is to find and return that address, or to return 0 if there
702 is no such address (the executable is statically linked for example).
704 For SunOS, the job is almost trivial, since the dynamic linker and
705 all of it's structures are statically linked to the executable at
706 link time. Thus the symbol for the address we are looking for has
707 already been added to the minimal symbol table for the executable's
708 objfile at the time the symbol file's symbols were read, and all we
709 have to do is look it up there. Note that we explicitly do NOT want
710 to find the copies in the shared library.
712 The SVR4 version is a bit more complicated because the address
713 is contained somewhere in the dynamic info section. We have to go
714 to a lot more work to discover the address of the debug base symbol.
715 Because of this complexity, we cache the value we find and return that
716 value on subsequent invocations. Note there is no copy in the
717 executable symbol tables.
725 #ifndef SVR4_SHARED_LIBS
727 struct minimal_symbol
*msymbol
;
728 CORE_ADDR address
= 0;
731 /* For SunOS, we want to limit the search for the debug base symbol to the
732 executable being debugged, since there is a duplicate named symbol in the
733 shared library. We don't want the shared library versions. */
735 for (symbolp
= debug_base_symbols
; *symbolp
!= NULL
; symbolp
++)
737 msymbol
= lookup_minimal_symbol (*symbolp
, NULL
, symfile_objfile
);
738 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
740 address
= SYMBOL_VALUE_ADDRESS (msymbol
);
746 #else /* SVR4_SHARED_LIBS */
748 /* Check to see if we have a currently valid address, and if so, avoid
749 doing all this work again and just return the cached address. If
750 we have no cached address, try to locate it in the dynamic info
751 section for ELF executables. */
756 && bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
757 debug_base
= elf_locate_base ();
758 #ifdef HANDLE_SVR4_EXEC_EMULATORS
759 /* Try it the hard way for emulated executables. */
760 else if (inferior_pid
!= 0 && target_has_execution
)
761 proc_iterate_over_mappings (look_for_base
);
766 #endif /* !SVR4_SHARED_LIBS */
774 first_link_map_member -- locate first member in dynamic linker's map
778 static struct link_map *first_link_map_member (void)
782 Read in a copy of the first member in the inferior's dynamic
783 link map from the inferior's dynamic linker structures, and return
784 a pointer to the copy in our address space.
787 static struct link_map
*
788 first_link_map_member ()
790 struct link_map
*lm
= NULL
;
792 #ifndef SVR4_SHARED_LIBS
794 read_memory (debug_base
, (char *) &dynamic_copy
, sizeof (dynamic_copy
));
795 if (dynamic_copy
.ld_version
>= 2)
797 /* It is a version that we can deal with, so read in the secondary
798 structure and find the address of the link map list from it. */
799 read_memory ((CORE_ADDR
) dynamic_copy
.ld_un
.ld_2
, (char *) &ld_2_copy
,
800 sizeof (struct link_dynamic_2
));
801 lm
= ld_2_copy
.ld_loaded
;
804 #else /* SVR4_SHARED_LIBS */
806 read_memory (debug_base
, (char *) &debug_copy
, sizeof (struct r_debug
));
807 /* FIXME: Perhaps we should validate the info somehow, perhaps by
808 checking r_version for a known version number, or r_state for
810 lm
= debug_copy
.r_map
;
812 #endif /* !SVR4_SHARED_LIBS */
821 find_solib -- step through list of shared objects
825 struct so_list *find_solib (struct so_list *so_list_ptr)
829 This module contains the routine which finds the names of any
830 loaded "images" in the current process. The argument in must be
831 NULL on the first call, and then the returned value must be passed
832 in on subsequent calls. This provides the capability to "step" down
833 the list of loaded objects. On the last object, a NULL value is
836 The arg and return value are "struct link_map" pointers, as defined
840 static struct so_list
*
841 find_solib (so_list_ptr
)
842 struct so_list
*so_list_ptr
; /* Last lm or NULL for first one */
844 struct so_list
*so_list_next
= NULL
;
845 struct link_map
*lm
= NULL
;
848 if (so_list_ptr
== NULL
)
850 /* We are setting up for a new scan through the loaded images. */
851 if ((so_list_next
= so_list_head
) == NULL
)
853 /* We have not already read in the dynamic linking structures
854 from the inferior, lookup the address of the base structure. */
855 debug_base
= locate_base ();
858 /* Read the base structure in and find the address of the first
859 link map list member. */
860 lm
= first_link_map_member ();
866 /* We have been called before, and are in the process of walking
867 the shared library list. Advance to the next shared object. */
868 if ((lm
= LM_NEXT (so_list_ptr
)) == NULL
)
870 /* We have hit the end of the list, so check to see if any were
871 added, but be quiet if we can't read from the target any more. */
872 int status
= target_read_memory ((CORE_ADDR
) so_list_ptr
-> lmaddr
,
873 (char *) &(so_list_ptr
-> lm
),
874 sizeof (struct link_map
));
877 lm
= LM_NEXT (so_list_ptr
);
884 so_list_next
= so_list_ptr
-> next
;
886 if ((so_list_next
== NULL
) && (lm
!= NULL
))
888 /* Get next link map structure from inferior image and build a local
889 abbreviated load_map structure */
890 new = (struct so_list
*) xmalloc (sizeof (struct so_list
));
891 memset ((char *) new, 0, sizeof (struct so_list
));
893 /* Add the new node as the next node in the list, or as the root
894 node if this is the first one. */
895 if (so_list_ptr
!= NULL
)
897 so_list_ptr
-> next
= new;
904 read_memory ((CORE_ADDR
) lm
, (char *) &(new -> lm
),
905 sizeof (struct link_map
));
906 /* For SVR4 versions, the first entry in the link map is for the
907 inferior executable, so we must ignore it. For some versions of
908 SVR4, it has no name. For others (Solaris 2.3 for example), it
909 does have a name, so we can no longer use a missing name to
910 decide when to ignore it. */
911 if (!IGNORE_FIRST_LINK_MAP_ENTRY (new -> lm
))
915 target_read_string ((CORE_ADDR
) LM_NAME (new), &buffer
,
916 MAX_PATH_SIZE
- 1, &errcode
);
918 error ("find_solib: Can't read pathname for load map: %s\n",
919 safe_strerror (errcode
));
920 strncpy (new -> so_name
, buffer
, MAX_PATH_SIZE
- 1);
921 new -> so_name
[MAX_PATH_SIZE
- 1] = '\0';
923 solib_map_sections (new);
926 return (so_list_next
);
929 /* A small stub to get us past the arg-passing pinhole of catch_errors. */
932 symbol_add_stub (arg
)
935 register struct so_list
*so
= (struct so_list
*) arg
; /* catch_errs bogon */
938 symbol_file_add (so
-> so_name
, so
-> from_tty
,
939 (so
->textsection
== NULL
941 : (unsigned int) so
-> textsection
-> addr
),
946 /* This function will check the so name to see if matches the main list.
947 In some system the main object is in the list, which we want to exclude */
949 static int match_main (soname
)
954 for (mainp
= main_name_list
; *mainp
!= NULL
; mainp
++)
956 if (strcmp (soname
, *mainp
) == 0)
967 solib_add -- add a shared library file to the symtab and section list
971 void solib_add (char *arg_string, int from_tty,
972 struct target_ops *target)
979 solib_add (arg_string
, from_tty
, target
)
982 struct target_ops
*target
;
984 register struct so_list
*so
= NULL
; /* link map state variable */
986 /* Last shared library that we read. */
987 struct so_list
*so_last
= NULL
;
993 if ((re_err
= re_comp (arg_string
? arg_string
: ".")) != NULL
)
995 error ("Invalid regexp: %s", re_err
);
998 /* Add the shared library sections to the section table of the
999 specified target, if any. */
1002 /* Count how many new section_table entries there are. */
1005 while ((so
= find_solib (so
)) != NULL
)
1007 if (so
-> so_name
[0] && !match_main (so
-> so_name
))
1009 count
+= so
-> sections_end
- so
-> sections
;
1017 /* We must update the to_sections field in the core_ops structure
1018 here, otherwise we dereference a potential dangling pointer
1019 for each call to target_read/write_memory within this routine. */
1020 update_coreops
= core_ops
.to_sections
== target
->to_sections
;
1022 /* Reallocate the target's section table including the new size. */
1023 if (target
-> to_sections
)
1025 old
= target
-> to_sections_end
- target
-> to_sections
;
1026 target
-> to_sections
= (struct section_table
*)
1027 xrealloc ((char *)target
-> to_sections
,
1028 (sizeof (struct section_table
)) * (count
+ old
));
1033 target
-> to_sections
= (struct section_table
*)
1034 xmalloc ((sizeof (struct section_table
)) * count
);
1036 target
-> to_sections_end
= target
-> to_sections
+ (count
+ old
);
1038 /* Update the to_sections field in the core_ops structure
1042 core_ops
.to_sections
= target
->to_sections
;
1043 core_ops
.to_sections_end
= target
->to_sections_end
;
1046 /* Add these section table entries to the target's table. */
1047 while ((so
= find_solib (so
)) != NULL
)
1049 if (so
-> so_name
[0])
1051 count
= so
-> sections_end
- so
-> sections
;
1052 memcpy ((char *) (target
-> to_sections
+ old
),
1054 (sizeof (struct section_table
)) * count
);
1061 /* Now add the symbol files. */
1062 while ((so
= find_solib (so
)) != NULL
)
1064 if (so
-> so_name
[0] && re_exec (so
-> so_name
) &&
1065 !match_main (so
-> so_name
))
1067 so
-> from_tty
= from_tty
;
1068 if (so
-> symbols_loaded
)
1072 printf_unfiltered ("Symbols already loaded for %s\n", so
-> so_name
);
1075 else if (catch_errors
1076 (symbol_add_stub
, (char *) so
,
1077 "Error while reading shared library symbols:\n",
1081 so
-> symbols_loaded
= 1;
1086 /* Getting new symbols may change our opinion about what is
1089 reinit_frame_cache ();
1092 special_symbol_handling (so_last
);
1099 info_sharedlibrary_command -- code for "info sharedlibrary"
1103 static void info_sharedlibrary_command ()
1107 Walk through the shared library list and print information
1108 about each attached library.
1112 info_sharedlibrary_command (ignore
, from_tty
)
1116 register struct so_list
*so
= NULL
; /* link map state variable */
1117 int header_done
= 0;
1119 if (exec_bfd
== NULL
)
1121 printf_unfiltered ("No exec file.\n");
1124 while ((so
= find_solib (so
)) != NULL
)
1126 if (so
-> so_name
[0])
1130 printf_unfiltered("%-12s%-12s%-12s%s\n", "From", "To", "Syms Read",
1131 "Shared Object Library");
1134 /* FIXME-32x64: need print_address_numeric with field width or
1136 printf_unfiltered ("%-12s",
1137 local_hex_string_custom ((unsigned long) LM_ADDR (so
),
1139 printf_unfiltered ("%-12s",
1140 local_hex_string_custom ((unsigned long) so
-> lmend
,
1142 printf_unfiltered ("%-12s", so
-> symbols_loaded
? "Yes" : "No");
1143 printf_unfiltered ("%s\n", so
-> so_name
);
1146 if (so_list_head
== NULL
)
1148 printf_unfiltered ("No shared libraries loaded at this time.\n");
1156 solib_address -- check to see if an address is in a shared lib
1160 char * solib_address (CORE_ADDR address)
1164 Provides a hook for other gdb routines to discover whether or
1165 not a particular address is within the mapped address space of
1166 a shared library. Any address between the base mapping address
1167 and the first address beyond the end of the last mapping, is
1168 considered to be within the shared library address space, for
1171 For example, this routine is called at one point to disable
1172 breakpoints which are in shared libraries that are not currently
1177 solib_address (address
)
1180 register struct so_list
*so
= 0; /* link map state variable */
1182 while ((so
= find_solib (so
)) != NULL
)
1184 if (so
-> so_name
[0])
1186 if ((address
>= (CORE_ADDR
) LM_ADDR (so
)) &&
1187 (address
< (CORE_ADDR
) so
-> lmend
))
1188 return (so
->so_name
);
1194 /* Called by free_all_symtabs */
1199 struct so_list
*next
;
1202 while (so_list_head
)
1204 if (so_list_head
-> sections
)
1206 free ((PTR
)so_list_head
-> sections
);
1208 if (so_list_head
-> abfd
)
1210 bfd_filename
= bfd_get_filename (so_list_head
-> abfd
);
1211 if (!bfd_close (so_list_head
-> abfd
))
1212 warning ("cannot close \"%s\": %s",
1213 bfd_filename
, bfd_errmsg (bfd_get_error ()));
1216 /* This happens for the executable on SVR4. */
1217 bfd_filename
= NULL
;
1219 next
= so_list_head
-> next
;
1221 free ((PTR
)bfd_filename
);
1222 free ((PTR
)so_list_head
);
1223 so_list_head
= next
;
1232 disable_break -- remove the "mapping changed" breakpoint
1236 static int disable_break ()
1240 Removes the breakpoint that gets hit when the dynamic linker
1241 completes a mapping change.
1245 #ifndef SVR4_SHARED_LIBS
1252 #ifndef SVR4_SHARED_LIBS
1254 int in_debugger
= 0;
1256 /* Read the debugger structure from the inferior to retrieve the
1257 address of the breakpoint and the original contents of the
1258 breakpoint address. Remove the breakpoint by writing the original
1261 read_memory (debug_addr
, (char *) &debug_copy
, sizeof (debug_copy
));
1263 /* Set `in_debugger' to zero now. */
1265 write_memory (flag_addr
, (char *) &in_debugger
, sizeof (in_debugger
));
1267 breakpoint_addr
= (CORE_ADDR
) debug_copy
.ldd_bp_addr
;
1268 write_memory (breakpoint_addr
, (char *) &debug_copy
.ldd_bp_inst
,
1269 sizeof (debug_copy
.ldd_bp_inst
));
1271 #else /* SVR4_SHARED_LIBS */
1273 /* Note that breakpoint address and original contents are in our address
1274 space, so we just need to write the original contents back. */
1276 if (memory_remove_breakpoint (breakpoint_addr
, shadow_contents
) != 0)
1281 #endif /* !SVR4_SHARED_LIBS */
1283 /* For the SVR4 version, we always know the breakpoint address. For the
1284 SunOS version we don't know it until the above code is executed.
1285 Grumble if we are stopped anywhere besides the breakpoint address. */
1287 if (stop_pc
!= breakpoint_addr
)
1289 warning ("stopped at unknown breakpoint while handling shared libraries");
1295 #endif /* #ifdef SVR4_SHARED_LIBS */
1301 enable_break -- arrange for dynamic linker to hit breakpoint
1305 int enable_break (void)
1309 Both the SunOS and the SVR4 dynamic linkers have, as part of their
1310 debugger interface, support for arranging for the inferior to hit
1311 a breakpoint after mapping in the shared libraries. This function
1312 enables that breakpoint.
1314 For SunOS, there is a special flag location (in_debugger) which we
1315 set to 1. When the dynamic linker sees this flag set, it will set
1316 a breakpoint at a location known only to itself, after saving the
1317 original contents of that place and the breakpoint address itself,
1318 in it's own internal structures. When we resume the inferior, it
1319 will eventually take a SIGTRAP when it runs into the breakpoint.
1320 We handle this (in a different place) by restoring the contents of
1321 the breakpointed location (which is only known after it stops),
1322 chasing around to locate the shared libraries that have been
1323 loaded, then resuming.
1325 For SVR4, the debugger interface structure contains a member (r_brk)
1326 which is statically initialized at the time the shared library is
1327 built, to the offset of a function (_r_debug_state) which is guaran-
1328 teed to be called once before mapping in a library, and again when
1329 the mapping is complete. At the time we are examining this member,
1330 it contains only the unrelocated offset of the function, so we have
1331 to do our own relocation. Later, when the dynamic linker actually
1332 runs, it relocates r_brk to be the actual address of _r_debug_state().
1334 The debugger interface structure also contains an enumeration which
1335 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
1336 depending upon whether or not the library is being mapped or unmapped,
1337 and then set to RT_CONSISTENT after the library is mapped/unmapped.
1345 #ifndef SVR4_SHARED_LIBS
1350 /* Get link_dynamic structure */
1352 j
= target_read_memory (debug_base
, (char *) &dynamic_copy
,
1353 sizeof (dynamic_copy
));
1360 /* Calc address of debugger interface structure */
1362 debug_addr
= (CORE_ADDR
) dynamic_copy
.ldd
;
1364 /* Calc address of `in_debugger' member of debugger interface structure */
1366 flag_addr
= debug_addr
+ (CORE_ADDR
) ((char *) &debug_copy
.ldd_in_debugger
-
1367 (char *) &debug_copy
);
1369 /* Write a value of 1 to this member. */
1372 write_memory (flag_addr
, (char *) &in_debugger
, sizeof (in_debugger
));
1375 #else /* SVR4_SHARED_LIBS */
1377 #ifdef BKPT_AT_SYMBOL
1379 struct minimal_symbol
*msymbol
;
1381 asection
*interp_sect
;
1383 /* First, remove all the solib event breakpoints. Their addresses
1384 may have changed since the last time we ran the program. */
1385 remove_solib_event_breakpoints ();
1387 #ifdef SVR4_SHARED_LIBS
1388 /* Find the .interp section; if not found, warn the user and drop
1389 into the old breakpoint at symbol code. */
1390 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
1393 unsigned int interp_sect_size
;
1395 CORE_ADDR load_addr
;
1397 CORE_ADDR sym_addr
= 0;
1399 /* Read the contents of the .interp section into a local buffer;
1400 the contents specify the dynamic linker this program uses. */
1401 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
1402 buf
= alloca (interp_sect_size
);
1403 bfd_get_section_contents (exec_bfd
, interp_sect
,
1404 buf
, 0, interp_sect_size
);
1406 /* Now we need to figure out where the dynamic linker was
1407 loaded so that we can load its symbols and place a breakpoint
1408 in the dynamic linker itself.
1410 This address is stored on the stack. However, I've been unable
1411 to find any magic formula to find it for Solaris (appears to
1412 be trivial on Linux). Therefore, we have to try an alternate
1413 mechanism to find the dynamic linker's base address. */
1414 tmp_bfd
= bfd_openr (buf
, gnutarget
);
1415 if (tmp_bfd
== NULL
)
1416 goto bkpt_at_symbol
;
1418 /* Make sure the dynamic linker's really a useful object. */
1419 if (!bfd_check_format (tmp_bfd
, bfd_object
))
1421 warning ("Unable to grok dynamic linker %s as an object file", buf
);
1422 bfd_close (tmp_bfd
);
1423 goto bkpt_at_symbol
;
1426 /* We find the dynamic linker's base address by examining the
1427 current pc (which point at the entry point for the dynamic
1428 linker) and subtracting the offset of the entry point. */
1429 load_addr
= read_pc () - tmp_bfd
->start_address
;
1431 /* Now try to set a breakpoint in the dynamic linker. */
1432 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1434 sym_addr
= bfd_lookup_symbol (tmp_bfd
, *bkpt_namep
);
1439 /* We're done with the temporary bfd. */
1440 bfd_close (tmp_bfd
);
1444 create_solib_event_breakpoint (load_addr
+ sym_addr
);
1448 /* For whatever reason we couldn't set a breakpoint in the dynamic
1449 linker. Warn and drop into the old code. */
1451 warning ("Unable to find dynamic linker breakpoint function.");
1452 warning ("GDB will be unable to debug shared library initializers");
1453 warning ("and track explicitly loaded dynamic code.");
1457 /* Scan through the list of symbols, trying to look up the symbol and
1458 set a breakpoint there. Terminate loop when we/if we succeed. */
1460 breakpoint_addr
= 0;
1461 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1463 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
1464 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
1466 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol
));
1471 /* Nothing good happened. */
1474 #endif /* BKPT_AT_SYMBOL */
1476 #endif /* !SVR4_SHARED_LIBS */
1485 solib_create_inferior_hook -- shared library startup support
1489 void solib_create_inferior_hook()
1493 When gdb starts up the inferior, it nurses it along (through the
1494 shell) until it is ready to execute it's first instruction. At this
1495 point, this function gets called via expansion of the macro
1496 SOLIB_CREATE_INFERIOR_HOOK.
1498 For SunOS executables, this first instruction is typically the
1499 one at "_start", or a similar text label, regardless of whether
1500 the executable is statically or dynamically linked. The runtime
1501 startup code takes care of dynamically linking in any shared
1502 libraries, once gdb allows the inferior to continue.
1504 For SVR4 executables, this first instruction is either the first
1505 instruction in the dynamic linker (for dynamically linked
1506 executables) or the instruction at "start" for statically linked
1507 executables. For dynamically linked executables, the system
1508 first exec's /lib/libc.so.N, which contains the dynamic linker,
1509 and starts it running. The dynamic linker maps in any needed
1510 shared libraries, maps in the actual user executable, and then
1511 jumps to "start" in the user executable.
1513 For both SunOS shared libraries, and SVR4 shared libraries, we
1514 can arrange to cooperate with the dynamic linker to discover the
1515 names of shared libraries that are dynamically linked, and the
1516 base addresses to which they are linked.
1518 This function is responsible for discovering those names and
1519 addresses, and saving sufficient information about them to allow
1520 their symbols to be read at a later time.
1524 Between enable_break() and disable_break(), this code does not
1525 properly handle hitting breakpoints which the user might have
1526 set in the startup code or in the dynamic linker itself. Proper
1527 handling will probably have to wait until the implementation is
1528 changed to use the "breakpoint handler function" method.
1530 Also, what if child has exit()ed? Must exit loop somehow.
1534 solib_create_inferior_hook()
1536 /* If we are using the BKPT_AT_SYMBOL code, then we don't need the base
1537 yet. In fact, in the case of a SunOS4 executable being run on
1538 Solaris, we can't get it yet. find_solib will get it when it needs
1540 #if !(defined (SVR4_SHARED_LIBS) && defined (BKPT_AT_SYMBOL))
1541 if ((debug_base
= locate_base ()) == 0)
1543 /* Can't find the symbol or the executable is statically linked. */
1548 if (!enable_break ())
1550 warning ("shared library handler failed to enable breakpoint");
1554 #ifndef SVR4_SHARED_LIBS
1555 /* Only SunOS needs the loop below, other systems should be using the
1556 special shared library breakpoints and the shared library breakpoint
1559 Now run the target. It will eventually hit the breakpoint, at
1560 which point all of the libraries will have been mapped in and we
1561 can go groveling around in the dynamic linker structures to find
1562 out what we need to know about them. */
1564 clear_proceed_status ();
1565 stop_soon_quietly
= 1;
1566 stop_signal
= TARGET_SIGNAL_0
;
1569 target_resume (-1, 0, stop_signal
);
1570 wait_for_inferior ();
1572 while (stop_signal
!= TARGET_SIGNAL_TRAP
);
1573 stop_soon_quietly
= 0;
1575 /* We are now either at the "mapping complete" breakpoint (or somewhere
1576 else, a condition we aren't prepared to deal with anyway), so adjust
1577 the PC as necessary after a breakpoint, disable the breakpoint, and
1578 add any shared libraries that were mapped in. */
1580 if (DECR_PC_AFTER_BREAK
)
1582 stop_pc
-= DECR_PC_AFTER_BREAK
;
1583 write_register (PC_REGNUM
, stop_pc
);
1586 if (!disable_break ())
1588 warning ("shared library handler failed to disable breakpoint");
1592 solib_add ((char *) 0, 0, (struct target_ops
*) 0);
1600 special_symbol_handling -- additional shared library symbol handling
1604 void special_symbol_handling (struct so_list *so)
1608 Once the symbols from a shared object have been loaded in the usual
1609 way, we are called to do any system specific symbol handling that
1612 For SunOS4, this consists of grunging around in the dynamic
1613 linkers structures to find symbol definitions for "common" symbols
1614 and adding them to the minimal symbol table for the runtime common
1620 special_symbol_handling (so
)
1623 #ifndef SVR4_SHARED_LIBS
1626 if (debug_addr
== 0)
1628 /* Get link_dynamic structure */
1630 j
= target_read_memory (debug_base
, (char *) &dynamic_copy
,
1631 sizeof (dynamic_copy
));
1638 /* Calc address of debugger interface structure */
1639 /* FIXME, this needs work for cross-debugging of core files
1640 (byteorder, size, alignment, etc). */
1642 debug_addr
= (CORE_ADDR
) dynamic_copy
.ldd
;
1645 /* Read the debugger structure from the inferior, just to make sure
1646 we have a current copy. */
1648 j
= target_read_memory (debug_addr
, (char *) &debug_copy
,
1649 sizeof (debug_copy
));
1651 return; /* unreadable */
1653 /* Get common symbol definitions for the loaded object. */
1655 if (debug_copy
.ldd_cp
)
1657 solib_add_common_symbols (debug_copy
.ldd_cp
);
1660 #endif /* !SVR4_SHARED_LIBS */
1668 sharedlibrary_command -- handle command to explicitly add library
1672 static void sharedlibrary_command (char *args, int from_tty)
1679 sharedlibrary_command (args
, from_tty
)
1684 solib_add (args
, from_tty
, (struct target_ops
*) 0);
1687 #endif /* HAVE_LINK_H */
1694 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
1695 "Load shared object library symbols for files matching REGEXP.");
1696 add_info ("sharedlibrary", info_sharedlibrary_command
,
1697 "Status of loaded shared object libraries.");
1700 (add_set_cmd ("auto-solib-add", class_support
, var_zinteger
,
1701 (char *) &auto_solib_add
,
1702 "Set autoloading of shared library symbols.\n\
1703 If nonzero, symbols from all shared object libraries will be loaded\n\
1704 automatically when the inferior begins execution or when the dynamic linker\n\
1705 informs gdb that a new library has been loaded. Otherwise, symbols\n\
1706 must be loaded manually, using `sharedlibrary'.",
1710 #endif /* HAVE_LINK_H */