1 /* Handle SunOS and SVR4 shared libraries for GDB, the GNU Debugger.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 98, 1999, 2000
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,
20 Boston, MA 02111-1307, USA. */
22 #define _SYSCALL32 /* for Sparc64 cross Sparc32 */
25 /* This file is only compilable if link.h is available. */
29 #include <sys/types.h>
31 #include "gdb_string.h"
32 #include <sys/param.h>
35 #ifndef SVR4_SHARED_LIBS
36 /* SunOS shared libs need the nlist structure. */
39 #include "elf/external.h"
52 #include "gdb_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
[] =
79 #define BKPT_AT_SYMBOL 1
81 #if defined (BKPT_AT_SYMBOL) && defined (SVR4_SHARED_LIBS)
82 static char *bkpt_names
[] =
84 #ifdef SOLIB_BKPT_NAME
85 SOLIB_BKPT_NAME
, /* Prefer configured name if it exists. */
93 /* Symbols which are used to locate the base of the link map structures. */
95 #ifndef SVR4_SHARED_LIBS
96 static char *debug_base_symbols
[] =
104 static char *main_name_list
[] =
110 /* Function to extract an address from a solib structure.
111 When GDB is configured for some 32-bit targets (e.g. Solaris 2.7
112 sparc), BFD is configured to handle 64-bit targets, so CORE_ADDR is
113 64 bits. We have to extract only the significant bits of addresses
114 to get the right address when accessing the core file BFD.
116 We'll use the BFD itself to determine the number of significant bits.
120 solib_extract_address (void *memberp
)
122 return extract_address (memberp
,
123 bfd_get_arch_size (exec_bfd
) / 8);
126 #define SOLIB_EXTRACT_ADDRESS(MEMBER) \
127 solib_extract_address (&MEMBER)
129 /* local data declarations */
131 #ifndef SVR4_SHARED_LIBS
133 /* NOTE: converted the macros LM_ADDR, LM_NEXT, LM_NAME and
134 IGNORE_FIRST_LINK_MAP_ENTRY into functions (see below).
137 static struct link_dynamic dynamic_copy
;
138 static struct link_dynamic_2 ld_2_copy
;
139 static struct ld_debug debug_copy
;
140 static CORE_ADDR debug_addr
;
141 static CORE_ADDR flag_addr
;
143 #else /* SVR4_SHARED_LIBS */
145 static struct r_debug debug_copy
;
146 #if defined (HAVE_STRUCT_LINK_MAP32)
147 static struct r_debug32 debug32_copy
; /* Sparc64 cross Sparc32 */
150 char shadow_contents
[BREAKPOINT_MAX
]; /* Stash old bkpt addr contents */
152 #endif /* !SVR4_SHARED_LIBS */
156 /* The following fields of the structure come directly from the
157 dynamic linker's tables in the inferior, and are initialized by
160 struct so_list
*next
; /* next structure in linked list */
161 struct link_map lm
; /* copy of link map from inferior */
162 #if defined (HAVE_STRUCT_LINK_MAP32)
163 struct link_map32 lm32
; /* copy of link map from 32-bit inferior */
165 CORE_ADDR lmaddr
; /* addr in inferior lm was read from */
167 /* Shared object file name, exactly as it appears in the
168 inferior's link map. This may be a relative path, or something
169 which needs to be looked up in LD_LIBRARY_PATH, etc. We use it
170 to tell which entries in the inferior's dynamic linker's link
171 map we've already loaded. */
172 char so_original_name
[MAX_PATH_SIZE
];
174 /* shared object file name, expanded to something GDB can open */
175 char so_name
[MAX_PATH_SIZE
];
177 /* The following fields of the structure are built from
178 information gathered from the shared object file itself, and
179 are initialized when we actually add it to our symbol tables. */
182 CORE_ADDR lmend
; /* upper addr bound of mapped object */
183 char symbols_loaded
; /* flag: symbols read in yet? */
184 char from_tty
; /* flag: print msgs? */
185 struct objfile
*objfile
; /* objfile for loaded lib */
186 struct section_table
*sections
;
187 struct section_table
*sections_end
;
188 struct section_table
*textsection
;
191 static struct so_list
*so_list_head
; /* List of known shared objects */
193 /* link map access functions */
195 #ifndef SVR4_SHARED_LIBS
201 #if defined (HAVE_STRUCT_LINK_MAP32)
202 if (bfd_get_arch_size (exec_bfd
) == 32)
203 return extract_address (&so
->lm32
.lm_addr
, sizeof (so
->lm32
.lm_addr
));
206 return extract_address (&so
->lm
.lm_addr
, sizeof (so
->lm
.lm_addr
));
213 #if defined (HAVE_STRUCT_LINK_MAP32)
214 if (bfd_get_arch_size (exec_bfd
) == 32)
215 return extract_address (&so
->lm32
.lm_next
, sizeof (so
->lm32
.lm_next
));
218 return extract_address (&so
->lm
.lm_next
, sizeof (so
->lm
.lm_next
));
225 #if defined (HAVE_STRUCT_LINK_MAP32)
226 if (bfd_get_arch_size (exec_bfd
) == 32)
227 return extract_address (&so
->lm32
.lm_name
, sizeof (so
->lm32
.lm_name
));
230 return extract_address (&so
->lm
.lm_name
, sizeof (so
->lm
.lm_name
));
234 IGNORE_FIRST_LINK_MAP_ENTRY (so
)
240 #else /* SVR4_SHARED_LIBS */
246 #if defined (HAVE_STRUCT_LINK_MAP32)
247 if (bfd_get_arch_size (exec_bfd
) == 32)
248 return extract_address (&so
->lm32
.l_addr
, sizeof (so
->lm32
.l_addr
));
251 return extract_address (&so
->lm
.l_addr
, sizeof (so
->lm
.l_addr
));
258 #if defined (HAVE_STRUCT_LINK_MAP32)
259 if (bfd_get_arch_size (exec_bfd
) == 32)
260 return extract_address (&so
->lm32
.l_next
, sizeof (so
->lm32
.l_next
));
263 return extract_address (&so
->lm
.l_next
, sizeof (so
->lm
.l_next
));
270 #if defined (HAVE_STRUCT_LINK_MAP32)
271 if (bfd_get_arch_size (exec_bfd
) == 32)
272 return extract_address (&so
->lm32
.l_name
, sizeof (so
->lm32
.l_name
));
275 return extract_address (&so
->lm
.l_name
, sizeof (so
->lm
.l_name
));
279 IGNORE_FIRST_LINK_MAP_ENTRY (so
)
282 #if defined (HAVE_STRUCT_LINK_MAP32)
283 if (bfd_get_arch_size (exec_bfd
) == 32)
284 return (solib_extract_address (&(so
) -> lm32
.l_prev
) == 0);
287 return (solib_extract_address (&(so
) -> lm
.l_prev
) == 0);
290 #endif /* !SVR4_SHARED_LIBS */
293 static CORE_ADDR debug_base
; /* Base of dynamic linker structures */
294 static CORE_ADDR breakpoint_addr
; /* Address where end bkpt is set */
296 static int solib_cleanup_queued
= 0; /* make_run_cleanup called */
298 extern int fdmatch (int, int); /* In libiberty */
300 /* Local function prototypes */
302 static void do_clear_solib (PTR
);
304 static int match_main (char *);
306 static void special_symbol_handling (void);
308 static void sharedlibrary_command (char *, int);
310 static int enable_break (void);
312 static void info_sharedlibrary_command (char *, int);
314 static int symbol_add_stub (PTR
);
316 static CORE_ADDR
first_link_map_member (void);
318 static CORE_ADDR
locate_base (void);
320 static int solib_map_sections (PTR
);
322 #ifdef SVR4_SHARED_LIBS
324 static CORE_ADDR
elf_locate_base (void);
328 static struct so_list
*current_sos (void);
329 static void free_so (struct so_list
*node
);
331 static int disable_break (void);
333 static void allocate_rt_common_objfile (void);
336 solib_add_common_symbols (CORE_ADDR
);
340 void _initialize_solib (void);
342 /* If non-zero, this is a prefix that will be added to the front of the name
343 shared libraries with an absolute filename for loading. */
344 static char *solib_absolute_prefix
= NULL
;
346 /* If non-empty, this is a search path for loading non-absolute shared library
347 symbol files. This takes precedence over the environment variables PATH
348 and LD_LIBRARY_PATH. */
349 static char *solib_search_path
= NULL
;
355 solib_map_sections -- open bfd and build sections for shared lib
359 static int solib_map_sections (struct so_list *so)
363 Given a pointer to one of the shared objects in our list
364 of mapped objects, use the recorded name to open a bfd
365 descriptor for the object, build a section table, and then
366 relocate all the section addresses by the base address at
367 which the shared object was mapped.
371 In most (all?) cases the shared object file name recorded in the
372 dynamic linkage tables will be a fully qualified pathname. For
373 cases where it isn't, do we really mimic the systems search
374 mechanism correctly in the below code (particularly the tilde
379 solib_map_sections (PTR arg
)
381 struct so_list
*so
= (struct so_list
*) arg
; /* catch_errors bogon */
383 char *scratch_pathname
;
385 struct section_table
*p
;
386 struct cleanup
*old_chain
;
389 filename
= tilde_expand (so
->so_name
);
391 if (solib_absolute_prefix
&& ROOTED_P (filename
))
392 /* Prefix shared libraries with absolute filenames with
393 SOLIB_ABSOLUTE_PREFIX. */
398 pfx_len
= strlen (solib_absolute_prefix
);
400 /* Remove trailing slashes. */
401 while (pfx_len
> 0 && SLASH_P (solib_absolute_prefix
[pfx_len
- 1]))
404 pfxed_fn
= xmalloc (pfx_len
+ strlen (filename
) + 1);
405 strcpy (pfxed_fn
, solib_absolute_prefix
);
406 strcat (pfxed_fn
, filename
);
412 old_chain
= make_cleanup (free
, filename
);
416 if (solib_search_path
)
417 scratch_chan
= openp (solib_search_path
,
418 1, filename
, O_RDONLY
, 0, &scratch_pathname
);
419 if (scratch_chan
< 0)
420 scratch_chan
= openp (get_in_environ (inferior_environ
, "PATH"),
421 1, filename
, O_RDONLY
, 0, &scratch_pathname
);
422 if (scratch_chan
< 0)
424 scratch_chan
= openp (get_in_environ
425 (inferior_environ
, "LD_LIBRARY_PATH"),
426 1, filename
, O_RDONLY
, 0, &scratch_pathname
);
428 if (scratch_chan
< 0)
430 perror_with_name (filename
);
432 /* Leave scratch_pathname allocated. abfd->name will point to it. */
434 abfd
= bfd_fdopenr (scratch_pathname
, gnutarget
, scratch_chan
);
437 close (scratch_chan
);
438 error ("Could not open `%s' as an executable file: %s",
439 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
441 /* Leave bfd open, core_xfer_memory and "info files" need it. */
443 abfd
->cacheable
= true;
445 /* copy full path name into so_name, so that later symbol_file_add can find
447 if (strlen (scratch_pathname
) >= MAX_PATH_SIZE
)
448 error ("Full path name length of shared library exceeds MAX_PATH_SIZE in so_list structure.");
449 strcpy (so
->so_name
, scratch_pathname
);
451 if (!bfd_check_format (abfd
, bfd_object
))
453 error ("\"%s\": not in executable format: %s.",
454 scratch_pathname
, bfd_errmsg (bfd_get_error ()));
456 if (build_section_table (abfd
, &so
->sections
, &so
->sections_end
))
458 error ("Can't find the file sections in `%s': %s",
459 bfd_get_filename (abfd
), bfd_errmsg (bfd_get_error ()));
462 for (p
= so
->sections
; p
< so
->sections_end
; p
++)
464 /* Relocate the section binding addresses as recorded in the shared
465 object's file by the base address to which the object was actually
467 p
->addr
+= LM_ADDR (so
);
468 p
->endaddr
+= LM_ADDR (so
);
469 so
->lmend
= max (p
->endaddr
, so
->lmend
);
470 if (STREQ (p
->the_bfd_section
->name
, ".text"))
476 /* Free the file names, close the file now. */
477 do_cleanups (old_chain
);
482 #ifndef SVR4_SHARED_LIBS
484 /* Allocate the runtime common object file. */
487 allocate_rt_common_objfile (void)
489 struct objfile
*objfile
;
490 struct objfile
*last_one
;
492 objfile
= (struct objfile
*) xmalloc (sizeof (struct objfile
));
493 memset (objfile
, 0, sizeof (struct objfile
));
495 obstack_specify_allocation (&objfile
->psymbol_cache
.cache
, 0, 0,
497 obstack_specify_allocation (&objfile
->psymbol_obstack
, 0, 0, xmalloc
,
499 obstack_specify_allocation (&objfile
->symbol_obstack
, 0, 0, xmalloc
,
501 obstack_specify_allocation (&objfile
->type_obstack
, 0, 0, xmalloc
,
503 objfile
->name
= mstrsave (objfile
->md
, "rt_common");
505 /* Add this file onto the tail of the linked list of other such files. */
507 objfile
->next
= NULL
;
508 if (object_files
== NULL
)
509 object_files
= objfile
;
512 for (last_one
= object_files
;
514 last_one
= last_one
->next
);
515 last_one
->next
= objfile
;
518 rt_common_objfile
= objfile
;
521 /* Read all dynamically loaded common symbol definitions from the inferior
522 and put them into the minimal symbol table for the runtime common
526 solib_add_common_symbols (CORE_ADDR rtc_symp
)
528 struct rtc_symb inferior_rtc_symb
;
529 struct nlist inferior_rtc_nlist
;
533 /* Remove any runtime common symbols from previous runs. */
535 if (rt_common_objfile
!= NULL
&& rt_common_objfile
->minimal_symbol_count
)
537 obstack_free (&rt_common_objfile
->symbol_obstack
, 0);
538 obstack_specify_allocation (&rt_common_objfile
->symbol_obstack
, 0, 0,
540 rt_common_objfile
->minimal_symbol_count
= 0;
541 rt_common_objfile
->msymbols
= NULL
;
544 init_minimal_symbol_collection ();
545 make_cleanup_discard_minimal_symbols ();
549 read_memory (rtc_symp
,
550 (char *) &inferior_rtc_symb
,
551 sizeof (inferior_rtc_symb
));
552 read_memory (SOLIB_EXTRACT_ADDRESS (inferior_rtc_symb
.rtc_sp
),
553 (char *) &inferior_rtc_nlist
,
554 sizeof (inferior_rtc_nlist
));
555 if (inferior_rtc_nlist
.n_type
== N_COMM
)
557 /* FIXME: The length of the symbol name is not available, but in the
558 current implementation the common symbol is allocated immediately
559 behind the name of the symbol. */
560 len
= inferior_rtc_nlist
.n_value
- inferior_rtc_nlist
.n_un
.n_strx
;
562 name
= xmalloc (len
);
563 read_memory (SOLIB_EXTRACT_ADDRESS (inferior_rtc_nlist
.n_un
.n_name
),
566 /* Allocate the runtime common objfile if necessary. */
567 if (rt_common_objfile
== NULL
)
568 allocate_rt_common_objfile ();
570 prim_record_minimal_symbol (name
, inferior_rtc_nlist
.n_value
,
571 mst_bss
, rt_common_objfile
);
574 rtc_symp
= SOLIB_EXTRACT_ADDRESS (inferior_rtc_symb
.rtc_next
);
577 /* Install any minimal symbols that have been collected as the current
578 minimal symbols for the runtime common objfile. */
580 install_minimal_symbols (rt_common_objfile
);
583 #endif /* SVR4_SHARED_LIBS */
586 #ifdef SVR4_SHARED_LIBS
588 static CORE_ADDR
bfd_lookup_symbol (bfd
*, char *);
594 bfd_lookup_symbol -- lookup the value for a specific symbol
598 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
602 An expensive way to lookup the value of a single symbol for
603 bfd's that are only temporary anyway. This is used by the
604 shared library support to find the address of the debugger
605 interface structures in the shared library.
607 Note that 0 is specifically allowed as an error return (no
612 bfd_lookup_symbol (bfd
*abfd
, char *symname
)
614 unsigned int storage_needed
;
616 asymbol
**symbol_table
;
617 unsigned int number_of_symbols
;
619 struct cleanup
*back_to
;
620 CORE_ADDR symaddr
= 0;
622 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
624 if (storage_needed
> 0)
626 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
627 back_to
= make_cleanup (free
, (PTR
) symbol_table
);
628 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
630 for (i
= 0; i
< number_of_symbols
; i
++)
632 sym
= *symbol_table
++;
633 if (STREQ (sym
->name
, symname
))
635 /* Bfd symbols are section relative. */
636 symaddr
= sym
->value
+ sym
->section
->vma
;
640 do_cleanups (back_to
);
646 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
647 have to check the dynamic string table too. */
649 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
651 if (storage_needed
> 0)
653 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
654 back_to
= make_cleanup (free
, (PTR
) symbol_table
);
655 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
657 for (i
= 0; i
< number_of_symbols
; i
++)
659 sym
= *symbol_table
++;
660 if (STREQ (sym
->name
, symname
))
662 /* Bfd symbols are section relative. */
663 symaddr
= sym
->value
+ sym
->section
->vma
;
667 do_cleanups (back_to
);
673 #ifdef HANDLE_SVR4_EXEC_EMULATORS
676 Solaris BCP (the part of Solaris which allows it to run SunOS4
677 a.out files) throws in another wrinkle. Solaris does not fill
678 in the usual a.out link map structures when running BCP programs,
679 the only way to get at them is via groping around in the dynamic
681 The dynamic linker and it's structures are located in the shared
682 C library, which gets run as the executable's "interpreter" by
685 Note that we can assume nothing about the process state at the time
686 we need to find these structures. We may be stopped on the first
687 instruction of the interpreter (C shared library), the first
688 instruction of the executable itself, or somewhere else entirely
689 (if we attached to the process for example).
692 static char *debug_base_symbols
[] =
694 "r_debug", /* Solaris 2.3 */
695 "_r_debug", /* Solaris 2.1, 2.2 */
699 static int look_for_base (int, CORE_ADDR
);
705 look_for_base -- examine file for each mapped address segment
709 static int look_for_base (int fd, CORE_ADDR baseaddr)
713 This function is passed to proc_iterate_over_mappings, which
714 causes it to get called once for each mapped address space, with
715 an open file descriptor for the file mapped to that space, and the
716 base address of that mapped space.
718 Our job is to find the debug base symbol in the file that this
719 fd is open on, if it exists, and if so, initialize the dynamic
720 linker structure base address debug_base.
722 Note that this is a computationally expensive proposition, since
723 we basically have to open a bfd on every call, so we specifically
724 avoid opening the exec file.
728 look_for_base (int fd
, CORE_ADDR baseaddr
)
731 CORE_ADDR address
= 0;
734 /* If the fd is -1, then there is no file that corresponds to this
735 mapped memory segment, so skip it. Also, if the fd corresponds
736 to the exec file, skip it as well. */
740 && fdmatch (fileno ((FILE *) (exec_bfd
->iostream
)), fd
)))
745 /* Try to open whatever random file this fd corresponds to. Note that
746 we have no way currently to find the filename. Don't gripe about
747 any problems we might have, just fail. */
749 if ((interp_bfd
= bfd_fdopenr ("unnamed", gnutarget
, fd
)) == NULL
)
753 if (!bfd_check_format (interp_bfd
, bfd_object
))
755 /* FIXME-leak: on failure, might not free all memory associated with
757 bfd_close (interp_bfd
);
761 /* Now try to find our debug base symbol in this file, which we at
762 least know to be a valid ELF executable or shared library. */
764 for (symbolp
= debug_base_symbols
; *symbolp
!= NULL
; symbolp
++)
766 address
= bfd_lookup_symbol (interp_bfd
, *symbolp
);
774 /* FIXME-leak: on failure, might not free all memory associated with
776 bfd_close (interp_bfd
);
780 /* Eureka! We found the symbol. But now we may need to relocate it
781 by the base address. If the symbol's value is less than the base
782 address of the shared library, then it hasn't yet been relocated
783 by the dynamic linker, and we have to do it ourself. FIXME: Note
784 that we make the assumption that the first segment that corresponds
785 to the shared library has the base address to which the library
788 if (address
< baseaddr
)
792 debug_base
= address
;
793 /* FIXME-leak: on failure, might not free all memory associated with
795 bfd_close (interp_bfd
);
798 #endif /* HANDLE_SVR4_EXEC_EMULATORS */
804 elf_locate_base -- locate the base address of dynamic linker structs
805 for SVR4 elf targets.
809 CORE_ADDR elf_locate_base (void)
813 For SVR4 elf targets the address of the dynamic linker's runtime
814 structure is contained within the dynamic info section in the
815 executable file. The dynamic section is also mapped into the
816 inferior address space. Because the runtime loader fills in the
817 real address before starting the inferior, we have to read in the
818 dynamic info section from the inferior address space.
819 If there are any errors while trying to find the address, we
820 silently return 0, otherwise the found address is returned.
825 elf_locate_base (void)
827 sec_ptr dyninfo_sect
;
828 int dyninfo_sect_size
;
829 CORE_ADDR dyninfo_addr
;
834 /* Find the start address of the .dynamic section. */
835 dyninfo_sect
= bfd_get_section_by_name (exec_bfd
, ".dynamic");
836 if (dyninfo_sect
== NULL
)
838 dyninfo_addr
= bfd_section_vma (exec_bfd
, dyninfo_sect
);
840 /* Read in .dynamic section, silently ignore errors. */
841 dyninfo_sect_size
= bfd_section_size (exec_bfd
, dyninfo_sect
);
842 buf
= alloca (dyninfo_sect_size
);
843 if (target_read_memory (dyninfo_addr
, buf
, dyninfo_sect_size
))
846 /* Find the DT_DEBUG entry in the the .dynamic section.
847 For mips elf we look for DT_MIPS_RLD_MAP, mips elf apparently has
848 no DT_DEBUG entries. */
850 arch_size
= bfd_get_arch_size (exec_bfd
);
851 if (arch_size
== -1) /* failure */
856 for (bufend
= buf
+ dyninfo_sect_size
;
858 buf
+= sizeof (Elf32_External_Dyn
))
860 Elf32_External_Dyn
*x_dynp
= (Elf32_External_Dyn
*) buf
;
864 dyn_tag
= bfd_h_get_32 (exec_bfd
, (bfd_byte
*) x_dynp
->d_tag
);
865 if (dyn_tag
== DT_NULL
)
867 else if (dyn_tag
== DT_DEBUG
)
869 dyn_ptr
= bfd_h_get_32 (exec_bfd
,
870 (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
873 #ifdef DT_MIPS_RLD_MAP
874 else if (dyn_tag
== DT_MIPS_RLD_MAP
)
878 pbuf
= alloca (TARGET_PTR_BIT
/ HOST_CHAR_BIT
);
879 /* DT_MIPS_RLD_MAP contains a pointer to the address
880 of the dynamic link structure. */
881 dyn_ptr
= bfd_h_get_32 (exec_bfd
,
882 (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
883 if (target_read_memory (dyn_ptr
, pbuf
, sizeof (pbuf
)))
885 return extract_unsigned_integer (pbuf
, sizeof (pbuf
));
890 else /* 64-bit elf */
892 for (bufend
= buf
+ dyninfo_sect_size
;
894 buf
+= sizeof (Elf64_External_Dyn
))
896 Elf64_External_Dyn
*x_dynp
= (Elf64_External_Dyn
*) buf
;
900 dyn_tag
= bfd_h_get_64 (exec_bfd
, (bfd_byte
*) x_dynp
->d_tag
);
901 if (dyn_tag
== DT_NULL
)
903 else if (dyn_tag
== DT_DEBUG
)
905 dyn_ptr
= bfd_h_get_64 (exec_bfd
,
906 (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
912 /* DT_DEBUG entry not found. */
916 #endif /* SVR4_SHARED_LIBS */
922 locate_base -- locate the base address of dynamic linker structs
926 CORE_ADDR locate_base (void)
930 For both the SunOS and SVR4 shared library implementations, if the
931 inferior executable has been linked dynamically, there is a single
932 address somewhere in the inferior's data space which is the key to
933 locating all of the dynamic linker's runtime structures. This
934 address is the value of the debug base symbol. The job of this
935 function is to find and return that address, or to return 0 if there
936 is no such address (the executable is statically linked for example).
938 For SunOS, the job is almost trivial, since the dynamic linker and
939 all of it's structures are statically linked to the executable at
940 link time. Thus the symbol for the address we are looking for has
941 already been added to the minimal symbol table for the executable's
942 objfile at the time the symbol file's symbols were read, and all we
943 have to do is look it up there. Note that we explicitly do NOT want
944 to find the copies in the shared library.
946 The SVR4 version is a bit more complicated because the address
947 is contained somewhere in the dynamic info section. We have to go
948 to a lot more work to discover the address of the debug base symbol.
949 Because of this complexity, we cache the value we find and return that
950 value on subsequent invocations. Note there is no copy in the
951 executable symbol tables.
959 #ifndef SVR4_SHARED_LIBS
961 struct minimal_symbol
*msymbol
;
962 CORE_ADDR address
= 0;
965 /* For SunOS, we want to limit the search for the debug base symbol to the
966 executable being debugged, since there is a duplicate named symbol in the
967 shared library. We don't want the shared library versions. */
969 for (symbolp
= debug_base_symbols
; *symbolp
!= NULL
; symbolp
++)
971 msymbol
= lookup_minimal_symbol (*symbolp
, NULL
, symfile_objfile
);
972 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
974 address
= SYMBOL_VALUE_ADDRESS (msymbol
);
980 #else /* SVR4_SHARED_LIBS */
982 /* Check to see if we have a currently valid address, and if so, avoid
983 doing all this work again and just return the cached address. If
984 we have no cached address, try to locate it in the dynamic info
985 section for ELF executables. */
990 && bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
991 debug_base
= elf_locate_base ();
992 #ifdef HANDLE_SVR4_EXEC_EMULATORS
993 /* Try it the hard way for emulated executables. */
994 else if (inferior_pid
!= 0 && target_has_execution
)
995 proc_iterate_over_mappings (look_for_base
);
1000 #endif /* !SVR4_SHARED_LIBS */
1008 first_link_map_member -- locate first member in dynamic linker's map
1012 static CORE_ADDR first_link_map_member (void)
1016 Find the first element in the inferior's dynamic link map, and
1017 return its address in the inferior. This function doesn't copy the
1018 link map entry itself into our address space; current_sos actually
1019 does the reading. */
1022 first_link_map_member (void)
1026 #ifndef SVR4_SHARED_LIBS
1028 read_memory (debug_base
, (char *) &dynamic_copy
, sizeof (dynamic_copy
));
1029 if (dynamic_copy
.ld_version
>= 2)
1031 /* It is a version that we can deal with, so read in the secondary
1032 structure and find the address of the link map list from it. */
1033 read_memory (SOLIB_EXTRACT_ADDRESS (dynamic_copy
.ld_un
.ld_2
),
1034 (char *) &ld_2_copy
, sizeof (struct link_dynamic_2
));
1035 lm
= SOLIB_EXTRACT_ADDRESS (ld_2_copy
.ld_loaded
);
1038 #else /* SVR4_SHARED_LIBS */
1039 #if defined (HAVE_STRUCT_LINK_MAP32)
1040 if (bfd_get_arch_size (exec_bfd
) == 32)
1042 read_memory (debug_base
, (char *) &debug32_copy
,
1043 sizeof (struct r_debug32
));
1044 lm
= SOLIB_EXTRACT_ADDRESS (debug32_copy
.r_map
);
1049 read_memory (debug_base
, (char *) &debug_copy
,
1050 sizeof (struct r_debug
));
1051 lm
= SOLIB_EXTRACT_ADDRESS (debug_copy
.r_map
);
1053 /* FIXME: Perhaps we should validate the info somehow, perhaps by
1054 checking r_version for a known version number, or r_state for
1057 #endif /* !SVR4_SHARED_LIBS */
1062 #ifdef SVR4_SHARED_LIBS
1067 open_symbol_file_object
1071 void open_symbol_file_object (int from_tty)
1075 If no open symbol file, attempt to locate and open the main symbol
1076 file. On SVR4 systems, this is the first link map entry. If its
1077 name is here, we can open it. Useful when attaching to a process
1078 without first loading its symbol file.
1083 open_symbol_file_object (from_ttyp
)
1084 int *from_ttyp
; /* sneak past catch_errors */
1090 if (symfile_objfile
)
1091 if (!query ("Attempt to reload symbols from process? "))
1094 if ((debug_base
= locate_base ()) == 0)
1095 return 0; /* failed somehow... */
1097 /* First link map member should be the executable. */
1098 if ((lm
= first_link_map_member ()) == 0)
1099 return 0; /* failed somehow... */
1101 #if defined (HAVE_STRUCT_LINK_MAP32)
1102 if (bfd_get_arch_size (exec_bfd
) == 32)
1104 struct link_map32 lmcopy
;
1105 /* Read from target memory to GDB. */
1106 read_memory (lm
, (void *) &lmcopy
, sizeof (lmcopy
));
1108 if (lmcopy
.l_name
== 0)
1109 return 0; /* no filename. */
1111 /* Now fetch the filename from target memory. */
1112 target_read_string (SOLIB_EXTRACT_ADDRESS (lmcopy
.l_name
),
1113 &filename
, MAX_PATH_SIZE
- 1, &errcode
);
1116 #endif /* HAVE_STRUCT_LINK_MAP32 */
1118 struct link_map lmcopy
;
1119 /* Read from target memory to GDB. */
1120 read_memory (lm
, (void *) &lmcopy
, sizeof (lmcopy
));
1122 if (lmcopy
.l_name
== 0)
1123 return 0; /* no filename. */
1125 /* Now fetch the filename from target memory. */
1126 target_read_string (SOLIB_EXTRACT_ADDRESS (lmcopy
.l_name
), &filename
,
1127 MAX_PATH_SIZE
- 1, &errcode
);
1132 warning ("failed to read exec filename from attached file: %s",
1133 safe_strerror (errcode
));
1137 make_cleanup (free
, filename
);
1138 /* Have a pathname: read the symbol file. */
1139 symbol_file_command (filename
, *from_ttyp
);
1143 #endif /* SVR4_SHARED_LIBS */
1148 free_so --- free a `struct so_list' object
1152 void free_so (struct so_list *so)
1156 Free the storage associated with the `struct so_list' object SO.
1157 If we have opened a BFD for SO, close it.
1159 The caller is responsible for removing SO from whatever list it is
1160 a member of. If we have placed SO's sections in some target's
1161 section table, the caller is responsible for removing them.
1163 This function doesn't mess with objfiles at all. If there is an
1164 objfile associated with SO that needs to be removed, the caller is
1165 responsible for taking care of that. */
1168 free_so (struct so_list
*so
)
1170 char *bfd_filename
= 0;
1173 free (so
->sections
);
1177 bfd_filename
= bfd_get_filename (so
->abfd
);
1178 if (! bfd_close (so
->abfd
))
1179 warning ("cannot close \"%s\": %s",
1180 bfd_filename
, bfd_errmsg (bfd_get_error ()));
1184 free (bfd_filename
);
1190 /* On some systems, the only way to recognize the link map entry for
1191 the main executable file is by looking at its name. Return
1192 non-zero iff SONAME matches one of the known main executable names. */
1195 match_main (char *soname
)
1199 for (mainp
= main_name_list
; *mainp
!= NULL
; mainp
++)
1201 if (strcmp (soname
, *mainp
) == 0)
1211 current_sos -- build a list of currently loaded shared objects
1215 struct so_list *current_sos ()
1219 Build a list of `struct so_list' objects describing the shared
1220 objects currently loaded in the inferior. This list does not
1221 include an entry for the main executable file.
1223 Note that we only gather information directly available from the
1224 inferior --- we don't examine any of the shared library files
1225 themselves. The declaration of `struct so_list' says which fields
1226 we provide values for. */
1228 static struct so_list
*
1232 struct so_list
*head
= 0;
1233 struct so_list
**link_ptr
= &head
;
1235 /* Make sure we've looked up the inferior's dynamic linker's base
1239 debug_base
= locate_base ();
1241 /* If we can't find the dynamic linker's base structure, this
1242 must not be a dynamically linked executable. Hmm. */
1247 /* Walk the inferior's link map list, and build our list of
1248 `struct so_list' nodes. */
1249 lm
= first_link_map_member ();
1253 = (struct so_list
*) xmalloc (sizeof (struct so_list
));
1254 struct cleanup
*old_chain
= make_cleanup (free
, new);
1255 memset (new, 0, sizeof (*new));
1259 #if defined (HAVE_STRUCT_LINK_MAP32)
1260 if (bfd_get_arch_size (exec_bfd
) == 32)
1261 read_memory (lm
, (char *) &(new->lm32
), sizeof (struct link_map32
));
1264 read_memory (lm
, (char *) &(new->lm
), sizeof (struct link_map
));
1268 /* For SVR4 versions, the first entry in the link map is for the
1269 inferior executable, so we must ignore it. For some versions of
1270 SVR4, it has no name. For others (Solaris 2.3 for example), it
1271 does have a name, so we can no longer use a missing name to
1272 decide when to ignore it. */
1273 if (IGNORE_FIRST_LINK_MAP_ENTRY (new))
1280 /* Extract this shared object's name. */
1281 target_read_string (LM_NAME (new), &buffer
,
1282 MAX_PATH_SIZE
- 1, &errcode
);
1285 warning ("current_sos: Can't read pathname for load map: %s\n",
1286 safe_strerror (errcode
));
1290 strncpy (new->so_name
, buffer
, MAX_PATH_SIZE
- 1);
1291 new->so_name
[MAX_PATH_SIZE
- 1] = '\0';
1293 strcpy (new->so_original_name
, new->so_name
);
1296 /* If this entry has no name, or its name matches the name
1297 for the main executable, don't include it in the list. */
1298 if (! new->so_name
[0]
1299 || match_main (new->so_name
))
1305 link_ptr
= &new->next
;
1309 discard_cleanups (old_chain
);
1316 /* A small stub to get us past the arg-passing pinhole of catch_errors. */
1319 symbol_add_stub (PTR arg
)
1321 register struct so_list
*so
= (struct so_list
*) arg
; /* catch_errs bogon */
1322 struct section_addr_info
*sap
;
1323 CORE_ADDR lowest_addr
= 0;
1325 asection
*lowest_sect
= NULL
;
1327 /* Have we already loaded this shared object? */
1328 ALL_OBJFILES (so
->objfile
)
1330 if (strcmp (so
->objfile
->name
, so
->so_name
) == 0)
1334 /* Find the shared object's text segment. */
1335 if (so
->textsection
)
1337 lowest_addr
= so
->textsection
->addr
;
1338 lowest_sect
= bfd_get_section_by_name (so
->abfd
, ".text");
1339 lowest_index
= lowest_sect
->index
;
1341 else if (so
->abfd
!= NULL
)
1343 /* If we didn't find a mapped non zero sized .text section, set
1344 up lowest_addr so that the relocation in symbol_file_add does
1346 lowest_sect
= bfd_get_section_by_name (so
->abfd
, ".text");
1347 if (lowest_sect
== NULL
)
1348 bfd_map_over_sections (so
->abfd
, find_lowest_section
,
1349 (PTR
) &lowest_sect
);
1352 lowest_addr
= bfd_section_vma (so
->abfd
, lowest_sect
)
1354 lowest_index
= lowest_sect
->index
;
1358 sap
= build_section_addr_info_from_section_table (so
->sections
,
1361 sap
->other
[lowest_index
].addr
= lowest_addr
;
1363 so
->objfile
= symbol_file_add (so
->so_name
, so
->from_tty
,
1364 sap
, 0, OBJF_SHARED
);
1365 free_section_addr_info (sap
);
1373 update_solib_list --- synchronize GDB's shared object list with inferior's
1377 void update_solib_list (int from_tty, struct target_ops *TARGET)
1379 Extract the list of currently loaded shared objects from the
1380 inferior, and compare it with the list of shared objects currently
1381 in GDB's so_list_head list. Edit so_list_head to bring it in sync
1382 with the inferior's new list.
1384 If we notice that the inferior has unloaded some shared objects,
1385 free any symbolic info GDB had read about those shared objects.
1387 Don't load symbolic info for any new shared objects; just add them
1388 to the list, and leave their symbols_loaded flag clear.
1390 If FROM_TTY is non-null, feel free to print messages about what
1393 If TARGET is non-null, add the sections of all new shared objects
1394 to TARGET's section table. Note that this doesn't remove any
1395 sections for shared objects that have been unloaded, and it
1396 doesn't check to see if the new shared objects are already present in
1397 the section table. But we only use this for core files and
1398 processes we've just attached to, so that's okay. */
1401 update_solib_list (int from_tty
, struct target_ops
*target
)
1403 struct so_list
*inferior
= current_sos ();
1404 struct so_list
*gdb
, **gdb_link
;
1406 #ifdef SVR4_SHARED_LIBS
1407 /* If we are attaching to a running process for which we
1408 have not opened a symbol file, we may be able to get its
1411 symfile_objfile
== NULL
)
1412 catch_errors (open_symbol_file_object
, (PTR
) &from_tty
,
1413 "Error reading attached process's symbol file.\n",
1416 #endif SVR4_SHARED_LIBS
1418 /* Since this function might actually add some elements to the
1419 so_list_head list, arrange for it to be cleaned up when
1421 if (!solib_cleanup_queued
)
1423 make_run_cleanup (do_clear_solib
, NULL
);
1424 solib_cleanup_queued
= 1;
1427 /* GDB and the inferior's dynamic linker each maintain their own
1428 list of currently loaded shared objects; we want to bring the
1429 former in sync with the latter. Scan both lists, seeing which
1430 shared objects appear where. There are three cases:
1432 - A shared object appears on both lists. This means that GDB
1433 knows about it already, and it's still loaded in the inferior.
1434 Nothing needs to happen.
1436 - A shared object appears only on GDB's list. This means that
1437 the inferior has unloaded it. We should remove the shared
1438 object from GDB's tables.
1440 - A shared object appears only on the inferior's list. This
1441 means that it's just been loaded. We should add it to GDB's
1444 So we walk GDB's list, checking each entry to see if it appears
1445 in the inferior's list too. If it does, no action is needed, and
1446 we remove it from the inferior's list. If it doesn't, the
1447 inferior has unloaded it, and we remove it from GDB's list. By
1448 the time we're done walking GDB's list, the inferior's list
1449 contains only the new shared objects, which we then add. */
1452 gdb_link
= &so_list_head
;
1455 struct so_list
*i
= inferior
;
1456 struct so_list
**i_link
= &inferior
;
1458 /* Check to see whether the shared object *gdb also appears in
1459 the inferior's current list. */
1462 if (! strcmp (gdb
->so_original_name
, i
->so_original_name
))
1469 /* If the shared object appears on the inferior's list too, then
1470 it's still loaded, so we don't need to do anything. Delete
1471 it from the inferior's list, and leave it on GDB's list. */
1476 gdb_link
= &gdb
->next
;
1480 /* If it's not on the inferior's list, remove it from GDB's tables. */
1483 *gdb_link
= gdb
->next
;
1485 /* Unless the user loaded it explicitly, free SO's objfile. */
1486 if (gdb
->objfile
&& ! (gdb
->objfile
->flags
& OBJF_USERLOADED
))
1487 free_objfile (gdb
->objfile
);
1489 /* Some targets' section tables might be referring to
1490 sections from so->abfd; remove them. */
1491 remove_target_sections (gdb
->abfd
);
1498 /* Now the inferior's list contains only shared objects that don't
1499 appear in GDB's list --- those that are newly loaded. Add them
1500 to GDB's shared object list. */
1505 /* Add the new shared objects to GDB's list. */
1506 *gdb_link
= inferior
;
1508 /* Fill in the rest of each of the `struct so_list' nodes. */
1509 for (i
= inferior
; i
; i
= i
->next
)
1511 i
->from_tty
= from_tty
;
1513 /* Fill in the rest of the `struct so_list' node. */
1514 catch_errors (solib_map_sections
, i
,
1515 "Error while mapping shared library sections:\n",
1519 /* If requested, add the shared objects' sections to the the
1520 TARGET's section table. */
1525 /* Figure out how many sections we'll need to add in total. */
1527 for (i
= inferior
; i
; i
= i
->next
)
1528 new_sections
+= (i
->sections_end
- i
->sections
);
1530 if (new_sections
> 0)
1532 int space
= target_resize_to_sections (target
, new_sections
);
1534 for (i
= inferior
; i
; i
= i
->next
)
1536 int count
= (i
->sections_end
- i
->sections
);
1537 memcpy (target
->to_sections
+ space
,
1539 count
* sizeof (i
->sections
[0]));
1550 solib_add -- read in symbol info for newly added shared libraries
1554 void solib_add (char *pattern, int from_tty, struct target_ops *TARGET)
1558 Read in symbolic information for any shared objects whose names
1559 match PATTERN. (If we've already read a shared object's symbol
1560 info, leave it alone.) If PATTERN is zero, read them all.
1562 FROM_TTY and TARGET are as described for update_solib_list, above. */
1565 solib_add (char *pattern
, int from_tty
, struct target_ops
*target
)
1567 struct so_list
*gdb
;
1571 char *re_err
= re_comp (pattern
);
1574 error ("Invalid regexp: %s", re_err
);
1577 update_solib_list (from_tty
, target
);
1579 /* Walk the list of currently loaded shared libraries, and read
1580 symbols for any that match the pattern --- or any whose symbols
1581 aren't already loaded, if no pattern was given. */
1583 int any_matches
= 0;
1584 int loaded_any_symbols
= 0;
1586 for (gdb
= so_list_head
; gdb
; gdb
= gdb
->next
)
1587 if (! pattern
|| re_exec (gdb
->so_name
))
1591 if (gdb
->symbols_loaded
)
1594 printf_unfiltered ("Symbols already loaded for %s\n",
1600 (symbol_add_stub
, gdb
,
1601 "Error while reading shared library symbols:\n",
1605 printf_unfiltered ("Loaded symbols for %s\n",
1607 gdb
->symbols_loaded
= 1;
1608 loaded_any_symbols
= 1;
1613 if (from_tty
&& pattern
&& ! any_matches
)
1615 ("No loaded shared libraries match the pattern `%s'.\n", pattern
);
1617 if (loaded_any_symbols
)
1619 /* Getting new symbols may change our opinion about what is
1621 reinit_frame_cache ();
1623 special_symbol_handling ();
1633 info_sharedlibrary_command -- code for "info sharedlibrary"
1637 static void info_sharedlibrary_command ()
1641 Walk through the shared library list and print information
1642 about each attached library.
1646 info_sharedlibrary_command (char *ignore
, int from_tty
)
1648 register struct so_list
*so
= NULL
; /* link map state variable */
1649 int header_done
= 0;
1654 if (exec_bfd
== NULL
)
1656 printf_unfiltered ("No executable file.\n");
1660 arch_size
= bfd_get_arch_size (exec_bfd
);
1661 /* Default to 32-bit in case of failure (non-elf). */
1662 if (arch_size
== 32 || arch_size
== -1)
1667 else if (arch_size
== 64)
1669 addr_width
= 16 + 4;
1673 update_solib_list (from_tty
, 0);
1675 for (so
= so_list_head
; so
; so
= so
->next
)
1681 printf_unfiltered ("%-*s%-*s%-12s%s\n", addr_width
, "From",
1682 addr_width
, "To", "Syms Read",
1683 "Shared Object Library");
1687 printf_unfiltered ("%-*s", addr_width
,
1688 local_hex_string_custom ((unsigned long) LM_ADDR (so
),
1690 printf_unfiltered ("%-*s", addr_width
,
1691 local_hex_string_custom ((unsigned long) so
->lmend
,
1693 printf_unfiltered ("%-12s", so
->symbols_loaded
? "Yes" : "No");
1694 printf_unfiltered ("%s\n", so
->so_name
);
1697 if (so_list_head
== NULL
)
1699 printf_unfiltered ("No shared libraries loaded at this time.\n");
1707 solib_address -- check to see if an address is in a shared lib
1711 char * solib_address (CORE_ADDR address)
1715 Provides a hook for other gdb routines to discover whether or
1716 not a particular address is within the mapped address space of
1717 a shared library. Any address between the base mapping address
1718 and the first address beyond the end of the last mapping, is
1719 considered to be within the shared library address space, for
1722 For example, this routine is called at one point to disable
1723 breakpoints which are in shared libraries that are not currently
1728 solib_address (CORE_ADDR address
)
1730 register struct so_list
*so
= 0; /* link map state variable */
1732 for (so
= so_list_head
; so
; so
= so
->next
)
1734 if (LM_ADDR (so
) <= address
&& address
< so
->lmend
)
1735 return (so
->so_name
);
1741 /* Called by free_all_symtabs */
1746 /* This function is expected to handle ELF shared libraries. It is
1747 also used on Solaris, which can run either ELF or a.out binaries
1748 (for compatibility with SunOS 4), both of which can use shared
1749 libraries. So we don't know whether we have an ELF executable or
1750 an a.out executable until the user chooses an executable file.
1752 ELF shared libraries don't get mapped into the address space
1753 until after the program starts, so we'd better not try to insert
1754 breakpoints in them immediately. We have to wait until the
1755 dynamic linker has loaded them; we'll hit a bp_shlib_event
1756 breakpoint (look for calls to create_solib_event_breakpoint) when
1759 SunOS shared libraries seem to be different --- they're present
1760 as soon as the process begins execution, so there's no need to
1761 put off inserting breakpoints. There's also nowhere to put a
1762 bp_shlib_event breakpoint, so if we put it off, we'll never get
1765 So: disable breakpoints only if we're using ELF shared libs. */
1766 if (exec_bfd
!= NULL
1767 && bfd_get_flavour (exec_bfd
) != bfd_target_aout_flavour
)
1768 disable_breakpoints_in_shlibs (1);
1770 while (so_list_head
)
1772 struct so_list
*so
= so_list_head
;
1773 so_list_head
= so
->next
;
1781 do_clear_solib (PTR dummy
)
1783 solib_cleanup_queued
= 0;
1787 #ifdef SVR4_SHARED_LIBS
1789 /* Return 1 if PC lies in the dynamic symbol resolution code of the
1790 SVR4 run time loader. */
1792 static CORE_ADDR interp_text_sect_low
;
1793 static CORE_ADDR interp_text_sect_high
;
1794 static CORE_ADDR interp_plt_sect_low
;
1795 static CORE_ADDR interp_plt_sect_high
;
1798 in_svr4_dynsym_resolve_code (CORE_ADDR pc
)
1800 return ((pc
>= interp_text_sect_low
&& pc
< interp_text_sect_high
)
1801 || (pc
>= interp_plt_sect_low
&& pc
< interp_plt_sect_high
)
1802 || in_plt_section (pc
, NULL
));
1810 disable_break -- remove the "mapping changed" breakpoint
1814 static int disable_break ()
1818 Removes the breakpoint that gets hit when the dynamic linker
1819 completes a mapping change.
1823 #ifndef SVR4_SHARED_LIBS
1826 disable_break (void)
1830 #ifndef SVR4_SHARED_LIBS
1832 int in_debugger
= 0;
1834 /* Read the debugger structure from the inferior to retrieve the
1835 address of the breakpoint and the original contents of the
1836 breakpoint address. Remove the breakpoint by writing the original
1839 read_memory (debug_addr
, (char *) &debug_copy
, sizeof (debug_copy
));
1841 /* Set `in_debugger' to zero now. */
1843 write_memory (flag_addr
, (char *) &in_debugger
, sizeof (in_debugger
));
1845 breakpoint_addr
= SOLIB_EXTRACT_ADDRESS (debug_copy
.ldd_bp_addr
);
1846 write_memory (breakpoint_addr
, (char *) &debug_copy
.ldd_bp_inst
,
1847 sizeof (debug_copy
.ldd_bp_inst
));
1849 #else /* SVR4_SHARED_LIBS */
1851 /* Note that breakpoint address and original contents are in our address
1852 space, so we just need to write the original contents back. */
1854 if (memory_remove_breakpoint (breakpoint_addr
, shadow_contents
) != 0)
1859 #endif /* !SVR4_SHARED_LIBS */
1861 /* For the SVR4 version, we always know the breakpoint address. For the
1862 SunOS version we don't know it until the above code is executed.
1863 Grumble if we are stopped anywhere besides the breakpoint address. */
1865 if (stop_pc
!= breakpoint_addr
)
1867 warning ("stopped at unknown breakpoint while handling shared libraries");
1873 #endif /* #ifdef SVR4_SHARED_LIBS */
1879 enable_break -- arrange for dynamic linker to hit breakpoint
1883 int enable_break (void)
1887 Both the SunOS and the SVR4 dynamic linkers have, as part of their
1888 debugger interface, support for arranging for the inferior to hit
1889 a breakpoint after mapping in the shared libraries. This function
1890 enables that breakpoint.
1892 For SunOS, there is a special flag location (in_debugger) which we
1893 set to 1. When the dynamic linker sees this flag set, it will set
1894 a breakpoint at a location known only to itself, after saving the
1895 original contents of that place and the breakpoint address itself,
1896 in it's own internal structures. When we resume the inferior, it
1897 will eventually take a SIGTRAP when it runs into the breakpoint.
1898 We handle this (in a different place) by restoring the contents of
1899 the breakpointed location (which is only known after it stops),
1900 chasing around to locate the shared libraries that have been
1901 loaded, then resuming.
1903 For SVR4, the debugger interface structure contains a member (r_brk)
1904 which is statically initialized at the time the shared library is
1905 built, to the offset of a function (_r_debug_state) which is guaran-
1906 teed to be called once before mapping in a library, and again when
1907 the mapping is complete. At the time we are examining this member,
1908 it contains only the unrelocated offset of the function, so we have
1909 to do our own relocation. Later, when the dynamic linker actually
1910 runs, it relocates r_brk to be the actual address of _r_debug_state().
1912 The debugger interface structure also contains an enumeration which
1913 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
1914 depending upon whether or not the library is being mapped or unmapped,
1915 and then set to RT_CONSISTENT after the library is mapped/unmapped.
1923 #ifndef SVR4_SHARED_LIBS
1928 /* Get link_dynamic structure */
1930 j
= target_read_memory (debug_base
, (char *) &dynamic_copy
,
1931 sizeof (dynamic_copy
));
1938 /* Calc address of debugger interface structure */
1940 debug_addr
= SOLIB_EXTRACT_ADDRESS (dynamic_copy
.ldd
);
1942 /* Calc address of `in_debugger' member of debugger interface structure */
1944 flag_addr
= debug_addr
+ (CORE_ADDR
) ((char *) &debug_copy
.ldd_in_debugger
-
1945 (char *) &debug_copy
);
1947 /* Write a value of 1 to this member. */
1950 write_memory (flag_addr
, (char *) &in_debugger
, sizeof (in_debugger
));
1953 #else /* SVR4_SHARED_LIBS */
1955 #ifdef BKPT_AT_SYMBOL
1957 struct minimal_symbol
*msymbol
;
1959 asection
*interp_sect
;
1961 /* First, remove all the solib event breakpoints. Their addresses
1962 may have changed since the last time we ran the program. */
1963 remove_solib_event_breakpoints ();
1965 #ifdef SVR4_SHARED_LIBS
1966 interp_text_sect_low
= interp_text_sect_high
= 0;
1967 interp_plt_sect_low
= interp_plt_sect_high
= 0;
1969 /* Find the .interp section; if not found, warn the user and drop
1970 into the old breakpoint at symbol code. */
1971 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
1974 unsigned int interp_sect_size
;
1976 CORE_ADDR load_addr
;
1978 CORE_ADDR sym_addr
= 0;
1980 /* Read the contents of the .interp section into a local buffer;
1981 the contents specify the dynamic linker this program uses. */
1982 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
1983 buf
= alloca (interp_sect_size
);
1984 bfd_get_section_contents (exec_bfd
, interp_sect
,
1985 buf
, 0, interp_sect_size
);
1987 /* Now we need to figure out where the dynamic linker was
1988 loaded so that we can load its symbols and place a breakpoint
1989 in the dynamic linker itself.
1991 This address is stored on the stack. However, I've been unable
1992 to find any magic formula to find it for Solaris (appears to
1993 be trivial on GNU/Linux). Therefore, we have to try an alternate
1994 mechanism to find the dynamic linker's base address. */
1995 tmp_bfd
= bfd_openr (buf
, gnutarget
);
1996 if (tmp_bfd
== NULL
)
1997 goto bkpt_at_symbol
;
1999 /* Make sure the dynamic linker's really a useful object. */
2000 if (!bfd_check_format (tmp_bfd
, bfd_object
))
2002 warning ("Unable to grok dynamic linker %s as an object file", buf
);
2003 bfd_close (tmp_bfd
);
2004 goto bkpt_at_symbol
;
2007 /* We find the dynamic linker's base address by examining the
2008 current pc (which point at the entry point for the dynamic
2009 linker) and subtracting the offset of the entry point. */
2010 load_addr
= read_pc () - tmp_bfd
->start_address
;
2012 /* Record the relocated start and end address of the dynamic linker
2013 text and plt section for in_svr4_dynsym_resolve_code. */
2014 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
2017 interp_text_sect_low
=
2018 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
2019 interp_text_sect_high
=
2020 interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
2022 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
2025 interp_plt_sect_low
=
2026 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
2027 interp_plt_sect_high
=
2028 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
2031 /* Now try to set a breakpoint in the dynamic linker. */
2032 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2034 sym_addr
= bfd_lookup_symbol (tmp_bfd
, *bkpt_namep
);
2039 /* We're done with the temporary bfd. */
2040 bfd_close (tmp_bfd
);
2044 create_solib_event_breakpoint (load_addr
+ sym_addr
);
2048 /* For whatever reason we couldn't set a breakpoint in the dynamic
2049 linker. Warn and drop into the old code. */
2051 warning ("Unable to find dynamic linker breakpoint function.\nGDB will be unable to debug shared library initializers\nand track explicitly loaded dynamic code.");
2055 /* Scan through the list of symbols, trying to look up the symbol and
2056 set a breakpoint there. Terminate loop when we/if we succeed. */
2058 breakpoint_addr
= 0;
2059 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2061 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
2062 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
2064 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol
));
2069 /* Nothing good happened. */
2072 #endif /* BKPT_AT_SYMBOL */
2074 #endif /* !SVR4_SHARED_LIBS */
2083 solib_create_inferior_hook -- shared library startup support
2087 void solib_create_inferior_hook()
2091 When gdb starts up the inferior, it nurses it along (through the
2092 shell) until it is ready to execute it's first instruction. At this
2093 point, this function gets called via expansion of the macro
2094 SOLIB_CREATE_INFERIOR_HOOK.
2096 For SunOS executables, this first instruction is typically the
2097 one at "_start", or a similar text label, regardless of whether
2098 the executable is statically or dynamically linked. The runtime
2099 startup code takes care of dynamically linking in any shared
2100 libraries, once gdb allows the inferior to continue.
2102 For SVR4 executables, this first instruction is either the first
2103 instruction in the dynamic linker (for dynamically linked
2104 executables) or the instruction at "start" for statically linked
2105 executables. For dynamically linked executables, the system
2106 first exec's /lib/libc.so.N, which contains the dynamic linker,
2107 and starts it running. The dynamic linker maps in any needed
2108 shared libraries, maps in the actual user executable, and then
2109 jumps to "start" in the user executable.
2111 For both SunOS shared libraries, and SVR4 shared libraries, we
2112 can arrange to cooperate with the dynamic linker to discover the
2113 names of shared libraries that are dynamically linked, and the
2114 base addresses to which they are linked.
2116 This function is responsible for discovering those names and
2117 addresses, and saving sufficient information about them to allow
2118 their symbols to be read at a later time.
2122 Between enable_break() and disable_break(), this code does not
2123 properly handle hitting breakpoints which the user might have
2124 set in the startup code or in the dynamic linker itself. Proper
2125 handling will probably have to wait until the implementation is
2126 changed to use the "breakpoint handler function" method.
2128 Also, what if child has exit()ed? Must exit loop somehow.
2132 solib_create_inferior_hook (void)
2134 /* If we are using the BKPT_AT_SYMBOL code, then we don't need the base
2135 yet. In fact, in the case of a SunOS4 executable being run on
2136 Solaris, we can't get it yet. current_sos will get it when it needs
2138 #if !(defined (SVR4_SHARED_LIBS) && defined (BKPT_AT_SYMBOL))
2139 if ((debug_base
= locate_base ()) == 0)
2141 /* Can't find the symbol or the executable is statically linked. */
2146 if (!enable_break ())
2148 warning ("shared library handler failed to enable breakpoint");
2152 #if !defined(SVR4_SHARED_LIBS) || defined(_SCO_DS)
2153 /* SCO and SunOS need the loop below, other systems should be using the
2154 special shared library breakpoints and the shared library breakpoint
2157 Now run the target. It will eventually hit the breakpoint, at
2158 which point all of the libraries will have been mapped in and we
2159 can go groveling around in the dynamic linker structures to find
2160 out what we need to know about them. */
2162 clear_proceed_status ();
2163 stop_soon_quietly
= 1;
2164 stop_signal
= TARGET_SIGNAL_0
;
2167 target_resume (-1, 0, stop_signal
);
2168 wait_for_inferior ();
2170 while (stop_signal
!= TARGET_SIGNAL_TRAP
);
2171 stop_soon_quietly
= 0;
2173 #if !defined(_SCO_DS)
2174 /* We are now either at the "mapping complete" breakpoint (or somewhere
2175 else, a condition we aren't prepared to deal with anyway), so adjust
2176 the PC as necessary after a breakpoint, disable the breakpoint, and
2177 add any shared libraries that were mapped in. */
2179 if (DECR_PC_AFTER_BREAK
)
2181 stop_pc
-= DECR_PC_AFTER_BREAK
;
2182 write_register (PC_REGNUM
, stop_pc
);
2185 if (!disable_break ())
2187 warning ("shared library handler failed to disable breakpoint");
2191 solib_add ((char *) 0, 0, (struct target_ops
*) 0);
2192 #endif /* ! _SCO_DS */
2200 special_symbol_handling -- additional shared library symbol handling
2204 void special_symbol_handling ()
2208 Once the symbols from a shared object have been loaded in the usual
2209 way, we are called to do any system specific symbol handling that
2212 For SunOS4, this consists of grunging around in the dynamic
2213 linkers structures to find symbol definitions for "common" symbols
2214 and adding them to the minimal symbol table for the runtime common
2220 special_symbol_handling (void)
2222 #ifndef SVR4_SHARED_LIBS
2225 if (debug_addr
== 0)
2227 /* Get link_dynamic structure */
2229 j
= target_read_memory (debug_base
, (char *) &dynamic_copy
,
2230 sizeof (dynamic_copy
));
2237 /* Calc address of debugger interface structure */
2238 /* FIXME, this needs work for cross-debugging of core files
2239 (byteorder, size, alignment, etc). */
2241 debug_addr
= SOLIB_EXTRACT_ADDRESS (dynamic_copy
.ldd
);
2244 /* Read the debugger structure from the inferior, just to make sure
2245 we have a current copy. */
2247 j
= target_read_memory (debug_addr
, (char *) &debug_copy
,
2248 sizeof (debug_copy
));
2250 return; /* unreadable */
2252 /* Get common symbol definitions for the loaded object. */
2254 if (debug_copy
.ldd_cp
)
2256 solib_add_common_symbols (SOLIB_EXTRACT_ADDRESS (debug_copy
.ldd_cp
));
2259 #endif /* !SVR4_SHARED_LIBS */
2267 sharedlibrary_command -- handle command to explicitly add library
2271 static void sharedlibrary_command (char *args, int from_tty)
2278 sharedlibrary_command (char *args
, int from_tty
)
2281 solib_add (args
, from_tty
, (struct target_ops
*) 0);
2284 #endif /* HAVE_LINK_H */
2287 _initialize_solib (void)
2291 add_com ("sharedlibrary", class_files
, sharedlibrary_command
,
2292 "Load shared object library symbols for files matching REGEXP.");
2293 add_info ("sharedlibrary", info_sharedlibrary_command
,
2294 "Status of loaded shared object libraries.");
2297 (add_set_cmd ("auto-solib-add", class_support
, var_zinteger
,
2298 (char *) &auto_solib_add
,
2299 "Set autoloading of shared library symbols.\n\
2300 If nonzero, symbols from all shared object libraries will be loaded\n\
2301 automatically when the inferior begins execution or when the dynamic linker\n\
2302 informs gdb that a new library has been loaded. Otherwise, symbols\n\
2303 must be loaded manually, using `sharedlibrary'.",
2308 (add_set_cmd ("solib-absolute-prefix", class_support
, var_filename
,
2309 (char *) &solib_absolute_prefix
,
2310 "Set prefix for loading absolute shared library symbol files.\n\
2311 For other (relative) files, you can add values using `set solib-search-path'.",
2315 (add_set_cmd ("solib-search-path", class_support
, var_string
,
2316 (char *) &solib_search_path
,
2317 "Set the search path for loading non-absolute shared library symbol files.\n\
2318 This takes precedence over the environment variables PATH and LD_LIBRARY_PATH.",
2322 #endif /* HAVE_LINK_H */