22 #include "elf/external.h"
23 #include "elf/common.h"
89 "__dl_rtld_db_dlactivity",
145 static const struct probe_info probe_info[] =
156 #define NUM_PROBES ARRAY_SIZE (probe_info)
162 svr4_same_1 (
const char *gdb_so_name,
const char *inferior_so_name)
164 if (strcmp (gdb_so_name, inferior_so_name) == 0)
173 if (strcmp (gdb_so_name,
"/usr/lib/ld.so.1") == 0
174 && strcmp (inferior_so_name,
"/lib/ld.so.1") == 0)
179 if (strcmp (gdb_so_name,
"/usr/lib/sparcv9/ld.so.1") == 0
180 && strcmp (inferior_so_name,
"/lib/sparcv9/ld.so.1") == 0)
205 warning (
_(
"Error reading shared library list entry at %s"),
213 lm_info =
xzalloc (
sizeof (*lm_info));
245 struct bfd_section *dyninfo_sect;
255 dyninfo_sect = bfd_get_section_by_name (abfd,
".dynamic");
256 if (dyninfo_sect == NULL)
259 dynaddr = bfd_section_vma (abfd, dyninfo_sect);
261 if (dynaddr + l_addr != l_dynaddr)
266 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
268 Elf_Internal_Ehdr *ehdr = elf_tdata (abfd)->elf_header;
269 Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
274 for (i = 0; i < ehdr->e_phnum; i++)
275 if (phdr[i].p_type == PT_LOAD && phdr[i].p_align > align)
276 align = phdr[i].p_align;
278 minpagesize = get_elf_backend_data (abfd)->minpagesize;
307 l_addr = l_dynaddr - dynaddr;
309 if ((l_addr & (minpagesize - 1)) == 0
310 && (l_addr & align) == ((l_dynaddr - dynaddr) & align))
314 "prelink displacement %s for \"%s\".\n"),
329 warning (
_(
".dynamic section for \"%s\" "
330 "is not at the expected address "
331 "(wrong library or version mismatch?)"), so->
so_name);
452 CORE_ADDR at_phdr, at_phent, at_phnum, pt_phdr = 0;
453 int arch_size, sect_size;
465 if (!at_phdr || !at_phnum)
469 if (at_phent ==
sizeof (Elf32_External_Phdr))
471 else if (at_phent ==
sizeof (Elf64_External_Phdr))
480 sect_size = at_phent * at_phnum;
482 else if (arch_size == 32)
484 Elf32_External_Phdr phdr;
488 for (i = 0; i < at_phnum; i++)
499 if (p_type == PT_PHDR)
521 Elf64_External_Phdr phdr;
525 for (i = 0; i < at_phnum; i++)
536 if (p_type == PT_PHDR)
564 sect_addr = sect_addr + (at_phdr - pt_phdr);
576 *p_arch_size = arch_size;
578 *p_sect_size = sect_size;
592 && bfd_get_flavour (
exec_bfd) == bfd_target_elf_flavour)
594 struct bfd_section *interp_sect;
596 interp_sect = bfd_get_section_by_name (
exec_bfd,
".interp");
597 if (interp_sect != NULL)
599 int sect_size = bfd_section_size (
exec_bfd, interp_sect);
602 bfd_get_section_contents (
exec_bfd, interp_sect, buf, 0, sect_size);
620 int arch_size, step, sect_size;
624 Elf32_External_Dyn *x_dynp_32;
625 Elf64_External_Dyn *x_dynp_64;
626 struct bfd_section *sect;
632 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
635 arch_size = bfd_get_arch_size (abfd);
640 sect = bfd_get_section_by_name (abfd,
".dynamic");
650 dyn_addr = target_section->
addr;
658 dyn_addr = bfd_section_vma (abfd, sect);
663 sect_size = bfd_section_size (abfd, sect);
664 buf = bufstart = alloca (sect_size);
665 if (!bfd_get_section_contents (abfd, sect,
670 step = (arch_size == 32) ?
sizeof (Elf32_External_Dyn)
671 :
sizeof (Elf64_External_Dyn);
672 for (bufend = buf + sect_size;
678 x_dynp_32 = (Elf32_External_Dyn *) buf;
679 current_dyntag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);
680 dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);
684 x_dynp_64 = (Elf64_External_Dyn *) buf;
685 current_dyntag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
686 dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);
688 if (current_dyntag == DT_NULL)
690 if (current_dyntag == desired_dyntag)
696 struct type *ptr_type;
701 ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
721 int sect_size, arch_size, step;
732 step = (arch_size == 32) ?
sizeof (Elf32_External_Dyn)
733 :
sizeof (Elf64_External_Dyn);
734 for (bufend = buf + sect_size;
740 Elf32_External_Dyn *dynp = (Elf32_External_Dyn *) buf;
749 Elf64_External_Dyn *dynp = (Elf64_External_Dyn *) buf;
756 if (current_dyntag == DT_NULL)
759 if (current_dyntag == desired_dyntag)
801 pbuf = alloca (pbuf_size);
817 if (msymbol.
minsym != NULL)
929 if (version < 2 || lmo->r_ldsomap_offset == -1)
963 newobj = XCNEW (
struct so_list);
970 return (name_lm >= vaddr && name_lm < vaddr + size);
986 int from_tty = *(
int *)from_ttyp;
995 if (!
query (
_(
"Attempt to reload symbols from process? ")))
1035 warning (
_(
"failed to read exec filename from attached file: %s"),
1084 while (list != NULL)
1106 memcpy (newobj, src,
sizeof (
struct so_list));
1111 newobj->
next = NULL;
1113 link = &newobj->
next;
1121 #ifdef HAVE_LIBEXPAT
1140 new_elem = XCNEW (
struct so_list);
1146 strncpy (new_elem->
so_name, name, sizeof (new_elem->
so_name) - 1);
1150 *list->
tailp = new_elem;
1165 if (strcmp (version,
"1.0") != 0)
1167 _(
"SVR4 Library list has unsupported version \"%s\""),
1222 memset (list, 0,
sizeof (*list));
1225 svr4_library_list_elements, document, list) == 0)
1250 char *svr4_library_document;
1260 if (svr4_library_document == NULL)
1293 newobj = XCNEW (
struct so_list);
1318 struct so_list ***link_ptr_ptr,
int ignore_first)
1323 for (; lm != 0; prev_lm = lm, lm = next_lm)
1330 newobj = XCNEW (
struct so_list);
1344 warning (
_(
"Corrupted shared library list: %s != %s"),
1375 if (first_l_name == 0 || newobj->
lm_info->
l_name != first_l_name)
1376 warning (
_(
"Can't read pathname for load map: %s."),
1397 **link_ptr_ptr = newobj;
1398 *link_ptr_ptr = &newobj->
next;
1414 struct so_list **link_ptr = &head;
1506 && vsyscall_range.
length != 0)
1511 while (*sop != NULL)
1603 const char *
const *mainp;
1605 for (mainp = main_name_list; *mainp != NULL; mainp++)
1607 if (strcmp (soname, *mainp) == 0)
1647 bfd_get_start_address (abfd),
1673 return (hashval_t) pa->
address;
1707 slot = htab_find_slot (info->
probes_table, &lookup, INSERT);
1729 slot = htab_find_slot (info->
probes_table, &lookup, NO_INSERT);
1744 unsigned probe_argc;
1759 if (probe_argc == 2)
1761 else if (probe_argc < 2)
1814 xsnprintf (annex,
sizeof (annex),
"start=%s;prev=%s",
1816 phex_nz (prev_lm,
sizeof (prev_lm)));
1846 warning (
_(
"Probes-based dynamic linker interface failed.\n"
1847 "Reverting to original interface.\n"));
1863 struct cleanup *old_chain, *usm_chain;
1920 if (debug_base == 0)
1985 for (loc = b->
loc; loc != NULL; loc = loc->
next)
1990 info = program_space_data (loc->
pspace, solib_svr4_pspace_data);
2077 for (with_prefix = 0; with_prefix <= 1; with_prefix++)
2080 int all_probes_found = 1;
2081 int checked_can_use_probe_arguments = 0;
2084 memset (probes, 0,
sizeof (probes));
2087 const char *
name = probe_info[i].
name;
2100 xsnprintf (buf,
sizeof (buf),
"rtld_%s", name);
2104 probes[i] = find_probes_in_objfile (os->
objfile,
"rtld", name);
2109 if (strcmp (name,
"rtld_map_failed") == 0)
2114 all_probes_found = 0;
2119 if (!checked_can_use_probe_arguments)
2124 all_probes_found = 0;
2127 checked_can_use_probe_arguments = 1;
2131 if (all_probes_found)
2137 if (all_probes_found)
2150 return (strcmp (sym->name, (
const char *) data) == 0
2151 && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0);
2189 const char *
const *bkpt_namep;
2190 asection *interp_sect;
2247 interp_sect = bfd_get_section_by_name (tmp_bfd,
".text");
2251 bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
2254 + bfd_section_size (tmp_bfd, interp_sect);
2256 interp_sect = bfd_get_section_by_name (tmp_bfd,
".plt");
2260 bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
2263 + bfd_section_size (tmp_bfd, interp_sect);
2277 int load_addr_found = 0;
2278 int loader_found_in_list = 0;
2280 bfd *tmp_bfd = NULL;
2303 if (tmp_bfd == NULL)
2304 goto bkpt_at_symbol;
2320 load_addr_found = 1;
2321 loader_found_in_list = 1;
2330 if (!load_addr_found)
2351 if (tmp_entry_point < space_size
2352 && tmp_entry_point + load_addr >= space_size)
2353 load_addr -= space_size;
2356 load_addr_found = 1;
2366 if (!load_addr_found)
2375 if (!loader_found_in_list)
2385 interp_sect = bfd_get_section_by_name (tmp_bfd,
".text");
2389 bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
2392 + bfd_section_size (tmp_bfd, interp_sect);
2394 interp_sect = bfd_get_section_by_name (tmp_bfd,
".plt");
2398 bfd_section_vma (tmp_bfd, interp_sect) + load_addr;
2401 + bfd_section_size (tmp_bfd, interp_sect);
2405 for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
2408 (
void *) *bkpt_namep);
2429 load_addr + sym_addr);
2430 xfree (interp_name);
2437 xfree (interp_name);
2438 warning (
_(
"Unable to find dynamic linker breakpoint function.\n"
2439 "GDB will be unable to debug shared library initializers\n"
2440 "and track explicitly loaded dynamic code."));
2446 for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
2449 if ((msymbol.
minsym != NULL)
2463 for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
2466 if ((msymbol.
minsym != NULL)
2495 Elf_Internal_Ehdr *ehdr;
2498 ehdr = elf_elfheader (abfd);
2500 *phdrs_size = ehdr->e_phnum * ehdr->e_phentsize;
2501 if (*phdrs_size == 0)
2505 if (bfd_seek (abfd, ehdr->e_phoff,
SEEK_SET) != 0
2506 || bfd_bread (buf, *phdrs_size, abfd) != *phdrs_size)
2563 CORE_ADDR entry_point, exec_displacement;
2572 if ((bfd_get_file_flags (
exec_bfd) & DYNAMIC) == 0)
2578 exec_displacement = entry_point - bfd_get_start_address (
exec_bfd);
2583 if (bfd_get_flavour (
exec_bfd) == bfd_target_elf_flavour)
2585 const struct elf_backend_data *elf = get_elf_backend_data (
exec_bfd);
2592 if ((exec_displacement & (elf->minpagesize - 1)) != 0)
2602 if (bfd_get_flavour (
exec_bfd) == bfd_target_elf_flavour)
2606 int phdrs_size, phdrs2_size, ok = 1;
2612 if (buf != NULL && buf2 != NULL)
2629 if (phdrs_size != phdrs2_size
2630 || bfd_get_arch_size (
exec_bfd) != arch_size)
2632 else if (arch_size == 32
2633 && phdrs_size >=
sizeof (Elf32_External_Phdr)
2634 && phdrs_size %
sizeof (Elf32_External_Phdr) == 0)
2636 Elf_Internal_Ehdr *ehdr2 = elf_tdata (
exec_bfd)->elf_header;
2637 Elf_Internal_Phdr *phdr2 = elf_tdata (
exec_bfd)->phdr;
2646 for (i = 0; i < ehdr2->e_phnum; i++)
2647 if (phdr2[i].p_type == PT_LOAD)
2649 Elf32_External_Phdr *phdrp;
2650 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2655 phdrp = &((Elf32_External_Phdr *) buf)[i];
2656 buf_vaddr_p = (
gdb_byte *) &phdrp->p_vaddr;
2657 buf_paddr_p = (
gdb_byte *) &phdrp->p_paddr;
2661 displacement_vaddr = vaddr - phdr2[i].p_vaddr;
2665 displacement_paddr = paddr - phdr2[i].p_paddr;
2667 if (displacement_vaddr == displacement_paddr)
2668 displacement = displacement_vaddr;
2675 for (i = 0; i < phdrs_size /
sizeof (Elf32_External_Phdr); i++)
2677 Elf32_External_Phdr *phdrp;
2678 Elf32_External_Phdr *phdr2p;
2679 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2681 asection *plt2_asect;
2683 phdrp = &((Elf32_External_Phdr *) buf)[i];
2684 buf_vaddr_p = (
gdb_byte *) &phdrp->p_vaddr;
2685 buf_paddr_p = (
gdb_byte *) &phdrp->p_paddr;
2686 phdr2p = &((Elf32_External_Phdr *) buf2)[i];
2691 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
2698 vaddr -= displacement;
2703 paddr -= displacement;
2706 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
2712 if (phdr2[i].p_type == PT_GNU_RELRO)
2714 Elf32_External_Phdr tmp_phdr = *phdrp;
2715 Elf32_External_Phdr tmp_phdr2 = *phdr2p;
2717 memset (tmp_phdr.p_filesz, 0, 4);
2718 memset (tmp_phdr.p_memsz, 0, 4);
2719 memset (tmp_phdr.p_flags, 0, 4);
2720 memset (tmp_phdr.p_align, 0, 4);
2721 memset (tmp_phdr2.p_filesz, 0, 4);
2722 memset (tmp_phdr2.p_memsz, 0, 4);
2723 memset (tmp_phdr2.p_flags, 0, 4);
2724 memset (tmp_phdr2.p_align, 0, 4);
2726 if (memcmp (&tmp_phdr, &tmp_phdr2,
sizeof (tmp_phdr))
2732 plt2_asect = bfd_get_section_by_name (
exec_bfd,
".plt");
2739 content2 = (bfd_get_section_flags (
exec_bfd, plt2_asect)
2740 & SEC_HAS_CONTENTS) != 0;
2748 filesz += bfd_get_section_size (plt2_asect);
2750 filesz -= bfd_get_section_size (plt2_asect);
2755 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
2763 else if (arch_size == 64
2764 && phdrs_size >=
sizeof (Elf64_External_Phdr)
2765 && phdrs_size %
sizeof (Elf64_External_Phdr) == 0)
2767 Elf_Internal_Ehdr *ehdr2 = elf_tdata (
exec_bfd)->elf_header;
2768 Elf_Internal_Phdr *phdr2 = elf_tdata (
exec_bfd)->phdr;
2777 for (i = 0; i < ehdr2->e_phnum; i++)
2778 if (phdr2[i].p_type == PT_LOAD)
2780 Elf64_External_Phdr *phdrp;
2781 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2786 phdrp = &((Elf64_External_Phdr *) buf)[i];
2787 buf_vaddr_p = (
gdb_byte *) &phdrp->p_vaddr;
2788 buf_paddr_p = (
gdb_byte *) &phdrp->p_paddr;
2792 displacement_vaddr = vaddr - phdr2[i].p_vaddr;
2796 displacement_paddr = paddr - phdr2[i].p_paddr;
2798 if (displacement_vaddr == displacement_paddr)
2799 displacement = displacement_vaddr;
2806 for (i = 0; i < phdrs_size /
sizeof (Elf64_External_Phdr); i++)
2808 Elf64_External_Phdr *phdrp;
2809 Elf64_External_Phdr *phdr2p;
2810 gdb_byte *buf_vaddr_p, *buf_paddr_p;
2812 asection *plt2_asect;
2814 phdrp = &((Elf64_External_Phdr *) buf)[i];
2815 buf_vaddr_p = (
gdb_byte *) &phdrp->p_vaddr;
2816 buf_paddr_p = (
gdb_byte *) &phdrp->p_paddr;
2817 phdr2p = &((Elf64_External_Phdr *) buf2)[i];
2822 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
2829 vaddr -= displacement;
2834 paddr -= displacement;
2837 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
2843 if (phdr2[i].p_type == PT_GNU_RELRO)
2845 Elf64_External_Phdr tmp_phdr = *phdrp;
2846 Elf64_External_Phdr tmp_phdr2 = *phdr2p;
2848 memset (tmp_phdr.p_filesz, 0, 8);
2849 memset (tmp_phdr.p_memsz, 0, 8);
2850 memset (tmp_phdr.p_flags, 0, 4);
2851 memset (tmp_phdr.p_align, 0, 8);
2852 memset (tmp_phdr2.p_filesz, 0, 8);
2853 memset (tmp_phdr2.p_memsz, 0, 8);
2854 memset (tmp_phdr2.p_flags, 0, 4);
2855 memset (tmp_phdr2.p_align, 0, 8);
2857 if (memcmp (&tmp_phdr, &tmp_phdr2,
sizeof (tmp_phdr))
2863 plt2_asect = bfd_get_section_by_name (
exec_bfd,
".plt");
2870 content2 = (bfd_get_section_flags (
exec_bfd, plt2_asect)
2871 & SEC_HAS_CONTENTS) != 0;
2879 filesz += bfd_get_section_size (plt2_asect);
2881 filesz -= bfd_get_section_size (plt2_asect);
2886 if (memcmp (phdrp, phdr2p,
sizeof (*phdrp)) == 0)
2912 "displacement %s for \"%s\".\n"),
2917 *displacementp = exec_displacement;
2969 * sizeof (*new_offsets));
2972 new_offsets->
offsets[i] = displacement;
2980 for (asect =
exec_bfd->sections; asect != NULL; asect = asect->next)
3228 abfd = objfile->
obfd;
3231 if (abfd == NULL ||
scan_dyntag (DT_SYMBOLIC, abfd, NULL) != 1)
3243 solib_svr4_pspace_data
struct gdbarch * target_gdbarch(void)
static void svr4_update_solib_event_breakpoints(void)
static const char *const bkpt_names[]
struct symbol *(* lookup_lib_global_symbol)(struct objfile *objfile, const char *name, const domain_enum domain)
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
static int enable_break(struct svr4_info *info, int from_tty)
struct cleanup * make_cleanup_free_so(struct so_list *so)
static int svr4_keep_data_in_core(CORE_ADDR vaddr, unsigned long size)
static void svr4_free_library_list(void *p_list)
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
static struct so_list * svr4_current_sos_1(void)
#define SECT_OFF_TEXT(objfile)
static void svr4_solib_create_inferior_hook(int from_tty)
static struct lm_info * lm_info_read(CORE_ADDR lm_addr)
struct frame_info * get_current_frame(void)
static int has_lm_dynamic_from_link_map(void)
struct link_map_offsets * svr4_lp64_fetch_link_map_offsets(void)
static void library_list_start_library(struct gdb_xml_parser *parser, const struct gdb_xml_element *element, void *user_data, VEC(gdb_xml_value_s)*attributes)
static struct so_list * svr4_current_sos_direct(struct svr4_info *info)
struct objfile * separate_debug_objfile_backlink
struct breakpoint * create_solib_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
static void svr4_pspace_data_cleanup(struct program_space *pspace, void *arg)
void set_solib_ops(struct gdbarch *gdbarch, const struct target_so_ops *new_ops)
#define BMSYMBOL_VALUE_ADDRESS(symbol)
static void svr4_clear_solib(void)
void warning(const char *fmt,...)
static void svr4_clear_so(struct so_list *so)
int query(const char *ctlstr,...)
int svr4_in_dynsym_resolve_code(CORE_ADDR pc)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
void(* update_breakpoints)(void)
CORE_ADDR interp_plt_sect_low
void * gdbarch_data(struct gdbarch *gdbarch, struct gdbarch_data *data)
static const struct program_space_data * solib_svr4_pspace_data
enum domain_enum_tag domain_enum
static CORE_ADDR solib_svr4_r_brk(struct svr4_info *info)
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
void(* relocate_section_addresses)(struct so_list *so, struct target_section *)
void(* solib_create_inferior_hook)(int from_tty)
struct so_list *(* current_sos)(void)
void objfile_relocate(struct objfile *objfile, const struct section_offsets *new_offsets)
static const struct gdb_xml_attribute svr4_library_list_attributes[]
bfd *(* bfd_open)(char *pathname)
static CORE_ADDR exec_entry_point(struct bfd *abfd, struct target_ops *targ)
static int svr4_update_solib_event_breakpoint(struct breakpoint *b, void *arg)
static CORE_ADDR locate_base(struct svr4_info *info)
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_create_solib_event_breakpoints(struct gdbarch *gdbarch, CORE_ADDR address)
struct link_map_offsets * svr4_ilp32_fetch_link_map_offsets(void)
static int svr4_read_so_list(CORE_ADDR lm, CORE_ADDR prev_lm, struct so_list ***link_ptr_ptr, int ignore_first)
int can_evaluate_probe_arguments(struct probe *probe)
struct symbol * lookup_global_symbol_from_objfile(struct objfile *main_objfile, const char *name, const domain_enum domain)
struct gdbarch_data * gdbarch_data_register_pre_init(gdbarch_data_pre_init_ftype *pre_init)
#define SO_NAME_MAX_PATH_SIZE
initialize_file_ftype _initialize_svr4_solib
static CORE_ADDR lm_addr(struct so_list *so)
static CORE_ADDR elf_locate_base(void)
void inhibit_section_map_updates(struct program_space *pspace)
static int svr4_same(struct so_list *gdb, struct so_list *inferior)
static CORE_ADDR solib_svr4_r_map(struct svr4_info *info)
int(* keep_data_in_core)(CORE_ADDR vaddr, unsigned long size)
int gdbarch_vsyscall_range(struct gdbarch *gdbarch, struct mem_range *range)
void enable_breakpoint(struct breakpoint *bpt)
struct regcache * get_current_regcache(void)
int(* open_symbol_file_object)(void *from_ttyp)
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
struct so_list * solib_list
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
static void svr4_special_symbol_handling(void)
static CORE_ADDR svr4_truncate_ptr(CORE_ADDR addr)
CORE_ADDR svr4_fetch_objfile_link_map(struct objfile *objfile)
static void svr4_relocate_section_addresses(struct so_list *so, struct target_section *sec)
static int solist_update_incremental(struct svr4_info *info, CORE_ADDR lm)
void(* clear_solib)(void)
static int equal_probe_and_action(const void *p1, const void *p2)
struct so_list * master_so_list(void)
static const char *const main_name_list[]
#define VEC_iterate(T, V, I, P)
int(* in_dynsym_resolve_code)(CORE_ADDR pc)
struct bp_location * next
#define CATCH(EXCEPTION, MASK)
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 target_ops current_target
void gdb_bfd_unref(struct bfd *abfd)
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
void initialize_file_ftype(void)
struct program_space * pspace
CORE_ADDR gdb_bfd_lookup_symbol(bfd *abfd, int(*match_sym)(asymbol *, void *), void *data)
static int scan_dyntag_auxv(const int desired_dyntag, CORE_ADDR *ptr)
struct breakpoint * iterate_over_breakpoints(int(*callback)(struct breakpoint *, void *), void *data)
void * xzalloc(size_t size)
static int svr4_same_1(const char *gdb_so_name, const char *inferior_so_name)
struct target_ops * target_bfd_reopen(struct bfd *abfd)
static void svr4_relocate_main_executable(void)
#define current_target_sections
static int solist_update_full(struct svr4_info *info)
CORE_ADDR gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
unsigned get_probe_argument_count(struct probe *probe, struct frame_info *frame)
int target_auxv_search(struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
void exception_print(struct ui_file *file, struct gdb_exception e)
static void disable_probes_interface_cleanup(void *arg)
char so_original_name[SO_NAME_MAX_PATH_SIZE]
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
void free_so(struct so_list *so)
void solib_add(const char *pattern, int from_tty, struct target_ops *target, int readsyms)
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
#define ANOFFSET(secoff, whichone)
static void free_solib_list(struct svr4_info *info)
void(* handle_event)(void)
void set_solib_svr4_fetch_link_map_offsets(struct gdbarch *gdbarch, struct link_map_offsets *(*flmo)(void))
int debug_loader_offset_p
void disable_breakpoint(struct breakpoint *bpt)
char so_name[SO_NAME_MAX_PATH_SIZE]
char * target_read_stralloc(struct target_ops *ops, enum target_object object, const char *annex)
void(* clear_so)(struct so_list *so)
#define VEC_index(T, V, I)
static void svr4_free_so(struct so_list *so)
static int svr4_current_sos_via_xfer_libraries(struct svr4_library_list *list, const char *annex)
int(* same)(struct so_list *gdb, struct so_list *inferior)
static void svr4_handle_solib_event(void)
void target_close(struct target_ops *targ)
int gdbarch_addr_bit(struct gdbarch *gdbarch)
#define target_has_execution
void printf_unfiltered(const char *format,...)
#define target_augmented_libraries_svr4_read()
static char * find_program_interpreter(void)
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
static void free_probes_table(struct svr4_info *info)
struct obj_section * find_pc_section(CORE_ADDR pc)
struct bfd_section * the_bfd_section
static void * solib_svr4_init(struct obstack *obstack)
static struct probe_and_action * solib_event_probe_at(struct svr4_info *info, CORE_ADDR address)
CORE_ADDR debug_loader_offset
void(* special_symbol_handling)(void)
void symbol_file_add_main(const char *args, int from_tty)
void gdb_xml_error(struct gdb_xml_parser *parser, const char *format,...)
const char * interp_name(struct interp *interp)
void exec_set_section_address(const char *filename, int index, CORE_ADDR address)
CORE_ADDR get_probe_address(struct probe *probe, struct objfile *objfile)
static struct so_list * svr4_default_sos(void)
struct target_so_ops svr4_so_ops
struct gdb_xml_value * xml_find_attribute(VEC(gdb_xml_value_s)*attributes, const char *name)
void discard_cleanups(struct cleanup *old_chain)
static int scan_dyntag(const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr)
char * phex_nz(ULONGEST l, int sizeof_l)
static struct link_map_offsets * svr4_fetch_link_map_offsets(void)
static CORE_ADDR interp_plt_sect_high
int xsnprintf(char *str, size_t size, const char *format,...)
CORE_ADDR interp_text_sect_high
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
struct ui_file * gdb_stderr
CORE_ADDR regcache_read_pc(struct regcache *regcache)
struct type * builtin_data_ptr
static int in_plt_section(CORE_ADDR pc)
struct minimal_symbol * minsym
static hashval_t hash_probe_and_action(const void *p)
void(* free_so)(struct so_list *so)
char * safe_strerror(int)
static struct so_list * svr4_current_sos(void)
static struct svr4_info * get_svr4_info(void)
static gdb_byte * read_program_header(int type, int *p_sect_size, int *p_arch_size)
static const char *const solib_break_names[]
int address_in_mem_range(CORE_ADDR address, const struct mem_range *r)
CORE_ADDR l_addr_inferior
CORE_ADDR interp_plt_sect_high
static int cmp_name_and_sec_flags(asymbol *sym, void *data)
struct inferior * current_inferior(void)
int in_gnu_ifunc_stub(CORE_ADDR pc)
gdb_xml_attribute_handler gdb_xml_parse_attr_ulongest
struct program_space * current_program_space
static gdb_byte * read_program_headers_from_bfd(bfd *abfd, int *phdrs_size)
unsigned long long ULONGEST
static int open_symbol_file_object(void *from_ttyp)
static CORE_ADDR lm_addr_check(const struct so_list *so, bfd *abfd)
static const struct gdb_xml_element svr4_library_list_children[]
struct link_map_offsets *(* fetch_link_map_offsets)(void)
CORE_ADDR value_as_address(struct value *val)
struct value * evaluate_probe_argument(struct probe *probe, unsigned n, struct frame_info *frame)
#define OBSTACK_ZALLOC(OBSTACK, TYPE)
#define TYPE_LENGTH(thistype)
static int svr4_have_link_map_offsets(void)
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
struct section_offsets * section_offsets
static CORE_ADDR interp_text_sect_high
CORE_ADDR read_memory_typed_address(CORE_ADDR addr, struct type *type)
static const struct gdb_xml_attribute svr4_library_attributes[]
enum enable_state enable_state
static struct so_list * svr4_copy_library_list(struct so_list *src)
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
PTR xcalloc(size_t number, size_t size)
static void svr4_create_probe_breakpoints(struct gdbarch *gdbarch, VEC(probe_p)**probes, struct objfile *objfile)
int target_read_string(CORE_ADDR memaddr, char **string, int len, int *errnop)
void resume_section_map_updates_cleanup(void *arg)
static void register_solib_event_probe(struct probe *probe, CORE_ADDR address, enum probe_action action)
static struct gdbarch_data * solib_svr4_data
static int svr4_parse_libraries(const char *document, struct svr4_library_list *list)
static struct symbol * elf_lookup_lib_symbol(struct objfile *objfile, const char *name, const domain_enum domain)
bfd * solib_bfd_open(char *pathname)
void do_cleanups(struct cleanup *old_chain)
struct regcache * get_thread_arch_regcache(ptid_t ptid, struct gdbarch *gdbarch)
static int match_main(const char *)
static int svr4_exec_displacement(CORE_ADDR *displacementp)
__extension__ enum domain_enum_tag domain
CORE_ADDR interp_text_sect_low
static void svr4_library_list_start_list(struct gdb_xml_parser *parser, const struct gdb_xml_element *element, void *user_data, VEC(gdb_xml_value_s)*attributes)