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 static char *bkpt_names
[] =
96 static char *main_name_list
[] =
102 /* Return non-zero if GDB_SO_NAME and INFERIOR_SO_NAME represent
103 the same shared library. */
106 svr4_same_1 (const char *gdb_so_name
, const char *inferior_so_name
)
108 if (strcmp (gdb_so_name
, inferior_so_name
) == 0)
111 /* On Solaris, when starting inferior we think that dynamic linker is
112 /usr/lib/ld.so.1, but later on, the table of loaded shared libraries
113 contains /lib/ld.so.1. Sometimes one file is a link to another, but
114 sometimes they have identical content, but are not linked to each
115 other. We don't restrict this check for Solaris, but the chances
116 of running into this situation elsewhere are very low. */
117 if (strcmp (gdb_so_name
, "/usr/lib/ld.so.1") == 0
118 && strcmp (inferior_so_name
, "/lib/ld.so.1") == 0)
121 /* Similarly, we observed the same issue with sparc64, but with
122 different locations. */
123 if (strcmp (gdb_so_name
, "/usr/lib/sparcv9/ld.so.1") == 0
124 && strcmp (inferior_so_name
, "/lib/sparcv9/ld.so.1") == 0)
131 svr4_same (struct so_list
*gdb
, struct so_list
*inferior
)
133 return (svr4_same_1 (gdb
->so_original_name
, inferior
->so_original_name
));
136 /* link map access functions */
139 LM_ADDR_FROM_LINK_MAP (struct so_list
*so
)
141 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
143 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_addr_offset
,
144 builtin_type_void_data_ptr
);
148 HAS_LM_DYNAMIC_FROM_LINK_MAP ()
150 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
152 return lmo
->l_ld_offset
>= 0;
156 LM_DYNAMIC_FROM_LINK_MAP (struct so_list
*so
)
158 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
160 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_ld_offset
,
161 builtin_type_void_data_ptr
);
165 LM_ADDR_CHECK (struct so_list
*so
, bfd
*abfd
)
167 if (so
->lm_info
->l_addr
== (CORE_ADDR
)-1)
169 struct bfd_section
*dyninfo_sect
;
170 CORE_ADDR l_addr
, l_dynaddr
, dynaddr
, align
= 0x1000;
172 l_addr
= LM_ADDR_FROM_LINK_MAP (so
);
174 if (! abfd
|| ! HAS_LM_DYNAMIC_FROM_LINK_MAP ())
177 l_dynaddr
= LM_DYNAMIC_FROM_LINK_MAP (so
);
179 dyninfo_sect
= bfd_get_section_by_name (abfd
, ".dynamic");
180 if (dyninfo_sect
== NULL
)
183 dynaddr
= bfd_section_vma (abfd
, dyninfo_sect
);
185 if (dynaddr
+ l_addr
!= l_dynaddr
)
187 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
189 Elf_Internal_Ehdr
*ehdr
= elf_tdata (abfd
)->elf_header
;
190 Elf_Internal_Phdr
*phdr
= elf_tdata (abfd
)->phdr
;
195 for (i
= 0; i
< ehdr
->e_phnum
; i
++)
196 if (phdr
[i
].p_type
== PT_LOAD
&& phdr
[i
].p_align
> align
)
197 align
= phdr
[i
].p_align
;
200 /* Turn it into a mask. */
203 /* If the changes match the alignment requirements, we
204 assume we're using a core file that was generated by the
205 same binary, just prelinked with a different base offset.
206 If it doesn't match, we may have a different binary, the
207 same binary with the dynamic table loaded at an unrelated
208 location, or anything, really. To avoid regressions,
209 don't adjust the base offset in the latter case, although
210 odds are that, if things really changed, debugging won't
212 if ((l_addr
& align
) == ((l_dynaddr
- dynaddr
) & align
))
214 l_addr
= l_dynaddr
- dynaddr
;
216 warning (_(".dynamic section for \"%s\" "
217 "is not at the expected address"), so
->so_name
);
218 warning (_("difference appears to be caused by prelink, "
219 "adjusting expectations"));
222 warning (_(".dynamic section for \"%s\" "
223 "is not at the expected address "
224 "(wrong library or version mismatch?)"), so
->so_name
);
228 so
->lm_info
->l_addr
= l_addr
;
231 return so
->lm_info
->l_addr
;
235 LM_NEXT (struct so_list
*so
)
237 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
239 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_next_offset
,
240 builtin_type_void_data_ptr
);
244 LM_NAME (struct so_list
*so
)
246 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
248 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_name_offset
,
249 builtin_type_void_data_ptr
);
253 IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list
*so
)
255 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
257 /* Assume that everything is a library if the dynamic loader was loaded
258 late by a static executable. */
259 if (bfd_get_section_by_name (exec_bfd
, ".dynamic") == NULL
)
262 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_prev_offset
,
263 builtin_type_void_data_ptr
) == 0;
266 static CORE_ADDR debug_base
; /* Base of dynamic linker structures */
268 /* Validity flag for debug_loader_offset. */
269 static int debug_loader_offset_p
;
271 /* Load address for the dynamic linker, inferred. */
272 static CORE_ADDR debug_loader_offset
;
274 /* Name of the dynamic linker, valid if debug_loader_offset_p. */
275 static char *debug_loader_name
;
277 /* Load map address for the main executable. */
278 static CORE_ADDR main_lm_addr
;
280 /* Local function prototypes */
282 static int match_main (char *);
284 static CORE_ADDR
bfd_lookup_symbol (bfd
*, char *);
290 bfd_lookup_symbol -- lookup the value for a specific symbol
294 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
298 An expensive way to lookup the value of a single symbol for
299 bfd's that are only temporary anyway. This is used by the
300 shared library support to find the address of the debugger
301 notification routine in the shared library.
303 The returned symbol may be in a code or data section; functions
304 will normally be in a code section, but may be in a data section
305 if this architecture uses function descriptors.
307 Note that 0 is specifically allowed as an error return (no
312 bfd_lookup_symbol (bfd
*abfd
, char *symname
)
316 asymbol
**symbol_table
;
317 unsigned int number_of_symbols
;
319 struct cleanup
*back_to
;
320 CORE_ADDR symaddr
= 0;
322 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
324 if (storage_needed
> 0)
326 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
327 back_to
= make_cleanup (xfree
, symbol_table
);
328 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
330 for (i
= 0; i
< number_of_symbols
; i
++)
332 sym
= *symbol_table
++;
333 if (strcmp (sym
->name
, symname
) == 0
334 && (sym
->section
->flags
& (SEC_CODE
| SEC_DATA
)) != 0)
336 /* BFD symbols are section relative. */
337 symaddr
= sym
->value
+ sym
->section
->vma
;
341 do_cleanups (back_to
);
347 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
348 have to check the dynamic string table too. */
350 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
352 if (storage_needed
> 0)
354 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
355 back_to
= make_cleanup (xfree
, symbol_table
);
356 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
358 for (i
= 0; i
< number_of_symbols
; i
++)
360 sym
= *symbol_table
++;
362 if (strcmp (sym
->name
, symname
) == 0
363 && (sym
->section
->flags
& (SEC_CODE
| SEC_DATA
)) != 0)
365 /* BFD symbols are section relative. */
366 symaddr
= sym
->value
+ sym
->section
->vma
;
370 do_cleanups (back_to
);
376 /* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
377 returned and the corresponding PTR is set. */
380 scan_dyntag (int dyntag
, bfd
*abfd
, CORE_ADDR
*ptr
)
382 int arch_size
, step
, sect_size
;
384 CORE_ADDR dyn_ptr
, dyn_addr
;
385 gdb_byte
*bufend
, *bufstart
, *buf
;
386 Elf32_External_Dyn
*x_dynp_32
;
387 Elf64_External_Dyn
*x_dynp_64
;
388 struct bfd_section
*sect
;
392 arch_size
= bfd_get_arch_size (abfd
);
396 /* Find the start address of the .dynamic section. */
397 sect
= bfd_get_section_by_name (abfd
, ".dynamic");
400 dyn_addr
= bfd_section_vma (abfd
, sect
);
402 /* Read in .dynamic from the BFD. We will get the actual value
403 from memory later. */
404 sect_size
= bfd_section_size (abfd
, sect
);
405 buf
= bufstart
= alloca (sect_size
);
406 if (!bfd_get_section_contents (abfd
, sect
,
410 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
411 step
= (arch_size
== 32) ? sizeof (Elf32_External_Dyn
)
412 : sizeof (Elf64_External_Dyn
);
413 for (bufend
= buf
+ sect_size
;
419 x_dynp_32
= (Elf32_External_Dyn
*) buf
;
420 dyn_tag
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_tag
);
421 dyn_ptr
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_un
.d_ptr
);
425 x_dynp_64
= (Elf64_External_Dyn
*) buf
;
426 dyn_tag
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_tag
);
427 dyn_ptr
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_un
.d_ptr
);
429 if (dyn_tag
== DT_NULL
)
431 if (dyn_tag
== dyntag
)
433 /* If requested, try to read the runtime value of this .dynamic
440 ptr_addr
= dyn_addr
+ (buf
- bufstart
) + arch_size
/ 8;
441 if (target_read_memory (ptr_addr
, ptr_buf
, arch_size
/ 8) == 0)
442 dyn_ptr
= extract_typed_address (ptr_buf
,
443 builtin_type_void_data_ptr
);
458 elf_locate_base -- locate the base address of dynamic linker structs
459 for SVR4 elf targets.
463 CORE_ADDR elf_locate_base (void)
467 For SVR4 elf targets the address of the dynamic linker's runtime
468 structure is contained within the dynamic info section in the
469 executable file. The dynamic section is also mapped into the
470 inferior address space. Because the runtime loader fills in the
471 real address before starting the inferior, we have to read in the
472 dynamic info section from the inferior address space.
473 If there are any errors while trying to find the address, we
474 silently return 0, otherwise the found address is returned.
479 elf_locate_base (void)
481 struct minimal_symbol
*msymbol
;
484 /* Look for DT_MIPS_RLD_MAP first. MIPS executables use this
485 instead of DT_DEBUG, although they sometimes contain an unused
487 if (scan_dyntag (DT_MIPS_RLD_MAP
, exec_bfd
, &dyn_ptr
))
490 int pbuf_size
= TYPE_LENGTH (builtin_type_void_data_ptr
);
491 pbuf
= alloca (pbuf_size
);
492 /* DT_MIPS_RLD_MAP contains a pointer to the address
493 of the dynamic link structure. */
494 if (target_read_memory (dyn_ptr
, pbuf
, pbuf_size
))
496 return extract_typed_address (pbuf
, builtin_type_void_data_ptr
);
500 if (scan_dyntag (DT_DEBUG
, exec_bfd
, &dyn_ptr
))
503 /* This may be a static executable. Look for the symbol
504 conventionally named _r_debug, as a last resort. */
505 msymbol
= lookup_minimal_symbol ("_r_debug", NULL
, symfile_objfile
);
507 return SYMBOL_VALUE_ADDRESS (msymbol
);
509 /* DT_DEBUG entry not found. */
517 locate_base -- locate the base address of dynamic linker structs
521 CORE_ADDR locate_base (void)
525 For both the SunOS and SVR4 shared library implementations, if the
526 inferior executable has been linked dynamically, there is a single
527 address somewhere in the inferior's data space which is the key to
528 locating all of the dynamic linker's runtime structures. This
529 address is the value of the debug base symbol. The job of this
530 function is to find and return that address, or to return 0 if there
531 is no such address (the executable is statically linked for example).
533 For SunOS, the job is almost trivial, since the dynamic linker and
534 all of it's structures are statically linked to the executable at
535 link time. Thus the symbol for the address we are looking for has
536 already been added to the minimal symbol table for the executable's
537 objfile at the time the symbol file's symbols were read, and all we
538 have to do is look it up there. Note that we explicitly do NOT want
539 to find the copies in the shared library.
541 The SVR4 version is a bit more complicated because the address
542 is contained somewhere in the dynamic info section. We have to go
543 to a lot more work to discover the address of the debug base symbol.
544 Because of this complexity, we cache the value we find and return that
545 value on subsequent invocations. Note there is no copy in the
546 executable symbol tables.
553 /* Check to see if we have a currently valid address, and if so, avoid
554 doing all this work again and just return the cached address. If
555 we have no cached address, try to locate it in the dynamic info
556 section for ELF executables. There's no point in doing any of this
557 though if we don't have some link map offsets to work with. */
559 if (debug_base
== 0 && svr4_have_link_map_offsets ())
562 && bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
563 debug_base
= elf_locate_base ();
568 /* Find the first element in the inferior's dynamic link map, and
569 return its address in the inferior.
571 FIXME: Perhaps we should validate the info somehow, perhaps by
572 checking r_version for a known version number, or r_state for
576 solib_svr4_r_map (void)
578 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
580 return read_memory_typed_address (debug_base
+ lmo
->r_map_offset
,
581 builtin_type_void_data_ptr
);
584 /* Find r_brk from the inferior's debug base. */
587 solib_svr4_r_brk (void)
589 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
591 return read_memory_typed_address (debug_base
+ lmo
->r_brk_offset
,
592 builtin_type_void_data_ptr
);
595 /* Find the link map for the dynamic linker (if it is not in the
596 normal list of loaded shared objects). */
599 solib_svr4_r_ldsomap (void)
601 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
604 /* Check version, and return zero if `struct r_debug' doesn't have
605 the r_ldsomap member. */
606 version
= read_memory_unsigned_integer (debug_base
+ lmo
->r_version_offset
,
607 lmo
->r_version_size
);
608 if (version
< 2 || lmo
->r_ldsomap_offset
== -1)
611 return read_memory_typed_address (debug_base
+ lmo
->r_ldsomap_offset
,
612 builtin_type_void_data_ptr
);
619 open_symbol_file_object
623 void open_symbol_file_object (void *from_tty)
627 If no open symbol file, attempt to locate and open the main symbol
628 file. On SVR4 systems, this is the first link map entry. If its
629 name is here, we can open it. Useful when attaching to a process
630 without first loading its symbol file.
632 If FROM_TTYP dereferences to a non-zero integer, allow messages to
633 be printed. This parameter is a pointer rather than an int because
634 open_symbol_file_object() is called via catch_errors() and
635 catch_errors() requires a pointer argument. */
638 open_symbol_file_object (void *from_ttyp
)
640 CORE_ADDR lm
, l_name
;
643 int from_tty
= *(int *)from_ttyp
;
644 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
645 int l_name_size
= TYPE_LENGTH (builtin_type_void_data_ptr
);
646 gdb_byte
*l_name_buf
= xmalloc (l_name_size
);
647 struct cleanup
*cleanups
= make_cleanup (xfree
, l_name_buf
);
650 if (!query ("Attempt to reload symbols from process? "))
653 /* Always locate the debug struct, in case it has moved. */
655 if (locate_base () == 0)
656 return 0; /* failed somehow... */
658 /* First link map member should be the executable. */
659 lm
= solib_svr4_r_map ();
661 return 0; /* failed somehow... */
663 /* Read address of name from target memory to GDB. */
664 read_memory (lm
+ lmo
->l_name_offset
, l_name_buf
, l_name_size
);
666 /* Convert the address to host format. */
667 l_name
= extract_typed_address (l_name_buf
, builtin_type_void_data_ptr
);
669 /* Free l_name_buf. */
670 do_cleanups (cleanups
);
673 return 0; /* No filename. */
675 /* Now fetch the filename from target memory. */
676 target_read_string (l_name
, &filename
, SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
677 make_cleanup (xfree
, filename
);
681 warning (_("failed to read exec filename from attached file: %s"),
682 safe_strerror (errcode
));
686 /* Have a pathname: read the symbol file. */
687 symbol_file_add_main (filename
, from_tty
);
692 /* If no shared library information is available from the dynamic
693 linker, build a fallback list from other sources. */
695 static struct so_list
*
696 svr4_default_sos (void)
698 struct so_list
*head
= NULL
;
699 struct so_list
**link_ptr
= &head
;
701 if (debug_loader_offset_p
)
703 struct so_list
*new = XZALLOC (struct so_list
);
705 new->lm_info
= xmalloc (sizeof (struct lm_info
));
707 /* Nothing will ever check the cached copy of the link
708 map if we set l_addr. */
709 new->lm_info
->l_addr
= debug_loader_offset
;
710 new->lm_info
->lm_addr
= 0;
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_addr
= lm
;
775 new->lm_info
->lm
= xzalloc (lmo
->link_map_size
);
776 make_cleanup (xfree
, new->lm_info
->lm
);
778 read_memory (lm
, new->lm_info
->lm
, lmo
->link_map_size
);
782 /* For SVR4 versions, the first entry in the link map is for the
783 inferior executable, so we must ignore it. For some versions of
784 SVR4, it has no name. For others (Solaris 2.3 for example), it
785 does have a name, so we can no longer use a missing name to
786 decide when to ignore it. */
787 if (IGNORE_FIRST_LINK_MAP_ENTRY (new) && ldsomap
== 0)
789 main_lm_addr
= new->lm_info
->lm_addr
;
797 /* Extract this shared object's name. */
798 target_read_string (LM_NAME (new), &buffer
,
799 SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
801 warning (_("Can't read pathname for load map: %s."),
802 safe_strerror (errcode
));
805 strncpy (new->so_name
, buffer
, SO_NAME_MAX_PATH_SIZE
- 1);
806 new->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
807 strcpy (new->so_original_name
, new->so_name
);
811 /* If this entry has no name, or its name matches the name
812 for the main executable, don't include it in the list. */
813 if (! new->so_name
[0]
814 || match_main (new->so_name
))
820 link_ptr
= &new->next
;
824 /* On Solaris, the dynamic linker is not in the normal list of
825 shared objects, so make sure we pick it up too. Having
826 symbol information for the dynamic linker is quite crucial
827 for skipping dynamic linker resolver code. */
828 if (lm
== 0 && ldsomap
== 0)
829 lm
= ldsomap
= solib_svr4_r_ldsomap ();
831 discard_cleanups (old_chain
);
835 return svr4_default_sos ();
840 /* Get the address of the link_map for a given OBJFILE. */
843 svr4_fetch_objfile_link_map (struct objfile
*objfile
)
847 /* Cause svr4_current_sos() to be run if it hasn't been already. */
848 if (main_lm_addr
== 0)
849 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
851 /* svr4_current_sos() will set main_lm_addr for the main executable. */
852 if (objfile
== symfile_objfile
)
855 /* The other link map addresses may be found by examining the list
856 of shared libraries. */
857 for (so
= master_so_list (); so
; so
= so
->next
)
858 if (so
->objfile
== objfile
)
859 return so
->lm_info
->lm_addr
;
865 /* On some systems, the only way to recognize the link map entry for
866 the main executable file is by looking at its name. Return
867 non-zero iff SONAME matches one of the known main executable names. */
870 match_main (char *soname
)
874 for (mainp
= main_name_list
; *mainp
!= NULL
; mainp
++)
876 if (strcmp (soname
, *mainp
) == 0)
883 /* Return 1 if PC lies in the dynamic symbol resolution code of the
884 SVR4 run time loader. */
885 static CORE_ADDR interp_text_sect_low
;
886 static CORE_ADDR interp_text_sect_high
;
887 static CORE_ADDR interp_plt_sect_low
;
888 static CORE_ADDR interp_plt_sect_high
;
891 svr4_in_dynsym_resolve_code (CORE_ADDR pc
)
893 return ((pc
>= interp_text_sect_low
&& pc
< interp_text_sect_high
)
894 || (pc
>= interp_plt_sect_low
&& pc
< interp_plt_sect_high
)
895 || in_plt_section (pc
, NULL
));
898 /* Given an executable's ABFD and target, compute the entry-point
902 exec_entry_point (struct bfd
*abfd
, struct target_ops
*targ
)
904 /* KevinB wrote ... for most targets, the address returned by
905 bfd_get_start_address() is the entry point for the start
906 function. But, for some targets, bfd_get_start_address() returns
907 the address of a function descriptor from which the entry point
908 address may be extracted. This address is extracted by
909 gdbarch_convert_from_func_ptr_addr(). The method
910 gdbarch_convert_from_func_ptr_addr() is the merely the identify
911 function for targets which don't use function descriptors. */
912 return gdbarch_convert_from_func_ptr_addr (target_gdbarch
,
913 bfd_get_start_address (abfd
),
921 enable_break -- arrange for dynamic linker to hit breakpoint
925 int enable_break (void)
929 Both the SunOS and the SVR4 dynamic linkers have, as part of their
930 debugger interface, support for arranging for the inferior to hit
931 a breakpoint after mapping in the shared libraries. This function
932 enables that breakpoint.
934 For SunOS, there is a special flag location (in_debugger) which we
935 set to 1. When the dynamic linker sees this flag set, it will set
936 a breakpoint at a location known only to itself, after saving the
937 original contents of that place and the breakpoint address itself,
938 in it's own internal structures. When we resume the inferior, it
939 will eventually take a SIGTRAP when it runs into the breakpoint.
940 We handle this (in a different place) by restoring the contents of
941 the breakpointed location (which is only known after it stops),
942 chasing around to locate the shared libraries that have been
943 loaded, then resuming.
945 For SVR4, the debugger interface structure contains a member (r_brk)
946 which is statically initialized at the time the shared library is
947 built, to the offset of a function (_r_debug_state) which is guaran-
948 teed to be called once before mapping in a library, and again when
949 the mapping is complete. At the time we are examining this member,
950 it contains only the unrelocated offset of the function, so we have
951 to do our own relocation. Later, when the dynamic linker actually
952 runs, it relocates r_brk to be the actual address of _r_debug_state().
954 The debugger interface structure also contains an enumeration which
955 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
956 depending upon whether or not the library is being mapped or unmapped,
957 and then set to RT_CONSISTENT after the library is mapped/unmapped.
963 struct minimal_symbol
*msymbol
;
965 asection
*interp_sect
;
968 /* First, remove all the solib event breakpoints. Their addresses
969 may have changed since the last time we ran the program. */
970 remove_solib_event_breakpoints ();
972 interp_text_sect_low
= interp_text_sect_high
= 0;
973 interp_plt_sect_low
= interp_plt_sect_high
= 0;
975 /* If we already have a shared library list in the target, and
976 r_debug contains r_brk, set the breakpoint there - this should
977 mean r_brk has already been relocated. Assume the dynamic linker
978 is the object containing r_brk. */
980 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
982 if (debug_base
&& solib_svr4_r_map () != 0)
983 sym_addr
= solib_svr4_r_brk ();
987 struct obj_section
*os
;
989 sym_addr
= gdbarch_addr_bits_remove
990 (target_gdbarch
, gdbarch_convert_from_func_ptr_addr (target_gdbarch
,
994 os
= find_pc_section (sym_addr
);
997 /* Record the relocated start and end address of the dynamic linker
998 text and plt section for svr4_in_dynsym_resolve_code. */
1000 CORE_ADDR load_addr
;
1002 tmp_bfd
= os
->objfile
->obfd
;
1003 load_addr
= ANOFFSET (os
->objfile
->section_offsets
,
1004 os
->objfile
->sect_index_text
);
1006 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
1009 interp_text_sect_low
=
1010 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1011 interp_text_sect_high
=
1012 interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1014 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
1017 interp_plt_sect_low
=
1018 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1019 interp_plt_sect_high
=
1020 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1023 create_solib_event_breakpoint (sym_addr
);
1028 /* Find the .interp section; if not found, warn the user and drop
1029 into the old breakpoint at symbol code. */
1030 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
1033 unsigned int interp_sect_size
;
1035 CORE_ADDR load_addr
= 0;
1036 int load_addr_found
= 0;
1037 int loader_found_in_list
= 0;
1039 bfd
*tmp_bfd
= NULL
;
1040 struct target_ops
*tmp_bfd_target
;
1042 char *tmp_pathname
= NULL
;
1044 /* Read the contents of the .interp section into a local buffer;
1045 the contents specify the dynamic linker this program uses. */
1047 interp_sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
1048 buf
= alloca (interp_sect_size
);
1049 bfd_get_section_contents (exec_bfd
, interp_sect
,
1050 buf
, 0, interp_sect_size
);
1052 /* Now we need to figure out where the dynamic linker was
1053 loaded so that we can load its symbols and place a breakpoint
1054 in the dynamic linker itself.
1056 This address is stored on the stack. However, I've been unable
1057 to find any magic formula to find it for Solaris (appears to
1058 be trivial on GNU/Linux). Therefore, we have to try an alternate
1059 mechanism to find the dynamic linker's base address. */
1061 tmp_fd
= solib_open (buf
, &tmp_pathname
);
1063 tmp_bfd
= bfd_fopen (tmp_pathname
, gnutarget
, FOPEN_RB
, tmp_fd
);
1065 if (tmp_bfd
== NULL
)
1066 goto bkpt_at_symbol
;
1068 /* Make sure the dynamic linker's really a useful object. */
1069 if (!bfd_check_format (tmp_bfd
, bfd_object
))
1071 warning (_("Unable to grok dynamic linker %s as an object file"), buf
);
1072 bfd_close (tmp_bfd
);
1073 goto bkpt_at_symbol
;
1076 /* Now convert the TMP_BFD into a target. That way target, as
1077 well as BFD operations can be used. Note that closing the
1078 target will also close the underlying bfd. */
1079 tmp_bfd_target
= target_bfd_reopen (tmp_bfd
);
1081 /* On a running target, we can get the dynamic linker's base
1082 address from the shared library table. */
1083 so
= master_so_list ();
1086 if (svr4_same_1 (buf
, so
->so_original_name
))
1088 load_addr_found
= 1;
1089 loader_found_in_list
= 1;
1090 load_addr
= LM_ADDR_CHECK (so
, tmp_bfd
);
1096 /* If we were not able to find the base address of the loader
1097 from our so_list, then try using the AT_BASE auxilliary entry. */
1098 if (!load_addr_found
)
1099 if (target_auxv_search (¤t_target
, AT_BASE
, &load_addr
) > 0)
1100 load_addr_found
= 1;
1102 /* Otherwise we find the dynamic linker's base address by examining
1103 the current pc (which should point at the entry point for the
1104 dynamic linker) and subtracting the offset of the entry point.
1106 This is more fragile than the previous approaches, but is a good
1107 fallback method because it has actually been working well in
1109 if (!load_addr_found
)
1110 load_addr
= (read_pc ()
1111 - exec_entry_point (tmp_bfd
, tmp_bfd_target
));
1113 if (!loader_found_in_list
)
1115 debug_loader_name
= xstrdup (buf
);
1116 debug_loader_offset_p
= 1;
1117 debug_loader_offset
= load_addr
;
1118 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
1121 /* Record the relocated start and end address of the dynamic linker
1122 text and plt section for svr4_in_dynsym_resolve_code. */
1123 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
1126 interp_text_sect_low
=
1127 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1128 interp_text_sect_high
=
1129 interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1131 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
1134 interp_plt_sect_low
=
1135 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1136 interp_plt_sect_high
=
1137 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1140 /* Now try to set a breakpoint in the dynamic linker. */
1141 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1143 sym_addr
= bfd_lookup_symbol (tmp_bfd
, *bkpt_namep
);
1149 /* Convert 'sym_addr' from a function pointer to an address.
1150 Because we pass tmp_bfd_target instead of the current
1151 target, this will always produce an unrelocated value. */
1152 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch
,
1156 /* We're done with both the temporary bfd and target. Remember,
1157 closing the target closes the underlying bfd. */
1158 target_close (tmp_bfd_target
, 0);
1162 create_solib_event_breakpoint (load_addr
+ sym_addr
);
1166 /* For whatever reason we couldn't set a breakpoint in the dynamic
1167 linker. Warn and drop into the old code. */
1169 xfree (tmp_pathname
);
1170 warning (_("Unable to find dynamic linker breakpoint function.\n"
1171 "GDB will be unable to debug shared library initializers\n"
1172 "and track explicitly loaded dynamic code."));
1175 /* Scan through the lists of symbols, trying to look up the symbol and
1176 set a breakpoint there. Terminate loop when we/if we succeed. */
1178 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1180 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
1181 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
1183 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol
));
1188 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1190 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
1191 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
1193 create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol
));
1204 special_symbol_handling -- additional shared library symbol handling
1208 void special_symbol_handling ()
1212 Once the symbols from a shared object have been loaded in the usual
1213 way, we are called to do any system specific symbol handling that
1216 For SunOS4, this consisted of grunging around in the dynamic
1217 linkers structures to find symbol definitions for "common" symbols
1218 and adding them to the minimal symbol table for the runtime common
1221 However, for SVR4, there's nothing to do.
1226 svr4_special_symbol_handling (void)
1230 /* Relocate the main executable. This function should be called upon
1231 stopping the inferior process at the entry point to the program.
1232 The entry point from BFD is compared to the PC and if they are
1233 different, the main executable is relocated by the proper amount.
1235 As written it will only attempt to relocate executables which
1236 lack interpreter sections. It seems likely that only dynamic
1237 linker executables will get relocated, though it should work
1238 properly for a position-independent static executable as well. */
1241 svr4_relocate_main_executable (void)
1243 asection
*interp_sect
;
1244 CORE_ADDR pc
= read_pc ();
1246 /* Decide if the objfile needs to be relocated. As indicated above,
1247 we will only be here when execution is stopped at the beginning
1248 of the program. Relocation is necessary if the address at which
1249 we are presently stopped differs from the start address stored in
1250 the executable AND there's no interpreter section. The condition
1251 regarding the interpreter section is very important because if
1252 there *is* an interpreter section, execution will begin there
1253 instead. When there is an interpreter section, the start address
1254 is (presumably) used by the interpreter at some point to start
1255 execution of the program.
1257 If there is an interpreter, it is normal for it to be set to an
1258 arbitrary address at the outset. The job of finding it is
1259 handled in enable_break().
1261 So, to summarize, relocations are necessary when there is no
1262 interpreter section and the start address obtained from the
1263 executable is different from the address at which GDB is
1266 [ The astute reader will note that we also test to make sure that
1267 the executable in question has the DYNAMIC flag set. It is my
1268 opinion that this test is unnecessary (undesirable even). It
1269 was added to avoid inadvertent relocation of an executable
1270 whose e_type member in the ELF header is not ET_DYN. There may
1271 be a time in the future when it is desirable to do relocations
1272 on other types of files as well in which case this condition
1273 should either be removed or modified to accomodate the new file
1274 type. (E.g, an ET_EXEC executable which has been built to be
1275 position-independent could safely be relocated by the OS if
1276 desired. It is true that this violates the ABI, but the ABI
1277 has been known to be bent from time to time.) - Kevin, Nov 2000. ]
1280 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
1281 if (interp_sect
== NULL
1282 && (bfd_get_file_flags (exec_bfd
) & DYNAMIC
) != 0
1283 && (exec_entry_point (exec_bfd
, &exec_ops
) != pc
))
1285 struct cleanup
*old_chain
;
1286 struct section_offsets
*new_offsets
;
1288 CORE_ADDR displacement
;
1290 /* It is necessary to relocate the objfile. The amount to
1291 relocate by is simply the address at which we are stopped
1292 minus the starting address from the executable.
1294 We relocate all of the sections by the same amount. This
1295 behavior is mandated by recent editions of the System V ABI.
1296 According to the System V Application Binary Interface,
1297 Edition 4.1, page 5-5:
1299 ... Though the system chooses virtual addresses for
1300 individual processes, it maintains the segments' relative
1301 positions. Because position-independent code uses relative
1302 addressesing between segments, the difference between
1303 virtual addresses in memory must match the difference
1304 between virtual addresses in the file. The difference
1305 between the virtual address of any segment in memory and
1306 the corresponding virtual address in the file is thus a
1307 single constant value for any one executable or shared
1308 object in a given process. This difference is the base
1309 address. One use of the base address is to relocate the
1310 memory image of the program during dynamic linking.
1312 The same language also appears in Edition 4.0 of the System V
1313 ABI and is left unspecified in some of the earlier editions. */
1315 displacement
= pc
- exec_entry_point (exec_bfd
, &exec_ops
);
1318 new_offsets
= xcalloc (symfile_objfile
->num_sections
,
1319 sizeof (struct section_offsets
));
1320 old_chain
= make_cleanup (xfree
, new_offsets
);
1322 for (i
= 0; i
< symfile_objfile
->num_sections
; i
++)
1324 if (displacement
!= ANOFFSET (symfile_objfile
->section_offsets
, i
))
1326 new_offsets
->offsets
[i
] = displacement
;
1330 objfile_relocate (symfile_objfile
, new_offsets
);
1332 do_cleanups (old_chain
);
1340 svr4_solib_create_inferior_hook -- shared library startup support
1344 void svr4_solib_create_inferior_hook ()
1348 When gdb starts up the inferior, it nurses it along (through the
1349 shell) until it is ready to execute it's first instruction. At this
1350 point, this function gets called via expansion of the macro
1351 SOLIB_CREATE_INFERIOR_HOOK.
1353 For SunOS executables, this first instruction is typically the
1354 one at "_start", or a similar text label, regardless of whether
1355 the executable is statically or dynamically linked. The runtime
1356 startup code takes care of dynamically linking in any shared
1357 libraries, once gdb allows the inferior to continue.
1359 For SVR4 executables, this first instruction is either the first
1360 instruction in the dynamic linker (for dynamically linked
1361 executables) or the instruction at "start" for statically linked
1362 executables. For dynamically linked executables, the system
1363 first exec's /lib/libc.so.N, which contains the dynamic linker,
1364 and starts it running. The dynamic linker maps in any needed
1365 shared libraries, maps in the actual user executable, and then
1366 jumps to "start" in the user executable.
1368 For both SunOS shared libraries, and SVR4 shared libraries, we
1369 can arrange to cooperate with the dynamic linker to discover the
1370 names of shared libraries that are dynamically linked, and the
1371 base addresses to which they are linked.
1373 This function is responsible for discovering those names and
1374 addresses, and saving sufficient information about them to allow
1375 their symbols to be read at a later time.
1379 Between enable_break() and disable_break(), this code does not
1380 properly handle hitting breakpoints which the user might have
1381 set in the startup code or in the dynamic linker itself. Proper
1382 handling will probably have to wait until the implementation is
1383 changed to use the "breakpoint handler function" method.
1385 Also, what if child has exit()ed? Must exit loop somehow.
1389 svr4_solib_create_inferior_hook (void)
1391 /* Relocate the main executable if necessary. */
1392 svr4_relocate_main_executable ();
1394 if (!svr4_have_link_map_offsets ())
1397 if (!enable_break ())
1400 #if defined(_SCO_DS)
1401 /* SCO needs the loop below, other systems should be using the
1402 special shared library breakpoints and the shared library breakpoint
1405 Now run the target. It will eventually hit the breakpoint, at
1406 which point all of the libraries will have been mapped in and we
1407 can go groveling around in the dynamic linker structures to find
1408 out what we need to know about them. */
1410 clear_proceed_status ();
1411 stop_soon
= STOP_QUIETLY
;
1412 stop_signal
= TARGET_SIGNAL_0
;
1415 target_resume (pid_to_ptid (-1), 0, stop_signal
);
1416 wait_for_inferior (0);
1418 while (stop_signal
!= TARGET_SIGNAL_TRAP
);
1419 stop_soon
= NO_STOP_QUIETLY
;
1420 #endif /* defined(_SCO_DS) */
1424 svr4_clear_solib (void)
1427 debug_loader_offset_p
= 0;
1428 debug_loader_offset
= 0;
1429 xfree (debug_loader_name
);
1430 debug_loader_name
= NULL
;
1435 svr4_free_so (struct so_list
*so
)
1437 xfree (so
->lm_info
->lm
);
1438 xfree (so
->lm_info
);
1442 /* Clear any bits of ADDR that wouldn't fit in a target-format
1443 data pointer. "Data pointer" here refers to whatever sort of
1444 address the dynamic linker uses to manage its sections. At the
1445 moment, we don't support shared libraries on any processors where
1446 code and data pointers are different sizes.
1448 This isn't really the right solution. What we really need here is
1449 a way to do arithmetic on CORE_ADDR values that respects the
1450 natural pointer/address correspondence. (For example, on the MIPS,
1451 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
1452 sign-extend the value. There, simply truncating the bits above
1453 gdbarch_ptr_bit, as we do below, is no good.) This should probably
1454 be a new gdbarch method or something. */
1456 svr4_truncate_ptr (CORE_ADDR addr
)
1458 if (gdbarch_ptr_bit (target_gdbarch
) == sizeof (CORE_ADDR
) * 8)
1459 /* We don't need to truncate anything, and the bit twiddling below
1460 will fail due to overflow problems. */
1463 return addr
& (((CORE_ADDR
) 1 << gdbarch_ptr_bit (target_gdbarch
)) - 1);
1468 svr4_relocate_section_addresses (struct so_list
*so
,
1469 struct section_table
*sec
)
1471 sec
->addr
= svr4_truncate_ptr (sec
->addr
+ LM_ADDR_CHECK (so
,
1473 sec
->endaddr
= svr4_truncate_ptr (sec
->endaddr
+ LM_ADDR_CHECK (so
,
1478 /* Architecture-specific operations. */
1480 /* Per-architecture data key. */
1481 static struct gdbarch_data
*solib_svr4_data
;
1483 struct solib_svr4_ops
1485 /* Return a description of the layout of `struct link_map'. */
1486 struct link_map_offsets
*(*fetch_link_map_offsets
)(void);
1489 /* Return a default for the architecture-specific operations. */
1492 solib_svr4_init (struct obstack
*obstack
)
1494 struct solib_svr4_ops
*ops
;
1496 ops
= OBSTACK_ZALLOC (obstack
, struct solib_svr4_ops
);
1497 ops
->fetch_link_map_offsets
= NULL
;
1501 /* Set the architecture-specific `struct link_map_offsets' fetcher for
1502 GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */
1505 set_solib_svr4_fetch_link_map_offsets (struct gdbarch
*gdbarch
,
1506 struct link_map_offsets
*(*flmo
) (void))
1508 struct solib_svr4_ops
*ops
= gdbarch_data (gdbarch
, solib_svr4_data
);
1510 ops
->fetch_link_map_offsets
= flmo
;
1512 set_solib_ops (gdbarch
, &svr4_so_ops
);
1515 /* Fetch a link_map_offsets structure using the architecture-specific
1516 `struct link_map_offsets' fetcher. */
1518 static struct link_map_offsets
*
1519 svr4_fetch_link_map_offsets (void)
1521 struct solib_svr4_ops
*ops
= gdbarch_data (target_gdbarch
, solib_svr4_data
);
1523 gdb_assert (ops
->fetch_link_map_offsets
);
1524 return ops
->fetch_link_map_offsets ();
1527 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
1530 svr4_have_link_map_offsets (void)
1532 struct solib_svr4_ops
*ops
= gdbarch_data (target_gdbarch
, solib_svr4_data
);
1533 return (ops
->fetch_link_map_offsets
!= NULL
);
1537 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
1538 `struct r_debug' and a `struct link_map' that are binary compatible
1539 with the origional SVR4 implementation. */
1541 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
1542 for an ILP32 SVR4 system. */
1544 struct link_map_offsets
*
1545 svr4_ilp32_fetch_link_map_offsets (void)
1547 static struct link_map_offsets lmo
;
1548 static struct link_map_offsets
*lmp
= NULL
;
1554 lmo
.r_version_offset
= 0;
1555 lmo
.r_version_size
= 4;
1556 lmo
.r_map_offset
= 4;
1557 lmo
.r_brk_offset
= 8;
1558 lmo
.r_ldsomap_offset
= 20;
1560 /* Everything we need is in the first 20 bytes. */
1561 lmo
.link_map_size
= 20;
1562 lmo
.l_addr_offset
= 0;
1563 lmo
.l_name_offset
= 4;
1564 lmo
.l_ld_offset
= 8;
1565 lmo
.l_next_offset
= 12;
1566 lmo
.l_prev_offset
= 16;
1572 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
1573 for an LP64 SVR4 system. */
1575 struct link_map_offsets
*
1576 svr4_lp64_fetch_link_map_offsets (void)
1578 static struct link_map_offsets lmo
;
1579 static struct link_map_offsets
*lmp
= NULL
;
1585 lmo
.r_version_offset
= 0;
1586 lmo
.r_version_size
= 4;
1587 lmo
.r_map_offset
= 8;
1588 lmo
.r_brk_offset
= 16;
1589 lmo
.r_ldsomap_offset
= 40;
1591 /* Everything we need is in the first 40 bytes. */
1592 lmo
.link_map_size
= 40;
1593 lmo
.l_addr_offset
= 0;
1594 lmo
.l_name_offset
= 8;
1595 lmo
.l_ld_offset
= 16;
1596 lmo
.l_next_offset
= 24;
1597 lmo
.l_prev_offset
= 32;
1604 struct target_so_ops svr4_so_ops
;
1606 /* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a
1607 different rule for symbol lookup. The lookup begins here in the DSO, not in
1608 the main executable. */
1610 static struct symbol
*
1611 elf_lookup_lib_symbol (const struct objfile
*objfile
,
1613 const char *linkage_name
,
1614 const domain_enum domain
)
1616 if (objfile
->obfd
== NULL
1617 || scan_dyntag (DT_SYMBOLIC
, objfile
->obfd
, NULL
) != 1)
1620 return lookup_global_symbol_from_objfile
1621 (objfile
, name
, linkage_name
, domain
);
1624 extern initialize_file_ftype _initialize_svr4_solib
; /* -Wmissing-prototypes */
1627 _initialize_svr4_solib (void)
1629 solib_svr4_data
= gdbarch_data_register_pre_init (solib_svr4_init
);
1631 svr4_so_ops
.relocate_section_addresses
= svr4_relocate_section_addresses
;
1632 svr4_so_ops
.free_so
= svr4_free_so
;
1633 svr4_so_ops
.clear_solib
= svr4_clear_solib
;
1634 svr4_so_ops
.solib_create_inferior_hook
= svr4_solib_create_inferior_hook
;
1635 svr4_so_ops
.special_symbol_handling
= svr4_special_symbol_handling
;
1636 svr4_so_ops
.current_sos
= svr4_current_sos
;
1637 svr4_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
1638 svr4_so_ops
.in_dynsym_resolve_code
= svr4_in_dynsym_resolve_code
;
1639 svr4_so_ops
.lookup_lib_global_symbol
= elf_lookup_lib_symbol
;
1640 svr4_so_ops
.same
= svr4_same
;