22#include "elf/external.h"
23#include "elf/common.h"
75 "__dl_rtld_db_dlactivity",
142#define NUM_PROBES ARRAY_SIZE (probe_info)
148svr4_same_1 (
const char *gdb_so_name,
const char *inferior_so_name)
150 if (strcmp (gdb_so_name, inferior_so_name) == 0)
159 if (strcmp (gdb_so_name,
"/usr/lib/ld.so.1") == 0
160 && strcmp (inferior_so_name,
"/lib/ld.so.1") == 0)
165 if (strcmp (gdb_so_name,
"/usr/lib/amd64/ld.so.1") == 0
166 && strcmp (inferior_so_name,
"/lib/amd64/ld.so.1") == 0)
169 if (strcmp (gdb_so_name,
"/usr/lib/sparcv9/ld.so.1") == 0
170 && strcmp (inferior_so_name,
"/lib/sparcv9/ld.so.1") == 0)
191static std::unique_ptr<lm_info_svr4>
195 std::unique_ptr<lm_info_svr4> lm_info;
200 warning (_(
"Error reading shared library list entry at %s"),
238 struct bfd_section *dyninfo_sect;
239 CORE_ADDR l_addr, l_dynaddr, dynaddr;
246 l_dynaddr = li->
l_ld;
248 dyninfo_sect = bfd_get_section_by_name (abfd,
".dynamic");
249 if (dyninfo_sect == NULL)
252 dynaddr = bfd_section_vma (dyninfo_sect);
254 if (dynaddr + l_addr != l_dynaddr)
256 CORE_ADDR align = 0x1000;
257 CORE_ADDR minpagesize = align;
259 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
261 Elf_Internal_Ehdr *ehdr = elf_tdata (abfd)->elf_header;
262 Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
267 for (i = 0; i < ehdr->e_phnum; i++)
268 if (phdr[i].p_type == PT_LOAD && phdr[i].p_align > align)
269 align = phdr[i].p_align;
271 minpagesize = get_elf_backend_data (abfd)->minpagesize;
300 l_addr = l_dynaddr - dynaddr;
302 if ((l_addr & (minpagesize - 1)) == 0
303 && (l_addr & align) == ((l_dynaddr - dynaddr) & align))
306 gdb_printf (_(
"Using PIC (Position Independent Code) "
307 "prelink displacement %s for \"%s\".\n"),
322 warning (_(
".dynamic section for \"%s\" "
323 "is not at the expected address "
324 "(wrong library or version mismatch?)"), so->
so_name);
399 return (debug_base == info->debug_base);
407 info->probes_table.reset (
nullptr);
415 for (
const std::pair<CORE_ADDR, so_list *> tuple
419 info->solib_lists.clear ();
456static gdb::optional<gdb::byte_vector>
460 CORE_ADDR at_phdr, at_phent, at_phnum, pt_phdr = 0;
461 int arch_size, sect_size;
472 if (!at_phdr || !at_phnum)
476 if (at_phent ==
sizeof (Elf32_External_Phdr))
478 else if (at_phent ==
sizeof (Elf64_External_Phdr))
487 sect_size = at_phent * at_phnum;
489 else if (arch_size == 32)
491 Elf32_External_Phdr phdr;
495 for (i = 0; i < at_phnum; i++)
500 (gdb_byte *)&phdr,
sizeof (phdr)))
506 if (p_type == PT_PHDR)
528 Elf64_External_Phdr phdr;
532 for (i = 0; i < at_phnum; i++)
537 (gdb_byte *)&phdr,
sizeof (phdr)))
543 if (p_type == PT_PHDR)
571 sect_addr = sect_addr + (at_phdr - pt_phdr);
575 gdb::byte_vector buf (sect_size);
580 *p_arch_size = arch_size;
582 *base_addr = sect_addr;
589static gdb::optional<gdb::byte_vector>
595 == bfd_target_elf_flavour))
597 struct bfd_section *interp_sect;
601 if (interp_sect != NULL)
603 int sect_size = bfd_section_size (interp_sect);
605 gdb::byte_vector buf (sect_size);
608 interp_sect, buf.data (), 0, sect_size);
634 gdb::optional<gdb::byte_vector> ph_data
640 step = (arch_size == 32) ?
sizeof (Elf32_External_Dyn)
641 :
sizeof (Elf64_External_Dyn);
642 for (gdb_byte *buf = ph_data->data (), *bufend = buf + ph_data->size ();
643 buf < bufend; buf += step)
647 Elf32_External_Dyn *dynp = (Elf32_External_Dyn *) buf;
656 Elf64_External_Dyn *dynp = (Elf64_External_Dyn *) buf;
663 if (current_dyntag == DT_NULL)
666 if (current_dyntag == desired_dyntag)
672 *ptr_addr = base_addr + buf - ph_data->data ();
697 CORE_ADDR dyn_ptr, dyn_ptr_addr;
712 int pbuf_size = ptr_type->
length ();
714 pbuf = (gdb_byte *) alloca (pbuf_size);
727 &dyn_ptr, &dyn_ptr_addr)
732 int pbuf_size = ptr_type->
length ();
734 pbuf = (gdb_byte *) alloca (pbuf_size);
752 if (msymbol.
minsym != NULL)
779 catch (
const gdb_exception_error &ex)
818 catch (
const gdb_exception_error &ex)
823 if (version < 2 || lmo->r_ldsomap_offset == -1)
846 catch (
const gdb_exception_error &ex)
852 if (version < 2 || lmo->r_next_offset == -1)
876 if (info->debug_base == 0)
883 std::unique_ptr<lm_info_svr4> li =
lm_info_read (ldsomap);
884 name_lm = li != NULL ? li->l_name : 0;
886 return (name_lm >= vaddr && name_lm < vaddr +
size);
894 CORE_ADDR lm, l_name;
897 int l_name_size = ptr_type->
length ();
898 gdb::byte_vector l_name_buf (l_name_size);
900 symfile_add_flags add_flags = 0;
906 if (!
query (_(
"Attempt to reload symbols from process? ")))
911 if (info->debug_base == 0)
929 gdb::unique_xmalloc_ptr<char> filename
932 if (filename ==
nullptr)
934 warning (_(
"failed to read exec filename from attached file"));
1019 newobj = XNEW (
struct so_list);
1020 memcpy (newobj, src,
sizeof (
struct so_list));
1025 newobj->
next = NULL;
1027 link = &newobj->
next;
1059 new_elem = XCNEW (
struct so_list);
1073 if (at_lmid ==
nullptr)
1075 *list->
tailp = new_elem;
1080 ULONGEST lmid = *(ULONGEST *) at_lmid->
value.get ();
1091 if (solist !=
nullptr)
1093 for (; solist->next !=
nullptr; solist = solist->next)
1096 pnext = &solist->next;
1116 if (strcmp (
version,
"1.0") != 0)
1118 _(
"SVR4 Library list has unsupported version \"%s\""),
1128 list->
tailp = solist;
1177 auto cleanup = make_scope_exit ([list] ()
1179 for (
const std::pair<CORE_ADDR, so_list *> tuple
1184 list->
tailp =
nullptr;
1215 gdb::optional<gdb::char_vector> svr4_library_document
1219 if (!svr4_library_document)
1244 if (!info->debug_loader_offset_p)
1247 newobj = XCNEW (
struct so_list);
1272 struct so_list ***link_ptr_ptr,
int ignore_first)
1274 CORE_ADDR first_l_name = 0;
1277 for (; lm != 0; prev_lm = lm, lm = next_lm)
1282 newobj->lm_info = li;
1288 if (li->
l_prev != prev_lm)
1290 warning (_(
"Corrupted shared library list: %s != %s"),
1301 if (ignore_first && li->
l_prev == 0)
1303 first_l_name = li->
l_name;
1304 info->main_lm_addr = li->
lm_addr;
1309 gdb::unique_xmalloc_ptr<char> buffer
1311 if (buffer ==
nullptr)
1317 if (first_l_name == 0 || li->
l_name != first_l_name)
1318 warning (_(
"Can't read pathname for load map."));
1324 strcpy (newobj->so_original_name, newobj->so_name);
1328 if (! newobj->so_name[0] ||
match_main (newobj->so_name))
1333 **link_ptr_ptr = newobj.release ();
1334 *link_ptr_ptr = &(**link_ptr_ptr)->
next;
1365 if (info->using_xfer)
1368 info->main_lm_addr = library_list.
main_lm;
1382 std::swap (info->solib_lists, library_list.
solib_lists);
1389 if (info->debug_base == 0)
1396 ".dynamic") == NULL)
1397 ignore_first =
false;
1399 ignore_first =
true;
1401 auto cleanup = make_scope_exit ([info] ()
1407 CORE_ADDR debug_base = info->debug_base;
1408 for (; debug_base != 0;
1415 so_list **sos = &info->solib_lists[debug_base];
1432 if (debug_base != 0)
1435 if (info->solib_lists.find (debug_base) == info->solib_lists.end ())
1437 so_list **sos = &info->solib_lists[debug_base];
1454 for (
const std::pair<CORE_ADDR, so_list *> tuple
1455 : info->solib_lists)
1457 so_list *solist = tuple.second;
1460 if (solist ==
nullptr)
1466 gdb_assert (*pnext !=
nullptr);
1470 if (next ==
nullptr)
1473 pnext = &next->
next;
1490 if (info->probes_table !=
nullptr)
1521 && vsyscall_range.
length != 0)
1526 while (*sop != NULL)
1596 if (info->main_lm_addr == 0)
1601 return info->main_lm_addr;
1624 const char *
const *mainp;
1628 if (strcmp (soname, *mainp) == 0)
1643 return ((pc >= info->interp_text_sect_low
1645 || (pc >= info->interp_plt_sect_low
1668 bfd_get_start_address (abfd),
1697 return (hashval_t) pa->
address;
1733 if (info->probes_table !=
nullptr)
1734 htab_traverse_noresize (info->probes_table.get (),
1743 probe *prob, CORE_ADDR address,
1750 if (info->probes_table == NULL)
1756 slot = htab_find_slot (info->probes_table.get (), &lookup, INSERT);
1757 gdb_assert (*slot == HTAB_EMPTY_ENTRY);
1779 slot = htab_find_slot (info->probes_table.get (), &lookup, NO_INSERT);
1794 unsigned probe_argc = 0;
1812 catch (
const gdb_exception_error &ex)
1824 if (probe_argc == 2)
1826 else if (probe_argc < 2)
1861 if (info->solib_lists.find (0) != info->solib_lists.end ())
1865 if (info->solib_lists.find (debug_base) == info->solib_lists.end ())
1866 info->solib_lists[debug_base] =
nullptr;
1868 so_list **psolist = &info->solib_lists[debug_base];
1873 if (solist ==
nullptr)
1888 for (; solist->
next !=
nullptr; solist = solist->
next)
1893 pnext = &solist->
next;
1897 if (info->using_xfer)
1903 xsnprintf (annex,
sizeof (annex),
"lmid=%s;start=%s;prev=%s",
1904 phex_nz (debug_base,
sizeof (debug_base)),
1905 phex_nz (lm,
sizeof (lm)),
1906 phex_nz (prev_lm,
sizeof (prev_lm)));
1919 std::swap (sos, library_list.
solib_lists[debug_base]);
1929 for (
const std::pair<CORE_ADDR, so_list *> tuple
1931 gdb_assert (tuple.second ==
nullptr);
1955 warning (_(
"Probes-based dynamic linker interface failed.\n"
1956 "Reverting to original interface."));
1972 struct value *val = NULL;
1973 CORE_ADDR pc, debug_base, lm = 0;
1977 if (info->probes_table == NULL)
1982 auto cleanup = make_scope_exit ([info] ()
2013 scoped_restore inhibit_updates
2020 catch (
const gdb_exception_error &ex)
2030 if (debug_base == 0)
2037 if (global_debug_base != info->debug_base)
2039 info->debug_base = global_debug_base;
2043 if (info->debug_base == 0)
2050 struct value *link_map_id_val;
2055 catch (
const gdb_exception_error)
2057 link_map_id_val = NULL;
2060 if (link_map_id_val != NULL &&
value_as_long (link_map_id_val) != 0)
2072 catch (
const gdb_exception_error &ex)
2121 if (info == NULL || info->probes_table == NULL)
2160 const std::vector<probe *> *probes,
2167 for (
probe *p : probes[i])
2208 xsnprintf (buf,
sizeof (buf),
"rtld_%s",
name);
2216 if (probes[i].empty ())
2245 for (
probe *p : probes[i])
2247 if (!p->can_evaluate_arguments ())
2253 p->get_argument_count (
gdbarch);
2255 catch (
const gdb_exception_error &ex)
2258 warning (_(
"Initializing probes-based dynamic linker interface "
2259 "failed.\nReverting to original interface."));
2304 return (strcmp (sym->name, (
const char *) data) == 0
2305 && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0);
2343 const char *
const *bkpt_namep;
2344 asection *interp_sect;
2347 info->interp_text_sect_low = info->interp_text_sect_high = 0;
2348 info->interp_plt_sect_low = info->interp_plt_sect_high = 0;
2394 CORE_ADDR load_addr;
2399 interp_sect = bfd_get_section_by_name (tmp_bfd,
".text");
2402 info->interp_text_sect_low
2403 = bfd_section_vma (interp_sect) + load_addr;
2404 info->interp_text_sect_high
2405 = info->interp_text_sect_low + bfd_section_size (interp_sect);
2407 interp_sect = bfd_get_section_by_name (tmp_bfd,
".plt");
2410 info->interp_plt_sect_low
2411 = bfd_section_vma (interp_sect) + load_addr;
2412 info->interp_plt_sect_high
2413 = info->interp_plt_sect_low + bfd_section_size (interp_sect);
2423 gdb::optional<gdb::byte_vector> interp_name_holder
2425 if (interp_name_holder)
2427 const char *interp_name = (
const char *) interp_name_holder->data ();
2428 CORE_ADDR load_addr = 0;
2429 int load_addr_found = 0;
2430 int loader_found_in_list = 0;
2449 catch (
const gdb_exception &ex)
2453 if (tmp_bfd == NULL)
2454 goto bkpt_at_symbol;
2464 if (
svr4_same_1 (interp_name, so->so_original_name))
2466 load_addr_found = 1;
2467 loader_found_in_list = 1;
2475 if (!load_addr_found)
2485 if (addr_bit < (
sizeof (CORE_ADDR) * HOST_CHAR_BIT))
2487 CORE_ADDR space_size = (CORE_ADDR) 1 << addr_bit;
2491 gdb_assert (load_addr < space_size);
2496 if (tmp_entry_point < space_size
2497 && tmp_entry_point + load_addr >= space_size)
2498 load_addr -= space_size;
2501 load_addr_found = 1;
2511 if (!load_addr_found)
2521 if (!loader_found_in_list)
2523 info->debug_loader_name = xstrdup (interp_name);
2524 info->debug_loader_offset_p = 1;
2525 info->debug_loader_offset = load_addr;
2531 interp_sect = bfd_get_section_by_name (tmp_bfd.get (),
".text");
2534 info->interp_text_sect_low
2535 = bfd_section_vma (interp_sect) + load_addr;
2536 info->interp_text_sect_high
2537 = info->interp_text_sect_low + bfd_section_size (interp_sect);
2539 interp_sect = bfd_get_section_by_name (tmp_bfd.get (),
".plt");
2542 info->interp_plt_sect_low
2543 = bfd_section_vma (interp_sect) + load_addr;
2544 info->interp_plt_sect_high
2545 = info->interp_plt_sect_low + bfd_section_size (interp_sect);
2574 load_addr + sym_addr);
2581 warning (_(
"Unable to find dynamic linker breakpoint function.\n"
2582 "GDB will be unable to debug shared library initializers\n"
2583 "and track explicitly loaded dynamic code."));
2593 if ((msymbol.
minsym != NULL)
2607 for (bkpt_namep =
bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
2610 if ((msymbol.
minsym != NULL)
2628static gdb::optional<gdb::byte_vector>
2631 Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
2632 int phdrs_size = ehdr->e_phnum * ehdr->e_phentsize;
2633 if (phdrs_size == 0)
2636 gdb::byte_vector buf (phdrs_size);
2637 if (bfd_seek (abfd, ehdr->e_phoff,
SEEK_SET) != 0
2638 || bfd_bread (buf.data (), phdrs_size, abfd) != phdrs_size)
2692 CORE_ADDR entry_point, exec_displacement;
2714 == bfd_target_elf_flavour)
2716 const struct elf_backend_data *elf
2724 if ((exec_displacement & (elf->minpagesize - 1)) != 0)
2735 == bfd_target_elf_flavour)
2741 gdb::optional<gdb::byte_vector> phdrs_target
2743 gdb::optional<gdb::byte_vector> phdrs_binary
2745 if (phdrs_target && phdrs_binary)
2762 if (phdrs_target->size () != phdrs_binary->size ()
2765 else if (arch_size == 32
2766 && phdrs_target->size () >= sizeof (Elf32_External_Phdr)
2767 && phdrs_target->size () % sizeof (Elf32_External_Phdr) == 0)
2769 Elf_Internal_Ehdr *ehdr2
2771 Elf_Internal_Phdr *phdr2
2773 CORE_ADDR displacement = 0;
2781 for (i = 0; i < ehdr2->e_phnum; i++)
2782 if (phdr2[i].p_type == PT_LOAD)
2784 Elf32_External_Phdr *phdrp;
2785 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2786 CORE_ADDR vaddr, paddr;
2787 CORE_ADDR displacement_vaddr = 0;
2788 CORE_ADDR displacement_paddr = 0;
2790 phdrp = &((Elf32_External_Phdr *) phdrs_target->data ())[i];
2791 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2792 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2796 displacement_vaddr = vaddr - phdr2[i].p_vaddr;
2800 displacement_paddr = paddr - phdr2[i].p_paddr;
2802 if (displacement_vaddr == displacement_paddr)
2803 displacement = displacement_vaddr;
2812 i < phdrs_target->size () /
sizeof (Elf32_External_Phdr);
2815 Elf32_External_Phdr *phdrp;
2816 Elf32_External_Phdr *phdr2p;
2817 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2818 CORE_ADDR vaddr, paddr;
2819 asection *plt2_asect;
2821 phdrp = &((Elf32_External_Phdr *) phdrs_target->data ())[i];
2822 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2823 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2824 phdr2p = &((Elf32_External_Phdr *) phdrs_binary->data ())[i];
2829 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
2836 vaddr -= displacement;
2841 paddr -= displacement;
2844 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
2851 if (phdr2[i].p_type == PT_GNU_RELRO
2852 || phdr2[i].p_type == PT_TLS)
2854 Elf32_External_Phdr tmp_phdr = *phdrp;
2855 Elf32_External_Phdr tmp_phdr2 = *phdr2p;
2857 memset (tmp_phdr.p_filesz, 0, 4);
2858 memset (tmp_phdr.p_memsz, 0, 4);
2859 memset (tmp_phdr.p_flags, 0, 4);
2860 memset (tmp_phdr.p_align, 0, 4);
2861 memset (tmp_phdr2.p_filesz, 0, 4);
2862 memset (tmp_phdr2.p_memsz, 0, 4);
2863 memset (tmp_phdr2.p_flags, 0, 4);
2864 memset (tmp_phdr2.p_align, 0, 4);
2866 if (memcmp (&tmp_phdr, &tmp_phdr2,
sizeof (tmp_phdr))
2873 plt2_asect = bfd_get_section_by_name (exec_bfd,
".plt");
2877 gdb_byte *buf_filesz_p = (gdb_byte *) &phdrp->p_filesz;
2880 content2 = (bfd_section_flags (plt2_asect)
2881 & SEC_HAS_CONTENTS) != 0;
2889 filesz += bfd_section_size (plt2_asect);
2891 filesz -= bfd_section_size (plt2_asect);
2896 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
2903 else if (arch_size == 64
2904 && phdrs_target->size () >= sizeof (Elf64_External_Phdr)
2905 && phdrs_target->size () % sizeof (Elf64_External_Phdr) == 0)
2907 Elf_Internal_Ehdr *ehdr2
2909 Elf_Internal_Phdr *phdr2
2911 CORE_ADDR displacement = 0;
2919 for (i = 0; i < ehdr2->e_phnum; i++)
2920 if (phdr2[i].p_type == PT_LOAD)
2922 Elf64_External_Phdr *phdrp;
2923 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2924 CORE_ADDR vaddr, paddr;
2925 CORE_ADDR displacement_vaddr = 0;
2926 CORE_ADDR displacement_paddr = 0;
2928 phdrp = &((Elf64_External_Phdr *) phdrs_target->data ())[i];
2929 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2930 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2934 displacement_vaddr = vaddr - phdr2[i].p_vaddr;
2938 displacement_paddr = paddr - phdr2[i].p_paddr;
2940 if (displacement_vaddr == displacement_paddr)
2941 displacement = displacement_vaddr;
2949 i < phdrs_target->size () /
sizeof (Elf64_External_Phdr);
2952 Elf64_External_Phdr *phdrp;
2953 Elf64_External_Phdr *phdr2p;
2954 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2955 CORE_ADDR vaddr, paddr;
2956 asection *plt2_asect;
2958 phdrp = &((Elf64_External_Phdr *) phdrs_target->data ())[i];
2959 buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr;
2960 buf_paddr_p = (gdb_byte *) &phdrp->p_paddr;
2961 phdr2p = &((Elf64_External_Phdr *) phdrs_binary->data ())[i];
2966 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
2973 vaddr -= displacement;
2978 paddr -= displacement;
2981 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
2988 if (phdr2[i].p_type == PT_GNU_RELRO
2989 || phdr2[i].p_type == PT_TLS)
2991 Elf64_External_Phdr tmp_phdr = *phdrp;
2992 Elf64_External_Phdr tmp_phdr2 = *phdr2p;
2994 memset (tmp_phdr.p_filesz, 0, 8);
2995 memset (tmp_phdr.p_memsz, 0, 8);
2996 memset (tmp_phdr.p_flags, 0, 4);
2997 memset (tmp_phdr.p_align, 0, 8);
2998 memset (tmp_phdr2.p_filesz, 0, 8);
2999 memset (tmp_phdr2.p_memsz, 0, 8);
3000 memset (tmp_phdr2.p_flags, 0, 4);
3001 memset (tmp_phdr2.p_align, 0, 8);
3003 if (memcmp (&tmp_phdr, &tmp_phdr2,
sizeof (tmp_phdr))
3015 gdb_byte *buf_filesz_p = (gdb_byte *) &phdrp->p_filesz;
3018 content2 = (bfd_section_flags (plt2_asect)
3019 & SEC_HAS_CONTENTS) != 0;
3028 filesz += bfd_section_size (plt2_asect);
3030 filesz -= bfd_section_size (plt2_asect);
3035 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
3053 gdb_printf (_(
"Using PIE (Position Independent Executable) "
3054 "displacement %s for \"%s\".\n"),
3059 *displacementp = exec_displacement;
3071 CORE_ADDR displacement;
3117 for (asect = exec_bfd->sections; asect != NULL; asect = asect->next)
3119 bfd_section_vma (asect) + displacement);
3174 info->debug_base = 0;
3175 info->debug_loader_offset_p = 0;
3176 info->debug_loader_offset = 0;
3177 xfree (info->debug_loader_name);
3178 info->debug_loader_name = NULL;
3377 if (solib ==
nullptr)
3381 gdb_assert (info !=
nullptr);
3382 for (
const std::pair<CORE_ADDR, so_list *> tuple
3383 : info->solib_lists)
3385 CORE_ADDR debug_base = tuple.first;
3386 so_list *solist = tuple.second;
3388 for (; solist !=
nullptr; solist = solist->
next)
3407 bool checked_current_objfile =
false;
3408 if (current_objfile !=
nullptr)
3418 abfd = current_objfile->
obfd.get ();
3423 checked_current_objfile =
true;
3424 if (cb (current_objfile))
3434 if (debug_base == 0)
3435 debug_base = initial;
3439 if (checked_current_objfile &&
objfile == current_objfile)
3449 if (solib_base == 0)
3450 solib_base = initial;
3453 if (solib_base != debug_base)
static struct @4 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 * 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)
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 void library_list_start_library(struct gdb_xml_parser *parser, const struct gdb_xml_element *element, void *user_data, std::vector< gdb_xml_value > &attributes)
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 void svr4_library_list_start_list(struct gdb_xml_parser *parser, const struct gdb_xml_element *element, void *user_data, std::vector< gdb_xml_value > &attributes)
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 const struct gdb_xml_element svr4_library_list_children[]
static int svr4_exec_displacement(CORE_ADDR *displacementp)
static const registry< program_space >::key< svr4_info > solib_svr4_pspace_data
static int svr4_parse_libraries(const char *document, struct svr4_library_list *list)
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 const struct gdb_xml_element svr4_library_list_elements[]
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 cmp_name_and_sec_flags(const asymbol *sym, const void *data)
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 const struct gdb_xml_attribute svr4_library_list_attributes[]
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 const struct gdb_xml_attribute svr4_library_attributes[]
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)
CORE_ADDR gdb_bfd_lookup_symbol(bfd *abfd, int(*match_sym)(const asymbol *, const void *), const void *data)
void solib_add(const char *pattern, int from_tty, int readsyms)
gdb_bfd_ref_ptr solib_bfd_open(const char *pathname)
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
const char * original_name
struct objfile * separate_debug_objfile_backlink
struct program_space * pspace
CORE_ADDR text_section_offset() const
::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)
void target_close(struct target_ops *targ)
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
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 gdb_xml_error(struct gdb_xml_parser *parser, const char *format,...)
int gdb_xml_parse_quick(const char *name, const char *dtd_name, const struct gdb_xml_element *elements, const char *document, void *user_data)
struct gdb_xml_value * xml_find_attribute(std::vector< gdb_xml_value > &attributes, const char *name)
gdb_xml_attribute_handler gdb_xml_parse_attr_ulongest