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. */
65 /* The target location of lm. */
69 /* On SVR4 systems, a list of symbols in the dynamic linker where
70 GDB can try to place a breakpoint to monitor shared library
73 If none of these symbols are found, or other errors occur, then
74 SVR4 systems will fall back to using a symbol as the "startup
75 mapping complete" breakpoint address. */
77 static char *solib_break_names
[] =
88 #define BKPT_AT_SYMBOL 1
90 #if defined (BKPT_AT_SYMBOL)
91 static char *bkpt_names
[] =
93 #ifdef SOLIB_BKPT_NAME
94 SOLIB_BKPT_NAME
, /* Prefer configured name if it exists. */
103 static char *main_name_list
[] =
109 /* Return non-zero if GDB_SO_NAME and INFERIOR_SO_NAME represent
110 the same shared library. */
113 svr4_same_1 (const char *gdb_so_name
, const char *inferior_so_name
)
115 if (strcmp (gdb_so_name
, inferior_so_name
) == 0)
118 /* On Solaris, when starting inferior we think that dynamic linker is
119 /usr/lib/ld.so.1, but later on, the table of loaded shared libraries
120 contains /lib/ld.so.1. Sometimes one file is a link to another, but
121 sometimes they have identical content, but are not linked to each
122 other. We don't restrict this check for Solaris, but the chances
123 of running into this situation elsewhere are very low. */
124 if (strcmp (gdb_so_name
, "/usr/lib/ld.so.1") == 0
125 && strcmp (inferior_so_name
, "/lib/ld.so.1") == 0)
128 /* Similarly, we observed the same issue with sparc64, but with
129 different locations. */
130 if (strcmp (gdb_so_name
, "/usr/lib/sparcv9/ld.so.1") == 0
131 && strcmp (inferior_so_name
, "/lib/sparcv9/ld.so.1") == 0)
138 svr4_same (struct so_list
*gdb
, struct so_list
*inferior
)
140 return (svr4_same_1 (gdb
->so_original_name
, inferior
->so_original_name
));
143 /* link map access functions */
146 LM_ADDR_FROM_LINK_MAP (struct so_list
*so
)
148 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
150 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_addr_offset
,
151 builtin_type_void_data_ptr
);
155 HAS_LM_DYNAMIC_FROM_LINK_MAP ()
157 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
159 return lmo
->l_ld_offset
>= 0;
163 LM_DYNAMIC_FROM_LINK_MAP (struct so_list
*so
)
165 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
167 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_ld_offset
,
168 builtin_type_void_data_ptr
);
172 LM_ADDR_CHECK (struct so_list
*so
, bfd
*abfd
)
174 if (so
->lm_info
->l_addr
== (CORE_ADDR
)-1)
176 struct bfd_section
*dyninfo_sect
;
177 CORE_ADDR l_addr
, l_dynaddr
, dynaddr
, align
= 0x1000;
179 l_addr
= LM_ADDR_FROM_LINK_MAP (so
);
181 if (! abfd
|| ! HAS_LM_DYNAMIC_FROM_LINK_MAP ())
184 l_dynaddr
= LM_DYNAMIC_FROM_LINK_MAP (so
);
186 dyninfo_sect
= bfd_get_section_by_name (abfd
, ".dynamic");
187 if (dyninfo_sect
== NULL
)
190 dynaddr
= bfd_section_vma (abfd
, dyninfo_sect
);
192 if (dynaddr
+ l_addr
!= l_dynaddr
)
194 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
196 Elf_Internal_Ehdr
*ehdr
= elf_tdata (abfd
)->elf_header
;
197 Elf_Internal_Phdr
*phdr
= elf_tdata (abfd
)->phdr
;
202 for (i
= 0; i
< ehdr
->e_phnum
; i
++)
203 if (phdr
[i
].p_type
== PT_LOAD
&& phdr
[i
].p_align
> align
)
204 align
= phdr
[i
].p_align
;
207 /* Turn it into a mask. */
210 /* If the changes match the alignment requirements, we
211 assume we're using a core file that was generated by the
212 same binary, just prelinked with a different base offset.
213 If it doesn't match, we may have a different binary, the
214 same binary with the dynamic table loaded at an unrelated
215 location, or anything, really. To avoid regressions,
216 don't adjust the base offset in the latter case, although
217 odds are that, if things really changed, debugging won't
219 if ((l_addr
& align
) == ((l_dynaddr
- dynaddr
) & align
))
221 l_addr
= l_dynaddr
- dynaddr
;
223 warning (_(".dynamic section for \"%s\" "
224 "is not at the expected address"), so
->so_name
);
225 warning (_("difference appears to be caused by prelink, "
226 "adjusting expectations"));
229 warning (_(".dynamic section for \"%s\" "
230 "is not at the expected address "
231 "(wrong library or version mismatch?)"), so
->so_name
);
235 so
->lm_info
->l_addr
= l_addr
;
238 return so
->lm_info
->l_addr
;
242 LM_NEXT (struct so_list
*so
)
244 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
246 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_next_offset
,
247 builtin_type_void_data_ptr
);
251 LM_NAME (struct so_list
*so
)
253 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
255 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_name_offset
,
256 builtin_type_void_data_ptr
);
260 IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list
*so
)
262 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
264 /* Assume that everything is a library if the dynamic loader was loaded
265 late by a static executable. */
266 if (bfd_get_section_by_name (exec_bfd
, ".dynamic") == NULL
)
269 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_prev_offset
,
270 builtin_type_void_data_ptr
) == 0;
273 static CORE_ADDR debug_base
; /* Base of dynamic linker structures */
275 /* Validity flag for debug_loader_offset. */
276 static int debug_loader_offset_p
;
278 /* Load address for the dynamic linker, inferred. */
279 static CORE_ADDR debug_loader_offset
;
281 /* Name of the dynamic linker, valid if debug_loader_offset_p. */
282 static char *debug_loader_name
;
284 /* Load map address for the main executable. */
285 static CORE_ADDR main_lm_addr
;
287 /* Local function prototypes */
289 static int match_main (char *);
291 static CORE_ADDR
bfd_lookup_symbol (bfd
*, char *);
297 bfd_lookup_symbol -- lookup the value for a specific symbol
301 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
305 An expensive way to lookup the value of a single symbol for
306 bfd's that are only temporary anyway. This is used by the
307 shared library support to find the address of the debugger
308 notification routine in the shared library.
310 The returned symbol may be in a code or data section; functions
311 will normally be in a code section, but may be in a data section
312 if this architecture uses function descriptors.
314 Note that 0 is specifically allowed as an error return (no
319 bfd_lookup_symbol (bfd
*abfd
, char *symname
)
323 asymbol
**symbol_table
;
324 unsigned int number_of_symbols
;
326 struct cleanup
*back_to
;
327 CORE_ADDR symaddr
= 0;
329 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
331 if (storage_needed
> 0)
333 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
334 back_to
= make_cleanup (xfree
, symbol_table
);
335 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
337 for (i
= 0; i
< number_of_symbols
; i
++)
339 sym
= *symbol_table
++;
340 if (strcmp (sym
->name
, symname
) == 0
341 && (sym
->section
->flags
& (SEC_CODE
| SEC_DATA
)) != 0)
343 /* BFD symbols are section relative. */
344 symaddr
= sym
->value
+ sym
->section
->vma
;
348 do_cleanups (back_to
);
354 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
355 have to check the dynamic string table too. */
357 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
359 if (storage_needed
> 0)
361 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
362 back_to
= make_cleanup (xfree
, symbol_table
);
363 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
365 for (i
= 0; i
< number_of_symbols
; i
++)
367 sym
= *symbol_table
++;
369 if (strcmp (sym
->name
, symname
) == 0
370 && (sym
->section
->flags
& (SEC_CODE
| SEC_DATA
)) != 0)
372 /* BFD symbols are section relative. */
373 symaddr
= sym
->value
+ sym
->section
->vma
;
377 do_cleanups (back_to
);
383 /* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
384 returned and the corresponding PTR is set. */
387 scan_dyntag (int dyntag
, bfd
*abfd
, CORE_ADDR
*ptr
)
389 int arch_size
, step
, sect_size
;
391 CORE_ADDR dyn_ptr
, dyn_addr
;
392 gdb_byte
*bufend
, *bufstart
, *buf
;
393 Elf32_External_Dyn
*x_dynp_32
;
394 Elf64_External_Dyn
*x_dynp_64
;
395 struct bfd_section
*sect
;
399 arch_size
= bfd_get_arch_size (abfd
);
403 /* Find the start address of the .dynamic section. */
404 sect
= bfd_get_section_by_name (abfd
, ".dynamic");
407 dyn_addr
= bfd_section_vma (abfd
, sect
);
409 /* Read in .dynamic from the BFD. We will get the actual value
410 from memory later. */
411 sect_size
= bfd_section_size (abfd
, sect
);
412 buf
= bufstart
= alloca (sect_size
);
413 if (!bfd_get_section_contents (abfd
, sect
,
417 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
418 step
= (arch_size
== 32) ? sizeof (Elf32_External_Dyn
)
419 : sizeof (Elf64_External_Dyn
);
420 for (bufend
= buf
+ sect_size
;
426 x_dynp_32
= (Elf32_External_Dyn
*) buf
;
427 dyn_tag
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_tag
);
428 dyn_ptr
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_un
.d_ptr
);
432 x_dynp_64
= (Elf64_External_Dyn
*) buf
;
433 dyn_tag
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_tag
);
434 dyn_ptr
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_un
.d_ptr
);
436 if (dyn_tag
== DT_NULL
)
438 if (dyn_tag
== dyntag
)
440 /* If requested, try to read the runtime value of this .dynamic
447 ptr_addr
= dyn_addr
+ (buf
- bufstart
) + arch_size
/ 8;
448 if (target_read_memory (ptr_addr
, ptr_buf
, arch_size
/ 8) == 0)
449 dyn_ptr
= extract_typed_address (ptr_buf
,
450 builtin_type_void_data_ptr
);
465 elf_locate_base -- locate the base address of dynamic linker structs
466 for SVR4 elf targets.
470 CORE_ADDR elf_locate_base (void)
474 For SVR4 elf targets the address of the dynamic linker's runtime
475 structure is contained within the dynamic info section in the
476 executable file. The dynamic section is also mapped into the
477 inferior address space. Because the runtime loader fills in the
478 real address before starting the inferior, we have to read in the
479 dynamic info section from the inferior address space.
480 If there are any errors while trying to find the address, we
481 silently return 0, otherwise the found address is returned.
486 elf_locate_base (void)
488 struct minimal_symbol
*msymbol
;
491 /* Look for DT_MIPS_RLD_MAP first. MIPS executables use this
492 instead of DT_DEBUG, although they sometimes contain an unused
494 if (scan_dyntag (DT_MIPS_RLD_MAP
, exec_bfd
, &dyn_ptr
))
497 int pbuf_size
= TYPE_LENGTH (builtin_type_void_data_ptr
);
498 pbuf
= alloca (pbuf_size
);
499 /* DT_MIPS_RLD_MAP contains a pointer to the address
500 of the dynamic link structure. */
501 if (target_read_memory (dyn_ptr
, pbuf
, pbuf_size
))
503 return extract_typed_address (pbuf
, builtin_type_void_data_ptr
);
507 if (scan_dyntag (DT_DEBUG
, exec_bfd
, &dyn_ptr
))
510 /* This may be a static executable. Look for the symbol
511 conventionally named _r_debug, as a last resort. */
512 msymbol
= lookup_minimal_symbol ("_r_debug", NULL
, symfile_objfile
);
514 return SYMBOL_VALUE_ADDRESS (msymbol
);
516 /* DT_DEBUG entry not found. */
524 locate_base -- locate the base address of dynamic linker structs
528 CORE_ADDR locate_base (void)
532 For both the SunOS and SVR4 shared library implementations, if the
533 inferior executable has been linked dynamically, there is a single
534 address somewhere in the inferior's data space which is the key to
535 locating all of the dynamic linker's runtime structures. This
536 address is the value of the debug base symbol. The job of this
537 function is to find and return that address, or to return 0 if there
538 is no such address (the executable is statically linked for example).
540 For SunOS, the job is almost trivial, since the dynamic linker and
541 all of it's structures are statically linked to the executable at
542 link time. Thus the symbol for the address we are looking for has
543 already been added to the minimal symbol table for the executable's
544 objfile at the time the symbol file's symbols were read, and all we
545 have to do is look it up there. Note that we explicitly do NOT want
546 to find the copies in the shared library.
548 The SVR4 version is a bit more complicated because the address
549 is contained somewhere in the dynamic info section. We have to go
550 to a lot more work to discover the address of the debug base symbol.
551 Because of this complexity, we cache the value we find and return that
552 value on subsequent invocations. Note there is no copy in the
553 executable symbol tables.
560 /* Check to see if we have a currently valid address, and if so, avoid
561 doing all this work again and just return the cached address. If
562 we have no cached address, try to locate it in the dynamic info
563 section for ELF executables. There's no point in doing any of this
564 though if we don't have some link map offsets to work with. */
566 if (debug_base
== 0 && svr4_have_link_map_offsets ())
569 && bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
570 debug_base
= elf_locate_base ();
575 /* Find the first element in the inferior's dynamic link map, and
576 return its address in the inferior.
578 FIXME: Perhaps we should validate the info somehow, perhaps by
579 checking r_version for a known version number, or r_state for
583 solib_svr4_r_map (void)
585 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
587 return read_memory_typed_address (debug_base
+ lmo
->r_map_offset
,
588 builtin_type_void_data_ptr
);
591 /* Find r_brk from the inferior's debug base. */
594 solib_svr4_r_brk (void)
596 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
598 return read_memory_typed_address (debug_base
+ lmo
->r_brk_offset
,
599 builtin_type_void_data_ptr
);
602 /* Find the link map for the dynamic linker (if it is not in the
603 normal list of loaded shared objects). */
606 solib_svr4_r_ldsomap (void)
608 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
611 /* Check version, and return zero if `struct r_debug' doesn't have
612 the r_ldsomap member. */
613 version
= read_memory_unsigned_integer (debug_base
+ lmo
->r_version_offset
,
614 lmo
->r_version_size
);
615 if (version
< 2 || lmo
->r_ldsomap_offset
== -1)
618 return read_memory_typed_address (debug_base
+ lmo
->r_ldsomap_offset
,
619 builtin_type_void_data_ptr
);
626 open_symbol_file_object
630 void open_symbol_file_object (void *from_tty)
634 If no open symbol file, attempt to locate and open the main symbol
635 file. On SVR4 systems, this is the first link map entry. If its
636 name is here, we can open it. Useful when attaching to a process
637 without first loading its symbol file.
639 If FROM_TTYP dereferences to a non-zero integer, allow messages to
640 be printed. This parameter is a pointer rather than an int because
641 open_symbol_file_object() is called via catch_errors() and
642 catch_errors() requires a pointer argument. */
645 open_symbol_file_object (void *from_ttyp
)
647 CORE_ADDR lm
, l_name
;
650 int from_tty
= *(int *)from_ttyp
;
651 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
652 int l_name_size
= TYPE_LENGTH (builtin_type_void_data_ptr
);
653 gdb_byte
*l_name_buf
= xmalloc (l_name_size
);
654 struct cleanup
*cleanups
= make_cleanup (xfree
, l_name_buf
);
657 if (!query ("Attempt to reload symbols from process? "))
660 /* Always locate the debug struct, in case it has moved. */
662 if (locate_base () == 0)
663 return 0; /* failed somehow... */
665 /* First link map member should be the executable. */
666 lm
= solib_svr4_r_map ();
668 return 0; /* failed somehow... */
670 /* Read address of name from target memory to GDB. */
671 read_memory (lm
+ lmo
->l_name_offset
, l_name_buf
, l_name_size
);
673 /* Convert the address to host format. */
674 l_name
= extract_typed_address (l_name_buf
, builtin_type_void_data_ptr
);
676 /* Free l_name_buf. */
677 do_cleanups (cleanups
);
680 return 0; /* No filename. */
682 /* Now fetch the filename from target memory. */
683 target_read_string (l_name
, &filename
, SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
684 make_cleanup (xfree
, filename
);
688 warning (_("failed to read exec filename from attached file: %s"),
689 safe_strerror (errcode
));
693 /* Have a pathname: read the symbol file. */
694 symbol_file_add_main (filename
, from_tty
);
699 /* If no shared library information is available from the dynamic
700 linker, build a fallback list from other sources. */
702 static struct so_list
*
703 svr4_default_sos (void)
705 struct so_list
*head
= NULL
;
706 struct so_list
**link_ptr
= &head
;
708 if (debug_loader_offset_p
)
710 struct so_list
*new = XZALLOC (struct so_list
);
712 new->lm_info
= xmalloc (sizeof (struct lm_info
));
714 /* Nothing will ever check the cached copy of the link
715 map if we set l_addr. */
716 new->lm_info
->l_addr
= debug_loader_offset
;
717 new->lm_info
->lm_addr
= 0;
718 new->lm_info
->lm
= NULL
;
720 strncpy (new->so_name
, debug_loader_name
, SO_NAME_MAX_PATH_SIZE
- 1);
721 new->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
722 strcpy (new->so_original_name
, new->so_name
);
725 link_ptr
= &new->next
;
733 current_sos -- build a list of currently loaded shared objects
737 struct so_list *current_sos ()
741 Build a list of `struct so_list' objects describing the shared
742 objects currently loaded in the inferior. This list does not
743 include an entry for the main executable file.
745 Note that we only gather information directly available from the
746 inferior --- we don't examine any of the shared library files
747 themselves. The declaration of `struct so_list' says which fields
748 we provide values for. */
750 static struct so_list
*
751 svr4_current_sos (void)
754 struct so_list
*head
= 0;
755 struct so_list
**link_ptr
= &head
;
756 CORE_ADDR ldsomap
= 0;
758 /* Always locate the debug struct, in case it has moved. */
762 /* If we can't find the dynamic linker's base structure, this
763 must not be a dynamically linked executable. Hmm. */
765 return svr4_default_sos ();
767 /* Walk the inferior's link map list, and build our list of
768 `struct so_list' nodes. */
769 lm
= solib_svr4_r_map ();
773 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
774 struct so_list
*new = XZALLOC (struct so_list
);
775 struct cleanup
*old_chain
= make_cleanup (xfree
, new);
777 new->lm_info
= xmalloc (sizeof (struct lm_info
));
778 make_cleanup (xfree
, new->lm_info
);
780 new->lm_info
->l_addr
= (CORE_ADDR
)-1;
781 new->lm_info
->lm_addr
= lm
;
782 new->lm_info
->lm
= xzalloc (lmo
->link_map_size
);
783 make_cleanup (xfree
, new->lm_info
->lm
);
785 read_memory (lm
, new->lm_info
->lm
, lmo
->link_map_size
);
789 /* For SVR4 versions, the first entry in the link map is for the
790 inferior executable, so we must ignore it. For some versions of
791 SVR4, it has no name. For others (Solaris 2.3 for example), it
792 does have a name, so we can no longer use a missing name to
793 decide when to ignore it. */
794 if (IGNORE_FIRST_LINK_MAP_ENTRY (new) && ldsomap
== 0)
796 main_lm_addr
= new->lm_info
->lm_addr
;
804 /* Extract this shared object's name. */
805 target_read_string (LM_NAME (new), &buffer
,
806 SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
808 warning (_("Can't read pathname for load map: %s."),
809 safe_strerror (errcode
));
812 strncpy (new->so_name
, buffer
, SO_NAME_MAX_PATH_SIZE
- 1);
813 new->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
814 strcpy (new->so_original_name
, new->so_name
);
818 /* If this entry has no name, or its name matches the name
819 for the main executable, don't include it in the list. */
820 if (! new->so_name
[0]
821 || match_main (new->so_name
))
827 link_ptr
= &new->next
;
831 /* On Solaris, the dynamic linker is not in the normal list of
832 shared objects, so make sure we pick it up too. Having
833 symbol information for the dynamic linker is quite crucial
834 for skipping dynamic linker resolver code. */
835 if (lm
== 0 && ldsomap
== 0)
836 lm
= ldsomap
= solib_svr4_r_ldsomap ();
838 discard_cleanups (old_chain
);
842 return svr4_default_sos ();
847 /* Get the address of the link_map for a given OBJFILE. */
850 svr4_fetch_objfile_link_map (struct objfile
*objfile
)
854 /* Cause svr4_current_sos() to be run if it hasn't been already. */
855 if (main_lm_addr
== 0)
856 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
858 /* svr4_current_sos() will set main_lm_addr for the main executable. */
859 if (objfile
== symfile_objfile
)
862 /* The other link map addresses may be found by examining the list
863 of shared libraries. */
864 for (so
= master_so_list (); so
; so
= so
->next
)
865 if (so
->objfile
== objfile
)
866 return so
->lm_info
->lm_addr
;
872 /* On some systems, the only way to recognize the link map entry for
873 the main executable file is by looking at its name. Return
874 non-zero iff SONAME matches one of the known main executable names. */
877 match_main (char *soname
)
881 for (mainp
= main_name_list
; *mainp
!= NULL
; mainp
++)
883 if (strcmp (soname
, *mainp
) == 0)
890 /* Return 1 if PC lies in the dynamic symbol resolution code of the
891 SVR4 run time loader. */
892 static CORE_ADDR interp_text_sect_low
;
893 static CORE_ADDR interp_text_sect_high
;
894 static CORE_ADDR interp_plt_sect_low
;
895 static CORE_ADDR interp_plt_sect_high
;
898 svr4_in_dynsym_resolve_code (CORE_ADDR pc
)
900 return ((pc
>= interp_text_sect_low
&& pc
< interp_text_sect_high
)
901 || (pc
>= interp_plt_sect_low
&& pc
< interp_plt_sect_high
)
902 || in_plt_section (pc
, NULL
));
905 /* Given an executable's ABFD and target, compute the entry-point
909 exec_entry_point (struct bfd
*abfd
, struct target_ops
*targ
)
911 /* KevinB wrote ... for most targets, the address returned by
912 bfd_get_start_address() is the entry point for the start
913 function. But, for some targets, bfd_get_start_address() returns
914 the address of a function descriptor from which the entry point
915 address may be extracted. This address is extracted by
916 gdbarch_convert_from_func_ptr_addr(). The method
917 gdbarch_convert_from_func_ptr_addr() is the merely the identify
918 function for targets which don't use function descriptors. */
919 return gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
920 bfd_get_start_address (abfd
),
928 enable_break -- arrange for dynamic linker to hit breakpoint
932 int enable_break (void)
936 Both the SunOS and the SVR4 dynamic linkers have, as part of their
937 debugger interface, support for arranging for the inferior to hit
938 a breakpoint after mapping in the shared libraries. This function
939 enables that breakpoint.
941 For SunOS, there is a special flag location (in_debugger) which we
942 set to 1. When the dynamic linker sees this flag set, it will set
943 a breakpoint at a location known only to itself, after saving the
944 original contents of that place and the breakpoint address itself,
945 in it's own internal structures. When we resume the inferior, it
946 will eventually take a SIGTRAP when it runs into the breakpoint.
947 We handle this (in a different place) by restoring the contents of
948 the breakpointed location (which is only known after it stops),
949 chasing around to locate the shared libraries that have been
950 loaded, then resuming.
952 For SVR4, the debugger interface structure contains a member (r_brk)
953 which is statically initialized at the time the shared library is
954 built, to the offset of a function (_r_debug_state) which is guaran-
955 teed to be called once before mapping in a library, and again when
956 the mapping is complete. At the time we are examining this member,
957 it contains only the unrelocated offset of the function, so we have
958 to do our own relocation. Later, when the dynamic linker actually
959 runs, it relocates r_brk to be the actual address of _r_debug_state().
961 The debugger interface structure also contains an enumeration which
962 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
963 depending upon whether or not the library is being mapped or unmapped,
964 and then set to RT_CONSISTENT after the library is mapped/unmapped.
970 #ifdef BKPT_AT_SYMBOL
972 struct minimal_symbol
*msymbol
;
974 asection
*interp_sect
;
977 /* First, remove all the solib event breakpoints. Their addresses
978 may have changed since the last time we ran the program. */
979 remove_solib_event_breakpoints ();
981 interp_text_sect_low
= interp_text_sect_high
= 0;
982 interp_plt_sect_low
= interp_plt_sect_high
= 0;
984 /* If we already have a shared library list in the target, and
985 r_debug contains r_brk, set the breakpoint there - this should
986 mean r_brk has already been relocated. Assume the dynamic linker
987 is the object containing r_brk. */
989 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
991 if (debug_base
&& solib_svr4_r_map () != 0)
992 sym_addr
= solib_svr4_r_brk ();
996 struct obj_section
*os
;
998 sym_addr
= gdbarch_addr_bits_remove
999 (current_gdbarch
, gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
1003 os
= find_pc_section (sym_addr
);
1006 /* Record the relocated start and end address of the dynamic linker
1007 text and plt section for svr4_in_dynsym_resolve_code. */
1009 CORE_ADDR load_addr
;
1011 tmp_bfd
= os
->objfile
->obfd
;
1012 load_addr
= ANOFFSET (os
->objfile
->section_offsets
,
1013 os
->objfile
->sect_index_text
);
1015 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
1018 interp_text_sect_low
=
1019 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1020 interp_text_sect_high
=
1021 interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1023 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
1026 interp_plt_sect_low
=
1027 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1028 interp_plt_sect_high
=
1029 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1032 create_solib_event_breakpoint (sym_addr
);
1037 /* Find the .interp section; if not found, warn the user and drop
1038 into the old breakpoint at symbol code. */
1039 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
1042 unsigned int interp_sect_size
;
1044 CORE_ADDR load_addr
= 0;
1045 int load_addr_found
= 0;
1046 int loader_found_in_list
= 0;
1048 bfd
*tmp_bfd
= NULL
;
1049 struct target_ops
*tmp_bfd_target
;
1051 char *tmp_pathname
= NULL
;
1053 /* Read the contents of the .interp section into a local buffer;
1054 the contents specify the dynamic linker this program uses. */
1056 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
1057 buf
= alloca (interp_sect_size
);
1058 bfd_get_section_contents (exec_bfd
, interp_sect
,
1059 buf
, 0, interp_sect_size
);
1061 /* Now we need to figure out where the dynamic linker was
1062 loaded so that we can load its symbols and place a breakpoint
1063 in the dynamic linker itself.
1065 This address is stored on the stack. However, I've been unable
1066 to find any magic formula to find it for Solaris (appears to
1067 be trivial on GNU/Linux). Therefore, we have to try an alternate
1068 mechanism to find the dynamic linker's base address. */
1070 tmp_fd
= solib_open (buf
, &tmp_pathname
);
1072 tmp_bfd
= bfd_fopen (tmp_pathname
, gnutarget
, FOPEN_RB
, tmp_fd
);
1074 if (tmp_bfd
== NULL
)
1075 goto bkpt_at_symbol
;
1077 /* Make sure the dynamic linker's really a useful object. */
1078 if (!bfd_check_format (tmp_bfd
, bfd_object
))
1080 warning (_("Unable to grok dynamic linker %s as an object file"), buf
);
1081 bfd_close (tmp_bfd
);
1082 goto bkpt_at_symbol
;
1085 /* Now convert the TMP_BFD into a target. That way target, as
1086 well as BFD operations can be used. Note that closing the
1087 target will also close the underlying bfd. */
1088 tmp_bfd_target
= target_bfd_reopen (tmp_bfd
);
1090 /* On a running target, we can get the dynamic linker's base
1091 address from the shared library table. */
1092 so
= master_so_list ();
1095 if (svr4_same_1 (buf
, so
->so_original_name
))
1097 load_addr_found
= 1;
1098 loader_found_in_list
= 1;
1099 load_addr
= LM_ADDR_CHECK (so
, tmp_bfd
);
1105 /* If we were not able to find the base address of the loader
1106 from our so_list, then try using the AT_BASE auxilliary entry. */
1107 if (!load_addr_found
)
1108 if (target_auxv_search (¤t_target
, AT_BASE
, &load_addr
) > 0)
1109 load_addr_found
= 1;
1111 /* Otherwise we find the dynamic linker's base address by examining
1112 the current pc (which should point at the entry point for the
1113 dynamic linker) and subtracting the offset of the entry point.
1115 This is more fragile than the previous approaches, but is a good
1116 fallback method because it has actually been working well in
1118 if (!load_addr_found
)
1119 load_addr
= (read_pc ()
1120 - exec_entry_point (tmp_bfd
, tmp_bfd_target
));
1122 if (!loader_found_in_list
)
1124 debug_loader_name
= xstrdup (buf
);
1125 debug_loader_offset_p
= 1;
1126 debug_loader_offset
= load_addr
;
1127 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
1130 /* Record the relocated start and end address of the dynamic linker
1131 text and plt section for svr4_in_dynsym_resolve_code. */
1132 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
1135 interp_text_sect_low
=
1136 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1137 interp_text_sect_high
=
1138 interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1140 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
1143 interp_plt_sect_low
=
1144 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1145 interp_plt_sect_high
=
1146 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1149 /* Now try to set a breakpoint in the dynamic linker. */
1150 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1152 sym_addr
= bfd_lookup_symbol (tmp_bfd
, *bkpt_namep
);
1158 /* Convert 'sym_addr' from a function pointer to an address.
1159 Because we pass tmp_bfd_target instead of the current
1160 target, this will always produce an unrelocated value. */
1161 sym_addr
= gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
1165 /* We're done with both the temporary bfd and target. Remember,
1166 closing the target closes the underlying bfd. */
1167 target_close (tmp_bfd_target
, 0);
1171 create_solib_event_breakpoint (load_addr
+ sym_addr
);
1175 /* For whatever reason we couldn't set a breakpoint in the dynamic
1176 linker. Warn and drop into the old code. */
1178 xfree (tmp_pathname
);
1179 warning (_("Unable to find dynamic linker breakpoint function.\n"
1180 "GDB will be unable to debug shared library initializers\n"
1181 "and track explicitly loaded dynamic code."));
1184 /* Scan through the lists of symbols, trying to look up the symbol and
1185 set a breakpoint there. Terminate loop when we/if we succeed. */
1187 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1189 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
1190 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
1192 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol
));
1197 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1199 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
1200 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
1202 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol
));
1206 #endif /* BKPT_AT_SYMBOL */
1215 special_symbol_handling -- additional shared library symbol handling
1219 void special_symbol_handling ()
1223 Once the symbols from a shared object have been loaded in the usual
1224 way, we are called to do any system specific symbol handling that
1227 For SunOS4, this consisted of grunging around in the dynamic
1228 linkers structures to find symbol definitions for "common" symbols
1229 and adding them to the minimal symbol table for the runtime common
1232 However, for SVR4, there's nothing to do.
1237 svr4_special_symbol_handling (void)
1241 /* Relocate the main executable. This function should be called upon
1242 stopping the inferior process at the entry point to the program.
1243 The entry point from BFD is compared to the PC and if they are
1244 different, the main executable is relocated by the proper amount.
1246 As written it will only attempt to relocate executables which
1247 lack interpreter sections. It seems likely that only dynamic
1248 linker executables will get relocated, though it should work
1249 properly for a position-independent static executable as well. */
1252 svr4_relocate_main_executable (void)
1254 asection
*interp_sect
;
1255 CORE_ADDR pc
= read_pc ();
1257 /* Decide if the objfile needs to be relocated. As indicated above,
1258 we will only be here when execution is stopped at the beginning
1259 of the program. Relocation is necessary if the address at which
1260 we are presently stopped differs from the start address stored in
1261 the executable AND there's no interpreter section. The condition
1262 regarding the interpreter section is very important because if
1263 there *is* an interpreter section, execution will begin there
1264 instead. When there is an interpreter section, the start address
1265 is (presumably) used by the interpreter at some point to start
1266 execution of the program.
1268 If there is an interpreter, it is normal for it to be set to an
1269 arbitrary address at the outset. The job of finding it is
1270 handled in enable_break().
1272 So, to summarize, relocations are necessary when there is no
1273 interpreter section and the start address obtained from the
1274 executable is different from the address at which GDB is
1277 [ The astute reader will note that we also test to make sure that
1278 the executable in question has the DYNAMIC flag set. It is my
1279 opinion that this test is unnecessary (undesirable even). It
1280 was added to avoid inadvertent relocation of an executable
1281 whose e_type member in the ELF header is not ET_DYN. There may
1282 be a time in the future when it is desirable to do relocations
1283 on other types of files as well in which case this condition
1284 should either be removed or modified to accomodate the new file
1285 type. (E.g, an ET_EXEC executable which has been built to be
1286 position-independent could safely be relocated by the OS if
1287 desired. It is true that this violates the ABI, but the ABI
1288 has been known to be bent from time to time.) - Kevin, Nov 2000. ]
1291 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
1292 if (interp_sect
== NULL
1293 && (bfd_get_file_flags (exec_bfd
) & DYNAMIC
) != 0
1294 && (exec_entry_point (exec_bfd
, &exec_ops
) != pc
))
1296 struct cleanup
*old_chain
;
1297 struct section_offsets
*new_offsets
;
1299 CORE_ADDR displacement
;
1301 /* It is necessary to relocate the objfile. The amount to
1302 relocate by is simply the address at which we are stopped
1303 minus the starting address from the executable.
1305 We relocate all of the sections by the same amount. This
1306 behavior is mandated by recent editions of the System V ABI.
1307 According to the System V Application Binary Interface,
1308 Edition 4.1, page 5-5:
1310 ... Though the system chooses virtual addresses for
1311 individual processes, it maintains the segments' relative
1312 positions. Because position-independent code uses relative
1313 addressesing between segments, the difference between
1314 virtual addresses in memory must match the difference
1315 between virtual addresses in the file. The difference
1316 between the virtual address of any segment in memory and
1317 the corresponding virtual address in the file is thus a
1318 single constant value for any one executable or shared
1319 object in a given process. This difference is the base
1320 address. One use of the base address is to relocate the
1321 memory image of the program during dynamic linking.
1323 The same language also appears in Edition 4.0 of the System V
1324 ABI and is left unspecified in some of the earlier editions. */
1326 displacement
= pc
- exec_entry_point (exec_bfd
, &exec_ops
);
1329 new_offsets
= xcalloc (symfile_objfile
->num_sections
,
1330 sizeof (struct section_offsets
));
1331 old_chain
= make_cleanup (xfree
, new_offsets
);
1333 for (i
= 0; i
< symfile_objfile
->num_sections
; i
++)
1335 if (displacement
!= ANOFFSET (symfile_objfile
->section_offsets
, i
))
1337 new_offsets
->offsets
[i
] = displacement
;
1341 objfile_relocate (symfile_objfile
, new_offsets
);
1343 do_cleanups (old_chain
);
1351 svr4_solib_create_inferior_hook -- shared library startup support
1355 void svr4_solib_create_inferior_hook ()
1359 When gdb starts up the inferior, it nurses it along (through the
1360 shell) until it is ready to execute it's first instruction. At this
1361 point, this function gets called via expansion of the macro
1362 SOLIB_CREATE_INFERIOR_HOOK.
1364 For SunOS executables, this first instruction is typically the
1365 one at "_start", or a similar text label, regardless of whether
1366 the executable is statically or dynamically linked. The runtime
1367 startup code takes care of dynamically linking in any shared
1368 libraries, once gdb allows the inferior to continue.
1370 For SVR4 executables, this first instruction is either the first
1371 instruction in the dynamic linker (for dynamically linked
1372 executables) or the instruction at "start" for statically linked
1373 executables. For dynamically linked executables, the system
1374 first exec's /lib/libc.so.N, which contains the dynamic linker,
1375 and starts it running. The dynamic linker maps in any needed
1376 shared libraries, maps in the actual user executable, and then
1377 jumps to "start" in the user executable.
1379 For both SunOS shared libraries, and SVR4 shared libraries, we
1380 can arrange to cooperate with the dynamic linker to discover the
1381 names of shared libraries that are dynamically linked, and the
1382 base addresses to which they are linked.
1384 This function is responsible for discovering those names and
1385 addresses, and saving sufficient information about them to allow
1386 their symbols to be read at a later time.
1390 Between enable_break() and disable_break(), this code does not
1391 properly handle hitting breakpoints which the user might have
1392 set in the startup code or in the dynamic linker itself. Proper
1393 handling will probably have to wait until the implementation is
1394 changed to use the "breakpoint handler function" method.
1396 Also, what if child has exit()ed? Must exit loop somehow.
1400 svr4_solib_create_inferior_hook (void)
1402 /* Relocate the main executable if necessary. */
1403 svr4_relocate_main_executable ();
1405 if (!svr4_have_link_map_offsets ())
1408 if (!enable_break ())
1411 #if defined(_SCO_DS)
1412 /* SCO needs the loop below, other systems should be using the
1413 special shared library breakpoints and the shared library breakpoint
1416 Now run the target. It will eventually hit the breakpoint, at
1417 which point all of the libraries will have been mapped in and we
1418 can go groveling around in the dynamic linker structures to find
1419 out what we need to know about them. */
1421 clear_proceed_status ();
1422 stop_soon
= STOP_QUIETLY
;
1423 stop_signal
= TARGET_SIGNAL_0
;
1426 target_resume (pid_to_ptid (-1), 0, stop_signal
);
1427 wait_for_inferior (0);
1429 while (stop_signal
!= TARGET_SIGNAL_TRAP
);
1430 stop_soon
= NO_STOP_QUIETLY
;
1431 #endif /* defined(_SCO_DS) */
1435 svr4_clear_solib (void)
1438 debug_loader_offset_p
= 0;
1439 debug_loader_offset
= 0;
1440 xfree (debug_loader_name
);
1441 debug_loader_name
= NULL
;
1446 svr4_free_so (struct so_list
*so
)
1448 xfree (so
->lm_info
->lm
);
1449 xfree (so
->lm_info
);
1453 /* Clear any bits of ADDR that wouldn't fit in a target-format
1454 data pointer. "Data pointer" here refers to whatever sort of
1455 address the dynamic linker uses to manage its sections. At the
1456 moment, we don't support shared libraries on any processors where
1457 code and data pointers are different sizes.
1459 This isn't really the right solution. What we really need here is
1460 a way to do arithmetic on CORE_ADDR values that respects the
1461 natural pointer/address correspondence. (For example, on the MIPS,
1462 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
1463 sign-extend the value. There, simply truncating the bits above
1464 gdbarch_ptr_bit, as we do below, is no good.) This should probably
1465 be a new gdbarch method or something. */
1467 svr4_truncate_ptr (CORE_ADDR addr
)
1469 if (gdbarch_ptr_bit (current_gdbarch
) == sizeof (CORE_ADDR
) * 8)
1470 /* We don't need to truncate anything, and the bit twiddling below
1471 will fail due to overflow problems. */
1474 return addr
& (((CORE_ADDR
) 1 << gdbarch_ptr_bit (current_gdbarch
)) - 1);
1479 svr4_relocate_section_addresses (struct so_list
*so
,
1480 struct section_table
*sec
)
1482 sec
->addr
= svr4_truncate_ptr (sec
->addr
+ LM_ADDR_CHECK (so
,
1484 sec
->endaddr
= svr4_truncate_ptr (sec
->endaddr
+ LM_ADDR_CHECK (so
,
1489 /* Architecture-specific operations. */
1491 /* Per-architecture data key. */
1492 static struct gdbarch_data
*solib_svr4_data
;
1494 struct solib_svr4_ops
1496 /* Return a description of the layout of `struct link_map'. */
1497 struct link_map_offsets
*(*fetch_link_map_offsets
)(void);
1500 /* Return a default for the architecture-specific operations. */
1503 solib_svr4_init (struct obstack
*obstack
)
1505 struct solib_svr4_ops
*ops
;
1507 ops
= OBSTACK_ZALLOC (obstack
, struct solib_svr4_ops
);
1508 ops
->fetch_link_map_offsets
= NULL
;
1512 /* Set the architecture-specific `struct link_map_offsets' fetcher for
1513 GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */
1516 set_solib_svr4_fetch_link_map_offsets (struct gdbarch
*gdbarch
,
1517 struct link_map_offsets
*(*flmo
) (void))
1519 struct solib_svr4_ops
*ops
= gdbarch_data (gdbarch
, solib_svr4_data
);
1521 ops
->fetch_link_map_offsets
= flmo
;
1523 set_solib_ops (gdbarch
, &svr4_so_ops
);
1526 /* Fetch a link_map_offsets structure using the architecture-specific
1527 `struct link_map_offsets' fetcher. */
1529 static struct link_map_offsets
*
1530 svr4_fetch_link_map_offsets (void)
1532 struct solib_svr4_ops
*ops
= gdbarch_data (current_gdbarch
, solib_svr4_data
);
1534 gdb_assert (ops
->fetch_link_map_offsets
);
1535 return ops
->fetch_link_map_offsets ();
1538 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
1541 svr4_have_link_map_offsets (void)
1543 struct solib_svr4_ops
*ops
= gdbarch_data (current_gdbarch
, solib_svr4_data
);
1544 return (ops
->fetch_link_map_offsets
!= NULL
);
1548 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
1549 `struct r_debug' and a `struct link_map' that are binary compatible
1550 with the origional SVR4 implementation. */
1552 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
1553 for an ILP32 SVR4 system. */
1555 struct link_map_offsets
*
1556 svr4_ilp32_fetch_link_map_offsets (void)
1558 static struct link_map_offsets lmo
;
1559 static struct link_map_offsets
*lmp
= NULL
;
1565 lmo
.r_version_offset
= 0;
1566 lmo
.r_version_size
= 4;
1567 lmo
.r_map_offset
= 4;
1568 lmo
.r_brk_offset
= 8;
1569 lmo
.r_ldsomap_offset
= 20;
1571 /* Everything we need is in the first 20 bytes. */
1572 lmo
.link_map_size
= 20;
1573 lmo
.l_addr_offset
= 0;
1574 lmo
.l_name_offset
= 4;
1575 lmo
.l_ld_offset
= 8;
1576 lmo
.l_next_offset
= 12;
1577 lmo
.l_prev_offset
= 16;
1583 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
1584 for an LP64 SVR4 system. */
1586 struct link_map_offsets
*
1587 svr4_lp64_fetch_link_map_offsets (void)
1589 static struct link_map_offsets lmo
;
1590 static struct link_map_offsets
*lmp
= NULL
;
1596 lmo
.r_version_offset
= 0;
1597 lmo
.r_version_size
= 4;
1598 lmo
.r_map_offset
= 8;
1599 lmo
.r_brk_offset
= 16;
1600 lmo
.r_ldsomap_offset
= 40;
1602 /* Everything we need is in the first 40 bytes. */
1603 lmo
.link_map_size
= 40;
1604 lmo
.l_addr_offset
= 0;
1605 lmo
.l_name_offset
= 8;
1606 lmo
.l_ld_offset
= 16;
1607 lmo
.l_next_offset
= 24;
1608 lmo
.l_prev_offset
= 32;
1615 struct target_so_ops svr4_so_ops
;
1617 /* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a
1618 different rule for symbol lookup. The lookup begins here in the DSO, not in
1619 the main executable. */
1621 static struct symbol
*
1622 elf_lookup_lib_symbol (const struct objfile
*objfile
,
1624 const char *linkage_name
,
1625 const domain_enum domain
)
1627 if (objfile
->obfd
== NULL
1628 || scan_dyntag (DT_SYMBOLIC
, objfile
->obfd
, NULL
) != 1)
1631 return lookup_global_symbol_from_objfile
1632 (objfile
, name
, linkage_name
, domain
);
1635 extern initialize_file_ftype _initialize_svr4_solib
; /* -Wmissing-prototypes */
1638 _initialize_svr4_solib (void)
1640 solib_svr4_data
= gdbarch_data_register_pre_init (solib_svr4_init
);
1642 svr4_so_ops
.relocate_section_addresses
= svr4_relocate_section_addresses
;
1643 svr4_so_ops
.free_so
= svr4_free_so
;
1644 svr4_so_ops
.clear_solib
= svr4_clear_solib
;
1645 svr4_so_ops
.solib_create_inferior_hook
= svr4_solib_create_inferior_hook
;
1646 svr4_so_ops
.special_symbol_handling
= svr4_special_symbol_handling
;
1647 svr4_so_ops
.current_sos
= svr4_current_sos
;
1648 svr4_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
1649 svr4_so_ops
.in_dynsym_resolve_code
= svr4_in_dynsym_resolve_code
;
1650 svr4_so_ops
.lookup_lib_global_symbol
= elf_lookup_lib_symbol
;
1651 svr4_so_ops
.same
= svr4_same
;