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 "gdbthread.h"
36 #include "observable.h"
40 #include "solib-svr4.h"
42 #include "bfd-target.h"
51 static struct link_map_offsets
*svr4_fetch_link_map_offsets (void);
52 static int svr4_have_link_map_offsets (void);
53 static void svr4_relocate_main_executable (void);
54 static void svr4_free_library_list (so_list
*solist
);
55 static void probes_table_remove_objfile_probes (struct objfile
*objfile
);
56 static void svr4_iterate_over_objfiles_in_search_order
57 (gdbarch
*gdbarch
, iterate_over_objfiles_in_search_order_cb_ftype cb
,
58 objfile
*current_objfile
);
61 /* On SVR4 systems, a list of symbols in the dynamic linker where
62 GDB can try to place a breakpoint to monitor shared library
65 If none of these symbols are found, or other errors occur, then
66 SVR4 systems will fall back to using a symbol as the "startup
67 mapping complete" breakpoint address. */
69 static const char * const solib_break_names
[] =
75 "__dl_rtld_db_dlactivity",
81 static const char * const bkpt_names
[] =
89 static const char * const main_name_list
[] =
95 /* What to do when a probe stop occurs. */
99 /* Something went seriously wrong. Stop using probes and
100 revert to using the older interface. */
101 PROBES_INTERFACE_FAILED
,
103 /* No action is required. The shared object list is still
107 /* The shared object list should be reloaded entirely. */
110 /* Attempt to incrementally update the shared object list. If
111 the update fails or is not possible, fall back to reloading
116 /* A probe's name and its associated action. */
120 /* The name of the probe. */
123 /* What to do when a probe stop occurs. */
124 enum probe_action action
;
127 /* A list of named probes and their associated actions. If all
128 probes are present in the dynamic linker then the probes-based
129 interface will be used. */
131 static const struct probe_info probe_info
[] =
133 { "init_start", DO_NOTHING
},
134 { "init_complete", FULL_RELOAD
},
135 { "map_start", DO_NOTHING
},
136 { "map_failed", DO_NOTHING
},
137 { "reloc_complete", UPDATE_OR_RELOAD
},
138 { "unmap_start", DO_NOTHING
},
139 { "unmap_complete", FULL_RELOAD
},
142 #define NUM_PROBES ARRAY_SIZE (probe_info)
144 /* Return non-zero if GDB_SO_NAME and INFERIOR_SO_NAME represent
145 the same shared library. */
148 svr4_same_1 (const char *gdb_so_name
, const char *inferior_so_name
)
150 if (strcmp (gdb_so_name
, inferior_so_name
) == 0)
153 /* On Solaris, when starting inferior we think that dynamic linker is
154 /usr/lib/ld.so.1, but later on, the table of loaded shared libraries
155 contains /lib/ld.so.1. Sometimes one file is a link to another, but
156 sometimes they have identical content, but are not linked to each
157 other. We don't restrict this check for Solaris, but the chances
158 of running into this situation elsewhere are very low. */
159 if (strcmp (gdb_so_name
, "/usr/lib/ld.so.1") == 0
160 && strcmp (inferior_so_name
, "/lib/ld.so.1") == 0)
163 /* Similarly, we observed the same issue with amd64 and sparcv9, but with
164 different locations. */
165 if (strcmp (gdb_so_name
, "/usr/lib/amd64/ld.so.1") == 0
166 && strcmp (inferior_so_name
, "/lib/amd64/ld.so.1") == 0)
169 if (strcmp (gdb_so_name
, "/usr/lib/sparcv9/ld.so.1") == 0
170 && strcmp (inferior_so_name
, "/lib/sparcv9/ld.so.1") == 0)
177 svr4_same (struct so_list
*gdb
, struct so_list
*inferior
)
179 if (!svr4_same_1 (gdb
->so_original_name
, inferior
->so_original_name
))
182 /* There may be different instances of the same library, in different
183 namespaces. Each instance, however, must have been loaded at a
184 different address so its relocation offset would be different. */
185 const lm_info_svr4
*lmg
= (const lm_info_svr4
*) gdb
->lm_info
;
186 const lm_info_svr4
*lmi
= (const lm_info_svr4
*) inferior
->lm_info
;
188 return (lmg
->l_addr_inferior
== lmi
->l_addr_inferior
);
191 static std::unique_ptr
<lm_info_svr4
>
192 lm_info_read (CORE_ADDR lm_addr
)
194 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
195 std::unique_ptr
<lm_info_svr4
> lm_info
;
197 gdb::byte_vector
lm (lmo
->link_map_size
);
199 if (target_read_memory (lm_addr
, lm
.data (), lmo
->link_map_size
) != 0)
200 warning (_("Error reading shared library list entry at %s"),
201 paddress (target_gdbarch (), lm_addr
));
204 struct type
*ptr_type
= builtin_type (target_gdbarch ())->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 (target_gdbarch (), 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 agrument 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 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
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 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
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
))
710 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
712 int pbuf_size
= ptr_type
->length ();
714 pbuf
= (gdb_byte
*) alloca (pbuf_size
);
715 /* DT_MIPS_RLD_MAP contains a pointer to the address
716 of the dynamic link structure. */
717 if (target_read_memory (dyn_ptr
, pbuf
, pbuf_size
))
719 return extract_typed_address (pbuf
, ptr_type
);
722 /* Then check DT_MIPS_RLD_MAP_REL. MIPS executables now use this form
723 because of needing to support PIE. DT_MIPS_RLD_MAP will also exist
725 if (gdb_bfd_scan_elf_dyntag (DT_MIPS_RLD_MAP_REL
,
726 current_program_space
->exec_bfd (),
727 &dyn_ptr
, &dyn_ptr_addr
)
728 || scan_dyntag_auxv (DT_MIPS_RLD_MAP_REL
, &dyn_ptr
, &dyn_ptr_addr
))
730 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
732 int pbuf_size
= ptr_type
->length ();
734 pbuf
= (gdb_byte
*) alloca (pbuf_size
);
735 /* DT_MIPS_RLD_MAP_REL contains an offset from the address of the
736 DT slot to the address of the dynamic link structure. */
737 if (target_read_memory (dyn_ptr
+ dyn_ptr_addr
, pbuf
, pbuf_size
))
739 return extract_typed_address (pbuf
, ptr_type
);
743 if (gdb_bfd_scan_elf_dyntag (DT_DEBUG
, current_program_space
->exec_bfd (),
745 || scan_dyntag_auxv (DT_DEBUG
, &dyn_ptr
, NULL
))
748 /* This may be a static executable. Look for the symbol
749 conventionally named _r_debug, as a last resort. */
750 msymbol
= lookup_minimal_symbol ("_r_debug", NULL
,
751 current_program_space
->symfile_object_file
);
752 if (msymbol
.minsym
!= NULL
)
753 return msymbol
.value_address ();
755 /* DT_DEBUG entry not found. */
759 /* Find the first element in the inferior's dynamic link map, and
760 return its address in the inferior. Return zero if the address
761 could not be determined.
763 FIXME: Perhaps we should validate the info somehow, perhaps by
764 checking r_version for a known version number, or r_state for
768 solib_svr4_r_map (CORE_ADDR debug_base
)
770 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
771 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
776 addr
= read_memory_typed_address (debug_base
+ lmo
->r_map_offset
,
779 catch (const gdb_exception_error
&ex
)
781 exception_print (gdb_stderr
, ex
);
787 /* Find r_brk from the inferior's debug base. */
790 solib_svr4_r_brk (struct svr4_info
*info
)
792 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
793 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
795 return read_memory_typed_address (info
->debug_base
+ lmo
->r_brk_offset
,
799 /* Find the link map for the dynamic linker (if it is not in the
800 normal list of loaded shared objects). */
803 solib_svr4_r_ldsomap (struct svr4_info
*info
)
805 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
806 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
807 enum bfd_endian byte_order
= type_byte_order (ptr_type
);
808 ULONGEST version
= 0;
812 /* Check version, and return zero if `struct r_debug' doesn't have
813 the r_ldsomap member. */
815 = read_memory_unsigned_integer (info
->debug_base
+ lmo
->r_version_offset
,
816 lmo
->r_version_size
, byte_order
);
818 catch (const gdb_exception_error
&ex
)
820 exception_print (gdb_stderr
, ex
);
823 if (version
< 2 || lmo
->r_ldsomap_offset
== -1)
826 return read_memory_typed_address (info
->debug_base
+ lmo
->r_ldsomap_offset
,
830 /* Find the next namespace from the r_next field. */
833 solib_svr4_r_next (CORE_ADDR debug_base
)
835 link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
836 type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
837 bfd_endian byte_order
= type_byte_order (ptr_type
);
838 ULONGEST version
= 0;
843 = read_memory_unsigned_integer (debug_base
+ lmo
->r_version_offset
,
844 lmo
->r_version_size
, byte_order
);
846 catch (const gdb_exception_error
&ex
)
848 exception_print (gdb_stderr
, ex
);
851 /* The r_next field is added with r_version == 2. */
852 if (version
< 2 || lmo
->r_next_offset
== -1)
855 return read_memory_typed_address (debug_base
+ lmo
->r_next_offset
,
859 /* On Solaris systems with some versions of the dynamic linker,
860 ld.so's l_name pointer points to the SONAME in the string table
861 rather than into writable memory. So that GDB can find shared
862 libraries when loading a core file generated by gcore, ensure that
863 memory areas containing the l_name string are saved in the core
867 svr4_keep_data_in_core (CORE_ADDR vaddr
, unsigned long size
)
869 struct svr4_info
*info
;
873 info
= get_svr4_info (current_program_space
);
875 info
->debug_base
= elf_locate_base ();
876 if (info
->debug_base
== 0)
879 ldsomap
= solib_svr4_r_ldsomap (info
);
883 std::unique_ptr
<lm_info_svr4
> li
= lm_info_read (ldsomap
);
884 name_lm
= li
!= NULL
? li
->l_name
: 0;
886 return (name_lm
>= vaddr
&& name_lm
< vaddr
+ size
);
892 open_symbol_file_object (int from_tty
)
894 CORE_ADDR lm
, l_name
;
895 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
896 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
897 int l_name_size
= ptr_type
->length ();
898 gdb::byte_vector
l_name_buf (l_name_size
);
899 struct svr4_info
*info
= get_svr4_info (current_program_space
);
900 symfile_add_flags add_flags
= 0;
903 add_flags
|= SYMFILE_VERBOSE
;
905 if (current_program_space
->symfile_object_file
)
906 if (!query (_("Attempt to reload symbols from process? ")))
909 /* Always locate the debug struct, in case it has moved. */
910 info
->debug_base
= elf_locate_base ();
911 if (info
->debug_base
== 0)
912 return 0; /* failed somehow... */
914 /* First link map member should be the executable. */
915 lm
= solib_svr4_r_map (info
->debug_base
);
917 return 0; /* failed somehow... */
919 /* Read address of name from target memory to GDB. */
920 read_memory (lm
+ lmo
->l_name_offset
, l_name_buf
.data (), l_name_size
);
922 /* Convert the address to host format. */
923 l_name
= extract_typed_address (l_name_buf
.data (), ptr_type
);
926 return 0; /* No filename. */
928 /* Now fetch the filename from target memory. */
929 gdb::unique_xmalloc_ptr
<char> filename
930 = target_read_string (l_name
, SO_NAME_MAX_PATH_SIZE
- 1);
932 if (filename
== nullptr)
934 warning (_("failed to read exec filename from attached file"));
938 /* Have a pathname: read the symbol file. */
939 symbol_file_add_main (filename
.get (), add_flags
);
944 /* Data exchange structure for the XML parser as returned by
945 svr4_current_sos_via_xfer_libraries. */
947 struct svr4_library_list
949 /* The tail pointer of the current namespace. This is internal to XML
953 /* Inferior address of struct link_map used for the main executable. It is
954 NULL if not known. */
957 /* List of objects loaded into the inferior per namespace. This does
958 not include any default sos.
960 See comment on struct svr4_info.solib_lists. */
961 std::map
<CORE_ADDR
, so_list
*> solib_lists
;
964 /* This module's 'free_objfile' observer. */
967 svr4_free_objfile_observer (struct objfile
*objfile
)
969 probes_table_remove_objfile_probes (objfile
);
972 /* Implementation for target_so_ops.free_so. */
975 svr4_free_so (struct so_list
*so
)
977 lm_info_svr4
*li
= (lm_info_svr4
*) so
->lm_info
;
982 /* Implement target_so_ops.clear_so. */
985 svr4_clear_so (struct so_list
*so
)
987 lm_info_svr4
*li
= (lm_info_svr4
*) so
->lm_info
;
993 /* Free so_list built so far. */
996 svr4_free_library_list (so_list
*list
)
1000 struct so_list
*next
= list
->next
;
1007 /* Copy library list. */
1009 static struct so_list
*
1010 svr4_copy_library_list (struct so_list
*src
)
1012 struct so_list
*dst
= NULL
;
1013 struct so_list
**link
= &dst
;
1017 struct so_list
*newobj
;
1019 newobj
= XNEW (struct so_list
);
1020 memcpy (newobj
, src
, sizeof (struct so_list
));
1022 lm_info_svr4
*src_li
= (lm_info_svr4
*) src
->lm_info
;
1023 newobj
->lm_info
= new lm_info_svr4 (*src_li
);
1025 newobj
->next
= NULL
;
1027 link
= &newobj
->next
;
1035 #ifdef HAVE_LIBEXPAT
1037 #include "xml-support.h"
1039 /* Handle the start of a <library> element. Note: new elements are added
1040 at the tail of the list, keeping the list in order. */
1043 library_list_start_library (struct gdb_xml_parser
*parser
,
1044 const struct gdb_xml_element
*element
,
1046 std::vector
<gdb_xml_value
> &attributes
)
1048 struct svr4_library_list
*list
= (struct svr4_library_list
*) user_data
;
1050 = (const char *) xml_find_attribute (attributes
, "name")->value
.get ();
1052 = (ULONGEST
*) xml_find_attribute (attributes
, "lm")->value
.get ();
1054 = (ULONGEST
*) xml_find_attribute (attributes
, "l_addr")->value
.get ();
1056 = (ULONGEST
*) xml_find_attribute (attributes
, "l_ld")->value
.get ();
1057 struct so_list
*new_elem
;
1059 new_elem
= XCNEW (struct so_list
);
1060 lm_info_svr4
*li
= new lm_info_svr4
;
1061 new_elem
->lm_info
= li
;
1063 li
->l_addr_inferior
= *l_addrp
;
1066 strncpy (new_elem
->so_name
, name
, sizeof (new_elem
->so_name
) - 1);
1067 new_elem
->so_name
[sizeof (new_elem
->so_name
) - 1] = 0;
1068 strcpy (new_elem
->so_original_name
, new_elem
->so_name
);
1070 /* Older versions did not supply lmid. Put the element into the flat
1071 list of the special namespace zero in that case. */
1072 gdb_xml_value
*at_lmid
= xml_find_attribute (attributes
, "lmid");
1073 if (at_lmid
== nullptr)
1075 *list
->tailp
= new_elem
;
1076 list
->tailp
= &new_elem
->next
;
1080 ULONGEST lmid
= *(ULONGEST
*) at_lmid
->value
.get ();
1082 /* Ensure that the element is actually initialized. */
1083 if (list
->solib_lists
.find (lmid
) == list
->solib_lists
.end ())
1084 list
->solib_lists
[lmid
] = nullptr;
1086 so_list
**psolist
= &list
->solib_lists
[lmid
];
1087 so_list
**pnext
= psolist
;
1089 /* Walk to the end of the list if we have one. */
1090 so_list
*solist
= *psolist
;
1091 if (solist
!= nullptr)
1093 for (; solist
->next
!= nullptr; solist
= solist
->next
)
1096 pnext
= &solist
->next
;
1103 /* Handle the start of a <library-list-svr4> element. */
1106 svr4_library_list_start_list (struct gdb_xml_parser
*parser
,
1107 const struct gdb_xml_element
*element
,
1109 std::vector
<gdb_xml_value
> &attributes
)
1111 struct svr4_library_list
*list
= (struct svr4_library_list
*) user_data
;
1113 = (const char *) xml_find_attribute (attributes
, "version")->value
.get ();
1114 struct gdb_xml_value
*main_lm
= xml_find_attribute (attributes
, "main-lm");
1116 if (strcmp (version
, "1.0") != 0)
1117 gdb_xml_error (parser
,
1118 _("SVR4 Library list has unsupported version \"%s\""),
1122 list
->main_lm
= *(ULONGEST
*) main_lm
->value
.get ();
1124 /* Older gdbserver do not support namespaces. We use the special
1125 namespace zero for a linear list of libraries. */
1126 so_list
**solist
= &list
->solib_lists
[0];
1128 list
->tailp
= solist
;
1131 /* The allowed elements and attributes for an XML library list.
1132 The root element is a <library-list>. */
1134 static const struct gdb_xml_attribute svr4_library_attributes
[] =
1136 { "name", GDB_XML_AF_NONE
, NULL
, NULL
},
1137 { "lm", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
1138 { "l_addr", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
1139 { "l_ld", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
1140 { "lmid", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
1141 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
1144 static const struct gdb_xml_element svr4_library_list_children
[] =
1147 "library", svr4_library_attributes
, NULL
,
1148 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
1149 library_list_start_library
, NULL
1151 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
1154 static const struct gdb_xml_attribute svr4_library_list_attributes
[] =
1156 { "version", GDB_XML_AF_NONE
, NULL
, NULL
},
1157 { "main-lm", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
1158 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
1161 static const struct gdb_xml_element svr4_library_list_elements
[] =
1163 { "library-list-svr4", svr4_library_list_attributes
, svr4_library_list_children
,
1164 GDB_XML_EF_NONE
, svr4_library_list_start_list
, NULL
},
1165 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
1168 /* Parse qXfer:libraries:read packet into *SO_LIST_RETURN. Return 1 if
1170 Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
1171 case. Return 1 if *SO_LIST_RETURN contains the library list, it may be
1172 empty, caller is responsible for freeing all its entries. */
1175 svr4_parse_libraries (const char *document
, struct svr4_library_list
*list
)
1177 auto cleanup
= make_scope_exit ([list
] ()
1179 for (const std::pair
<CORE_ADDR
, so_list
*> tuple
1180 : list
->solib_lists
)
1181 svr4_free_library_list (tuple
.second
);
1184 list
->tailp
= nullptr;
1186 list
->solib_lists
.clear ();
1187 if (gdb_xml_parse_quick (_("target library list"), "library-list-svr4.dtd",
1188 svr4_library_list_elements
, document
, list
) == 0)
1190 /* Parsed successfully, keep the result. */
1198 /* Attempt to get so_list from target via qXfer:libraries-svr4:read packet.
1200 Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
1201 case. Return 1 if *SO_LIST_RETURN contains the library list, it may be
1202 empty, caller is responsible for freeing all its entries.
1204 Note that ANNEX must be NULL if the remote does not explicitly allow
1205 qXfer:libraries-svr4:read packets with non-empty annexes. Support for
1206 this can be checked using target_augmented_libraries_svr4_read (). */
1209 svr4_current_sos_via_xfer_libraries (struct svr4_library_list
*list
,
1212 gdb_assert (annex
== NULL
|| target_augmented_libraries_svr4_read ());
1214 /* Fetch the list of shared libraries. */
1215 gdb::optional
<gdb::char_vector
> svr4_library_document
1216 = target_read_stralloc (current_inferior ()->top_target (),
1217 TARGET_OBJECT_LIBRARIES_SVR4
,
1219 if (!svr4_library_document
)
1222 return svr4_parse_libraries (svr4_library_document
->data (), list
);
1228 svr4_current_sos_via_xfer_libraries (struct svr4_library_list
*list
,
1236 /* If no shared library information is available from the dynamic
1237 linker, build a fallback list from other sources. */
1239 static struct so_list
*
1240 svr4_default_sos (svr4_info
*info
)
1242 struct so_list
*newobj
;
1244 if (!info
->debug_loader_offset_p
)
1247 newobj
= XCNEW (struct so_list
);
1248 lm_info_svr4
*li
= new lm_info_svr4
;
1249 newobj
->lm_info
= li
;
1251 /* Nothing will ever check the other fields if we set l_addr_p. */
1252 li
->l_addr
= li
->l_addr_inferior
= info
->debug_loader_offset
;
1255 strncpy (newobj
->so_name
, info
->debug_loader_name
, SO_NAME_MAX_PATH_SIZE
- 1);
1256 newobj
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
1257 strcpy (newobj
->so_original_name
, newobj
->so_name
);
1262 /* Read the whole inferior libraries chain starting at address LM.
1263 Expect the first entry in the chain's previous entry to be PREV_LM.
1264 Add the entries to the tail referenced by LINK_PTR_PTR. Ignore the
1265 first entry if IGNORE_FIRST and set global MAIN_LM_ADDR according
1266 to it. Returns nonzero upon success. If zero is returned the
1267 entries stored to LINK_PTR_PTR are still valid although they may
1268 represent only part of the inferior library list. */
1271 svr4_read_so_list (svr4_info
*info
, CORE_ADDR lm
, CORE_ADDR prev_lm
,
1272 struct so_list
***link_ptr_ptr
, int ignore_first
)
1274 CORE_ADDR first_l_name
= 0;
1277 for (; lm
!= 0; prev_lm
= lm
, lm
= next_lm
)
1279 so_list_up
newobj (XCNEW (struct so_list
));
1281 lm_info_svr4
*li
= lm_info_read (lm
).release ();
1282 newobj
->lm_info
= li
;
1286 next_lm
= li
->l_next
;
1288 if (li
->l_prev
!= prev_lm
)
1290 warning (_("Corrupted shared library list: %s != %s"),
1291 paddress (target_gdbarch (), prev_lm
),
1292 paddress (target_gdbarch (), li
->l_prev
));
1296 /* For SVR4 versions, the first entry in the link map is for the
1297 inferior executable, so we must ignore it. For some versions of
1298 SVR4, it has no name. For others (Solaris 2.3 for example), it
1299 does have a name, so we can no longer use a missing name to
1300 decide when to ignore it. */
1301 if (ignore_first
&& li
->l_prev
== 0)
1303 first_l_name
= li
->l_name
;
1304 info
->main_lm_addr
= li
->lm_addr
;
1308 /* Extract this shared object's name. */
1309 gdb::unique_xmalloc_ptr
<char> buffer
1310 = target_read_string (li
->l_name
, SO_NAME_MAX_PATH_SIZE
- 1);
1311 if (buffer
== nullptr)
1313 /* If this entry's l_name address matches that of the
1314 inferior executable, then this is not a normal shared
1315 object, but (most likely) a vDSO. In this case, silently
1316 skip it; otherwise emit a warning. */
1317 if (first_l_name
== 0 || li
->l_name
!= first_l_name
)
1318 warning (_("Can't read pathname for load map."));
1322 strncpy (newobj
->so_name
, buffer
.get (), SO_NAME_MAX_PATH_SIZE
- 1);
1323 newobj
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
1324 strcpy (newobj
->so_original_name
, newobj
->so_name
);
1326 /* If this entry has no name, or its name matches the name
1327 for the main executable, don't include it in the list. */
1328 if (! newobj
->so_name
[0] || match_main (newobj
->so_name
))
1332 /* Don't free it now. */
1333 **link_ptr_ptr
= newobj
.release ();
1334 *link_ptr_ptr
= &(**link_ptr_ptr
)->next
;
1340 /* Read the full list of currently loaded shared objects directly
1341 from the inferior, without referring to any libraries read and
1342 stored by the probes interface. Handle special cases relating
1343 to the first elements of the list in default namespace. */
1346 svr4_current_sos_direct (struct svr4_info
*info
)
1350 struct svr4_library_list library_list
;
1352 /* Remove any old libraries. We're going to read them back in again. */
1353 free_solib_lists (info
);
1355 /* Fall back to manual examination of the target if the packet is not
1356 supported or gdbserver failed to find DT_DEBUG. gdb.server/solib-list.exp
1357 tests a case where gdbserver cannot find the shared libraries list while
1358 GDB itself is able to find it via SYMFILE_OBJFILE.
1360 Unfortunately statically linked inferiors will also fall back through this
1361 suboptimal code path. */
1363 info
->using_xfer
= svr4_current_sos_via_xfer_libraries (&library_list
,
1365 if (info
->using_xfer
)
1367 if (library_list
.main_lm
)
1368 info
->main_lm_addr
= library_list
.main_lm
;
1370 /* Remove an empty special zero namespace so we know that when there
1371 is one, it is actually used, and we have a flat list without
1372 namespace information. */
1373 if ((library_list
.solib_lists
.find (0)
1374 != library_list
.solib_lists
.end ())
1375 && (library_list
.solib_lists
[0] == nullptr))
1376 library_list
.solib_lists
.erase (0);
1378 /* Replace the (empty) solib_lists in INFO with the one generated
1379 from the target. We don't want to copy it on assignment and then
1380 delete the original afterwards, so let's just swap the
1382 std::swap (info
->solib_lists
, library_list
.solib_lists
);
1386 /* If we can't find the dynamic linker's base structure, this
1387 must not be a dynamically linked executable. Hmm. */
1388 info
->debug_base
= elf_locate_base ();
1389 if (info
->debug_base
== 0)
1392 /* Assume that everything is a library if the dynamic loader was loaded
1393 late by a static executable. */
1394 if (current_program_space
->exec_bfd ()
1395 && bfd_get_section_by_name (current_program_space
->exec_bfd (),
1396 ".dynamic") == NULL
)
1397 ignore_first
= false;
1399 ignore_first
= true;
1401 auto cleanup
= make_scope_exit ([info
] ()
1403 free_solib_lists (info
);
1406 /* Collect the sos in each namespace. */
1407 CORE_ADDR debug_base
= info
->debug_base
;
1408 for (; debug_base
!= 0;
1409 ignore_first
= false, debug_base
= solib_svr4_r_next (debug_base
))
1411 /* Walk the inferior's link map list, and build our so_list list. */
1412 lm
= solib_svr4_r_map (debug_base
);
1415 so_list
**sos
= &info
->solib_lists
[debug_base
];
1418 svr4_read_so_list (info
, lm
, 0, &sos
, ignore_first
);
1422 /* On Solaris, the dynamic linker is not in the normal list of
1423 shared objects, so make sure we pick it up too. Having
1424 symbol information for the dynamic linker is quite crucial
1425 for skipping dynamic linker resolver code.
1427 Note that we interpret the ldsomap load map address as 'virtual'
1428 r_debug object. If we added it to the default namespace (as it was),
1429 we would probably run into inconsistencies with the load map's
1430 prev/next links (I wonder if we did). */
1431 debug_base
= solib_svr4_r_ldsomap (info
);
1432 if (debug_base
!= 0)
1434 /* Add the dynamic linker's namespace unless we already did. */
1435 if (info
->solib_lists
.find (debug_base
) == info
->solib_lists
.end ())
1437 so_list
**sos
= &info
->solib_lists
[debug_base
];
1439 svr4_read_so_list (info
, debug_base
, 0, &sos
, 0);
1446 /* Collect sos read and stored by the probes interface. */
1449 svr4_collect_probes_sos (svr4_info
*info
)
1451 so_list
*sos
= nullptr;
1452 so_list
**pnext
= &sos
;
1454 for (const std::pair
<CORE_ADDR
, so_list
*> tuple
1455 : info
->solib_lists
)
1457 so_list
*solist
= tuple
.second
;
1459 /* Allow the linker to report empty namespaces. */
1460 if (solist
== nullptr)
1463 *pnext
= svr4_copy_library_list (solist
);
1465 /* Update PNEXT to point to the next member of the last element. */
1466 gdb_assert (*pnext
!= nullptr);
1469 so_list
*next
= *pnext
;
1470 if (next
== nullptr)
1473 pnext
= &next
->next
;
1480 /* Implement the main part of the "current_sos" target_so_ops
1483 static struct so_list
*
1484 svr4_current_sos_1 (svr4_info
*info
)
1486 so_list
*sos
= nullptr;
1488 /* If we're using the probes interface, we can use the cache as it will
1489 be maintained by probe update/reload actions. */
1490 if (info
->probes_table
!= nullptr)
1491 sos
= svr4_collect_probes_sos (info
);
1493 /* If we're not using the probes interface or if we didn't cache
1494 anything, read the sos to fill the cache, then collect them from the
1498 svr4_current_sos_direct (info
);
1500 sos
= svr4_collect_probes_sos (info
);
1502 sos
= svr4_default_sos (info
);
1508 /* Implement the "current_sos" target_so_ops method. */
1510 static struct so_list
*
1511 svr4_current_sos (void)
1513 svr4_info
*info
= get_svr4_info (current_program_space
);
1514 struct so_list
*so_head
= svr4_current_sos_1 (info
);
1515 struct mem_range vsyscall_range
;
1517 /* Filter out the vDSO module, if present. Its symbol file would
1518 not be found on disk. The vDSO/vsyscall's OBJFILE is instead
1519 managed by symfile-mem.c:add_vsyscall_page. */
1520 if (gdbarch_vsyscall_range (target_gdbarch (), &vsyscall_range
)
1521 && vsyscall_range
.length
!= 0)
1523 struct so_list
**sop
;
1526 while (*sop
!= NULL
)
1528 struct so_list
*so
= *sop
;
1530 /* We can't simply match the vDSO by starting address alone,
1531 because lm_info->l_addr_inferior (and also l_addr) do not
1532 necessarily represent the real starting address of the
1533 ELF if the vDSO's ELF itself is "prelinked". The l_ld
1534 field (the ".dynamic" section of the shared object)
1535 always points at the absolute/resolved address though.
1536 So check whether that address is inside the vDSO's
1539 E.g., on Linux 3.16 (x86_64) the vDSO is a regular
1540 0-based ELF, and we see:
1543 33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffb000
1544 (gdb) p/x *_r_debug.r_map.l_next
1545 $1 = {l_addr = 0x7ffff7ffb000, ..., l_ld = 0x7ffff7ffb318, ...}
1547 And on Linux 2.6.32 (x86_64) we see:
1550 33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffe000
1551 (gdb) p/x *_r_debug.r_map.l_next
1552 $5 = {l_addr = 0x7ffff88fe000, ..., l_ld = 0x7ffff7ffe580, ... }
1554 Dumping that vDSO shows:
1556 (gdb) info proc mappings
1557 0x7ffff7ffe000 0x7ffff7fff000 0x1000 0 [vdso]
1558 (gdb) dump memory vdso.bin 0x7ffff7ffe000 0x7ffff7fff000
1559 # readelf -Wa vdso.bin
1561 Entry point address: 0xffffffffff700700
1564 [Nr] Name Type Address Off Size
1565 [ 0] NULL 0000000000000000 000000 000000
1566 [ 1] .hash HASH ffffffffff700120 000120 000038
1567 [ 2] .dynsym DYNSYM ffffffffff700158 000158 0000d8
1569 [ 9] .dynamic DYNAMIC ffffffffff700580 000580 0000f0
1572 lm_info_svr4
*li
= (lm_info_svr4
*) so
->lm_info
;
1574 if (address_in_mem_range (li
->l_ld
, &vsyscall_range
))
1588 /* Get the address of the link_map for a given OBJFILE. */
1591 svr4_fetch_objfile_link_map (struct objfile
*objfile
)
1593 struct svr4_info
*info
= get_svr4_info (objfile
->pspace
);
1595 /* Cause svr4_current_sos() to be run if it hasn't been already. */
1596 if (info
->main_lm_addr
== 0)
1597 solib_add (NULL
, 0, auto_solib_add
);
1599 /* svr4_current_sos() will set main_lm_addr for the main executable. */
1600 if (objfile
== current_program_space
->symfile_object_file
)
1601 return info
->main_lm_addr
;
1603 /* The other link map addresses may be found by examining the list
1604 of shared libraries. */
1605 for (struct so_list
*so
: current_program_space
->solibs ())
1606 if (so
->objfile
== objfile
)
1608 lm_info_svr4
*li
= (lm_info_svr4
*) so
->lm_info
;
1617 /* On some systems, the only way to recognize the link map entry for
1618 the main executable file is by looking at its name. Return
1619 non-zero iff SONAME matches one of the known main executable names. */
1622 match_main (const char *soname
)
1624 const char * const *mainp
;
1626 for (mainp
= main_name_list
; *mainp
!= NULL
; mainp
++)
1628 if (strcmp (soname
, *mainp
) == 0)
1635 /* Return 1 if PC lies in the dynamic symbol resolution code of the
1636 SVR4 run time loader. */
1639 svr4_in_dynsym_resolve_code (CORE_ADDR pc
)
1641 struct svr4_info
*info
= get_svr4_info (current_program_space
);
1643 return ((pc
>= info
->interp_text_sect_low
1644 && pc
< info
->interp_text_sect_high
)
1645 || (pc
>= info
->interp_plt_sect_low
1646 && pc
< info
->interp_plt_sect_high
)
1647 || in_plt_section (pc
)
1648 || in_gnu_ifunc_stub (pc
));
1651 /* Given an executable's ABFD and target, compute the entry-point
1655 exec_entry_point (struct bfd
*abfd
, struct target_ops
*targ
)
1659 /* KevinB wrote ... for most targets, the address returned by
1660 bfd_get_start_address() is the entry point for the start
1661 function. But, for some targets, bfd_get_start_address() returns
1662 the address of a function descriptor from which the entry point
1663 address may be extracted. This address is extracted by
1664 gdbarch_convert_from_func_ptr_addr(). The method
1665 gdbarch_convert_from_func_ptr_addr() is the merely the identify
1666 function for targets which don't use function descriptors. */
1667 addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
1668 bfd_get_start_address (abfd
),
1670 return gdbarch_addr_bits_remove (target_gdbarch (), addr
);
1673 /* A probe and its associated action. */
1675 struct probe_and_action
1680 /* The relocated address of the probe. */
1684 enum probe_action action
;
1686 /* The objfile where this probe was found. */
1687 struct objfile
*objfile
;
1690 /* Returns a hash code for the probe_and_action referenced by p. */
1693 hash_probe_and_action (const void *p
)
1695 const struct probe_and_action
*pa
= (const struct probe_and_action
*) p
;
1697 return (hashval_t
) pa
->address
;
1700 /* Returns non-zero if the probe_and_actions referenced by p1 and p2
1704 equal_probe_and_action (const void *p1
, const void *p2
)
1706 const struct probe_and_action
*pa1
= (const struct probe_and_action
*) p1
;
1707 const struct probe_and_action
*pa2
= (const struct probe_and_action
*) p2
;
1709 return pa1
->address
== pa2
->address
;
1712 /* Traversal function for probes_table_remove_objfile_probes. */
1715 probes_table_htab_remove_objfile_probes (void **slot
, void *info
)
1717 probe_and_action
*pa
= (probe_and_action
*) *slot
;
1718 struct objfile
*objfile
= (struct objfile
*) info
;
1720 if (pa
->objfile
== objfile
)
1721 htab_clear_slot (get_svr4_info (objfile
->pspace
)->probes_table
.get (),
1727 /* Remove all probes that belong to OBJFILE from the probes table. */
1730 probes_table_remove_objfile_probes (struct objfile
*objfile
)
1732 svr4_info
*info
= get_svr4_info (objfile
->pspace
);
1733 if (info
->probes_table
!= nullptr)
1734 htab_traverse_noresize (info
->probes_table
.get (),
1735 probes_table_htab_remove_objfile_probes
, objfile
);
1738 /* Register a solib event probe and its associated action in the
1742 register_solib_event_probe (svr4_info
*info
, struct objfile
*objfile
,
1743 probe
*prob
, CORE_ADDR address
,
1744 enum probe_action action
)
1746 struct probe_and_action lookup
, *pa
;
1749 /* Create the probes table, if necessary. */
1750 if (info
->probes_table
== NULL
)
1751 info
->probes_table
.reset (htab_create_alloc (1, hash_probe_and_action
,
1752 equal_probe_and_action
,
1753 xfree
, xcalloc
, xfree
));
1755 lookup
.address
= address
;
1756 slot
= htab_find_slot (info
->probes_table
.get (), &lookup
, INSERT
);
1757 gdb_assert (*slot
== HTAB_EMPTY_ENTRY
);
1759 pa
= XCNEW (struct probe_and_action
);
1761 pa
->address
= address
;
1762 pa
->action
= action
;
1763 pa
->objfile
= objfile
;
1768 /* Get the solib event probe at the specified location, and the
1769 action associated with it. Returns NULL if no solib event probe
1772 static struct probe_and_action
*
1773 solib_event_probe_at (struct svr4_info
*info
, CORE_ADDR address
)
1775 struct probe_and_action lookup
;
1778 lookup
.address
= address
;
1779 slot
= htab_find_slot (info
->probes_table
.get (), &lookup
, NO_INSERT
);
1784 return (struct probe_and_action
*) *slot
;
1787 /* Decide what action to take when the specified solib event probe is
1790 static enum probe_action
1791 solib_event_probe_action (struct probe_and_action
*pa
)
1793 enum probe_action action
;
1794 unsigned probe_argc
= 0;
1795 frame_info_ptr frame
= get_current_frame ();
1797 action
= pa
->action
;
1798 if (action
== DO_NOTHING
|| action
== PROBES_INTERFACE_FAILED
)
1801 gdb_assert (action
== FULL_RELOAD
|| action
== UPDATE_OR_RELOAD
);
1803 /* Check that an appropriate number of arguments has been supplied.
1805 arg0: Lmid_t lmid (mandatory)
1806 arg1: struct r_debug *debug_base (mandatory)
1807 arg2: struct link_map *new (optional, for incremental updates) */
1810 probe_argc
= pa
->prob
->get_argument_count (get_frame_arch (frame
));
1812 catch (const gdb_exception_error
&ex
)
1814 exception_print (gdb_stderr
, ex
);
1818 /* If get_argument_count throws an exception, probe_argc will be set
1819 to zero. However, if pa->prob does not have arguments, then
1820 get_argument_count will succeed but probe_argc will also be zero.
1821 Both cases happen because of different things, but they are
1822 treated equally here: action will be set to
1823 PROBES_INTERFACE_FAILED. */
1824 if (probe_argc
== 2)
1825 action
= FULL_RELOAD
;
1826 else if (probe_argc
< 2)
1827 action
= PROBES_INTERFACE_FAILED
;
1832 /* Populate the shared object list by reading the entire list of
1833 shared objects from the inferior. Handle special cases relating
1834 to the first elements of the list. Returns nonzero on success. */
1837 solist_update_full (struct svr4_info
*info
)
1839 svr4_current_sos_direct (info
);
1844 /* Update the shared object list starting from the link-map entry
1845 passed by the linker in the probe's third argument. Returns
1846 nonzero if the list was successfully updated, or zero to indicate
1850 solist_update_incremental (svr4_info
*info
, CORE_ADDR debug_base
,
1853 /* Fall back to a full update if we are using a remote target
1854 that does not support incremental transfers. */
1855 if (info
->using_xfer
&& !target_augmented_libraries_svr4_read ())
1858 /* Fall back to a full update if we used the special namespace zero. We
1859 wouldn't be able to find the last item in the DEBUG_BASE namespace
1860 and hence get the prev link wrong. */
1861 if (info
->solib_lists
.find (0) != info
->solib_lists
.end ())
1864 /* Ensure that the element is actually initialized. */
1865 if (info
->solib_lists
.find (debug_base
) == info
->solib_lists
.end ())
1866 info
->solib_lists
[debug_base
] = nullptr;
1868 so_list
**psolist
= &info
->solib_lists
[debug_base
];
1869 so_list
**pnext
= nullptr;
1870 so_list
*solist
= *psolist
;
1873 if (solist
== nullptr)
1875 /* svr4_current_sos_direct contains logic to handle a number of
1876 special cases relating to the first elements of the list in
1877 default namespace. To avoid duplicating this logic we defer to
1878 solist_update_full in this case. */
1879 if (svr4_is_default_namespace (info
, debug_base
))
1887 /* Walk to the end of the list. */
1888 for (; solist
->next
!= nullptr; solist
= solist
->next
)
1891 lm_info_svr4
*li
= (lm_info_svr4
*) solist
->lm_info
;
1892 prev_lm
= li
->lm_addr
;
1893 pnext
= &solist
->next
;
1896 /* Read the new objects. */
1897 if (info
->using_xfer
)
1899 struct svr4_library_list library_list
;
1902 /* Unknown key=value pairs are ignored by the gdbstub. */
1903 xsnprintf (annex
, sizeof (annex
), "lmid=%s;start=%s;prev=%s",
1904 phex_nz (debug_base
, sizeof (debug_base
)),
1905 phex_nz (lm
, sizeof (lm
)),
1906 phex_nz (prev_lm
, sizeof (prev_lm
)));
1907 if (!svr4_current_sos_via_xfer_libraries (&library_list
, annex
))
1910 /* Get the so list from the target. We replace the list in the
1911 target response so we can easily check that the response only
1912 covers one namespace.
1914 We expect gdbserver to provide updates for the namespace that
1915 contains LM, which whould be this namespace... */
1916 so_list
*sos
= nullptr;
1917 if (library_list
.solib_lists
.find (debug_base
)
1918 != library_list
.solib_lists
.end ())
1919 std::swap (sos
, library_list
.solib_lists
[debug_base
]);
1922 /* ...or for the special zero namespace for earlier versions... */
1923 if (library_list
.solib_lists
.find (0)
1924 != library_list
.solib_lists
.end ())
1925 std::swap (sos
, library_list
.solib_lists
[0]);
1928 /* ...but nothing else. */
1929 for (const std::pair
<CORE_ADDR
, so_list
*> tuple
1930 : library_list
.solib_lists
)
1931 gdb_assert (tuple
.second
== nullptr);
1937 /* IGNORE_FIRST may safely be set to zero here because the
1938 above check and deferral to solist_update_full ensures
1939 that this call to svr4_read_so_list will never see the
1941 if (!svr4_read_so_list (info
, lm
, prev_lm
, &pnext
, 0))
1948 /* Disable the probes-based linker interface and revert to the
1949 original interface. We don't reset the breakpoints as the
1950 ones set up for the probes-based interface are adequate. */
1953 disable_probes_interface (svr4_info
*info
)
1955 warning (_("Probes-based dynamic linker interface failed.\n"
1956 "Reverting to original interface."));
1958 free_probes_table (info
);
1959 free_solib_lists (info
);
1962 /* Update the solib list as appropriate when using the
1963 probes-based linker interface. Do nothing if using the
1964 standard interface. */
1967 svr4_handle_solib_event (void)
1969 struct svr4_info
*info
= get_svr4_info (current_program_space
);
1970 struct probe_and_action
*pa
;
1971 enum probe_action action
;
1972 struct value
*val
= NULL
;
1973 CORE_ADDR pc
, debug_base
, lm
= 0;
1974 frame_info_ptr frame
= get_current_frame ();
1976 /* Do nothing if not using the probes interface. */
1977 if (info
->probes_table
== NULL
)
1980 pc
= regcache_read_pc (get_current_regcache ());
1981 pa
= solib_event_probe_at (info
, pc
);
1984 /* When some solib ops sits above us, it can respond to a solib event
1985 by calling in here. This is done assuming that if the current event
1986 is not an SVR4 solib event, calling here should be a no-op. */
1990 /* If anything goes wrong we revert to the original linker
1992 auto cleanup
= make_scope_exit ([info
] ()
1994 disable_probes_interface (info
);
1997 action
= solib_event_probe_action (pa
);
1998 if (action
== PROBES_INTERFACE_FAILED
)
2001 if (action
== DO_NOTHING
)
2007 /* evaluate_argument looks up symbols in the dynamic linker
2008 using find_pc_section. find_pc_section is accelerated by a cache
2009 called the section map. The section map is invalidated every
2010 time a shared library is loaded or unloaded, and if the inferior
2011 is generating a lot of shared library events then the section map
2012 will be updated every time svr4_handle_solib_event is called.
2013 We called find_pc_section in svr4_create_solib_event_breakpoints,
2014 so we can guarantee that the dynamic linker's sections are in the
2015 section map. We can therefore inhibit section map updates across
2016 these calls to evaluate_argument and save a lot of time. */
2018 scoped_restore inhibit_updates
2019 = inhibit_section_map_updates (current_program_space
);
2023 val
= pa
->prob
->evaluate_argument (1, frame
);
2025 catch (const gdb_exception_error
&ex
)
2027 exception_print (gdb_stderr
, ex
);
2034 debug_base
= value_as_address (val
);
2035 if (debug_base
== 0)
2038 /* If the global _r_debug object moved, we need to reload everything
2039 since we cannot identify namespaces (by the location of their
2040 r_debug_ext object) anymore. */
2041 CORE_ADDR global_debug_base
= elf_locate_base ();
2042 if (global_debug_base
!= info
->debug_base
)
2044 info
->debug_base
= global_debug_base
;
2045 action
= FULL_RELOAD
;
2048 if (info
->debug_base
== 0)
2050 /* It's possible for the reloc_complete probe to be triggered before
2051 the linker has set the DT_DEBUG pointer (for example, when the
2052 linker has finished relocating an LD_AUDIT library or its
2053 dependencies). Since we can't yet handle libraries from other link
2054 namespaces, we don't lose anything by ignoring them here. */
2055 struct value
*link_map_id_val
;
2058 link_map_id_val
= pa
->prob
->evaluate_argument (0, frame
);
2060 catch (const gdb_exception_error
)
2062 link_map_id_val
= NULL
;
2064 /* glibc and illumos' libc both define LM_ID_BASE as zero. */
2065 if (link_map_id_val
!= NULL
&& value_as_long (link_map_id_val
) != 0)
2066 action
= DO_NOTHING
;
2071 if (action
== UPDATE_OR_RELOAD
)
2075 val
= pa
->prob
->evaluate_argument (2, frame
);
2077 catch (const gdb_exception_error
&ex
)
2079 exception_print (gdb_stderr
, ex
);
2084 lm
= value_as_address (val
);
2087 action
= FULL_RELOAD
;
2090 /* Resume section map updates. Closing the scope is
2094 if (action
== UPDATE_OR_RELOAD
)
2096 if (!solist_update_incremental (info
, debug_base
, lm
))
2097 action
= FULL_RELOAD
;
2100 if (action
== FULL_RELOAD
)
2102 if (!solist_update_full (info
))
2109 /* Helper function for svr4_update_solib_event_breakpoints. */
2112 svr4_update_solib_event_breakpoint (struct breakpoint
*b
)
2114 if (b
->type
!= bp_shlib_event
)
2116 /* Continue iterating. */
2120 for (bp_location
*loc
: b
->locations ())
2122 struct svr4_info
*info
;
2123 struct probe_and_action
*pa
;
2125 info
= solib_svr4_pspace_data
.get (loc
->pspace
);
2126 if (info
== NULL
|| info
->probes_table
== NULL
)
2129 pa
= solib_event_probe_at (info
, loc
->address
);
2133 if (pa
->action
== DO_NOTHING
)
2135 if (b
->enable_state
== bp_disabled
&& stop_on_solib_events
)
2136 enable_breakpoint (b
);
2137 else if (b
->enable_state
== bp_enabled
&& !stop_on_solib_events
)
2138 disable_breakpoint (b
);
2144 /* Continue iterating. */
2148 /* Enable or disable optional solib event breakpoints as appropriate.
2149 Called whenever stop_on_solib_events is changed. */
2152 svr4_update_solib_event_breakpoints (void)
2154 for (breakpoint
*bp
: all_breakpoints_safe ())
2155 svr4_update_solib_event_breakpoint (bp
);
2158 /* Create and register solib event breakpoints. PROBES is an array
2159 of NUM_PROBES elements, each of which is vector of probes. A
2160 solib event breakpoint will be created and registered for each
2164 svr4_create_probe_breakpoints (svr4_info
*info
, struct gdbarch
*gdbarch
,
2165 const std::vector
<probe
*> *probes
,
2166 struct objfile
*objfile
)
2168 for (int i
= 0; i
< NUM_PROBES
; i
++)
2170 enum probe_action action
= probe_info
[i
].action
;
2172 for (probe
*p
: probes
[i
])
2174 CORE_ADDR address
= p
->get_relocated_address (objfile
);
2176 solib_debug_printf ("name=%s, addr=%s", probe_info
[i
].name
,
2177 paddress (gdbarch
, address
));
2179 create_solib_event_breakpoint (gdbarch
, address
);
2180 register_solib_event_probe (info
, objfile
, p
, address
, action
);
2184 svr4_update_solib_event_breakpoints ();
2187 /* Find all the glibc named probes. Only if all of the probes are found, then
2188 create them and return true. Otherwise return false. If WITH_PREFIX is set
2189 then add "rtld" to the front of the probe names. */
2191 svr4_find_and_create_probe_breakpoints (svr4_info
*info
,
2192 struct gdbarch
*gdbarch
,
2193 struct obj_section
*os
,
2196 SOLIB_SCOPED_DEBUG_START_END ("objfile=%s, with_prefix=%d",
2197 os
->objfile
->original_name
, with_prefix
);
2199 std::vector
<probe
*> probes
[NUM_PROBES
];
2201 for (int i
= 0; i
< NUM_PROBES
; i
++)
2203 const char *name
= probe_info
[i
].name
;
2206 /* Fedora 17 and Red Hat Enterprise Linux 6.2-6.4 shipped with an early
2207 version of the probes code in which the probes' names were prefixed
2208 with "rtld_" and the "map_failed" probe did not exist. The locations
2209 of the probes are otherwise the same, so we check for probes with
2210 prefixed names if probes with unprefixed names are not present. */
2213 xsnprintf (buf
, sizeof (buf
), "rtld_%s", name
);
2217 probes
[i
] = find_probes_in_objfile (os
->objfile
, "rtld", name
);
2218 solib_debug_printf ("probe=%s, num found=%zu", name
, probes
[i
].size ());
2220 /* Ensure at least one probe for the current name was found. */
2221 if (probes
[i
].empty ())
2223 /* The "map_failed" probe did not exist in early versions of the
2224 probes code in which the probes' names were prefixed with
2227 Additionally, the "map_failed" probe was accidentally removed
2228 from glibc 2.35 and 2.36, when changes in glibc meant the
2229 probe could no longer be reached, and the compiler optimized
2230 the probe away. In this case the probe name doesn't have the
2233 To handle this, and give GDB as much flexibility as possible,
2234 we make the rule that, if a probe isn't required for the
2235 correct operation of GDB (i.e. its action is DO_NOTHING), then
2236 we will still use the probes interface, even if that probe is
2239 The only (possible) downside of this is that, if the user has
2240 'set stop-on-solib-events on' in effect, then they might get
2241 fewer events using the probes interface than with the classic
2242 non-probes interface. */
2243 if (probe_info
[i
].action
== DO_NOTHING
)
2249 /* Ensure probe arguments can be evaluated. */
2250 for (probe
*p
: probes
[i
])
2252 if (!p
->can_evaluate_arguments ())
2254 /* This will fail if the probe is invalid. This has been seen on Arm
2255 due to references to symbols that have been resolved away. */
2258 p
->get_argument_count (gdbarch
);
2260 catch (const gdb_exception_error
&ex
)
2262 exception_print (gdb_stderr
, ex
);
2263 warning (_("Initializing probes-based dynamic linker interface "
2264 "failed.\nReverting to original interface."));
2270 /* All probes found. Now create them. */
2271 solib_debug_printf ("using probes interface");
2272 svr4_create_probe_breakpoints (info
, gdbarch
, probes
, os
->objfile
);
2276 /* Both the SunOS and the SVR4 dynamic linkers call a marker function
2277 before and after mapping and unmapping shared libraries. The sole
2278 purpose of this method is to allow debuggers to set a breakpoint so
2279 they can track these changes.
2281 Some versions of the glibc dynamic linker contain named probes
2282 to allow more fine grained stopping. Given the address of the
2283 original marker function, this function attempts to find these
2284 probes, and if found, sets breakpoints on those instead. If the
2285 probes aren't found, a single breakpoint is set on the original
2289 svr4_create_solib_event_breakpoints (svr4_info
*info
, struct gdbarch
*gdbarch
,
2292 struct obj_section
*os
= find_pc_section (address
);
2295 || (!svr4_find_and_create_probe_breakpoints (info
, gdbarch
, os
, false)
2296 && !svr4_find_and_create_probe_breakpoints (info
, gdbarch
, os
, true)))
2298 solib_debug_printf ("falling back to r_brk breakpoint: addr=%s",
2299 paddress (gdbarch
, address
));
2300 create_solib_event_breakpoint (gdbarch
, address
);
2304 /* Helper function for gdb_bfd_lookup_symbol. */
2307 cmp_name_and_sec_flags (const asymbol
*sym
, const void *data
)
2309 return (strcmp (sym
->name
, (const char *) data
) == 0
2310 && (sym
->section
->flags
& (SEC_CODE
| SEC_DATA
)) != 0);
2312 /* Arrange for dynamic linker to hit breakpoint.
2314 Both the SunOS and the SVR4 dynamic linkers have, as part of their
2315 debugger interface, support for arranging for the inferior to hit
2316 a breakpoint after mapping in the shared libraries. This function
2317 enables that breakpoint.
2319 For SunOS, there is a special flag location (in_debugger) which we
2320 set to 1. When the dynamic linker sees this flag set, it will set
2321 a breakpoint at a location known only to itself, after saving the
2322 original contents of that place and the breakpoint address itself,
2323 in it's own internal structures. When we resume the inferior, it
2324 will eventually take a SIGTRAP when it runs into the breakpoint.
2325 We handle this (in a different place) by restoring the contents of
2326 the breakpointed location (which is only known after it stops),
2327 chasing around to locate the shared libraries that have been
2328 loaded, then resuming.
2330 For SVR4, the debugger interface structure contains a member (r_brk)
2331 which is statically initialized at the time the shared library is
2332 built, to the offset of a function (_r_debug_state) which is guaran-
2333 teed to be called once before mapping in a library, and again when
2334 the mapping is complete. At the time we are examining this member,
2335 it contains only the unrelocated offset of the function, so we have
2336 to do our own relocation. Later, when the dynamic linker actually
2337 runs, it relocates r_brk to be the actual address of _r_debug_state().
2339 The debugger interface structure also contains an enumeration which
2340 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
2341 depending upon whether or not the library is being mapped or unmapped,
2342 and then set to RT_CONSISTENT after the library is mapped/unmapped. */
2345 enable_break (struct svr4_info
*info
, int from_tty
)
2347 struct bound_minimal_symbol msymbol
;
2348 const char * const *bkpt_namep
;
2349 asection
*interp_sect
;
2352 info
->interp_text_sect_low
= info
->interp_text_sect_high
= 0;
2353 info
->interp_plt_sect_low
= info
->interp_plt_sect_high
= 0;
2355 /* If we already have a shared library list in the target, and
2356 r_debug contains r_brk, set the breakpoint there - this should
2357 mean r_brk has already been relocated. Assume the dynamic linker
2358 is the object containing r_brk. */
2360 solib_add (NULL
, from_tty
, auto_solib_add
);
2362 if (info
->debug_base
&& solib_svr4_r_map (info
->debug_base
) != 0)
2363 sym_addr
= solib_svr4_r_brk (info
);
2367 struct obj_section
*os
;
2369 sym_addr
= gdbarch_addr_bits_remove
2371 gdbarch_convert_from_func_ptr_addr
2372 (target_gdbarch (), sym_addr
, 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 (info
, target_gdbarch (), sym_addr
);
2426 /* Find the program interpreter; if not found, warn the user and drop
2427 into the old breakpoint at symbol code. */
2428 gdb::optional
<gdb::byte_vector
> interp_name_holder
2429 = find_program_interpreter ();
2430 if (interp_name_holder
)
2432 const char *interp_name
= (const char *) interp_name_holder
->data ();
2433 CORE_ADDR load_addr
= 0;
2434 int load_addr_found
= 0;
2435 int loader_found_in_list
= 0;
2436 struct target_ops
*tmp_bfd_target
;
2440 /* Now we need to figure out where the dynamic linker was
2441 loaded so that we can load its symbols and place a breakpoint
2442 in the dynamic linker itself.
2444 This address is stored on the stack. However, I've been unable
2445 to find any magic formula to find it for Solaris (appears to
2446 be trivial on GNU/Linux). Therefore, we have to try an alternate
2447 mechanism to find the dynamic linker's base address. */
2449 gdb_bfd_ref_ptr tmp_bfd
;
2452 tmp_bfd
= solib_bfd_open (interp_name
);
2454 catch (const gdb_exception
&ex
)
2458 if (tmp_bfd
== NULL
)
2459 goto bkpt_at_symbol
;
2461 /* Now convert the TMP_BFD into a target. That way target, as
2462 well as BFD operations can be used. */
2463 tmp_bfd_target
= target_bfd_reopen (tmp_bfd
);
2465 /* On a running target, we can get the dynamic linker's base
2466 address from the shared library table. */
2467 for (struct so_list
*so
: current_program_space
->solibs ())
2469 if (svr4_same_1 (interp_name
, so
->so_original_name
))
2471 load_addr_found
= 1;
2472 loader_found_in_list
= 1;
2473 load_addr
= lm_addr_check (so
, tmp_bfd
.get ());
2478 /* If we were not able to find the base address of the loader
2479 from our so_list, then try using the AT_BASE auxilliary entry. */
2480 if (!load_addr_found
)
2481 if (target_auxv_search (AT_BASE
, &load_addr
) > 0)
2483 int addr_bit
= gdbarch_addr_bit (target_gdbarch ());
2485 /* Ensure LOAD_ADDR has proper sign in its possible upper bits so
2486 that `+ load_addr' will overflow CORE_ADDR width not creating
2487 invalid addresses like 0x101234567 for 32bit inferiors on 64bit
2490 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2492 CORE_ADDR space_size
= (CORE_ADDR
) 1 << addr_bit
;
2493 CORE_ADDR tmp_entry_point
= exec_entry_point (tmp_bfd
.get (),
2496 gdb_assert (load_addr
< space_size
);
2498 /* TMP_ENTRY_POINT exceeding SPACE_SIZE would be for prelinked
2499 64bit ld.so with 32bit executable, it should not happen. */
2501 if (tmp_entry_point
< space_size
2502 && tmp_entry_point
+ load_addr
>= space_size
)
2503 load_addr
-= space_size
;
2506 load_addr_found
= 1;
2509 /* Otherwise we find the dynamic linker's base address by examining
2510 the current pc (which should point at the entry point for the
2511 dynamic linker) and subtracting the offset of the entry point.
2513 This is more fragile than the previous approaches, but is a good
2514 fallback method because it has actually been working well in
2516 if (!load_addr_found
)
2518 struct regcache
*regcache
2519 = get_thread_arch_regcache (current_inferior ()->process_target (),
2520 inferior_ptid
, target_gdbarch ());
2522 load_addr
= (regcache_read_pc (regcache
)
2523 - exec_entry_point (tmp_bfd
.get (), tmp_bfd_target
));
2526 if (!loader_found_in_list
)
2528 info
->debug_loader_name
= xstrdup (interp_name
);
2529 info
->debug_loader_offset_p
= 1;
2530 info
->debug_loader_offset
= load_addr
;
2531 solib_add (NULL
, from_tty
, auto_solib_add
);
2534 /* Record the relocated start and end address of the dynamic linker
2535 text and plt section for svr4_in_dynsym_resolve_code. */
2536 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".text");
2539 info
->interp_text_sect_low
2540 = bfd_section_vma (interp_sect
) + load_addr
;
2541 info
->interp_text_sect_high
2542 = info
->interp_text_sect_low
+ bfd_section_size (interp_sect
);
2544 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".plt");
2547 info
->interp_plt_sect_low
2548 = bfd_section_vma (interp_sect
) + load_addr
;
2549 info
->interp_plt_sect_high
2550 = info
->interp_plt_sect_low
+ bfd_section_size (interp_sect
);
2553 /* Now try to set a breakpoint in the dynamic linker. */
2554 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2556 sym_addr
= gdb_bfd_lookup_symbol (tmp_bfd
.get (),
2557 cmp_name_and_sec_flags
,
2564 /* Convert 'sym_addr' from a function pointer to an address.
2565 Because we pass tmp_bfd_target instead of the current
2566 target, this will always produce an unrelocated value. */
2567 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2571 /* We're done with both the temporary bfd and target. Closing
2572 the target closes the underlying bfd, because it holds the
2573 only remaining reference. */
2574 target_close (tmp_bfd_target
);
2578 svr4_create_solib_event_breakpoints (info
, target_gdbarch (),
2579 load_addr
+ sym_addr
);
2583 /* For whatever reason we couldn't set a breakpoint in the dynamic
2584 linker. Warn and drop into the old code. */
2586 warning (_("Unable to find dynamic linker breakpoint function.\n"
2587 "GDB will be unable to debug shared library initializers\n"
2588 "and track explicitly loaded dynamic code."));
2591 /* Scan through the lists of symbols, trying to look up the symbol and
2592 set a breakpoint there. Terminate loop when we/if we succeed. */
2594 objfile
*objf
= current_program_space
->symfile_object_file
;
2595 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2597 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, objf
);
2598 if ((msymbol
.minsym
!= NULL
)
2599 && (msymbol
.value_address () != 0))
2601 sym_addr
= msymbol
.value_address ();
2602 sym_addr
= gdbarch_convert_from_func_ptr_addr
2603 (target_gdbarch (), sym_addr
, current_inferior ()->top_target ());
2604 svr4_create_solib_event_breakpoints (info
, target_gdbarch (),
2610 if (interp_name_holder
&& !current_inferior ()->attach_flag
)
2612 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2614 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, objf
);
2615 if ((msymbol
.minsym
!= NULL
)
2616 && (msymbol
.value_address () != 0))
2618 sym_addr
= msymbol
.value_address ();
2619 sym_addr
= gdbarch_convert_from_func_ptr_addr
2620 (target_gdbarch (), sym_addr
,
2621 current_inferior ()->top_target ());
2622 svr4_create_solib_event_breakpoints (info
, target_gdbarch (),
2631 /* Read the ELF program headers from ABFD. */
2633 static gdb::optional
<gdb::byte_vector
>
2634 read_program_headers_from_bfd (bfd
*abfd
)
2636 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
2637 int phdrs_size
= ehdr
->e_phnum
* ehdr
->e_phentsize
;
2638 if (phdrs_size
== 0)
2641 gdb::byte_vector
buf (phdrs_size
);
2642 if (bfd_seek (abfd
, ehdr
->e_phoff
, SEEK_SET
) != 0
2643 || bfd_bread (buf
.data (), phdrs_size
, abfd
) != phdrs_size
)
2649 /* Return 1 and fill *DISPLACEMENTP with detected PIE offset of inferior
2650 exec_bfd. Otherwise return 0.
2652 We relocate all of the sections by the same amount. This
2653 behavior is mandated by recent editions of the System V ABI.
2654 According to the System V Application Binary Interface,
2655 Edition 4.1, page 5-5:
2657 ... Though the system chooses virtual addresses for
2658 individual processes, it maintains the segments' relative
2659 positions. Because position-independent code uses relative
2660 addressing between segments, the difference between
2661 virtual addresses in memory must match the difference
2662 between virtual addresses in the file. The difference
2663 between the virtual address of any segment in memory and
2664 the corresponding virtual address in the file is thus a
2665 single constant value for any one executable or shared
2666 object in a given process. This difference is the base
2667 address. One use of the base address is to relocate the
2668 memory image of the program during dynamic linking.
2670 The same language also appears in Edition 4.0 of the System V
2671 ABI and is left unspecified in some of the earlier editions.
2673 Decide if the objfile needs to be relocated. As indicated above, we will
2674 only be here when execution is stopped. But during attachment PC can be at
2675 arbitrary address therefore regcache_read_pc can be misleading (contrary to
2676 the auxv AT_ENTRY value). Moreover for executable with interpreter section
2677 regcache_read_pc would point to the interpreter and not the main executable.
2679 So, to summarize, relocations are necessary when the start address obtained
2680 from the executable is different from the address in auxv AT_ENTRY entry.
2682 [ The astute reader will note that we also test to make sure that
2683 the executable in question has the DYNAMIC flag set. It is my
2684 opinion that this test is unnecessary (undesirable even). It
2685 was added to avoid inadvertent relocation of an executable
2686 whose e_type member in the ELF header is not ET_DYN. There may
2687 be a time in the future when it is desirable to do relocations
2688 on other types of files as well in which case this condition
2689 should either be removed or modified to accomodate the new file
2690 type. - Kevin, Nov 2000. ] */
2693 svr4_exec_displacement (CORE_ADDR
*displacementp
)
2695 /* ENTRY_POINT is a possible function descriptor - before
2696 a call to gdbarch_convert_from_func_ptr_addr. */
2697 CORE_ADDR entry_point
, exec_displacement
;
2699 if (current_program_space
->exec_bfd () == NULL
)
2702 /* Therefore for ELF it is ET_EXEC and not ET_DYN. Both shared libraries
2703 being executed themselves and PIE (Position Independent Executable)
2704 executables are ET_DYN. */
2706 if ((bfd_get_file_flags (current_program_space
->exec_bfd ()) & DYNAMIC
) == 0)
2709 if (target_auxv_search (AT_ENTRY
, &entry_point
) <= 0)
2713 = entry_point
- bfd_get_start_address (current_program_space
->exec_bfd ());
2715 /* Verify the EXEC_DISPLACEMENT candidate complies with the required page
2716 alignment. It is cheaper than the program headers comparison below. */
2718 if (bfd_get_flavour (current_program_space
->exec_bfd ())
2719 == bfd_target_elf_flavour
)
2721 const struct elf_backend_data
*elf
2722 = get_elf_backend_data (current_program_space
->exec_bfd ());
2724 /* p_align of PT_LOAD segments does not specify any alignment but
2725 only congruency of addresses:
2726 p_offset % p_align == p_vaddr % p_align
2727 Kernel is free to load the executable with lower alignment. */
2729 if ((exec_displacement
& (elf
->minpagesize
- 1)) != 0)
2733 /* Verify that the auxilliary vector describes the same file as exec_bfd, by
2734 comparing their program headers. If the program headers in the auxilliary
2735 vector do not match the program headers in the executable, then we are
2736 looking at a different file than the one used by the kernel - for
2737 instance, "gdb program" connected to "gdbserver :PORT ld.so program". */
2739 if (bfd_get_flavour (current_program_space
->exec_bfd ())
2740 == bfd_target_elf_flavour
)
2742 /* Be optimistic and return 0 only if GDB was able to verify the headers
2743 really do not match. */
2746 gdb::optional
<gdb::byte_vector
> phdrs_target
2747 = read_program_header (-1, &arch_size
, NULL
);
2748 gdb::optional
<gdb::byte_vector
> phdrs_binary
2749 = read_program_headers_from_bfd (current_program_space
->exec_bfd ());
2750 if (phdrs_target
&& phdrs_binary
)
2752 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
2754 /* We are dealing with three different addresses. EXEC_BFD
2755 represents current address in on-disk file. target memory content
2756 may be different from EXEC_BFD as the file may have been prelinked
2757 to a different address after the executable has been loaded.
2758 Moreover the address of placement in target memory can be
2759 different from what the program headers in target memory say -
2760 this is the goal of PIE.
2762 Detected DISPLACEMENT covers both the offsets of PIE placement and
2763 possible new prelink performed after start of the program. Here
2764 relocate BUF and BUF2 just by the EXEC_BFD vs. target memory
2765 content offset for the verification purpose. */
2767 if (phdrs_target
->size () != phdrs_binary
->size ()
2768 || bfd_get_arch_size (current_program_space
->exec_bfd ()) != arch_size
)
2770 else if (arch_size
== 32
2771 && phdrs_target
->size () >= sizeof (Elf32_External_Phdr
)
2772 && phdrs_target
->size () % sizeof (Elf32_External_Phdr
) == 0)
2774 Elf_Internal_Ehdr
*ehdr2
2775 = elf_tdata (current_program_space
->exec_bfd ())->elf_header
;
2776 Elf_Internal_Phdr
*phdr2
2777 = elf_tdata (current_program_space
->exec_bfd ())->phdr
;
2778 CORE_ADDR displacement
= 0;
2781 /* DISPLACEMENT could be found more easily by the difference of
2782 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2783 already have enough information to compute that displacement
2784 with what we've read. */
2786 for (i
= 0; i
< ehdr2
->e_phnum
; i
++)
2787 if (phdr2
[i
].p_type
== PT_LOAD
)
2789 Elf32_External_Phdr
*phdrp
;
2790 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2791 CORE_ADDR vaddr
, paddr
;
2792 CORE_ADDR displacement_vaddr
= 0;
2793 CORE_ADDR displacement_paddr
= 0;
2795 phdrp
= &((Elf32_External_Phdr
*) phdrs_target
->data ())[i
];
2796 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2797 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2799 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 4,
2801 displacement_vaddr
= vaddr
- phdr2
[i
].p_vaddr
;
2803 paddr
= extract_unsigned_integer (buf_paddr_p
, 4,
2805 displacement_paddr
= paddr
- phdr2
[i
].p_paddr
;
2807 if (displacement_vaddr
== displacement_paddr
)
2808 displacement
= displacement_vaddr
;
2813 /* Now compare program headers from the target and the binary
2814 with optional DISPLACEMENT. */
2817 i
< phdrs_target
->size () / sizeof (Elf32_External_Phdr
);
2820 Elf32_External_Phdr
*phdrp
;
2821 Elf32_External_Phdr
*phdr2p
;
2822 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2823 CORE_ADDR vaddr
, paddr
;
2824 asection
*plt2_asect
;
2826 phdrp
= &((Elf32_External_Phdr
*) phdrs_target
->data ())[i
];
2827 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2828 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2829 phdr2p
= &((Elf32_External_Phdr
*) phdrs_binary
->data ())[i
];
2831 /* PT_GNU_STACK is an exception by being never relocated by
2832 prelink as its addresses are always zero. */
2834 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2837 /* Check also other adjustment combinations - PR 11786. */
2839 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 4,
2841 vaddr
-= displacement
;
2842 store_unsigned_integer (buf_vaddr_p
, 4, byte_order
, vaddr
);
2844 paddr
= extract_unsigned_integer (buf_paddr_p
, 4,
2846 paddr
-= displacement
;
2847 store_unsigned_integer (buf_paddr_p
, 4, byte_order
, paddr
);
2849 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2852 /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2853 CentOS-5 has problems with filesz, memsz as well.
2854 Strip also modifies memsz of PT_TLS.
2856 if (phdr2
[i
].p_type
== PT_GNU_RELRO
2857 || phdr2
[i
].p_type
== PT_TLS
)
2859 Elf32_External_Phdr tmp_phdr
= *phdrp
;
2860 Elf32_External_Phdr tmp_phdr2
= *phdr2p
;
2862 memset (tmp_phdr
.p_filesz
, 0, 4);
2863 memset (tmp_phdr
.p_memsz
, 0, 4);
2864 memset (tmp_phdr
.p_flags
, 0, 4);
2865 memset (tmp_phdr
.p_align
, 0, 4);
2866 memset (tmp_phdr2
.p_filesz
, 0, 4);
2867 memset (tmp_phdr2
.p_memsz
, 0, 4);
2868 memset (tmp_phdr2
.p_flags
, 0, 4);
2869 memset (tmp_phdr2
.p_align
, 0, 4);
2871 if (memcmp (&tmp_phdr
, &tmp_phdr2
, sizeof (tmp_phdr
))
2876 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2877 bfd
*exec_bfd
= current_program_space
->exec_bfd ();
2878 plt2_asect
= bfd_get_section_by_name (exec_bfd
, ".plt");
2882 gdb_byte
*buf_filesz_p
= (gdb_byte
*) &phdrp
->p_filesz
;
2885 content2
= (bfd_section_flags (plt2_asect
)
2886 & SEC_HAS_CONTENTS
) != 0;
2888 filesz
= extract_unsigned_integer (buf_filesz_p
, 4,
2891 /* PLT2_ASECT is from on-disk file (exec_bfd) while
2892 FILESZ is from the in-memory image. */
2894 filesz
+= bfd_section_size (plt2_asect
);
2896 filesz
-= bfd_section_size (plt2_asect
);
2898 store_unsigned_integer (buf_filesz_p
, 4, byte_order
,
2901 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2908 else if (arch_size
== 64
2909 && phdrs_target
->size () >= sizeof (Elf64_External_Phdr
)
2910 && phdrs_target
->size () % sizeof (Elf64_External_Phdr
) == 0)
2912 Elf_Internal_Ehdr
*ehdr2
2913 = elf_tdata (current_program_space
->exec_bfd ())->elf_header
;
2914 Elf_Internal_Phdr
*phdr2
2915 = elf_tdata (current_program_space
->exec_bfd ())->phdr
;
2916 CORE_ADDR displacement
= 0;
2919 /* DISPLACEMENT could be found more easily by the difference of
2920 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2921 already have enough information to compute that displacement
2922 with what we've read. */
2924 for (i
= 0; i
< ehdr2
->e_phnum
; i
++)
2925 if (phdr2
[i
].p_type
== PT_LOAD
)
2927 Elf64_External_Phdr
*phdrp
;
2928 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2929 CORE_ADDR vaddr
, paddr
;
2930 CORE_ADDR displacement_vaddr
= 0;
2931 CORE_ADDR displacement_paddr
= 0;
2933 phdrp
= &((Elf64_External_Phdr
*) phdrs_target
->data ())[i
];
2934 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2935 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2937 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 8,
2939 displacement_vaddr
= vaddr
- phdr2
[i
].p_vaddr
;
2941 paddr
= extract_unsigned_integer (buf_paddr_p
, 8,
2943 displacement_paddr
= paddr
- phdr2
[i
].p_paddr
;
2945 if (displacement_vaddr
== displacement_paddr
)
2946 displacement
= displacement_vaddr
;
2951 /* Now compare BUF and BUF2 with optional DISPLACEMENT. */
2954 i
< phdrs_target
->size () / sizeof (Elf64_External_Phdr
);
2957 Elf64_External_Phdr
*phdrp
;
2958 Elf64_External_Phdr
*phdr2p
;
2959 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2960 CORE_ADDR vaddr
, paddr
;
2961 asection
*plt2_asect
;
2963 phdrp
= &((Elf64_External_Phdr
*) phdrs_target
->data ())[i
];
2964 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2965 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2966 phdr2p
= &((Elf64_External_Phdr
*) phdrs_binary
->data ())[i
];
2968 /* PT_GNU_STACK is an exception by being never relocated by
2969 prelink as its addresses are always zero. */
2971 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2974 /* Check also other adjustment combinations - PR 11786. */
2976 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 8,
2978 vaddr
-= displacement
;
2979 store_unsigned_integer (buf_vaddr_p
, 8, byte_order
, vaddr
);
2981 paddr
= extract_unsigned_integer (buf_paddr_p
, 8,
2983 paddr
-= displacement
;
2984 store_unsigned_integer (buf_paddr_p
, 8, byte_order
, paddr
);
2986 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2989 /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2990 CentOS-5 has problems with filesz, memsz as well.
2991 Strip also modifies memsz of PT_TLS.
2993 if (phdr2
[i
].p_type
== PT_GNU_RELRO
2994 || phdr2
[i
].p_type
== PT_TLS
)
2996 Elf64_External_Phdr tmp_phdr
= *phdrp
;
2997 Elf64_External_Phdr tmp_phdr2
= *phdr2p
;
2999 memset (tmp_phdr
.p_filesz
, 0, 8);
3000 memset (tmp_phdr
.p_memsz
, 0, 8);
3001 memset (tmp_phdr
.p_flags
, 0, 4);
3002 memset (tmp_phdr
.p_align
, 0, 8);
3003 memset (tmp_phdr2
.p_filesz
, 0, 8);
3004 memset (tmp_phdr2
.p_memsz
, 0, 8);
3005 memset (tmp_phdr2
.p_flags
, 0, 4);
3006 memset (tmp_phdr2
.p_align
, 0, 8);
3008 if (memcmp (&tmp_phdr
, &tmp_phdr2
, sizeof (tmp_phdr
))
3013 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
3015 = bfd_get_section_by_name (current_program_space
->exec_bfd (),
3020 gdb_byte
*buf_filesz_p
= (gdb_byte
*) &phdrp
->p_filesz
;
3023 content2
= (bfd_section_flags (plt2_asect
)
3024 & SEC_HAS_CONTENTS
) != 0;
3026 filesz
= extract_unsigned_integer (buf_filesz_p
, 8,
3029 /* PLT2_ASECT is from on-disk file (current
3030 exec_bfd) while FILESZ is from the in-memory
3033 filesz
+= bfd_section_size (plt2_asect
);
3035 filesz
-= bfd_section_size (plt2_asect
);
3037 store_unsigned_integer (buf_filesz_p
, 8, byte_order
,
3040 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
3054 /* It can be printed repeatedly as there is no easy way to check
3055 the executable symbols/file has been already relocated to
3058 gdb_printf (_("Using PIE (Position Independent Executable) "
3059 "displacement %s for \"%s\".\n"),
3060 paddress (target_gdbarch (), exec_displacement
),
3061 bfd_get_filename (current_program_space
->exec_bfd ()));
3064 *displacementp
= exec_displacement
;
3068 /* Relocate the main executable. This function should be called upon
3069 stopping the inferior process at the entry point to the program.
3070 The entry point from BFD is compared to the AT_ENTRY of AUXV and if they are
3071 different, the main executable is relocated by the proper amount. */
3074 svr4_relocate_main_executable (void)
3076 CORE_ADDR displacement
;
3078 /* If we are re-running this executable, SYMFILE_OBJFILE->SECTION_OFFSETS
3079 probably contains the offsets computed using the PIE displacement
3080 from the previous run, which of course are irrelevant for this run.
3081 So we need to determine the new PIE displacement and recompute the
3082 section offsets accordingly, even if SYMFILE_OBJFILE->SECTION_OFFSETS
3083 already contains pre-computed offsets.
3085 If we cannot compute the PIE displacement, either:
3087 - The executable is not PIE.
3089 - SYMFILE_OBJFILE does not match the executable started in the target.
3090 This can happen for main executable symbols loaded at the host while
3091 `ld.so --ld-args main-executable' is loaded in the target.
3093 Then we leave the section offsets untouched and use them as is for
3096 - These section offsets were properly reset earlier, and thus
3097 already contain the correct values. This can happen for instance
3098 when reconnecting via the remote protocol to a target that supports
3099 the `qOffsets' packet.
3101 - The section offsets were not reset earlier, and the best we can
3102 hope is that the old offsets are still applicable to the new run. */
3104 if (! svr4_exec_displacement (&displacement
))
3107 /* Even DISPLACEMENT 0 is a valid new difference of in-memory vs. in-file
3110 objfile
*objf
= current_program_space
->symfile_object_file
;
3113 section_offsets
new_offsets (objf
->section_offsets
.size (),
3115 objfile_relocate (objf
, new_offsets
);
3117 else if (current_program_space
->exec_bfd ())
3121 bfd
*exec_bfd
= current_program_space
->exec_bfd ();
3122 for (asect
= exec_bfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
3123 exec_set_section_address (bfd_get_filename (exec_bfd
), asect
->index
,
3124 bfd_section_vma (asect
) + displacement
);
3128 /* Implement the "create_inferior_hook" target_solib_ops method.
3130 For SVR4 executables, this first instruction is either the first
3131 instruction in the dynamic linker (for dynamically linked
3132 executables) or the instruction at "start" for statically linked
3133 executables. For dynamically linked executables, the system
3134 first exec's /lib/libc.so.N, which contains the dynamic linker,
3135 and starts it running. The dynamic linker maps in any needed
3136 shared libraries, maps in the actual user executable, and then
3137 jumps to "start" in the user executable.
3139 We can arrange to cooperate with the dynamic linker to discover the
3140 names of shared libraries that are dynamically linked, and the base
3141 addresses to which they are linked.
3143 This function is responsible for discovering those names and
3144 addresses, and saving sufficient information about them to allow
3145 their symbols to be read at a later time. */
3148 svr4_solib_create_inferior_hook (int from_tty
)
3150 struct svr4_info
*info
;
3152 info
= get_svr4_info (current_program_space
);
3154 /* Clear the probes-based interface's state. */
3155 free_probes_table (info
);
3156 free_solib_lists (info
);
3158 /* Relocate the main executable if necessary. */
3159 svr4_relocate_main_executable ();
3161 /* No point setting a breakpoint in the dynamic linker if we can't
3162 hit it (e.g., a core file, or a trace file). */
3163 if (!target_has_execution ())
3166 if (!svr4_have_link_map_offsets ())
3169 if (!enable_break (info
, from_tty
))
3174 svr4_clear_solib (void)
3176 struct svr4_info
*info
;
3178 info
= get_svr4_info (current_program_space
);
3179 info
->debug_base
= 0;
3180 info
->debug_loader_offset_p
= 0;
3181 info
->debug_loader_offset
= 0;
3182 xfree (info
->debug_loader_name
);
3183 info
->debug_loader_name
= NULL
;
3186 /* Clear any bits of ADDR that wouldn't fit in a target-format
3187 data pointer. "Data pointer" here refers to whatever sort of
3188 address the dynamic linker uses to manage its sections. At the
3189 moment, we don't support shared libraries on any processors where
3190 code and data pointers are different sizes.
3192 This isn't really the right solution. What we really need here is
3193 a way to do arithmetic on CORE_ADDR values that respects the
3194 natural pointer/address correspondence. (For example, on the MIPS,
3195 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
3196 sign-extend the value. There, simply truncating the bits above
3197 gdbarch_ptr_bit, as we do below, is no good.) This should probably
3198 be a new gdbarch method or something. */
3200 svr4_truncate_ptr (CORE_ADDR addr
)
3202 if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR
) * 8)
3203 /* We don't need to truncate anything, and the bit twiddling below
3204 will fail due to overflow problems. */
3207 return addr
& (((CORE_ADDR
) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
3212 svr4_relocate_section_addresses (struct so_list
*so
,
3213 struct target_section
*sec
)
3215 bfd
*abfd
= sec
->the_bfd_section
->owner
;
3217 sec
->addr
= svr4_truncate_ptr (sec
->addr
+ lm_addr_check (so
, abfd
));
3218 sec
->endaddr
= svr4_truncate_ptr (sec
->endaddr
+ lm_addr_check (so
, abfd
));
3222 /* Architecture-specific operations. */
3224 struct solib_svr4_ops
3226 /* Return a description of the layout of `struct link_map'. */
3227 struct link_map_offsets
*(*fetch_link_map_offsets
)(void) = nullptr;
3230 /* Per-architecture data key. */
3231 static const registry
<gdbarch
>::key
<struct solib_svr4_ops
> solib_svr4_data
;
3233 /* Return a default for the architecture-specific operations. */
3235 static struct solib_svr4_ops
*
3236 get_ops (struct gdbarch
*gdbarch
)
3238 struct solib_svr4_ops
*ops
= solib_svr4_data
.get (gdbarch
);
3240 ops
= solib_svr4_data
.emplace (gdbarch
);
3244 /* Set the architecture-specific `struct link_map_offsets' fetcher for
3245 GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */
3248 set_solib_svr4_fetch_link_map_offsets (struct gdbarch
*gdbarch
,
3249 struct link_map_offsets
*(*flmo
) (void))
3251 struct solib_svr4_ops
*ops
= get_ops (gdbarch
);
3253 ops
->fetch_link_map_offsets
= flmo
;
3255 set_gdbarch_so_ops (gdbarch
, &svr4_so_ops
);
3256 set_gdbarch_iterate_over_objfiles_in_search_order
3257 (gdbarch
, svr4_iterate_over_objfiles_in_search_order
);
3260 /* Fetch a link_map_offsets structure using the architecture-specific
3261 `struct link_map_offsets' fetcher. */
3263 static struct link_map_offsets
*
3264 svr4_fetch_link_map_offsets (void)
3266 struct solib_svr4_ops
*ops
= get_ops (target_gdbarch ());
3268 gdb_assert (ops
->fetch_link_map_offsets
);
3269 return ops
->fetch_link_map_offsets ();
3272 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
3275 svr4_have_link_map_offsets (void)
3277 struct solib_svr4_ops
*ops
= get_ops (target_gdbarch ());
3279 return (ops
->fetch_link_map_offsets
!= NULL
);
3283 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
3284 `struct r_debug' and a `struct link_map' that are binary compatible
3285 with the original SVR4 implementation. */
3287 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3288 for an ILP32 SVR4 system. */
3290 struct link_map_offsets
*
3291 svr4_ilp32_fetch_link_map_offsets (void)
3293 static struct link_map_offsets lmo
;
3294 static struct link_map_offsets
*lmp
= NULL
;
3300 lmo
.r_version_offset
= 0;
3301 lmo
.r_version_size
= 4;
3302 lmo
.r_map_offset
= 4;
3303 lmo
.r_brk_offset
= 8;
3304 lmo
.r_ldsomap_offset
= 20;
3305 lmo
.r_next_offset
= -1;
3307 /* Everything we need is in the first 20 bytes. */
3308 lmo
.link_map_size
= 20;
3309 lmo
.l_addr_offset
= 0;
3310 lmo
.l_name_offset
= 4;
3311 lmo
.l_ld_offset
= 8;
3312 lmo
.l_next_offset
= 12;
3313 lmo
.l_prev_offset
= 16;
3319 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3320 for an LP64 SVR4 system. */
3322 struct link_map_offsets
*
3323 svr4_lp64_fetch_link_map_offsets (void)
3325 static struct link_map_offsets lmo
;
3326 static struct link_map_offsets
*lmp
= NULL
;
3332 lmo
.r_version_offset
= 0;
3333 lmo
.r_version_size
= 4;
3334 lmo
.r_map_offset
= 8;
3335 lmo
.r_brk_offset
= 16;
3336 lmo
.r_ldsomap_offset
= 40;
3337 lmo
.r_next_offset
= -1;
3339 /* Everything we need is in the first 40 bytes. */
3340 lmo
.link_map_size
= 40;
3341 lmo
.l_addr_offset
= 0;
3342 lmo
.l_name_offset
= 8;
3343 lmo
.l_ld_offset
= 16;
3344 lmo
.l_next_offset
= 24;
3345 lmo
.l_prev_offset
= 32;
3352 /* Return the DSO matching OBJFILE or nullptr if none can be found. */
3355 find_solib_for_objfile (struct objfile
*objfile
)
3357 if (objfile
== nullptr)
3360 /* If OBJFILE is a separate debug object file, look for the original
3362 if (objfile
->separate_debug_objfile_backlink
!= nullptr)
3363 objfile
= objfile
->separate_debug_objfile_backlink
;
3365 for (so_list
*so
: current_program_space
->solibs ())
3366 if (so
->objfile
== objfile
)
3372 /* Return the address of the r_debug object for the namespace containing
3373 SOLIB or zero if it cannot be found. This may happen when symbol files
3374 are added manually, for example, or with the main executable.
3376 Current callers treat zero as initial namespace so they are doing the
3377 right thing for the main executable. */
3380 find_debug_base_for_solib (so_list
*solib
)
3382 if (solib
== nullptr)
3385 svr4_info
*info
= get_svr4_info (current_program_space
);
3386 gdb_assert (info
!= nullptr);
3387 for (const std::pair
<CORE_ADDR
, so_list
*> tuple
3388 : info
->solib_lists
)
3390 CORE_ADDR debug_base
= tuple
.first
;
3391 so_list
*solist
= tuple
.second
;
3393 for (; solist
!= nullptr; solist
= solist
->next
)
3394 if (svr4_same (solib
, solist
))
3401 /* Search order for ELF DSOs linked with -Bsymbolic. Those DSOs have a
3402 different rule for symbol lookup. The lookup begins here in the DSO,
3403 not in the main executable. When starting from CURRENT_OBJFILE, we
3404 stay in the same namespace as that file. Otherwise, we only consider
3405 the initial namespace. */
3408 svr4_iterate_over_objfiles_in_search_order
3409 (gdbarch
*gdbarch
, iterate_over_objfiles_in_search_order_cb_ftype cb
,
3410 objfile
*current_objfile
)
3412 bool checked_current_objfile
= false;
3413 if (current_objfile
!= nullptr)
3417 if (current_objfile
->separate_debug_objfile_backlink
!= nullptr)
3418 current_objfile
= current_objfile
->separate_debug_objfile_backlink
;
3420 if (current_objfile
== current_program_space
->symfile_object_file
)
3421 abfd
= current_program_space
->exec_bfd ();
3423 abfd
= current_objfile
->obfd
.get ();
3426 && gdb_bfd_scan_elf_dyntag (DT_SYMBOLIC
, abfd
, nullptr, nullptr) == 1)
3428 checked_current_objfile
= true;
3429 if (cb (current_objfile
))
3434 /* The linker namespace to iterate identified by the address of its
3435 r_debug object, defaulting to the initial namespace. */
3436 CORE_ADDR initial
= elf_locate_base ();
3437 so_list
*curr_solib
= find_solib_for_objfile (current_objfile
);
3438 CORE_ADDR debug_base
= find_debug_base_for_solib (curr_solib
);
3439 if (debug_base
== 0)
3440 debug_base
= initial
;
3442 for (objfile
*objfile
: current_program_space
->objfiles ())
3444 if (checked_current_objfile
&& objfile
== current_objfile
)
3447 /* Try to determine the namespace into which objfile was loaded.
3449 If we fail, e.g. for manually added symbol files or for the main
3450 executable, we assume that they were added to the initial
3452 so_list
*solib
= find_solib_for_objfile (objfile
);
3453 CORE_ADDR solib_base
= find_debug_base_for_solib (solib
);
3454 if (solib_base
== 0)
3455 solib_base
= initial
;
3457 /* Ignore objfiles that were added to a different namespace. */
3458 if (solib_base
!= debug_base
)
3466 const struct target_so_ops svr4_so_ops
=
3468 svr4_relocate_section_addresses
,
3472 svr4_solib_create_inferior_hook
,
3474 open_symbol_file_object
,
3475 svr4_in_dynsym_resolve_code
,
3479 svr4_keep_data_in_core
,
3480 svr4_update_solib_event_breakpoints
,
3481 svr4_handle_solib_event
,
3484 void _initialize_svr4_solib ();
3486 _initialize_svr4_solib ()
3488 gdb::observers::free_objfile
.attach (svr4_free_objfile_observer
,