1 /* Handle SunOS and SVR4 shared libraries for GDB, the GNU Debugger.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
4 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. */
27 #include <sys/types.h>
29 #include "gdb_string.h"
30 #include <sys/param.h>
33 #ifndef SVR4_SHARED_LIBS
34 /* SunOS shared libs need the nlist structure. */
38 #include "elf/external.h"
39 #include "elf/common.h"
51 #include "gdb_regex.h"
58 #include "solib-svr4.h"
60 #ifndef SVR4_FETCH_LINK_MAP_OFFSETS
61 #define SVR4_FETCH_LINK_MAP_OFFSETS() fetch_link_map_offsets ()
64 static struct link_map_offsets
*default_svr4_fetch_link_map_offsets (void);
65 static struct link_map_offsets
*(*fetch_link_map_offsets
)(void) =
66 default_svr4_fetch_link_map_offsets
;
68 /* legacy_svr4_fetch_link_map_offsets_hook is a pointer to a function
69 which is used to fetch link map offsets. It will only be set
70 by solib-legacy.c, if at all. */
71 struct link_map_offsets
*(*legacy_svr4_fetch_link_map_offsets_hook
)(void) = 0;
73 /* Link map info to include in an allocated so_list entry */
77 /* Pointer to copy of link map from inferior. The type is char *
78 rather than void *, so that we may use byte offsets to find the
79 various fields without the need for a cast. */
83 /* On SVR4 systems, a list of symbols in the dynamic linker where
84 GDB can try to place a breakpoint to monitor shared library
87 If none of these symbols are found, or other errors occur, then
88 SVR4 systems will fall back to using a symbol as the "startup
89 mapping complete" breakpoint address. */
91 #ifdef SVR4_SHARED_LIBS
92 static char *solib_break_names
[] =
103 #define BKPT_AT_SYMBOL 1
105 #if defined (BKPT_AT_SYMBOL) && defined (SVR4_SHARED_LIBS)
106 static char *bkpt_names
[] =
108 #ifdef SOLIB_BKPT_NAME
109 SOLIB_BKPT_NAME
, /* Prefer configured name if it exists. */
117 /* Symbols which are used to locate the base of the link map structures. */
119 #ifndef SVR4_SHARED_LIBS
120 static char *debug_base_symbols
[] =
128 static char *main_name_list
[] =
135 /* Fetch (and possibly build) an appropriate link_map_offsets structure
136 for native targets using struct definitions from link.h.
138 Note: For non-native targets (i.e. cross-debugging situations),
139 you need to define a target specific fetch_link_map_offsets()
140 function and call set_solib_svr4_fetch_link_map_offsets () to
141 register this function. */
143 static struct link_map_offsets
*
144 default_svr4_fetch_link_map_offsets (void)
146 if (legacy_svr4_fetch_link_map_offsets_hook
)
147 return legacy_svr4_fetch_link_map_offsets_hook ();
150 internal_error (__FILE__
, __LINE__
,
151 "default_svr4_fetch_link_map_offsets called without legacy link_map support enabled.");
156 /* Macro to extract an address from a solib structure.
157 When GDB is configured for some 32-bit targets (e.g. Solaris 2.7
158 sparc), BFD is configured to handle 64-bit targets, so CORE_ADDR is
159 64 bits. We have to extract only the significant bits of addresses
160 to get the right address when accessing the core file BFD. */
162 #define SOLIB_EXTRACT_ADDRESS(MEMBER) \
163 extract_address (&(MEMBER), sizeof (MEMBER))
165 /* local data declarations */
167 #ifndef SVR4_SHARED_LIBS
169 /* NOTE: converted the macros LM_ADDR, LM_NEXT, LM_NAME and
170 IGNORE_FIRST_LINK_MAP_ENTRY into functions (see below).
173 static struct link_dynamic dynamic_copy
;
174 static struct link_dynamic_2 ld_2_copy
;
175 static struct ld_debug debug_copy
;
176 static CORE_ADDR debug_addr
;
177 static CORE_ADDR flag_addr
;
179 #endif /* !SVR4_SHARED_LIBS */
181 /* link map access functions */
184 LM_ADDR (struct so_list
*so
)
186 struct link_map_offsets
*lmo
= SVR4_FETCH_LINK_MAP_OFFSETS ();
188 return (CORE_ADDR
) extract_signed_integer (so
->lm_info
->lm
+ lmo
->l_addr_offset
,
193 LM_NEXT (struct so_list
*so
)
195 struct link_map_offsets
*lmo
= SVR4_FETCH_LINK_MAP_OFFSETS ();
197 return extract_address (so
->lm_info
->lm
+ lmo
->l_next_offset
, lmo
->l_next_size
);
201 LM_NAME (struct so_list
*so
)
203 struct link_map_offsets
*lmo
= SVR4_FETCH_LINK_MAP_OFFSETS ();
205 return extract_address (so
->lm_info
->lm
+ lmo
->l_name_offset
, lmo
->l_name_size
);
208 #ifndef SVR4_SHARED_LIBS
211 IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list
*so
)
216 #else /* SVR4_SHARED_LIBS */
219 IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list
*so
)
221 struct link_map_offsets
*lmo
= SVR4_FETCH_LINK_MAP_OFFSETS ();
223 return extract_address (so
->lm_info
->lm
+ lmo
->l_prev_offset
,
224 lmo
->l_prev_size
) == 0;
227 #endif /* !SVR4_SHARED_LIBS */
229 static CORE_ADDR debug_base
; /* Base of dynamic linker structures */
230 static CORE_ADDR breakpoint_addr
; /* Address where end bkpt is set */
232 /* Local function prototypes */
234 static int match_main (char *);
236 #ifndef SVR4_SHARED_LIBS
238 /* Allocate the runtime common object file. */
241 allocate_rt_common_objfile (void)
243 struct objfile
*objfile
;
244 struct objfile
*last_one
;
246 objfile
= (struct objfile
*) xmalloc (sizeof (struct objfile
));
247 memset (objfile
, 0, sizeof (struct objfile
));
249 obstack_specify_allocation (&objfile
->psymbol_cache
.cache
, 0, 0,
251 obstack_specify_allocation (&objfile
->psymbol_obstack
, 0, 0, xmalloc
,
253 obstack_specify_allocation (&objfile
->symbol_obstack
, 0, 0, xmalloc
,
255 obstack_specify_allocation (&objfile
->type_obstack
, 0, 0, xmalloc
,
257 objfile
->name
= mstrsave (objfile
->md
, "rt_common");
259 /* Add this file onto the tail of the linked list of other such files. */
261 objfile
->next
= NULL
;
262 if (object_files
== NULL
)
263 object_files
= objfile
;
266 for (last_one
= object_files
;
268 last_one
= last_one
->next
);
269 last_one
->next
= objfile
;
272 rt_common_objfile
= objfile
;
275 /* Read all dynamically loaded common symbol definitions from the inferior
276 and put them into the minimal symbol table for the runtime common
280 solib_add_common_symbols (CORE_ADDR rtc_symp
)
282 struct rtc_symb inferior_rtc_symb
;
283 struct nlist inferior_rtc_nlist
;
287 /* Remove any runtime common symbols from previous runs. */
289 if (rt_common_objfile
!= NULL
&& rt_common_objfile
->minimal_symbol_count
)
291 obstack_free (&rt_common_objfile
->symbol_obstack
, 0);
292 obstack_specify_allocation (&rt_common_objfile
->symbol_obstack
, 0, 0,
294 rt_common_objfile
->minimal_symbol_count
= 0;
295 rt_common_objfile
->msymbols
= NULL
;
298 init_minimal_symbol_collection ();
299 make_cleanup_discard_minimal_symbols ();
303 read_memory (rtc_symp
,
304 (char *) &inferior_rtc_symb
,
305 sizeof (inferior_rtc_symb
));
306 read_memory (SOLIB_EXTRACT_ADDRESS (inferior_rtc_symb
.rtc_sp
),
307 (char *) &inferior_rtc_nlist
,
308 sizeof (inferior_rtc_nlist
));
309 if (inferior_rtc_nlist
.n_type
== N_COMM
)
311 /* FIXME: The length of the symbol name is not available, but in the
312 current implementation the common symbol is allocated immediately
313 behind the name of the symbol. */
314 len
= inferior_rtc_nlist
.n_value
- inferior_rtc_nlist
.n_un
.n_strx
;
316 name
= xmalloc (len
);
317 read_memory (SOLIB_EXTRACT_ADDRESS (inferior_rtc_nlist
.n_un
.n_name
),
320 /* Allocate the runtime common objfile if necessary. */
321 if (rt_common_objfile
== NULL
)
322 allocate_rt_common_objfile ();
324 prim_record_minimal_symbol (name
, inferior_rtc_nlist
.n_value
,
325 mst_bss
, rt_common_objfile
);
328 rtc_symp
= SOLIB_EXTRACT_ADDRESS (inferior_rtc_symb
.rtc_next
);
331 /* Install any minimal symbols that have been collected as the current
332 minimal symbols for the runtime common objfile. */
334 install_minimal_symbols (rt_common_objfile
);
337 #endif /* SVR4_SHARED_LIBS */
340 #ifdef SVR4_SHARED_LIBS
342 static CORE_ADDR
bfd_lookup_symbol (bfd
*, char *);
348 bfd_lookup_symbol -- lookup the value for a specific symbol
352 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
356 An expensive way to lookup the value of a single symbol for
357 bfd's that are only temporary anyway. This is used by the
358 shared library support to find the address of the debugger
359 interface structures in the shared library.
361 Note that 0 is specifically allowed as an error return (no
366 bfd_lookup_symbol (bfd
*abfd
, char *symname
)
370 asymbol
**symbol_table
;
371 unsigned int number_of_symbols
;
373 struct cleanup
*back_to
;
374 CORE_ADDR symaddr
= 0;
376 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
378 if (storage_needed
> 0)
380 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
381 back_to
= make_cleanup (xfree
, (PTR
) symbol_table
);
382 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
384 for (i
= 0; i
< number_of_symbols
; i
++)
386 sym
= *symbol_table
++;
387 if (STREQ (sym
->name
, symname
))
389 /* Bfd symbols are section relative. */
390 symaddr
= sym
->value
+ sym
->section
->vma
;
394 do_cleanups (back_to
);
400 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
401 have to check the dynamic string table too. */
403 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
405 if (storage_needed
> 0)
407 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
408 back_to
= make_cleanup (xfree
, (PTR
) symbol_table
);
409 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
411 for (i
= 0; i
< number_of_symbols
; i
++)
413 sym
= *symbol_table
++;
414 if (STREQ (sym
->name
, symname
))
416 /* Bfd symbols are section relative. */
417 symaddr
= sym
->value
+ sym
->section
->vma
;
421 do_cleanups (back_to
);
427 #ifdef HANDLE_SVR4_EXEC_EMULATORS
430 Solaris BCP (the part of Solaris which allows it to run SunOS4
431 a.out files) throws in another wrinkle. Solaris does not fill
432 in the usual a.out link map structures when running BCP programs,
433 the only way to get at them is via groping around in the dynamic
435 The dynamic linker and it's structures are located in the shared
436 C library, which gets run as the executable's "interpreter" by
439 Note that we can assume nothing about the process state at the time
440 we need to find these structures. We may be stopped on the first
441 instruction of the interpreter (C shared library), the first
442 instruction of the executable itself, or somewhere else entirely
443 (if we attached to the process for example).
446 static char *debug_base_symbols
[] =
448 "r_debug", /* Solaris 2.3 */
449 "_r_debug", /* Solaris 2.1, 2.2 */
453 static int look_for_base (int, CORE_ADDR
);
459 look_for_base -- examine file for each mapped address segment
463 static int look_for_base (int fd, CORE_ADDR baseaddr)
467 This function is passed to proc_iterate_over_mappings, which
468 causes it to get called once for each mapped address space, with
469 an open file descriptor for the file mapped to that space, and the
470 base address of that mapped space.
472 Our job is to find the debug base symbol in the file that this
473 fd is open on, if it exists, and if so, initialize the dynamic
474 linker structure base address debug_base.
476 Note that this is a computationally expensive proposition, since
477 we basically have to open a bfd on every call, so we specifically
478 avoid opening the exec file.
482 look_for_base (int fd
, CORE_ADDR baseaddr
)
485 CORE_ADDR address
= 0;
488 /* If the fd is -1, then there is no file that corresponds to this
489 mapped memory segment, so skip it. Also, if the fd corresponds
490 to the exec file, skip it as well. */
494 && fdmatch (fileno ((FILE *) (exec_bfd
->iostream
)), fd
)))
499 /* Try to open whatever random file this fd corresponds to. Note that
500 we have no way currently to find the filename. Don't gripe about
501 any problems we might have, just fail. */
503 if ((interp_bfd
= bfd_fdopenr ("unnamed", gnutarget
, fd
)) == NULL
)
507 if (!bfd_check_format (interp_bfd
, bfd_object
))
509 /* FIXME-leak: on failure, might not free all memory associated with
511 bfd_close (interp_bfd
);
515 /* Now try to find our debug base symbol in this file, which we at
516 least know to be a valid ELF executable or shared library. */
518 for (symbolp
= debug_base_symbols
; *symbolp
!= NULL
; symbolp
++)
520 address
= bfd_lookup_symbol (interp_bfd
, *symbolp
);
528 /* FIXME-leak: on failure, might not free all memory associated with
530 bfd_close (interp_bfd
);
534 /* Eureka! We found the symbol. But now we may need to relocate it
535 by the base address. If the symbol's value is less than the base
536 address of the shared library, then it hasn't yet been relocated
537 by the dynamic linker, and we have to do it ourself. FIXME: Note
538 that we make the assumption that the first segment that corresponds
539 to the shared library has the base address to which the library
542 if (address
< baseaddr
)
546 debug_base
= address
;
547 /* FIXME-leak: on failure, might not free all memory associated with
549 bfd_close (interp_bfd
);
552 #endif /* HANDLE_SVR4_EXEC_EMULATORS */
558 elf_locate_base -- locate the base address of dynamic linker structs
559 for SVR4 elf targets.
563 CORE_ADDR elf_locate_base (void)
567 For SVR4 elf targets the address of the dynamic linker's runtime
568 structure is contained within the dynamic info section in the
569 executable file. The dynamic section is also mapped into the
570 inferior address space. Because the runtime loader fills in the
571 real address before starting the inferior, we have to read in the
572 dynamic info section from the inferior address space.
573 If there are any errors while trying to find the address, we
574 silently return 0, otherwise the found address is returned.
579 elf_locate_base (void)
581 sec_ptr dyninfo_sect
;
582 int dyninfo_sect_size
;
583 CORE_ADDR dyninfo_addr
;
588 /* Find the start address of the .dynamic section. */
589 dyninfo_sect
= bfd_get_section_by_name (exec_bfd
, ".dynamic");
590 if (dyninfo_sect
== NULL
)
592 dyninfo_addr
= bfd_section_vma (exec_bfd
, dyninfo_sect
);
594 /* Read in .dynamic section, silently ignore errors. */
595 dyninfo_sect_size
= bfd_section_size (exec_bfd
, dyninfo_sect
);
596 buf
= alloca (dyninfo_sect_size
);
597 if (target_read_memory (dyninfo_addr
, buf
, dyninfo_sect_size
))
600 /* Find the DT_DEBUG entry in the the .dynamic section.
601 For mips elf we look for DT_MIPS_RLD_MAP, mips elf apparently has
602 no DT_DEBUG entries. */
604 arch_size
= bfd_get_arch_size (exec_bfd
);
605 if (arch_size
== -1) /* failure */
610 for (bufend
= buf
+ dyninfo_sect_size
;
612 buf
+= sizeof (Elf32_External_Dyn
))
614 Elf32_External_Dyn
*x_dynp
= (Elf32_External_Dyn
*) buf
;
618 dyn_tag
= bfd_h_get_32 (exec_bfd
, (bfd_byte
*) x_dynp
->d_tag
);
619 if (dyn_tag
== DT_NULL
)
621 else if (dyn_tag
== DT_DEBUG
)
623 dyn_ptr
= bfd_h_get_32 (exec_bfd
,
624 (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
627 else if (dyn_tag
== DT_MIPS_RLD_MAP
)
631 pbuf
= alloca (TARGET_PTR_BIT
/ HOST_CHAR_BIT
);
632 /* DT_MIPS_RLD_MAP contains a pointer to the address
633 of the dynamic link structure. */
634 dyn_ptr
= bfd_h_get_32 (exec_bfd
,
635 (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
636 if (target_read_memory (dyn_ptr
, pbuf
, sizeof (pbuf
)))
638 return extract_unsigned_integer (pbuf
, sizeof (pbuf
));
642 else /* 64-bit elf */
644 for (bufend
= buf
+ dyninfo_sect_size
;
646 buf
+= sizeof (Elf64_External_Dyn
))
648 Elf64_External_Dyn
*x_dynp
= (Elf64_External_Dyn
*) buf
;
652 dyn_tag
= bfd_h_get_64 (exec_bfd
, (bfd_byte
*) x_dynp
->d_tag
);
653 if (dyn_tag
== DT_NULL
)
655 else if (dyn_tag
== DT_DEBUG
)
657 dyn_ptr
= bfd_h_get_64 (exec_bfd
,
658 (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
664 /* DT_DEBUG entry not found. */
668 #endif /* SVR4_SHARED_LIBS */
674 locate_base -- locate the base address of dynamic linker structs
678 CORE_ADDR locate_base (void)
682 For both the SunOS and SVR4 shared library implementations, if the
683 inferior executable has been linked dynamically, there is a single
684 address somewhere in the inferior's data space which is the key to
685 locating all of the dynamic linker's runtime structures. This
686 address is the value of the debug base symbol. The job of this
687 function is to find and return that address, or to return 0 if there
688 is no such address (the executable is statically linked for example).
690 For SunOS, the job is almost trivial, since the dynamic linker and
691 all of it's structures are statically linked to the executable at
692 link time. Thus the symbol for the address we are looking for has
693 already been added to the minimal symbol table for the executable's
694 objfile at the time the symbol file's symbols were read, and all we
695 have to do is look it up there. Note that we explicitly do NOT want
696 to find the copies in the shared library.
698 The SVR4 version is a bit more complicated because the address
699 is contained somewhere in the dynamic info section. We have to go
700 to a lot more work to discover the address of the debug base symbol.
701 Because of this complexity, we cache the value we find and return that
702 value on subsequent invocations. Note there is no copy in the
703 executable symbol tables.
711 #ifndef SVR4_SHARED_LIBS
713 struct minimal_symbol
*msymbol
;
714 CORE_ADDR address
= 0;
717 /* For SunOS, we want to limit the search for the debug base symbol to the
718 executable being debugged, since there is a duplicate named symbol in the
719 shared library. We don't want the shared library versions. */
721 for (symbolp
= debug_base_symbols
; *symbolp
!= NULL
; symbolp
++)
723 msymbol
= lookup_minimal_symbol (*symbolp
, NULL
, symfile_objfile
);
724 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
726 address
= SYMBOL_VALUE_ADDRESS (msymbol
);
732 #else /* SVR4_SHARED_LIBS */
734 /* Check to see if we have a currently valid address, and if so, avoid
735 doing all this work again and just return the cached address. If
736 we have no cached address, try to locate it in the dynamic info
737 section for ELF executables. */
742 && bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
743 debug_base
= elf_locate_base ();
744 #ifdef HANDLE_SVR4_EXEC_EMULATORS
745 /* Try it the hard way for emulated executables. */
746 else if (!ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
747 proc_iterate_over_mappings (look_for_base
);
752 #endif /* !SVR4_SHARED_LIBS */
760 first_link_map_member -- locate first member in dynamic linker's map
764 static CORE_ADDR first_link_map_member (void)
768 Find the first element in the inferior's dynamic link map, and
769 return its address in the inferior. This function doesn't copy the
770 link map entry itself into our address space; current_sos actually
774 first_link_map_member (void)
778 #ifndef SVR4_SHARED_LIBS
780 read_memory (debug_base
, (char *) &dynamic_copy
, sizeof (dynamic_copy
));
781 if (dynamic_copy
.ld_version
>= 2)
783 /* It is a version that we can deal with, so read in the secondary
784 structure and find the address of the link map list from it. */
785 read_memory (SOLIB_EXTRACT_ADDRESS (dynamic_copy
.ld_un
.ld_2
),
786 (char *) &ld_2_copy
, sizeof (struct link_dynamic_2
));
787 lm
= SOLIB_EXTRACT_ADDRESS (ld_2_copy
.ld_loaded
);
790 #else /* SVR4_SHARED_LIBS */
791 struct link_map_offsets
*lmo
= SVR4_FETCH_LINK_MAP_OFFSETS ();
792 char *r_map_buf
= xmalloc (lmo
->r_map_size
);
793 struct cleanup
*cleanups
= make_cleanup (xfree
, r_map_buf
);
795 read_memory (debug_base
+ lmo
->r_map_offset
, r_map_buf
, lmo
->r_map_size
);
797 lm
= extract_address (r_map_buf
, lmo
->r_map_size
);
799 /* FIXME: Perhaps we should validate the info somehow, perhaps by
800 checking r_version for a known version number, or r_state for
803 do_cleanups (cleanups
);
805 #endif /* !SVR4_SHARED_LIBS */
810 #ifdef SVR4_SHARED_LIBS
815 open_symbol_file_object
819 void open_symbol_file_object (void *from_tty)
823 If no open symbol file, attempt to locate and open the main symbol
824 file. On SVR4 systems, this is the first link map entry. If its
825 name is here, we can open it. Useful when attaching to a process
826 without first loading its symbol file.
828 If FROM_TTYP dereferences to a non-zero integer, allow messages to
829 be printed. This parameter is a pointer rather than an int because
830 open_symbol_file_object() is called via catch_errors() and
831 catch_errors() requires a pointer argument. */
834 open_symbol_file_object (void *from_ttyp
)
836 CORE_ADDR lm
, l_name
;
839 int from_tty
= *(int *)from_ttyp
;
840 struct link_map_offsets
*lmo
= SVR4_FETCH_LINK_MAP_OFFSETS ();
841 char *l_name_buf
= xmalloc (lmo
->l_name_size
);
842 struct cleanup
*cleanups
= make_cleanup (xfree
, l_name_buf
);
845 if (!query ("Attempt to reload symbols from process? "))
848 if ((debug_base
= locate_base ()) == 0)
849 return 0; /* failed somehow... */
851 /* First link map member should be the executable. */
852 if ((lm
= first_link_map_member ()) == 0)
853 return 0; /* failed somehow... */
855 /* Read address of name from target memory to GDB. */
856 read_memory (lm
+ lmo
->l_name_offset
, l_name_buf
, lmo
->l_name_size
);
858 /* Convert the address to host format. */
859 l_name
= extract_address (l_name_buf
, lmo
->l_name_size
);
861 /* Free l_name_buf. */
862 do_cleanups (cleanups
);
865 return 0; /* No filename. */
867 /* Now fetch the filename from target memory. */
868 target_read_string (l_name
, &filename
, SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
872 warning ("failed to read exec filename from attached file: %s",
873 safe_strerror (errcode
));
877 make_cleanup (xfree
, filename
);
878 /* Have a pathname: read the symbol file. */
879 symbol_file_add_main (filename
, from_tty
);
886 open_symbol_file_object (void *from_ttyp
)
891 #endif /* SVR4_SHARED_LIBS */
896 current_sos -- build a list of currently loaded shared objects
900 struct so_list *current_sos ()
904 Build a list of `struct so_list' objects describing the shared
905 objects currently loaded in the inferior. This list does not
906 include an entry for the main executable file.
908 Note that we only gather information directly available from the
909 inferior --- we don't examine any of the shared library files
910 themselves. The declaration of `struct so_list' says which fields
911 we provide values for. */
913 static struct so_list
*
914 svr4_current_sos (void)
917 struct so_list
*head
= 0;
918 struct so_list
**link_ptr
= &head
;
920 /* Make sure we've looked up the inferior's dynamic linker's base
924 debug_base
= locate_base ();
926 /* If we can't find the dynamic linker's base structure, this
927 must not be a dynamically linked executable. Hmm. */
932 /* Walk the inferior's link map list, and build our list of
933 `struct so_list' nodes. */
934 lm
= first_link_map_member ();
937 struct link_map_offsets
*lmo
= SVR4_FETCH_LINK_MAP_OFFSETS ();
939 = (struct so_list
*) xmalloc (sizeof (struct so_list
));
940 struct cleanup
*old_chain
= make_cleanup (xfree
, new);
942 memset (new, 0, sizeof (*new));
944 new->lm_info
= xmalloc (sizeof (struct lm_info
));
945 make_cleanup (xfree
, new->lm_info
);
947 new->lm_info
->lm
= xmalloc (lmo
->link_map_size
);
948 make_cleanup (xfree
, new->lm_info
->lm
);
949 memset (new->lm_info
->lm
, 0, lmo
->link_map_size
);
951 read_memory (lm
, new->lm_info
->lm
, lmo
->link_map_size
);
955 /* For SVR4 versions, the first entry in the link map is for the
956 inferior executable, so we must ignore it. For some versions of
957 SVR4, it has no name. For others (Solaris 2.3 for example), it
958 does have a name, so we can no longer use a missing name to
959 decide when to ignore it. */
960 if (IGNORE_FIRST_LINK_MAP_ENTRY (new))
967 /* Extract this shared object's name. */
968 target_read_string (LM_NAME (new), &buffer
,
969 SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
972 warning ("current_sos: Can't read pathname for load map: %s\n",
973 safe_strerror (errcode
));
977 strncpy (new->so_name
, buffer
, SO_NAME_MAX_PATH_SIZE
- 1);
978 new->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
980 strcpy (new->so_original_name
, new->so_name
);
983 /* If this entry has no name, or its name matches the name
984 for the main executable, don't include it in the list. */
985 if (! new->so_name
[0]
986 || match_main (new->so_name
))
992 link_ptr
= &new->next
;
996 discard_cleanups (old_chain
);
1003 /* On some systems, the only way to recognize the link map entry for
1004 the main executable file is by looking at its name. Return
1005 non-zero iff SONAME matches one of the known main executable names. */
1008 match_main (char *soname
)
1012 for (mainp
= main_name_list
; *mainp
!= NULL
; mainp
++)
1014 if (strcmp (soname
, *mainp
) == 0)
1022 /* Return 1 if PC lies in the dynamic symbol resolution code of the
1023 SVR4 run time loader. */
1024 #ifdef SVR4_SHARED_LIBS
1025 static CORE_ADDR interp_text_sect_low
;
1026 static CORE_ADDR interp_text_sect_high
;
1027 static CORE_ADDR interp_plt_sect_low
;
1028 static CORE_ADDR interp_plt_sect_high
;
1031 svr4_in_dynsym_resolve_code (CORE_ADDR pc
)
1033 return ((pc
>= interp_text_sect_low
&& pc
< interp_text_sect_high
)
1034 || (pc
>= interp_plt_sect_low
&& pc
< interp_plt_sect_high
)
1035 || in_plt_section (pc
, NULL
));
1037 #else /* !SVR4_SHARED_LIBS */
1039 svr4_in_dynsym_resolve_code (CORE_ADDR pc
)
1043 #endif /* SVR4_SHARED_LIBS */
1049 disable_break -- remove the "mapping changed" breakpoint
1053 static int disable_break ()
1057 Removes the breakpoint that gets hit when the dynamic linker
1058 completes a mapping change.
1062 #ifndef SVR4_SHARED_LIBS
1065 disable_break (void)
1069 int in_debugger
= 0;
1071 /* Read the debugger structure from the inferior to retrieve the
1072 address of the breakpoint and the original contents of the
1073 breakpoint address. Remove the breakpoint by writing the original
1076 read_memory (debug_addr
, (char *) &debug_copy
, sizeof (debug_copy
));
1078 /* Set `in_debugger' to zero now. */
1080 write_memory (flag_addr
, (char *) &in_debugger
, sizeof (in_debugger
));
1082 breakpoint_addr
= SOLIB_EXTRACT_ADDRESS (debug_copy
.ldd_bp_addr
);
1083 write_memory (breakpoint_addr
, (char *) &debug_copy
.ldd_bp_inst
,
1084 sizeof (debug_copy
.ldd_bp_inst
));
1086 /* For the SVR4 version, we always know the breakpoint address. For the
1087 SunOS version we don't know it until the above code is executed.
1088 Grumble if we are stopped anywhere besides the breakpoint address. */
1090 if (stop_pc
!= breakpoint_addr
)
1092 warning ("stopped at unknown breakpoint while handling shared libraries");
1098 #endif /* #ifdef SVR4_SHARED_LIBS */
1104 enable_break -- arrange for dynamic linker to hit breakpoint
1108 int enable_break (void)
1112 Both the SunOS and the SVR4 dynamic linkers have, as part of their
1113 debugger interface, support for arranging for the inferior to hit
1114 a breakpoint after mapping in the shared libraries. This function
1115 enables that breakpoint.
1117 For SunOS, there is a special flag location (in_debugger) which we
1118 set to 1. When the dynamic linker sees this flag set, it will set
1119 a breakpoint at a location known only to itself, after saving the
1120 original contents of that place and the breakpoint address itself,
1121 in it's own internal structures. When we resume the inferior, it
1122 will eventually take a SIGTRAP when it runs into the breakpoint.
1123 We handle this (in a different place) by restoring the contents of
1124 the breakpointed location (which is only known after it stops),
1125 chasing around to locate the shared libraries that have been
1126 loaded, then resuming.
1128 For SVR4, the debugger interface structure contains a member (r_brk)
1129 which is statically initialized at the time the shared library is
1130 built, to the offset of a function (_r_debug_state) which is guaran-
1131 teed to be called once before mapping in a library, and again when
1132 the mapping is complete. At the time we are examining this member,
1133 it contains only the unrelocated offset of the function, so we have
1134 to do our own relocation. Later, when the dynamic linker actually
1135 runs, it relocates r_brk to be the actual address of _r_debug_state().
1137 The debugger interface structure also contains an enumeration which
1138 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
1139 depending upon whether or not the library is being mapped or unmapped,
1140 and then set to RT_CONSISTENT after the library is mapped/unmapped.
1148 #ifndef SVR4_SHARED_LIBS
1153 /* Get link_dynamic structure */
1155 j
= target_read_memory (debug_base
, (char *) &dynamic_copy
,
1156 sizeof (dynamic_copy
));
1163 /* Calc address of debugger interface structure */
1165 debug_addr
= SOLIB_EXTRACT_ADDRESS (dynamic_copy
.ldd
);
1167 /* Calc address of `in_debugger' member of debugger interface structure */
1169 flag_addr
= debug_addr
+ (CORE_ADDR
) ((char *) &debug_copy
.ldd_in_debugger
-
1170 (char *) &debug_copy
);
1172 /* Write a value of 1 to this member. */
1175 write_memory (flag_addr
, (char *) &in_debugger
, sizeof (in_debugger
));
1178 #else /* SVR4_SHARED_LIBS */
1180 #ifdef BKPT_AT_SYMBOL
1182 struct minimal_symbol
*msymbol
;
1184 asection
*interp_sect
;
1186 /* First, remove all the solib event breakpoints. Their addresses
1187 may have changed since the last time we ran the program. */
1188 remove_solib_event_breakpoints ();
1190 #ifdef SVR4_SHARED_LIBS
1191 interp_text_sect_low
= interp_text_sect_high
= 0;
1192 interp_plt_sect_low
= interp_plt_sect_high
= 0;
1194 /* Find the .interp section; if not found, warn the user and drop
1195 into the old breakpoint at symbol code. */
1196 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
1199 unsigned int interp_sect_size
;
1201 CORE_ADDR load_addr
;
1202 bfd
*tmp_bfd
= NULL
;
1204 char *tmp_pathname
= NULL
;
1205 CORE_ADDR sym_addr
= 0;
1207 /* Read the contents of the .interp section into a local buffer;
1208 the contents specify the dynamic linker this program uses. */
1209 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
1210 buf
= alloca (interp_sect_size
);
1211 bfd_get_section_contents (exec_bfd
, interp_sect
,
1212 buf
, 0, interp_sect_size
);
1214 /* Now we need to figure out where the dynamic linker was
1215 loaded so that we can load its symbols and place a breakpoint
1216 in the dynamic linker itself.
1218 This address is stored on the stack. However, I've been unable
1219 to find any magic formula to find it for Solaris (appears to
1220 be trivial on GNU/Linux). Therefore, we have to try an alternate
1221 mechanism to find the dynamic linker's base address. */
1223 tmp_fd
= solib_open (buf
, &tmp_pathname
);
1225 tmp_bfd
= bfd_fdopenr (tmp_pathname
, gnutarget
, tmp_fd
);
1227 if (tmp_bfd
== NULL
)
1228 goto bkpt_at_symbol
;
1230 /* Make sure the dynamic linker's really a useful object. */
1231 if (!bfd_check_format (tmp_bfd
, bfd_object
))
1233 warning ("Unable to grok dynamic linker %s as an object file", buf
);
1234 bfd_close (tmp_bfd
);
1235 goto bkpt_at_symbol
;
1238 /* We find the dynamic linker's base address by examining the
1239 current pc (which point at the entry point for the dynamic
1240 linker) and subtracting the offset of the entry point. */
1241 load_addr
= read_pc () - tmp_bfd
->start_address
;
1243 /* Record the relocated start and end address of the dynamic linker
1244 text and plt section for svr4_in_dynsym_resolve_code. */
1245 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
1248 interp_text_sect_low
=
1249 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1250 interp_text_sect_high
=
1251 interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1253 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
1256 interp_plt_sect_low
=
1257 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1258 interp_plt_sect_high
=
1259 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1262 /* Now try to set a breakpoint in the dynamic linker. */
1263 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1265 sym_addr
= bfd_lookup_symbol (tmp_bfd
, *bkpt_namep
);
1270 /* We're done with the temporary bfd. */
1271 bfd_close (tmp_bfd
);
1275 create_solib_event_breakpoint (load_addr
+ sym_addr
);
1279 /* For whatever reason we couldn't set a breakpoint in the dynamic
1280 linker. Warn and drop into the old code. */
1282 warning ("Unable to find dynamic linker breakpoint function.\nGDB will be unable to debug shared library initializers\nand track explicitly loaded dynamic code.");
1286 /* Scan through the list of symbols, trying to look up the symbol and
1287 set a breakpoint there. Terminate loop when we/if we succeed. */
1289 breakpoint_addr
= 0;
1290 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1292 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
1293 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
1295 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol
));
1300 /* Nothing good happened. */
1303 #endif /* BKPT_AT_SYMBOL */
1305 #endif /* !SVR4_SHARED_LIBS */
1314 special_symbol_handling -- additional shared library symbol handling
1318 void special_symbol_handling ()
1322 Once the symbols from a shared object have been loaded in the usual
1323 way, we are called to do any system specific symbol handling that
1326 For SunOS4, this consists of grunging around in the dynamic
1327 linkers structures to find symbol definitions for "common" symbols
1328 and adding them to the minimal symbol table for the runtime common
1334 svr4_special_symbol_handling (void)
1336 #ifndef SVR4_SHARED_LIBS
1339 if (debug_addr
== 0)
1341 /* Get link_dynamic structure */
1343 j
= target_read_memory (debug_base
, (char *) &dynamic_copy
,
1344 sizeof (dynamic_copy
));
1351 /* Calc address of debugger interface structure */
1352 /* FIXME, this needs work for cross-debugging of core files
1353 (byteorder, size, alignment, etc). */
1355 debug_addr
= SOLIB_EXTRACT_ADDRESS (dynamic_copy
.ldd
);
1358 /* Read the debugger structure from the inferior, just to make sure
1359 we have a current copy. */
1361 j
= target_read_memory (debug_addr
, (char *) &debug_copy
,
1362 sizeof (debug_copy
));
1364 return; /* unreadable */
1366 /* Get common symbol definitions for the loaded object. */
1368 if (debug_copy
.ldd_cp
)
1370 solib_add_common_symbols (SOLIB_EXTRACT_ADDRESS (debug_copy
.ldd_cp
));
1373 #endif /* !SVR4_SHARED_LIBS */
1376 /* Relocate the main executable. This function should be called upon
1377 stopping the inferior process at the entry point to the program.
1378 The entry point from BFD is compared to the PC and if they are
1379 different, the main executable is relocated by the proper amount.
1381 As written it will only attempt to relocate executables which
1382 lack interpreter sections. It seems likely that only dynamic
1383 linker executables will get relocated, though it should work
1384 properly for a position-independent static executable as well. */
1387 svr4_relocate_main_executable (void)
1389 asection
*interp_sect
;
1390 CORE_ADDR pc
= read_pc ();
1392 /* Decide if the objfile needs to be relocated. As indicated above,
1393 we will only be here when execution is stopped at the beginning
1394 of the program. Relocation is necessary if the address at which
1395 we are presently stopped differs from the start address stored in
1396 the executable AND there's no interpreter section. The condition
1397 regarding the interpreter section is very important because if
1398 there *is* an interpreter section, execution will begin there
1399 instead. When there is an interpreter section, the start address
1400 is (presumably) used by the interpreter at some point to start
1401 execution of the program.
1403 If there is an interpreter, it is normal for it to be set to an
1404 arbitrary address at the outset. The job of finding it is
1405 handled in enable_break().
1407 So, to summarize, relocations are necessary when there is no
1408 interpreter section and the start address obtained from the
1409 executable is different from the address at which GDB is
1412 [ The astute reader will note that we also test to make sure that
1413 the executable in question has the DYNAMIC flag set. It is my
1414 opinion that this test is unnecessary (undesirable even). It
1415 was added to avoid inadvertent relocation of an executable
1416 whose e_type member in the ELF header is not ET_DYN. There may
1417 be a time in the future when it is desirable to do relocations
1418 on other types of files as well in which case this condition
1419 should either be removed or modified to accomodate the new file
1420 type. (E.g, an ET_EXEC executable which has been built to be
1421 position-independent could safely be relocated by the OS if
1422 desired. It is true that this violates the ABI, but the ABI
1423 has been known to be bent from time to time.) - Kevin, Nov 2000. ]
1426 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
1427 if (interp_sect
== NULL
1428 && (bfd_get_file_flags (exec_bfd
) & DYNAMIC
) != 0
1429 && bfd_get_start_address (exec_bfd
) != pc
)
1431 struct cleanup
*old_chain
;
1432 struct section_offsets
*new_offsets
;
1434 CORE_ADDR displacement
;
1436 /* It is necessary to relocate the objfile. The amount to
1437 relocate by is simply the address at which we are stopped
1438 minus the starting address from the executable.
1440 We relocate all of the sections by the same amount. This
1441 behavior is mandated by recent editions of the System V ABI.
1442 According to the System V Application Binary Interface,
1443 Edition 4.1, page 5-5:
1445 ... Though the system chooses virtual addresses for
1446 individual processes, it maintains the segments' relative
1447 positions. Because position-independent code uses relative
1448 addressesing between segments, the difference between
1449 virtual addresses in memory must match the difference
1450 between virtual addresses in the file. The difference
1451 between the virtual address of any segment in memory and
1452 the corresponding virtual address in the file is thus a
1453 single constant value for any one executable or shared
1454 object in a given process. This difference is the base
1455 address. One use of the base address is to relocate the
1456 memory image of the program during dynamic linking.
1458 The same language also appears in Edition 4.0 of the System V
1459 ABI and is left unspecified in some of the earlier editions. */
1461 displacement
= pc
- bfd_get_start_address (exec_bfd
);
1464 new_offsets
= xcalloc (sizeof (struct section_offsets
),
1465 symfile_objfile
->num_sections
);
1466 old_chain
= make_cleanup (xfree
, new_offsets
);
1468 for (i
= 0; i
< symfile_objfile
->num_sections
; i
++)
1470 if (displacement
!= ANOFFSET (symfile_objfile
->section_offsets
, i
))
1472 new_offsets
->offsets
[i
] = displacement
;
1476 objfile_relocate (symfile_objfile
, new_offsets
);
1478 do_cleanups (old_chain
);
1486 svr4_solib_create_inferior_hook -- shared library startup support
1490 void svr4_solib_create_inferior_hook()
1494 When gdb starts up the inferior, it nurses it along (through the
1495 shell) until it is ready to execute it's first instruction. At this
1496 point, this function gets called via expansion of the macro
1497 SOLIB_CREATE_INFERIOR_HOOK.
1499 For SunOS executables, this first instruction is typically the
1500 one at "_start", or a similar text label, regardless of whether
1501 the executable is statically or dynamically linked. The runtime
1502 startup code takes care of dynamically linking in any shared
1503 libraries, once gdb allows the inferior to continue.
1505 For SVR4 executables, this first instruction is either the first
1506 instruction in the dynamic linker (for dynamically linked
1507 executables) or the instruction at "start" for statically linked
1508 executables. For dynamically linked executables, the system
1509 first exec's /lib/libc.so.N, which contains the dynamic linker,
1510 and starts it running. The dynamic linker maps in any needed
1511 shared libraries, maps in the actual user executable, and then
1512 jumps to "start" in the user executable.
1514 For both SunOS shared libraries, and SVR4 shared libraries, we
1515 can arrange to cooperate with the dynamic linker to discover the
1516 names of shared libraries that are dynamically linked, and the
1517 base addresses to which they are linked.
1519 This function is responsible for discovering those names and
1520 addresses, and saving sufficient information about them to allow
1521 their symbols to be read at a later time.
1525 Between enable_break() and disable_break(), this code does not
1526 properly handle hitting breakpoints which the user might have
1527 set in the startup code or in the dynamic linker itself. Proper
1528 handling will probably have to wait until the implementation is
1529 changed to use the "breakpoint handler function" method.
1531 Also, what if child has exit()ed? Must exit loop somehow.
1535 svr4_solib_create_inferior_hook (void)
1537 /* Relocate the main executable if necessary. */
1538 svr4_relocate_main_executable ();
1540 /* If we are using the BKPT_AT_SYMBOL code, then we don't need the base
1541 yet. In fact, in the case of a SunOS4 executable being run on
1542 Solaris, we can't get it yet. current_sos will get it when it needs
1544 #if !(defined (SVR4_SHARED_LIBS) && defined (BKPT_AT_SYMBOL))
1545 if ((debug_base
= locate_base ()) == 0)
1547 /* Can't find the symbol or the executable is statically linked. */
1552 if (!enable_break ())
1554 warning ("shared library handler failed to enable breakpoint");
1558 #if !defined(SVR4_SHARED_LIBS) || defined(_SCO_DS)
1559 /* SCO and SunOS need the loop below, other systems should be using the
1560 special shared library breakpoints and the shared library breakpoint
1563 Now run the target. It will eventually hit the breakpoint, at
1564 which point all of the libraries will have been mapped in and we
1565 can go groveling around in the dynamic linker structures to find
1566 out what we need to know about them. */
1568 clear_proceed_status ();
1569 stop_soon_quietly
= 1;
1570 stop_signal
= TARGET_SIGNAL_0
;
1573 target_resume (pid_to_ptid (-1), 0, stop_signal
);
1574 wait_for_inferior ();
1576 while (stop_signal
!= TARGET_SIGNAL_TRAP
);
1577 stop_soon_quietly
= 0;
1579 #if !defined(_SCO_DS)
1580 /* We are now either at the "mapping complete" breakpoint (or somewhere
1581 else, a condition we aren't prepared to deal with anyway), so adjust
1582 the PC as necessary after a breakpoint, disable the breakpoint, and
1583 add any shared libraries that were mapped in. */
1585 if (DECR_PC_AFTER_BREAK
)
1587 stop_pc
-= DECR_PC_AFTER_BREAK
;
1588 write_register (PC_REGNUM
, stop_pc
);
1591 if (!disable_break ())
1593 warning ("shared library handler failed to disable breakpoint");
1597 solib_add ((char *) 0, 0, (struct target_ops
*) 0);
1598 #endif /* ! _SCO_DS */
1603 svr4_clear_solib (void)
1609 svr4_free_so (struct so_list
*so
)
1611 xfree (so
->lm_info
->lm
);
1612 xfree (so
->lm_info
);
1616 svr4_relocate_section_addresses (struct so_list
*so
,
1617 struct section_table
*sec
)
1619 sec
->addr
+= LM_ADDR (so
);
1620 sec
->endaddr
+= LM_ADDR (so
);
1624 set_solib_svr4_fetch_link_map_offsets (struct link_map_offsets
*(*flmo
) (void))
1626 fetch_link_map_offsets
= flmo
;
1630 init_fetch_link_map_offsets (void)
1632 set_solib_svr4_fetch_link_map_offsets (default_svr4_fetch_link_map_offsets
);
1635 static struct target_so_ops svr4_so_ops
;
1638 _initialize_svr4_solib (void)
1640 register_gdbarch_swap (&fetch_link_map_offsets
,
1641 sizeof (fetch_link_map_offsets
),
1642 init_fetch_link_map_offsets
);
1644 svr4_so_ops
.relocate_section_addresses
= svr4_relocate_section_addresses
;
1645 svr4_so_ops
.free_so
= svr4_free_so
;
1646 svr4_so_ops
.clear_solib
= svr4_clear_solib
;
1647 svr4_so_ops
.solib_create_inferior_hook
= svr4_solib_create_inferior_hook
;
1648 svr4_so_ops
.special_symbol_handling
= svr4_special_symbol_handling
;
1649 svr4_so_ops
.current_sos
= svr4_current_sos
;
1650 svr4_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
1651 svr4_so_ops
.in_dynsym_resolve_code
= svr4_in_dynsym_resolve_code
;
1653 /* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */
1654 current_target_so_ops
= &svr4_so_ops
;