X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;ds=sidebyside;f=gdb%2Fsolib-svr4.c;h=080fd795ed48e70e86c6a7f1676e720e10d1d623;hb=043a49349c713dc329a2dfc413b082c3826ecdb8;hp=978564c1bc1f246c6499002862b02a4b4cb85149;hpb=2eca4a8d84ce27d0768702e93b8fca1578f84d06;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c index 978564c1bc..080fd795ed 100644 --- a/gdb/solib-svr4.c +++ b/gdb/solib-svr4.c @@ -1,6 +1,6 @@ /* Handle SVR4 shared libraries for GDB, the GNU Debugger. - Copyright (C) 1990-2014 Free Software Foundation, Inc. + Copyright (C) 1990-2017 Free Software Foundation, Inc. This file is part of GDB. @@ -43,7 +43,6 @@ #include "elf-bfd.h" #include "exec.h" #include "auxv.h" -#include "exceptions.h" #include "gdb_bfd.h" #include "probe.h" @@ -52,27 +51,6 @@ static int svr4_have_link_map_offsets (void); static void svr4_relocate_main_executable (void); static void svr4_free_library_list (void *p_list); -/* Link map info to include in an allocated so_list entry. */ - -struct lm_info - { - /* Amount by which addresses in the binary should be relocated to - match the inferior. The direct inferior value is L_ADDR_INFERIOR. - When prelinking is involved and the prelink base address changes, - we may need a different offset - the recomputed offset is in L_ADDR. - It is commonly the same value. It is cached as we want to warn about - the difference and compute it only once. L_ADDR is valid - iff L_ADDR_P. */ - CORE_ADDR l_addr, l_addr_inferior; - unsigned int l_addr_p : 1; - - /* The target location of lm. */ - CORE_ADDR lm_addr; - - /* Values read in from inferior's fields of the same name. */ - CORE_ADDR l_ld, l_next, l_prev, l_name; - }; - /* On SVR4 systems, a list of symbols in the dynamic linker where GDB can try to place a breakpoint to monitor shared library events. @@ -190,15 +168,15 @@ svr4_same (struct so_list *gdb, struct so_list *inferior) return (svr4_same_1 (gdb->so_original_name, inferior->so_original_name)); } -static struct lm_info * +static lm_info_svr4 * lm_info_read (CORE_ADDR lm_addr) { struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); gdb_byte *lm; - struct lm_info *lm_info; + lm_info_svr4 *lm_info; struct cleanup *back_to; - lm = xmalloc (lmo->link_map_size); + lm = (gdb_byte *) xmalloc (lmo->link_map_size); back_to = make_cleanup (xfree, lm); if (target_read_memory (lm_addr, lm, lmo->link_map_size) != 0) @@ -211,7 +189,7 @@ lm_info_read (CORE_ADDR lm_addr) { struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; - lm_info = xzalloc (sizeof (*lm_info)); + lm_info = new lm_info_svr4; lm_info->lm_addr = lm_addr; lm_info->l_addr_inferior = extract_typed_address (&lm[lmo->l_addr_offset], @@ -241,17 +219,19 @@ has_lm_dynamic_from_link_map (void) static CORE_ADDR lm_addr_check (const struct so_list *so, bfd *abfd) { - if (!so->lm_info->l_addr_p) + lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info; + + if (!li->l_addr_p) { struct bfd_section *dyninfo_sect; CORE_ADDR l_addr, l_dynaddr, dynaddr; - l_addr = so->lm_info->l_addr_inferior; + l_addr = li->l_addr_inferior; if (! abfd || ! has_lm_dynamic_from_link_map ()) goto set_addr; - l_dynaddr = so->lm_info->l_ld; + l_dynaddr = li->l_ld; dyninfo_sect = bfd_get_section_by_name (abfd, ".dynamic"); if (dyninfo_sect == NULL) @@ -334,11 +314,11 @@ lm_addr_check (const struct so_list *so, bfd *abfd) } set_addr: - so->lm_info->l_addr = l_addr; - so->lm_info->l_addr_p = 1; + li->l_addr = l_addr; + li->l_addr_p = 1; } - return so->lm_info->l_addr; + return li->l_addr; } /* Per pspace SVR4 specific data. */ @@ -406,7 +386,7 @@ free_solib_list (struct svr4_info *info) static void svr4_pspace_data_cleanup (struct program_space *pspace, void *arg) { - struct svr4_info *info = arg; + struct svr4_info *info = (struct svr4_info *) arg; free_probes_table (info); free_solib_list (info); @@ -422,7 +402,8 @@ get_svr4_info (void) { struct svr4_info *info; - info = program_space_data (current_program_space, solib_svr4_pspace_data); + info = (struct svr4_info *) program_space_data (current_program_space, + solib_svr4_pspace_data); if (info != NULL) return info; @@ -444,10 +425,12 @@ static int match_main (const char *); Return a pointer to allocated memory holding the program header contents, or NULL on failure. If sucessful, and unless P_SECT_SIZE is NULL, the size of those contents is returned to P_SECT_SIZE. Likewise, the target - architecture size (32-bit or 64-bit) is returned to P_ARCH_SIZE. */ + architecture size (32-bit or 64-bit) is returned to P_ARCH_SIZE and + the base address of the section is returned in BASE_ADDR. */ static gdb_byte * -read_program_header (int type, int *p_sect_size, int *p_arch_size) +read_program_header (int type, int *p_sect_size, int *p_arch_size, + CORE_ADDR *base_addr) { enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); CORE_ADDR at_phdr, at_phent, at_phnum, pt_phdr = 0; @@ -566,7 +549,7 @@ read_program_header (int type, int *p_sect_size, int *p_arch_size) } /* Read in requested program header. */ - buf = xmalloc (sect_size); + buf = (gdb_byte *) xmalloc (sect_size); if (target_read_memory (sect_addr, buf, sect_size)) { xfree (buf); @@ -577,6 +560,8 @@ read_program_header (int type, int *p_sect_size, int *p_arch_size) *p_arch_size = arch_size; if (p_sect_size) *p_sect_size = sect_size; + if (base_addr) + *base_addr = sect_addr; return buf; } @@ -599,14 +584,14 @@ find_program_interpreter (void) { int sect_size = bfd_section_size (exec_bfd, interp_sect); - buf = xmalloc (sect_size); + buf = (gdb_byte *) xmalloc (sect_size); bfd_get_section_contents (exec_bfd, interp_sect, buf, 0, sect_size); } } /* If we didn't find it, use the target auxillary vector. */ if (!buf) - buf = read_program_header (PT_INTERP, NULL, NULL); + buf = read_program_header (PT_INTERP, NULL, NULL, NULL); return (char *) buf; } @@ -616,7 +601,8 @@ find_program_interpreter (void) found, 1 is returned and the corresponding PTR is set. */ static int -scan_dyntag (const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr) +scan_dyntag (const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr, + CORE_ADDR *ptr_addr) { int arch_size, step, sect_size; long current_dyntag; @@ -662,7 +648,7 @@ scan_dyntag (const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr) /* Read in .dynamic from the BFD. We will get the actual value from memory later. */ sect_size = bfd_section_size (abfd, sect); - buf = bufstart = alloca (sect_size); + buf = bufstart = (gdb_byte *) alloca (sect_size); if (!bfd_get_section_contents (abfd, sect, buf, 0, sect_size)) return 0; @@ -696,13 +682,15 @@ scan_dyntag (const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr) { struct type *ptr_type; gdb_byte ptr_buf[8]; - CORE_ADDR ptr_addr; + CORE_ADDR ptr_addr_1; ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; - ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8; - if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0) + ptr_addr_1 = dyn_addr + (buf - bufstart) + arch_size / 8; + if (target_read_memory (ptr_addr_1, ptr_buf, arch_size / 8) == 0) dyn_ptr = extract_typed_address (ptr_buf, ptr_type); *ptr = dyn_ptr; + if (ptr_addr) + *ptr_addr = dyn_addr + (buf - bufstart); } return 1; } @@ -716,16 +704,19 @@ scan_dyntag (const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr) is returned and the corresponding PTR is set. */ static int -scan_dyntag_auxv (const int desired_dyntag, CORE_ADDR *ptr) +scan_dyntag_auxv (const int desired_dyntag, CORE_ADDR *ptr, + CORE_ADDR *ptr_addr) { enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); int sect_size, arch_size, step; long current_dyntag; CORE_ADDR dyn_ptr; + CORE_ADDR base_addr; gdb_byte *bufend, *bufstart, *buf; /* Read in .dynamic section. */ - buf = bufstart = read_program_header (PT_DYNAMIC, §_size, &arch_size); + buf = bufstart = read_program_header (PT_DYNAMIC, §_size, &arch_size, + &base_addr); if (!buf) return 0; @@ -762,6 +753,9 @@ scan_dyntag_auxv (const int desired_dyntag, CORE_ADDR *ptr) if (ptr) *ptr = dyn_ptr; + if (ptr_addr) + *ptr_addr = base_addr + buf - bufstart; + xfree (bufstart); return 1; } @@ -787,19 +781,19 @@ static CORE_ADDR elf_locate_base (void) { struct bound_minimal_symbol msymbol; - CORE_ADDR dyn_ptr; + CORE_ADDR dyn_ptr, dyn_ptr_addr; /* Look for DT_MIPS_RLD_MAP first. MIPS executables use this instead of DT_DEBUG, although they sometimes contain an unused DT_DEBUG. */ - if (scan_dyntag (DT_MIPS_RLD_MAP, exec_bfd, &dyn_ptr) - || scan_dyntag_auxv (DT_MIPS_RLD_MAP, &dyn_ptr)) + if (scan_dyntag (DT_MIPS_RLD_MAP, exec_bfd, &dyn_ptr, NULL) + || scan_dyntag_auxv (DT_MIPS_RLD_MAP, &dyn_ptr, NULL)) { struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; gdb_byte *pbuf; int pbuf_size = TYPE_LENGTH (ptr_type); - pbuf = alloca (pbuf_size); + pbuf = (gdb_byte *) alloca (pbuf_size); /* DT_MIPS_RLD_MAP contains a pointer to the address of the dynamic link structure. */ if (target_read_memory (dyn_ptr, pbuf, pbuf_size)) @@ -807,9 +801,27 @@ elf_locate_base (void) return extract_typed_address (pbuf, ptr_type); } + /* Then check DT_MIPS_RLD_MAP_REL. MIPS executables now use this form + because of needing to support PIE. DT_MIPS_RLD_MAP will also exist + in non-PIE. */ + if (scan_dyntag (DT_MIPS_RLD_MAP_REL, exec_bfd, &dyn_ptr, &dyn_ptr_addr) + || scan_dyntag_auxv (DT_MIPS_RLD_MAP_REL, &dyn_ptr, &dyn_ptr_addr)) + { + struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; + gdb_byte *pbuf; + int pbuf_size = TYPE_LENGTH (ptr_type); + + pbuf = (gdb_byte *) alloca (pbuf_size); + /* DT_MIPS_RLD_MAP_REL contains an offset from the address of the + DT slot to the address of the dynamic link structure. */ + if (target_read_memory (dyn_ptr + dyn_ptr_addr, pbuf, pbuf_size)) + return 0; + return extract_typed_address (pbuf, ptr_type); + } + /* Find DT_DEBUG. */ - if (scan_dyntag (DT_DEBUG, exec_bfd, &dyn_ptr) - || scan_dyntag_auxv (DT_DEBUG, &dyn_ptr)) + if (scan_dyntag (DT_DEBUG, exec_bfd, &dyn_ptr, NULL) + || scan_dyntag_auxv (DT_DEBUG, &dyn_ptr, NULL)) return dyn_ptr; /* This may be a static executable. Look for the symbol @@ -875,14 +887,18 @@ solib_svr4_r_map (struct svr4_info *info) struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; CORE_ADDR addr = 0; - volatile struct gdb_exception ex; - TRY_CATCH (ex, RETURN_MASK_ERROR) + TRY { addr = read_memory_typed_address (info->debug_base + lmo->r_map_offset, ptr_type); } - exception_print (gdb_stderr, ex); + CATCH (ex, RETURN_MASK_ERROR) + { + exception_print (gdb_stderr, ex); + } + END_CATCH + return addr; } @@ -907,13 +923,22 @@ solib_svr4_r_ldsomap (struct svr4_info *info) struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); - ULONGEST version; + ULONGEST version = 0; + + TRY + { + /* Check version, and return zero if `struct r_debug' doesn't have + the r_ldsomap member. */ + version + = read_memory_unsigned_integer (info->debug_base + lmo->r_version_offset, + lmo->r_version_size, byte_order); + } + CATCH (ex, RETURN_MASK_ERROR) + { + exception_print (gdb_stderr, ex); + } + END_CATCH - /* Check version, and return zero if `struct r_debug' doesn't have - the r_ldsomap member. */ - version - = read_memory_unsigned_integer (info->debug_base + lmo->r_version_offset, - lmo->r_version_size, byte_order); if (version < 2 || lmo->r_ldsomap_offset == -1) return 0; @@ -933,7 +958,7 @@ svr4_keep_data_in_core (CORE_ADDR vaddr, unsigned long size) { struct svr4_info *info; CORE_ADDR ldsomap; - struct so_list *new; + struct so_list *newobj; struct cleanup *old_chain; CORE_ADDR name_lm; @@ -948,11 +973,12 @@ svr4_keep_data_in_core (CORE_ADDR vaddr, unsigned long size) if (!ldsomap) return 0; - new = XCNEW (struct so_list); - old_chain = make_cleanup (xfree, new); - new->lm_info = lm_info_read (ldsomap); - make_cleanup (xfree, new->lm_info); - name_lm = new->lm_info ? new->lm_info->l_name : 0; + newobj = XCNEW (struct so_list); + old_chain = make_cleanup (xfree, newobj); + lm_info_svr4 *li = lm_info_read (ldsomap); + newobj->lm_info = li; + make_cleanup (xfree, newobj->lm_info); + name_lm = li != NULL ? li->l_name : 0; do_cleanups (old_chain); return (name_lm >= vaddr && name_lm < vaddr + size); @@ -975,9 +1001,13 @@ open_symbol_file_object (void *from_ttyp) struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; int l_name_size = TYPE_LENGTH (ptr_type); - gdb_byte *l_name_buf = xmalloc (l_name_size); + gdb_byte *l_name_buf = (gdb_byte *) xmalloc (l_name_size); struct cleanup *cleanups = make_cleanup (xfree, l_name_buf); struct svr4_info *info = get_svr4_info (); + symfile_add_flags add_flags = 0; + + if (from_tty) + add_flags |= SYMFILE_VERBOSE; if (symfile_objfile) if (!query (_("Attempt to reload symbols from process? "))) @@ -1027,7 +1057,7 @@ open_symbol_file_object (void *from_ttyp) } /* Have a pathname: read the symbol file. */ - symbol_file_add_main (filename, from_tty); + symbol_file_add_main (filename, add_flags); do_cleanups (cleanups); return 1; @@ -1050,7 +1080,9 @@ struct svr4_library_list static void svr4_free_so (struct so_list *so) { - xfree (so->lm_info); + lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info; + + delete li; } /* Implement target_so_ops.clear_so. */ @@ -1058,8 +1090,10 @@ svr4_free_so (struct so_list *so) static void svr4_clear_so (struct so_list *so) { - if (so->lm_info != NULL) - so->lm_info->l_addr_p = 0; + lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info; + + if (li != NULL) + li->l_addr_p = 0; } /* Free so_list built so far (called via cleanup). */ @@ -1088,17 +1122,17 @@ svr4_copy_library_list (struct so_list *src) while (src != NULL) { - struct so_list *new; + struct so_list *newobj; - new = xmalloc (sizeof (struct so_list)); - memcpy (new, src, sizeof (struct so_list)); + newobj = XNEW (struct so_list); + memcpy (newobj, src, sizeof (struct so_list)); - new->lm_info = xmalloc (sizeof (struct lm_info)); - memcpy (new->lm_info, src->lm_info, sizeof (struct lm_info)); + lm_info_svr4 *src_li = (lm_info_svr4 *) src->lm_info; + newobj->lm_info = new lm_info_svr4 (*src_li); - new->next = NULL; - *link = new; - link = &new->next; + newobj->next = NULL; + *link = newobj; + link = &newobj->next; src = src->next; } @@ -1118,18 +1152,23 @@ library_list_start_library (struct gdb_xml_parser *parser, const struct gdb_xml_element *element, void *user_data, VEC(gdb_xml_value_s) *attributes) { - struct svr4_library_list *list = user_data; - const char *name = xml_find_attribute (attributes, "name")->value; - ULONGEST *lmp = xml_find_attribute (attributes, "lm")->value; - ULONGEST *l_addrp = xml_find_attribute (attributes, "l_addr")->value; - ULONGEST *l_ldp = xml_find_attribute (attributes, "l_ld")->value; + struct svr4_library_list *list = (struct svr4_library_list *) user_data; + const char *name + = (const char *) xml_find_attribute (attributes, "name")->value; + ULONGEST *lmp + = (ULONGEST *) xml_find_attribute (attributes, "lm")->value; + ULONGEST *l_addrp + = (ULONGEST *) xml_find_attribute (attributes, "l_addr")->value; + ULONGEST *l_ldp + = (ULONGEST *) xml_find_attribute (attributes, "l_ld")->value; struct so_list *new_elem; new_elem = XCNEW (struct so_list); - new_elem->lm_info = XCNEW (struct lm_info); - new_elem->lm_info->lm_addr = *lmp; - new_elem->lm_info->l_addr_inferior = *l_addrp; - new_elem->lm_info->l_ld = *l_ldp; + lm_info_svr4 *li = new lm_info_svr4; + new_elem->lm_info = li; + li->lm_addr = *lmp; + li->l_addr_inferior = *l_addrp; + li->l_ld = *l_ldp; strncpy (new_elem->so_name, name, sizeof (new_elem->so_name) - 1); new_elem->so_name[sizeof (new_elem->so_name) - 1] = 0; @@ -1146,8 +1185,9 @@ 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) { - struct svr4_library_list *list = user_data; - const char *version = xml_find_attribute (attributes, "version")->value; + struct svr4_library_list *list = (struct svr4_library_list *) user_data; + const char *version + = (const char *) xml_find_attribute (attributes, "version")->value; struct gdb_xml_value *main_lm = xml_find_attribute (attributes, "main-lm"); if (strcmp (version, "1.0") != 0) @@ -1273,24 +1313,24 @@ static struct so_list * svr4_default_sos (void) { struct svr4_info *info = get_svr4_info (); - struct so_list *new; + struct so_list *newobj; if (!info->debug_loader_offset_p) return NULL; - new = XCNEW (struct so_list); - - new->lm_info = xzalloc (sizeof (struct lm_info)); + newobj = XCNEW (struct so_list); + lm_info_svr4 *li = new lm_info_svr4; + newobj->lm_info = li; /* Nothing will ever check the other fields if we set l_addr_p. */ - new->lm_info->l_addr = info->debug_loader_offset; - new->lm_info->l_addr_p = 1; + li->l_addr = info->debug_loader_offset; + li->l_addr_p = 1; - strncpy (new->so_name, info->debug_loader_name, SO_NAME_MAX_PATH_SIZE - 1); - new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0'; - strcpy (new->so_original_name, new->so_name); + strncpy (newobj->so_name, info->debug_loader_name, SO_NAME_MAX_PATH_SIZE - 1); + newobj->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0'; + strcpy (newobj->so_original_name, newobj->so_name); - return new; + return newobj; } /* Read the whole inferior libraries chain starting at address LM. @@ -1310,28 +1350,29 @@ svr4_read_so_list (CORE_ADDR lm, CORE_ADDR prev_lm, for (; lm != 0; prev_lm = lm, lm = next_lm) { - struct so_list *new; + struct so_list *newobj; struct cleanup *old_chain; int errcode; char *buffer; - new = XCNEW (struct so_list); - old_chain = make_cleanup_free_so (new); + newobj = XCNEW (struct so_list); + old_chain = make_cleanup_free_so (newobj); - new->lm_info = lm_info_read (lm); - if (new->lm_info == NULL) + lm_info_svr4 *li = lm_info_read (lm); + newobj->lm_info = li; + if (li == NULL) { do_cleanups (old_chain); return 0; } - next_lm = new->lm_info->l_next; + next_lm = li->l_next; - if (new->lm_info->l_prev != prev_lm) + if (li->l_prev != prev_lm) { warning (_("Corrupted shared library list: %s != %s"), paddress (target_gdbarch (), prev_lm), - paddress (target_gdbarch (), new->lm_info->l_prev)); + paddress (target_gdbarch (), li->l_prev)); do_cleanups (old_chain); return 0; } @@ -1341,49 +1382,49 @@ svr4_read_so_list (CORE_ADDR lm, CORE_ADDR prev_lm, SVR4, it has no name. For others (Solaris 2.3 for example), it does have a name, so we can no longer use a missing name to decide when to ignore it. */ - if (ignore_first && new->lm_info->l_prev == 0) + if (ignore_first && li->l_prev == 0) { struct svr4_info *info = get_svr4_info (); - first_l_name = new->lm_info->l_name; - info->main_lm_addr = new->lm_info->lm_addr; + first_l_name = li->l_name; + info->main_lm_addr = li->lm_addr; do_cleanups (old_chain); continue; } /* Extract this shared object's name. */ - target_read_string (new->lm_info->l_name, &buffer, - SO_NAME_MAX_PATH_SIZE - 1, &errcode); + target_read_string (li->l_name, &buffer, SO_NAME_MAX_PATH_SIZE - 1, + &errcode); if (errcode != 0) { /* If this entry's l_name address matches that of the inferior executable, then this is not a normal shared object, but (most likely) a vDSO. In this case, silently skip it; otherwise emit a warning. */ - if (first_l_name == 0 || new->lm_info->l_name != first_l_name) + if (first_l_name == 0 || li->l_name != first_l_name) warning (_("Can't read pathname for load map: %s."), safe_strerror (errcode)); do_cleanups (old_chain); continue; } - strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1); - new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0'; - strcpy (new->so_original_name, new->so_name); + strncpy (newobj->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1); + newobj->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0'; + strcpy (newobj->so_original_name, newobj->so_name); xfree (buffer); /* If this entry has no name, or its name matches the name for the main executable, don't include it in the list. */ - if (! new->so_name[0] || match_main (new->so_name)) + if (! newobj->so_name[0] || match_main (newobj->so_name)) { do_cleanups (old_chain); continue; } discard_cleanups (old_chain); - new->next = 0; - **link_ptr_ptr = new; - *link_ptr_ptr = &new->next; + newobj->next = 0; + **link_ptr_ptr = newobj; + *link_ptr_ptr = &newobj->next; } return 1; @@ -1462,10 +1503,11 @@ svr4_current_sos_direct (struct svr4_info *info) return head; } -/* Implement the "current_sos" target_so_ops method. */ +/* Implement the main part of the "current_sos" target_so_ops + method. */ static struct so_list * -svr4_current_sos (void) +svr4_current_sos_1 (void) { struct svr4_info *info = get_svr4_info (); @@ -1478,6 +1520,85 @@ svr4_current_sos (void) return svr4_current_sos_direct (info); } +/* Implement the "current_sos" target_so_ops method. */ + +static struct so_list * +svr4_current_sos (void) +{ + struct so_list *so_head = svr4_current_sos_1 (); + struct mem_range vsyscall_range; + + /* Filter out the vDSO module, if present. Its symbol file would + not be found on disk. The vDSO/vsyscall's OBJFILE is instead + managed by symfile-mem.c:add_vsyscall_page. */ + if (gdbarch_vsyscall_range (target_gdbarch (), &vsyscall_range) + && vsyscall_range.length != 0) + { + struct so_list **sop; + + sop = &so_head; + while (*sop != NULL) + { + struct so_list *so = *sop; + + /* We can't simply match the vDSO by starting address alone, + because lm_info->l_addr_inferior (and also l_addr) do not + necessarily represent the real starting address of the + ELF if the vDSO's ELF itself is "prelinked". The l_ld + field (the ".dynamic" section of the shared object) + always points at the absolute/resolved address though. + So check whether that address is inside the vDSO's + mapping instead. + + E.g., on Linux 3.16 (x86_64) the vDSO is a regular + 0-based ELF, and we see: + + (gdb) info auxv + 33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffb000 + (gdb) p/x *_r_debug.r_map.l_next + $1 = {l_addr = 0x7ffff7ffb000, ..., l_ld = 0x7ffff7ffb318, ...} + + And on Linux 2.6.32 (x86_64) we see: + + (gdb) info auxv + 33 AT_SYSINFO_EHDR System-supplied DSO's ELF header 0x7ffff7ffe000 + (gdb) p/x *_r_debug.r_map.l_next + $5 = {l_addr = 0x7ffff88fe000, ..., l_ld = 0x7ffff7ffe580, ... } + + Dumping that vDSO shows: + + (gdb) info proc mappings + 0x7ffff7ffe000 0x7ffff7fff000 0x1000 0 [vdso] + (gdb) dump memory vdso.bin 0x7ffff7ffe000 0x7ffff7fff000 + # readelf -Wa vdso.bin + [...] + Entry point address: 0xffffffffff700700 + [...] + Section Headers: + [Nr] Name Type Address Off Size + [ 0] NULL 0000000000000000 000000 000000 + [ 1] .hash HASH ffffffffff700120 000120 000038 + [ 2] .dynsym DYNSYM ffffffffff700158 000158 0000d8 + [...] + [ 9] .dynamic DYNAMIC ffffffffff700580 000580 0000f0 + */ + + lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info; + + if (address_in_mem_range (li->l_ld, &vsyscall_range)) + { + *sop = so->next; + free_so (so); + break; + } + + sop = &so->next; + } + } + + return so_head; +} + /* Get the address of the link_map for a given OBJFILE. */ CORE_ADDR @@ -1488,7 +1609,7 @@ svr4_fetch_objfile_link_map (struct objfile *objfile) /* Cause svr4_current_sos() to be run if it hasn't been already. */ if (info->main_lm_addr == 0) - solib_add (NULL, 0, ¤t_target, auto_solib_add); + solib_add (NULL, 0, auto_solib_add); /* svr4_current_sos() will set main_lm_addr for the main executable. */ if (objfile == symfile_objfile) @@ -1498,7 +1619,11 @@ svr4_fetch_objfile_link_map (struct objfile *objfile) of shared libraries. */ for (so = master_so_list (); so; so = so->next) if (so->objfile == objfile) - return so->lm_info->lm_addr; + { + lm_info_svr4 *li = (lm_info_svr4 *) so->lm_info; + + return li->lm_addr; + } /* Not found! */ return 0; @@ -1579,7 +1704,7 @@ struct probe_and_action static hashval_t hash_probe_and_action (const void *p) { - const struct probe_and_action *pa = p; + const struct probe_and_action *pa = (const struct probe_and_action *) p; return (hashval_t) pa->address; } @@ -1590,8 +1715,8 @@ hash_probe_and_action (const void *p) static int equal_probe_and_action (const void *p1, const void *p2) { - const struct probe_and_action *pa1 = p1; - const struct probe_and_action *pa2 = p2; + const struct probe_and_action *pa1 = (const struct probe_and_action *) p1; + const struct probe_and_action *pa2 = (const struct probe_and_action *) p2; return pa1->address == pa2->address; } @@ -1652,7 +1777,7 @@ static enum probe_action solib_event_probe_action (struct probe_and_action *pa) { enum probe_action action; - unsigned probe_argc; + unsigned probe_argc = 0; struct frame_info *frame = get_current_frame (); action = pa->action; @@ -1666,7 +1791,23 @@ solib_event_probe_action (struct probe_and_action *pa) arg0: Lmid_t lmid (mandatory) arg1: struct r_debug *debug_base (mandatory) arg2: struct link_map *new (optional, for incremental updates) */ - probe_argc = get_probe_argument_count (pa->probe, frame); + TRY + { + probe_argc = get_probe_argument_count (pa->probe, frame); + } + CATCH (ex, RETURN_MASK_ERROR) + { + exception_print (gdb_stderr, ex); + probe_argc = 0; + } + END_CATCH + + /* If get_probe_argument_count throws an exception, probe_argc will + be set to zero. However, if pa->probe does not have arguments, + then get_probe_argument_count will succeed but probe_argc will + also be zero. Both cases happen because of different things, but + they are treated equally here: action will be set to + PROBES_INTERFACE_FAILED. */ if (probe_argc == 2) action = FULL_RELOAD; else if (probe_argc < 2) @@ -1714,7 +1855,9 @@ solist_update_incremental (struct svr4_info *info, CORE_ADDR lm) /* Walk to the end of the list. */ for (tail = info->solib_list; tail->next != NULL; tail = tail->next) /* Nothing. */; - prev_lm = tail->lm_info->lm_addr; + + lm_info_svr4 *li = (lm_info_svr4 *) tail->lm_info; + prev_lm = li->lm_addr; /* Read the new objects. */ if (info->using_xfer) @@ -1772,9 +1915,8 @@ svr4_handle_solib_event (void) struct probe_and_action *pa; enum probe_action action; struct cleanup *old_chain, *usm_chain; - struct value *val; + struct value *val = NULL; CORE_ADDR pc, debug_base, lm = 0; - int is_initial_ns; struct frame_info *frame = get_current_frame (); /* Do nothing if not using the probes interface. */ @@ -1820,7 +1962,17 @@ svr4_handle_solib_event (void) usm_chain = make_cleanup (resume_section_map_updates_cleanup, current_program_space); - val = evaluate_probe_argument (pa->probe, 1, frame); + TRY + { + val = evaluate_probe_argument (pa->probe, 1, frame); + } + CATCH (ex, RETURN_MASK_ERROR) + { + exception_print (gdb_stderr, ex); + val = NULL; + } + END_CATCH + if (val == NULL) { do_cleanups (old_chain); @@ -1851,7 +2003,18 @@ svr4_handle_solib_event (void) if (action == UPDATE_OR_RELOAD) { - val = evaluate_probe_argument (pa->probe, 2, frame); + TRY + { + val = evaluate_probe_argument (pa->probe, 2, frame); + } + CATCH (ex, RETURN_MASK_ERROR) + { + exception_print (gdb_stderr, ex); + do_cleanups (old_chain); + return; + } + END_CATCH + if (val != NULL) lm = value_as_address (val); @@ -1898,7 +2061,8 @@ svr4_update_solib_event_breakpoint (struct breakpoint *b, void *arg) struct svr4_info *info; struct probe_and_action *pa; - info = program_space_data (loc->pspace, solib_svr4_pspace_data); + info = ((struct svr4_info *) + program_space_data (loc->pspace, solib_svr4_pspace_data)); if (info == NULL || info->probes_table == NULL) continue; @@ -2056,7 +2220,7 @@ svr4_create_solib_event_breakpoints (struct gdbarch *gdbarch, /* Helper function for gdb_bfd_lookup_symbol. */ static int -cmp_name_and_sec_flags (asymbol *sym, void *data) +cmp_name_and_sec_flags (const asymbol *sym, const void *data) { return (strcmp (sym->name, (const char *) data) == 0 && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0); @@ -2110,7 +2274,7 @@ enable_break (struct svr4_info *info, int from_tty) mean r_brk has already been relocated. Assume the dynamic linker is the object containing r_brk. */ - solib_add (NULL, from_tty, ¤t_target, auto_solib_add); + solib_add (NULL, from_tty, auto_solib_add); sym_addr = 0; if (info->debug_base && solib_svr4_r_map (info) != 0) sym_addr = solib_svr4_r_brk (info); @@ -2188,9 +2352,7 @@ enable_break (struct svr4_info *info, int from_tty) int load_addr_found = 0; int loader_found_in_list = 0; struct so_list *so; - bfd *tmp_bfd = NULL; struct target_ops *tmp_bfd_target; - volatile struct gdb_exception ex; sym_addr = 0; @@ -2203,19 +2365,23 @@ enable_break (struct svr4_info *info, int from_tty) be trivial on GNU/Linux). Therefore, we have to try an alternate mechanism to find the dynamic linker's base address. */ - TRY_CATCH (ex, RETURN_MASK_ALL) + gdb_bfd_ref_ptr tmp_bfd; + TRY { tmp_bfd = solib_bfd_open (interp_name); } + CATCH (ex, RETURN_MASK_ALL) + { + } + END_CATCH + if (tmp_bfd == NULL) goto bkpt_at_symbol; /* Now convert the TMP_BFD into a target. That way target, as - well as BFD operations can be used. */ - tmp_bfd_target = target_bfd_reopen (tmp_bfd); - /* target_bfd_reopen acquired its own reference, so we can - release ours now. */ - gdb_bfd_unref (tmp_bfd); + well as BFD operations can be used. target_bfd_reopen + acquires its own reference. */ + tmp_bfd_target = target_bfd_reopen (tmp_bfd.get ()); /* On a running target, we can get the dynamic linker's base address from the shared library table. */ @@ -2226,7 +2392,7 @@ enable_break (struct svr4_info *info, int from_tty) { load_addr_found = 1; loader_found_in_list = 1; - load_addr = lm_addr_check (so, tmp_bfd); + load_addr = lm_addr_check (so, tmp_bfd.get ()); break; } so = so->next; @@ -2247,7 +2413,7 @@ enable_break (struct svr4_info *info, int from_tty) if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT)) { CORE_ADDR space_size = (CORE_ADDR) 1 << addr_bit; - CORE_ADDR tmp_entry_point = exec_entry_point (tmp_bfd, + CORE_ADDR tmp_entry_point = exec_entry_point (tmp_bfd.get (), tmp_bfd_target); gdb_assert (load_addr < space_size); @@ -2276,7 +2442,7 @@ enable_break (struct svr4_info *info, int from_tty) = get_thread_arch_regcache (inferior_ptid, target_gdbarch ()); load_addr = (regcache_read_pc (regcache) - - exec_entry_point (tmp_bfd, tmp_bfd_target)); + - exec_entry_point (tmp_bfd.get (), tmp_bfd_target)); } if (!loader_found_in_list) @@ -2284,35 +2450,36 @@ enable_break (struct svr4_info *info, int from_tty) info->debug_loader_name = xstrdup (interp_name); info->debug_loader_offset_p = 1; info->debug_loader_offset = load_addr; - solib_add (NULL, from_tty, ¤t_target, auto_solib_add); + solib_add (NULL, from_tty, auto_solib_add); } /* Record the relocated start and end address of the dynamic linker text and plt section for svr4_in_dynsym_resolve_code. */ - interp_sect = bfd_get_section_by_name (tmp_bfd, ".text"); + interp_sect = bfd_get_section_by_name (tmp_bfd.get (), ".text"); if (interp_sect) { info->interp_text_sect_low = - bfd_section_vma (tmp_bfd, interp_sect) + load_addr; + bfd_section_vma (tmp_bfd.get (), interp_sect) + load_addr; info->interp_text_sect_high = info->interp_text_sect_low - + bfd_section_size (tmp_bfd, interp_sect); + + bfd_section_size (tmp_bfd.get (), interp_sect); } - interp_sect = bfd_get_section_by_name (tmp_bfd, ".plt"); + interp_sect = bfd_get_section_by_name (tmp_bfd.get (), ".plt"); if (interp_sect) { info->interp_plt_sect_low = - bfd_section_vma (tmp_bfd, interp_sect) + load_addr; + bfd_section_vma (tmp_bfd.get (), interp_sect) + load_addr; info->interp_plt_sect_high = info->interp_plt_sect_low - + bfd_section_size (tmp_bfd, interp_sect); + + bfd_section_size (tmp_bfd.get (), interp_sect); } /* Now try to set a breakpoint in the dynamic linker. */ for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++) { - sym_addr = gdb_bfd_lookup_symbol (tmp_bfd, cmp_name_and_sec_flags, - (void *) *bkpt_namep); + sym_addr = gdb_bfd_lookup_symbol (tmp_bfd.get (), + cmp_name_and_sec_flags, + *bkpt_namep); if (sym_addr != 0) break; } @@ -2385,14 +2552,6 @@ enable_break (struct svr4_info *info, int from_tty) return 0; } -/* Implement the "special_symbol_handling" target_so_ops method. */ - -static void -svr4_special_symbol_handling (void) -{ - /* Nothing to do. */ -} - /* Read the ELF program headers from ABFD. Return the contents and set *PHDRS_SIZE to the size of the program headers. */ @@ -2408,7 +2567,7 @@ read_program_headers_from_bfd (bfd *abfd, int *phdrs_size) if (*phdrs_size == 0) return NULL; - buf = xmalloc (*phdrs_size); + buf = (gdb_byte *) xmalloc (*phdrs_size); if (bfd_seek (abfd, ehdr->e_phoff, SEEK_SET) != 0 || bfd_bread (buf, *phdrs_size, abfd) != *phdrs_size) { @@ -2467,7 +2626,7 @@ svr4_exec_displacement (CORE_ADDR *displacementp) { /* ENTRY_POINT is a possible function descriptor - before a call to gdbarch_convert_from_func_ptr_addr. */ - CORE_ADDR entry_point, displacement; + CORE_ADDR entry_point, exec_displacement; if (exec_bfd == NULL) return 0; @@ -2482,9 +2641,9 @@ svr4_exec_displacement (CORE_ADDR *displacementp) if (target_auxv_search (¤t_target, AT_ENTRY, &entry_point) <= 0) return 0; - displacement = entry_point - bfd_get_start_address (exec_bfd); + exec_displacement = entry_point - bfd_get_start_address (exec_bfd); - /* Verify the DISPLACEMENT candidate complies with the required page + /* Verify the EXEC_DISPLACEMENT candidate complies with the required page alignment. It is cheaper than the program headers comparison below. */ if (bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour) @@ -2496,7 +2655,7 @@ svr4_exec_displacement (CORE_ADDR *displacementp) p_offset % p_align == p_vaddr % p_align Kernel is free to load the executable with lower alignment. */ - if ((displacement & (elf->minpagesize - 1)) != 0) + if ((exec_displacement & (elf->minpagesize - 1)) != 0) return 0; } @@ -2514,7 +2673,7 @@ svr4_exec_displacement (CORE_ADDR *displacementp) gdb_byte *buf, *buf2; int arch_size; - buf = read_program_header (-1, &phdrs_size, &arch_size); + buf = read_program_header (-1, &phdrs_size, &arch_size, NULL); buf2 = read_program_headers_from_bfd (exec_bfd, &phdrs2_size); if (buf != NULL && buf2 != NULL) { @@ -2817,11 +2976,11 @@ svr4_exec_displacement (CORE_ADDR *displacementp) printf_unfiltered (_("Using PIE (Position Independent Executable) " "displacement %s for \"%s\".\n"), - paddress (target_gdbarch (), displacement), + paddress (target_gdbarch (), exec_displacement), bfd_get_filename (exec_bfd)); } - *displacementp = displacement; + *displacementp = exec_displacement; return 1; } @@ -2872,8 +3031,8 @@ svr4_relocate_main_executable (void) struct section_offsets *new_offsets; int i; - new_offsets = alloca (symfile_objfile->num_sections - * sizeof (*new_offsets)); + new_offsets = XALLOCAVEC (struct section_offsets, + symfile_objfile->num_sections); for (i = 0; i < symfile_objfile->num_sections; i++) new_offsets->offsets[i] = displacement; @@ -3015,7 +3174,8 @@ void set_solib_svr4_fetch_link_map_offsets (struct gdbarch *gdbarch, struct link_map_offsets *(*flmo) (void)) { - struct solib_svr4_ops *ops = gdbarch_data (gdbarch, solib_svr4_data); + struct solib_svr4_ops *ops + = (struct solib_svr4_ops *) gdbarch_data (gdbarch, solib_svr4_data); ops->fetch_link_map_offsets = flmo; @@ -3028,7 +3188,9 @@ set_solib_svr4_fetch_link_map_offsets (struct gdbarch *gdbarch, static struct link_map_offsets * svr4_fetch_link_map_offsets (void) { - struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch (), solib_svr4_data); + struct solib_svr4_ops *ops + = (struct solib_svr4_ops *) gdbarch_data (target_gdbarch (), + solib_svr4_data); gdb_assert (ops->fetch_link_map_offsets); return ops->fetch_link_map_offsets (); @@ -3039,7 +3201,9 @@ svr4_fetch_link_map_offsets (void) static int svr4_have_link_map_offsets (void) { - struct solib_svr4_ops *ops = gdbarch_data (target_gdbarch (), solib_svr4_data); + struct solib_svr4_ops *ops + = (struct solib_svr4_ops *) gdbarch_data (target_gdbarch (), + solib_svr4_data); return (ops->fetch_link_map_offsets != NULL); } @@ -3118,8 +3282,8 @@ struct target_so_ops svr4_so_ops; different rule for symbol lookup. The lookup begins here in the DSO, not in the main executable. */ -static struct symbol * -elf_lookup_lib_symbol (const struct objfile *objfile, +static struct block_symbol +elf_lookup_lib_symbol (struct objfile *objfile, const char *name, const domain_enum domain) { @@ -3135,8 +3299,8 @@ elf_lookup_lib_symbol (const struct objfile *objfile, abfd = objfile->obfd; } - if (abfd == NULL || scan_dyntag (DT_SYMBOLIC, abfd, NULL) != 1) - return NULL; + if (abfd == NULL || scan_dyntag (DT_SYMBOLIC, abfd, NULL, NULL) != 1) + return (struct block_symbol) {NULL, NULL}; return lookup_global_symbol_from_objfile (objfile, name, domain); } @@ -3155,7 +3319,6 @@ _initialize_svr4_solib (void) svr4_so_ops.clear_so = svr4_clear_so; svr4_so_ops.clear_solib = svr4_clear_solib; svr4_so_ops.solib_create_inferior_hook = svr4_solib_create_inferior_hook; - svr4_so_ops.special_symbol_handling = svr4_special_symbol_handling; svr4_so_ops.current_sos = svr4_current_sos; svr4_so_ops.open_symbol_file_object = open_symbol_file_object; svr4_so_ops.in_dynsym_resolve_code = svr4_in_dynsym_resolve_code;