1 /* Handle SVR4 shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 1990-2015 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"
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);
54 /* Link map info to include in an allocated so_list entry. */
58 /* Amount by which addresses in the binary should be relocated to
59 match the inferior. The direct inferior value is L_ADDR_INFERIOR.
60 When prelinking is involved and the prelink base address changes,
61 we may need a different offset - the recomputed offset is in L_ADDR.
62 It is commonly the same value. It is cached as we want to warn about
63 the difference and compute it only once. L_ADDR is valid
65 CORE_ADDR l_addr, l_addr_inferior;
66 unsigned int l_addr_p : 1;
68 /* The target location of lm. */
71 /* Values read in from inferior's fields of the same name. */
72 CORE_ADDR l_ld, l_next, l_prev, l_name;
75 /* On SVR4 systems, a list of symbols in the dynamic linker where
76 GDB can try to place a breakpoint to monitor shared library
79 If none of these symbols are found, or other errors occur, then
80 SVR4 systems will fall back to using a symbol as the "startup
81 mapping complete" breakpoint address. */
83 static const char * const solib_break_names[] =
89 "__dl_rtld_db_dlactivity",
95 static const char * const bkpt_names[] =
103 static const char * const main_name_list[] =
109 /* What to do when a probe stop occurs. */
113 /* Something went seriously wrong. Stop using probes and
114 revert to using the older interface. */
115 PROBES_INTERFACE_FAILED,
117 /* No action is required. The shared object list is still
121 /* The shared object list should be reloaded entirely. */
124 /* Attempt to incrementally update the shared object list. If
125 the update fails or is not possible, fall back to reloading
130 /* A probe's name and its associated action. */
134 /* The name of the probe. */
137 /* What to do when a probe stop occurs. */
138 enum probe_action action;
141 /* A list of named probes and their associated actions. If all
142 probes are present in the dynamic linker then the probes-based
143 interface will be used. */
145 static const struct probe_info probe_info[] =
147 { "init_start", DO_NOTHING },
148 { "init_complete", FULL_RELOAD },
149 { "map_start", DO_NOTHING },
150 { "map_failed", DO_NOTHING },
151 { "reloc_complete", UPDATE_OR_RELOAD },
152 { "unmap_start", DO_NOTHING },
153 { "unmap_complete", FULL_RELOAD },
156 #define NUM_PROBES ARRAY_SIZE (probe_info)
158 /* Return non-zero if GDB_SO_NAME and INFERIOR_SO_NAME represent
159 the same shared library. */
162 svr4_same_1 (const char *gdb_so_name, const char *inferior_so_name)
164 if (strcmp (gdb_so_name, inferior_so_name) == 0)
167 /* On Solaris, when starting inferior we think that dynamic linker is
168 /usr/lib/ld.so.1, but later on, the table of loaded shared libraries
169 contains /lib/ld.so.1. Sometimes one file is a link to another, but
170 sometimes they have identical content, but are not linked to each
171 other. We don't restrict this check for Solaris, but the chances
172 of running into this situation elsewhere are very low. */
173 if (strcmp (gdb_so_name, "/usr/lib/ld.so.1") == 0
174 && strcmp (inferior_so_name, "/lib/ld.so.1") == 0)
177 /* Similarly, we observed the same issue with sparc64, but with
178 different locations. */
179 if (strcmp (gdb_so_name, "/usr/lib/sparcv9/ld.so.1") == 0
180 && strcmp (inferior_so_name, "/lib/sparcv9/ld.so.1") == 0)
187 svr4_same (struct so_list *gdb, struct so_list *inferior)
189 return (svr4_same_1 (gdb->so_original_name, inferior->so_original_name));
192 static struct lm_info *
193 lm_info_read (CORE_ADDR lm_addr)
195 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
197 struct lm_info *lm_info;
198 struct cleanup *back_to;
200 lm = xmalloc (lmo->link_map_size);
201 back_to = make_cleanup (xfree, lm);
203 if (target_read_memory (lm_addr, lm, lmo->link_map_size) != 0)
205 warning (_("Error reading shared library list entry at %s"),
206 paddress (target_gdbarch (), lm_addr)),
211 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
213 lm_info = xzalloc (sizeof (*lm_info));
214 lm_info->lm_addr = lm_addr;
216 lm_info->l_addr_inferior = extract_typed_address (&lm[lmo->l_addr_offset],
218 lm_info->l_ld = extract_typed_address (&lm[lmo->l_ld_offset], ptr_type);
219 lm_info->l_next = extract_typed_address (&lm[lmo->l_next_offset],
221 lm_info->l_prev = extract_typed_address (&lm[lmo->l_prev_offset],
223 lm_info->l_name = extract_typed_address (&lm[lmo->l_name_offset],
227 do_cleanups (back_to);
233 has_lm_dynamic_from_link_map (void)
235 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
237 return lmo->l_ld_offset >= 0;
241 lm_addr_check (const struct so_list *so, bfd *abfd)
243 if (!so->lm_info->l_addr_p)
245 struct bfd_section *dyninfo_sect;
246 CORE_ADDR l_addr, l_dynaddr, dynaddr;
248 l_addr = so->lm_info->l_addr_inferior;
250 if (! abfd || ! has_lm_dynamic_from_link_map ())
253 l_dynaddr = so->lm_info->l_ld;
255 dyninfo_sect = bfd_get_section_by_name (abfd, ".dynamic");
256 if (dyninfo_sect == NULL)
259 dynaddr = bfd_section_vma (abfd, dyninfo_sect);
261 if (dynaddr + l_addr != l_dynaddr)
263 CORE_ADDR align = 0x1000;
264 CORE_ADDR minpagesize = align;
266 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
268 Elf_Internal_Ehdr *ehdr = elf_tdata (abfd)->elf_header;
269 Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
274 for (i = 0; i < ehdr->e_phnum; i++)
275 if (phdr[i].p_type == PT_LOAD && phdr[i].p_align > align)
276 align = phdr[i].p_align;
278 minpagesize = get_elf_backend_data (abfd)->minpagesize;
281 /* Turn it into a mask. */
284 /* If the changes match the alignment requirements, we
285 assume we're using a core file that was generated by the
286 same binary, just prelinked with a different base offset.
287 If it doesn't match, we may have a different binary, the
288 same binary with the dynamic table loaded at an unrelated
289 location, or anything, really. To avoid regressions,
290 don't adjust the base offset in the latter case, although
291 odds are that, if things really changed, debugging won't
294 One could expect more the condition
295 ((l_addr & align) == 0 && ((l_dynaddr - dynaddr) & align) == 0)
296 but the one below is relaxed for PPC. The PPC kernel supports
297 either 4k or 64k page sizes. To be prepared for 64k pages,
298 PPC ELF files are built using an alignment requirement of 64k.
299 However, when running on a kernel supporting 4k pages, the memory
300 mapping of the library may not actually happen on a 64k boundary!
302 (In the usual case where (l_addr & align) == 0, this check is
303 equivalent to the possibly expected check above.)
305 Even on PPC it must be zero-aligned at least for MINPAGESIZE. */
307 l_addr = l_dynaddr - dynaddr;
309 if ((l_addr & (minpagesize - 1)) == 0
310 && (l_addr & align) == ((l_dynaddr - dynaddr) & align))
313 printf_unfiltered (_("Using PIC (Position Independent Code) "
314 "prelink displacement %s for \"%s\".\n"),
315 paddress (target_gdbarch (), l_addr),
320 /* There is no way to verify the library file matches. prelink
321 can during prelinking of an unprelinked file (or unprelinking
322 of a prelinked file) shift the DYNAMIC segment by arbitrary
323 offset without any page size alignment. There is no way to
324 find out the ELF header and/or Program Headers for a limited
325 verification if it they match. One could do a verification
326 of the DYNAMIC segment. Still the found address is the best
327 one GDB could find. */
329 warning (_(".dynamic section for \"%s\" "
330 "is not at the expected address "
331 "(wrong library or version mismatch?)"), so->so_name);
336 so->lm_info->l_addr = l_addr;
337 so->lm_info->l_addr_p = 1;
340 return so->lm_info->l_addr;
343 /* Per pspace SVR4 specific data. */
347 CORE_ADDR debug_base; /* Base of dynamic linker structures. */
349 /* Validity flag for debug_loader_offset. */
350 int debug_loader_offset_p;
352 /* Load address for the dynamic linker, inferred. */
353 CORE_ADDR debug_loader_offset;
355 /* Name of the dynamic linker, valid if debug_loader_offset_p. */
356 char *debug_loader_name;
358 /* Load map address for the main executable. */
359 CORE_ADDR main_lm_addr;
361 CORE_ADDR interp_text_sect_low;
362 CORE_ADDR interp_text_sect_high;
363 CORE_ADDR interp_plt_sect_low;
364 CORE_ADDR interp_plt_sect_high;
366 /* Nonzero if the list of objects was last obtained from the target
367 via qXfer:libraries-svr4:read. */
370 /* Table of struct probe_and_action instances, used by the
371 probes-based interface to map breakpoint addresses to probes
372 and their associated actions. Lookup is performed using
373 probe_and_action->probe->address. */
376 /* List of objects loaded into the inferior, used by the probes-
378 struct so_list *solib_list;
381 /* Per-program-space data key. */
382 static const struct program_space_data *solib_svr4_pspace_data;
384 /* Free the probes table. */
387 free_probes_table (struct svr4_info *info)
389 if (info->probes_table == NULL)
392 htab_delete (info->probes_table);
393 info->probes_table = NULL;
396 /* Free the solib list. */
399 free_solib_list (struct svr4_info *info)
401 svr4_free_library_list (&info->solib_list);
402 info->solib_list = NULL;
406 svr4_pspace_data_cleanup (struct program_space *pspace, void *arg)
408 struct svr4_info *info = arg;
410 free_probes_table (info);
411 free_solib_list (info);
416 /* Get the current svr4 data. If none is found yet, add it now. This
417 function always returns a valid object. */
419 static struct svr4_info *
422 struct svr4_info *info;
424 info = program_space_data (current_program_space, solib_svr4_pspace_data);
428 info = XCNEW (struct svr4_info);
429 set_program_space_data (current_program_space, solib_svr4_pspace_data, info);
433 /* Local function prototypes */
435 static int match_main (const char *);
437 /* Read program header TYPE from inferior memory. The header is found
438 by scanning the OS auxillary vector.
440 If TYPE == -1, return the program headers instead of the contents of
443 Return a pointer to allocated memory holding the program header contents,
444 or NULL on failure. If sucessful, and unless P_SECT_SIZE is NULL, the
445 size of those contents is returned to P_SECT_SIZE. Likewise, the target
446 architecture size (32-bit or 64-bit) is returned to P_ARCH_SIZE. */
449 read_program_header (int type, int *p_sect_size, int *p_arch_size)
451 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
452 CORE_ADDR at_phdr, at_phent, at_phnum, pt_phdr = 0;
453 int arch_size, sect_size;
458 /* Get required auxv elements from target. */
459 if (target_auxv_search (¤t_target, AT_PHDR, &at_phdr) <= 0)
461 if (target_auxv_search (¤t_target, AT_PHENT, &at_phent) <= 0)
463 if (target_auxv_search (¤t_target, AT_PHNUM, &at_phnum) <= 0)
465 if (!at_phdr || !at_phnum)
468 /* Determine ELF architecture type. */
469 if (at_phent == sizeof (Elf32_External_Phdr))
471 else if (at_phent == sizeof (Elf64_External_Phdr))
476 /* Find the requested segment. */
480 sect_size = at_phent * at_phnum;
482 else if (arch_size == 32)
484 Elf32_External_Phdr phdr;
487 /* Search for requested PHDR. */
488 for (i = 0; i < at_phnum; i++)
492 if (target_read_memory (at_phdr + i * sizeof (phdr),
493 (gdb_byte *)&phdr, sizeof (phdr)))
496 p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type,
499 if (p_type == PT_PHDR)
502 pt_phdr = extract_unsigned_integer ((gdb_byte *) phdr.p_vaddr,
513 /* Retrieve address and size. */
514 sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr,
516 sect_size = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz,
521 Elf64_External_Phdr phdr;
524 /* Search for requested PHDR. */
525 for (i = 0; i < at_phnum; i++)
529 if (target_read_memory (at_phdr + i * sizeof (phdr),
530 (gdb_byte *)&phdr, sizeof (phdr)))
533 p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type,
536 if (p_type == PT_PHDR)
539 pt_phdr = extract_unsigned_integer ((gdb_byte *) phdr.p_vaddr,
550 /* Retrieve address and size. */
551 sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr,
553 sect_size = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz,
557 /* PT_PHDR is optional, but we really need it
558 for PIE to make this work in general. */
562 /* at_phdr is real address in memory. pt_phdr is what pheader says it is.
563 Relocation offset is the difference between the two. */
564 sect_addr = sect_addr + (at_phdr - pt_phdr);
567 /* Read in requested program header. */
568 buf = xmalloc (sect_size);
569 if (target_read_memory (sect_addr, buf, sect_size))
576 *p_arch_size = arch_size;
578 *p_sect_size = sect_size;
584 /* Return program interpreter string. */
586 find_program_interpreter (void)
588 gdb_byte *buf = NULL;
590 /* If we have an exec_bfd, use its section table. */
592 && bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
594 struct bfd_section *interp_sect;
596 interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
597 if (interp_sect != NULL)
599 int sect_size = bfd_section_size (exec_bfd, interp_sect);
601 buf = xmalloc (sect_size);
602 bfd_get_section_contents (exec_bfd, interp_sect, buf, 0, sect_size);
606 /* If we didn't find it, use the target auxillary vector. */
608 buf = read_program_header (PT_INTERP, NULL, NULL);
614 /* Scan for DESIRED_DYNTAG in .dynamic section of ABFD. If DESIRED_DYNTAG is
615 found, 1 is returned and the corresponding PTR is set. */
618 scan_dyntag (const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr)
620 int arch_size, step, sect_size;
622 CORE_ADDR dyn_ptr, dyn_addr;
623 gdb_byte *bufend, *bufstart, *buf;
624 Elf32_External_Dyn *x_dynp_32;
625 Elf64_External_Dyn *x_dynp_64;
626 struct bfd_section *sect;
627 struct target_section *target_section;
632 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
635 arch_size = bfd_get_arch_size (abfd);
639 /* Find the start address of the .dynamic section. */
640 sect = bfd_get_section_by_name (abfd, ".dynamic");
644 for (target_section = current_target_sections->sections;
645 target_section < current_target_sections->sections_end;
647 if (sect == target_section->the_bfd_section)
649 if (target_section < current_target_sections->sections_end)
650 dyn_addr = target_section->addr;
653 /* ABFD may come from OBJFILE acting only as a symbol file without being
654 loaded into the target (see add_symbol_file_command). This case is
655 such fallback to the file VMA address without the possibility of
656 having the section relocated to its actual in-memory address. */
658 dyn_addr = bfd_section_vma (abfd, sect);
661 /* Read in .dynamic from the BFD. We will get the actual value
662 from memory later. */
663 sect_size = bfd_section_size (abfd, sect);
664 buf = bufstart = alloca (sect_size);
665 if (!bfd_get_section_contents (abfd, sect,
669 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
670 step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
671 : sizeof (Elf64_External_Dyn);
672 for (bufend = buf + sect_size;
678 x_dynp_32 = (Elf32_External_Dyn *) buf;
679 current_dyntag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);
680 dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);
684 x_dynp_64 = (Elf64_External_Dyn *) buf;
685 current_dyntag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
686 dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);
688 if (current_dyntag == DT_NULL)
690 if (current_dyntag == desired_dyntag)
692 /* If requested, try to read the runtime value of this .dynamic
696 struct type *ptr_type;
700 ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
701 ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
702 if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)
703 dyn_ptr = extract_typed_address (ptr_buf, ptr_type);
713 /* Scan for DESIRED_DYNTAG in .dynamic section of the target's main executable,
714 found by consulting the OS auxillary vector. If DESIRED_DYNTAG is found, 1
715 is returned and the corresponding PTR is set. */
718 scan_dyntag_auxv (const int desired_dyntag, CORE_ADDR *ptr)
720 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
721 int sect_size, arch_size, step;
724 gdb_byte *bufend, *bufstart, *buf;
726 /* Read in .dynamic section. */
727 buf = bufstart = read_program_header (PT_DYNAMIC, §_size, &arch_size);
731 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
732 step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
733 : sizeof (Elf64_External_Dyn);
734 for (bufend = buf + sect_size;
740 Elf32_External_Dyn *dynp = (Elf32_External_Dyn *) buf;
742 current_dyntag = extract_unsigned_integer ((gdb_byte *) dynp->d_tag,
744 dyn_ptr = extract_unsigned_integer ((gdb_byte *) dynp->d_un.d_ptr,
749 Elf64_External_Dyn *dynp = (Elf64_External_Dyn *) buf;
751 current_dyntag = extract_unsigned_integer ((gdb_byte *) dynp->d_tag,
753 dyn_ptr = extract_unsigned_integer ((gdb_byte *) dynp->d_un.d_ptr,
756 if (current_dyntag == DT_NULL)
759 if (current_dyntag == desired_dyntag)
773 /* Locate the base address of dynamic linker structs for SVR4 elf
776 For SVR4 elf targets the address of the dynamic linker's runtime
777 structure is contained within the dynamic info section in the
778 executable file. The dynamic section is also mapped into the
779 inferior address space. Because the runtime loader fills in the
780 real address before starting the inferior, we have to read in the
781 dynamic info section from the inferior address space.
782 If there are any errors while trying to find the address, we
783 silently return 0, otherwise the found address is returned. */
786 elf_locate_base (void)
788 struct bound_minimal_symbol msymbol;
791 /* Look for DT_MIPS_RLD_MAP first. MIPS executables use this
792 instead of DT_DEBUG, although they sometimes contain an unused
794 if (scan_dyntag (DT_MIPS_RLD_MAP, exec_bfd, &dyn_ptr)
795 || scan_dyntag_auxv (DT_MIPS_RLD_MAP, &dyn_ptr))
797 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
799 int pbuf_size = TYPE_LENGTH (ptr_type);
801 pbuf = alloca (pbuf_size);
802 /* DT_MIPS_RLD_MAP contains a pointer to the address
803 of the dynamic link structure. */
804 if (target_read_memory (dyn_ptr, pbuf, pbuf_size))
806 return extract_typed_address (pbuf, ptr_type);
810 if (scan_dyntag (DT_DEBUG, exec_bfd, &dyn_ptr)
811 || scan_dyntag_auxv (DT_DEBUG, &dyn_ptr))
814 /* This may be a static executable. Look for the symbol
815 conventionally named _r_debug, as a last resort. */
816 msymbol = lookup_minimal_symbol ("_r_debug", NULL, symfile_objfile);
817 if (msymbol.minsym != NULL)
818 return BMSYMBOL_VALUE_ADDRESS (msymbol);
820 /* DT_DEBUG entry not found. */
824 /* Locate the base address of dynamic linker structs.
826 For both the SunOS and SVR4 shared library implementations, if the
827 inferior executable has been linked dynamically, there is a single
828 address somewhere in the inferior's data space which is the key to
829 locating all of the dynamic linker's runtime structures. This
830 address is the value of the debug base symbol. The job of this
831 function is to find and return that address, or to return 0 if there
832 is no such address (the executable is statically linked for example).
834 For SunOS, the job is almost trivial, since the dynamic linker and
835 all of it's structures are statically linked to the executable at
836 link time. Thus the symbol for the address we are looking for has
837 already been added to the minimal symbol table for the executable's
838 objfile at the time the symbol file's symbols were read, and all we
839 have to do is look it up there. Note that we explicitly do NOT want
840 to find the copies in the shared library.
842 The SVR4 version is a bit more complicated because the address
843 is contained somewhere in the dynamic info section. We have to go
844 to a lot more work to discover the address of the debug base symbol.
845 Because of this complexity, we cache the value we find and return that
846 value on subsequent invocations. Note there is no copy in the
847 executable symbol tables. */
850 locate_base (struct svr4_info *info)
852 /* Check to see if we have a currently valid address, and if so, avoid
853 doing all this work again and just return the cached address. If
854 we have no cached address, try to locate it in the dynamic info
855 section for ELF executables. There's no point in doing any of this
856 though if we don't have some link map offsets to work with. */
858 if (info->debug_base == 0 && svr4_have_link_map_offsets ())
859 info->debug_base = elf_locate_base ();
860 return info->debug_base;
863 /* Find the first element in the inferior's dynamic link map, and
864 return its address in the inferior. Return zero if the address
865 could not be determined.
867 FIXME: Perhaps we should validate the info somehow, perhaps by
868 checking r_version for a known version number, or r_state for
872 solib_svr4_r_map (struct svr4_info *info)
874 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
875 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
880 addr = read_memory_typed_address (info->debug_base + lmo->r_map_offset,
883 CATCH (ex, RETURN_MASK_ERROR)
885 exception_print (gdb_stderr, ex);
892 /* Find r_brk from the inferior's debug base. */
895 solib_svr4_r_brk (struct svr4_info *info)
897 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
898 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
900 return read_memory_typed_address (info->debug_base + lmo->r_brk_offset,
904 /* Find the link map for the dynamic linker (if it is not in the
905 normal list of loaded shared objects). */
908 solib_svr4_r_ldsomap (struct svr4_info *info)
910 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
911 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
912 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
913 ULONGEST version = 0;
917 /* Check version, and return zero if `struct r_debug' doesn't have
918 the r_ldsomap member. */
920 = read_memory_unsigned_integer (info->debug_base + lmo->r_version_offset,
921 lmo->r_version_size, byte_order);
923 CATCH (ex, RETURN_MASK_ERROR)
925 exception_print (gdb_stderr, ex);
929 if (version < 2 || lmo->r_ldsomap_offset == -1)
932 return read_memory_typed_address (info->debug_base + lmo->r_ldsomap_offset,
936 /* On Solaris systems with some versions of the dynamic linker,
937 ld.so's l_name pointer points to the SONAME in the string table
938 rather than into writable memory. So that GDB can find shared
939 libraries when loading a core file generated by gcore, ensure that
940 memory areas containing the l_name string are saved in the core
944 svr4_keep_data_in_core (CORE_ADDR vaddr, unsigned long size)
946 struct svr4_info *info;
948 struct so_list *newobj;
949 struct cleanup *old_chain;
952 info = get_svr4_info ();
954 info->debug_base = 0;
956 if (!info->debug_base)
959 ldsomap = solib_svr4_r_ldsomap (info);
963 newobj = XCNEW (struct so_list);
964 old_chain = make_cleanup (xfree, newobj);
965 newobj->lm_info = lm_info_read (ldsomap);
966 make_cleanup (xfree, newobj->lm_info);
967 name_lm = newobj->lm_info ? newobj->lm_info->l_name : 0;
968 do_cleanups (old_chain);
970 return (name_lm >= vaddr && name_lm < vaddr + size);
973 /* Implement the "open_symbol_file_object" target_so_ops method.
975 If no open symbol file, attempt to locate and open the main symbol
976 file. On SVR4 systems, this is the first link map entry. If its
977 name is here, we can open it. Useful when attaching to a process
978 without first loading its symbol file. */
981 open_symbol_file_object (void *from_ttyp)
983 CORE_ADDR lm, l_name;
986 int from_tty = *(int *)from_ttyp;
987 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
988 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
989 int l_name_size = TYPE_LENGTH (ptr_type);
990 gdb_byte *l_name_buf = xmalloc (l_name_size);
991 struct cleanup *cleanups = make_cleanup (xfree, l_name_buf);
992 struct svr4_info *info = get_svr4_info ();
995 if (!query (_("Attempt to reload symbols from process? ")))
997 do_cleanups (cleanups);
1001 /* Always locate the debug struct, in case it has moved. */
1002 info->debug_base = 0;
1003 if (locate_base (info) == 0)
1005 do_cleanups (cleanups);
1006 return 0; /* failed somehow... */
1009 /* First link map member should be the executable. */
1010 lm = solib_svr4_r_map (info);
1013 do_cleanups (cleanups);
1014 return 0; /* failed somehow... */
1017 /* Read address of name from target memory to GDB. */
1018 read_memory (lm + lmo->l_name_offset, l_name_buf, l_name_size);
1020 /* Convert the address to host format. */
1021 l_name = extract_typed_address (l_name_buf, ptr_type);
1025 do_cleanups (cleanups);
1026 return 0; /* No filename. */
1029 /* Now fetch the filename from target memory. */
1030 target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
1031 make_cleanup (xfree, filename);
1035 warning (_("failed to read exec filename from attached file: %s"),
1036 safe_strerror (errcode));
1037 do_cleanups (cleanups);
1041 /* Have a pathname: read the symbol file. */
1042 symbol_file_add_main (filename, from_tty);
1044 do_cleanups (cleanups);
1048 /* Data exchange structure for the XML parser as returned by
1049 svr4_current_sos_via_xfer_libraries. */
1051 struct svr4_library_list
1053 struct so_list *head, **tailp;
1055 /* Inferior address of struct link_map used for the main executable. It is
1056 NULL if not known. */
1060 /* Implementation for target_so_ops.free_so. */
1063 svr4_free_so (struct so_list *so)
1065 xfree (so->lm_info);
1068 /* Implement target_so_ops.clear_so. */
1071 svr4_clear_so (struct so_list *so)
1073 if (so->lm_info != NULL)
1074 so->lm_info->l_addr_p = 0;
1077 /* Free so_list built so far (called via cleanup). */
1080 svr4_free_library_list (void *p_list)
1082 struct so_list *list = *(struct so_list **) p_list;
1084 while (list != NULL)
1086 struct so_list *next = list->next;
1093 /* Copy library list. */
1095 static struct so_list *
1096 svr4_copy_library_list (struct so_list *src)
1098 struct so_list *dst = NULL;
1099 struct so_list **link = &dst;
1103 struct so_list *newobj;
1105 newobj = xmalloc (sizeof (struct so_list));
1106 memcpy (newobj, src, sizeof (struct so_list));
1108 newobj->lm_info = xmalloc (sizeof (struct lm_info));
1109 memcpy (newobj->lm_info, src->lm_info, sizeof (struct lm_info));
1111 newobj->next = NULL;
1113 link = &newobj->next;
1121 #ifdef HAVE_LIBEXPAT
1123 #include "xml-support.h"
1125 /* Handle the start of a <library> element. Note: new elements are added
1126 at the tail of the list, keeping the list in order. */
1129 library_list_start_library (struct gdb_xml_parser *parser,
1130 const struct gdb_xml_element *element,
1131 void *user_data, VEC(gdb_xml_value_s) *attributes)
1133 struct svr4_library_list *list = user_data;
1134 const char *name = xml_find_attribute (attributes, "name")->value;
1135 ULONGEST *lmp = xml_find_attribute (attributes, "lm")->value;
1136 ULONGEST *l_addrp = xml_find_attribute (attributes, "l_addr")->value;
1137 ULONGEST *l_ldp = xml_find_attribute (attributes, "l_ld")->value;
1138 struct so_list *new_elem;
1140 new_elem = XCNEW (struct so_list);
1141 new_elem->lm_info = XCNEW (struct lm_info);
1142 new_elem->lm_info->lm_addr = *lmp;
1143 new_elem->lm_info->l_addr_inferior = *l_addrp;
1144 new_elem->lm_info->l_ld = *l_ldp;
1146 strncpy (new_elem->so_name, name, sizeof (new_elem->so_name) - 1);
1147 new_elem->so_name[sizeof (new_elem->so_name) - 1] = 0;
1148 strcpy (new_elem->so_original_name, new_elem->so_name);
1150 *list->tailp = new_elem;
1151 list->tailp = &new_elem->next;
1154 /* Handle the start of a <library-list-svr4> element. */
1157 svr4_library_list_start_list (struct gdb_xml_parser *parser,
1158 const struct gdb_xml_element *element,
1159 void *user_data, VEC(gdb_xml_value_s) *attributes)
1161 struct svr4_library_list *list = user_data;
1162 const char *version = xml_find_attribute (attributes, "version")->value;
1163 struct gdb_xml_value *main_lm = xml_find_attribute (attributes, "main-lm");
1165 if (strcmp (version, "1.0") != 0)
1166 gdb_xml_error (parser,
1167 _("SVR4 Library list has unsupported version \"%s\""),
1171 list->main_lm = *(ULONGEST *) main_lm->value;
1174 /* The allowed elements and attributes for an XML library list.
1175 The root element is a <library-list>. */
1177 static const struct gdb_xml_attribute svr4_library_attributes[] =
1179 { "name", GDB_XML_AF_NONE, NULL, NULL },
1180 { "lm", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
1181 { "l_addr", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
1182 { "l_ld", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
1183 { NULL, GDB_XML_AF_NONE, NULL, NULL }
1186 static const struct gdb_xml_element svr4_library_list_children[] =
1189 "library", svr4_library_attributes, NULL,
1190 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
1191 library_list_start_library, NULL
1193 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
1196 static const struct gdb_xml_attribute svr4_library_list_attributes[] =
1198 { "version", GDB_XML_AF_NONE, NULL, NULL },
1199 { "main-lm", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
1200 { NULL, GDB_XML_AF_NONE, NULL, NULL }
1203 static const struct gdb_xml_element svr4_library_list_elements[] =
1205 { "library-list-svr4", svr4_library_list_attributes, svr4_library_list_children,
1206 GDB_XML_EF_NONE, svr4_library_list_start_list, NULL },
1207 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
1210 /* Parse qXfer:libraries:read packet into *SO_LIST_RETURN. Return 1 if
1212 Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
1213 case. Return 1 if *SO_LIST_RETURN contains the library list, it may be
1214 empty, caller is responsible for freeing all its entries. */
1217 svr4_parse_libraries (const char *document, struct svr4_library_list *list)
1219 struct cleanup *back_to = make_cleanup (svr4_free_library_list,
1222 memset (list, 0, sizeof (*list));
1223 list->tailp = &list->head;
1224 if (gdb_xml_parse_quick (_("target library list"), "library-list-svr4.dtd",
1225 svr4_library_list_elements, document, list) == 0)
1227 /* Parsed successfully, keep the result. */
1228 discard_cleanups (back_to);
1232 do_cleanups (back_to);
1236 /* Attempt to get so_list from target via qXfer:libraries-svr4:read packet.
1238 Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
1239 case. Return 1 if *SO_LIST_RETURN contains the library list, it may be
1240 empty, caller is responsible for freeing all its entries.
1242 Note that ANNEX must be NULL if the remote does not explicitly allow
1243 qXfer:libraries-svr4:read packets with non-empty annexes. Support for
1244 this can be checked using target_augmented_libraries_svr4_read (). */
1247 svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list,
1250 char *svr4_library_document;
1252 struct cleanup *back_to;
1254 gdb_assert (annex == NULL || target_augmented_libraries_svr4_read ());
1256 /* Fetch the list of shared libraries. */
1257 svr4_library_document = target_read_stralloc (¤t_target,
1258 TARGET_OBJECT_LIBRARIES_SVR4,
1260 if (svr4_library_document == NULL)
1263 back_to = make_cleanup (xfree, svr4_library_document);
1264 result = svr4_parse_libraries (svr4_library_document, list);
1265 do_cleanups (back_to);
1273 svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list,
1281 /* If no shared library information is available from the dynamic
1282 linker, build a fallback list from other sources. */
1284 static struct so_list *
1285 svr4_default_sos (void)
1287 struct svr4_info *info = get_svr4_info ();
1288 struct so_list *newobj;
1290 if (!info->debug_loader_offset_p)
1293 newobj = XCNEW (struct so_list);
1295 newobj->lm_info = xzalloc (sizeof (struct lm_info));
1297 /* Nothing will ever check the other fields if we set l_addr_p. */
1298 newobj->lm_info->l_addr = info->debug_loader_offset;
1299 newobj->lm_info->l_addr_p = 1;
1301 strncpy (newobj->so_name, info->debug_loader_name, SO_NAME_MAX_PATH_SIZE - 1);
1302 newobj->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
1303 strcpy (newobj->so_original_name, newobj->so_name);
1308 /* Read the whole inferior libraries chain starting at address LM.
1309 Expect the first entry in the chain's previous entry to be PREV_LM.
1310 Add the entries to the tail referenced by LINK_PTR_PTR. Ignore the
1311 first entry if IGNORE_FIRST and set global MAIN_LM_ADDR according
1312 to it. Returns nonzero upon success. If zero is returned the
1313 entries stored to LINK_PTR_PTR are still valid although they may
1314 represent only part of the inferior library list. */
1317 svr4_read_so_list (CORE_ADDR lm, CORE_ADDR prev_lm,
1318 struct so_list ***link_ptr_ptr, int ignore_first)
1320 CORE_ADDR first_l_name = 0;
1323 for (; lm != 0; prev_lm = lm, lm = next_lm)
1325 struct so_list *newobj;
1326 struct cleanup *old_chain;
1330 newobj = XCNEW (struct so_list);
1331 old_chain = make_cleanup_free_so (newobj);
1333 newobj->lm_info = lm_info_read (lm);
1334 if (newobj->lm_info == NULL)
1336 do_cleanups (old_chain);
1340 next_lm = newobj->lm_info->l_next;
1342 if (newobj->lm_info->l_prev != prev_lm)
1344 warning (_("Corrupted shared library list: %s != %s"),
1345 paddress (target_gdbarch (), prev_lm),
1346 paddress (target_gdbarch (), newobj->lm_info->l_prev));
1347 do_cleanups (old_chain);
1351 /* For SVR4 versions, the first entry in the link map is for the
1352 inferior executable, so we must ignore it. For some versions of
1353 SVR4, it has no name. For others (Solaris 2.3 for example), it
1354 does have a name, so we can no longer use a missing name to
1355 decide when to ignore it. */
1356 if (ignore_first && newobj->lm_info->l_prev == 0)
1358 struct svr4_info *info = get_svr4_info ();
1360 first_l_name = newobj->lm_info->l_name;
1361 info->main_lm_addr = newobj->lm_info->lm_addr;
1362 do_cleanups (old_chain);
1366 /* Extract this shared object's name. */
1367 target_read_string (newobj->lm_info->l_name, &buffer,
1368 SO_NAME_MAX_PATH_SIZE - 1, &errcode);
1371 /* If this entry's l_name address matches that of the
1372 inferior executable, then this is not a normal shared
1373 object, but (most likely) a vDSO. In this case, silently
1374 skip it; otherwise emit a warning. */
1375 if (first_l_name == 0 || newobj->lm_info->l_name != first_l_name)
1376 warning (_("Can't read pathname for load map: %s."),
1377 safe_strerror (errcode));
1378 do_cleanups (old_chain);
1382 strncpy (newobj->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);
1383 newobj->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
1384 strcpy (newobj->so_original_name, newobj->so_name);
1387 /* If this entry has no name, or its name matches the name
1388 for the main executable, don't include it in the list. */
1389 if (! newobj->so_name[0] || match_main (newobj->so_name))
1391 do_cleanups (old_chain);
1395 discard_cleanups (old_chain);
1397 **link_ptr_ptr = newobj;
1398 *link_ptr_ptr = &newobj->next;
1404 /* Read the full list of currently loaded shared objects directly
1405 from the inferior, without referring to any libraries read and
1406 stored by the probes interface. Handle special cases relating
1407 to the first elements of the list. */
1409 static struct so_list *
1410 svr4_current_sos_direct (struct svr4_info *info)
1413 struct so_list *head = NULL;
1414 struct so_list **link_ptr = &head;
1415 struct cleanup *back_to;
1417 struct svr4_library_list library_list;
1419 /* Fall back to manual examination of the target if the packet is not
1420 supported or gdbserver failed to find DT_DEBUG. gdb.server/solib-list.exp
1421 tests a case where gdbserver cannot find the shared libraries list while
1422 GDB itself is able to find it via SYMFILE_OBJFILE.
1424 Unfortunately statically linked inferiors will also fall back through this
1425 suboptimal code path. */
1427 info->using_xfer = svr4_current_sos_via_xfer_libraries (&library_list,
1429 if (info->using_xfer)
1431 if (library_list.main_lm)
1432 info->main_lm_addr = library_list.main_lm;
1434 return library_list.head ? library_list.head : svr4_default_sos ();
1437 /* Always locate the debug struct, in case it has moved. */
1438 info->debug_base = 0;
1441 /* If we can't find the dynamic linker's base structure, this
1442 must not be a dynamically linked executable. Hmm. */
1443 if (! info->debug_base)
1444 return svr4_default_sos ();
1446 /* Assume that everything is a library if the dynamic loader was loaded
1447 late by a static executable. */
1448 if (exec_bfd && bfd_get_section_by_name (exec_bfd, ".dynamic") == NULL)
1453 back_to = make_cleanup (svr4_free_library_list, &head);
1455 /* Walk the inferior's link map list, and build our list of
1456 `struct so_list' nodes. */
1457 lm = solib_svr4_r_map (info);
1459 svr4_read_so_list (lm, 0, &link_ptr, ignore_first);
1461 /* On Solaris, the dynamic linker is not in the normal list of
1462 shared objects, so make sure we pick it up too. Having
1463 symbol information for the dynamic linker is quite crucial
1464 for skipping dynamic linker resolver code. */
1465 lm = solib_svr4_r_ldsomap (info);
1467 svr4_read_so_list (lm, 0, &link_ptr, 0);
1469 discard_cleanups (back_to);
1472 return svr4_default_sos ();
1477 /* Implement the main part of the "current_sos" target_so_ops
1480 static struct so_list *
1481 svr4_current_sos_1 (void)
1483 struct svr4_info *info = get_svr4_info ();
1485 /* If the solib list has been read and stored by the probes
1486 interface then we return a copy of the stored list. */
1487 if (info->solib_list != NULL)
1488 return svr4_copy_library_list (info->solib_list);
1490 /* Otherwise obtain the solib list directly from the inferior. */
1491 return svr4_current_sos_direct (info);
1494 /* Implement the "current_sos" target_so_ops method. */
1496 static struct so_list *
1497 svr4_current_sos (void)
1499 struct so_list *so_head = svr4_current_sos_1 ();
1500 struct mem_range vsyscall_range;
1502 /* Filter out the vDSO module, if present. Its symbol file would
1503 not be found on disk. The vDSO/vsyscall's OBJFILE is instead
1504 managed by symfile-mem.c:add_vsyscall_page. */
1505 if (gdbarch_vsyscall_range (target_gdbarch (), &vsyscall_range)
1506 && vsyscall_range.length != 0)
1508 struct so_list **sop;
1511 while (*sop != NULL)
1513 struct so_list *so = *sop;
1515 /* We can't simply match the vDSO by starting address alone,
1516 because lm_info->l_addr_inferior (and also l_addr) do not
1517 necessarily represent the real starting address of the
1518 ELF if the vDSO's ELF itself is "prelinked". The l_ld
1519 field (the ".dynamic" section of the shared object)
1520 always points at the absolute/resolved address though.
1521 So check whether that address is inside the vDSO's
1524 E.g., on Linux 3.16 (x86_64) the vDSO is a regular
1525 0-based ELF, and we see:
1528 33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffb000
1529 (gdb) p/x *_r_debug.r_map.l_next
1530 $1 = {l_addr = 0x7ffff7ffb000, ..., l_ld = 0x7ffff7ffb318, ...}
1532 And on Linux 2.6.32 (x86_64) we see:
1535 33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffe000
1536 (gdb) p/x *_r_debug.r_map.l_next
1537 $5 = {l_addr = 0x7ffff88fe000, ..., l_ld = 0x7ffff7ffe580, ... }
1539 Dumping that vDSO shows:
1541 (gdb) info proc mappings
1542 0x7ffff7ffe000 0x7ffff7fff000 0x1000 0 [vdso]
1543 (gdb) dump memory vdso.bin 0x7ffff7ffe000 0x7ffff7fff000
1544 # readelf -Wa vdso.bin
1546 Entry point address: 0xffffffffff700700
1549 [Nr] Name Type Address Off Size
1550 [ 0] NULL 0000000000000000 000000 000000
1551 [ 1] .hash HASH ffffffffff700120 000120 000038
1552 [ 2] .dynsym DYNSYM ffffffffff700158 000158 0000d8
1554 [ 9] .dynamic DYNAMIC ffffffffff700580 000580 0000f0
1556 if (address_in_mem_range (so->lm_info->l_ld, &vsyscall_range))
1570 /* Get the address of the link_map for a given OBJFILE. */
1573 svr4_fetch_objfile_link_map (struct objfile *objfile)
1576 struct svr4_info *info = get_svr4_info ();
1578 /* Cause svr4_current_sos() to be run if it hasn't been already. */
1579 if (info->main_lm_addr == 0)
1580 solib_add (NULL, 0, ¤t_target, auto_solib_add);
1582 /* svr4_current_sos() will set main_lm_addr for the main executable. */
1583 if (objfile == symfile_objfile)
1584 return info->main_lm_addr;
1586 /* The other link map addresses may be found by examining the list
1587 of shared libraries. */
1588 for (so = master_so_list (); so; so = so->next)
1589 if (so->objfile == objfile)
1590 return so->lm_info->lm_addr;
1596 /* On some systems, the only way to recognize the link map entry for
1597 the main executable file is by looking at its name. Return
1598 non-zero iff SONAME matches one of the known main executable names. */
1601 match_main (const char *soname)
1603 const char * const *mainp;
1605 for (mainp = main_name_list; *mainp != NULL; mainp++)
1607 if (strcmp (soname, *mainp) == 0)
1614 /* Return 1 if PC lies in the dynamic symbol resolution code of the
1615 SVR4 run time loader. */
1618 svr4_in_dynsym_resolve_code (CORE_ADDR pc)
1620 struct svr4_info *info = get_svr4_info ();
1622 return ((pc >= info->interp_text_sect_low
1623 && pc < info->interp_text_sect_high)
1624 || (pc >= info->interp_plt_sect_low
1625 && pc < info->interp_plt_sect_high)
1626 || in_plt_section (pc)
1627 || in_gnu_ifunc_stub (pc));
1630 /* Given an executable's ABFD and target, compute the entry-point
1634 exec_entry_point (struct bfd *abfd, struct target_ops *targ)
1638 /* KevinB wrote ... for most targets, the address returned by
1639 bfd_get_start_address() is the entry point for the start
1640 function. But, for some targets, bfd_get_start_address() returns
1641 the address of a function descriptor from which the entry point
1642 address may be extracted. This address is extracted by
1643 gdbarch_convert_from_func_ptr_addr(). The method
1644 gdbarch_convert_from_func_ptr_addr() is the merely the identify
1645 function for targets which don't use function descriptors. */
1646 addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
1647 bfd_get_start_address (abfd),
1649 return gdbarch_addr_bits_remove (target_gdbarch (), addr);
1652 /* A probe and its associated action. */
1654 struct probe_and_action
1657 struct probe *probe;
1659 /* The relocated address of the probe. */
1663 enum probe_action action;
1666 /* Returns a hash code for the probe_and_action referenced by p. */
1669 hash_probe_and_action (const void *p)
1671 const struct probe_and_action *pa = p;
1673 return (hashval_t) pa->address;
1676 /* Returns non-zero if the probe_and_actions referenced by p1 and p2
1680 equal_probe_and_action (const void *p1, const void *p2)
1682 const struct probe_and_action *pa1 = p1;
1683 const struct probe_and_action *pa2 = p2;
1685 return pa1->address == pa2->address;
1688 /* Register a solib event probe and its associated action in the
1692 register_solib_event_probe (struct probe *probe, CORE_ADDR address,
1693 enum probe_action action)
1695 struct svr4_info *info = get_svr4_info ();
1696 struct probe_and_action lookup, *pa;
1699 /* Create the probes table, if necessary. */
1700 if (info->probes_table == NULL)
1701 info->probes_table = htab_create_alloc (1, hash_probe_and_action,
1702 equal_probe_and_action,
1703 xfree, xcalloc, xfree);
1705 lookup.probe = probe;
1706 lookup.address = address;
1707 slot = htab_find_slot (info->probes_table, &lookup, INSERT);
1708 gdb_assert (*slot == HTAB_EMPTY_ENTRY);
1710 pa = XCNEW (struct probe_and_action);
1712 pa->address = address;
1713 pa->action = action;
1718 /* Get the solib event probe at the specified location, and the
1719 action associated with it. Returns NULL if no solib event probe
1722 static struct probe_and_action *
1723 solib_event_probe_at (struct svr4_info *info, CORE_ADDR address)
1725 struct probe_and_action lookup;
1728 lookup.address = address;
1729 slot = htab_find_slot (info->probes_table, &lookup, NO_INSERT);
1734 return (struct probe_and_action *) *slot;
1737 /* Decide what action to take when the specified solib event probe is
1740 static enum probe_action
1741 solib_event_probe_action (struct probe_and_action *pa)
1743 enum probe_action action;
1744 unsigned probe_argc;
1745 struct frame_info *frame = get_current_frame ();
1747 action = pa->action;
1748 if (action == DO_NOTHING || action == PROBES_INTERFACE_FAILED)
1751 gdb_assert (action == FULL_RELOAD || action == UPDATE_OR_RELOAD);
1753 /* Check that an appropriate number of arguments has been supplied.
1755 arg0: Lmid_t lmid (mandatory)
1756 arg1: struct r_debug *debug_base (mandatory)
1757 arg2: struct link_map *new (optional, for incremental updates) */
1758 probe_argc = get_probe_argument_count (pa->probe, frame);
1759 if (probe_argc == 2)
1760 action = FULL_RELOAD;
1761 else if (probe_argc < 2)
1762 action = PROBES_INTERFACE_FAILED;
1767 /* Populate the shared object list by reading the entire list of
1768 shared objects from the inferior. Handle special cases relating
1769 to the first elements of the list. Returns nonzero on success. */
1772 solist_update_full (struct svr4_info *info)
1774 free_solib_list (info);
1775 info->solib_list = svr4_current_sos_direct (info);
1780 /* Update the shared object list starting from the link-map entry
1781 passed by the linker in the probe's third argument. Returns
1782 nonzero if the list was successfully updated, or zero to indicate
1786 solist_update_incremental (struct svr4_info *info, CORE_ADDR lm)
1788 struct so_list *tail;
1791 /* svr4_current_sos_direct contains logic to handle a number of
1792 special cases relating to the first elements of the list. To
1793 avoid duplicating this logic we defer to solist_update_full
1794 if the list is empty. */
1795 if (info->solib_list == NULL)
1798 /* Fall back to a full update if we are using a remote target
1799 that does not support incremental transfers. */
1800 if (info->using_xfer && !target_augmented_libraries_svr4_read ())
1803 /* Walk to the end of the list. */
1804 for (tail = info->solib_list; tail->next != NULL; tail = tail->next)
1806 prev_lm = tail->lm_info->lm_addr;
1808 /* Read the new objects. */
1809 if (info->using_xfer)
1811 struct svr4_library_list library_list;
1814 xsnprintf (annex, sizeof (annex), "start=%s;prev=%s",
1815 phex_nz (lm, sizeof (lm)),
1816 phex_nz (prev_lm, sizeof (prev_lm)));
1817 if (!svr4_current_sos_via_xfer_libraries (&library_list, annex))
1820 tail->next = library_list.head;
1824 struct so_list **link = &tail->next;
1826 /* IGNORE_FIRST may safely be set to zero here because the
1827 above check and deferral to solist_update_full ensures
1828 that this call to svr4_read_so_list will never see the
1830 if (!svr4_read_so_list (lm, prev_lm, &link, 0))
1837 /* Disable the probes-based linker interface and revert to the
1838 original interface. We don't reset the breakpoints as the
1839 ones set up for the probes-based interface are adequate. */
1842 disable_probes_interface_cleanup (void *arg)
1844 struct svr4_info *info = get_svr4_info ();
1846 warning (_("Probes-based dynamic linker interface failed.\n"
1847 "Reverting to original interface.\n"));
1849 free_probes_table (info);
1850 free_solib_list (info);
1853 /* Update the solib list as appropriate when using the
1854 probes-based linker interface. Do nothing if using the
1855 standard interface. */
1858 svr4_handle_solib_event (void)
1860 struct svr4_info *info = get_svr4_info ();
1861 struct probe_and_action *pa;
1862 enum probe_action action;
1863 struct cleanup *old_chain, *usm_chain;
1865 CORE_ADDR pc, debug_base, lm = 0;
1867 struct frame_info *frame = get_current_frame ();
1869 /* Do nothing if not using the probes interface. */
1870 if (info->probes_table == NULL)
1873 /* If anything goes wrong we revert to the original linker
1875 old_chain = make_cleanup (disable_probes_interface_cleanup, NULL);
1877 pc = regcache_read_pc (get_current_regcache ());
1878 pa = solib_event_probe_at (info, pc);
1881 do_cleanups (old_chain);
1885 action = solib_event_probe_action (pa);
1886 if (action == PROBES_INTERFACE_FAILED)
1888 do_cleanups (old_chain);
1892 if (action == DO_NOTHING)
1894 discard_cleanups (old_chain);
1898 /* evaluate_probe_argument looks up symbols in the dynamic linker
1899 using find_pc_section. find_pc_section is accelerated by a cache
1900 called the section map. The section map is invalidated every
1901 time a shared library is loaded or unloaded, and if the inferior
1902 is generating a lot of shared library events then the section map
1903 will be updated every time svr4_handle_solib_event is called.
1904 We called find_pc_section in svr4_create_solib_event_breakpoints,
1905 so we can guarantee that the dynamic linker's sections are in the
1906 section map. We can therefore inhibit section map updates across
1907 these calls to evaluate_probe_argument and save a lot of time. */
1908 inhibit_section_map_updates (current_program_space);
1909 usm_chain = make_cleanup (resume_section_map_updates_cleanup,
1910 current_program_space);
1912 val = evaluate_probe_argument (pa->probe, 1, frame);
1915 do_cleanups (old_chain);
1919 debug_base = value_as_address (val);
1920 if (debug_base == 0)
1922 do_cleanups (old_chain);
1926 /* Always locate the debug struct, in case it moved. */
1927 info->debug_base = 0;
1928 if (locate_base (info) == 0)
1930 do_cleanups (old_chain);
1934 /* GDB does not currently support libraries loaded via dlmopen
1935 into namespaces other than the initial one. We must ignore
1936 any namespace other than the initial namespace here until
1937 support for this is added to GDB. */
1938 if (debug_base != info->debug_base)
1939 action = DO_NOTHING;
1941 if (action == UPDATE_OR_RELOAD)
1943 val = evaluate_probe_argument (pa->probe, 2, frame);
1945 lm = value_as_address (val);
1948 action = FULL_RELOAD;
1951 /* Resume section map updates. */
1952 do_cleanups (usm_chain);
1954 if (action == UPDATE_OR_RELOAD)
1956 if (!solist_update_incremental (info, lm))
1957 action = FULL_RELOAD;
1960 if (action == FULL_RELOAD)
1962 if (!solist_update_full (info))
1964 do_cleanups (old_chain);
1969 discard_cleanups (old_chain);
1972 /* Helper function for svr4_update_solib_event_breakpoints. */
1975 svr4_update_solib_event_breakpoint (struct breakpoint *b, void *arg)
1977 struct bp_location *loc;
1979 if (b->type != bp_shlib_event)
1981 /* Continue iterating. */
1985 for (loc = b->loc; loc != NULL; loc = loc->next)
1987 struct svr4_info *info;
1988 struct probe_and_action *pa;
1990 info = program_space_data (loc->pspace, solib_svr4_pspace_data);
1991 if (info == NULL || info->probes_table == NULL)
1994 pa = solib_event_probe_at (info, loc->address);
1998 if (pa->action == DO_NOTHING)
2000 if (b->enable_state == bp_disabled && stop_on_solib_events)
2001 enable_breakpoint (b);
2002 else if (b->enable_state == bp_enabled && !stop_on_solib_events)
2003 disable_breakpoint (b);
2009 /* Continue iterating. */
2013 /* Enable or disable optional solib event breakpoints as appropriate.
2014 Called whenever stop_on_solib_events is changed. */
2017 svr4_update_solib_event_breakpoints (void)
2019 iterate_over_breakpoints (svr4_update_solib_event_breakpoint, NULL);
2022 /* Create and register solib event breakpoints. PROBES is an array
2023 of NUM_PROBES elements, each of which is vector of probes. A
2024 solib event breakpoint will be created and registered for each
2028 svr4_create_probe_breakpoints (struct gdbarch *gdbarch,
2029 VEC (probe_p) **probes,
2030 struct objfile *objfile)
2034 for (i = 0; i < NUM_PROBES; i++)
2036 enum probe_action action = probe_info[i].action;
2037 struct probe *probe;
2041 VEC_iterate (probe_p, probes[i], ix, probe);
2044 CORE_ADDR address = get_probe_address (probe, objfile);
2046 create_solib_event_breakpoint (gdbarch, address);
2047 register_solib_event_probe (probe, address, action);
2051 svr4_update_solib_event_breakpoints ();
2054 /* Both the SunOS and the SVR4 dynamic linkers call a marker function
2055 before and after mapping and unmapping shared libraries. The sole
2056 purpose of this method is to allow debuggers to set a breakpoint so
2057 they can track these changes.
2059 Some versions of the glibc dynamic linker contain named probes
2060 to allow more fine grained stopping. Given the address of the
2061 original marker function, this function attempts to find these
2062 probes, and if found, sets breakpoints on those instead. If the
2063 probes aren't found, a single breakpoint is set on the original
2067 svr4_create_solib_event_breakpoints (struct gdbarch *gdbarch,
2070 struct obj_section *os;
2072 os = find_pc_section (address);
2077 for (with_prefix = 0; with_prefix <= 1; with_prefix++)
2079 VEC (probe_p) *probes[NUM_PROBES];
2080 int all_probes_found = 1;
2081 int checked_can_use_probe_arguments = 0;
2084 memset (probes, 0, sizeof (probes));
2085 for (i = 0; i < NUM_PROBES; i++)
2087 const char *name = probe_info[i].name;
2091 /* Fedora 17 and Red Hat Enterprise Linux 6.2-6.4
2092 shipped with an early version of the probes code in
2093 which the probes' names were prefixed with "rtld_"
2094 and the "map_failed" probe did not exist. The
2095 locations of the probes are otherwise the same, so
2096 we check for probes with prefixed names if probes
2097 with unprefixed names are not present. */
2100 xsnprintf (buf, sizeof (buf), "rtld_%s", name);
2104 probes[i] = find_probes_in_objfile (os->objfile, "rtld", name);
2106 /* The "map_failed" probe did not exist in early
2107 versions of the probes code in which the probes'
2108 names were prefixed with "rtld_". */
2109 if (strcmp (name, "rtld_map_failed") == 0)
2112 if (VEC_empty (probe_p, probes[i]))
2114 all_probes_found = 0;
2118 /* Ensure probe arguments can be evaluated. */
2119 if (!checked_can_use_probe_arguments)
2121 p = VEC_index (probe_p, probes[i], 0);
2122 if (!can_evaluate_probe_arguments (p))
2124 all_probes_found = 0;
2127 checked_can_use_probe_arguments = 1;
2131 if (all_probes_found)
2132 svr4_create_probe_breakpoints (gdbarch, probes, os->objfile);
2134 for (i = 0; i < NUM_PROBES; i++)
2135 VEC_free (probe_p, probes[i]);
2137 if (all_probes_found)
2142 create_solib_event_breakpoint (gdbarch, address);
2145 /* Helper function for gdb_bfd_lookup_symbol. */
2148 cmp_name_and_sec_flags (asymbol *sym, void *data)
2150 return (strcmp (sym->name, (const char *) data) == 0
2151 && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0);
2153 /* Arrange for dynamic linker to hit breakpoint.
2155 Both the SunOS and the SVR4 dynamic linkers have, as part of their
2156 debugger interface, support for arranging for the inferior to hit
2157 a breakpoint after mapping in the shared libraries. This function
2158 enables that breakpoint.
2160 For SunOS, there is a special flag location (in_debugger) which we
2161 set to 1. When the dynamic linker sees this flag set, it will set
2162 a breakpoint at a location known only to itself, after saving the
2163 original contents of that place and the breakpoint address itself,
2164 in it's own internal structures. When we resume the inferior, it
2165 will eventually take a SIGTRAP when it runs into the breakpoint.
2166 We handle this (in a different place) by restoring the contents of
2167 the breakpointed location (which is only known after it stops),
2168 chasing around to locate the shared libraries that have been
2169 loaded, then resuming.
2171 For SVR4, the debugger interface structure contains a member (r_brk)
2172 which is statically initialized at the time the shared library is
2173 built, to the offset of a function (_r_debug_state) which is guaran-
2174 teed to be called once before mapping in a library, and again when
2175 the mapping is complete. At the time we are examining this member,
2176 it contains only the unrelocated offset of the function, so we have
2177 to do our own relocation. Later, when the dynamic linker actually
2178 runs, it relocates r_brk to be the actual address of _r_debug_state().
2180 The debugger interface structure also contains an enumeration which
2181 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
2182 depending upon whether or not the library is being mapped or unmapped,
2183 and then set to RT_CONSISTENT after the library is mapped/unmapped. */
2186 enable_break (struct svr4_info *info, int from_tty)
2188 struct bound_minimal_symbol msymbol;
2189 const char * const *bkpt_namep;
2190 asection *interp_sect;
2194 info->interp_text_sect_low = info->interp_text_sect_high = 0;
2195 info->interp_plt_sect_low = info->interp_plt_sect_high = 0;
2197 /* If we already have a shared library list in the target, and
2198 r_debug contains r_brk, set the breakpoint there - this should
2199 mean r_brk has already been relocated. Assume the dynamic linker
2200 is the object containing r_brk. */
2202 solib_add (NULL, from_tty, ¤t_target, auto_solib_add);
2204 if (info->debug_base && solib_svr4_r_map (info) != 0)
2205 sym_addr = solib_svr4_r_brk (info);
2209 struct obj_section *os;
2211 sym_addr = gdbarch_addr_bits_remove
2212 (target_gdbarch (), gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2216 /* On at least some versions of Solaris there's a dynamic relocation
2217 on _r_debug.r_brk and SYM_ADDR may not be relocated yet, e.g., if
2218 we get control before the dynamic linker has self-relocated.
2219 Check if SYM_ADDR is in a known section, if it is assume we can
2220 trust its value. This is just a heuristic though, it could go away
2221 or be replaced if it's getting in the way.
2223 On ARM we need to know whether the ISA of rtld_db_dlactivity (or
2224 however it's spelled in your particular system) is ARM or Thumb.
2225 That knowledge is encoded in the address, if it's Thumb the low bit
2226 is 1. However, we've stripped that info above and it's not clear
2227 what all the consequences are of passing a non-addr_bits_remove'd
2228 address to svr4_create_solib_event_breakpoints. The call to
2229 find_pc_section verifies we know about the address and have some
2230 hope of computing the right kind of breakpoint to use (via
2231 symbol info). It does mean that GDB needs to be pointed at a
2232 non-stripped version of the dynamic linker in order to obtain
2233 information it already knows about. Sigh. */
2235 os = find_pc_section (sym_addr);
2238 /* Record the relocated start and end address of the dynamic linker
2239 text and plt section for svr4_in_dynsym_resolve_code. */
2241 CORE_ADDR load_addr;
2243 tmp_bfd = os->objfile->obfd;
2244 load_addr = ANOFFSET (os->objfile->section_offsets,
2245 SECT_OFF_TEXT (os->objfile));
2247 interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
2250 info->interp_text_sect_low =
2251 bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
2252 info->interp_text_sect_high =
2253 info->interp_text_sect_low
2254 + bfd_section_size (tmp_bfd, interp_sect);
2256 interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
2259 info->interp_plt_sect_low =
2260 bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
2261 info->interp_plt_sect_high =
2262 info->interp_plt_sect_low
2263 + bfd_section_size (tmp_bfd, interp_sect);
2266 svr4_create_solib_event_breakpoints (target_gdbarch (), sym_addr);
2271 /* Find the program interpreter; if not found, warn the user and drop
2272 into the old breakpoint at symbol code. */
2273 interp_name = find_program_interpreter ();
2276 CORE_ADDR load_addr = 0;
2277 int load_addr_found = 0;
2278 int loader_found_in_list = 0;
2280 bfd *tmp_bfd = NULL;
2281 struct target_ops *tmp_bfd_target;
2285 /* Now we need to figure out where the dynamic linker was
2286 loaded so that we can load its symbols and place a breakpoint
2287 in the dynamic linker itself.
2289 This address is stored on the stack. However, I've been unable
2290 to find any magic formula to find it for Solaris (appears to
2291 be trivial on GNU/Linux). Therefore, we have to try an alternate
2292 mechanism to find the dynamic linker's base address. */
2296 tmp_bfd = solib_bfd_open (interp_name);
2298 CATCH (ex, RETURN_MASK_ALL)
2303 if (tmp_bfd == NULL)
2304 goto bkpt_at_symbol;
2306 /* Now convert the TMP_BFD into a target. That way target, as
2307 well as BFD operations can be used. */
2308 tmp_bfd_target = target_bfd_reopen (tmp_bfd);
2309 /* target_bfd_reopen acquired its own reference, so we can
2310 release ours now. */
2311 gdb_bfd_unref (tmp_bfd);
2313 /* On a running target, we can get the dynamic linker's base
2314 address from the shared library table. */
2315 so = master_so_list ();
2318 if (svr4_same_1 (interp_name, so->so_original_name))
2320 load_addr_found = 1;
2321 loader_found_in_list = 1;
2322 load_addr = lm_addr_check (so, tmp_bfd);
2328 /* If we were not able to find the base address of the loader
2329 from our so_list, then try using the AT_BASE auxilliary entry. */
2330 if (!load_addr_found)
2331 if (target_auxv_search (¤t_target, AT_BASE, &load_addr) > 0)
2333 int addr_bit = gdbarch_addr_bit (target_gdbarch ());
2335 /* Ensure LOAD_ADDR has proper sign in its possible upper bits so
2336 that `+ load_addr' will overflow CORE_ADDR width not creating
2337 invalid addresses like 0x101234567 for 32bit inferiors on 64bit
2340 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
2342 CORE_ADDR space_size = (CORE_ADDR) 1 << addr_bit;
2343 CORE_ADDR tmp_entry_point = exec_entry_point (tmp_bfd,
2346 gdb_assert (load_addr < space_size);
2348 /* TMP_ENTRY_POINT exceeding SPACE_SIZE would be for prelinked
2349 64bit ld.so with 32bit executable, it should not happen. */
2351 if (tmp_entry_point < space_size
2352 && tmp_entry_point + load_addr >= space_size)
2353 load_addr -= space_size;
2356 load_addr_found = 1;
2359 /* Otherwise we find the dynamic linker's base address by examining
2360 the current pc (which should point at the entry point for the
2361 dynamic linker) and subtracting the offset of the entry point.
2363 This is more fragile than the previous approaches, but is a good
2364 fallback method because it has actually been working well in
2366 if (!load_addr_found)
2368 struct regcache *regcache
2369 = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
2371 load_addr = (regcache_read_pc (regcache)
2372 - exec_entry_point (tmp_bfd, tmp_bfd_target));
2375 if (!loader_found_in_list)
2377 info->debug_loader_name = xstrdup (interp_name);
2378 info->debug_loader_offset_p = 1;
2379 info->debug_loader_offset = load_addr;
2380 solib_add (NULL, from_tty, ¤t_target, auto_solib_add);
2383 /* Record the relocated start and end address of the dynamic linker
2384 text and plt section for svr4_in_dynsym_resolve_code. */
2385 interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
2388 info->interp_text_sect_low =
2389 bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
2390 info->interp_text_sect_high =
2391 info->interp_text_sect_low
2392 + bfd_section_size (tmp_bfd, interp_sect);
2394 interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
2397 info->interp_plt_sect_low =
2398 bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
2399 info->interp_plt_sect_high =
2400 info->interp_plt_sect_low
2401 + bfd_section_size (tmp_bfd, interp_sect);
2404 /* Now try to set a breakpoint in the dynamic linker. */
2405 for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
2407 sym_addr = gdb_bfd_lookup_symbol (tmp_bfd, cmp_name_and_sec_flags,
2408 (void *) *bkpt_namep);
2414 /* Convert 'sym_addr' from a function pointer to an address.
2415 Because we pass tmp_bfd_target instead of the current
2416 target, this will always produce an unrelocated value. */
2417 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2421 /* We're done with both the temporary bfd and target. Closing
2422 the target closes the underlying bfd, because it holds the
2423 only remaining reference. */
2424 target_close (tmp_bfd_target);
2428 svr4_create_solib_event_breakpoints (target_gdbarch (),
2429 load_addr + sym_addr);
2430 xfree (interp_name);
2434 /* For whatever reason we couldn't set a breakpoint in the dynamic
2435 linker. Warn and drop into the old code. */
2437 xfree (interp_name);
2438 warning (_("Unable to find dynamic linker breakpoint function.\n"
2439 "GDB will be unable to debug shared library initializers\n"
2440 "and track explicitly loaded dynamic code."));
2443 /* Scan through the lists of symbols, trying to look up the symbol and
2444 set a breakpoint there. Terminate loop when we/if we succeed. */
2446 for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
2448 msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
2449 if ((msymbol.minsym != NULL)
2450 && (BMSYMBOL_VALUE_ADDRESS (msymbol) != 0))
2452 sym_addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
2453 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2456 svr4_create_solib_event_breakpoints (target_gdbarch (), sym_addr);
2461 if (interp_name != NULL && !current_inferior ()->attach_flag)
2463 for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
2465 msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
2466 if ((msymbol.minsym != NULL)
2467 && (BMSYMBOL_VALUE_ADDRESS (msymbol) != 0))
2469 sym_addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
2470 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2473 svr4_create_solib_event_breakpoints (target_gdbarch (), sym_addr);
2481 /* Implement the "special_symbol_handling" target_so_ops method. */
2484 svr4_special_symbol_handling (void)
2486 /* Nothing to do. */
2489 /* Read the ELF program headers from ABFD. Return the contents and
2490 set *PHDRS_SIZE to the size of the program headers. */
2493 read_program_headers_from_bfd (bfd *abfd, int *phdrs_size)
2495 Elf_Internal_Ehdr *ehdr;
2498 ehdr = elf_elfheader (abfd);
2500 *phdrs_size = ehdr->e_phnum * ehdr->e_phentsize;
2501 if (*phdrs_size == 0)
2504 buf = xmalloc (*phdrs_size);
2505 if (bfd_seek (abfd, ehdr->e_phoff, SEEK_SET) != 0
2506 || bfd_bread (buf, *phdrs_size, abfd) != *phdrs_size)
2515 /* Return 1 and fill *DISPLACEMENTP with detected PIE offset of inferior
2516 exec_bfd. Otherwise return 0.
2518 We relocate all of the sections by the same amount. This
2519 behavior is mandated by recent editions of the System V ABI.
2520 According to the System V Application Binary Interface,
2521 Edition 4.1, page 5-5:
2523 ... Though the system chooses virtual addresses for
2524 individual processes, it maintains the segments' relative
2525 positions. Because position-independent code uses relative
2526 addressesing between segments, the difference between
2527 virtual addresses in memory must match the difference
2528 between virtual addresses in the file. The difference
2529 between the virtual address of any segment in memory and
2530 the corresponding virtual address in the file is thus a
2531 single constant value for any one executable or shared
2532 object in a given process. This difference is the base
2533 address. One use of the base address is to relocate the
2534 memory image of the program during dynamic linking.
2536 The same language also appears in Edition 4.0 of the System V
2537 ABI and is left unspecified in some of the earlier editions.
2539 Decide if the objfile needs to be relocated. As indicated above, we will
2540 only be here when execution is stopped. But during attachment PC can be at
2541 arbitrary address therefore regcache_read_pc can be misleading (contrary to
2542 the auxv AT_ENTRY value). Moreover for executable with interpreter section
2543 regcache_read_pc would point to the interpreter and not the main executable.
2545 So, to summarize, relocations are necessary when the start address obtained
2546 from the executable is different from the address in auxv AT_ENTRY entry.
2548 [ The astute reader will note that we also test to make sure that
2549 the executable in question has the DYNAMIC flag set. It is my
2550 opinion that this test is unnecessary (undesirable even). It
2551 was added to avoid inadvertent relocation of an executable
2552 whose e_type member in the ELF header is not ET_DYN. There may
2553 be a time in the future when it is desirable to do relocations
2554 on other types of files as well in which case this condition
2555 should either be removed or modified to accomodate the new file
2556 type. - Kevin, Nov 2000. ] */
2559 svr4_exec_displacement (CORE_ADDR *displacementp)
2561 /* ENTRY_POINT is a possible function descriptor - before
2562 a call to gdbarch_convert_from_func_ptr_addr. */
2563 CORE_ADDR entry_point, displacement;
2565 if (exec_bfd == NULL)
2568 /* Therefore for ELF it is ET_EXEC and not ET_DYN. Both shared libraries
2569 being executed themselves and PIE (Position Independent Executable)
2570 executables are ET_DYN. */
2572 if ((bfd_get_file_flags (exec_bfd) & DYNAMIC) == 0)
2575 if (target_auxv_search (¤t_target, AT_ENTRY, &entry_point) <= 0)
2578 displacement = entry_point - bfd_get_start_address (exec_bfd);
2580 /* Verify the DISPLACEMENT candidate complies with the required page
2581 alignment. It is cheaper than the program headers comparison below. */
2583 if (bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
2585 const struct elf_backend_data *elf = get_elf_backend_data (exec_bfd);
2587 /* p_align of PT_LOAD segments does not specify any alignment but
2588 only congruency of addresses:
2589 p_offset % p_align == p_vaddr % p_align
2590 Kernel is free to load the executable with lower alignment. */
2592 if ((displacement & (elf->minpagesize - 1)) != 0)
2596 /* Verify that the auxilliary vector describes the same file as exec_bfd, by
2597 comparing their program headers. If the program headers in the auxilliary
2598 vector do not match the program headers in the executable, then we are
2599 looking at a different file than the one used by the kernel - for
2600 instance, "gdb program" connected to "gdbserver :PORT ld.so program". */
2602 if (bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
2604 /* Be optimistic and clear OK only if GDB was able to verify the headers
2605 really do not match. */
2606 int phdrs_size, phdrs2_size, ok = 1;
2607 gdb_byte *buf, *buf2;
2610 buf = read_program_header (-1, &phdrs_size, &arch_size);
2611 buf2 = read_program_headers_from_bfd (exec_bfd, &phdrs2_size);
2612 if (buf != NULL && buf2 != NULL)
2614 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
2616 /* We are dealing with three different addresses. EXEC_BFD
2617 represents current address in on-disk file. target memory content
2618 may be different from EXEC_BFD as the file may have been prelinked
2619 to a different address after the executable has been loaded.
2620 Moreover the address of placement in target memory can be
2621 different from what the program headers in target memory say -
2622 this is the goal of PIE.
2624 Detected DISPLACEMENT covers both the offsets of PIE placement and
2625 possible new prelink performed after start of the program. Here
2626 relocate BUF and BUF2 just by the EXEC_BFD vs. target memory
2627 content offset for the verification purpose. */
2629 if (phdrs_size != phdrs2_size
2630 || bfd_get_arch_size (exec_bfd) != arch_size)
2632 else if (arch_size == 32
2633 && phdrs_size >= sizeof (Elf32_External_Phdr)
2634 && phdrs_size % sizeof (Elf32_External_Phdr) == 0)
2636 Elf_Internal_Ehdr *ehdr2 = elf_tdata (exec_bfd)->elf_header;
2637 Elf_Internal_Phdr *phdr2 = elf_tdata (exec_bfd)->phdr;
2638 CORE_ADDR displacement = 0;
2641 /* DISPLACEMENT could be found more easily by the difference of
2642 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2643 already have enough information to compute that displacement
2644 with what we've read. */
2646 for (i = 0; i < ehdr2->e_phnum; i++)
2647 if (phdr2[i].p_type == PT_LOAD)
2649 Elf32_External_Phdr *phdrp;
2650 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2651 CORE_ADDR vaddr, paddr;
2652 CORE_ADDR displacement_vaddr = 0;
2653 CORE_ADDR displacement_paddr = 0;
2655 phdrp = &((Elf32_External_Phdr *) buf)[i];
2656 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2657 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2659 vaddr = extract_unsigned_integer (buf_vaddr_p, 4,
2661 displacement_vaddr = vaddr - phdr2[i].p_vaddr;
2663 paddr = extract_unsigned_integer (buf_paddr_p, 4,
2665 displacement_paddr = paddr - phdr2[i].p_paddr;
2667 if (displacement_vaddr == displacement_paddr)
2668 displacement = displacement_vaddr;
2673 /* Now compare BUF and BUF2 with optional DISPLACEMENT. */
2675 for (i = 0; i < phdrs_size / sizeof (Elf32_External_Phdr); i++)
2677 Elf32_External_Phdr *phdrp;
2678 Elf32_External_Phdr *phdr2p;
2679 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2680 CORE_ADDR vaddr, paddr;
2681 asection *plt2_asect;
2683 phdrp = &((Elf32_External_Phdr *) buf)[i];
2684 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2685 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2686 phdr2p = &((Elf32_External_Phdr *) buf2)[i];
2688 /* PT_GNU_STACK is an exception by being never relocated by
2689 prelink as its addresses are always zero. */
2691 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2694 /* Check also other adjustment combinations - PR 11786. */
2696 vaddr = extract_unsigned_integer (buf_vaddr_p, 4,
2698 vaddr -= displacement;
2699 store_unsigned_integer (buf_vaddr_p, 4, byte_order, vaddr);
2701 paddr = extract_unsigned_integer (buf_paddr_p, 4,
2703 paddr -= displacement;
2704 store_unsigned_integer (buf_paddr_p, 4, byte_order, paddr);
2706 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2709 /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2710 CentOS-5 has problems with filesz, memsz as well.
2712 if (phdr2[i].p_type == PT_GNU_RELRO)
2714 Elf32_External_Phdr tmp_phdr = *phdrp;
2715 Elf32_External_Phdr tmp_phdr2 = *phdr2p;
2717 memset (tmp_phdr.p_filesz, 0, 4);
2718 memset (tmp_phdr.p_memsz, 0, 4);
2719 memset (tmp_phdr.p_flags, 0, 4);
2720 memset (tmp_phdr.p_align, 0, 4);
2721 memset (tmp_phdr2.p_filesz, 0, 4);
2722 memset (tmp_phdr2.p_memsz, 0, 4);
2723 memset (tmp_phdr2.p_flags, 0, 4);
2724 memset (tmp_phdr2.p_align, 0, 4);
2726 if (memcmp (&tmp_phdr, &tmp_phdr2, sizeof (tmp_phdr))
2731 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2732 plt2_asect = bfd_get_section_by_name (exec_bfd, ".plt");
2736 gdb_byte *buf_filesz_p = (gdb_byte *) &phdrp->p_filesz;
2739 content2 = (bfd_get_section_flags (exec_bfd, plt2_asect)
2740 & SEC_HAS_CONTENTS) != 0;
2742 filesz = extract_unsigned_integer (buf_filesz_p, 4,
2745 /* PLT2_ASECT is from on-disk file (exec_bfd) while
2746 FILESZ is from the in-memory image. */
2748 filesz += bfd_get_section_size (plt2_asect);
2750 filesz -= bfd_get_section_size (plt2_asect);
2752 store_unsigned_integer (buf_filesz_p, 4, byte_order,
2755 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2763 else if (arch_size == 64
2764 && phdrs_size >= sizeof (Elf64_External_Phdr)
2765 && phdrs_size % sizeof (Elf64_External_Phdr) == 0)
2767 Elf_Internal_Ehdr *ehdr2 = elf_tdata (exec_bfd)->elf_header;
2768 Elf_Internal_Phdr *phdr2 = elf_tdata (exec_bfd)->phdr;
2769 CORE_ADDR displacement = 0;
2772 /* DISPLACEMENT could be found more easily by the difference of
2773 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2774 already have enough information to compute that displacement
2775 with what we've read. */
2777 for (i = 0; i < ehdr2->e_phnum; i++)
2778 if (phdr2[i].p_type == PT_LOAD)
2780 Elf64_External_Phdr *phdrp;
2781 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2782 CORE_ADDR vaddr, paddr;
2783 CORE_ADDR displacement_vaddr = 0;
2784 CORE_ADDR displacement_paddr = 0;
2786 phdrp = &((Elf64_External_Phdr *) buf)[i];
2787 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2788 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2790 vaddr = extract_unsigned_integer (buf_vaddr_p, 8,
2792 displacement_vaddr = vaddr - phdr2[i].p_vaddr;
2794 paddr = extract_unsigned_integer (buf_paddr_p, 8,
2796 displacement_paddr = paddr - phdr2[i].p_paddr;
2798 if (displacement_vaddr == displacement_paddr)
2799 displacement = displacement_vaddr;
2804 /* Now compare BUF and BUF2 with optional DISPLACEMENT. */
2806 for (i = 0; i < phdrs_size / sizeof (Elf64_External_Phdr); i++)
2808 Elf64_External_Phdr *phdrp;
2809 Elf64_External_Phdr *phdr2p;
2810 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2811 CORE_ADDR vaddr, paddr;
2812 asection *plt2_asect;
2814 phdrp = &((Elf64_External_Phdr *) buf)[i];
2815 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2816 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2817 phdr2p = &((Elf64_External_Phdr *) buf2)[i];
2819 /* PT_GNU_STACK is an exception by being never relocated by
2820 prelink as its addresses are always zero. */
2822 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2825 /* Check also other adjustment combinations - PR 11786. */
2827 vaddr = extract_unsigned_integer (buf_vaddr_p, 8,
2829 vaddr -= displacement;
2830 store_unsigned_integer (buf_vaddr_p, 8, byte_order, vaddr);
2832 paddr = extract_unsigned_integer (buf_paddr_p, 8,
2834 paddr -= displacement;
2835 store_unsigned_integer (buf_paddr_p, 8, byte_order, paddr);
2837 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2840 /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2841 CentOS-5 has problems with filesz, memsz as well.
2843 if (phdr2[i].p_type == PT_GNU_RELRO)
2845 Elf64_External_Phdr tmp_phdr = *phdrp;
2846 Elf64_External_Phdr tmp_phdr2 = *phdr2p;
2848 memset (tmp_phdr.p_filesz, 0, 8);
2849 memset (tmp_phdr.p_memsz, 0, 8);
2850 memset (tmp_phdr.p_flags, 0, 4);
2851 memset (tmp_phdr.p_align, 0, 8);
2852 memset (tmp_phdr2.p_filesz, 0, 8);
2853 memset (tmp_phdr2.p_memsz, 0, 8);
2854 memset (tmp_phdr2.p_flags, 0, 4);
2855 memset (tmp_phdr2.p_align, 0, 8);
2857 if (memcmp (&tmp_phdr, &tmp_phdr2, sizeof (tmp_phdr))
2862 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2863 plt2_asect = bfd_get_section_by_name (exec_bfd, ".plt");
2867 gdb_byte *buf_filesz_p = (gdb_byte *) &phdrp->p_filesz;
2870 content2 = (bfd_get_section_flags (exec_bfd, plt2_asect)
2871 & SEC_HAS_CONTENTS) != 0;
2873 filesz = extract_unsigned_integer (buf_filesz_p, 8,
2876 /* PLT2_ASECT is from on-disk file (exec_bfd) while
2877 FILESZ is from the in-memory image. */
2879 filesz += bfd_get_section_size (plt2_asect);
2881 filesz -= bfd_get_section_size (plt2_asect);
2883 store_unsigned_integer (buf_filesz_p, 8, byte_order,
2886 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2907 /* It can be printed repeatedly as there is no easy way to check
2908 the executable symbols/file has been already relocated to
2911 printf_unfiltered (_("Using PIE (Position Independent Executable) "
2912 "displacement %s for \"%s\".\n"),
2913 paddress (target_gdbarch (), displacement),
2914 bfd_get_filename (exec_bfd));
2917 *displacementp = displacement;
2921 /* Relocate the main executable. This function should be called upon
2922 stopping the inferior process at the entry point to the program.
2923 The entry point from BFD is compared to the AT_ENTRY of AUXV and if they are
2924 different, the main executable is relocated by the proper amount. */
2927 svr4_relocate_main_executable (void)
2929 CORE_ADDR displacement;
2931 /* If we are re-running this executable, SYMFILE_OBJFILE->SECTION_OFFSETS
2932 probably contains the offsets computed using the PIE displacement
2933 from the previous run, which of course are irrelevant for this run.
2934 So we need to determine the new PIE displacement and recompute the
2935 section offsets accordingly, even if SYMFILE_OBJFILE->SECTION_OFFSETS
2936 already contains pre-computed offsets.
2938 If we cannot compute the PIE displacement, either:
2940 - The executable is not PIE.
2942 - SYMFILE_OBJFILE does not match the executable started in the target.
2943 This can happen for main executable symbols loaded at the host while
2944 `ld.so --ld-args main-executable' is loaded in the target.
2946 Then we leave the section offsets untouched and use them as is for
2949 - These section offsets were properly reset earlier, and thus
2950 already contain the correct values. This can happen for instance
2951 when reconnecting via the remote protocol to a target that supports
2952 the `qOffsets' packet.
2954 - The section offsets were not reset earlier, and the best we can
2955 hope is that the old offsets are still applicable to the new run. */
2957 if (! svr4_exec_displacement (&displacement))
2960 /* Even DISPLACEMENT 0 is a valid new difference of in-memory vs. in-file
2963 if (symfile_objfile)
2965 struct section_offsets *new_offsets;
2968 new_offsets = alloca (symfile_objfile->num_sections
2969 * sizeof (*new_offsets));
2971 for (i = 0; i < symfile_objfile->num_sections; i++)
2972 new_offsets->offsets[i] = displacement;
2974 objfile_relocate (symfile_objfile, new_offsets);
2980 for (asect = exec_bfd->sections; asect != NULL; asect = asect->next)
2981 exec_set_section_address (bfd_get_filename (exec_bfd), asect->index,
2982 (bfd_section_vma (exec_bfd, asect)
2987 /* Implement the "create_inferior_hook" target_solib_ops method.
2989 For SVR4 executables, this first instruction is either the first
2990 instruction in the dynamic linker (for dynamically linked
2991 executables) or the instruction at "start" for statically linked
2992 executables. For dynamically linked executables, the system
2993 first exec's /lib/libc.so.N, which contains the dynamic linker,
2994 and starts it running. The dynamic linker maps in any needed
2995 shared libraries, maps in the actual user executable, and then
2996 jumps to "start" in the user executable.
2998 We can arrange to cooperate with the dynamic linker to discover the
2999 names of shared libraries that are dynamically linked, and the base
3000 addresses to which they are linked.
3002 This function is responsible for discovering those names and
3003 addresses, and saving sufficient information about them to allow
3004 their symbols to be read at a later time. */
3007 svr4_solib_create_inferior_hook (int from_tty)
3009 struct svr4_info *info;
3011 info = get_svr4_info ();
3013 /* Clear the probes-based interface's state. */
3014 free_probes_table (info);
3015 free_solib_list (info);
3017 /* Relocate the main executable if necessary. */
3018 svr4_relocate_main_executable ();
3020 /* No point setting a breakpoint in the dynamic linker if we can't
3021 hit it (e.g., a core file, or a trace file). */
3022 if (!target_has_execution)
3025 if (!svr4_have_link_map_offsets ())
3028 if (!enable_break (info, from_tty))
3033 svr4_clear_solib (void)
3035 struct svr4_info *info;
3037 info = get_svr4_info ();
3038 info->debug_base = 0;
3039 info->debug_loader_offset_p = 0;
3040 info->debug_loader_offset = 0;
3041 xfree (info->debug_loader_name);
3042 info->debug_loader_name = NULL;
3045 /* Clear any bits of ADDR that wouldn't fit in a target-format
3046 data pointer. "Data pointer" here refers to whatever sort of
3047 address the dynamic linker uses to manage its sections. At the
3048 moment, we don't support shared libraries on any processors where
3049 code and data pointers are different sizes.
3051 This isn't really the right solution. What we really need here is
3052 a way to do arithmetic on CORE_ADDR values that respects the
3053 natural pointer/address correspondence. (For example, on the MIPS,
3054 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
3055 sign-extend the value. There, simply truncating the bits above
3056 gdbarch_ptr_bit, as we do below, is no good.) This should probably
3057 be a new gdbarch method or something. */
3059 svr4_truncate_ptr (CORE_ADDR addr)
3061 if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR) * 8)
3062 /* We don't need to truncate anything, and the bit twiddling below
3063 will fail due to overflow problems. */
3066 return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
3071 svr4_relocate_section_addresses (struct so_list *so,
3072 struct target_section *sec)
3074 bfd *abfd = sec->the_bfd_section->owner;
3076 sec->addr = svr4_truncate_ptr (sec->addr + lm_addr_check (so, abfd));
3077 sec->endaddr = svr4_truncate_ptr (sec->endaddr + lm_addr_check (so, abfd));
3081 /* Architecture-specific operations. */
3083 /* Per-architecture data key. */
3084 static struct gdbarch_data *solib_svr4_data;
3086 struct solib_svr4_ops
3088 /* Return a description of the layout of `struct link_map'. */
3089 struct link_map_offsets *(*fetch_link_map_offsets)(void);
3092 /* Return a default for the architecture-specific operations. */
3095 solib_svr4_init (struct obstack *obstack)
3097 struct solib_svr4_ops *ops;
3099 ops = OBSTACK_ZALLOC (obstack, struct solib_svr4_ops);
3100 ops->fetch_link_map_offsets = NULL;
3104 /* Set the architecture-specific `struct link_map_offsets' fetcher for
3105 GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */
3108 set_solib_svr4_fetch_link_map_offsets (struct gdbarch *gdbarch,
3109 struct link_map_offsets *(*flmo) (void))
3111 struct solib_svr4_ops *ops = gdbarch_data (gdbarch, solib_svr4_data);
3113 ops->fetch_link_map_offsets = flmo;
3115 set_solib_ops (gdbarch, &svr4_so_ops);
3118 /* Fetch a link_map_offsets structure using the architecture-specific
3119 `struct link_map_offsets' fetcher. */
3121 static struct link_map_offsets *
3122 svr4_fetch_link_map_offsets (void)
3124 struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch (), solib_svr4_data);
3126 gdb_assert (ops->fetch_link_map_offsets);
3127 return ops->fetch_link_map_offsets ();
3130 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
3133 svr4_have_link_map_offsets (void)
3135 struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch (), solib_svr4_data);
3137 return (ops->fetch_link_map_offsets != NULL);
3141 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
3142 `struct r_debug' and a `struct link_map' that are binary compatible
3143 with the origional SVR4 implementation. */
3145 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3146 for an ILP32 SVR4 system. */
3148 struct link_map_offsets *
3149 svr4_ilp32_fetch_link_map_offsets (void)
3151 static struct link_map_offsets lmo;
3152 static struct link_map_offsets *lmp = NULL;
3158 lmo.r_version_offset = 0;
3159 lmo.r_version_size = 4;
3160 lmo.r_map_offset = 4;
3161 lmo.r_brk_offset = 8;
3162 lmo.r_ldsomap_offset = 20;
3164 /* Everything we need is in the first 20 bytes. */
3165 lmo.link_map_size = 20;
3166 lmo.l_addr_offset = 0;
3167 lmo.l_name_offset = 4;
3168 lmo.l_ld_offset = 8;
3169 lmo.l_next_offset = 12;
3170 lmo.l_prev_offset = 16;
3176 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3177 for an LP64 SVR4 system. */
3179 struct link_map_offsets *
3180 svr4_lp64_fetch_link_map_offsets (void)
3182 static struct link_map_offsets lmo;
3183 static struct link_map_offsets *lmp = NULL;
3189 lmo.r_version_offset = 0;
3190 lmo.r_version_size = 4;
3191 lmo.r_map_offset = 8;
3192 lmo.r_brk_offset = 16;
3193 lmo.r_ldsomap_offset = 40;
3195 /* Everything we need is in the first 40 bytes. */
3196 lmo.link_map_size = 40;
3197 lmo.l_addr_offset = 0;
3198 lmo.l_name_offset = 8;
3199 lmo.l_ld_offset = 16;
3200 lmo.l_next_offset = 24;
3201 lmo.l_prev_offset = 32;
3208 struct target_so_ops svr4_so_ops;
3210 /* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a
3211 different rule for symbol lookup. The lookup begins here in the DSO, not in
3212 the main executable. */
3214 static struct symbol *
3215 elf_lookup_lib_symbol (struct objfile *objfile,
3217 const domain_enum domain)
3221 if (objfile == symfile_objfile)
3225 /* OBJFILE should have been passed as the non-debug one. */
3226 gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
3228 abfd = objfile->obfd;
3231 if (abfd == NULL || scan_dyntag (DT_SYMBOLIC, abfd, NULL) != 1)
3234 return lookup_global_symbol_from_objfile (objfile, name, domain);
3237 extern initialize_file_ftype _initialize_svr4_solib; /* -Wmissing-prototypes */
3240 _initialize_svr4_solib (void)
3242 solib_svr4_data = gdbarch_data_register_pre_init (solib_svr4_init);
3243 solib_svr4_pspace_data
3244 = register_program_space_data_with_cleanup (NULL, svr4_pspace_data_cleanup);
3246 svr4_so_ops.relocate_section_addresses = svr4_relocate_section_addresses;
3247 svr4_so_ops.free_so = svr4_free_so;
3248 svr4_so_ops.clear_so = svr4_clear_so;
3249 svr4_so_ops.clear_solib = svr4_clear_solib;
3250 svr4_so_ops.solib_create_inferior_hook = svr4_solib_create_inferior_hook;
3251 svr4_so_ops.special_symbol_handling = svr4_special_symbol_handling;
3252 svr4_so_ops.current_sos = svr4_current_sos;
3253 svr4_so_ops.open_symbol_file_object = open_symbol_file_object;
3254 svr4_so_ops.in_dynsym_resolve_code = svr4_in_dynsym_resolve_code;
3255 svr4_so_ops.bfd_open = solib_bfd_open;
3256 svr4_so_ops.lookup_lib_global_symbol = elf_lookup_lib_symbol;
3257 svr4_so_ops.same = svr4_same;
3258 svr4_so_ops.keep_data_in_core = svr4_keep_data_in_core;
3259 svr4_so_ops.update_breakpoints = svr4_update_solib_event_breakpoints;
3260 svr4_so_ops.handle_event = svr4_handle_solib_event;