1 /* Handle SVR4 shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 1990-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "elf/external.h"
23 #include "elf/common.h"
35 #include "gdbthread.h"
36 #include "observable.h"
40 #include "solib-svr4.h"
42 #include "bfd-target.h"
49 static struct link_map_offsets *svr4_fetch_link_map_offsets (void);
50 static int svr4_have_link_map_offsets (void);
51 static void svr4_relocate_main_executable (void);
52 static void svr4_free_library_list (void *p_list);
53 static void probes_table_remove_objfile_probes (struct objfile *objfile);
55 /* On SVR4 systems, a list of symbols in the dynamic linker where
56 GDB can try to place a breakpoint to monitor shared library
59 If none of these symbols are found, or other errors occur, then
60 SVR4 systems will fall back to using a symbol as the "startup
61 mapping complete" breakpoint address. */
63 static const char * const solib_break_names[] =
69 "__dl_rtld_db_dlactivity",
75 static const char * const bkpt_names[] =
83 static const char * const main_name_list[] =
89 /* What to do when a probe stop occurs. */
93 /* Something went seriously wrong. Stop using probes and
94 revert to using the older interface. */
95 PROBES_INTERFACE_FAILED,
97 /* No action is required. The shared object list is still
101 /* The shared object list should be reloaded entirely. */
104 /* Attempt to incrementally update the shared object list. If
105 the update fails or is not possible, fall back to reloading
110 /* A probe's name and its associated action. */
114 /* The name of the probe. */
117 /* What to do when a probe stop occurs. */
118 enum probe_action action;
121 /* A list of named probes and their associated actions. If all
122 probes are present in the dynamic linker then the probes-based
123 interface will be used. */
125 static const struct probe_info probe_info[] =
127 { "init_start", DO_NOTHING },
128 { "init_complete", FULL_RELOAD },
129 { "map_start", DO_NOTHING },
130 { "map_failed", DO_NOTHING },
131 { "reloc_complete", UPDATE_OR_RELOAD },
132 { "unmap_start", DO_NOTHING },
133 { "unmap_complete", FULL_RELOAD },
136 #define NUM_PROBES ARRAY_SIZE (probe_info)
138 /* Return non-zero if GDB_SO_NAME and INFERIOR_SO_NAME represent
139 the same shared library. */
142 svr4_same_1 (const char *gdb_so_name, const char *inferior_so_name)
144 if (strcmp (gdb_so_name, inferior_so_name) == 0)
147 /* On Solaris, when starting inferior we think that dynamic linker is
148 /usr/lib/ld.so.1, but later on, the table of loaded shared libraries
149 contains /lib/ld.so.1. Sometimes one file is a link to another, but
150 sometimes they have identical content, but are not linked to each
151 other. We don't restrict this check for Solaris, but the chances
152 of running into this situation elsewhere are very low. */
153 if (strcmp (gdb_so_name, "/usr/lib/ld.so.1") == 0
154 && strcmp (inferior_so_name, "/lib/ld.so.1") == 0)
157 /* Similarly, we observed the same issue with amd64 and sparcv9, but with
158 different locations. */
159 if (strcmp (gdb_so_name, "/usr/lib/amd64/ld.so.1") == 0
160 && strcmp (inferior_so_name, "/lib/amd64/ld.so.1") == 0)
163 if (strcmp (gdb_so_name, "/usr/lib/sparcv9/ld.so.1") == 0
164 && strcmp (inferior_so_name, "/lib/sparcv9/ld.so.1") == 0)
171 svr4_same (struct so_list *gdb, struct so_list *inferior)
173 return (svr4_same_1 (gdb->so_original_name, inferior->so_original_name));
176 static std::unique_ptr<lm_info_svr4>
177 lm_info_read (CORE_ADDR lm_addr)
179 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
180 std::unique_ptr<lm_info_svr4> lm_info;
182 gdb::byte_vector lm (lmo->link_map_size);
184 if (target_read_memory (lm_addr, lm.data (), lmo->link_map_size) != 0)
185 warning (_("Error reading shared library list entry at %s"),
186 paddress (target_gdbarch (), lm_addr));
189 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
191 lm_info.reset (new lm_info_svr4);
192 lm_info->lm_addr = lm_addr;
194 lm_info->l_addr_inferior = extract_typed_address (&lm[lmo->l_addr_offset],
196 lm_info->l_ld = extract_typed_address (&lm[lmo->l_ld_offset], ptr_type);
197 lm_info->l_next = extract_typed_address (&lm[lmo->l_next_offset],
199 lm_info->l_prev = extract_typed_address (&lm[lmo->l_prev_offset],
201 lm_info->l_name = extract_typed_address (&lm[lmo->l_name_offset],
209 has_lm_dynamic_from_link_map (void)
211 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
213 return lmo->l_ld_offset >= 0;
217 lm_addr_check (const struct so_list *so, bfd *abfd)
219 lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info;
223 struct bfd_section *dyninfo_sect;
224 CORE_ADDR l_addr, l_dynaddr, dynaddr;
226 l_addr = li->l_addr_inferior;
228 if (! abfd || ! has_lm_dynamic_from_link_map ())
231 l_dynaddr = li->l_ld;
233 dyninfo_sect = bfd_get_section_by_name (abfd, ".dynamic");
234 if (dyninfo_sect == NULL)
237 dynaddr = bfd_section_vma (abfd, dyninfo_sect);
239 if (dynaddr + l_addr != l_dynaddr)
241 CORE_ADDR align = 0x1000;
242 CORE_ADDR minpagesize = align;
244 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
246 Elf_Internal_Ehdr *ehdr = elf_tdata (abfd)->elf_header;
247 Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
252 for (i = 0; i < ehdr->e_phnum; i++)
253 if (phdr[i].p_type == PT_LOAD && phdr[i].p_align > align)
254 align = phdr[i].p_align;
256 minpagesize = get_elf_backend_data (abfd)->minpagesize;
259 /* Turn it into a mask. */
262 /* If the changes match the alignment requirements, we
263 assume we're using a core file that was generated by the
264 same binary, just prelinked with a different base offset.
265 If it doesn't match, we may have a different binary, the
266 same binary with the dynamic table loaded at an unrelated
267 location, or anything, really. To avoid regressions,
268 don't adjust the base offset in the latter case, although
269 odds are that, if things really changed, debugging won't
272 One could expect more the condition
273 ((l_addr & align) == 0 && ((l_dynaddr - dynaddr) & align) == 0)
274 but the one below is relaxed for PPC. The PPC kernel supports
275 either 4k or 64k page sizes. To be prepared for 64k pages,
276 PPC ELF files are built using an alignment requirement of 64k.
277 However, when running on a kernel supporting 4k pages, the memory
278 mapping of the library may not actually happen on a 64k boundary!
280 (In the usual case where (l_addr & align) == 0, this check is
281 equivalent to the possibly expected check above.)
283 Even on PPC it must be zero-aligned at least for MINPAGESIZE. */
285 l_addr = l_dynaddr - dynaddr;
287 if ((l_addr & (minpagesize - 1)) == 0
288 && (l_addr & align) == ((l_dynaddr - dynaddr) & align))
291 printf_unfiltered (_("Using PIC (Position Independent Code) "
292 "prelink displacement %s for \"%s\".\n"),
293 paddress (target_gdbarch (), l_addr),
298 /* There is no way to verify the library file matches. prelink
299 can during prelinking of an unprelinked file (or unprelinking
300 of a prelinked file) shift the DYNAMIC segment by arbitrary
301 offset without any page size alignment. There is no way to
302 find out the ELF header and/or Program Headers for a limited
303 verification if it they match. One could do a verification
304 of the DYNAMIC segment. Still the found address is the best
305 one GDB could find. */
307 warning (_(".dynamic section for \"%s\" "
308 "is not at the expected address "
309 "(wrong library or version mismatch?)"), so->so_name);
321 /* Per pspace SVR4 specific data. */
325 CORE_ADDR debug_base; /* Base of dynamic linker structures. */
327 /* Validity flag for debug_loader_offset. */
328 int debug_loader_offset_p;
330 /* Load address for the dynamic linker, inferred. */
331 CORE_ADDR debug_loader_offset;
333 /* Name of the dynamic linker, valid if debug_loader_offset_p. */
334 char *debug_loader_name;
336 /* Load map address for the main executable. */
337 CORE_ADDR main_lm_addr;
339 CORE_ADDR interp_text_sect_low;
340 CORE_ADDR interp_text_sect_high;
341 CORE_ADDR interp_plt_sect_low;
342 CORE_ADDR interp_plt_sect_high;
344 /* Nonzero if the list of objects was last obtained from the target
345 via qXfer:libraries-svr4:read. */
348 /* Table of struct probe_and_action instances, used by the
349 probes-based interface to map breakpoint addresses to probes
350 and their associated actions. Lookup is performed using
351 probe_and_action->prob->address. */
354 /* List of objects loaded into the inferior, used by the probes-
356 struct so_list *solib_list;
359 /* Per-program-space data key. */
360 static const struct program_space_data *solib_svr4_pspace_data;
362 /* Free the probes table. */
365 free_probes_table (struct svr4_info *info)
367 if (info->probes_table == NULL)
370 htab_delete (info->probes_table);
371 info->probes_table = NULL;
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;
384 svr4_pspace_data_cleanup (struct program_space *pspace, void *arg)
386 struct svr4_info *info = (struct svr4_info *) arg;
388 free_probes_table (info);
389 free_solib_list (info);
394 /* Get the svr4 data for program space PSPACE. If none is found yet, add it now.
395 This function always returns a valid object. */
397 static struct svr4_info *
398 get_svr4_info (program_space *pspace)
400 struct svr4_info *info;
402 info = (struct svr4_info *) program_space_data (pspace,
403 solib_svr4_pspace_data);
407 info = XCNEW (struct svr4_info);
408 set_program_space_data (pspace, solib_svr4_pspace_data, info);
412 /* Local function prototypes */
414 static int match_main (const char *);
416 /* Read program header TYPE from inferior memory. The header is found
417 by scanning the OS auxiliary vector.
419 If TYPE == -1, return the program headers instead of the contents of
422 Return vector of bytes holding the program header contents, or an empty
423 optional on failure. If successful and P_ARCH_SIZE is non-NULL, the target
424 architecture size (32-bit or 64-bit) is returned to *P_ARCH_SIZE. Likewise,
425 the base address of the section is returned in *BASE_ADDR. */
427 static gdb::optional<gdb::byte_vector>
428 read_program_header (int type, int *p_arch_size, CORE_ADDR *base_addr)
430 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
431 CORE_ADDR at_phdr, at_phent, at_phnum, pt_phdr = 0;
432 int arch_size, sect_size;
436 /* Get required auxv elements from target. */
437 if (target_auxv_search (current_top_target (), AT_PHDR, &at_phdr) <= 0)
439 if (target_auxv_search (current_top_target (), AT_PHENT, &at_phent) <= 0)
441 if (target_auxv_search (current_top_target (), AT_PHNUM, &at_phnum) <= 0)
443 if (!at_phdr || !at_phnum)
446 /* Determine ELF architecture type. */
447 if (at_phent == sizeof (Elf32_External_Phdr))
449 else if (at_phent == sizeof (Elf64_External_Phdr))
454 /* Find the requested segment. */
458 sect_size = at_phent * at_phnum;
460 else if (arch_size == 32)
462 Elf32_External_Phdr phdr;
465 /* Search for requested PHDR. */
466 for (i = 0; i < at_phnum; i++)
470 if (target_read_memory (at_phdr + i * sizeof (phdr),
471 (gdb_byte *)&phdr, sizeof (phdr)))
474 p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type,
477 if (p_type == PT_PHDR)
480 pt_phdr = extract_unsigned_integer ((gdb_byte *) phdr.p_vaddr,
491 /* Retrieve address and size. */
492 sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr,
494 sect_size = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz,
499 Elf64_External_Phdr phdr;
502 /* Search for requested PHDR. */
503 for (i = 0; i < at_phnum; i++)
507 if (target_read_memory (at_phdr + i * sizeof (phdr),
508 (gdb_byte *)&phdr, sizeof (phdr)))
511 p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type,
514 if (p_type == PT_PHDR)
517 pt_phdr = extract_unsigned_integer ((gdb_byte *) phdr.p_vaddr,
528 /* Retrieve address and size. */
529 sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr,
531 sect_size = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz,
535 /* PT_PHDR is optional, but we really need it
536 for PIE to make this work in general. */
540 /* at_phdr is real address in memory. pt_phdr is what pheader says it is.
541 Relocation offset is the difference between the two. */
542 sect_addr = sect_addr + (at_phdr - pt_phdr);
545 /* Read in requested program header. */
546 gdb::byte_vector buf (sect_size);
547 if (target_read_memory (sect_addr, buf.data (), sect_size))
551 *p_arch_size = arch_size;
553 *base_addr = sect_addr;
559 /* Return program interpreter string. */
560 static gdb::optional<gdb::byte_vector>
561 find_program_interpreter (void)
563 /* If we have an exec_bfd, use its section table. */
565 && bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
567 struct bfd_section *interp_sect;
569 interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
570 if (interp_sect != NULL)
572 int sect_size = bfd_section_size (exec_bfd, interp_sect);
574 gdb::byte_vector buf (sect_size);
575 bfd_get_section_contents (exec_bfd, interp_sect, buf.data (), 0,
581 /* If we didn't find it, use the target auxiliary vector. */
582 return read_program_header (PT_INTERP, NULL, NULL);
586 /* Scan for DESIRED_DYNTAG in .dynamic section of ABFD. If DESIRED_DYNTAG is
587 found, 1 is returned and the corresponding PTR is set. */
590 scan_dyntag (const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr,
593 int arch_size, step, sect_size;
595 CORE_ADDR dyn_ptr, dyn_addr;
596 gdb_byte *bufend, *bufstart, *buf;
597 Elf32_External_Dyn *x_dynp_32;
598 Elf64_External_Dyn *x_dynp_64;
599 struct bfd_section *sect;
600 struct target_section *target_section;
605 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
608 arch_size = bfd_get_arch_size (abfd);
612 /* Find the start address of the .dynamic section. */
613 sect = bfd_get_section_by_name (abfd, ".dynamic");
617 for (target_section = current_target_sections->sections;
618 target_section < current_target_sections->sections_end;
620 if (sect == target_section->the_bfd_section)
622 if (target_section < current_target_sections->sections_end)
623 dyn_addr = target_section->addr;
626 /* ABFD may come from OBJFILE acting only as a symbol file without being
627 loaded into the target (see add_symbol_file_command). This case is
628 such fallback to the file VMA address without the possibility of
629 having the section relocated to its actual in-memory address. */
631 dyn_addr = bfd_section_vma (abfd, sect);
634 /* Read in .dynamic from the BFD. We will get the actual value
635 from memory later. */
636 sect_size = bfd_section_size (abfd, sect);
637 buf = bufstart = (gdb_byte *) alloca (sect_size);
638 if (!bfd_get_section_contents (abfd, sect,
642 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
643 step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
644 : sizeof (Elf64_External_Dyn);
645 for (bufend = buf + sect_size;
651 x_dynp_32 = (Elf32_External_Dyn *) buf;
652 current_dyntag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);
653 dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);
657 x_dynp_64 = (Elf64_External_Dyn *) buf;
658 current_dyntag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
659 dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);
661 if (current_dyntag == DT_NULL)
663 if (current_dyntag == desired_dyntag)
665 /* If requested, try to read the runtime value of this .dynamic
669 struct type *ptr_type;
671 CORE_ADDR ptr_addr_1;
673 ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
674 ptr_addr_1 = dyn_addr + (buf - bufstart) + arch_size / 8;
675 if (target_read_memory (ptr_addr_1, ptr_buf, arch_size / 8) == 0)
676 dyn_ptr = extract_typed_address (ptr_buf, ptr_type);
679 *ptr_addr = dyn_addr + (buf - bufstart);
688 /* Scan for DESIRED_DYNTAG in .dynamic section of the target's main executable,
689 found by consulting the OS auxillary vector. If DESIRED_DYNTAG is found, 1
690 is returned and the corresponding PTR is set. */
693 scan_dyntag_auxv (const int desired_dyntag, CORE_ADDR *ptr,
696 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
702 /* Read in .dynamic section. */
703 gdb::optional<gdb::byte_vector> ph_data
704 = read_program_header (PT_DYNAMIC, &arch_size, &base_addr);
708 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
709 step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
710 : sizeof (Elf64_External_Dyn);
711 for (gdb_byte *buf = ph_data->data (), *bufend = buf + ph_data->size ();
712 buf < bufend; buf += step)
716 Elf32_External_Dyn *dynp = (Elf32_External_Dyn *) buf;
718 current_dyntag = extract_unsigned_integer ((gdb_byte *) dynp->d_tag,
720 dyn_ptr = extract_unsigned_integer ((gdb_byte *) dynp->d_un.d_ptr,
725 Elf64_External_Dyn *dynp = (Elf64_External_Dyn *) buf;
727 current_dyntag = extract_unsigned_integer ((gdb_byte *) dynp->d_tag,
729 dyn_ptr = extract_unsigned_integer ((gdb_byte *) dynp->d_un.d_ptr,
732 if (current_dyntag == DT_NULL)
735 if (current_dyntag == desired_dyntag)
741 *ptr_addr = base_addr + buf - ph_data->data ();
750 /* Locate the base address of dynamic linker structs for SVR4 elf
753 For SVR4 elf targets the address of the dynamic linker's runtime
754 structure is contained within the dynamic info section in the
755 executable file. The dynamic section is also mapped into the
756 inferior address space. Because the runtime loader fills in the
757 real address before starting the inferior, we have to read in the
758 dynamic info section from the inferior address space.
759 If there are any errors while trying to find the address, we
760 silently return 0, otherwise the found address is returned. */
763 elf_locate_base (void)
765 struct bound_minimal_symbol msymbol;
766 CORE_ADDR dyn_ptr, dyn_ptr_addr;
768 /* Look for DT_MIPS_RLD_MAP first. MIPS executables use this
769 instead of DT_DEBUG, although they sometimes contain an unused
771 if (scan_dyntag (DT_MIPS_RLD_MAP, exec_bfd, &dyn_ptr, NULL)
772 || scan_dyntag_auxv (DT_MIPS_RLD_MAP, &dyn_ptr, NULL))
774 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
776 int pbuf_size = TYPE_LENGTH (ptr_type);
778 pbuf = (gdb_byte *) alloca (pbuf_size);
779 /* DT_MIPS_RLD_MAP contains a pointer to the address
780 of the dynamic link structure. */
781 if (target_read_memory (dyn_ptr, pbuf, pbuf_size))
783 return extract_typed_address (pbuf, ptr_type);
786 /* Then check DT_MIPS_RLD_MAP_REL. MIPS executables now use this form
787 because of needing to support PIE. DT_MIPS_RLD_MAP will also exist
789 if (scan_dyntag (DT_MIPS_RLD_MAP_REL, exec_bfd, &dyn_ptr, &dyn_ptr_addr)
790 || scan_dyntag_auxv (DT_MIPS_RLD_MAP_REL, &dyn_ptr, &dyn_ptr_addr))
792 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
794 int pbuf_size = TYPE_LENGTH (ptr_type);
796 pbuf = (gdb_byte *) alloca (pbuf_size);
797 /* DT_MIPS_RLD_MAP_REL contains an offset from the address of the
798 DT slot to the address of the dynamic link structure. */
799 if (target_read_memory (dyn_ptr + dyn_ptr_addr, pbuf, pbuf_size))
801 return extract_typed_address (pbuf, ptr_type);
805 if (scan_dyntag (DT_DEBUG, exec_bfd, &dyn_ptr, NULL)
806 || scan_dyntag_auxv (DT_DEBUG, &dyn_ptr, NULL))
809 /* This may be a static executable. Look for the symbol
810 conventionally named _r_debug, as a last resort. */
811 msymbol = lookup_minimal_symbol ("_r_debug", NULL, symfile_objfile);
812 if (msymbol.minsym != NULL)
813 return BMSYMBOL_VALUE_ADDRESS (msymbol);
815 /* DT_DEBUG entry not found. */
819 /* Locate the base address of dynamic linker structs.
821 For both the SunOS and SVR4 shared library implementations, if the
822 inferior executable has been linked dynamically, there is a single
823 address somewhere in the inferior's data space which is the key to
824 locating all of the dynamic linker's runtime structures. This
825 address is the value of the debug base symbol. The job of this
826 function is to find and return that address, or to return 0 if there
827 is no such address (the executable is statically linked for example).
829 For SunOS, the job is almost trivial, since the dynamic linker and
830 all of it's structures are statically linked to the executable at
831 link time. Thus the symbol for the address we are looking for has
832 already been added to the minimal symbol table for the executable's
833 objfile at the time the symbol file's symbols were read, and all we
834 have to do is look it up there. Note that we explicitly do NOT want
835 to find the copies in the shared library.
837 The SVR4 version is a bit more complicated because the address
838 is contained somewhere in the dynamic info section. We have to go
839 to a lot more work to discover the address of the debug base symbol.
840 Because of this complexity, we cache the value we find and return that
841 value on subsequent invocations. Note there is no copy in the
842 executable symbol tables. */
845 locate_base (struct svr4_info *info)
847 /* Check to see if we have a currently valid address, and if so, avoid
848 doing all this work again and just return the cached address. If
849 we have no cached address, try to locate it in the dynamic info
850 section for ELF executables. There's no point in doing any of this
851 though if we don't have some link map offsets to work with. */
853 if (info->debug_base == 0 && svr4_have_link_map_offsets ())
854 info->debug_base = elf_locate_base ();
855 return info->debug_base;
858 /* Find the first element in the inferior's dynamic link map, and
859 return its address in the inferior. Return zero if the address
860 could not be determined.
862 FIXME: Perhaps we should validate the info somehow, perhaps by
863 checking r_version for a known version number, or r_state for
867 solib_svr4_r_map (struct svr4_info *info)
869 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
870 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
875 addr = read_memory_typed_address (info->debug_base + lmo->r_map_offset,
878 catch (const gdb_exception_error &ex)
880 exception_print (gdb_stderr, ex);
886 /* Find r_brk from the inferior's debug base. */
889 solib_svr4_r_brk (struct svr4_info *info)
891 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
892 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
894 return read_memory_typed_address (info->debug_base + lmo->r_brk_offset,
898 /* Find the link map for the dynamic linker (if it is not in the
899 normal list of loaded shared objects). */
902 solib_svr4_r_ldsomap (struct svr4_info *info)
904 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
905 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
906 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
907 ULONGEST version = 0;
911 /* Check version, and return zero if `struct r_debug' doesn't have
912 the r_ldsomap member. */
914 = read_memory_unsigned_integer (info->debug_base + lmo->r_version_offset,
915 lmo->r_version_size, byte_order);
917 catch (const gdb_exception_error &ex)
919 exception_print (gdb_stderr, ex);
922 if (version < 2 || lmo->r_ldsomap_offset == -1)
925 return read_memory_typed_address (info->debug_base + lmo->r_ldsomap_offset,
929 /* On Solaris systems with some versions of the dynamic linker,
930 ld.so's l_name pointer points to the SONAME in the string table
931 rather than into writable memory. So that GDB can find shared
932 libraries when loading a core file generated by gcore, ensure that
933 memory areas containing the l_name string are saved in the core
937 svr4_keep_data_in_core (CORE_ADDR vaddr, unsigned long size)
939 struct svr4_info *info;
943 info = get_svr4_info (current_program_space);
945 info->debug_base = 0;
947 if (!info->debug_base)
950 ldsomap = solib_svr4_r_ldsomap (info);
954 std::unique_ptr<lm_info_svr4> li = lm_info_read (ldsomap);
955 name_lm = li != NULL ? li->l_name : 0;
957 return (name_lm >= vaddr && name_lm < vaddr + size);
963 open_symbol_file_object (int from_tty)
965 CORE_ADDR lm, l_name;
966 gdb::unique_xmalloc_ptr<char> filename;
968 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
969 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
970 int l_name_size = TYPE_LENGTH (ptr_type);
971 gdb::byte_vector l_name_buf (l_name_size);
972 struct svr4_info *info = get_svr4_info (current_program_space);
973 symfile_add_flags add_flags = 0;
976 add_flags |= SYMFILE_VERBOSE;
979 if (!query (_("Attempt to reload symbols from process? ")))
982 /* Always locate the debug struct, in case it has moved. */
983 info->debug_base = 0;
984 if (locate_base (info) == 0)
985 return 0; /* failed somehow... */
987 /* First link map member should be the executable. */
988 lm = solib_svr4_r_map (info);
990 return 0; /* failed somehow... */
992 /* Read address of name from target memory to GDB. */
993 read_memory (lm + lmo->l_name_offset, l_name_buf.data (), l_name_size);
995 /* Convert the address to host format. */
996 l_name = extract_typed_address (l_name_buf.data (), ptr_type);
999 return 0; /* No filename. */
1001 /* Now fetch the filename from target memory. */
1002 target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
1006 warning (_("failed to read exec filename from attached file: %s"),
1007 safe_strerror (errcode));
1011 /* Have a pathname: read the symbol file. */
1012 symbol_file_add_main (filename.get (), add_flags);
1017 /* Data exchange structure for the XML parser as returned by
1018 svr4_current_sos_via_xfer_libraries. */
1020 struct svr4_library_list
1022 struct so_list *head, **tailp;
1024 /* Inferior address of struct link_map used for the main executable. It is
1025 NULL if not known. */
1029 /* This module's 'free_objfile' observer. */
1032 svr4_free_objfile_observer (struct objfile *objfile)
1034 probes_table_remove_objfile_probes (objfile);
1037 /* Implementation for target_so_ops.free_so. */
1040 svr4_free_so (struct so_list *so)
1042 lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info;
1047 /* Implement target_so_ops.clear_so. */
1050 svr4_clear_so (struct so_list *so)
1052 lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info;
1058 /* Free so_list built so far (called via cleanup). */
1061 svr4_free_library_list (void *p_list)
1063 struct so_list *list = *(struct so_list **) p_list;
1065 while (list != NULL)
1067 struct so_list *next = list->next;
1074 /* Copy library list. */
1076 static struct so_list *
1077 svr4_copy_library_list (struct so_list *src)
1079 struct so_list *dst = NULL;
1080 struct so_list **link = &dst;
1084 struct so_list *newobj;
1086 newobj = XNEW (struct so_list);
1087 memcpy (newobj, src, sizeof (struct so_list));
1089 lm_info_svr4 *src_li = (lm_info_svr4 *) src->lm_info;
1090 newobj->lm_info = new lm_info_svr4 (*src_li);
1092 newobj->next = NULL;
1094 link = &newobj->next;
1102 #ifdef HAVE_LIBEXPAT
1104 #include "xml-support.h"
1106 /* Handle the start of a <library> element. Note: new elements are added
1107 at the tail of the list, keeping the list in order. */
1110 library_list_start_library (struct gdb_xml_parser *parser,
1111 const struct gdb_xml_element *element,
1113 std::vector<gdb_xml_value> &attributes)
1115 struct svr4_library_list *list = (struct svr4_library_list *) user_data;
1117 = (const char *) xml_find_attribute (attributes, "name")->value.get ();
1119 = (ULONGEST *) xml_find_attribute (attributes, "lm")->value.get ();
1121 = (ULONGEST *) xml_find_attribute (attributes, "l_addr")->value.get ();
1123 = (ULONGEST *) xml_find_attribute (attributes, "l_ld")->value.get ();
1124 struct so_list *new_elem;
1126 new_elem = XCNEW (struct so_list);
1127 lm_info_svr4 *li = new lm_info_svr4;
1128 new_elem->lm_info = li;
1130 li->l_addr_inferior = *l_addrp;
1133 strncpy (new_elem->so_name, name, sizeof (new_elem->so_name) - 1);
1134 new_elem->so_name[sizeof (new_elem->so_name) - 1] = 0;
1135 strcpy (new_elem->so_original_name, new_elem->so_name);
1137 *list->tailp = new_elem;
1138 list->tailp = &new_elem->next;
1141 /* Handle the start of a <library-list-svr4> element. */
1144 svr4_library_list_start_list (struct gdb_xml_parser *parser,
1145 const struct gdb_xml_element *element,
1147 std::vector<gdb_xml_value> &attributes)
1149 struct svr4_library_list *list = (struct svr4_library_list *) user_data;
1151 = (const char *) xml_find_attribute (attributes, "version")->value.get ();
1152 struct gdb_xml_value *main_lm = xml_find_attribute (attributes, "main-lm");
1154 if (strcmp (version, "1.0") != 0)
1155 gdb_xml_error (parser,
1156 _("SVR4 Library list has unsupported version \"%s\""),
1160 list->main_lm = *(ULONGEST *) main_lm->value.get ();
1163 /* The allowed elements and attributes for an XML library list.
1164 The root element is a <library-list>. */
1166 static const struct gdb_xml_attribute svr4_library_attributes[] =
1168 { "name", GDB_XML_AF_NONE, NULL, NULL },
1169 { "lm", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
1170 { "l_addr", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
1171 { "l_ld", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
1172 { NULL, GDB_XML_AF_NONE, NULL, NULL }
1175 static const struct gdb_xml_element svr4_library_list_children[] =
1178 "library", svr4_library_attributes, NULL,
1179 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
1180 library_list_start_library, NULL
1182 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
1185 static const struct gdb_xml_attribute svr4_library_list_attributes[] =
1187 { "version", GDB_XML_AF_NONE, NULL, NULL },
1188 { "main-lm", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
1189 { NULL, GDB_XML_AF_NONE, NULL, NULL }
1192 static const struct gdb_xml_element svr4_library_list_elements[] =
1194 { "library-list-svr4", svr4_library_list_attributes, svr4_library_list_children,
1195 GDB_XML_EF_NONE, svr4_library_list_start_list, NULL },
1196 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
1199 /* Parse qXfer:libraries:read packet into *SO_LIST_RETURN. Return 1 if
1201 Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
1202 case. Return 1 if *SO_LIST_RETURN contains the library list, it may be
1203 empty, caller is responsible for freeing all its entries. */
1206 svr4_parse_libraries (const char *document, struct svr4_library_list *list)
1208 auto cleanup = make_scope_exit ([&] ()
1210 svr4_free_library_list (&list->head);
1213 memset (list, 0, sizeof (*list));
1214 list->tailp = &list->head;
1215 if (gdb_xml_parse_quick (_("target library list"), "library-list-svr4.dtd",
1216 svr4_library_list_elements, document, list) == 0)
1218 /* Parsed successfully, keep the result. */
1226 /* Attempt to get so_list from target via qXfer:libraries-svr4:read packet.
1228 Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
1229 case. Return 1 if *SO_LIST_RETURN contains the library list, it may be
1230 empty, caller is responsible for freeing all its entries.
1232 Note that ANNEX must be NULL if the remote does not explicitly allow
1233 qXfer:libraries-svr4:read packets with non-empty annexes. Support for
1234 this can be checked using target_augmented_libraries_svr4_read (). */
1237 svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list,
1240 gdb_assert (annex == NULL || target_augmented_libraries_svr4_read ());
1242 /* Fetch the list of shared libraries. */
1243 gdb::optional<gdb::char_vector> svr4_library_document
1244 = target_read_stralloc (current_top_target (), TARGET_OBJECT_LIBRARIES_SVR4,
1246 if (!svr4_library_document)
1249 return svr4_parse_libraries (svr4_library_document->data (), list);
1255 svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list,
1263 /* If no shared library information is available from the dynamic
1264 linker, build a fallback list from other sources. */
1266 static struct so_list *
1267 svr4_default_sos (svr4_info *info)
1269 struct so_list *newobj;
1271 if (!info->debug_loader_offset_p)
1274 newobj = XCNEW (struct so_list);
1275 lm_info_svr4 *li = new lm_info_svr4;
1276 newobj->lm_info = li;
1278 /* Nothing will ever check the other fields if we set l_addr_p. */
1279 li->l_addr = info->debug_loader_offset;
1282 strncpy (newobj->so_name, info->debug_loader_name, SO_NAME_MAX_PATH_SIZE - 1);
1283 newobj->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
1284 strcpy (newobj->so_original_name, newobj->so_name);
1289 /* Read the whole inferior libraries chain starting at address LM.
1290 Expect the first entry in the chain's previous entry to be PREV_LM.
1291 Add the entries to the tail referenced by LINK_PTR_PTR. Ignore the
1292 first entry if IGNORE_FIRST and set global MAIN_LM_ADDR according
1293 to it. Returns nonzero upon success. If zero is returned the
1294 entries stored to LINK_PTR_PTR are still valid although they may
1295 represent only part of the inferior library list. */
1298 svr4_read_so_list (svr4_info *info, CORE_ADDR lm, CORE_ADDR prev_lm,
1299 struct so_list ***link_ptr_ptr, int ignore_first)
1301 CORE_ADDR first_l_name = 0;
1304 for (; lm != 0; prev_lm = lm, lm = next_lm)
1307 gdb::unique_xmalloc_ptr<char> buffer;
1309 so_list_up newobj (XCNEW (struct so_list));
1311 lm_info_svr4 *li = lm_info_read (lm).release ();
1312 newobj->lm_info = li;
1316 next_lm = li->l_next;
1318 if (li->l_prev != prev_lm)
1320 warning (_("Corrupted shared library list: %s != %s"),
1321 paddress (target_gdbarch (), prev_lm),
1322 paddress (target_gdbarch (), li->l_prev));
1326 /* For SVR4 versions, the first entry in the link map is for the
1327 inferior executable, so we must ignore it. For some versions of
1328 SVR4, it has no name. For others (Solaris 2.3 for example), it
1329 does have a name, so we can no longer use a missing name to
1330 decide when to ignore it. */
1331 if (ignore_first && li->l_prev == 0)
1333 first_l_name = li->l_name;
1334 info->main_lm_addr = li->lm_addr;
1338 /* Extract this shared object's name. */
1339 target_read_string (li->l_name, &buffer, SO_NAME_MAX_PATH_SIZE - 1,
1343 /* If this entry's l_name address matches that of the
1344 inferior executable, then this is not a normal shared
1345 object, but (most likely) a vDSO. In this case, silently
1346 skip it; otherwise emit a warning. */
1347 if (first_l_name == 0 || li->l_name != first_l_name)
1348 warning (_("Can't read pathname for load map: %s."),
1349 safe_strerror (errcode));
1353 strncpy (newobj->so_name, buffer.get (), SO_NAME_MAX_PATH_SIZE - 1);
1354 newobj->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
1355 strcpy (newobj->so_original_name, newobj->so_name);
1357 /* If this entry has no name, or its name matches the name
1358 for the main executable, don't include it in the list. */
1359 if (! newobj->so_name[0] || match_main (newobj->so_name))
1363 /* Don't free it now. */
1364 **link_ptr_ptr = newobj.release ();
1365 *link_ptr_ptr = &(**link_ptr_ptr)->next;
1371 /* Read the full list of currently loaded shared objects directly
1372 from the inferior, without referring to any libraries read and
1373 stored by the probes interface. Handle special cases relating
1374 to the first elements of the list. */
1376 static struct so_list *
1377 svr4_current_sos_direct (struct svr4_info *info)
1380 struct so_list *head = NULL;
1381 struct so_list **link_ptr = &head;
1383 struct svr4_library_list library_list;
1385 /* Fall back to manual examination of the target if the packet is not
1386 supported or gdbserver failed to find DT_DEBUG. gdb.server/solib-list.exp
1387 tests a case where gdbserver cannot find the shared libraries list while
1388 GDB itself is able to find it via SYMFILE_OBJFILE.
1390 Unfortunately statically linked inferiors will also fall back through this
1391 suboptimal code path. */
1393 info->using_xfer = svr4_current_sos_via_xfer_libraries (&library_list,
1395 if (info->using_xfer)
1397 if (library_list.main_lm)
1398 info->main_lm_addr = library_list.main_lm;
1400 return library_list.head ? library_list.head : svr4_default_sos (info);
1403 /* Always locate the debug struct, in case it has moved. */
1404 info->debug_base = 0;
1407 /* If we can't find the dynamic linker's base structure, this
1408 must not be a dynamically linked executable. Hmm. */
1409 if (! info->debug_base)
1410 return svr4_default_sos (info);
1412 /* Assume that everything is a library if the dynamic loader was loaded
1413 late by a static executable. */
1414 if (exec_bfd && bfd_get_section_by_name (exec_bfd, ".dynamic") == NULL)
1419 auto cleanup = make_scope_exit ([&] ()
1421 svr4_free_library_list (&head);
1424 /* Walk the inferior's link map list, and build our list of
1425 `struct so_list' nodes. */
1426 lm = solib_svr4_r_map (info);
1428 svr4_read_so_list (info, lm, 0, &link_ptr, ignore_first);
1430 /* On Solaris, the dynamic linker is not in the normal list of
1431 shared objects, so make sure we pick it up too. Having
1432 symbol information for the dynamic linker is quite crucial
1433 for skipping dynamic linker resolver code. */
1434 lm = solib_svr4_r_ldsomap (info);
1436 svr4_read_so_list (info, lm, 0, &link_ptr, 0);
1441 return svr4_default_sos (info);
1446 /* Implement the main part of the "current_sos" target_so_ops
1449 static struct so_list *
1450 svr4_current_sos_1 (svr4_info *info)
1452 /* If the solib list has been read and stored by the probes
1453 interface then we return a copy of the stored list. */
1454 if (info->solib_list != NULL)
1455 return svr4_copy_library_list (info->solib_list);
1457 /* Otherwise obtain the solib list directly from the inferior. */
1458 return svr4_current_sos_direct (info);
1461 /* Implement the "current_sos" target_so_ops method. */
1463 static struct so_list *
1464 svr4_current_sos (void)
1466 svr4_info *info = get_svr4_info (current_program_space);
1467 struct so_list *so_head = svr4_current_sos_1 (info);
1468 struct mem_range vsyscall_range;
1470 /* Filter out the vDSO module, if present. Its symbol file would
1471 not be found on disk. The vDSO/vsyscall's OBJFILE is instead
1472 managed by symfile-mem.c:add_vsyscall_page. */
1473 if (gdbarch_vsyscall_range (target_gdbarch (), &vsyscall_range)
1474 && vsyscall_range.length != 0)
1476 struct so_list **sop;
1479 while (*sop != NULL)
1481 struct so_list *so = *sop;
1483 /* We can't simply match the vDSO by starting address alone,
1484 because lm_info->l_addr_inferior (and also l_addr) do not
1485 necessarily represent the real starting address of the
1486 ELF if the vDSO's ELF itself is "prelinked". The l_ld
1487 field (the ".dynamic" section of the shared object)
1488 always points at the absolute/resolved address though.
1489 So check whether that address is inside the vDSO's
1492 E.g., on Linux 3.16 (x86_64) the vDSO is a regular
1493 0-based ELF, and we see:
1496 33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffb000
1497 (gdb) p/x *_r_debug.r_map.l_next
1498 $1 = {l_addr = 0x7ffff7ffb000, ..., l_ld = 0x7ffff7ffb318, ...}
1500 And on Linux 2.6.32 (x86_64) we see:
1503 33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffe000
1504 (gdb) p/x *_r_debug.r_map.l_next
1505 $5 = {l_addr = 0x7ffff88fe000, ..., l_ld = 0x7ffff7ffe580, ... }
1507 Dumping that vDSO shows:
1509 (gdb) info proc mappings
1510 0x7ffff7ffe000 0x7ffff7fff000 0x1000 0 [vdso]
1511 (gdb) dump memory vdso.bin 0x7ffff7ffe000 0x7ffff7fff000
1512 # readelf -Wa vdso.bin
1514 Entry point address: 0xffffffffff700700
1517 [Nr] Name Type Address Off Size
1518 [ 0] NULL 0000000000000000 000000 000000
1519 [ 1] .hash HASH ffffffffff700120 000120 000038
1520 [ 2] .dynsym DYNSYM ffffffffff700158 000158 0000d8
1522 [ 9] .dynamic DYNAMIC ffffffffff700580 000580 0000f0
1525 lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info;
1527 if (address_in_mem_range (li->l_ld, &vsyscall_range))
1541 /* Get the address of the link_map for a given OBJFILE. */
1544 svr4_fetch_objfile_link_map (struct objfile *objfile)
1547 struct svr4_info *info = get_svr4_info (objfile->pspace);
1549 /* Cause svr4_current_sos() to be run if it hasn't been already. */
1550 if (info->main_lm_addr == 0)
1551 solib_add (NULL, 0, auto_solib_add);
1553 /* svr4_current_sos() will set main_lm_addr for the main executable. */
1554 if (objfile == symfile_objfile)
1555 return info->main_lm_addr;
1557 /* If OBJFILE is a separate debug object file, look for the
1558 original object file. */
1559 if (objfile->separate_debug_objfile_backlink != NULL)
1560 objfile = objfile->separate_debug_objfile_backlink;
1562 /* The other link map addresses may be found by examining the list
1563 of shared libraries. */
1564 for (so = master_so_list (); so; so = so->next)
1565 if (so->objfile == objfile)
1567 lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info;
1576 /* On some systems, the only way to recognize the link map entry for
1577 the main executable file is by looking at its name. Return
1578 non-zero iff SONAME matches one of the known main executable names. */
1581 match_main (const char *soname)
1583 const char * const *mainp;
1585 for (mainp = main_name_list; *mainp != NULL; mainp++)
1587 if (strcmp (soname, *mainp) == 0)
1594 /* Return 1 if PC lies in the dynamic symbol resolution code of the
1595 SVR4 run time loader. */
1598 svr4_in_dynsym_resolve_code (CORE_ADDR pc)
1600 struct svr4_info *info = get_svr4_info (current_program_space);
1602 return ((pc >= info->interp_text_sect_low
1603 && pc < info->interp_text_sect_high)
1604 || (pc >= info->interp_plt_sect_low
1605 && pc < info->interp_plt_sect_high)
1606 || in_plt_section (pc)
1607 || in_gnu_ifunc_stub (pc));
1610 /* Given an executable's ABFD and target, compute the entry-point
1614 exec_entry_point (struct bfd *abfd, struct target_ops *targ)
1618 /* KevinB wrote ... for most targets, the address returned by
1619 bfd_get_start_address() is the entry point for the start
1620 function. But, for some targets, bfd_get_start_address() returns
1621 the address of a function descriptor from which the entry point
1622 address may be extracted. This address is extracted by
1623 gdbarch_convert_from_func_ptr_addr(). The method
1624 gdbarch_convert_from_func_ptr_addr() is the merely the identify
1625 function for targets which don't use function descriptors. */
1626 addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
1627 bfd_get_start_address (abfd),
1629 return gdbarch_addr_bits_remove (target_gdbarch (), addr);
1632 /* A probe and its associated action. */
1634 struct probe_and_action
1639 /* The relocated address of the probe. */
1643 enum probe_action action;
1645 /* The objfile where this probe was found. */
1646 struct objfile *objfile;
1649 /* Returns a hash code for the probe_and_action referenced by p. */
1652 hash_probe_and_action (const void *p)
1654 const struct probe_and_action *pa = (const struct probe_and_action *) p;
1656 return (hashval_t) pa->address;
1659 /* Returns non-zero if the probe_and_actions referenced by p1 and p2
1663 equal_probe_and_action (const void *p1, const void *p2)
1665 const struct probe_and_action *pa1 = (const struct probe_and_action *) p1;
1666 const struct probe_and_action *pa2 = (const struct probe_and_action *) p2;
1668 return pa1->address == pa2->address;
1671 /* Traversal function for probes_table_remove_objfile_probes. */
1674 probes_table_htab_remove_objfile_probes (void **slot, void *info)
1676 probe_and_action *pa = (probe_and_action *) *slot;
1677 struct objfile *objfile = (struct objfile *) info;
1679 if (pa->objfile == objfile)
1680 htab_clear_slot (get_svr4_info (objfile->pspace)->probes_table, slot);
1685 /* Remove all probes that belong to OBJFILE from the probes table. */
1688 probes_table_remove_objfile_probes (struct objfile *objfile)
1690 svr4_info *info = get_svr4_info (objfile->pspace);
1691 if (info->probes_table != nullptr)
1692 htab_traverse_noresize (info->probes_table,
1693 probes_table_htab_remove_objfile_probes, objfile);
1696 /* Register a solib event probe and its associated action in the
1700 register_solib_event_probe (svr4_info *info, struct objfile *objfile,
1701 probe *prob, CORE_ADDR address,
1702 enum probe_action action)
1704 struct probe_and_action lookup, *pa;
1707 /* Create the probes table, if necessary. */
1708 if (info->probes_table == NULL)
1709 info->probes_table = htab_create_alloc (1, hash_probe_and_action,
1710 equal_probe_and_action,
1711 xfree, xcalloc, xfree);
1713 lookup.address = address;
1714 slot = htab_find_slot (info->probes_table, &lookup, INSERT);
1715 gdb_assert (*slot == HTAB_EMPTY_ENTRY);
1717 pa = XCNEW (struct probe_and_action);
1719 pa->address = address;
1720 pa->action = action;
1721 pa->objfile = objfile;
1726 /* Get the solib event probe at the specified location, and the
1727 action associated with it. Returns NULL if no solib event probe
1730 static struct probe_and_action *
1731 solib_event_probe_at (struct svr4_info *info, CORE_ADDR address)
1733 struct probe_and_action lookup;
1736 lookup.address = address;
1737 slot = htab_find_slot (info->probes_table, &lookup, NO_INSERT);
1742 return (struct probe_and_action *) *slot;
1745 /* Decide what action to take when the specified solib event probe is
1748 static enum probe_action
1749 solib_event_probe_action (struct probe_and_action *pa)
1751 enum probe_action action;
1752 unsigned probe_argc = 0;
1753 struct frame_info *frame = get_current_frame ();
1755 action = pa->action;
1756 if (action == DO_NOTHING || action == PROBES_INTERFACE_FAILED)
1759 gdb_assert (action == FULL_RELOAD || action == UPDATE_OR_RELOAD);
1761 /* Check that an appropriate number of arguments has been supplied.
1763 arg0: Lmid_t lmid (mandatory)
1764 arg1: struct r_debug *debug_base (mandatory)
1765 arg2: struct link_map *new (optional, for incremental updates) */
1768 probe_argc = pa->prob->get_argument_count (frame);
1770 catch (const gdb_exception_error &ex)
1772 exception_print (gdb_stderr, ex);
1776 /* If get_argument_count throws an exception, probe_argc will be set
1777 to zero. However, if pa->prob does not have arguments, then
1778 get_argument_count will succeed but probe_argc will also be zero.
1779 Both cases happen because of different things, but they are
1780 treated equally here: action will be set to
1781 PROBES_INTERFACE_FAILED. */
1782 if (probe_argc == 2)
1783 action = FULL_RELOAD;
1784 else if (probe_argc < 2)
1785 action = PROBES_INTERFACE_FAILED;
1790 /* Populate the shared object list by reading the entire list of
1791 shared objects from the inferior. Handle special cases relating
1792 to the first elements of the list. Returns nonzero on success. */
1795 solist_update_full (struct svr4_info *info)
1797 free_solib_list (info);
1798 info->solib_list = svr4_current_sos_direct (info);
1803 /* Update the shared object list starting from the link-map entry
1804 passed by the linker in the probe's third argument. Returns
1805 nonzero if the list was successfully updated, or zero to indicate
1809 solist_update_incremental (struct svr4_info *info, CORE_ADDR lm)
1811 struct so_list *tail;
1814 /* svr4_current_sos_direct contains logic to handle a number of
1815 special cases relating to the first elements of the list. To
1816 avoid duplicating this logic we defer to solist_update_full
1817 if the list is empty. */
1818 if (info->solib_list == NULL)
1821 /* Fall back to a full update if we are using a remote target
1822 that does not support incremental transfers. */
1823 if (info->using_xfer && !target_augmented_libraries_svr4_read ())
1826 /* Walk to the end of the list. */
1827 for (tail = info->solib_list; tail->next != NULL; tail = tail->next)
1830 lm_info_svr4 *li = (lm_info_svr4 *) tail->lm_info;
1831 prev_lm = li->lm_addr;
1833 /* Read the new objects. */
1834 if (info->using_xfer)
1836 struct svr4_library_list library_list;
1839 xsnprintf (annex, sizeof (annex), "start=%s;prev=%s",
1840 phex_nz (lm, sizeof (lm)),
1841 phex_nz (prev_lm, sizeof (prev_lm)));
1842 if (!svr4_current_sos_via_xfer_libraries (&library_list, annex))
1845 tail->next = library_list.head;
1849 struct so_list **link = &tail->next;
1851 /* IGNORE_FIRST may safely be set to zero here because the
1852 above check and deferral to solist_update_full ensures
1853 that this call to svr4_read_so_list will never see the
1855 if (!svr4_read_so_list (info, lm, prev_lm, &link, 0))
1862 /* Disable the probes-based linker interface and revert to the
1863 original interface. We don't reset the breakpoints as the
1864 ones set up for the probes-based interface are adequate. */
1867 disable_probes_interface (svr4_info *info)
1869 warning (_("Probes-based dynamic linker interface failed.\n"
1870 "Reverting to original interface.\n"));
1872 free_probes_table (info);
1873 free_solib_list (info);
1876 /* Update the solib list as appropriate when using the
1877 probes-based linker interface. Do nothing if using the
1878 standard interface. */
1881 svr4_handle_solib_event (void)
1883 struct svr4_info *info = get_svr4_info (current_program_space);
1884 struct probe_and_action *pa;
1885 enum probe_action action;
1886 struct value *val = NULL;
1887 CORE_ADDR pc, debug_base, lm = 0;
1888 struct frame_info *frame = get_current_frame ();
1890 /* Do nothing if not using the probes interface. */
1891 if (info->probes_table == NULL)
1894 /* If anything goes wrong we revert to the original linker
1896 auto cleanup = make_scope_exit ([info] ()
1898 disable_probes_interface (info);
1901 pc = regcache_read_pc (get_current_regcache ());
1902 pa = solib_event_probe_at (info, pc);
1906 action = solib_event_probe_action (pa);
1907 if (action == PROBES_INTERFACE_FAILED)
1910 if (action == DO_NOTHING)
1916 /* evaluate_argument looks up symbols in the dynamic linker
1917 using find_pc_section. find_pc_section is accelerated by a cache
1918 called the section map. The section map is invalidated every
1919 time a shared library is loaded or unloaded, and if the inferior
1920 is generating a lot of shared library events then the section map
1921 will be updated every time svr4_handle_solib_event is called.
1922 We called find_pc_section in svr4_create_solib_event_breakpoints,
1923 so we can guarantee that the dynamic linker's sections are in the
1924 section map. We can therefore inhibit section map updates across
1925 these calls to evaluate_argument and save a lot of time. */
1927 scoped_restore inhibit_updates
1928 = inhibit_section_map_updates (current_program_space);
1932 val = pa->prob->evaluate_argument (1, frame);
1934 catch (const gdb_exception_error &ex)
1936 exception_print (gdb_stderr, ex);
1943 debug_base = value_as_address (val);
1944 if (debug_base == 0)
1947 /* Always locate the debug struct, in case it moved. */
1948 info->debug_base = 0;
1949 if (locate_base (info) == 0)
1952 /* GDB does not currently support libraries loaded via dlmopen
1953 into namespaces other than the initial one. We must ignore
1954 any namespace other than the initial namespace here until
1955 support for this is added to GDB. */
1956 if (debug_base != info->debug_base)
1957 action = DO_NOTHING;
1959 if (action == UPDATE_OR_RELOAD)
1963 val = pa->prob->evaluate_argument (2, frame);
1965 catch (const gdb_exception_error &ex)
1967 exception_print (gdb_stderr, ex);
1972 lm = value_as_address (val);
1975 action = FULL_RELOAD;
1978 /* Resume section map updates. Closing the scope is
1982 if (action == UPDATE_OR_RELOAD)
1984 if (!solist_update_incremental (info, lm))
1985 action = FULL_RELOAD;
1988 if (action == FULL_RELOAD)
1990 if (!solist_update_full (info))
1997 /* Helper function for svr4_update_solib_event_breakpoints. */
2000 svr4_update_solib_event_breakpoint (struct breakpoint *b, void *arg)
2002 struct bp_location *loc;
2004 if (b->type != bp_shlib_event)
2006 /* Continue iterating. */
2010 for (loc = b->loc; loc != NULL; loc = loc->next)
2012 struct svr4_info *info;
2013 struct probe_and_action *pa;
2015 info = ((struct svr4_info *)
2016 program_space_data (loc->pspace, solib_svr4_pspace_data));
2017 if (info == NULL || info->probes_table == NULL)
2020 pa = solib_event_probe_at (info, loc->address);
2024 if (pa->action == DO_NOTHING)
2026 if (b->enable_state == bp_disabled && stop_on_solib_events)
2027 enable_breakpoint (b);
2028 else if (b->enable_state == bp_enabled && !stop_on_solib_events)
2029 disable_breakpoint (b);
2035 /* Continue iterating. */
2039 /* Enable or disable optional solib event breakpoints as appropriate.
2040 Called whenever stop_on_solib_events is changed. */
2043 svr4_update_solib_event_breakpoints (void)
2045 iterate_over_breakpoints (svr4_update_solib_event_breakpoint, NULL);
2048 /* Create and register solib event breakpoints. PROBES is an array
2049 of NUM_PROBES elements, each of which is vector of probes. A
2050 solib event breakpoint will be created and registered for each
2054 svr4_create_probe_breakpoints (svr4_info *info, struct gdbarch *gdbarch,
2055 const std::vector<probe *> *probes,
2056 struct objfile *objfile)
2058 for (int i = 0; i < NUM_PROBES; i++)
2060 enum probe_action action = probe_info[i].action;
2062 for (probe *p : probes[i])
2064 CORE_ADDR address = p->get_relocated_address (objfile);
2066 create_solib_event_breakpoint (gdbarch, address);
2067 register_solib_event_probe (info, objfile, p, address, action);
2071 svr4_update_solib_event_breakpoints ();
2074 /* Both the SunOS and the SVR4 dynamic linkers call a marker function
2075 before and after mapping and unmapping shared libraries. The sole
2076 purpose of this method is to allow debuggers to set a breakpoint so
2077 they can track these changes.
2079 Some versions of the glibc dynamic linker contain named probes
2080 to allow more fine grained stopping. Given the address of the
2081 original marker function, this function attempts to find these
2082 probes, and if found, sets breakpoints on those instead. If the
2083 probes aren't found, a single breakpoint is set on the original
2087 svr4_create_solib_event_breakpoints (svr4_info *info, struct gdbarch *gdbarch,
2090 struct obj_section *os;
2092 os = find_pc_section (address);
2097 for (with_prefix = 0; with_prefix <= 1; with_prefix++)
2099 std::vector<probe *> probes[NUM_PROBES];
2100 int all_probes_found = 1;
2101 int checked_can_use_probe_arguments = 0;
2103 for (int i = 0; i < NUM_PROBES; i++)
2105 const char *name = probe_info[i].name;
2109 /* Fedora 17 and Red Hat Enterprise Linux 6.2-6.4
2110 shipped with an early version of the probes code in
2111 which the probes' names were prefixed with "rtld_"
2112 and the "map_failed" probe did not exist. The
2113 locations of the probes are otherwise the same, so
2114 we check for probes with prefixed names if probes
2115 with unprefixed names are not present. */
2118 xsnprintf (buf, sizeof (buf), "rtld_%s", name);
2122 probes[i] = find_probes_in_objfile (os->objfile, "rtld", name);
2124 /* The "map_failed" probe did not exist in early
2125 versions of the probes code in which the probes'
2126 names were prefixed with "rtld_". */
2127 if (strcmp (name, "rtld_map_failed") == 0)
2130 if (probes[i].empty ())
2132 all_probes_found = 0;
2136 /* Ensure probe arguments can be evaluated. */
2137 if (!checked_can_use_probe_arguments)
2140 if (!p->can_evaluate_arguments ())
2142 all_probes_found = 0;
2145 checked_can_use_probe_arguments = 1;
2149 if (all_probes_found)
2150 svr4_create_probe_breakpoints (info, gdbarch, probes, os->objfile);
2152 if (all_probes_found)
2157 create_solib_event_breakpoint (gdbarch, address);
2160 /* Helper function for gdb_bfd_lookup_symbol. */
2163 cmp_name_and_sec_flags (const asymbol *sym, const void *data)
2165 return (strcmp (sym->name, (const char *) data) == 0
2166 && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0);
2168 /* Arrange for dynamic linker to hit breakpoint.
2170 Both the SunOS and the SVR4 dynamic linkers have, as part of their
2171 debugger interface, support for arranging for the inferior to hit
2172 a breakpoint after mapping in the shared libraries. This function
2173 enables that breakpoint.
2175 For SunOS, there is a special flag location (in_debugger) which we
2176 set to 1. When the dynamic linker sees this flag set, it will set
2177 a breakpoint at a location known only to itself, after saving the
2178 original contents of that place and the breakpoint address itself,
2179 in it's own internal structures. When we resume the inferior, it
2180 will eventually take a SIGTRAP when it runs into the breakpoint.
2181 We handle this (in a different place) by restoring the contents of
2182 the breakpointed location (which is only known after it stops),
2183 chasing around to locate the shared libraries that have been
2184 loaded, then resuming.
2186 For SVR4, the debugger interface structure contains a member (r_brk)
2187 which is statically initialized at the time the shared library is
2188 built, to the offset of a function (_r_debug_state) which is guaran-
2189 teed to be called once before mapping in a library, and again when
2190 the mapping is complete. At the time we are examining this member,
2191 it contains only the unrelocated offset of the function, so we have
2192 to do our own relocation. Later, when the dynamic linker actually
2193 runs, it relocates r_brk to be the actual address of _r_debug_state().
2195 The debugger interface structure also contains an enumeration which
2196 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
2197 depending upon whether or not the library is being mapped or unmapped,
2198 and then set to RT_CONSISTENT after the library is mapped/unmapped. */
2201 enable_break (struct svr4_info *info, int from_tty)
2203 struct bound_minimal_symbol msymbol;
2204 const char * const *bkpt_namep;
2205 asection *interp_sect;
2208 info->interp_text_sect_low = info->interp_text_sect_high = 0;
2209 info->interp_plt_sect_low = info->interp_plt_sect_high = 0;
2211 /* If we already have a shared library list in the target, and
2212 r_debug contains r_brk, set the breakpoint there - this should
2213 mean r_brk has already been relocated. Assume the dynamic linker
2214 is the object containing r_brk. */
2216 solib_add (NULL, from_tty, auto_solib_add);
2218 if (info->debug_base && solib_svr4_r_map (info) != 0)
2219 sym_addr = solib_svr4_r_brk (info);
2223 struct obj_section *os;
2225 sym_addr = gdbarch_addr_bits_remove
2227 gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2229 current_top_target ()));
2231 /* On at least some versions of Solaris there's a dynamic relocation
2232 on _r_debug.r_brk and SYM_ADDR may not be relocated yet, e.g., if
2233 we get control before the dynamic linker has self-relocated.
2234 Check if SYM_ADDR is in a known section, if it is assume we can
2235 trust its value. This is just a heuristic though, it could go away
2236 or be replaced if it's getting in the way.
2238 On ARM we need to know whether the ISA of rtld_db_dlactivity (or
2239 however it's spelled in your particular system) is ARM or Thumb.
2240 That knowledge is encoded in the address, if it's Thumb the low bit
2241 is 1. However, we've stripped that info above and it's not clear
2242 what all the consequences are of passing a non-addr_bits_remove'd
2243 address to svr4_create_solib_event_breakpoints. The call to
2244 find_pc_section verifies we know about the address and have some
2245 hope of computing the right kind of breakpoint to use (via
2246 symbol info). It does mean that GDB needs to be pointed at a
2247 non-stripped version of the dynamic linker in order to obtain
2248 information it already knows about. Sigh. */
2250 os = find_pc_section (sym_addr);
2253 /* Record the relocated start and end address of the dynamic linker
2254 text and plt section for svr4_in_dynsym_resolve_code. */
2256 CORE_ADDR load_addr;
2258 tmp_bfd = os->objfile->obfd;
2259 load_addr = ANOFFSET (os->objfile->section_offsets,
2260 SECT_OFF_TEXT (os->objfile));
2262 interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
2265 info->interp_text_sect_low =
2266 bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
2267 info->interp_text_sect_high =
2268 info->interp_text_sect_low
2269 + bfd_section_size (tmp_bfd, interp_sect);
2271 interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
2274 info->interp_plt_sect_low =
2275 bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
2276 info->interp_plt_sect_high =
2277 info->interp_plt_sect_low
2278 + bfd_section_size (tmp_bfd, interp_sect);
2281 svr4_create_solib_event_breakpoints (info, target_gdbarch (), sym_addr);
2286 /* Find the program interpreter; if not found, warn the user and drop
2287 into the old breakpoint at symbol code. */
2288 gdb::optional<gdb::byte_vector> interp_name_holder
2289 = find_program_interpreter ();
2290 if (interp_name_holder)
2292 const char *interp_name = (const char *) interp_name_holder->data ();
2293 CORE_ADDR load_addr = 0;
2294 int load_addr_found = 0;
2295 int loader_found_in_list = 0;
2297 struct target_ops *tmp_bfd_target;
2301 /* Now we need to figure out where the dynamic linker was
2302 loaded so that we can load its symbols and place a breakpoint
2303 in the dynamic linker itself.
2305 This address is stored on the stack. However, I've been unable
2306 to find any magic formula to find it for Solaris (appears to
2307 be trivial on GNU/Linux). Therefore, we have to try an alternate
2308 mechanism to find the dynamic linker's base address. */
2310 gdb_bfd_ref_ptr tmp_bfd;
2313 tmp_bfd = solib_bfd_open (interp_name);
2315 catch (const gdb_exception &ex)
2319 if (tmp_bfd == NULL)
2320 goto bkpt_at_symbol;
2322 /* Now convert the TMP_BFD into a target. That way target, as
2323 well as BFD operations can be used. target_bfd_reopen
2324 acquires its own reference. */
2325 tmp_bfd_target = target_bfd_reopen (tmp_bfd.get ());
2327 /* On a running target, we can get the dynamic linker's base
2328 address from the shared library table. */
2329 so = master_so_list ();
2332 if (svr4_same_1 (interp_name, so->so_original_name))
2334 load_addr_found = 1;
2335 loader_found_in_list = 1;
2336 load_addr = lm_addr_check (so, tmp_bfd.get ());
2342 /* If we were not able to find the base address of the loader
2343 from our so_list, then try using the AT_BASE auxilliary entry. */
2344 if (!load_addr_found)
2345 if (target_auxv_search (current_top_target (), AT_BASE, &load_addr) > 0)
2347 int addr_bit = gdbarch_addr_bit (target_gdbarch ());
2349 /* Ensure LOAD_ADDR has proper sign in its possible upper bits so
2350 that `+ load_addr' will overflow CORE_ADDR width not creating
2351 invalid addresses like 0x101234567 for 32bit inferiors on 64bit
2354 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
2356 CORE_ADDR space_size = (CORE_ADDR) 1 << addr_bit;
2357 CORE_ADDR tmp_entry_point = exec_entry_point (tmp_bfd.get (),
2360 gdb_assert (load_addr < space_size);
2362 /* TMP_ENTRY_POINT exceeding SPACE_SIZE would be for prelinked
2363 64bit ld.so with 32bit executable, it should not happen. */
2365 if (tmp_entry_point < space_size
2366 && tmp_entry_point + load_addr >= space_size)
2367 load_addr -= space_size;
2370 load_addr_found = 1;
2373 /* Otherwise we find the dynamic linker's base address by examining
2374 the current pc (which should point at the entry point for the
2375 dynamic linker) and subtracting the offset of the entry point.
2377 This is more fragile than the previous approaches, but is a good
2378 fallback method because it has actually been working well in
2380 if (!load_addr_found)
2382 struct regcache *regcache
2383 = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
2385 load_addr = (regcache_read_pc (regcache)
2386 - exec_entry_point (tmp_bfd.get (), tmp_bfd_target));
2389 if (!loader_found_in_list)
2391 info->debug_loader_name = xstrdup (interp_name);
2392 info->debug_loader_offset_p = 1;
2393 info->debug_loader_offset = load_addr;
2394 solib_add (NULL, from_tty, auto_solib_add);
2397 /* Record the relocated start and end address of the dynamic linker
2398 text and plt section for svr4_in_dynsym_resolve_code. */
2399 interp_sect = bfd_get_section_by_name (tmp_bfd.get (), ".text");
2402 info->interp_text_sect_low =
2403 bfd_section_vma (tmp_bfd.get (), interp_sect) + load_addr;
2404 info->interp_text_sect_high =
2405 info->interp_text_sect_low
2406 + bfd_section_size (tmp_bfd.get (), interp_sect);
2408 interp_sect = bfd_get_section_by_name (tmp_bfd.get (), ".plt");
2411 info->interp_plt_sect_low =
2412 bfd_section_vma (tmp_bfd.get (), interp_sect) + load_addr;
2413 info->interp_plt_sect_high =
2414 info->interp_plt_sect_low
2415 + bfd_section_size (tmp_bfd.get (), interp_sect);
2418 /* Now try to set a breakpoint in the dynamic linker. */
2419 for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
2421 sym_addr = gdb_bfd_lookup_symbol (tmp_bfd.get (),
2422 cmp_name_and_sec_flags,
2429 /* Convert 'sym_addr' from a function pointer to an address.
2430 Because we pass tmp_bfd_target instead of the current
2431 target, this will always produce an unrelocated value. */
2432 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2436 /* We're done with both the temporary bfd and target. Closing
2437 the target closes the underlying bfd, because it holds the
2438 only remaining reference. */
2439 target_close (tmp_bfd_target);
2443 svr4_create_solib_event_breakpoints (info, target_gdbarch (),
2444 load_addr + sym_addr);
2448 /* For whatever reason we couldn't set a breakpoint in the dynamic
2449 linker. Warn and drop into the old code. */
2451 warning (_("Unable to find dynamic linker breakpoint function.\n"
2452 "GDB will be unable to debug shared library initializers\n"
2453 "and track explicitly loaded dynamic code."));
2456 /* Scan through the lists of symbols, trying to look up the symbol and
2457 set a breakpoint there. Terminate loop when we/if we succeed. */
2459 for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
2461 msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
2462 if ((msymbol.minsym != NULL)
2463 && (BMSYMBOL_VALUE_ADDRESS (msymbol) != 0))
2465 sym_addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
2466 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2468 current_top_target ());
2469 svr4_create_solib_event_breakpoints (info, target_gdbarch (),
2475 if (interp_name_holder && !current_inferior ()->attach_flag)
2477 for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
2479 msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
2480 if ((msymbol.minsym != NULL)
2481 && (BMSYMBOL_VALUE_ADDRESS (msymbol) != 0))
2483 sym_addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
2484 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
2486 current_top_target ());
2487 svr4_create_solib_event_breakpoints (info, target_gdbarch (),
2496 /* Read the ELF program headers from ABFD. */
2498 static gdb::optional<gdb::byte_vector>
2499 read_program_headers_from_bfd (bfd *abfd)
2501 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
2502 int phdrs_size = ehdr->e_phnum * ehdr->e_phentsize;
2503 if (phdrs_size == 0)
2506 gdb::byte_vector buf (phdrs_size);
2507 if (bfd_seek (abfd, ehdr->e_phoff, SEEK_SET) != 0
2508 || bfd_bread (buf.data (), phdrs_size, abfd) != phdrs_size)
2514 /* Return 1 and fill *DISPLACEMENTP with detected PIE offset of inferior
2515 exec_bfd. Otherwise return 0.
2517 We relocate all of the sections by the same amount. This
2518 behavior is mandated by recent editions of the System V ABI.
2519 According to the System V Application Binary Interface,
2520 Edition 4.1, page 5-5:
2522 ... Though the system chooses virtual addresses for
2523 individual processes, it maintains the segments' relative
2524 positions. Because position-independent code uses relative
2525 addressesing between segments, the difference between
2526 virtual addresses in memory must match the difference
2527 between virtual addresses in the file. The difference
2528 between the virtual address of any segment in memory and
2529 the corresponding virtual address in the file is thus a
2530 single constant value for any one executable or shared
2531 object in a given process. This difference is the base
2532 address. One use of the base address is to relocate the
2533 memory image of the program during dynamic linking.
2535 The same language also appears in Edition 4.0 of the System V
2536 ABI and is left unspecified in some of the earlier editions.
2538 Decide if the objfile needs to be relocated. As indicated above, we will
2539 only be here when execution is stopped. But during attachment PC can be at
2540 arbitrary address therefore regcache_read_pc can be misleading (contrary to
2541 the auxv AT_ENTRY value). Moreover for executable with interpreter section
2542 regcache_read_pc would point to the interpreter and not the main executable.
2544 So, to summarize, relocations are necessary when the start address obtained
2545 from the executable is different from the address in auxv AT_ENTRY entry.
2547 [ The astute reader will note that we also test to make sure that
2548 the executable in question has the DYNAMIC flag set. It is my
2549 opinion that this test is unnecessary (undesirable even). It
2550 was added to avoid inadvertent relocation of an executable
2551 whose e_type member in the ELF header is not ET_DYN. There may
2552 be a time in the future when it is desirable to do relocations
2553 on other types of files as well in which case this condition
2554 should either be removed or modified to accomodate the new file
2555 type. - Kevin, Nov 2000. ] */
2558 svr4_exec_displacement (CORE_ADDR *displacementp)
2560 /* ENTRY_POINT is a possible function descriptor - before
2561 a call to gdbarch_convert_from_func_ptr_addr. */
2562 CORE_ADDR entry_point, exec_displacement;
2564 if (exec_bfd == NULL)
2567 /* Therefore for ELF it is ET_EXEC and not ET_DYN. Both shared libraries
2568 being executed themselves and PIE (Position Independent Executable)
2569 executables are ET_DYN. */
2571 if ((bfd_get_file_flags (exec_bfd) & DYNAMIC) == 0)
2574 if (target_auxv_search (current_top_target (), AT_ENTRY, &entry_point) <= 0)
2577 exec_displacement = entry_point - bfd_get_start_address (exec_bfd);
2579 /* Verify the EXEC_DISPLACEMENT candidate complies with the required page
2580 alignment. It is cheaper than the program headers comparison below. */
2582 if (bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
2584 const struct elf_backend_data *elf = get_elf_backend_data (exec_bfd);
2586 /* p_align of PT_LOAD segments does not specify any alignment but
2587 only congruency of addresses:
2588 p_offset % p_align == p_vaddr % p_align
2589 Kernel is free to load the executable with lower alignment. */
2591 if ((exec_displacement & (elf->minpagesize - 1)) != 0)
2595 /* Verify that the auxilliary vector describes the same file as exec_bfd, by
2596 comparing their program headers. If the program headers in the auxilliary
2597 vector do not match the program headers in the executable, then we are
2598 looking at a different file than the one used by the kernel - for
2599 instance, "gdb program" connected to "gdbserver :PORT ld.so program". */
2601 if (bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
2603 /* Be optimistic and return 0 only if GDB was able to verify the headers
2604 really do not match. */
2607 gdb::optional<gdb::byte_vector> phdrs_target
2608 = read_program_header (-1, &arch_size, NULL);
2609 gdb::optional<gdb::byte_vector> phdrs_binary
2610 = read_program_headers_from_bfd (exec_bfd);
2611 if (phdrs_target && phdrs_binary)
2613 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
2615 /* We are dealing with three different addresses. EXEC_BFD
2616 represents current address in on-disk file. target memory content
2617 may be different from EXEC_BFD as the file may have been prelinked
2618 to a different address after the executable has been loaded.
2619 Moreover the address of placement in target memory can be
2620 different from what the program headers in target memory say -
2621 this is the goal of PIE.
2623 Detected DISPLACEMENT covers both the offsets of PIE placement and
2624 possible new prelink performed after start of the program. Here
2625 relocate BUF and BUF2 just by the EXEC_BFD vs. target memory
2626 content offset for the verification purpose. */
2628 if (phdrs_target->size () != phdrs_binary->size ()
2629 || bfd_get_arch_size (exec_bfd) != arch_size)
2631 else if (arch_size == 32
2632 && phdrs_target->size () >= sizeof (Elf32_External_Phdr)
2633 && phdrs_target->size () % sizeof (Elf32_External_Phdr) == 0)
2635 Elf_Internal_Ehdr *ehdr2 = elf_tdata (exec_bfd)->elf_header;
2636 Elf_Internal_Phdr *phdr2 = elf_tdata (exec_bfd)->phdr;
2637 CORE_ADDR displacement = 0;
2640 /* DISPLACEMENT could be found more easily by the difference of
2641 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2642 already have enough information to compute that displacement
2643 with what we've read. */
2645 for (i = 0; i < ehdr2->e_phnum; i++)
2646 if (phdr2[i].p_type == PT_LOAD)
2648 Elf32_External_Phdr *phdrp;
2649 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2650 CORE_ADDR vaddr, paddr;
2651 CORE_ADDR displacement_vaddr = 0;
2652 CORE_ADDR displacement_paddr = 0;
2654 phdrp = &((Elf32_External_Phdr *) phdrs_target->data ())[i];
2655 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2656 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2658 vaddr = extract_unsigned_integer (buf_vaddr_p, 4,
2660 displacement_vaddr = vaddr - phdr2[i].p_vaddr;
2662 paddr = extract_unsigned_integer (buf_paddr_p, 4,
2664 displacement_paddr = paddr - phdr2[i].p_paddr;
2666 if (displacement_vaddr == displacement_paddr)
2667 displacement = displacement_vaddr;
2672 /* Now compare program headers from the target and the binary
2673 with optional DISPLACEMENT. */
2676 i < phdrs_target->size () / sizeof (Elf32_External_Phdr);
2679 Elf32_External_Phdr *phdrp;
2680 Elf32_External_Phdr *phdr2p;
2681 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2682 CORE_ADDR vaddr, paddr;
2683 asection *plt2_asect;
2685 phdrp = &((Elf32_External_Phdr *) phdrs_target->data ())[i];
2686 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2687 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2688 phdr2p = &((Elf32_External_Phdr *) phdrs_binary->data ())[i];
2690 /* PT_GNU_STACK is an exception by being never relocated by
2691 prelink as its addresses are always zero. */
2693 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2696 /* Check also other adjustment combinations - PR 11786. */
2698 vaddr = extract_unsigned_integer (buf_vaddr_p, 4,
2700 vaddr -= displacement;
2701 store_unsigned_integer (buf_vaddr_p, 4, byte_order, vaddr);
2703 paddr = extract_unsigned_integer (buf_paddr_p, 4,
2705 paddr -= displacement;
2706 store_unsigned_integer (buf_paddr_p, 4, byte_order, paddr);
2708 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2711 /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2712 CentOS-5 has problems with filesz, memsz as well.
2713 Strip also modifies memsz of PT_TLS.
2715 if (phdr2[i].p_type == PT_GNU_RELRO
2716 || phdr2[i].p_type == PT_TLS)
2718 Elf32_External_Phdr tmp_phdr = *phdrp;
2719 Elf32_External_Phdr tmp_phdr2 = *phdr2p;
2721 memset (tmp_phdr.p_filesz, 0, 4);
2722 memset (tmp_phdr.p_memsz, 0, 4);
2723 memset (tmp_phdr.p_flags, 0, 4);
2724 memset (tmp_phdr.p_align, 0, 4);
2725 memset (tmp_phdr2.p_filesz, 0, 4);
2726 memset (tmp_phdr2.p_memsz, 0, 4);
2727 memset (tmp_phdr2.p_flags, 0, 4);
2728 memset (tmp_phdr2.p_align, 0, 4);
2730 if (memcmp (&tmp_phdr, &tmp_phdr2, sizeof (tmp_phdr))
2735 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2736 plt2_asect = bfd_get_section_by_name (exec_bfd, ".plt");
2740 gdb_byte *buf_filesz_p = (gdb_byte *) &phdrp->p_filesz;
2743 content2 = (bfd_get_section_flags (exec_bfd, plt2_asect)
2744 & SEC_HAS_CONTENTS) != 0;
2746 filesz = extract_unsigned_integer (buf_filesz_p, 4,
2749 /* PLT2_ASECT is from on-disk file (exec_bfd) while
2750 FILESZ is from the in-memory image. */
2752 filesz += bfd_get_section_size (plt2_asect);
2754 filesz -= bfd_get_section_size (plt2_asect);
2756 store_unsigned_integer (buf_filesz_p, 4, byte_order,
2759 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2766 else if (arch_size == 64
2767 && phdrs_target->size () >= sizeof (Elf64_External_Phdr)
2768 && phdrs_target->size () % sizeof (Elf64_External_Phdr) == 0)
2770 Elf_Internal_Ehdr *ehdr2 = elf_tdata (exec_bfd)->elf_header;
2771 Elf_Internal_Phdr *phdr2 = elf_tdata (exec_bfd)->phdr;
2772 CORE_ADDR displacement = 0;
2775 /* DISPLACEMENT could be found more easily by the difference of
2776 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2777 already have enough information to compute that displacement
2778 with what we've read. */
2780 for (i = 0; i < ehdr2->e_phnum; i++)
2781 if (phdr2[i].p_type == PT_LOAD)
2783 Elf64_External_Phdr *phdrp;
2784 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2785 CORE_ADDR vaddr, paddr;
2786 CORE_ADDR displacement_vaddr = 0;
2787 CORE_ADDR displacement_paddr = 0;
2789 phdrp = &((Elf64_External_Phdr *) phdrs_target->data ())[i];
2790 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2791 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2793 vaddr = extract_unsigned_integer (buf_vaddr_p, 8,
2795 displacement_vaddr = vaddr - phdr2[i].p_vaddr;
2797 paddr = extract_unsigned_integer (buf_paddr_p, 8,
2799 displacement_paddr = paddr - phdr2[i].p_paddr;
2801 if (displacement_vaddr == displacement_paddr)
2802 displacement = displacement_vaddr;
2807 /* Now compare BUF and BUF2 with optional DISPLACEMENT. */
2810 i < phdrs_target->size () / sizeof (Elf64_External_Phdr);
2813 Elf64_External_Phdr *phdrp;
2814 Elf64_External_Phdr *phdr2p;
2815 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2816 CORE_ADDR vaddr, paddr;
2817 asection *plt2_asect;
2819 phdrp = &((Elf64_External_Phdr *) phdrs_target->data ())[i];
2820 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2821 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2822 phdr2p = &((Elf64_External_Phdr *) phdrs_binary->data ())[i];
2824 /* PT_GNU_STACK is an exception by being never relocated by
2825 prelink as its addresses are always zero. */
2827 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2830 /* Check also other adjustment combinations - PR 11786. */
2832 vaddr = extract_unsigned_integer (buf_vaddr_p, 8,
2834 vaddr -= displacement;
2835 store_unsigned_integer (buf_vaddr_p, 8, byte_order, vaddr);
2837 paddr = extract_unsigned_integer (buf_paddr_p, 8,
2839 paddr -= displacement;
2840 store_unsigned_integer (buf_paddr_p, 8, byte_order, paddr);
2842 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2845 /* Strip modifies the flags and alignment of PT_GNU_RELRO.
2846 CentOS-5 has problems with filesz, memsz as well.
2847 Strip also modifies memsz of PT_TLS.
2849 if (phdr2[i].p_type == PT_GNU_RELRO
2850 || phdr2[i].p_type == PT_TLS)
2852 Elf64_External_Phdr tmp_phdr = *phdrp;
2853 Elf64_External_Phdr tmp_phdr2 = *phdr2p;
2855 memset (tmp_phdr.p_filesz, 0, 8);
2856 memset (tmp_phdr.p_memsz, 0, 8);
2857 memset (tmp_phdr.p_flags, 0, 4);
2858 memset (tmp_phdr.p_align, 0, 8);
2859 memset (tmp_phdr2.p_filesz, 0, 8);
2860 memset (tmp_phdr2.p_memsz, 0, 8);
2861 memset (tmp_phdr2.p_flags, 0, 4);
2862 memset (tmp_phdr2.p_align, 0, 8);
2864 if (memcmp (&tmp_phdr, &tmp_phdr2, sizeof (tmp_phdr))
2869 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2870 plt2_asect = bfd_get_section_by_name (exec_bfd, ".plt");
2874 gdb_byte *buf_filesz_p = (gdb_byte *) &phdrp->p_filesz;
2877 content2 = (bfd_get_section_flags (exec_bfd, plt2_asect)
2878 & SEC_HAS_CONTENTS) != 0;
2880 filesz = extract_unsigned_integer (buf_filesz_p, 8,
2883 /* PLT2_ASECT is from on-disk file (exec_bfd) while
2884 FILESZ is from the in-memory image. */
2886 filesz += bfd_get_section_size (plt2_asect);
2888 filesz -= bfd_get_section_size (plt2_asect);
2890 store_unsigned_integer (buf_filesz_p, 8, byte_order,
2893 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 (), exec_displacement),
2914 bfd_get_filename (exec_bfd));
2917 *displacementp = exec_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 = XALLOCAVEC (struct section_offsets,
2969 symfile_objfile->num_sections);
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 (current_program_space);
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 (current_program_space);
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
3112 = (struct solib_svr4_ops *) gdbarch_data (gdbarch, solib_svr4_data);
3114 ops->fetch_link_map_offsets = flmo;
3116 set_solib_ops (gdbarch, &svr4_so_ops);
3119 /* Fetch a link_map_offsets structure using the architecture-specific
3120 `struct link_map_offsets' fetcher. */
3122 static struct link_map_offsets *
3123 svr4_fetch_link_map_offsets (void)
3125 struct solib_svr4_ops *ops
3126 = (struct solib_svr4_ops *) gdbarch_data (target_gdbarch (),
3129 gdb_assert (ops->fetch_link_map_offsets);
3130 return ops->fetch_link_map_offsets ();
3133 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
3136 svr4_have_link_map_offsets (void)
3138 struct solib_svr4_ops *ops
3139 = (struct solib_svr4_ops *) gdbarch_data (target_gdbarch (),
3142 return (ops->fetch_link_map_offsets != NULL);
3146 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
3147 `struct r_debug' and a `struct link_map' that are binary compatible
3148 with the origional SVR4 implementation. */
3150 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3151 for an ILP32 SVR4 system. */
3153 struct link_map_offsets *
3154 svr4_ilp32_fetch_link_map_offsets (void)
3156 static struct link_map_offsets lmo;
3157 static struct link_map_offsets *lmp = NULL;
3163 lmo.r_version_offset = 0;
3164 lmo.r_version_size = 4;
3165 lmo.r_map_offset = 4;
3166 lmo.r_brk_offset = 8;
3167 lmo.r_ldsomap_offset = 20;
3169 /* Everything we need is in the first 20 bytes. */
3170 lmo.link_map_size = 20;
3171 lmo.l_addr_offset = 0;
3172 lmo.l_name_offset = 4;
3173 lmo.l_ld_offset = 8;
3174 lmo.l_next_offset = 12;
3175 lmo.l_prev_offset = 16;
3181 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
3182 for an LP64 SVR4 system. */
3184 struct link_map_offsets *
3185 svr4_lp64_fetch_link_map_offsets (void)
3187 static struct link_map_offsets lmo;
3188 static struct link_map_offsets *lmp = NULL;
3194 lmo.r_version_offset = 0;
3195 lmo.r_version_size = 4;
3196 lmo.r_map_offset = 8;
3197 lmo.r_brk_offset = 16;
3198 lmo.r_ldsomap_offset = 40;
3200 /* Everything we need is in the first 40 bytes. */
3201 lmo.link_map_size = 40;
3202 lmo.l_addr_offset = 0;
3203 lmo.l_name_offset = 8;
3204 lmo.l_ld_offset = 16;
3205 lmo.l_next_offset = 24;
3206 lmo.l_prev_offset = 32;
3213 struct target_so_ops svr4_so_ops;
3215 /* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a
3216 different rule for symbol lookup. The lookup begins here in the DSO, not in
3217 the main executable. */
3219 static struct block_symbol
3220 elf_lookup_lib_symbol (struct objfile *objfile,
3222 const domain_enum domain)
3226 if (objfile == symfile_objfile)
3230 /* OBJFILE should have been passed as the non-debug one. */
3231 gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
3233 abfd = objfile->obfd;
3236 if (abfd == NULL || scan_dyntag (DT_SYMBOLIC, abfd, NULL, NULL) != 1)
3239 return lookup_global_symbol_from_objfile (objfile, name, domain);
3243 _initialize_svr4_solib (void)
3245 solib_svr4_data = gdbarch_data_register_pre_init (solib_svr4_init);
3246 solib_svr4_pspace_data
3247 = register_program_space_data_with_cleanup (NULL, svr4_pspace_data_cleanup);
3249 svr4_so_ops.relocate_section_addresses = svr4_relocate_section_addresses;
3250 svr4_so_ops.free_so = svr4_free_so;
3251 svr4_so_ops.clear_so = svr4_clear_so;
3252 svr4_so_ops.clear_solib = svr4_clear_solib;
3253 svr4_so_ops.solib_create_inferior_hook = svr4_solib_create_inferior_hook;
3254 svr4_so_ops.current_sos = svr4_current_sos;
3255 svr4_so_ops.open_symbol_file_object = open_symbol_file_object;
3256 svr4_so_ops.in_dynsym_resolve_code = svr4_in_dynsym_resolve_code;
3257 svr4_so_ops.bfd_open = solib_bfd_open;
3258 svr4_so_ops.lookup_lib_global_symbol = elf_lookup_lib_symbol;
3259 svr4_so_ops.same = svr4_same;
3260 svr4_so_ops.keep_data_in_core = svr4_keep_data_in_core;
3261 svr4_so_ops.update_breakpoints = svr4_update_solib_event_breakpoints;
3262 svr4_so_ops.handle_event = svr4_handle_solib_event;
3264 gdb::observers::free_objfile.attach (svr4_free_objfile_observer);