1 /* Handle SVR4 shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 1990-2019 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"
49 static struct link_map_offsets
*svr4_fetch_link_map_offsets (void);
50 static int svr4_have_link_map_offsets (void);
51 static void svr4_relocate_main_executable (void);
52 static void svr4_free_library_list (void *p_list
);
53 static void probes_table_remove_objfile_probes (struct objfile
*objfile
);
55 /* On SVR4 systems, a list of symbols in the dynamic linker where
56 GDB can try to place a breakpoint to monitor shared library
59 If none of these symbols are found, or other errors occur, then
60 SVR4 systems will fall back to using a symbol as the "startup
61 mapping complete" breakpoint address. */
63 static const char * const solib_break_names
[] =
69 "__dl_rtld_db_dlactivity",
75 static const char * const bkpt_names
[] =
83 static const char * const main_name_list
[] =
89 /* What to do when a probe stop occurs. */
93 /* Something went seriously wrong. Stop using probes and
94 revert to using the older interface. */
95 PROBES_INTERFACE_FAILED
,
97 /* No action is required. The shared object list is still
101 /* The shared object list should be reloaded entirely. */
104 /* Attempt to incrementally update the shared object list. If
105 the update fails or is not possible, fall back to reloading
110 /* A probe's name and its associated action. */
114 /* The name of the probe. */
117 /* What to do when a probe stop occurs. */
118 enum probe_action action
;
121 /* A list of named probes and their associated actions. If all
122 probes are present in the dynamic linker then the probes-based
123 interface will be used. */
125 static const struct probe_info probe_info
[] =
127 { "init_start", DO_NOTHING
},
128 { "init_complete", FULL_RELOAD
},
129 { "map_start", DO_NOTHING
},
130 { "map_failed", DO_NOTHING
},
131 { "reloc_complete", UPDATE_OR_RELOAD
},
132 { "unmap_start", DO_NOTHING
},
133 { "unmap_complete", FULL_RELOAD
},
136 #define NUM_PROBES ARRAY_SIZE (probe_info)
138 /* Return non-zero if GDB_SO_NAME and INFERIOR_SO_NAME represent
139 the same shared library. */
142 svr4_same_1 (const char *gdb_so_name
, const char *inferior_so_name
)
144 if (strcmp (gdb_so_name
, inferior_so_name
) == 0)
147 /* On Solaris, when starting inferior we think that dynamic linker is
148 /usr/lib/ld.so.1, but later on, the table of loaded shared libraries
149 contains /lib/ld.so.1. Sometimes one file is a link to another, but
150 sometimes they have identical content, but are not linked to each
151 other. We don't restrict this check for Solaris, but the chances
152 of running into this situation elsewhere are very low. */
153 if (strcmp (gdb_so_name
, "/usr/lib/ld.so.1") == 0
154 && strcmp (inferior_so_name
, "/lib/ld.so.1") == 0)
157 /* Similarly, we observed the same issue with amd64 and sparcv9, but with
158 different locations. */
159 if (strcmp (gdb_so_name
, "/usr/lib/amd64/ld.so.1") == 0
160 && strcmp (inferior_so_name
, "/lib/amd64/ld.so.1") == 0)
163 if (strcmp (gdb_so_name
, "/usr/lib/sparcv9/ld.so.1") == 0
164 && strcmp (inferior_so_name
, "/lib/sparcv9/ld.so.1") == 0)
171 svr4_same (struct so_list
*gdb
, struct so_list
*inferior
)
173 return (svr4_same_1 (gdb
->so_original_name
, inferior
->so_original_name
));
176 static std::unique_ptr
<lm_info_svr4
>
177 lm_info_read (CORE_ADDR lm_addr
)
179 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
180 std::unique_ptr
<lm_info_svr4
> lm_info
;
182 gdb::byte_vector
lm (lmo
->link_map_size
);
184 if (target_read_memory (lm_addr
, lm
.data (), lmo
->link_map_size
) != 0)
185 warning (_("Error reading shared library list entry at %s"),
186 paddress (target_gdbarch (), lm_addr
));
189 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
191 lm_info
.reset (new lm_info_svr4
);
192 lm_info
->lm_addr
= lm_addr
;
194 lm_info
->l_addr_inferior
= extract_typed_address (&lm
[lmo
->l_addr_offset
],
196 lm_info
->l_ld
= extract_typed_address (&lm
[lmo
->l_ld_offset
], ptr_type
);
197 lm_info
->l_next
= extract_typed_address (&lm
[lmo
->l_next_offset
],
199 lm_info
->l_prev
= extract_typed_address (&lm
[lmo
->l_prev_offset
],
201 lm_info
->l_name
= extract_typed_address (&lm
[lmo
->l_name_offset
],
209 has_lm_dynamic_from_link_map (void)
211 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
213 return lmo
->l_ld_offset
>= 0;
217 lm_addr_check (const struct so_list
*so
, bfd
*abfd
)
219 lm_info_svr4
*li
= (lm_info_svr4
*) so
->lm_info
;
223 struct bfd_section
*dyninfo_sect
;
224 CORE_ADDR l_addr
, l_dynaddr
, dynaddr
;
226 l_addr
= li
->l_addr_inferior
;
228 if (! abfd
|| ! has_lm_dynamic_from_link_map ())
231 l_dynaddr
= li
->l_ld
;
233 dyninfo_sect
= bfd_get_section_by_name (abfd
, ".dynamic");
234 if (dyninfo_sect
== NULL
)
237 dynaddr
= bfd_section_vma (abfd
, dyninfo_sect
);
239 if (dynaddr
+ l_addr
!= l_dynaddr
)
241 CORE_ADDR align
= 0x1000;
242 CORE_ADDR minpagesize
= align
;
244 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
246 Elf_Internal_Ehdr
*ehdr
= elf_tdata (abfd
)->elf_header
;
247 Elf_Internal_Phdr
*phdr
= elf_tdata (abfd
)->phdr
;
252 for (i
= 0; i
< ehdr
->e_phnum
; i
++)
253 if (phdr
[i
].p_type
== PT_LOAD
&& phdr
[i
].p_align
> align
)
254 align
= phdr
[i
].p_align
;
256 minpagesize
= get_elf_backend_data (abfd
)->minpagesize
;
259 /* Turn it into a mask. */
262 /* If the changes match the alignment requirements, we
263 assume we're using a core file that was generated by the
264 same binary, just prelinked with a different base offset.
265 If it doesn't match, we may have a different binary, the
266 same binary with the dynamic table loaded at an unrelated
267 location, or anything, really. To avoid regressions,
268 don't adjust the base offset in the latter case, although
269 odds are that, if things really changed, debugging won't
272 One could expect more the condition
273 ((l_addr & align) == 0 && ((l_dynaddr - dynaddr) & align) == 0)
274 but the one below is relaxed for PPC. The PPC kernel supports
275 either 4k or 64k page sizes. To be prepared for 64k pages,
276 PPC ELF files are built using an alignment requirement of 64k.
277 However, when running on a kernel supporting 4k pages, the memory
278 mapping of the library may not actually happen on a 64k boundary!
280 (In the usual case where (l_addr & align) == 0, this check is
281 equivalent to the possibly expected check above.)
283 Even on PPC it must be zero-aligned at least for MINPAGESIZE. */
285 l_addr
= l_dynaddr
- dynaddr
;
287 if ((l_addr
& (minpagesize
- 1)) == 0
288 && (l_addr
& align
) == ((l_dynaddr
- dynaddr
) & align
))
291 printf_unfiltered (_("Using PIC (Position Independent Code) "
292 "prelink displacement %s for \"%s\".\n"),
293 paddress (target_gdbarch (), l_addr
),
298 /* There is no way to verify the library file matches. prelink
299 can during prelinking of an unprelinked file (or unprelinking
300 of a prelinked file) shift the DYNAMIC segment by arbitrary
301 offset without any page size alignment. There is no way to
302 find out the ELF header and/or Program Headers for a limited
303 verification if it they match. One could do a verification
304 of the DYNAMIC segment. Still the found address is the best
305 one GDB could find. */
307 warning (_(".dynamic section for \"%s\" "
308 "is not at the expected address "
309 "(wrong library or version mismatch?)"), so
->so_name
);
321 /* Per pspace SVR4 specific data. */
325 svr4_info () = default;
328 /* Base of dynamic linker structures. */
329 CORE_ADDR debug_base
= 0;
331 /* Validity flag for debug_loader_offset. */
332 int debug_loader_offset_p
= 0;
334 /* Load address for the dynamic linker, inferred. */
335 CORE_ADDR debug_loader_offset
= 0;
337 /* Name of the dynamic linker, valid if debug_loader_offset_p. */
338 char *debug_loader_name
= nullptr;
340 /* Load map address for the main executable. */
341 CORE_ADDR main_lm_addr
= 0;
343 CORE_ADDR interp_text_sect_low
= 0;
344 CORE_ADDR interp_text_sect_high
= 0;
345 CORE_ADDR interp_plt_sect_low
= 0;
346 CORE_ADDR interp_plt_sect_high
= 0;
348 /* Nonzero if the list of objects was last obtained from the target
349 via qXfer:libraries-svr4:read. */
352 /* Table of struct probe_and_action instances, used by the
353 probes-based interface to map breakpoint addresses to probes
354 and their associated actions. Lookup is performed using
355 probe_and_action->prob->address. */
356 htab_up probes_table
;
358 /* List of objects loaded into the inferior, used by the probes-
360 struct so_list
*solib_list
= nullptr;
363 /* Per-program-space data key. */
364 static const struct program_space_key
<svr4_info
> solib_svr4_pspace_data
;
366 /* Free the probes table. */
369 free_probes_table (struct svr4_info
*info
)
371 info
->probes_table
.reset (nullptr);
374 /* Free the solib list. */
377 free_solib_list (struct svr4_info
*info
)
379 svr4_free_library_list (&info
->solib_list
);
380 info
->solib_list
= NULL
;
383 svr4_info::~svr4_info ()
385 free_solib_list (this);
388 /* Get the svr4 data for program space PSPACE. If none is found yet, add it now.
389 This function always returns a valid object. */
391 static struct svr4_info
*
392 get_svr4_info (program_space
*pspace
)
394 struct svr4_info
*info
= solib_svr4_pspace_data
.get (pspace
);
397 info
= solib_svr4_pspace_data
.emplace (pspace
);
402 /* Local function prototypes */
404 static int match_main (const char *);
406 /* Read program header TYPE from inferior memory. The header is found
407 by scanning the OS auxiliary vector.
409 If TYPE == -1, return the program headers instead of the contents of
412 Return vector of bytes holding the program header contents, or an empty
413 optional on failure. If successful and P_ARCH_SIZE is non-NULL, the target
414 architecture size (32-bit or 64-bit) is returned to *P_ARCH_SIZE. Likewise,
415 the base address of the section is returned in *BASE_ADDR. */
417 static gdb::optional
<gdb::byte_vector
>
418 read_program_header (int type
, int *p_arch_size
, CORE_ADDR
*base_addr
)
420 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
421 CORE_ADDR at_phdr
, at_phent
, at_phnum
, pt_phdr
= 0;
422 int arch_size
, sect_size
;
426 /* Get required auxv elements from target. */
427 if (target_auxv_search (current_top_target (), AT_PHDR
, &at_phdr
) <= 0)
429 if (target_auxv_search (current_top_target (), AT_PHENT
, &at_phent
) <= 0)
431 if (target_auxv_search (current_top_target (), AT_PHNUM
, &at_phnum
) <= 0)
433 if (!at_phdr
|| !at_phnum
)
436 /* Determine ELF architecture type. */
437 if (at_phent
== sizeof (Elf32_External_Phdr
))
439 else if (at_phent
== sizeof (Elf64_External_Phdr
))
444 /* Find the requested segment. */
448 sect_size
= at_phent
* at_phnum
;
450 else if (arch_size
== 32)
452 Elf32_External_Phdr phdr
;
455 /* Search for requested PHDR. */
456 for (i
= 0; i
< at_phnum
; i
++)
460 if (target_read_memory (at_phdr
+ i
* sizeof (phdr
),
461 (gdb_byte
*)&phdr
, sizeof (phdr
)))
464 p_type
= extract_unsigned_integer ((gdb_byte
*) phdr
.p_type
,
467 if (p_type
== PT_PHDR
)
470 pt_phdr
= extract_unsigned_integer ((gdb_byte
*) phdr
.p_vaddr
,
481 /* Retrieve address and size. */
482 sect_addr
= extract_unsigned_integer ((gdb_byte
*)phdr
.p_vaddr
,
484 sect_size
= extract_unsigned_integer ((gdb_byte
*)phdr
.p_memsz
,
489 Elf64_External_Phdr phdr
;
492 /* Search for requested PHDR. */
493 for (i
= 0; i
< at_phnum
; i
++)
497 if (target_read_memory (at_phdr
+ i
* sizeof (phdr
),
498 (gdb_byte
*)&phdr
, sizeof (phdr
)))
501 p_type
= extract_unsigned_integer ((gdb_byte
*) phdr
.p_type
,
504 if (p_type
== PT_PHDR
)
507 pt_phdr
= extract_unsigned_integer ((gdb_byte
*) phdr
.p_vaddr
,
518 /* Retrieve address and size. */
519 sect_addr
= extract_unsigned_integer ((gdb_byte
*)phdr
.p_vaddr
,
521 sect_size
= extract_unsigned_integer ((gdb_byte
*)phdr
.p_memsz
,
525 /* PT_PHDR is optional, but we really need it
526 for PIE to make this work in general. */
530 /* at_phdr is real address in memory. pt_phdr is what pheader says it is.
531 Relocation offset is the difference between the two. */
532 sect_addr
= sect_addr
+ (at_phdr
- pt_phdr
);
535 /* Read in requested program header. */
536 gdb::byte_vector
buf (sect_size
);
537 if (target_read_memory (sect_addr
, buf
.data (), sect_size
))
541 *p_arch_size
= arch_size
;
543 *base_addr
= sect_addr
;
549 /* Return program interpreter string. */
550 static gdb::optional
<gdb::byte_vector
>
551 find_program_interpreter (void)
553 /* If we have an exec_bfd, use its section table. */
555 && bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
557 struct bfd_section
*interp_sect
;
559 interp_sect
= bfd_get_section_by_name (exec_bfd
, ".interp");
560 if (interp_sect
!= NULL
)
562 int sect_size
= bfd_section_size (exec_bfd
, interp_sect
);
564 gdb::byte_vector
buf (sect_size
);
565 bfd_get_section_contents (exec_bfd
, interp_sect
, buf
.data (), 0,
571 /* If we didn't find it, use the target auxiliary vector. */
572 return read_program_header (PT_INTERP
, NULL
, NULL
);
576 /* Scan for DESIRED_DYNTAG in .dynamic section of ABFD. If DESIRED_DYNTAG is
577 found, 1 is returned and the corresponding PTR is set. */
580 scan_dyntag (const int desired_dyntag
, bfd
*abfd
, CORE_ADDR
*ptr
,
583 int arch_size
, step
, sect_size
;
585 CORE_ADDR dyn_ptr
, dyn_addr
;
586 gdb_byte
*bufend
, *bufstart
, *buf
;
587 Elf32_External_Dyn
*x_dynp_32
;
588 Elf64_External_Dyn
*x_dynp_64
;
589 struct bfd_section
*sect
;
590 struct target_section
*target_section
;
595 if (bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
598 arch_size
= bfd_get_arch_size (abfd
);
602 /* Find the start address of the .dynamic section. */
603 sect
= bfd_get_section_by_name (abfd
, ".dynamic");
607 for (target_section
= current_target_sections
->sections
;
608 target_section
< current_target_sections
->sections_end
;
610 if (sect
== target_section
->the_bfd_section
)
612 if (target_section
< current_target_sections
->sections_end
)
613 dyn_addr
= target_section
->addr
;
616 /* ABFD may come from OBJFILE acting only as a symbol file without being
617 loaded into the target (see add_symbol_file_command). This case is
618 such fallback to the file VMA address without the possibility of
619 having the section relocated to its actual in-memory address. */
621 dyn_addr
= bfd_section_vma (abfd
, sect
);
624 /* Read in .dynamic from the BFD. We will get the actual value
625 from memory later. */
626 sect_size
= bfd_section_size (abfd
, sect
);
627 buf
= bufstart
= (gdb_byte
*) alloca (sect_size
);
628 if (!bfd_get_section_contents (abfd
, sect
,
632 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
633 step
= (arch_size
== 32) ? sizeof (Elf32_External_Dyn
)
634 : sizeof (Elf64_External_Dyn
);
635 for (bufend
= buf
+ sect_size
;
641 x_dynp_32
= (Elf32_External_Dyn
*) buf
;
642 current_dyntag
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_tag
);
643 dyn_ptr
= bfd_h_get_32 (abfd
, (bfd_byte
*) x_dynp_32
->d_un
.d_ptr
);
647 x_dynp_64
= (Elf64_External_Dyn
*) buf
;
648 current_dyntag
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_tag
);
649 dyn_ptr
= bfd_h_get_64 (abfd
, (bfd_byte
*) x_dynp_64
->d_un
.d_ptr
);
651 if (current_dyntag
== DT_NULL
)
653 if (current_dyntag
== desired_dyntag
)
655 /* If requested, try to read the runtime value of this .dynamic
659 struct type
*ptr_type
;
661 CORE_ADDR ptr_addr_1
;
663 ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
664 ptr_addr_1
= dyn_addr
+ (buf
- bufstart
) + arch_size
/ 8;
665 if (target_read_memory (ptr_addr_1
, ptr_buf
, arch_size
/ 8) == 0)
666 dyn_ptr
= extract_typed_address (ptr_buf
, ptr_type
);
669 *ptr_addr
= dyn_addr
+ (buf
- bufstart
);
678 /* Scan for DESIRED_DYNTAG in .dynamic section of the target's main executable,
679 found by consulting the OS auxillary vector. If DESIRED_DYNTAG is found, 1
680 is returned and the corresponding PTR is set. */
683 scan_dyntag_auxv (const int desired_dyntag
, CORE_ADDR
*ptr
,
686 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
692 /* Read in .dynamic section. */
693 gdb::optional
<gdb::byte_vector
> ph_data
694 = read_program_header (PT_DYNAMIC
, &arch_size
, &base_addr
);
698 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
699 step
= (arch_size
== 32) ? sizeof (Elf32_External_Dyn
)
700 : sizeof (Elf64_External_Dyn
);
701 for (gdb_byte
*buf
= ph_data
->data (), *bufend
= buf
+ ph_data
->size ();
702 buf
< bufend
; buf
+= step
)
706 Elf32_External_Dyn
*dynp
= (Elf32_External_Dyn
*) buf
;
708 current_dyntag
= extract_unsigned_integer ((gdb_byte
*) dynp
->d_tag
,
710 dyn_ptr
= extract_unsigned_integer ((gdb_byte
*) dynp
->d_un
.d_ptr
,
715 Elf64_External_Dyn
*dynp
= (Elf64_External_Dyn
*) buf
;
717 current_dyntag
= extract_unsigned_integer ((gdb_byte
*) dynp
->d_tag
,
719 dyn_ptr
= extract_unsigned_integer ((gdb_byte
*) dynp
->d_un
.d_ptr
,
722 if (current_dyntag
== DT_NULL
)
725 if (current_dyntag
== desired_dyntag
)
731 *ptr_addr
= base_addr
+ buf
- ph_data
->data ();
740 /* Locate the base address of dynamic linker structs for SVR4 elf
743 For SVR4 elf targets the address of the dynamic linker's runtime
744 structure is contained within the dynamic info section in the
745 executable file. The dynamic section is also mapped into the
746 inferior address space. Because the runtime loader fills in the
747 real address before starting the inferior, we have to read in the
748 dynamic info section from the inferior address space.
749 If there are any errors while trying to find the address, we
750 silently return 0, otherwise the found address is returned. */
753 elf_locate_base (void)
755 struct bound_minimal_symbol msymbol
;
756 CORE_ADDR dyn_ptr
, dyn_ptr_addr
;
758 /* Look for DT_MIPS_RLD_MAP first. MIPS executables use this
759 instead of DT_DEBUG, although they sometimes contain an unused
761 if (scan_dyntag (DT_MIPS_RLD_MAP
, exec_bfd
, &dyn_ptr
, NULL
)
762 || scan_dyntag_auxv (DT_MIPS_RLD_MAP
, &dyn_ptr
, NULL
))
764 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
766 int pbuf_size
= TYPE_LENGTH (ptr_type
);
768 pbuf
= (gdb_byte
*) alloca (pbuf_size
);
769 /* DT_MIPS_RLD_MAP contains a pointer to the address
770 of the dynamic link structure. */
771 if (target_read_memory (dyn_ptr
, pbuf
, pbuf_size
))
773 return extract_typed_address (pbuf
, ptr_type
);
776 /* Then check DT_MIPS_RLD_MAP_REL. MIPS executables now use this form
777 because of needing to support PIE. DT_MIPS_RLD_MAP will also exist
779 if (scan_dyntag (DT_MIPS_RLD_MAP_REL
, exec_bfd
, &dyn_ptr
, &dyn_ptr_addr
)
780 || scan_dyntag_auxv (DT_MIPS_RLD_MAP_REL
, &dyn_ptr
, &dyn_ptr_addr
))
782 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
784 int pbuf_size
= TYPE_LENGTH (ptr_type
);
786 pbuf
= (gdb_byte
*) alloca (pbuf_size
);
787 /* DT_MIPS_RLD_MAP_REL contains an offset from the address of the
788 DT slot to the address of the dynamic link structure. */
789 if (target_read_memory (dyn_ptr
+ dyn_ptr_addr
, pbuf
, pbuf_size
))
791 return extract_typed_address (pbuf
, ptr_type
);
795 if (scan_dyntag (DT_DEBUG
, exec_bfd
, &dyn_ptr
, NULL
)
796 || scan_dyntag_auxv (DT_DEBUG
, &dyn_ptr
, NULL
))
799 /* This may be a static executable. Look for the symbol
800 conventionally named _r_debug, as a last resort. */
801 msymbol
= lookup_minimal_symbol ("_r_debug", NULL
, symfile_objfile
);
802 if (msymbol
.minsym
!= NULL
)
803 return BMSYMBOL_VALUE_ADDRESS (msymbol
);
805 /* DT_DEBUG entry not found. */
809 /* Locate the base address of dynamic linker structs.
811 For both the SunOS and SVR4 shared library implementations, if the
812 inferior executable has been linked dynamically, there is a single
813 address somewhere in the inferior's data space which is the key to
814 locating all of the dynamic linker's runtime structures. This
815 address is the value of the debug base symbol. The job of this
816 function is to find and return that address, or to return 0 if there
817 is no such address (the executable is statically linked for example).
819 For SunOS, the job is almost trivial, since the dynamic linker and
820 all of it's structures are statically linked to the executable at
821 link time. Thus the symbol for the address we are looking for has
822 already been added to the minimal symbol table for the executable's
823 objfile at the time the symbol file's symbols were read, and all we
824 have to do is look it up there. Note that we explicitly do NOT want
825 to find the copies in the shared library.
827 The SVR4 version is a bit more complicated because the address
828 is contained somewhere in the dynamic info section. We have to go
829 to a lot more work to discover the address of the debug base symbol.
830 Because of this complexity, we cache the value we find and return that
831 value on subsequent invocations. Note there is no copy in the
832 executable symbol tables. */
835 locate_base (struct svr4_info
*info
)
837 /* Check to see if we have a currently valid address, and if so, avoid
838 doing all this work again and just return the cached address. If
839 we have no cached address, try to locate it in the dynamic info
840 section for ELF executables. There's no point in doing any of this
841 though if we don't have some link map offsets to work with. */
843 if (info
->debug_base
== 0 && svr4_have_link_map_offsets ())
844 info
->debug_base
= elf_locate_base ();
845 return info
->debug_base
;
848 /* Find the first element in the inferior's dynamic link map, and
849 return its address in the inferior. Return zero if the address
850 could not be determined.
852 FIXME: Perhaps we should validate the info somehow, perhaps by
853 checking r_version for a known version number, or r_state for
857 solib_svr4_r_map (struct svr4_info
*info
)
859 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
860 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
865 addr
= read_memory_typed_address (info
->debug_base
+ lmo
->r_map_offset
,
868 catch (const gdb_exception_error
&ex
)
870 exception_print (gdb_stderr
, ex
);
876 /* Find r_brk from the inferior's debug base. */
879 solib_svr4_r_brk (struct svr4_info
*info
)
881 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
882 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
884 return read_memory_typed_address (info
->debug_base
+ lmo
->r_brk_offset
,
888 /* Find the link map for the dynamic linker (if it is not in the
889 normal list of loaded shared objects). */
892 solib_svr4_r_ldsomap (struct svr4_info
*info
)
894 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
895 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
896 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
897 ULONGEST version
= 0;
901 /* Check version, and return zero if `struct r_debug' doesn't have
902 the r_ldsomap member. */
904 = read_memory_unsigned_integer (info
->debug_base
+ lmo
->r_version_offset
,
905 lmo
->r_version_size
, byte_order
);
907 catch (const gdb_exception_error
&ex
)
909 exception_print (gdb_stderr
, ex
);
912 if (version
< 2 || lmo
->r_ldsomap_offset
== -1)
915 return read_memory_typed_address (info
->debug_base
+ lmo
->r_ldsomap_offset
,
919 /* On Solaris systems with some versions of the dynamic linker,
920 ld.so's l_name pointer points to the SONAME in the string table
921 rather than into writable memory. So that GDB can find shared
922 libraries when loading a core file generated by gcore, ensure that
923 memory areas containing the l_name string are saved in the core
927 svr4_keep_data_in_core (CORE_ADDR vaddr
, unsigned long size
)
929 struct svr4_info
*info
;
933 info
= get_svr4_info (current_program_space
);
935 info
->debug_base
= 0;
937 if (!info
->debug_base
)
940 ldsomap
= solib_svr4_r_ldsomap (info
);
944 std::unique_ptr
<lm_info_svr4
> li
= lm_info_read (ldsomap
);
945 name_lm
= li
!= NULL
? li
->l_name
: 0;
947 return (name_lm
>= vaddr
&& name_lm
< vaddr
+ size
);
953 open_symbol_file_object (int from_tty
)
955 CORE_ADDR lm
, l_name
;
956 gdb::unique_xmalloc_ptr
<char> filename
;
958 struct link_map_offsets
*lmo
= svr4_fetch_link_map_offsets ();
959 struct type
*ptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
960 int l_name_size
= TYPE_LENGTH (ptr_type
);
961 gdb::byte_vector
l_name_buf (l_name_size
);
962 struct svr4_info
*info
= get_svr4_info (current_program_space
);
963 symfile_add_flags add_flags
= 0;
966 add_flags
|= SYMFILE_VERBOSE
;
969 if (!query (_("Attempt to reload symbols from process? ")))
972 /* Always locate the debug struct, in case it has moved. */
973 info
->debug_base
= 0;
974 if (locate_base (info
) == 0)
975 return 0; /* failed somehow... */
977 /* First link map member should be the executable. */
978 lm
= solib_svr4_r_map (info
);
980 return 0; /* failed somehow... */
982 /* Read address of name from target memory to GDB. */
983 read_memory (lm
+ lmo
->l_name_offset
, l_name_buf
.data (), l_name_size
);
985 /* Convert the address to host format. */
986 l_name
= extract_typed_address (l_name_buf
.data (), ptr_type
);
989 return 0; /* No filename. */
991 /* Now fetch the filename from target memory. */
992 target_read_string (l_name
, &filename
, SO_NAME_MAX_PATH_SIZE
- 1, &errcode
);
996 warning (_("failed to read exec filename from attached file: %s"),
997 safe_strerror (errcode
));
1001 /* Have a pathname: read the symbol file. */
1002 symbol_file_add_main (filename
.get (), add_flags
);
1007 /* Data exchange structure for the XML parser as returned by
1008 svr4_current_sos_via_xfer_libraries. */
1010 struct svr4_library_list
1012 struct so_list
*head
, **tailp
;
1014 /* Inferior address of struct link_map used for the main executable. It is
1015 NULL if not known. */
1019 /* This module's 'free_objfile' observer. */
1022 svr4_free_objfile_observer (struct objfile
*objfile
)
1024 probes_table_remove_objfile_probes (objfile
);
1027 /* Implementation for target_so_ops.free_so. */
1030 svr4_free_so (struct so_list
*so
)
1032 lm_info_svr4
*li
= (lm_info_svr4
*) so
->lm_info
;
1037 /* Implement target_so_ops.clear_so. */
1040 svr4_clear_so (struct so_list
*so
)
1042 lm_info_svr4
*li
= (lm_info_svr4
*) so
->lm_info
;
1048 /* Free so_list built so far (called via cleanup). */
1051 svr4_free_library_list (void *p_list
)
1053 struct so_list
*list
= *(struct so_list
**) p_list
;
1055 while (list
!= NULL
)
1057 struct so_list
*next
= list
->next
;
1064 /* Copy library list. */
1066 static struct so_list
*
1067 svr4_copy_library_list (struct so_list
*src
)
1069 struct so_list
*dst
= NULL
;
1070 struct so_list
**link
= &dst
;
1074 struct so_list
*newobj
;
1076 newobj
= XNEW (struct so_list
);
1077 memcpy (newobj
, src
, sizeof (struct so_list
));
1079 lm_info_svr4
*src_li
= (lm_info_svr4
*) src
->lm_info
;
1080 newobj
->lm_info
= new lm_info_svr4 (*src_li
);
1082 newobj
->next
= NULL
;
1084 link
= &newobj
->next
;
1092 #ifdef HAVE_LIBEXPAT
1094 #include "xml-support.h"
1096 /* Handle the start of a <library> element. Note: new elements are added
1097 at the tail of the list, keeping the list in order. */
1100 library_list_start_library (struct gdb_xml_parser
*parser
,
1101 const struct gdb_xml_element
*element
,
1103 std::vector
<gdb_xml_value
> &attributes
)
1105 struct svr4_library_list
*list
= (struct svr4_library_list
*) user_data
;
1107 = (const char *) xml_find_attribute (attributes
, "name")->value
.get ();
1109 = (ULONGEST
*) xml_find_attribute (attributes
, "lm")->value
.get ();
1111 = (ULONGEST
*) xml_find_attribute (attributes
, "l_addr")->value
.get ();
1113 = (ULONGEST
*) xml_find_attribute (attributes
, "l_ld")->value
.get ();
1114 struct so_list
*new_elem
;
1116 new_elem
= XCNEW (struct so_list
);
1117 lm_info_svr4
*li
= new lm_info_svr4
;
1118 new_elem
->lm_info
= li
;
1120 li
->l_addr_inferior
= *l_addrp
;
1123 strncpy (new_elem
->so_name
, name
, sizeof (new_elem
->so_name
) - 1);
1124 new_elem
->so_name
[sizeof (new_elem
->so_name
) - 1] = 0;
1125 strcpy (new_elem
->so_original_name
, new_elem
->so_name
);
1127 *list
->tailp
= new_elem
;
1128 list
->tailp
= &new_elem
->next
;
1131 /* Handle the start of a <library-list-svr4> element. */
1134 svr4_library_list_start_list (struct gdb_xml_parser
*parser
,
1135 const struct gdb_xml_element
*element
,
1137 std::vector
<gdb_xml_value
> &attributes
)
1139 struct svr4_library_list
*list
= (struct svr4_library_list
*) user_data
;
1141 = (const char *) xml_find_attribute (attributes
, "version")->value
.get ();
1142 struct gdb_xml_value
*main_lm
= xml_find_attribute (attributes
, "main-lm");
1144 if (strcmp (version
, "1.0") != 0)
1145 gdb_xml_error (parser
,
1146 _("SVR4 Library list has unsupported version \"%s\""),
1150 list
->main_lm
= *(ULONGEST
*) main_lm
->value
.get ();
1153 /* The allowed elements and attributes for an XML library list.
1154 The root element is a <library-list>. */
1156 static const struct gdb_xml_attribute svr4_library_attributes
[] =
1158 { "name", GDB_XML_AF_NONE
, NULL
, NULL
},
1159 { "lm", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
1160 { "l_addr", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
1161 { "l_ld", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
1162 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
1165 static const struct gdb_xml_element svr4_library_list_children
[] =
1168 "library", svr4_library_attributes
, NULL
,
1169 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
1170 library_list_start_library
, NULL
1172 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
1175 static const struct gdb_xml_attribute svr4_library_list_attributes
[] =
1177 { "version", GDB_XML_AF_NONE
, NULL
, NULL
},
1178 { "main-lm", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
1179 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
1182 static const struct gdb_xml_element svr4_library_list_elements
[] =
1184 { "library-list-svr4", svr4_library_list_attributes
, svr4_library_list_children
,
1185 GDB_XML_EF_NONE
, svr4_library_list_start_list
, NULL
},
1186 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
1189 /* Parse qXfer:libraries:read packet into *SO_LIST_RETURN. Return 1 if
1191 Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
1192 case. Return 1 if *SO_LIST_RETURN contains the library list, it may be
1193 empty, caller is responsible for freeing all its entries. */
1196 svr4_parse_libraries (const char *document
, struct svr4_library_list
*list
)
1198 auto cleanup
= make_scope_exit ([&] ()
1200 svr4_free_library_list (&list
->head
);
1203 memset (list
, 0, sizeof (*list
));
1204 list
->tailp
= &list
->head
;
1205 if (gdb_xml_parse_quick (_("target library list"), "library-list-svr4.dtd",
1206 svr4_library_list_elements
, document
, list
) == 0)
1208 /* Parsed successfully, keep the result. */
1216 /* Attempt to get so_list from target via qXfer:libraries-svr4:read packet.
1218 Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
1219 case. Return 1 if *SO_LIST_RETURN contains the library list, it may be
1220 empty, caller is responsible for freeing all its entries.
1222 Note that ANNEX must be NULL if the remote does not explicitly allow
1223 qXfer:libraries-svr4:read packets with non-empty annexes. Support for
1224 this can be checked using target_augmented_libraries_svr4_read (). */
1227 svr4_current_sos_via_xfer_libraries (struct svr4_library_list
*list
,
1230 gdb_assert (annex
== NULL
|| target_augmented_libraries_svr4_read ());
1232 /* Fetch the list of shared libraries. */
1233 gdb::optional
<gdb::char_vector
> svr4_library_document
1234 = target_read_stralloc (current_top_target (), TARGET_OBJECT_LIBRARIES_SVR4
,
1236 if (!svr4_library_document
)
1239 return svr4_parse_libraries (svr4_library_document
->data (), list
);
1245 svr4_current_sos_via_xfer_libraries (struct svr4_library_list
*list
,
1253 /* If no shared library information is available from the dynamic
1254 linker, build a fallback list from other sources. */
1256 static struct so_list
*
1257 svr4_default_sos (svr4_info
*info
)
1259 struct so_list
*newobj
;
1261 if (!info
->debug_loader_offset_p
)
1264 newobj
= XCNEW (struct so_list
);
1265 lm_info_svr4
*li
= new lm_info_svr4
;
1266 newobj
->lm_info
= li
;
1268 /* Nothing will ever check the other fields if we set l_addr_p. */
1269 li
->l_addr
= info
->debug_loader_offset
;
1272 strncpy (newobj
->so_name
, info
->debug_loader_name
, SO_NAME_MAX_PATH_SIZE
- 1);
1273 newobj
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
1274 strcpy (newobj
->so_original_name
, newobj
->so_name
);
1279 /* Read the whole inferior libraries chain starting at address LM.
1280 Expect the first entry in the chain's previous entry to be PREV_LM.
1281 Add the entries to the tail referenced by LINK_PTR_PTR. Ignore the
1282 first entry if IGNORE_FIRST and set global MAIN_LM_ADDR according
1283 to it. Returns nonzero upon success. If zero is returned the
1284 entries stored to LINK_PTR_PTR are still valid although they may
1285 represent only part of the inferior library list. */
1288 svr4_read_so_list (svr4_info
*info
, CORE_ADDR lm
, CORE_ADDR prev_lm
,
1289 struct so_list
***link_ptr_ptr
, int ignore_first
)
1291 CORE_ADDR first_l_name
= 0;
1294 for (; lm
!= 0; prev_lm
= lm
, lm
= next_lm
)
1297 gdb::unique_xmalloc_ptr
<char> buffer
;
1299 so_list_up
newobj (XCNEW (struct so_list
));
1301 lm_info_svr4
*li
= lm_info_read (lm
).release ();
1302 newobj
->lm_info
= li
;
1306 next_lm
= li
->l_next
;
1308 if (li
->l_prev
!= prev_lm
)
1310 warning (_("Corrupted shared library list: %s != %s"),
1311 paddress (target_gdbarch (), prev_lm
),
1312 paddress (target_gdbarch (), li
->l_prev
));
1316 /* For SVR4 versions, the first entry in the link map is for the
1317 inferior executable, so we must ignore it. For some versions of
1318 SVR4, it has no name. For others (Solaris 2.3 for example), it
1319 does have a name, so we can no longer use a missing name to
1320 decide when to ignore it. */
1321 if (ignore_first
&& li
->l_prev
== 0)
1323 first_l_name
= li
->l_name
;
1324 info
->main_lm_addr
= li
->lm_addr
;
1328 /* Extract this shared object's name. */
1329 target_read_string (li
->l_name
, &buffer
, SO_NAME_MAX_PATH_SIZE
- 1,
1333 /* If this entry's l_name address matches that of the
1334 inferior executable, then this is not a normal shared
1335 object, but (most likely) a vDSO. In this case, silently
1336 skip it; otherwise emit a warning. */
1337 if (first_l_name
== 0 || li
->l_name
!= first_l_name
)
1338 warning (_("Can't read pathname for load map: %s."),
1339 safe_strerror (errcode
));
1343 strncpy (newobj
->so_name
, buffer
.get (), SO_NAME_MAX_PATH_SIZE
- 1);
1344 newobj
->so_name
[SO_NAME_MAX_PATH_SIZE
- 1] = '\0';
1345 strcpy (newobj
->so_original_name
, newobj
->so_name
);
1347 /* If this entry has no name, or its name matches the name
1348 for the main executable, don't include it in the list. */
1349 if (! newobj
->so_name
[0] || match_main (newobj
->so_name
))
1353 /* Don't free it now. */
1354 **link_ptr_ptr
= newobj
.release ();
1355 *link_ptr_ptr
= &(**link_ptr_ptr
)->next
;
1361 /* Read the full list of currently loaded shared objects directly
1362 from the inferior, without referring to any libraries read and
1363 stored by the probes interface. Handle special cases relating
1364 to the first elements of the list. */
1366 static struct so_list
*
1367 svr4_current_sos_direct (struct svr4_info
*info
)
1370 struct so_list
*head
= NULL
;
1371 struct so_list
**link_ptr
= &head
;
1373 struct svr4_library_list library_list
;
1375 /* Fall back to manual examination of the target if the packet is not
1376 supported or gdbserver failed to find DT_DEBUG. gdb.server/solib-list.exp
1377 tests a case where gdbserver cannot find the shared libraries list while
1378 GDB itself is able to find it via SYMFILE_OBJFILE.
1380 Unfortunately statically linked inferiors will also fall back through this
1381 suboptimal code path. */
1383 info
->using_xfer
= svr4_current_sos_via_xfer_libraries (&library_list
,
1385 if (info
->using_xfer
)
1387 if (library_list
.main_lm
)
1388 info
->main_lm_addr
= library_list
.main_lm
;
1390 return library_list
.head
? library_list
.head
: svr4_default_sos (info
);
1393 /* Always locate the debug struct, in case it has moved. */
1394 info
->debug_base
= 0;
1397 /* If we can't find the dynamic linker's base structure, this
1398 must not be a dynamically linked executable. Hmm. */
1399 if (! info
->debug_base
)
1400 return svr4_default_sos (info
);
1402 /* Assume that everything is a library if the dynamic loader was loaded
1403 late by a static executable. */
1404 if (exec_bfd
&& bfd_get_section_by_name (exec_bfd
, ".dynamic") == NULL
)
1409 auto cleanup
= make_scope_exit ([&] ()
1411 svr4_free_library_list (&head
);
1414 /* Walk the inferior's link map list, and build our list of
1415 `struct so_list' nodes. */
1416 lm
= solib_svr4_r_map (info
);
1418 svr4_read_so_list (info
, lm
, 0, &link_ptr
, ignore_first
);
1420 /* On Solaris, the dynamic linker is not in the normal list of
1421 shared objects, so make sure we pick it up too. Having
1422 symbol information for the dynamic linker is quite crucial
1423 for skipping dynamic linker resolver code. */
1424 lm
= solib_svr4_r_ldsomap (info
);
1426 svr4_read_so_list (info
, lm
, 0, &link_ptr
, 0);
1431 return svr4_default_sos (info
);
1436 /* Implement the main part of the "current_sos" target_so_ops
1439 static struct so_list
*
1440 svr4_current_sos_1 (svr4_info
*info
)
1442 /* If the solib list has been read and stored by the probes
1443 interface then we return a copy of the stored list. */
1444 if (info
->solib_list
!= NULL
)
1445 return svr4_copy_library_list (info
->solib_list
);
1447 /* Otherwise obtain the solib list directly from the inferior. */
1448 return svr4_current_sos_direct (info
);
1451 /* Implement the "current_sos" target_so_ops method. */
1453 static struct so_list
*
1454 svr4_current_sos (void)
1456 svr4_info
*info
= get_svr4_info (current_program_space
);
1457 struct so_list
*so_head
= svr4_current_sos_1 (info
);
1458 struct mem_range vsyscall_range
;
1460 /* Filter out the vDSO module, if present. Its symbol file would
1461 not be found on disk. The vDSO/vsyscall's OBJFILE is instead
1462 managed by symfile-mem.c:add_vsyscall_page. */
1463 if (gdbarch_vsyscall_range (target_gdbarch (), &vsyscall_range
)
1464 && vsyscall_range
.length
!= 0)
1466 struct so_list
**sop
;
1469 while (*sop
!= NULL
)
1471 struct so_list
*so
= *sop
;
1473 /* We can't simply match the vDSO by starting address alone,
1474 because lm_info->l_addr_inferior (and also l_addr) do not
1475 necessarily represent the real starting address of the
1476 ELF if the vDSO's ELF itself is "prelinked". The l_ld
1477 field (the ".dynamic" section of the shared object)
1478 always points at the absolute/resolved address though.
1479 So check whether that address is inside the vDSO's
1482 E.g., on Linux 3.16 (x86_64) the vDSO is a regular
1483 0-based ELF, and we see:
1486 33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffb000
1487 (gdb) p/x *_r_debug.r_map.l_next
1488 $1 = {l_addr = 0x7ffff7ffb000, ..., l_ld = 0x7ffff7ffb318, ...}
1490 And on Linux 2.6.32 (x86_64) we see:
1493 33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffe000
1494 (gdb) p/x *_r_debug.r_map.l_next
1495 $5 = {l_addr = 0x7ffff88fe000, ..., l_ld = 0x7ffff7ffe580, ... }
1497 Dumping that vDSO shows:
1499 (gdb) info proc mappings
1500 0x7ffff7ffe000 0x7ffff7fff000 0x1000 0 [vdso]
1501 (gdb) dump memory vdso.bin 0x7ffff7ffe000 0x7ffff7fff000
1502 # readelf -Wa vdso.bin
1504 Entry point address: 0xffffffffff700700
1507 [Nr] Name Type Address Off Size
1508 [ 0] NULL 0000000000000000 000000 000000
1509 [ 1] .hash HASH ffffffffff700120 000120 000038
1510 [ 2] .dynsym DYNSYM ffffffffff700158 000158 0000d8
1512 [ 9] .dynamic DYNAMIC ffffffffff700580 000580 0000f0
1515 lm_info_svr4
*li
= (lm_info_svr4
*) so
->lm_info
;
1517 if (address_in_mem_range (li
->l_ld
, &vsyscall_range
))
1531 /* Get the address of the link_map for a given OBJFILE. */
1534 svr4_fetch_objfile_link_map (struct objfile
*objfile
)
1537 struct svr4_info
*info
= get_svr4_info (objfile
->pspace
);
1539 /* Cause svr4_current_sos() to be run if it hasn't been already. */
1540 if (info
->main_lm_addr
== 0)
1541 solib_add (NULL
, 0, auto_solib_add
);
1543 /* svr4_current_sos() will set main_lm_addr for the main executable. */
1544 if (objfile
== symfile_objfile
)
1545 return info
->main_lm_addr
;
1547 /* If OBJFILE is a separate debug object file, look for the
1548 original object file. */
1549 if (objfile
->separate_debug_objfile_backlink
!= NULL
)
1550 objfile
= objfile
->separate_debug_objfile_backlink
;
1552 /* The other link map addresses may be found by examining the list
1553 of shared libraries. */
1554 for (so
= master_so_list (); so
; so
= so
->next
)
1555 if (so
->objfile
== objfile
)
1557 lm_info_svr4
*li
= (lm_info_svr4
*) so
->lm_info
;
1566 /* On some systems, the only way to recognize the link map entry for
1567 the main executable file is by looking at its name. Return
1568 non-zero iff SONAME matches one of the known main executable names. */
1571 match_main (const char *soname
)
1573 const char * const *mainp
;
1575 for (mainp
= main_name_list
; *mainp
!= NULL
; mainp
++)
1577 if (strcmp (soname
, *mainp
) == 0)
1584 /* Return 1 if PC lies in the dynamic symbol resolution code of the
1585 SVR4 run time loader. */
1588 svr4_in_dynsym_resolve_code (CORE_ADDR pc
)
1590 struct svr4_info
*info
= get_svr4_info (current_program_space
);
1592 return ((pc
>= info
->interp_text_sect_low
1593 && pc
< info
->interp_text_sect_high
)
1594 || (pc
>= info
->interp_plt_sect_low
1595 && pc
< info
->interp_plt_sect_high
)
1596 || in_plt_section (pc
)
1597 || in_gnu_ifunc_stub (pc
));
1600 /* Given an executable's ABFD and target, compute the entry-point
1604 exec_entry_point (struct bfd
*abfd
, struct target_ops
*targ
)
1608 /* KevinB wrote ... for most targets, the address returned by
1609 bfd_get_start_address() is the entry point for the start
1610 function. But, for some targets, bfd_get_start_address() returns
1611 the address of a function descriptor from which the entry point
1612 address may be extracted. This address is extracted by
1613 gdbarch_convert_from_func_ptr_addr(). The method
1614 gdbarch_convert_from_func_ptr_addr() is the merely the identify
1615 function for targets which don't use function descriptors. */
1616 addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
1617 bfd_get_start_address (abfd
),
1619 return gdbarch_addr_bits_remove (target_gdbarch (), addr
);
1622 /* A probe and its associated action. */
1624 struct probe_and_action
1629 /* The relocated address of the probe. */
1633 enum probe_action action
;
1635 /* The objfile where this probe was found. */
1636 struct objfile
*objfile
;
1639 /* Returns a hash code for the probe_and_action referenced by p. */
1642 hash_probe_and_action (const void *p
)
1644 const struct probe_and_action
*pa
= (const struct probe_and_action
*) p
;
1646 return (hashval_t
) pa
->address
;
1649 /* Returns non-zero if the probe_and_actions referenced by p1 and p2
1653 equal_probe_and_action (const void *p1
, const void *p2
)
1655 const struct probe_and_action
*pa1
= (const struct probe_and_action
*) p1
;
1656 const struct probe_and_action
*pa2
= (const struct probe_and_action
*) p2
;
1658 return pa1
->address
== pa2
->address
;
1661 /* Traversal function for probes_table_remove_objfile_probes. */
1664 probes_table_htab_remove_objfile_probes (void **slot
, void *info
)
1666 probe_and_action
*pa
= (probe_and_action
*) *slot
;
1667 struct objfile
*objfile
= (struct objfile
*) info
;
1669 if (pa
->objfile
== objfile
)
1670 htab_clear_slot (get_svr4_info (objfile
->pspace
)->probes_table
.get (),
1676 /* Remove all probes that belong to OBJFILE from the probes table. */
1679 probes_table_remove_objfile_probes (struct objfile
*objfile
)
1681 svr4_info
*info
= get_svr4_info (objfile
->pspace
);
1682 if (info
->probes_table
!= nullptr)
1683 htab_traverse_noresize (info
->probes_table
.get (),
1684 probes_table_htab_remove_objfile_probes
, objfile
);
1687 /* Register a solib event probe and its associated action in the
1691 register_solib_event_probe (svr4_info
*info
, struct objfile
*objfile
,
1692 probe
*prob
, CORE_ADDR address
,
1693 enum probe_action action
)
1695 struct probe_and_action lookup
, *pa
;
1698 /* Create the probes table, if necessary. */
1699 if (info
->probes_table
== NULL
)
1700 info
->probes_table
.reset (htab_create_alloc (1, hash_probe_and_action
,
1701 equal_probe_and_action
,
1702 xfree
, xcalloc
, xfree
));
1704 lookup
.address
= address
;
1705 slot
= htab_find_slot (info
->probes_table
.get (), &lookup
, INSERT
);
1706 gdb_assert (*slot
== HTAB_EMPTY_ENTRY
);
1708 pa
= XCNEW (struct probe_and_action
);
1710 pa
->address
= address
;
1711 pa
->action
= action
;
1712 pa
->objfile
= objfile
;
1717 /* Get the solib event probe at the specified location, and the
1718 action associated with it. Returns NULL if no solib event probe
1721 static struct probe_and_action
*
1722 solib_event_probe_at (struct svr4_info
*info
, CORE_ADDR address
)
1724 struct probe_and_action lookup
;
1727 lookup
.address
= address
;
1728 slot
= htab_find_slot (info
->probes_table
.get (), &lookup
, NO_INSERT
);
1733 return (struct probe_and_action
*) *slot
;
1736 /* Decide what action to take when the specified solib event probe is
1739 static enum probe_action
1740 solib_event_probe_action (struct probe_and_action
*pa
)
1742 enum probe_action action
;
1743 unsigned probe_argc
= 0;
1744 struct frame_info
*frame
= get_current_frame ();
1746 action
= pa
->action
;
1747 if (action
== DO_NOTHING
|| action
== PROBES_INTERFACE_FAILED
)
1750 gdb_assert (action
== FULL_RELOAD
|| action
== UPDATE_OR_RELOAD
);
1752 /* Check that an appropriate number of arguments has been supplied.
1754 arg0: Lmid_t lmid (mandatory)
1755 arg1: struct r_debug *debug_base (mandatory)
1756 arg2: struct link_map *new (optional, for incremental updates) */
1759 probe_argc
= pa
->prob
->get_argument_count (get_frame_arch (frame
));
1761 catch (const gdb_exception_error
&ex
)
1763 exception_print (gdb_stderr
, ex
);
1767 /* If get_argument_count throws an exception, probe_argc will be set
1768 to zero. However, if pa->prob does not have arguments, then
1769 get_argument_count will succeed but probe_argc will also be zero.
1770 Both cases happen because of different things, but they are
1771 treated equally here: action will be set to
1772 PROBES_INTERFACE_FAILED. */
1773 if (probe_argc
== 2)
1774 action
= FULL_RELOAD
;
1775 else if (probe_argc
< 2)
1776 action
= PROBES_INTERFACE_FAILED
;
1781 /* Populate the shared object list by reading the entire list of
1782 shared objects from the inferior. Handle special cases relating
1783 to the first elements of the list. Returns nonzero on success. */
1786 solist_update_full (struct svr4_info
*info
)
1788 free_solib_list (info
);
1789 info
->solib_list
= svr4_current_sos_direct (info
);
1794 /* Update the shared object list starting from the link-map entry
1795 passed by the linker in the probe's third argument. Returns
1796 nonzero if the list was successfully updated, or zero to indicate
1800 solist_update_incremental (struct svr4_info
*info
, CORE_ADDR lm
)
1802 struct so_list
*tail
;
1805 /* svr4_current_sos_direct contains logic to handle a number of
1806 special cases relating to the first elements of the list. To
1807 avoid duplicating this logic we defer to solist_update_full
1808 if the list is empty. */
1809 if (info
->solib_list
== NULL
)
1812 /* Fall back to a full update if we are using a remote target
1813 that does not support incremental transfers. */
1814 if (info
->using_xfer
&& !target_augmented_libraries_svr4_read ())
1817 /* Walk to the end of the list. */
1818 for (tail
= info
->solib_list
; tail
->next
!= NULL
; tail
= tail
->next
)
1821 lm_info_svr4
*li
= (lm_info_svr4
*) tail
->lm_info
;
1822 prev_lm
= li
->lm_addr
;
1824 /* Read the new objects. */
1825 if (info
->using_xfer
)
1827 struct svr4_library_list library_list
;
1830 xsnprintf (annex
, sizeof (annex
), "start=%s;prev=%s",
1831 phex_nz (lm
, sizeof (lm
)),
1832 phex_nz (prev_lm
, sizeof (prev_lm
)));
1833 if (!svr4_current_sos_via_xfer_libraries (&library_list
, annex
))
1836 tail
->next
= library_list
.head
;
1840 struct so_list
**link
= &tail
->next
;
1842 /* IGNORE_FIRST may safely be set to zero here because the
1843 above check and deferral to solist_update_full ensures
1844 that this call to svr4_read_so_list will never see the
1846 if (!svr4_read_so_list (info
, lm
, prev_lm
, &link
, 0))
1853 /* Disable the probes-based linker interface and revert to the
1854 original interface. We don't reset the breakpoints as the
1855 ones set up for the probes-based interface are adequate. */
1858 disable_probes_interface (svr4_info
*info
)
1860 warning (_("Probes-based dynamic linker interface failed.\n"
1861 "Reverting to original interface."));
1863 free_probes_table (info
);
1864 free_solib_list (info
);
1867 /* Update the solib list as appropriate when using the
1868 probes-based linker interface. Do nothing if using the
1869 standard interface. */
1872 svr4_handle_solib_event (void)
1874 struct svr4_info
*info
= get_svr4_info (current_program_space
);
1875 struct probe_and_action
*pa
;
1876 enum probe_action action
;
1877 struct value
*val
= NULL
;
1878 CORE_ADDR pc
, debug_base
, lm
= 0;
1879 struct frame_info
*frame
= get_current_frame ();
1881 /* Do nothing if not using the probes interface. */
1882 if (info
->probes_table
== NULL
)
1885 /* If anything goes wrong we revert to the original linker
1887 auto cleanup
= make_scope_exit ([info
] ()
1889 disable_probes_interface (info
);
1892 pc
= regcache_read_pc (get_current_regcache ());
1893 pa
= solib_event_probe_at (info
, pc
);
1897 action
= solib_event_probe_action (pa
);
1898 if (action
== PROBES_INTERFACE_FAILED
)
1901 if (action
== DO_NOTHING
)
1907 /* evaluate_argument looks up symbols in the dynamic linker
1908 using find_pc_section. find_pc_section is accelerated by a cache
1909 called the section map. The section map is invalidated every
1910 time a shared library is loaded or unloaded, and if the inferior
1911 is generating a lot of shared library events then the section map
1912 will be updated every time svr4_handle_solib_event is called.
1913 We called find_pc_section in svr4_create_solib_event_breakpoints,
1914 so we can guarantee that the dynamic linker's sections are in the
1915 section map. We can therefore inhibit section map updates across
1916 these calls to evaluate_argument and save a lot of time. */
1918 scoped_restore inhibit_updates
1919 = inhibit_section_map_updates (current_program_space
);
1923 val
= pa
->prob
->evaluate_argument (1, frame
);
1925 catch (const gdb_exception_error
&ex
)
1927 exception_print (gdb_stderr
, ex
);
1934 debug_base
= value_as_address (val
);
1935 if (debug_base
== 0)
1938 /* Always locate the debug struct, in case it moved. */
1939 info
->debug_base
= 0;
1940 if (locate_base (info
) == 0)
1943 /* GDB does not currently support libraries loaded via dlmopen
1944 into namespaces other than the initial one. We must ignore
1945 any namespace other than the initial namespace here until
1946 support for this is added to GDB. */
1947 if (debug_base
!= info
->debug_base
)
1948 action
= DO_NOTHING
;
1950 if (action
== UPDATE_OR_RELOAD
)
1954 val
= pa
->prob
->evaluate_argument (2, frame
);
1956 catch (const gdb_exception_error
&ex
)
1958 exception_print (gdb_stderr
, ex
);
1963 lm
= value_as_address (val
);
1966 action
= FULL_RELOAD
;
1969 /* Resume section map updates. Closing the scope is
1973 if (action
== UPDATE_OR_RELOAD
)
1975 if (!solist_update_incremental (info
, lm
))
1976 action
= FULL_RELOAD
;
1979 if (action
== FULL_RELOAD
)
1981 if (!solist_update_full (info
))
1988 /* Helper function for svr4_update_solib_event_breakpoints. */
1991 svr4_update_solib_event_breakpoint (struct breakpoint
*b
, void *arg
)
1993 struct bp_location
*loc
;
1995 if (b
->type
!= bp_shlib_event
)
1997 /* Continue iterating. */
2001 for (loc
= b
->loc
; loc
!= NULL
; loc
= loc
->next
)
2003 struct svr4_info
*info
;
2004 struct probe_and_action
*pa
;
2006 info
= solib_svr4_pspace_data
.get (loc
->pspace
);
2007 if (info
== NULL
|| info
->probes_table
== NULL
)
2010 pa
= solib_event_probe_at (info
, loc
->address
);
2014 if (pa
->action
== DO_NOTHING
)
2016 if (b
->enable_state
== bp_disabled
&& stop_on_solib_events
)
2017 enable_breakpoint (b
);
2018 else if (b
->enable_state
== bp_enabled
&& !stop_on_solib_events
)
2019 disable_breakpoint (b
);
2025 /* Continue iterating. */
2029 /* Enable or disable optional solib event breakpoints as appropriate.
2030 Called whenever stop_on_solib_events is changed. */
2033 svr4_update_solib_event_breakpoints (void)
2035 iterate_over_breakpoints (svr4_update_solib_event_breakpoint
, NULL
);
2038 /* Create and register solib event breakpoints. PROBES is an array
2039 of NUM_PROBES elements, each of which is vector of probes. A
2040 solib event breakpoint will be created and registered for each
2044 svr4_create_probe_breakpoints (svr4_info
*info
, struct gdbarch
*gdbarch
,
2045 const std::vector
<probe
*> *probes
,
2046 struct objfile
*objfile
)
2048 for (int i
= 0; i
< NUM_PROBES
; i
++)
2050 enum probe_action action
= probe_info
[i
].action
;
2052 for (probe
*p
: probes
[i
])
2054 CORE_ADDR address
= p
->get_relocated_address (objfile
);
2056 create_solib_event_breakpoint (gdbarch
, address
);
2057 register_solib_event_probe (info
, objfile
, p
, address
, action
);
2061 svr4_update_solib_event_breakpoints ();
2064 /* Find all the glibc named probes. Only if all of the probes are found, then
2065 create them and return true. Otherwise return false. If WITH_PREFIX is set
2066 then add "rtld" to the front of the probe names. */
2068 svr4_find_and_create_probe_breakpoints (svr4_info
*info
,
2069 struct gdbarch
*gdbarch
,
2070 struct obj_section
*os
,
2073 std::vector
<probe
*> probes
[NUM_PROBES
];
2074 bool checked_can_use_probe_arguments
= false;
2076 for (int i
= 0; i
< NUM_PROBES
; i
++)
2078 const char *name
= probe_info
[i
].name
;
2081 /* Fedora 17 and Red Hat Enterprise Linux 6.2-6.4 shipped with an early
2082 version of the probes code in which the probes' names were prefixed
2083 with "rtld_" and the "map_failed" probe did not exist. The locations
2084 of the probes are otherwise the same, so we check for probes with
2085 prefixed names if probes with unprefixed names are not present. */
2088 xsnprintf (buf
, sizeof (buf
), "rtld_%s", name
);
2092 probes
[i
] = find_probes_in_objfile (os
->objfile
, "rtld", name
);
2094 /* The "map_failed" probe did not exist in early
2095 versions of the probes code in which the probes'
2096 names were prefixed with "rtld_". */
2097 if (with_prefix
&& streq (name
, "rtld_map_failed"))
2100 /* Ensure at least one probe for the current name was found. */
2101 if (probes
[i
].empty ())
2104 /* Ensure probe arguments can be evaluated. */
2105 if (!checked_can_use_probe_arguments
)
2107 probe
*p
= probes
[i
][0];
2108 if (!p
->can_evaluate_arguments ())
2110 checked_can_use_probe_arguments
= true;
2114 /* All probes found. Now create them. */
2115 svr4_create_probe_breakpoints (info
, gdbarch
, probes
, os
->objfile
);
2119 /* Both the SunOS and the SVR4 dynamic linkers call a marker function
2120 before and after mapping and unmapping shared libraries. The sole
2121 purpose of this method is to allow debuggers to set a breakpoint so
2122 they can track these changes.
2124 Some versions of the glibc dynamic linker contain named probes
2125 to allow more fine grained stopping. Given the address of the
2126 original marker function, this function attempts to find these
2127 probes, and if found, sets breakpoints on those instead. If the
2128 probes aren't found, a single breakpoint is set on the original
2132 svr4_create_solib_event_breakpoints (svr4_info
*info
, struct gdbarch
*gdbarch
,
2135 struct obj_section
*os
= find_pc_section (address
);
2138 || (!svr4_find_and_create_probe_breakpoints (info
, gdbarch
, os
, false)
2139 && !svr4_find_and_create_probe_breakpoints (info
, gdbarch
, os
, true)))
2140 create_solib_event_breakpoint (gdbarch
, address
);
2143 /* Helper function for gdb_bfd_lookup_symbol. */
2146 cmp_name_and_sec_flags (const asymbol
*sym
, const void *data
)
2148 return (strcmp (sym
->name
, (const char *) data
) == 0
2149 && (sym
->section
->flags
& (SEC_CODE
| SEC_DATA
)) != 0);
2151 /* Arrange for dynamic linker to hit breakpoint.
2153 Both the SunOS and the SVR4 dynamic linkers have, as part of their
2154 debugger interface, support for arranging for the inferior to hit
2155 a breakpoint after mapping in the shared libraries. This function
2156 enables that breakpoint.
2158 For SunOS, there is a special flag location (in_debugger) which we
2159 set to 1. When the dynamic linker sees this flag set, it will set
2160 a breakpoint at a location known only to itself, after saving the
2161 original contents of that place and the breakpoint address itself,
2162 in it's own internal structures. When we resume the inferior, it
2163 will eventually take a SIGTRAP when it runs into the breakpoint.
2164 We handle this (in a different place) by restoring the contents of
2165 the breakpointed location (which is only known after it stops),
2166 chasing around to locate the shared libraries that have been
2167 loaded, then resuming.
2169 For SVR4, the debugger interface structure contains a member (r_brk)
2170 which is statically initialized at the time the shared library is
2171 built, to the offset of a function (_r_debug_state) which is guaran-
2172 teed to be called once before mapping in a library, and again when
2173 the mapping is complete. At the time we are examining this member,
2174 it contains only the unrelocated offset of the function, so we have
2175 to do our own relocation. Later, when the dynamic linker actually
2176 runs, it relocates r_brk to be the actual address of _r_debug_state().
2178 The debugger interface structure also contains an enumeration which
2179 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
2180 depending upon whether or not the library is being mapped or unmapped,
2181 and then set to RT_CONSISTENT after the library is mapped/unmapped. */
2184 enable_break (struct svr4_info
*info
, int from_tty
)
2186 struct bound_minimal_symbol msymbol
;
2187 const char * const *bkpt_namep
;
2188 asection
*interp_sect
;
2191 info
->interp_text_sect_low
= info
->interp_text_sect_high
= 0;
2192 info
->interp_plt_sect_low
= info
->interp_plt_sect_high
= 0;
2194 /* If we already have a shared library list in the target, and
2195 r_debug contains r_brk, set the breakpoint there - this should
2196 mean r_brk has already been relocated. Assume the dynamic linker
2197 is the object containing r_brk. */
2199 solib_add (NULL
, from_tty
, auto_solib_add
);
2201 if (info
->debug_base
&& solib_svr4_r_map (info
) != 0)
2202 sym_addr
= solib_svr4_r_brk (info
);
2206 struct obj_section
*os
;
2208 sym_addr
= gdbarch_addr_bits_remove
2210 gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2212 current_top_target ()));
2214 /* On at least some versions of Solaris there's a dynamic relocation
2215 on _r_debug.r_brk and SYM_ADDR may not be relocated yet, e.g., if
2216 we get control before the dynamic linker has self-relocated.
2217 Check if SYM_ADDR is in a known section, if it is assume we can
2218 trust its value. This is just a heuristic though, it could go away
2219 or be replaced if it's getting in the way.
2221 On ARM we need to know whether the ISA of rtld_db_dlactivity (or
2222 however it's spelled in your particular system) is ARM or Thumb.
2223 That knowledge is encoded in the address, if it's Thumb the low bit
2224 is 1. However, we've stripped that info above and it's not clear
2225 what all the consequences are of passing a non-addr_bits_remove'd
2226 address to svr4_create_solib_event_breakpoints. The call to
2227 find_pc_section verifies we know about the address and have some
2228 hope of computing the right kind of breakpoint to use (via
2229 symbol info). It does mean that GDB needs to be pointed at a
2230 non-stripped version of the dynamic linker in order to obtain
2231 information it already knows about. Sigh. */
2233 os
= find_pc_section (sym_addr
);
2236 /* Record the relocated start and end address of the dynamic linker
2237 text and plt section for svr4_in_dynsym_resolve_code. */
2239 CORE_ADDR load_addr
;
2241 tmp_bfd
= os
->objfile
->obfd
;
2242 load_addr
= ANOFFSET (os
->objfile
->section_offsets
,
2243 SECT_OFF_TEXT (os
->objfile
));
2245 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
2248 info
->interp_text_sect_low
=
2249 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
2250 info
->interp_text_sect_high
=
2251 info
->interp_text_sect_low
2252 + bfd_section_size (tmp_bfd
, interp_sect
);
2254 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
2257 info
->interp_plt_sect_low
=
2258 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
2259 info
->interp_plt_sect_high
=
2260 info
->interp_plt_sect_low
2261 + bfd_section_size (tmp_bfd
, interp_sect
);
2264 svr4_create_solib_event_breakpoints (info
, target_gdbarch (), sym_addr
);
2269 /* Find the program interpreter; if not found, warn the user and drop
2270 into the old breakpoint at symbol code. */
2271 gdb::optional
<gdb::byte_vector
> interp_name_holder
2272 = find_program_interpreter ();
2273 if (interp_name_holder
)
2275 const char *interp_name
= (const char *) interp_name_holder
->data ();
2276 CORE_ADDR load_addr
= 0;
2277 int load_addr_found
= 0;
2278 int loader_found_in_list
= 0;
2280 struct target_ops
*tmp_bfd_target
;
2284 /* Now we need to figure out where the dynamic linker was
2285 loaded so that we can load its symbols and place a breakpoint
2286 in the dynamic linker itself.
2288 This address is stored on the stack. However, I've been unable
2289 to find any magic formula to find it for Solaris (appears to
2290 be trivial on GNU/Linux). Therefore, we have to try an alternate
2291 mechanism to find the dynamic linker's base address. */
2293 gdb_bfd_ref_ptr tmp_bfd
;
2296 tmp_bfd
= solib_bfd_open (interp_name
);
2298 catch (const gdb_exception
&ex
)
2302 if (tmp_bfd
== NULL
)
2303 goto bkpt_at_symbol
;
2305 /* Now convert the TMP_BFD into a target. That way target, as
2306 well as BFD operations can be used. target_bfd_reopen
2307 acquires its own reference. */
2308 tmp_bfd_target
= target_bfd_reopen (tmp_bfd
.get ());
2310 /* On a running target, we can get the dynamic linker's base
2311 address from the shared library table. */
2312 so
= master_so_list ();
2315 if (svr4_same_1 (interp_name
, so
->so_original_name
))
2317 load_addr_found
= 1;
2318 loader_found_in_list
= 1;
2319 load_addr
= lm_addr_check (so
, tmp_bfd
.get ());
2325 /* If we were not able to find the base address of the loader
2326 from our so_list, then try using the AT_BASE auxilliary entry. */
2327 if (!load_addr_found
)
2328 if (target_auxv_search (current_top_target (), AT_BASE
, &load_addr
) > 0)
2330 int addr_bit
= gdbarch_addr_bit (target_gdbarch ());
2332 /* Ensure LOAD_ADDR has proper sign in its possible upper bits so
2333 that `+ load_addr' will overflow CORE_ADDR width not creating
2334 invalid addresses like 0x101234567 for 32bit inferiors on 64bit
2337 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2339 CORE_ADDR space_size
= (CORE_ADDR
) 1 << addr_bit
;
2340 CORE_ADDR tmp_entry_point
= exec_entry_point (tmp_bfd
.get (),
2343 gdb_assert (load_addr
< space_size
);
2345 /* TMP_ENTRY_POINT exceeding SPACE_SIZE would be for prelinked
2346 64bit ld.so with 32bit executable, it should not happen. */
2348 if (tmp_entry_point
< space_size
2349 && tmp_entry_point
+ load_addr
>= space_size
)
2350 load_addr
-= space_size
;
2353 load_addr_found
= 1;
2356 /* Otherwise we find the dynamic linker's base address by examining
2357 the current pc (which should point at the entry point for the
2358 dynamic linker) and subtracting the offset of the entry point.
2360 This is more fragile than the previous approaches, but is a good
2361 fallback method because it has actually been working well in
2363 if (!load_addr_found
)
2365 struct regcache
*regcache
2366 = get_thread_arch_regcache (inferior_ptid
, target_gdbarch ());
2368 load_addr
= (regcache_read_pc (regcache
)
2369 - exec_entry_point (tmp_bfd
.get (), tmp_bfd_target
));
2372 if (!loader_found_in_list
)
2374 info
->debug_loader_name
= xstrdup (interp_name
);
2375 info
->debug_loader_offset_p
= 1;
2376 info
->debug_loader_offset
= load_addr
;
2377 solib_add (NULL
, from_tty
, auto_solib_add
);
2380 /* Record the relocated start and end address of the dynamic linker
2381 text and plt section for svr4_in_dynsym_resolve_code. */
2382 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".text");
2385 info
->interp_text_sect_low
=
2386 bfd_section_vma (tmp_bfd
.get (), interp_sect
) + load_addr
;
2387 info
->interp_text_sect_high
=
2388 info
->interp_text_sect_low
2389 + bfd_section_size (tmp_bfd
.get (), interp_sect
);
2391 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".plt");
2394 info
->interp_plt_sect_low
=
2395 bfd_section_vma (tmp_bfd
.get (), interp_sect
) + load_addr
;
2396 info
->interp_plt_sect_high
=
2397 info
->interp_plt_sect_low
2398 + bfd_section_size (tmp_bfd
.get (), interp_sect
);
2401 /* Now try to set a breakpoint in the dynamic linker. */
2402 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2404 sym_addr
= gdb_bfd_lookup_symbol (tmp_bfd
.get (),
2405 cmp_name_and_sec_flags
,
2412 /* Convert 'sym_addr' from a function pointer to an address.
2413 Because we pass tmp_bfd_target instead of the current
2414 target, this will always produce an unrelocated value. */
2415 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2419 /* We're done with both the temporary bfd and target. Closing
2420 the target closes the underlying bfd, because it holds the
2421 only remaining reference. */
2422 target_close (tmp_bfd_target
);
2426 svr4_create_solib_event_breakpoints (info
, target_gdbarch (),
2427 load_addr
+ sym_addr
);
2431 /* For whatever reason we couldn't set a breakpoint in the dynamic
2432 linker. Warn and drop into the old code. */
2434 warning (_("Unable to find dynamic linker breakpoint function.\n"
2435 "GDB will be unable to debug shared library initializers\n"
2436 "and track explicitly loaded dynamic code."));
2439 /* Scan through the lists of symbols, trying to look up the symbol and
2440 set a breakpoint there. Terminate loop when we/if we succeed. */
2442 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2444 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
2445 if ((msymbol
.minsym
!= NULL
)
2446 && (BMSYMBOL_VALUE_ADDRESS (msymbol
) != 0))
2448 sym_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
2449 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2451 current_top_target ());
2452 svr4_create_solib_event_breakpoints (info
, target_gdbarch (),
2458 if (interp_name_holder
&& !current_inferior ()->attach_flag
)
2460 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2462 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
2463 if ((msymbol
.minsym
!= NULL
)
2464 && (BMSYMBOL_VALUE_ADDRESS (msymbol
) != 0))
2466 sym_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
2467 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2469 current_top_target ());
2470 svr4_create_solib_event_breakpoints (info
, target_gdbarch (),
2479 /* Read the ELF program headers from ABFD. */
2481 static gdb::optional
<gdb::byte_vector
>
2482 read_program_headers_from_bfd (bfd
*abfd
)
2484 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
2485 int phdrs_size
= ehdr
->e_phnum
* ehdr
->e_phentsize
;
2486 if (phdrs_size
== 0)
2489 gdb::byte_vector
buf (phdrs_size
);
2490 if (bfd_seek (abfd
, ehdr
->e_phoff
, SEEK_SET
) != 0
2491 || bfd_bread (buf
.data (), phdrs_size
, abfd
) != phdrs_size
)
2497 /* Return 1 and fill *DISPLACEMENTP with detected PIE offset of inferior
2498 exec_bfd. Otherwise return 0.
2500 We relocate all of the sections by the same amount. This
2501 behavior is mandated by recent editions of the System V ABI.
2502 According to the System V Application Binary Interface,
2503 Edition 4.1, page 5-5:
2505 ... Though the system chooses virtual addresses for
2506 individual processes, it maintains the segments' relative
2507 positions. Because position-independent code uses relative
2508 addressesing between segments, the difference between
2509 virtual addresses in memory must match the difference
2510 between virtual addresses in the file. The difference
2511 between the virtual address of any segment in memory and
2512 the corresponding virtual address in the file is thus a
2513 single constant value for any one executable or shared
2514 object in a given process. This difference is the base
2515 address. One use of the base address is to relocate the
2516 memory image of the program during dynamic linking.
2518 The same language also appears in Edition 4.0 of the System V
2519 ABI and is left unspecified in some of the earlier editions.
2521 Decide if the objfile needs to be relocated. As indicated above, we will
2522 only be here when execution is stopped. But during attachment PC can be at
2523 arbitrary address therefore regcache_read_pc can be misleading (contrary to
2524 the auxv AT_ENTRY value). Moreover for executable with interpreter section
2525 regcache_read_pc would point to the interpreter and not the main executable.
2527 So, to summarize, relocations are necessary when the start address obtained
2528 from the executable is different from the address in auxv AT_ENTRY entry.
2530 [ The astute reader will note that we also test to make sure that
2531 the executable in question has the DYNAMIC flag set. It is my
2532 opinion that this test is unnecessary (undesirable even). It
2533 was added to avoid inadvertent relocation of an executable
2534 whose e_type member in the ELF header is not ET_DYN. There may
2535 be a time in the future when it is desirable to do relocations
2536 on other types of files as well in which case this condition
2537 should either be removed or modified to accomodate the new file
2538 type. - Kevin, Nov 2000. ] */
2541 svr4_exec_displacement (CORE_ADDR
*displacementp
)
2543 /* ENTRY_POINT is a possible function descriptor - before
2544 a call to gdbarch_convert_from_func_ptr_addr. */
2545 CORE_ADDR entry_point
, exec_displacement
;
2547 if (exec_bfd
== NULL
)
2550 /* Therefore for ELF it is ET_EXEC and not ET_DYN. Both shared libraries
2551 being executed themselves and PIE (Position Independent Executable)
2552 executables are ET_DYN. */
2554 if ((bfd_get_file_flags (exec_bfd
) & DYNAMIC
) == 0)
2557 if (target_auxv_search (current_top_target (), AT_ENTRY
, &entry_point
) <= 0)
2560 exec_displacement
= entry_point
- bfd_get_start_address (exec_bfd
);
2562 /* Verify the EXEC_DISPLACEMENT candidate complies with the required page
2563 alignment. It is cheaper than the program headers comparison below. */
2565 if (bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
2567 const struct elf_backend_data
*elf
= get_elf_backend_data (exec_bfd
);
2569 /* p_align of PT_LOAD segments does not specify any alignment but
2570 only congruency of addresses:
2571 p_offset % p_align == p_vaddr % p_align
2572 Kernel is free to load the executable with lower alignment. */
2574 if ((exec_displacement
& (elf
->minpagesize
- 1)) != 0)
2578 /* Verify that the auxilliary vector describes the same file as exec_bfd, by
2579 comparing their program headers. If the program headers in the auxilliary
2580 vector do not match the program headers in the executable, then we are
2581 looking at a different file than the one used by the kernel - for
2582 instance, "gdb program" connected to "gdbserver :PORT ld.so program". */
2584 if (bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
2586 /* Be optimistic and return 0 only if GDB was able to verify the headers
2587 really do not match. */
2590 gdb::optional
<gdb::byte_vector
> phdrs_target
2591 = read_program_header (-1, &arch_size
, NULL
);
2592 gdb::optional
<gdb::byte_vector
> phdrs_binary
2593 = read_program_headers_from_bfd (exec_bfd
);
2594 if (phdrs_target
&& phdrs_binary
)
2596 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
2598 /* We are dealing with three different addresses. EXEC_BFD
2599 represents current address in on-disk file. target memory content
2600 may be different from EXEC_BFD as the file may have been prelinked
2601 to a different address after the executable has been loaded.
2602 Moreover the address of placement in target memory can be
2603 different from what the program headers in target memory say -
2604 this is the goal of PIE.
2606 Detected DISPLACEMENT covers both the offsets of PIE placement and
2607 possible new prelink performed after start of the program. Here
2608 relocate BUF and BUF2 just by the EXEC_BFD vs. target memory
2609 content offset for the verification purpose. */
2611 if (phdrs_target
->size () != phdrs_binary
->size ()
2612 || bfd_get_arch_size (exec_bfd
) != arch_size
)
2614 else if (arch_size
== 32
2615 && phdrs_target
->size () >= sizeof (Elf32_External_Phdr
)
2616 && phdrs_target
->size () % sizeof (Elf32_External_Phdr
) == 0)
2618 Elf_Internal_Ehdr
*ehdr2
= elf_tdata (exec_bfd
)->elf_header
;
2619 Elf_Internal_Phdr
*phdr2
= elf_tdata (exec_bfd
)->phdr
;
2620 CORE_ADDR displacement
= 0;
2623 /* DISPLACEMENT could be found more easily by the difference of
2624 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2625 already have enough information to compute that displacement
2626 with what we've read. */
2628 for (i
= 0; i
< ehdr2
->e_phnum
; i
++)
2629 if (phdr2
[i
].p_type
== PT_LOAD
)
2631 Elf32_External_Phdr
*phdrp
;
2632 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2633 CORE_ADDR vaddr
, paddr
;
2634 CORE_ADDR displacement_vaddr
= 0;
2635 CORE_ADDR displacement_paddr
= 0;
2637 phdrp
= &((Elf32_External_Phdr
*) phdrs_target
->data ())[i
];
2638 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2639 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2641 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 4,
2643 displacement_vaddr
= vaddr
- phdr2
[i
].p_vaddr
;
2645 paddr
= extract_unsigned_integer (buf_paddr_p
, 4,
2647 displacement_paddr
= paddr
- phdr2
[i
].p_paddr
;
2649 if (displacement_vaddr
== displacement_paddr
)
2650 displacement
= displacement_vaddr
;
2655 /* Now compare program headers from the target and the binary
2656 with optional DISPLACEMENT. */
2659 i
< phdrs_target
->size () / sizeof (Elf32_External_Phdr
);
2662 Elf32_External_Phdr
*phdrp
;
2663 Elf32_External_Phdr
*phdr2p
;
2664 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2665 CORE_ADDR vaddr
, paddr
;
2666 asection
*plt2_asect
;
2668 phdrp
= &((Elf32_External_Phdr
*) phdrs_target
->data ())[i
];
2669 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2670 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2671 phdr2p
= &((Elf32_External_Phdr
*) phdrs_binary
->data ())[i
];
2673 /* PT_GNU_STACK is an exception by being never relocated by
2674 prelink as its addresses are always zero. */
2676 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2679 /* Check also other adjustment combinations - PR 11786. */
2681 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 4,
2683 vaddr
-= displacement
;
2684 store_unsigned_integer (buf_vaddr_p
, 4, byte_order
, vaddr
);
2686 paddr
= extract_unsigned_integer (buf_paddr_p
, 4,
2688 paddr
-= displacement
;
2689 store_unsigned_integer (buf_paddr_p
, 4, byte_order
, paddr
);
2691 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2694 /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2695 CentOS-5 has problems with filesz, memsz as well.
2696 Strip also modifies memsz of PT_TLS.
2698 if (phdr2
[i
].p_type
== PT_GNU_RELRO
2699 || phdr2
[i
].p_type
== PT_TLS
)
2701 Elf32_External_Phdr tmp_phdr
= *phdrp
;
2702 Elf32_External_Phdr tmp_phdr2
= *phdr2p
;
2704 memset (tmp_phdr
.p_filesz
, 0, 4);
2705 memset (tmp_phdr
.p_memsz
, 0, 4);
2706 memset (tmp_phdr
.p_flags
, 0, 4);
2707 memset (tmp_phdr
.p_align
, 0, 4);
2708 memset (tmp_phdr2
.p_filesz
, 0, 4);
2709 memset (tmp_phdr2
.p_memsz
, 0, 4);
2710 memset (tmp_phdr2
.p_flags
, 0, 4);
2711 memset (tmp_phdr2
.p_align
, 0, 4);
2713 if (memcmp (&tmp_phdr
, &tmp_phdr2
, sizeof (tmp_phdr
))
2718 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2719 plt2_asect
= bfd_get_section_by_name (exec_bfd
, ".plt");
2723 gdb_byte
*buf_filesz_p
= (gdb_byte
*) &phdrp
->p_filesz
;
2726 content2
= (bfd_get_section_flags (exec_bfd
, plt2_asect
)
2727 & SEC_HAS_CONTENTS
) != 0;
2729 filesz
= extract_unsigned_integer (buf_filesz_p
, 4,
2732 /* PLT2_ASECT is from on-disk file (exec_bfd) while
2733 FILESZ is from the in-memory image. */
2735 filesz
+= bfd_get_section_size (plt2_asect
);
2737 filesz
-= bfd_get_section_size (plt2_asect
);
2739 store_unsigned_integer (buf_filesz_p
, 4, byte_order
,
2742 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2749 else if (arch_size
== 64
2750 && phdrs_target
->size () >= sizeof (Elf64_External_Phdr
)
2751 && phdrs_target
->size () % sizeof (Elf64_External_Phdr
) == 0)
2753 Elf_Internal_Ehdr
*ehdr2
= elf_tdata (exec_bfd
)->elf_header
;
2754 Elf_Internal_Phdr
*phdr2
= elf_tdata (exec_bfd
)->phdr
;
2755 CORE_ADDR displacement
= 0;
2758 /* DISPLACEMENT could be found more easily by the difference of
2759 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2760 already have enough information to compute that displacement
2761 with what we've read. */
2763 for (i
= 0; i
< ehdr2
->e_phnum
; i
++)
2764 if (phdr2
[i
].p_type
== PT_LOAD
)
2766 Elf64_External_Phdr
*phdrp
;
2767 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2768 CORE_ADDR vaddr
, paddr
;
2769 CORE_ADDR displacement_vaddr
= 0;
2770 CORE_ADDR displacement_paddr
= 0;
2772 phdrp
= &((Elf64_External_Phdr
*) phdrs_target
->data ())[i
];
2773 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2774 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2776 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 8,
2778 displacement_vaddr
= vaddr
- phdr2
[i
].p_vaddr
;
2780 paddr
= extract_unsigned_integer (buf_paddr_p
, 8,
2782 displacement_paddr
= paddr
- phdr2
[i
].p_paddr
;
2784 if (displacement_vaddr
== displacement_paddr
)
2785 displacement
= displacement_vaddr
;
2790 /* Now compare BUF and BUF2 with optional DISPLACEMENT. */
2793 i
< phdrs_target
->size () / sizeof (Elf64_External_Phdr
);
2796 Elf64_External_Phdr
*phdrp
;
2797 Elf64_External_Phdr
*phdr2p
;
2798 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2799 CORE_ADDR vaddr
, paddr
;
2800 asection
*plt2_asect
;
2802 phdrp
= &((Elf64_External_Phdr
*) phdrs_target
->data ())[i
];
2803 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2804 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2805 phdr2p
= &((Elf64_External_Phdr
*) phdrs_binary
->data ())[i
];
2807 /* PT_GNU_STACK is an exception by being never relocated by
2808 prelink as its addresses are always zero. */
2810 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2813 /* Check also other adjustment combinations - PR 11786. */
2815 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 8,
2817 vaddr
-= displacement
;
2818 store_unsigned_integer (buf_vaddr_p
, 8, byte_order
, vaddr
);
2820 paddr
= extract_unsigned_integer (buf_paddr_p
, 8,
2822 paddr
-= displacement
;
2823 store_unsigned_integer (buf_paddr_p
, 8, byte_order
, paddr
);
2825 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2828 /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2829 CentOS-5 has problems with filesz, memsz as well.
2830 Strip also modifies memsz of PT_TLS.
2832 if (phdr2
[i
].p_type
== PT_GNU_RELRO
2833 || phdr2
[i
].p_type
== PT_TLS
)
2835 Elf64_External_Phdr tmp_phdr
= *phdrp
;
2836 Elf64_External_Phdr tmp_phdr2
= *phdr2p
;
2838 memset (tmp_phdr
.p_filesz
, 0, 8);
2839 memset (tmp_phdr
.p_memsz
, 0, 8);
2840 memset (tmp_phdr
.p_flags
, 0, 4);
2841 memset (tmp_phdr
.p_align
, 0, 8);
2842 memset (tmp_phdr2
.p_filesz
, 0, 8);
2843 memset (tmp_phdr2
.p_memsz
, 0, 8);
2844 memset (tmp_phdr2
.p_flags
, 0, 4);
2845 memset (tmp_phdr2
.p_align
, 0, 8);
2847 if (memcmp (&tmp_phdr
, &tmp_phdr2
, sizeof (tmp_phdr
))
2852 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2853 plt2_asect
= bfd_get_section_by_name (exec_bfd
, ".plt");
2857 gdb_byte
*buf_filesz_p
= (gdb_byte
*) &phdrp
->p_filesz
;
2860 content2
= (bfd_get_section_flags (exec_bfd
, plt2_asect
)
2861 & SEC_HAS_CONTENTS
) != 0;
2863 filesz
= extract_unsigned_integer (buf_filesz_p
, 8,
2866 /* PLT2_ASECT is from on-disk file (exec_bfd) while
2867 FILESZ is from the in-memory image. */
2869 filesz
+= bfd_get_section_size (plt2_asect
);
2871 filesz
-= bfd_get_section_size (plt2_asect
);
2873 store_unsigned_integer (buf_filesz_p
, 8, byte_order
,
2876 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2890 /* It can be printed repeatedly as there is no easy way to check
2891 the executable symbols/file has been already relocated to
2894 printf_unfiltered (_("Using PIE (Position Independent Executable) "
2895 "displacement %s for \"%s\".\n"),
2896 paddress (target_gdbarch (), exec_displacement
),
2897 bfd_get_filename (exec_bfd
));
2900 *displacementp
= exec_displacement
;
2904 /* Relocate the main executable. This function should be called upon
2905 stopping the inferior process at the entry point to the program.
2906 The entry point from BFD is compared to the AT_ENTRY of AUXV and if they are
2907 different, the main executable is relocated by the proper amount. */
2910 svr4_relocate_main_executable (void)
2912 CORE_ADDR displacement
;
2914 /* If we are re-running this executable, SYMFILE_OBJFILE->SECTION_OFFSETS
2915 probably contains the offsets computed using the PIE displacement
2916 from the previous run, which of course are irrelevant for this run.
2917 So we need to determine the new PIE displacement and recompute the
2918 section offsets accordingly, even if SYMFILE_OBJFILE->SECTION_OFFSETS
2919 already contains pre-computed offsets.
2921 If we cannot compute the PIE displacement, either:
2923 - The executable is not PIE.
2925 - SYMFILE_OBJFILE does not match the executable started in the target.
2926 This can happen for main executable symbols loaded at the host while
2927 `ld.so --ld-args main-executable' is loaded in the target.
2929 Then we leave the section offsets untouched and use them as is for
2932 - These section offsets were properly reset earlier, and thus
2933 already contain the correct values. This can happen for instance
2934 when reconnecting via the remote protocol to a target that supports
2935 the `qOffsets' packet.
2937 - The section offsets were not reset earlier, and the best we can
2938 hope is that the old offsets are still applicable to the new run. */
2940 if (! svr4_exec_displacement (&displacement
))
2943 /* Even DISPLACEMENT 0 is a valid new difference of in-memory vs. in-file
2946 if (symfile_objfile
)
2948 struct section_offsets
*new_offsets
;
2951 new_offsets
= XALLOCAVEC (struct section_offsets
,
2952 symfile_objfile
->num_sections
);
2954 for (i
= 0; i
< symfile_objfile
->num_sections
; i
++)
2955 new_offsets
->offsets
[i
] = displacement
;
2957 objfile_relocate (symfile_objfile
, new_offsets
);
2963 for (asect
= exec_bfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
2964 exec_set_section_address (bfd_get_filename (exec_bfd
), asect
->index
,
2965 (bfd_section_vma (exec_bfd
, asect
)
2970 /* Implement the "create_inferior_hook" target_solib_ops method.
2972 For SVR4 executables, this first instruction is either the first
2973 instruction in the dynamic linker (for dynamically linked
2974 executables) or the instruction at "start" for statically linked
2975 executables. For dynamically linked executables, the system
2976 first exec's /lib/libc.so.N, which contains the dynamic linker,
2977 and starts it running. The dynamic linker maps in any needed
2978 shared libraries, maps in the actual user executable, and then
2979 jumps to "start" in the user executable.
2981 We can arrange to cooperate with the dynamic linker to discover the
2982 names of shared libraries that are dynamically linked, and the base
2983 addresses to which they are linked.
2985 This function is responsible for discovering those names and
2986 addresses, and saving sufficient information about them to allow
2987 their symbols to be read at a later time. */
2990 svr4_solib_create_inferior_hook (int from_tty
)
2992 struct svr4_info
*info
;
2994 info
= get_svr4_info (current_program_space
);
2996 /* Clear the probes-based interface's state. */
2997 free_probes_table (info
);
2998 free_solib_list (info
);
3000 /* Relocate the main executable if necessary. */
3001 svr4_relocate_main_executable ();
3003 /* No point setting a breakpoint in the dynamic linker if we can't
3004 hit it (e.g., a core file, or a trace file). */
3005 if (!target_has_execution
)
3008 if (!svr4_have_link_map_offsets ())
3011 if (!enable_break (info
, from_tty
))
3016 svr4_clear_solib (void)
3018 struct svr4_info
*info
;
3020 info
= get_svr4_info (current_program_space
);
3021 info
->debug_base
= 0;
3022 info
->debug_loader_offset_p
= 0;
3023 info
->debug_loader_offset
= 0;
3024 xfree (info
->debug_loader_name
);
3025 info
->debug_loader_name
= NULL
;
3028 /* Clear any bits of ADDR that wouldn't fit in a target-format
3029 data pointer. "Data pointer" here refers to whatever sort of
3030 address the dynamic linker uses to manage its sections. At the
3031 moment, we don't support shared libraries on any processors where
3032 code and data pointers are different sizes.
3034 This isn't really the right solution. What we really need here is
3035 a way to do arithmetic on CORE_ADDR values that respects the
3036 natural pointer/address correspondence. (For example, on the MIPS,
3037 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
3038 sign-extend the value. There, simply truncating the bits above
3039 gdbarch_ptr_bit, as we do below, is no good.) This should probably
3040 be a new gdbarch method or something. */
3042 svr4_truncate_ptr (CORE_ADDR addr
)
3044 if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR
) * 8)
3045 /* We don't need to truncate anything, and the bit twiddling below
3046 will fail due to overflow problems. */
3049 return addr
& (((CORE_ADDR
) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
3054 svr4_relocate_section_addresses (struct so_list
*so
,
3055 struct target_section
*sec
)
3057 bfd
*abfd
= sec
->the_bfd_section
->owner
;
3059 sec
->addr
= svr4_truncate_ptr (sec
->addr
+ lm_addr_check (so
, abfd
));
3060 sec
->endaddr
= svr4_truncate_ptr (sec
->endaddr
+ lm_addr_check (so
, abfd
));
3064 /* Architecture-specific operations. */
3066 /* Per-architecture data key. */
3067 static struct gdbarch_data
*solib_svr4_data
;
3069 struct solib_svr4_ops
3071 /* Return a description of the layout of `struct link_map'. */
3072 struct link_map_offsets
*(*fetch_link_map_offsets
)(void);
3075 /* Return a default for the architecture-specific operations. */
3078 solib_svr4_init (struct obstack
*obstack
)
3080 struct solib_svr4_ops
*ops
;
3082 ops
= OBSTACK_ZALLOC (obstack
, struct solib_svr4_ops
);
3083 ops
->fetch_link_map_offsets
= NULL
;
3087 /* Set the architecture-specific `struct link_map_offsets' fetcher for
3088 GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */
3091 set_solib_svr4_fetch_link_map_offsets (struct gdbarch
*gdbarch
,
3092 struct link_map_offsets
*(*flmo
) (void))
3094 struct solib_svr4_ops
*ops
3095 = (struct solib_svr4_ops
*) gdbarch_data (gdbarch
, solib_svr4_data
);
3097 ops
->fetch_link_map_offsets
= flmo
;
3099 set_solib_ops (gdbarch
, &svr4_so_ops
);
3102 /* Fetch a link_map_offsets structure using the architecture-specific
3103 `struct link_map_offsets' fetcher. */
3105 static struct link_map_offsets
*
3106 svr4_fetch_link_map_offsets (void)
3108 struct solib_svr4_ops
*ops
3109 = (struct solib_svr4_ops
*) gdbarch_data (target_gdbarch (),
3112 gdb_assert (ops
->fetch_link_map_offsets
);
3113 return ops
->fetch_link_map_offsets ();
3116 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
3119 svr4_have_link_map_offsets (void)
3121 struct solib_svr4_ops
*ops
3122 = (struct solib_svr4_ops
*) gdbarch_data (target_gdbarch (),
3125 return (ops
->fetch_link_map_offsets
!= NULL
);
3129 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
3130 `struct r_debug' and a `struct link_map' that are binary compatible
3131 with the origional SVR4 implementation. */
3133 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3134 for an ILP32 SVR4 system. */
3136 struct link_map_offsets
*
3137 svr4_ilp32_fetch_link_map_offsets (void)
3139 static struct link_map_offsets lmo
;
3140 static struct link_map_offsets
*lmp
= NULL
;
3146 lmo
.r_version_offset
= 0;
3147 lmo
.r_version_size
= 4;
3148 lmo
.r_map_offset
= 4;
3149 lmo
.r_brk_offset
= 8;
3150 lmo
.r_ldsomap_offset
= 20;
3152 /* Everything we need is in the first 20 bytes. */
3153 lmo
.link_map_size
= 20;
3154 lmo
.l_addr_offset
= 0;
3155 lmo
.l_name_offset
= 4;
3156 lmo
.l_ld_offset
= 8;
3157 lmo
.l_next_offset
= 12;
3158 lmo
.l_prev_offset
= 16;
3164 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3165 for an LP64 SVR4 system. */
3167 struct link_map_offsets
*
3168 svr4_lp64_fetch_link_map_offsets (void)
3170 static struct link_map_offsets lmo
;
3171 static struct link_map_offsets
*lmp
= NULL
;
3177 lmo
.r_version_offset
= 0;
3178 lmo
.r_version_size
= 4;
3179 lmo
.r_map_offset
= 8;
3180 lmo
.r_brk_offset
= 16;
3181 lmo
.r_ldsomap_offset
= 40;
3183 /* Everything we need is in the first 40 bytes. */
3184 lmo
.link_map_size
= 40;
3185 lmo
.l_addr_offset
= 0;
3186 lmo
.l_name_offset
= 8;
3187 lmo
.l_ld_offset
= 16;
3188 lmo
.l_next_offset
= 24;
3189 lmo
.l_prev_offset
= 32;
3196 struct target_so_ops svr4_so_ops
;
3198 /* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a
3199 different rule for symbol lookup. The lookup begins here in the DSO, not in
3200 the main executable. */
3202 static struct block_symbol
3203 elf_lookup_lib_symbol (struct objfile
*objfile
,
3205 const domain_enum domain
)
3209 if (objfile
== symfile_objfile
)
3213 /* OBJFILE should have been passed as the non-debug one. */
3214 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
3216 abfd
= objfile
->obfd
;
3219 if (abfd
== NULL
|| scan_dyntag (DT_SYMBOLIC
, abfd
, NULL
, NULL
) != 1)
3222 return lookup_global_symbol_from_objfile (objfile
, GLOBAL_BLOCK
, name
,
3227 _initialize_svr4_solib (void)
3229 solib_svr4_data
= gdbarch_data_register_pre_init (solib_svr4_init
);
3231 svr4_so_ops
.relocate_section_addresses
= svr4_relocate_section_addresses
;
3232 svr4_so_ops
.free_so
= svr4_free_so
;
3233 svr4_so_ops
.clear_so
= svr4_clear_so
;
3234 svr4_so_ops
.clear_solib
= svr4_clear_solib
;
3235 svr4_so_ops
.solib_create_inferior_hook
= svr4_solib_create_inferior_hook
;
3236 svr4_so_ops
.current_sos
= svr4_current_sos
;
3237 svr4_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
3238 svr4_so_ops
.in_dynsym_resolve_code
= svr4_in_dynsym_resolve_code
;
3239 svr4_so_ops
.bfd_open
= solib_bfd_open
;
3240 svr4_so_ops
.lookup_lib_global_symbol
= elf_lookup_lib_symbol
;
3241 svr4_so_ops
.same
= svr4_same
;
3242 svr4_so_ops
.keep_data_in_core
= svr4_keep_data_in_core
;
3243 svr4_so_ops
.update_breakpoints
= svr4_update_solib_event_breakpoints
;
3244 svr4_so_ops
.handle_event
= svr4_handle_solib_event
;
3246 gdb::observers::free_objfile
.attach (svr4_free_objfile_observer
);