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
198 LM_ADDR (struct so_list *so)
200 #if defined (HAVE_STRUCT_LINK_MAP32)
201 if (bfd_get_arch_size (exec_bfd) == 32)
202 return extract_address (&so->lm32.lm_addr, sizeof (so->lm32.lm_addr));
205 return extract_address (&so->lm.lm_addr, sizeof (so->lm.lm_addr));
209 LM_NEXT (struct so_list *so)
211 #if defined (HAVE_STRUCT_LINK_MAP32)
212 if (bfd_get_arch_size (exec_bfd) == 32)
213 return extract_address (&so->lm32.lm_next, sizeof (so->lm32.lm_next));
216 return extract_address (&so->lm.lm_next, sizeof (so->lm.lm_next));
220 LM_NAME (struct so_list *so)
222 #if defined (HAVE_STRUCT_LINK_MAP32)
223 if (bfd_get_arch_size (exec_bfd) == 32)
224 return extract_address (&so->lm32.lm_name, sizeof (so->lm32.lm_name));
227 return extract_address (&so->lm.lm_name, sizeof (so->lm.lm_name));
231 IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list *so)
236 #else /* SVR4_SHARED_LIBS */
239 LM_ADDR (struct so_list *so)
241 #if defined (HAVE_STRUCT_LINK_MAP32)
242 if (bfd_get_arch_size (exec_bfd) == 32)
243 return extract_address (&so->lm32.l_addr, sizeof (so->lm32.l_addr));
246 return extract_address (&so->lm.l_addr, sizeof (so->lm.l_addr));
250 LM_NEXT (struct so_list *so)
252 #if defined (HAVE_STRUCT_LINK_MAP32)
253 if (bfd_get_arch_size (exec_bfd) == 32)
254 return extract_address (&so->lm32.l_next, sizeof (so->lm32.l_next));
257 return extract_address (&so->lm.l_next, sizeof (so->lm.l_next));
261 LM_NAME (struct so_list *so)
263 #if defined (HAVE_STRUCT_LINK_MAP32)
264 if (bfd_get_arch_size (exec_bfd) == 32)
265 return extract_address (&so->lm32.l_name, sizeof (so->lm32.l_name));
268 return extract_address (&so->lm.l_name, sizeof (so->lm.l_name));
272 IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list *so)
274 #if defined (HAVE_STRUCT_LINK_MAP32)
275 if (bfd_get_arch_size (exec_bfd) == 32)
276 return (solib_extract_address (&(so) -> lm32.l_prev) == 0);
279 return (solib_extract_address (&(so) -> lm.l_prev) == 0);
282 #endif /* !SVR4_SHARED_LIBS */
285 static CORE_ADDR debug_base; /* Base of dynamic linker structures */
286 static CORE_ADDR breakpoint_addr; /* Address where end bkpt is set */
288 static int solib_cleanup_queued = 0; /* make_run_cleanup called */
290 extern int fdmatch (int, int); /* In libiberty */
292 /* Local function prototypes */
294 static void do_clear_solib (PTR);
296 static int match_main (char *);
298 static void special_symbol_handling (void);
300 static void sharedlibrary_command (char *, int);
302 static int enable_break (void);
304 static void info_sharedlibrary_command (char *, int);
306 static int symbol_add_stub (PTR);
308 static CORE_ADDR first_link_map_member (void);
310 static CORE_ADDR locate_base (void);
312 static int solib_map_sections (PTR);
314 #ifdef SVR4_SHARED_LIBS
316 static CORE_ADDR elf_locate_base (void);
320 static struct so_list *current_sos (void);
321 static void free_so (struct so_list *node);
323 static int disable_break (void);
325 static void allocate_rt_common_objfile (void);
328 solib_add_common_symbols (CORE_ADDR);
332 void _initialize_solib (void);
334 /* If non-zero, this is a prefix that will be added to the front of the name
335 shared libraries with an absolute filename for loading. */
336 static char *solib_absolute_prefix = NULL;
338 /* If non-empty, this is a search path for loading non-absolute shared library
339 symbol files. This takes precedence over the environment variables PATH
340 and LD_LIBRARY_PATH. */
341 static char *solib_search_path = NULL;
347 solib_map_sections -- open bfd and build sections for shared lib
351 static int solib_map_sections (struct so_list *so)
355 Given a pointer to one of the shared objects in our list
356 of mapped objects, use the recorded name to open a bfd
357 descriptor for the object, build a section table, and then
358 relocate all the section addresses by the base address at
359 which the shared object was mapped.
363 In most (all?) cases the shared object file name recorded in the
364 dynamic linkage tables will be a fully qualified pathname. For
365 cases where it isn't, do we really mimic the systems search
366 mechanism correctly in the below code (particularly the tilde
371 solib_map_sections (PTR arg)
373 struct so_list *so = (struct so_list *) arg; /* catch_errors bogon */
375 char *scratch_pathname;
377 struct section_table *p;
378 struct cleanup *old_chain;
381 filename = tilde_expand (so->so_name);
383 if (solib_absolute_prefix && ROOTED_P (filename))
384 /* Prefix shared libraries with absolute filenames with
385 SOLIB_ABSOLUTE_PREFIX. */
390 pfx_len = strlen (solib_absolute_prefix);
392 /* Remove trailing slashes. */
393 while (pfx_len > 0 && SLASH_P (solib_absolute_prefix[pfx_len - 1]))
396 pfxed_fn = xmalloc (pfx_len + strlen (filename) + 1);
397 strcpy (pfxed_fn, solib_absolute_prefix);
398 strcat (pfxed_fn, filename);
404 old_chain = make_cleanup (free, filename);
408 if (solib_search_path)
409 scratch_chan = openp (solib_search_path,
410 1, filename, O_RDONLY, 0, &scratch_pathname);
411 if (scratch_chan < 0)
412 scratch_chan = openp (get_in_environ (inferior_environ, "PATH"),
413 1, filename, O_RDONLY, 0, &scratch_pathname);
414 if (scratch_chan < 0)
416 scratch_chan = openp (get_in_environ
417 (inferior_environ, "LD_LIBRARY_PATH"),
418 1, filename, O_RDONLY, 0, &scratch_pathname);
420 if (scratch_chan < 0)
422 perror_with_name (filename);
424 /* Leave scratch_pathname allocated. abfd->name will point to it. */
426 abfd = bfd_fdopenr (scratch_pathname, gnutarget, scratch_chan);
429 close (scratch_chan);
430 error ("Could not open `%s' as an executable file: %s",
431 scratch_pathname, bfd_errmsg (bfd_get_error ()));
433 /* Leave bfd open, core_xfer_memory and "info files" need it. */
435 abfd->cacheable = true;
437 /* copy full path name into so_name, so that later symbol_file_add can find
439 if (strlen (scratch_pathname) >= MAX_PATH_SIZE)
440 error ("Full path name length of shared library exceeds MAX_PATH_SIZE in so_list structure.");
441 strcpy (so->so_name, scratch_pathname);
443 if (!bfd_check_format (abfd, bfd_object))
445 error ("\"%s\": not in executable format: %s.",
446 scratch_pathname, bfd_errmsg (bfd_get_error ()));
448 if (build_section_table (abfd, &so->sections, &so->sections_end))
450 error ("Can't find the file sections in `%s': %s",
451 bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
454 for (p = so->sections; p < so->sections_end; p++)
456 /* Relocate the section binding addresses as recorded in the shared
457 object's file by the base address to which the object was actually
459 p->addr += LM_ADDR (so);
460 p->endaddr += LM_ADDR (so);
461 so->lmend = max (p->endaddr, so->lmend);
462 if (STREQ (p->the_bfd_section->name, ".text"))
468 /* Free the file names, close the file now. */
469 do_cleanups (old_chain);
474 #ifndef SVR4_SHARED_LIBS
476 /* Allocate the runtime common object file. */
479 allocate_rt_common_objfile (void)
481 struct objfile *objfile;
482 struct objfile *last_one;
484 objfile = (struct objfile *) xmalloc (sizeof (struct objfile));
485 memset (objfile, 0, sizeof (struct objfile));
487 obstack_specify_allocation (&objfile->psymbol_cache.cache, 0, 0,
489 obstack_specify_allocation (&objfile->psymbol_obstack, 0, 0, xmalloc,
491 obstack_specify_allocation (&objfile->symbol_obstack, 0, 0, xmalloc,
493 obstack_specify_allocation (&objfile->type_obstack, 0, 0, xmalloc,
495 objfile->name = mstrsave (objfile->md, "rt_common");
497 /* Add this file onto the tail of the linked list of other such files. */
499 objfile->next = NULL;
500 if (object_files == NULL)
501 object_files = objfile;
504 for (last_one = object_files;
506 last_one = last_one->next);
507 last_one->next = objfile;
510 rt_common_objfile = objfile;
513 /* Read all dynamically loaded common symbol definitions from the inferior
514 and put them into the minimal symbol table for the runtime common
518 solib_add_common_symbols (CORE_ADDR rtc_symp)
520 struct rtc_symb inferior_rtc_symb;
521 struct nlist inferior_rtc_nlist;
525 /* Remove any runtime common symbols from previous runs. */
527 if (rt_common_objfile != NULL && rt_common_objfile->minimal_symbol_count)
529 obstack_free (&rt_common_objfile->symbol_obstack, 0);
530 obstack_specify_allocation (&rt_common_objfile->symbol_obstack, 0, 0,
532 rt_common_objfile->minimal_symbol_count = 0;
533 rt_common_objfile->msymbols = NULL;
536 init_minimal_symbol_collection ();
537 make_cleanup_discard_minimal_symbols ();
541 read_memory (rtc_symp,
542 (char *) &inferior_rtc_symb,
543 sizeof (inferior_rtc_symb));
544 read_memory (SOLIB_EXTRACT_ADDRESS (inferior_rtc_symb.rtc_sp),
545 (char *) &inferior_rtc_nlist,
546 sizeof (inferior_rtc_nlist));
547 if (inferior_rtc_nlist.n_type == N_COMM)
549 /* FIXME: The length of the symbol name is not available, but in the
550 current implementation the common symbol is allocated immediately
551 behind the name of the symbol. */
552 len = inferior_rtc_nlist.n_value - inferior_rtc_nlist.n_un.n_strx;
554 name = xmalloc (len);
555 read_memory (SOLIB_EXTRACT_ADDRESS (inferior_rtc_nlist.n_un.n_name),
558 /* Allocate the runtime common objfile if necessary. */
559 if (rt_common_objfile == NULL)
560 allocate_rt_common_objfile ();
562 prim_record_minimal_symbol (name, inferior_rtc_nlist.n_value,
563 mst_bss, rt_common_objfile);
566 rtc_symp = SOLIB_EXTRACT_ADDRESS (inferior_rtc_symb.rtc_next);
569 /* Install any minimal symbols that have been collected as the current
570 minimal symbols for the runtime common objfile. */
572 install_minimal_symbols (rt_common_objfile);
575 #endif /* SVR4_SHARED_LIBS */
578 #ifdef SVR4_SHARED_LIBS
580 static CORE_ADDR bfd_lookup_symbol (bfd *, char *);
586 bfd_lookup_symbol -- lookup the value for a specific symbol
590 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
594 An expensive way to lookup the value of a single symbol for
595 bfd's that are only temporary anyway. This is used by the
596 shared library support to find the address of the debugger
597 interface structures in the shared library.
599 Note that 0 is specifically allowed as an error return (no
604 bfd_lookup_symbol (bfd *abfd, char *symname)
606 unsigned int storage_needed;
608 asymbol **symbol_table;
609 unsigned int number_of_symbols;
611 struct cleanup *back_to;
612 CORE_ADDR symaddr = 0;
614 storage_needed = bfd_get_symtab_upper_bound (abfd);
616 if (storage_needed > 0)
618 symbol_table = (asymbol **) xmalloc (storage_needed);
619 back_to = make_cleanup (free, (PTR) symbol_table);
620 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
622 for (i = 0; i < number_of_symbols; i++)
624 sym = *symbol_table++;
625 if (STREQ (sym->name, symname))
627 /* Bfd symbols are section relative. */
628 symaddr = sym->value + sym->section->vma;
632 do_cleanups (back_to);
638 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
639 have to check the dynamic string table too. */
641 storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
643 if (storage_needed > 0)
645 symbol_table = (asymbol **) xmalloc (storage_needed);
646 back_to = make_cleanup (free, (PTR) symbol_table);
647 number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, symbol_table);
649 for (i = 0; i < number_of_symbols; i++)
651 sym = *symbol_table++;
652 if (STREQ (sym->name, symname))
654 /* Bfd symbols are section relative. */
655 symaddr = sym->value + sym->section->vma;
659 do_cleanups (back_to);
665 #ifdef HANDLE_SVR4_EXEC_EMULATORS
668 Solaris BCP (the part of Solaris which allows it to run SunOS4
669 a.out files) throws in another wrinkle. Solaris does not fill
670 in the usual a.out link map structures when running BCP programs,
671 the only way to get at them is via groping around in the dynamic
673 The dynamic linker and it's structures are located in the shared
674 C library, which gets run as the executable's "interpreter" by
677 Note that we can assume nothing about the process state at the time
678 we need to find these structures. We may be stopped on the first
679 instruction of the interpreter (C shared library), the first
680 instruction of the executable itself, or somewhere else entirely
681 (if we attached to the process for example).
684 static char *debug_base_symbols[] =
686 "r_debug", /* Solaris 2.3 */
687 "_r_debug", /* Solaris 2.1, 2.2 */
691 static int look_for_base (int, CORE_ADDR);
697 look_for_base -- examine file for each mapped address segment
701 static int look_for_base (int fd, CORE_ADDR baseaddr)
705 This function is passed to proc_iterate_over_mappings, which
706 causes it to get called once for each mapped address space, with
707 an open file descriptor for the file mapped to that space, and the
708 base address of that mapped space.
710 Our job is to find the debug base symbol in the file that this
711 fd is open on, if it exists, and if so, initialize the dynamic
712 linker structure base address debug_base.
714 Note that this is a computationally expensive proposition, since
715 we basically have to open a bfd on every call, so we specifically
716 avoid opening the exec file.
720 look_for_base (int fd, CORE_ADDR baseaddr)
723 CORE_ADDR address = 0;
726 /* If the fd is -1, then there is no file that corresponds to this
727 mapped memory segment, so skip it. Also, if the fd corresponds
728 to the exec file, skip it as well. */
732 && fdmatch (fileno ((FILE *) (exec_bfd->iostream)), fd)))
737 /* Try to open whatever random file this fd corresponds to. Note that
738 we have no way currently to find the filename. Don't gripe about
739 any problems we might have, just fail. */
741 if ((interp_bfd = bfd_fdopenr ("unnamed", gnutarget, fd)) == NULL)
745 if (!bfd_check_format (interp_bfd, bfd_object))
747 /* FIXME-leak: on failure, might not free all memory associated with
749 bfd_close (interp_bfd);
753 /* Now try to find our debug base symbol in this file, which we at
754 least know to be a valid ELF executable or shared library. */
756 for (symbolp = debug_base_symbols; *symbolp != NULL; symbolp++)
758 address = bfd_lookup_symbol (interp_bfd, *symbolp);
766 /* FIXME-leak: on failure, might not free all memory associated with
768 bfd_close (interp_bfd);
772 /* Eureka! We found the symbol. But now we may need to relocate it
773 by the base address. If the symbol's value is less than the base
774 address of the shared library, then it hasn't yet been relocated
775 by the dynamic linker, and we have to do it ourself. FIXME: Note
776 that we make the assumption that the first segment that corresponds
777 to the shared library has the base address to which the library
780 if (address < baseaddr)
784 debug_base = address;
785 /* FIXME-leak: on failure, might not free all memory associated with
787 bfd_close (interp_bfd);
790 #endif /* HANDLE_SVR4_EXEC_EMULATORS */
796 elf_locate_base -- locate the base address of dynamic linker structs
797 for SVR4 elf targets.
801 CORE_ADDR elf_locate_base (void)
805 For SVR4 elf targets the address of the dynamic linker's runtime
806 structure is contained within the dynamic info section in the
807 executable file. The dynamic section is also mapped into the
808 inferior address space. Because the runtime loader fills in the
809 real address before starting the inferior, we have to read in the
810 dynamic info section from the inferior address space.
811 If there are any errors while trying to find the address, we
812 silently return 0, otherwise the found address is returned.
817 elf_locate_base (void)
819 sec_ptr dyninfo_sect;
820 int dyninfo_sect_size;
821 CORE_ADDR dyninfo_addr;
826 /* Find the start address of the .dynamic section. */
827 dyninfo_sect = bfd_get_section_by_name (exec_bfd, ".dynamic");
828 if (dyninfo_sect == NULL)
830 dyninfo_addr = bfd_section_vma (exec_bfd, dyninfo_sect);
832 /* Read in .dynamic section, silently ignore errors. */
833 dyninfo_sect_size = bfd_section_size (exec_bfd, dyninfo_sect);
834 buf = alloca (dyninfo_sect_size);
835 if (target_read_memory (dyninfo_addr, buf, dyninfo_sect_size))
838 /* Find the DT_DEBUG entry in the the .dynamic section.
839 For mips elf we look for DT_MIPS_RLD_MAP, mips elf apparently has
840 no DT_DEBUG entries. */
842 arch_size = bfd_get_arch_size (exec_bfd);
843 if (arch_size == -1) /* failure */
848 for (bufend = buf + dyninfo_sect_size;
850 buf += sizeof (Elf32_External_Dyn))
852 Elf32_External_Dyn *x_dynp = (Elf32_External_Dyn *) buf;
856 dyn_tag = bfd_h_get_32 (exec_bfd, (bfd_byte *) x_dynp->d_tag);
857 if (dyn_tag == DT_NULL)
859 else if (dyn_tag == DT_DEBUG)
861 dyn_ptr = bfd_h_get_32 (exec_bfd,
862 (bfd_byte *) x_dynp->d_un.d_ptr);
865 #ifdef DT_MIPS_RLD_MAP
866 else if (dyn_tag == DT_MIPS_RLD_MAP)
870 pbuf = alloca (TARGET_PTR_BIT / HOST_CHAR_BIT);
871 /* DT_MIPS_RLD_MAP contains a pointer to the address
872 of the dynamic link structure. */
873 dyn_ptr = bfd_h_get_32 (exec_bfd,
874 (bfd_byte *) x_dynp->d_un.d_ptr);
875 if (target_read_memory (dyn_ptr, pbuf, sizeof (pbuf)))
877 return extract_unsigned_integer (pbuf, sizeof (pbuf));
882 else /* 64-bit elf */
884 for (bufend = buf + dyninfo_sect_size;
886 buf += sizeof (Elf64_External_Dyn))
888 Elf64_External_Dyn *x_dynp = (Elf64_External_Dyn *) buf;
892 dyn_tag = bfd_h_get_64 (exec_bfd, (bfd_byte *) x_dynp->d_tag);
893 if (dyn_tag == DT_NULL)
895 else if (dyn_tag == DT_DEBUG)
897 dyn_ptr = bfd_h_get_64 (exec_bfd,
898 (bfd_byte *) x_dynp->d_un.d_ptr);
904 /* DT_DEBUG entry not found. */
908 #endif /* SVR4_SHARED_LIBS */
914 locate_base -- locate the base address of dynamic linker structs
918 CORE_ADDR locate_base (void)
922 For both the SunOS and SVR4 shared library implementations, if the
923 inferior executable has been linked dynamically, there is a single
924 address somewhere in the inferior's data space which is the key to
925 locating all of the dynamic linker's runtime structures. This
926 address is the value of the debug base symbol. The job of this
927 function is to find and return that address, or to return 0 if there
928 is no such address (the executable is statically linked for example).
930 For SunOS, the job is almost trivial, since the dynamic linker and
931 all of it's structures are statically linked to the executable at
932 link time. Thus the symbol for the address we are looking for has
933 already been added to the minimal symbol table for the executable's
934 objfile at the time the symbol file's symbols were read, and all we
935 have to do is look it up there. Note that we explicitly do NOT want
936 to find the copies in the shared library.
938 The SVR4 version is a bit more complicated because the address
939 is contained somewhere in the dynamic info section. We have to go
940 to a lot more work to discover the address of the debug base symbol.
941 Because of this complexity, we cache the value we find and return that
942 value on subsequent invocations. Note there is no copy in the
943 executable symbol tables.
951 #ifndef SVR4_SHARED_LIBS
953 struct minimal_symbol *msymbol;
954 CORE_ADDR address = 0;
957 /* For SunOS, we want to limit the search for the debug base symbol to the
958 executable being debugged, since there is a duplicate named symbol in the
959 shared library. We don't want the shared library versions. */
961 for (symbolp = debug_base_symbols; *symbolp != NULL; symbolp++)
963 msymbol = lookup_minimal_symbol (*symbolp, NULL, symfile_objfile);
964 if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
966 address = SYMBOL_VALUE_ADDRESS (msymbol);
972 #else /* SVR4_SHARED_LIBS */
974 /* Check to see if we have a currently valid address, and if so, avoid
975 doing all this work again and just return the cached address. If
976 we have no cached address, try to locate it in the dynamic info
977 section for ELF executables. */
982 && bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
983 debug_base = elf_locate_base ();
984 #ifdef HANDLE_SVR4_EXEC_EMULATORS
985 /* Try it the hard way for emulated executables. */
986 else if (inferior_pid != 0 && target_has_execution)
987 proc_iterate_over_mappings (look_for_base);
992 #endif /* !SVR4_SHARED_LIBS */
1000 first_link_map_member -- locate first member in dynamic linker's map
1004 static CORE_ADDR first_link_map_member (void)
1008 Find the first element in the inferior's dynamic link map, and
1009 return its address in the inferior. This function doesn't copy the
1010 link map entry itself into our address space; current_sos actually
1011 does the reading. */
1014 first_link_map_member (void)
1018 #ifndef SVR4_SHARED_LIBS
1020 read_memory (debug_base, (char *) &dynamic_copy, sizeof (dynamic_copy));
1021 if (dynamic_copy.ld_version >= 2)
1023 /* It is a version that we can deal with, so read in the secondary
1024 structure and find the address of the link map list from it. */
1025 read_memory (SOLIB_EXTRACT_ADDRESS (dynamic_copy.ld_un.ld_2),
1026 (char *) &ld_2_copy, sizeof (struct link_dynamic_2));
1027 lm = SOLIB_EXTRACT_ADDRESS (ld_2_copy.ld_loaded);
1030 #else /* SVR4_SHARED_LIBS */
1031 #if defined (HAVE_STRUCT_LINK_MAP32)
1032 if (bfd_get_arch_size (exec_bfd) == 32)
1034 read_memory (debug_base, (char *) &debug32_copy,
1035 sizeof (struct r_debug32));
1036 lm = SOLIB_EXTRACT_ADDRESS (debug32_copy.r_map);
1041 read_memory (debug_base, (char *) &debug_copy,
1042 sizeof (struct r_debug));
1043 lm = SOLIB_EXTRACT_ADDRESS (debug_copy.r_map);
1045 /* FIXME: Perhaps we should validate the info somehow, perhaps by
1046 checking r_version for a known version number, or r_state for
1049 #endif /* !SVR4_SHARED_LIBS */
1054 #ifdef SVR4_SHARED_LIBS
1059 open_symbol_file_object
1063 int open_symbol_file_object (void *from_ttyp)
1067 If no open symbol file, attempt to locate and open the main symbol
1068 file. On SVR4 systems, this is the first link map entry. If its
1069 name is here, we can open it. Useful when attaching to a process
1070 without first loading its symbol file.
1072 If FROM_TTYP dereferences to a non-zero integer, allow messages to
1073 be printed. This parameter is a pointer rather than an int because
1074 open_symbol_file_object() is called via catch_errors() and
1075 catch_errors() requires a pointer argument. */
1078 open_symbol_file_object (void *from_ttyp)
1083 int from_tty = *(int *)from_ttyp;
1085 if (symfile_objfile)
1086 if (!query ("Attempt to reload symbols from process? "))
1089 if ((debug_base = locate_base ()) == 0)
1090 return 0; /* failed somehow... */
1092 /* First link map member should be the executable. */
1093 if ((lm = first_link_map_member ()) == 0)
1094 return 0; /* failed somehow... */
1096 #if defined (HAVE_STRUCT_LINK_MAP32)
1097 if (bfd_get_arch_size (exec_bfd) == 32)
1099 struct link_map32 lmcopy;
1100 /* Read from target memory to GDB. */
1101 read_memory (lm, (void *) &lmcopy, sizeof (lmcopy));
1103 if (lmcopy.l_name == 0)
1104 return 0; /* no filename. */
1106 /* Now fetch the filename from target memory. */
1107 target_read_string (SOLIB_EXTRACT_ADDRESS (lmcopy.l_name),
1108 &filename, MAX_PATH_SIZE - 1, &errcode);
1111 #endif /* HAVE_STRUCT_LINK_MAP32 */
1113 struct link_map lmcopy;
1114 /* Read from target memory to GDB. */
1115 read_memory (lm, (void *) &lmcopy, sizeof (lmcopy));
1117 if (lmcopy.l_name == 0)
1118 return 0; /* no filename. */
1120 /* Now fetch the filename from target memory. */
1121 target_read_string (SOLIB_EXTRACT_ADDRESS (lmcopy.l_name), &filename,
1122 MAX_PATH_SIZE - 1, &errcode);
1127 warning ("failed to read exec filename from attached file: %s",
1128 safe_strerror (errcode));
1132 make_cleanup (free, filename);
1133 /* Have a pathname: read the symbol file. */
1134 symbol_file_command (filename, from_tty);
1138 #endif /* SVR4_SHARED_LIBS */
1143 free_so --- free a `struct so_list' object
1147 void free_so (struct so_list *so)
1151 Free the storage associated with the `struct so_list' object SO.
1152 If we have opened a BFD for SO, close it.
1154 The caller is responsible for removing SO from whatever list it is
1155 a member of. If we have placed SO's sections in some target's
1156 section table, the caller is responsible for removing them.
1158 This function doesn't mess with objfiles at all. If there is an
1159 objfile associated with SO that needs to be removed, the caller is
1160 responsible for taking care of that. */
1163 free_so (struct so_list *so)
1165 char *bfd_filename = 0;
1168 free (so->sections);
1172 bfd_filename = bfd_get_filename (so->abfd);
1173 if (! bfd_close (so->abfd))
1174 warning ("cannot close \"%s\": %s",
1175 bfd_filename, bfd_errmsg (bfd_get_error ()));
1179 free (bfd_filename);
1185 /* On some systems, the only way to recognize the link map entry for
1186 the main executable file is by looking at its name. Return
1187 non-zero iff SONAME matches one of the known main executable names. */
1190 match_main (char *soname)
1194 for (mainp = main_name_list; *mainp != NULL; mainp++)
1196 if (strcmp (soname, *mainp) == 0)
1206 current_sos -- build a list of currently loaded shared objects
1210 struct so_list *current_sos ()
1214 Build a list of `struct so_list' objects describing the shared
1215 objects currently loaded in the inferior. This list does not
1216 include an entry for the main executable file.
1218 Note that we only gather information directly available from the
1219 inferior --- we don't examine any of the shared library files
1220 themselves. The declaration of `struct so_list' says which fields
1221 we provide values for. */
1223 static struct so_list *
1227 struct so_list *head = 0;
1228 struct so_list **link_ptr = &head;
1230 /* Make sure we've looked up the inferior's dynamic linker's base
1234 debug_base = locate_base ();
1236 /* If we can't find the dynamic linker's base structure, this
1237 must not be a dynamically linked executable. Hmm. */
1242 /* Walk the inferior's link map list, and build our list of
1243 `struct so_list' nodes. */
1244 lm = first_link_map_member ();
1248 = (struct so_list *) xmalloc (sizeof (struct so_list));
1249 struct cleanup *old_chain = make_cleanup (free, new);
1250 memset (new, 0, sizeof (*new));
1254 #if defined (HAVE_STRUCT_LINK_MAP32)
1255 if (bfd_get_arch_size (exec_bfd) == 32)
1256 read_memory (lm, (char *) &(new->lm32), sizeof (struct link_map32));
1259 read_memory (lm, (char *) &(new->lm), sizeof (struct link_map));
1263 /* For SVR4 versions, the first entry in the link map is for the
1264 inferior executable, so we must ignore it. For some versions of
1265 SVR4, it has no name. For others (Solaris 2.3 for example), it
1266 does have a name, so we can no longer use a missing name to
1267 decide when to ignore it. */
1268 if (IGNORE_FIRST_LINK_MAP_ENTRY (new))
1275 /* Extract this shared object's name. */
1276 target_read_string (LM_NAME (new), &buffer,
1277 MAX_PATH_SIZE - 1, &errcode);
1280 warning ("current_sos: Can't read pathname for load map: %s\n",
1281 safe_strerror (errcode));
1285 strncpy (new->so_name, buffer, MAX_PATH_SIZE - 1);
1286 new->so_name[MAX_PATH_SIZE - 1] = '\0';
1288 strcpy (new->so_original_name, new->so_name);
1291 /* If this entry has no name, or its name matches the name
1292 for the main executable, don't include it in the list. */
1293 if (! new->so_name[0]
1294 || match_main (new->so_name))
1300 link_ptr = &new->next;
1304 discard_cleanups (old_chain);
1311 /* A small stub to get us past the arg-passing pinhole of catch_errors. */
1314 symbol_add_stub (PTR arg)
1316 register struct so_list *so = (struct so_list *) arg; /* catch_errs bogon */
1317 struct section_addr_info *sap;
1318 CORE_ADDR lowest_addr = 0;
1320 asection *lowest_sect = NULL;
1322 /* Have we already loaded this shared object? */
1323 ALL_OBJFILES (so->objfile)
1325 if (strcmp (so->objfile->name, so->so_name) == 0)
1329 /* Find the shared object's text segment. */
1330 if (so->textsection)
1332 lowest_addr = so->textsection->addr;
1333 lowest_sect = bfd_get_section_by_name (so->abfd, ".text");
1334 lowest_index = lowest_sect->index;
1336 else if (so->abfd != NULL)
1338 /* If we didn't find a mapped non zero sized .text section, set
1339 up lowest_addr so that the relocation in symbol_file_add does
1341 lowest_sect = bfd_get_section_by_name (so->abfd, ".text");
1342 if (lowest_sect == NULL)
1343 bfd_map_over_sections (so->abfd, find_lowest_section,
1344 (PTR) &lowest_sect);
1347 lowest_addr = bfd_section_vma (so->abfd, lowest_sect)
1349 lowest_index = lowest_sect->index;
1353 sap = build_section_addr_info_from_section_table (so->sections,
1356 sap->other[lowest_index].addr = lowest_addr;
1358 so->objfile = symbol_file_add (so->so_name, so->from_tty,
1359 sap, 0, OBJF_SHARED);
1360 free_section_addr_info (sap);
1368 update_solib_list --- synchronize GDB's shared object list with inferior's
1372 void update_solib_list (int from_tty, struct target_ops *TARGET)
1374 Extract the list of currently loaded shared objects from the
1375 inferior, and compare it with the list of shared objects currently
1376 in GDB's so_list_head list. Edit so_list_head to bring it in sync
1377 with the inferior's new list.
1379 If we notice that the inferior has unloaded some shared objects,
1380 free any symbolic info GDB had read about those shared objects.
1382 Don't load symbolic info for any new shared objects; just add them
1383 to the list, and leave their symbols_loaded flag clear.
1385 If FROM_TTY is non-null, feel free to print messages about what
1388 If TARGET is non-null, add the sections of all new shared objects
1389 to TARGET's section table. Note that this doesn't remove any
1390 sections for shared objects that have been unloaded, and it
1391 doesn't check to see if the new shared objects are already present in
1392 the section table. But we only use this for core files and
1393 processes we've just attached to, so that's okay. */
1396 update_solib_list (int from_tty, struct target_ops *target)
1398 struct so_list *inferior = current_sos ();
1399 struct so_list *gdb, **gdb_link;
1401 #ifdef SVR4_SHARED_LIBS
1402 /* If we are attaching to a running process for which we
1403 have not opened a symbol file, we may be able to get its
1406 symfile_objfile == NULL)
1407 catch_errors (open_symbol_file_object, (PTR) &from_tty,
1408 "Error reading attached process's symbol file.\n",
1411 #endif SVR4_SHARED_LIBS
1413 /* Since this function might actually add some elements to the
1414 so_list_head list, arrange for it to be cleaned up when
1416 if (!solib_cleanup_queued)
1418 make_run_cleanup (do_clear_solib, NULL);
1419 solib_cleanup_queued = 1;
1422 /* GDB and the inferior's dynamic linker each maintain their own
1423 list of currently loaded shared objects; we want to bring the
1424 former in sync with the latter. Scan both lists, seeing which
1425 shared objects appear where. There are three cases:
1427 - A shared object appears on both lists. This means that GDB
1428 knows about it already, and it's still loaded in the inferior.
1429 Nothing needs to happen.
1431 - A shared object appears only on GDB's list. This means that
1432 the inferior has unloaded it. We should remove the shared
1433 object from GDB's tables.
1435 - A shared object appears only on the inferior's list. This
1436 means that it's just been loaded. We should add it to GDB's
1439 So we walk GDB's list, checking each entry to see if it appears
1440 in the inferior's list too. If it does, no action is needed, and
1441 we remove it from the inferior's list. If it doesn't, the
1442 inferior has unloaded it, and we remove it from GDB's list. By
1443 the time we're done walking GDB's list, the inferior's list
1444 contains only the new shared objects, which we then add. */
1447 gdb_link = &so_list_head;
1450 struct so_list *i = inferior;
1451 struct so_list **i_link = &inferior;
1453 /* Check to see whether the shared object *gdb also appears in
1454 the inferior's current list. */
1457 if (! strcmp (gdb->so_original_name, i->so_original_name))
1464 /* If the shared object appears on the inferior's list too, then
1465 it's still loaded, so we don't need to do anything. Delete
1466 it from the inferior's list, and leave it on GDB's list. */
1471 gdb_link = &gdb->next;
1475 /* If it's not on the inferior's list, remove it from GDB's tables. */
1478 *gdb_link = gdb->next;
1480 /* Unless the user loaded it explicitly, free SO's objfile. */
1481 if (gdb->objfile && ! (gdb->objfile->flags & OBJF_USERLOADED))
1482 free_objfile (gdb->objfile);
1484 /* Some targets' section tables might be referring to
1485 sections from so->abfd; remove them. */
1486 remove_target_sections (gdb->abfd);
1493 /* Now the inferior's list contains only shared objects that don't
1494 appear in GDB's list --- those that are newly loaded. Add them
1495 to GDB's shared object list. */
1500 /* Add the new shared objects to GDB's list. */
1501 *gdb_link = inferior;
1503 /* Fill in the rest of each of the `struct so_list' nodes. */
1504 for (i = inferior; i; i = i->next)
1506 i->from_tty = from_tty;
1508 /* Fill in the rest of the `struct so_list' node. */
1509 catch_errors (solib_map_sections, i,
1510 "Error while mapping shared library sections:\n",
1514 /* If requested, add the shared objects' sections to the the
1515 TARGET's section table. */
1520 /* Figure out how many sections we'll need to add in total. */
1522 for (i = inferior; i; i = i->next)
1523 new_sections += (i->sections_end - i->sections);
1525 if (new_sections > 0)
1527 int space = target_resize_to_sections (target, new_sections);
1529 for (i = inferior; i; i = i->next)
1531 int count = (i->sections_end - i->sections);
1532 memcpy (target->to_sections + space,
1534 count * sizeof (i->sections[0]));
1545 solib_add -- read in symbol info for newly added shared libraries
1549 void solib_add (char *pattern, int from_tty, struct target_ops *TARGET)
1553 Read in symbolic information for any shared objects whose names
1554 match PATTERN. (If we've already read a shared object's symbol
1555 info, leave it alone.) If PATTERN is zero, read them all.
1557 FROM_TTY and TARGET are as described for update_solib_list, above. */
1560 solib_add (char *pattern, int from_tty, struct target_ops *target)
1562 struct so_list *gdb;
1566 char *re_err = re_comp (pattern);
1569 error ("Invalid regexp: %s", re_err);
1572 update_solib_list (from_tty, target);
1574 /* Walk the list of currently loaded shared libraries, and read
1575 symbols for any that match the pattern --- or any whose symbols
1576 aren't already loaded, if no pattern was given. */
1578 int any_matches = 0;
1579 int loaded_any_symbols = 0;
1581 for (gdb = so_list_head; gdb; gdb = gdb->next)
1582 if (! pattern || re_exec (gdb->so_name))
1586 if (gdb->symbols_loaded)
1589 printf_unfiltered ("Symbols already loaded for %s\n",
1595 (symbol_add_stub, gdb,
1596 "Error while reading shared library symbols:\n",
1600 printf_unfiltered ("Loaded symbols for %s\n",
1602 gdb->symbols_loaded = 1;
1603 loaded_any_symbols = 1;
1608 if (from_tty && pattern && ! any_matches)
1610 ("No loaded shared libraries match the pattern `%s'.\n", pattern);
1612 if (loaded_any_symbols)
1614 /* Getting new symbols may change our opinion about what is
1616 reinit_frame_cache ();
1618 special_symbol_handling ();
1628 info_sharedlibrary_command -- code for "info sharedlibrary"
1632 static void info_sharedlibrary_command ()
1636 Walk through the shared library list and print information
1637 about each attached library.
1641 info_sharedlibrary_command (char *ignore, int from_tty)
1643 register struct so_list *so = NULL; /* link map state variable */
1644 int header_done = 0;
1649 if (exec_bfd == NULL)
1651 printf_unfiltered ("No executable file.\n");
1655 arch_size = bfd_get_arch_size (exec_bfd);
1656 /* Default to 32-bit in case of failure (non-elf). */
1657 if (arch_size == 32 || arch_size == -1)
1662 else if (arch_size == 64)
1664 addr_width = 16 + 4;
1668 update_solib_list (from_tty, 0);
1670 for (so = so_list_head; so; so = so->next)
1676 printf_unfiltered ("%-*s%-*s%-12s%s\n", addr_width, "From",
1677 addr_width, "To", "Syms Read",
1678 "Shared Object Library");
1682 printf_unfiltered ("%-*s", addr_width,
1683 local_hex_string_custom ((unsigned long) LM_ADDR (so),
1685 printf_unfiltered ("%-*s", addr_width,
1686 local_hex_string_custom ((unsigned long) so->lmend,
1688 printf_unfiltered ("%-12s", so->symbols_loaded ? "Yes" : "No");
1689 printf_unfiltered ("%s\n", so->so_name);
1692 if (so_list_head == NULL)
1694 printf_unfiltered ("No shared libraries loaded at this time.\n");
1702 solib_address -- check to see if an address is in a shared lib
1706 char * solib_address (CORE_ADDR address)
1710 Provides a hook for other gdb routines to discover whether or
1711 not a particular address is within the mapped address space of
1712 a shared library. Any address between the base mapping address
1713 and the first address beyond the end of the last mapping, is
1714 considered to be within the shared library address space, for
1717 For example, this routine is called at one point to disable
1718 breakpoints which are in shared libraries that are not currently
1723 solib_address (CORE_ADDR address)
1725 register struct so_list *so = 0; /* link map state variable */
1727 for (so = so_list_head; so; so = so->next)
1729 if (LM_ADDR (so) <= address && address < so->lmend)
1730 return (so->so_name);
1736 /* Called by free_all_symtabs */
1741 /* This function is expected to handle ELF shared libraries. It is
1742 also used on Solaris, which can run either ELF or a.out binaries
1743 (for compatibility with SunOS 4), both of which can use shared
1744 libraries. So we don't know whether we have an ELF executable or
1745 an a.out executable until the user chooses an executable file.
1747 ELF shared libraries don't get mapped into the address space
1748 until after the program starts, so we'd better not try to insert
1749 breakpoints in them immediately. We have to wait until the
1750 dynamic linker has loaded them; we'll hit a bp_shlib_event
1751 breakpoint (look for calls to create_solib_event_breakpoint) when
1754 SunOS shared libraries seem to be different --- they're present
1755 as soon as the process begins execution, so there's no need to
1756 put off inserting breakpoints. There's also nowhere to put a
1757 bp_shlib_event breakpoint, so if we put it off, we'll never get
1760 So: disable breakpoints only if we're using ELF shared libs. */
1761 if (exec_bfd != NULL
1762 && bfd_get_flavour (exec_bfd) != bfd_target_aout_flavour)
1763 disable_breakpoints_in_shlibs (1);
1765 while (so_list_head)
1767 struct so_list *so = so_list_head;
1768 so_list_head = so->next;
1776 do_clear_solib (PTR dummy)
1778 solib_cleanup_queued = 0;
1782 #ifdef SVR4_SHARED_LIBS
1784 /* Return 1 if PC lies in the dynamic symbol resolution code of the
1785 SVR4 run time loader. */
1787 static CORE_ADDR interp_text_sect_low;
1788 static CORE_ADDR interp_text_sect_high;
1789 static CORE_ADDR interp_plt_sect_low;
1790 static CORE_ADDR interp_plt_sect_high;
1793 in_svr4_dynsym_resolve_code (CORE_ADDR pc)
1795 return ((pc >= interp_text_sect_low && pc < interp_text_sect_high)
1796 || (pc >= interp_plt_sect_low && pc < interp_plt_sect_high)
1797 || in_plt_section (pc, NULL));
1805 disable_break -- remove the "mapping changed" breakpoint
1809 static int disable_break ()
1813 Removes the breakpoint that gets hit when the dynamic linker
1814 completes a mapping change.
1818 #ifndef SVR4_SHARED_LIBS
1821 disable_break (void)
1825 #ifndef SVR4_SHARED_LIBS
1827 int in_debugger = 0;
1829 /* Read the debugger structure from the inferior to retrieve the
1830 address of the breakpoint and the original contents of the
1831 breakpoint address. Remove the breakpoint by writing the original
1834 read_memory (debug_addr, (char *) &debug_copy, sizeof (debug_copy));
1836 /* Set `in_debugger' to zero now. */
1838 write_memory (flag_addr, (char *) &in_debugger, sizeof (in_debugger));
1840 breakpoint_addr = SOLIB_EXTRACT_ADDRESS (debug_copy.ldd_bp_addr);
1841 write_memory (breakpoint_addr, (char *) &debug_copy.ldd_bp_inst,
1842 sizeof (debug_copy.ldd_bp_inst));
1844 #else /* SVR4_SHARED_LIBS */
1846 /* Note that breakpoint address and original contents are in our address
1847 space, so we just need to write the original contents back. */
1849 if (memory_remove_breakpoint (breakpoint_addr, shadow_contents) != 0)
1854 #endif /* !SVR4_SHARED_LIBS */
1856 /* For the SVR4 version, we always know the breakpoint address. For the
1857 SunOS version we don't know it until the above code is executed.
1858 Grumble if we are stopped anywhere besides the breakpoint address. */
1860 if (stop_pc != breakpoint_addr)
1862 warning ("stopped at unknown breakpoint while handling shared libraries");
1868 #endif /* #ifdef SVR4_SHARED_LIBS */
1874 enable_break -- arrange for dynamic linker to hit breakpoint
1878 int enable_break (void)
1882 Both the SunOS and the SVR4 dynamic linkers have, as part of their
1883 debugger interface, support for arranging for the inferior to hit
1884 a breakpoint after mapping in the shared libraries. This function
1885 enables that breakpoint.
1887 For SunOS, there is a special flag location (in_debugger) which we
1888 set to 1. When the dynamic linker sees this flag set, it will set
1889 a breakpoint at a location known only to itself, after saving the
1890 original contents of that place and the breakpoint address itself,
1891 in it's own internal structures. When we resume the inferior, it
1892 will eventually take a SIGTRAP when it runs into the breakpoint.
1893 We handle this (in a different place) by restoring the contents of
1894 the breakpointed location (which is only known after it stops),
1895 chasing around to locate the shared libraries that have been
1896 loaded, then resuming.
1898 For SVR4, the debugger interface structure contains a member (r_brk)
1899 which is statically initialized at the time the shared library is
1900 built, to the offset of a function (_r_debug_state) which is guaran-
1901 teed to be called once before mapping in a library, and again when
1902 the mapping is complete. At the time we are examining this member,
1903 it contains only the unrelocated offset of the function, so we have
1904 to do our own relocation. Later, when the dynamic linker actually
1905 runs, it relocates r_brk to be the actual address of _r_debug_state().
1907 The debugger interface structure also contains an enumeration which
1908 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
1909 depending upon whether or not the library is being mapped or unmapped,
1910 and then set to RT_CONSISTENT after the library is mapped/unmapped.
1918 #ifndef SVR4_SHARED_LIBS
1923 /* Get link_dynamic structure */
1925 j = target_read_memory (debug_base, (char *) &dynamic_copy,
1926 sizeof (dynamic_copy));
1933 /* Calc address of debugger interface structure */
1935 debug_addr = SOLIB_EXTRACT_ADDRESS (dynamic_copy.ldd);
1937 /* Calc address of `in_debugger' member of debugger interface structure */
1939 flag_addr = debug_addr + (CORE_ADDR) ((char *) &debug_copy.ldd_in_debugger -
1940 (char *) &debug_copy);
1942 /* Write a value of 1 to this member. */
1945 write_memory (flag_addr, (char *) &in_debugger, sizeof (in_debugger));
1948 #else /* SVR4_SHARED_LIBS */
1950 #ifdef BKPT_AT_SYMBOL
1952 struct minimal_symbol *msymbol;
1954 asection *interp_sect;
1956 /* First, remove all the solib event breakpoints. Their addresses
1957 may have changed since the last time we ran the program. */
1958 remove_solib_event_breakpoints ();
1960 #ifdef SVR4_SHARED_LIBS
1961 interp_text_sect_low = interp_text_sect_high = 0;
1962 interp_plt_sect_low = interp_plt_sect_high = 0;
1964 /* Find the .interp section; if not found, warn the user and drop
1965 into the old breakpoint at symbol code. */
1966 interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
1969 unsigned int interp_sect_size;
1971 CORE_ADDR load_addr;
1973 CORE_ADDR sym_addr = 0;
1975 /* Read the contents of the .interp section into a local buffer;
1976 the contents specify the dynamic linker this program uses. */
1977 interp_sect_size = bfd_section_size (exec_bfd, interp_sect);
1978 buf = alloca (interp_sect_size);
1979 bfd_get_section_contents (exec_bfd, interp_sect,
1980 buf, 0, interp_sect_size);
1982 /* Now we need to figure out where the dynamic linker was
1983 loaded so that we can load its symbols and place a breakpoint
1984 in the dynamic linker itself.
1986 This address is stored on the stack. However, I've been unable
1987 to find any magic formula to find it for Solaris (appears to
1988 be trivial on GNU/Linux). Therefore, we have to try an alternate
1989 mechanism to find the dynamic linker's base address. */
1990 tmp_bfd = bfd_openr (buf, gnutarget);
1991 if (tmp_bfd == NULL)
1992 goto bkpt_at_symbol;
1994 /* Make sure the dynamic linker's really a useful object. */
1995 if (!bfd_check_format (tmp_bfd, bfd_object))
1997 warning ("Unable to grok dynamic linker %s as an object file", buf);
1998 bfd_close (tmp_bfd);
1999 goto bkpt_at_symbol;
2002 /* We find the dynamic linker's base address by examining the
2003 current pc (which point at the entry point for the dynamic
2004 linker) and subtracting the offset of the entry point. */
2005 load_addr = read_pc () - tmp_bfd->start_address;
2007 /* Record the relocated start and end address of the dynamic linker
2008 text and plt section for in_svr4_dynsym_resolve_code. */
2009 interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
2012 interp_text_sect_low =
2013 bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
2014 interp_text_sect_high =
2015 interp_text_sect_low + bfd_section_size (tmp_bfd, interp_sect);
2017 interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
2020 interp_plt_sect_low =
2021 bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
2022 interp_plt_sect_high =
2023 interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
2026 /* Now try to set a breakpoint in the dynamic linker. */
2027 for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
2029 sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep);
2034 /* We're done with the temporary bfd. */
2035 bfd_close (tmp_bfd);
2039 create_solib_event_breakpoint (load_addr + sym_addr);
2043 /* For whatever reason we couldn't set a breakpoint in the dynamic
2044 linker. Warn and drop into the old code. */
2046 warning ("Unable to find dynamic linker breakpoint function.\nGDB will be unable to debug shared library initializers\nand track explicitly loaded dynamic code.");
2050 /* Scan through the list of symbols, trying to look up the symbol and
2051 set a breakpoint there. Terminate loop when we/if we succeed. */
2053 breakpoint_addr = 0;
2054 for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
2056 msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
2057 if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
2059 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol));
2064 /* Nothing good happened. */
2067 #endif /* BKPT_AT_SYMBOL */
2069 #endif /* !SVR4_SHARED_LIBS */
2078 solib_create_inferior_hook -- shared library startup support
2082 void solib_create_inferior_hook()
2086 When gdb starts up the inferior, it nurses it along (through the
2087 shell) until it is ready to execute it's first instruction. At this
2088 point, this function gets called via expansion of the macro
2089 SOLIB_CREATE_INFERIOR_HOOK.
2091 For SunOS executables, this first instruction is typically the
2092 one at "_start", or a similar text label, regardless of whether
2093 the executable is statically or dynamically linked. The runtime
2094 startup code takes care of dynamically linking in any shared
2095 libraries, once gdb allows the inferior to continue.
2097 For SVR4 executables, this first instruction is either the first
2098 instruction in the dynamic linker (for dynamically linked
2099 executables) or the instruction at "start" for statically linked
2100 executables. For dynamically linked executables, the system
2101 first exec's /lib/libc.so.N, which contains the dynamic linker,
2102 and starts it running. The dynamic linker maps in any needed
2103 shared libraries, maps in the actual user executable, and then
2104 jumps to "start" in the user executable.
2106 For both SunOS shared libraries, and SVR4 shared libraries, we
2107 can arrange to cooperate with the dynamic linker to discover the
2108 names of shared libraries that are dynamically linked, and the
2109 base addresses to which they are linked.
2111 This function is responsible for discovering those names and
2112 addresses, and saving sufficient information about them to allow
2113 their symbols to be read at a later time.
2117 Between enable_break() and disable_break(), this code does not
2118 properly handle hitting breakpoints which the user might have
2119 set in the startup code or in the dynamic linker itself. Proper
2120 handling will probably have to wait until the implementation is
2121 changed to use the "breakpoint handler function" method.
2123 Also, what if child has exit()ed? Must exit loop somehow.
2127 solib_create_inferior_hook (void)
2129 /* If we are using the BKPT_AT_SYMBOL code, then we don't need the base
2130 yet. In fact, in the case of a SunOS4 executable being run on
2131 Solaris, we can't get it yet. current_sos will get it when it needs
2133 #if !(defined (SVR4_SHARED_LIBS) && defined (BKPT_AT_SYMBOL))
2134 if ((debug_base = locate_base ()) == 0)
2136 /* Can't find the symbol or the executable is statically linked. */
2141 if (!enable_break ())
2143 warning ("shared library handler failed to enable breakpoint");
2147 #if !defined(SVR4_SHARED_LIBS) || defined(_SCO_DS)
2148 /* SCO and SunOS need the loop below, other systems should be using the
2149 special shared library breakpoints and the shared library breakpoint
2152 Now run the target. It will eventually hit the breakpoint, at
2153 which point all of the libraries will have been mapped in and we
2154 can go groveling around in the dynamic linker structures to find
2155 out what we need to know about them. */
2157 clear_proceed_status ();
2158 stop_soon_quietly = 1;
2159 stop_signal = TARGET_SIGNAL_0;
2162 target_resume (-1, 0, stop_signal);
2163 wait_for_inferior ();
2165 while (stop_signal != TARGET_SIGNAL_TRAP);
2166 stop_soon_quietly = 0;
2168 #if !defined(_SCO_DS)
2169 /* We are now either at the "mapping complete" breakpoint (or somewhere
2170 else, a condition we aren't prepared to deal with anyway), so adjust
2171 the PC as necessary after a breakpoint, disable the breakpoint, and
2172 add any shared libraries that were mapped in. */
2174 if (DECR_PC_AFTER_BREAK)
2176 stop_pc -= DECR_PC_AFTER_BREAK;
2177 write_register (PC_REGNUM, stop_pc);
2180 if (!disable_break ())
2182 warning ("shared library handler failed to disable breakpoint");
2186 solib_add ((char *) 0, 0, (struct target_ops *) 0);
2187 #endif /* ! _SCO_DS */
2195 special_symbol_handling -- additional shared library symbol handling
2199 void special_symbol_handling ()
2203 Once the symbols from a shared object have been loaded in the usual
2204 way, we are called to do any system specific symbol handling that
2207 For SunOS4, this consists of grunging around in the dynamic
2208 linkers structures to find symbol definitions for "common" symbols
2209 and adding them to the minimal symbol table for the runtime common
2215 special_symbol_handling (void)
2217 #ifndef SVR4_SHARED_LIBS
2220 if (debug_addr == 0)
2222 /* Get link_dynamic structure */
2224 j = target_read_memory (debug_base, (char *) &dynamic_copy,
2225 sizeof (dynamic_copy));
2232 /* Calc address of debugger interface structure */
2233 /* FIXME, this needs work for cross-debugging of core files
2234 (byteorder, size, alignment, etc). */
2236 debug_addr = SOLIB_EXTRACT_ADDRESS (dynamic_copy.ldd);
2239 /* Read the debugger structure from the inferior, just to make sure
2240 we have a current copy. */
2242 j = target_read_memory (debug_addr, (char *) &debug_copy,
2243 sizeof (debug_copy));
2245 return; /* unreadable */
2247 /* Get common symbol definitions for the loaded object. */
2249 if (debug_copy.ldd_cp)
2251 solib_add_common_symbols (SOLIB_EXTRACT_ADDRESS (debug_copy.ldd_cp));
2254 #endif /* !SVR4_SHARED_LIBS */
2262 sharedlibrary_command -- handle command to explicitly add library
2266 static void sharedlibrary_command (char *args, int from_tty)
2273 sharedlibrary_command (char *args, int from_tty)
2276 solib_add (args, from_tty, (struct target_ops *) 0);
2279 #endif /* HAVE_LINK_H */
2282 _initialize_solib (void)
2286 add_com ("sharedlibrary", class_files, sharedlibrary_command,
2287 "Load shared object library symbols for files matching REGEXP.");
2288 add_info ("sharedlibrary", info_sharedlibrary_command,
2289 "Status of loaded shared object libraries.");
2292 (add_set_cmd ("auto-solib-add", class_support, var_zinteger,
2293 (char *) &auto_solib_add,
2294 "Set autoloading of shared library symbols.\n\
2295 If nonzero, symbols from all shared object libraries will be loaded\n\
2296 automatically when the inferior begins execution or when the dynamic linker\n\
2297 informs gdb that a new library has been loaded. Otherwise, symbols\n\
2298 must be loaded manually, using `sharedlibrary'.",
2303 (add_set_cmd ("solib-absolute-prefix", class_support, var_filename,
2304 (char *) &solib_absolute_prefix,
2305 "Set prefix for loading absolute shared library symbol files.\n\
2306 For other (relative) files, you can add values using `set solib-search-path'.",
2310 (add_set_cmd ("solib-search-path", class_support, var_string,
2311 (char *) &solib_search_path,
2312 "Set the search path for loading non-absolute shared library symbol files.\n\
2313 This takes precedence over the environment variables PATH and LD_LIBRARY_PATH.",
2317 #endif /* HAVE_LINK_H */