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 (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 (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 (sect
);
624 /* Read in .dynamic from the BFD. We will get the actual value
625 from memory later. */
626 sect_size
= bfd_section_size (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 (interp_sect
) + load_addr
;
2260 info
->interp_text_sect_high
2261 = info
->interp_text_sect_low
+ bfd_section_size (interp_sect
);
2263 interp_sect
= bfd_get_section_by_name (tmp_bfd
, ".plt");
2266 info
->interp_plt_sect_low
2267 = bfd_section_vma (interp_sect
) + load_addr
;
2268 info
->interp_plt_sect_high
2269 = info
->interp_plt_sect_low
+ bfd_section_size (interp_sect
);
2272 svr4_create_solib_event_breakpoints (info
, target_gdbarch (), sym_addr
);
2277 /* Find the program interpreter; if not found, warn the user and drop
2278 into the old breakpoint at symbol code. */
2279 gdb::optional
<gdb::byte_vector
> interp_name_holder
2280 = find_program_interpreter ();
2281 if (interp_name_holder
)
2283 const char *interp_name
= (const char *) interp_name_holder
->data ();
2284 CORE_ADDR load_addr
= 0;
2285 int load_addr_found
= 0;
2286 int loader_found_in_list
= 0;
2288 struct target_ops
*tmp_bfd_target
;
2292 /* Now we need to figure out where the dynamic linker was
2293 loaded so that we can load its symbols and place a breakpoint
2294 in the dynamic linker itself.
2296 This address is stored on the stack. However, I've been unable
2297 to find any magic formula to find it for Solaris (appears to
2298 be trivial on GNU/Linux). Therefore, we have to try an alternate
2299 mechanism to find the dynamic linker's base address. */
2301 gdb_bfd_ref_ptr tmp_bfd
;
2304 tmp_bfd
= solib_bfd_open (interp_name
);
2306 catch (const gdb_exception
&ex
)
2310 if (tmp_bfd
== NULL
)
2311 goto bkpt_at_symbol
;
2313 /* Now convert the TMP_BFD into a target. That way target, as
2314 well as BFD operations can be used. target_bfd_reopen
2315 acquires its own reference. */
2316 tmp_bfd_target
= target_bfd_reopen (tmp_bfd
.get ());
2318 /* On a running target, we can get the dynamic linker's base
2319 address from the shared library table. */
2320 so
= master_so_list ();
2323 if (svr4_same_1 (interp_name
, so
->so_original_name
))
2325 load_addr_found
= 1;
2326 loader_found_in_list
= 1;
2327 load_addr
= lm_addr_check (so
, tmp_bfd
.get ());
2333 /* If we were not able to find the base address of the loader
2334 from our so_list, then try using the AT_BASE auxilliary entry. */
2335 if (!load_addr_found
)
2336 if (target_auxv_search (current_top_target (), AT_BASE
, &load_addr
) > 0)
2338 int addr_bit
= gdbarch_addr_bit (target_gdbarch ());
2340 /* Ensure LOAD_ADDR has proper sign in its possible upper bits so
2341 that `+ load_addr' will overflow CORE_ADDR width not creating
2342 invalid addresses like 0x101234567 for 32bit inferiors on 64bit
2345 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
2347 CORE_ADDR space_size
= (CORE_ADDR
) 1 << addr_bit
;
2348 CORE_ADDR tmp_entry_point
= exec_entry_point (tmp_bfd
.get (),
2351 gdb_assert (load_addr
< space_size
);
2353 /* TMP_ENTRY_POINT exceeding SPACE_SIZE would be for prelinked
2354 64bit ld.so with 32bit executable, it should not happen. */
2356 if (tmp_entry_point
< space_size
2357 && tmp_entry_point
+ load_addr
>= space_size
)
2358 load_addr
-= space_size
;
2361 load_addr_found
= 1;
2364 /* Otherwise we find the dynamic linker's base address by examining
2365 the current pc (which should point at the entry point for the
2366 dynamic linker) and subtracting the offset of the entry point.
2368 This is more fragile than the previous approaches, but is a good
2369 fallback method because it has actually been working well in
2371 if (!load_addr_found
)
2373 struct regcache
*regcache
2374 = get_thread_arch_regcache (inferior_ptid
, target_gdbarch ());
2376 load_addr
= (regcache_read_pc (regcache
)
2377 - exec_entry_point (tmp_bfd
.get (), tmp_bfd_target
));
2380 if (!loader_found_in_list
)
2382 info
->debug_loader_name
= xstrdup (interp_name
);
2383 info
->debug_loader_offset_p
= 1;
2384 info
->debug_loader_offset
= load_addr
;
2385 solib_add (NULL
, from_tty
, auto_solib_add
);
2388 /* Record the relocated start and end address of the dynamic linker
2389 text and plt section for svr4_in_dynsym_resolve_code. */
2390 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".text");
2393 info
->interp_text_sect_low
2394 = bfd_section_vma (interp_sect
) + load_addr
;
2395 info
->interp_text_sect_high
2396 = info
->interp_text_sect_low
+ bfd_section_size (interp_sect
);
2398 interp_sect
= bfd_get_section_by_name (tmp_bfd
.get (), ".plt");
2401 info
->interp_plt_sect_low
2402 = bfd_section_vma (interp_sect
) + load_addr
;
2403 info
->interp_plt_sect_high
2404 = info
->interp_plt_sect_low
+ bfd_section_size (interp_sect
);
2407 /* Now try to set a breakpoint in the dynamic linker. */
2408 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2410 sym_addr
= gdb_bfd_lookup_symbol (tmp_bfd
.get (),
2411 cmp_name_and_sec_flags
,
2418 /* Convert 'sym_addr' from a function pointer to an address.
2419 Because we pass tmp_bfd_target instead of the current
2420 target, this will always produce an unrelocated value. */
2421 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2425 /* We're done with both the temporary bfd and target. Closing
2426 the target closes the underlying bfd, because it holds the
2427 only remaining reference. */
2428 target_close (tmp_bfd_target
);
2432 svr4_create_solib_event_breakpoints (info
, target_gdbarch (),
2433 load_addr
+ sym_addr
);
2437 /* For whatever reason we couldn't set a breakpoint in the dynamic
2438 linker. Warn and drop into the old code. */
2440 warning (_("Unable to find dynamic linker breakpoint function.\n"
2441 "GDB will be unable to debug shared library initializers\n"
2442 "and track explicitly loaded dynamic code."));
2445 /* Scan through the lists of symbols, trying to look up the symbol and
2446 set a breakpoint there. Terminate loop when we/if we succeed. */
2448 for (bkpt_namep
= solib_break_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2450 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
2451 if ((msymbol
.minsym
!= NULL
)
2452 && (BMSYMBOL_VALUE_ADDRESS (msymbol
) != 0))
2454 sym_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
2455 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2457 current_top_target ());
2458 svr4_create_solib_event_breakpoints (info
, target_gdbarch (),
2464 if (interp_name_holder
&& !current_inferior ()->attach_flag
)
2466 for (bkpt_namep
= bkpt_names
; *bkpt_namep
!= NULL
; bkpt_namep
++)
2468 msymbol
= lookup_minimal_symbol (*bkpt_namep
, NULL
, symfile_objfile
);
2469 if ((msymbol
.minsym
!= NULL
)
2470 && (BMSYMBOL_VALUE_ADDRESS (msymbol
) != 0))
2472 sym_addr
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
2473 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2475 current_top_target ());
2476 svr4_create_solib_event_breakpoints (info
, target_gdbarch (),
2485 /* Read the ELF program headers from ABFD. */
2487 static gdb::optional
<gdb::byte_vector
>
2488 read_program_headers_from_bfd (bfd
*abfd
)
2490 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (abfd
);
2491 int phdrs_size
= ehdr
->e_phnum
* ehdr
->e_phentsize
;
2492 if (phdrs_size
== 0)
2495 gdb::byte_vector
buf (phdrs_size
);
2496 if (bfd_seek (abfd
, ehdr
->e_phoff
, SEEK_SET
) != 0
2497 || bfd_bread (buf
.data (), phdrs_size
, abfd
) != phdrs_size
)
2503 /* Return 1 and fill *DISPLACEMENTP with detected PIE offset of inferior
2504 exec_bfd. Otherwise return 0.
2506 We relocate all of the sections by the same amount. This
2507 behavior is mandated by recent editions of the System V ABI.
2508 According to the System V Application Binary Interface,
2509 Edition 4.1, page 5-5:
2511 ... Though the system chooses virtual addresses for
2512 individual processes, it maintains the segments' relative
2513 positions. Because position-independent code uses relative
2514 addressesing between segments, the difference between
2515 virtual addresses in memory must match the difference
2516 between virtual addresses in the file. The difference
2517 between the virtual address of any segment in memory and
2518 the corresponding virtual address in the file is thus a
2519 single constant value for any one executable or shared
2520 object in a given process. This difference is the base
2521 address. One use of the base address is to relocate the
2522 memory image of the program during dynamic linking.
2524 The same language also appears in Edition 4.0 of the System V
2525 ABI and is left unspecified in some of the earlier editions.
2527 Decide if the objfile needs to be relocated. As indicated above, we will
2528 only be here when execution is stopped. But during attachment PC can be at
2529 arbitrary address therefore regcache_read_pc can be misleading (contrary to
2530 the auxv AT_ENTRY value). Moreover for executable with interpreter section
2531 regcache_read_pc would point to the interpreter and not the main executable.
2533 So, to summarize, relocations are necessary when the start address obtained
2534 from the executable is different from the address in auxv AT_ENTRY entry.
2536 [ The astute reader will note that we also test to make sure that
2537 the executable in question has the DYNAMIC flag set. It is my
2538 opinion that this test is unnecessary (undesirable even). It
2539 was added to avoid inadvertent relocation of an executable
2540 whose e_type member in the ELF header is not ET_DYN. There may
2541 be a time in the future when it is desirable to do relocations
2542 on other types of files as well in which case this condition
2543 should either be removed or modified to accomodate the new file
2544 type. - Kevin, Nov 2000. ] */
2547 svr4_exec_displacement (CORE_ADDR
*displacementp
)
2549 /* ENTRY_POINT is a possible function descriptor - before
2550 a call to gdbarch_convert_from_func_ptr_addr. */
2551 CORE_ADDR entry_point
, exec_displacement
;
2553 if (exec_bfd
== NULL
)
2556 /* Therefore for ELF it is ET_EXEC and not ET_DYN. Both shared libraries
2557 being executed themselves and PIE (Position Independent Executable)
2558 executables are ET_DYN. */
2560 if ((bfd_get_file_flags (exec_bfd
) & DYNAMIC
) == 0)
2563 if (target_auxv_search (current_top_target (), AT_ENTRY
, &entry_point
) <= 0)
2566 exec_displacement
= entry_point
- bfd_get_start_address (exec_bfd
);
2568 /* Verify the EXEC_DISPLACEMENT candidate complies with the required page
2569 alignment. It is cheaper than the program headers comparison below. */
2571 if (bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
2573 const struct elf_backend_data
*elf
= get_elf_backend_data (exec_bfd
);
2575 /* p_align of PT_LOAD segments does not specify any alignment but
2576 only congruency of addresses:
2577 p_offset % p_align == p_vaddr % p_align
2578 Kernel is free to load the executable with lower alignment. */
2580 if ((exec_displacement
& (elf
->minpagesize
- 1)) != 0)
2584 /* Verify that the auxilliary vector describes the same file as exec_bfd, by
2585 comparing their program headers. If the program headers in the auxilliary
2586 vector do not match the program headers in the executable, then we are
2587 looking at a different file than the one used by the kernel - for
2588 instance, "gdb program" connected to "gdbserver :PORT ld.so program". */
2590 if (bfd_get_flavour (exec_bfd
) == bfd_target_elf_flavour
)
2592 /* Be optimistic and return 0 only if GDB was able to verify the headers
2593 really do not match. */
2596 gdb::optional
<gdb::byte_vector
> phdrs_target
2597 = read_program_header (-1, &arch_size
, NULL
);
2598 gdb::optional
<gdb::byte_vector
> phdrs_binary
2599 = read_program_headers_from_bfd (exec_bfd
);
2600 if (phdrs_target
&& phdrs_binary
)
2602 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
2604 /* We are dealing with three different addresses. EXEC_BFD
2605 represents current address in on-disk file. target memory content
2606 may be different from EXEC_BFD as the file may have been prelinked
2607 to a different address after the executable has been loaded.
2608 Moreover the address of placement in target memory can be
2609 different from what the program headers in target memory say -
2610 this is the goal of PIE.
2612 Detected DISPLACEMENT covers both the offsets of PIE placement and
2613 possible new prelink performed after start of the program. Here
2614 relocate BUF and BUF2 just by the EXEC_BFD vs. target memory
2615 content offset for the verification purpose. */
2617 if (phdrs_target
->size () != phdrs_binary
->size ()
2618 || bfd_get_arch_size (exec_bfd
) != arch_size
)
2620 else if (arch_size
== 32
2621 && phdrs_target
->size () >= sizeof (Elf32_External_Phdr
)
2622 && phdrs_target
->size () % sizeof (Elf32_External_Phdr
) == 0)
2624 Elf_Internal_Ehdr
*ehdr2
= elf_tdata (exec_bfd
)->elf_header
;
2625 Elf_Internal_Phdr
*phdr2
= elf_tdata (exec_bfd
)->phdr
;
2626 CORE_ADDR displacement
= 0;
2629 /* DISPLACEMENT could be found more easily by the difference of
2630 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2631 already have enough information to compute that displacement
2632 with what we've read. */
2634 for (i
= 0; i
< ehdr2
->e_phnum
; i
++)
2635 if (phdr2
[i
].p_type
== PT_LOAD
)
2637 Elf32_External_Phdr
*phdrp
;
2638 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2639 CORE_ADDR vaddr
, paddr
;
2640 CORE_ADDR displacement_vaddr
= 0;
2641 CORE_ADDR displacement_paddr
= 0;
2643 phdrp
= &((Elf32_External_Phdr
*) phdrs_target
->data ())[i
];
2644 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2645 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2647 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 4,
2649 displacement_vaddr
= vaddr
- phdr2
[i
].p_vaddr
;
2651 paddr
= extract_unsigned_integer (buf_paddr_p
, 4,
2653 displacement_paddr
= paddr
- phdr2
[i
].p_paddr
;
2655 if (displacement_vaddr
== displacement_paddr
)
2656 displacement
= displacement_vaddr
;
2661 /* Now compare program headers from the target and the binary
2662 with optional DISPLACEMENT. */
2665 i
< phdrs_target
->size () / sizeof (Elf32_External_Phdr
);
2668 Elf32_External_Phdr
*phdrp
;
2669 Elf32_External_Phdr
*phdr2p
;
2670 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2671 CORE_ADDR vaddr
, paddr
;
2672 asection
*plt2_asect
;
2674 phdrp
= &((Elf32_External_Phdr
*) phdrs_target
->data ())[i
];
2675 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2676 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2677 phdr2p
= &((Elf32_External_Phdr
*) phdrs_binary
->data ())[i
];
2679 /* PT_GNU_STACK is an exception by being never relocated by
2680 prelink as its addresses are always zero. */
2682 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2685 /* Check also other adjustment combinations - PR 11786. */
2687 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 4,
2689 vaddr
-= displacement
;
2690 store_unsigned_integer (buf_vaddr_p
, 4, byte_order
, vaddr
);
2692 paddr
= extract_unsigned_integer (buf_paddr_p
, 4,
2694 paddr
-= displacement
;
2695 store_unsigned_integer (buf_paddr_p
, 4, byte_order
, paddr
);
2697 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2700 /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2701 CentOS-5 has problems with filesz, memsz as well.
2702 Strip also modifies memsz of PT_TLS.
2704 if (phdr2
[i
].p_type
== PT_GNU_RELRO
2705 || phdr2
[i
].p_type
== PT_TLS
)
2707 Elf32_External_Phdr tmp_phdr
= *phdrp
;
2708 Elf32_External_Phdr tmp_phdr2
= *phdr2p
;
2710 memset (tmp_phdr
.p_filesz
, 0, 4);
2711 memset (tmp_phdr
.p_memsz
, 0, 4);
2712 memset (tmp_phdr
.p_flags
, 0, 4);
2713 memset (tmp_phdr
.p_align
, 0, 4);
2714 memset (tmp_phdr2
.p_filesz
, 0, 4);
2715 memset (tmp_phdr2
.p_memsz
, 0, 4);
2716 memset (tmp_phdr2
.p_flags
, 0, 4);
2717 memset (tmp_phdr2
.p_align
, 0, 4);
2719 if (memcmp (&tmp_phdr
, &tmp_phdr2
, sizeof (tmp_phdr
))
2724 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2725 plt2_asect
= bfd_get_section_by_name (exec_bfd
, ".plt");
2729 gdb_byte
*buf_filesz_p
= (gdb_byte
*) &phdrp
->p_filesz
;
2732 content2
= (bfd_section_flags (plt2_asect
)
2733 & SEC_HAS_CONTENTS
) != 0;
2735 filesz
= extract_unsigned_integer (buf_filesz_p
, 4,
2738 /* PLT2_ASECT is from on-disk file (exec_bfd) while
2739 FILESZ is from the in-memory image. */
2741 filesz
+= bfd_section_size (plt2_asect
);
2743 filesz
-= bfd_section_size (plt2_asect
);
2745 store_unsigned_integer (buf_filesz_p
, 4, byte_order
,
2748 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2755 else if (arch_size
== 64
2756 && phdrs_target
->size () >= sizeof (Elf64_External_Phdr
)
2757 && phdrs_target
->size () % sizeof (Elf64_External_Phdr
) == 0)
2759 Elf_Internal_Ehdr
*ehdr2
= elf_tdata (exec_bfd
)->elf_header
;
2760 Elf_Internal_Phdr
*phdr2
= elf_tdata (exec_bfd
)->phdr
;
2761 CORE_ADDR displacement
= 0;
2764 /* DISPLACEMENT could be found more easily by the difference of
2765 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2766 already have enough information to compute that displacement
2767 with what we've read. */
2769 for (i
= 0; i
< ehdr2
->e_phnum
; i
++)
2770 if (phdr2
[i
].p_type
== PT_LOAD
)
2772 Elf64_External_Phdr
*phdrp
;
2773 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2774 CORE_ADDR vaddr
, paddr
;
2775 CORE_ADDR displacement_vaddr
= 0;
2776 CORE_ADDR displacement_paddr
= 0;
2778 phdrp
= &((Elf64_External_Phdr
*) phdrs_target
->data ())[i
];
2779 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2780 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2782 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 8,
2784 displacement_vaddr
= vaddr
- phdr2
[i
].p_vaddr
;
2786 paddr
= extract_unsigned_integer (buf_paddr_p
, 8,
2788 displacement_paddr
= paddr
- phdr2
[i
].p_paddr
;
2790 if (displacement_vaddr
== displacement_paddr
)
2791 displacement
= displacement_vaddr
;
2796 /* Now compare BUF and BUF2 with optional DISPLACEMENT. */
2799 i
< phdrs_target
->size () / sizeof (Elf64_External_Phdr
);
2802 Elf64_External_Phdr
*phdrp
;
2803 Elf64_External_Phdr
*phdr2p
;
2804 gdb_byte
*buf_vaddr_p
, *buf_paddr_p
;
2805 CORE_ADDR vaddr
, paddr
;
2806 asection
*plt2_asect
;
2808 phdrp
= &((Elf64_External_Phdr
*) phdrs_target
->data ())[i
];
2809 buf_vaddr_p
= (gdb_byte
*) &phdrp
->p_vaddr
;
2810 buf_paddr_p
= (gdb_byte
*) &phdrp
->p_paddr
;
2811 phdr2p
= &((Elf64_External_Phdr
*) phdrs_binary
->data ())[i
];
2813 /* PT_GNU_STACK is an exception by being never relocated by
2814 prelink as its addresses are always zero. */
2816 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2819 /* Check also other adjustment combinations - PR 11786. */
2821 vaddr
= extract_unsigned_integer (buf_vaddr_p
, 8,
2823 vaddr
-= displacement
;
2824 store_unsigned_integer (buf_vaddr_p
, 8, byte_order
, vaddr
);
2826 paddr
= extract_unsigned_integer (buf_paddr_p
, 8,
2828 paddr
-= displacement
;
2829 store_unsigned_integer (buf_paddr_p
, 8, byte_order
, paddr
);
2831 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2834 /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2835 CentOS-5 has problems with filesz, memsz as well.
2836 Strip also modifies memsz of PT_TLS.
2838 if (phdr2
[i
].p_type
== PT_GNU_RELRO
2839 || phdr2
[i
].p_type
== PT_TLS
)
2841 Elf64_External_Phdr tmp_phdr
= *phdrp
;
2842 Elf64_External_Phdr tmp_phdr2
= *phdr2p
;
2844 memset (tmp_phdr
.p_filesz
, 0, 8);
2845 memset (tmp_phdr
.p_memsz
, 0, 8);
2846 memset (tmp_phdr
.p_flags
, 0, 4);
2847 memset (tmp_phdr
.p_align
, 0, 8);
2848 memset (tmp_phdr2
.p_filesz
, 0, 8);
2849 memset (tmp_phdr2
.p_memsz
, 0, 8);
2850 memset (tmp_phdr2
.p_flags
, 0, 4);
2851 memset (tmp_phdr2
.p_align
, 0, 8);
2853 if (memcmp (&tmp_phdr
, &tmp_phdr2
, sizeof (tmp_phdr
))
2858 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2859 plt2_asect
= bfd_get_section_by_name (exec_bfd
, ".plt");
2863 gdb_byte
*buf_filesz_p
= (gdb_byte
*) &phdrp
->p_filesz
;
2866 content2
= (bfd_section_flags (plt2_asect
)
2867 & SEC_HAS_CONTENTS
) != 0;
2869 filesz
= extract_unsigned_integer (buf_filesz_p
, 8,
2872 /* PLT2_ASECT is from on-disk file (exec_bfd) while
2873 FILESZ is from the in-memory image. */
2875 filesz
+= bfd_section_size (plt2_asect
);
2877 filesz
-= bfd_section_size (plt2_asect
);
2879 store_unsigned_integer (buf_filesz_p
, 8, byte_order
,
2882 if (memcmp (phdrp
, phdr2p
, sizeof (*phdrp
)) == 0)
2896 /* It can be printed repeatedly as there is no easy way to check
2897 the executable symbols/file has been already relocated to
2900 printf_unfiltered (_("Using PIE (Position Independent Executable) "
2901 "displacement %s for \"%s\".\n"),
2902 paddress (target_gdbarch (), exec_displacement
),
2903 bfd_get_filename (exec_bfd
));
2906 *displacementp
= exec_displacement
;
2910 /* Relocate the main executable. This function should be called upon
2911 stopping the inferior process at the entry point to the program.
2912 The entry point from BFD is compared to the AT_ENTRY of AUXV and if they are
2913 different, the main executable is relocated by the proper amount. */
2916 svr4_relocate_main_executable (void)
2918 CORE_ADDR displacement
;
2920 /* If we are re-running this executable, SYMFILE_OBJFILE->SECTION_OFFSETS
2921 probably contains the offsets computed using the PIE displacement
2922 from the previous run, which of course are irrelevant for this run.
2923 So we need to determine the new PIE displacement and recompute the
2924 section offsets accordingly, even if SYMFILE_OBJFILE->SECTION_OFFSETS
2925 already contains pre-computed offsets.
2927 If we cannot compute the PIE displacement, either:
2929 - The executable is not PIE.
2931 - SYMFILE_OBJFILE does not match the executable started in the target.
2932 This can happen for main executable symbols loaded at the host while
2933 `ld.so --ld-args main-executable' is loaded in the target.
2935 Then we leave the section offsets untouched and use them as is for
2938 - These section offsets were properly reset earlier, and thus
2939 already contain the correct values. This can happen for instance
2940 when reconnecting via the remote protocol to a target that supports
2941 the `qOffsets' packet.
2943 - The section offsets were not reset earlier, and the best we can
2944 hope is that the old offsets are still applicable to the new run. */
2946 if (! svr4_exec_displacement (&displacement
))
2949 /* Even DISPLACEMENT 0 is a valid new difference of in-memory vs. in-file
2952 if (symfile_objfile
)
2954 struct section_offsets
*new_offsets
;
2957 new_offsets
= XALLOCAVEC (struct section_offsets
,
2958 symfile_objfile
->num_sections
);
2960 for (i
= 0; i
< symfile_objfile
->num_sections
; i
++)
2961 new_offsets
->offsets
[i
] = displacement
;
2963 objfile_relocate (symfile_objfile
, new_offsets
);
2969 for (asect
= exec_bfd
->sections
; asect
!= NULL
; asect
= asect
->next
)
2970 exec_set_section_address (bfd_get_filename (exec_bfd
), asect
->index
,
2971 bfd_section_vma (asect
) + displacement
);
2975 /* Implement the "create_inferior_hook" target_solib_ops method.
2977 For SVR4 executables, this first instruction is either the first
2978 instruction in the dynamic linker (for dynamically linked
2979 executables) or the instruction at "start" for statically linked
2980 executables. For dynamically linked executables, the system
2981 first exec's /lib/libc.so.N, which contains the dynamic linker,
2982 and starts it running. The dynamic linker maps in any needed
2983 shared libraries, maps in the actual user executable, and then
2984 jumps to "start" in the user executable.
2986 We can arrange to cooperate with the dynamic linker to discover the
2987 names of shared libraries that are dynamically linked, and the base
2988 addresses to which they are linked.
2990 This function is responsible for discovering those names and
2991 addresses, and saving sufficient information about them to allow
2992 their symbols to be read at a later time. */
2995 svr4_solib_create_inferior_hook (int from_tty
)
2997 struct svr4_info
*info
;
2999 info
= get_svr4_info (current_program_space
);
3001 /* Clear the probes-based interface's state. */
3002 free_probes_table (info
);
3003 free_solib_list (info
);
3005 /* Relocate the main executable if necessary. */
3006 svr4_relocate_main_executable ();
3008 /* No point setting a breakpoint in the dynamic linker if we can't
3009 hit it (e.g., a core file, or a trace file). */
3010 if (!target_has_execution
)
3013 if (!svr4_have_link_map_offsets ())
3016 if (!enable_break (info
, from_tty
))
3021 svr4_clear_solib (void)
3023 struct svr4_info
*info
;
3025 info
= get_svr4_info (current_program_space
);
3026 info
->debug_base
= 0;
3027 info
->debug_loader_offset_p
= 0;
3028 info
->debug_loader_offset
= 0;
3029 xfree (info
->debug_loader_name
);
3030 info
->debug_loader_name
= NULL
;
3033 /* Clear any bits of ADDR that wouldn't fit in a target-format
3034 data pointer. "Data pointer" here refers to whatever sort of
3035 address the dynamic linker uses to manage its sections. At the
3036 moment, we don't support shared libraries on any processors where
3037 code and data pointers are different sizes.
3039 This isn't really the right solution. What we really need here is
3040 a way to do arithmetic on CORE_ADDR values that respects the
3041 natural pointer/address correspondence. (For example, on the MIPS,
3042 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
3043 sign-extend the value. There, simply truncating the bits above
3044 gdbarch_ptr_bit, as we do below, is no good.) This should probably
3045 be a new gdbarch method or something. */
3047 svr4_truncate_ptr (CORE_ADDR addr
)
3049 if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR
) * 8)
3050 /* We don't need to truncate anything, and the bit twiddling below
3051 will fail due to overflow problems. */
3054 return addr
& (((CORE_ADDR
) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
3059 svr4_relocate_section_addresses (struct so_list
*so
,
3060 struct target_section
*sec
)
3062 bfd
*abfd
= sec
->the_bfd_section
->owner
;
3064 sec
->addr
= svr4_truncate_ptr (sec
->addr
+ lm_addr_check (so
, abfd
));
3065 sec
->endaddr
= svr4_truncate_ptr (sec
->endaddr
+ lm_addr_check (so
, abfd
));
3069 /* Architecture-specific operations. */
3071 /* Per-architecture data key. */
3072 static struct gdbarch_data
*solib_svr4_data
;
3074 struct solib_svr4_ops
3076 /* Return a description of the layout of `struct link_map'. */
3077 struct link_map_offsets
*(*fetch_link_map_offsets
)(void);
3080 /* Return a default for the architecture-specific operations. */
3083 solib_svr4_init (struct obstack
*obstack
)
3085 struct solib_svr4_ops
*ops
;
3087 ops
= OBSTACK_ZALLOC (obstack
, struct solib_svr4_ops
);
3088 ops
->fetch_link_map_offsets
= NULL
;
3092 /* Set the architecture-specific `struct link_map_offsets' fetcher for
3093 GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */
3096 set_solib_svr4_fetch_link_map_offsets (struct gdbarch
*gdbarch
,
3097 struct link_map_offsets
*(*flmo
) (void))
3099 struct solib_svr4_ops
*ops
3100 = (struct solib_svr4_ops
*) gdbarch_data (gdbarch
, solib_svr4_data
);
3102 ops
->fetch_link_map_offsets
= flmo
;
3104 set_solib_ops (gdbarch
, &svr4_so_ops
);
3107 /* Fetch a link_map_offsets structure using the architecture-specific
3108 `struct link_map_offsets' fetcher. */
3110 static struct link_map_offsets
*
3111 svr4_fetch_link_map_offsets (void)
3113 struct solib_svr4_ops
*ops
3114 = (struct solib_svr4_ops
*) gdbarch_data (target_gdbarch (),
3117 gdb_assert (ops
->fetch_link_map_offsets
);
3118 return ops
->fetch_link_map_offsets ();
3121 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
3124 svr4_have_link_map_offsets (void)
3126 struct solib_svr4_ops
*ops
3127 = (struct solib_svr4_ops
*) gdbarch_data (target_gdbarch (),
3130 return (ops
->fetch_link_map_offsets
!= NULL
);
3134 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
3135 `struct r_debug' and a `struct link_map' that are binary compatible
3136 with the origional SVR4 implementation. */
3138 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3139 for an ILP32 SVR4 system. */
3141 struct link_map_offsets
*
3142 svr4_ilp32_fetch_link_map_offsets (void)
3144 static struct link_map_offsets lmo
;
3145 static struct link_map_offsets
*lmp
= NULL
;
3151 lmo
.r_version_offset
= 0;
3152 lmo
.r_version_size
= 4;
3153 lmo
.r_map_offset
= 4;
3154 lmo
.r_brk_offset
= 8;
3155 lmo
.r_ldsomap_offset
= 20;
3157 /* Everything we need is in the first 20 bytes. */
3158 lmo
.link_map_size
= 20;
3159 lmo
.l_addr_offset
= 0;
3160 lmo
.l_name_offset
= 4;
3161 lmo
.l_ld_offset
= 8;
3162 lmo
.l_next_offset
= 12;
3163 lmo
.l_prev_offset
= 16;
3169 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3170 for an LP64 SVR4 system. */
3172 struct link_map_offsets
*
3173 svr4_lp64_fetch_link_map_offsets (void)
3175 static struct link_map_offsets lmo
;
3176 static struct link_map_offsets
*lmp
= NULL
;
3182 lmo
.r_version_offset
= 0;
3183 lmo
.r_version_size
= 4;
3184 lmo
.r_map_offset
= 8;
3185 lmo
.r_brk_offset
= 16;
3186 lmo
.r_ldsomap_offset
= 40;
3188 /* Everything we need is in the first 40 bytes. */
3189 lmo
.link_map_size
= 40;
3190 lmo
.l_addr_offset
= 0;
3191 lmo
.l_name_offset
= 8;
3192 lmo
.l_ld_offset
= 16;
3193 lmo
.l_next_offset
= 24;
3194 lmo
.l_prev_offset
= 32;
3201 struct target_so_ops svr4_so_ops
;
3203 /* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a
3204 different rule for symbol lookup. The lookup begins here in the DSO, not in
3205 the main executable. */
3207 static struct block_symbol
3208 elf_lookup_lib_symbol (struct objfile
*objfile
,
3210 const domain_enum domain
)
3214 if (objfile
== symfile_objfile
)
3218 /* OBJFILE should have been passed as the non-debug one. */
3219 gdb_assert (objfile
->separate_debug_objfile_backlink
== NULL
);
3221 abfd
= objfile
->obfd
;
3224 if (abfd
== NULL
|| scan_dyntag (DT_SYMBOLIC
, abfd
, NULL
, NULL
) != 1)
3227 return lookup_global_symbol_from_objfile (objfile
, GLOBAL_BLOCK
, name
,
3232 _initialize_svr4_solib (void)
3234 solib_svr4_data
= gdbarch_data_register_pre_init (solib_svr4_init
);
3236 svr4_so_ops
.relocate_section_addresses
= svr4_relocate_section_addresses
;
3237 svr4_so_ops
.free_so
= svr4_free_so
;
3238 svr4_so_ops
.clear_so
= svr4_clear_so
;
3239 svr4_so_ops
.clear_solib
= svr4_clear_solib
;
3240 svr4_so_ops
.solib_create_inferior_hook
= svr4_solib_create_inferior_hook
;
3241 svr4_so_ops
.current_sos
= svr4_current_sos
;
3242 svr4_so_ops
.open_symbol_file_object
= open_symbol_file_object
;
3243 svr4_so_ops
.in_dynsym_resolve_code
= svr4_in_dynsym_resolve_code
;
3244 svr4_so_ops
.bfd_open
= solib_bfd_open
;
3245 svr4_so_ops
.lookup_lib_global_symbol
= elf_lookup_lib_symbol
;
3246 svr4_so_ops
.same
= svr4_same
;
3247 svr4_so_ops
.keep_data_in_core
= svr4_keep_data_in_core
;
3248 svr4_so_ops
.update_breakpoints
= svr4_update_solib_event_breakpoints
;
3249 svr4_so_ops
.handle_event
= svr4_handle_solib_event
;
3251 gdb::observers::free_objfile
.attach (svr4_free_objfile_observer
);