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
];
2075 for (int i
= 0; i
< NUM_PROBES
; i
++)
2077 const char *name
= probe_info
[i
].name
;
2080 /* Fedora 17 and Red Hat Enterprise Linux 6.2-6.4 shipped with an early
2081 version of the probes code in which the probes' names were prefixed
2082 with "rtld_" and the "map_failed" probe did not exist. The locations
2083 of the probes are otherwise the same, so we check for probes with
2084 prefixed names if probes with unprefixed names are not present. */
2087 xsnprintf (buf
, sizeof (buf
), "rtld_%s", name
);
2091 probes
[i
] = find_probes_in_objfile (os
->objfile
, "rtld", name
);
2093 /* The "map_failed" probe did not exist in early
2094 versions of the probes code in which the probes'
2095 names were prefixed with "rtld_". */
2096 if (with_prefix
&& streq (name
, "rtld_map_failed"))
2099 /* Ensure at least one probe for the current name was found. */
2100 if (probes
[i
].empty ())
2103 /* Ensure probe arguments can be evaluated. */
2104 for (probe
*p
: probes
[i
])
2106 if (!p
->can_evaluate_arguments ())
2108 /* This will fail if the probe is invalid. This has been seen on Arm
2109 due to references to symbols that have been resolved away. */
2112 p
->get_argument_count (gdbarch
);
2114 catch (const gdb_exception_error
&ex
)
2116 exception_print (gdb_stderr
, ex
);
2117 warning (_("Initializing probes-based dynamic linker interface "
2118 "failed.\nReverting to original interface."));
2124 /* All probes found. Now create them. */
2125 svr4_create_probe_breakpoints (info
, gdbarch
, probes
, os
->objfile
);
2129 /* Both the SunOS and the SVR4 dynamic linkers call a marker function
2130 before and after mapping and unmapping shared libraries. The sole
2131 purpose of this method is to allow debuggers to set a breakpoint so
2132 they can track these changes.
2134 Some versions of the glibc dynamic linker contain named probes
2135 to allow more fine grained stopping. Given the address of the
2136 original marker function, this function attempts to find these
2137 probes, and if found, sets breakpoints on those instead. If the
2138 probes aren't found, a single breakpoint is set on the original
2142 svr4_create_solib_event_breakpoints (svr4_info
*info
, struct gdbarch
*gdbarch
,
2145 struct obj_section
*os
= find_pc_section (address
);
2148 || (!svr4_find_and_create_probe_breakpoints (info
, gdbarch
, os
, false)
2149 && !svr4_find_and_create_probe_breakpoints (info
, gdbarch
, os
, true)))
2150 create_solib_event_breakpoint (gdbarch
, address
);
2153 /* Helper function for gdb_bfd_lookup_symbol. */
2156 cmp_name_and_sec_flags (const asymbol
*sym
, const void *data
)
2158 return (strcmp (sym
->name
, (const char *) data
) == 0
2159 && (sym
->section
->flags
& (SEC_CODE
| SEC_DATA
)) != 0);
2161 /* Arrange for dynamic linker to hit breakpoint.
2163 Both the SunOS and the SVR4 dynamic linkers have, as part of their
2164 debugger interface, support for arranging for the inferior to hit
2165 a breakpoint after mapping in the shared libraries. This function
2166 enables that breakpoint.
2168 For SunOS, there is a special flag location (in_debugger) which we
2169 set to 1. When the dynamic linker sees this flag set, it will set
2170 a breakpoint at a location known only to itself, after saving the
2171 original contents of that place and the breakpoint address itself,
2172 in it's own internal structures. When we resume the inferior, it
2173 will eventually take a SIGTRAP when it runs into the breakpoint.
2174 We handle this (in a different place) by restoring the contents of
2175 the breakpointed location (which is only known after it stops),
2176 chasing around to locate the shared libraries that have been
2177 loaded, then resuming.
2179 For SVR4, the debugger interface structure contains a member (r_brk)
2180 which is statically initialized at the time the shared library is
2181 built, to the offset of a function (_r_debug_state) which is guaran-
2182 teed to be called once before mapping in a library, and again when
2183 the mapping is complete. At the time we are examining this member,
2184 it contains only the unrelocated offset of the function, so we have
2185 to do our own relocation. Later, when the dynamic linker actually
2186 runs, it relocates r_brk to be the actual address of _r_debug_state().
2188 The debugger interface structure also contains an enumeration which
2189 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
2190 depending upon whether or not the library is being mapped or unmapped,
2191 and then set to RT_CONSISTENT after the library is mapped/unmapped. */
2194 enable_break (struct svr4_info
*info
, int from_tty
)
2196 struct bound_minimal_symbol msymbol
;
2197 const char * const *bkpt_namep
;
2198 asection
*interp_sect
;
2201 info
->interp_text_sect_low
= info
->interp_text_sect_high
= 0;
2202 info
->interp_plt_sect_low
= info
->interp_plt_sect_high
= 0;
2204 /* If we already have a shared library list in the target, and
2205 r_debug contains r_brk, set the breakpoint there - this should
2206 mean r_brk has already been relocated. Assume the dynamic linker
2207 is the object containing r_brk. */
2209 solib_add (NULL
, from_tty
, auto_solib_add
);
2211 if (info
->debug_base
&& solib_svr4_r_map (info
) != 0)
2212 sym_addr
= solib_svr4_r_brk (info
);
2216 struct obj_section
*os
;
2218 sym_addr
= gdbarch_addr_bits_remove
2220 gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2222 current_top_target ()));
2224 /* On at least some versions of Solaris there's a dynamic relocation
2225 on _r_debug.r_brk and SYM_ADDR may not be relocated yet, e.g., if
2226 we get control before the dynamic linker has self-relocated.
2227 Check if SYM_ADDR is in a known section, if it is assume we can
2228 trust its value. This is just a heuristic though, it could go away
2229 or be replaced if it's getting in the way.
2231 On ARM we need to know whether the ISA of rtld_db_dlactivity (or
2232 however it's spelled in your particular system) is ARM or Thumb.
2233 That knowledge is encoded in the address, if it's Thumb the low bit
2234 is 1. However, we've stripped that info above and it's not clear
2235 what all the consequences are of passing a non-addr_bits_remove'd
2236 address to svr4_create_solib_event_breakpoints. The call to
2237 find_pc_section verifies we know about the address and have some
2238 hope of computing the right kind of breakpoint to use (via
2239 symbol info). It does mean that GDB needs to be pointed at a
2240 non-stripped version of the dynamic linker in order to obtain
2241 information it already knows about. Sigh. */
2243 os
= find_pc_section (sym_addr
);
2246 /* Record the relocated start and end address of the dynamic linker
2247 text and plt section for svr4_in_dynsym_resolve_code. */
2249 CORE_ADDR load_addr
;
2251 tmp_bfd
= os
->objfile
->obfd
;
2252 load_addr
= ANOFFSET (os
->objfile
->section_offsets
,
2253 SECT_OFF_TEXT (os
->objfile
));
2255 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".text");
2258 info
->interp_text_sect_low
=
2259 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
2260 info
->interp_text_sect_high
=
2261 info
->interp_text_sect_low
2262 + bfd_section_size (tmp_bfd
, interp_sect
);
2264 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
2267 info
->interp_plt_sect_low
=
2268 bfd_section_vma (tmp_bfd
, interp_sect
) + load_addr
;
2269 info
->interp_plt_sect_high
=
2270 info
->interp_plt_sect_low
2271 + bfd_section_size (tmp_bfd
, interp_sect
);
2274 svr4_create_solib_event_breakpoints (info
, target_gdbarch (), sym_addr
);
2279 /* Find the program interpreter; if not found, warn the user and drop
2280 into the old breakpoint at symbol code. */
2281 gdb::optional
<gdb::byte_vector
> interp_name_holder
2282 = find_program_interpreter ();
2283 if (interp_name_holder
)
2285 const char *interp_name
= (const char *) interp_name_holder
->data ();
2286 CORE_ADDR load_addr
= 0;
2287 int load_addr_found
= 0;
2288 int loader_found_in_list
= 0;
2290 struct target_ops
*tmp_bfd_target
;
2294 /* Now we need to figure out where the dynamic linker was
2295 loaded so that we can load its symbols and place a breakpoint
2296 in the dynamic linker itself.
2298 This address is stored on the stack. However, I've been unable
2299 to find any magic formula to find it for Solaris (appears to
2300 be trivial on GNU/Linux). Therefore, we have to try an alternate
2301 mechanism to find the dynamic linker's base address. */
2303 gdb_bfd_ref_ptr tmp_bfd
;
2306 tmp_bfd
= solib_bfd_open (interp_name
);
2308 catch (const gdb_exception
&ex
)
2312 if (tmp_bfd
== NULL
)
2313 goto bkpt_at_symbol
;
2315 /* Now convert the TMP_BFD into a target. That way target, as
2316 well as BFD operations can be used. target_bfd_reopen
2317 acquires its own reference. */
2318 tmp_bfd_target
= target_bfd_reopen (tmp_bfd
.get ());
2320 /* On a running target, we can get the dynamic linker's base
2321 address from the shared library table. */
2322 so
= master_so_list ();
2325 if (svr4_same_1 (interp_name
, so
->so_original_name
))
2327 load_addr_found
= 1;
2328 loader_found_in_list
= 1;
2329 load_addr
= lm_addr_check (so
, tmp_bfd
.get ());
2335 /* If we were not able to find the base address of the loader
2336 from our so_list, then try using the AT_BASE auxilliary entry. */
2337 if (!load_addr_found
)
2338 if (target_auxv_search (current_top_target (), AT_BASE
, &load_addr
) > 0)
2340 int addr_bit
= gdbarch_addr_bit (target_gdbarch ());
2342 /* Ensure LOAD_ADDR has proper sign in its possible upper bits so
2343 that `+ load_addr' will overflow CORE_ADDR width not creating
2344 invalid addresses like 0x101234567 for 32bit inferiors on 64bit
2347 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2349 CORE_ADDR space_size
= (CORE_ADDR
) 1 << addr_bit
;
2350 CORE_ADDR tmp_entry_point
= exec_entry_point (tmp_bfd
.get (),
2353 gdb_assert (load_addr
< space_size
);
2355 /* TMP_ENTRY_POINT exceeding SPACE_SIZE would be for prelinked
2356 64bit ld.so with 32bit executable, it should not happen. */
2358 if (tmp_entry_point
< space_size
2359 && tmp_entry_point
+ load_addr
>= space_size
)
2360 load_addr
-= space_size
;
2363 load_addr_found
= 1;
2366 /* Otherwise we find the dynamic linker's base address by examining
2367 the current pc (which should point at the entry point for the
2368 dynamic linker) and subtracting the offset of the entry point.
2370 This is more fragile than the previous approaches, but is a good
2371 fallback method because it has actually been working well in
2373 if (!load_addr_found
)
2375 struct regcache
*regcache
2376 = get_thread_arch_regcache (inferior_ptid
, target_gdbarch ());
2378 load_addr
= (regcache_read_pc (regcache
)
2379 - exec_entry_point (tmp_bfd
.get (), tmp_bfd_target
));
2382 if (!loader_found_in_list
)
2384 info
->debug_loader_name
= xstrdup (interp_name
);
2385 info
->debug_loader_offset_p
= 1;
2386 info
->debug_loader_offset
= load_addr
;
2387 solib_add (NULL
, from_tty
, auto_solib_add
);
2390 /* Record the relocated start and end address of the dynamic linker
2391 text and plt section for svr4_in_dynsym_resolve_code. */
2392 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".text");
2395 info
->interp_text_sect_low
=
2396 bfd_section_vma (tmp_bfd
.get (), interp_sect
) + load_addr
;
2397 info
->interp_text_sect_high
=
2398 info
->interp_text_sect_low
2399 + bfd_section_size (tmp_bfd
.get (), interp_sect
);
2401 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".plt");
2404 info
->interp_plt_sect_low
=
2405 bfd_section_vma (tmp_bfd
.get (), interp_sect
) + load_addr
;
2406 info
->interp_plt_sect_high
=
2407 info
->interp_plt_sect_low
2408 + bfd_section_size (tmp_bfd
.get (), interp_sect
);
2411 /* Now try to set a breakpoint in the dynamic linker. */
2412 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2414 sym_addr
= gdb_bfd_lookup_symbol (tmp_bfd
.get (),
2415 cmp_name_and_sec_flags
,
2422 /* Convert 'sym_addr' from a function pointer to an address.
2423 Because we pass tmp_bfd_target instead of the current
2424 target, this will always produce an unrelocated value. */
2425 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2429 /* We're done with both the temporary bfd and target. Closing
2430 the target closes the underlying bfd, because it holds the
2431 only remaining reference. */
2432 target_close (tmp_bfd_target
);
2436 svr4_create_solib_event_breakpoints (info
, target_gdbarch (),
2437 load_addr
+ sym_addr
);
2441 /* For whatever reason we couldn't set a breakpoint in the dynamic
2442 linker. Warn and drop into the old code. */
2444 warning (_("Unable to find dynamic linker breakpoint function.\n"
2445 "GDB will be unable to debug shared library initializers\n"
2446 "and track explicitly loaded dynamic code."));
2449 /* Scan through the lists of symbols, trying to look up the symbol and
2450 set a breakpoint there. Terminate loop when we/if we succeed. */
2452 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2454 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
2455 if ((msymbol
.minsym
!= NULL
)
2456 && (BMSYMBOL_VALUE_ADDRESS (msymbol
) != 0))
2458 sym_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
2459 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2461 current_top_target ());
2462 svr4_create_solib_event_breakpoints (info
, target_gdbarch (),
2468 if (interp_name_holder
&& !current_inferior ()->attach_flag
)
2470 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2472 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
2473 if ((msymbol
.minsym
!= NULL
)
2474 && (BMSYMBOL_VALUE_ADDRESS (msymbol
) != 0))
2476 sym_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
2477 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2479 current_top_target ());
2480 svr4_create_solib_event_breakpoints (info
, target_gdbarch (),
2489 /* Read the ELF program headers from ABFD. */
2491 static gdb::optional
<gdb::byte_vector
>
2492 read_program_headers_from_bfd (bfd
*abfd
)
2494 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
2495 int phdrs_size
= ehdr
->e_phnum
* ehdr
->e_phentsize
;
2496 if (phdrs_size
== 0)
2499 gdb::byte_vector
buf (phdrs_size
);
2500 if (bfd_seek (abfd
, ehdr
->e_phoff
, SEEK_SET
) != 0
2501 || bfd_bread (buf
.data (), phdrs_size
, abfd
) != phdrs_size
)
2507 /* Return 1 and fill *DISPLACEMENTP with detected PIE offset of inferior
2508 exec_bfd. Otherwise return 0.
2510 We relocate all of the sections by the same amount. This
2511 behavior is mandated by recent editions of the System V ABI.
2512 According to the System V Application Binary Interface,
2513 Edition 4.1, page 5-5:
2515 ... Though the system chooses virtual addresses for
2516 individual processes, it maintains the segments' relative
2517 positions. Because position-independent code uses relative
2518 addressesing between segments, the difference between
2519 virtual addresses in memory must match the difference
2520 between virtual addresses in the file. The difference
2521 between the virtual address of any segment in memory and
2522 the corresponding virtual address in the file is thus a
2523 single constant value for any one executable or shared
2524 object in a given process. This difference is the base
2525 address. One use of the base address is to relocate the
2526 memory image of the program during dynamic linking.
2528 The same language also appears in Edition 4.0 of the System V
2529 ABI and is left unspecified in some of the earlier editions.
2531 Decide if the objfile needs to be relocated. As indicated above, we will
2532 only be here when execution is stopped. But during attachment PC can be at
2533 arbitrary address therefore regcache_read_pc can be misleading (contrary to
2534 the auxv AT_ENTRY value). Moreover for executable with interpreter section
2535 regcache_read_pc would point to the interpreter and not the main executable.
2537 So, to summarize, relocations are necessary when the start address obtained
2538 from the executable is different from the address in auxv AT_ENTRY entry.
2540 [ The astute reader will note that we also test to make sure that
2541 the executable in question has the DYNAMIC flag set. It is my
2542 opinion that this test is unnecessary (undesirable even). It
2543 was added to avoid inadvertent relocation of an executable
2544 whose e_type member in the ELF header is not ET_DYN. There may
2545 be a time in the future when it is desirable to do relocations
2546 on other types of files as well in which case this condition
2547 should either be removed or modified to accomodate the new file
2548 type. - Kevin, Nov 2000. ] */
2551 svr4_exec_displacement (CORE_ADDR
*displacementp
)
2553 /* ENTRY_POINT is a possible function descriptor - before
2554 a call to gdbarch_convert_from_func_ptr_addr. */
2555 CORE_ADDR entry_point
, exec_displacement
;
2557 if (exec_bfd
== NULL
)
2560 /* Therefore for ELF it is ET_EXEC and not ET_DYN. Both shared libraries
2561 being executed themselves and PIE (Position Independent Executable)
2562 executables are ET_DYN. */
2564 if ((bfd_get_file_flags (exec_bfd
) & DYNAMIC
) == 0)
2567 if (target_auxv_search (current_top_target (), AT_ENTRY
, &entry_point
) <= 0)
2570 exec_displacement
= entry_point
- bfd_get_start_address (exec_bfd
);
2572 /* Verify the EXEC_DISPLACEMENT candidate complies with the required page
2573 alignment. It is cheaper than the program headers comparison below. */
2575 if (bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
2577 const struct elf_backend_data
*elf
= get_elf_backend_data (exec_bfd
);
2579 /* p_align of PT_LOAD segments does not specify any alignment but
2580 only congruency of addresses:
2581 p_offset % p_align == p_vaddr % p_align
2582 Kernel is free to load the executable with lower alignment. */
2584 if ((exec_displacement
& (elf
->minpagesize
- 1)) != 0)
2588 /* Verify that the auxilliary vector describes the same file as exec_bfd, by
2589 comparing their program headers. If the program headers in the auxilliary
2590 vector do not match the program headers in the executable, then we are
2591 looking at a different file than the one used by the kernel - for
2592 instance, "gdb program" connected to "gdbserver :PORT ld.so program". */
2594 if (bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
2596 /* Be optimistic and return 0 only if GDB was able to verify the headers
2597 really do not match. */
2600 gdb::optional
<gdb::byte_vector
> phdrs_target
2601 = read_program_header (-1, &arch_size
, NULL
);
2602 gdb::optional
<gdb::byte_vector
> phdrs_binary
2603 = read_program_headers_from_bfd (exec_bfd
);
2604 if (phdrs_target
&& phdrs_binary
)
2606 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
2608 /* We are dealing with three different addresses. EXEC_BFD
2609 represents current address in on-disk file. target memory content
2610 may be different from EXEC_BFD as the file may have been prelinked
2611 to a different address after the executable has been loaded.
2612 Moreover the address of placement in target memory can be
2613 different from what the program headers in target memory say -
2614 this is the goal of PIE.
2616 Detected DISPLACEMENT covers both the offsets of PIE placement and
2617 possible new prelink performed after start of the program. Here
2618 relocate BUF and BUF2 just by the EXEC_BFD vs. target memory
2619 content offset for the verification purpose. */
2621 if (phdrs_target
->size () != phdrs_binary
->size ()
2622 || bfd_get_arch_size (exec_bfd
) != arch_size
)
2624 else if (arch_size
== 32
2625 && phdrs_target
->size () >= sizeof (Elf32_External_Phdr
)
2626 && phdrs_target
->size () % sizeof (Elf32_External_Phdr
) == 0)
2628 Elf_Internal_Ehdr
*ehdr2
= elf_tdata (exec_bfd
)->elf_header
;
2629 Elf_Internal_Phdr
*phdr2
= elf_tdata (exec_bfd
)->phdr
;
2630 CORE_ADDR displacement
= 0;
2633 /* DISPLACEMENT could be found more easily by the difference of
2634 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2635 already have enough information to compute that displacement
2636 with what we've read. */
2638 for (i
= 0; i
< ehdr2
->e_phnum
; i
++)
2639 if (phdr2
[i
].p_type
== PT_LOAD
)
2641 Elf32_External_Phdr
*phdrp
;
2642 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2643 CORE_ADDR vaddr
, paddr
;
2644 CORE_ADDR displacement_vaddr
= 0;
2645 CORE_ADDR displacement_paddr
= 0;
2647 phdrp
= &((Elf32_External_Phdr
*) phdrs_target
->data ())[i
];
2648 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2649 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2651 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 4,
2653 displacement_vaddr
= vaddr
- phdr2
[i
].p_vaddr
;
2655 paddr
= extract_unsigned_integer (buf_paddr_p
, 4,
2657 displacement_paddr
= paddr
- phdr2
[i
].p_paddr
;
2659 if (displacement_vaddr
== displacement_paddr
)
2660 displacement
= displacement_vaddr
;
2665 /* Now compare program headers from the target and the binary
2666 with optional DISPLACEMENT. */
2669 i
< phdrs_target
->size () / sizeof (Elf32_External_Phdr
);
2672 Elf32_External_Phdr
*phdrp
;
2673 Elf32_External_Phdr
*phdr2p
;
2674 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2675 CORE_ADDR vaddr
, paddr
;
2676 asection
*plt2_asect
;
2678 phdrp
= &((Elf32_External_Phdr
*) phdrs_target
->data ())[i
];
2679 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2680 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2681 phdr2p
= &((Elf32_External_Phdr
*) phdrs_binary
->data ())[i
];
2683 /* PT_GNU_STACK is an exception by being never relocated by
2684 prelink as its addresses are always zero. */
2686 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2689 /* Check also other adjustment combinations - PR 11786. */
2691 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 4,
2693 vaddr
-= displacement
;
2694 store_unsigned_integer (buf_vaddr_p
, 4, byte_order
, vaddr
);
2696 paddr
= extract_unsigned_integer (buf_paddr_p
, 4,
2698 paddr
-= displacement
;
2699 store_unsigned_integer (buf_paddr_p
, 4, byte_order
, paddr
);
2701 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2704 /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2705 CentOS-5 has problems with filesz, memsz as well.
2706 Strip also modifies memsz of PT_TLS.
2708 if (phdr2
[i
].p_type
== PT_GNU_RELRO
2709 || phdr2
[i
].p_type
== PT_TLS
)
2711 Elf32_External_Phdr tmp_phdr
= *phdrp
;
2712 Elf32_External_Phdr tmp_phdr2
= *phdr2p
;
2714 memset (tmp_phdr
.p_filesz
, 0, 4);
2715 memset (tmp_phdr
.p_memsz
, 0, 4);
2716 memset (tmp_phdr
.p_flags
, 0, 4);
2717 memset (tmp_phdr
.p_align
, 0, 4);
2718 memset (tmp_phdr2
.p_filesz
, 0, 4);
2719 memset (tmp_phdr2
.p_memsz
, 0, 4);
2720 memset (tmp_phdr2
.p_flags
, 0, 4);
2721 memset (tmp_phdr2
.p_align
, 0, 4);
2723 if (memcmp (&tmp_phdr
, &tmp_phdr2
, sizeof (tmp_phdr
))
2728 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2729 plt2_asect
= bfd_get_section_by_name (exec_bfd
, ".plt");
2733 gdb_byte
*buf_filesz_p
= (gdb_byte
*) &phdrp
->p_filesz
;
2736 content2
= (bfd_get_section_flags (exec_bfd
, plt2_asect
)
2737 & SEC_HAS_CONTENTS
) != 0;
2739 filesz
= extract_unsigned_integer (buf_filesz_p
, 4,
2742 /* PLT2_ASECT is from on-disk file (exec_bfd) while
2743 FILESZ is from the in-memory image. */
2745 filesz
+= bfd_get_section_size (plt2_asect
);
2747 filesz
-= bfd_get_section_size (plt2_asect
);
2749 store_unsigned_integer (buf_filesz_p
, 4, byte_order
,
2752 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2759 else if (arch_size
== 64
2760 && phdrs_target
->size () >= sizeof (Elf64_External_Phdr
)
2761 && phdrs_target
->size () % sizeof (Elf64_External_Phdr
) == 0)
2763 Elf_Internal_Ehdr
*ehdr2
= elf_tdata (exec_bfd
)->elf_header
;
2764 Elf_Internal_Phdr
*phdr2
= elf_tdata (exec_bfd
)->phdr
;
2765 CORE_ADDR displacement
= 0;
2768 /* DISPLACEMENT could be found more easily by the difference of
2769 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2770 already have enough information to compute that displacement
2771 with what we've read. */
2773 for (i
= 0; i
< ehdr2
->e_phnum
; i
++)
2774 if (phdr2
[i
].p_type
== PT_LOAD
)
2776 Elf64_External_Phdr
*phdrp
;
2777 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2778 CORE_ADDR vaddr
, paddr
;
2779 CORE_ADDR displacement_vaddr
= 0;
2780 CORE_ADDR displacement_paddr
= 0;
2782 phdrp
= &((Elf64_External_Phdr
*) phdrs_target
->data ())[i
];
2783 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2784 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2786 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 8,
2788 displacement_vaddr
= vaddr
- phdr2
[i
].p_vaddr
;
2790 paddr
= extract_unsigned_integer (buf_paddr_p
, 8,
2792 displacement_paddr
= paddr
- phdr2
[i
].p_paddr
;
2794 if (displacement_vaddr
== displacement_paddr
)
2795 displacement
= displacement_vaddr
;
2800 /* Now compare BUF and BUF2 with optional DISPLACEMENT. */
2803 i
< phdrs_target
->size () / sizeof (Elf64_External_Phdr
);
2806 Elf64_External_Phdr
*phdrp
;
2807 Elf64_External_Phdr
*phdr2p
;
2808 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2809 CORE_ADDR vaddr
, paddr
;
2810 asection
*plt2_asect
;
2812 phdrp
= &((Elf64_External_Phdr
*) phdrs_target
->data ())[i
];
2813 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2814 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2815 phdr2p
= &((Elf64_External_Phdr
*) phdrs_binary
->data ())[i
];
2817 /* PT_GNU_STACK is an exception by being never relocated by
2818 prelink as its addresses are always zero. */
2820 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2823 /* Check also other adjustment combinations - PR 11786. */
2825 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 8,
2827 vaddr
-= displacement
;
2828 store_unsigned_integer (buf_vaddr_p
, 8, byte_order
, vaddr
);
2830 paddr
= extract_unsigned_integer (buf_paddr_p
, 8,
2832 paddr
-= displacement
;
2833 store_unsigned_integer (buf_paddr_p
, 8, byte_order
, paddr
);
2835 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2838 /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2839 CentOS-5 has problems with filesz, memsz as well.
2840 Strip also modifies memsz of PT_TLS.
2842 if (phdr2
[i
].p_type
== PT_GNU_RELRO
2843 || phdr2
[i
].p_type
== PT_TLS
)
2845 Elf64_External_Phdr tmp_phdr
= *phdrp
;
2846 Elf64_External_Phdr tmp_phdr2
= *phdr2p
;
2848 memset (tmp_phdr
.p_filesz
, 0, 8);
2849 memset (tmp_phdr
.p_memsz
, 0, 8);
2850 memset (tmp_phdr
.p_flags
, 0, 4);
2851 memset (tmp_phdr
.p_align
, 0, 8);
2852 memset (tmp_phdr2
.p_filesz
, 0, 8);
2853 memset (tmp_phdr2
.p_memsz
, 0, 8);
2854 memset (tmp_phdr2
.p_flags
, 0, 4);
2855 memset (tmp_phdr2
.p_align
, 0, 8);
2857 if (memcmp (&tmp_phdr
, &tmp_phdr2
, sizeof (tmp_phdr
))
2862 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2863 plt2_asect
= bfd_get_section_by_name (exec_bfd
, ".plt");
2867 gdb_byte
*buf_filesz_p
= (gdb_byte
*) &phdrp
->p_filesz
;
2870 content2
= (bfd_get_section_flags (exec_bfd
, plt2_asect
)
2871 & SEC_HAS_CONTENTS
) != 0;
2873 filesz
= extract_unsigned_integer (buf_filesz_p
, 8,
2876 /* PLT2_ASECT is from on-disk file (exec_bfd) while
2877 FILESZ is from the in-memory image. */
2879 filesz
+= bfd_get_section_size (plt2_asect
);
2881 filesz
-= bfd_get_section_size (plt2_asect
);
2883 store_unsigned_integer (buf_filesz_p
, 8, byte_order
,
2886 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2900 /* It can be printed repeatedly as there is no easy way to check
2901 the executable symbols/file has been already relocated to
2904 printf_unfiltered (_("Using PIE (Position Independent Executable) "
2905 "displacement %s for \"%s\".\n"),
2906 paddress (target_gdbarch (), exec_displacement
),
2907 bfd_get_filename (exec_bfd
));
2910 *displacementp
= exec_displacement
;
2914 /* Relocate the main executable. This function should be called upon
2915 stopping the inferior process at the entry point to the program.
2916 The entry point from BFD is compared to the AT_ENTRY of AUXV and if they are
2917 different, the main executable is relocated by the proper amount. */
2920 svr4_relocate_main_executable (void)
2922 CORE_ADDR displacement
;
2924 /* If we are re-running this executable, SYMFILE_OBJFILE->SECTION_OFFSETS
2925 probably contains the offsets computed using the PIE displacement
2926 from the previous run, which of course are irrelevant for this run.
2927 So we need to determine the new PIE displacement and recompute the
2928 section offsets accordingly, even if SYMFILE_OBJFILE->SECTION_OFFSETS
2929 already contains pre-computed offsets.
2931 If we cannot compute the PIE displacement, either:
2933 - The executable is not PIE.
2935 - SYMFILE_OBJFILE does not match the executable started in the target.
2936 This can happen for main executable symbols loaded at the host while
2937 `ld.so --ld-args main-executable' is loaded in the target.
2939 Then we leave the section offsets untouched and use them as is for
2942 - These section offsets were properly reset earlier, and thus
2943 already contain the correct values. This can happen for instance
2944 when reconnecting via the remote protocol to a target that supports
2945 the `qOffsets' packet.
2947 - The section offsets were not reset earlier, and the best we can
2948 hope is that the old offsets are still applicable to the new run. */
2950 if (! svr4_exec_displacement (&displacement
))
2953 /* Even DISPLACEMENT 0 is a valid new difference of in-memory vs. in-file
2956 if (symfile_objfile
)
2958 struct section_offsets
*new_offsets
;
2961 new_offsets
= XALLOCAVEC (struct section_offsets
,
2962 symfile_objfile
->num_sections
);
2964 for (i
= 0; i
< symfile_objfile
->num_sections
; i
++)
2965 new_offsets
->offsets
[i
] = displacement
;
2967 objfile_relocate (symfile_objfile
, new_offsets
);
2973 for (asect
= exec_bfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
2974 exec_set_section_address (bfd_get_filename (exec_bfd
), asect
->index
,
2975 (bfd_section_vma (exec_bfd
, asect
)
2980 /* Implement the "create_inferior_hook" target_solib_ops method.
2982 For SVR4 executables, this first instruction is either the first
2983 instruction in the dynamic linker (for dynamically linked
2984 executables) or the instruction at "start" for statically linked
2985 executables. For dynamically linked executables, the system
2986 first exec's /lib/libc.so.N, which contains the dynamic linker,
2987 and starts it running. The dynamic linker maps in any needed
2988 shared libraries, maps in the actual user executable, and then
2989 jumps to "start" in the user executable.
2991 We can arrange to cooperate with the dynamic linker to discover the
2992 names of shared libraries that are dynamically linked, and the base
2993 addresses to which they are linked.
2995 This function is responsible for discovering those names and
2996 addresses, and saving sufficient information about them to allow
2997 their symbols to be read at a later time. */
3000 svr4_solib_create_inferior_hook (int from_tty
)
3002 struct svr4_info
*info
;
3004 info
= get_svr4_info (current_program_space
);
3006 /* Clear the probes-based interface's state. */
3007 free_probes_table (info
);
3008 free_solib_list (info
);
3010 /* Relocate the main executable if necessary. */
3011 svr4_relocate_main_executable ();
3013 /* No point setting a breakpoint in the dynamic linker if we can't
3014 hit it (e.g., a core file, or a trace file). */
3015 if (!target_has_execution
)
3018 if (!svr4_have_link_map_offsets ())
3021 if (!enable_break (info
, from_tty
))
3026 svr4_clear_solib (void)
3028 struct svr4_info
*info
;
3030 info
= get_svr4_info (current_program_space
);
3031 info
->debug_base
= 0;
3032 info
->debug_loader_offset_p
= 0;
3033 info
->debug_loader_offset
= 0;
3034 xfree (info
->debug_loader_name
);
3035 info
->debug_loader_name
= NULL
;
3038 /* Clear any bits of ADDR that wouldn't fit in a target-format
3039 data pointer. "Data pointer" here refers to whatever sort of
3040 address the dynamic linker uses to manage its sections. At the
3041 moment, we don't support shared libraries on any processors where
3042 code and data pointers are different sizes.
3044 This isn't really the right solution. What we really need here is
3045 a way to do arithmetic on CORE_ADDR values that respects the
3046 natural pointer/address correspondence. (For example, on the MIPS,
3047 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
3048 sign-extend the value. There, simply truncating the bits above
3049 gdbarch_ptr_bit, as we do below, is no good.) This should probably
3050 be a new gdbarch method or something. */
3052 svr4_truncate_ptr (CORE_ADDR addr
)
3054 if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR
) * 8)
3055 /* We don't need to truncate anything, and the bit twiddling below
3056 will fail due to overflow problems. */
3059 return addr
& (((CORE_ADDR
) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
3064 svr4_relocate_section_addresses (struct so_list
*so
,
3065 struct target_section
*sec
)
3067 bfd
*abfd
= sec
->the_bfd_section
->owner
;
3069 sec
->addr
= svr4_truncate_ptr (sec
->addr
+ lm_addr_check (so
, abfd
));
3070 sec
->endaddr
= svr4_truncate_ptr (sec
->endaddr
+ lm_addr_check (so
, abfd
));
3074 /* Architecture-specific operations. */
3076 /* Per-architecture data key. */
3077 static struct gdbarch_data
*solib_svr4_data
;
3079 struct solib_svr4_ops
3081 /* Return a description of the layout of `struct link_map'. */
3082 struct link_map_offsets
*(*fetch_link_map_offsets
)(void);
3085 /* Return a default for the architecture-specific operations. */
3088 solib_svr4_init (struct obstack
*obstack
)
3090 struct solib_svr4_ops
*ops
;
3092 ops
= OBSTACK_ZALLOC (obstack
, struct solib_svr4_ops
);
3093 ops
->fetch_link_map_offsets
= NULL
;
3097 /* Set the architecture-specific `struct link_map_offsets' fetcher for
3098 GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */
3101 set_solib_svr4_fetch_link_map_offsets (struct gdbarch
*gdbarch
,
3102 struct link_map_offsets
*(*flmo
) (void))
3104 struct solib_svr4_ops
*ops
3105 = (struct solib_svr4_ops
*) gdbarch_data (gdbarch
, solib_svr4_data
);
3107 ops
->fetch_link_map_offsets
= flmo
;
3109 set_solib_ops (gdbarch
, &svr4_so_ops
);
3112 /* Fetch a link_map_offsets structure using the architecture-specific
3113 `struct link_map_offsets' fetcher. */
3115 static struct link_map_offsets
*
3116 svr4_fetch_link_map_offsets (void)
3118 struct solib_svr4_ops
*ops
3119 = (struct solib_svr4_ops
*) gdbarch_data (target_gdbarch (),
3122 gdb_assert (ops
->fetch_link_map_offsets
);
3123 return ops
->fetch_link_map_offsets ();
3126 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
3129 svr4_have_link_map_offsets (void)
3131 struct solib_svr4_ops
*ops
3132 = (struct solib_svr4_ops
*) gdbarch_data (target_gdbarch (),
3135 return (ops
->fetch_link_map_offsets
!= NULL
);
3139 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
3140 `struct r_debug' and a `struct link_map' that are binary compatible
3141 with the origional SVR4 implementation. */
3143 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3144 for an ILP32 SVR4 system. */
3146 struct link_map_offsets
*
3147 svr4_ilp32_fetch_link_map_offsets (void)
3149 static struct link_map_offsets lmo
;
3150 static struct link_map_offsets
*lmp
= NULL
;
3156 lmo
.r_version_offset
= 0;
3157 lmo
.r_version_size
= 4;
3158 lmo
.r_map_offset
= 4;
3159 lmo
.r_brk_offset
= 8;
3160 lmo
.r_ldsomap_offset
= 20;
3162 /* Everything we need is in the first 20 bytes. */
3163 lmo
.link_map_size
= 20;
3164 lmo
.l_addr_offset
= 0;
3165 lmo
.l_name_offset
= 4;
3166 lmo
.l_ld_offset
= 8;
3167 lmo
.l_next_offset
= 12;
3168 lmo
.l_prev_offset
= 16;
3174 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3175 for an LP64 SVR4 system. */
3177 struct link_map_offsets
*
3178 svr4_lp64_fetch_link_map_offsets (void)
3180 static struct link_map_offsets lmo
;
3181 static struct link_map_offsets
*lmp
= NULL
;
3187 lmo
.r_version_offset
= 0;
3188 lmo
.r_version_size
= 4;
3189 lmo
.r_map_offset
= 8;
3190 lmo
.r_brk_offset
= 16;
3191 lmo
.r_ldsomap_offset
= 40;
3193 /* Everything we need is in the first 40 bytes. */
3194 lmo
.link_map_size
= 40;
3195 lmo
.l_addr_offset
= 0;
3196 lmo
.l_name_offset
= 8;
3197 lmo
.l_ld_offset
= 16;
3198 lmo
.l_next_offset
= 24;
3199 lmo
.l_prev_offset
= 32;
3206 struct target_so_ops svr4_so_ops
;
3208 /* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a
3209 different rule for symbol lookup. The lookup begins here in the DSO, not in
3210 the main executable. */
3212 static struct block_symbol
3213 elf_lookup_lib_symbol (struct objfile
*objfile
,
3215 const domain_enum domain
)
3219 if (objfile
== symfile_objfile
)
3223 /* OBJFILE should have been passed as the non-debug one. */
3224 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
3226 abfd
= objfile
->obfd
;
3229 if (abfd
== NULL
|| scan_dyntag (DT_SYMBOLIC
, abfd
, NULL
, NULL
) != 1)
3232 return lookup_global_symbol_from_objfile (objfile
, GLOBAL_BLOCK
, name
,
3237 _initialize_svr4_solib (void)
3239 solib_svr4_data
= gdbarch_data_register_pre_init (solib_svr4_init
);
3241 svr4_so_ops
.relocate_section_addresses
= svr4_relocate_section_addresses
;
3242 svr4_so_ops
.free_so
= svr4_free_so
;
3243 svr4_so_ops
.clear_so
= svr4_clear_so
;
3244 svr4_so_ops
.clear_solib
= svr4_clear_solib
;
3245 svr4_so_ops
.solib_create_inferior_hook
= svr4_solib_create_inferior_hook
;
3246 svr4_so_ops
.current_sos
= svr4_current_sos
;
3247 svr4_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
3248 svr4_so_ops
.in_dynsym_resolve_code
= svr4_in_dynsym_resolve_code
;
3249 svr4_so_ops
.bfd_open
= solib_bfd_open
;
3250 svr4_so_ops
.lookup_lib_global_symbol
= elf_lookup_lib_symbol
;
3251 svr4_so_ops
.same
= svr4_same
;
3252 svr4_so_ops
.keep_data_in_core
= svr4_keep_data_in_core
;
3253 svr4_so_ops
.update_breakpoints
= svr4_update_solib_event_breakpoints
;
3254 svr4_so_ops
.handle_event
= svr4_handle_solib_event
;
3256 gdb::observers::free_objfile
.attach (svr4_free_objfile_observer
);