22#include "elf/external.h"
23#include "elf/common.h"
74 "__dl_rtld_db_dlactivity",
141#define NUM_PROBES ARRAY_SIZE (probe_info)
147svr4_same_1 (
const char *gdb_so_name,
const char *inferior_so_name)
149 if (strcmp (gdb_so_name, inferior_so_name) == 0)
158 if (strcmp (gdb_so_name,
"/usr/lib/ld.so.1") == 0
159 && strcmp (inferior_so_name,
"/lib/ld.so.1") == 0)
164 if (strcmp (gdb_so_name,
"/usr/lib/amd64/ld.so.1") == 0
165 && strcmp (inferior_so_name,
"/lib/amd64/ld.so.1") == 0)
168 if (strcmp (gdb_so_name,
"/usr/lib/sparcv9/ld.so.1") == 0
169 && strcmp (inferior_so_name,
"/lib/sparcv9/ld.so.1") == 0)
190static std::unique_ptr<lm_info_svr4>
194 std::unique_ptr<lm_info_svr4> lm_info;
199 warning (_(
"Error reading shared library list entry at %s"),
237 struct bfd_section *dyninfo_sect;
238 CORE_ADDR l_addr, l_dynaddr, dynaddr;
245 l_dynaddr = li->
l_ld;
247 dyninfo_sect = bfd_get_section_by_name (abfd,
".dynamic");
248 if (dyninfo_sect == NULL)
251 dynaddr = bfd_section_vma (dyninfo_sect);
253 if (dynaddr + l_addr != l_dynaddr)
255 CORE_ADDR align = 0x1000;
256 CORE_ADDR minpagesize = align;
258 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
260 Elf_Internal_Ehdr *ehdr = elf_tdata (abfd)->elf_header;
261 Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
266 for (i = 0; i < ehdr->e_phnum; i++)
267 if (phdr[i].p_type == PT_LOAD && phdr[i].p_align > align)
268 align = phdr[i].p_align;
270 minpagesize = get_elf_backend_data (abfd)->minpagesize;
299 l_addr = l_dynaddr - dynaddr;
301 if ((l_addr & (minpagesize - 1)) == 0
302 && (l_addr & align) == ((l_dynaddr - dynaddr) & align))
305 gdb_printf (_(
"Using PIC (Position Independent Code) "
306 "prelink displacement %s for \"%s\".\n"),
321 warning (_(
".dynamic section for \"%s\" "
322 "is not at the expected address "
323 "(wrong library or version mismatch?)"), so->
so_name);
398 return (debug_base == info->debug_base);
406 info->probes_table.reset (
nullptr);
414 for (
const std::pair<CORE_ADDR, so_list *> tuple
418 info->solib_lists.clear ();
455static gdb::optional<gdb::byte_vector>
459 CORE_ADDR at_phdr, at_phent, at_phnum, pt_phdr = 0;
460 int arch_size, sect_size;
471 if (!at_phdr || !at_phnum)
475 if (at_phent ==
sizeof (Elf32_External_Phdr))
477 else if (at_phent ==
sizeof (Elf64_External_Phdr))
486 sect_size = at_phent * at_phnum;
488 else if (arch_size == 32)
490 Elf32_External_Phdr phdr;
494 for (i = 0; i < at_phnum; i++)
499 (gdb_byte *)&phdr,
sizeof (phdr)))
505 if (p_type == PT_PHDR)
527 Elf64_External_Phdr phdr;
531 for (i = 0; i < at_phnum; i++)
536 (gdb_byte *)&phdr,
sizeof (phdr)))
542 if (p_type == PT_PHDR)
570 sect_addr = sect_addr + (at_phdr - pt_phdr);
574 gdb::byte_vector buf (sect_size);
579 *p_arch_size = arch_size;
581 *base_addr = sect_addr;
588static gdb::optional<gdb::byte_vector>
594 == bfd_target_elf_flavour))
596 struct bfd_section *interp_sect;
600 if (interp_sect != NULL)
602 int sect_size = bfd_section_size (interp_sect);
604 gdb::byte_vector buf (sect_size);
607 interp_sect, buf.data (), 0, sect_size);
633 gdb::optional<gdb::byte_vector> ph_data
639 step = (arch_size == 32) ?
sizeof (Elf32_External_Dyn)
640 :
sizeof (Elf64_External_Dyn);
641 for (gdb_byte *buf = ph_data->data (), *bufend = buf + ph_data->size ();
642 buf < bufend; buf += step)
646 Elf32_External_Dyn *dynp = (Elf32_External_Dyn *) buf;
655 Elf64_External_Dyn *dynp = (Elf64_External_Dyn *) buf;
662 if (current_dyntag == DT_NULL)
665 if (current_dyntag == desired_dyntag)
671 *ptr_addr = base_addr + buf - ph_data->data ();
696 CORE_ADDR dyn_ptr, dyn_ptr_addr;
711 int pbuf_size = ptr_type->
length ();
713 pbuf = (gdb_byte *) alloca (pbuf_size);
726 &dyn_ptr, &dyn_ptr_addr)
731 int pbuf_size = ptr_type->
length ();
733 pbuf = (gdb_byte *) alloca (pbuf_size);
751 if (msymbol.
minsym != NULL)
778 catch (
const gdb_exception_error &ex)
817 catch (
const gdb_exception_error &ex)
822 if (version < 2 || lmo->r_ldsomap_offset == -1)
845 catch (
const gdb_exception_error &ex)
851 if (version < 2 || lmo->r_next_offset == -1)
875 if (info->debug_base == 0)
882 std::unique_ptr<lm_info_svr4> li =
lm_info_read (ldsomap);
883 name_lm = li != NULL ? li->l_name : 0;
885 return (name_lm >= vaddr && name_lm < vaddr +
size);
893 CORE_ADDR lm, l_name;
896 int l_name_size = ptr_type->
length ();
897 gdb::byte_vector l_name_buf (l_name_size);
899 symfile_add_flags add_flags = 0;
905 if (!
query (_(
"Attempt to reload symbols from process? ")))
910 if (info->debug_base == 0)
928 gdb::unique_xmalloc_ptr<char> filename
931 if (filename ==
nullptr)
933 warning (_(
"failed to read exec filename from attached file"));
1018 newobj = XNEW (
struct so_list);
1019 memcpy (newobj, src,
sizeof (
struct so_list));
1024 newobj->
next = NULL;
1026 link = &newobj->
next;
1042library_list_start_library (
struct gdb_xml_parser *parser,
1058 new_elem = XCNEW (
struct so_list);
1072 if (at_lmid ==
nullptr)
1074 *list->
tailp = new_elem;
1079 ULONGEST lmid = *(ULONGEST *) at_lmid->
value.get ();
1090 if (solist !=
nullptr)
1092 for (; solist->
next !=
nullptr; solist = solist->
next)
1095 pnext = &solist->
next;
1105svr4_library_list_start_list (
struct gdb_xml_parser *parser,
1115 if (strcmp (
version,
"1.0") != 0)
1117 _(
"SVR4 Library list has unsupported version \"%s\""),
1127 list->
tailp = solist;
1146 "library", svr4_library_attributes, NULL,
1148 library_list_start_library, NULL
1162 {
"library-list-svr4", svr4_library_list_attributes, svr4_library_list_children,
1176 auto cleanup = make_scope_exit ([list] ()
1178 for (
const std::pair<CORE_ADDR, so_list *> tuple
1179 : list->solib_lists)
1183 list->
tailp =
nullptr;
1187 svr4_library_list_elements, document, list) == 0)
1214 gdb::optional<gdb::char_vector> svr4_library_document
1218 if (!svr4_library_document)
1221 return svr4_parse_libraries (svr4_library_document->data (), list);
1243 if (!info->debug_loader_offset_p)
1246 newobj = XCNEW (
struct so_list);
1271 struct so_list ***link_ptr_ptr,
int ignore_first)
1273 CORE_ADDR first_l_name = 0;
1276 for (; lm != 0; prev_lm = lm, lm = next_lm)
1281 newobj->lm_info = li;
1287 if (li->
l_prev != prev_lm)
1289 warning (_(
"Corrupted shared library list: %s != %s"),
1300 if (ignore_first && li->
l_prev == 0)
1302 first_l_name = li->
l_name;
1303 info->main_lm_addr = li->
lm_addr;
1308 gdb::unique_xmalloc_ptr<char> buffer
1310 if (buffer ==
nullptr)
1316 if (first_l_name == 0 || li->
l_name != first_l_name)
1317 warning (_(
"Can't read pathname for load map."));
1323 strcpy (newobj->so_original_name, newobj->so_name);
1327 if (! newobj->so_name[0] ||
match_main (newobj->so_name))
1332 **link_ptr_ptr = newobj.release ();
1333 *link_ptr_ptr = &(**link_ptr_ptr)->
next;
1364 if (info->using_xfer)
1367 info->main_lm_addr = library_list.
main_lm;
1381 std::swap (info->solib_lists, library_list.
solib_lists);
1388 if (info->debug_base == 0)
1395 ".dynamic") == NULL)
1396 ignore_first =
false;
1398 ignore_first =
true;
1400 auto cleanup = make_scope_exit ([info] ()
1406 CORE_ADDR debug_base = info->debug_base;
1407 for (; debug_base != 0;
1414 so_list **sos = &info->solib_lists[debug_base];
1431 if (debug_base != 0)
1434 if (info->solib_lists.find (debug_base) == info->solib_lists.end ())
1436 so_list **sos = &info->solib_lists[debug_base];
1453 for (
const std::pair<CORE_ADDR, so_list *> tuple
1454 : info->solib_lists)
1456 so_list *solist = tuple.second;
1459 if (solist ==
nullptr)
1465 gdb_assert (*pnext !=
nullptr);
1469 if (next ==
nullptr)
1472 pnext = &next->
next;
1489 if (info->probes_table !=
nullptr)
1520 && vsyscall_range.
length != 0)
1525 while (*sop != NULL)
1595 if (info->main_lm_addr == 0)
1600 return info->main_lm_addr;
1623 const char *
const *mainp;
1627 if (strcmp (soname, *mainp) == 0)
1642 return ((pc >= info->interp_text_sect_low
1644 || (pc >= info->interp_plt_sect_low
1667 bfd_get_start_address (abfd),
1696 return (hashval_t) pa->
address;
1732 if (info->probes_table !=
nullptr)
1733 htab_traverse_noresize (info->probes_table.get (),
1742 probe *prob, CORE_ADDR address,
1749 if (info->probes_table == NULL)
1755 slot = htab_find_slot (info->probes_table.get (), &lookup, INSERT);
1756 gdb_assert (*slot == HTAB_EMPTY_ENTRY);
1778 slot = htab_find_slot (info->probes_table.get (), &lookup, NO_INSERT);
1793 unsigned probe_argc = 0;
1811 catch (
const gdb_exception_error &ex)
1823 if (probe_argc == 2)
1825 else if (probe_argc < 2)
1860 if (info->solib_lists.find (0) != info->solib_lists.end ())
1864 if (info->solib_lists.find (debug_base) == info->solib_lists.end ())
1865 info->solib_lists[debug_base] =
nullptr;
1867 so_list **psolist = &info->solib_lists[debug_base];
1872 if (solist ==
nullptr)
1887 for (; solist->
next !=
nullptr; solist = solist->
next)
1892 pnext = &solist->
next;
1896 if (info->using_xfer)
1902 xsnprintf (annex,
sizeof (annex),
"lmid=%s;start=%s;prev=%s",
1903 phex_nz (debug_base,
sizeof (debug_base)),
1904 phex_nz (lm,
sizeof (lm)),
1905 phex_nz (prev_lm,
sizeof (prev_lm)));
1918 std::swap (sos, library_list.
solib_lists[debug_base]);
1928 for (
const std::pair<CORE_ADDR, so_list *> tuple
1930 gdb_assert (tuple.second ==
nullptr);
1954 warning (_(
"Probes-based dynamic linker interface failed.\n"
1955 "Reverting to original interface."));
1971 struct value *val = NULL;
1972 CORE_ADDR pc, debug_base, lm = 0;
1976 if (info->probes_table == NULL)
1991 auto cleanup = make_scope_exit ([info] ()
2017 scoped_restore inhibit_updates
2024 catch (
const gdb_exception_error &ex)
2034 if (debug_base == 0)
2041 if (global_debug_base != info->debug_base)
2043 info->debug_base = global_debug_base;
2047 if (info->debug_base == 0)
2054 struct value *link_map_id_val;
2059 catch (
const gdb_exception_error)
2061 link_map_id_val = NULL;
2064 if (link_map_id_val != NULL &&
value_as_long (link_map_id_val) != 0)
2076 catch (
const gdb_exception_error &ex)
2125 if (info == NULL || info->probes_table == NULL)
2164 const std::vector<probe *> *probes,
2171 for (
probe *p : probes[i])
2196 os->objfile->original_name, with_prefix);
2212 xsnprintf (buf,
sizeof (buf),
"rtld_%s",
name);
2220 if (probes[i].empty ())
2249 for (
probe *p : probes[i])
2251 if (!p->can_evaluate_arguments ())
2257 p->get_argument_count (
gdbarch);
2259 catch (
const gdb_exception_error &ex)
2262 warning (_(
"Initializing probes-based dynamic linker interface "
2263 "failed.\nReverting to original interface."));
2339 const char *
const *bkpt_namep;
2340 asection *interp_sect;
2343 info->interp_text_sect_low = info->interp_text_sect_high = 0;
2344 info->interp_plt_sect_low = info->interp_plt_sect_high = 0;
2390 CORE_ADDR load_addr;
2392 tmp_bfd = os->objfile->obfd.get ();
2393 load_addr = os->objfile->text_section_offset ();
2395 interp_sect = bfd_get_section_by_name (tmp_bfd,
".text");
2398 info->interp_text_sect_low
2399 = bfd_section_vma (interp_sect) + load_addr;
2400 info->interp_text_sect_high
2401 = info->interp_text_sect_low + bfd_section_size (interp_sect);
2403 interp_sect = bfd_get_section_by_name (tmp_bfd,
".plt");
2406 info->interp_plt_sect_low
2407 = bfd_section_vma (interp_sect) + load_addr;
2408 info->interp_plt_sect_high
2409 = info->interp_plt_sect_low + bfd_section_size (interp_sect);
2419 gdb::optional<gdb::byte_vector> interp_name_holder
2421 if (interp_name_holder)
2423 const char *interp_name = (
const char *) interp_name_holder->data ();
2424 CORE_ADDR load_addr = 0;
2425 int load_addr_found = 0;
2426 int loader_found_in_list = 0;
2445 catch (
const gdb_exception &ex)
2449 if (tmp_bfd == NULL)
2450 goto bkpt_at_symbol;
2460 if (
svr4_same_1 (interp_name, so->so_original_name))
2462 load_addr_found = 1;
2463 loader_found_in_list = 1;
2471 if (!load_addr_found)
2481 if (addr_bit < (
sizeof (CORE_ADDR) * HOST_CHAR_BIT))
2483 CORE_ADDR space_size = (CORE_ADDR) 1 << addr_bit;
2484 CORE_ADDR tmp_entry_point
2487 gdb_assert (load_addr < space_size);
2492 if (tmp_entry_point < space_size
2493 && tmp_entry_point + load_addr >= space_size)
2494 load_addr -= space_size;
2497 load_addr_found = 1;
2507 if (!load_addr_found)
2515 tmp_bfd_target.get ()));
2518 if (!loader_found_in_list)
2520 info->debug_loader_name = xstrdup (interp_name);
2521 info->debug_loader_offset_p = 1;
2522 info->debug_loader_offset = load_addr;
2528 interp_sect = bfd_get_section_by_name (tmp_bfd.get (),
".text");
2531 info->interp_text_sect_low
2532 = bfd_section_vma (interp_sect) + load_addr;
2533 info->interp_text_sect_high
2534 = info->interp_text_sect_low + bfd_section_size (interp_sect);
2536 interp_sect = bfd_get_section_by_name (tmp_bfd.get (),
".plt");
2539 info->interp_plt_sect_low
2540 = bfd_section_vma (interp_sect) + load_addr;
2541 info->interp_plt_sect_high
2542 = info->interp_plt_sect_low + bfd_section_size (interp_sect);
2551 [=] (
const asymbol *sym)
2553 return (strcmp (sym->name, *bkpt_namep) == 0
2554 && ((sym->section->flags & (SEC_CODE | SEC_DATA))
2567 tmp_bfd_target.get ());
2572 load_addr + sym_addr);
2579 warning (_(
"Unable to find dynamic linker breakpoint function.\n"
2580 "GDB will be unable to debug shared library initializers\n"
2581 "and track explicitly loaded dynamic code."));
2591 if ((msymbol.
minsym != NULL)
2605 for (bkpt_namep =
bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
2608 if ((msymbol.
minsym != NULL)
2626static gdb::optional<gdb::byte_vector>
2629 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
2630 int phdrs_size = ehdr->e_phnum * ehdr->e_phentsize;
2631 if (phdrs_size == 0)
2634 gdb::byte_vector buf (phdrs_size);
2635 if (bfd_seek (abfd, ehdr->e_phoff,
SEEK_SET) != 0
2636 || bfd_read (buf.data (), phdrs_size, abfd) != phdrs_size)
2690 CORE_ADDR entry_point, exec_displacement;
2712 == bfd_target_elf_flavour)
2714 const struct elf_backend_data *elf
2722 if ((exec_displacement & (elf->minpagesize - 1)) != 0)
2733 == bfd_target_elf_flavour)
2739 gdb::optional<gdb::byte_vector> phdrs_target
2741 gdb::optional<gdb::byte_vector> phdrs_binary
2743 if (phdrs_target && phdrs_binary)
2760 if (phdrs_target->size () != phdrs_binary->size ()
2763 else if (arch_size == 32
2764 && phdrs_target->size () >= sizeof (Elf32_External_Phdr)
2765 && phdrs_target->size () % sizeof (Elf32_External_Phdr) == 0)
2767 Elf_Internal_Ehdr *ehdr2
2769 Elf_Internal_Phdr *phdr2
2771 CORE_ADDR displacement = 0;
2779 for (i = 0; i < ehdr2->e_phnum; i++)
2780 if (phdr2[i].p_type == PT_LOAD)
2782 Elf32_External_Phdr *phdrp;
2783 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2784 CORE_ADDR vaddr, paddr;
2785 CORE_ADDR displacement_vaddr = 0;
2786 CORE_ADDR displacement_paddr = 0;
2788 phdrp = &((Elf32_External_Phdr *) phdrs_target->data ())[i];
2789 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2790 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2794 displacement_vaddr = vaddr - phdr2[i].p_vaddr;
2798 displacement_paddr = paddr - phdr2[i].p_paddr;
2800 if (displacement_vaddr == displacement_paddr)
2801 displacement = displacement_vaddr;
2810 i < phdrs_target->size () /
sizeof (Elf32_External_Phdr);
2813 Elf32_External_Phdr *phdrp;
2814 Elf32_External_Phdr *phdr2p;
2815 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2816 CORE_ADDR vaddr, paddr;
2817 asection *plt2_asect;
2819 phdrp = &((Elf32_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 = &((Elf32_External_Phdr *) phdrs_binary->data ())[i];
2827 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
2834 vaddr -= displacement;
2839 paddr -= displacement;
2842 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
2849 if (phdr2[i].p_type == PT_GNU_RELRO
2850 || phdr2[i].p_type == PT_TLS)
2852 Elf32_External_Phdr tmp_phdr = *phdrp;
2853 Elf32_External_Phdr tmp_phdr2 = *phdr2p;
2855 memset (tmp_phdr.p_filesz, 0, 4);
2856 memset (tmp_phdr.p_memsz, 0, 4);
2857 memset (tmp_phdr.p_flags, 0, 4);
2858 memset (tmp_phdr.p_align, 0, 4);
2859 memset (tmp_phdr2.p_filesz, 0, 4);
2860 memset (tmp_phdr2.p_memsz, 0, 4);
2861 memset (tmp_phdr2.p_flags, 0, 4);
2862 memset (tmp_phdr2.p_align, 0, 4);
2864 if (memcmp (&tmp_phdr, &tmp_phdr2,
sizeof (tmp_phdr))
2871 plt2_asect = bfd_get_section_by_name (exec_bfd,
".plt");
2875 gdb_byte *buf_filesz_p = (gdb_byte *) &phdrp->p_filesz;
2878 content2 = (bfd_section_flags (plt2_asect)
2879 & SEC_HAS_CONTENTS) != 0;
2887 filesz += bfd_section_size (plt2_asect);
2889 filesz -= bfd_section_size (plt2_asect);
2894 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
2901 else if (arch_size == 64
2902 && phdrs_target->size () >= sizeof (Elf64_External_Phdr)
2903 && phdrs_target->size () % sizeof (Elf64_External_Phdr) == 0)
2905 Elf_Internal_Ehdr *ehdr2
2907 Elf_Internal_Phdr *phdr2
2909 CORE_ADDR displacement = 0;
2917 for (i = 0; i < ehdr2->e_phnum; i++)
2918 if (phdr2[i].p_type == PT_LOAD)
2920 Elf64_External_Phdr *phdrp;
2921 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2922 CORE_ADDR vaddr, paddr;
2923 CORE_ADDR displacement_vaddr = 0;
2924 CORE_ADDR displacement_paddr = 0;
2926 phdrp = &((Elf64_External_Phdr *) phdrs_target->data ())[i];
2927 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2928 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2932 displacement_vaddr = vaddr - phdr2[i].p_vaddr;
2936 displacement_paddr = paddr - phdr2[i].p_paddr;
2938 if (displacement_vaddr == displacement_paddr)
2939 displacement = displacement_vaddr;
2947 i < phdrs_target->size () /
sizeof (Elf64_External_Phdr);
2950 Elf64_External_Phdr *phdrp;
2951 Elf64_External_Phdr *phdr2p;
2952 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2953 CORE_ADDR vaddr, paddr;
2954 asection *plt2_asect;
2956 phdrp = &((Elf64_External_Phdr *) phdrs_target->data ())[i];
2957 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2958 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2959 phdr2p = &((Elf64_External_Phdr *) phdrs_binary->data ())[i];
2964 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
2971 vaddr -= displacement;
2976 paddr -= displacement;
2979 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
2986 if (phdr2[i].p_type == PT_GNU_RELRO
2987 || phdr2[i].p_type == PT_TLS)
2989 Elf64_External_Phdr tmp_phdr = *phdrp;
2990 Elf64_External_Phdr tmp_phdr2 = *phdr2p;
2992 memset (tmp_phdr.p_filesz, 0, 8);
2993 memset (tmp_phdr.p_memsz, 0, 8);
2994 memset (tmp_phdr.p_flags, 0, 4);
2995 memset (tmp_phdr.p_align, 0, 8);
2996 memset (tmp_phdr2.p_filesz, 0, 8);
2997 memset (tmp_phdr2.p_memsz, 0, 8);
2998 memset (tmp_phdr2.p_flags, 0, 4);
2999 memset (tmp_phdr2.p_align, 0, 8);
3001 if (memcmp (&tmp_phdr, &tmp_phdr2,
sizeof (tmp_phdr))
3013 gdb_byte *buf_filesz_p = (gdb_byte *) &phdrp->p_filesz;
3016 content2 = (bfd_section_flags (plt2_asect)
3017 & SEC_HAS_CONTENTS) != 0;
3026 filesz += bfd_section_size (plt2_asect);
3028 filesz -= bfd_section_size (plt2_asect);
3033 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
3051 gdb_printf (_(
"Using PIE (Position Independent Executable) "
3052 "displacement %s for \"%s\".\n"),
3057 *displacementp = exec_displacement;
3069 CORE_ADDR displacement;
3115 for (asect = exec_bfd->sections; asect != NULL; asect = asect->next)
3117 bfd_section_vma (asect) + displacement);
3172 info->debug_base = 0;
3173 info->debug_loader_offset_p = 0;
3174 info->debug_loader_offset = 0;
3175 xfree (info->debug_loader_name);
3176 info->debug_loader_name = NULL;
3375 if (solib ==
nullptr)
3379 gdb_assert (info !=
nullptr);
3380 for (
const std::pair<CORE_ADDR, so_list *> tuple
3381 : info->solib_lists)
3383 CORE_ADDR debug_base = tuple.first;
3384 so_list *solist = tuple.second;
3386 for (; solist !=
nullptr; solist = solist->
next)
3405 bool checked_current_objfile =
false;
3406 if (current_objfile !=
nullptr)
3416 abfd = current_objfile->
obfd.get ();
3421 checked_current_objfile =
true;
3422 if (cb (current_objfile))
3432 if (debug_base == 0)
3433 debug_base = initial;
3437 if (checked_current_objfile &&
objfile == current_objfile)
3447 if (solib_base == 0)
3448 solib_base = initial;
3451 if (solib_base != debug_base)
static struct @5 attributes[]
void * xcalloc(size_t number, size_t size)
struct gdbarch * target_gdbarch(void)
int target_auxv_search(const gdb::byte_vector &auxv, target_ops *ops, gdbarch *gdbarch, CORE_ADDR match, CORE_ADDR *valp)
target_ops_up target_bfd_reopen(const gdb_bfd_ref_ptr &abfd)
void enable_breakpoint(struct breakpoint *bpt)
struct breakpoint * create_solib_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
void disable_breakpoint(struct breakpoint *bpt)
breakpoint_safe_range all_breakpoints_safe()
virtual struct value * evaluate_argument(unsigned n, frame_info_ptr frame)=0
virtual unsigned get_argument_count(struct gdbarch *gdbarch)=0
CORE_ADDR read_memory_typed_address(CORE_ADDR addr, struct type *type)
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
void exception_print(struct ui_file *file, const struct gdb_exception &e)
void exec_set_section_address(const char *filename, int index, CORE_ADDR address)
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
frame_info_ptr get_current_frame(void)
gdb::ref_ptr< struct bfd, gdb_bfd_ref_policy > gdb_bfd_ref_ptr
int gdbarch_vsyscall_range(struct gdbarch *gdbarch, struct mem_range *range)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
int gdbarch_addr_bit(struct gdbarch *gdbarch)
void set_gdbarch_iterate_over_objfiles_in_search_order(struct gdbarch *gdbarch, gdbarch_iterate_over_objfiles_in_search_order_ftype *iterate_over_objfiles_in_search_order)
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
void set_gdbarch_so_ops(struct gdbarch *gdbarch, const struct target_so_ops *so_ops)
gdb::function_view< bool(objfile *)> iterate_over_objfiles_in_search_order_cb_ftype
enum bfd_endian type_byte_order(const struct type *type)
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
struct inferior * current_inferior(void)
int address_in_mem_range(CORE_ADDR address, const struct mem_range *r)
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
bool in_gnu_ifunc_stub(CORE_ADDR pc)
observable< struct objfile * > free_objfile
static CORE_ADDR lm_addr(struct so_list *so)
scoped_restore_tmpl< int > inhibit_section_map_updates(struct program_space *pspace)
void objfile_relocate(struct objfile *objfile, const section_offsets &new_offsets)
struct obj_section * find_pc_section(CORE_ADDR pc)
static int in_plt_section(CORE_ADDR pc)
std::vector< probe * > find_probes_in_objfile(struct objfile *objfile, const char *provider, const char *name)
struct program_space * current_program_space
CORE_ADDR regcache_read_pc(struct regcache *regcache)
struct regcache * get_thread_arch_regcache(process_stratum_target *target, ptid_t ptid, struct gdbarch *gdbarch)
struct regcache * get_current_regcache(void)
static int enable_break(void)
static CORE_ADDR interp_text_sect_high
static CORE_ADDR interp_plt_sect_high
static struct so_list * svr4_default_sos(svr4_info *info)
static void svr4_create_probe_breakpoints(svr4_info *info, struct gdbarch *gdbarch, const std::vector< probe * > *probes, struct objfile *objfile)
static struct so_list * svr4_current_sos(void)
static so_list * find_solib_for_objfile(struct objfile *objfile)
static int svr4_read_so_list(svr4_info *info, CORE_ADDR lm, CORE_ADDR prev_lm, struct so_list ***link_ptr_ptr, int ignore_first)
static bool svr4_find_and_create_probe_breakpoints(svr4_info *info, struct gdbarch *gdbarch, struct obj_section *os, bool with_prefix)
static bool svr4_update_solib_event_breakpoint(struct breakpoint *b)
static void svr4_create_solib_event_breakpoints(svr4_info *info, struct gdbarch *gdbarch, CORE_ADDR address)
static CORE_ADDR find_debug_base_for_solib(so_list *solib)
void set_solib_svr4_fetch_link_map_offsets(struct gdbarch *gdbarch, struct link_map_offsets *(*flmo)(void))
static CORE_ADDR solib_svr4_r_ldsomap(struct svr4_info *info)
static enum probe_action solib_event_probe_action(struct probe_and_action *pa)
static void svr4_relocate_main_executable(void)
const struct target_so_ops svr4_so_ops
static so_list * svr4_collect_probes_sos(svr4_info *info)
static hashval_t hash_probe_and_action(const void *p)
static void free_solib_lists(svr4_info *info)
static CORE_ADDR elf_locate_base(void)
static struct svr4_info * get_svr4_info(program_space *pspace)
static int svr4_current_sos_via_xfer_libraries(struct svr4_library_list *list, const char *annex)
@ PROBES_INTERFACE_FAILED
static CORE_ADDR solib_svr4_r_map(CORE_ADDR debug_base)
static CORE_ADDR lm_addr_check(const struct so_list *so, bfd *abfd)
static void probes_table_remove_objfile_probes(struct objfile *objfile)
static const registry< gdbarch >::key< struct solib_svr4_ops > solib_svr4_data
static void svr4_iterate_over_objfiles_in_search_order(gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype cb, objfile *current_objfile)
static void svr4_handle_solib_event(void)
int svr4_in_dynsym_resolve_code(CORE_ADDR pc)
static int svr4_exec_displacement(CORE_ADDR *displacementp)
static const registry< program_space >::key< svr4_info > solib_svr4_pspace_data
static gdb::optional< gdb::byte_vector > find_program_interpreter(void)
static void svr4_update_solib_event_breakpoints(void)
static struct so_list * svr4_current_sos_1(svr4_info *info)
static int solist_update_full(struct svr4_info *info)
struct link_map_offsets * svr4_lp64_fetch_link_map_offsets(void)
static int svr4_have_link_map_offsets(void)
static void free_probes_table(struct svr4_info *info)
static void svr4_current_sos_direct(struct svr4_info *info)
static void svr4_relocate_section_addresses(struct so_list *so, struct target_section *sec)
static struct so_list * svr4_copy_library_list(struct so_list *src)
CORE_ADDR svr4_fetch_objfile_link_map(struct objfile *objfile)
static int svr4_keep_data_in_core(CORE_ADDR vaddr, unsigned long size)
static struct solib_svr4_ops * get_ops(struct gdbarch *gdbarch)
static int open_symbol_file_object(int from_tty)
static gdb::optional< gdb::byte_vector > read_program_header(int type, int *p_arch_size, CORE_ADDR *base_addr)
static void svr4_free_so(struct so_list *so)
static void svr4_free_objfile_observer(struct objfile *objfile)
static void svr4_solib_create_inferior_hook(int from_tty)
static void svr4_clear_so(struct so_list *so)
static int scan_dyntag_auxv(const int desired_dyntag, CORE_ADDR *ptr, CORE_ADDR *ptr_addr)
static CORE_ADDR solib_svr4_r_next(CORE_ADDR debug_base)
static const char *const bkpt_names[]
static int probes_table_htab_remove_objfile_probes(void **slot, void *info)
static void disable_probes_interface(svr4_info *info)
static void svr4_free_library_list(so_list *solist)
static bool svr4_is_default_namespace(const svr4_info *info, CORE_ADDR debug_base)
static std::unique_ptr< lm_info_svr4 > lm_info_read(CORE_ADDR lm_addr)
static void svr4_clear_solib(void)
static int has_lm_dynamic_from_link_map(void)
static struct link_map_offsets * svr4_fetch_link_map_offsets(void)
static CORE_ADDR solib_svr4_r_brk(struct svr4_info *info)
static int svr4_same(struct so_list *gdb, struct so_list *inferior)
static const char *const main_name_list[]
static int match_main(const char *)
static CORE_ADDR exec_entry_point(struct bfd *abfd, struct target_ops *targ)
static int svr4_same_1(const char *gdb_so_name, const char *inferior_so_name)
void _initialize_svr4_solib()
static int solist_update_incremental(svr4_info *info, CORE_ADDR debug_base, CORE_ADDR lm)
static gdb::optional< gdb::byte_vector > read_program_headers_from_bfd(bfd *abfd)
static CORE_ADDR svr4_truncate_ptr(CORE_ADDR addr)
static struct probe_and_action * solib_event_probe_at(struct svr4_info *info, CORE_ADDR address)
static int equal_probe_and_action(const void *p1, const void *p2)
static void register_solib_event_probe(svr4_info *info, struct objfile *objfile, probe *prob, CORE_ADDR address, enum probe_action action)
struct link_map_offsets * svr4_ilp32_fetch_link_map_offsets(void)
static const char *const solib_break_names[]
void free_so(struct so_list *so)
void solib_add(const char *pattern, int from_tty, int readsyms)
gdb_bfd_ref_ptr solib_bfd_open(const char *pathname)
CORE_ADDR gdb_bfd_lookup_symbol(bfd *abfd, gdb::function_view< bool(const asymbol *)> match_sym)
int gdb_bfd_scan_elf_dyntag(const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr, CORE_ADDR *ptr_addr)
#define solib_debug_printf(fmt,...)
#define SOLIB_SCOPED_DEBUG_START_END(fmt,...)
std::unique_ptr< so_list, so_deleter > so_list_up
#define SO_NAME_MAX_PATH_SIZE
CORE_ADDR value_address() const
struct minimal_symbol * minsym
bp_location_range locations() const
enum enable_state enable_state
struct type * builtin_data_ptr
gdb::unique_xmalloc_ptr< void > value
CORE_ADDR l_addr_inferior
struct objfile * separate_debug_objfile_backlink
struct program_space * pspace
::section_offsets section_offsets
objfiles_range objfiles()
struct objfile * symfile_object_file
so_list_range solibs() const
char so_name[SO_NAME_MAX_PATH_SIZE]
char so_original_name[SO_NAME_MAX_PATH_SIZE]
struct link_map_offsets *(* fetch_link_map_offsets)(void)
CORE_ADDR debug_loader_offset
int debug_loader_offset_p
std::map< CORE_ADDR, so_list * > solib_lists
CORE_ADDR interp_text_sect_high
CORE_ADDR interp_text_sect_low
CORE_ADDR interp_plt_sect_high
CORE_ADDR interp_plt_sect_low
std::map< CORE_ADDR, so_list * > solib_lists
struct bfd_section * the_bfd_section
void symbol_file_add_main(const char *args, symfile_add_flags add_flags)
std::vector< CORE_ADDR > section_offsets
int target_read_string(CORE_ADDR addr, int len, int width, unsigned int fetchlimit, gdb::unique_xmalloc_ptr< gdb_byte > *buffer, int *bytes_read)
gdb::optional< gdb::char_vector > target_read_stralloc(struct target_ops *ops, enum target_object object, const char *annex)
bool target_has_execution(inferior *inf)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
bool target_augmented_libraries_svr4_read()
@ TARGET_OBJECT_LIBRARIES_SVR4
std::unique_ptr< target_ops, target_ops_deleter > target_ops_up
int query(const char *ctlstr,...)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
void gdb_printf(struct ui_file *stream, const char *format,...)
CORE_ADDR value_as_address(struct value *val)
LONGEST value_as_long(struct value *val)
void void gdb_xml_error(struct gdb_xml_parser *parser, const char *format,...) ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF(2
void void struct gdb_xml_value * xml_find_attribute(std::vector< gdb_xml_value > &attributes, const char *name)
int gdb_xml_parse_quick(const char *name, const char *dtd_name, const struct gdb_xml_element *elements, const char *document, void *user_data)
gdb_xml_attribute_handler gdb_xml_parse_attr_ulongest