X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fsolib-svr4.c;h=0b8cadb2dc7879303fb54866707ae88ab5616327;hb=24e31cf3aa66e20877358040ceb35b87dde66d12;hp=2dc1692ab1b0c9384e0e7f2f196d03d1def4a1ba;hpb=3953f15ce4b4154e9fd7951424fedac0170ab59c;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c index 2dc1692ab1..0b8cadb2dc 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-2015 Free Software Foundation, Inc. + Copyright (C) 1990-2019 Free Software Foundation, Inc. This file is part of GDB. @@ -33,7 +33,7 @@ #include "infrun.h" #include "regcache.h" #include "gdbthread.h" -#include "observer.h" +#include "observable.h" #include "solist.h" #include "solib.h" @@ -51,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. @@ -174,8 +153,12 @@ svr4_same_1 (const char *gdb_so_name, const char *inferior_so_name) && strcmp (inferior_so_name, "/lib/ld.so.1") == 0) return 1; - /* Similarly, we observed the same issue with sparc64, but with + /* Similarly, we observed the same issue with amd64 and sparcv9, but with different locations. */ + if (strcmp (gdb_so_name, "/usr/lib/amd64/ld.so.1") == 0 + && strcmp (inferior_so_name, "/lib/amd64/ld.so.1") == 0) + return 1; + if (strcmp (gdb_so_name, "/usr/lib/sparcv9/ld.so.1") == 0 && strcmp (inferior_so_name, "/lib/sparcv9/ld.so.1") == 0) return 1; @@ -189,28 +172,22 @@ 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 std::unique_ptr 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; - struct cleanup *back_to; + std::unique_ptr lm_info; - lm = (gdb_byte *) xmalloc (lmo->link_map_size); - back_to = make_cleanup (xfree, lm); + gdb::byte_vector lm (lmo->link_map_size); - if (target_read_memory (lm_addr, lm, lmo->link_map_size) != 0) - { - warning (_("Error reading shared library list entry at %s"), - paddress (target_gdbarch (), lm_addr)), - lm_info = NULL; - } + if (target_read_memory (lm_addr, lm.data (), lmo->link_map_size) != 0) + warning (_("Error reading shared library list entry at %s"), + paddress (target_gdbarch (), lm_addr)); else { struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; - lm_info = XCNEW (struct lm_info); + lm_info.reset (new lm_info_svr4); lm_info->lm_addr = lm_addr; lm_info->l_addr_inferior = extract_typed_address (&lm[lmo->l_addr_offset], @@ -224,8 +201,6 @@ lm_info_read (CORE_ADDR lm_addr) ptr_type); } - do_cleanups (back_to); - return lm_info; } @@ -240,17 +215,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) @@ -333,11 +310,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. */ @@ -370,7 +347,7 @@ struct svr4_info /* Table of struct probe_and_action instances, used by the probes-based interface to map breakpoint addresses to probes and their associated actions. Lookup is performed using - probe_and_action->probe->address. */ + probe_and_action->prob->address. */ htab_t probes_table; /* List of objects loaded into the inferior, used by the probes- @@ -436,37 +413,34 @@ get_svr4_info (void) static int match_main (const char *); /* Read program header TYPE from inferior memory. The header is found - by scanning the OS auxillary vector. + by scanning the OS auxiliary vector. If TYPE == -1, return the program headers instead of the contents of one program header. - 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 and - the base address of the section is returned in BASE_ADDR. */ + Return vector of bytes holding the program header contents, or an empty + optional on failure. If successful and P_ARCH_SIZE is non-NULL, the target + architecture size (32-bit or 64-bit) is returned to *P_ARCH_SIZE. Likewise, + 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, - CORE_ADDR *base_addr) +static gdb::optional +read_program_header (int type, 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; int arch_size, sect_size; CORE_ADDR sect_addr; - gdb_byte *buf; int pt_phdr_p = 0; /* Get required auxv elements from target. */ - if (target_auxv_search (¤t_target, AT_PHDR, &at_phdr) <= 0) - return 0; - if (target_auxv_search (¤t_target, AT_PHENT, &at_phent) <= 0) - return 0; - if (target_auxv_search (¤t_target, AT_PHNUM, &at_phnum) <= 0) - return 0; + if (target_auxv_search (current_top_target (), AT_PHDR, &at_phdr) <= 0) + return {}; + if (target_auxv_search (current_top_target (), AT_PHENT, &at_phent) <= 0) + return {}; + if (target_auxv_search (current_top_target (), AT_PHNUM, &at_phnum) <= 0) + return {}; if (!at_phdr || !at_phnum) - return 0; + return {}; /* Determine ELF architecture type. */ if (at_phent == sizeof (Elf32_External_Phdr)) @@ -474,7 +448,7 @@ read_program_header (int type, int *p_sect_size, int *p_arch_size, else if (at_phent == sizeof (Elf64_External_Phdr)) arch_size = 64; else - return 0; + return {}; /* Find the requested segment. */ if (type == -1) @@ -494,7 +468,7 @@ read_program_header (int type, int *p_sect_size, int *p_arch_size, if (target_read_memory (at_phdr + i * sizeof (phdr), (gdb_byte *)&phdr, sizeof (phdr))) - return 0; + return {}; p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type, 4, byte_order); @@ -511,7 +485,7 @@ read_program_header (int type, int *p_sect_size, int *p_arch_size, } if (i == at_phnum) - return 0; + return {}; /* Retrieve address and size. */ sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr, @@ -531,7 +505,7 @@ read_program_header (int type, int *p_sect_size, int *p_arch_size, if (target_read_memory (at_phdr + i * sizeof (phdr), (gdb_byte *)&phdr, sizeof (phdr))) - return 0; + return {}; p_type = extract_unsigned_integer ((gdb_byte *) phdr.p_type, 4, byte_order); @@ -548,7 +522,7 @@ read_program_header (int type, int *p_sect_size, int *p_arch_size, } if (i == at_phnum) - return 0; + return {}; /* Retrieve address and size. */ sect_addr = extract_unsigned_integer ((gdb_byte *)phdr.p_vaddr, @@ -568,17 +542,12 @@ read_program_header (int type, int *p_sect_size, int *p_arch_size, } /* Read in requested program header. */ - buf = (gdb_byte *) xmalloc (sect_size); - if (target_read_memory (sect_addr, buf, sect_size)) - { - xfree (buf); - return NULL; - } + gdb::byte_vector buf (sect_size); + if (target_read_memory (sect_addr, buf.data (), sect_size)) + return {}; if (p_arch_size) *p_arch_size = arch_size; - if (p_sect_size) - *p_sect_size = sect_size; if (base_addr) *base_addr = sect_addr; @@ -587,11 +556,9 @@ read_program_header (int type, int *p_sect_size, int *p_arch_size, /* Return program interpreter string. */ -static char * +static gdb::optional find_program_interpreter (void) { - gdb_byte *buf = NULL; - /* If we have an exec_bfd, use its section table. */ if (exec_bfd && bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour) @@ -603,16 +570,15 @@ find_program_interpreter (void) { int sect_size = bfd_section_size (exec_bfd, interp_sect); - buf = (gdb_byte *) xmalloc (sect_size); - bfd_get_section_contents (exec_bfd, interp_sect, buf, 0, sect_size); + gdb::byte_vector buf (sect_size); + bfd_get_section_contents (exec_bfd, interp_sect, buf.data (), 0, + sect_size); + return buf; } } - /* If we didn't find it, use the target auxillary vector. */ - if (!buf) - buf = read_program_header (PT_INTERP, NULL, NULL, NULL); - - return (char *) buf; + /* If we didn't find it, use the target auxiliary vector. */ + return read_program_header (PT_INTERP, NULL, NULL); } @@ -727,24 +693,22 @@ 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; + int 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, - &base_addr); - if (!buf) + gdb::optional ph_data + = read_program_header (PT_DYNAMIC, &arch_size, &base_addr); + if (!ph_data) return 0; /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */ step = (arch_size == 32) ? sizeof (Elf32_External_Dyn) : sizeof (Elf64_External_Dyn); - for (bufend = buf + sect_size; - buf < bufend; - buf += step) + for (gdb_byte *buf = ph_data->data (), *bufend = buf + ph_data->size (); + buf < bufend; buf += step) { if (arch_size == 32) { @@ -773,14 +737,12 @@ scan_dyntag_auxv (const int desired_dyntag, CORE_ADDR *ptr, *ptr = dyn_ptr; if (ptr_addr) - *ptr_addr = base_addr + buf - bufstart; + *ptr_addr = base_addr + buf - ph_data->data (); - xfree (bufstart); return 1; } } - xfree (bufstart); return 0; } @@ -977,8 +939,6 @@ svr4_keep_data_in_core (CORE_ADDR vaddr, unsigned long size) { struct svr4_info *info; CORE_ADDR ldsomap; - struct so_list *newobj; - struct cleanup *old_chain; CORE_ADDR name_lm; info = get_svr4_info (); @@ -992,88 +952,66 @@ svr4_keep_data_in_core (CORE_ADDR vaddr, unsigned long size) if (!ldsomap) return 0; - newobj = XCNEW (struct so_list); - old_chain = make_cleanup (xfree, newobj); - newobj->lm_info = lm_info_read (ldsomap); - make_cleanup (xfree, newobj->lm_info); - name_lm = newobj->lm_info ? newobj->lm_info->l_name : 0; - do_cleanups (old_chain); + std::unique_ptr li = lm_info_read (ldsomap); + name_lm = li != NULL ? li->l_name : 0; return (name_lm >= vaddr && name_lm < vaddr + size); } -/* Implement the "open_symbol_file_object" target_so_ops method. - - If no open symbol file, attempt to locate and open the main symbol - file. On SVR4 systems, this is the first link map entry. If its - name is here, we can open it. Useful when attaching to a process - without first loading its symbol file. */ +/* See solist.h. */ static int -open_symbol_file_object (void *from_ttyp) +open_symbol_file_object (int from_tty) { CORE_ADDR lm, l_name; - char *filename; + gdb::unique_xmalloc_ptr filename; int errcode; - int from_tty = *(int *)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 = (gdb_byte *) xmalloc (l_name_size); - struct cleanup *cleanups = make_cleanup (xfree, l_name_buf); + gdb::byte_vector l_name_buf (l_name_size); 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? "))) - { - do_cleanups (cleanups); - return 0; - } + return 0; /* Always locate the debug struct, in case it has moved. */ info->debug_base = 0; if (locate_base (info) == 0) - { - do_cleanups (cleanups); - return 0; /* failed somehow... */ - } + return 0; /* failed somehow... */ /* First link map member should be the executable. */ lm = solib_svr4_r_map (info); if (lm == 0) - { - do_cleanups (cleanups); - return 0; /* failed somehow... */ - } + return 0; /* failed somehow... */ /* Read address of name from target memory to GDB. */ - read_memory (lm + lmo->l_name_offset, l_name_buf, l_name_size); + read_memory (lm + lmo->l_name_offset, l_name_buf.data (), l_name_size); /* Convert the address to host format. */ - l_name = extract_typed_address (l_name_buf, ptr_type); + l_name = extract_typed_address (l_name_buf.data (), ptr_type); if (l_name == 0) - { - do_cleanups (cleanups); - return 0; /* No filename. */ - } + return 0; /* No filename. */ /* Now fetch the filename from target memory. */ target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode); - make_cleanup (xfree, filename); if (errcode) { warning (_("failed to read exec filename from attached file: %s"), safe_strerror (errcode)); - do_cleanups (cleanups); return 0; } /* Have a pathname: read the symbol file. */ - symbol_file_add_main (filename, from_tty); + symbol_file_add_main (filename.get (), add_flags); - do_cleanups (cleanups); return 1; } @@ -1094,7 +1032,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. */ @@ -1102,8 +1042,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). */ @@ -1137,8 +1079,8 @@ svr4_copy_library_list (struct so_list *src) newobj = XNEW (struct so_list); memcpy (newobj, src, sizeof (struct so_list)); - newobj->lm_info = XNEW (struct lm_info); - memcpy (newobj->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); newobj->next = NULL; *link = newobj; @@ -1160,24 +1102,26 @@ svr4_copy_library_list (struct so_list *src) 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) + void *user_data, + std::vector &attributes) { struct svr4_library_list *list = (struct svr4_library_list *) user_data; const char *name - = (const char *) xml_find_attribute (attributes, "name")->value; + = (const char *) xml_find_attribute (attributes, "name")->value.get (); ULONGEST *lmp - = (ULONGEST *) xml_find_attribute (attributes, "lm")->value; + = (ULONGEST *) xml_find_attribute (attributes, "lm")->value.get (); ULONGEST *l_addrp - = (ULONGEST *) xml_find_attribute (attributes, "l_addr")->value; + = (ULONGEST *) xml_find_attribute (attributes, "l_addr")->value.get (); ULONGEST *l_ldp - = (ULONGEST *) xml_find_attribute (attributes, "l_ld")->value; + = (ULONGEST *) xml_find_attribute (attributes, "l_ld")->value.get (); 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; @@ -1192,11 +1136,12 @@ library_list_start_library (struct gdb_xml_parser *parser, 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) + void *user_data, + std::vector &attributes) { struct svr4_library_list *list = (struct svr4_library_list *) user_data; const char *version - = (const char *) xml_find_attribute (attributes, "version")->value; + = (const char *) xml_find_attribute (attributes, "version")->value.get (); struct gdb_xml_value *main_lm = xml_find_attribute (attributes, "main-lm"); if (strcmp (version, "1.0") != 0) @@ -1205,7 +1150,7 @@ svr4_library_list_start_list (struct gdb_xml_parser *parser, version); if (main_lm) - list->main_lm = *(ULONGEST *) main_lm->value; + list->main_lm = *(ULONGEST *) main_lm->value.get (); } /* The allowed elements and attributes for an XML library list. @@ -1253,8 +1198,10 @@ static const struct gdb_xml_element svr4_library_list_elements[] = static int svr4_parse_libraries (const char *document, struct svr4_library_list *list) { - struct cleanup *back_to = make_cleanup (svr4_free_library_list, - &list->head); + auto cleanup = make_scope_exit ([&] () + { + svr4_free_library_list (&list->head); + }); memset (list, 0, sizeof (*list)); list->tailp = &list->head; @@ -1262,11 +1209,10 @@ svr4_parse_libraries (const char *document, struct svr4_library_list *list) svr4_library_list_elements, document, list) == 0) { /* Parsed successfully, keep the result. */ - discard_cleanups (back_to); + cleanup.release (); return 1; } - do_cleanups (back_to); return 0; } @@ -1284,24 +1230,16 @@ static int svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list, const char *annex) { - char *svr4_library_document; - int result; - struct cleanup *back_to; - gdb_assert (annex == NULL || target_augmented_libraries_svr4_read ()); /* Fetch the list of shared libraries. */ - svr4_library_document = target_read_stralloc (¤t_target, - TARGET_OBJECT_LIBRARIES_SVR4, - annex); - if (svr4_library_document == NULL) + gdb::optional svr4_library_document + = target_read_stralloc (current_top_target (), TARGET_OBJECT_LIBRARIES_SVR4, + annex); + if (!svr4_library_document) return 0; - back_to = make_cleanup (xfree, svr4_library_document); - result = svr4_parse_libraries (svr4_library_document, list); - do_cleanups (back_to); - - return result; + return svr4_parse_libraries (svr4_library_document->data (), list); } #else @@ -1328,12 +1266,12 @@ svr4_default_sos (void) return NULL; newobj = XCNEW (struct so_list); - - newobj->lm_info = XCNEW (struct lm_info); + 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. */ - newobj->lm_info->l_addr = info->debug_loader_offset; - newobj->lm_info->l_addr_p = 1; + li->l_addr = info->debug_loader_offset; + li->l_addr_p = 1; strncpy (newobj->so_name, info->debug_loader_name, SO_NAME_MAX_PATH_SIZE - 1); newobj->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0'; @@ -1359,29 +1297,23 @@ svr4_read_so_list (CORE_ADDR lm, CORE_ADDR prev_lm, for (; lm != 0; prev_lm = lm, lm = next_lm) { - struct so_list *newobj; - struct cleanup *old_chain; int errcode; - char *buffer; + gdb::unique_xmalloc_ptr buffer; - newobj = XCNEW (struct so_list); - old_chain = make_cleanup_free_so (newobj); + so_list_up newobj (XCNEW (struct so_list)); - newobj->lm_info = lm_info_read (lm); - if (newobj->lm_info == NULL) - { - do_cleanups (old_chain); - return 0; - } + lm_info_svr4 *li = lm_info_read (lm).release (); + newobj->lm_info = li; + if (li == NULL) + return 0; - next_lm = newobj->lm_info->l_next; + next_lm = li->l_next; - if (newobj->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 (), newobj->lm_info->l_prev)); - do_cleanups (old_chain); + paddress (target_gdbarch (), li->l_prev)); return 0; } @@ -1390,49 +1322,43 @@ 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 && newobj->lm_info->l_prev == 0) + if (ignore_first && li->l_prev == 0) { struct svr4_info *info = get_svr4_info (); - first_l_name = newobj->lm_info->l_name; - info->main_lm_addr = newobj->lm_info->lm_addr; - do_cleanups (old_chain); + first_l_name = li->l_name; + info->main_lm_addr = li->lm_addr; continue; } /* Extract this shared object's name. */ - target_read_string (newobj->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 || newobj->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 (newobj->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1); + strncpy (newobj->so_name, buffer.get (), 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 (! newobj->so_name[0] || match_main (newobj->so_name)) - { - do_cleanups (old_chain); - continue; - } + continue; - discard_cleanups (old_chain); newobj->next = 0; - **link_ptr_ptr = newobj; - *link_ptr_ptr = &newobj->next; + /* Don't free it now. */ + **link_ptr_ptr = newobj.release (); + *link_ptr_ptr = &(**link_ptr_ptr)->next; } return 1; @@ -1449,7 +1375,6 @@ svr4_current_sos_direct (struct svr4_info *info) CORE_ADDR lm; struct so_list *head = NULL; struct so_list **link_ptr = &head; - struct cleanup *back_to; int ignore_first; struct svr4_library_list library_list; @@ -1487,7 +1412,10 @@ svr4_current_sos_direct (struct svr4_info *info) else ignore_first = 1; - back_to = make_cleanup (svr4_free_library_list, &head); + auto cleanup = make_scope_exit ([&] () + { + svr4_free_library_list (&head); + }); /* Walk the inferior's link map list, and build our list of `struct so_list' nodes. */ @@ -1503,7 +1431,7 @@ svr4_current_sos_direct (struct svr4_info *info) if (lm) svr4_read_so_list (lm, 0, &link_ptr, 0); - discard_cleanups (back_to); + cleanup.release (); if (head == NULL) return svr4_default_sos (); @@ -1590,7 +1518,10 @@ svr4_current_sos (void) [...] [ 9] .dynamic DYNAMIC ffffffffff700580 000580 0000f0 */ - if (address_in_mem_range (so->lm_info->l_ld, &vsyscall_range)) + + 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); @@ -1614,17 +1545,26 @@ 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) return info->main_lm_addr; + /* If OBJFILE is a separate debug object file, look for the + original object file. */ + if (objfile->separate_debug_objfile_backlink != NULL) + objfile = objfile->separate_debug_objfile_backlink; + /* The other link map addresses may be found by examining the list 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; @@ -1691,7 +1631,7 @@ exec_entry_point (struct bfd *abfd, struct target_ops *targ) struct probe_and_action { /* The probe. */ - struct probe *probe; + probe *prob; /* The relocated address of the probe. */ CORE_ADDR address; @@ -1726,7 +1666,7 @@ equal_probe_and_action (const void *p1, const void *p2) probes table. */ static void -register_solib_event_probe (struct probe *probe, CORE_ADDR address, +register_solib_event_probe (probe *prob, CORE_ADDR address, enum probe_action action) { struct svr4_info *info = get_svr4_info (); @@ -1739,13 +1679,13 @@ register_solib_event_probe (struct probe *probe, CORE_ADDR address, equal_probe_and_action, xfree, xcalloc, xfree); - lookup.probe = probe; + lookup.prob = prob; lookup.address = address; slot = htab_find_slot (info->probes_table, &lookup, INSERT); gdb_assert (*slot == HTAB_EMPTY_ENTRY); pa = XCNEW (struct probe_and_action); - pa->probe = probe; + pa->prob = prob; pa->address = address; pa->action = action; @@ -1794,7 +1734,7 @@ solib_event_probe_action (struct probe_and_action *pa) arg2: struct link_map *new (optional, for incremental updates) */ TRY { - probe_argc = get_probe_argument_count (pa->probe, frame); + probe_argc = pa->prob->get_argument_count (frame); } CATCH (ex, RETURN_MASK_ERROR) { @@ -1803,11 +1743,11 @@ solib_event_probe_action (struct probe_and_action *pa) } 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 + /* If get_argument_count throws an exception, probe_argc will be set + to zero. However, if pa->prob does not have arguments, then + get_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; @@ -1856,7 +1796,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) @@ -1892,7 +1834,7 @@ solist_update_incremental (struct svr4_info *info, CORE_ADDR lm) ones set up for the probes-based interface are adequate. */ static void -disable_probes_interface_cleanup (void *arg) +disable_probes_interface () { struct svr4_info *info = get_svr4_info (); @@ -1913,10 +1855,8 @@ svr4_handle_solib_event (void) struct svr4_info *info = get_svr4_info (); struct probe_and_action *pa; enum probe_action action; - struct cleanup *old_chain, *usm_chain; 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. */ @@ -1925,30 +1865,24 @@ svr4_handle_solib_event (void) /* If anything goes wrong we revert to the original linker interface. */ - old_chain = make_cleanup (disable_probes_interface_cleanup, NULL); + auto cleanup = make_scope_exit (disable_probes_interface); pc = regcache_read_pc (get_current_regcache ()); pa = solib_event_probe_at (info, pc); if (pa == NULL) - { - do_cleanups (old_chain); - return; - } + return; action = solib_event_probe_action (pa); if (action == PROBES_INTERFACE_FAILED) - { - do_cleanups (old_chain); - return; - } + return; if (action == DO_NOTHING) { - discard_cleanups (old_chain); + cleanup.release (); return; } - /* evaluate_probe_argument looks up symbols in the dynamic linker + /* evaluate_argument looks up symbols in the dynamic linker using find_pc_section. find_pc_section is accelerated by a cache called the section map. The section map is invalidated every time a shared library is loaded or unloaded, and if the inferior @@ -1957,73 +1891,64 @@ svr4_handle_solib_event (void) We called find_pc_section in svr4_create_solib_event_breakpoints, so we can guarantee that the dynamic linker's sections are in the section map. We can therefore inhibit section map updates across - these calls to evaluate_probe_argument and save a lot of time. */ - inhibit_section_map_updates (current_program_space); - usm_chain = make_cleanup (resume_section_map_updates_cleanup, - current_program_space); + these calls to evaluate_argument and save a lot of time. */ + { + scoped_restore inhibit_updates + = inhibit_section_map_updates (current_program_space); - TRY - { - val = evaluate_probe_argument (pa->probe, 1, frame); - } - CATCH (ex, RETURN_MASK_ERROR) - { - exception_print (gdb_stderr, ex); - val = NULL; - } - END_CATCH + TRY + { + val = pa->prob->evaluate_argument (1, frame); + } + CATCH (ex, RETURN_MASK_ERROR) + { + exception_print (gdb_stderr, ex); + val = NULL; + } + END_CATCH - if (val == NULL) - { - do_cleanups (old_chain); + if (val == NULL) return; - } - debug_base = value_as_address (val); - if (debug_base == 0) - { - do_cleanups (old_chain); + debug_base = value_as_address (val); + if (debug_base == 0) return; - } - /* Always locate the debug struct, in case it moved. */ - info->debug_base = 0; - if (locate_base (info) == 0) - { - do_cleanups (old_chain); + /* Always locate the debug struct, in case it moved. */ + info->debug_base = 0; + if (locate_base (info) == 0) return; - } - /* GDB does not currently support libraries loaded via dlmopen - into namespaces other than the initial one. We must ignore - any namespace other than the initial namespace here until - support for this is added to GDB. */ - if (debug_base != info->debug_base) - action = DO_NOTHING; + /* GDB does not currently support libraries loaded via dlmopen + into namespaces other than the initial one. We must ignore + any namespace other than the initial namespace here until + support for this is added to GDB. */ + if (debug_base != info->debug_base) + action = DO_NOTHING; - if (action == UPDATE_OR_RELOAD) - { - 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 (action == UPDATE_OR_RELOAD) + { + TRY + { + val = pa->prob->evaluate_argument (2, frame); + } + CATCH (ex, RETURN_MASK_ERROR) + { + exception_print (gdb_stderr, ex); + return; + } + END_CATCH - if (val != NULL) - lm = value_as_address (val); + if (val != NULL) + lm = value_as_address (val); - if (lm == 0) - action = FULL_RELOAD; - } + if (lm == 0) + action = FULL_RELOAD; + } - /* Resume section map updates. */ - do_cleanups (usm_chain); + /* Resume section map updates. Closing the scope is + sufficient. */ + } if (action == UPDATE_OR_RELOAD) { @@ -2034,13 +1959,10 @@ svr4_handle_solib_event (void) if (action == FULL_RELOAD) { if (!solist_update_full (info)) - { - do_cleanups (old_chain); - return; - } + return; } - discard_cleanups (old_chain); + cleanup.release (); } /* Helper function for svr4_update_solib_event_breakpoints. */ @@ -2101,25 +2023,19 @@ svr4_update_solib_event_breakpoints (void) static void svr4_create_probe_breakpoints (struct gdbarch *gdbarch, - VEC (probe_p) **probes, + const std::vector *probes, struct objfile *objfile) { - int i; - - for (i = 0; i < NUM_PROBES; i++) + for (int i = 0; i < NUM_PROBES; i++) { enum probe_action action = probe_info[i].action; - struct probe *probe; - int ix; - for (ix = 0; - VEC_iterate (probe_p, probes[i], ix, probe); - ++ix) + for (probe *p : probes[i]) { - CORE_ADDR address = get_probe_address (probe, objfile); + CORE_ADDR address = p->get_relocated_address (objfile); create_solib_event_breakpoint (gdbarch, address); - register_solib_event_probe (probe, address, action); + register_solib_event_probe (p, address, action); } } @@ -2151,16 +2067,14 @@ svr4_create_solib_event_breakpoints (struct gdbarch *gdbarch, for (with_prefix = 0; with_prefix <= 1; with_prefix++) { - VEC (probe_p) *probes[NUM_PROBES]; + std::vector probes[NUM_PROBES]; int all_probes_found = 1; int checked_can_use_probe_arguments = 0; - int i; - memset (probes, 0, sizeof (probes)); - for (i = 0; i < NUM_PROBES; i++) + for (int i = 0; i < NUM_PROBES; i++) { const char *name = probe_info[i].name; - struct probe *p; + probe *p; char buf[32]; /* Fedora 17 and Red Hat Enterprise Linux 6.2-6.4 @@ -2184,7 +2098,7 @@ svr4_create_solib_event_breakpoints (struct gdbarch *gdbarch, if (strcmp (name, "rtld_map_failed") == 0) continue; - if (VEC_empty (probe_p, probes[i])) + if (probes[i].empty ()) { all_probes_found = 0; break; @@ -2193,8 +2107,8 @@ svr4_create_solib_event_breakpoints (struct gdbarch *gdbarch, /* Ensure probe arguments can be evaluated. */ if (!checked_can_use_probe_arguments) { - p = VEC_index (probe_p, probes[i], 0); - if (!can_evaluate_probe_arguments (p)) + p = probes[i][0]; + if (!p->can_evaluate_arguments ()) { all_probes_found = 0; break; @@ -2206,9 +2120,6 @@ svr4_create_solib_event_breakpoints (struct gdbarch *gdbarch, if (all_probes_found) svr4_create_probe_breakpoints (gdbarch, probes, os->objfile); - for (i = 0; i < NUM_PROBES; i++) - VEC_free (probe_p, probes[i]); - if (all_probes_found) return; } @@ -2263,7 +2174,6 @@ enable_break (struct svr4_info *info, int from_tty) struct bound_minimal_symbol msymbol; const char * const *bkpt_namep; asection *interp_sect; - char *interp_name; CORE_ADDR sym_addr; info->interp_text_sect_low = info->interp_text_sect_high = 0; @@ -2274,7 +2184,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); @@ -2284,9 +2194,10 @@ enable_break (struct svr4_info *info, int from_tty) struct obj_section *os; sym_addr = gdbarch_addr_bits_remove - (target_gdbarch (), gdbarch_convert_from_func_ptr_addr (target_gdbarch (), - sym_addr, - ¤t_target)); + (target_gdbarch (), + gdbarch_convert_from_func_ptr_addr (target_gdbarch (), + sym_addr, + current_top_target ())); /* On at least some versions of Solaris there's a dynamic relocation on _r_debug.r_brk and SYM_ADDR may not be relocated yet, e.g., if @@ -2345,14 +2256,15 @@ enable_break (struct svr4_info *info, int from_tty) /* Find the program interpreter; if not found, warn the user and drop into the old breakpoint at symbol code. */ - interp_name = find_program_interpreter (); - if (interp_name) + gdb::optional interp_name_holder + = find_program_interpreter (); + if (interp_name_holder) { + const char *interp_name = (const char *) interp_name_holder->data (); CORE_ADDR load_addr = 0; 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; sym_addr = 0; @@ -2366,6 +2278,7 @@ 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. */ + gdb_bfd_ref_ptr tmp_bfd; TRY { tmp_bfd = solib_bfd_open (interp_name); @@ -2379,11 +2292,9 @@ enable_break (struct svr4_info *info, int from_tty) 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. */ @@ -2394,7 +2305,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; @@ -2403,7 +2314,7 @@ enable_break (struct svr4_info *info, int from_tty) /* If we were not able to find the base address of the loader from our so_list, then try using the AT_BASE auxilliary entry. */ if (!load_addr_found) - if (target_auxv_search (¤t_target, AT_BASE, &load_addr) > 0) + if (target_auxv_search (current_top_target (), AT_BASE, &load_addr) > 0) { int addr_bit = gdbarch_addr_bit (target_gdbarch ()); @@ -2415,7 +2326,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); @@ -2444,7 +2355,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) @@ -2452,34 +2363,35 @@ 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, + sym_addr = gdb_bfd_lookup_symbol (tmp_bfd.get (), + cmp_name_and_sec_flags, *bkpt_namep); if (sym_addr != 0) break; @@ -2502,14 +2414,12 @@ enable_break (struct svr4_info *info, int from_tty) { svr4_create_solib_event_breakpoints (target_gdbarch (), load_addr + sym_addr); - xfree (interp_name); return 1; } /* For whatever reason we couldn't set a breakpoint in the dynamic linker. Warn and drop into the old code. */ bkpt_at_symbol: - xfree (interp_name); warning (_("Unable to find dynamic linker breakpoint function.\n" "GDB will be unable to debug shared library initializers\n" "and track explicitly loaded dynamic code.")); @@ -2527,13 +2437,13 @@ enable_break (struct svr4_info *info, int from_tty) sym_addr = BMSYMBOL_VALUE_ADDRESS (msymbol); sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (), sym_addr, - ¤t_target); + current_top_target ()); svr4_create_solib_event_breakpoints (target_gdbarch (), sym_addr); return 1; } } - if (interp_name != NULL && !current_inferior ()->attach_flag) + if (interp_name_holder && !current_inferior ()->attach_flag) { for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++) { @@ -2544,7 +2454,7 @@ enable_break (struct svr4_info *info, int from_tty) sym_addr = BMSYMBOL_VALUE_ADDRESS (msymbol); sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (), sym_addr, - ¤t_target); + current_top_target ()); svr4_create_solib_event_breakpoints (target_gdbarch (), sym_addr); return 1; } @@ -2553,36 +2463,20 @@ enable_break (struct svr4_info *info, int from_tty) return 0; } -/* Implement the "special_symbol_handling" target_so_ops method. */ +/* Read the ELF program headers from ABFD. */ -static void -svr4_special_symbol_handling (void) +static gdb::optional +read_program_headers_from_bfd (bfd *abfd) { - /* Nothing to do. */ -} - -/* Read the ELF program headers from ABFD. Return the contents and - set *PHDRS_SIZE to the size of the program headers. */ + Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd); + int phdrs_size = ehdr->e_phnum * ehdr->e_phentsize; + if (phdrs_size == 0) + return {}; -static gdb_byte * -read_program_headers_from_bfd (bfd *abfd, int *phdrs_size) -{ - Elf_Internal_Ehdr *ehdr; - gdb_byte *buf; - - ehdr = elf_elfheader (abfd); - - *phdrs_size = ehdr->e_phnum * ehdr->e_phentsize; - if (*phdrs_size == 0) - return NULL; - - buf = (gdb_byte *) xmalloc (*phdrs_size); + gdb::byte_vector buf (phdrs_size); if (bfd_seek (abfd, ehdr->e_phoff, SEEK_SET) != 0 - || bfd_bread (buf, *phdrs_size, abfd) != *phdrs_size) - { - xfree (buf); - return NULL; - } + || bfd_bread (buf.data (), phdrs_size, abfd) != phdrs_size) + return {}; return buf; } @@ -2647,7 +2541,7 @@ svr4_exec_displacement (CORE_ADDR *displacementp) if ((bfd_get_file_flags (exec_bfd) & DYNAMIC) == 0) return 0; - if (target_auxv_search (¤t_target, AT_ENTRY, &entry_point) <= 0) + if (target_auxv_search (current_top_target (), AT_ENTRY, &entry_point) <= 0) return 0; exec_displacement = entry_point - bfd_get_start_address (exec_bfd); @@ -2676,15 +2570,15 @@ svr4_exec_displacement (CORE_ADDR *displacementp) if (bfd_get_flavour (exec_bfd) == bfd_target_elf_flavour) { - /* Be optimistic and clear OK only if GDB was able to verify the headers + /* Be optimistic and return 0 only if GDB was able to verify the headers really do not match. */ - int phdrs_size, phdrs2_size, ok = 1; - gdb_byte *buf, *buf2; int 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) + gdb::optional phdrs_target + = read_program_header (-1, &arch_size, NULL); + gdb::optional phdrs_binary + = read_program_headers_from_bfd (exec_bfd); + if (phdrs_target && phdrs_binary) { enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); @@ -2701,12 +2595,12 @@ svr4_exec_displacement (CORE_ADDR *displacementp) relocate BUF and BUF2 just by the EXEC_BFD vs. target memory content offset for the verification purpose. */ - if (phdrs_size != phdrs2_size + if (phdrs_target->size () != phdrs_binary->size () || bfd_get_arch_size (exec_bfd) != arch_size) - ok = 0; + return 0; else if (arch_size == 32 - && phdrs_size >= sizeof (Elf32_External_Phdr) - && phdrs_size % sizeof (Elf32_External_Phdr) == 0) + && phdrs_target->size () >= sizeof (Elf32_External_Phdr) + && phdrs_target->size () % sizeof (Elf32_External_Phdr) == 0) { Elf_Internal_Ehdr *ehdr2 = elf_tdata (exec_bfd)->elf_header; Elf_Internal_Phdr *phdr2 = elf_tdata (exec_bfd)->phdr; @@ -2727,7 +2621,7 @@ svr4_exec_displacement (CORE_ADDR *displacementp) CORE_ADDR displacement_vaddr = 0; CORE_ADDR displacement_paddr = 0; - phdrp = &((Elf32_External_Phdr *) buf)[i]; + phdrp = &((Elf32_External_Phdr *) phdrs_target->data ())[i]; buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr; buf_paddr_p = (gdb_byte *) &phdrp->p_paddr; @@ -2745,9 +2639,12 @@ svr4_exec_displacement (CORE_ADDR *displacementp) break; } - /* Now compare BUF and BUF2 with optional DISPLACEMENT. */ + /* Now compare program headers from the target and the binary + with optional DISPLACEMENT. */ - for (i = 0; i < phdrs_size / sizeof (Elf32_External_Phdr); i++) + for (i = 0; + i < phdrs_target->size () / sizeof (Elf32_External_Phdr); + i++) { Elf32_External_Phdr *phdrp; Elf32_External_Phdr *phdr2p; @@ -2755,10 +2652,10 @@ svr4_exec_displacement (CORE_ADDR *displacementp) CORE_ADDR vaddr, paddr; asection *plt2_asect; - phdrp = &((Elf32_External_Phdr *) buf)[i]; + phdrp = &((Elf32_External_Phdr *) phdrs_target->data ())[i]; buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr; buf_paddr_p = (gdb_byte *) &phdrp->p_paddr; - phdr2p = &((Elf32_External_Phdr *) buf2)[i]; + phdr2p = &((Elf32_External_Phdr *) phdrs_binary->data ())[i]; /* PT_GNU_STACK is an exception by being never relocated by prelink as its addresses are always zero. */ @@ -2783,8 +2680,10 @@ svr4_exec_displacement (CORE_ADDR *displacementp) /* Strip modifies the flags and alignment of PT_GNU_RELRO. CentOS-5 has problems with filesz, memsz as well. + Strip also modifies memsz of PT_TLS. See PR 11786. */ - if (phdr2[i].p_type == PT_GNU_RELRO) + if (phdr2[i].p_type == PT_GNU_RELRO + || phdr2[i].p_type == PT_TLS) { Elf32_External_Phdr tmp_phdr = *phdrp; Elf32_External_Phdr tmp_phdr2 = *phdr2p; @@ -2831,13 +2730,12 @@ svr4_exec_displacement (CORE_ADDR *displacementp) continue; } - ok = 0; - break; + return 0; } } else if (arch_size == 64 - && phdrs_size >= sizeof (Elf64_External_Phdr) - && phdrs_size % sizeof (Elf64_External_Phdr) == 0) + && phdrs_target->size () >= sizeof (Elf64_External_Phdr) + && phdrs_target->size () % sizeof (Elf64_External_Phdr) == 0) { Elf_Internal_Ehdr *ehdr2 = elf_tdata (exec_bfd)->elf_header; Elf_Internal_Phdr *phdr2 = elf_tdata (exec_bfd)->phdr; @@ -2858,7 +2756,7 @@ svr4_exec_displacement (CORE_ADDR *displacementp) CORE_ADDR displacement_vaddr = 0; CORE_ADDR displacement_paddr = 0; - phdrp = &((Elf64_External_Phdr *) buf)[i]; + phdrp = &((Elf64_External_Phdr *) phdrs_target->data ())[i]; buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr; buf_paddr_p = (gdb_byte *) &phdrp->p_paddr; @@ -2878,7 +2776,9 @@ svr4_exec_displacement (CORE_ADDR *displacementp) /* Now compare BUF and BUF2 with optional DISPLACEMENT. */ - for (i = 0; i < phdrs_size / sizeof (Elf64_External_Phdr); i++) + for (i = 0; + i < phdrs_target->size () / sizeof (Elf64_External_Phdr); + i++) { Elf64_External_Phdr *phdrp; Elf64_External_Phdr *phdr2p; @@ -2886,10 +2786,10 @@ svr4_exec_displacement (CORE_ADDR *displacementp) CORE_ADDR vaddr, paddr; asection *plt2_asect; - phdrp = &((Elf64_External_Phdr *) buf)[i]; + phdrp = &((Elf64_External_Phdr *) phdrs_target->data ())[i]; buf_vaddr_p = (gdb_byte *) &phdrp->p_vaddr; buf_paddr_p = (gdb_byte *) &phdrp->p_paddr; - phdr2p = &((Elf64_External_Phdr *) buf2)[i]; + phdr2p = &((Elf64_External_Phdr *) phdrs_binary->data ())[i]; /* PT_GNU_STACK is an exception by being never relocated by prelink as its addresses are always zero. */ @@ -2914,8 +2814,10 @@ svr4_exec_displacement (CORE_ADDR *displacementp) /* Strip modifies the flags and alignment of PT_GNU_RELRO. CentOS-5 has problems with filesz, memsz as well. + Strip also modifies memsz of PT_TLS. See PR 11786. */ - if (phdr2[i].p_type == PT_GNU_RELRO) + if (phdr2[i].p_type == PT_GNU_RELRO + || phdr2[i].p_type == PT_TLS) { Elf64_External_Phdr tmp_phdr = *phdrp; Elf64_External_Phdr tmp_phdr2 = *phdr2p; @@ -2962,19 +2864,12 @@ svr4_exec_displacement (CORE_ADDR *displacementp) continue; } - ok = 0; - break; + return 0; } } else - ok = 0; + return 0; } - - xfree (buf); - xfree (buf2); - - if (!ok) - return 0; } if (info_verbose) @@ -3309,13 +3204,11 @@ elf_lookup_lib_symbol (struct objfile *objfile, } if (abfd == NULL || scan_dyntag (DT_SYMBOLIC, abfd, NULL, NULL) != 1) - return (struct block_symbol) {NULL, NULL}; + return {}; return lookup_global_symbol_from_objfile (objfile, name, domain); } -extern initialize_file_ftype _initialize_svr4_solib; /* -Wmissing-prototypes */ - void _initialize_svr4_solib (void) { @@ -3328,7 +3221,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;