1 /* Handle SVR4 shared libraries for GDB, the GNU Debugger.
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999,
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
26 #include "elf/external.h"
27 #include "elf/common.h"
39 #include "solib-svr4.h"
41 #include "bfd-target.h"
44 #ifndef SVR4_FETCH_LINK_MAP_OFFSETS
45 #define SVR4_FETCH_LINK_MAP_OFFSETS() svr4_fetch_link_map_offsets ()
48 static struct link_map_offsets
*svr4_fetch_link_map_offsets (void);
49 static struct link_map_offsets
*legacy_fetch_link_map_offsets (void);
50 static int svr4_have_link_map_offsets (void);
52 /* fetch_link_map_offsets_gdbarch_data is a handle used to obtain the
53 architecture specific link map offsets fetching function. */
55 static struct gdbarch_data
*fetch_link_map_offsets_gdbarch_data
;
57 /* legacy_svr4_fetch_link_map_offsets_hook is a pointer to a function
58 which is used to fetch link map offsets. It will only be set
59 by solib-legacy.c, if at all. */
61 struct link_map_offsets
*(*legacy_svr4_fetch_link_map_offsets_hook
) (void) = 0;
63 /* Link map info to include in an allocated so_list entry */
67 /* Pointer to copy of link map from inferior. The type is char *
68 rather than void *, so that we may use byte offsets to find the
69 various fields without the need for a cast. */
73 /* On SVR4 systems, a list of symbols in the dynamic linker where
74 GDB can try to place a breakpoint to monitor shared library
77 If none of these symbols are found, or other errors occur, then
78 SVR4 systems will fall back to using a symbol as the "startup
79 mapping complete" breakpoint address. */
81 static char *solib_break_names
[] =
89 /* On the 64-bit PowerPC, the linker symbol with the same name as
90 the C function points to a function descriptor, not to the entry
91 point. The linker symbol whose name is the C function name
92 prefixed with a '.' points to the function's entry point. So
93 when we look through this table, we ignore symbols that point
94 into the data section (thus skipping the descriptor's symbol),
95 and eventually try this one, giving us the real entry point
102 #define BKPT_AT_SYMBOL 1
104 #if defined (BKPT_AT_SYMBOL)
105 static char *bkpt_names
[] =
107 #ifdef SOLIB_BKPT_NAME
108 SOLIB_BKPT_NAME
, /* Prefer configured name if it exists. */
117 static char *main_name_list
[] =
123 /* Macro to extract an address from a solib structure. When GDB is
124 configured for some 32-bit targets (e.g. Solaris 2.7 sparc), BFD is
125 configured to handle 64-bit targets, so CORE_ADDR is 64 bits. We
126 have to extract only the significant bits of addresses to get the
127 right address when accessing the core file BFD.
129 Assume that the address is unsigned. */
131 #define SOLIB_EXTRACT_ADDRESS(MEMBER) \
132 extract_unsigned_integer (&(MEMBER), sizeof (MEMBER))
134 /* local data declarations */
136 /* link map access functions */
139 LM_ADDR (struct so_list
*so
)
141 struct link_map_offsets
*lmo
= SVR4_FETCH_LINK_MAP_OFFSETS ();
143 return (CORE_ADDR
) extract_signed_integer (so
->lm_info
->lm
+ lmo
->l_addr_offset
,
148 LM_NEXT (struct so_list
*so
)
150 struct link_map_offsets
*lmo
= SVR4_FETCH_LINK_MAP_OFFSETS ();
152 /* Assume that the address is unsigned. */
153 return extract_unsigned_integer (so
->lm_info
->lm
+ lmo
->l_next_offset
,
158 LM_NAME (struct so_list
*so
)
160 struct link_map_offsets
*lmo
= SVR4_FETCH_LINK_MAP_OFFSETS ();
162 /* Assume that the address is unsigned. */
163 return extract_unsigned_integer (so
->lm_info
->lm
+ lmo
->l_name_offset
,
168 IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list
*so
)
170 struct link_map_offsets
*lmo
= SVR4_FETCH_LINK_MAP_OFFSETS ();
172 /* Assume that the address is unsigned. */
173 return extract_unsigned_integer (so
->lm_info
->lm
+ lmo
->l_prev_offset
,
174 lmo
->l_prev_size
) == 0;
177 static CORE_ADDR debug_base
; /* Base of dynamic linker structures */
178 static CORE_ADDR breakpoint_addr
; /* Address where end bkpt is set */
180 /* Local function prototypes */
182 static int match_main (char *);
184 static CORE_ADDR
bfd_lookup_symbol (bfd
*, char *, flagword
);
190 bfd_lookup_symbol -- lookup the value for a specific symbol
194 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname, flagword sect_flags)
198 An expensive way to lookup the value of a single symbol for
199 bfd's that are only temporary anyway. This is used by the
200 shared library support to find the address of the debugger
201 interface structures in the shared library.
203 If SECT_FLAGS is non-zero, only match symbols in sections whose
204 flags include all those in SECT_FLAGS.
206 Note that 0 is specifically allowed as an error return (no
211 bfd_lookup_symbol (bfd
*abfd
, char *symname
, flagword sect_flags
)
215 asymbol
**symbol_table
;
216 unsigned int number_of_symbols
;
218 struct cleanup
*back_to
;
219 CORE_ADDR symaddr
= 0;
221 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
223 if (storage_needed
> 0)
225 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
226 back_to
= make_cleanup (xfree
, symbol_table
);
227 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
229 for (i
= 0; i
< number_of_symbols
; i
++)
231 sym
= *symbol_table
++;
232 if (strcmp (sym
->name
, symname
) == 0
233 && (sym
->section
->flags
& sect_flags
) == sect_flags
)
235 /* Bfd symbols are section relative. */
236 symaddr
= sym
->value
+ sym
->section
->vma
;
240 do_cleanups (back_to
);
246 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
247 have to check the dynamic string table too. */
249 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
251 if (storage_needed
> 0)
253 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
254 back_to
= make_cleanup (xfree
, symbol_table
);
255 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
257 for (i
= 0; i
< number_of_symbols
; i
++)
259 sym
= *symbol_table
++;
261 if (strcmp (sym
->name
, symname
) == 0
262 && (sym
->section
->flags
& sect_flags
) == sect_flags
)
264 /* Bfd symbols are section relative. */
265 symaddr
= sym
->value
+ sym
->section
->vma
;
269 do_cleanups (back_to
);
279 elf_locate_base -- locate the base address of dynamic linker structs
280 for SVR4 elf targets.
284 CORE_ADDR elf_locate_base (void)
288 For SVR4 elf targets the address of the dynamic linker's runtime
289 structure is contained within the dynamic info section in the
290 executable file. The dynamic section is also mapped into the
291 inferior address space. Because the runtime loader fills in the
292 real address before starting the inferior, we have to read in the
293 dynamic info section from the inferior address space.
294 If there are any errors while trying to find the address, we
295 silently return 0, otherwise the found address is returned.
300 elf_locate_base (void)
302 struct bfd_section
*dyninfo_sect
;
303 int dyninfo_sect_size
;
304 CORE_ADDR dyninfo_addr
;
309 /* Find the start address of the .dynamic section. */
310 dyninfo_sect
= bfd_get_section_by_name (exec_bfd
, ".dynamic");
311 if (dyninfo_sect
== NULL
)
313 dyninfo_addr
= bfd_section_vma (exec_bfd
, dyninfo_sect
);
315 /* Read in .dynamic section, silently ignore errors. */
316 dyninfo_sect_size
= bfd_section_size (exec_bfd
, dyninfo_sect
);
317 buf
= alloca (dyninfo_sect_size
);
318 if (target_read_memory (dyninfo_addr
, buf
, dyninfo_sect_size
))
321 /* Find the DT_DEBUG entry in the the .dynamic section.
322 For mips elf we look for DT_MIPS_RLD_MAP, mips elf apparently has
323 no DT_DEBUG entries. */
325 arch_size
= bfd_get_arch_size (exec_bfd
);
326 if (arch_size
== -1) /* failure */
331 for (bufend
= buf
+ dyninfo_sect_size
;
333 buf
+= sizeof (Elf32_External_Dyn
))
335 Elf32_External_Dyn
*x_dynp
= (Elf32_External_Dyn
*) buf
;
339 dyn_tag
= bfd_h_get_32 (exec_bfd
, (bfd_byte
*) x_dynp
->d_tag
);
340 if (dyn_tag
== DT_NULL
)
342 else if (dyn_tag
== DT_DEBUG
)
344 dyn_ptr
= bfd_h_get_32 (exec_bfd
,
345 (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
348 else if (dyn_tag
== DT_MIPS_RLD_MAP
)
351 int pbuf_size
= TARGET_PTR_BIT
/ HOST_CHAR_BIT
;
353 pbuf
= alloca (pbuf_size
);
354 /* DT_MIPS_RLD_MAP contains a pointer to the address
355 of the dynamic link structure. */
356 dyn_ptr
= bfd_h_get_32 (exec_bfd
,
357 (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
358 if (target_read_memory (dyn_ptr
, pbuf
, pbuf_size
))
360 return extract_unsigned_integer (pbuf
, pbuf_size
);
364 else /* 64-bit elf */
366 for (bufend
= buf
+ dyninfo_sect_size
;
368 buf
+= sizeof (Elf64_External_Dyn
))
370 Elf64_External_Dyn
*x_dynp
= (Elf64_External_Dyn
*) buf
;
374 dyn_tag
= bfd_h_get_64 (exec_bfd
, (bfd_byte
*) x_dynp
->d_tag
);
375 if (dyn_tag
== DT_NULL
)
377 else if (dyn_tag
== DT_DEBUG
)
379 dyn_ptr
= bfd_h_get_64 (exec_bfd
,
380 (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
383 else if (dyn_tag
== DT_MIPS_RLD_MAP
)
386 int pbuf_size
= TARGET_PTR_BIT
/ HOST_CHAR_BIT
;
388 pbuf
= alloca (pbuf_size
);
389 /* DT_MIPS_RLD_MAP contains a pointer to the address
390 of the dynamic link structure. */
391 dyn_ptr
= bfd_h_get_64 (exec_bfd
,
392 (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
393 if (target_read_memory (dyn_ptr
, pbuf
, pbuf_size
))
395 return extract_unsigned_integer (pbuf
, pbuf_size
);
400 /* DT_DEBUG entry not found. */
408 locate_base -- locate the base address of dynamic linker structs
412 CORE_ADDR locate_base (void)
416 For both the SunOS and SVR4 shared library implementations, if the
417 inferior executable has been linked dynamically, there is a single
418 address somewhere in the inferior's data space which is the key to
419 locating all of the dynamic linker's runtime structures. This
420 address is the value of the debug base symbol. The job of this
421 function is to find and return that address, or to return 0 if there
422 is no such address (the executable is statically linked for example).
424 For SunOS, the job is almost trivial, since the dynamic linker and
425 all of it's structures are statically linked to the executable at
426 link time. Thus the symbol for the address we are looking for has
427 already been added to the minimal symbol table for the executable's
428 objfile at the time the symbol file's symbols were read, and all we
429 have to do is look it up there. Note that we explicitly do NOT want
430 to find the copies in the shared library.
432 The SVR4 version is a bit more complicated because the address
433 is contained somewhere in the dynamic info section. We have to go
434 to a lot more work to discover the address of the debug base symbol.
435 Because of this complexity, we cache the value we find and return that
436 value on subsequent invocations. Note there is no copy in the
437 executable symbol tables.
444 /* Check to see if we have a currently valid address, and if so, avoid
445 doing all this work again and just return the cached address. If
446 we have no cached address, try to locate it in the dynamic info
447 section for ELF executables. There's no point in doing any of this
448 though if we don't have some link map offsets to work with. */
450 if (debug_base
== 0 && svr4_have_link_map_offsets ())
453 && bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
454 debug_base
= elf_locate_base ();
463 first_link_map_member -- locate first member in dynamic linker's map
467 static CORE_ADDR first_link_map_member (void)
471 Find the first element in the inferior's dynamic link map, and
472 return its address in the inferior. This function doesn't copy the
473 link map entry itself into our address space; current_sos actually
477 first_link_map_member (void)
480 struct link_map_offsets
*lmo
= SVR4_FETCH_LINK_MAP_OFFSETS ();
481 char *r_map_buf
= xmalloc (lmo
->r_map_size
);
482 struct cleanup
*cleanups
= make_cleanup (xfree
, r_map_buf
);
484 read_memory (debug_base
+ lmo
->r_map_offset
, r_map_buf
, lmo
->r_map_size
);
486 /* Assume that the address is unsigned. */
487 lm
= extract_unsigned_integer (r_map_buf
, lmo
->r_map_size
);
489 /* FIXME: Perhaps we should validate the info somehow, perhaps by
490 checking r_version for a known version number, or r_state for
493 do_cleanups (cleanups
);
502 open_symbol_file_object
506 void open_symbol_file_object (void *from_tty)
510 If no open symbol file, attempt to locate and open the main symbol
511 file. On SVR4 systems, this is the first link map entry. If its
512 name is here, we can open it. Useful when attaching to a process
513 without first loading its symbol file.
515 If FROM_TTYP dereferences to a non-zero integer, allow messages to
516 be printed. This parameter is a pointer rather than an int because
517 open_symbol_file_object() is called via catch_errors() and
518 catch_errors() requires a pointer argument. */
521 open_symbol_file_object (void *from_ttyp
)
523 CORE_ADDR lm
, l_name
;
526 int from_tty
= *(int *)from_ttyp
;
527 struct link_map_offsets
*lmo
= SVR4_FETCH_LINK_MAP_OFFSETS ();
528 char *l_name_buf
= xmalloc (lmo
->l_name_size
);
529 struct cleanup
*cleanups
= make_cleanup (xfree
, l_name_buf
);
532 if (!query ("Attempt to reload symbols from process? "))
535 if ((debug_base
= locate_base ()) == 0)
536 return 0; /* failed somehow... */
538 /* First link map member should be the executable. */
539 if ((lm
= first_link_map_member ()) == 0)
540 return 0; /* failed somehow... */
542 /* Read address of name from target memory to GDB. */
543 read_memory (lm
+ lmo
->l_name_offset
, l_name_buf
, lmo
->l_name_size
);
545 /* Convert the address to host format. Assume that the address is
547 l_name
= extract_unsigned_integer (l_name_buf
, lmo
->l_name_size
);
549 /* Free l_name_buf. */
550 do_cleanups (cleanups
);
553 return 0; /* No filename. */
555 /* Now fetch the filename from target memory. */
556 target_read_string (l_name
, &filename
, SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
560 warning (_("failed to read exec filename from attached file: %s"),
561 safe_strerror (errcode
));
565 make_cleanup (xfree
, filename
);
566 /* Have a pathname: read the symbol file. */
567 symbol_file_add_main (filename
, from_tty
);
574 current_sos -- build a list of currently loaded shared objects
578 struct so_list *current_sos ()
582 Build a list of `struct so_list' objects describing the shared
583 objects currently loaded in the inferior. This list does not
584 include an entry for the main executable file.
586 Note that we only gather information directly available from the
587 inferior --- we don't examine any of the shared library files
588 themselves. The declaration of `struct so_list' says which fields
589 we provide values for. */
591 static struct so_list
*
592 svr4_current_sos (void)
595 struct so_list
*head
= 0;
596 struct so_list
**link_ptr
= &head
;
598 /* Make sure we've looked up the inferior's dynamic linker's base
602 debug_base
= locate_base ();
604 /* If we can't find the dynamic linker's base structure, this
605 must not be a dynamically linked executable. Hmm. */
610 /* Walk the inferior's link map list, and build our list of
611 `struct so_list' nodes. */
612 lm
= first_link_map_member ();
615 struct link_map_offsets
*lmo
= SVR4_FETCH_LINK_MAP_OFFSETS ();
617 = (struct so_list
*) xmalloc (sizeof (struct so_list
));
618 struct cleanup
*old_chain
= make_cleanup (xfree
, new);
620 memset (new, 0, sizeof (*new));
622 new->lm_info
= xmalloc (sizeof (struct lm_info
));
623 make_cleanup (xfree
, new->lm_info
);
625 new->lm_info
->lm
= xmalloc (lmo
->link_map_size
);
626 make_cleanup (xfree
, new->lm_info
->lm
);
627 memset (new->lm_info
->lm
, 0, lmo
->link_map_size
);
629 read_memory (lm
, new->lm_info
->lm
, lmo
->link_map_size
);
633 /* For SVR4 versions, the first entry in the link map is for the
634 inferior executable, so we must ignore it. For some versions of
635 SVR4, it has no name. For others (Solaris 2.3 for example), it
636 does have a name, so we can no longer use a missing name to
637 decide when to ignore it. */
638 if (IGNORE_FIRST_LINK_MAP_ENTRY (new))
645 /* Extract this shared object's name. */
646 target_read_string (LM_NAME (new), &buffer
,
647 SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
649 warning (_("Can't read pathname for load map: %s."),
650 safe_strerror (errcode
));
653 strncpy (new->so_name
, buffer
, SO_NAME_MAX_PATH_SIZE
- 1);
654 new->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
656 strcpy (new->so_original_name
, new->so_name
);
659 /* If this entry has no name, or its name matches the name
660 for the main executable, don't include it in the list. */
661 if (! new->so_name
[0]
662 || match_main (new->so_name
))
668 link_ptr
= &new->next
;
672 discard_cleanups (old_chain
);
678 /* Get the address of the link_map for a given OBJFILE. Loop through
679 the link maps, and return the address of the one corresponding to
680 the given objfile. Note that this function takes into account that
681 objfile can be the main executable, not just a shared library. The
682 main executable has always an empty name field in the linkmap. */
685 svr4_fetch_objfile_link_map (struct objfile
*objfile
)
689 if ((debug_base
= locate_base ()) == 0)
690 return 0; /* failed somehow... */
692 /* Position ourselves on the first link map. */
693 lm
= first_link_map_member ();
696 /* Get info on the layout of the r_debug and link_map structures. */
697 struct link_map_offsets
*lmo
= SVR4_FETCH_LINK_MAP_OFFSETS ();
700 struct lm_info objfile_lm_info
;
701 struct cleanup
*old_chain
;
702 CORE_ADDR name_address
;
703 char *l_name_buf
= xmalloc (lmo
->l_name_size
);
704 old_chain
= make_cleanup (xfree
, l_name_buf
);
706 /* Set up the buffer to contain the portion of the link_map
707 structure that gdb cares about. Note that this is not the
708 whole link_map structure. */
709 objfile_lm_info
.lm
= xmalloc (lmo
->link_map_size
);
710 make_cleanup (xfree
, objfile_lm_info
.lm
);
711 memset (objfile_lm_info
.lm
, 0, lmo
->link_map_size
);
713 /* Read the link map into our internal structure. */
714 read_memory (lm
, objfile_lm_info
.lm
, lmo
->link_map_size
);
716 /* Read address of name from target memory to GDB. */
717 read_memory (lm
+ lmo
->l_name_offset
, l_name_buf
, lmo
->l_name_size
);
719 /* Extract this object's name. Assume that the address is
721 name_address
= extract_unsigned_integer (l_name_buf
, lmo
->l_name_size
);
722 target_read_string (name_address
, &buffer
,
723 SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
724 make_cleanup (xfree
, buffer
);
726 warning (_("Can't read pathname for load map: %s."),
727 safe_strerror (errcode
));
730 /* Is this the linkmap for the file we want? */
731 /* If the file is not a shared library and has no name,
732 we are sure it is the main executable, so we return that. */
733 if ((buffer
&& strcmp (buffer
, objfile
->name
) == 0)
734 || (!(objfile
->flags
& OBJF_SHARED
) && (strcmp (buffer
, "") == 0)))
736 do_cleanups (old_chain
);
740 /* Not the file we wanted, continue checking. Assume that the
741 address is unsigned. */
742 lm
= extract_unsigned_integer (objfile_lm_info
.lm
+ lmo
->l_next_offset
,
744 do_cleanups (old_chain
);
749 /* On some systems, the only way to recognize the link map entry for
750 the main executable file is by looking at its name. Return
751 non-zero iff SONAME matches one of the known main executable names. */
754 match_main (char *soname
)
758 for (mainp
= main_name_list
; *mainp
!= NULL
; mainp
++)
760 if (strcmp (soname
, *mainp
) == 0)
767 /* Return 1 if PC lies in the dynamic symbol resolution code of the
768 SVR4 run time loader. */
769 static CORE_ADDR interp_text_sect_low
;
770 static CORE_ADDR interp_text_sect_high
;
771 static CORE_ADDR interp_plt_sect_low
;
772 static CORE_ADDR interp_plt_sect_high
;
775 svr4_in_dynsym_resolve_code (CORE_ADDR pc
)
777 return ((pc
>= interp_text_sect_low
&& pc
< interp_text_sect_high
)
778 || (pc
>= interp_plt_sect_low
&& pc
< interp_plt_sect_high
)
779 || in_plt_section (pc
, NULL
));
782 /* Given an executable's ABFD and target, compute the entry-point
786 exec_entry_point (struct bfd
*abfd
, struct target_ops
*targ
)
788 /* KevinB wrote ... for most targets, the address returned by
789 bfd_get_start_address() is the entry point for the start
790 function. But, for some targets, bfd_get_start_address() returns
791 the address of a function descriptor from which the entry point
792 address may be extracted. This address is extracted by
793 gdbarch_convert_from_func_ptr_addr(). The method
794 gdbarch_convert_from_func_ptr_addr() is the merely the identify
795 function for targets which don't use function descriptors. */
796 return gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
797 bfd_get_start_address (abfd
),
805 enable_break -- arrange for dynamic linker to hit breakpoint
809 int enable_break (void)
813 Both the SunOS and the SVR4 dynamic linkers have, as part of their
814 debugger interface, support for arranging for the inferior to hit
815 a breakpoint after mapping in the shared libraries. This function
816 enables that breakpoint.
818 For SunOS, there is a special flag location (in_debugger) which we
819 set to 1. When the dynamic linker sees this flag set, it will set
820 a breakpoint at a location known only to itself, after saving the
821 original contents of that place and the breakpoint address itself,
822 in it's own internal structures. When we resume the inferior, it
823 will eventually take a SIGTRAP when it runs into the breakpoint.
824 We handle this (in a different place) by restoring the contents of
825 the breakpointed location (which is only known after it stops),
826 chasing around to locate the shared libraries that have been
827 loaded, then resuming.
829 For SVR4, the debugger interface structure contains a member (r_brk)
830 which is statically initialized at the time the shared library is
831 built, to the offset of a function (_r_debug_state) which is guaran-
832 teed to be called once before mapping in a library, and again when
833 the mapping is complete. At the time we are examining this member,
834 it contains only the unrelocated offset of the function, so we have
835 to do our own relocation. Later, when the dynamic linker actually
836 runs, it relocates r_brk to be the actual address of _r_debug_state().
838 The debugger interface structure also contains an enumeration which
839 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
840 depending upon whether or not the library is being mapped or unmapped,
841 and then set to RT_CONSISTENT after the library is mapped/unmapped.
849 #ifdef BKPT_AT_SYMBOL
851 struct minimal_symbol
*msymbol
;
853 asection
*interp_sect
;
855 /* First, remove all the solib event breakpoints. Their addresses
856 may have changed since the last time we ran the program. */
857 remove_solib_event_breakpoints ();
859 interp_text_sect_low
= interp_text_sect_high
= 0;
860 interp_plt_sect_low
= interp_plt_sect_high
= 0;
862 /* Find the .interp section; if not found, warn the user and drop
863 into the old breakpoint at symbol code. */
864 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
867 unsigned int interp_sect_size
;
869 CORE_ADDR load_addr
= 0;
870 int load_addr_found
= 0;
873 struct target_ops
*tmp_bfd_target
;
875 char *tmp_pathname
= NULL
;
876 CORE_ADDR sym_addr
= 0;
878 /* Read the contents of the .interp section into a local buffer;
879 the contents specify the dynamic linker this program uses. */
880 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
881 buf
= alloca (interp_sect_size
);
882 bfd_get_section_contents (exec_bfd
, interp_sect
,
883 buf
, 0, interp_sect_size
);
885 /* Now we need to figure out where the dynamic linker was
886 loaded so that we can load its symbols and place a breakpoint
887 in the dynamic linker itself.
889 This address is stored on the stack. However, I've been unable
890 to find any magic formula to find it for Solaris (appears to
891 be trivial on GNU/Linux). Therefore, we have to try an alternate
892 mechanism to find the dynamic linker's base address. */
894 tmp_fd
= solib_open (buf
, &tmp_pathname
);
896 tmp_bfd
= bfd_fdopenr (tmp_pathname
, gnutarget
, tmp_fd
);
901 /* Make sure the dynamic linker's really a useful object. */
902 if (!bfd_check_format (tmp_bfd
, bfd_object
))
904 warning (_("Unable to grok dynamic linker %s as an object file"), buf
);
909 /* Now convert the TMP_BFD into a target. That way target, as
910 well as BFD operations can be used. Note that closing the
911 target will also close the underlying bfd. */
912 tmp_bfd_target
= target_bfd_reopen (tmp_bfd
);
914 /* On a running target, we can get the dynamic linker's base
915 address from the shared library table. */
916 solib_add (NULL
, 0, NULL
, auto_solib_add
);
917 so
= master_so_list ();
920 if (strcmp (buf
, so
->so_original_name
) == 0)
923 load_addr
= LM_ADDR (so
);
929 /* Otherwise we find the dynamic linker's base address by examining
930 the current pc (which should point at the entry point for the
931 dynamic linker) and subtracting the offset of the entry point. */
932 if (!load_addr_found
)
933 load_addr
= (read_pc ()
934 - exec_entry_point (tmp_bfd
, tmp_bfd_target
));
936 /* Record the relocated start and end address of the dynamic linker
937 text and plt section for svr4_in_dynsym_resolve_code. */
938 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
941 interp_text_sect_low
=
942 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
943 interp_text_sect_high
=
944 interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
946 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
949 interp_plt_sect_low
=
950 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
951 interp_plt_sect_high
=
952 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
955 /* Now try to set a breakpoint in the dynamic linker. */
956 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
958 /* On ABI's that use function descriptors, there are usually
959 two linker symbols associated with each C function: one
960 pointing at the actual entry point of the machine code,
961 and one pointing at the function's descriptor. The
962 latter symbol has the same name as the C function.
964 What we're looking for here is the machine code entry
965 point, so we are only interested in symbols in code
967 sym_addr
= bfd_lookup_symbol (tmp_bfd
, *bkpt_namep
, SEC_CODE
);
972 /* We're done with both the temporary bfd and target. Remember,
973 closing the target closes the underlying bfd. */
974 target_close (tmp_bfd_target
, 0);
978 create_solib_event_breakpoint (load_addr
+ sym_addr
);
982 /* For whatever reason we couldn't set a breakpoint in the dynamic
983 linker. Warn and drop into the old code. */
985 warning (_("Unable to find dynamic linker breakpoint function.\nGDB will be unable to debug shared library initializers\nand track explicitly loaded dynamic code."));
988 /* Scan through the list of symbols, trying to look up the symbol and
989 set a breakpoint there. Terminate loop when we/if we succeed. */
992 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
994 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
995 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
997 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol
));
1002 /* Nothing good happened. */
1005 #endif /* BKPT_AT_SYMBOL */
1014 special_symbol_handling -- additional shared library symbol handling
1018 void special_symbol_handling ()
1022 Once the symbols from a shared object have been loaded in the usual
1023 way, we are called to do any system specific symbol handling that
1026 For SunOS4, this consisted of grunging around in the dynamic
1027 linkers structures to find symbol definitions for "common" symbols
1028 and adding them to the minimal symbol table for the runtime common
1031 However, for SVR4, there's nothing to do.
1036 svr4_special_symbol_handling (void)
1040 /* Relocate the main executable. This function should be called upon
1041 stopping the inferior process at the entry point to the program.
1042 The entry point from BFD is compared to the PC and if they are
1043 different, the main executable is relocated by the proper amount.
1045 As written it will only attempt to relocate executables which
1046 lack interpreter sections. It seems likely that only dynamic
1047 linker executables will get relocated, though it should work
1048 properly for a position-independent static executable as well. */
1051 svr4_relocate_main_executable (void)
1053 asection
*interp_sect
;
1054 CORE_ADDR pc
= read_pc ();
1056 /* Decide if the objfile needs to be relocated. As indicated above,
1057 we will only be here when execution is stopped at the beginning
1058 of the program. Relocation is necessary if the address at which
1059 we are presently stopped differs from the start address stored in
1060 the executable AND there's no interpreter section. The condition
1061 regarding the interpreter section is very important because if
1062 there *is* an interpreter section, execution will begin there
1063 instead. When there is an interpreter section, the start address
1064 is (presumably) used by the interpreter at some point to start
1065 execution of the program.
1067 If there is an interpreter, it is normal for it to be set to an
1068 arbitrary address at the outset. The job of finding it is
1069 handled in enable_break().
1071 So, to summarize, relocations are necessary when there is no
1072 interpreter section and the start address obtained from the
1073 executable is different from the address at which GDB is
1076 [ The astute reader will note that we also test to make sure that
1077 the executable in question has the DYNAMIC flag set. It is my
1078 opinion that this test is unnecessary (undesirable even). It
1079 was added to avoid inadvertent relocation of an executable
1080 whose e_type member in the ELF header is not ET_DYN. There may
1081 be a time in the future when it is desirable to do relocations
1082 on other types of files as well in which case this condition
1083 should either be removed or modified to accomodate the new file
1084 type. (E.g, an ET_EXEC executable which has been built to be
1085 position-independent could safely be relocated by the OS if
1086 desired. It is true that this violates the ABI, but the ABI
1087 has been known to be bent from time to time.) - Kevin, Nov 2000. ]
1090 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
1091 if (interp_sect
== NULL
1092 && (bfd_get_file_flags (exec_bfd
) & DYNAMIC
) != 0
1093 && (exec_entry_point (exec_bfd
, &exec_ops
) != pc
))
1095 struct cleanup
*old_chain
;
1096 struct section_offsets
*new_offsets
;
1098 CORE_ADDR displacement
;
1100 /* It is necessary to relocate the objfile. The amount to
1101 relocate by is simply the address at which we are stopped
1102 minus the starting address from the executable.
1104 We relocate all of the sections by the same amount. This
1105 behavior is mandated by recent editions of the System V ABI.
1106 According to the System V Application Binary Interface,
1107 Edition 4.1, page 5-5:
1109 ... Though the system chooses virtual addresses for
1110 individual processes, it maintains the segments' relative
1111 positions. Because position-independent code uses relative
1112 addressesing between segments, the difference between
1113 virtual addresses in memory must match the difference
1114 between virtual addresses in the file. The difference
1115 between the virtual address of any segment in memory and
1116 the corresponding virtual address in the file is thus a
1117 single constant value for any one executable or shared
1118 object in a given process. This difference is the base
1119 address. One use of the base address is to relocate the
1120 memory image of the program during dynamic linking.
1122 The same language also appears in Edition 4.0 of the System V
1123 ABI and is left unspecified in some of the earlier editions. */
1125 displacement
= pc
- exec_entry_point (exec_bfd
, &exec_ops
);
1128 new_offsets
= xcalloc (symfile_objfile
->num_sections
,
1129 sizeof (struct section_offsets
));
1130 old_chain
= make_cleanup (xfree
, new_offsets
);
1132 for (i
= 0; i
< symfile_objfile
->num_sections
; i
++)
1134 if (displacement
!= ANOFFSET (symfile_objfile
->section_offsets
, i
))
1136 new_offsets
->offsets
[i
] = displacement
;
1140 objfile_relocate (symfile_objfile
, new_offsets
);
1142 do_cleanups (old_chain
);
1150 svr4_solib_create_inferior_hook -- shared library startup support
1154 void svr4_solib_create_inferior_hook ()
1158 When gdb starts up the inferior, it nurses it along (through the
1159 shell) until it is ready to execute it's first instruction. At this
1160 point, this function gets called via expansion of the macro
1161 SOLIB_CREATE_INFERIOR_HOOK.
1163 For SunOS executables, this first instruction is typically the
1164 one at "_start", or a similar text label, regardless of whether
1165 the executable is statically or dynamically linked. The runtime
1166 startup code takes care of dynamically linking in any shared
1167 libraries, once gdb allows the inferior to continue.
1169 For SVR4 executables, this first instruction is either the first
1170 instruction in the dynamic linker (for dynamically linked
1171 executables) or the instruction at "start" for statically linked
1172 executables. For dynamically linked executables, the system
1173 first exec's /lib/libc.so.N, which contains the dynamic linker,
1174 and starts it running. The dynamic linker maps in any needed
1175 shared libraries, maps in the actual user executable, and then
1176 jumps to "start" in the user executable.
1178 For both SunOS shared libraries, and SVR4 shared libraries, we
1179 can arrange to cooperate with the dynamic linker to discover the
1180 names of shared libraries that are dynamically linked, and the
1181 base addresses to which they are linked.
1183 This function is responsible for discovering those names and
1184 addresses, and saving sufficient information about them to allow
1185 their symbols to be read at a later time.
1189 Between enable_break() and disable_break(), this code does not
1190 properly handle hitting breakpoints which the user might have
1191 set in the startup code or in the dynamic linker itself. Proper
1192 handling will probably have to wait until the implementation is
1193 changed to use the "breakpoint handler function" method.
1195 Also, what if child has exit()ed? Must exit loop somehow.
1199 svr4_solib_create_inferior_hook (void)
1201 /* Relocate the main executable if necessary. */
1202 svr4_relocate_main_executable ();
1204 if (!svr4_have_link_map_offsets ())
1206 warning (_("no shared library support for this OS / ABI"));
1211 if (!enable_break ())
1213 warning (_("shared library handler failed to enable breakpoint"));
1217 #if defined(_SCO_DS)
1218 /* SCO needs the loop below, other systems should be using the
1219 special shared library breakpoints and the shared library breakpoint
1222 Now run the target. It will eventually hit the breakpoint, at
1223 which point all of the libraries will have been mapped in and we
1224 can go groveling around in the dynamic linker structures to find
1225 out what we need to know about them. */
1227 clear_proceed_status ();
1228 stop_soon
= STOP_QUIETLY
;
1229 stop_signal
= TARGET_SIGNAL_0
;
1232 target_resume (pid_to_ptid (-1), 0, stop_signal
);
1233 wait_for_inferior ();
1235 while (stop_signal
!= TARGET_SIGNAL_TRAP
);
1236 stop_soon
= NO_STOP_QUIETLY
;
1237 #endif /* defined(_SCO_DS) */
1241 svr4_clear_solib (void)
1247 svr4_free_so (struct so_list
*so
)
1249 xfree (so
->lm_info
->lm
);
1250 xfree (so
->lm_info
);
1254 /* Clear any bits of ADDR that wouldn't fit in a target-format
1255 data pointer. "Data pointer" here refers to whatever sort of
1256 address the dynamic linker uses to manage its sections. At the
1257 moment, we don't support shared libraries on any processors where
1258 code and data pointers are different sizes.
1260 This isn't really the right solution. What we really need here is
1261 a way to do arithmetic on CORE_ADDR values that respects the
1262 natural pointer/address correspondence. (For example, on the MIPS,
1263 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
1264 sign-extend the value. There, simply truncating the bits above
1265 TARGET_PTR_BIT, as we do below, is no good.) This should probably
1266 be a new gdbarch method or something. */
1268 svr4_truncate_ptr (CORE_ADDR addr
)
1270 if (TARGET_PTR_BIT
== sizeof (CORE_ADDR
) * 8)
1271 /* We don't need to truncate anything, and the bit twiddling below
1272 will fail due to overflow problems. */
1275 return addr
& (((CORE_ADDR
) 1 << TARGET_PTR_BIT
) - 1);
1280 svr4_relocate_section_addresses (struct so_list
*so
,
1281 struct section_table
*sec
)
1283 sec
->addr
= svr4_truncate_ptr (sec
->addr
+ LM_ADDR (so
));
1284 sec
->endaddr
= svr4_truncate_ptr (sec
->endaddr
+ LM_ADDR (so
));
1288 /* Fetch a link_map_offsets structure for native targets using struct
1289 definitions from link.h. See solib-legacy.c for the function
1290 which does the actual work.
1292 Note: For non-native targets (i.e. cross-debugging situations),
1293 a target specific fetch_link_map_offsets() function should be
1294 defined and registered via set_solib_svr4_fetch_link_map_offsets(). */
1296 static struct link_map_offsets
*
1297 legacy_fetch_link_map_offsets (void)
1299 if (legacy_svr4_fetch_link_map_offsets_hook
)
1300 return legacy_svr4_fetch_link_map_offsets_hook ();
1303 internal_error (__FILE__
, __LINE__
,
1304 _("legacy_fetch_link_map_offsets called without legacy "
1305 "link_map support enabled."));
1310 /* Fetch a link_map_offsets structure using the method registered in the
1311 architecture vector. */
1313 static struct link_map_offsets
*
1314 svr4_fetch_link_map_offsets (void)
1316 struct link_map_offsets
*(*flmo
)(void) =
1317 gdbarch_data (current_gdbarch
, fetch_link_map_offsets_gdbarch_data
);
1321 internal_error (__FILE__
, __LINE__
,
1322 _("svr4_fetch_link_map_offsets: fetch_link_map_offsets "
1323 "method not defined for this architecture."));
1330 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
1332 svr4_have_link_map_offsets (void)
1334 struct link_map_offsets
*(*flmo
)(void) =
1335 gdbarch_data (current_gdbarch
, fetch_link_map_offsets_gdbarch_data
);
1337 || (flmo
== legacy_fetch_link_map_offsets
1338 && legacy_svr4_fetch_link_map_offsets_hook
== NULL
))
1344 /* set_solib_svr4_fetch_link_map_offsets() is intended to be called by
1345 a <arch>_gdbarch_init() function. It is used to establish an
1346 architecture specific link_map_offsets fetcher for the architecture
1350 set_solib_svr4_fetch_link_map_offsets (struct gdbarch
*gdbarch
,
1351 struct link_map_offsets
*(*flmo
) (void))
1353 deprecated_set_gdbarch_data (gdbarch
, fetch_link_map_offsets_gdbarch_data
, flmo
);
1356 /* Initialize the architecture-specific link_map_offsets fetcher.
1357 This is called after <arch>_gdbarch_init() has set up its `struct
1358 gdbarch' for the new architecture, and is only called if the
1359 link_map_offsets fetcher isn't already initialized (which is
1360 usually done by calling set_solib_svr4_fetch_link_map_offsets()
1361 above in <arch>_gdbarch_init()). Therefore we attempt to provide a
1362 reasonable alternative (for native targets anyway) if the
1363 <arch>_gdbarch_init() fails to call
1364 set_solib_svr4_fetch_link_map_offsets(). */
1367 init_fetch_link_map_offsets (struct gdbarch
*gdbarch
)
1369 return legacy_fetch_link_map_offsets
;
1372 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
1373 `struct r_debug' and a `struct link_map' that are binary compatible
1374 with the origional SVR4 implementation. */
1376 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
1377 for an ILP32 SVR4 system. */
1379 struct link_map_offsets
*
1380 svr4_ilp32_fetch_link_map_offsets (void)
1382 static struct link_map_offsets lmo
;
1383 static struct link_map_offsets
*lmp
= NULL
;
1389 /* Everything we need is in the first 8 bytes. */
1390 lmo
.r_debug_size
= 8;
1391 lmo
.r_map_offset
= 4;
1394 /* Everything we need is in the first 20 bytes. */
1395 lmo
.link_map_size
= 20;
1396 lmo
.l_addr_offset
= 0;
1397 lmo
.l_addr_size
= 4;
1398 lmo
.l_name_offset
= 4;
1399 lmo
.l_name_size
= 4;
1400 lmo
.l_next_offset
= 12;
1401 lmo
.l_next_size
= 4;
1402 lmo
.l_prev_offset
= 16;
1403 lmo
.l_prev_size
= 4;
1409 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
1410 for an LP64 SVR4 system. */
1412 struct link_map_offsets
*
1413 svr4_lp64_fetch_link_map_offsets (void)
1415 static struct link_map_offsets lmo
;
1416 static struct link_map_offsets
*lmp
= NULL
;
1422 /* Everything we need is in the first 16 bytes. */
1423 lmo
.r_debug_size
= 16;
1424 lmo
.r_map_offset
= 8;
1427 /* Everything we need is in the first 40 bytes. */
1428 lmo
.link_map_size
= 40;
1429 lmo
.l_addr_offset
= 0;
1430 lmo
.l_addr_size
= 8;
1431 lmo
.l_name_offset
= 8;
1432 lmo
.l_name_size
= 8;
1433 lmo
.l_next_offset
= 24;
1434 lmo
.l_next_size
= 8;
1435 lmo
.l_prev_offset
= 32;
1436 lmo
.l_prev_size
= 8;
1443 static struct target_so_ops svr4_so_ops
;
1445 extern initialize_file_ftype _initialize_svr4_solib
; /* -Wmissing-prototypes */
1448 _initialize_svr4_solib (void)
1450 fetch_link_map_offsets_gdbarch_data
=
1451 gdbarch_data_register_post_init (init_fetch_link_map_offsets
);
1453 svr4_so_ops
.relocate_section_addresses
= svr4_relocate_section_addresses
;
1454 svr4_so_ops
.free_so
= svr4_free_so
;
1455 svr4_so_ops
.clear_solib
= svr4_clear_solib
;
1456 svr4_so_ops
.solib_create_inferior_hook
= svr4_solib_create_inferior_hook
;
1457 svr4_so_ops
.special_symbol_handling
= svr4_special_symbol_handling
;
1458 svr4_so_ops
.current_sos
= svr4_current_sos
;
1459 svr4_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
1460 svr4_so_ops
.in_dynsym_resolve_code
= svr4_in_dynsym_resolve_code
;
1462 /* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */
1463 current_target_so_ops
= &svr4_so_ops
;