1 /* Handle SVR4 shared libraries for GDB, the GNU Debugger.
3 Copyright (C) 1990-1996, 1998-2001, 2003-2012 Free Software
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "elf/external.h"
24 #include "elf/common.h"
35 #include "gdbthread.h"
38 #include "gdb_assert.h"
42 #include "solib-svr4.h"
44 #include "bfd-target.h"
48 #include "exceptions.h"
51 static struct link_map_offsets *svr4_fetch_link_map_offsets (void);
52 static int svr4_have_link_map_offsets (void);
53 static void svr4_relocate_main_executable (void);
55 /* Link map info to include in an allocated so_list entry. */
59 /* Amount by which addresses in the binary should be relocated to
60 match the inferior. The direct inferior value is L_ADDR_INFERIOR.
61 When prelinking is involved and the prelink base address changes,
62 we may need a different offset - the recomputed offset is in L_ADDR.
63 It is commonly the same value. It is cached as we want to warn about
64 the difference and compute it only once. L_ADDR is valid
66 CORE_ADDR l_addr, l_addr_inferior;
67 unsigned int l_addr_p : 1;
69 /* The target location of lm. */
72 /* Values read in from inferior's fields of the same name. */
73 CORE_ADDR l_ld, l_next, l_prev, l_name;
76 /* On SVR4 systems, a list of symbols in the dynamic linker where
77 GDB can try to place a breakpoint to monitor shared library
80 If none of these symbols are found, or other errors occur, then
81 SVR4 systems will fall back to using a symbol as the "startup
82 mapping complete" breakpoint address. */
84 static const char * const solib_break_names[] =
90 "__dl_rtld_db_dlactivity",
96 static const char * const bkpt_names[] =
104 static const char * const main_name_list[] =
110 /* Return non-zero if GDB_SO_NAME and INFERIOR_SO_NAME represent
111 the same shared library. */
114 svr4_same_1 (const char *gdb_so_name, const char *inferior_so_name)
116 if (strcmp (gdb_so_name, inferior_so_name) == 0)
119 /* On Solaris, when starting inferior we think that dynamic linker is
120 /usr/lib/ld.so.1, but later on, the table of loaded shared libraries
121 contains /lib/ld.so.1. Sometimes one file is a link to another, but
122 sometimes they have identical content, but are not linked to each
123 other. We don't restrict this check for Solaris, but the chances
124 of running into this situation elsewhere are very low. */
125 if (strcmp (gdb_so_name, "/usr/lib/ld.so.1") == 0
126 && strcmp (inferior_so_name, "/lib/ld.so.1") == 0)
129 /* Similarly, we observed the same issue with sparc64, but with
130 different locations. */
131 if (strcmp (gdb_so_name, "/usr/lib/sparcv9/ld.so.1") == 0
132 && strcmp (inferior_so_name, "/lib/sparcv9/ld.so.1") == 0)
139 svr4_same (struct so_list *gdb, struct so_list *inferior)
141 return (svr4_same_1 (gdb->so_original_name, inferior->so_original_name));
144 static struct lm_info *
145 lm_info_read (CORE_ADDR lm_addr)
147 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
149 struct lm_info *lm_info;
150 struct cleanup *back_to;
152 lm = xmalloc (lmo->link_map_size);
153 back_to = make_cleanup (xfree, lm);
155 if (target_read_memory (lm_addr, lm, lmo->link_map_size) != 0)
157 warning (_("Error reading shared library list entry at %s"),
158 paddress (target_gdbarch (), lm_addr)),
163 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
165 lm_info = xzalloc (sizeof (*lm_info));
166 lm_info->lm_addr = lm_addr;
168 lm_info->l_addr_inferior = extract_typed_address (&lm[lmo->l_addr_offset],
170 lm_info->l_ld = extract_typed_address (&lm[lmo->l_ld_offset], ptr_type);
171 lm_info->l_next = extract_typed_address (&lm[lmo->l_next_offset],
173 lm_info->l_prev = extract_typed_address (&lm[lmo->l_prev_offset],
175 lm_info->l_name = extract_typed_address (&lm[lmo->l_name_offset],
179 do_cleanups (back_to);
185 has_lm_dynamic_from_link_map (void)
187 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
189 return lmo->l_ld_offset >= 0;
193 lm_addr_check (struct so_list *so, bfd *abfd)
195 if (!so->lm_info->l_addr_p)
197 struct bfd_section *dyninfo_sect;
198 CORE_ADDR l_addr, l_dynaddr, dynaddr;
200 l_addr = so->lm_info->l_addr_inferior;
202 if (! abfd || ! has_lm_dynamic_from_link_map ())
205 l_dynaddr = so->lm_info->l_ld;
207 dyninfo_sect = bfd_get_section_by_name (abfd, ".dynamic");
208 if (dyninfo_sect == NULL)
211 dynaddr = bfd_section_vma (abfd, dyninfo_sect);
213 if (dynaddr + l_addr != l_dynaddr)
215 CORE_ADDR align = 0x1000;
216 CORE_ADDR minpagesize = align;
218 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
220 Elf_Internal_Ehdr *ehdr = elf_tdata (abfd)->elf_header;
221 Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
226 for (i = 0; i < ehdr->e_phnum; i++)
227 if (phdr[i].p_type == PT_LOAD && phdr[i].p_align > align)
228 align = phdr[i].p_align;
230 minpagesize = get_elf_backend_data (abfd)->minpagesize;
233 /* Turn it into a mask. */
236 /* If the changes match the alignment requirements, we
237 assume we're using a core file that was generated by the
238 same binary, just prelinked with a different base offset.
239 If it doesn't match, we may have a different binary, the
240 same binary with the dynamic table loaded at an unrelated
241 location, or anything, really. To avoid regressions,
242 don't adjust the base offset in the latter case, although
243 odds are that, if things really changed, debugging won't
246 One could expect more the condition
247 ((l_addr & align) == 0 && ((l_dynaddr - dynaddr) & align) == 0)
248 but the one below is relaxed for PPC. The PPC kernel supports
249 either 4k or 64k page sizes. To be prepared for 64k pages,
250 PPC ELF files are built using an alignment requirement of 64k.
251 However, when running on a kernel supporting 4k pages, the memory
252 mapping of the library may not actually happen on a 64k boundary!
254 (In the usual case where (l_addr & align) == 0, this check is
255 equivalent to the possibly expected check above.)
257 Even on PPC it must be zero-aligned at least for MINPAGESIZE. */
259 l_addr = l_dynaddr - dynaddr;
261 if ((l_addr & (minpagesize - 1)) == 0
262 && (l_addr & align) == ((l_dynaddr - dynaddr) & align))
265 printf_unfiltered (_("Using PIC (Position Independent Code) "
266 "prelink displacement %s for \"%s\".\n"),
267 paddress (target_gdbarch (), l_addr),
272 /* There is no way to verify the library file matches. prelink
273 can during prelinking of an unprelinked file (or unprelinking
274 of a prelinked file) shift the DYNAMIC segment by arbitrary
275 offset without any page size alignment. There is no way to
276 find out the ELF header and/or Program Headers for a limited
277 verification if it they match. One could do a verification
278 of the DYNAMIC segment. Still the found address is the best
279 one GDB could find. */
281 warning (_(".dynamic section for \"%s\" "
282 "is not at the expected address "
283 "(wrong library or version mismatch?)"), so->so_name);
288 so->lm_info->l_addr = l_addr;
289 so->lm_info->l_addr_p = 1;
292 return so->lm_info->l_addr;
295 /* Per pspace SVR4 specific data. */
299 CORE_ADDR debug_base; /* Base of dynamic linker structures. */
301 /* Validity flag for debug_loader_offset. */
302 int debug_loader_offset_p;
304 /* Load address for the dynamic linker, inferred. */
305 CORE_ADDR debug_loader_offset;
307 /* Name of the dynamic linker, valid if debug_loader_offset_p. */
308 char *debug_loader_name;
310 /* Load map address for the main executable. */
311 CORE_ADDR main_lm_addr;
313 CORE_ADDR interp_text_sect_low;
314 CORE_ADDR interp_text_sect_high;
315 CORE_ADDR interp_plt_sect_low;
316 CORE_ADDR interp_plt_sect_high;
319 /* Per-program-space data key. */
320 static const struct program_space_data *solib_svr4_pspace_data;
323 svr4_pspace_data_cleanup (struct program_space *pspace, void *arg)
325 struct svr4_info *info;
327 info = program_space_data (pspace, solib_svr4_pspace_data);
331 /* Get the current svr4 data. If none is found yet, add it now. This
332 function always returns a valid object. */
334 static struct svr4_info *
337 struct svr4_info *info;
339 info = program_space_data (current_program_space, solib_svr4_pspace_data);
343 info = XZALLOC (struct svr4_info);
344 set_program_space_data (current_program_space, solib_svr4_pspace_data, info);
348 /* Local function prototypes */
350 static int match_main (const char *);
352 /* Read program header TYPE from inferior memory. The header is found
353 by scanning the OS auxillary vector.
355 If TYPE == -1, return the program headers instead of the contents of
358 Return a pointer to allocated memory holding the program header contents,
359 or NULL on failure. If sucessful, and unless P_SECT_SIZE is NULL, the
360 size of those contents is returned to P_SECT_SIZE. Likewise, the target
361 architecture size (32-bit or 64-bit) is returned to P_ARCH_SIZE. */
364 read_program_header (int type, int *p_sect_size, int *p_arch_size)
366 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
367 CORE_ADDR at_phdr, at_phent, at_phnum, pt_phdr = 0;
368 int arch_size, sect_size;
373 /* Get required auxv elements from target. */
374 if (target_auxv_search (¤t_target, AT_PHDR, &at_phdr) <= 0)
376 if (target_auxv_search (¤t_target, AT_PHENT, &at_phent) <= 0)
378 if (target_auxv_search (¤t_target, AT_PHNUM, &at_phnum) <= 0)
380 if (!at_phdr || !at_phnum)
383 /* Determine ELF architecture type. */
384 if (at_phent == sizeof (Elf32_External_Phdr))
386 else if (at_phent == sizeof (Elf64_External_Phdr))
391 /* Find the requested segment. */
395 sect_size = at_phent * at_phnum;
397 else if (arch_size == 32)
399 Elf32_External_Phdr phdr;
402 /* Search for requested PHDR. */
403 for (i = 0; i < at_phnum; i++)
407 if (target_read_memory (at_phdr + i * sizeof (phdr),
408 (gdb_byte *)&phdr, sizeof (phdr)))
411 p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type,
414 if (p_type == PT_PHDR)
417 pt_phdr = extract_unsigned_integer ((gdb_byte *) phdr.p_vaddr,
428 /* Retrieve address and size. */
429 sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr,
431 sect_size = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz,
436 Elf64_External_Phdr phdr;
439 /* Search for requested PHDR. */
440 for (i = 0; i < at_phnum; i++)
444 if (target_read_memory (at_phdr + i * sizeof (phdr),
445 (gdb_byte *)&phdr, sizeof (phdr)))
448 p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type,
451 if (p_type == PT_PHDR)
454 pt_phdr = extract_unsigned_integer ((gdb_byte *) phdr.p_vaddr,
465 /* Retrieve address and size. */
466 sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr,
468 sect_size = extract_unsigned_integer ((gdb_byte *)phdr.p_memsz,
472 /* PT_PHDR is optional, but we really need it
473 for PIE to make this work in general. */
477 /* at_phdr is real address in memory. pt_phdr is what pheader says it is.
478 Relocation offset is the difference between the two. */
479 sect_addr = sect_addr + (at_phdr - pt_phdr);
482 /* Read in requested program header. */
483 buf = xmalloc (sect_size);
484 if (target_read_memory (sect_addr, buf, sect_size))
491 *p_arch_size = arch_size;
493 *p_sect_size = sect_size;
499 /* Return program interpreter string. */
501 find_program_interpreter (void)
503 gdb_byte *buf = NULL;
505 /* If we have an exec_bfd, use its section table. */
507 && bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
509 struct bfd_section *interp_sect;
511 interp_sect = bfd_get_section_by_name (exec_bfd, ".interp");
512 if (interp_sect != NULL)
514 int sect_size = bfd_section_size (exec_bfd, interp_sect);
516 buf = xmalloc (sect_size);
517 bfd_get_section_contents (exec_bfd, interp_sect, buf, 0, sect_size);
521 /* If we didn't find it, use the target auxillary vector. */
523 buf = read_program_header (PT_INTERP, NULL, NULL);
529 /* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
530 returned and the corresponding PTR is set. */
533 scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
535 int arch_size, step, sect_size;
537 CORE_ADDR dyn_ptr, dyn_addr;
538 gdb_byte *bufend, *bufstart, *buf;
539 Elf32_External_Dyn *x_dynp_32;
540 Elf64_External_Dyn *x_dynp_64;
541 struct bfd_section *sect;
542 struct target_section *target_section;
547 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
550 arch_size = bfd_get_arch_size (abfd);
554 /* Find the start address of the .dynamic section. */
555 sect = bfd_get_section_by_name (abfd, ".dynamic");
559 for (target_section = current_target_sections->sections;
560 target_section < current_target_sections->sections_end;
562 if (sect == target_section->the_bfd_section)
564 if (target_section < current_target_sections->sections_end)
565 dyn_addr = target_section->addr;
568 /* ABFD may come from OBJFILE acting only as a symbol file without being
569 loaded into the target (see add_symbol_file_command). This case is
570 such fallback to the file VMA address without the possibility of
571 having the section relocated to its actual in-memory address. */
573 dyn_addr = bfd_section_vma (abfd, sect);
576 /* Read in .dynamic from the BFD. We will get the actual value
577 from memory later. */
578 sect_size = bfd_section_size (abfd, sect);
579 buf = bufstart = alloca (sect_size);
580 if (!bfd_get_section_contents (abfd, sect,
584 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
585 step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
586 : sizeof (Elf64_External_Dyn);
587 for (bufend = buf + sect_size;
593 x_dynp_32 = (Elf32_External_Dyn *) buf;
594 dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);
595 dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);
599 x_dynp_64 = (Elf64_External_Dyn *) buf;
600 dyn_tag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
601 dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);
603 if (dyn_tag == DT_NULL)
605 if (dyn_tag == dyntag)
607 /* If requested, try to read the runtime value of this .dynamic
611 struct type *ptr_type;
615 ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
616 ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
617 if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)
618 dyn_ptr = extract_typed_address (ptr_buf, ptr_type);
628 /* Scan for DYNTAG in .dynamic section of the target's main executable,
629 found by consulting the OS auxillary vector. If DYNTAG is found 1 is
630 returned and the corresponding PTR is set. */
633 scan_dyntag_auxv (int dyntag, CORE_ADDR *ptr)
635 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
636 int sect_size, arch_size, step;
639 gdb_byte *bufend, *bufstart, *buf;
641 /* Read in .dynamic section. */
642 buf = bufstart = read_program_header (PT_DYNAMIC, §_size, &arch_size);
646 /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
647 step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
648 : sizeof (Elf64_External_Dyn);
649 for (bufend = buf + sect_size;
655 Elf32_External_Dyn *dynp = (Elf32_External_Dyn *) buf;
657 dyn_tag = extract_unsigned_integer ((gdb_byte *) dynp->d_tag,
659 dyn_ptr = extract_unsigned_integer ((gdb_byte *) dynp->d_un.d_ptr,
664 Elf64_External_Dyn *dynp = (Elf64_External_Dyn *) buf;
666 dyn_tag = extract_unsigned_integer ((gdb_byte *) dynp->d_tag,
668 dyn_ptr = extract_unsigned_integer ((gdb_byte *) dynp->d_un.d_ptr,
671 if (dyn_tag == DT_NULL)
674 if (dyn_tag == dyntag)
688 /* Locate the base address of dynamic linker structs for SVR4 elf
691 For SVR4 elf targets the address of the dynamic linker's runtime
692 structure is contained within the dynamic info section in the
693 executable file. The dynamic section is also mapped into the
694 inferior address space. Because the runtime loader fills in the
695 real address before starting the inferior, we have to read in the
696 dynamic info section from the inferior address space.
697 If there are any errors while trying to find the address, we
698 silently return 0, otherwise the found address is returned. */
701 elf_locate_base (void)
703 struct minimal_symbol *msymbol;
706 /* Look for DT_MIPS_RLD_MAP first. MIPS executables use this
707 instead of DT_DEBUG, although they sometimes contain an unused
709 if (scan_dyntag (DT_MIPS_RLD_MAP, exec_bfd, &dyn_ptr)
710 || scan_dyntag_auxv (DT_MIPS_RLD_MAP, &dyn_ptr))
712 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
714 int pbuf_size = TYPE_LENGTH (ptr_type);
716 pbuf = alloca (pbuf_size);
717 /* DT_MIPS_RLD_MAP contains a pointer to the address
718 of the dynamic link structure. */
719 if (target_read_memory (dyn_ptr, pbuf, pbuf_size))
721 return extract_typed_address (pbuf, ptr_type);
725 if (scan_dyntag (DT_DEBUG, exec_bfd, &dyn_ptr)
726 || scan_dyntag_auxv (DT_DEBUG, &dyn_ptr))
729 /* This may be a static executable. Look for the symbol
730 conventionally named _r_debug, as a last resort. */
731 msymbol = lookup_minimal_symbol ("_r_debug", NULL, symfile_objfile);
733 return SYMBOL_VALUE_ADDRESS (msymbol);
735 /* DT_DEBUG entry not found. */
739 /* Locate the base address of dynamic linker structs.
741 For both the SunOS and SVR4 shared library implementations, if the
742 inferior executable has been linked dynamically, there is a single
743 address somewhere in the inferior's data space which is the key to
744 locating all of the dynamic linker's runtime structures. This
745 address is the value of the debug base symbol. The job of this
746 function is to find and return that address, or to return 0 if there
747 is no such address (the executable is statically linked for example).
749 For SunOS, the job is almost trivial, since the dynamic linker and
750 all of it's structures are statically linked to the executable at
751 link time. Thus the symbol for the address we are looking for has
752 already been added to the minimal symbol table for the executable's
753 objfile at the time the symbol file's symbols were read, and all we
754 have to do is look it up there. Note that we explicitly do NOT want
755 to find the copies in the shared library.
757 The SVR4 version is a bit more complicated because the address
758 is contained somewhere in the dynamic info section. We have to go
759 to a lot more work to discover the address of the debug base symbol.
760 Because of this complexity, we cache the value we find and return that
761 value on subsequent invocations. Note there is no copy in the
762 executable symbol tables. */
765 locate_base (struct svr4_info *info)
767 /* Check to see if we have a currently valid address, and if so, avoid
768 doing all this work again and just return the cached address. If
769 we have no cached address, try to locate it in the dynamic info
770 section for ELF executables. There's no point in doing any of this
771 though if we don't have some link map offsets to work with. */
773 if (info->debug_base == 0 && svr4_have_link_map_offsets ())
774 info->debug_base = elf_locate_base ();
775 return info->debug_base;
778 /* Find the first element in the inferior's dynamic link map, and
779 return its address in the inferior. Return zero if the address
780 could not be determined.
782 FIXME: Perhaps we should validate the info somehow, perhaps by
783 checking r_version for a known version number, or r_state for
787 solib_svr4_r_map (struct svr4_info *info)
789 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
790 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
792 volatile struct gdb_exception ex;
794 TRY_CATCH (ex, RETURN_MASK_ERROR)
796 addr = read_memory_typed_address (info->debug_base + lmo->r_map_offset,
799 exception_print (gdb_stderr, ex);
803 /* Find r_brk from the inferior's debug base. */
806 solib_svr4_r_brk (struct svr4_info *info)
808 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
809 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
811 return read_memory_typed_address (info->debug_base + lmo->r_brk_offset,
815 /* Find the link map for the dynamic linker (if it is not in the
816 normal list of loaded shared objects). */
819 solib_svr4_r_ldsomap (struct svr4_info *info)
821 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
822 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
823 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
826 /* Check version, and return zero if `struct r_debug' doesn't have
827 the r_ldsomap member. */
829 = read_memory_unsigned_integer (info->debug_base + lmo->r_version_offset,
830 lmo->r_version_size, byte_order);
831 if (version < 2 || lmo->r_ldsomap_offset == -1)
834 return read_memory_typed_address (info->debug_base + lmo->r_ldsomap_offset,
838 /* On Solaris systems with some versions of the dynamic linker,
839 ld.so's l_name pointer points to the SONAME in the string table
840 rather than into writable memory. So that GDB can find shared
841 libraries when loading a core file generated by gcore, ensure that
842 memory areas containing the l_name string are saved in the core
846 svr4_keep_data_in_core (CORE_ADDR vaddr, unsigned long size)
848 struct svr4_info *info;
851 struct cleanup *old_chain;
852 struct link_map_offsets *lmo;
855 info = get_svr4_info ();
857 info->debug_base = 0;
859 if (!info->debug_base)
862 ldsomap = solib_svr4_r_ldsomap (info);
866 lmo = svr4_fetch_link_map_offsets ();
867 new = XZALLOC (struct so_list);
868 old_chain = make_cleanup (xfree, new);
869 new->lm_info = lm_info_read (ldsomap);
870 make_cleanup (xfree, new->lm_info);
871 name_lm = new->lm_info ? new->lm_info->l_name : 0;
872 do_cleanups (old_chain);
874 return (name_lm >= vaddr && name_lm < vaddr + size);
877 /* Implement the "open_symbol_file_object" target_so_ops method.
879 If no open symbol file, attempt to locate and open the main symbol
880 file. On SVR4 systems, this is the first link map entry. If its
881 name is here, we can open it. Useful when attaching to a process
882 without first loading its symbol file. */
885 open_symbol_file_object (void *from_ttyp)
887 CORE_ADDR lm, l_name;
890 int from_tty = *(int *)from_ttyp;
891 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
892 struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
893 int l_name_size = TYPE_LENGTH (ptr_type);
894 gdb_byte *l_name_buf = xmalloc (l_name_size);
895 struct cleanup *cleanups = make_cleanup (xfree, l_name_buf);
896 struct svr4_info *info = get_svr4_info ();
899 if (!query (_("Attempt to reload symbols from process? ")))
901 do_cleanups (cleanups);
905 /* Always locate the debug struct, in case it has moved. */
906 info->debug_base = 0;
907 if (locate_base (info) == 0)
909 do_cleanups (cleanups);
910 return 0; /* failed somehow... */
913 /* First link map member should be the executable. */
914 lm = solib_svr4_r_map (info);
917 do_cleanups (cleanups);
918 return 0; /* failed somehow... */
921 /* Read address of name from target memory to GDB. */
922 read_memory (lm + lmo->l_name_offset, l_name_buf, l_name_size);
924 /* Convert the address to host format. */
925 l_name = extract_typed_address (l_name_buf, ptr_type);
929 do_cleanups (cleanups);
930 return 0; /* No filename. */
933 /* Now fetch the filename from target memory. */
934 target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
935 make_cleanup (xfree, filename);
939 warning (_("failed to read exec filename from attached file: %s"),
940 safe_strerror (errcode));
941 do_cleanups (cleanups);
945 /* Have a pathname: read the symbol file. */
946 symbol_file_add_main (filename, from_tty);
948 do_cleanups (cleanups);
952 /* Data exchange structure for the XML parser as returned by
953 svr4_current_sos_via_xfer_libraries. */
955 struct svr4_library_list
957 struct so_list *head, **tailp;
959 /* Inferior address of struct link_map used for the main executable. It is
960 NULL if not known. */
964 /* Implementation for target_so_ops.free_so. */
967 svr4_free_so (struct so_list *so)
972 /* Free so_list built so far (called via cleanup). */
975 svr4_free_library_list (void *p_list)
977 struct so_list *list = *(struct so_list **) p_list;
981 struct so_list *next = list->next;
990 #include "xml-support.h"
992 /* Handle the start of a <library> element. Note: new elements are added
993 at the tail of the list, keeping the list in order. */
996 library_list_start_library (struct gdb_xml_parser *parser,
997 const struct gdb_xml_element *element,
998 void *user_data, VEC(gdb_xml_value_s) *attributes)
1000 struct svr4_library_list *list = user_data;
1001 const char *name = xml_find_attribute (attributes, "name")->value;
1002 ULONGEST *lmp = xml_find_attribute (attributes, "lm")->value;
1003 ULONGEST *l_addrp = xml_find_attribute (attributes, "l_addr")->value;
1004 ULONGEST *l_ldp = xml_find_attribute (attributes, "l_ld")->value;
1005 struct so_list *new_elem;
1007 new_elem = XZALLOC (struct so_list);
1008 new_elem->lm_info = XZALLOC (struct lm_info);
1009 new_elem->lm_info->lm_addr = *lmp;
1010 new_elem->lm_info->l_addr_inferior = *l_addrp;
1011 new_elem->lm_info->l_ld = *l_ldp;
1013 strncpy (new_elem->so_name, name, sizeof (new_elem->so_name) - 1);
1014 new_elem->so_name[sizeof (new_elem->so_name) - 1] = 0;
1015 strcpy (new_elem->so_original_name, new_elem->so_name);
1017 *list->tailp = new_elem;
1018 list->tailp = &new_elem->next;
1021 /* Handle the start of a <library-list-svr4> element. */
1024 svr4_library_list_start_list (struct gdb_xml_parser *parser,
1025 const struct gdb_xml_element *element,
1026 void *user_data, VEC(gdb_xml_value_s) *attributes)
1028 struct svr4_library_list *list = user_data;
1029 const char *version = xml_find_attribute (attributes, "version")->value;
1030 struct gdb_xml_value *main_lm = xml_find_attribute (attributes, "main-lm");
1032 if (strcmp (version, "1.0") != 0)
1033 gdb_xml_error (parser,
1034 _("SVR4 Library list has unsupported version \"%s\""),
1038 list->main_lm = *(ULONGEST *) main_lm->value;
1041 /* The allowed elements and attributes for an XML library list.
1042 The root element is a <library-list>. */
1044 static const struct gdb_xml_attribute svr4_library_attributes[] =
1046 { "name", GDB_XML_AF_NONE, NULL, NULL },
1047 { "lm", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
1048 { "l_addr", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
1049 { "l_ld", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
1050 { NULL, GDB_XML_AF_NONE, NULL, NULL }
1053 static const struct gdb_xml_element svr4_library_list_children[] =
1056 "library", svr4_library_attributes, NULL,
1057 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
1058 library_list_start_library, NULL
1060 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
1063 static const struct gdb_xml_attribute svr4_library_list_attributes[] =
1065 { "version", GDB_XML_AF_NONE, NULL, NULL },
1066 { "main-lm", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
1067 { NULL, GDB_XML_AF_NONE, NULL, NULL }
1070 static const struct gdb_xml_element svr4_library_list_elements[] =
1072 { "library-list-svr4", svr4_library_list_attributes, svr4_library_list_children,
1073 GDB_XML_EF_NONE, svr4_library_list_start_list, NULL },
1074 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
1077 /* Parse qXfer:libraries:read packet into *SO_LIST_RETURN. Return 1 if
1079 Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
1080 case. Return 1 if *SO_LIST_RETURN contains the library list, it may be
1081 empty, caller is responsible for freeing all its entries. */
1084 svr4_parse_libraries (const char *document, struct svr4_library_list *list)
1086 struct cleanup *back_to = make_cleanup (svr4_free_library_list,
1089 memset (list, 0, sizeof (*list));
1090 list->tailp = &list->head;
1091 if (gdb_xml_parse_quick (_("target library list"), "library-list.dtd",
1092 svr4_library_list_elements, document, list) == 0)
1094 /* Parsed successfully, keep the result. */
1095 discard_cleanups (back_to);
1099 do_cleanups (back_to);
1103 /* Attempt to get so_list from target via qXfer:libraries:read packet.
1105 Return 0 if packet not supported, *SO_LIST_RETURN is not modified in such
1106 case. Return 1 if *SO_LIST_RETURN contains the library list, it may be
1107 empty, caller is responsible for freeing all its entries. */
1110 svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list)
1112 char *svr4_library_document;
1114 struct cleanup *back_to;
1116 /* Fetch the list of shared libraries. */
1117 svr4_library_document = target_read_stralloc (¤t_target,
1118 TARGET_OBJECT_LIBRARIES_SVR4,
1120 if (svr4_library_document == NULL)
1123 back_to = make_cleanup (xfree, svr4_library_document);
1124 result = svr4_parse_libraries (svr4_library_document, list);
1125 do_cleanups (back_to);
1133 svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list)
1140 /* If no shared library information is available from the dynamic
1141 linker, build a fallback list from other sources. */
1143 static struct so_list *
1144 svr4_default_sos (void)
1146 struct svr4_info *info = get_svr4_info ();
1147 struct so_list *new;
1149 if (!info->debug_loader_offset_p)
1152 new = XZALLOC (struct so_list);
1154 new->lm_info = xzalloc (sizeof (struct lm_info));
1156 /* Nothing will ever check the other fields if we set l_addr_p. */
1157 new->lm_info->l_addr = info->debug_loader_offset;
1158 new->lm_info->l_addr_p = 1;
1160 strncpy (new->so_name, info->debug_loader_name, SO_NAME_MAX_PATH_SIZE - 1);
1161 new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
1162 strcpy (new->so_original_name, new->so_name);
1167 /* Read the whole inferior libraries chain starting at address LM. Add the
1168 entries to the tail referenced by LINK_PTR_PTR. Ignore the first entry if
1169 IGNORE_FIRST and set global MAIN_LM_ADDR according to it. */
1172 svr4_read_so_list (CORE_ADDR lm, struct so_list ***link_ptr_ptr,
1175 CORE_ADDR prev_lm = 0, next_lm;
1177 for (; lm != 0; prev_lm = lm, lm = next_lm)
1179 struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
1180 struct so_list *new;
1181 struct cleanup *old_chain;
1185 new = XZALLOC (struct so_list);
1186 old_chain = make_cleanup_free_so (new);
1188 new->lm_info = lm_info_read (lm);
1189 if (new->lm_info == NULL)
1191 do_cleanups (old_chain);
1195 next_lm = new->lm_info->l_next;
1197 if (new->lm_info->l_prev != prev_lm)
1199 warning (_("Corrupted shared library list: %s != %s"),
1200 paddress (target_gdbarch (), prev_lm),
1201 paddress (target_gdbarch (), new->lm_info->l_prev));
1202 do_cleanups (old_chain);
1206 /* For SVR4 versions, the first entry in the link map is for the
1207 inferior executable, so we must ignore it. For some versions of
1208 SVR4, it has no name. For others (Solaris 2.3 for example), it
1209 does have a name, so we can no longer use a missing name to
1210 decide when to ignore it. */
1211 if (ignore_first && new->lm_info->l_prev == 0)
1213 struct svr4_info *info = get_svr4_info ();
1215 info->main_lm_addr = new->lm_info->lm_addr;
1216 do_cleanups (old_chain);
1220 /* Extract this shared object's name. */
1221 target_read_string (new->lm_info->l_name, &buffer,
1222 SO_NAME_MAX_PATH_SIZE - 1, &errcode);
1225 warning (_("Can't read pathname for load map: %s."),
1226 safe_strerror (errcode));
1227 do_cleanups (old_chain);
1231 strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);
1232 new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
1233 strcpy (new->so_original_name, new->so_name);
1236 /* If this entry has no name, or its name matches the name
1237 for the main executable, don't include it in the list. */
1238 if (! new->so_name[0] || match_main (new->so_name))
1240 do_cleanups (old_chain);
1244 discard_cleanups (old_chain);
1246 **link_ptr_ptr = new;
1247 *link_ptr_ptr = &new->next;
1251 /* Implement the "current_sos" target_so_ops method. */
1253 static struct so_list *
1254 svr4_current_sos (void)
1257 struct so_list *head = NULL;
1258 struct so_list **link_ptr = &head;
1259 struct svr4_info *info;
1260 struct cleanup *back_to;
1262 struct svr4_library_list library_list;
1264 /* Fall back to manual examination of the target if the packet is not
1265 supported or gdbserver failed to find DT_DEBUG. gdb.server/solib-list.exp
1266 tests a case where gdbserver cannot find the shared libraries list while
1267 GDB itself is able to find it via SYMFILE_OBJFILE.
1269 Unfortunately statically linked inferiors will also fall back through this
1270 suboptimal code path. */
1272 if (svr4_current_sos_via_xfer_libraries (&library_list))
1274 if (library_list.main_lm)
1276 info = get_svr4_info ();
1277 info->main_lm_addr = library_list.main_lm;
1280 return library_list.head ? library_list.head : svr4_default_sos ();
1283 info = get_svr4_info ();
1285 /* Always locate the debug struct, in case it has moved. */
1286 info->debug_base = 0;
1289 /* If we can't find the dynamic linker's base structure, this
1290 must not be a dynamically linked executable. Hmm. */
1291 if (! info->debug_base)
1292 return svr4_default_sos ();
1294 /* Assume that everything is a library if the dynamic loader was loaded
1295 late by a static executable. */
1296 if (exec_bfd && bfd_get_section_by_name (exec_bfd, ".dynamic") == NULL)
1301 back_to = make_cleanup (svr4_free_library_list, &head);
1303 /* Walk the inferior's link map list, and build our list of
1304 `struct so_list' nodes. */
1305 lm = solib_svr4_r_map (info);
1307 svr4_read_so_list (lm, &link_ptr, ignore_first);
1309 /* On Solaris, the dynamic linker is not in the normal list of
1310 shared objects, so make sure we pick it up too. Having
1311 symbol information for the dynamic linker is quite crucial
1312 for skipping dynamic linker resolver code. */
1313 lm = solib_svr4_r_ldsomap (info);
1315 svr4_read_so_list (lm, &link_ptr, 0);
1317 discard_cleanups (back_to);
1320 return svr4_default_sos ();
1325 /* Get the address of the link_map for a given OBJFILE. */
1328 svr4_fetch_objfile_link_map (struct objfile *objfile)
1331 struct svr4_info *info = get_svr4_info ();
1333 /* Cause svr4_current_sos() to be run if it hasn't been already. */
1334 if (info->main_lm_addr == 0)
1335 solib_add (NULL, 0, ¤t_target, auto_solib_add);
1337 /* svr4_current_sos() will set main_lm_addr for the main executable. */
1338 if (objfile == symfile_objfile)
1339 return info->main_lm_addr;
1341 /* The other link map addresses may be found by examining the list
1342 of shared libraries. */
1343 for (so = master_so_list (); so; so = so->next)
1344 if (so->objfile == objfile)
1345 return so->lm_info->lm_addr;
1351 /* On some systems, the only way to recognize the link map entry for
1352 the main executable file is by looking at its name. Return
1353 non-zero iff SONAME matches one of the known main executable names. */
1356 match_main (const char *soname)
1358 const char * const *mainp;
1360 for (mainp = main_name_list; *mainp != NULL; mainp++)
1362 if (strcmp (soname, *mainp) == 0)
1369 /* Return 1 if PC lies in the dynamic symbol resolution code of the
1370 SVR4 run time loader. */
1373 svr4_in_dynsym_resolve_code (CORE_ADDR pc)
1375 struct svr4_info *info = get_svr4_info ();
1377 return ((pc >= info->interp_text_sect_low
1378 && pc < info->interp_text_sect_high)
1379 || (pc >= info->interp_plt_sect_low
1380 && pc < info->interp_plt_sect_high)
1381 || in_plt_section (pc, NULL)
1382 || in_gnu_ifunc_stub (pc));
1385 /* Given an executable's ABFD and target, compute the entry-point
1389 exec_entry_point (struct bfd *abfd, struct target_ops *targ)
1393 /* KevinB wrote ... for most targets, the address returned by
1394 bfd_get_start_address() is the entry point for the start
1395 function. But, for some targets, bfd_get_start_address() returns
1396 the address of a function descriptor from which the entry point
1397 address may be extracted. This address is extracted by
1398 gdbarch_convert_from_func_ptr_addr(). The method
1399 gdbarch_convert_from_func_ptr_addr() is the merely the identify
1400 function for targets which don't use function descriptors. */
1401 addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
1402 bfd_get_start_address (abfd),
1404 return gdbarch_addr_bits_remove (target_gdbarch (), addr);
1407 /* Helper function for gdb_bfd_lookup_symbol. */
1410 cmp_name_and_sec_flags (asymbol *sym, void *data)
1412 return (strcmp (sym->name, (const char *) data) == 0
1413 && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0);
1415 /* Arrange for dynamic linker to hit breakpoint.
1417 Both the SunOS and the SVR4 dynamic linkers have, as part of their
1418 debugger interface, support for arranging for the inferior to hit
1419 a breakpoint after mapping in the shared libraries. This function
1420 enables that breakpoint.
1422 For SunOS, there is a special flag location (in_debugger) which we
1423 set to 1. When the dynamic linker sees this flag set, it will set
1424 a breakpoint at a location known only to itself, after saving the
1425 original contents of that place and the breakpoint address itself,
1426 in it's own internal structures. When we resume the inferior, it
1427 will eventually take a SIGTRAP when it runs into the breakpoint.
1428 We handle this (in a different place) by restoring the contents of
1429 the breakpointed location (which is only known after it stops),
1430 chasing around to locate the shared libraries that have been
1431 loaded, then resuming.
1433 For SVR4, the debugger interface structure contains a member (r_brk)
1434 which is statically initialized at the time the shared library is
1435 built, to the offset of a function (_r_debug_state) which is guaran-
1436 teed to be called once before mapping in a library, and again when
1437 the mapping is complete. At the time we are examining this member,
1438 it contains only the unrelocated offset of the function, so we have
1439 to do our own relocation. Later, when the dynamic linker actually
1440 runs, it relocates r_brk to be the actual address of _r_debug_state().
1442 The debugger interface structure also contains an enumeration which
1443 is set to either RT_ADD or RT_DELETE prior to changing the mapping,
1444 depending upon whether or not the library is being mapped or unmapped,
1445 and then set to RT_CONSISTENT after the library is mapped/unmapped. */
1448 enable_break (struct svr4_info *info, int from_tty)
1450 struct minimal_symbol *msymbol;
1451 const char * const *bkpt_namep;
1452 asection *interp_sect;
1453 gdb_byte *interp_name;
1456 info->interp_text_sect_low = info->interp_text_sect_high = 0;
1457 info->interp_plt_sect_low = info->interp_plt_sect_high = 0;
1459 /* If we already have a shared library list in the target, and
1460 r_debug contains r_brk, set the breakpoint there - this should
1461 mean r_brk has already been relocated. Assume the dynamic linker
1462 is the object containing r_brk. */
1464 solib_add (NULL, from_tty, ¤t_target, auto_solib_add);
1466 if (info->debug_base && solib_svr4_r_map (info) != 0)
1467 sym_addr = solib_svr4_r_brk (info);
1471 struct obj_section *os;
1473 sym_addr = gdbarch_addr_bits_remove
1474 (target_gdbarch (), gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
1478 /* On at least some versions of Solaris there's a dynamic relocation
1479 on _r_debug.r_brk and SYM_ADDR may not be relocated yet, e.g., if
1480 we get control before the dynamic linker has self-relocated.
1481 Check if SYM_ADDR is in a known section, if it is assume we can
1482 trust its value. This is just a heuristic though, it could go away
1483 or be replaced if it's getting in the way.
1485 On ARM we need to know whether the ISA of rtld_db_dlactivity (or
1486 however it's spelled in your particular system) is ARM or Thumb.
1487 That knowledge is encoded in the address, if it's Thumb the low bit
1488 is 1. However, we've stripped that info above and it's not clear
1489 what all the consequences are of passing a non-addr_bits_remove'd
1490 address to create_solib_event_breakpoint. The call to
1491 find_pc_section verifies we know about the address and have some
1492 hope of computing the right kind of breakpoint to use (via
1493 symbol info). It does mean that GDB needs to be pointed at a
1494 non-stripped version of the dynamic linker in order to obtain
1495 information it already knows about. Sigh. */
1497 os = find_pc_section (sym_addr);
1500 /* Record the relocated start and end address of the dynamic linker
1501 text and plt section for svr4_in_dynsym_resolve_code. */
1503 CORE_ADDR load_addr;
1505 tmp_bfd = os->objfile->obfd;
1506 load_addr = ANOFFSET (os->objfile->section_offsets,
1507 os->objfile->sect_index_text);
1509 interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
1512 info->interp_text_sect_low =
1513 bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
1514 info->interp_text_sect_high =
1515 info->interp_text_sect_low
1516 + bfd_section_size (tmp_bfd, interp_sect);
1518 interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
1521 info->interp_plt_sect_low =
1522 bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
1523 info->interp_plt_sect_high =
1524 info->interp_plt_sect_low
1525 + bfd_section_size (tmp_bfd, interp_sect);
1528 create_solib_event_breakpoint (target_gdbarch (), sym_addr);
1533 /* Find the program interpreter; if not found, warn the user and drop
1534 into the old breakpoint at symbol code. */
1535 interp_name = find_program_interpreter ();
1538 CORE_ADDR load_addr = 0;
1539 int load_addr_found = 0;
1540 int loader_found_in_list = 0;
1542 bfd *tmp_bfd = NULL;
1543 struct target_ops *tmp_bfd_target;
1544 volatile struct gdb_exception ex;
1548 /* Now we need to figure out where the dynamic linker was
1549 loaded so that we can load its symbols and place a breakpoint
1550 in the dynamic linker itself.
1552 This address is stored on the stack. However, I've been unable
1553 to find any magic formula to find it for Solaris (appears to
1554 be trivial on GNU/Linux). Therefore, we have to try an alternate
1555 mechanism to find the dynamic linker's base address. */
1557 TRY_CATCH (ex, RETURN_MASK_ALL)
1559 tmp_bfd = solib_bfd_open (interp_name);
1561 if (tmp_bfd == NULL)
1562 goto bkpt_at_symbol;
1564 /* Now convert the TMP_BFD into a target. That way target, as
1565 well as BFD operations can be used. */
1566 tmp_bfd_target = target_bfd_reopen (tmp_bfd);
1567 /* target_bfd_reopen acquired its own reference, so we can
1568 release ours now. */
1569 gdb_bfd_unref (tmp_bfd);
1571 /* On a running target, we can get the dynamic linker's base
1572 address from the shared library table. */
1573 so = master_so_list ();
1576 if (svr4_same_1 (interp_name, so->so_original_name))
1578 load_addr_found = 1;
1579 loader_found_in_list = 1;
1580 load_addr = lm_addr_check (so, tmp_bfd);
1586 /* If we were not able to find the base address of the loader
1587 from our so_list, then try using the AT_BASE auxilliary entry. */
1588 if (!load_addr_found)
1589 if (target_auxv_search (¤t_target, AT_BASE, &load_addr) > 0)
1591 int addr_bit = gdbarch_addr_bit (target_gdbarch ());
1593 /* Ensure LOAD_ADDR has proper sign in its possible upper bits so
1594 that `+ load_addr' will overflow CORE_ADDR width not creating
1595 invalid addresses like 0x101234567 for 32bit inferiors on 64bit
1598 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
1600 CORE_ADDR space_size = (CORE_ADDR) 1 << addr_bit;
1601 CORE_ADDR tmp_entry_point = exec_entry_point (tmp_bfd,
1604 gdb_assert (load_addr < space_size);
1606 /* TMP_ENTRY_POINT exceeding SPACE_SIZE would be for prelinked
1607 64bit ld.so with 32bit executable, it should not happen. */
1609 if (tmp_entry_point < space_size
1610 && tmp_entry_point + load_addr >= space_size)
1611 load_addr -= space_size;
1614 load_addr_found = 1;
1617 /* Otherwise we find the dynamic linker's base address by examining
1618 the current pc (which should point at the entry point for the
1619 dynamic linker) and subtracting the offset of the entry point.
1621 This is more fragile than the previous approaches, but is a good
1622 fallback method because it has actually been working well in
1624 if (!load_addr_found)
1626 struct regcache *regcache
1627 = get_thread_arch_regcache (inferior_ptid, target_gdbarch ());
1629 load_addr = (regcache_read_pc (regcache)
1630 - exec_entry_point (tmp_bfd, tmp_bfd_target));
1633 if (!loader_found_in_list)
1635 info->debug_loader_name = xstrdup (interp_name);
1636 info->debug_loader_offset_p = 1;
1637 info->debug_loader_offset = load_addr;
1638 solib_add (NULL, from_tty, ¤t_target, auto_solib_add);
1641 /* Record the relocated start and end address of the dynamic linker
1642 text and plt section for svr4_in_dynsym_resolve_code. */
1643 interp_sect = bfd_get_section_by_name (tmp_bfd, ".text");
1646 info->interp_text_sect_low =
1647 bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
1648 info->interp_text_sect_high =
1649 info->interp_text_sect_low
1650 + bfd_section_size (tmp_bfd, interp_sect);
1652 interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt");
1655 info->interp_plt_sect_low =
1656 bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
1657 info->interp_plt_sect_high =
1658 info->interp_plt_sect_low
1659 + bfd_section_size (tmp_bfd, interp_sect);
1662 /* Now try to set a breakpoint in the dynamic linker. */
1663 for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
1665 sym_addr = gdb_bfd_lookup_symbol (tmp_bfd, cmp_name_and_sec_flags,
1666 (void *) *bkpt_namep);
1672 /* Convert 'sym_addr' from a function pointer to an address.
1673 Because we pass tmp_bfd_target instead of the current
1674 target, this will always produce an unrelocated value. */
1675 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
1679 /* We're done with both the temporary bfd and target. Closing
1680 the target closes the underlying bfd, because it holds the
1681 only remaining reference. */
1682 target_close (tmp_bfd_target, 0);
1686 create_solib_event_breakpoint (target_gdbarch (), load_addr + sym_addr);
1687 xfree (interp_name);
1691 /* For whatever reason we couldn't set a breakpoint in the dynamic
1692 linker. Warn and drop into the old code. */
1694 xfree (interp_name);
1695 warning (_("Unable to find dynamic linker breakpoint function.\n"
1696 "GDB will be unable to debug shared library initializers\n"
1697 "and track explicitly loaded dynamic code."));
1700 /* Scan through the lists of symbols, trying to look up the symbol and
1701 set a breakpoint there. Terminate loop when we/if we succeed. */
1703 for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
1705 msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
1706 if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
1708 sym_addr = SYMBOL_VALUE_ADDRESS (msymbol);
1709 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
1712 create_solib_event_breakpoint (target_gdbarch (), sym_addr);
1717 if (interp_name != NULL && !current_inferior ()->attach_flag)
1719 for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
1721 msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
1722 if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
1724 sym_addr = SYMBOL_VALUE_ADDRESS (msymbol);
1725 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
1728 create_solib_event_breakpoint (target_gdbarch (), sym_addr);
1736 /* Implement the "special_symbol_handling" target_so_ops method. */
1739 svr4_special_symbol_handling (void)
1741 /* Nothing to do. */
1744 /* Read the ELF program headers from ABFD. Return the contents and
1745 set *PHDRS_SIZE to the size of the program headers. */
1748 read_program_headers_from_bfd (bfd *abfd, int *phdrs_size)
1750 Elf_Internal_Ehdr *ehdr;
1753 ehdr = elf_elfheader (abfd);
1755 *phdrs_size = ehdr->e_phnum * ehdr->e_phentsize;
1756 if (*phdrs_size == 0)
1759 buf = xmalloc (*phdrs_size);
1760 if (bfd_seek (abfd, ehdr->e_phoff, SEEK_SET) != 0
1761 || bfd_bread (buf, *phdrs_size, abfd) != *phdrs_size)
1770 /* Return 1 and fill *DISPLACEMENTP with detected PIE offset of inferior
1771 exec_bfd. Otherwise return 0.
1773 We relocate all of the sections by the same amount. This
1774 behavior is mandated by recent editions of the System V ABI.
1775 According to the System V Application Binary Interface,
1776 Edition 4.1, page 5-5:
1778 ... Though the system chooses virtual addresses for
1779 individual processes, it maintains the segments' relative
1780 positions. Because position-independent code uses relative
1781 addressesing between segments, the difference between
1782 virtual addresses in memory must match the difference
1783 between virtual addresses in the file. The difference
1784 between the virtual address of any segment in memory and
1785 the corresponding virtual address in the file is thus a
1786 single constant value for any one executable or shared
1787 object in a given process. This difference is the base
1788 address. One use of the base address is to relocate the
1789 memory image of the program during dynamic linking.
1791 The same language also appears in Edition 4.0 of the System V
1792 ABI and is left unspecified in some of the earlier editions.
1794 Decide if the objfile needs to be relocated. As indicated above, we will
1795 only be here when execution is stopped. But during attachment PC can be at
1796 arbitrary address therefore regcache_read_pc can be misleading (contrary to
1797 the auxv AT_ENTRY value). Moreover for executable with interpreter section
1798 regcache_read_pc would point to the interpreter and not the main executable.
1800 So, to summarize, relocations are necessary when the start address obtained
1801 from the executable is different from the address in auxv AT_ENTRY entry.
1803 [ The astute reader will note that we also test to make sure that
1804 the executable in question has the DYNAMIC flag set. It is my
1805 opinion that this test is unnecessary (undesirable even). It
1806 was added to avoid inadvertent relocation of an executable
1807 whose e_type member in the ELF header is not ET_DYN. There may
1808 be a time in the future when it is desirable to do relocations
1809 on other types of files as well in which case this condition
1810 should either be removed or modified to accomodate the new file
1811 type. - Kevin, Nov 2000. ] */
1814 svr4_exec_displacement (CORE_ADDR *displacementp)
1816 /* ENTRY_POINT is a possible function descriptor - before
1817 a call to gdbarch_convert_from_func_ptr_addr. */
1818 CORE_ADDR entry_point, displacement;
1820 if (exec_bfd == NULL)
1823 /* Therefore for ELF it is ET_EXEC and not ET_DYN. Both shared libraries
1824 being executed themselves and PIE (Position Independent Executable)
1825 executables are ET_DYN. */
1827 if ((bfd_get_file_flags (exec_bfd) & DYNAMIC) == 0)
1830 if (target_auxv_search (¤t_target, AT_ENTRY, &entry_point) <= 0)
1833 displacement = entry_point - bfd_get_start_address (exec_bfd);
1835 /* Verify the DISPLACEMENT candidate complies with the required page
1836 alignment. It is cheaper than the program headers comparison below. */
1838 if (bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
1840 const struct elf_backend_data *elf = get_elf_backend_data (exec_bfd);
1842 /* p_align of PT_LOAD segments does not specify any alignment but
1843 only congruency of addresses:
1844 p_offset % p_align == p_vaddr % p_align
1845 Kernel is free to load the executable with lower alignment. */
1847 if ((displacement & (elf->minpagesize - 1)) != 0)
1851 /* Verify that the auxilliary vector describes the same file as exec_bfd, by
1852 comparing their program headers. If the program headers in the auxilliary
1853 vector do not match the program headers in the executable, then we are
1854 looking at a different file than the one used by the kernel - for
1855 instance, "gdb program" connected to "gdbserver :PORT ld.so program". */
1857 if (bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour)
1859 /* Be optimistic and clear OK only if GDB was able to verify the headers
1860 really do not match. */
1861 int phdrs_size, phdrs2_size, ok = 1;
1862 gdb_byte *buf, *buf2;
1865 buf = read_program_header (-1, &phdrs_size, &arch_size);
1866 buf2 = read_program_headers_from_bfd (exec_bfd, &phdrs2_size);
1867 if (buf != NULL && buf2 != NULL)
1869 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
1871 /* We are dealing with three different addresses. EXEC_BFD
1872 represents current address in on-disk file. target memory content
1873 may be different from EXEC_BFD as the file may have been prelinked
1874 to a different address after the executable has been loaded.
1875 Moreover the address of placement in target memory can be
1876 different from what the program headers in target memory say -
1877 this is the goal of PIE.
1879 Detected DISPLACEMENT covers both the offsets of PIE placement and
1880 possible new prelink performed after start of the program. Here
1881 relocate BUF and BUF2 just by the EXEC_BFD vs. target memory
1882 content offset for the verification purpose. */
1884 if (phdrs_size != phdrs2_size
1885 || bfd_get_arch_size (exec_bfd) != arch_size)
1887 else if (arch_size == 32
1888 && phdrs_size >= sizeof (Elf32_External_Phdr)
1889 && phdrs_size % sizeof (Elf32_External_Phdr) == 0)
1891 Elf_Internal_Ehdr *ehdr2 = elf_tdata (exec_bfd)->elf_header;
1892 Elf_Internal_Phdr *phdr2 = elf_tdata (exec_bfd)->phdr;
1893 CORE_ADDR displacement = 0;
1896 /* DISPLACEMENT could be found more easily by the difference of
1897 ehdr2->e_entry. But we haven't read the ehdr yet, and we
1898 already have enough information to compute that displacement
1899 with what we've read. */
1901 for (i = 0; i < ehdr2->e_phnum; i++)
1902 if (phdr2[i].p_type == PT_LOAD)
1904 Elf32_External_Phdr *phdrp;
1905 gdb_byte *buf_vaddr_p, *buf_paddr_p;
1906 CORE_ADDR vaddr, paddr;
1907 CORE_ADDR displacement_vaddr = 0;
1908 CORE_ADDR displacement_paddr = 0;
1910 phdrp = &((Elf32_External_Phdr *) buf)[i];
1911 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
1912 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
1914 vaddr = extract_unsigned_integer (buf_vaddr_p, 4,
1916 displacement_vaddr = vaddr - phdr2[i].p_vaddr;
1918 paddr = extract_unsigned_integer (buf_paddr_p, 4,
1920 displacement_paddr = paddr - phdr2[i].p_paddr;
1922 if (displacement_vaddr == displacement_paddr)
1923 displacement = displacement_vaddr;
1928 /* Now compare BUF and BUF2 with optional DISPLACEMENT. */
1930 for (i = 0; i < phdrs_size / sizeof (Elf32_External_Phdr); i++)
1932 Elf32_External_Phdr *phdrp;
1933 Elf32_External_Phdr *phdr2p;
1934 gdb_byte *buf_vaddr_p, *buf_paddr_p;
1935 CORE_ADDR vaddr, paddr;
1936 asection *plt2_asect;
1938 phdrp = &((Elf32_External_Phdr *) buf)[i];
1939 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
1940 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
1941 phdr2p = &((Elf32_External_Phdr *) buf2)[i];
1943 /* PT_GNU_STACK is an exception by being never relocated by
1944 prelink as its addresses are always zero. */
1946 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
1949 /* Check also other adjustment combinations - PR 11786. */
1951 vaddr = extract_unsigned_integer (buf_vaddr_p, 4,
1953 vaddr -= displacement;
1954 store_unsigned_integer (buf_vaddr_p, 4, byte_order, vaddr);
1956 paddr = extract_unsigned_integer (buf_paddr_p, 4,
1958 paddr -= displacement;
1959 store_unsigned_integer (buf_paddr_p, 4, byte_order, paddr);
1961 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
1964 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
1965 plt2_asect = bfd_get_section_by_name (exec_bfd, ".plt");
1969 gdb_byte *buf_filesz_p = (gdb_byte *) &phdrp->p_filesz;
1972 content2 = (bfd_get_section_flags (exec_bfd, plt2_asect)
1973 & SEC_HAS_CONTENTS) != 0;
1975 filesz = extract_unsigned_integer (buf_filesz_p, 4,
1978 /* PLT2_ASECT is from on-disk file (exec_bfd) while
1979 FILESZ is from the in-memory image. */
1981 filesz += bfd_get_section_size (plt2_asect);
1983 filesz -= bfd_get_section_size (plt2_asect);
1985 store_unsigned_integer (buf_filesz_p, 4, byte_order,
1988 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
1996 else if (arch_size == 64
1997 && phdrs_size >= sizeof (Elf64_External_Phdr)
1998 && phdrs_size % sizeof (Elf64_External_Phdr) == 0)
2000 Elf_Internal_Ehdr *ehdr2 = elf_tdata (exec_bfd)->elf_header;
2001 Elf_Internal_Phdr *phdr2 = elf_tdata (exec_bfd)->phdr;
2002 CORE_ADDR displacement = 0;
2005 /* DISPLACEMENT could be found more easily by the difference of
2006 ehdr2->e_entry. But we haven't read the ehdr yet, and we
2007 already have enough information to compute that displacement
2008 with what we've read. */
2010 for (i = 0; i < ehdr2->e_phnum; i++)
2011 if (phdr2[i].p_type == PT_LOAD)
2013 Elf64_External_Phdr *phdrp;
2014 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2015 CORE_ADDR vaddr, paddr;
2016 CORE_ADDR displacement_vaddr = 0;
2017 CORE_ADDR displacement_paddr = 0;
2019 phdrp = &((Elf64_External_Phdr *) buf)[i];
2020 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2021 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2023 vaddr = extract_unsigned_integer (buf_vaddr_p, 8,
2025 displacement_vaddr = vaddr - phdr2[i].p_vaddr;
2027 paddr = extract_unsigned_integer (buf_paddr_p, 8,
2029 displacement_paddr = paddr - phdr2[i].p_paddr;
2031 if (displacement_vaddr == displacement_paddr)
2032 displacement = displacement_vaddr;
2037 /* Now compare BUF and BUF2 with optional DISPLACEMENT. */
2039 for (i = 0; i < phdrs_size / sizeof (Elf64_External_Phdr); i++)
2041 Elf64_External_Phdr *phdrp;
2042 Elf64_External_Phdr *phdr2p;
2043 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2044 CORE_ADDR vaddr, paddr;
2045 asection *plt2_asect;
2047 phdrp = &((Elf64_External_Phdr *) buf)[i];
2048 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2049 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2050 phdr2p = &((Elf64_External_Phdr *) buf2)[i];
2052 /* PT_GNU_STACK is an exception by being never relocated by
2053 prelink as its addresses are always zero. */
2055 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2058 /* Check also other adjustment combinations - PR 11786. */
2060 vaddr = extract_unsigned_integer (buf_vaddr_p, 8,
2062 vaddr -= displacement;
2063 store_unsigned_integer (buf_vaddr_p, 8, byte_order, vaddr);
2065 paddr = extract_unsigned_integer (buf_paddr_p, 8,
2067 paddr -= displacement;
2068 store_unsigned_integer (buf_paddr_p, 8, byte_order, paddr);
2070 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2073 /* prelink can convert .plt SHT_NOBITS to SHT_PROGBITS. */
2074 plt2_asect = bfd_get_section_by_name (exec_bfd, ".plt");
2078 gdb_byte *buf_filesz_p = (gdb_byte *) &phdrp->p_filesz;
2081 content2 = (bfd_get_section_flags (exec_bfd, plt2_asect)
2082 & SEC_HAS_CONTENTS) != 0;
2084 filesz = extract_unsigned_integer (buf_filesz_p, 8,
2087 /* PLT2_ASECT is from on-disk file (exec_bfd) while
2088 FILESZ is from the in-memory image. */
2090 filesz += bfd_get_section_size (plt2_asect);
2092 filesz -= bfd_get_section_size (plt2_asect);
2094 store_unsigned_integer (buf_filesz_p, 8, byte_order,
2097 if (memcmp (phdrp, phdr2p, sizeof (*phdrp)) == 0)
2118 /* It can be printed repeatedly as there is no easy way to check
2119 the executable symbols/file has been already relocated to
2122 printf_unfiltered (_("Using PIE (Position Independent Executable) "
2123 "displacement %s for \"%s\".\n"),
2124 paddress (target_gdbarch (), displacement),
2125 bfd_get_filename (exec_bfd));
2128 *displacementp = displacement;
2132 /* Relocate the main executable. This function should be called upon
2133 stopping the inferior process at the entry point to the program.
2134 The entry point from BFD is compared to the AT_ENTRY of AUXV and if they are
2135 different, the main executable is relocated by the proper amount. */
2138 svr4_relocate_main_executable (void)
2140 CORE_ADDR displacement;
2142 /* If we are re-running this executable, SYMFILE_OBJFILE->SECTION_OFFSETS
2143 probably contains the offsets computed using the PIE displacement
2144 from the previous run, which of course are irrelevant for this run.
2145 So we need to determine the new PIE displacement and recompute the
2146 section offsets accordingly, even if SYMFILE_OBJFILE->SECTION_OFFSETS
2147 already contains pre-computed offsets.
2149 If we cannot compute the PIE displacement, either:
2151 - The executable is not PIE.
2153 - SYMFILE_OBJFILE does not match the executable started in the target.
2154 This can happen for main executable symbols loaded at the host while
2155 `ld.so --ld-args main-executable' is loaded in the target.
2157 Then we leave the section offsets untouched and use them as is for
2160 - These section offsets were properly reset earlier, and thus
2161 already contain the correct values. This can happen for instance
2162 when reconnecting via the remote protocol to a target that supports
2163 the `qOffsets' packet.
2165 - The section offsets were not reset earlier, and the best we can
2166 hope is that the old offsets are still applicable to the new run. */
2168 if (! svr4_exec_displacement (&displacement))
2171 /* Even DISPLACEMENT 0 is a valid new difference of in-memory vs. in-file
2174 if (symfile_objfile)
2176 struct section_offsets *new_offsets;
2179 new_offsets = alloca (symfile_objfile->num_sections
2180 * sizeof (*new_offsets));
2182 for (i = 0; i < symfile_objfile->num_sections; i++)
2183 new_offsets->offsets[i] = displacement;
2185 objfile_relocate (symfile_objfile, new_offsets);
2191 for (asect = exec_bfd->sections; asect != NULL; asect = asect->next)
2192 exec_set_section_address (bfd_get_filename (exec_bfd), asect->index,
2193 (bfd_section_vma (exec_bfd, asect)
2198 /* Implement the "create_inferior_hook" target_solib_ops method.
2200 For SVR4 executables, this first instruction is either the first
2201 instruction in the dynamic linker (for dynamically linked
2202 executables) or the instruction at "start" for statically linked
2203 executables. For dynamically linked executables, the system
2204 first exec's /lib/libc.so.N, which contains the dynamic linker,
2205 and starts it running. The dynamic linker maps in any needed
2206 shared libraries, maps in the actual user executable, and then
2207 jumps to "start" in the user executable.
2209 We can arrange to cooperate with the dynamic linker to discover the
2210 names of shared libraries that are dynamically linked, and the base
2211 addresses to which they are linked.
2213 This function is responsible for discovering those names and
2214 addresses, and saving sufficient information about them to allow
2215 their symbols to be read at a later time.
2219 Between enable_break() and disable_break(), this code does not
2220 properly handle hitting breakpoints which the user might have
2221 set in the startup code or in the dynamic linker itself. Proper
2222 handling will probably have to wait until the implementation is
2223 changed to use the "breakpoint handler function" method.
2225 Also, what if child has exit()ed? Must exit loop somehow. */
2228 svr4_solib_create_inferior_hook (int from_tty)
2230 #if defined(_SCO_DS)
2231 struct inferior *inf;
2232 struct thread_info *tp;
2233 #endif /* defined(_SCO_DS) */
2234 struct svr4_info *info;
2236 info = get_svr4_info ();
2238 /* Relocate the main executable if necessary. */
2239 svr4_relocate_main_executable ();
2241 /* No point setting a breakpoint in the dynamic linker if we can't
2242 hit it (e.g., a core file, or a trace file). */
2243 if (!target_has_execution)
2246 if (!svr4_have_link_map_offsets ())
2249 if (!enable_break (info, from_tty))
2252 #if defined(_SCO_DS)
2253 /* SCO needs the loop below, other systems should be using the
2254 special shared library breakpoints and the shared library breakpoint
2257 Now run the target. It will eventually hit the breakpoint, at
2258 which point all of the libraries will have been mapped in and we
2259 can go groveling around in the dynamic linker structures to find
2260 out what we need to know about them. */
2262 inf = current_inferior ();
2263 tp = inferior_thread ();
2265 clear_proceed_status ();
2266 inf->control.stop_soon = STOP_QUIETLY;
2267 tp->suspend.stop_signal = GDB_SIGNAL_0;
2270 target_resume (pid_to_ptid (-1), 0, tp->suspend.stop_signal);
2271 wait_for_inferior ();
2273 while (tp->suspend.stop_signal != GDB_SIGNAL_TRAP);
2274 inf->control.stop_soon = NO_STOP_QUIETLY;
2275 #endif /* defined(_SCO_DS) */
2279 svr4_clear_solib (void)
2281 struct svr4_info *info;
2283 info = get_svr4_info ();
2284 info->debug_base = 0;
2285 info->debug_loader_offset_p = 0;
2286 info->debug_loader_offset = 0;
2287 xfree (info->debug_loader_name);
2288 info->debug_loader_name = NULL;
2291 /* Clear any bits of ADDR that wouldn't fit in a target-format
2292 data pointer. "Data pointer" here refers to whatever sort of
2293 address the dynamic linker uses to manage its sections. At the
2294 moment, we don't support shared libraries on any processors where
2295 code and data pointers are different sizes.
2297 This isn't really the right solution. What we really need here is
2298 a way to do arithmetic on CORE_ADDR values that respects the
2299 natural pointer/address correspondence. (For example, on the MIPS,
2300 converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
2301 sign-extend the value. There, simply truncating the bits above
2302 gdbarch_ptr_bit, as we do below, is no good.) This should probably
2303 be a new gdbarch method or something. */
2305 svr4_truncate_ptr (CORE_ADDR addr)
2307 if (gdbarch_ptr_bit (target_gdbarch ()) == sizeof (CORE_ADDR) * 8)
2308 /* We don't need to truncate anything, and the bit twiddling below
2309 will fail due to overflow problems. */
2312 return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (target_gdbarch ())) - 1);
2317 svr4_relocate_section_addresses (struct so_list *so,
2318 struct target_section *sec)
2320 sec->addr = svr4_truncate_ptr (sec->addr + lm_addr_check (so,
2322 sec->endaddr = svr4_truncate_ptr (sec->endaddr + lm_addr_check (so,
2327 /* Architecture-specific operations. */
2329 /* Per-architecture data key. */
2330 static struct gdbarch_data *solib_svr4_data;
2332 struct solib_svr4_ops
2334 /* Return a description of the layout of `struct link_map'. */
2335 struct link_map_offsets *(*fetch_link_map_offsets)(void);
2338 /* Return a default for the architecture-specific operations. */
2341 solib_svr4_init (struct obstack *obstack)
2343 struct solib_svr4_ops *ops;
2345 ops = OBSTACK_ZALLOC (obstack, struct solib_svr4_ops);
2346 ops->fetch_link_map_offsets = NULL;
2350 /* Set the architecture-specific `struct link_map_offsets' fetcher for
2351 GDBARCH to FLMO. Also, install SVR4 solib_ops into GDBARCH. */
2354 set_solib_svr4_fetch_link_map_offsets (struct gdbarch *gdbarch,
2355 struct link_map_offsets *(*flmo) (void))
2357 struct solib_svr4_ops *ops = gdbarch_data (gdbarch, solib_svr4_data);
2359 ops->fetch_link_map_offsets = flmo;
2361 set_solib_ops (gdbarch, &svr4_so_ops);
2364 /* Fetch a link_map_offsets structure using the architecture-specific
2365 `struct link_map_offsets' fetcher. */
2367 static struct link_map_offsets *
2368 svr4_fetch_link_map_offsets (void)
2370 struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch (), solib_svr4_data);
2372 gdb_assert (ops->fetch_link_map_offsets);
2373 return ops->fetch_link_map_offsets ();
2376 /* Return 1 if a link map offset fetcher has been defined, 0 otherwise. */
2379 svr4_have_link_map_offsets (void)
2381 struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch (), solib_svr4_data);
2383 return (ops->fetch_link_map_offsets != NULL);
2387 /* Most OS'es that have SVR4-style ELF dynamic libraries define a
2388 `struct r_debug' and a `struct link_map' that are binary compatible
2389 with the origional SVR4 implementation. */
2391 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
2392 for an ILP32 SVR4 system. */
2394 struct link_map_offsets *
2395 svr4_ilp32_fetch_link_map_offsets (void)
2397 static struct link_map_offsets lmo;
2398 static struct link_map_offsets *lmp = NULL;
2404 lmo.r_version_offset = 0;
2405 lmo.r_version_size = 4;
2406 lmo.r_map_offset = 4;
2407 lmo.r_brk_offset = 8;
2408 lmo.r_ldsomap_offset = 20;
2410 /* Everything we need is in the first 20 bytes. */
2411 lmo.link_map_size = 20;
2412 lmo.l_addr_offset = 0;
2413 lmo.l_name_offset = 4;
2414 lmo.l_ld_offset = 8;
2415 lmo.l_next_offset = 12;
2416 lmo.l_prev_offset = 16;
2422 /* Fetch (and possibly build) an appropriate `struct link_map_offsets'
2423 for an LP64 SVR4 system. */
2425 struct link_map_offsets *
2426 svr4_lp64_fetch_link_map_offsets (void)
2428 static struct link_map_offsets lmo;
2429 static struct link_map_offsets *lmp = NULL;
2435 lmo.r_version_offset = 0;
2436 lmo.r_version_size = 4;
2437 lmo.r_map_offset = 8;
2438 lmo.r_brk_offset = 16;
2439 lmo.r_ldsomap_offset = 40;
2441 /* Everything we need is in the first 40 bytes. */
2442 lmo.link_map_size = 40;
2443 lmo.l_addr_offset = 0;
2444 lmo.l_name_offset = 8;
2445 lmo.l_ld_offset = 16;
2446 lmo.l_next_offset = 24;
2447 lmo.l_prev_offset = 32;
2454 struct target_so_ops svr4_so_ops;
2456 /* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a
2457 different rule for symbol lookup. The lookup begins here in the DSO, not in
2458 the main executable. */
2460 static struct symbol *
2461 elf_lookup_lib_symbol (const struct objfile *objfile,
2463 const domain_enum domain)
2467 if (objfile == symfile_objfile)
2471 /* OBJFILE should have been passed as the non-debug one. */
2472 gdb_assert (objfile->separate_debug_objfile_backlink == NULL);
2474 abfd = objfile->obfd;
2477 if (abfd == NULL || scan_dyntag (DT_SYMBOLIC, abfd, NULL) != 1)
2480 return lookup_global_symbol_from_objfile (objfile, name, domain);
2483 extern initialize_file_ftype _initialize_svr4_solib; /* -Wmissing-prototypes */
2486 _initialize_svr4_solib (void)
2488 solib_svr4_data = gdbarch_data_register_pre_init (solib_svr4_init);
2489 solib_svr4_pspace_data
2490 = register_program_space_data_with_cleanup (NULL, svr4_pspace_data_cleanup);
2492 svr4_so_ops.relocate_section_addresses = svr4_relocate_section_addresses;
2493 svr4_so_ops.free_so = svr4_free_so;
2494 svr4_so_ops.clear_solib = svr4_clear_solib;
2495 svr4_so_ops.solib_create_inferior_hook = svr4_solib_create_inferior_hook;
2496 svr4_so_ops.special_symbol_handling = svr4_special_symbol_handling;
2497 svr4_so_ops.current_sos = svr4_current_sos;
2498 svr4_so_ops.open_symbol_file_object = open_symbol_file_object;
2499 svr4_so_ops.in_dynsym_resolve_code = svr4_in_dynsym_resolve_code;
2500 svr4_so_ops.bfd_open = solib_bfd_open;
2501 svr4_so_ops.lookup_lib_global_symbol = elf_lookup_lib_symbol;
2502 svr4_so_ops.same = svr4_same;
2503 svr4_so_ops.keep_data_in_core = svr4_keep_data_in_core;