From patchwork Mon Jul 15 20:27:58 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Tromey X-Patchwork-Id: 33693 Received: (qmail 87502 invoked by alias); 15 Jul 2019 20:28:04 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 87493 invoked by uid 89); 15 Jul 2019 20:28:04 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-22.3 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.1 spammy=Hardware, fro X-HELO: rock.gnat.com Received: from rock.gnat.com (HELO rock.gnat.com) (205.232.38.15) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 15 Jul 2019 20:28:02 +0000 Received: from localhost (localhost.localdomain [127.0.0.1]) by filtered-rock.gnat.com (Postfix) with ESMTP id C90D156016; Mon, 15 Jul 2019 16:28:00 -0400 (EDT) Received: from rock.gnat.com ([127.0.0.1]) by localhost (rock.gnat.com [127.0.0.1]) (amavisd-new, port 10024) with LMTP id 5CczCdnfLdGu; Mon, 15 Jul 2019 16:28:00 -0400 (EDT) Received: from murgatroyd.Home (97-122-178-82.hlrn.qwest.net [97.122.178.82]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by rock.gnat.com (Postfix) with ESMTPSA id 7009656015; Mon, 15 Jul 2019 16:28:00 -0400 (EDT) From: Tom Tromey To: gdb-patches@sourceware.org Cc: Tom Tromey Subject: [PATCH] Remove a VEC from s390-linux-nat.c Date: Mon, 15 Jul 2019 14:27:58 -0600 Message-Id: <20190715202758.23743-1-tromey@adacore.com> MIME-Version: 1.0 This removes a use of VEC fro s390-linux-nat.c, replacing it with std::vector. Tested using the Fedora-s390x-m64 buildbot builder. gdb/ChangeLog 2019-07-15 Tom Tromey * s390-linux-nat.c (s390_watch_area): Remove typedef. Don't declare VEC. (struct s390_debug_reg_state) : Now std::vector. (struct s390_process_info): Add initializers. (s390_add_process): Use new. (s390_linux_nat_target::low_forget_process): Use delete. (s390_linux_nat_target::low_new_fork) (s390_linux_nat_target::stopped_by_watchpoint) (s390_linux_nat_target::low_prepare_to_resume) (s390_linux_nat_target::insert_watchpoint) (s390_linux_nat_target::insert_hw_breakpoint) (s390_linux_nat_target::remove_watchpoint) (s390_linux_nat_target::remove_hw_breakpoint): Update. --- gdb/ChangeLog | 17 ++++++++++ gdb/s390-linux-nat.c | 80 ++++++++++++++++++-------------------------- 2 files changed, 49 insertions(+), 48 deletions(-) diff --git a/gdb/s390-linux-nat.c b/gdb/s390-linux-nat.c index ecb90b2422b..e77f4ac14d4 100644 --- a/gdb/s390-linux-nat.c +++ b/gdb/s390-linux-nat.c @@ -500,28 +500,26 @@ s390_linux_nat_target::store_registers (struct regcache *regcache, int regnum) The only thing we actually need is the total address space area spanned by the watchpoints. */ -typedef struct watch_area +struct watch_area { CORE_ADDR lo_addr; CORE_ADDR hi_addr; -} s390_watch_area; - -DEF_VEC_O (s390_watch_area); +}; /* Hardware debug state. */ struct s390_debug_reg_state { - VEC_s390_watch_area *watch_areas; - VEC_s390_watch_area *break_areas; + std::vector watch_areas; + std::vector break_areas; }; /* Per-process data. */ struct s390_process_info { - struct s390_process_info *next; - pid_t pid; + struct s390_process_info *next = nullptr; + pid_t pid = 0; struct s390_debug_reg_state state; }; @@ -547,7 +545,7 @@ s390_find_process_pid (pid_t pid) static struct s390_process_info * s390_add_process (pid_t pid) { - struct s390_process_info *proc = XCNEW (struct s390_process_info); + struct s390_process_info *proc = new struct s390_process_info; proc->pid = pid; proc->next = s390_process_list; @@ -594,10 +592,8 @@ s390_linux_nat_target::low_forget_process (pid_t pid) { if (proc->pid == pid) { - VEC_free (s390_watch_area, proc->state.watch_areas); - VEC_free (s390_watch_area, proc->state.break_areas); *proc_link = proc->next; - xfree (proc); + delete proc; return; } @@ -627,10 +623,8 @@ s390_linux_nat_target::low_new_fork (struct lwp_info *parent, pid_t child_pid) parent_state = s390_get_debug_reg_state (parent_pid); child_state = s390_get_debug_reg_state (child_pid); - child_state->watch_areas = VEC_copy (s390_watch_area, - parent_state->watch_areas); - child_state->break_areas = VEC_copy (s390_watch_area, - parent_state->break_areas); + child_state->watch_areas = parent_state->watch_areas; + child_state->break_areas = parent_state->break_areas; } /* Dump PER state. */ @@ -676,7 +670,7 @@ s390_linux_nat_target::stopped_by_watchpoint () s390_show_debug_regs (s390_inferior_tid (), "stop"); /* Speed up common case. */ - if (VEC_empty (s390_watch_area, state->watch_areas)) + if (state->watch_areas.empty ()) return false; parea.len = sizeof (per_lowcore); @@ -711,8 +705,6 @@ s390_linux_nat_target::low_prepare_to_resume (struct lwp_info *lp) ptrace_area parea; CORE_ADDR watch_lo_addr = (CORE_ADDR)-1, watch_hi_addr = 0; - unsigned ix; - s390_watch_area *area; struct arch_lwp_info *lp_priv = lwp_arch_private_info (lp); struct s390_debug_reg_state *state = s390_get_debug_reg_state (pid); int step = lwp_is_stepping (lp); @@ -725,7 +717,7 @@ s390_linux_nat_target::low_prepare_to_resume (struct lwp_info *lp) hardware breakpoints (if any). Otherwise we're done. */ if (!lp_priv->per_info_changed) { - if (!step || VEC_empty (s390_watch_area, state->break_areas)) + if (!step || state->break_areas.empty ()) return; } @@ -744,14 +736,12 @@ s390_linux_nat_target::low_prepare_to_resume (struct lwp_info *lp) memset (&per_info, 0, sizeof (per_info)); per_info.single_step = (step != 0); - if (!VEC_empty (s390_watch_area, state->watch_areas)) + if (!state->watch_areas.empty ()) { - for (ix = 0; - VEC_iterate (s390_watch_area, state->watch_areas, ix, area); - ix++) + for (const auto &area : state->watch_areas) { - watch_lo_addr = std::min (watch_lo_addr, area->lo_addr); - watch_hi_addr = std::max (watch_hi_addr, area->hi_addr); + watch_lo_addr = std::min (watch_lo_addr, area.lo_addr); + watch_hi_addr = std::max (watch_hi_addr, area.hi_addr); } /* Enable storage-alteration events. */ @@ -759,7 +749,7 @@ s390_linux_nat_target::low_prepare_to_resume (struct lwp_info *lp) | PER_CONTROL_ALTERATION); } - if (!VEC_empty (s390_watch_area, state->break_areas)) + if (!state->break_areas.empty ()) { /* Don't install hardware breakpoints while single-stepping, since our PER settings (e.g. the nullification bit) might then conflict @@ -768,12 +758,10 @@ s390_linux_nat_target::low_prepare_to_resume (struct lwp_info *lp) lp_priv->per_info_changed = 1; else { - for (ix = 0; - VEC_iterate (s390_watch_area, state->break_areas, ix, area); - ix++) + for (const auto &area : state->break_areas) { - watch_lo_addr = std::min (watch_lo_addr, area->lo_addr); - watch_hi_addr = std::max (watch_hi_addr, area->hi_addr); + watch_lo_addr = std::min (watch_lo_addr, area.lo_addr); + watch_hi_addr = std::max (watch_hi_addr, area.hi_addr); } /* If there's just one breakpoint, enable instruction-fetching @@ -860,13 +848,13 @@ s390_linux_nat_target::insert_watchpoint (CORE_ADDR addr, int len, enum target_hw_bp_type type, struct expression *cond) { - s390_watch_area area; + watch_area area; struct s390_debug_reg_state *state = s390_get_debug_reg_state (inferior_ptid.pid ()); area.lo_addr = addr; area.hi_addr = addr + len - 1; - VEC_safe_push (s390_watch_area, state->watch_areas, &area); + state->watch_areas.push_back (area); return s390_refresh_per_info (); } @@ -877,17 +865,15 @@ s390_linux_nat_target::remove_watchpoint (CORE_ADDR addr, int len, struct expression *cond) { unsigned ix; - s390_watch_area *area; struct s390_debug_reg_state *state = s390_get_debug_reg_state (inferior_ptid.pid ()); - for (ix = 0; - VEC_iterate (s390_watch_area, state->watch_areas, ix, area); - ix++) + for (ix = 0; ix < state->watch_areas.size (); ix++) { - if (area->lo_addr == addr && area->hi_addr == addr + len - 1) + watch_area &area = state->watch_areas[ix]; + if (area.lo_addr == addr && area.hi_addr == addr + len - 1) { - VEC_unordered_remove (s390_watch_area, state->watch_areas, ix); + unordered_remove (state->watch_areas, ix); return s390_refresh_per_info (); } } @@ -914,13 +900,13 @@ int s390_linux_nat_target::insert_hw_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt) { - s390_watch_area area; + watch_area area; struct s390_debug_reg_state *state; area.lo_addr = bp_tgt->placed_address = bp_tgt->reqstd_address; area.hi_addr = area.lo_addr; state = s390_get_debug_reg_state (inferior_ptid.pid ()); - VEC_safe_push (s390_watch_area, state->break_areas, &area); + state->break_areas.push_back (area); return s390_refresh_per_info (); } @@ -932,17 +918,15 @@ s390_linux_nat_target::remove_hw_breakpoint (struct gdbarch *gdbarch, struct bp_target_info *bp_tgt) { unsigned ix; - struct watch_area *area; struct s390_debug_reg_state *state; state = s390_get_debug_reg_state (inferior_ptid.pid ()); - for (ix = 0; - VEC_iterate (s390_watch_area, state->break_areas, ix, area); - ix++) + for (ix = 0; state->break_areas.size (); ix++) { - if (area->lo_addr == bp_tgt->placed_address) + watch_area &area = state->break_areas[ix]; + if (area.lo_addr == bp_tgt->placed_address) { - VEC_unordered_remove (s390_watch_area, state->break_areas, ix); + unordered_remove (state->break_areas, ix); return s390_refresh_per_info (); } }