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, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "elf/external.h"
25 #include "elf/common.h"
36 #include "gdbthread.h"
39 #include "gdb_assert.h"
43 #include "solib-svr4.h"
45 #include "bfd-target.h"
49 #include "exceptions.h"
51 static struct link_map_offsets
*svr4_fetch_link_map_offsets (void);
52 static int svr4_have_link_map_offsets (void);
53 static void svr4_relocate_main_executable (void);
55 /* Link map info to include in an allocated so_list entry. */
59 /* Pointer to copy of link map from inferior. The type is char *
60 rather than void *, so that we may use byte offsets to find the
61 various fields without the need for a cast. */
64 /* Amount by which addresses in the binary should be relocated to
65 match the inferior. This could most often be taken directly
66 from lm, but when prelinking is involved and the prelink base
67 address changes, we may need a different offset, we want to
68 warn about the difference and compute it only once. */
71 /* The target location of lm. */
75 /* On SVR4 systems, a list of symbols in the dynamic linker where
76 GDB can try to place a breakpoint to monitor shared library
79 If none of these symbols are found, or other errors occur, then
80 SVR4 systems will fall back to using a symbol as the "startup
81 mapping complete" breakpoint address. */
83 static const char * const solib_break_names
[] =
89 "__dl_rtld_db_dlactivity",
95 static const char * const bkpt_names
[] =
103 static const char * const 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 ();
149 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
151 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_addr_offset
,
156 has_lm_dynamic_from_link_map (void)
158 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
160 return lmo
->l_ld_offset
>= 0;
164 lm_dynamic_from_link_map (struct so_list
*so
)
166 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
167 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
169 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_ld_offset
,
174 lm_addr_check (struct so_list
*so
, bfd
*abfd
)
176 if (so
->lm_info
->l_addr
== (CORE_ADDR
)-1)
178 struct bfd_section
*dyninfo_sect
;
179 CORE_ADDR l_addr
, l_dynaddr
, dynaddr
;
181 l_addr
= lm_addr_from_link_map (so
);
183 if (! abfd
|| ! has_lm_dynamic_from_link_map ())
186 l_dynaddr
= lm_dynamic_from_link_map (so
);
188 dyninfo_sect
= bfd_get_section_by_name (abfd
, ".dynamic");
189 if (dyninfo_sect
== NULL
)
192 dynaddr
= bfd_section_vma (abfd
, dyninfo_sect
);
194 if (dynaddr
+ l_addr
!= l_dynaddr
)
196 CORE_ADDR align
= 0x1000;
197 CORE_ADDR minpagesize
= align
;
199 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
201 Elf_Internal_Ehdr
*ehdr
= elf_tdata (abfd
)->elf_header
;
202 Elf_Internal_Phdr
*phdr
= elf_tdata (abfd
)->phdr
;
207 for (i
= 0; i
< ehdr
->e_phnum
; i
++)
208 if (phdr
[i
].p_type
== PT_LOAD
&& phdr
[i
].p_align
> align
)
209 align
= phdr
[i
].p_align
;
211 minpagesize
= get_elf_backend_data (abfd
)->minpagesize
;
214 /* Turn it into a mask. */
217 /* If the changes match the alignment requirements, we
218 assume we're using a core file that was generated by the
219 same binary, just prelinked with a different base offset.
220 If it doesn't match, we may have a different binary, the
221 same binary with the dynamic table loaded at an unrelated
222 location, or anything, really. To avoid regressions,
223 don't adjust the base offset in the latter case, although
224 odds are that, if things really changed, debugging won't
227 One could expect more the condition
228 ((l_addr & align) == 0 && ((l_dynaddr - dynaddr) & align) == 0)
229 but the one below is relaxed for PPC. The PPC kernel supports
230 either 4k or 64k page sizes. To be prepared for 64k pages,
231 PPC ELF files are built using an alignment requirement of 64k.
232 However, when running on a kernel supporting 4k pages, the memory
233 mapping of the library may not actually happen on a 64k boundary!
235 (In the usual case where (l_addr & align) == 0, this check is
236 equivalent to the possibly expected check above.)
238 Even on PPC it must be zero-aligned at least for MINPAGESIZE. */
240 l_addr
= l_dynaddr
- dynaddr
;
242 if ((l_addr
& (minpagesize
- 1)) == 0
243 && (l_addr
& align
) == ((l_dynaddr
- dynaddr
) & align
))
246 printf_unfiltered (_("Using PIC (Position Independent Code) "
247 "prelink displacement %s for \"%s\".\n"),
248 paddress (target_gdbarch
, l_addr
),
253 /* There is no way to verify the library file matches. prelink
254 can during prelinking of an unprelinked file (or unprelinking
255 of a prelinked file) shift the DYNAMIC segment by arbitrary
256 offset without any page size alignment. There is no way to
257 find out the ELF header and/or Program Headers for a limited
258 verification if it they match. One could do a verification
259 of the DYNAMIC segment. Still the found address is the best
260 one GDB could find. */
262 warning (_(".dynamic section for \"%s\" "
263 "is not at the expected address "
264 "(wrong library or version mismatch?)"), so
->so_name
);
269 so
->lm_info
->l_addr
= l_addr
;
272 return so
->lm_info
->l_addr
;
276 lm_next (struct so_list
*so
)
278 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
279 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
281 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_next_offset
,
286 lm_prev (struct so_list
*so
)
288 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
289 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
291 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_prev_offset
,
296 lm_name (struct so_list
*so
)
298 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
299 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
301 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_name_offset
,
306 ignore_first_link_map_entry (struct so_list
*so
)
308 /* Assume that everything is a library if the dynamic loader was loaded
309 late by a static executable. */
310 if (exec_bfd
&& bfd_get_section_by_name (exec_bfd
, ".dynamic") == NULL
)
313 return lm_prev (so
) == 0;
316 /* Per pspace SVR4 specific data. */
320 CORE_ADDR debug_base
; /* Base of dynamic linker structures. */
322 /* Validity flag for debug_loader_offset. */
323 int debug_loader_offset_p
;
325 /* Load address for the dynamic linker, inferred. */
326 CORE_ADDR debug_loader_offset
;
328 /* Name of the dynamic linker, valid if debug_loader_offset_p. */
329 char *debug_loader_name
;
331 /* Load map address for the main executable. */
332 CORE_ADDR main_lm_addr
;
334 CORE_ADDR interp_text_sect_low
;
335 CORE_ADDR interp_text_sect_high
;
336 CORE_ADDR interp_plt_sect_low
;
337 CORE_ADDR interp_plt_sect_high
;
340 /* Per-program-space data key. */
341 static const struct program_space_data
*solib_svr4_pspace_data
;
344 svr4_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
346 struct svr4_info
*info
;
348 info
= program_space_data (pspace
, solib_svr4_pspace_data
);
352 /* Get the current svr4 data. If none is found yet, add it now. This
353 function always returns a valid object. */
355 static struct svr4_info
*
358 struct svr4_info
*info
;
360 info
= program_space_data (current_program_space
, solib_svr4_pspace_data
);
364 info
= XZALLOC (struct svr4_info
);
365 set_program_space_data (current_program_space
, solib_svr4_pspace_data
, info
);
369 /* Local function prototypes */
371 static int match_main (const char *);
377 bfd_lookup_symbol -- lookup the value for a specific symbol
381 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
385 An expensive way to lookup the value of a single symbol for
386 bfd's that are only temporary anyway. This is used by the
387 shared library support to find the address of the debugger
388 notification routine in the shared library.
390 The returned symbol may be in a code or data section; functions
391 will normally be in a code section, but may be in a data section
392 if this architecture uses function descriptors.
394 Note that 0 is specifically allowed as an error return (no
399 bfd_lookup_symbol (bfd
*abfd
, const char *symname
)
403 asymbol
**symbol_table
;
404 unsigned int number_of_symbols
;
406 struct cleanup
*back_to
;
407 CORE_ADDR symaddr
= 0;
409 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
411 if (storage_needed
> 0)
413 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
414 back_to
= make_cleanup (xfree
, symbol_table
);
415 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
417 for (i
= 0; i
< number_of_symbols
; i
++)
419 sym
= *symbol_table
++;
420 if (strcmp (sym
->name
, symname
) == 0
421 && (sym
->section
->flags
& (SEC_CODE
| SEC_DATA
)) != 0)
423 /* BFD symbols are section relative. */
424 symaddr
= sym
->value
+ sym
->section
->vma
;
428 do_cleanups (back_to
);
434 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
435 have to check the dynamic string table too. */
437 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
439 if (storage_needed
> 0)
441 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
442 back_to
= make_cleanup (xfree
, symbol_table
);
443 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
445 for (i
= 0; i
< number_of_symbols
; i
++)
447 sym
= *symbol_table
++;
449 if (strcmp (sym
->name
, symname
) == 0
450 && (sym
->section
->flags
& (SEC_CODE
| SEC_DATA
)) != 0)
452 /* BFD symbols are section relative. */
453 symaddr
= sym
->value
+ sym
->section
->vma
;
457 do_cleanups (back_to
);
464 /* Read program header TYPE from inferior memory. The header is found
465 by scanning the OS auxillary vector.
467 If TYPE == -1, return the program headers instead of the contents of
470 Return a pointer to allocated memory holding the program header contents,
471 or NULL on failure. If sucessful, and unless P_SECT_SIZE is NULL, the
472 size of those contents is returned to P_SECT_SIZE. Likewise, the target
473 architecture size (32-bit or 64-bit) is returned to P_ARCH_SIZE. */
476 read_program_header (int type
, int *p_sect_size
, int *p_arch_size
)
478 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
479 CORE_ADDR at_phdr
, at_phent
, at_phnum
;
480 int arch_size
, sect_size
;
484 /* Get required auxv elements from target. */
485 if (target_auxv_search (¤t_target
, AT_PHDR
, &at_phdr
) <= 0)
487 if (target_auxv_search (¤t_target
, AT_PHENT
, &at_phent
) <= 0)
489 if (target_auxv_search (¤t_target
, AT_PHNUM
, &at_phnum
) <= 0)
491 if (!at_phdr
|| !at_phnum
)
494 /* Determine ELF architecture type. */
495 if (at_phent
== sizeof (Elf32_External_Phdr
))
497 else if (at_phent
== sizeof (Elf64_External_Phdr
))
502 /* Find the requested segment. */
506 sect_size
= at_phent
* at_phnum
;
508 else if (arch_size
== 32)
510 Elf32_External_Phdr phdr
;
513 /* Search for requested PHDR. */
514 for (i
= 0; i
< at_phnum
; i
++)
516 if (target_read_memory (at_phdr
+ i
* sizeof (phdr
),
517 (gdb_byte
*)&phdr
, sizeof (phdr
)))
520 if (extract_unsigned_integer ((gdb_byte
*)phdr
.p_type
,
521 4, byte_order
) == type
)
528 /* Retrieve address and size. */
529 sect_addr
= extract_unsigned_integer ((gdb_byte
*)phdr
.p_vaddr
,
531 sect_size
= extract_unsigned_integer ((gdb_byte
*)phdr
.p_memsz
,
536 Elf64_External_Phdr phdr
;
539 /* Search for requested PHDR. */
540 for (i
= 0; i
< at_phnum
; i
++)
542 if (target_read_memory (at_phdr
+ i
* sizeof (phdr
),
543 (gdb_byte
*)&phdr
, sizeof (phdr
)))
546 if (extract_unsigned_integer ((gdb_byte
*)phdr
.p_type
,
547 4, byte_order
) == type
)
554 /* Retrieve address and size. */
555 sect_addr
= extract_unsigned_integer ((gdb_byte
*)phdr
.p_vaddr
,
557 sect_size
= extract_unsigned_integer ((gdb_byte
*)phdr
.p_memsz
,
561 /* Read in requested program header. */
562 buf
= xmalloc (sect_size
);
563 if (target_read_memory (sect_addr
, buf
, sect_size
))
570 *p_arch_size
= arch_size
;
572 *p_sect_size
= sect_size
;
578 /* Return program interpreter string. */
580 find_program_interpreter (void)
582 gdb_byte
*buf
= NULL
;
584 /* If we have an exec_bfd, use its section table. */
586 && bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
588 struct bfd_section
*interp_sect
;
590 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
591 if (interp_sect
!= NULL
)
593 int sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
595 buf
= xmalloc (sect_size
);
596 bfd_get_section_contents (exec_bfd
, interp_sect
, buf
, 0, sect_size
);
600 /* If we didn't find it, use the target auxillary vector. */
602 buf
= read_program_header (PT_INTERP
, NULL
, NULL
);
608 /* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
609 returned and the corresponding PTR is set. */
612 scan_dyntag (int dyntag
, bfd
*abfd
, CORE_ADDR
*ptr
)
614 int arch_size
, step
, sect_size
;
616 CORE_ADDR dyn_ptr
, dyn_addr
;
617 gdb_byte
*bufend
, *bufstart
, *buf
;
618 Elf32_External_Dyn
*x_dynp_32
;
619 Elf64_External_Dyn
*x_dynp_64
;
620 struct bfd_section
*sect
;
621 struct target_section
*target_section
;
626 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
629 arch_size
= bfd_get_arch_size (abfd
);
633 /* Find the start address of the .dynamic section. */
634 sect
= bfd_get_section_by_name (abfd
, ".dynamic");
638 for (target_section
= current_target_sections
->sections
;
639 target_section
< current_target_sections
->sections_end
;
641 if (sect
== target_section
->the_bfd_section
)
643 if (target_section
< current_target_sections
->sections_end
)
644 dyn_addr
= target_section
->addr
;
647 /* ABFD may come from OBJFILE acting only as a symbol file without being
648 loaded into the target (see add_symbol_file_command). This case is
649 such fallback to the file VMA address without the possibility of
650 having the section relocated to its actual in-memory address. */
652 dyn_addr
= bfd_section_vma (abfd
, sect
);
655 /* Read in .dynamic from the BFD. We will get the actual value
656 from memory later. */
657 sect_size
= bfd_section_size (abfd
, sect
);
658 buf
= bufstart
= alloca (sect_size
);
659 if (!bfd_get_section_contents (abfd
, sect
,
663 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
664 step
= (arch_size
== 32) ? sizeof (Elf32_External_Dyn
)
665 : sizeof (Elf64_External_Dyn
);
666 for (bufend
= buf
+ sect_size
;
672 x_dynp_32
= (Elf32_External_Dyn
*) buf
;
673 dyn_tag
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_tag
);
674 dyn_ptr
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_un
.d_ptr
);
678 x_dynp_64
= (Elf64_External_Dyn
*) buf
;
679 dyn_tag
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_tag
);
680 dyn_ptr
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_un
.d_ptr
);
682 if (dyn_tag
== DT_NULL
)
684 if (dyn_tag
== dyntag
)
686 /* If requested, try to read the runtime value of this .dynamic
690 struct type
*ptr_type
;
694 ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
695 ptr_addr
= dyn_addr
+ (buf
- bufstart
) + arch_size
/ 8;
696 if (target_read_memory (ptr_addr
, ptr_buf
, arch_size
/ 8) == 0)
697 dyn_ptr
= extract_typed_address (ptr_buf
, ptr_type
);
707 /* Scan for DYNTAG in .dynamic section of the target's main executable,
708 found by consulting the OS auxillary vector. If DYNTAG is found 1 is
709 returned and the corresponding PTR is set. */
712 scan_dyntag_auxv (int dyntag
, CORE_ADDR
*ptr
)
714 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
715 int sect_size
, arch_size
, step
;
718 gdb_byte
*bufend
, *bufstart
, *buf
;
720 /* Read in .dynamic section. */
721 buf
= bufstart
= read_program_header (PT_DYNAMIC
, §_size
, &arch_size
);
725 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
726 step
= (arch_size
== 32) ? sizeof (Elf32_External_Dyn
)
727 : sizeof (Elf64_External_Dyn
);
728 for (bufend
= buf
+ sect_size
;
734 Elf32_External_Dyn
*dynp
= (Elf32_External_Dyn
*) buf
;
736 dyn_tag
= extract_unsigned_integer ((gdb_byte
*) dynp
->d_tag
,
738 dyn_ptr
= extract_unsigned_integer ((gdb_byte
*) dynp
->d_un
.d_ptr
,
743 Elf64_External_Dyn
*dynp
= (Elf64_External_Dyn
*) buf
;
745 dyn_tag
= extract_unsigned_integer ((gdb_byte
*) dynp
->d_tag
,
747 dyn_ptr
= extract_unsigned_integer ((gdb_byte
*) dynp
->d_un
.d_ptr
,
750 if (dyn_tag
== DT_NULL
)
753 if (dyn_tag
== dyntag
)
772 elf_locate_base -- locate the base address of dynamic linker structs
773 for SVR4 elf targets.
777 CORE_ADDR elf_locate_base (void)
781 For SVR4 elf targets the address of the dynamic linker's runtime
782 structure is contained within the dynamic info section in the
783 executable file. The dynamic section is also mapped into the
784 inferior address space. Because the runtime loader fills in the
785 real address before starting the inferior, we have to read in the
786 dynamic info section from the inferior address space.
787 If there are any errors while trying to find the address, we
788 silently return 0, otherwise the found address is returned.
793 elf_locate_base (void)
795 struct minimal_symbol
*msymbol
;
798 /* Look for DT_MIPS_RLD_MAP first. MIPS executables use this
799 instead of DT_DEBUG, although they sometimes contain an unused
801 if (scan_dyntag (DT_MIPS_RLD_MAP
, exec_bfd
, &dyn_ptr
)
802 || scan_dyntag_auxv (DT_MIPS_RLD_MAP
, &dyn_ptr
))
804 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
806 int pbuf_size
= TYPE_LENGTH (ptr_type
);
808 pbuf
= alloca (pbuf_size
);
809 /* DT_MIPS_RLD_MAP contains a pointer to the address
810 of the dynamic link structure. */
811 if (target_read_memory (dyn_ptr
, pbuf
, pbuf_size
))
813 return extract_typed_address (pbuf
, ptr_type
);
817 if (scan_dyntag (DT_DEBUG
, exec_bfd
, &dyn_ptr
)
818 || scan_dyntag_auxv (DT_DEBUG
, &dyn_ptr
))
821 /* This may be a static executable. Look for the symbol
822 conventionally named _r_debug, as a last resort. */
823 msymbol
= lookup_minimal_symbol ("_r_debug", NULL
, symfile_objfile
);
825 return SYMBOL_VALUE_ADDRESS (msymbol
);
827 /* DT_DEBUG entry not found. */
835 locate_base -- locate the base address of dynamic linker structs
839 CORE_ADDR locate_base (struct svr4_info *)
843 For both the SunOS and SVR4 shared library implementations, if the
844 inferior executable has been linked dynamically, there is a single
845 address somewhere in the inferior's data space which is the key to
846 locating all of the dynamic linker's runtime structures. This
847 address is the value of the debug base symbol. The job of this
848 function is to find and return that address, or to return 0 if there
849 is no such address (the executable is statically linked for example).
851 For SunOS, the job is almost trivial, since the dynamic linker and
852 all of it's structures are statically linked to the executable at
853 link time. Thus the symbol for the address we are looking for has
854 already been added to the minimal symbol table for the executable's
855 objfile at the time the symbol file's symbols were read, and all we
856 have to do is look it up there. Note that we explicitly do NOT want
857 to find the copies in the shared library.
859 The SVR4 version is a bit more complicated because the address
860 is contained somewhere in the dynamic info section. We have to go
861 to a lot more work to discover the address of the debug base symbol.
862 Because of this complexity, we cache the value we find and return that
863 value on subsequent invocations. Note there is no copy in the
864 executable symbol tables.
869 locate_base (struct svr4_info
*info
)
871 /* Check to see if we have a currently valid address, and if so, avoid
872 doing all this work again and just return the cached address. If
873 we have no cached address, try to locate it in the dynamic info
874 section for ELF executables. There's no point in doing any of this
875 though if we don't have some link map offsets to work with. */
877 if (info
->debug_base
== 0 && svr4_have_link_map_offsets ())
878 info
->debug_base
= elf_locate_base ();
879 return info
->debug_base
;
882 /* Find the first element in the inferior's dynamic link map, and
883 return its address in the inferior. Return zero if the address
884 could not be determined.
886 FIXME: Perhaps we should validate the info somehow, perhaps by
887 checking r_version for a known version number, or r_state for
891 solib_svr4_r_map (struct svr4_info
*info
)
893 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
894 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
896 volatile struct gdb_exception ex
;
898 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
900 addr
= read_memory_typed_address (info
->debug_base
+ lmo
->r_map_offset
,
903 exception_print (gdb_stderr
, ex
);
907 /* Find r_brk from the inferior's debug base. */
910 solib_svr4_r_brk (struct svr4_info
*info
)
912 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
913 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
915 return read_memory_typed_address (info
->debug_base
+ lmo
->r_brk_offset
,
919 /* Find the link map for the dynamic linker (if it is not in the
920 normal list of loaded shared objects). */
923 solib_svr4_r_ldsomap (struct svr4_info
*info
)
925 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
926 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
927 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
930 /* Check version, and return zero if `struct r_debug' doesn't have
931 the r_ldsomap member. */
933 = read_memory_unsigned_integer (info
->debug_base
+ lmo
->r_version_offset
,
934 lmo
->r_version_size
, byte_order
);
935 if (version
< 2 || lmo
->r_ldsomap_offset
== -1)
938 return read_memory_typed_address (info
->debug_base
+ lmo
->r_ldsomap_offset
,
942 /* On Solaris systems with some versions of the dynamic linker,
943 ld.so's l_name pointer points to the SONAME in the string table
944 rather than into writable memory. So that GDB can find shared
945 libraries when loading a core file generated by gcore, ensure that
946 memory areas containing the l_name string are saved in the core
950 svr4_keep_data_in_core (CORE_ADDR vaddr
, unsigned long size
)
952 struct svr4_info
*info
;
955 struct cleanup
*old_chain
;
956 struct link_map_offsets
*lmo
;
959 info
= get_svr4_info ();
961 info
->debug_base
= 0;
963 if (!info
->debug_base
)
966 ldsomap
= solib_svr4_r_ldsomap (info
);
970 lmo
= svr4_fetch_link_map_offsets ();
971 new = XZALLOC (struct so_list
);
972 old_chain
= make_cleanup (xfree
, new);
973 new->lm_info
= xmalloc (sizeof (struct lm_info
));
974 make_cleanup (xfree
, new->lm_info
);
975 new->lm_info
->l_addr
= (CORE_ADDR
)-1;
976 new->lm_info
->lm_addr
= ldsomap
;
977 new->lm_info
->lm
= xzalloc (lmo
->link_map_size
);
978 make_cleanup (xfree
, new->lm_info
->lm
);
979 read_memory (ldsomap
, new->lm_info
->lm
, lmo
->link_map_size
);
980 name_lm
= lm_name (new);
981 do_cleanups (old_chain
);
983 return (name_lm
>= vaddr
&& name_lm
< vaddr
+ size
);
990 open_symbol_file_object
994 void open_symbol_file_object (void *from_tty)
998 If no open symbol file, attempt to locate and open the main symbol
999 file. On SVR4 systems, this is the first link map entry. If its
1000 name is here, we can open it. Useful when attaching to a process
1001 without first loading its symbol file.
1003 If FROM_TTYP dereferences to a non-zero integer, allow messages to
1004 be printed. This parameter is a pointer rather than an int because
1005 open_symbol_file_object() is called via catch_errors() and
1006 catch_errors() requires a pointer argument. */
1009 open_symbol_file_object (void *from_ttyp
)
1011 CORE_ADDR lm
, l_name
;
1014 int from_tty
= *(int *)from_ttyp
;
1015 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
1016 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
1017 int l_name_size
= TYPE_LENGTH (ptr_type
);
1018 gdb_byte
*l_name_buf
= xmalloc (l_name_size
);
1019 struct cleanup
*cleanups
= make_cleanup (xfree
, l_name_buf
);
1020 struct svr4_info
*info
= get_svr4_info ();
1022 if (symfile_objfile
)
1023 if (!query (_("Attempt to reload symbols from process? ")))
1025 do_cleanups (cleanups
);
1029 /* Always locate the debug struct, in case it has moved. */
1030 info
->debug_base
= 0;
1031 if (locate_base (info
) == 0)
1033 do_cleanups (cleanups
);
1034 return 0; /* failed somehow... */
1037 /* First link map member should be the executable. */
1038 lm
= solib_svr4_r_map (info
);
1041 do_cleanups (cleanups
);
1042 return 0; /* failed somehow... */
1045 /* Read address of name from target memory to GDB. */
1046 read_memory (lm
+ lmo
->l_name_offset
, l_name_buf
, l_name_size
);
1048 /* Convert the address to host format. */
1049 l_name
= extract_typed_address (l_name_buf
, ptr_type
);
1053 do_cleanups (cleanups
);
1054 return 0; /* No filename. */
1057 /* Now fetch the filename from target memory. */
1058 target_read_string (l_name
, &filename
, SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
1059 make_cleanup (xfree
, filename
);
1063 warning (_("failed to read exec filename from attached file: %s"),
1064 safe_strerror (errcode
));
1065 do_cleanups (cleanups
);
1069 /* Have a pathname: read the symbol file. */
1070 symbol_file_add_main (filename
, from_tty
);
1072 do_cleanups (cleanups
);
1076 /* If no shared library information is available from the dynamic
1077 linker, build a fallback list from other sources. */
1079 static struct so_list
*
1080 svr4_default_sos (void)
1082 struct svr4_info
*info
= get_svr4_info ();
1084 struct so_list
*head
= NULL
;
1085 struct so_list
**link_ptr
= &head
;
1087 if (info
->debug_loader_offset_p
)
1089 struct so_list
*new = XZALLOC (struct so_list
);
1091 new->lm_info
= xmalloc (sizeof (struct lm_info
));
1093 /* Nothing will ever check the cached copy of the link
1094 map if we set l_addr. */
1095 new->lm_info
->l_addr
= info
->debug_loader_offset
;
1096 new->lm_info
->lm_addr
= 0;
1097 new->lm_info
->lm
= NULL
;
1099 strncpy (new->so_name
, info
->debug_loader_name
,
1100 SO_NAME_MAX_PATH_SIZE
- 1);
1101 new->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
1102 strcpy (new->so_original_name
, new->so_name
);
1105 link_ptr
= &new->next
;
1113 current_sos -- build a list of currently loaded shared objects
1117 struct so_list *current_sos ()
1121 Build a list of `struct so_list' objects describing the shared
1122 objects currently loaded in the inferior. This list does not
1123 include an entry for the main executable file.
1125 Note that we only gather information directly available from the
1126 inferior --- we don't examine any of the shared library files
1127 themselves. The declaration of `struct so_list' says which fields
1128 we provide values for. */
1130 static struct so_list
*
1131 svr4_current_sos (void)
1133 CORE_ADDR lm
, prev_lm
;
1134 struct so_list
*head
= 0;
1135 struct so_list
**link_ptr
= &head
;
1136 CORE_ADDR ldsomap
= 0;
1137 struct svr4_info
*info
;
1139 info
= get_svr4_info ();
1141 /* Always locate the debug struct, in case it has moved. */
1142 info
->debug_base
= 0;
1145 /* If we can't find the dynamic linker's base structure, this
1146 must not be a dynamically linked executable. Hmm. */
1147 if (! info
->debug_base
)
1148 return svr4_default_sos ();
1150 /* Walk the inferior's link map list, and build our list of
1151 `struct so_list' nodes. */
1153 lm
= solib_svr4_r_map (info
);
1157 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
1158 struct so_list
*new = XZALLOC (struct so_list
);
1159 struct cleanup
*old_chain
= make_cleanup (xfree
, new);
1162 new->lm_info
= xmalloc (sizeof (struct lm_info
));
1163 make_cleanup (xfree
, new->lm_info
);
1165 new->lm_info
->l_addr
= (CORE_ADDR
)-1;
1166 new->lm_info
->lm_addr
= lm
;
1167 new->lm_info
->lm
= xzalloc (lmo
->link_map_size
);
1168 make_cleanup (xfree
, new->lm_info
->lm
);
1170 read_memory (lm
, new->lm_info
->lm
, lmo
->link_map_size
);
1172 next_lm
= lm_next (new);
1174 if (lm_prev (new) != prev_lm
)
1176 warning (_("Corrupted shared library list"));
1181 /* For SVR4 versions, the first entry in the link map is for the
1182 inferior executable, so we must ignore it. For some versions of
1183 SVR4, it has no name. For others (Solaris 2.3 for example), it
1184 does have a name, so we can no longer use a missing name to
1185 decide when to ignore it. */
1186 else if (ignore_first_link_map_entry (new) && ldsomap
== 0)
1188 info
->main_lm_addr
= new->lm_info
->lm_addr
;
1196 /* Extract this shared object's name. */
1197 target_read_string (lm_name (new), &buffer
,
1198 SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
1200 warning (_("Can't read pathname for load map: %s."),
1201 safe_strerror (errcode
));
1204 strncpy (new->so_name
, buffer
, SO_NAME_MAX_PATH_SIZE
- 1);
1205 new->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
1206 strcpy (new->so_original_name
, new->so_name
);
1210 /* If this entry has no name, or its name matches the name
1211 for the main executable, don't include it in the list. */
1212 if (! new->so_name
[0]
1213 || match_main (new->so_name
))
1219 link_ptr
= &new->next
;
1226 /* On Solaris, the dynamic linker is not in the normal list of
1227 shared objects, so make sure we pick it up too. Having
1228 symbol information for the dynamic linker is quite crucial
1229 for skipping dynamic linker resolver code. */
1230 if (lm
== 0 && ldsomap
== 0)
1232 lm
= ldsomap
= solib_svr4_r_ldsomap (info
);
1236 discard_cleanups (old_chain
);
1240 return svr4_default_sos ();
1245 /* Get the address of the link_map for a given OBJFILE. */
1248 svr4_fetch_objfile_link_map (struct objfile
*objfile
)
1251 struct svr4_info
*info
= get_svr4_info ();
1253 /* Cause svr4_current_sos() to be run if it hasn't been already. */
1254 if (info
->main_lm_addr
== 0)
1255 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
1257 /* svr4_current_sos() will set main_lm_addr for the main executable. */
1258 if (objfile
== symfile_objfile
)
1259 return info
->main_lm_addr
;
1261 /* The other link map addresses may be found by examining the list
1262 of shared libraries. */
1263 for (so
= master_so_list (); so
; so
= so
->next
)
1264 if (so
->objfile
== objfile
)
1265 return so
->lm_info
->lm_addr
;
1271 /* On some systems, the only way to recognize the link map entry for
1272 the main executable file is by looking at its name. Return
1273 non-zero iff SONAME matches one of the known main executable names. */
1276 match_main (const char *soname
)
1278 const char * const *mainp
;
1280 for (mainp
= main_name_list
; *mainp
!= NULL
; mainp
++)
1282 if (strcmp (soname
, *mainp
) == 0)
1289 /* Return 1 if PC lies in the dynamic symbol resolution code of the
1290 SVR4 run time loader. */
1293 svr4_in_dynsym_resolve_code (CORE_ADDR pc
)
1295 struct svr4_info
*info
= get_svr4_info ();
1297 return ((pc
>= info
->interp_text_sect_low
1298 && pc
< info
->interp_text_sect_high
)
1299 || (pc
>= info
->interp_plt_sect_low
1300 && pc
< info
->interp_plt_sect_high
)
1301 || in_plt_section (pc
, NULL
)
1302 || in_gnu_ifunc_stub (pc
));
1305 /* Given an executable's ABFD and target, compute the entry-point
1309 exec_entry_point (struct bfd
*abfd
, struct target_ops
*targ
)
1311 /* KevinB wrote ... for most targets, the address returned by
1312 bfd_get_start_address() is the entry point for the start
1313 function. But, for some targets, bfd_get_start_address() returns
1314 the address of a function descriptor from which the entry point
1315 address may be extracted. This address is extracted by
1316 gdbarch_convert_from_func_ptr_addr(). The method
1317 gdbarch_convert_from_func_ptr_addr() is the merely the identify
1318 function for targets which don't use function descriptors. */
1319 return gdbarch_convert_from_func_ptr_addr (target_gdbarch
,
1320 bfd_get_start_address (abfd
),
1328 enable_break -- arrange for dynamic linker to hit breakpoint
1332 int enable_break (void)
1336 Both the SunOS and the SVR4 dynamic linkers have, as part of their
1337 debugger interface, support for arranging for the inferior to hit
1338 a breakpoint after mapping in the shared libraries. This function
1339 enables that breakpoint.
1341 For SunOS, there is a special flag location (in_debugger) which we
1342 set to 1. When the dynamic linker sees this flag set, it will set
1343 a breakpoint at a location known only to itself, after saving the
1344 original contents of that place and the breakpoint address itself,
1345 in it's own internal structures. When we resume the inferior, it
1346 will eventually take a SIGTRAP when it runs into the breakpoint.
1347 We handle this (in a different place) by restoring the contents of
1348 the breakpointed location (which is only known after it stops),
1349 chasing around to locate the shared libraries that have been
1350 loaded, then resuming.
1352 For SVR4, the debugger interface structure contains a member (r_brk)
1353 which is statically initialized at the time the shared library is
1354 built, to the offset of a function (_r_debug_state) which is guaran-
1355 teed to be called once before mapping in a library, and again when
1356 the mapping is complete. At the time we are examining this member,
1357 it contains only the unrelocated offset of the function, so we have
1358 to do our own relocation. Later, when the dynamic linker actually
1359 runs, it relocates r_brk to be the actual address of _r_debug_state().
1361 The debugger interface structure also contains an enumeration which
1362 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
1363 depending upon whether or not the library is being mapped or unmapped,
1364 and then set to RT_CONSISTENT after the library is mapped/unmapped.
1368 enable_break (struct svr4_info
*info
, int from_tty
)
1370 struct minimal_symbol
*msymbol
;
1371 const char * const *bkpt_namep
;
1372 asection
*interp_sect
;
1373 gdb_byte
*interp_name
;
1376 info
->interp_text_sect_low
= info
->interp_text_sect_high
= 0;
1377 info
->interp_plt_sect_low
= info
->interp_plt_sect_high
= 0;
1379 /* If we already have a shared library list in the target, and
1380 r_debug contains r_brk, set the breakpoint there - this should
1381 mean r_brk has already been relocated. Assume the dynamic linker
1382 is the object containing r_brk. */
1384 solib_add (NULL
, from_tty
, ¤t_target
, auto_solib_add
);
1386 if (info
->debug_base
&& solib_svr4_r_map (info
) != 0)
1387 sym_addr
= solib_svr4_r_brk (info
);
1391 struct obj_section
*os
;
1393 sym_addr
= gdbarch_addr_bits_remove
1394 (target_gdbarch
, gdbarch_convert_from_func_ptr_addr (target_gdbarch
,
1398 /* On at least some versions of Solaris there's a dynamic relocation
1399 on _r_debug.r_brk and SYM_ADDR may not be relocated yet, e.g., if
1400 we get control before the dynamic linker has self-relocated.
1401 Check if SYM_ADDR is in a known section, if it is assume we can
1402 trust its value. This is just a heuristic though, it could go away
1403 or be replaced if it's getting in the way.
1405 On ARM we need to know whether the ISA of rtld_db_dlactivity (or
1406 however it's spelled in your particular system) is ARM or Thumb.
1407 That knowledge is encoded in the address, if it's Thumb the low bit
1408 is 1. However, we've stripped that info above and it's not clear
1409 what all the consequences are of passing a non-addr_bits_remove'd
1410 address to create_solib_event_breakpoint. The call to
1411 find_pc_section verifies we know about the address and have some
1412 hope of computing the right kind of breakpoint to use (via
1413 symbol info). It does mean that GDB needs to be pointed at a
1414 non-stripped version of the dynamic linker in order to obtain
1415 information it already knows about. Sigh. */
1417 os
= find_pc_section (sym_addr
);
1420 /* Record the relocated start and end address of the dynamic linker
1421 text and plt section for svr4_in_dynsym_resolve_code. */
1423 CORE_ADDR load_addr
;
1425 tmp_bfd
= os
->objfile
->obfd
;
1426 load_addr
= ANOFFSET (os
->objfile
->section_offsets
,
1427 os
->objfile
->sect_index_text
);
1429 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
1432 info
->interp_text_sect_low
=
1433 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1434 info
->interp_text_sect_high
=
1435 info
->interp_text_sect_low
1436 + bfd_section_size (tmp_bfd
, interp_sect
);
1438 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
1441 info
->interp_plt_sect_low
=
1442 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1443 info
->interp_plt_sect_high
=
1444 info
->interp_plt_sect_low
1445 + bfd_section_size (tmp_bfd
, interp_sect
);
1448 create_solib_event_breakpoint (target_gdbarch
, sym_addr
);
1453 /* Find the program interpreter; if not found, warn the user and drop
1454 into the old breakpoint at symbol code. */
1455 interp_name
= find_program_interpreter ();
1458 CORE_ADDR load_addr
= 0;
1459 int load_addr_found
= 0;
1460 int loader_found_in_list
= 0;
1462 bfd
*tmp_bfd
= NULL
;
1463 struct target_ops
*tmp_bfd_target
;
1464 volatile struct gdb_exception ex
;
1468 /* Now we need to figure out where the dynamic linker was
1469 loaded so that we can load its symbols and place a breakpoint
1470 in the dynamic linker itself.
1472 This address is stored on the stack. However, I've been unable
1473 to find any magic formula to find it for Solaris (appears to
1474 be trivial on GNU/Linux). Therefore, we have to try an alternate
1475 mechanism to find the dynamic linker's base address. */
1477 TRY_CATCH (ex
, RETURN_MASK_ALL
)
1479 tmp_bfd
= solib_bfd_open (interp_name
);
1481 if (tmp_bfd
== NULL
)
1482 goto bkpt_at_symbol
;
1484 /* Now convert the TMP_BFD into a target. That way target, as
1485 well as BFD operations can be used. Note that closing the
1486 target will also close the underlying bfd. */
1487 tmp_bfd_target
= target_bfd_reopen (tmp_bfd
);
1489 /* On a running target, we can get the dynamic linker's base
1490 address from the shared library table. */
1491 so
= master_so_list ();
1494 if (svr4_same_1 (interp_name
, so
->so_original_name
))
1496 load_addr_found
= 1;
1497 loader_found_in_list
= 1;
1498 load_addr
= lm_addr_check (so
, tmp_bfd
);
1504 /* If we were not able to find the base address of the loader
1505 from our so_list, then try using the AT_BASE auxilliary entry. */
1506 if (!load_addr_found
)
1507 if (target_auxv_search (¤t_target
, AT_BASE
, &load_addr
) > 0)
1509 int addr_bit
= gdbarch_addr_bit (target_gdbarch
);
1511 /* Ensure LOAD_ADDR has proper sign in its possible upper bits so
1512 that `+ load_addr' will overflow CORE_ADDR width not creating
1513 invalid addresses like 0x101234567 for 32bit inferiors on 64bit
1516 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
1518 CORE_ADDR space_size
= (CORE_ADDR
) 1 << addr_bit
;
1519 CORE_ADDR tmp_entry_point
= exec_entry_point (tmp_bfd
,
1522 gdb_assert (load_addr
< space_size
);
1524 /* TMP_ENTRY_POINT exceeding SPACE_SIZE would be for prelinked
1525 64bit ld.so with 32bit executable, it should not happen. */
1527 if (tmp_entry_point
< space_size
1528 && tmp_entry_point
+ load_addr
>= space_size
)
1529 load_addr
-= space_size
;
1532 load_addr_found
= 1;
1535 /* Otherwise we find the dynamic linker's base address by examining
1536 the current pc (which should point at the entry point for the
1537 dynamic linker) and subtracting the offset of the entry point.
1539 This is more fragile than the previous approaches, but is a good
1540 fallback method because it has actually been working well in
1542 if (!load_addr_found
)
1544 struct regcache
*regcache
1545 = get_thread_arch_regcache (inferior_ptid
, target_gdbarch
);
1547 load_addr
= (regcache_read_pc (regcache
)
1548 - exec_entry_point (tmp_bfd
, tmp_bfd_target
));
1551 if (!loader_found_in_list
)
1553 info
->debug_loader_name
= xstrdup (interp_name
);
1554 info
->debug_loader_offset_p
= 1;
1555 info
->debug_loader_offset
= load_addr
;
1556 solib_add (NULL
, from_tty
, ¤t_target
, auto_solib_add
);
1559 /* Record the relocated start and end address of the dynamic linker
1560 text and plt section for svr4_in_dynsym_resolve_code. */
1561 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
1564 info
->interp_text_sect_low
=
1565 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1566 info
->interp_text_sect_high
=
1567 info
->interp_text_sect_low
1568 + bfd_section_size (tmp_bfd
, interp_sect
);
1570 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
1573 info
->interp_plt_sect_low
=
1574 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1575 info
->interp_plt_sect_high
=
1576 info
->interp_plt_sect_low
1577 + bfd_section_size (tmp_bfd
, interp_sect
);
1580 /* Now try to set a breakpoint in the dynamic linker. */
1581 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1583 sym_addr
= bfd_lookup_symbol (tmp_bfd
, *bkpt_namep
);
1589 /* Convert 'sym_addr' from a function pointer to an address.
1590 Because we pass tmp_bfd_target instead of the current
1591 target, this will always produce an unrelocated value. */
1592 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch
,
1596 /* We're done with both the temporary bfd and target. Remember,
1597 closing the target closes the underlying bfd. */
1598 target_close (tmp_bfd_target
, 0);
1602 create_solib_event_breakpoint (target_gdbarch
, load_addr
+ sym_addr
);
1603 xfree (interp_name
);
1607 /* For whatever reason we couldn't set a breakpoint in the dynamic
1608 linker. Warn and drop into the old code. */
1610 xfree (interp_name
);
1611 warning (_("Unable to find dynamic linker breakpoint function.\n"
1612 "GDB will be unable to debug shared library initializers\n"
1613 "and track explicitly loaded dynamic code."));
1616 /* Scan through the lists of symbols, trying to look up the symbol and
1617 set a breakpoint there. Terminate loop when we/if we succeed. */
1619 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1621 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
1622 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
1624 sym_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1625 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch
,
1628 create_solib_event_breakpoint (target_gdbarch
, sym_addr
);
1633 if (!current_inferior ()->attach_flag
)
1635 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1637 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
1638 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
1640 sym_addr
= SYMBOL_VALUE_ADDRESS (msymbol
);
1641 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch
,
1644 create_solib_event_breakpoint (target_gdbarch
, sym_addr
);
1656 special_symbol_handling -- additional shared library symbol handling
1660 void special_symbol_handling ()
1664 Once the symbols from a shared object have been loaded in the usual
1665 way, we are called to do any system specific symbol handling that
1668 For SunOS4, this consisted of grunging around in the dynamic
1669 linkers structures to find symbol definitions for "common" symbols
1670 and adding them to the minimal symbol table for the runtime common
1673 However, for SVR4, there's nothing to do.
1678 svr4_special_symbol_handling (void)
1682 /* Read the ELF program headers from ABFD. Return the contents and
1683 set *PHDRS_SIZE to the size of the program headers. */
1686 read_program_headers_from_bfd (bfd
*abfd
, int *phdrs_size
)
1688 Elf_Internal_Ehdr
*ehdr
;
1691 ehdr
= elf_elfheader (abfd
);
1693 *phdrs_size
= ehdr
->e_phnum
* ehdr
->e_phentsize
;
1694 if (*phdrs_size
== 0)
1697 buf
= xmalloc (*phdrs_size
);
1698 if (bfd_seek (abfd
, ehdr
->e_phoff
, SEEK_SET
) != 0
1699 || bfd_bread (buf
, *phdrs_size
, abfd
) != *phdrs_size
)
1708 /* Return 1 and fill *DISPLACEMENTP with detected PIE offset of inferior
1709 exec_bfd. Otherwise return 0.
1711 We relocate all of the sections by the same amount. This
1712 behavior is mandated by recent editions of the System V ABI.
1713 According to the System V Application Binary Interface,
1714 Edition 4.1, page 5-5:
1716 ... Though the system chooses virtual addresses for
1717 individual processes, it maintains the segments' relative
1718 positions. Because position-independent code uses relative
1719 addressesing between segments, the difference between
1720 virtual addresses in memory must match the difference
1721 between virtual addresses in the file. The difference
1722 between the virtual address of any segment in memory and
1723 the corresponding virtual address in the file is thus a
1724 single constant value for any one executable or shared
1725 object in a given process. This difference is the base
1726 address. One use of the base address is to relocate the
1727 memory image of the program during dynamic linking.
1729 The same language also appears in Edition 4.0 of the System V
1730 ABI and is left unspecified in some of the earlier editions.
1732 Decide if the objfile needs to be relocated. As indicated above, we will
1733 only be here when execution is stopped. But during attachment PC can be at
1734 arbitrary address therefore regcache_read_pc can be misleading (contrary to
1735 the auxv AT_ENTRY value). Moreover for executable with interpreter section
1736 regcache_read_pc would point to the interpreter and not the main executable.
1738 So, to summarize, relocations are necessary when the start address obtained
1739 from the executable is different from the address in auxv AT_ENTRY entry.
1741 [ The astute reader will note that we also test to make sure that
1742 the executable in question has the DYNAMIC flag set. It is my
1743 opinion that this test is unnecessary (undesirable even). It
1744 was added to avoid inadvertent relocation of an executable
1745 whose e_type member in the ELF header is not ET_DYN. There may
1746 be a time in the future when it is desirable to do relocations
1747 on other types of files as well in which case this condition
1748 should either be removed or modified to accomodate the new file
1749 type. - Kevin, Nov 2000. ] */
1752 svr4_exec_displacement (CORE_ADDR
*displacementp
)
1754 /* ENTRY_POINT is a possible function descriptor - before
1755 a call to gdbarch_convert_from_func_ptr_addr. */
1756 CORE_ADDR entry_point
, displacement
;
1758 if (exec_bfd
== NULL
)
1761 /* Therefore for ELF it is ET_EXEC and not ET_DYN. Both shared libraries
1762 being executed themselves and PIE (Position Independent Executable)
1763 executables are ET_DYN. */
1765 if ((bfd_get_file_flags (exec_bfd
) & DYNAMIC
) == 0)
1768 if (target_auxv_search (¤t_target
, AT_ENTRY
, &entry_point
) <= 0)
1771 displacement
= entry_point
- bfd_get_start_address (exec_bfd
);
1773 /* Verify the DISPLACEMENT candidate complies with the required page
1774 alignment. It is cheaper than the program headers comparison below. */
1776 if (bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
1778 const struct elf_backend_data
*elf
= get_elf_backend_data (exec_bfd
);
1780 /* p_align of PT_LOAD segments does not specify any alignment but
1781 only congruency of addresses:
1782 p_offset % p_align == p_vaddr % p_align
1783 Kernel is free to load the executable with lower alignment. */
1785 if ((displacement
& (elf
->minpagesize
- 1)) != 0)
1789 /* Verify that the auxilliary vector describes the same file as exec_bfd, by
1790 comparing their program headers. If the program headers in the auxilliary
1791 vector do not match the program headers in the executable, then we are
1792 looking at a different file than the one used by the kernel - for
1793 instance, "gdb program" connected to "gdbserver :PORT ld.so program". */
1795 if (bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
1797 /* Be optimistic and clear OK only if GDB was able to verify the headers
1798 really do not match. */
1799 int phdrs_size
, phdrs2_size
, ok
= 1;
1800 gdb_byte
*buf
, *buf2
;
1803 buf
= read_program_header (-1, &phdrs_size
, &arch_size
);
1804 buf2
= read_program_headers_from_bfd (exec_bfd
, &phdrs2_size
);
1805 if (buf
!= NULL
&& buf2
!= NULL
)
1807 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
1809 /* We are dealing with three different addresses. EXEC_BFD
1810 represents current address in on-disk file. target memory content
1811 may be different from EXEC_BFD as the file may have been prelinked
1812 to a different address after the executable has been loaded.
1813 Moreover the address of placement in target memory can be
1814 different from what the program headers in target memory say -
1815 this is the goal of PIE.
1817 Detected DISPLACEMENT covers both the offsets of PIE placement and
1818 possible new prelink performed after start of the program. Here
1819 relocate BUF and BUF2 just by the EXEC_BFD vs. target memory
1820 content offset for the verification purpose. */
1822 if (phdrs_size
!= phdrs2_size
1823 || bfd_get_arch_size (exec_bfd
) != arch_size
)
1825 else if (arch_size
== 32
1826 && phdrs_size
>= sizeof (Elf32_External_Phdr
)
1827 && phdrs_size
% sizeof (Elf32_External_Phdr
) == 0)
1829 Elf_Internal_Ehdr
*ehdr2
= elf_tdata (exec_bfd
)->elf_header
;
1830 Elf_Internal_Phdr
*phdr2
= elf_tdata (exec_bfd
)->phdr
;
1831 CORE_ADDR displacement
= 0;
1834 /* DISPLACEMENT could be found more easily by the difference of
1835 ehdr2->e_entry. But we haven't read the ehdr yet, and we
1836 already have enough information to compute that displacement
1837 with what we've read. */
1839 for (i
= 0; i
< ehdr2
->e_phnum
; i
++)
1840 if (phdr2
[i
].p_type
== PT_LOAD
)
1842 Elf32_External_Phdr
*phdrp
;
1843 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
1844 CORE_ADDR vaddr
, paddr
;
1845 CORE_ADDR displacement_vaddr
= 0;
1846 CORE_ADDR displacement_paddr
= 0;
1848 phdrp
= &((Elf32_External_Phdr
*) buf
)[i
];
1849 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
1850 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
1852 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 4,
1854 displacement_vaddr
= vaddr
- phdr2
[i
].p_vaddr
;
1856 paddr
= extract_unsigned_integer (buf_paddr_p
, 4,
1858 displacement_paddr
= paddr
- phdr2
[i
].p_paddr
;
1860 if (displacement_vaddr
== displacement_paddr
)
1861 displacement
= displacement_vaddr
;
1866 /* Now compare BUF and BUF2 with optional DISPLACEMENT. */
1868 for (i
= 0; i
< phdrs_size
/ sizeof (Elf32_External_Phdr
); i
++)
1870 Elf32_External_Phdr
*phdrp
;
1871 Elf32_External_Phdr
*phdr2p
;
1872 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
1873 CORE_ADDR vaddr
, paddr
;
1874 asection
*plt2_asect
;
1876 phdrp
= &((Elf32_External_Phdr
*) buf
)[i
];
1877 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
1878 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
1879 phdr2p
= &((Elf32_External_Phdr
*) buf2
)[i
];
1881 /* PT_GNU_STACK is an exception by being never relocated by
1882 prelink as its addresses are always zero. */
1884 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
1887 /* Check also other adjustment combinations - PR 11786. */
1889 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 4,
1891 vaddr
-= displacement
;
1892 store_unsigned_integer (buf_vaddr_p
, 4, byte_order
, vaddr
);
1894 paddr
= extract_unsigned_integer (buf_paddr_p
, 4,
1896 paddr
-= displacement
;
1897 store_unsigned_integer (buf_paddr_p
, 4, byte_order
, paddr
);
1899 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
1902 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
1903 plt2_asect
= bfd_get_section_by_name (exec_bfd
, ".plt");
1907 gdb_byte
*buf_filesz_p
= (gdb_byte
*) &phdrp
->p_filesz
;
1910 content2
= (bfd_get_section_flags (exec_bfd
, plt2_asect
)
1911 & SEC_HAS_CONTENTS
) != 0;
1913 filesz
= extract_unsigned_integer (buf_filesz_p
, 4,
1916 /* PLT2_ASECT is from on-disk file (exec_bfd) while
1917 FILESZ is from the in-memory image. */
1919 filesz
+= bfd_get_section_size (plt2_asect
);
1921 filesz
-= bfd_get_section_size (plt2_asect
);
1923 store_unsigned_integer (buf_filesz_p
, 4, byte_order
,
1926 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
1934 else if (arch_size
== 64
1935 && phdrs_size
>= sizeof (Elf64_External_Phdr
)
1936 && phdrs_size
% sizeof (Elf64_External_Phdr
) == 0)
1938 Elf_Internal_Ehdr
*ehdr2
= elf_tdata (exec_bfd
)->elf_header
;
1939 Elf_Internal_Phdr
*phdr2
= elf_tdata (exec_bfd
)->phdr
;
1940 CORE_ADDR displacement
= 0;
1943 /* DISPLACEMENT could be found more easily by the difference of
1944 ehdr2->e_entry. But we haven't read the ehdr yet, and we
1945 already have enough information to compute that displacement
1946 with what we've read. */
1948 for (i
= 0; i
< ehdr2
->e_phnum
; i
++)
1949 if (phdr2
[i
].p_type
== PT_LOAD
)
1951 Elf64_External_Phdr
*phdrp
;
1952 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
1953 CORE_ADDR vaddr
, paddr
;
1954 CORE_ADDR displacement_vaddr
= 0;
1955 CORE_ADDR displacement_paddr
= 0;
1957 phdrp
= &((Elf64_External_Phdr
*) buf
)[i
];
1958 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
1959 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
1961 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 8,
1963 displacement_vaddr
= vaddr
- phdr2
[i
].p_vaddr
;
1965 paddr
= extract_unsigned_integer (buf_paddr_p
, 8,
1967 displacement_paddr
= paddr
- phdr2
[i
].p_paddr
;
1969 if (displacement_vaddr
== displacement_paddr
)
1970 displacement
= displacement_vaddr
;
1975 /* Now compare BUF and BUF2 with optional DISPLACEMENT. */
1977 for (i
= 0; i
< phdrs_size
/ sizeof (Elf64_External_Phdr
); i
++)
1979 Elf64_External_Phdr
*phdrp
;
1980 Elf64_External_Phdr
*phdr2p
;
1981 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
1982 CORE_ADDR vaddr
, paddr
;
1983 asection
*plt2_asect
;
1985 phdrp
= &((Elf64_External_Phdr
*) buf
)[i
];
1986 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
1987 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
1988 phdr2p
= &((Elf64_External_Phdr
*) buf2
)[i
];
1990 /* PT_GNU_STACK is an exception by being never relocated by
1991 prelink as its addresses are always zero. */
1993 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
1996 /* Check also other adjustment combinations - PR 11786. */
1998 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 8,
2000 vaddr
-= displacement
;
2001 store_unsigned_integer (buf_vaddr_p
, 8, byte_order
, vaddr
);
2003 paddr
= extract_unsigned_integer (buf_paddr_p
, 8,
2005 paddr
-= displacement
;
2006 store_unsigned_integer (buf_paddr_p
, 8, byte_order
, paddr
);
2008 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2011 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2012 plt2_asect
= bfd_get_section_by_name (exec_bfd
, ".plt");
2016 gdb_byte
*buf_filesz_p
= (gdb_byte
*) &phdrp
->p_filesz
;
2019 content2
= (bfd_get_section_flags (exec_bfd
, plt2_asect
)
2020 & SEC_HAS_CONTENTS
) != 0;
2022 filesz
= extract_unsigned_integer (buf_filesz_p
, 8,
2025 /* PLT2_ASECT is from on-disk file (exec_bfd) while
2026 FILESZ is from the in-memory image. */
2028 filesz
+= bfd_get_section_size (plt2_asect
);
2030 filesz
-= bfd_get_section_size (plt2_asect
);
2032 store_unsigned_integer (buf_filesz_p
, 8, byte_order
,
2035 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2056 /* It can be printed repeatedly as there is no easy way to check
2057 the executable symbols/file has been already relocated to
2060 printf_unfiltered (_("Using PIE (Position Independent Executable) "
2061 "displacement %s for \"%s\".\n"),
2062 paddress (target_gdbarch
, displacement
),
2063 bfd_get_filename (exec_bfd
));
2066 *displacementp
= displacement
;
2070 /* Relocate the main executable. This function should be called upon
2071 stopping the inferior process at the entry point to the program.
2072 The entry point from BFD is compared to the AT_ENTRY of AUXV and if they are
2073 different, the main executable is relocated by the proper amount. */
2076 svr4_relocate_main_executable (void)
2078 CORE_ADDR displacement
;
2080 /* If we are re-running this executable, SYMFILE_OBJFILE->SECTION_OFFSETS
2081 probably contains the offsets computed using the PIE displacement
2082 from the previous run, which of course are irrelevant for this run.
2083 So we need to determine the new PIE displacement and recompute the
2084 section offsets accordingly, even if SYMFILE_OBJFILE->SECTION_OFFSETS
2085 already contains pre-computed offsets.
2087 If we cannot compute the PIE displacement, either:
2089 - The executable is not PIE.
2091 - SYMFILE_OBJFILE does not match the executable started in the target.
2092 This can happen for main executable symbols loaded at the host while
2093 `ld.so --ld-args main-executable' is loaded in the target.
2095 Then we leave the section offsets untouched and use them as is for
2098 - These section offsets were properly reset earlier, and thus
2099 already contain the correct values. This can happen for instance
2100 when reconnecting via the remote protocol to a target that supports
2101 the `qOffsets' packet.
2103 - The section offsets were not reset earlier, and the best we can
2104 hope is that the old offsets are still applicable to the new run. */
2106 if (! svr4_exec_displacement (&displacement
))
2109 /* Even DISPLACEMENT 0 is a valid new difference of in-memory vs. in-file
2112 if (symfile_objfile
)
2114 struct section_offsets
*new_offsets
;
2117 new_offsets
= alloca (symfile_objfile
->num_sections
2118 * sizeof (*new_offsets
));
2120 for (i
= 0; i
< symfile_objfile
->num_sections
; i
++)
2121 new_offsets
->offsets
[i
] = displacement
;
2123 objfile_relocate (symfile_objfile
, new_offsets
);
2129 for (asect
= exec_bfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
2130 exec_set_section_address (bfd_get_filename (exec_bfd
), asect
->index
,
2131 (bfd_section_vma (exec_bfd
, asect
)
2140 svr4_solib_create_inferior_hook -- shared library startup support
2144 void svr4_solib_create_inferior_hook (int from_tty)
2148 When gdb starts up the inferior, it nurses it along (through the
2149 shell) until it is ready to execute it's first instruction. At this
2150 point, this function gets called via expansion of the macro
2151 SOLIB_CREATE_INFERIOR_HOOK.
2153 For SunOS executables, this first instruction is typically the
2154 one at "_start", or a similar text label, regardless of whether
2155 the executable is statically or dynamically linked. The runtime
2156 startup code takes care of dynamically linking in any shared
2157 libraries, once gdb allows the inferior to continue.
2159 For SVR4 executables, this first instruction is either the first
2160 instruction in the dynamic linker (for dynamically linked
2161 executables) or the instruction at "start" for statically linked
2162 executables. For dynamically linked executables, the system
2163 first exec's /lib/libc.so.N, which contains the dynamic linker,
2164 and starts it running. The dynamic linker maps in any needed
2165 shared libraries, maps in the actual user executable, and then
2166 jumps to "start" in the user executable.
2168 For both SunOS shared libraries, and SVR4 shared libraries, we
2169 can arrange to cooperate with the dynamic linker to discover the
2170 names of shared libraries that are dynamically linked, and the
2171 base addresses to which they are linked.
2173 This function is responsible for discovering those names and
2174 addresses, and saving sufficient information about them to allow
2175 their symbols to be read at a later time.
2179 Between enable_break() and disable_break(), this code does not
2180 properly handle hitting breakpoints which the user might have
2181 set in the startup code or in the dynamic linker itself. Proper
2182 handling will probably have to wait until the implementation is
2183 changed to use the "breakpoint handler function" method.
2185 Also, what if child has exit()ed? Must exit loop somehow.
2189 svr4_solib_create_inferior_hook (int from_tty
)
2191 #if defined(_SCO_DS)
2192 struct inferior
*inf
;
2193 struct thread_info
*tp
;
2194 #endif /* defined(_SCO_DS) */
2195 struct svr4_info
*info
;
2197 info
= get_svr4_info ();
2199 /* Relocate the main executable if necessary. */
2200 svr4_relocate_main_executable ();
2202 /* No point setting a breakpoint in the dynamic linker if we can't
2203 hit it (e.g., a core file, or a trace file). */
2204 if (!target_has_execution
)
2207 if (!svr4_have_link_map_offsets ())
2210 if (!enable_break (info
, from_tty
))
2213 #if defined(_SCO_DS)
2214 /* SCO needs the loop below, other systems should be using the
2215 special shared library breakpoints and the shared library breakpoint
2218 Now run the target. It will eventually hit the breakpoint, at
2219 which point all of the libraries will have been mapped in and we
2220 can go groveling around in the dynamic linker structures to find
2221 out what we need to know about them. */
2223 inf
= current_inferior ();
2224 tp
= inferior_thread ();
2226 clear_proceed_status ();
2227 inf
->control
.stop_soon
= STOP_QUIETLY
;
2228 tp
->suspend
.stop_signal
= TARGET_SIGNAL_0
;
2231 target_resume (pid_to_ptid (-1), 0, tp
->suspend
.stop_signal
);
2232 wait_for_inferior ();
2234 while (tp
->suspend
.stop_signal
!= TARGET_SIGNAL_TRAP
);
2235 inf
->control
.stop_soon
= NO_STOP_QUIETLY
;
2236 #endif /* defined(_SCO_DS) */
2240 svr4_clear_solib (void)
2242 struct svr4_info
*info
;
2244 info
= get_svr4_info ();
2245 info
->debug_base
= 0;
2246 info
->debug_loader_offset_p
= 0;
2247 info
->debug_loader_offset
= 0;
2248 xfree (info
->debug_loader_name
);
2249 info
->debug_loader_name
= NULL
;
2253 svr4_free_so (struct so_list
*so
)
2255 xfree (so
->lm_info
->lm
);
2256 xfree (so
->lm_info
);
2260 /* Clear any bits of ADDR that wouldn't fit in a target-format
2261 data pointer. "Data pointer" here refers to whatever sort of
2262 address the dynamic linker uses to manage its sections. At the
2263 moment, we don't support shared libraries on any processors where
2264 code and data pointers are different sizes.
2266 This isn't really the right solution. What we really need here is
2267 a way to do arithmetic on CORE_ADDR values that respects the
2268 natural pointer/address correspondence. (For example, on the MIPS,
2269 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
2270 sign-extend the value. There, simply truncating the bits above
2271 gdbarch_ptr_bit, as we do below, is no good.) This should probably
2272 be a new gdbarch method or something. */
2274 svr4_truncate_ptr (CORE_ADDR addr
)
2276 if (gdbarch_ptr_bit (target_gdbarch
) == sizeof (CORE_ADDR
) * 8)
2277 /* We don't need to truncate anything, and the bit twiddling below
2278 will fail due to overflow problems. */
2281 return addr
& (((CORE_ADDR
) 1 << gdbarch_ptr_bit (target_gdbarch
)) - 1);
2286 svr4_relocate_section_addresses (struct so_list
*so
,
2287 struct target_section
*sec
)
2289 sec
->addr
= svr4_truncate_ptr (sec
->addr
+ lm_addr_check (so
,
2291 sec
->endaddr
= svr4_truncate_ptr (sec
->endaddr
+ lm_addr_check (so
,
2296 /* Architecture-specific operations. */
2298 /* Per-architecture data key. */
2299 static struct gdbarch_data
*solib_svr4_data
;
2301 struct solib_svr4_ops
2303 /* Return a description of the layout of `struct link_map'. */
2304 struct link_map_offsets
*(*fetch_link_map_offsets
)(void);
2307 /* Return a default for the architecture-specific operations. */
2310 solib_svr4_init (struct obstack
*obstack
)
2312 struct solib_svr4_ops
*ops
;
2314 ops
= OBSTACK_ZALLOC (obstack
, struct solib_svr4_ops
);
2315 ops
->fetch_link_map_offsets
= NULL
;
2319 /* Set the architecture-specific `struct link_map_offsets' fetcher for
2320 GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */
2323 set_solib_svr4_fetch_link_map_offsets (struct gdbarch
*gdbarch
,
2324 struct link_map_offsets
*(*flmo
) (void))
2326 struct solib_svr4_ops
*ops
= gdbarch_data (gdbarch
, solib_svr4_data
);
2328 ops
->fetch_link_map_offsets
= flmo
;
2330 set_solib_ops (gdbarch
, &svr4_so_ops
);
2333 /* Fetch a link_map_offsets structure using the architecture-specific
2334 `struct link_map_offsets' fetcher. */
2336 static struct link_map_offsets
*
2337 svr4_fetch_link_map_offsets (void)
2339 struct solib_svr4_ops
*ops
= gdbarch_data (target_gdbarch
, solib_svr4_data
);
2341 gdb_assert (ops
->fetch_link_map_offsets
);
2342 return ops
->fetch_link_map_offsets ();
2345 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
2348 svr4_have_link_map_offsets (void)
2350 struct solib_svr4_ops
*ops
= gdbarch_data (target_gdbarch
, solib_svr4_data
);
2352 return (ops
->fetch_link_map_offsets
!= NULL
);
2356 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
2357 `struct r_debug' and a `struct link_map' that are binary compatible
2358 with the origional SVR4 implementation. */
2360 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
2361 for an ILP32 SVR4 system. */
2363 struct link_map_offsets
*
2364 svr4_ilp32_fetch_link_map_offsets (void)
2366 static struct link_map_offsets lmo
;
2367 static struct link_map_offsets
*lmp
= NULL
;
2373 lmo
.r_version_offset
= 0;
2374 lmo
.r_version_size
= 4;
2375 lmo
.r_map_offset
= 4;
2376 lmo
.r_brk_offset
= 8;
2377 lmo
.r_ldsomap_offset
= 20;
2379 /* Everything we need is in the first 20 bytes. */
2380 lmo
.link_map_size
= 20;
2381 lmo
.l_addr_offset
= 0;
2382 lmo
.l_name_offset
= 4;
2383 lmo
.l_ld_offset
= 8;
2384 lmo
.l_next_offset
= 12;
2385 lmo
.l_prev_offset
= 16;
2391 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
2392 for an LP64 SVR4 system. */
2394 struct link_map_offsets
*
2395 svr4_lp64_fetch_link_map_offsets (void)
2397 static struct link_map_offsets lmo
;
2398 static struct link_map_offsets
*lmp
= NULL
;
2404 lmo
.r_version_offset
= 0;
2405 lmo
.r_version_size
= 4;
2406 lmo
.r_map_offset
= 8;
2407 lmo
.r_brk_offset
= 16;
2408 lmo
.r_ldsomap_offset
= 40;
2410 /* Everything we need is in the first 40 bytes. */
2411 lmo
.link_map_size
= 40;
2412 lmo
.l_addr_offset
= 0;
2413 lmo
.l_name_offset
= 8;
2414 lmo
.l_ld_offset
= 16;
2415 lmo
.l_next_offset
= 24;
2416 lmo
.l_prev_offset
= 32;
2423 struct target_so_ops svr4_so_ops
;
2425 /* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a
2426 different rule for symbol lookup. The lookup begins here in the DSO, not in
2427 the main executable. */
2429 static struct symbol
*
2430 elf_lookup_lib_symbol (const struct objfile
*objfile
,
2432 const domain_enum domain
)
2436 if (objfile
== symfile_objfile
)
2440 /* OBJFILE should have been passed as the non-debug one. */
2441 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
2443 abfd
= objfile
->obfd
;
2446 if (abfd
== NULL
|| scan_dyntag (DT_SYMBOLIC
, abfd
, NULL
) != 1)
2449 return lookup_global_symbol_from_objfile (objfile
, name
, domain
);
2452 extern initialize_file_ftype _initialize_svr4_solib
; /* -Wmissing-prototypes */
2455 _initialize_svr4_solib (void)
2457 solib_svr4_data
= gdbarch_data_register_pre_init (solib_svr4_init
);
2458 solib_svr4_pspace_data
2459 = register_program_space_data_with_cleanup (svr4_pspace_data_cleanup
);
2461 svr4_so_ops
.relocate_section_addresses
= svr4_relocate_section_addresses
;
2462 svr4_so_ops
.free_so
= svr4_free_so
;
2463 svr4_so_ops
.clear_solib
= svr4_clear_solib
;
2464 svr4_so_ops
.solib_create_inferior_hook
= svr4_solib_create_inferior_hook
;
2465 svr4_so_ops
.special_symbol_handling
= svr4_special_symbol_handling
;
2466 svr4_so_ops
.current_sos
= svr4_current_sos
;
2467 svr4_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
2468 svr4_so_ops
.in_dynsym_resolve_code
= svr4_in_dynsym_resolve_code
;
2469 svr4_so_ops
.bfd_open
= solib_bfd_open
;
2470 svr4_so_ops
.lookup_lib_global_symbol
= elf_lookup_lib_symbol
;
2471 svr4_so_ops
.same
= svr4_same
;
2472 svr4_so_ops
.keep_data_in_core
= svr4_keep_data_in_core
;