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 argument to the
378 'reloc_complete' probe but we don't get it when scanning the load map
381 The r_debug[_ext] objects may move when ld.so itself moves. In that
382 case, we expect also the global _r_debug to move so we can detect
383 this and reload everything. The r_debug[_ext] objects are not
384 expected to move individually.
386 The special entry zero is reserved for a linear list to support
387 gdbstubs that do not support namespaces. */
388 std::map
<CORE_ADDR
, so_list
*> solib_lists
;
391 /* Per-program-space data key. */
392 static const registry
<program_space
>::key
<svr4_info
> solib_svr4_pspace_data
;
394 /* Return whether DEBUG_BASE is the default namespace of INFO. */
397 svr4_is_default_namespace (const svr4_info
*info
, CORE_ADDR debug_base
)
399 return (debug_base
== info
->debug_base
);
402 /* Free the probes table. */
405 free_probes_table (struct svr4_info
*info
)
407 info
->probes_table
.reset (nullptr);
410 /* Free the solib lists for all namespaces. */
413 free_solib_lists (svr4_info
*info
)
415 for (const std::pair
<CORE_ADDR
, so_list
*> tuple
417 svr4_free_library_list (tuple
.second
);
419 info
->solib_lists
.clear ();
422 svr4_info::~svr4_info ()
424 free_solib_lists (this);
427 /* Get the svr4 data for program space PSPACE. If none is found yet, add it now.
428 This function always returns a valid object. */
430 static struct svr4_info
*
431 get_svr4_info (program_space
*pspace
)
433 struct svr4_info
*info
= solib_svr4_pspace_data
.get (pspace
);
436 info
= solib_svr4_pspace_data
.emplace (pspace
);
441 /* Local function prototypes */
443 static int match_main (const char *);
445 /* Read program header TYPE from inferior memory. The header is found
446 by scanning the OS auxiliary vector.
448 If TYPE == -1, return the program headers instead of the contents of
451 Return vector of bytes holding the program header contents, or an empty
452 optional on failure. If successful and P_ARCH_SIZE is non-NULL, the target
453 architecture size (32-bit or 64-bit) is returned to *P_ARCH_SIZE. Likewise,
454 the base address of the section is returned in *BASE_ADDR. */
456 static gdb::optional
<gdb::byte_vector
>
457 read_program_header (int type
, int *p_arch_size
, CORE_ADDR
*base_addr
)
459 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 would 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 /* Arrange for dynamic linker to hit breakpoint.
2306 Both the SunOS and the SVR4 dynamic linkers have, as part of their
2307 debugger interface, support for arranging for the inferior to hit
2308 a breakpoint after mapping in the shared libraries. This function
2309 enables that breakpoint.
2311 For SunOS, there is a special flag location (in_debugger) which we
2312 set to 1. When the dynamic linker sees this flag set, it will set
2313 a breakpoint at a location known only to itself, after saving the
2314 original contents of that place and the breakpoint address itself,
2315 in its own internal structures. When we resume the inferior, it
2316 will eventually take a SIGTRAP when it runs into the breakpoint.
2317 We handle this (in a different place) by restoring the contents of
2318 the breakpointed location (which is only known after it stops),
2319 chasing around to locate the shared libraries that have been
2320 loaded, then resuming.
2322 For SVR4, the debugger interface structure contains a member (r_brk)
2323 which is statically initialized at the time the shared library is
2324 built, to the offset of a function (_r_debug_state) which is guaran-
2325 teed to be called once before mapping in a library, and again when
2326 the mapping is complete. At the time we are examining this member,
2327 it contains only the unrelocated offset of the function, so we have
2328 to do our own relocation. Later, when the dynamic linker actually
2329 runs, it relocates r_brk to be the actual address of _r_debug_state().
2331 The debugger interface structure also contains an enumeration which
2332 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
2333 depending upon whether or not the library is being mapped or unmapped,
2334 and then set to RT_CONSISTENT after the library is mapped/unmapped. */
2337 enable_break (struct svr4_info
*info
, int from_tty
)
2339 struct bound_minimal_symbol msymbol
;
2340 const char * const *bkpt_namep
;
2341 asection
*interp_sect
;
2344 info
->interp_text_sect_low
= info
->interp_text_sect_high
= 0;
2345 info
->interp_plt_sect_low
= info
->interp_plt_sect_high
= 0;
2347 /* If we already have a shared library list in the target, and
2348 r_debug contains r_brk, set the breakpoint there - this should
2349 mean r_brk has already been relocated. Assume the dynamic linker
2350 is the object containing r_brk. */
2352 solib_add (NULL
, from_tty
, auto_solib_add
);
2354 if (info
->debug_base
&& solib_svr4_r_map (info
->debug_base
) != 0)
2355 sym_addr
= solib_svr4_r_brk (info
);
2359 struct obj_section
*os
;
2361 sym_addr
= gdbarch_addr_bits_remove
2363 gdbarch_convert_from_func_ptr_addr
2364 (target_gdbarch (), sym_addr
, current_inferior ()->top_target ()));
2366 /* On at least some versions of Solaris there's a dynamic relocation
2367 on _r_debug.r_brk and SYM_ADDR may not be relocated yet, e.g., if
2368 we get control before the dynamic linker has self-relocated.
2369 Check if SYM_ADDR is in a known section, if it is assume we can
2370 trust its value. This is just a heuristic though, it could go away
2371 or be replaced if it's getting in the way.
2373 On ARM we need to know whether the ISA of rtld_db_dlactivity (or
2374 however it's spelled in your particular system) is ARM or Thumb.
2375 That knowledge is encoded in the address, if it's Thumb the low bit
2376 is 1. However, we've stripped that info above and it's not clear
2377 what all the consequences are of passing a non-addr_bits_remove'd
2378 address to svr4_create_solib_event_breakpoints. The call to
2379 find_pc_section verifies we know about the address and have some
2380 hope of computing the right kind of breakpoint to use (via
2381 symbol info). It does mean that GDB needs to be pointed at a
2382 non-stripped version of the dynamic linker in order to obtain
2383 information it already knows about. Sigh. */
2385 os
= find_pc_section (sym_addr
);
2388 /* Record the relocated start and end address of the dynamic linker
2389 text and plt section for svr4_in_dynsym_resolve_code. */
2391 CORE_ADDR load_addr
;
2393 tmp_bfd
= os
->objfile
->obfd
.get ();
2394 load_addr
= os
->objfile
->text_section_offset ();
2396 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
2399 info
->interp_text_sect_low
2400 = bfd_section_vma (interp_sect
) + load_addr
;
2401 info
->interp_text_sect_high
2402 = info
->interp_text_sect_low
+ bfd_section_size (interp_sect
);
2404 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
2407 info
->interp_plt_sect_low
2408 = bfd_section_vma (interp_sect
) + load_addr
;
2409 info
->interp_plt_sect_high
2410 = info
->interp_plt_sect_low
+ bfd_section_size (interp_sect
);
2413 svr4_create_solib_event_breakpoints (info
, target_gdbarch (), sym_addr
);
2418 /* Find the program interpreter; if not found, warn the user and drop
2419 into the old breakpoint at symbol code. */
2420 gdb::optional
<gdb::byte_vector
> interp_name_holder
2421 = find_program_interpreter ();
2422 if (interp_name_holder
)
2424 const char *interp_name
= (const char *) interp_name_holder
->data ();
2425 CORE_ADDR load_addr
= 0;
2426 int load_addr_found
= 0;
2427 int loader_found_in_list
= 0;
2428 target_ops_up tmp_bfd_target
;
2432 /* Now we need to figure out where the dynamic linker was
2433 loaded so that we can load its symbols and place a breakpoint
2434 in the dynamic linker itself.
2436 This address is stored on the stack. However, I've been unable
2437 to find any magic formula to find it for Solaris (appears to
2438 be trivial on GNU/Linux). Therefore, we have to try an alternate
2439 mechanism to find the dynamic linker's base address. */
2441 gdb_bfd_ref_ptr tmp_bfd
;
2444 tmp_bfd
= solib_bfd_open (interp_name
);
2446 catch (const gdb_exception
&ex
)
2450 if (tmp_bfd
== NULL
)
2451 goto bkpt_at_symbol
;
2453 /* Now convert the TMP_BFD into a target. That way target, as
2454 well as BFD operations can be used. */
2455 tmp_bfd_target
= target_bfd_reopen (tmp_bfd
);
2457 /* On a running target, we can get the dynamic linker's base
2458 address from the shared library table. */
2459 for (struct so_list
*so
: current_program_space
->solibs ())
2461 if (svr4_same_1 (interp_name
, so
->so_original_name
))
2463 load_addr_found
= 1;
2464 loader_found_in_list
= 1;
2465 load_addr
= lm_addr_check (so
, tmp_bfd
.get ());
2470 /* If we were not able to find the base address of the loader
2471 from our so_list, then try using the AT_BASE auxilliary entry. */
2472 if (!load_addr_found
)
2473 if (target_auxv_search (AT_BASE
, &load_addr
) > 0)
2475 int addr_bit
= gdbarch_addr_bit (target_gdbarch ());
2477 /* Ensure LOAD_ADDR has proper sign in its possible upper bits so
2478 that `+ load_addr' will overflow CORE_ADDR width not creating
2479 invalid addresses like 0x101234567 for 32bit inferiors on 64bit
2482 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2484 CORE_ADDR space_size
= (CORE_ADDR
) 1 << addr_bit
;
2485 CORE_ADDR tmp_entry_point
2486 = exec_entry_point (tmp_bfd
.get (), tmp_bfd_target
.get ());
2488 gdb_assert (load_addr
< space_size
);
2490 /* TMP_ENTRY_POINT exceeding SPACE_SIZE would be for prelinked
2491 64bit ld.so with 32bit executable, it should not happen. */
2493 if (tmp_entry_point
< space_size
2494 && tmp_entry_point
+ load_addr
>= space_size
)
2495 load_addr
-= space_size
;
2498 load_addr_found
= 1;
2501 /* Otherwise we find the dynamic linker's base address by examining
2502 the current pc (which should point at the entry point for the
2503 dynamic linker) and subtracting the offset of the entry point.
2505 This is more fragile than the previous approaches, but is a good
2506 fallback method because it has actually been working well in
2508 if (!load_addr_found
)
2510 struct regcache
*regcache
2511 = get_thread_arch_regcache (current_inferior ()->process_target (),
2512 inferior_ptid
, target_gdbarch ());
2514 load_addr
= (regcache_read_pc (regcache
)
2515 - exec_entry_point (tmp_bfd
.get (),
2516 tmp_bfd_target
.get ()));
2519 if (!loader_found_in_list
)
2521 info
->debug_loader_name
= xstrdup (interp_name
);
2522 info
->debug_loader_offset_p
= 1;
2523 info
->debug_loader_offset
= load_addr
;
2524 solib_add (NULL
, from_tty
, auto_solib_add
);
2527 /* Record the relocated start and end address of the dynamic linker
2528 text and plt section for svr4_in_dynsym_resolve_code. */
2529 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".text");
2532 info
->interp_text_sect_low
2533 = bfd_section_vma (interp_sect
) + load_addr
;
2534 info
->interp_text_sect_high
2535 = info
->interp_text_sect_low
+ bfd_section_size (interp_sect
);
2537 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".plt");
2540 info
->interp_plt_sect_low
2541 = bfd_section_vma (interp_sect
) + load_addr
;
2542 info
->interp_plt_sect_high
2543 = info
->interp_plt_sect_low
+ bfd_section_size (interp_sect
);
2546 /* Now try to set a breakpoint in the dynamic linker. */
2547 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2550 = (gdb_bfd_lookup_symbol
2552 [=] (const asymbol
*sym
)
2554 return (strcmp (sym
->name
, *bkpt_namep
) == 0
2555 && ((sym
->section
->flags
& (SEC_CODE
| SEC_DATA
))
2563 /* Convert 'sym_addr' from a function pointer to an address.
2564 Because we pass tmp_bfd_target instead of the current
2565 target, this will always produce an unrelocated value. */
2566 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2568 tmp_bfd_target
.get ());
2572 svr4_create_solib_event_breakpoints (info
, target_gdbarch (),
2573 load_addr
+ sym_addr
);
2577 /* For whatever reason we couldn't set a breakpoint in the dynamic
2578 linker. Warn and drop into the old code. */
2580 warning (_("Unable to find dynamic linker breakpoint function.\n"
2581 "GDB will be unable to debug shared library initializers\n"
2582 "and track explicitly loaded dynamic code."));
2585 /* Scan through the lists of symbols, trying to look up the symbol and
2586 set a breakpoint there. Terminate loop when we/if we succeed. */
2588 objfile
*objf
= current_program_space
->symfile_object_file
;
2589 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2591 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, objf
);
2592 if ((msymbol
.minsym
!= NULL
)
2593 && (msymbol
.value_address () != 0))
2595 sym_addr
= msymbol
.value_address ();
2596 sym_addr
= gdbarch_convert_from_func_ptr_addr
2597 (target_gdbarch (), sym_addr
, current_inferior ()->top_target ());
2598 svr4_create_solib_event_breakpoints (info
, target_gdbarch (),
2604 if (interp_name_holder
&& !current_inferior ()->attach_flag
)
2606 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2608 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, objf
);
2609 if ((msymbol
.minsym
!= NULL
)
2610 && (msymbol
.value_address () != 0))
2612 sym_addr
= msymbol
.value_address ();
2613 sym_addr
= gdbarch_convert_from_func_ptr_addr
2614 (target_gdbarch (), sym_addr
,
2615 current_inferior ()->top_target ());
2616 svr4_create_solib_event_breakpoints (info
, target_gdbarch (),
2625 /* Read the ELF program headers from ABFD. */
2627 static gdb::optional
<gdb::byte_vector
>
2628 read_program_headers_from_bfd (bfd
*abfd
)
2630 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
2631 int phdrs_size
= ehdr
->e_phnum
* ehdr
->e_phentsize
;
2632 if (phdrs_size
== 0)
2635 gdb::byte_vector
buf (phdrs_size
);
2636 if (bfd_seek (abfd
, ehdr
->e_phoff
, SEEK_SET
) != 0
2637 || bfd_read (buf
.data (), phdrs_size
, abfd
) != phdrs_size
)
2643 /* Return 1 and fill *DISPLACEMENTP with detected PIE offset of inferior
2644 exec_bfd. Otherwise return 0.
2646 We relocate all of the sections by the same amount. This
2647 behavior is mandated by recent editions of the System V ABI.
2648 According to the System V Application Binary Interface,
2649 Edition 4.1, page 5-5:
2651 ... Though the system chooses virtual addresses for
2652 individual processes, it maintains the segments' relative
2653 positions. Because position-independent code uses relative
2654 addressing between segments, the difference between
2655 virtual addresses in memory must match the difference
2656 between virtual addresses in the file. The difference
2657 between the virtual address of any segment in memory and
2658 the corresponding virtual address in the file is thus a
2659 single constant value for any one executable or shared
2660 object in a given process. This difference is the base
2661 address. One use of the base address is to relocate the
2662 memory image of the program during dynamic linking.
2664 The same language also appears in Edition 4.0 of the System V
2665 ABI and is left unspecified in some of the earlier editions.
2667 Decide if the objfile needs to be relocated. As indicated above, we will
2668 only be here when execution is stopped. But during attachment PC can be at
2669 arbitrary address therefore regcache_read_pc can be misleading (contrary to
2670 the auxv AT_ENTRY value). Moreover for executable with interpreter section
2671 regcache_read_pc would point to the interpreter and not the main executable.
2673 So, to summarize, relocations are necessary when the start address obtained
2674 from the executable is different from the address in auxv AT_ENTRY entry.
2676 [ The astute reader will note that we also test to make sure that
2677 the executable in question has the DYNAMIC flag set. It is my
2678 opinion that this test is unnecessary (undesirable even). It
2679 was added to avoid inadvertent relocation of an executable
2680 whose e_type member in the ELF header is not ET_DYN. There may
2681 be a time in the future when it is desirable to do relocations
2682 on other types of files as well in which case this condition
2683 should either be removed or modified to accommodate the new file
2684 type. - Kevin, Nov 2000. ] */
2687 svr4_exec_displacement (CORE_ADDR
*displacementp
)
2689 /* ENTRY_POINT is a possible function descriptor - before
2690 a call to gdbarch_convert_from_func_ptr_addr. */
2691 CORE_ADDR entry_point
, exec_displacement
;
2693 if (current_program_space
->exec_bfd () == NULL
)
2696 /* Therefore for ELF it is ET_EXEC and not ET_DYN. Both shared libraries
2697 being executed themselves and PIE (Position Independent Executable)
2698 executables are ET_DYN. */
2700 if ((bfd_get_file_flags (current_program_space
->exec_bfd ()) & DYNAMIC
) == 0)
2703 if (target_auxv_search (AT_ENTRY
, &entry_point
) <= 0)
2707 = entry_point
- bfd_get_start_address (current_program_space
->exec_bfd ());
2709 /* Verify the EXEC_DISPLACEMENT candidate complies with the required page
2710 alignment. It is cheaper than the program headers comparison below. */
2712 if (bfd_get_flavour (current_program_space
->exec_bfd ())
2713 == bfd_target_elf_flavour
)
2715 const struct elf_backend_data
*elf
2716 = get_elf_backend_data (current_program_space
->exec_bfd ());
2718 /* p_align of PT_LOAD segments does not specify any alignment but
2719 only congruency of addresses:
2720 p_offset % p_align == p_vaddr % p_align
2721 Kernel is free to load the executable with lower alignment. */
2723 if ((exec_displacement
& (elf
->minpagesize
- 1)) != 0)
2727 /* Verify that the auxilliary vector describes the same file as exec_bfd, by
2728 comparing their program headers. If the program headers in the auxilliary
2729 vector do not match the program headers in the executable, then we are
2730 looking at a different file than the one used by the kernel - for
2731 instance, "gdb program" connected to "gdbserver :PORT ld.so program". */
2733 if (bfd_get_flavour (current_program_space
->exec_bfd ())
2734 == bfd_target_elf_flavour
)
2736 /* Be optimistic and return 0 only if GDB was able to verify the headers
2737 really do not match. */
2740 gdb::optional
<gdb::byte_vector
> phdrs_target
2741 = read_program_header (-1, &arch_size
, NULL
);
2742 gdb::optional
<gdb::byte_vector
> phdrs_binary
2743 = read_program_headers_from_bfd (current_program_space
->exec_bfd ());
2744 if (phdrs_target
&& phdrs_binary
)
2746 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
2748 /* We are dealing with three different addresses. EXEC_BFD
2749 represents current address in on-disk file. target memory content
2750 may be different from EXEC_BFD as the file may have been prelinked
2751 to a different address after the executable has been loaded.
2752 Moreover the address of placement in target memory can be
2753 different from what the program headers in target memory say -
2754 this is the goal of PIE.
2756 Detected DISPLACEMENT covers both the offsets of PIE placement and
2757 possible new prelink performed after start of the program. Here
2758 relocate BUF and BUF2 just by the EXEC_BFD vs. target memory
2759 content offset for the verification purpose. */
2761 if (phdrs_target
->size () != phdrs_binary
->size ()
2762 || bfd_get_arch_size (current_program_space
->exec_bfd ()) != arch_size
)
2764 else if (arch_size
== 32
2765 && phdrs_target
->size () >= sizeof (Elf32_External_Phdr
)
2766 && phdrs_target
->size () % sizeof (Elf32_External_Phdr
) == 0)
2768 Elf_Internal_Ehdr
*ehdr2
2769 = elf_tdata (current_program_space
->exec_bfd ())->elf_header
;
2770 Elf_Internal_Phdr
*phdr2
2771 = elf_tdata (current_program_space
->exec_bfd ())->phdr
;
2772 CORE_ADDR displacement
= 0;
2775 /* DISPLACEMENT could be found more easily by the difference of
2776 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2777 already have enough information to compute that displacement
2778 with what we've read. */
2780 for (i
= 0; i
< ehdr2
->e_phnum
; i
++)
2781 if (phdr2
[i
].p_type
== PT_LOAD
)
2783 Elf32_External_Phdr
*phdrp
;
2784 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2785 CORE_ADDR vaddr
, paddr
;
2786 CORE_ADDR displacement_vaddr
= 0;
2787 CORE_ADDR displacement_paddr
= 0;
2789 phdrp
= &((Elf32_External_Phdr
*) phdrs_target
->data ())[i
];
2790 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2791 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2793 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 4,
2795 displacement_vaddr
= vaddr
- phdr2
[i
].p_vaddr
;
2797 paddr
= extract_unsigned_integer (buf_paddr_p
, 4,
2799 displacement_paddr
= paddr
- phdr2
[i
].p_paddr
;
2801 if (displacement_vaddr
== displacement_paddr
)
2802 displacement
= displacement_vaddr
;
2807 /* Now compare program headers from the target and the binary
2808 with optional DISPLACEMENT. */
2811 i
< phdrs_target
->size () / sizeof (Elf32_External_Phdr
);
2814 Elf32_External_Phdr
*phdrp
;
2815 Elf32_External_Phdr
*phdr2p
;
2816 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2817 CORE_ADDR vaddr
, paddr
;
2818 asection
*plt2_asect
;
2820 phdrp
= &((Elf32_External_Phdr
*) phdrs_target
->data ())[i
];
2821 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2822 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2823 phdr2p
= &((Elf32_External_Phdr
*) phdrs_binary
->data ())[i
];
2825 /* PT_GNU_STACK is an exception by being never relocated by
2826 prelink as its addresses are always zero. */
2828 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2831 /* Check also other adjustment combinations - PR 11786. */
2833 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 4,
2835 vaddr
-= displacement
;
2836 store_unsigned_integer (buf_vaddr_p
, 4, byte_order
, vaddr
);
2838 paddr
= extract_unsigned_integer (buf_paddr_p
, 4,
2840 paddr
-= displacement
;
2841 store_unsigned_integer (buf_paddr_p
, 4, byte_order
, paddr
);
2843 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2846 /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2847 CentOS-5 has problems with filesz, memsz as well.
2848 Strip also modifies memsz of PT_TLS.
2850 if (phdr2
[i
].p_type
== PT_GNU_RELRO
2851 || phdr2
[i
].p_type
== PT_TLS
)
2853 Elf32_External_Phdr tmp_phdr
= *phdrp
;
2854 Elf32_External_Phdr tmp_phdr2
= *phdr2p
;
2856 memset (tmp_phdr
.p_filesz
, 0, 4);
2857 memset (tmp_phdr
.p_memsz
, 0, 4);
2858 memset (tmp_phdr
.p_flags
, 0, 4);
2859 memset (tmp_phdr
.p_align
, 0, 4);
2860 memset (tmp_phdr2
.p_filesz
, 0, 4);
2861 memset (tmp_phdr2
.p_memsz
, 0, 4);
2862 memset (tmp_phdr2
.p_flags
, 0, 4);
2863 memset (tmp_phdr2
.p_align
, 0, 4);
2865 if (memcmp (&tmp_phdr
, &tmp_phdr2
, sizeof (tmp_phdr
))
2870 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2871 bfd
*exec_bfd
= current_program_space
->exec_bfd ();
2872 plt2_asect
= bfd_get_section_by_name (exec_bfd
, ".plt");
2876 gdb_byte
*buf_filesz_p
= (gdb_byte
*) &phdrp
->p_filesz
;
2879 content2
= (bfd_section_flags (plt2_asect
)
2880 & SEC_HAS_CONTENTS
) != 0;
2882 filesz
= extract_unsigned_integer (buf_filesz_p
, 4,
2885 /* PLT2_ASECT is from on-disk file (exec_bfd) while
2886 FILESZ is from the in-memory image. */
2888 filesz
+= bfd_section_size (plt2_asect
);
2890 filesz
-= bfd_section_size (plt2_asect
);
2892 store_unsigned_integer (buf_filesz_p
, 4, byte_order
,
2895 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2902 else if (arch_size
== 64
2903 && phdrs_target
->size () >= sizeof (Elf64_External_Phdr
)
2904 && phdrs_target
->size () % sizeof (Elf64_External_Phdr
) == 0)
2906 Elf_Internal_Ehdr
*ehdr2
2907 = elf_tdata (current_program_space
->exec_bfd ())->elf_header
;
2908 Elf_Internal_Phdr
*phdr2
2909 = elf_tdata (current_program_space
->exec_bfd ())->phdr
;
2910 CORE_ADDR displacement
= 0;
2913 /* DISPLACEMENT could be found more easily by the difference of
2914 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2915 already have enough information to compute that displacement
2916 with what we've read. */
2918 for (i
= 0; i
< ehdr2
->e_phnum
; i
++)
2919 if (phdr2
[i
].p_type
== PT_LOAD
)
2921 Elf64_External_Phdr
*phdrp
;
2922 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2923 CORE_ADDR vaddr
, paddr
;
2924 CORE_ADDR displacement_vaddr
= 0;
2925 CORE_ADDR displacement_paddr
= 0;
2927 phdrp
= &((Elf64_External_Phdr
*) phdrs_target
->data ())[i
];
2928 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2929 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2931 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 8,
2933 displacement_vaddr
= vaddr
- phdr2
[i
].p_vaddr
;
2935 paddr
= extract_unsigned_integer (buf_paddr_p
, 8,
2937 displacement_paddr
= paddr
- phdr2
[i
].p_paddr
;
2939 if (displacement_vaddr
== displacement_paddr
)
2940 displacement
= displacement_vaddr
;
2945 /* Now compare BUF and BUF2 with optional DISPLACEMENT. */
2948 i
< phdrs_target
->size () / sizeof (Elf64_External_Phdr
);
2951 Elf64_External_Phdr
*phdrp
;
2952 Elf64_External_Phdr
*phdr2p
;
2953 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2954 CORE_ADDR vaddr
, paddr
;
2955 asection
*plt2_asect
;
2957 phdrp
= &((Elf64_External_Phdr
*) phdrs_target
->data ())[i
];
2958 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2959 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2960 phdr2p
= &((Elf64_External_Phdr
*) phdrs_binary
->data ())[i
];
2962 /* PT_GNU_STACK is an exception by being never relocated by
2963 prelink as its addresses are always zero. */
2965 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2968 /* Check also other adjustment combinations - PR 11786. */
2970 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 8,
2972 vaddr
-= displacement
;
2973 store_unsigned_integer (buf_vaddr_p
, 8, byte_order
, vaddr
);
2975 paddr
= extract_unsigned_integer (buf_paddr_p
, 8,
2977 paddr
-= displacement
;
2978 store_unsigned_integer (buf_paddr_p
, 8, byte_order
, paddr
);
2980 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2983 /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2984 CentOS-5 has problems with filesz, memsz as well.
2985 Strip also modifies memsz of PT_TLS.
2987 if (phdr2
[i
].p_type
== PT_GNU_RELRO
2988 || phdr2
[i
].p_type
== PT_TLS
)
2990 Elf64_External_Phdr tmp_phdr
= *phdrp
;
2991 Elf64_External_Phdr tmp_phdr2
= *phdr2p
;
2993 memset (tmp_phdr
.p_filesz
, 0, 8);
2994 memset (tmp_phdr
.p_memsz
, 0, 8);
2995 memset (tmp_phdr
.p_flags
, 0, 4);
2996 memset (tmp_phdr
.p_align
, 0, 8);
2997 memset (tmp_phdr2
.p_filesz
, 0, 8);
2998 memset (tmp_phdr2
.p_memsz
, 0, 8);
2999 memset (tmp_phdr2
.p_flags
, 0, 4);
3000 memset (tmp_phdr2
.p_align
, 0, 8);
3002 if (memcmp (&tmp_phdr
, &tmp_phdr2
, sizeof (tmp_phdr
))
3007 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
3009 = bfd_get_section_by_name (current_program_space
->exec_bfd (),
3014 gdb_byte
*buf_filesz_p
= (gdb_byte
*) &phdrp
->p_filesz
;
3017 content2
= (bfd_section_flags (plt2_asect
)
3018 & SEC_HAS_CONTENTS
) != 0;
3020 filesz
= extract_unsigned_integer (buf_filesz_p
, 8,
3023 /* PLT2_ASECT is from on-disk file (current
3024 exec_bfd) while FILESZ is from the in-memory
3027 filesz
+= bfd_section_size (plt2_asect
);
3029 filesz
-= bfd_section_size (plt2_asect
);
3031 store_unsigned_integer (buf_filesz_p
, 8, byte_order
,
3034 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
3048 /* It can be printed repeatedly as there is no easy way to check
3049 the executable symbols/file has been already relocated to
3052 gdb_printf (_("Using PIE (Position Independent Executable) "
3053 "displacement %s for \"%s\".\n"),
3054 paddress (target_gdbarch (), exec_displacement
),
3055 bfd_get_filename (current_program_space
->exec_bfd ()));
3058 *displacementp
= exec_displacement
;
3062 /* Relocate the main executable. This function should be called upon
3063 stopping the inferior process at the entry point to the program.
3064 The entry point from BFD is compared to the AT_ENTRY of AUXV and if they are
3065 different, the main executable is relocated by the proper amount. */
3068 svr4_relocate_main_executable (void)
3070 CORE_ADDR displacement
;
3072 /* If we are re-running this executable, SYMFILE_OBJFILE->SECTION_OFFSETS
3073 probably contains the offsets computed using the PIE displacement
3074 from the previous run, which of course are irrelevant for this run.
3075 So we need to determine the new PIE displacement and recompute the
3076 section offsets accordingly, even if SYMFILE_OBJFILE->SECTION_OFFSETS
3077 already contains pre-computed offsets.
3079 If we cannot compute the PIE displacement, either:
3081 - The executable is not PIE.
3083 - SYMFILE_OBJFILE does not match the executable started in the target.
3084 This can happen for main executable symbols loaded at the host while
3085 `ld.so --ld-args main-executable' is loaded in the target.
3087 Then we leave the section offsets untouched and use them as is for
3090 - These section offsets were properly reset earlier, and thus
3091 already contain the correct values. This can happen for instance
3092 when reconnecting via the remote protocol to a target that supports
3093 the `qOffsets' packet.
3095 - The section offsets were not reset earlier, and the best we can
3096 hope is that the old offsets are still applicable to the new run. */
3098 if (! svr4_exec_displacement (&displacement
))
3101 /* Even DISPLACEMENT 0 is a valid new difference of in-memory vs. in-file
3104 objfile
*objf
= current_program_space
->symfile_object_file
;
3107 section_offsets
new_offsets (objf
->section_offsets
.size (),
3109 objfile_relocate (objf
, new_offsets
);
3111 else if (current_program_space
->exec_bfd ())
3115 bfd
*exec_bfd
= current_program_space
->exec_bfd ();
3116 for (asect
= exec_bfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
3117 exec_set_section_address (bfd_get_filename (exec_bfd
), asect
->index
,
3118 bfd_section_vma (asect
) + displacement
);
3122 /* Implement the "create_inferior_hook" target_solib_ops method.
3124 For SVR4 executables, this first instruction is either the first
3125 instruction in the dynamic linker (for dynamically linked
3126 executables) or the instruction at "start" for statically linked
3127 executables. For dynamically linked executables, the system
3128 first exec's /lib/libc.so.N, which contains the dynamic linker,
3129 and starts it running. The dynamic linker maps in any needed
3130 shared libraries, maps in the actual user executable, and then
3131 jumps to "start" in the user executable.
3133 We can arrange to cooperate with the dynamic linker to discover the
3134 names of shared libraries that are dynamically linked, and the base
3135 addresses to which they are linked.
3137 This function is responsible for discovering those names and
3138 addresses, and saving sufficient information about them to allow
3139 their symbols to be read at a later time. */
3142 svr4_solib_create_inferior_hook (int from_tty
)
3144 struct svr4_info
*info
;
3146 info
= get_svr4_info (current_program_space
);
3148 /* Clear the probes-based interface's state. */
3149 free_probes_table (info
);
3150 free_solib_lists (info
);
3152 /* Relocate the main executable if necessary. */
3153 svr4_relocate_main_executable ();
3155 /* No point setting a breakpoint in the dynamic linker if we can't
3156 hit it (e.g., a core file, or a trace file). */
3157 if (!target_has_execution ())
3160 if (!svr4_have_link_map_offsets ())
3163 if (!enable_break (info
, from_tty
))
3168 svr4_clear_solib (void)
3170 struct svr4_info
*info
;
3172 info
= get_svr4_info (current_program_space
);
3173 info
->debug_base
= 0;
3174 info
->debug_loader_offset_p
= 0;
3175 info
->debug_loader_offset
= 0;
3176 xfree (info
->debug_loader_name
);
3177 info
->debug_loader_name
= NULL
;
3180 /* Clear any bits of ADDR that wouldn't fit in a target-format
3181 data pointer. "Data pointer" here refers to whatever sort of
3182 address the dynamic linker uses to manage its sections. At the
3183 moment, we don't support shared libraries on any processors where
3184 code and data pointers are different sizes.
3186 This isn't really the right solution. What we really need here is
3187 a way to do arithmetic on CORE_ADDR values that respects the
3188 natural pointer/address correspondence. (For example, on the MIPS,
3189 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
3190 sign-extend the value. There, simply truncating the bits above
3191 gdbarch_ptr_bit, as we do below, is no good.) This should probably
3192 be a new gdbarch method or something. */
3194 svr4_truncate_ptr (CORE_ADDR addr
)
3196 if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR
) * 8)
3197 /* We don't need to truncate anything, and the bit twiddling below
3198 will fail due to overflow problems. */
3201 return addr
& (((CORE_ADDR
) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
3206 svr4_relocate_section_addresses (struct so_list
*so
,
3207 struct target_section
*sec
)
3209 bfd
*abfd
= sec
->the_bfd_section
->owner
;
3211 sec
->addr
= svr4_truncate_ptr (sec
->addr
+ lm_addr_check (so
, abfd
));
3212 sec
->endaddr
= svr4_truncate_ptr (sec
->endaddr
+ lm_addr_check (so
, abfd
));
3216 /* Architecture-specific operations. */
3218 struct solib_svr4_ops
3220 /* Return a description of the layout of `struct link_map'. */
3221 struct link_map_offsets
*(*fetch_link_map_offsets
)(void) = nullptr;
3224 /* Per-architecture data key. */
3225 static const registry
<gdbarch
>::key
<struct solib_svr4_ops
> solib_svr4_data
;
3227 /* Return a default for the architecture-specific operations. */
3229 static struct solib_svr4_ops
*
3230 get_ops (struct gdbarch
*gdbarch
)
3232 struct solib_svr4_ops
*ops
= solib_svr4_data
.get (gdbarch
);
3234 ops
= solib_svr4_data
.emplace (gdbarch
);
3238 /* Set the architecture-specific `struct link_map_offsets' fetcher for
3239 GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */
3242 set_solib_svr4_fetch_link_map_offsets (struct gdbarch
*gdbarch
,
3243 struct link_map_offsets
*(*flmo
) (void))
3245 struct solib_svr4_ops
*ops
= get_ops (gdbarch
);
3247 ops
->fetch_link_map_offsets
= flmo
;
3249 set_gdbarch_so_ops (gdbarch
, &svr4_so_ops
);
3250 set_gdbarch_iterate_over_objfiles_in_search_order
3251 (gdbarch
, svr4_iterate_over_objfiles_in_search_order
);
3254 /* Fetch a link_map_offsets structure using the architecture-specific
3255 `struct link_map_offsets' fetcher. */
3257 static struct link_map_offsets
*
3258 svr4_fetch_link_map_offsets (void)
3260 struct solib_svr4_ops
*ops
= get_ops (target_gdbarch ());
3262 gdb_assert (ops
->fetch_link_map_offsets
);
3263 return ops
->fetch_link_map_offsets ();
3266 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
3269 svr4_have_link_map_offsets (void)
3271 struct solib_svr4_ops
*ops
= get_ops (target_gdbarch ());
3273 return (ops
->fetch_link_map_offsets
!= NULL
);
3277 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
3278 `struct r_debug' and a `struct link_map' that are binary compatible
3279 with the original SVR4 implementation. */
3281 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3282 for an ILP32 SVR4 system. */
3284 struct link_map_offsets
*
3285 svr4_ilp32_fetch_link_map_offsets (void)
3287 static struct link_map_offsets lmo
;
3288 static struct link_map_offsets
*lmp
= NULL
;
3294 lmo
.r_version_offset
= 0;
3295 lmo
.r_version_size
= 4;
3296 lmo
.r_map_offset
= 4;
3297 lmo
.r_brk_offset
= 8;
3298 lmo
.r_ldsomap_offset
= 20;
3299 lmo
.r_next_offset
= -1;
3301 /* Everything we need is in the first 20 bytes. */
3302 lmo
.link_map_size
= 20;
3303 lmo
.l_addr_offset
= 0;
3304 lmo
.l_name_offset
= 4;
3305 lmo
.l_ld_offset
= 8;
3306 lmo
.l_next_offset
= 12;
3307 lmo
.l_prev_offset
= 16;
3313 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3314 for an LP64 SVR4 system. */
3316 struct link_map_offsets
*
3317 svr4_lp64_fetch_link_map_offsets (void)
3319 static struct link_map_offsets lmo
;
3320 static struct link_map_offsets
*lmp
= NULL
;
3326 lmo
.r_version_offset
= 0;
3327 lmo
.r_version_size
= 4;
3328 lmo
.r_map_offset
= 8;
3329 lmo
.r_brk_offset
= 16;
3330 lmo
.r_ldsomap_offset
= 40;
3331 lmo
.r_next_offset
= -1;
3333 /* Everything we need is in the first 40 bytes. */
3334 lmo
.link_map_size
= 40;
3335 lmo
.l_addr_offset
= 0;
3336 lmo
.l_name_offset
= 8;
3337 lmo
.l_ld_offset
= 16;
3338 lmo
.l_next_offset
= 24;
3339 lmo
.l_prev_offset
= 32;
3346 /* Return the DSO matching OBJFILE or nullptr if none can be found. */
3349 find_solib_for_objfile (struct objfile
*objfile
)
3351 if (objfile
== nullptr)
3354 /* If OBJFILE is a separate debug object file, look for the original
3356 if (objfile
->separate_debug_objfile_backlink
!= nullptr)
3357 objfile
= objfile
->separate_debug_objfile_backlink
;
3359 for (so_list
*so
: current_program_space
->solibs ())
3360 if (so
->objfile
== objfile
)
3366 /* Return the address of the r_debug object for the namespace containing
3367 SOLIB or zero if it cannot be found. This may happen when symbol files
3368 are added manually, for example, or with the main executable.
3370 Current callers treat zero as initial namespace so they are doing the
3371 right thing for the main executable. */
3374 find_debug_base_for_solib (so_list
*solib
)
3376 if (solib
== nullptr)
3379 svr4_info
*info
= get_svr4_info (current_program_space
);
3380 gdb_assert (info
!= nullptr);
3381 for (const std::pair
<CORE_ADDR
, so_list
*> tuple
3382 : info
->solib_lists
)
3384 CORE_ADDR debug_base
= tuple
.first
;
3385 so_list
*solist
= tuple
.second
;
3387 for (; solist
!= nullptr; solist
= solist
->next
)
3388 if (svr4_same (solib
, solist
))
3395 /* Search order for ELF DSOs linked with -Bsymbolic. Those DSOs have a
3396 different rule for symbol lookup. The lookup begins here in the DSO,
3397 not in the main executable. When starting from CURRENT_OBJFILE, we
3398 stay in the same namespace as that file. Otherwise, we only consider
3399 the initial namespace. */
3402 svr4_iterate_over_objfiles_in_search_order
3403 (gdbarch
*gdbarch
, iterate_over_objfiles_in_search_order_cb_ftype cb
,
3404 objfile
*current_objfile
)
3406 bool checked_current_objfile
= false;
3407 if (current_objfile
!= nullptr)
3411 if (current_objfile
->separate_debug_objfile_backlink
!= nullptr)
3412 current_objfile
= current_objfile
->separate_debug_objfile_backlink
;
3414 if (current_objfile
== current_program_space
->symfile_object_file
)
3415 abfd
= current_program_space
->exec_bfd ();
3417 abfd
= current_objfile
->obfd
.get ();
3420 && gdb_bfd_scan_elf_dyntag (DT_SYMBOLIC
, abfd
, nullptr, nullptr) == 1)
3422 checked_current_objfile
= true;
3423 if (cb (current_objfile
))
3428 /* The linker namespace to iterate identified by the address of its
3429 r_debug object, defaulting to the initial namespace. */
3430 CORE_ADDR initial
= elf_locate_base ();
3431 so_list
*curr_solib
= find_solib_for_objfile (current_objfile
);
3432 CORE_ADDR debug_base
= find_debug_base_for_solib (curr_solib
);
3433 if (debug_base
== 0)
3434 debug_base
= initial
;
3436 for (objfile
*objfile
: current_program_space
->objfiles ())
3438 if (checked_current_objfile
&& objfile
== current_objfile
)
3441 /* Try to determine the namespace into which objfile was loaded.
3443 If we fail, e.g. for manually added symbol files or for the main
3444 executable, we assume that they were added to the initial
3446 so_list
*solib
= find_solib_for_objfile (objfile
);
3447 CORE_ADDR solib_base
= find_debug_base_for_solib (solib
);
3448 if (solib_base
== 0)
3449 solib_base
= initial
;
3451 /* Ignore objfiles that were added to a different namespace. */
3452 if (solib_base
!= debug_base
)
3460 const struct target_so_ops svr4_so_ops
=
3462 svr4_relocate_section_addresses
,
3466 svr4_solib_create_inferior_hook
,
3468 open_symbol_file_object
,
3469 svr4_in_dynsym_resolve_code
,
3473 svr4_keep_data_in_core
,
3474 svr4_update_solib_event_breakpoints
,
3475 svr4_handle_solib_event
,
3478 void _initialize_svr4_solib ();
3480 _initialize_svr4_solib ()
3482 gdb::observers::free_objfile
.attach (svr4_free_objfile_observer
,