X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fsolib-svr4.c;h=11e29c1868adab713d1498a8901b18ea6c74baf4;hb=a6535de1903d9caad8c10c1d81c51a29612456a6;hp=36b6c598a4fae80819d34cbfef43e32a5adcdffe;hpb=8d7493201cf01c9836403695f67f7e157341bfd5;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c index 36b6c598a4..11e29c1868 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-2018 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. @@ -189,28 +168,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 = 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 +197,6 @@ lm_info_read (CORE_ADDR lm_addr) ptr_type); } - do_cleanups (back_to); - return lm_info; } @@ -240,17 +211,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 +306,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 +343,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- @@ -405,7 +378,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); @@ -421,7 +394,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; @@ -567,7 +541,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); @@ -602,7 +576,7 @@ 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); } } @@ -666,7 +640,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; @@ -811,7 +785,7 @@ elf_locate_base (void) 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)) @@ -829,7 +803,7 @@ elf_locate_base (void) gdb_byte *pbuf; int pbuf_size = TYPE_LENGTH (ptr_type); - pbuf = alloca (pbuf_size); + 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)) @@ -976,8 +950,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 (); @@ -991,88 +963,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 = 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; } @@ -1093,7 +1043,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. */ @@ -1101,8 +1053,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). */ @@ -1136,8 +1090,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; @@ -1159,20 +1113,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) -{ - 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; + 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.get (); + ULONGEST *lmp + = (ULONGEST *) xml_find_attribute (attributes, "lm")->value.get (); + ULONGEST *l_addrp + = (ULONGEST *) xml_find_attribute (attributes, "l_addr")->value.get (); + ULONGEST *l_ldp + = (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; @@ -1187,10 +1147,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 = 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.get (); struct gdb_xml_value *main_lm = xml_find_attribute (attributes, "main-lm"); if (strcmp (version, "1.0") != 0) @@ -1199,7 +1161,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. @@ -1278,24 +1240,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); + gdb::unique_xmalloc_ptr svr4_library_document + = target_read_stralloc (¤t_target, TARGET_OBJECT_LIBRARIES_SVR4, + annex); if (svr4_library_document == NULL) 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.get (), list); } #else @@ -1322,12 +1276,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'; @@ -1353,29 +1307,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; } @@ -1384,49 +1332,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; @@ -1584,7 +1526,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); @@ -1608,7 +1553,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) @@ -1618,7 +1563,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; @@ -1685,7 +1634,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; @@ -1699,7 +1648,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; } @@ -1710,8 +1659,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; } @@ -1720,7 +1669,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 (); @@ -1733,13 +1682,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; @@ -1772,7 +1721,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; @@ -1786,7 +1735,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 = pa->prob->get_argument_count (frame); + } + CATCH (ex, RETURN_MASK_ERROR) + { + exception_print (gdb_stderr, ex); + probe_argc = 0; + } + END_CATCH + + /* 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; else if (probe_argc < 2) @@ -1834,7 +1799,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,9 +1859,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. */ @@ -1926,7 +1892,7 @@ svr4_handle_solib_event (void) 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 @@ -1935,12 +1901,22 @@ 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. */ + these calls to evaluate_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); - val = evaluate_probe_argument (pa->probe, 1, frame); + 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); @@ -1971,7 +1947,18 @@ svr4_handle_solib_event (void) if (action == UPDATE_OR_RELOAD) { - val = evaluate_probe_argument (pa->probe, 2, frame); + TRY + { + val = pa->prob->evaluate_argument (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); @@ -2018,7 +2005,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; @@ -2057,25 +2045,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); } } @@ -2107,16 +2089,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 @@ -2140,7 +2120,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; @@ -2149,8 +2129,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; @@ -2162,9 +2142,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; } @@ -2176,7 +2153,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); @@ -2230,7 +2207,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); @@ -2308,7 +2285,6 @@ 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; sym_addr = 0; @@ -2322,6 +2298,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); @@ -2335,11 +2312,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. */ @@ -2350,7 +2325,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; @@ -2371,7 +2346,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); @@ -2400,7 +2375,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) @@ -2408,35 +2383,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; } @@ -2509,14 +2485,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. */ @@ -2532,7 +2500,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) { @@ -2996,8 +2964,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; @@ -3139,7 +3107,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; @@ -3152,7 +3121,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 (); @@ -3163,7 +3134,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); } @@ -3265,8 +3238,6 @@ elf_lookup_lib_symbol (struct objfile *objfile, return lookup_global_symbol_from_objfile (objfile, name, domain); } -extern initialize_file_ftype _initialize_svr4_solib; /* -Wmissing-prototypes */ - void _initialize_svr4_solib (void) { @@ -3279,7 +3250,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;