1 /* Handle SVR4 shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999,
4 2000, 2001, 2003, 2004, 2005, 2006
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., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
26 #include "elf/external.h"
27 #include "elf/common.h"
38 #include "gdb_assert.h"
42 #include "solib-svr4.h"
44 #include "bfd-target.h"
48 static struct link_map_offsets
*svr4_fetch_link_map_offsets (void);
49 static int svr4_have_link_map_offsets (void);
51 /* This hook is set to a function that provides native link map
52 offsets if the code in solib-legacy.c is linked in. */
53 struct link_map_offsets
*(*legacy_svr4_fetch_link_map_offsets_hook
) (void);
55 /* Link map info to include in an allocated so_list entry */
59 /* Pointer to copy of link map from inferior. The type is char *
60 rather than void *, so that we may use byte offsets to find the
61 various fields without the need for a cast. */
64 /* Amount by which addresses in the binary should be relocated to
65 match the inferior. This could most often be taken directly
66 from lm, but when prelinking is involved and the prelink base
67 address changes, we may need a different offset, we want to
68 warn about the difference and compute it only once. */
72 /* On SVR4 systems, a list of symbols in the dynamic linker where
73 GDB can try to place a breakpoint to monitor shared library
76 If none of these symbols are found, or other errors occur, then
77 SVR4 systems will fall back to using a symbol as the "startup
78 mapping complete" breakpoint address. */
80 static char *solib_break_names
[] =
88 /* On the 64-bit PowerPC, the linker symbol with the same name as
89 the C function points to a function descriptor, not to the entry
90 point. The linker symbol whose name is the C function name
91 prefixed with a '.' points to the function's entry point. So
92 when we look through this table, we ignore symbols that point
93 into the data section (thus skipping the descriptor's symbol),
94 and eventually try this one, giving us the real entry point
101 #define BKPT_AT_SYMBOL 1
103 #if defined (BKPT_AT_SYMBOL)
104 static char *bkpt_names
[] =
106 #ifdef SOLIB_BKPT_NAME
107 SOLIB_BKPT_NAME
, /* Prefer configured name if it exists. */
116 static char *main_name_list
[] =
122 /* Macro to extract an address from a solib structure. When GDB is
123 configured for some 32-bit targets (e.g. Solaris 2.7 sparc), BFD is
124 configured to handle 64-bit targets, so CORE_ADDR is 64 bits. We
125 have to extract only the significant bits of addresses to get the
126 right address when accessing the core file BFD.
128 Assume that the address is unsigned. */
130 #define SOLIB_EXTRACT_ADDRESS(MEMBER) \
131 extract_unsigned_integer (&(MEMBER), sizeof (MEMBER))
133 /* local data declarations */
135 /* link map access functions */
138 LM_ADDR_FROM_LINK_MAP (struct so_list
*so
)
140 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
142 return (CORE_ADDR
) extract_signed_integer (so
->lm_info
->lm
143 + lmo
->l_addr_offset
,
148 HAS_LM_DYNAMIC_FROM_LINK_MAP ()
150 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
152 return (lmo
->l_ld_size
!= 0);
156 LM_DYNAMIC_FROM_LINK_MAP (struct so_list
*so
)
158 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
160 gdb_assert (lmo
->l_ld_size
!= 0);
162 return (CORE_ADDR
) extract_signed_integer (so
->lm_info
->lm
168 LM_ADDR_CHECK (struct so_list
*so
, bfd
*abfd
)
170 if (so
->lm_info
->l_addr
== (CORE_ADDR
)-1)
172 struct bfd_section
*dyninfo_sect
;
173 CORE_ADDR l_addr
, l_dynaddr
, dynaddr
, align
= 0x1000;
175 l_addr
= LM_ADDR_FROM_LINK_MAP (so
);
177 if (! abfd
|| ! HAS_LM_DYNAMIC_FROM_LINK_MAP ())
180 l_dynaddr
= LM_DYNAMIC_FROM_LINK_MAP (so
);
182 dyninfo_sect
= bfd_get_section_by_name (abfd
, ".dynamic");
183 if (dyninfo_sect
== NULL
)
186 dynaddr
= bfd_section_vma (abfd
, dyninfo_sect
);
188 if (dynaddr
+ l_addr
!= l_dynaddr
)
190 warning (_(".dynamic section for \"%s\" "
191 "is not at the expected address"), so
->so_name
);
193 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
195 Elf_Internal_Ehdr
*ehdr
= elf_tdata (abfd
)->elf_header
;
196 Elf_Internal_Phdr
*phdr
= elf_tdata (abfd
)->phdr
;
201 for (i
= 0; i
< ehdr
->e_phnum
; i
++)
202 if (phdr
[i
].p_type
== PT_LOAD
&& phdr
[i
].p_align
> align
)
203 align
= phdr
[i
].p_align
;
206 /* Turn it into a mask. */
209 /* If the changes match the alignment requirements, we
210 assume we're using a core file that was generated by the
211 same binary, just prelinked with a different base offset.
212 If it doesn't match, we may have a different binary, the
213 same binary with the dynamic table loaded at an unrelated
214 location, or anything, really. To avoid regressions,
215 don't adjust the base offset in the latter case, although
216 odds are that, if things really changed, debugging won't
218 if ((l_addr
& align
) == 0 && ((dynaddr
- l_dynaddr
) & align
) == 0)
220 l_addr
= l_dynaddr
- dynaddr
;
221 warning (_("difference appears to be caused by prelink, "
222 "adjusting expectations"));
227 so
->lm_info
->l_addr
= l_addr
;
230 return so
->lm_info
->l_addr
;
234 LM_NEXT (struct so_list
*so
)
236 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
238 /* Assume that the address is unsigned. */
239 return extract_unsigned_integer (so
->lm_info
->lm
+ lmo
->l_next_offset
,
244 LM_NAME (struct so_list
*so
)
246 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
248 /* Assume that the address is unsigned. */
249 return extract_unsigned_integer (so
->lm_info
->lm
+ lmo
->l_name_offset
,
254 IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list
*so
)
256 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
258 /* Assume that the address is unsigned. */
259 return extract_unsigned_integer (so
->lm_info
->lm
+ lmo
->l_prev_offset
,
260 lmo
->l_prev_size
) == 0;
263 static CORE_ADDR debug_base
; /* Base of dynamic linker structures */
264 static CORE_ADDR breakpoint_addr
; /* Address where end bkpt is set */
266 /* Local function prototypes */
268 static int match_main (char *);
270 static CORE_ADDR
bfd_lookup_symbol (bfd
*, char *, flagword
);
276 bfd_lookup_symbol -- lookup the value for a specific symbol
280 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname, flagword sect_flags)
284 An expensive way to lookup the value of a single symbol for
285 bfd's that are only temporary anyway. This is used by the
286 shared library support to find the address of the debugger
287 interface structures in the shared library.
289 If SECT_FLAGS is non-zero, only match symbols in sections whose
290 flags include all those in SECT_FLAGS.
292 Note that 0 is specifically allowed as an error return (no
297 bfd_lookup_symbol (bfd
*abfd
, char *symname
, flagword sect_flags
)
301 asymbol
**symbol_table
;
302 unsigned int number_of_symbols
;
304 struct cleanup
*back_to
;
305 CORE_ADDR symaddr
= 0;
307 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
309 if (storage_needed
> 0)
311 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
312 back_to
= make_cleanup (xfree
, symbol_table
);
313 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
315 for (i
= 0; i
< number_of_symbols
; i
++)
317 sym
= *symbol_table
++;
318 if (strcmp (sym
->name
, symname
) == 0
319 && (sym
->section
->flags
& sect_flags
) == sect_flags
)
321 /* Bfd symbols are section relative. */
322 symaddr
= sym
->value
+ sym
->section
->vma
;
326 do_cleanups (back_to
);
332 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
333 have to check the dynamic string table too. */
335 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
337 if (storage_needed
> 0)
339 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
340 back_to
= make_cleanup (xfree
, symbol_table
);
341 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
343 for (i
= 0; i
< number_of_symbols
; i
++)
345 sym
= *symbol_table
++;
347 if (strcmp (sym
->name
, symname
) == 0
348 && (sym
->section
->flags
& sect_flags
) == sect_flags
)
350 /* Bfd symbols are section relative. */
351 symaddr
= sym
->value
+ sym
->section
->vma
;
355 do_cleanups (back_to
);
365 elf_locate_base -- locate the base address of dynamic linker structs
366 for SVR4 elf targets.
370 CORE_ADDR elf_locate_base (void)
374 For SVR4 elf targets the address of the dynamic linker's runtime
375 structure is contained within the dynamic info section in the
376 executable file. The dynamic section is also mapped into the
377 inferior address space. Because the runtime loader fills in the
378 real address before starting the inferior, we have to read in the
379 dynamic info section from the inferior address space.
380 If there are any errors while trying to find the address, we
381 silently return 0, otherwise the found address is returned.
386 elf_locate_base (void)
388 struct bfd_section
*dyninfo_sect
;
389 int dyninfo_sect_size
;
390 CORE_ADDR dyninfo_addr
;
395 /* Find the start address of the .dynamic section. */
396 dyninfo_sect
= bfd_get_section_by_name (exec_bfd
, ".dynamic");
397 if (dyninfo_sect
== NULL
)
399 dyninfo_addr
= bfd_section_vma (exec_bfd
, dyninfo_sect
);
401 /* Read in .dynamic section, silently ignore errors. */
402 dyninfo_sect_size
= bfd_section_size (exec_bfd
, dyninfo_sect
);
403 buf
= alloca (dyninfo_sect_size
);
404 if (target_read_memory (dyninfo_addr
, buf
, dyninfo_sect_size
))
407 /* Find the DT_DEBUG entry in the the .dynamic section.
408 For mips elf we look for DT_MIPS_RLD_MAP, mips elf apparently has
409 no DT_DEBUG entries. */
411 arch_size
= bfd_get_arch_size (exec_bfd
);
412 if (arch_size
== -1) /* failure */
417 for (bufend
= buf
+ dyninfo_sect_size
;
419 buf
+= sizeof (Elf32_External_Dyn
))
421 Elf32_External_Dyn
*x_dynp
= (Elf32_External_Dyn
*) buf
;
425 dyn_tag
= bfd_h_get_32 (exec_bfd
, (bfd_byte
*) x_dynp
->d_tag
);
426 if (dyn_tag
== DT_NULL
)
428 else if (dyn_tag
== DT_DEBUG
)
430 dyn_ptr
= bfd_h_get_32 (exec_bfd
,
431 (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
434 else if (dyn_tag
== DT_MIPS_RLD_MAP
)
437 int pbuf_size
= TARGET_PTR_BIT
/ HOST_CHAR_BIT
;
439 pbuf
= alloca (pbuf_size
);
440 /* DT_MIPS_RLD_MAP contains a pointer to the address
441 of the dynamic link structure. */
442 dyn_ptr
= bfd_h_get_32 (exec_bfd
,
443 (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
444 if (target_read_memory (dyn_ptr
, pbuf
, pbuf_size
))
446 return extract_unsigned_integer (pbuf
, pbuf_size
);
450 else /* 64-bit elf */
452 for (bufend
= buf
+ dyninfo_sect_size
;
454 buf
+= sizeof (Elf64_External_Dyn
))
456 Elf64_External_Dyn
*x_dynp
= (Elf64_External_Dyn
*) buf
;
460 dyn_tag
= bfd_h_get_64 (exec_bfd
, (bfd_byte
*) x_dynp
->d_tag
);
461 if (dyn_tag
== DT_NULL
)
463 else if (dyn_tag
== DT_DEBUG
)
465 dyn_ptr
= bfd_h_get_64 (exec_bfd
,
466 (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
469 else if (dyn_tag
== DT_MIPS_RLD_MAP
)
472 int pbuf_size
= TARGET_PTR_BIT
/ HOST_CHAR_BIT
;
474 pbuf
= alloca (pbuf_size
);
475 /* DT_MIPS_RLD_MAP contains a pointer to the address
476 of the dynamic link structure. */
477 dyn_ptr
= bfd_h_get_64 (exec_bfd
,
478 (bfd_byte
*) x_dynp
->d_un
.d_ptr
);
479 if (target_read_memory (dyn_ptr
, pbuf
, pbuf_size
))
481 return extract_unsigned_integer (pbuf
, pbuf_size
);
486 /* DT_DEBUG entry not found. */
494 locate_base -- locate the base address of dynamic linker structs
498 CORE_ADDR locate_base (void)
502 For both the SunOS and SVR4 shared library implementations, if the
503 inferior executable has been linked dynamically, there is a single
504 address somewhere in the inferior's data space which is the key to
505 locating all of the dynamic linker's runtime structures. This
506 address is the value of the debug base symbol. The job of this
507 function is to find and return that address, or to return 0 if there
508 is no such address (the executable is statically linked for example).
510 For SunOS, the job is almost trivial, since the dynamic linker and
511 all of it's structures are statically linked to the executable at
512 link time. Thus the symbol for the address we are looking for has
513 already been added to the minimal symbol table for the executable's
514 objfile at the time the symbol file's symbols were read, and all we
515 have to do is look it up there. Note that we explicitly do NOT want
516 to find the copies in the shared library.
518 The SVR4 version is a bit more complicated because the address
519 is contained somewhere in the dynamic info section. We have to go
520 to a lot more work to discover the address of the debug base symbol.
521 Because of this complexity, we cache the value we find and return that
522 value on subsequent invocations. Note there is no copy in the
523 executable symbol tables.
530 /* Check to see if we have a currently valid address, and if so, avoid
531 doing all this work again and just return the cached address. If
532 we have no cached address, try to locate it in the dynamic info
533 section for ELF executables. There's no point in doing any of this
534 though if we don't have some link map offsets to work with. */
536 if (debug_base
== 0 && svr4_have_link_map_offsets ())
539 && bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
540 debug_base
= elf_locate_base ();
545 /* Find the first element in the inferior's dynamic link map, and
546 return its address in the inferior.
548 FIXME: Perhaps we should validate the info somehow, perhaps by
549 checking r_version for a known version number, or r_state for
553 solib_svr4_r_map (void)
555 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
557 return read_memory_typed_address (debug_base
+ lmo
->r_map_offset
,
558 builtin_type_void_data_ptr
);
561 /* Find the link map for the dynamic linker (if it is not in the
562 normal list of loaded shared objects). */
565 solib_svr4_r_ldsomap (void)
567 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
570 /* Check version, and return zero if `struct r_debug' doesn't have
571 the r_ldsomap member. */
572 version
= read_memory_unsigned_integer (debug_base
+ lmo
->r_version_offset
,
573 lmo
->r_version_size
);
574 if (version
< 2 || lmo
->r_ldsomap_offset
== -1)
577 return read_memory_typed_address (debug_base
+ lmo
->r_ldsomap_offset
,
578 builtin_type_void_data_ptr
);
585 open_symbol_file_object
589 void open_symbol_file_object (void *from_tty)
593 If no open symbol file, attempt to locate and open the main symbol
594 file. On SVR4 systems, this is the first link map entry. If its
595 name is here, we can open it. Useful when attaching to a process
596 without first loading its symbol file.
598 If FROM_TTYP dereferences to a non-zero integer, allow messages to
599 be printed. This parameter is a pointer rather than an int because
600 open_symbol_file_object() is called via catch_errors() and
601 catch_errors() requires a pointer argument. */
604 open_symbol_file_object (void *from_ttyp
)
606 CORE_ADDR lm
, l_name
;
609 int from_tty
= *(int *)from_ttyp
;
610 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
611 gdb_byte
*l_name_buf
= xmalloc (lmo
->l_name_size
);
612 struct cleanup
*cleanups
= make_cleanup (xfree
, l_name_buf
);
615 if (!query ("Attempt to reload symbols from process? "))
618 if ((debug_base
= locate_base ()) == 0)
619 return 0; /* failed somehow... */
621 /* First link map member should be the executable. */
622 lm
= solib_svr4_r_map ();
624 return 0; /* failed somehow... */
626 /* Read address of name from target memory to GDB. */
627 read_memory (lm
+ lmo
->l_name_offset
, l_name_buf
, lmo
->l_name_size
);
629 /* Convert the address to host format. Assume that the address is
631 l_name
= extract_unsigned_integer (l_name_buf
, lmo
->l_name_size
);
633 /* Free l_name_buf. */
634 do_cleanups (cleanups
);
637 return 0; /* No filename. */
639 /* Now fetch the filename from target memory. */
640 target_read_string (l_name
, &filename
, SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
644 warning (_("failed to read exec filename from attached file: %s"),
645 safe_strerror (errcode
));
649 make_cleanup (xfree
, filename
);
650 /* Have a pathname: read the symbol file. */
651 symbol_file_add_main (filename
, from_tty
);
658 current_sos -- build a list of currently loaded shared objects
662 struct so_list *current_sos ()
666 Build a list of `struct so_list' objects describing the shared
667 objects currently loaded in the inferior. This list does not
668 include an entry for the main executable file.
670 Note that we only gather information directly available from the
671 inferior --- we don't examine any of the shared library files
672 themselves. The declaration of `struct so_list' says which fields
673 we provide values for. */
675 static struct so_list
*
676 svr4_current_sos (void)
679 struct so_list
*head
= 0;
680 struct so_list
**link_ptr
= &head
;
681 CORE_ADDR ldsomap
= 0;
683 /* Make sure we've looked up the inferior's dynamic linker's base
687 debug_base
= locate_base ();
689 /* If we can't find the dynamic linker's base structure, this
690 must not be a dynamically linked executable. Hmm. */
695 /* Walk the inferior's link map list, and build our list of
696 `struct so_list' nodes. */
697 lm
= solib_svr4_r_map ();
700 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
701 struct so_list
*new = XZALLOC (struct so_list
);
702 struct cleanup
*old_chain
= make_cleanup (xfree
, new);
704 new->lm_info
= xmalloc (sizeof (struct lm_info
));
705 make_cleanup (xfree
, new->lm_info
);
707 new->lm_info
->lm
= xzalloc (lmo
->link_map_size
);
708 make_cleanup (xfree
, new->lm_info
->lm
);
710 read_memory (lm
, new->lm_info
->lm
, lmo
->link_map_size
);
714 /* For SVR4 versions, the first entry in the link map is for the
715 inferior executable, so we must ignore it. For some versions of
716 SVR4, it has no name. For others (Solaris 2.3 for example), it
717 does have a name, so we can no longer use a missing name to
718 decide when to ignore it. */
719 if (IGNORE_FIRST_LINK_MAP_ENTRY (new) && ldsomap
== 0)
726 /* Extract this shared object's name. */
727 target_read_string (LM_NAME (new), &buffer
,
728 SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
730 warning (_("Can't read pathname for load map: %s."),
731 safe_strerror (errcode
));
734 strncpy (new->so_name
, buffer
, SO_NAME_MAX_PATH_SIZE
- 1);
735 new->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
737 strcpy (new->so_original_name
, new->so_name
);
740 /* If this entry has no name, or its name matches the name
741 for the main executable, don't include it in the list. */
742 if (! new->so_name
[0]
743 || match_main (new->so_name
))
747 new->lm_info
->l_addr
= (CORE_ADDR
)-1;
751 link_ptr
= &new->next
;
755 /* On Solaris, the dynamic linker is not in the normal list of
756 shared objects, so make sure we pick it up too. Having
757 symbol information for the dynamic linker is quite crucial
758 for skipping dynamic linker resolver code. */
759 if (lm
== 0 && ldsomap
== 0)
760 lm
= ldsomap
= solib_svr4_r_ldsomap ();
762 discard_cleanups (old_chain
);
768 /* Get the address of the link_map for a given OBJFILE. Loop through
769 the link maps, and return the address of the one corresponding to
770 the given objfile. Note that this function takes into account that
771 objfile can be the main executable, not just a shared library. The
772 main executable has always an empty name field in the linkmap. */
775 svr4_fetch_objfile_link_map (struct objfile
*objfile
)
779 if ((debug_base
= locate_base ()) == 0)
780 return 0; /* failed somehow... */
782 /* Position ourselves on the first link map. */
783 lm
= solib_svr4_r_map ();
786 /* Get info on the layout of the r_debug and link_map structures. */
787 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
790 struct lm_info objfile_lm_info
;
791 struct cleanup
*old_chain
;
792 CORE_ADDR name_address
;
793 gdb_byte
*l_name_buf
= xmalloc (lmo
->l_name_size
);
794 old_chain
= make_cleanup (xfree
, l_name_buf
);
796 /* Set up the buffer to contain the portion of the link_map
797 structure that gdb cares about. Note that this is not the
798 whole link_map structure. */
799 objfile_lm_info
.lm
= xzalloc (lmo
->link_map_size
);
800 make_cleanup (xfree
, objfile_lm_info
.lm
);
802 /* Read the link map into our internal structure. */
803 read_memory (lm
, objfile_lm_info
.lm
, lmo
->link_map_size
);
805 /* Read address of name from target memory to GDB. */
806 read_memory (lm
+ lmo
->l_name_offset
, l_name_buf
, lmo
->l_name_size
);
808 /* Extract this object's name. Assume that the address is
810 name_address
= extract_unsigned_integer (l_name_buf
, lmo
->l_name_size
);
811 target_read_string (name_address
, &buffer
,
812 SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
813 make_cleanup (xfree
, buffer
);
815 warning (_("Can't read pathname for load map: %s."),
816 safe_strerror (errcode
));
819 /* Is this the linkmap for the file we want? */
820 /* If the file is not a shared library and has no name,
821 we are sure it is the main executable, so we return that. */
822 if ((buffer
&& strcmp (buffer
, objfile
->name
) == 0)
823 || (!(objfile
->flags
& OBJF_SHARED
) && (strcmp (buffer
, "") == 0)))
825 do_cleanups (old_chain
);
829 /* Not the file we wanted, continue checking. Assume that the
830 address is unsigned. */
831 lm
= extract_unsigned_integer (objfile_lm_info
.lm
+ lmo
->l_next_offset
,
833 do_cleanups (old_chain
);
838 /* On some systems, the only way to recognize the link map entry for
839 the main executable file is by looking at its name. Return
840 non-zero iff SONAME matches one of the known main executable names. */
843 match_main (char *soname
)
847 for (mainp
= main_name_list
; *mainp
!= NULL
; mainp
++)
849 if (strcmp (soname
, *mainp
) == 0)
856 /* Return 1 if PC lies in the dynamic symbol resolution code of the
857 SVR4 run time loader. */
858 static CORE_ADDR interp_text_sect_low
;
859 static CORE_ADDR interp_text_sect_high
;
860 static CORE_ADDR interp_plt_sect_low
;
861 static CORE_ADDR interp_plt_sect_high
;
864 svr4_in_dynsym_resolve_code (CORE_ADDR pc
)
866 return ((pc
>= interp_text_sect_low
&& pc
< interp_text_sect_high
)
867 || (pc
>= interp_plt_sect_low
&& pc
< interp_plt_sect_high
)
868 || in_plt_section (pc
, NULL
));
871 /* Given an executable's ABFD and target, compute the entry-point
875 exec_entry_point (struct bfd
*abfd
, struct target_ops
*targ
)
877 /* KevinB wrote ... for most targets, the address returned by
878 bfd_get_start_address() is the entry point for the start
879 function. But, for some targets, bfd_get_start_address() returns
880 the address of a function descriptor from which the entry point
881 address may be extracted. This address is extracted by
882 gdbarch_convert_from_func_ptr_addr(). The method
883 gdbarch_convert_from_func_ptr_addr() is the merely the identify
884 function for targets which don't use function descriptors. */
885 return gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
886 bfd_get_start_address (abfd
),
894 enable_break -- arrange for dynamic linker to hit breakpoint
898 int enable_break (void)
902 Both the SunOS and the SVR4 dynamic linkers have, as part of their
903 debugger interface, support for arranging for the inferior to hit
904 a breakpoint after mapping in the shared libraries. This function
905 enables that breakpoint.
907 For SunOS, there is a special flag location (in_debugger) which we
908 set to 1. When the dynamic linker sees this flag set, it will set
909 a breakpoint at a location known only to itself, after saving the
910 original contents of that place and the breakpoint address itself,
911 in it's own internal structures. When we resume the inferior, it
912 will eventually take a SIGTRAP when it runs into the breakpoint.
913 We handle this (in a different place) by restoring the contents of
914 the breakpointed location (which is only known after it stops),
915 chasing around to locate the shared libraries that have been
916 loaded, then resuming.
918 For SVR4, the debugger interface structure contains a member (r_brk)
919 which is statically initialized at the time the shared library is
920 built, to the offset of a function (_r_debug_state) which is guaran-
921 teed to be called once before mapping in a library, and again when
922 the mapping is complete. At the time we are examining this member,
923 it contains only the unrelocated offset of the function, so we have
924 to do our own relocation. Later, when the dynamic linker actually
925 runs, it relocates r_brk to be the actual address of _r_debug_state().
927 The debugger interface structure also contains an enumeration which
928 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
929 depending upon whether or not the library is being mapped or unmapped,
930 and then set to RT_CONSISTENT after the library is mapped/unmapped.
938 #ifdef BKPT_AT_SYMBOL
940 struct minimal_symbol
*msymbol
;
942 asection
*interp_sect
;
944 /* First, remove all the solib event breakpoints. Their addresses
945 may have changed since the last time we ran the program. */
946 remove_solib_event_breakpoints ();
948 interp_text_sect_low
= interp_text_sect_high
= 0;
949 interp_plt_sect_low
= interp_plt_sect_high
= 0;
951 /* Find the .interp section; if not found, warn the user and drop
952 into the old breakpoint at symbol code. */
953 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
956 unsigned int interp_sect_size
;
958 CORE_ADDR load_addr
= 0;
959 int load_addr_found
= 0;
962 struct target_ops
*tmp_bfd_target
;
964 char *tmp_pathname
= NULL
;
965 CORE_ADDR sym_addr
= 0;
967 /* Read the contents of the .interp section into a local buffer;
968 the contents specify the dynamic linker this program uses. */
969 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
970 buf
= alloca (interp_sect_size
);
971 bfd_get_section_contents (exec_bfd
, interp_sect
,
972 buf
, 0, interp_sect_size
);
974 /* Now we need to figure out where the dynamic linker was
975 loaded so that we can load its symbols and place a breakpoint
976 in the dynamic linker itself.
978 This address is stored on the stack. However, I've been unable
979 to find any magic formula to find it for Solaris (appears to
980 be trivial on GNU/Linux). Therefore, we have to try an alternate
981 mechanism to find the dynamic linker's base address. */
983 tmp_fd
= solib_open (buf
, &tmp_pathname
);
985 tmp_bfd
= bfd_fopen (tmp_pathname
, gnutarget
, FOPEN_RB
, tmp_fd
);
990 /* Make sure the dynamic linker's really a useful object. */
991 if (!bfd_check_format (tmp_bfd
, bfd_object
))
993 warning (_("Unable to grok dynamic linker %s as an object file"), buf
);
998 /* Now convert the TMP_BFD into a target. That way target, as
999 well as BFD operations can be used. Note that closing the
1000 target will also close the underlying bfd. */
1001 tmp_bfd_target
= target_bfd_reopen (tmp_bfd
);
1003 /* On a running target, we can get the dynamic linker's base
1004 address from the shared library table. */
1005 solib_add (NULL
, 0, NULL
, auto_solib_add
);
1006 so
= master_so_list ();
1009 if (strcmp (buf
, so
->so_original_name
) == 0)
1011 load_addr_found
= 1;
1012 load_addr
= LM_ADDR_CHECK (so
, tmp_bfd
);
1018 /* Otherwise we find the dynamic linker's base address by examining
1019 the current pc (which should point at the entry point for the
1020 dynamic linker) and subtracting the offset of the entry point. */
1021 if (!load_addr_found
)
1022 load_addr
= (read_pc ()
1023 - exec_entry_point (tmp_bfd
, tmp_bfd_target
));
1025 /* Record the relocated start and end address of the dynamic linker
1026 text and plt section for svr4_in_dynsym_resolve_code. */
1027 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
1030 interp_text_sect_low
=
1031 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1032 interp_text_sect_high
=
1033 interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1035 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
1038 interp_plt_sect_low
=
1039 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1040 interp_plt_sect_high
=
1041 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1044 /* Now try to set a breakpoint in the dynamic linker. */
1045 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1047 /* On ABI's that use function descriptors, there are usually
1048 two linker symbols associated with each C function: one
1049 pointing at the actual entry point of the machine code,
1050 and one pointing at the function's descriptor. The
1051 latter symbol has the same name as the C function.
1053 What we're looking for here is the machine code entry
1054 point, so we are only interested in symbols in code
1056 sym_addr
= bfd_lookup_symbol (tmp_bfd
, *bkpt_namep
, SEC_CODE
);
1061 /* We're done with both the temporary bfd and target. Remember,
1062 closing the target closes the underlying bfd. */
1063 target_close (tmp_bfd_target
, 0);
1067 create_solib_event_breakpoint (load_addr
+ sym_addr
);
1071 /* For whatever reason we couldn't set a breakpoint in the dynamic
1072 linker. Warn and drop into the old code. */
1074 warning (_("Unable to find dynamic linker breakpoint function.\nGDB will be unable to debug shared library initializers\nand track explicitly loaded dynamic code."));
1077 /* Scan through the list of symbols, trying to look up the symbol and
1078 set a breakpoint there. Terminate loop when we/if we succeed. */
1080 breakpoint_addr
= 0;
1081 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1083 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
1084 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
1086 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol
));
1091 /* Nothing good happened. */
1094 #endif /* BKPT_AT_SYMBOL */
1103 special_symbol_handling -- additional shared library symbol handling
1107 void special_symbol_handling ()
1111 Once the symbols from a shared object have been loaded in the usual
1112 way, we are called to do any system specific symbol handling that
1115 For SunOS4, this consisted of grunging around in the dynamic
1116 linkers structures to find symbol definitions for "common" symbols
1117 and adding them to the minimal symbol table for the runtime common
1120 However, for SVR4, there's nothing to do.
1125 svr4_special_symbol_handling (void)
1129 /* Relocate the main executable. This function should be called upon
1130 stopping the inferior process at the entry point to the program.
1131 The entry point from BFD is compared to the PC and if they are
1132 different, the main executable is relocated by the proper amount.
1134 As written it will only attempt to relocate executables which
1135 lack interpreter sections. It seems likely that only dynamic
1136 linker executables will get relocated, though it should work
1137 properly for a position-independent static executable as well. */
1140 svr4_relocate_main_executable (void)
1142 asection
*interp_sect
;
1143 CORE_ADDR pc
= read_pc ();
1145 /* Decide if the objfile needs to be relocated. As indicated above,
1146 we will only be here when execution is stopped at the beginning
1147 of the program. Relocation is necessary if the address at which
1148 we are presently stopped differs from the start address stored in
1149 the executable AND there's no interpreter section. The condition
1150 regarding the interpreter section is very important because if
1151 there *is* an interpreter section, execution will begin there
1152 instead. When there is an interpreter section, the start address
1153 is (presumably) used by the interpreter at some point to start
1154 execution of the program.
1156 If there is an interpreter, it is normal for it to be set to an
1157 arbitrary address at the outset. The job of finding it is
1158 handled in enable_break().
1160 So, to summarize, relocations are necessary when there is no
1161 interpreter section and the start address obtained from the
1162 executable is different from the address at which GDB is
1165 [ The astute reader will note that we also test to make sure that
1166 the executable in question has the DYNAMIC flag set. It is my
1167 opinion that this test is unnecessary (undesirable even). It
1168 was added to avoid inadvertent relocation of an executable
1169 whose e_type member in the ELF header is not ET_DYN. There may
1170 be a time in the future when it is desirable to do relocations
1171 on other types of files as well in which case this condition
1172 should either be removed or modified to accomodate the new file
1173 type. (E.g, an ET_EXEC executable which has been built to be
1174 position-independent could safely be relocated by the OS if
1175 desired. It is true that this violates the ABI, but the ABI
1176 has been known to be bent from time to time.) - Kevin, Nov 2000. ]
1179 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
1180 if (interp_sect
== NULL
1181 && (bfd_get_file_flags (exec_bfd
) & DYNAMIC
) != 0
1182 && (exec_entry_point (exec_bfd
, &exec_ops
) != pc
))
1184 struct cleanup
*old_chain
;
1185 struct section_offsets
*new_offsets
;
1187 CORE_ADDR displacement
;
1189 /* It is necessary to relocate the objfile. The amount to
1190 relocate by is simply the address at which we are stopped
1191 minus the starting address from the executable.
1193 We relocate all of the sections by the same amount. This
1194 behavior is mandated by recent editions of the System V ABI.
1195 According to the System V Application Binary Interface,
1196 Edition 4.1, page 5-5:
1198 ... Though the system chooses virtual addresses for
1199 individual processes, it maintains the segments' relative
1200 positions. Because position-independent code uses relative
1201 addressesing between segments, the difference between
1202 virtual addresses in memory must match the difference
1203 between virtual addresses in the file. The difference
1204 between the virtual address of any segment in memory and
1205 the corresponding virtual address in the file is thus a
1206 single constant value for any one executable or shared
1207 object in a given process. This difference is the base
1208 address. One use of the base address is to relocate the
1209 memory image of the program during dynamic linking.
1211 The same language also appears in Edition 4.0 of the System V
1212 ABI and is left unspecified in some of the earlier editions. */
1214 displacement
= pc
- exec_entry_point (exec_bfd
, &exec_ops
);
1217 new_offsets
= xcalloc (symfile_objfile
->num_sections
,
1218 sizeof (struct section_offsets
));
1219 old_chain
= make_cleanup (xfree
, new_offsets
);
1221 for (i
= 0; i
< symfile_objfile
->num_sections
; i
++)
1223 if (displacement
!= ANOFFSET (symfile_objfile
->section_offsets
, i
))
1225 new_offsets
->offsets
[i
] = displacement
;
1229 objfile_relocate (symfile_objfile
, new_offsets
);
1231 do_cleanups (old_chain
);
1239 svr4_solib_create_inferior_hook -- shared library startup support
1243 void svr4_solib_create_inferior_hook ()
1247 When gdb starts up the inferior, it nurses it along (through the
1248 shell) until it is ready to execute it's first instruction. At this
1249 point, this function gets called via expansion of the macro
1250 SOLIB_CREATE_INFERIOR_HOOK.
1252 For SunOS executables, this first instruction is typically the
1253 one at "_start", or a similar text label, regardless of whether
1254 the executable is statically or dynamically linked. The runtime
1255 startup code takes care of dynamically linking in any shared
1256 libraries, once gdb allows the inferior to continue.
1258 For SVR4 executables, this first instruction is either the first
1259 instruction in the dynamic linker (for dynamically linked
1260 executables) or the instruction at "start" for statically linked
1261 executables. For dynamically linked executables, the system
1262 first exec's /lib/libc.so.N, which contains the dynamic linker,
1263 and starts it running. The dynamic linker maps in any needed
1264 shared libraries, maps in the actual user executable, and then
1265 jumps to "start" in the user executable.
1267 For both SunOS shared libraries, and SVR4 shared libraries, we
1268 can arrange to cooperate with the dynamic linker to discover the
1269 names of shared libraries that are dynamically linked, and the
1270 base addresses to which they are linked.
1272 This function is responsible for discovering those names and
1273 addresses, and saving sufficient information about them to allow
1274 their symbols to be read at a later time.
1278 Between enable_break() and disable_break(), this code does not
1279 properly handle hitting breakpoints which the user might have
1280 set in the startup code or in the dynamic linker itself. Proper
1281 handling will probably have to wait until the implementation is
1282 changed to use the "breakpoint handler function" method.
1284 Also, what if child has exit()ed? Must exit loop somehow.
1288 svr4_solib_create_inferior_hook (void)
1290 /* Relocate the main executable if necessary. */
1291 svr4_relocate_main_executable ();
1293 if (!svr4_have_link_map_offsets ())
1295 warning (_("no shared library support for this OS / ABI"));
1300 if (!enable_break ())
1302 warning (_("shared library handler failed to enable breakpoint"));
1306 #if defined(_SCO_DS)
1307 /* SCO needs the loop below, other systems should be using the
1308 special shared library breakpoints and the shared library breakpoint
1311 Now run the target. It will eventually hit the breakpoint, at
1312 which point all of the libraries will have been mapped in and we
1313 can go groveling around in the dynamic linker structures to find
1314 out what we need to know about them. */
1316 clear_proceed_status ();
1317 stop_soon
= STOP_QUIETLY
;
1318 stop_signal
= TARGET_SIGNAL_0
;
1321 target_resume (pid_to_ptid (-1), 0, stop_signal
);
1322 wait_for_inferior ();
1324 while (stop_signal
!= TARGET_SIGNAL_TRAP
);
1325 stop_soon
= NO_STOP_QUIETLY
;
1326 #endif /* defined(_SCO_DS) */
1330 svr4_clear_solib (void)
1336 svr4_free_so (struct so_list
*so
)
1338 xfree (so
->lm_info
->lm
);
1339 xfree (so
->lm_info
);
1343 /* Clear any bits of ADDR that wouldn't fit in a target-format
1344 data pointer. "Data pointer" here refers to whatever sort of
1345 address the dynamic linker uses to manage its sections. At the
1346 moment, we don't support shared libraries on any processors where
1347 code and data pointers are different sizes.
1349 This isn't really the right solution. What we really need here is
1350 a way to do arithmetic on CORE_ADDR values that respects the
1351 natural pointer/address correspondence. (For example, on the MIPS,
1352 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
1353 sign-extend the value. There, simply truncating the bits above
1354 TARGET_PTR_BIT, as we do below, is no good.) This should probably
1355 be a new gdbarch method or something. */
1357 svr4_truncate_ptr (CORE_ADDR addr
)
1359 if (TARGET_PTR_BIT
== sizeof (CORE_ADDR
) * 8)
1360 /* We don't need to truncate anything, and the bit twiddling below
1361 will fail due to overflow problems. */
1364 return addr
& (((CORE_ADDR
) 1 << TARGET_PTR_BIT
) - 1);
1369 svr4_relocate_section_addresses (struct so_list
*so
,
1370 struct section_table
*sec
)
1372 sec
->addr
= svr4_truncate_ptr (sec
->addr
+ LM_ADDR_CHECK (so
,
1374 sec
->endaddr
= svr4_truncate_ptr (sec
->endaddr
+ LM_ADDR_CHECK (so
,
1379 /* Architecture-specific operations. */
1381 /* Per-architecture data key. */
1382 static struct gdbarch_data
*solib_svr4_data
;
1384 struct solib_svr4_ops
1386 /* Return a description of the layout of `struct link_map'. */
1387 struct link_map_offsets
*(*fetch_link_map_offsets
)(void);
1390 /* Return a default for the architecture-specific operations. */
1393 solib_svr4_init (struct obstack
*obstack
)
1395 struct solib_svr4_ops
*ops
;
1397 ops
= OBSTACK_ZALLOC (obstack
, struct solib_svr4_ops
);
1398 ops
->fetch_link_map_offsets
= legacy_svr4_fetch_link_map_offsets_hook
;
1402 /* Set the architecture-specific `struct link_map_offsets' fetcher for
1406 set_solib_svr4_fetch_link_map_offsets (struct gdbarch
*gdbarch
,
1407 struct link_map_offsets
*(*flmo
) (void))
1409 struct solib_svr4_ops
*ops
= gdbarch_data (gdbarch
, solib_svr4_data
);
1411 ops
->fetch_link_map_offsets
= flmo
;
1414 /* Fetch a link_map_offsets structure using the architecture-specific
1415 `struct link_map_offsets' fetcher. */
1417 static struct link_map_offsets
*
1418 svr4_fetch_link_map_offsets (void)
1420 struct solib_svr4_ops
*ops
= gdbarch_data (current_gdbarch
, solib_svr4_data
);
1422 gdb_assert (ops
->fetch_link_map_offsets
);
1423 return ops
->fetch_link_map_offsets ();
1426 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
1429 svr4_have_link_map_offsets (void)
1431 struct solib_svr4_ops
*ops
= gdbarch_data (current_gdbarch
, solib_svr4_data
);
1432 return (ops
->fetch_link_map_offsets
!= NULL
);
1436 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
1437 `struct r_debug' and a `struct link_map' that are binary compatible
1438 with the origional SVR4 implementation. */
1440 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
1441 for an ILP32 SVR4 system. */
1443 struct link_map_offsets
*
1444 svr4_ilp32_fetch_link_map_offsets (void)
1446 static struct link_map_offsets lmo
;
1447 static struct link_map_offsets
*lmp
= NULL
;
1453 lmo
.r_version_offset
= 0;
1454 lmo
.r_version_size
= 4;
1455 lmo
.r_map_offset
= 4;
1456 lmo
.r_ldsomap_offset
= 20;
1458 /* Everything we need is in the first 20 bytes. */
1459 lmo
.link_map_size
= 20;
1460 lmo
.l_addr_offset
= 0;
1461 lmo
.l_addr_size
= 4;
1462 lmo
.l_name_offset
= 4;
1463 lmo
.l_name_size
= 4;
1464 lmo
.l_ld_offset
= 8;
1466 lmo
.l_next_offset
= 12;
1467 lmo
.l_next_size
= 4;
1468 lmo
.l_prev_offset
= 16;
1469 lmo
.l_prev_size
= 4;
1475 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
1476 for an LP64 SVR4 system. */
1478 struct link_map_offsets
*
1479 svr4_lp64_fetch_link_map_offsets (void)
1481 static struct link_map_offsets lmo
;
1482 static struct link_map_offsets
*lmp
= NULL
;
1488 lmo
.r_version_offset
= 0;
1489 lmo
.r_version_size
= 4;
1490 lmo
.r_map_offset
= 8;
1491 lmo
.r_ldsomap_offset
= 40;
1493 /* Everything we need is in the first 40 bytes. */
1494 lmo
.link_map_size
= 40;
1495 lmo
.l_addr_offset
= 0;
1496 lmo
.l_addr_size
= 8;
1497 lmo
.l_name_offset
= 8;
1498 lmo
.l_name_size
= 8;
1499 lmo
.l_ld_offset
= 16;
1501 lmo
.l_next_offset
= 24;
1502 lmo
.l_next_size
= 8;
1503 lmo
.l_prev_offset
= 32;
1504 lmo
.l_prev_size
= 8;
1511 static struct target_so_ops svr4_so_ops
;
1513 extern initialize_file_ftype _initialize_svr4_solib
; /* -Wmissing-prototypes */
1516 _initialize_svr4_solib (void)
1518 solib_svr4_data
= gdbarch_data_register_pre_init (solib_svr4_init
);
1520 svr4_so_ops
.relocate_section_addresses
= svr4_relocate_section_addresses
;
1521 svr4_so_ops
.free_so
= svr4_free_so
;
1522 svr4_so_ops
.clear_solib
= svr4_clear_solib
;
1523 svr4_so_ops
.solib_create_inferior_hook
= svr4_solib_create_inferior_hook
;
1524 svr4_so_ops
.special_symbol_handling
= svr4_special_symbol_handling
;
1525 svr4_so_ops
.current_sos
= svr4_current_sos
;
1526 svr4_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
1527 svr4_so_ops
.in_dynsym_resolve_code
= svr4_in_dynsym_resolve_code
;
1529 /* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */
1530 current_target_so_ops
= &svr4_so_ops
;