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
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);
54 /* Link map info to include in an allocated so_list entry */
58 /* Pointer to copy of link map from inferior. The type is char *
59 rather than void *, so that we may use byte offsets to find the
60 various fields without the need for a cast. */
63 /* Amount by which addresses in the binary should be relocated to
64 match the inferior. This could most often be taken directly
65 from lm, but when prelinking is involved and the prelink base
66 address changes, we may need a different offset, we want to
67 warn about the difference and compute it only once. */
70 /* The target location of lm. */
74 /* On SVR4 systems, a list of symbols in the dynamic linker where
75 GDB can try to place a breakpoint to monitor shared library
78 If none of these symbols are found, or other errors occur, then
79 SVR4 systems will fall back to using a symbol as the "startup
80 mapping complete" breakpoint address. */
82 static char *solib_break_names
[] =
93 static char *bkpt_names
[] =
101 static char *main_name_list
[] =
107 /* Return non-zero if GDB_SO_NAME and INFERIOR_SO_NAME represent
108 the same shared library. */
111 svr4_same_1 (const char *gdb_so_name
, const char *inferior_so_name
)
113 if (strcmp (gdb_so_name
, inferior_so_name
) == 0)
116 /* On Solaris, when starting inferior we think that dynamic linker is
117 /usr/lib/ld.so.1, but later on, the table of loaded shared libraries
118 contains /lib/ld.so.1. Sometimes one file is a link to another, but
119 sometimes they have identical content, but are not linked to each
120 other. We don't restrict this check for Solaris, but the chances
121 of running into this situation elsewhere are very low. */
122 if (strcmp (gdb_so_name
, "/usr/lib/ld.so.1") == 0
123 && strcmp (inferior_so_name
, "/lib/ld.so.1") == 0)
126 /* Similarly, we observed the same issue with sparc64, but with
127 different locations. */
128 if (strcmp (gdb_so_name
, "/usr/lib/sparcv9/ld.so.1") == 0
129 && strcmp (inferior_so_name
, "/lib/sparcv9/ld.so.1") == 0)
136 svr4_same (struct so_list
*gdb
, struct so_list
*inferior
)
138 return (svr4_same_1 (gdb
->so_original_name
, inferior
->so_original_name
));
141 /* link map access functions */
144 LM_ADDR_FROM_LINK_MAP (struct so_list
*so
)
146 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
147 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
149 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_addr_offset
,
154 HAS_LM_DYNAMIC_FROM_LINK_MAP (void)
156 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
158 return lmo
->l_ld_offset
>= 0;
162 LM_DYNAMIC_FROM_LINK_MAP (struct so_list
*so
)
164 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
165 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
167 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_ld_offset
,
172 LM_ADDR_CHECK (struct so_list
*so
, bfd
*abfd
)
174 if (so
->lm_info
->l_addr
== (CORE_ADDR
)-1)
176 struct bfd_section
*dyninfo_sect
;
177 CORE_ADDR l_addr
, l_dynaddr
, dynaddr
, align
= 0x1000;
179 l_addr
= LM_ADDR_FROM_LINK_MAP (so
);
181 if (! abfd
|| ! HAS_LM_DYNAMIC_FROM_LINK_MAP ())
184 l_dynaddr
= LM_DYNAMIC_FROM_LINK_MAP (so
);
186 dyninfo_sect
= bfd_get_section_by_name (abfd
, ".dynamic");
187 if (dyninfo_sect
== NULL
)
190 dynaddr
= bfd_section_vma (abfd
, dyninfo_sect
);
192 if (dynaddr
+ l_addr
!= l_dynaddr
)
194 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
196 Elf_Internal_Ehdr
*ehdr
= elf_tdata (abfd
)->elf_header
;
197 Elf_Internal_Phdr
*phdr
= elf_tdata (abfd
)->phdr
;
202 for (i
= 0; i
< ehdr
->e_phnum
; i
++)
203 if (phdr
[i
].p_type
== PT_LOAD
&& phdr
[i
].p_align
> align
)
204 align
= phdr
[i
].p_align
;
207 /* Turn it into a mask. */
210 /* If the changes match the alignment requirements, we
211 assume we're using a core file that was generated by the
212 same binary, just prelinked with a different base offset.
213 If it doesn't match, we may have a different binary, the
214 same binary with the dynamic table loaded at an unrelated
215 location, or anything, really. To avoid regressions,
216 don't adjust the base offset in the latter case, although
217 odds are that, if things really changed, debugging won't
219 if ((l_addr
& align
) == ((l_dynaddr
- dynaddr
) & align
))
221 l_addr
= l_dynaddr
- dynaddr
;
223 warning (_(".dynamic section for \"%s\" "
224 "is not at the expected address"), so
->so_name
);
225 warning (_("difference appears to be caused by prelink, "
226 "adjusting expectations"));
229 warning (_(".dynamic section for \"%s\" "
230 "is not at the expected address "
231 "(wrong library or version mismatch?)"), so
->so_name
);
235 so
->lm_info
->l_addr
= l_addr
;
238 return so
->lm_info
->l_addr
;
242 LM_NEXT (struct so_list
*so
)
244 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
245 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
247 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_next_offset
,
252 LM_NAME (struct so_list
*so
)
254 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
255 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
257 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_name_offset
,
262 IGNORE_FIRST_LINK_MAP_ENTRY (struct so_list
*so
)
264 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
265 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
267 /* Assume that everything is a library if the dynamic loader was loaded
268 late by a static executable. */
269 if (exec_bfd
&& bfd_get_section_by_name (exec_bfd
, ".dynamic") == NULL
)
272 return extract_typed_address (so
->lm_info
->lm
+ lmo
->l_prev_offset
,
276 /* Per-inferior SVR4 specific data. */
282 CORE_ADDR debug_base
; /* Base of dynamic linker structures */
284 /* Validity flag for debug_loader_offset. */
285 int debug_loader_offset_p
;
287 /* Load address for the dynamic linker, inferred. */
288 CORE_ADDR debug_loader_offset
;
290 /* Name of the dynamic linker, valid if debug_loader_offset_p. */
291 char *debug_loader_name
;
293 /* Load map address for the main executable. */
294 CORE_ADDR main_lm_addr
;
297 /* List of known processes using solib-svr4 shared libraries, storing
298 the required bookkeeping for each. */
300 typedef struct svr4_info
*svr4_info_p
;
301 DEF_VEC_P(svr4_info_p
);
302 VEC(svr4_info_p
) *svr4_info
= NULL
;
304 /* Get svr4 data for inferior PID (target id). If none is found yet,
305 add it now. This function always returns a valid object. */
308 get_svr4_info (int pid
)
311 struct svr4_info
*it
;
313 gdb_assert (pid
!= 0);
315 for (ix
= 0; VEC_iterate (svr4_info_p
, svr4_info
, ix
, it
); ++ix
)
321 it
= XZALLOC (struct svr4_info
);
324 VEC_safe_push (svr4_info_p
, svr4_info
, it
);
329 /* Get rid of any svr4 related bookkeeping for inferior PID (target
333 remove_svr4_info (int pid
)
336 struct svr4_info
*it
;
338 for (ix
= 0; VEC_iterate (svr4_info_p
, svr4_info
, ix
, it
); ++ix
)
342 VEC_unordered_remove (svr4_info_p
, svr4_info
, ix
);
348 /* This is an "inferior_exit" observer. Inferior PID (target id) is
349 being removed from the inferior list, because it exited, was
350 killed, detached, or we just dropped the connection to the debug
351 interface --- discard any solib-svr4 related bookkeeping for this
355 solib_svr4_inferior_exit (int pid
)
357 remove_svr4_info (pid
);
360 /* Local function prototypes */
362 static int match_main (char *);
364 static CORE_ADDR
bfd_lookup_symbol (bfd
*, char *);
370 bfd_lookup_symbol -- lookup the value for a specific symbol
374 CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
378 An expensive way to lookup the value of a single symbol for
379 bfd's that are only temporary anyway. This is used by the
380 shared library support to find the address of the debugger
381 notification routine in the shared library.
383 The returned symbol may be in a code or data section; functions
384 will normally be in a code section, but may be in a data section
385 if this architecture uses function descriptors.
387 Note that 0 is specifically allowed as an error return (no
392 bfd_lookup_symbol (bfd
*abfd
, char *symname
)
396 asymbol
**symbol_table
;
397 unsigned int number_of_symbols
;
399 struct cleanup
*back_to
;
400 CORE_ADDR symaddr
= 0;
402 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
404 if (storage_needed
> 0)
406 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
407 back_to
= make_cleanup (xfree
, symbol_table
);
408 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
410 for (i
= 0; i
< number_of_symbols
; i
++)
412 sym
= *symbol_table
++;
413 if (strcmp (sym
->name
, symname
) == 0
414 && (sym
->section
->flags
& (SEC_CODE
| SEC_DATA
)) != 0)
416 /* BFD symbols are section relative. */
417 symaddr
= sym
->value
+ sym
->section
->vma
;
421 do_cleanups (back_to
);
427 /* On FreeBSD, the dynamic linker is stripped by default. So we'll
428 have to check the dynamic string table too. */
430 storage_needed
= bfd_get_dynamic_symtab_upper_bound (abfd
);
432 if (storage_needed
> 0)
434 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
435 back_to
= make_cleanup (xfree
, symbol_table
);
436 number_of_symbols
= bfd_canonicalize_dynamic_symtab (abfd
, symbol_table
);
438 for (i
= 0; i
< number_of_symbols
; i
++)
440 sym
= *symbol_table
++;
442 if (strcmp (sym
->name
, symname
) == 0
443 && (sym
->section
->flags
& (SEC_CODE
| SEC_DATA
)) != 0)
445 /* BFD symbols are section relative. */
446 symaddr
= sym
->value
+ sym
->section
->vma
;
450 do_cleanups (back_to
);
457 /* Read program header TYPE from inferior memory. The header is found
458 by scanning the OS auxillary vector.
460 Return a pointer to allocated memory holding the program header contents,
461 or NULL on failure. If sucessful, and unless P_SECT_SIZE is NULL, the
462 size of those contents is returned to P_SECT_SIZE. Likewise, the target
463 architecture size (32-bit or 64-bit) is returned to P_ARCH_SIZE. */
466 read_program_header (int type
, int *p_sect_size
, int *p_arch_size
)
468 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
469 CORE_ADDR at_phdr
, at_phent
, at_phnum
;
470 int arch_size
, sect_size
;
474 /* Get required auxv elements from target. */
475 if (target_auxv_search (¤t_target
, AT_PHDR
, &at_phdr
) <= 0)
477 if (target_auxv_search (¤t_target
, AT_PHENT
, &at_phent
) <= 0)
479 if (target_auxv_search (¤t_target
, AT_PHNUM
, &at_phnum
) <= 0)
481 if (!at_phdr
|| !at_phnum
)
484 /* Determine ELF architecture type. */
485 if (at_phent
== sizeof (Elf32_External_Phdr
))
487 else if (at_phent
== sizeof (Elf64_External_Phdr
))
492 /* Find .dynamic section via the PT_DYNAMIC PHDR. */
495 Elf32_External_Phdr phdr
;
498 /* Search for requested PHDR. */
499 for (i
= 0; i
< at_phnum
; i
++)
501 if (target_read_memory (at_phdr
+ i
* sizeof (phdr
),
502 (gdb_byte
*)&phdr
, sizeof (phdr
)))
505 if (extract_unsigned_integer ((gdb_byte
*)phdr
.p_type
,
506 4, byte_order
) == type
)
513 /* Retrieve address and size. */
514 sect_addr
= extract_unsigned_integer ((gdb_byte
*)phdr
.p_vaddr
,
516 sect_size
= extract_unsigned_integer ((gdb_byte
*)phdr
.p_memsz
,
521 Elf64_External_Phdr phdr
;
524 /* Search for requested PHDR. */
525 for (i
= 0; i
< at_phnum
; i
++)
527 if (target_read_memory (at_phdr
+ i
* sizeof (phdr
),
528 (gdb_byte
*)&phdr
, sizeof (phdr
)))
531 if (extract_unsigned_integer ((gdb_byte
*)phdr
.p_type
,
532 4, byte_order
) == type
)
539 /* Retrieve address and size. */
540 sect_addr
= extract_unsigned_integer ((gdb_byte
*)phdr
.p_vaddr
,
542 sect_size
= extract_unsigned_integer ((gdb_byte
*)phdr
.p_memsz
,
546 /* Read in requested program header. */
547 buf
= xmalloc (sect_size
);
548 if (target_read_memory (sect_addr
, buf
, sect_size
))
555 *p_arch_size
= arch_size
;
557 *p_sect_size
= sect_size
;
563 /* Return program interpreter string. */
565 find_program_interpreter (void)
567 gdb_byte
*buf
= NULL
;
569 /* If we have an exec_bfd, use its section table. */
571 && bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
573 struct bfd_section
*interp_sect
;
575 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
576 if (interp_sect
!= NULL
)
578 CORE_ADDR sect_addr
= bfd_section_vma (exec_bfd
, interp_sect
);
579 int sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
581 buf
= xmalloc (sect_size
);
582 bfd_get_section_contents (exec_bfd
, interp_sect
, buf
, 0, sect_size
);
586 /* If we didn't find it, use the target auxillary vector. */
588 buf
= read_program_header (PT_INTERP
, NULL
, NULL
);
594 /* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
595 returned and the corresponding PTR is set. */
598 scan_dyntag (int dyntag
, bfd
*abfd
, CORE_ADDR
*ptr
)
600 int arch_size
, step
, sect_size
;
602 CORE_ADDR dyn_ptr
, dyn_addr
;
603 gdb_byte
*bufend
, *bufstart
, *buf
;
604 Elf32_External_Dyn
*x_dynp_32
;
605 Elf64_External_Dyn
*x_dynp_64
;
606 struct bfd_section
*sect
;
611 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
614 arch_size
= bfd_get_arch_size (abfd
);
618 /* Find the start address of the .dynamic section. */
619 sect
= bfd_get_section_by_name (abfd
, ".dynamic");
622 dyn_addr
= bfd_section_vma (abfd
, sect
);
624 /* Read in .dynamic from the BFD. We will get the actual value
625 from memory later. */
626 sect_size
= bfd_section_size (abfd
, sect
);
627 buf
= bufstart
= alloca (sect_size
);
628 if (!bfd_get_section_contents (abfd
, sect
,
632 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
633 step
= (arch_size
== 32) ? sizeof (Elf32_External_Dyn
)
634 : sizeof (Elf64_External_Dyn
);
635 for (bufend
= buf
+ sect_size
;
641 x_dynp_32
= (Elf32_External_Dyn
*) buf
;
642 dyn_tag
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_tag
);
643 dyn_ptr
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_un
.d_ptr
);
647 x_dynp_64
= (Elf64_External_Dyn
*) buf
;
648 dyn_tag
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_tag
);
649 dyn_ptr
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_un
.d_ptr
);
651 if (dyn_tag
== DT_NULL
)
653 if (dyn_tag
== dyntag
)
655 /* If requested, try to read the runtime value of this .dynamic
659 struct type
*ptr_type
;
663 ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
664 ptr_addr
= dyn_addr
+ (buf
- bufstart
) + arch_size
/ 8;
665 if (target_read_memory (ptr_addr
, ptr_buf
, arch_size
/ 8) == 0)
666 dyn_ptr
= extract_typed_address (ptr_buf
, ptr_type
);
676 /* Scan for DYNTAG in .dynamic section of the target's main executable,
677 found by consulting the OS auxillary vector. If DYNTAG is found 1 is
678 returned and the corresponding PTR is set. */
681 scan_dyntag_auxv (int dyntag
, CORE_ADDR
*ptr
)
683 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
684 int sect_size
, arch_size
, step
;
687 gdb_byte
*bufend
, *bufstart
, *buf
;
689 /* Read in .dynamic section. */
690 buf
= bufstart
= read_program_header (PT_DYNAMIC
, §_size
, &arch_size
);
694 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
695 step
= (arch_size
== 32) ? sizeof (Elf32_External_Dyn
)
696 : sizeof (Elf64_External_Dyn
);
697 for (bufend
= buf
+ sect_size
;
703 Elf32_External_Dyn
*dynp
= (Elf32_External_Dyn
*) buf
;
704 dyn_tag
= extract_unsigned_integer ((gdb_byte
*) dynp
->d_tag
,
706 dyn_ptr
= extract_unsigned_integer ((gdb_byte
*) dynp
->d_un
.d_ptr
,
711 Elf64_External_Dyn
*dynp
= (Elf64_External_Dyn
*) buf
;
712 dyn_tag
= extract_unsigned_integer ((gdb_byte
*) dynp
->d_tag
,
714 dyn_ptr
= extract_unsigned_integer ((gdb_byte
*) dynp
->d_un
.d_ptr
,
717 if (dyn_tag
== DT_NULL
)
720 if (dyn_tag
== dyntag
)
739 elf_locate_base -- locate the base address of dynamic linker structs
740 for SVR4 elf targets.
744 CORE_ADDR elf_locate_base (void)
748 For SVR4 elf targets the address of the dynamic linker's runtime
749 structure is contained within the dynamic info section in the
750 executable file. The dynamic section is also mapped into the
751 inferior address space. Because the runtime loader fills in the
752 real address before starting the inferior, we have to read in the
753 dynamic info section from the inferior address space.
754 If there are any errors while trying to find the address, we
755 silently return 0, otherwise the found address is returned.
760 elf_locate_base (void)
762 struct minimal_symbol
*msymbol
;
765 /* Look for DT_MIPS_RLD_MAP first. MIPS executables use this
766 instead of DT_DEBUG, although they sometimes contain an unused
768 if (scan_dyntag (DT_MIPS_RLD_MAP
, exec_bfd
, &dyn_ptr
)
769 || scan_dyntag_auxv (DT_MIPS_RLD_MAP
, &dyn_ptr
))
771 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
773 int pbuf_size
= TYPE_LENGTH (ptr_type
);
774 pbuf
= alloca (pbuf_size
);
775 /* DT_MIPS_RLD_MAP contains a pointer to the address
776 of the dynamic link structure. */
777 if (target_read_memory (dyn_ptr
, pbuf
, pbuf_size
))
779 return extract_typed_address (pbuf
, ptr_type
);
783 if (scan_dyntag (DT_DEBUG
, exec_bfd
, &dyn_ptr
)
784 || scan_dyntag_auxv (DT_DEBUG
, &dyn_ptr
))
787 /* This may be a static executable. Look for the symbol
788 conventionally named _r_debug, as a last resort. */
789 msymbol
= lookup_minimal_symbol ("_r_debug", NULL
, symfile_objfile
);
791 return SYMBOL_VALUE_ADDRESS (msymbol
);
793 /* DT_DEBUG entry not found. */
801 locate_base -- locate the base address of dynamic linker structs
805 CORE_ADDR locate_base (struct svr4_info *)
809 For both the SunOS and SVR4 shared library implementations, if the
810 inferior executable has been linked dynamically, there is a single
811 address somewhere in the inferior's data space which is the key to
812 locating all of the dynamic linker's runtime structures. This
813 address is the value of the debug base symbol. The job of this
814 function is to find and return that address, or to return 0 if there
815 is no such address (the executable is statically linked for example).
817 For SunOS, the job is almost trivial, since the dynamic linker and
818 all of it's structures are statically linked to the executable at
819 link time. Thus the symbol for the address we are looking for has
820 already been added to the minimal symbol table for the executable's
821 objfile at the time the symbol file's symbols were read, and all we
822 have to do is look it up there. Note that we explicitly do NOT want
823 to find the copies in the shared library.
825 The SVR4 version is a bit more complicated because the address
826 is contained somewhere in the dynamic info section. We have to go
827 to a lot more work to discover the address of the debug base symbol.
828 Because of this complexity, we cache the value we find and return that
829 value on subsequent invocations. Note there is no copy in the
830 executable symbol tables.
835 locate_base (struct svr4_info
*info
)
837 /* Check to see if we have a currently valid address, and if so, avoid
838 doing all this work again and just return the cached address. If
839 we have no cached address, try to locate it in the dynamic info
840 section for ELF executables. There's no point in doing any of this
841 though if we don't have some link map offsets to work with. */
843 if (info
->debug_base
== 0 && svr4_have_link_map_offsets ())
844 info
->debug_base
= elf_locate_base ();
845 return info
->debug_base
;
848 /* Find the first element in the inferior's dynamic link map, and
849 return its address in the inferior.
851 FIXME: Perhaps we should validate the info somehow, perhaps by
852 checking r_version for a known version number, or r_state for
856 solib_svr4_r_map (struct svr4_info
*info
)
858 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
859 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
861 return read_memory_typed_address (info
->debug_base
+ lmo
->r_map_offset
,
865 /* Find r_brk from the inferior's debug base. */
868 solib_svr4_r_brk (struct svr4_info
*info
)
870 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
871 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
873 return read_memory_typed_address (info
->debug_base
+ lmo
->r_brk_offset
,
877 /* Find the link map for the dynamic linker (if it is not in the
878 normal list of loaded shared objects). */
881 solib_svr4_r_ldsomap (struct svr4_info
*info
)
883 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
884 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
885 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
888 /* Check version, and return zero if `struct r_debug' doesn't have
889 the r_ldsomap member. */
891 = read_memory_unsigned_integer (info
->debug_base
+ lmo
->r_version_offset
,
892 lmo
->r_version_size
, byte_order
);
893 if (version
< 2 || lmo
->r_ldsomap_offset
== -1)
896 return read_memory_typed_address (info
->debug_base
+ lmo
->r_ldsomap_offset
,
904 open_symbol_file_object
908 void open_symbol_file_object (void *from_tty)
912 If no open symbol file, attempt to locate and open the main symbol
913 file. On SVR4 systems, this is the first link map entry. If its
914 name is here, we can open it. Useful when attaching to a process
915 without first loading its symbol file.
917 If FROM_TTYP dereferences to a non-zero integer, allow messages to
918 be printed. This parameter is a pointer rather than an int because
919 open_symbol_file_object() is called via catch_errors() and
920 catch_errors() requires a pointer argument. */
923 open_symbol_file_object (void *from_ttyp
)
925 CORE_ADDR lm
, l_name
;
928 int from_tty
= *(int *)from_ttyp
;
929 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
930 struct type
*ptr_type
= builtin_type (target_gdbarch
)->builtin_data_ptr
;
931 int l_name_size
= TYPE_LENGTH (ptr_type
);
932 gdb_byte
*l_name_buf
= xmalloc (l_name_size
);
933 struct cleanup
*cleanups
= make_cleanup (xfree
, l_name_buf
);
934 struct svr4_info
*info
= get_svr4_info (PIDGET (inferior_ptid
));
937 if (!query (_("Attempt to reload symbols from process? ")))
940 /* Always locate the debug struct, in case it has moved. */
941 info
->debug_base
= 0;
942 if (locate_base (info
) == 0)
943 return 0; /* failed somehow... */
945 /* First link map member should be the executable. */
946 lm
= solib_svr4_r_map (info
);
948 return 0; /* failed somehow... */
950 /* Read address of name from target memory to GDB. */
951 read_memory (lm
+ lmo
->l_name_offset
, l_name_buf
, l_name_size
);
953 /* Convert the address to host format. */
954 l_name
= extract_typed_address (l_name_buf
, ptr_type
);
956 /* Free l_name_buf. */
957 do_cleanups (cleanups
);
960 return 0; /* No filename. */
962 /* Now fetch the filename from target memory. */
963 target_read_string (l_name
, &filename
, SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
964 make_cleanup (xfree
, filename
);
968 warning (_("failed to read exec filename from attached file: %s"),
969 safe_strerror (errcode
));
973 /* Have a pathname: read the symbol file. */
974 symbol_file_add_main (filename
, from_tty
);
979 /* If no shared library information is available from the dynamic
980 linker, build a fallback list from other sources. */
982 static struct so_list
*
983 svr4_default_sos (void)
985 struct inferior
*inf
= current_inferior ();
986 struct svr4_info
*info
= get_svr4_info (inf
->pid
);
988 struct so_list
*head
= NULL
;
989 struct so_list
**link_ptr
= &head
;
991 if (info
->debug_loader_offset_p
)
993 struct so_list
*new = XZALLOC (struct so_list
);
995 new->lm_info
= xmalloc (sizeof (struct lm_info
));
997 /* Nothing will ever check the cached copy of the link
998 map if we set l_addr. */
999 new->lm_info
->l_addr
= info
->debug_loader_offset
;
1000 new->lm_info
->lm_addr
= 0;
1001 new->lm_info
->lm
= NULL
;
1003 strncpy (new->so_name
, info
->debug_loader_name
,
1004 SO_NAME_MAX_PATH_SIZE
- 1);
1005 new->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
1006 strcpy (new->so_original_name
, new->so_name
);
1009 link_ptr
= &new->next
;
1017 current_sos -- build a list of currently loaded shared objects
1021 struct so_list *current_sos ()
1025 Build a list of `struct so_list' objects describing the shared
1026 objects currently loaded in the inferior. This list does not
1027 include an entry for the main executable file.
1029 Note that we only gather information directly available from the
1030 inferior --- we don't examine any of the shared library files
1031 themselves. The declaration of `struct so_list' says which fields
1032 we provide values for. */
1034 static struct so_list
*
1035 svr4_current_sos (void)
1038 struct so_list
*head
= 0;
1039 struct so_list
**link_ptr
= &head
;
1040 CORE_ADDR ldsomap
= 0;
1041 struct inferior
*inf
;
1042 struct svr4_info
*info
;
1044 if (ptid_equal (inferior_ptid
, null_ptid
))
1047 inf
= current_inferior ();
1048 info
= get_svr4_info (inf
->pid
);
1050 /* Always locate the debug struct, in case it has moved. */
1051 info
->debug_base
= 0;
1054 /* If we can't find the dynamic linker's base structure, this
1055 must not be a dynamically linked executable. Hmm. */
1056 if (! info
->debug_base
)
1057 return svr4_default_sos ();
1059 /* Walk the inferior's link map list, and build our list of
1060 `struct so_list' nodes. */
1061 lm
= solib_svr4_r_map (info
);
1065 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
1066 struct so_list
*new = XZALLOC (struct so_list
);
1067 struct cleanup
*old_chain
= make_cleanup (xfree
, new);
1069 new->lm_info
= xmalloc (sizeof (struct lm_info
));
1070 make_cleanup (xfree
, new->lm_info
);
1072 new->lm_info
->l_addr
= (CORE_ADDR
)-1;
1073 new->lm_info
->lm_addr
= lm
;
1074 new->lm_info
->lm
= xzalloc (lmo
->link_map_size
);
1075 make_cleanup (xfree
, new->lm_info
->lm
);
1077 read_memory (lm
, new->lm_info
->lm
, lmo
->link_map_size
);
1081 /* For SVR4 versions, the first entry in the link map is for the
1082 inferior executable, so we must ignore it. For some versions of
1083 SVR4, it has no name. For others (Solaris 2.3 for example), it
1084 does have a name, so we can no longer use a missing name to
1085 decide when to ignore it. */
1086 if (IGNORE_FIRST_LINK_MAP_ENTRY (new) && ldsomap
== 0)
1088 info
->main_lm_addr
= new->lm_info
->lm_addr
;
1096 /* Extract this shared object's name. */
1097 target_read_string (LM_NAME (new), &buffer
,
1098 SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
1100 warning (_("Can't read pathname for load map: %s."),
1101 safe_strerror (errcode
));
1104 strncpy (new->so_name
, buffer
, SO_NAME_MAX_PATH_SIZE
- 1);
1105 new->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
1106 strcpy (new->so_original_name
, new->so_name
);
1110 /* If this entry has no name, or its name matches the name
1111 for the main executable, don't include it in the list. */
1112 if (! new->so_name
[0]
1113 || match_main (new->so_name
))
1119 link_ptr
= &new->next
;
1123 /* On Solaris, the dynamic linker is not in the normal list of
1124 shared objects, so make sure we pick it up too. Having
1125 symbol information for the dynamic linker is quite crucial
1126 for skipping dynamic linker resolver code. */
1127 if (lm
== 0 && ldsomap
== 0)
1128 lm
= ldsomap
= solib_svr4_r_ldsomap (info
);
1130 discard_cleanups (old_chain
);
1134 return svr4_default_sos ();
1139 /* Get the address of the link_map for a given OBJFILE. */
1142 svr4_fetch_objfile_link_map (struct objfile
*objfile
)
1145 struct svr4_info
*info
= get_svr4_info (PIDGET (inferior_ptid
));
1147 /* Cause svr4_current_sos() to be run if it hasn't been already. */
1148 if (info
->main_lm_addr
== 0)
1149 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
1151 /* svr4_current_sos() will set main_lm_addr for the main executable. */
1152 if (objfile
== symfile_objfile
)
1153 return info
->main_lm_addr
;
1155 /* The other link map addresses may be found by examining the list
1156 of shared libraries. */
1157 for (so
= master_so_list (); so
; so
= so
->next
)
1158 if (so
->objfile
== objfile
)
1159 return so
->lm_info
->lm_addr
;
1165 /* On some systems, the only way to recognize the link map entry for
1166 the main executable file is by looking at its name. Return
1167 non-zero iff SONAME matches one of the known main executable names. */
1170 match_main (char *soname
)
1174 for (mainp
= main_name_list
; *mainp
!= NULL
; mainp
++)
1176 if (strcmp (soname
, *mainp
) == 0)
1183 /* Return 1 if PC lies in the dynamic symbol resolution code of the
1184 SVR4 run time loader. */
1185 static CORE_ADDR interp_text_sect_low
;
1186 static CORE_ADDR interp_text_sect_high
;
1187 static CORE_ADDR interp_plt_sect_low
;
1188 static CORE_ADDR interp_plt_sect_high
;
1191 svr4_in_dynsym_resolve_code (CORE_ADDR pc
)
1193 return ((pc
>= interp_text_sect_low
&& pc
< interp_text_sect_high
)
1194 || (pc
>= interp_plt_sect_low
&& pc
< interp_plt_sect_high
)
1195 || in_plt_section (pc
, NULL
));
1198 /* Given an executable's ABFD and target, compute the entry-point
1202 exec_entry_point (struct bfd
*abfd
, struct target_ops
*targ
)
1204 /* KevinB wrote ... for most targets, the address returned by
1205 bfd_get_start_address() is the entry point for the start
1206 function. But, for some targets, bfd_get_start_address() returns
1207 the address of a function descriptor from which the entry point
1208 address may be extracted. This address is extracted by
1209 gdbarch_convert_from_func_ptr_addr(). The method
1210 gdbarch_convert_from_func_ptr_addr() is the merely the identify
1211 function for targets which don't use function descriptors. */
1212 return gdbarch_convert_from_func_ptr_addr (target_gdbarch
,
1213 bfd_get_start_address (abfd
),
1221 enable_break -- arrange for dynamic linker to hit breakpoint
1225 int enable_break (void)
1229 Both the SunOS and the SVR4 dynamic linkers have, as part of their
1230 debugger interface, support for arranging for the inferior to hit
1231 a breakpoint after mapping in the shared libraries. This function
1232 enables that breakpoint.
1234 For SunOS, there is a special flag location (in_debugger) which we
1235 set to 1. When the dynamic linker sees this flag set, it will set
1236 a breakpoint at a location known only to itself, after saving the
1237 original contents of that place and the breakpoint address itself,
1238 in it's own internal structures. When we resume the inferior, it
1239 will eventually take a SIGTRAP when it runs into the breakpoint.
1240 We handle this (in a different place) by restoring the contents of
1241 the breakpointed location (which is only known after it stops),
1242 chasing around to locate the shared libraries that have been
1243 loaded, then resuming.
1245 For SVR4, the debugger interface structure contains a member (r_brk)
1246 which is statically initialized at the time the shared library is
1247 built, to the offset of a function (_r_debug_state) which is guaran-
1248 teed to be called once before mapping in a library, and again when
1249 the mapping is complete. At the time we are examining this member,
1250 it contains only the unrelocated offset of the function, so we have
1251 to do our own relocation. Later, when the dynamic linker actually
1252 runs, it relocates r_brk to be the actual address of _r_debug_state().
1254 The debugger interface structure also contains an enumeration which
1255 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
1256 depending upon whether or not the library is being mapped or unmapped,
1257 and then set to RT_CONSISTENT after the library is mapped/unmapped.
1261 enable_break (struct svr4_info
*info
)
1263 struct minimal_symbol
*msymbol
;
1265 asection
*interp_sect
;
1266 gdb_byte
*interp_name
;
1268 struct inferior
*inf
= current_inferior ();
1270 /* First, remove all the solib event breakpoints. Their addresses
1271 may have changed since the last time we ran the program. */
1272 remove_solib_event_breakpoints ();
1274 interp_text_sect_low
= interp_text_sect_high
= 0;
1275 interp_plt_sect_low
= interp_plt_sect_high
= 0;
1277 /* If we already have a shared library list in the target, and
1278 r_debug contains r_brk, set the breakpoint there - this should
1279 mean r_brk has already been relocated. Assume the dynamic linker
1280 is the object containing r_brk. */
1282 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
1284 if (info
->debug_base
&& solib_svr4_r_map (info
) != 0)
1285 sym_addr
= solib_svr4_r_brk (info
);
1289 struct obj_section
*os
;
1291 sym_addr
= gdbarch_addr_bits_remove
1292 (target_gdbarch
, gdbarch_convert_from_func_ptr_addr (target_gdbarch
,
1296 os
= find_pc_section (sym_addr
);
1299 /* Record the relocated start and end address of the dynamic linker
1300 text and plt section for svr4_in_dynsym_resolve_code. */
1302 CORE_ADDR load_addr
;
1304 tmp_bfd
= os
->objfile
->obfd
;
1305 load_addr
= ANOFFSET (os
->objfile
->section_offsets
,
1306 os
->objfile
->sect_index_text
);
1308 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
1311 interp_text_sect_low
=
1312 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1313 interp_text_sect_high
=
1314 interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1316 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
1319 interp_plt_sect_low
=
1320 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1321 interp_plt_sect_high
=
1322 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1325 create_solib_event_breakpoint (target_gdbarch
, sym_addr
);
1330 /* Find the program interpreter; if not found, warn the user and drop
1331 into the old breakpoint at symbol code. */
1332 interp_name
= find_program_interpreter ();
1335 CORE_ADDR load_addr
= 0;
1336 int load_addr_found
= 0;
1337 int loader_found_in_list
= 0;
1339 bfd
*tmp_bfd
= NULL
;
1340 struct target_ops
*tmp_bfd_target
;
1341 volatile struct gdb_exception ex
;
1345 /* Now we need to figure out where the dynamic linker was
1346 loaded so that we can load its symbols and place a breakpoint
1347 in the dynamic linker itself.
1349 This address is stored on the stack. However, I've been unable
1350 to find any magic formula to find it for Solaris (appears to
1351 be trivial on GNU/Linux). Therefore, we have to try an alternate
1352 mechanism to find the dynamic linker's base address. */
1354 TRY_CATCH (ex
, RETURN_MASK_ALL
)
1356 tmp_bfd
= solib_bfd_open (interp_name
);
1358 if (tmp_bfd
== NULL
)
1359 goto bkpt_at_symbol
;
1361 /* Now convert the TMP_BFD into a target. That way target, as
1362 well as BFD operations can be used. Note that closing the
1363 target will also close the underlying bfd. */
1364 tmp_bfd_target
= target_bfd_reopen (tmp_bfd
);
1366 /* On a running target, we can get the dynamic linker's base
1367 address from the shared library table. */
1368 so
= master_so_list ();
1371 if (svr4_same_1 (interp_name
, so
->so_original_name
))
1373 load_addr_found
= 1;
1374 loader_found_in_list
= 1;
1375 load_addr
= LM_ADDR_CHECK (so
, tmp_bfd
);
1381 /* If we were not able to find the base address of the loader
1382 from our so_list, then try using the AT_BASE auxilliary entry. */
1383 if (!load_addr_found
)
1384 if (target_auxv_search (¤t_target
, AT_BASE
, &load_addr
) > 0)
1385 load_addr_found
= 1;
1387 /* Otherwise we find the dynamic linker's base address by examining
1388 the current pc (which should point at the entry point for the
1389 dynamic linker) and subtracting the offset of the entry point.
1391 This is more fragile than the previous approaches, but is a good
1392 fallback method because it has actually been working well in
1394 if (!load_addr_found
)
1396 struct regcache
*regcache
1397 = get_thread_arch_regcache (inferior_ptid
, target_gdbarch
);
1398 load_addr
= (regcache_read_pc (regcache
)
1399 - exec_entry_point (tmp_bfd
, tmp_bfd_target
));
1402 if (!loader_found_in_list
)
1404 info
->debug_loader_name
= xstrdup (interp_name
);
1405 info
->debug_loader_offset_p
= 1;
1406 info
->debug_loader_offset
= load_addr
;
1407 solib_add (NULL
, 0, ¤t_target
, auto_solib_add
);
1410 /* Record the relocated start and end address of the dynamic linker
1411 text and plt section for svr4_in_dynsym_resolve_code. */
1412 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
1415 interp_text_sect_low
=
1416 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1417 interp_text_sect_high
=
1418 interp_text_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1420 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
1423 interp_plt_sect_low
=
1424 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
1425 interp_plt_sect_high
=
1426 interp_plt_sect_low
+ bfd_section_size (tmp_bfd
, interp_sect
);
1429 /* Now try to set a breakpoint in the dynamic linker. */
1430 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1432 sym_addr
= bfd_lookup_symbol (tmp_bfd
, *bkpt_namep
);
1438 /* Convert 'sym_addr' from a function pointer to an address.
1439 Because we pass tmp_bfd_target instead of the current
1440 target, this will always produce an unrelocated value. */
1441 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch
,
1445 /* We're done with both the temporary bfd and target. Remember,
1446 closing the target closes the underlying bfd. */
1447 target_close (tmp_bfd_target
, 0);
1451 create_solib_event_breakpoint (target_gdbarch
, load_addr
+ sym_addr
);
1452 xfree (interp_name
);
1456 /* For whatever reason we couldn't set a breakpoint in the dynamic
1457 linker. Warn and drop into the old code. */
1459 xfree (interp_name
);
1460 warning (_("Unable to find dynamic linker breakpoint function.\n"
1461 "GDB will be unable to debug shared library initializers\n"
1462 "and track explicitly loaded dynamic code."));
1465 /* Scan through the lists of symbols, trying to look up the symbol and
1466 set a breakpoint there. Terminate loop when we/if we succeed. */
1468 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1470 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
1471 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
1473 create_solib_event_breakpoint (target_gdbarch
,
1474 SYMBOL_VALUE_ADDRESS (msymbol
));
1479 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
1481 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
1482 if ((msymbol
!= NULL
) && (SYMBOL_VALUE_ADDRESS (msymbol
) != 0))
1484 create_solib_event_breakpoint (target_gdbarch
,
1485 SYMBOL_VALUE_ADDRESS (msymbol
));
1496 special_symbol_handling -- additional shared library symbol handling
1500 void special_symbol_handling ()
1504 Once the symbols from a shared object have been loaded in the usual
1505 way, we are called to do any system specific symbol handling that
1508 For SunOS4, this consisted of grunging around in the dynamic
1509 linkers structures to find symbol definitions for "common" symbols
1510 and adding them to the minimal symbol table for the runtime common
1513 However, for SVR4, there's nothing to do.
1518 svr4_special_symbol_handling (void)
1522 /* Relocate the main executable. This function should be called upon
1523 stopping the inferior process at the entry point to the program.
1524 The entry point from BFD is compared to the PC and if they are
1525 different, the main executable is relocated by the proper amount.
1527 As written it will only attempt to relocate executables which
1528 lack interpreter sections. It seems likely that only dynamic
1529 linker executables will get relocated, though it should work
1530 properly for a position-independent static executable as well. */
1533 svr4_relocate_main_executable (void)
1535 asection
*interp_sect
;
1536 struct regcache
*regcache
1537 = get_thread_arch_regcache (inferior_ptid
, target_gdbarch
);
1538 CORE_ADDR pc
= regcache_read_pc (regcache
);
1540 /* Decide if the objfile needs to be relocated. As indicated above,
1541 we will only be here when execution is stopped at the beginning
1542 of the program. Relocation is necessary if the address at which
1543 we are presently stopped differs from the start address stored in
1544 the executable AND there's no interpreter section. The condition
1545 regarding the interpreter section is very important because if
1546 there *is* an interpreter section, execution will begin there
1547 instead. When there is an interpreter section, the start address
1548 is (presumably) used by the interpreter at some point to start
1549 execution of the program.
1551 If there is an interpreter, it is normal for it to be set to an
1552 arbitrary address at the outset. The job of finding it is
1553 handled in enable_break().
1555 So, to summarize, relocations are necessary when there is no
1556 interpreter section and the start address obtained from the
1557 executable is different from the address at which GDB is
1560 [ The astute reader will note that we also test to make sure that
1561 the executable in question has the DYNAMIC flag set. It is my
1562 opinion that this test is unnecessary (undesirable even). It
1563 was added to avoid inadvertent relocation of an executable
1564 whose e_type member in the ELF header is not ET_DYN. There may
1565 be a time in the future when it is desirable to do relocations
1566 on other types of files as well in which case this condition
1567 should either be removed or modified to accomodate the new file
1568 type. (E.g, an ET_EXEC executable which has been built to be
1569 position-independent could safely be relocated by the OS if
1570 desired. It is true that this violates the ABI, but the ABI
1571 has been known to be bent from time to time.) - Kevin, Nov 2000. ]
1574 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
1575 if (interp_sect
== NULL
1576 && (bfd_get_file_flags (exec_bfd
) & DYNAMIC
) != 0
1577 && (exec_entry_point (exec_bfd
, &exec_ops
) != pc
))
1579 struct cleanup
*old_chain
;
1580 struct section_offsets
*new_offsets
;
1582 CORE_ADDR displacement
;
1584 /* It is necessary to relocate the objfile. The amount to
1585 relocate by is simply the address at which we are stopped
1586 minus the starting address from the executable.
1588 We relocate all of the sections by the same amount. This
1589 behavior is mandated by recent editions of the System V ABI.
1590 According to the System V Application Binary Interface,
1591 Edition 4.1, page 5-5:
1593 ... Though the system chooses virtual addresses for
1594 individual processes, it maintains the segments' relative
1595 positions. Because position-independent code uses relative
1596 addressesing between segments, the difference between
1597 virtual addresses in memory must match the difference
1598 between virtual addresses in the file. The difference
1599 between the virtual address of any segment in memory and
1600 the corresponding virtual address in the file is thus a
1601 single constant value for any one executable or shared
1602 object in a given process. This difference is the base
1603 address. One use of the base address is to relocate the
1604 memory image of the program during dynamic linking.
1606 The same language also appears in Edition 4.0 of the System V
1607 ABI and is left unspecified in some of the earlier editions. */
1609 displacement
= pc
- exec_entry_point (exec_bfd
, &exec_ops
);
1612 new_offsets
= xcalloc (symfile_objfile
->num_sections
,
1613 sizeof (struct section_offsets
));
1614 old_chain
= make_cleanup (xfree
, new_offsets
);
1616 for (i
= 0; i
< symfile_objfile
->num_sections
; i
++)
1618 if (displacement
!= ANOFFSET (symfile_objfile
->section_offsets
, i
))
1620 new_offsets
->offsets
[i
] = displacement
;
1624 objfile_relocate (symfile_objfile
, new_offsets
);
1626 do_cleanups (old_chain
);
1634 svr4_solib_create_inferior_hook -- shared library startup support
1638 void svr4_solib_create_inferior_hook ()
1642 When gdb starts up the inferior, it nurses it along (through the
1643 shell) until it is ready to execute it's first instruction. At this
1644 point, this function gets called via expansion of the macro
1645 SOLIB_CREATE_INFERIOR_HOOK.
1647 For SunOS executables, this first instruction is typically the
1648 one at "_start", or a similar text label, regardless of whether
1649 the executable is statically or dynamically linked. The runtime
1650 startup code takes care of dynamically linking in any shared
1651 libraries, once gdb allows the inferior to continue.
1653 For SVR4 executables, this first instruction is either the first
1654 instruction in the dynamic linker (for dynamically linked
1655 executables) or the instruction at "start" for statically linked
1656 executables. For dynamically linked executables, the system
1657 first exec's /lib/libc.so.N, which contains the dynamic linker,
1658 and starts it running. The dynamic linker maps in any needed
1659 shared libraries, maps in the actual user executable, and then
1660 jumps to "start" in the user executable.
1662 For both SunOS shared libraries, and SVR4 shared libraries, we
1663 can arrange to cooperate with the dynamic linker to discover the
1664 names of shared libraries that are dynamically linked, and the
1665 base addresses to which they are linked.
1667 This function is responsible for discovering those names and
1668 addresses, and saving sufficient information about them to allow
1669 their symbols to be read at a later time.
1673 Between enable_break() and disable_break(), this code does not
1674 properly handle hitting breakpoints which the user might have
1675 set in the startup code or in the dynamic linker itself. Proper
1676 handling will probably have to wait until the implementation is
1677 changed to use the "breakpoint handler function" method.
1679 Also, what if child has exit()ed? Must exit loop somehow.
1683 svr4_solib_create_inferior_hook (void)
1685 struct inferior
*inf
;
1686 struct thread_info
*tp
;
1687 struct svr4_info
*info
;
1689 info
= get_svr4_info (PIDGET (inferior_ptid
));
1691 /* Relocate the main executable if necessary. */
1692 svr4_relocate_main_executable ();
1694 if (!svr4_have_link_map_offsets ())
1697 if (!enable_break (info
))
1700 #if defined(_SCO_DS)
1701 /* SCO needs the loop below, other systems should be using the
1702 special shared library breakpoints and the shared library breakpoint
1705 Now run the target. It will eventually hit the breakpoint, at
1706 which point all of the libraries will have been mapped in and we
1707 can go groveling around in the dynamic linker structures to find
1708 out what we need to know about them. */
1710 inf
= current_inferior ();
1711 tp
= inferior_thread ();
1713 clear_proceed_status ();
1714 inf
->stop_soon
= STOP_QUIETLY
;
1715 tp
->stop_signal
= TARGET_SIGNAL_0
;
1718 target_resume (pid_to_ptid (-1), 0, tp
->stop_signal
);
1719 wait_for_inferior (0);
1721 while (tp
->stop_signal
!= TARGET_SIGNAL_TRAP
);
1722 inf
->stop_soon
= NO_STOP_QUIETLY
;
1723 #endif /* defined(_SCO_DS) */
1727 svr4_clear_solib (void)
1729 remove_svr4_info (PIDGET (inferior_ptid
));
1733 svr4_free_so (struct so_list
*so
)
1735 xfree (so
->lm_info
->lm
);
1736 xfree (so
->lm_info
);
1740 /* Clear any bits of ADDR that wouldn't fit in a target-format
1741 data pointer. "Data pointer" here refers to whatever sort of
1742 address the dynamic linker uses to manage its sections. At the
1743 moment, we don't support shared libraries on any processors where
1744 code and data pointers are different sizes.
1746 This isn't really the right solution. What we really need here is
1747 a way to do arithmetic on CORE_ADDR values that respects the
1748 natural pointer/address correspondence. (For example, on the MIPS,
1749 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
1750 sign-extend the value. There, simply truncating the bits above
1751 gdbarch_ptr_bit, as we do below, is no good.) This should probably
1752 be a new gdbarch method or something. */
1754 svr4_truncate_ptr (CORE_ADDR addr
)
1756 if (gdbarch_ptr_bit (target_gdbarch
) == sizeof (CORE_ADDR
) * 8)
1757 /* We don't need to truncate anything, and the bit twiddling below
1758 will fail due to overflow problems. */
1761 return addr
& (((CORE_ADDR
) 1 << gdbarch_ptr_bit (target_gdbarch
)) - 1);
1766 svr4_relocate_section_addresses (struct so_list
*so
,
1767 struct target_section
*sec
)
1769 sec
->addr
= svr4_truncate_ptr (sec
->addr
+ LM_ADDR_CHECK (so
,
1771 sec
->endaddr
= svr4_truncate_ptr (sec
->endaddr
+ LM_ADDR_CHECK (so
,
1776 /* Architecture-specific operations. */
1778 /* Per-architecture data key. */
1779 static struct gdbarch_data
*solib_svr4_data
;
1781 struct solib_svr4_ops
1783 /* Return a description of the layout of `struct link_map'. */
1784 struct link_map_offsets
*(*fetch_link_map_offsets
)(void);
1787 /* Return a default for the architecture-specific operations. */
1790 solib_svr4_init (struct obstack
*obstack
)
1792 struct solib_svr4_ops
*ops
;
1794 ops
= OBSTACK_ZALLOC (obstack
, struct solib_svr4_ops
);
1795 ops
->fetch_link_map_offsets
= NULL
;
1799 /* Set the architecture-specific `struct link_map_offsets' fetcher for
1800 GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */
1803 set_solib_svr4_fetch_link_map_offsets (struct gdbarch
*gdbarch
,
1804 struct link_map_offsets
*(*flmo
) (void))
1806 struct solib_svr4_ops
*ops
= gdbarch_data (gdbarch
, solib_svr4_data
);
1808 ops
->fetch_link_map_offsets
= flmo
;
1810 set_solib_ops (gdbarch
, &svr4_so_ops
);
1813 /* Fetch a link_map_offsets structure using the architecture-specific
1814 `struct link_map_offsets' fetcher. */
1816 static struct link_map_offsets
*
1817 svr4_fetch_link_map_offsets (void)
1819 struct solib_svr4_ops
*ops
= gdbarch_data (target_gdbarch
, solib_svr4_data
);
1821 gdb_assert (ops
->fetch_link_map_offsets
);
1822 return ops
->fetch_link_map_offsets ();
1825 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
1828 svr4_have_link_map_offsets (void)
1830 struct solib_svr4_ops
*ops
= gdbarch_data (target_gdbarch
, solib_svr4_data
);
1831 return (ops
->fetch_link_map_offsets
!= NULL
);
1835 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
1836 `struct r_debug' and a `struct link_map' that are binary compatible
1837 with the origional SVR4 implementation. */
1839 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
1840 for an ILP32 SVR4 system. */
1842 struct link_map_offsets
*
1843 svr4_ilp32_fetch_link_map_offsets (void)
1845 static struct link_map_offsets lmo
;
1846 static struct link_map_offsets
*lmp
= NULL
;
1852 lmo
.r_version_offset
= 0;
1853 lmo
.r_version_size
= 4;
1854 lmo
.r_map_offset
= 4;
1855 lmo
.r_brk_offset
= 8;
1856 lmo
.r_ldsomap_offset
= 20;
1858 /* Everything we need is in the first 20 bytes. */
1859 lmo
.link_map_size
= 20;
1860 lmo
.l_addr_offset
= 0;
1861 lmo
.l_name_offset
= 4;
1862 lmo
.l_ld_offset
= 8;
1863 lmo
.l_next_offset
= 12;
1864 lmo
.l_prev_offset
= 16;
1870 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
1871 for an LP64 SVR4 system. */
1873 struct link_map_offsets
*
1874 svr4_lp64_fetch_link_map_offsets (void)
1876 static struct link_map_offsets lmo
;
1877 static struct link_map_offsets
*lmp
= NULL
;
1883 lmo
.r_version_offset
= 0;
1884 lmo
.r_version_size
= 4;
1885 lmo
.r_map_offset
= 8;
1886 lmo
.r_brk_offset
= 16;
1887 lmo
.r_ldsomap_offset
= 40;
1889 /* Everything we need is in the first 40 bytes. */
1890 lmo
.link_map_size
= 40;
1891 lmo
.l_addr_offset
= 0;
1892 lmo
.l_name_offset
= 8;
1893 lmo
.l_ld_offset
= 16;
1894 lmo
.l_next_offset
= 24;
1895 lmo
.l_prev_offset
= 32;
1902 struct target_so_ops svr4_so_ops
;
1904 /* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a
1905 different rule for symbol lookup. The lookup begins here in the DSO, not in
1906 the main executable. */
1908 static struct symbol
*
1909 elf_lookup_lib_symbol (const struct objfile
*objfile
,
1911 const char *linkage_name
,
1912 const domain_enum domain
)
1914 if (objfile
->obfd
== NULL
1915 || scan_dyntag (DT_SYMBOLIC
, objfile
->obfd
, NULL
) != 1)
1918 return lookup_global_symbol_from_objfile
1919 (objfile
, name
, linkage_name
, domain
);
1922 extern initialize_file_ftype _initialize_svr4_solib
; /* -Wmissing-prototypes */
1925 _initialize_svr4_solib (void)
1927 solib_svr4_data
= gdbarch_data_register_pre_init (solib_svr4_init
);
1929 svr4_so_ops
.relocate_section_addresses
= svr4_relocate_section_addresses
;
1930 svr4_so_ops
.free_so
= svr4_free_so
;
1931 svr4_so_ops
.clear_solib
= svr4_clear_solib
;
1932 svr4_so_ops
.solib_create_inferior_hook
= svr4_solib_create_inferior_hook
;
1933 svr4_so_ops
.special_symbol_handling
= svr4_special_symbol_handling
;
1934 svr4_so_ops
.current_sos
= svr4_current_sos
;
1935 svr4_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
1936 svr4_so_ops
.in_dynsym_resolve_code
= svr4_in_dynsym_resolve_code
;
1937 svr4_so_ops
.bfd_open
= solib_bfd_open
;
1938 svr4_so_ops
.lookup_lib_global_symbol
= elf_lookup_lib_symbol
;
1939 svr4_so_ops
.same
= svr4_same
;
1941 observer_attach_inferior_exit (solib_svr4_inferior_exit
);