1 /* Handle SVR4 shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 1990-2023 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "elf/external.h"
23 #include "elf/common.h"
35 #include "observable.h"
39 #include "solib-svr4.h"
41 #include "bfd-target.h"
50 static struct link_map_offsets
*svr4_fetch_link_map_offsets (void);
51 static int svr4_have_link_map_offsets (void);
52 static void svr4_relocate_main_executable (void);
53 static void svr4_free_library_list (so_list
*solist
);
54 static void probes_table_remove_objfile_probes (struct objfile
*objfile
);
55 static void svr4_iterate_over_objfiles_in_search_order
56 (gdbarch
*gdbarch
, iterate_over_objfiles_in_search_order_cb_ftype cb
,
57 objfile
*current_objfile
);
60 /* On SVR4 systems, a list of symbols in the dynamic linker where
61 GDB can try to place a breakpoint to monitor shared library
64 If none of these symbols are found, or other errors occur, then
65 SVR4 systems will fall back to using a symbol as the "startup
66 mapping complete" breakpoint address. */
68 static const char * const solib_break_names
[] =
74 "__dl_rtld_db_dlactivity",
80 static const char * const bkpt_names
[] =
88 static const char * const main_name_list
[] =
94 /* What to do when a probe stop occurs. */
98 /* Something went seriously wrong. Stop using probes and
99 revert to using the older interface. */
100 PROBES_INTERFACE_FAILED
,
102 /* No action is required. The shared object list is still
106 /* The shared object list should be reloaded entirely. */
109 /* Attempt to incrementally update the shared object list. If
110 the update fails or is not possible, fall back to reloading
115 /* A probe's name and its associated action. */
119 /* The name of the probe. */
122 /* What to do when a probe stop occurs. */
123 enum probe_action action
;
126 /* A list of named probes and their associated actions. If all
127 probes are present in the dynamic linker then the probes-based
128 interface will be used. */
130 static const struct probe_info probe_info
[] =
132 { "init_start", DO_NOTHING
},
133 { "init_complete", FULL_RELOAD
},
134 { "map_start", DO_NOTHING
},
135 { "map_failed", DO_NOTHING
},
136 { "reloc_complete", UPDATE_OR_RELOAD
},
137 { "unmap_start", DO_NOTHING
},
138 { "unmap_complete", FULL_RELOAD
},
141 #define NUM_PROBES ARRAY_SIZE (probe_info)
143 /* Return non-zero if GDB_SO_NAME and INFERIOR_SO_NAME represent
144 the same shared library. */
147 svr4_same_1 (const char *gdb_so_name
, const char *inferior_so_name
)
149 if (strcmp (gdb_so_name
, inferior_so_name
) == 0)
152 /* On Solaris, when starting inferior we think that dynamic linker is
153 /usr/lib/ld.so.1, but later on, the table of loaded shared libraries
154 contains /lib/ld.so.1. Sometimes one file is a link to another, but
155 sometimes they have identical content, but are not linked to each
156 other. We don't restrict this check for Solaris, but the chances
157 of running into this situation elsewhere are very low. */
158 if (strcmp (gdb_so_name
, "/usr/lib/ld.so.1") == 0
159 && strcmp (inferior_so_name
, "/lib/ld.so.1") == 0)
162 /* Similarly, we observed the same issue with amd64 and sparcv9, but with
163 different locations. */
164 if (strcmp (gdb_so_name
, "/usr/lib/amd64/ld.so.1") == 0
165 && strcmp (inferior_so_name
, "/lib/amd64/ld.so.1") == 0)
168 if (strcmp (gdb_so_name
, "/usr/lib/sparcv9/ld.so.1") == 0
169 && strcmp (inferior_so_name
, "/lib/sparcv9/ld.so.1") == 0)
176 svr4_same (struct so_list
*gdb
, struct so_list
*inferior
)
178 if (!svr4_same_1 (gdb
->so_original_name
, inferior
->so_original_name
))
181 /* There may be different instances of the same library, in different
182 namespaces. Each instance, however, must have been loaded at a
183 different address so its relocation offset would be different. */
184 const lm_info_svr4
*lmg
= (const lm_info_svr4
*) gdb
->lm_info
;
185 const lm_info_svr4
*lmi
= (const lm_info_svr4
*) inferior
->lm_info
;
187 return (lmg
->l_addr_inferior
== lmi
->l_addr_inferior
);
190 static std::unique_ptr
<lm_info_svr4
>
191 lm_info_read (CORE_ADDR lm_addr
)
193 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
194 std::unique_ptr
<lm_info_svr4
> lm_info
;
196 gdb::byte_vector
lm (lmo
->link_map_size
);
198 if (target_read_memory (lm_addr
, lm
.data (), lmo
->link_map_size
) != 0)
199 warning (_("Error reading shared library list entry at %s"),
200 paddress (current_inferior ()->arch (), lm_addr
));
204 = builtin_type (current_inferior ()->arch ())->builtin_data_ptr
;
206 lm_info
.reset (new lm_info_svr4
);
207 lm_info
->lm_addr
= lm_addr
;
209 lm_info
->l_addr_inferior
= extract_typed_address (&lm
[lmo
->l_addr_offset
],
211 lm_info
->l_ld
= extract_typed_address (&lm
[lmo
->l_ld_offset
], ptr_type
);
212 lm_info
->l_next
= extract_typed_address (&lm
[lmo
->l_next_offset
],
214 lm_info
->l_prev
= extract_typed_address (&lm
[lmo
->l_prev_offset
],
216 lm_info
->l_name
= extract_typed_address (&lm
[lmo
->l_name_offset
],
224 has_lm_dynamic_from_link_map (void)
226 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
228 return lmo
->l_ld_offset
>= 0;
232 lm_addr_check (const struct so_list
*so
, bfd
*abfd
)
234 lm_info_svr4
*li
= (lm_info_svr4
*) so
->lm_info
;
238 struct bfd_section
*dyninfo_sect
;
239 CORE_ADDR l_addr
, l_dynaddr
, dynaddr
;
241 l_addr
= li
->l_addr_inferior
;
243 if (! abfd
|| ! has_lm_dynamic_from_link_map ())
246 l_dynaddr
= li
->l_ld
;
248 dyninfo_sect
= bfd_get_section_by_name (abfd
, ".dynamic");
249 if (dyninfo_sect
== NULL
)
252 dynaddr
= bfd_section_vma (dyninfo_sect
);
254 if (dynaddr
+ l_addr
!= l_dynaddr
)
256 CORE_ADDR align
= 0x1000;
257 CORE_ADDR minpagesize
= align
;
259 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
261 Elf_Internal_Ehdr
*ehdr
= elf_tdata (abfd
)->elf_header
;
262 Elf_Internal_Phdr
*phdr
= elf_tdata (abfd
)->phdr
;
267 for (i
= 0; i
< ehdr
->e_phnum
; i
++)
268 if (phdr
[i
].p_type
== PT_LOAD
&& phdr
[i
].p_align
> align
)
269 align
= phdr
[i
].p_align
;
271 minpagesize
= get_elf_backend_data (abfd
)->minpagesize
;
274 /* Turn it into a mask. */
277 /* If the changes match the alignment requirements, we
278 assume we're using a core file that was generated by the
279 same binary, just prelinked with a different base offset.
280 If it doesn't match, we may have a different binary, the
281 same binary with the dynamic table loaded at an unrelated
282 location, or anything, really. To avoid regressions,
283 don't adjust the base offset in the latter case, although
284 odds are that, if things really changed, debugging won't
287 One could expect more the condition
288 ((l_addr & align) == 0 && ((l_dynaddr - dynaddr) & align) == 0)
289 but the one below is relaxed for PPC. The PPC kernel supports
290 either 4k or 64k page sizes. To be prepared for 64k pages,
291 PPC ELF files are built using an alignment requirement of 64k.
292 However, when running on a kernel supporting 4k pages, the memory
293 mapping of the library may not actually happen on a 64k boundary!
295 (In the usual case where (l_addr & align) == 0, this check is
296 equivalent to the possibly expected check above.)
298 Even on PPC it must be zero-aligned at least for MINPAGESIZE. */
300 l_addr
= l_dynaddr
- dynaddr
;
302 if ((l_addr
& (minpagesize
- 1)) == 0
303 && (l_addr
& align
) == ((l_dynaddr
- dynaddr
) & align
))
306 gdb_printf (_("Using PIC (Position Independent Code) "
307 "prelink displacement %s for \"%s\".\n"),
308 paddress (current_inferior ()->arch (), l_addr
),
313 /* There is no way to verify the library file matches. prelink
314 can during prelinking of an unprelinked file (or unprelinking
315 of a prelinked file) shift the DYNAMIC segment by arbitrary
316 offset without any page size alignment. There is no way to
317 find out the ELF header and/or Program Headers for a limited
318 verification if it they match. One could do a verification
319 of the DYNAMIC segment. Still the found address is the best
320 one GDB could find. */
322 warning (_(".dynamic section for \"%s\" "
323 "is not at the expected address "
324 "(wrong library or version mismatch?)"), so
->so_name
);
336 /* Per pspace SVR4 specific data. */
340 svr4_info () = default;
343 /* Base of dynamic linker structures in default namespace. */
344 CORE_ADDR debug_base
= 0;
346 /* Validity flag for debug_loader_offset. */
347 int debug_loader_offset_p
= 0;
349 /* Load address for the dynamic linker, inferred. */
350 CORE_ADDR debug_loader_offset
= 0;
352 /* Name of the dynamic linker, valid if debug_loader_offset_p. */
353 char *debug_loader_name
= nullptr;
355 /* Load map address for the main executable in default namespace. */
356 CORE_ADDR main_lm_addr
= 0;
358 CORE_ADDR interp_text_sect_low
= 0;
359 CORE_ADDR interp_text_sect_high
= 0;
360 CORE_ADDR interp_plt_sect_low
= 0;
361 CORE_ADDR interp_plt_sect_high
= 0;
363 /* True if the list of objects was last obtained from the target
364 via qXfer:libraries-svr4:read. */
365 bool using_xfer
= false;
367 /* Table of struct probe_and_action instances, used by the
368 probes-based interface to map breakpoint addresses to probes
369 and their associated actions. Lookup is performed using
370 probe_and_action->prob->address. */
371 htab_up probes_table
;
373 /* List of objects loaded into the inferior per namespace, used by the
374 probes-based interface.
376 The namespace is represented by the address of its corresponding
377 r_debug[_ext] object. We get the namespace id as argument to the
378 'reloc_complete' probe but we don't get it when scanning the load map
381 The r_debug[_ext] objects may move when ld.so itself moves. In that
382 case, we expect also the global _r_debug to move so we can detect
383 this and reload everything. The r_debug[_ext] objects are not
384 expected to move individually.
386 The special entry zero is reserved for a linear list to support
387 gdbstubs that do not support namespaces. */
388 std::map
<CORE_ADDR
, so_list
*> solib_lists
;
391 /* Per-program-space data key. */
392 static const registry
<program_space
>::key
<svr4_info
> solib_svr4_pspace_data
;
394 /* Return whether DEBUG_BASE is the default namespace of INFO. */
397 svr4_is_default_namespace (const svr4_info
*info
, CORE_ADDR debug_base
)
399 return (debug_base
== info
->debug_base
);
402 /* Free the probes table. */
405 free_probes_table (struct svr4_info
*info
)
407 info
->probes_table
.reset (nullptr);
410 /* Free the solib lists for all namespaces. */
413 free_solib_lists (svr4_info
*info
)
415 for (const std::pair
<CORE_ADDR
, so_list
*> tuple
417 svr4_free_library_list (tuple
.second
);
419 info
->solib_lists
.clear ();
422 svr4_info::~svr4_info ()
424 free_solib_lists (this);
427 /* Get the svr4 data for program space PSPACE. If none is found yet, add it now.
428 This function always returns a valid object. */
430 static struct svr4_info
*
431 get_svr4_info (program_space
*pspace
)
433 struct svr4_info
*info
= solib_svr4_pspace_data
.get (pspace
);
436 info
= solib_svr4_pspace_data
.emplace (pspace
);
441 /* Local function prototypes */
443 static int match_main (const char *);
445 /* Read program header TYPE from inferior memory. The header is found
446 by scanning the OS auxiliary vector.
448 If TYPE == -1, return the program headers instead of the contents of
451 Return vector of bytes holding the program header contents, or an empty
452 optional on failure. If successful and P_ARCH_SIZE is non-NULL, the target
453 architecture size (32-bit or 64-bit) is returned to *P_ARCH_SIZE. Likewise,
454 the base address of the section is returned in *BASE_ADDR. */
456 static gdb::optional
<gdb::byte_vector
>
457 read_program_header (int type
, int *p_arch_size
, CORE_ADDR
*base_addr
)
459 bfd_endian byte_order
= gdbarch_byte_order (current_inferior ()->arch ());
460 CORE_ADDR at_phdr
, at_phent
, at_phnum
, pt_phdr
= 0;
461 int arch_size
, sect_size
;
465 /* Get required auxv elements from target. */
466 if (target_auxv_search (AT_PHDR
, &at_phdr
) <= 0)
468 if (target_auxv_search (AT_PHENT
, &at_phent
) <= 0)
470 if (target_auxv_search (AT_PHNUM
, &at_phnum
) <= 0)
472 if (!at_phdr
|| !at_phnum
)
475 /* Determine ELF architecture type. */
476 if (at_phent
== sizeof (Elf32_External_Phdr
))
478 else if (at_phent
== sizeof (Elf64_External_Phdr
))
483 /* Find the requested segment. */
487 sect_size
= at_phent
* at_phnum
;
489 else if (arch_size
== 32)
491 Elf32_External_Phdr phdr
;
494 /* Search for requested PHDR. */
495 for (i
= 0; i
< at_phnum
; i
++)
499 if (target_read_memory (at_phdr
+ i
* sizeof (phdr
),
500 (gdb_byte
*)&phdr
, sizeof (phdr
)))
503 p_type
= extract_unsigned_integer ((gdb_byte
*) phdr
.p_type
,
506 if (p_type
== PT_PHDR
)
509 pt_phdr
= extract_unsigned_integer ((gdb_byte
*) phdr
.p_vaddr
,
520 /* Retrieve address and size. */
521 sect_addr
= extract_unsigned_integer ((gdb_byte
*)phdr
.p_vaddr
,
523 sect_size
= extract_unsigned_integer ((gdb_byte
*)phdr
.p_memsz
,
528 Elf64_External_Phdr phdr
;
531 /* Search for requested PHDR. */
532 for (i
= 0; i
< at_phnum
; i
++)
536 if (target_read_memory (at_phdr
+ i
* sizeof (phdr
),
537 (gdb_byte
*)&phdr
, sizeof (phdr
)))
540 p_type
= extract_unsigned_integer ((gdb_byte
*) phdr
.p_type
,
543 if (p_type
== PT_PHDR
)
546 pt_phdr
= extract_unsigned_integer ((gdb_byte
*) phdr
.p_vaddr
,
557 /* Retrieve address and size. */
558 sect_addr
= extract_unsigned_integer ((gdb_byte
*)phdr
.p_vaddr
,
560 sect_size
= extract_unsigned_integer ((gdb_byte
*)phdr
.p_memsz
,
564 /* PT_PHDR is optional, but we really need it
565 for PIE to make this work in general. */
569 /* at_phdr is real address in memory. pt_phdr is what pheader says it is.
570 Relocation offset is the difference between the two. */
571 sect_addr
= sect_addr
+ (at_phdr
- pt_phdr
);
574 /* Read in requested program header. */
575 gdb::byte_vector
buf (sect_size
);
576 if (target_read_memory (sect_addr
, buf
.data (), sect_size
))
580 *p_arch_size
= arch_size
;
582 *base_addr
= sect_addr
;
588 /* Return program interpreter string. */
589 static gdb::optional
<gdb::byte_vector
>
590 find_program_interpreter (void)
592 /* If we have a current exec_bfd, use its section table. */
593 if (current_program_space
->exec_bfd ()
594 && (bfd_get_flavour (current_program_space
->exec_bfd ())
595 == bfd_target_elf_flavour
))
597 struct bfd_section
*interp_sect
;
599 interp_sect
= bfd_get_section_by_name (current_program_space
->exec_bfd (),
601 if (interp_sect
!= NULL
)
603 int sect_size
= bfd_section_size (interp_sect
);
605 gdb::byte_vector
buf (sect_size
);
607 = bfd_get_section_contents (current_program_space
->exec_bfd (),
608 interp_sect
, buf
.data (), 0, sect_size
);
614 /* If we didn't find it, use the target auxiliary vector. */
615 return read_program_header (PT_INTERP
, NULL
, NULL
);
619 /* Scan for DESIRED_DYNTAG in .dynamic section of the target's main executable,
620 found by consulting the OS auxillary vector. If DESIRED_DYNTAG is found, 1
621 is returned and the corresponding PTR is set. */
624 scan_dyntag_auxv (const int desired_dyntag
, CORE_ADDR
*ptr
,
627 bfd_endian byte_order
= gdbarch_byte_order (current_inferior ()->arch ());
633 /* Read in .dynamic section. */
634 gdb::optional
<gdb::byte_vector
> ph_data
635 = read_program_header (PT_DYNAMIC
, &arch_size
, &base_addr
);
639 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
640 step
= (arch_size
== 32) ? sizeof (Elf32_External_Dyn
)
641 : sizeof (Elf64_External_Dyn
);
642 for (gdb_byte
*buf
= ph_data
->data (), *bufend
= buf
+ ph_data
->size ();
643 buf
< bufend
; buf
+= step
)
647 Elf32_External_Dyn
*dynp
= (Elf32_External_Dyn
*) buf
;
649 current_dyntag
= extract_unsigned_integer ((gdb_byte
*) dynp
->d_tag
,
651 dyn_ptr
= extract_unsigned_integer ((gdb_byte
*) dynp
->d_un
.d_ptr
,
656 Elf64_External_Dyn
*dynp
= (Elf64_External_Dyn
*) buf
;
658 current_dyntag
= extract_unsigned_integer ((gdb_byte
*) dynp
->d_tag
,
660 dyn_ptr
= extract_unsigned_integer ((gdb_byte
*) dynp
->d_un
.d_ptr
,
663 if (current_dyntag
== DT_NULL
)
666 if (current_dyntag
== desired_dyntag
)
672 *ptr_addr
= base_addr
+ buf
- ph_data
->data ();
681 /* Locate the base address of dynamic linker structs for SVR4 elf
684 For SVR4 elf targets the address of the dynamic linker's runtime
685 structure is contained within the dynamic info section in the
686 executable file. The dynamic section is also mapped into the
687 inferior address space. Because the runtime loader fills in the
688 real address before starting the inferior, we have to read in the
689 dynamic info section from the inferior address space.
690 If there are any errors while trying to find the address, we
691 silently return 0, otherwise the found address is returned. */
694 elf_locate_base (void)
696 struct bound_minimal_symbol msymbol
;
697 CORE_ADDR dyn_ptr
, dyn_ptr_addr
;
699 if (!svr4_have_link_map_offsets ())
702 /* Look for DT_MIPS_RLD_MAP first. MIPS executables use this
703 instead of DT_DEBUG, although they sometimes contain an unused
705 if (gdb_bfd_scan_elf_dyntag (DT_MIPS_RLD_MAP
,
706 current_program_space
->exec_bfd (),
708 || scan_dyntag_auxv (DT_MIPS_RLD_MAP
, &dyn_ptr
, NULL
))
711 = builtin_type (current_inferior ()->arch ())->builtin_data_ptr
;
713 int pbuf_size
= ptr_type
->length ();
715 pbuf
= (gdb_byte
*) alloca (pbuf_size
);
716 /* DT_MIPS_RLD_MAP contains a pointer to the address
717 of the dynamic link structure. */
718 if (target_read_memory (dyn_ptr
, pbuf
, pbuf_size
))
720 return extract_typed_address (pbuf
, ptr_type
);
723 /* Then check DT_MIPS_RLD_MAP_REL. MIPS executables now use this form
724 because of needing to support PIE. DT_MIPS_RLD_MAP will also exist
726 if (gdb_bfd_scan_elf_dyntag (DT_MIPS_RLD_MAP_REL
,
727 current_program_space
->exec_bfd (),
728 &dyn_ptr
, &dyn_ptr_addr
)
729 || scan_dyntag_auxv (DT_MIPS_RLD_MAP_REL
, &dyn_ptr
, &dyn_ptr_addr
))
732 = builtin_type (current_inferior ()->arch ())->builtin_data_ptr
;
734 int pbuf_size
= ptr_type
->length ();
736 pbuf
= (gdb_byte
*) alloca (pbuf_size
);
737 /* DT_MIPS_RLD_MAP_REL contains an offset from the address of the
738 DT slot to the address of the dynamic link structure. */
739 if (target_read_memory (dyn_ptr
+ dyn_ptr_addr
, pbuf
, pbuf_size
))
741 return extract_typed_address (pbuf
, ptr_type
);
745 if (gdb_bfd_scan_elf_dyntag (DT_DEBUG
, current_program_space
->exec_bfd (),
747 || scan_dyntag_auxv (DT_DEBUG
, &dyn_ptr
, NULL
))
750 /* This may be a static executable. Look for the symbol
751 conventionally named _r_debug, as a last resort. */
752 msymbol
= lookup_minimal_symbol ("_r_debug", NULL
,
753 current_program_space
->symfile_object_file
);
754 if (msymbol
.minsym
!= NULL
)
755 return msymbol
.value_address ();
757 /* DT_DEBUG entry not found. */
761 /* Find the first element in the inferior's dynamic link map, and
762 return its address in the inferior. Return zero if the address
763 could not be determined.
765 FIXME: Perhaps we should validate the info somehow, perhaps by
766 checking r_version for a known version number, or r_state for
770 solib_svr4_r_map (CORE_ADDR debug_base
)
772 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
774 = builtin_type (current_inferior ()->arch ())->builtin_data_ptr
;
779 addr
= read_memory_typed_address (debug_base
+ lmo
->r_map_offset
,
782 catch (const gdb_exception_error
&ex
)
784 exception_print (gdb_stderr
, ex
);
790 /* Find r_brk from the inferior's debug base. */
793 solib_svr4_r_brk (struct svr4_info
*info
)
795 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
797 = builtin_type (current_inferior ()->arch ())->builtin_data_ptr
;
799 return read_memory_typed_address (info
->debug_base
+ lmo
->r_brk_offset
,
803 /* Find the link map for the dynamic linker (if it is not in the
804 normal list of loaded shared objects). */
807 solib_svr4_r_ldsomap (struct svr4_info
*info
)
809 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
811 = builtin_type (current_inferior ()->arch ())->builtin_data_ptr
;
812 enum bfd_endian byte_order
= type_byte_order (ptr_type
);
813 ULONGEST version
= 0;
817 /* Check version, and return zero if `struct r_debug' doesn't have
818 the r_ldsomap member. */
820 = read_memory_unsigned_integer (info
->debug_base
+ lmo
->r_version_offset
,
821 lmo
->r_version_size
, byte_order
);
823 catch (const gdb_exception_error
&ex
)
825 exception_print (gdb_stderr
, ex
);
828 if (version
< 2 || lmo
->r_ldsomap_offset
== -1)
831 return read_memory_typed_address (info
->debug_base
+ lmo
->r_ldsomap_offset
,
835 /* Find the next namespace from the r_next field. */
838 solib_svr4_r_next (CORE_ADDR debug_base
)
840 link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
842 = builtin_type (current_inferior ()->arch ())->builtin_data_ptr
;
843 bfd_endian byte_order
= type_byte_order (ptr_type
);
844 ULONGEST version
= 0;
849 = read_memory_unsigned_integer (debug_base
+ lmo
->r_version_offset
,
850 lmo
->r_version_size
, byte_order
);
852 catch (const gdb_exception_error
&ex
)
854 exception_print (gdb_stderr
, ex
);
857 /* The r_next field is added with r_version == 2. */
858 if (version
< 2 || lmo
->r_next_offset
== -1)
861 return read_memory_typed_address (debug_base
+ lmo
->r_next_offset
,
865 /* On Solaris systems with some versions of the dynamic linker,
866 ld.so's l_name pointer points to the SONAME in the string table
867 rather than into writable memory. So that GDB can find shared
868 libraries when loading a core file generated by gcore, ensure that
869 memory areas containing the l_name string are saved in the core
873 svr4_keep_data_in_core (CORE_ADDR vaddr
, unsigned long size
)
875 struct svr4_info
*info
;
879 info
= get_svr4_info (current_program_space
);
881 info
->debug_base
= elf_locate_base ();
882 if (info
->debug_base
== 0)
885 ldsomap
= solib_svr4_r_ldsomap (info
);
889 std::unique_ptr
<lm_info_svr4
> li
= lm_info_read (ldsomap
);
890 name_lm
= li
!= NULL
? li
->l_name
: 0;
892 return (name_lm
>= vaddr
&& name_lm
< vaddr
+ size
);
898 open_symbol_file_object (int from_tty
)
900 CORE_ADDR lm
, l_name
;
901 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
903 = builtin_type (current_inferior ()->arch ())->builtin_data_ptr
;
904 int l_name_size
= ptr_type
->length ();
905 gdb::byte_vector
l_name_buf (l_name_size
);
906 struct svr4_info
*info
= get_svr4_info (current_program_space
);
907 symfile_add_flags add_flags
= 0;
910 add_flags
|= SYMFILE_VERBOSE
;
912 if (current_program_space
->symfile_object_file
)
913 if (!query (_("Attempt to reload symbols from process? ")))
916 /* Always locate the debug struct, in case it has moved. */
917 info
->debug_base
= elf_locate_base ();
918 if (info
->debug_base
== 0)
919 return 0; /* failed somehow... */
921 /* First link map member should be the executable. */
922 lm
= solib_svr4_r_map (info
->debug_base
);
924 return 0; /* failed somehow... */
926 /* Read address of name from target memory to GDB. */
927 read_memory (lm
+ lmo
->l_name_offset
, l_name_buf
.data (), l_name_size
);
929 /* Convert the address to host format. */
930 l_name
= extract_typed_address (l_name_buf
.data (), ptr_type
);
933 return 0; /* No filename. */
935 /* Now fetch the filename from target memory. */
936 gdb::unique_xmalloc_ptr
<char> filename
937 = target_read_string (l_name
, SO_NAME_MAX_PATH_SIZE
- 1);
939 if (filename
== nullptr)
941 warning (_("failed to read exec filename from attached file"));
945 /* Have a pathname: read the symbol file. */
946 symbol_file_add_main (filename
.get (), add_flags
);
951 /* Data exchange structure for the XML parser as returned by
952 svr4_current_sos_via_xfer_libraries. */
954 struct svr4_library_list
956 /* The tail pointer of the current namespace. This is internal to XML
960 /* Inferior address of struct link_map used for the main executable. It is
961 NULL if not known. */
964 /* List of objects loaded into the inferior per namespace. This does
965 not include any default sos.
967 See comment on struct svr4_info.solib_lists. */
968 std::map
<CORE_ADDR
, so_list
*> solib_lists
;
971 /* This module's 'free_objfile' observer. */
974 svr4_free_objfile_observer (struct objfile
*objfile
)
976 probes_table_remove_objfile_probes (objfile
);
979 /* Implementation for target_so_ops.free_so. */
982 svr4_free_so (struct so_list
*so
)
984 lm_info_svr4
*li
= (lm_info_svr4
*) so
->lm_info
;
989 /* Implement target_so_ops.clear_so. */
992 svr4_clear_so (struct so_list
*so
)
994 lm_info_svr4
*li
= (lm_info_svr4
*) so
->lm_info
;
1000 /* Free so_list built so far. */
1003 svr4_free_library_list (so_list
*list
)
1005 while (list
!= NULL
)
1007 struct so_list
*next
= list
->next
;
1014 /* Copy library list. */
1016 static struct so_list
*
1017 svr4_copy_library_list (struct so_list
*src
)
1019 struct so_list
*dst
= NULL
;
1020 struct so_list
**link
= &dst
;
1024 struct so_list
*newobj
;
1026 newobj
= XNEW (struct so_list
);
1027 memcpy (newobj
, src
, sizeof (struct so_list
));
1029 lm_info_svr4
*src_li
= (lm_info_svr4
*) src
->lm_info
;
1030 newobj
->lm_info
= new lm_info_svr4 (*src_li
);
1032 newobj
->next
= NULL
;
1034 link
= &newobj
->next
;
1042 #ifdef HAVE_LIBEXPAT
1044 #include "xml-support.h"
1046 /* Handle the start of a <library> element. Note: new elements are added
1047 at the tail of the list, keeping the list in order. */
1050 library_list_start_library (struct gdb_xml_parser
*parser
,
1051 const struct gdb_xml_element
*element
,
1053 std::vector
<gdb_xml_value
> &attributes
)
1055 struct svr4_library_list
*list
= (struct svr4_library_list
*) user_data
;
1057 = (const char *) xml_find_attribute (attributes
, "name")->value
.get ();
1059 = (ULONGEST
*) xml_find_attribute (attributes
, "lm")->value
.get ();
1061 = (ULONGEST
*) xml_find_attribute (attributes
, "l_addr")->value
.get ();
1063 = (ULONGEST
*) xml_find_attribute (attributes
, "l_ld")->value
.get ();
1064 struct so_list
*new_elem
;
1066 new_elem
= XCNEW (struct so_list
);
1067 lm_info_svr4
*li
= new lm_info_svr4
;
1068 new_elem
->lm_info
= li
;
1070 li
->l_addr_inferior
= *l_addrp
;
1073 strncpy (new_elem
->so_name
, name
, sizeof (new_elem
->so_name
) - 1);
1074 new_elem
->so_name
[sizeof (new_elem
->so_name
) - 1] = 0;
1075 strcpy (new_elem
->so_original_name
, new_elem
->so_name
);
1077 /* Older versions did not supply lmid. Put the element into the flat
1078 list of the special namespace zero in that case. */
1079 gdb_xml_value
*at_lmid
= xml_find_attribute (attributes
, "lmid");
1080 if (at_lmid
== nullptr)
1082 *list
->tailp
= new_elem
;
1083 list
->tailp
= &new_elem
->next
;
1087 ULONGEST lmid
= *(ULONGEST
*) at_lmid
->value
.get ();
1089 /* Ensure that the element is actually initialized. */
1090 if (list
->solib_lists
.find (lmid
) == list
->solib_lists
.end ())
1091 list
->solib_lists
[lmid
] = nullptr;
1093 so_list
**psolist
= &list
->solib_lists
[lmid
];
1094 so_list
**pnext
= psolist
;
1096 /* Walk to the end of the list if we have one. */
1097 so_list
*solist
= *psolist
;
1098 if (solist
!= nullptr)
1100 for (; solist
->next
!= nullptr; solist
= solist
->next
)
1103 pnext
= &solist
->next
;
1110 /* Handle the start of a <library-list-svr4> element. */
1113 svr4_library_list_start_list (struct gdb_xml_parser
*parser
,
1114 const struct gdb_xml_element
*element
,
1116 std::vector
<gdb_xml_value
> &attributes
)
1118 struct svr4_library_list
*list
= (struct svr4_library_list
*) user_data
;
1120 = (const char *) xml_find_attribute (attributes
, "version")->value
.get ();
1121 struct gdb_xml_value
*main_lm
= xml_find_attribute (attributes
, "main-lm");
1123 if (strcmp (version
, "1.0") != 0)
1124 gdb_xml_error (parser
,
1125 _("SVR4 Library list has unsupported version \"%s\""),
1129 list
->main_lm
= *(ULONGEST
*) main_lm
->value
.get ();
1131 /* Older gdbserver do not support namespaces. We use the special
1132 namespace zero for a linear list of libraries. */
1133 so_list
**solist
= &list
->solib_lists
[0];
1135 list
->tailp
= solist
;
1138 /* The allowed elements and attributes for an XML library list.
1139 The root element is a <library-list>. */
1141 static const struct gdb_xml_attribute svr4_library_attributes
[] =
1143 { "name", GDB_XML_AF_NONE
, NULL
, NULL
},
1144 { "lm", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
1145 { "l_addr", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
1146 { "l_ld", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
1147 { "lmid", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
1148 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
1151 static const struct gdb_xml_element svr4_library_list_children
[] =
1154 "library", svr4_library_attributes
, NULL
,
1155 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
1156 library_list_start_library
, NULL
1158 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
1161 static const struct gdb_xml_attribute svr4_library_list_attributes
[] =
1163 { "version", GDB_XML_AF_NONE
, NULL
, NULL
},
1164 { "main-lm", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
1165 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
1168 static const struct gdb_xml_element svr4_library_list_elements
[] =
1170 { "library-list-svr4", svr4_library_list_attributes
, svr4_library_list_children
,
1171 GDB_XML_EF_NONE
, svr4_library_list_start_list
, NULL
},
1172 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
1175 /* Parse qXfer:libraries:read packet into *SO_LIST_RETURN. Return 1 if
1177 Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
1178 case. Return 1 if *SO_LIST_RETURN contains the library list, it may be
1179 empty, caller is responsible for freeing all its entries. */
1182 svr4_parse_libraries (const char *document
, struct svr4_library_list
*list
)
1184 auto cleanup
= make_scope_exit ([list
] ()
1186 for (const std::pair
<CORE_ADDR
, so_list
*> tuple
1187 : list
->solib_lists
)
1188 svr4_free_library_list (tuple
.second
);
1191 list
->tailp
= nullptr;
1193 list
->solib_lists
.clear ();
1194 if (gdb_xml_parse_quick (_("target library list"), "library-list-svr4.dtd",
1195 svr4_library_list_elements
, document
, list
) == 0)
1197 /* Parsed successfully, keep the result. */
1205 /* Attempt to get so_list from target via qXfer:libraries-svr4:read packet.
1207 Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
1208 case. Return 1 if *SO_LIST_RETURN contains the library list, it may be
1209 empty, caller is responsible for freeing all its entries.
1211 Note that ANNEX must be NULL if the remote does not explicitly allow
1212 qXfer:libraries-svr4:read packets with non-empty annexes. Support for
1213 this can be checked using target_augmented_libraries_svr4_read (). */
1216 svr4_current_sos_via_xfer_libraries (struct svr4_library_list
*list
,
1219 gdb_assert (annex
== NULL
|| target_augmented_libraries_svr4_read ());
1221 /* Fetch the list of shared libraries. */
1222 gdb::optional
<gdb::char_vector
> svr4_library_document
1223 = target_read_stralloc (current_inferior ()->top_target (),
1224 TARGET_OBJECT_LIBRARIES_SVR4
,
1226 if (!svr4_library_document
)
1229 return svr4_parse_libraries (svr4_library_document
->data (), list
);
1235 svr4_current_sos_via_xfer_libraries (struct svr4_library_list
*list
,
1243 /* If no shared library information is available from the dynamic
1244 linker, build a fallback list from other sources. */
1246 static struct so_list
*
1247 svr4_default_sos (svr4_info
*info
)
1249 struct so_list
*newobj
;
1251 if (!info
->debug_loader_offset_p
)
1254 newobj
= XCNEW (struct so_list
);
1255 lm_info_svr4
*li
= new lm_info_svr4
;
1256 newobj
->lm_info
= li
;
1258 /* Nothing will ever check the other fields if we set l_addr_p. */
1259 li
->l_addr
= li
->l_addr_inferior
= info
->debug_loader_offset
;
1262 strncpy (newobj
->so_name
, info
->debug_loader_name
, SO_NAME_MAX_PATH_SIZE
- 1);
1263 newobj
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
1264 strcpy (newobj
->so_original_name
, newobj
->so_name
);
1269 /* Read the whole inferior libraries chain starting at address LM.
1270 Expect the first entry in the chain's previous entry to be PREV_LM.
1271 Add the entries to the tail referenced by LINK_PTR_PTR. Ignore the
1272 first entry if IGNORE_FIRST and set global MAIN_LM_ADDR according
1273 to it. Returns nonzero upon success. If zero is returned the
1274 entries stored to LINK_PTR_PTR are still valid although they may
1275 represent only part of the inferior library list. */
1278 svr4_read_so_list (svr4_info
*info
, CORE_ADDR lm
, CORE_ADDR prev_lm
,
1279 struct so_list
***link_ptr_ptr
, int ignore_first
)
1281 CORE_ADDR first_l_name
= 0;
1284 for (; lm
!= 0; prev_lm
= lm
, lm
= next_lm
)
1286 so_list_up
newobj (XCNEW (struct so_list
));
1288 lm_info_svr4
*li
= lm_info_read (lm
).release ();
1289 newobj
->lm_info
= li
;
1293 next_lm
= li
->l_next
;
1295 if (li
->l_prev
!= prev_lm
)
1297 warning (_("Corrupted shared library list: %s != %s"),
1298 paddress (current_inferior ()->arch (), prev_lm
),
1299 paddress (current_inferior ()->arch (), li
->l_prev
));
1303 /* For SVR4 versions, the first entry in the link map is for the
1304 inferior executable, so we must ignore it. For some versions of
1305 SVR4, it has no name. For others (Solaris 2.3 for example), it
1306 does have a name, so we can no longer use a missing name to
1307 decide when to ignore it. */
1308 if (ignore_first
&& li
->l_prev
== 0)
1310 first_l_name
= li
->l_name
;
1311 info
->main_lm_addr
= li
->lm_addr
;
1315 /* Extract this shared object's name. */
1316 gdb::unique_xmalloc_ptr
<char> buffer
1317 = target_read_string (li
->l_name
, SO_NAME_MAX_PATH_SIZE
- 1);
1318 if (buffer
== nullptr)
1320 /* If this entry's l_name address matches that of the
1321 inferior executable, then this is not a normal shared
1322 object, but (most likely) a vDSO. In this case, silently
1323 skip it; otherwise emit a warning. */
1324 if (first_l_name
== 0 || li
->l_name
!= first_l_name
)
1325 warning (_("Can't read pathname for load map."));
1329 strncpy (newobj
->so_name
, buffer
.get (), SO_NAME_MAX_PATH_SIZE
- 1);
1330 newobj
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
1331 strcpy (newobj
->so_original_name
, newobj
->so_name
);
1333 /* If this entry has no name, or its name matches the name
1334 for the main executable, don't include it in the list. */
1335 if (! newobj
->so_name
[0] || match_main (newobj
->so_name
))
1339 /* Don't free it now. */
1340 **link_ptr_ptr
= newobj
.release ();
1341 *link_ptr_ptr
= &(**link_ptr_ptr
)->next
;
1347 /* Read the full list of currently loaded shared objects directly
1348 from the inferior, without referring to any libraries read and
1349 stored by the probes interface. Handle special cases relating
1350 to the first elements of the list in default namespace. */
1353 svr4_current_sos_direct (struct svr4_info
*info
)
1357 struct svr4_library_list library_list
;
1359 /* Remove any old libraries. We're going to read them back in again. */
1360 free_solib_lists (info
);
1362 /* Fall back to manual examination of the target if the packet is not
1363 supported or gdbserver failed to find DT_DEBUG. gdb.server/solib-list.exp
1364 tests a case where gdbserver cannot find the shared libraries list while
1365 GDB itself is able to find it via SYMFILE_OBJFILE.
1367 Unfortunately statically linked inferiors will also fall back through this
1368 suboptimal code path. */
1370 info
->using_xfer
= svr4_current_sos_via_xfer_libraries (&library_list
,
1372 if (info
->using_xfer
)
1374 if (library_list
.main_lm
)
1375 info
->main_lm_addr
= library_list
.main_lm
;
1377 /* Remove an empty special zero namespace so we know that when there
1378 is one, it is actually used, and we have a flat list without
1379 namespace information. */
1380 if ((library_list
.solib_lists
.find (0)
1381 != library_list
.solib_lists
.end ())
1382 && (library_list
.solib_lists
[0] == nullptr))
1383 library_list
.solib_lists
.erase (0);
1385 /* Replace the (empty) solib_lists in INFO with the one generated
1386 from the target. We don't want to copy it on assignment and then
1387 delete the original afterwards, so let's just swap the
1389 std::swap (info
->solib_lists
, library_list
.solib_lists
);
1393 /* If we can't find the dynamic linker's base structure, this
1394 must not be a dynamically linked executable. Hmm. */
1395 info
->debug_base
= elf_locate_base ();
1396 if (info
->debug_base
== 0)
1399 /* Assume that everything is a library if the dynamic loader was loaded
1400 late by a static executable. */
1401 if (current_program_space
->exec_bfd ()
1402 && bfd_get_section_by_name (current_program_space
->exec_bfd (),
1403 ".dynamic") == NULL
)
1404 ignore_first
= false;
1406 ignore_first
= true;
1408 auto cleanup
= make_scope_exit ([info
] ()
1410 free_solib_lists (info
);
1413 /* Collect the sos in each namespace. */
1414 CORE_ADDR debug_base
= info
->debug_base
;
1415 for (; debug_base
!= 0;
1416 ignore_first
= false, debug_base
= solib_svr4_r_next (debug_base
))
1418 /* Walk the inferior's link map list, and build our so_list list. */
1419 lm
= solib_svr4_r_map (debug_base
);
1422 so_list
**sos
= &info
->solib_lists
[debug_base
];
1425 svr4_read_so_list (info
, lm
, 0, &sos
, ignore_first
);
1429 /* On Solaris, the dynamic linker is not in the normal list of
1430 shared objects, so make sure we pick it up too. Having
1431 symbol information for the dynamic linker is quite crucial
1432 for skipping dynamic linker resolver code.
1434 Note that we interpret the ldsomap load map address as 'virtual'
1435 r_debug object. If we added it to the default namespace (as it was),
1436 we would probably run into inconsistencies with the load map's
1437 prev/next links (I wonder if we did). */
1438 debug_base
= solib_svr4_r_ldsomap (info
);
1439 if (debug_base
!= 0)
1441 /* Add the dynamic linker's namespace unless we already did. */
1442 if (info
->solib_lists
.find (debug_base
) == info
->solib_lists
.end ())
1444 so_list
**sos
= &info
->solib_lists
[debug_base
];
1446 svr4_read_so_list (info
, debug_base
, 0, &sos
, 0);
1453 /* Collect sos read and stored by the probes interface. */
1456 svr4_collect_probes_sos (svr4_info
*info
)
1458 so_list
*sos
= nullptr;
1459 so_list
**pnext
= &sos
;
1461 for (const std::pair
<CORE_ADDR
, so_list
*> tuple
1462 : info
->solib_lists
)
1464 so_list
*solist
= tuple
.second
;
1466 /* Allow the linker to report empty namespaces. */
1467 if (solist
== nullptr)
1470 *pnext
= svr4_copy_library_list (solist
);
1472 /* Update PNEXT to point to the next member of the last element. */
1473 gdb_assert (*pnext
!= nullptr);
1476 so_list
*next
= *pnext
;
1477 if (next
== nullptr)
1480 pnext
= &next
->next
;
1487 /* Implement the main part of the "current_sos" target_so_ops
1490 static struct so_list
*
1491 svr4_current_sos_1 (svr4_info
*info
)
1493 so_list
*sos
= nullptr;
1495 /* If we're using the probes interface, we can use the cache as it will
1496 be maintained by probe update/reload actions. */
1497 if (info
->probes_table
!= nullptr)
1498 sos
= svr4_collect_probes_sos (info
);
1500 /* If we're not using the probes interface or if we didn't cache
1501 anything, read the sos to fill the cache, then collect them from the
1505 svr4_current_sos_direct (info
);
1507 sos
= svr4_collect_probes_sos (info
);
1509 sos
= svr4_default_sos (info
);
1515 /* Implement the "current_sos" target_so_ops method. */
1517 static struct so_list
*
1518 svr4_current_sos (void)
1520 svr4_info
*info
= get_svr4_info (current_program_space
);
1521 struct so_list
*so_head
= svr4_current_sos_1 (info
);
1522 struct mem_range vsyscall_range
;
1524 /* Filter out the vDSO module, if present. Its symbol file would
1525 not be found on disk. The vDSO/vsyscall's OBJFILE is instead
1526 managed by symfile-mem.c:add_vsyscall_page. */
1527 if (gdbarch_vsyscall_range (current_inferior ()->arch (), &vsyscall_range
)
1528 && vsyscall_range
.length
!= 0)
1530 struct so_list
**sop
;
1533 while (*sop
!= NULL
)
1535 struct so_list
*so
= *sop
;
1537 /* We can't simply match the vDSO by starting address alone,
1538 because lm_info->l_addr_inferior (and also l_addr) do not
1539 necessarily represent the real starting address of the
1540 ELF if the vDSO's ELF itself is "prelinked". The l_ld
1541 field (the ".dynamic" section of the shared object)
1542 always points at the absolute/resolved address though.
1543 So check whether that address is inside the vDSO's
1546 E.g., on Linux 3.16 (x86_64) the vDSO is a regular
1547 0-based ELF, and we see:
1550 33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffb000
1551 (gdb) p/x *_r_debug.r_map.l_next
1552 $1 = {l_addr = 0x7ffff7ffb000, ..., l_ld = 0x7ffff7ffb318, ...}
1554 And on Linux 2.6.32 (x86_64) we see:
1557 33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffe000
1558 (gdb) p/x *_r_debug.r_map.l_next
1559 $5 = {l_addr = 0x7ffff88fe000, ..., l_ld = 0x7ffff7ffe580, ... }
1561 Dumping that vDSO shows:
1563 (gdb) info proc mappings
1564 0x7ffff7ffe000 0x7ffff7fff000 0x1000 0 [vdso]
1565 (gdb) dump memory vdso.bin 0x7ffff7ffe000 0x7ffff7fff000
1566 # readelf -Wa vdso.bin
1568 Entry point address: 0xffffffffff700700
1571 [Nr] Name Type Address Off Size
1572 [ 0] NULL 0000000000000000 000000 000000
1573 [ 1] .hash HASH ffffffffff700120 000120 000038
1574 [ 2] .dynsym DYNSYM ffffffffff700158 000158 0000d8
1576 [ 9] .dynamic DYNAMIC ffffffffff700580 000580 0000f0
1579 lm_info_svr4
*li
= (lm_info_svr4
*) so
->lm_info
;
1581 if (address_in_mem_range (li
->l_ld
, &vsyscall_range
))
1595 /* Get the address of the link_map for a given OBJFILE. */
1598 svr4_fetch_objfile_link_map (struct objfile
*objfile
)
1600 struct svr4_info
*info
= get_svr4_info (objfile
->pspace
);
1602 /* Cause svr4_current_sos() to be run if it hasn't been already. */
1603 if (info
->main_lm_addr
== 0)
1604 solib_add (NULL
, 0, auto_solib_add
);
1606 /* svr4_current_sos() will set main_lm_addr for the main executable. */
1607 if (objfile
== current_program_space
->symfile_object_file
)
1608 return info
->main_lm_addr
;
1610 /* The other link map addresses may be found by examining the list
1611 of shared libraries. */
1612 for (struct so_list
*so
: current_program_space
->solibs ())
1613 if (so
->objfile
== objfile
)
1615 lm_info_svr4
*li
= (lm_info_svr4
*) so
->lm_info
;
1624 /* On some systems, the only way to recognize the link map entry for
1625 the main executable file is by looking at its name. Return
1626 non-zero iff SONAME matches one of the known main executable names. */
1629 match_main (const char *soname
)
1631 const char * const *mainp
;
1633 for (mainp
= main_name_list
; *mainp
!= NULL
; mainp
++)
1635 if (strcmp (soname
, *mainp
) == 0)
1642 /* Return 1 if PC lies in the dynamic symbol resolution code of the
1643 SVR4 run time loader. */
1646 svr4_in_dynsym_resolve_code (CORE_ADDR pc
)
1648 struct svr4_info
*info
= get_svr4_info (current_program_space
);
1650 return ((pc
>= info
->interp_text_sect_low
1651 && pc
< info
->interp_text_sect_high
)
1652 || (pc
>= info
->interp_plt_sect_low
1653 && pc
< info
->interp_plt_sect_high
)
1654 || in_plt_section (pc
)
1655 || in_gnu_ifunc_stub (pc
));
1658 /* Given an executable's ABFD and target, compute the entry-point
1662 exec_entry_point (struct bfd
*abfd
, struct target_ops
*targ
)
1666 /* KevinB wrote ... for most targets, the address returned by
1667 bfd_get_start_address() is the entry point for the start
1668 function. But, for some targets, bfd_get_start_address() returns
1669 the address of a function descriptor from which the entry point
1670 address may be extracted. This address is extracted by
1671 gdbarch_convert_from_func_ptr_addr(). The method
1672 gdbarch_convert_from_func_ptr_addr() is the merely the identify
1673 function for targets which don't use function descriptors. */
1674 addr
= gdbarch_convert_from_func_ptr_addr (current_inferior ()->arch (),
1675 bfd_get_start_address (abfd
),
1677 return gdbarch_addr_bits_remove (current_inferior ()->arch (), addr
);
1680 /* A probe and its associated action. */
1682 struct probe_and_action
1687 /* The relocated address of the probe. */
1691 enum probe_action action
;
1693 /* The objfile where this probe was found. */
1694 struct objfile
*objfile
;
1697 /* Returns a hash code for the probe_and_action referenced by p. */
1700 hash_probe_and_action (const void *p
)
1702 const struct probe_and_action
*pa
= (const struct probe_and_action
*) p
;
1704 return (hashval_t
) pa
->address
;
1707 /* Returns non-zero if the probe_and_actions referenced by p1 and p2
1711 equal_probe_and_action (const void *p1
, const void *p2
)
1713 const struct probe_and_action
*pa1
= (const struct probe_and_action
*) p1
;
1714 const struct probe_and_action
*pa2
= (const struct probe_and_action
*) p2
;
1716 return pa1
->address
== pa2
->address
;
1719 /* Traversal function for probes_table_remove_objfile_probes. */
1722 probes_table_htab_remove_objfile_probes (void **slot
, void *info
)
1724 probe_and_action
*pa
= (probe_and_action
*) *slot
;
1725 struct objfile
*objfile
= (struct objfile
*) info
;
1727 if (pa
->objfile
== objfile
)
1728 htab_clear_slot (get_svr4_info (objfile
->pspace
)->probes_table
.get (),
1734 /* Remove all probes that belong to OBJFILE from the probes table. */
1737 probes_table_remove_objfile_probes (struct objfile
*objfile
)
1739 svr4_info
*info
= get_svr4_info (objfile
->pspace
);
1740 if (info
->probes_table
!= nullptr)
1741 htab_traverse_noresize (info
->probes_table
.get (),
1742 probes_table_htab_remove_objfile_probes
, objfile
);
1745 /* Register a solib event probe and its associated action in the
1749 register_solib_event_probe (svr4_info
*info
, struct objfile
*objfile
,
1750 probe
*prob
, CORE_ADDR address
,
1751 enum probe_action action
)
1753 struct probe_and_action lookup
, *pa
;
1756 /* Create the probes table, if necessary. */
1757 if (info
->probes_table
== NULL
)
1758 info
->probes_table
.reset (htab_create_alloc (1, hash_probe_and_action
,
1759 equal_probe_and_action
,
1760 xfree
, xcalloc
, xfree
));
1762 lookup
.address
= address
;
1763 slot
= htab_find_slot (info
->probes_table
.get (), &lookup
, INSERT
);
1764 gdb_assert (*slot
== HTAB_EMPTY_ENTRY
);
1766 pa
= XCNEW (struct probe_and_action
);
1768 pa
->address
= address
;
1769 pa
->action
= action
;
1770 pa
->objfile
= objfile
;
1775 /* Get the solib event probe at the specified location, and the
1776 action associated with it. Returns NULL if no solib event probe
1779 static struct probe_and_action
*
1780 solib_event_probe_at (struct svr4_info
*info
, CORE_ADDR address
)
1782 struct probe_and_action lookup
;
1785 lookup
.address
= address
;
1786 slot
= htab_find_slot (info
->probes_table
.get (), &lookup
, NO_INSERT
);
1791 return (struct probe_and_action
*) *slot
;
1794 /* Decide what action to take when the specified solib event probe is
1797 static enum probe_action
1798 solib_event_probe_action (struct probe_and_action
*pa
)
1800 enum probe_action action
;
1801 unsigned probe_argc
= 0;
1802 frame_info_ptr frame
= get_current_frame ();
1804 action
= pa
->action
;
1805 if (action
== DO_NOTHING
|| action
== PROBES_INTERFACE_FAILED
)
1808 gdb_assert (action
== FULL_RELOAD
|| action
== UPDATE_OR_RELOAD
);
1810 /* Check that an appropriate number of arguments has been supplied.
1812 arg0: Lmid_t lmid (mandatory)
1813 arg1: struct r_debug *debug_base (mandatory)
1814 arg2: struct link_map *new (optional, for incremental updates) */
1817 probe_argc
= pa
->prob
->get_argument_count (get_frame_arch (frame
));
1819 catch (const gdb_exception_error
&ex
)
1821 exception_print (gdb_stderr
, ex
);
1825 /* If get_argument_count throws an exception, probe_argc will be set
1826 to zero. However, if pa->prob does not have arguments, then
1827 get_argument_count will succeed but probe_argc will also be zero.
1828 Both cases happen because of different things, but they are
1829 treated equally here: action will be set to
1830 PROBES_INTERFACE_FAILED. */
1831 if (probe_argc
== 2)
1832 action
= FULL_RELOAD
;
1833 else if (probe_argc
< 2)
1834 action
= PROBES_INTERFACE_FAILED
;
1839 /* Populate the shared object list by reading the entire list of
1840 shared objects from the inferior. Handle special cases relating
1841 to the first elements of the list. Returns nonzero on success. */
1844 solist_update_full (struct svr4_info
*info
)
1846 svr4_current_sos_direct (info
);
1851 /* Update the shared object list starting from the link-map entry
1852 passed by the linker in the probe's third argument. Returns
1853 nonzero if the list was successfully updated, or zero to indicate
1857 solist_update_incremental (svr4_info
*info
, CORE_ADDR debug_base
,
1860 /* Fall back to a full update if we are using a remote target
1861 that does not support incremental transfers. */
1862 if (info
->using_xfer
&& !target_augmented_libraries_svr4_read ())
1865 /* Fall back to a full update if we used the special namespace zero. We
1866 wouldn't be able to find the last item in the DEBUG_BASE namespace
1867 and hence get the prev link wrong. */
1868 if (info
->solib_lists
.find (0) != info
->solib_lists
.end ())
1871 /* Ensure that the element is actually initialized. */
1872 if (info
->solib_lists
.find (debug_base
) == info
->solib_lists
.end ())
1873 info
->solib_lists
[debug_base
] = nullptr;
1875 so_list
**psolist
= &info
->solib_lists
[debug_base
];
1876 so_list
**pnext
= nullptr;
1877 so_list
*solist
= *psolist
;
1880 if (solist
== nullptr)
1882 /* svr4_current_sos_direct contains logic to handle a number of
1883 special cases relating to the first elements of the list in
1884 default namespace. To avoid duplicating this logic we defer to
1885 solist_update_full in this case. */
1886 if (svr4_is_default_namespace (info
, debug_base
))
1894 /* Walk to the end of the list. */
1895 for (; solist
->next
!= nullptr; solist
= solist
->next
)
1898 lm_info_svr4
*li
= (lm_info_svr4
*) solist
->lm_info
;
1899 prev_lm
= li
->lm_addr
;
1900 pnext
= &solist
->next
;
1903 /* Read the new objects. */
1904 if (info
->using_xfer
)
1906 struct svr4_library_list library_list
;
1909 /* Unknown key=value pairs are ignored by the gdbstub. */
1910 xsnprintf (annex
, sizeof (annex
), "lmid=%s;start=%s;prev=%s",
1911 phex_nz (debug_base
, sizeof (debug_base
)),
1912 phex_nz (lm
, sizeof (lm
)),
1913 phex_nz (prev_lm
, sizeof (prev_lm
)));
1914 if (!svr4_current_sos_via_xfer_libraries (&library_list
, annex
))
1917 /* Get the so list from the target. We replace the list in the
1918 target response so we can easily check that the response only
1919 covers one namespace.
1921 We expect gdbserver to provide updates for the namespace that
1922 contains LM, which would be this namespace... */
1923 so_list
*sos
= nullptr;
1924 if (library_list
.solib_lists
.find (debug_base
)
1925 != library_list
.solib_lists
.end ())
1926 std::swap (sos
, library_list
.solib_lists
[debug_base
]);
1929 /* ...or for the special zero namespace for earlier versions... */
1930 if (library_list
.solib_lists
.find (0)
1931 != library_list
.solib_lists
.end ())
1932 std::swap (sos
, library_list
.solib_lists
[0]);
1935 /* ...but nothing else. */
1936 for (const std::pair
<CORE_ADDR
, so_list
*> tuple
1937 : library_list
.solib_lists
)
1938 gdb_assert (tuple
.second
== nullptr);
1944 /* IGNORE_FIRST may safely be set to zero here because the
1945 above check and deferral to solist_update_full ensures
1946 that this call to svr4_read_so_list will never see the
1948 if (!svr4_read_so_list (info
, lm
, prev_lm
, &pnext
, 0))
1955 /* Disable the probes-based linker interface and revert to the
1956 original interface. We don't reset the breakpoints as the
1957 ones set up for the probes-based interface are adequate. */
1960 disable_probes_interface (svr4_info
*info
)
1962 warning (_("Probes-based dynamic linker interface failed.\n"
1963 "Reverting to original interface."));
1965 free_probes_table (info
);
1966 free_solib_lists (info
);
1969 /* Update the solib list as appropriate when using the
1970 probes-based linker interface. Do nothing if using the
1971 standard interface. */
1974 svr4_handle_solib_event (void)
1976 struct svr4_info
*info
= get_svr4_info (current_program_space
);
1977 struct probe_and_action
*pa
;
1978 enum probe_action action
;
1979 struct value
*val
= NULL
;
1980 CORE_ADDR pc
, debug_base
, lm
= 0;
1981 frame_info_ptr frame
= get_current_frame ();
1983 /* Do nothing if not using the probes interface. */
1984 if (info
->probes_table
== NULL
)
1987 pc
= regcache_read_pc (get_current_regcache ());
1988 pa
= solib_event_probe_at (info
, pc
);
1991 /* When some solib ops sits above us, it can respond to a solib event
1992 by calling in here. This is done assuming that if the current event
1993 is not an SVR4 solib event, calling here should be a no-op. */
1997 /* If anything goes wrong we revert to the original linker
1999 auto cleanup
= make_scope_exit ([info
] ()
2001 disable_probes_interface (info
);
2004 action
= solib_event_probe_action (pa
);
2005 if (action
== PROBES_INTERFACE_FAILED
)
2008 if (action
== DO_NOTHING
)
2014 /* evaluate_argument looks up symbols in the dynamic linker
2015 using find_pc_section. find_pc_section is accelerated by a cache
2016 called the section map. The section map is invalidated every
2017 time a shared library is loaded or unloaded, and if the inferior
2018 is generating a lot of shared library events then the section map
2019 will be updated every time svr4_handle_solib_event is called.
2020 We called find_pc_section in svr4_create_solib_event_breakpoints,
2021 so we can guarantee that the dynamic linker's sections are in the
2022 section map. We can therefore inhibit section map updates across
2023 these calls to evaluate_argument and save a lot of time. */
2025 scoped_restore inhibit_updates
2026 = inhibit_section_map_updates (current_program_space
);
2030 val
= pa
->prob
->evaluate_argument (1, frame
);
2032 catch (const gdb_exception_error
&ex
)
2034 exception_print (gdb_stderr
, ex
);
2041 debug_base
= value_as_address (val
);
2042 if (debug_base
== 0)
2045 /* If the global _r_debug object moved, we need to reload everything
2046 since we cannot identify namespaces (by the location of their
2047 r_debug_ext object) anymore. */
2048 CORE_ADDR global_debug_base
= elf_locate_base ();
2049 if (global_debug_base
!= info
->debug_base
)
2051 info
->debug_base
= global_debug_base
;
2052 action
= FULL_RELOAD
;
2055 if (info
->debug_base
== 0)
2057 /* It's possible for the reloc_complete probe to be triggered before
2058 the linker has set the DT_DEBUG pointer (for example, when the
2059 linker has finished relocating an LD_AUDIT library or its
2060 dependencies). Since we can't yet handle libraries from other link
2061 namespaces, we don't lose anything by ignoring them here. */
2062 struct value
*link_map_id_val
;
2065 link_map_id_val
= pa
->prob
->evaluate_argument (0, frame
);
2067 catch (const gdb_exception_error
)
2069 link_map_id_val
= NULL
;
2071 /* glibc and illumos' libc both define LM_ID_BASE as zero. */
2072 if (link_map_id_val
!= NULL
&& value_as_long (link_map_id_val
) != 0)
2073 action
= DO_NOTHING
;
2078 if (action
== UPDATE_OR_RELOAD
)
2082 val
= pa
->prob
->evaluate_argument (2, frame
);
2084 catch (const gdb_exception_error
&ex
)
2086 exception_print (gdb_stderr
, ex
);
2091 lm
= value_as_address (val
);
2094 action
= FULL_RELOAD
;
2097 /* Resume section map updates. Closing the scope is
2101 if (action
== UPDATE_OR_RELOAD
)
2103 if (!solist_update_incremental (info
, debug_base
, lm
))
2104 action
= FULL_RELOAD
;
2107 if (action
== FULL_RELOAD
)
2109 if (!solist_update_full (info
))
2116 /* Helper function for svr4_update_solib_event_breakpoints. */
2119 svr4_update_solib_event_breakpoint (struct breakpoint
*b
)
2121 if (b
->type
!= bp_shlib_event
)
2123 /* Continue iterating. */
2127 for (bp_location
&loc
: b
->locations ())
2129 struct svr4_info
*info
;
2130 struct probe_and_action
*pa
;
2132 info
= solib_svr4_pspace_data
.get (loc
.pspace
);
2133 if (info
== NULL
|| info
->probes_table
== NULL
)
2136 pa
= solib_event_probe_at (info
, loc
.address
);
2140 if (pa
->action
== DO_NOTHING
)
2142 if (b
->enable_state
== bp_disabled
&& stop_on_solib_events
)
2143 enable_breakpoint (b
);
2144 else if (b
->enable_state
== bp_enabled
&& !stop_on_solib_events
)
2145 disable_breakpoint (b
);
2151 /* Continue iterating. */
2155 /* Enable or disable optional solib event breakpoints as appropriate.
2156 Called whenever stop_on_solib_events is changed. */
2159 svr4_update_solib_event_breakpoints (void)
2161 for (breakpoint
&bp
: all_breakpoints_safe ())
2162 svr4_update_solib_event_breakpoint (&bp
);
2165 /* Create and register solib event breakpoints. PROBES is an array
2166 of NUM_PROBES elements, each of which is vector of probes. A
2167 solib event breakpoint will be created and registered for each
2171 svr4_create_probe_breakpoints (svr4_info
*info
, struct gdbarch
*gdbarch
,
2172 const std::vector
<probe
*> *probes
,
2173 struct objfile
*objfile
)
2175 for (int i
= 0; i
< NUM_PROBES
; i
++)
2177 enum probe_action action
= probe_info
[i
].action
;
2179 for (probe
*p
: probes
[i
])
2181 CORE_ADDR address
= p
->get_relocated_address (objfile
);
2183 solib_debug_printf ("name=%s, addr=%s", probe_info
[i
].name
,
2184 paddress (gdbarch
, address
));
2186 create_solib_event_breakpoint (gdbarch
, address
);
2187 register_solib_event_probe (info
, objfile
, p
, address
, action
);
2191 svr4_update_solib_event_breakpoints ();
2194 /* Find all the glibc named probes. Only if all of the probes are found, then
2195 create them and return true. Otherwise return false. If WITH_PREFIX is set
2196 then add "rtld" to the front of the probe names. */
2198 svr4_find_and_create_probe_breakpoints (svr4_info
*info
,
2199 struct gdbarch
*gdbarch
,
2200 struct obj_section
*os
,
2203 SOLIB_SCOPED_DEBUG_START_END ("objfile=%s, with_prefix=%d",
2204 os
->objfile
->original_name
, with_prefix
);
2206 std::vector
<probe
*> probes
[NUM_PROBES
];
2208 for (int i
= 0; i
< NUM_PROBES
; i
++)
2210 const char *name
= probe_info
[i
].name
;
2213 /* Fedora 17 and Red Hat Enterprise Linux 6.2-6.4 shipped with an early
2214 version of the probes code in which the probes' names were prefixed
2215 with "rtld_" and the "map_failed" probe did not exist. The locations
2216 of the probes are otherwise the same, so we check for probes with
2217 prefixed names if probes with unprefixed names are not present. */
2220 xsnprintf (buf
, sizeof (buf
), "rtld_%s", name
);
2224 probes
[i
] = find_probes_in_objfile (os
->objfile
, "rtld", name
);
2225 solib_debug_printf ("probe=%s, num found=%zu", name
, probes
[i
].size ());
2227 /* Ensure at least one probe for the current name was found. */
2228 if (probes
[i
].empty ())
2230 /* The "map_failed" probe did not exist in early versions of the
2231 probes code in which the probes' names were prefixed with
2234 Additionally, the "map_failed" probe was accidentally removed
2235 from glibc 2.35 and 2.36, when changes in glibc meant the
2236 probe could no longer be reached, and the compiler optimized
2237 the probe away. In this case the probe name doesn't have the
2240 To handle this, and give GDB as much flexibility as possible,
2241 we make the rule that, if a probe isn't required for the
2242 correct operation of GDB (i.e. its action is DO_NOTHING), then
2243 we will still use the probes interface, even if that probe is
2246 The only (possible) downside of this is that, if the user has
2247 'set stop-on-solib-events on' in effect, then they might get
2248 fewer events using the probes interface than with the classic
2249 non-probes interface. */
2250 if (probe_info
[i
].action
== DO_NOTHING
)
2256 /* Ensure probe arguments can be evaluated. */
2257 for (probe
*p
: probes
[i
])
2259 if (!p
->can_evaluate_arguments ())
2261 /* This will fail if the probe is invalid. This has been seen on Arm
2262 due to references to symbols that have been resolved away. */
2265 p
->get_argument_count (gdbarch
);
2267 catch (const gdb_exception_error
&ex
)
2269 exception_print (gdb_stderr
, ex
);
2270 warning (_("Initializing probes-based dynamic linker interface "
2271 "failed.\nReverting to original interface."));
2277 /* All probes found. Now create them. */
2278 solib_debug_printf ("using probes interface");
2279 svr4_create_probe_breakpoints (info
, gdbarch
, probes
, os
->objfile
);
2283 /* Both the SunOS and the SVR4 dynamic linkers call a marker function
2284 before and after mapping and unmapping shared libraries. The sole
2285 purpose of this method is to allow debuggers to set a breakpoint so
2286 they can track these changes.
2288 Some versions of the glibc dynamic linker contain named probes
2289 to allow more fine grained stopping. Given the address of the
2290 original marker function, this function attempts to find these
2291 probes, and if found, sets breakpoints on those instead. If the
2292 probes aren't found, a single breakpoint is set on the original
2296 svr4_create_solib_event_breakpoints (svr4_info
*info
, struct gdbarch
*gdbarch
,
2299 struct obj_section
*os
= find_pc_section (address
);
2302 || (!svr4_find_and_create_probe_breakpoints (info
, gdbarch
, os
, false)
2303 && !svr4_find_and_create_probe_breakpoints (info
, gdbarch
, os
, true)))
2305 solib_debug_printf ("falling back to r_brk breakpoint: addr=%s",
2306 paddress (gdbarch
, address
));
2307 create_solib_event_breakpoint (gdbarch
, address
);
2311 /* Arrange for dynamic linker to hit breakpoint.
2313 Both the SunOS and the SVR4 dynamic linkers have, as part of their
2314 debugger interface, support for arranging for the inferior to hit
2315 a breakpoint after mapping in the shared libraries. This function
2316 enables that breakpoint.
2318 For SunOS, there is a special flag location (in_debugger) which we
2319 set to 1. When the dynamic linker sees this flag set, it will set
2320 a breakpoint at a location known only to itself, after saving the
2321 original contents of that place and the breakpoint address itself,
2322 in its own internal structures. When we resume the inferior, it
2323 will eventually take a SIGTRAP when it runs into the breakpoint.
2324 We handle this (in a different place) by restoring the contents of
2325 the breakpointed location (which is only known after it stops),
2326 chasing around to locate the shared libraries that have been
2327 loaded, then resuming.
2329 For SVR4, the debugger interface structure contains a member (r_brk)
2330 which is statically initialized at the time the shared library is
2331 built, to the offset of a function (_r_debug_state) which is guaran-
2332 teed to be called once before mapping in a library, and again when
2333 the mapping is complete. At the time we are examining this member,
2334 it contains only the unrelocated offset of the function, so we have
2335 to do our own relocation. Later, when the dynamic linker actually
2336 runs, it relocates r_brk to be the actual address of _r_debug_state().
2338 The debugger interface structure also contains an enumeration which
2339 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
2340 depending upon whether or not the library is being mapped or unmapped,
2341 and then set to RT_CONSISTENT after the library is mapped/unmapped. */
2344 enable_break (struct svr4_info
*info
, int from_tty
)
2346 struct bound_minimal_symbol msymbol
;
2347 const char * const *bkpt_namep
;
2348 asection
*interp_sect
;
2351 info
->interp_text_sect_low
= info
->interp_text_sect_high
= 0;
2352 info
->interp_plt_sect_low
= info
->interp_plt_sect_high
= 0;
2354 /* If we already have a shared library list in the target, and
2355 r_debug contains r_brk, set the breakpoint there - this should
2356 mean r_brk has already been relocated. Assume the dynamic linker
2357 is the object containing r_brk. */
2359 solib_add (NULL
, from_tty
, auto_solib_add
);
2361 if (info
->debug_base
&& solib_svr4_r_map (info
->debug_base
) != 0)
2362 sym_addr
= solib_svr4_r_brk (info
);
2366 struct obj_section
*os
;
2368 sym_addr
= gdbarch_addr_bits_remove
2369 (current_inferior ()->arch (),
2370 gdbarch_convert_from_func_ptr_addr
2371 (current_inferior ()->arch (), sym_addr
,
2372 current_inferior ()->top_target ()));
2374 /* On at least some versions of Solaris there's a dynamic relocation
2375 on _r_debug.r_brk and SYM_ADDR may not be relocated yet, e.g., if
2376 we get control before the dynamic linker has self-relocated.
2377 Check if SYM_ADDR is in a known section, if it is assume we can
2378 trust its value. This is just a heuristic though, it could go away
2379 or be replaced if it's getting in the way.
2381 On ARM we need to know whether the ISA of rtld_db_dlactivity (or
2382 however it's spelled in your particular system) is ARM or Thumb.
2383 That knowledge is encoded in the address, if it's Thumb the low bit
2384 is 1. However, we've stripped that info above and it's not clear
2385 what all the consequences are of passing a non-addr_bits_remove'd
2386 address to svr4_create_solib_event_breakpoints. The call to
2387 find_pc_section verifies we know about the address and have some
2388 hope of computing the right kind of breakpoint to use (via
2389 symbol info). It does mean that GDB needs to be pointed at a
2390 non-stripped version of the dynamic linker in order to obtain
2391 information it already knows about. Sigh. */
2393 os
= find_pc_section (sym_addr
);
2396 /* Record the relocated start and end address of the dynamic linker
2397 text and plt section for svr4_in_dynsym_resolve_code. */
2399 CORE_ADDR load_addr
;
2401 tmp_bfd
= os
->objfile
->obfd
.get ();
2402 load_addr
= os
->objfile
->text_section_offset ();
2404 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
2407 info
->interp_text_sect_low
2408 = bfd_section_vma (interp_sect
) + load_addr
;
2409 info
->interp_text_sect_high
2410 = info
->interp_text_sect_low
+ bfd_section_size (interp_sect
);
2412 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
2415 info
->interp_plt_sect_low
2416 = bfd_section_vma (interp_sect
) + load_addr
;
2417 info
->interp_plt_sect_high
2418 = info
->interp_plt_sect_low
+ bfd_section_size (interp_sect
);
2421 svr4_create_solib_event_breakpoints
2422 (info
, current_inferior ()->arch (), sym_addr
);
2427 /* Find the program interpreter; if not found, warn the user and drop
2428 into the old breakpoint at symbol code. */
2429 gdb::optional
<gdb::byte_vector
> interp_name_holder
2430 = find_program_interpreter ();
2431 if (interp_name_holder
)
2433 const char *interp_name
= (const char *) interp_name_holder
->data ();
2434 CORE_ADDR load_addr
= 0;
2435 int load_addr_found
= 0;
2436 int loader_found_in_list
= 0;
2437 target_ops_up tmp_bfd_target
;
2441 /* Now we need to figure out where the dynamic linker was
2442 loaded so that we can load its symbols and place a breakpoint
2443 in the dynamic linker itself.
2445 This address is stored on the stack. However, I've been unable
2446 to find any magic formula to find it for Solaris (appears to
2447 be trivial on GNU/Linux). Therefore, we have to try an alternate
2448 mechanism to find the dynamic linker's base address. */
2450 gdb_bfd_ref_ptr tmp_bfd
;
2453 tmp_bfd
= solib_bfd_open (interp_name
);
2455 catch (const gdb_exception
&ex
)
2459 if (tmp_bfd
== NULL
)
2460 goto bkpt_at_symbol
;
2462 /* Now convert the TMP_BFD into a target. That way target, as
2463 well as BFD operations can be used. */
2464 tmp_bfd_target
= target_bfd_reopen (tmp_bfd
);
2466 /* On a running target, we can get the dynamic linker's base
2467 address from the shared library table. */
2468 for (struct so_list
*so
: current_program_space
->solibs ())
2470 if (svr4_same_1 (interp_name
, so
->so_original_name
))
2472 load_addr_found
= 1;
2473 loader_found_in_list
= 1;
2474 load_addr
= lm_addr_check (so
, tmp_bfd
.get ());
2479 /* If we were not able to find the base address of the loader
2480 from our so_list, then try using the AT_BASE auxilliary entry. */
2481 if (!load_addr_found
)
2482 if (target_auxv_search (AT_BASE
, &load_addr
) > 0)
2484 int addr_bit
= gdbarch_addr_bit (current_inferior ()->arch ());
2486 /* Ensure LOAD_ADDR has proper sign in its possible upper bits so
2487 that `+ load_addr' will overflow CORE_ADDR width not creating
2488 invalid addresses like 0x101234567 for 32bit inferiors on 64bit
2491 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2493 CORE_ADDR space_size
= (CORE_ADDR
) 1 << addr_bit
;
2494 CORE_ADDR tmp_entry_point
2495 = exec_entry_point (tmp_bfd
.get (), tmp_bfd_target
.get ());
2497 gdb_assert (load_addr
< space_size
);
2499 /* TMP_ENTRY_POINT exceeding SPACE_SIZE would be for prelinked
2500 64bit ld.so with 32bit executable, it should not happen. */
2502 if (tmp_entry_point
< space_size
2503 && tmp_entry_point
+ load_addr
>= space_size
)
2504 load_addr
-= space_size
;
2507 load_addr_found
= 1;
2510 /* Otherwise we find the dynamic linker's base address by examining
2511 the current pc (which should point at the entry point for the
2512 dynamic linker) and subtracting the offset of the entry point.
2514 This is more fragile than the previous approaches, but is a good
2515 fallback method because it has actually been working well in
2517 if (!load_addr_found
)
2519 struct regcache
*regcache
2520 = get_thread_arch_regcache (current_inferior ()->process_target (),
2522 current_inferior ()->arch ());
2524 load_addr
= (regcache_read_pc (regcache
)
2525 - exec_entry_point (tmp_bfd
.get (),
2526 tmp_bfd_target
.get ()));
2529 if (!loader_found_in_list
)
2531 info
->debug_loader_name
= xstrdup (interp_name
);
2532 info
->debug_loader_offset_p
= 1;
2533 info
->debug_loader_offset
= load_addr
;
2534 solib_add (NULL
, from_tty
, auto_solib_add
);
2537 /* Record the relocated start and end address of the dynamic linker
2538 text and plt section for svr4_in_dynsym_resolve_code. */
2539 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".text");
2542 info
->interp_text_sect_low
2543 = bfd_section_vma (interp_sect
) + load_addr
;
2544 info
->interp_text_sect_high
2545 = info
->interp_text_sect_low
+ bfd_section_size (interp_sect
);
2547 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".plt");
2550 info
->interp_plt_sect_low
2551 = bfd_section_vma (interp_sect
) + load_addr
;
2552 info
->interp_plt_sect_high
2553 = info
->interp_plt_sect_low
+ bfd_section_size (interp_sect
);
2556 /* Now try to set a breakpoint in the dynamic linker. */
2557 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2560 = (gdb_bfd_lookup_symbol
2562 [=] (const asymbol
*sym
)
2564 return (strcmp (sym
->name
, *bkpt_namep
) == 0
2565 && ((sym
->section
->flags
& (SEC_CODE
| SEC_DATA
))
2573 /* Convert 'sym_addr' from a function pointer to an address.
2574 Because we pass tmp_bfd_target instead of the current
2575 target, this will always produce an unrelocated value. */
2576 sym_addr
= gdbarch_convert_from_func_ptr_addr
2577 (current_inferior ()->arch (), sym_addr
,
2578 tmp_bfd_target
.get ());
2582 svr4_create_solib_event_breakpoints (info
,
2583 current_inferior ()->arch (),
2584 load_addr
+ sym_addr
);
2588 /* For whatever reason we couldn't set a breakpoint in the dynamic
2589 linker. Warn and drop into the old code. */
2591 warning (_("Unable to find dynamic linker breakpoint function.\n"
2592 "GDB will be unable to debug shared library initializers\n"
2593 "and track explicitly loaded dynamic code."));
2596 /* Scan through the lists of symbols, trying to look up the symbol and
2597 set a breakpoint there. Terminate loop when we/if we succeed. */
2599 objfile
*objf
= current_program_space
->symfile_object_file
;
2600 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2602 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, objf
);
2603 if ((msymbol
.minsym
!= NULL
)
2604 && (msymbol
.value_address () != 0))
2606 sym_addr
= msymbol
.value_address ();
2607 sym_addr
= gdbarch_convert_from_func_ptr_addr
2608 (current_inferior ()->arch (), sym_addr
,
2609 current_inferior ()->top_target ());
2610 svr4_create_solib_event_breakpoints (info
,
2611 current_inferior ()->arch (),
2617 if (interp_name_holder
&& !current_inferior ()->attach_flag
)
2619 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2621 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, objf
);
2622 if ((msymbol
.minsym
!= NULL
)
2623 && (msymbol
.value_address () != 0))
2625 sym_addr
= msymbol
.value_address ();
2626 sym_addr
= gdbarch_convert_from_func_ptr_addr
2627 (current_inferior ()->arch (), sym_addr
,
2628 current_inferior ()->top_target ());
2629 svr4_create_solib_event_breakpoints
2630 (info
, current_inferior ()->arch (), sym_addr
);
2638 /* Read the ELF program headers from ABFD. */
2640 static gdb::optional
<gdb::byte_vector
>
2641 read_program_headers_from_bfd (bfd
*abfd
)
2643 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
2644 int phdrs_size
= ehdr
->e_phnum
* ehdr
->e_phentsize
;
2645 if (phdrs_size
== 0)
2648 gdb::byte_vector
buf (phdrs_size
);
2649 if (bfd_seek (abfd
, ehdr
->e_phoff
, SEEK_SET
) != 0
2650 || bfd_read (buf
.data (), phdrs_size
, abfd
) != phdrs_size
)
2656 /* Return 1 and fill *DISPLACEMENTP with detected PIE offset of inferior
2657 exec_bfd. Otherwise return 0.
2659 We relocate all of the sections by the same amount. This
2660 behavior is mandated by recent editions of the System V ABI.
2661 According to the System V Application Binary Interface,
2662 Edition 4.1, page 5-5:
2664 ... Though the system chooses virtual addresses for
2665 individual processes, it maintains the segments' relative
2666 positions. Because position-independent code uses relative
2667 addressing between segments, the difference between
2668 virtual addresses in memory must match the difference
2669 between virtual addresses in the file. The difference
2670 between the virtual address of any segment in memory and
2671 the corresponding virtual address in the file is thus a
2672 single constant value for any one executable or shared
2673 object in a given process. This difference is the base
2674 address. One use of the base address is to relocate the
2675 memory image of the program during dynamic linking.
2677 The same language also appears in Edition 4.0 of the System V
2678 ABI and is left unspecified in some of the earlier editions.
2680 Decide if the objfile needs to be relocated. As indicated above, we will
2681 only be here when execution is stopped. But during attachment PC can be at
2682 arbitrary address therefore regcache_read_pc can be misleading (contrary to
2683 the auxv AT_ENTRY value). Moreover for executable with interpreter section
2684 regcache_read_pc would point to the interpreter and not the main executable.
2686 So, to summarize, relocations are necessary when the start address obtained
2687 from the executable is different from the address in auxv AT_ENTRY entry.
2689 [ The astute reader will note that we also test to make sure that
2690 the executable in question has the DYNAMIC flag set. It is my
2691 opinion that this test is unnecessary (undesirable even). It
2692 was added to avoid inadvertent relocation of an executable
2693 whose e_type member in the ELF header is not ET_DYN. There may
2694 be a time in the future when it is desirable to do relocations
2695 on other types of files as well in which case this condition
2696 should either be removed or modified to accommodate the new file
2697 type. - Kevin, Nov 2000. ] */
2700 svr4_exec_displacement (CORE_ADDR
*displacementp
)
2702 /* ENTRY_POINT is a possible function descriptor - before
2703 a call to gdbarch_convert_from_func_ptr_addr. */
2704 CORE_ADDR entry_point
, exec_displacement
;
2706 if (current_program_space
->exec_bfd () == NULL
)
2709 /* Therefore for ELF it is ET_EXEC and not ET_DYN. Both shared libraries
2710 being executed themselves and PIE (Position Independent Executable)
2711 executables are ET_DYN. */
2713 if ((bfd_get_file_flags (current_program_space
->exec_bfd ()) & DYNAMIC
) == 0)
2716 if (target_auxv_search (AT_ENTRY
, &entry_point
) <= 0)
2720 = entry_point
- bfd_get_start_address (current_program_space
->exec_bfd ());
2722 /* Verify the EXEC_DISPLACEMENT candidate complies with the required page
2723 alignment. It is cheaper than the program headers comparison below. */
2725 if (bfd_get_flavour (current_program_space
->exec_bfd ())
2726 == bfd_target_elf_flavour
)
2728 const struct elf_backend_data
*elf
2729 = get_elf_backend_data (current_program_space
->exec_bfd ());
2731 /* p_align of PT_LOAD segments does not specify any alignment but
2732 only congruency of addresses:
2733 p_offset % p_align == p_vaddr % p_align
2734 Kernel is free to load the executable with lower alignment. */
2736 if ((exec_displacement
& (elf
->minpagesize
- 1)) != 0)
2740 /* Verify that the auxilliary vector describes the same file as exec_bfd, by
2741 comparing their program headers. If the program headers in the auxilliary
2742 vector do not match the program headers in the executable, then we are
2743 looking at a different file than the one used by the kernel - for
2744 instance, "gdb program" connected to "gdbserver :PORT ld.so program". */
2746 if (bfd_get_flavour (current_program_space
->exec_bfd ())
2747 == bfd_target_elf_flavour
)
2749 /* Be optimistic and return 0 only if GDB was able to verify the headers
2750 really do not match. */
2753 gdb::optional
<gdb::byte_vector
> phdrs_target
2754 = read_program_header (-1, &arch_size
, NULL
);
2755 gdb::optional
<gdb::byte_vector
> phdrs_binary
2756 = read_program_headers_from_bfd (current_program_space
->exec_bfd ());
2757 if (phdrs_target
&& phdrs_binary
)
2759 bfd_endian byte_order
= gdbarch_byte_order (current_inferior ()->arch ());
2761 /* We are dealing with three different addresses. EXEC_BFD
2762 represents current address in on-disk file. target memory content
2763 may be different from EXEC_BFD as the file may have been prelinked
2764 to a different address after the executable has been loaded.
2765 Moreover the address of placement in target memory can be
2766 different from what the program headers in target memory say -
2767 this is the goal of PIE.
2769 Detected DISPLACEMENT covers both the offsets of PIE placement and
2770 possible new prelink performed after start of the program. Here
2771 relocate BUF and BUF2 just by the EXEC_BFD vs. target memory
2772 content offset for the verification purpose. */
2774 if (phdrs_target
->size () != phdrs_binary
->size ()
2775 || bfd_get_arch_size (current_program_space
->exec_bfd ()) != arch_size
)
2777 else if (arch_size
== 32
2778 && phdrs_target
->size () >= sizeof (Elf32_External_Phdr
)
2779 && phdrs_target
->size () % sizeof (Elf32_External_Phdr
) == 0)
2781 Elf_Internal_Ehdr
*ehdr2
2782 = elf_tdata (current_program_space
->exec_bfd ())->elf_header
;
2783 Elf_Internal_Phdr
*phdr2
2784 = elf_tdata (current_program_space
->exec_bfd ())->phdr
;
2785 CORE_ADDR displacement
= 0;
2788 /* DISPLACEMENT could be found more easily by the difference of
2789 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2790 already have enough information to compute that displacement
2791 with what we've read. */
2793 for (i
= 0; i
< ehdr2
->e_phnum
; i
++)
2794 if (phdr2
[i
].p_type
== PT_LOAD
)
2796 Elf32_External_Phdr
*phdrp
;
2797 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2798 CORE_ADDR vaddr
, paddr
;
2799 CORE_ADDR displacement_vaddr
= 0;
2800 CORE_ADDR displacement_paddr
= 0;
2802 phdrp
= &((Elf32_External_Phdr
*) phdrs_target
->data ())[i
];
2803 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2804 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2806 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 4,
2808 displacement_vaddr
= vaddr
- phdr2
[i
].p_vaddr
;
2810 paddr
= extract_unsigned_integer (buf_paddr_p
, 4,
2812 displacement_paddr
= paddr
- phdr2
[i
].p_paddr
;
2814 if (displacement_vaddr
== displacement_paddr
)
2815 displacement
= displacement_vaddr
;
2820 /* Now compare program headers from the target and the binary
2821 with optional DISPLACEMENT. */
2824 i
< phdrs_target
->size () / sizeof (Elf32_External_Phdr
);
2827 Elf32_External_Phdr
*phdrp
;
2828 Elf32_External_Phdr
*phdr2p
;
2829 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2830 CORE_ADDR vaddr
, paddr
;
2831 asection
*plt2_asect
;
2833 phdrp
= &((Elf32_External_Phdr
*) phdrs_target
->data ())[i
];
2834 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2835 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2836 phdr2p
= &((Elf32_External_Phdr
*) phdrs_binary
->data ())[i
];
2838 /* PT_GNU_STACK is an exception by being never relocated by
2839 prelink as its addresses are always zero. */
2841 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2844 /* Check also other adjustment combinations - PR 11786. */
2846 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 4,
2848 vaddr
-= displacement
;
2849 store_unsigned_integer (buf_vaddr_p
, 4, byte_order
, vaddr
);
2851 paddr
= extract_unsigned_integer (buf_paddr_p
, 4,
2853 paddr
-= displacement
;
2854 store_unsigned_integer (buf_paddr_p
, 4, byte_order
, paddr
);
2856 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2859 /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2860 CentOS-5 has problems with filesz, memsz as well.
2861 Strip also modifies memsz of PT_TLS.
2863 if (phdr2
[i
].p_type
== PT_GNU_RELRO
2864 || phdr2
[i
].p_type
== PT_TLS
)
2866 Elf32_External_Phdr tmp_phdr
= *phdrp
;
2867 Elf32_External_Phdr tmp_phdr2
= *phdr2p
;
2869 memset (tmp_phdr
.p_filesz
, 0, 4);
2870 memset (tmp_phdr
.p_memsz
, 0, 4);
2871 memset (tmp_phdr
.p_flags
, 0, 4);
2872 memset (tmp_phdr
.p_align
, 0, 4);
2873 memset (tmp_phdr2
.p_filesz
, 0, 4);
2874 memset (tmp_phdr2
.p_memsz
, 0, 4);
2875 memset (tmp_phdr2
.p_flags
, 0, 4);
2876 memset (tmp_phdr2
.p_align
, 0, 4);
2878 if (memcmp (&tmp_phdr
, &tmp_phdr2
, sizeof (tmp_phdr
))
2883 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2884 bfd
*exec_bfd
= current_program_space
->exec_bfd ();
2885 plt2_asect
= bfd_get_section_by_name (exec_bfd
, ".plt");
2889 gdb_byte
*buf_filesz_p
= (gdb_byte
*) &phdrp
->p_filesz
;
2892 content2
= (bfd_section_flags (plt2_asect
)
2893 & SEC_HAS_CONTENTS
) != 0;
2895 filesz
= extract_unsigned_integer (buf_filesz_p
, 4,
2898 /* PLT2_ASECT is from on-disk file (exec_bfd) while
2899 FILESZ is from the in-memory image. */
2901 filesz
+= bfd_section_size (plt2_asect
);
2903 filesz
-= bfd_section_size (plt2_asect
);
2905 store_unsigned_integer (buf_filesz_p
, 4, byte_order
,
2908 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2915 else if (arch_size
== 64
2916 && phdrs_target
->size () >= sizeof (Elf64_External_Phdr
)
2917 && phdrs_target
->size () % sizeof (Elf64_External_Phdr
) == 0)
2919 Elf_Internal_Ehdr
*ehdr2
2920 = elf_tdata (current_program_space
->exec_bfd ())->elf_header
;
2921 Elf_Internal_Phdr
*phdr2
2922 = elf_tdata (current_program_space
->exec_bfd ())->phdr
;
2923 CORE_ADDR displacement
= 0;
2926 /* DISPLACEMENT could be found more easily by the difference of
2927 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2928 already have enough information to compute that displacement
2929 with what we've read. */
2931 for (i
= 0; i
< ehdr2
->e_phnum
; i
++)
2932 if (phdr2
[i
].p_type
== PT_LOAD
)
2934 Elf64_External_Phdr
*phdrp
;
2935 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2936 CORE_ADDR vaddr
, paddr
;
2937 CORE_ADDR displacement_vaddr
= 0;
2938 CORE_ADDR displacement_paddr
= 0;
2940 phdrp
= &((Elf64_External_Phdr
*) phdrs_target
->data ())[i
];
2941 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2942 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2944 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 8,
2946 displacement_vaddr
= vaddr
- phdr2
[i
].p_vaddr
;
2948 paddr
= extract_unsigned_integer (buf_paddr_p
, 8,
2950 displacement_paddr
= paddr
- phdr2
[i
].p_paddr
;
2952 if (displacement_vaddr
== displacement_paddr
)
2953 displacement
= displacement_vaddr
;
2958 /* Now compare BUF and BUF2 with optional DISPLACEMENT. */
2961 i
< phdrs_target
->size () / sizeof (Elf64_External_Phdr
);
2964 Elf64_External_Phdr
*phdrp
;
2965 Elf64_External_Phdr
*phdr2p
;
2966 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2967 CORE_ADDR vaddr
, paddr
;
2968 asection
*plt2_asect
;
2970 phdrp
= &((Elf64_External_Phdr
*) phdrs_target
->data ())[i
];
2971 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2972 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2973 phdr2p
= &((Elf64_External_Phdr
*) phdrs_binary
->data ())[i
];
2975 /* PT_GNU_STACK is an exception by being never relocated by
2976 prelink as its addresses are always zero. */
2978 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2981 /* Check also other adjustment combinations - PR 11786. */
2983 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 8,
2985 vaddr
-= displacement
;
2986 store_unsigned_integer (buf_vaddr_p
, 8, byte_order
, vaddr
);
2988 paddr
= extract_unsigned_integer (buf_paddr_p
, 8,
2990 paddr
-= displacement
;
2991 store_unsigned_integer (buf_paddr_p
, 8, byte_order
, paddr
);
2993 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2996 /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2997 CentOS-5 has problems with filesz, memsz as well.
2998 Strip also modifies memsz of PT_TLS.
3000 if (phdr2
[i
].p_type
== PT_GNU_RELRO
3001 || phdr2
[i
].p_type
== PT_TLS
)
3003 Elf64_External_Phdr tmp_phdr
= *phdrp
;
3004 Elf64_External_Phdr tmp_phdr2
= *phdr2p
;
3006 memset (tmp_phdr
.p_filesz
, 0, 8);
3007 memset (tmp_phdr
.p_memsz
, 0, 8);
3008 memset (tmp_phdr
.p_flags
, 0, 4);
3009 memset (tmp_phdr
.p_align
, 0, 8);
3010 memset (tmp_phdr2
.p_filesz
, 0, 8);
3011 memset (tmp_phdr2
.p_memsz
, 0, 8);
3012 memset (tmp_phdr2
.p_flags
, 0, 4);
3013 memset (tmp_phdr2
.p_align
, 0, 8);
3015 if (memcmp (&tmp_phdr
, &tmp_phdr2
, sizeof (tmp_phdr
))
3020 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
3022 = bfd_get_section_by_name (current_program_space
->exec_bfd (),
3027 gdb_byte
*buf_filesz_p
= (gdb_byte
*) &phdrp
->p_filesz
;
3030 content2
= (bfd_section_flags (plt2_asect
)
3031 & SEC_HAS_CONTENTS
) != 0;
3033 filesz
= extract_unsigned_integer (buf_filesz_p
, 8,
3036 /* PLT2_ASECT is from on-disk file (current
3037 exec_bfd) while FILESZ is from the in-memory
3040 filesz
+= bfd_section_size (plt2_asect
);
3042 filesz
-= bfd_section_size (plt2_asect
);
3044 store_unsigned_integer (buf_filesz_p
, 8, byte_order
,
3047 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
3061 /* It can be printed repeatedly as there is no easy way to check
3062 the executable symbols/file has been already relocated to
3065 gdb_printf (_("Using PIE (Position Independent Executable) "
3066 "displacement %s for \"%s\".\n"),
3067 paddress (current_inferior ()->arch (), exec_displacement
),
3068 bfd_get_filename (current_program_space
->exec_bfd ()));
3071 *displacementp
= exec_displacement
;
3075 /* Relocate the main executable. This function should be called upon
3076 stopping the inferior process at the entry point to the program.
3077 The entry point from BFD is compared to the AT_ENTRY of AUXV and if they are
3078 different, the main executable is relocated by the proper amount. */
3081 svr4_relocate_main_executable (void)
3083 CORE_ADDR displacement
;
3085 /* If we are re-running this executable, SYMFILE_OBJFILE->SECTION_OFFSETS
3086 probably contains the offsets computed using the PIE displacement
3087 from the previous run, which of course are irrelevant for this run.
3088 So we need to determine the new PIE displacement and recompute the
3089 section offsets accordingly, even if SYMFILE_OBJFILE->SECTION_OFFSETS
3090 already contains pre-computed offsets.
3092 If we cannot compute the PIE displacement, either:
3094 - The executable is not PIE.
3096 - SYMFILE_OBJFILE does not match the executable started in the target.
3097 This can happen for main executable symbols loaded at the host while
3098 `ld.so --ld-args main-executable' is loaded in the target.
3100 Then we leave the section offsets untouched and use them as is for
3103 - These section offsets were properly reset earlier, and thus
3104 already contain the correct values. This can happen for instance
3105 when reconnecting via the remote protocol to a target that supports
3106 the `qOffsets' packet.
3108 - The section offsets were not reset earlier, and the best we can
3109 hope is that the old offsets are still applicable to the new run. */
3111 if (! svr4_exec_displacement (&displacement
))
3114 /* Even DISPLACEMENT 0 is a valid new difference of in-memory vs. in-file
3117 objfile
*objf
= current_program_space
->symfile_object_file
;
3120 section_offsets
new_offsets (objf
->section_offsets
.size (),
3122 objfile_relocate (objf
, new_offsets
);
3124 else if (current_program_space
->exec_bfd ())
3128 bfd
*exec_bfd
= current_program_space
->exec_bfd ();
3129 for (asect
= exec_bfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
3130 exec_set_section_address (bfd_get_filename (exec_bfd
), asect
->index
,
3131 bfd_section_vma (asect
) + displacement
);
3135 /* Implement the "create_inferior_hook" target_solib_ops method.
3137 For SVR4 executables, this first instruction is either the first
3138 instruction in the dynamic linker (for dynamically linked
3139 executables) or the instruction at "start" for statically linked
3140 executables. For dynamically linked executables, the system
3141 first exec's /lib/libc.so.N, which contains the dynamic linker,
3142 and starts it running. The dynamic linker maps in any needed
3143 shared libraries, maps in the actual user executable, and then
3144 jumps to "start" in the user executable.
3146 We can arrange to cooperate with the dynamic linker to discover the
3147 names of shared libraries that are dynamically linked, and the base
3148 addresses to which they are linked.
3150 This function is responsible for discovering those names and
3151 addresses, and saving sufficient information about them to allow
3152 their symbols to be read at a later time. */
3155 svr4_solib_create_inferior_hook (int from_tty
)
3157 struct svr4_info
*info
;
3159 info
= get_svr4_info (current_program_space
);
3161 /* Clear the probes-based interface's state. */
3162 free_probes_table (info
);
3163 free_solib_lists (info
);
3165 /* Relocate the main executable if necessary. */
3166 svr4_relocate_main_executable ();
3168 /* No point setting a breakpoint in the dynamic linker if we can't
3169 hit it (e.g., a core file, or a trace file). */
3170 if (!target_has_execution ())
3173 if (!svr4_have_link_map_offsets ())
3176 if (!enable_break (info
, from_tty
))
3181 svr4_clear_solib (void)
3183 struct svr4_info
*info
;
3185 info
= get_svr4_info (current_program_space
);
3186 info
->debug_base
= 0;
3187 info
->debug_loader_offset_p
= 0;
3188 info
->debug_loader_offset
= 0;
3189 xfree (info
->debug_loader_name
);
3190 info
->debug_loader_name
= NULL
;
3193 /* Clear any bits of ADDR that wouldn't fit in a target-format
3194 data pointer. "Data pointer" here refers to whatever sort of
3195 address the dynamic linker uses to manage its sections. At the
3196 moment, we don't support shared libraries on any processors where
3197 code and data pointers are different sizes.
3199 This isn't really the right solution. What we really need here is
3200 a way to do arithmetic on CORE_ADDR values that respects the
3201 natural pointer/address correspondence. (For example, on the MIPS,
3202 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
3203 sign-extend the value. There, simply truncating the bits above
3204 gdbarch_ptr_bit, as we do below, is no good.) This should probably
3205 be a new gdbarch method or something. */
3207 svr4_truncate_ptr (CORE_ADDR addr
)
3209 if (gdbarch_ptr_bit (current_inferior ()->arch ()) == sizeof (CORE_ADDR
) * 8)
3210 /* We don't need to truncate anything, and the bit twiddling below
3211 will fail due to overflow problems. */
3214 return addr
& (((CORE_ADDR
) 1 << gdbarch_ptr_bit (current_inferior ()->arch ())) - 1);
3219 svr4_relocate_section_addresses (struct so_list
*so
,
3220 struct target_section
*sec
)
3222 bfd
*abfd
= sec
->the_bfd_section
->owner
;
3224 sec
->addr
= svr4_truncate_ptr (sec
->addr
+ lm_addr_check (so
, abfd
));
3225 sec
->endaddr
= svr4_truncate_ptr (sec
->endaddr
+ lm_addr_check (so
, abfd
));
3229 /* Architecture-specific operations. */
3231 struct solib_svr4_ops
3233 /* Return a description of the layout of `struct link_map'. */
3234 struct link_map_offsets
*(*fetch_link_map_offsets
)(void) = nullptr;
3237 /* Per-architecture data key. */
3238 static const registry
<gdbarch
>::key
<struct solib_svr4_ops
> solib_svr4_data
;
3240 /* Return a default for the architecture-specific operations. */
3242 static struct solib_svr4_ops
*
3243 get_ops (struct gdbarch
*gdbarch
)
3245 struct solib_svr4_ops
*ops
= solib_svr4_data
.get (gdbarch
);
3247 ops
= solib_svr4_data
.emplace (gdbarch
);
3251 /* Set the architecture-specific `struct link_map_offsets' fetcher for
3252 GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */
3255 set_solib_svr4_fetch_link_map_offsets (struct gdbarch
*gdbarch
,
3256 struct link_map_offsets
*(*flmo
) (void))
3258 struct solib_svr4_ops
*ops
= get_ops (gdbarch
);
3260 ops
->fetch_link_map_offsets
= flmo
;
3262 set_gdbarch_so_ops (gdbarch
, &svr4_so_ops
);
3263 set_gdbarch_iterate_over_objfiles_in_search_order
3264 (gdbarch
, svr4_iterate_over_objfiles_in_search_order
);
3267 /* Fetch a link_map_offsets structure using the architecture-specific
3268 `struct link_map_offsets' fetcher. */
3270 static struct link_map_offsets
*
3271 svr4_fetch_link_map_offsets (void)
3273 struct solib_svr4_ops
*ops
= get_ops (current_inferior ()->arch ());
3275 gdb_assert (ops
->fetch_link_map_offsets
);
3276 return ops
->fetch_link_map_offsets ();
3279 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
3282 svr4_have_link_map_offsets (void)
3284 struct solib_svr4_ops
*ops
= get_ops (current_inferior ()->arch ());
3286 return (ops
->fetch_link_map_offsets
!= NULL
);
3290 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
3291 `struct r_debug' and a `struct link_map' that are binary compatible
3292 with the original SVR4 implementation. */
3294 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3295 for an ILP32 SVR4 system. */
3297 struct link_map_offsets
*
3298 svr4_ilp32_fetch_link_map_offsets (void)
3300 static struct link_map_offsets lmo
;
3301 static struct link_map_offsets
*lmp
= NULL
;
3307 lmo
.r_version_offset
= 0;
3308 lmo
.r_version_size
= 4;
3309 lmo
.r_map_offset
= 4;
3310 lmo
.r_brk_offset
= 8;
3311 lmo
.r_ldsomap_offset
= 20;
3312 lmo
.r_next_offset
= -1;
3314 /* Everything we need is in the first 20 bytes. */
3315 lmo
.link_map_size
= 20;
3316 lmo
.l_addr_offset
= 0;
3317 lmo
.l_name_offset
= 4;
3318 lmo
.l_ld_offset
= 8;
3319 lmo
.l_next_offset
= 12;
3320 lmo
.l_prev_offset
= 16;
3326 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3327 for an LP64 SVR4 system. */
3329 struct link_map_offsets
*
3330 svr4_lp64_fetch_link_map_offsets (void)
3332 static struct link_map_offsets lmo
;
3333 static struct link_map_offsets
*lmp
= NULL
;
3339 lmo
.r_version_offset
= 0;
3340 lmo
.r_version_size
= 4;
3341 lmo
.r_map_offset
= 8;
3342 lmo
.r_brk_offset
= 16;
3343 lmo
.r_ldsomap_offset
= 40;
3344 lmo
.r_next_offset
= -1;
3346 /* Everything we need is in the first 40 bytes. */
3347 lmo
.link_map_size
= 40;
3348 lmo
.l_addr_offset
= 0;
3349 lmo
.l_name_offset
= 8;
3350 lmo
.l_ld_offset
= 16;
3351 lmo
.l_next_offset
= 24;
3352 lmo
.l_prev_offset
= 32;
3359 /* Return the DSO matching OBJFILE or nullptr if none can be found. */
3362 find_solib_for_objfile (struct objfile
*objfile
)
3364 if (objfile
== nullptr)
3367 /* If OBJFILE is a separate debug object file, look for the original
3369 if (objfile
->separate_debug_objfile_backlink
!= nullptr)
3370 objfile
= objfile
->separate_debug_objfile_backlink
;
3372 for (so_list
*so
: current_program_space
->solibs ())
3373 if (so
->objfile
== objfile
)
3379 /* Return the address of the r_debug object for the namespace containing
3380 SOLIB or zero if it cannot be found. This may happen when symbol files
3381 are added manually, for example, or with the main executable.
3383 Current callers treat zero as initial namespace so they are doing the
3384 right thing for the main executable. */
3387 find_debug_base_for_solib (so_list
*solib
)
3389 if (solib
== nullptr)
3392 svr4_info
*info
= get_svr4_info (current_program_space
);
3393 gdb_assert (info
!= nullptr);
3394 for (const std::pair
<CORE_ADDR
, so_list
*> tuple
3395 : info
->solib_lists
)
3397 CORE_ADDR debug_base
= tuple
.first
;
3398 so_list
*solist
= tuple
.second
;
3400 for (; solist
!= nullptr; solist
= solist
->next
)
3401 if (svr4_same (solib
, solist
))
3408 /* Search order for ELF DSOs linked with -Bsymbolic. Those DSOs have a
3409 different rule for symbol lookup. The lookup begins here in the DSO,
3410 not in the main executable. When starting from CURRENT_OBJFILE, we
3411 stay in the same namespace as that file. Otherwise, we only consider
3412 the initial namespace. */
3415 svr4_iterate_over_objfiles_in_search_order
3416 (gdbarch
*gdbarch
, iterate_over_objfiles_in_search_order_cb_ftype cb
,
3417 objfile
*current_objfile
)
3419 bool checked_current_objfile
= false;
3420 if (current_objfile
!= nullptr)
3424 if (current_objfile
->separate_debug_objfile_backlink
!= nullptr)
3425 current_objfile
= current_objfile
->separate_debug_objfile_backlink
;
3427 if (current_objfile
== current_program_space
->symfile_object_file
)
3428 abfd
= current_program_space
->exec_bfd ();
3430 abfd
= current_objfile
->obfd
.get ();
3433 && gdb_bfd_scan_elf_dyntag (DT_SYMBOLIC
, abfd
, nullptr, nullptr) == 1)
3435 checked_current_objfile
= true;
3436 if (cb (current_objfile
))
3441 /* The linker namespace to iterate identified by the address of its
3442 r_debug object, defaulting to the initial namespace. */
3443 CORE_ADDR initial
= elf_locate_base ();
3444 so_list
*curr_solib
= find_solib_for_objfile (current_objfile
);
3445 CORE_ADDR debug_base
= find_debug_base_for_solib (curr_solib
);
3446 if (debug_base
== 0)
3447 debug_base
= initial
;
3449 for (objfile
*objfile
: current_program_space
->objfiles ())
3451 if (checked_current_objfile
&& objfile
== current_objfile
)
3454 /* Try to determine the namespace into which objfile was loaded.
3456 If we fail, e.g. for manually added symbol files or for the main
3457 executable, we assume that they were added to the initial
3459 so_list
*solib
= find_solib_for_objfile (objfile
);
3460 CORE_ADDR solib_base
= find_debug_base_for_solib (solib
);
3461 if (solib_base
== 0)
3462 solib_base
= initial
;
3464 /* Ignore objfiles that were added to a different namespace. */
3465 if (solib_base
!= debug_base
)
3473 const struct target_so_ops svr4_so_ops
=
3475 svr4_relocate_section_addresses
,
3479 svr4_solib_create_inferior_hook
,
3481 open_symbol_file_object
,
3482 svr4_in_dynsym_resolve_code
,
3486 svr4_keep_data_in_core
,
3487 svr4_update_solib_event_breakpoints
,
3488 svr4_handle_solib_event
,
3491 void _initialize_svr4_solib ();
3493 _initialize_svr4_solib ()
3495 gdb::observers::free_objfile
.attach (svr4_free_objfile_observer
,