1 /* Handle SVR4 shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
4 2001, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "elf/external.h"
24 #include "elf/common.h"
35 #include "gdb_assert.h"
39 #include "solib-svr4.h"
41 #include "bfd-target.h"
46 static struct link_map_offsets
*svr4_fetch_link_map_offsets (void);
47 static int svr4_have_link_map_offsets (void);
49 /* Link map info to include in an allocated so_list entry */
53 /* Pointer to copy of link map from inferior. The type is char *
54 rather than void *, so that we may use byte offsets to find the
55 various fields without the need for a cast. */
58 /* Amount by which addresses in the binary should be relocated to
59 match the inferior. This could most often be taken directly
60 from lm, but when prelinking is involved and the prelink base
61 address changes, we may need a different offset, we want to
62 warn about the difference and compute it only once. */
66 /* On SVR4 systems, a list of symbols in the dynamic linker where
67 GDB can try to place a breakpoint to monitor shared library
70 If none of these symbols are found, or other errors occur, then
71 SVR4 systems will fall back to using a symbol as the "startup
72 mapping complete" breakpoint address. */
74 static char *solib_break_names
[] =
85 #define BKPT_AT_SYMBOL 1
87 #if defined (BKPT_AT_SYMBOL)
88 static char *bkpt_names
[] =
90 #ifdef SOLIB_BKPT_NAME
91 SOLIB_BKPT_NAME
, /* Prefer configured name if it exists. */
100 static char *main_name_list
[] =
106 /* Return non-zero if GDB_SO_NAME and INFERIOR_SO_NAME represent
107 the same shared library. */
110 svr4_same_1 (const char *gdb_so_name
, const char *inferior_so_name
)
112 if (strcmp (gdb_so_name
, inferior_so_name
) == 0)
115 /* On Solaris, when starting inferior we think that dynamic linker is
116 /usr/lib/ld.so.1, but later on, the table of loaded shared libraries
117 contains /lib/ld.so.1. Sometimes one file is a link to another, but
118 sometimes they have identical content, but are not linked to each
119 other. We don't restrict this check for Solaris, but the chances
120 of running into this situation elsewhere are very low. */
121 if (strcmp (gdb_so_name
, "/usr/lib/ld.so.1") == 0
122 && strcmp (inferior_so_name
, "/lib/ld.so.1") == 0)
125 /* Similarly, we observed the same issue with sparc64, but with
126 different locations. */
127 if (strcmp (gdb_so_name
, "/usr/lib/sparcv9/ld.so.1") == 0
128 && strcmp (inferior_so_name
, "/lib/sparcv9/ld.so.1") == 0)
135 svr4_same (struct so_list
*gdb
, struct so_list
*inferior
)
137 return (svr4_same_1 (gdb
->so_original_name
, inferior
->so_original_name
));
140 /* link map access functions */
143 LM_ADDR_FROM_LINK_MAP (struct so_list
*so
)
145 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
147 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_addr_offset
,
148 builtin_type_void_data_ptr
);
152 HAS_LM_DYNAMIC_FROM_LINK_MAP ()
154 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
156 return lmo
->l_ld_offset
>= 0;
160 LM_DYNAMIC_FROM_LINK_MAP (struct so_list
*so
)
162 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
164 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_ld_offset
,
165 builtin_type_void_data_ptr
);
169 LM_ADDR_CHECK (struct so_list
*so
, bfd
*abfd
)
171 if (so
->lm_info
->l_addr
== (CORE_ADDR
)-1)
173 struct bfd_section
*dyninfo_sect
;
174 CORE_ADDR l_addr
, l_dynaddr
, dynaddr
, align
= 0x1000;
176 l_addr
= LM_ADDR_FROM_LINK_MAP (so
);
178 if (! abfd
|| ! HAS_LM_DYNAMIC_FROM_LINK_MAP ())
181 l_dynaddr
= LM_DYNAMIC_FROM_LINK_MAP (so
);
183 dyninfo_sect
= bfd_get_section_by_name (abfd
, ".dynamic");
184 if (dyninfo_sect
== NULL
)
187 dynaddr
= bfd_section_vma (abfd
, dyninfo_sect
);
189 if (dynaddr
+ l_addr
!= l_dynaddr
)
191 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
193 Elf_Internal_Ehdr
*ehdr
= elf_tdata (abfd
)->elf_header
;
194 Elf_Internal_Phdr
*phdr
= elf_tdata (abfd
)->phdr
;
199 for (i
= 0; i
< ehdr
->e_phnum
; i
++)
200 if (phdr
[i
].p_type
== PT_LOAD
&& phdr
[i
].p_align
> align
)
201 align
= phdr
[i
].p_align
;
204 /* Turn it into a mask. */
207 /* If the changes match the alignment requirements, we
208 assume we're using a core file that was generated by the
209 same binary, just prelinked with a different base offset.
210 If it doesn't match, we may have a different binary, the
211 same binary with the dynamic table loaded at an unrelated
212 location, or anything, really. To avoid regressions,
213 don't adjust the base offset in the latter case, although
214 odds are that, if things really changed, debugging won't
216 if ((l_addr
& align
) == ((l_dynaddr
- dynaddr
) & align
))
218 l_addr
= l_dynaddr
- dynaddr
;
220 warning (_(".dynamic section for \"%s\" "
221 "is not at the expected address"), so
->so_name
);
222 warning (_("difference appears to be caused by prelink, "
223 "adjusting expectations"));
226 warning (_(".dynamic section for \"%s\" "
227 "is not at the expected address "
228 "(wrong library or version mismatch?)"), so
->so_name
);
232 so
->lm_info
->l_addr
= l_addr
;
235 return so
->lm_info
->l_addr
;
239 LM_NEXT (struct so_list
*so
)
241 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
243 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_next_offset
,
244 builtin_type_void_data_ptr
);
248 LM_NAME (struct so_list
*so
)
250 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
252 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_name_offset
,
253 builtin_type_void_data_ptr
);
257 IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list
*so
)
259 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
261 /* Assume that everything is a library if the dynamic loader was loaded
262 late by a static executable. */
263 if (bfd_get_section_by_name (exec_bfd
, ".dynamic") == NULL
)
266 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_prev_offset
,
267 builtin_type_void_data_ptr
) == 0;
270 static CORE_ADDR debug_base
; /* Base of dynamic linker structures */
272 /* Validity flag for debug_loader_offset. */
273 static int debug_loader_offset_p
;
275 /* Load address for the dynamic linker, inferred. */
276 static CORE_ADDR debug_loader_offset
;
278 /* Name of the dynamic linker, valid if debug_loader_offset_p. */
279 static char *debug_loader_name
;
281 /* Local function prototypes */
283 static int match_main (char *);
285 static CORE_ADDR
bfd_lookup_symbol (bfd
*, char *);
291 bfd_lookup_symbol -- lookup the value for a specific symbol
295 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
299 An expensive way to lookup the value of a single symbol for
300 bfd's that are only temporary anyway. This is used by the
301 shared library support to find the address of the debugger
302 notification routine in the shared library.
304 The returned symbol may be in a code or data section; functions
305 will normally be in a code section, but may be in a data section
306 if this architecture uses function descriptors.
308 Note that 0 is specifically allowed as an error return (no
313 bfd_lookup_symbol (bfd
*abfd
, char *symname
)
317 asymbol
**symbol_table
;
318 unsigned int number_of_symbols
;
320 struct cleanup
*back_to
;
321 CORE_ADDR symaddr
= 0;
323 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
325 if (storage_needed
> 0)
327 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
328 back_to
= make_cleanup (xfree
, symbol_table
);
329 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
331 for (i
= 0; i
< number_of_symbols
; i
++)
333 sym
= *symbol_table
++;
334 if (strcmp (sym
->name
, symname
) == 0
335 && (sym
->section
->flags
& (SEC_CODE
| SEC_DATA
)) != 0)
337 /* BFD symbols are section relative. */
338 symaddr
= sym
->value
+ sym
->section
->vma
;
342 do_cleanups (back_to
);
348 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
349 have to check the dynamic string table too. */
351 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
353 if (storage_needed
> 0)
355 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
356 back_to
= make_cleanup (xfree
, symbol_table
);
357 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
359 for (i
= 0; i
< number_of_symbols
; i
++)
361 sym
= *symbol_table
++;
363 if (strcmp (sym
->name
, symname
) == 0
364 && (sym
->section
->flags
& (SEC_CODE
| SEC_DATA
)) != 0)
366 /* BFD symbols are section relative. */
367 symaddr
= sym
->value
+ sym
->section
->vma
;
371 do_cleanups (back_to
);
377 /* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
378 returned and the corresponding PTR is set. */
381 scan_dyntag (int dyntag
, bfd
*abfd
, CORE_ADDR
*ptr
)
383 int arch_size
, step
, sect_size
;
385 CORE_ADDR dyn_ptr
, dyn_addr
;
386 gdb_byte
*bufend
, *bufstart
, *buf
;
387 Elf32_External_Dyn
*x_dynp_32
;
388 Elf64_External_Dyn
*x_dynp_64
;
389 struct bfd_section
*sect
;
393 arch_size
= bfd_get_arch_size (abfd
);
397 /* Find the start address of the .dynamic section. */
398 sect
= bfd_get_section_by_name (abfd
, ".dynamic");
401 dyn_addr
= bfd_section_vma (abfd
, sect
);
403 /* Read in .dynamic from the BFD. We will get the actual value
404 from memory later. */
405 sect_size
= bfd_section_size (abfd
, sect
);
406 buf
= bufstart
= alloca (sect_size
);
407 if (!bfd_get_section_contents (abfd
, sect
,
411 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
412 step
= (arch_size
== 32) ? sizeof (Elf32_External_Dyn
)
413 : sizeof (Elf64_External_Dyn
);
414 for (bufend
= buf
+ sect_size
;
420 x_dynp_32
= (Elf32_External_Dyn
*) buf
;
421 dyn_tag
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_tag
);
422 dyn_ptr
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_un
.d_ptr
);
426 x_dynp_64
= (Elf64_External_Dyn
*) buf
;
427 dyn_tag
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_tag
);
428 dyn_ptr
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_un
.d_ptr
);
430 if (dyn_tag
== DT_NULL
)
432 if (dyn_tag
== dyntag
)
434 /* If requested, try to read the runtime value of this .dynamic
441 ptr_addr
= dyn_addr
+ (buf
- bufstart
) + arch_size
/ 8;
442 if (target_read_memory (ptr_addr
, ptr_buf
, arch_size
/ 8) == 0)
443 dyn_ptr
= extract_typed_address (ptr_buf
,
444 builtin_type_void_data_ptr
);
459 elf_locate_base -- locate the base address of dynamic linker structs
460 for SVR4 elf targets.
464 CORE_ADDR elf_locate_base (void)
468 For SVR4 elf targets the address of the dynamic linker's runtime
469 structure is contained within the dynamic info section in the
470 executable file. The dynamic section is also mapped into the
471 inferior address space. Because the runtime loader fills in the
472 real address before starting the inferior, we have to read in the
473 dynamic info section from the inferior address space.
474 If there are any errors while trying to find the address, we
475 silently return 0, otherwise the found address is returned.
480 elf_locate_base (void)
482 struct minimal_symbol
*msymbol
;
485 /* Look for DT_MIPS_RLD_MAP first. MIPS executables use this
486 instead of DT_DEBUG, although they sometimes contain an unused
488 if (scan_dyntag (DT_MIPS_RLD_MAP
, exec_bfd
, &dyn_ptr
))
491 int pbuf_size
= TYPE_LENGTH (builtin_type_void_data_ptr
);
492 pbuf
= alloca (pbuf_size
);
493 /* DT_MIPS_RLD_MAP contains a pointer to the address
494 of the dynamic link structure. */
495 if (target_read_memory (dyn_ptr
, pbuf
, pbuf_size
))
497 return extract_typed_address (pbuf
, builtin_type_void_data_ptr
);
501 if (scan_dyntag (DT_DEBUG
, exec_bfd
, &dyn_ptr
))
504 /* This may be a static executable. Look for the symbol
505 conventionally named _r_debug, as a last resort. */
506 msymbol
= lookup_minimal_symbol ("_r_debug", NULL
, symfile_objfile
);
508 return SYMBOL_VALUE_ADDRESS (msymbol
);
510 /* DT_DEBUG entry not found. */
518 locate_base -- locate the base address of dynamic linker structs
522 CORE_ADDR locate_base (void)
526 For both the SunOS and SVR4 shared library implementations, if the
527 inferior executable has been linked dynamically, there is a single
528 address somewhere in the inferior's data space which is the key to
529 locating all of the dynamic linker's runtime structures. This
530 address is the value of the debug base symbol. The job of this
531 function is to find and return that address, or to return 0 if there
532 is no such address (the executable is statically linked for example).
534 For SunOS, the job is almost trivial, since the dynamic linker and
535 all of it's structures are statically linked to the executable at
536 link time. Thus the symbol for the address we are looking for has
537 already been added to the minimal symbol table for the executable's
538 objfile at the time the symbol file's symbols were read, and all we
539 have to do is look it up there. Note that we explicitly do NOT want
540 to find the copies in the shared library.
542 The SVR4 version is a bit more complicated because the address
543 is contained somewhere in the dynamic info section. We have to go
544 to a lot more work to discover the address of the debug base symbol.
545 Because of this complexity, we cache the value we find and return that
546 value on subsequent invocations. Note there is no copy in the
547 executable symbol tables.
554 /* Check to see if we have a currently valid address, and if so, avoid
555 doing all this work again and just return the cached address. If
556 we have no cached address, try to locate it in the dynamic info
557 section for ELF executables. There's no point in doing any of this
558 though if we don't have some link map offsets to work with. */
560 if (debug_base
== 0 && svr4_have_link_map_offsets ())
563 && bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
564 debug_base
= elf_locate_base ();
569 /* Find the first element in the inferior's dynamic link map, and
570 return its address in the inferior.
572 FIXME: Perhaps we should validate the info somehow, perhaps by
573 checking r_version for a known version number, or r_state for
577 solib_svr4_r_map (void)
579 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
581 return read_memory_typed_address (debug_base
+ lmo
->r_map_offset
,
582 builtin_type_void_data_ptr
);
585 /* Find r_brk from the inferior's debug base. */
588 solib_svr4_r_brk (void)
590 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
592 return read_memory_typed_address (debug_base
+ lmo
->r_brk_offset
,
593 builtin_type_void_data_ptr
);
596 /* Find the link map for the dynamic linker (if it is not in the
597 normal list of loaded shared objects). */
600 solib_svr4_r_ldsomap (void)
602 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
605 /* Check version, and return zero if `struct r_debug' doesn't have
606 the r_ldsomap member. */
607 version
= read_memory_unsigned_integer (debug_base
+ lmo
->r_version_offset
,
608 lmo
->r_version_size
);
609 if (version
< 2 || lmo
->r_ldsomap_offset
== -1)
612 return read_memory_typed_address (debug_base
+ lmo
->r_ldsomap_offset
,
613 builtin_type_void_data_ptr
);
620 open_symbol_file_object
624 void open_symbol_file_object (void *from_tty)
628 If no open symbol file, attempt to locate and open the main symbol
629 file. On SVR4 systems, this is the first link map entry. If its
630 name is here, we can open it. Useful when attaching to a process
631 without first loading its symbol file.
633 If FROM_TTYP dereferences to a non-zero integer, allow messages to
634 be printed. This parameter is a pointer rather than an int because
635 open_symbol_file_object() is called via catch_errors() and
636 catch_errors() requires a pointer argument. */
639 open_symbol_file_object (void *from_ttyp
)
641 CORE_ADDR lm
, l_name
;
644 int from_tty
= *(int *)from_ttyp
;
645 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
646 int l_name_size
= TYPE_LENGTH (builtin_type_void_data_ptr
);
647 gdb_byte
*l_name_buf
= xmalloc (l_name_size
);
648 struct cleanup
*cleanups
= make_cleanup (xfree
, l_name_buf
);
651 if (!query ("Attempt to reload symbols from process? "))
654 /* Always locate the debug struct, in case it has moved. */
656 if (locate_base () == 0)
657 return 0; /* failed somehow... */
659 /* First link map member should be the executable. */
660 lm
= solib_svr4_r_map ();
662 return 0; /* failed somehow... */
664 /* Read address of name from target memory to GDB. */
665 read_memory (lm
+ lmo
->l_name_offset
, l_name_buf
, l_name_size
);
667 /* Convert the address to host format. */
668 l_name
= extract_typed_address (l_name_buf
, builtin_type_void_data_ptr
);
670 /* Free l_name_buf. */
671 do_cleanups (cleanups
);
674 return 0; /* No filename. */
676 /* Now fetch the filename from target memory. */
677 target_read_string (l_name
, &filename
, SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
678 make_cleanup (xfree
, filename
);
682 warning (_("failed to read exec filename from attached file: %s"),
683 safe_strerror (errcode
));
687 /* Have a pathname: read the symbol file. */
688 symbol_file_add_main (filename
, from_tty
);
693 /* If no shared library information is available from the dynamic
694 linker, build a fallback list from other sources. */
696 static struct so_list
*
697 svr4_default_sos (void)
699 struct so_list
*head
= NULL
;
700 struct so_list
**link_ptr
= &head
;
702 if (debug_loader_offset_p
)
704 struct so_list
*new = XZALLOC (struct so_list
);
706 new->lm_info
= xmalloc (sizeof (struct lm_info
));
708 /* Nothing will ever check the cached copy of the link
709 map if we set l_addr. */
710 new->lm_info
->l_addr
= debug_loader_offset
;
711 new->lm_info
->lm
= NULL
;
713 strncpy (new->so_name
, debug_loader_name
, SO_NAME_MAX_PATH_SIZE
- 1);
714 new->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
715 strcpy (new->so_original_name
, new->so_name
);
718 link_ptr
= &new->next
;
726 current_sos -- build a list of currently loaded shared objects
730 struct so_list *current_sos ()
734 Build a list of `struct so_list' objects describing the shared
735 objects currently loaded in the inferior. This list does not
736 include an entry for the main executable file.
738 Note that we only gather information directly available from the
739 inferior --- we don't examine any of the shared library files
740 themselves. The declaration of `struct so_list' says which fields
741 we provide values for. */
743 static struct so_list
*
744 svr4_current_sos (void)
747 struct so_list
*head
= 0;
748 struct so_list
**link_ptr
= &head
;
749 CORE_ADDR ldsomap
= 0;
751 /* Always locate the debug struct, in case it has moved. */
755 /* If we can't find the dynamic linker's base structure, this
756 must not be a dynamically linked executable. Hmm. */
758 return svr4_default_sos ();
760 /* Walk the inferior's link map list, and build our list of
761 `struct so_list' nodes. */
762 lm
= solib_svr4_r_map ();
766 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
767 struct so_list
*new = XZALLOC (struct so_list
);
768 struct cleanup
*old_chain
= make_cleanup (xfree
, new);
770 new->lm_info
= xmalloc (sizeof (struct lm_info
));
771 make_cleanup (xfree
, new->lm_info
);
773 new->lm_info
->l_addr
= (CORE_ADDR
)-1;
774 new->lm_info
->lm
= xzalloc (lmo
->link_map_size
);
775 make_cleanup (xfree
, new->lm_info
->lm
);
777 read_memory (lm
, new->lm_info
->lm
, lmo
->link_map_size
);
781 /* For SVR4 versions, the first entry in the link map is for the
782 inferior executable, so we must ignore it. For some versions of
783 SVR4, it has no name. For others (Solaris 2.3 for example), it
784 does have a name, so we can no longer use a missing name to
785 decide when to ignore it. */
786 if (IGNORE_FIRST_LINK_MAP_ENTRY (new) && ldsomap
== 0)
793 /* Extract this shared object's name. */
794 target_read_string (LM_NAME (new), &buffer
,
795 SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
797 warning (_("Can't read pathname for load map: %s."),
798 safe_strerror (errcode
));
801 strncpy (new->so_name
, buffer
, SO_NAME_MAX_PATH_SIZE
- 1);
802 new->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
803 strcpy (new->so_original_name
, new->so_name
);
807 /* If this entry has no name, or its name matches the name
808 for the main executable, don't include it in the list. */
809 if (! new->so_name
[0]
810 || match_main (new->so_name
))
816 link_ptr
= &new->next
;
820 /* On Solaris, the dynamic linker is not in the normal list of
821 shared objects, so make sure we pick it up too. Having
822 symbol information for the dynamic linker is quite crucial
823 for skipping dynamic linker resolver code. */
824 if (lm
== 0 && ldsomap
== 0)
825 lm
= ldsomap
= solib_svr4_r_ldsomap ();
827 discard_cleanups (old_chain
);
831 return svr4_default_sos ();
836 /* Get the address of the link_map for a given OBJFILE. Loop through
837 the link maps, and return the address of the one corresponding to
838 the given objfile. Note that this function takes into account that
839 objfile can be the main executable, not just a shared library. The
840 main executable has always an empty name field in the linkmap. */
843 svr4_fetch_objfile_link_map (struct objfile
*objfile
)
847 if (locate_base () == 0)
848 return 0; /* failed somehow... */
850 /* Position ourselves on the first link map. */
851 lm
= solib_svr4_r_map ();
854 /* Get info on the layout of the r_debug and link_map structures. */
855 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
858 struct lm_info objfile_lm_info
;
859 struct cleanup
*old_chain
;
860 CORE_ADDR name_address
;
861 int l_name_size
= TYPE_LENGTH (builtin_type_void_data_ptr
);
862 gdb_byte
*l_name_buf
= xmalloc (l_name_size
);
863 old_chain
= make_cleanup (xfree
, l_name_buf
);
865 /* Set up the buffer to contain the portion of the link_map
866 structure that gdb cares about. Note that this is not the
867 whole link_map structure. */
868 objfile_lm_info
.lm
= xzalloc (lmo
->link_map_size
);
869 make_cleanup (xfree
, objfile_lm_info
.lm
);
871 /* Read the link map into our internal structure. */
872 read_memory (lm
, objfile_lm_info
.lm
, lmo
->link_map_size
);
874 /* Read address of name from target memory to GDB. */
875 read_memory (lm
+ lmo
->l_name_offset
, l_name_buf
, l_name_size
);
877 /* Extract this object's name. */
878 name_address
= extract_typed_address (l_name_buf
,
879 builtin_type_void_data_ptr
);
880 target_read_string (name_address
, &buffer
,
881 SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
882 make_cleanup (xfree
, buffer
);
884 warning (_("Can't read pathname for load map: %s."),
885 safe_strerror (errcode
));
888 /* Is this the linkmap for the file we want? */
889 /* If the file is not a shared library and has no name,
890 we are sure it is the main executable, so we return that. */
893 && ((strcmp (buffer
, objfile
->name
) == 0)
894 || (!(objfile
->flags
& OBJF_SHARED
)
895 && (strcmp (buffer
, "") == 0))))
897 do_cleanups (old_chain
);
901 /* Not the file we wanted, continue checking. */
902 lm
= extract_typed_address (objfile_lm_info
.lm
+ lmo
->l_next_offset
,
903 builtin_type_void_data_ptr
);
904 do_cleanups (old_chain
);
909 /* On some systems, the only way to recognize the link map entry for
910 the main executable file is by looking at its name. Return
911 non-zero iff SONAME matches one of the known main executable names. */
914 match_main (char *soname
)
918 for (mainp
= main_name_list
; *mainp
!= NULL
; mainp
++)
920 if (strcmp (soname
, *mainp
) == 0)
927 /* Return 1 if PC lies in the dynamic symbol resolution code of the
928 SVR4 run time loader. */
929 static CORE_ADDR interp_text_sect_low
;
930 static CORE_ADDR interp_text_sect_high
;
931 static CORE_ADDR interp_plt_sect_low
;
932 static CORE_ADDR interp_plt_sect_high
;
935 svr4_in_dynsym_resolve_code (CORE_ADDR pc
)
937 return ((pc
>= interp_text_sect_low
&& pc
< interp_text_sect_high
)
938 || (pc
>= interp_plt_sect_low
&& pc
< interp_plt_sect_high
)
939 || in_plt_section (pc
, NULL
));
942 /* Given an executable's ABFD and target, compute the entry-point
946 exec_entry_point (struct bfd
*abfd
, struct target_ops
*targ
)
948 /* KevinB wrote ... for most targets, the address returned by
949 bfd_get_start_address() is the entry point for the start
950 function. But, for some targets, bfd_get_start_address() returns
951 the address of a function descriptor from which the entry point
952 address may be extracted. This address is extracted by
953 gdbarch_convert_from_func_ptr_addr(). The method
954 gdbarch_convert_from_func_ptr_addr() is the merely the identify
955 function for targets which don't use function descriptors. */
956 return gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
957 bfd_get_start_address (abfd
),
965 enable_break -- arrange for dynamic linker to hit breakpoint
969 int enable_break (void)
973 Both the SunOS and the SVR4 dynamic linkers have, as part of their
974 debugger interface, support for arranging for the inferior to hit
975 a breakpoint after mapping in the shared libraries. This function
976 enables that breakpoint.
978 For SunOS, there is a special flag location (in_debugger) which we
979 set to 1. When the dynamic linker sees this flag set, it will set
980 a breakpoint at a location known only to itself, after saving the
981 original contents of that place and the breakpoint address itself,
982 in it's own internal structures. When we resume the inferior, it
983 will eventually take a SIGTRAP when it runs into the breakpoint.
984 We handle this (in a different place) by restoring the contents of
985 the breakpointed location (which is only known after it stops),
986 chasing around to locate the shared libraries that have been
987 loaded, then resuming.
989 For SVR4, the debugger interface structure contains a member (r_brk)
990 which is statically initialized at the time the shared library is
991 built, to the offset of a function (_r_debug_state) which is guaran-
992 teed to be called once before mapping in a library, and again when
993 the mapping is complete. At the time we are examining this member,
994 it contains only the unrelocated offset of the function, so we have
995 to do our own relocation. Later, when the dynamic linker actually
996 runs, it relocates r_brk to be the actual address of _r_debug_state().
998 The debugger interface structure also contains an enumeration which
999 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
1000 depending upon whether or not the library is being mapped or unmapped,
1001 and then set to RT_CONSISTENT after the library is mapped/unmapped.
1007 #ifdef BKPT_AT_SYMBOL
1009 struct minimal_symbol
*msymbol
;
1011 asection
*interp_sect
;
1014 /* First, remove all the solib event breakpoints. Their addresses
1015 may have changed since the last time we ran the program. */
1016 remove_solib_event_breakpoints ();
1018 interp_text_sect_low
= interp_text_sect_high
= 0;
1019 interp_plt_sect_low
= interp_plt_sect_high
= 0;
1021 /* If we already have a shared library list in the target, and
1022 r_debug contains r_brk, set the breakpoint there - this should
1023 mean r_brk has already been relocated. Assume the dynamic linker
1024 is the object containing r_brk. */
1026 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
1028 if (debug_base
&& solib_svr4_r_map () != 0)
1029 sym_addr
= solib_svr4_r_brk ();
1033 struct obj_section
*os
;
1035 sym_addr
= gdbarch_addr_bits_remove
1036 (current_gdbarch
, gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
1040 os
= find_pc_section (sym_addr
);
1043 /* Record the relocated start and end address of the dynamic linker
1044 text and plt section for svr4_in_dynsym_resolve_code. */
1046 CORE_ADDR load_addr
;
1048 tmp_bfd
= os
->objfile
->obfd
;
1049 load_addr
= ANOFFSET (os
->objfile
->section_offsets
,
1050 os
->objfile
->sect_index_text
);
1052 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
1055 interp_text_sect_low
=
1056 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1057 interp_text_sect_high
=
1058 interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1060 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
1063 interp_plt_sect_low
=
1064 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1065 interp_plt_sect_high
=
1066 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1069 create_solib_event_breakpoint (sym_addr
);
1074 /* Find the .interp section; if not found, warn the user and drop
1075 into the old breakpoint at symbol code. */
1076 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
1079 unsigned int interp_sect_size
;
1081 CORE_ADDR load_addr
= 0;
1082 int load_addr_found
= 0;
1083 int loader_found_in_list
= 0;
1085 bfd
*tmp_bfd
= NULL
;
1086 struct target_ops
*tmp_bfd_target
;
1088 char *tmp_pathname
= NULL
;
1090 /* Read the contents of the .interp section into a local buffer;
1091 the contents specify the dynamic linker this program uses. */
1093 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
1094 buf
= alloca (interp_sect_size
);
1095 bfd_get_section_contents (exec_bfd
, interp_sect
,
1096 buf
, 0, interp_sect_size
);
1098 /* Now we need to figure out where the dynamic linker was
1099 loaded so that we can load its symbols and place a breakpoint
1100 in the dynamic linker itself.
1102 This address is stored on the stack. However, I've been unable
1103 to find any magic formula to find it for Solaris (appears to
1104 be trivial on GNU/Linux). Therefore, we have to try an alternate
1105 mechanism to find the dynamic linker's base address. */
1107 tmp_fd
= solib_open (buf
, &tmp_pathname
);
1109 tmp_bfd
= bfd_fopen (tmp_pathname
, gnutarget
, FOPEN_RB
, tmp_fd
);
1111 if (tmp_bfd
== NULL
)
1112 goto bkpt_at_symbol
;
1114 /* Make sure the dynamic linker's really a useful object. */
1115 if (!bfd_check_format (tmp_bfd
, bfd_object
))
1117 warning (_("Unable to grok dynamic linker %s as an object file"), buf
);
1118 bfd_close (tmp_bfd
);
1119 goto bkpt_at_symbol
;
1122 /* Now convert the TMP_BFD into a target. That way target, as
1123 well as BFD operations can be used. Note that closing the
1124 target will also close the underlying bfd. */
1125 tmp_bfd_target
= target_bfd_reopen (tmp_bfd
);
1127 /* On a running target, we can get the dynamic linker's base
1128 address from the shared library table. */
1129 so
= master_so_list ();
1132 if (svr4_same_1 (buf
, so
->so_original_name
))
1134 load_addr_found
= 1;
1135 loader_found_in_list
= 1;
1136 load_addr
= LM_ADDR_CHECK (so
, tmp_bfd
);
1142 /* If we were not able to find the base address of the loader
1143 from our so_list, then try using the AT_BASE auxilliary entry. */
1144 if (!load_addr_found
)
1145 if (target_auxv_search (¤t_target
, AT_BASE
, &load_addr
) > 0)
1146 load_addr_found
= 1;
1148 /* Otherwise we find the dynamic linker's base address by examining
1149 the current pc (which should point at the entry point for the
1150 dynamic linker) and subtracting the offset of the entry point.
1152 This is more fragile than the previous approaches, but is a good
1153 fallback method because it has actually been working well in
1155 if (!load_addr_found
)
1156 load_addr
= (read_pc ()
1157 - exec_entry_point (tmp_bfd
, tmp_bfd_target
));
1159 if (!loader_found_in_list
)
1161 debug_loader_name
= xstrdup (buf
);
1162 debug_loader_offset_p
= 1;
1163 debug_loader_offset
= load_addr
;
1164 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
1167 /* Record the relocated start and end address of the dynamic linker
1168 text and plt section for svr4_in_dynsym_resolve_code. */
1169 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
1172 interp_text_sect_low
=
1173 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1174 interp_text_sect_high
=
1175 interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1177 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
1180 interp_plt_sect_low
=
1181 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1182 interp_plt_sect_high
=
1183 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1186 /* Now try to set a breakpoint in the dynamic linker. */
1187 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1189 sym_addr
= bfd_lookup_symbol (tmp_bfd
, *bkpt_namep
);
1195 /* Convert 'sym_addr' from a function pointer to an address.
1196 Because we pass tmp_bfd_target instead of the current
1197 target, this will always produce an unrelocated value. */
1198 sym_addr
= gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
1202 /* We're done with both the temporary bfd and target. Remember,
1203 closing the target closes the underlying bfd. */
1204 target_close (tmp_bfd_target
, 0);
1208 create_solib_event_breakpoint (load_addr
+ sym_addr
);
1212 /* For whatever reason we couldn't set a breakpoint in the dynamic
1213 linker. Warn and drop into the old code. */
1215 xfree (tmp_pathname
);
1216 warning (_("Unable to find dynamic linker breakpoint function.\n"
1217 "GDB will be unable to debug shared library initializers\n"
1218 "and track explicitly loaded dynamic code."));
1221 /* Scan through the lists of symbols, trying to look up the symbol and
1222 set a breakpoint there. Terminate loop when we/if we succeed. */
1224 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1226 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
1227 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
1229 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol
));
1234 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1236 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
1237 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
1239 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol
));
1243 #endif /* BKPT_AT_SYMBOL */
1252 special_symbol_handling -- additional shared library symbol handling
1256 void special_symbol_handling ()
1260 Once the symbols from a shared object have been loaded in the usual
1261 way, we are called to do any system specific symbol handling that
1264 For SunOS4, this consisted of grunging around in the dynamic
1265 linkers structures to find symbol definitions for "common" symbols
1266 and adding them to the minimal symbol table for the runtime common
1269 However, for SVR4, there's nothing to do.
1274 svr4_special_symbol_handling (void)
1278 /* Relocate the main executable. This function should be called upon
1279 stopping the inferior process at the entry point to the program.
1280 The entry point from BFD is compared to the PC and if they are
1281 different, the main executable is relocated by the proper amount.
1283 As written it will only attempt to relocate executables which
1284 lack interpreter sections. It seems likely that only dynamic
1285 linker executables will get relocated, though it should work
1286 properly for a position-independent static executable as well. */
1289 svr4_relocate_main_executable (void)
1291 asection
*interp_sect
;
1292 CORE_ADDR pc
= read_pc ();
1294 /* Decide if the objfile needs to be relocated. As indicated above,
1295 we will only be here when execution is stopped at the beginning
1296 of the program. Relocation is necessary if the address at which
1297 we are presently stopped differs from the start address stored in
1298 the executable AND there's no interpreter section. The condition
1299 regarding the interpreter section is very important because if
1300 there *is* an interpreter section, execution will begin there
1301 instead. When there is an interpreter section, the start address
1302 is (presumably) used by the interpreter at some point to start
1303 execution of the program.
1305 If there is an interpreter, it is normal for it to be set to an
1306 arbitrary address at the outset. The job of finding it is
1307 handled in enable_break().
1309 So, to summarize, relocations are necessary when there is no
1310 interpreter section and the start address obtained from the
1311 executable is different from the address at which GDB is
1314 [ The astute reader will note that we also test to make sure that
1315 the executable in question has the DYNAMIC flag set. It is my
1316 opinion that this test is unnecessary (undesirable even). It
1317 was added to avoid inadvertent relocation of an executable
1318 whose e_type member in the ELF header is not ET_DYN. There may
1319 be a time in the future when it is desirable to do relocations
1320 on other types of files as well in which case this condition
1321 should either be removed or modified to accomodate the new file
1322 type. (E.g, an ET_EXEC executable which has been built to be
1323 position-independent could safely be relocated by the OS if
1324 desired. It is true that this violates the ABI, but the ABI
1325 has been known to be bent from time to time.) - Kevin, Nov 2000. ]
1328 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
1329 if (interp_sect
== NULL
1330 && (bfd_get_file_flags (exec_bfd
) & DYNAMIC
) != 0
1331 && (exec_entry_point (exec_bfd
, &exec_ops
) != pc
))
1333 struct cleanup
*old_chain
;
1334 struct section_offsets
*new_offsets
;
1336 CORE_ADDR displacement
;
1338 /* It is necessary to relocate the objfile. The amount to
1339 relocate by is simply the address at which we are stopped
1340 minus the starting address from the executable.
1342 We relocate all of the sections by the same amount. This
1343 behavior is mandated by recent editions of the System V ABI.
1344 According to the System V Application Binary Interface,
1345 Edition 4.1, page 5-5:
1347 ... Though the system chooses virtual addresses for
1348 individual processes, it maintains the segments' relative
1349 positions. Because position-independent code uses relative
1350 addressesing between segments, the difference between
1351 virtual addresses in memory must match the difference
1352 between virtual addresses in the file. The difference
1353 between the virtual address of any segment in memory and
1354 the corresponding virtual address in the file is thus a
1355 single constant value for any one executable or shared
1356 object in a given process. This difference is the base
1357 address. One use of the base address is to relocate the
1358 memory image of the program during dynamic linking.
1360 The same language also appears in Edition 4.0 of the System V
1361 ABI and is left unspecified in some of the earlier editions. */
1363 displacement
= pc
- exec_entry_point (exec_bfd
, &exec_ops
);
1366 new_offsets
= xcalloc (symfile_objfile
->num_sections
,
1367 sizeof (struct section_offsets
));
1368 old_chain
= make_cleanup (xfree
, new_offsets
);
1370 for (i
= 0; i
< symfile_objfile
->num_sections
; i
++)
1372 if (displacement
!= ANOFFSET (symfile_objfile
->section_offsets
, i
))
1374 new_offsets
->offsets
[i
] = displacement
;
1378 objfile_relocate (symfile_objfile
, new_offsets
);
1380 do_cleanups (old_chain
);
1388 svr4_solib_create_inferior_hook -- shared library startup support
1392 void svr4_solib_create_inferior_hook ()
1396 When gdb starts up the inferior, it nurses it along (through the
1397 shell) until it is ready to execute it's first instruction. At this
1398 point, this function gets called via expansion of the macro
1399 SOLIB_CREATE_INFERIOR_HOOK.
1401 For SunOS executables, this first instruction is typically the
1402 one at "_start", or a similar text label, regardless of whether
1403 the executable is statically or dynamically linked. The runtime
1404 startup code takes care of dynamically linking in any shared
1405 libraries, once gdb allows the inferior to continue.
1407 For SVR4 executables, this first instruction is either the first
1408 instruction in the dynamic linker (for dynamically linked
1409 executables) or the instruction at "start" for statically linked
1410 executables. For dynamically linked executables, the system
1411 first exec's /lib/libc.so.N, which contains the dynamic linker,
1412 and starts it running. The dynamic linker maps in any needed
1413 shared libraries, maps in the actual user executable, and then
1414 jumps to "start" in the user executable.
1416 For both SunOS shared libraries, and SVR4 shared libraries, we
1417 can arrange to cooperate with the dynamic linker to discover the
1418 names of shared libraries that are dynamically linked, and the
1419 base addresses to which they are linked.
1421 This function is responsible for discovering those names and
1422 addresses, and saving sufficient information about them to allow
1423 their symbols to be read at a later time.
1427 Between enable_break() and disable_break(), this code does not
1428 properly handle hitting breakpoints which the user might have
1429 set in the startup code or in the dynamic linker itself. Proper
1430 handling will probably have to wait until the implementation is
1431 changed to use the "breakpoint handler function" method.
1433 Also, what if child has exit()ed? Must exit loop somehow.
1437 svr4_solib_create_inferior_hook (void)
1439 /* Relocate the main executable if necessary. */
1440 svr4_relocate_main_executable ();
1442 if (!svr4_have_link_map_offsets ())
1445 if (!enable_break ())
1448 #if defined(_SCO_DS)
1449 /* SCO needs the loop below, other systems should be using the
1450 special shared library breakpoints and the shared library breakpoint
1453 Now run the target. It will eventually hit the breakpoint, at
1454 which point all of the libraries will have been mapped in and we
1455 can go groveling around in the dynamic linker structures to find
1456 out what we need to know about them. */
1458 clear_proceed_status ();
1459 stop_soon
= STOP_QUIETLY
;
1460 stop_signal
= TARGET_SIGNAL_0
;
1463 target_resume (pid_to_ptid (-1), 0, stop_signal
);
1464 wait_for_inferior (0);
1466 while (stop_signal
!= TARGET_SIGNAL_TRAP
);
1467 stop_soon
= NO_STOP_QUIETLY
;
1468 #endif /* defined(_SCO_DS) */
1472 svr4_clear_solib (void)
1475 debug_loader_offset_p
= 0;
1476 debug_loader_offset
= 0;
1477 xfree (debug_loader_name
);
1478 debug_loader_name
= NULL
;
1482 svr4_free_so (struct so_list
*so
)
1484 xfree (so
->lm_info
->lm
);
1485 xfree (so
->lm_info
);
1489 /* Clear any bits of ADDR that wouldn't fit in a target-format
1490 data pointer. "Data pointer" here refers to whatever sort of
1491 address the dynamic linker uses to manage its sections. At the
1492 moment, we don't support shared libraries on any processors where
1493 code and data pointers are different sizes.
1495 This isn't really the right solution. What we really need here is
1496 a way to do arithmetic on CORE_ADDR values that respects the
1497 natural pointer/address correspondence. (For example, on the MIPS,
1498 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
1499 sign-extend the value. There, simply truncating the bits above
1500 gdbarch_ptr_bit, as we do below, is no good.) This should probably
1501 be a new gdbarch method or something. */
1503 svr4_truncate_ptr (CORE_ADDR addr
)
1505 if (gdbarch_ptr_bit (current_gdbarch
) == sizeof (CORE_ADDR
) * 8)
1506 /* We don't need to truncate anything, and the bit twiddling below
1507 will fail due to overflow problems. */
1510 return addr
& (((CORE_ADDR
) 1 << gdbarch_ptr_bit (current_gdbarch
)) - 1);
1515 svr4_relocate_section_addresses (struct so_list
*so
,
1516 struct section_table
*sec
)
1518 sec
->addr
= svr4_truncate_ptr (sec
->addr
+ LM_ADDR_CHECK (so
,
1520 sec
->endaddr
= svr4_truncate_ptr (sec
->endaddr
+ LM_ADDR_CHECK (so
,
1525 /* Architecture-specific operations. */
1527 /* Per-architecture data key. */
1528 static struct gdbarch_data
*solib_svr4_data
;
1530 struct solib_svr4_ops
1532 /* Return a description of the layout of `struct link_map'. */
1533 struct link_map_offsets
*(*fetch_link_map_offsets
)(void);
1536 /* Return a default for the architecture-specific operations. */
1539 solib_svr4_init (struct obstack
*obstack
)
1541 struct solib_svr4_ops
*ops
;
1543 ops
= OBSTACK_ZALLOC (obstack
, struct solib_svr4_ops
);
1544 ops
->fetch_link_map_offsets
= NULL
;
1548 /* Set the architecture-specific `struct link_map_offsets' fetcher for
1549 GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */
1552 set_solib_svr4_fetch_link_map_offsets (struct gdbarch
*gdbarch
,
1553 struct link_map_offsets
*(*flmo
) (void))
1555 struct solib_svr4_ops
*ops
= gdbarch_data (gdbarch
, solib_svr4_data
);
1557 ops
->fetch_link_map_offsets
= flmo
;
1559 set_solib_ops (gdbarch
, &svr4_so_ops
);
1562 /* Fetch a link_map_offsets structure using the architecture-specific
1563 `struct link_map_offsets' fetcher. */
1565 static struct link_map_offsets
*
1566 svr4_fetch_link_map_offsets (void)
1568 struct solib_svr4_ops
*ops
= gdbarch_data (current_gdbarch
, solib_svr4_data
);
1570 gdb_assert (ops
->fetch_link_map_offsets
);
1571 return ops
->fetch_link_map_offsets ();
1574 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
1577 svr4_have_link_map_offsets (void)
1579 struct solib_svr4_ops
*ops
= gdbarch_data (current_gdbarch
, solib_svr4_data
);
1580 return (ops
->fetch_link_map_offsets
!= NULL
);
1584 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
1585 `struct r_debug' and a `struct link_map' that are binary compatible
1586 with the origional SVR4 implementation. */
1588 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
1589 for an ILP32 SVR4 system. */
1591 struct link_map_offsets
*
1592 svr4_ilp32_fetch_link_map_offsets (void)
1594 static struct link_map_offsets lmo
;
1595 static struct link_map_offsets
*lmp
= NULL
;
1601 lmo
.r_version_offset
= 0;
1602 lmo
.r_version_size
= 4;
1603 lmo
.r_map_offset
= 4;
1604 lmo
.r_brk_offset
= 8;
1605 lmo
.r_ldsomap_offset
= 20;
1607 /* Everything we need is in the first 20 bytes. */
1608 lmo
.link_map_size
= 20;
1609 lmo
.l_addr_offset
= 0;
1610 lmo
.l_name_offset
= 4;
1611 lmo
.l_ld_offset
= 8;
1612 lmo
.l_next_offset
= 12;
1613 lmo
.l_prev_offset
= 16;
1619 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
1620 for an LP64 SVR4 system. */
1622 struct link_map_offsets
*
1623 svr4_lp64_fetch_link_map_offsets (void)
1625 static struct link_map_offsets lmo
;
1626 static struct link_map_offsets
*lmp
= NULL
;
1632 lmo
.r_version_offset
= 0;
1633 lmo
.r_version_size
= 4;
1634 lmo
.r_map_offset
= 8;
1635 lmo
.r_brk_offset
= 16;
1636 lmo
.r_ldsomap_offset
= 40;
1638 /* Everything we need is in the first 40 bytes. */
1639 lmo
.link_map_size
= 40;
1640 lmo
.l_addr_offset
= 0;
1641 lmo
.l_name_offset
= 8;
1642 lmo
.l_ld_offset
= 16;
1643 lmo
.l_next_offset
= 24;
1644 lmo
.l_prev_offset
= 32;
1651 struct target_so_ops svr4_so_ops
;
1653 /* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a
1654 different rule for symbol lookup. The lookup begins here in the DSO, not in
1655 the main executable. */
1657 static struct symbol
*
1658 elf_lookup_lib_symbol (const struct objfile
*objfile
,
1660 const char *linkage_name
,
1661 const domain_enum domain
, struct symtab
**symtab
)
1663 if (objfile
->obfd
== NULL
1664 || scan_dyntag (DT_SYMBOLIC
, objfile
->obfd
, NULL
) != 1)
1667 return lookup_global_symbol_from_objfile
1668 (objfile
, name
, linkage_name
, domain
, symtab
);
1671 extern initialize_file_ftype _initialize_svr4_solib
; /* -Wmissing-prototypes */
1674 _initialize_svr4_solib (void)
1676 solib_svr4_data
= gdbarch_data_register_pre_init (solib_svr4_init
);
1678 svr4_so_ops
.relocate_section_addresses
= svr4_relocate_section_addresses
;
1679 svr4_so_ops
.free_so
= svr4_free_so
;
1680 svr4_so_ops
.clear_solib
= svr4_clear_solib
;
1681 svr4_so_ops
.solib_create_inferior_hook
= svr4_solib_create_inferior_hook
;
1682 svr4_so_ops
.special_symbol_handling
= svr4_special_symbol_handling
;
1683 svr4_so_ops
.current_sos
= svr4_current_sos
;
1684 svr4_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
1685 svr4_so_ops
.in_dynsym_resolve_code
= svr4_in_dynsym_resolve_code
;
1686 svr4_so_ops
.lookup_lib_global_symbol
= elf_lookup_lib_symbol
;
1687 svr4_so_ops
.same
= svr4_same
;