From patchwork Fri Oct 3 13:54:12 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pedro Alves X-Patchwork-Id: 3086 Received: (qmail 18496 invoked by alias); 3 Oct 2014 13:54:28 -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 18407 invoked by uid 89); 3 Oct 2014 13:54:27 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.0 required=5.0 tests=AWL, BAYES_00, SPF_HELO_PASS, SPF_PASS, T_RP_MATCHES_RCVD autolearn=ham version=3.3.2 X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-GCM-SHA384 encrypted) ESMTPS; Fri, 03 Oct 2014 13:54:23 +0000 Received: from int-mx14.intmail.prod.int.phx2.redhat.com (int-mx14.intmail.prod.int.phx2.redhat.com [10.5.11.27]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id s93DsMXZ010474 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=FAIL) for ; Fri, 3 Oct 2014 09:54:22 -0400 Received: from brno.lan (ovpn01.gateway.prod.ext.ams2.redhat.com [10.39.146.11]) by int-mx14.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id s93DsJ7a025501 for ; Fri, 3 Oct 2014 09:54:21 -0400 From: Pedro Alves To: gdb-patches@sourceware.org Subject: [PATCH v2 2/8] Rewrite non-continuable watchpoints handling Date: Fri, 3 Oct 2014 14:54:12 +0100 Message-Id: <1412344458-31774-3-git-send-email-palves@redhat.com> In-Reply-To: <1412344458-31774-1-git-send-email-palves@redhat.com> References: <1412344458-31774-1-git-send-email-palves@redhat.com> When GDB finds out the target triggered a watchpoint, and the target has non-continuable watchpoints, GDB sets things up to step past the instruction that triggered the watchpoint. This is just like stepping past a breakpoint, but goes through a different mechanism - it resumes only the thread that needs to step past the watchpoint, but also switches a "infwait state" global, that has the effect that the next target_wait only wait for events only from that thread. This forcing of a ptid to pass to target_wait obviously becomes a bottleneck if we ever support stepping past different watchpoints simultaneously (in separate processes). It's also unnecessary -- the target should only return events for threads that have been resumed; if no other thread than the one we're stepping past the watchpoint has been resumed, then those other threads should not report events. If we couldn't assume that, then stepping past regular breakpoints would be broken for not likewise forcing a similar infwait_state. So this patch eliminates infwait_state, and instead teaches keep_going to mark step_over_info in a way that has the breakpoints module skip inserting watchpoints (because we're stepping past one), like it skips breakpoints when we're stepping past one. Tested on: - x86_64 Fedora 20 (continuable watchpoints) - PPC64 Fedora 18 (non-steppable watchpoints) gdb/ 2014-10-03 Pedro Alves * breakpoint.c (should_be_inserted): Don't insert watchpoints if trying to step past a non-steppable watchpoint. * gdbthread.h (struct thread_info) : New field. * infrun.c (struct step_over_info): Add new field 'nonsteppable_watchpoint_p' and adjust comments. (set_step_over_info): New 'nonsteppable_watchpoint_p' parameter. Adjust. (clear_step_over_info): Clear nonsteppable_watchpoint_p as well. (stepping_past_nonsteppable_watchpoint): New function. (step_over_info_valid_p): Also return true if stepping past a nonsteppable watchpoint. (proceed): Adjust call to set_step_over_info. Remove reference to init_infwait_state. (init_wait_for_inferior): Remove reference to init_infwait_state. (waiton_ptid): Delete global. (struct execution_control_state) : Delete field. (wait_for_inferior, fetch_inferior_event): Always pass minus_one_ptid to target_wait. (init_thread_stepping_state): Clear 'stepping_over_watchpoint' field. (init_infwait_state): Delete function. (handle_inferior_event): Remove infwait_state handling. (handle_signal_stop) : Adjust after stepped_after_stopped_by_watchpoint removal. Don't remove breakpoints here nor set infwait_state. Set the thread's stepping_over_watchpoint flag, and call keep_going instead. (keep_going): Handle stepping_over_watchpoint. Adjust set_step_over_info calls. * infrun.h (stepping_past_nonsteppable_watchpoint): Declare function. --- gdb/breakpoint.c | 16 +++++++ gdb/gdbthread.h | 5 ++ gdb/infrun.c | 144 +++++++++++++++++++++---------------------------------- gdb/infrun.h | 4 ++ 4 files changed, 79 insertions(+), 90 deletions(-) diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c index e2170b4..08ec533 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -2209,6 +2209,22 @@ should_be_inserted (struct bp_location *bl) return 0; } + /* Don't insert watchpoints if we're trying to step past the + instruction that triggered one. */ + if ((bl->loc_type == bp_loc_hardware_watchpoint) + && stepping_past_nonsteppable_watchpoint ()) + { + if (debug_infrun) + { + fprintf_unfiltered (gdb_stdlog, + "infrun: stepping past non-steppable watchpoint. " + "skipping watchpoint at %s:%d\n", + paddress (bl->gdbarch, bl->address), + bl->length); + } + return 0; + } + return 1; } diff --git a/gdb/gdbthread.h b/gdb/gdbthread.h index 26ca925..36ad5a7 100644 --- a/gdb/gdbthread.h +++ b/gdb/gdbthread.h @@ -197,6 +197,11 @@ struct thread_info /* Should we step over breakpoint next time keep_going is called? */ int stepping_over_breakpoint; + /* Should we step over a watchpoint next time keep_going is called? + This is needed on targets with non-continuable, non-steppable + watchpoints. */ + int stepping_over_watchpoint; + /* Set to TRUE if we should finish single-stepping over a breakpoint after hitting the current step-resume breakpoint. The context here is that GDB is to do `next' or `step' while signal arrives. diff --git a/gdb/infrun.c b/gdb/infrun.c index 9875183..31a1d35 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -378,8 +378,6 @@ static void context_switch (ptid_t ptid); void init_thread_stepping_state (struct thread_info *tss); -static void init_infwait_state (void); - static const char follow_fork_mode_child[] = "child"; static const char follow_fork_mode_parent[] = "parent"; @@ -1209,16 +1207,20 @@ static ptid_t singlestep_ptid; /* PC when we started this single-step. */ static CORE_ADDR singlestep_pc; -/* Info about an instruction that is being stepped over. Invalid if - ASPACE is NULL. */ +/* Info about an instruction that is being stepped over. */ struct step_over_info { - /* The instruction's address space. */ + /* If we're stepping past a breakpoint, this is the address space + and address of the instruction the breakpoint is set at. We'll + skip inserting all breakpoints here. Valid iff ASPACE is + non-NULL. */ struct address_space *aspace; - - /* The instruction's address. */ CORE_ADDR address; + + /* The instruction being stepped over triggers a nonsteppable + watchpoint. If true, we'll skip inserting watchpoints. */ + int nonsteppable_watchpoint_p; }; /* The step-over info of the location that is being stepped over. @@ -1251,10 +1253,12 @@ static struct step_over_info step_over_info; stepping over. */ static void -set_step_over_info (struct address_space *aspace, CORE_ADDR address) +set_step_over_info (struct address_space *aspace, CORE_ADDR address, + int nonsteppable_watchpoint_p) { step_over_info.aspace = aspace; step_over_info.address = address; + step_over_info.nonsteppable_watchpoint_p = nonsteppable_watchpoint_p; } /* Called when we're not longer stepping over a breakpoint / an @@ -1265,6 +1269,7 @@ clear_step_over_info (void) { step_over_info.aspace = NULL; step_over_info.address = 0; + step_over_info.nonsteppable_watchpoint_p = 0; } /* See infrun.h. */ @@ -1279,12 +1284,21 @@ stepping_past_instruction_at (struct address_space *aspace, step_over_info.address)); } +/* See infrun.h. */ + +int +stepping_past_nonsteppable_watchpoint (void) +{ + return step_over_info.nonsteppable_watchpoint_p; +} + /* Returns true if step-over info is valid. */ static int step_over_info_valid_p (void) { - return (step_over_info.aspace != NULL); + return (step_over_info.aspace != NULL + || stepping_past_nonsteppable_watchpoint ()); } @@ -2556,7 +2570,7 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal, int step) struct regcache *regcache = get_current_regcache (); set_step_over_info (get_regcache_aspace (regcache), - regcache_read_pc (regcache)); + regcache_read_pc (regcache), 0); } else clear_step_over_info (); @@ -2596,9 +2610,6 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal, int step) correctly when the inferior is stopped. */ tp->prev_pc = regcache_read_pc (get_current_regcache ()); - /* Reset to normal state. */ - init_infwait_state (); - /* Resume inferior. */ resume (tp->control.trap_expected || step || bpstat_should_step (), tp->suspend.stop_signal); @@ -2663,7 +2674,6 @@ init_wait_for_inferior (void) target_last_wait_ptid = minus_one_ptid; previous_inferior_ptid = inferior_ptid; - init_infwait_state (); /* Discard any skipped inlined frames. */ clear_inline_frame_state (minus_one_ptid); @@ -2684,9 +2694,6 @@ enum infwait_states infwait_nonstep_watch_state }; -/* The PTID we'll do a target_wait on.*/ -ptid_t waiton_ptid; - /* Current inferior wait state. */ static enum infwait_states infwait_state; @@ -2706,11 +2713,6 @@ struct execution_control_state const char *stop_func_name; int wait_some_more; - /* We were in infwait_step_watch_state or - infwait_nonstep_watch_state state, and the thread reported an - event. */ - int stepped_after_stopped_by_watchpoint; - /* True if the event thread hit the single-step breakpoint of another thread. Thus the event doesn't cause a stop, the thread needs to be single-stepped past the single-step breakpoint before @@ -3035,6 +3037,7 @@ wait_for_inferior (void) struct execution_control_state ecss; struct execution_control_state *ecs = &ecss; struct cleanup *old_chain; + ptid_t waiton_ptid = minus_one_ptid; memset (ecs, 0, sizeof (*ecs)); @@ -3090,6 +3093,7 @@ fetch_inferior_event (void *client_data) struct cleanup *ts_old_chain; int was_sync = sync_execution; int cmd_done = 0; + ptid_t waiton_ptid = minus_one_ptid; memset (ecs, 0, sizeof (*ecs)); @@ -3207,6 +3211,7 @@ void init_thread_stepping_state (struct thread_info *tss) { tss->stepping_over_breakpoint = 0; + tss->stepping_over_watchpoint = 0; tss->step_after_step_resume_breakpoint = 0; } @@ -3376,13 +3381,6 @@ adjust_pc_after_break (struct execution_control_state *ecs) } } -static void -init_infwait_state (void) -{ - waiton_ptid = pid_to_ptid (-1); - infwait_state = infwait_normal_state; -} - static int stepped_in_from (struct frame_info *frame, struct frame_id step_frame_id) { @@ -3603,40 +3601,6 @@ handle_inferior_event (struct execution_control_state *ecs) && ecs->ws.kind != TARGET_WAITKIND_EXITED) set_executing (ecs->ptid, 0); - switch (infwait_state) - { - case infwait_normal_state: - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, "infrun: infwait_normal_state\n"); - break; - - case infwait_step_watch_state: - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, - "infrun: infwait_step_watch_state\n"); - - ecs->stepped_after_stopped_by_watchpoint = 1; - break; - - case infwait_nonstep_watch_state: - if (debug_infrun) - fprintf_unfiltered (gdb_stdlog, - "infrun: infwait_nonstep_watch_state\n"); - insert_breakpoints (); - - /* FIXME-maybe: is this cleaner than setting a flag? Does it - handle things like signals arriving and other things happening - in combination correctly? */ - ecs->stepped_after_stopped_by_watchpoint = 1; - break; - - default: - internal_error (__FILE__, __LINE__, _("bad switch")); - } - - infwait_state = infwait_normal_state; - waiton_ptid = pid_to_ptid (-1); - switch (ecs->ws.kind) { case TARGET_WAITKIND_LOADED: @@ -4226,7 +4190,9 @@ handle_signal_stop (struct execution_control_state *ecs) singlestep_breakpoints_inserted_p = 0; } - if (ecs->stepped_after_stopped_by_watchpoint) + if (ecs->event_thread->suspend.stop_signal == GDB_SIGNAL_TRAP + && ecs->event_thread->control.trap_expected + && ecs->event_thread->stepping_over_watchpoint) stopped_by_watchpoint = 0; else stopped_by_watchpoint = watchpoints_triggered (&ecs->ws); @@ -4256,29 +4222,21 @@ handle_signal_stop (struct execution_control_state *ecs) It is far more common to need to disable a watchpoint to step the inferior over it. If we have non-steppable watchpoints, we must disable the current watchpoint; it's simplest to - disable all watchpoints and breakpoints. */ - int hw_step = 1; - - if (!target_have_steppable_watchpoint) - { - remove_breakpoints (); - /* See comment in resume why we need to stop bypassing signals - while breakpoints have been removed. */ - target_pass_signals (0, NULL); - } - /* Single step */ - hw_step = maybe_software_singlestep (gdbarch, stop_pc); - target_resume (ecs->ptid, hw_step, GDB_SIGNAL_0); - waiton_ptid = ecs->ptid; - if (target_have_steppable_watchpoint) - infwait_state = infwait_step_watch_state; - else - infwait_state = infwait_nonstep_watch_state; - prepare_to_wait (ecs); + disable all watchpoints. + + Any breakpoint at PC must also be stepped over -- if there's + one, it will have already triggered before the watchpoint + triggered, and we either already reported it to the user, or + it didn't cause a stop and we called keep_going. In either + case, if there was a breakpoint at PC, we must be trying to + step past it. */ + ecs->event_thread->stepping_over_watchpoint = 1; + keep_going (ecs); return; } ecs->event_thread->stepping_over_breakpoint = 0; + ecs->event_thread->stepping_over_watchpoint = 0; bpstat_clear (&ecs->event_thread->control.stop_bpstat); ecs->event_thread->control.stop_step = 0; stop_print_frame = 1; @@ -6014,6 +5972,8 @@ keep_going (struct execution_control_state *ecs) { volatile struct gdb_exception e; struct regcache *regcache = get_current_regcache (); + int remove_bp; + int remove_wps; /* Either the trap was not expected, but we are continuing anyway (if we got a signal, the user asked it be passed to @@ -6033,13 +5993,19 @@ keep_going (struct execution_control_state *ecs) (watchpoints, etc.) but the one we're stepping over, step one instruction, and then re-insert the breakpoint when that step is finished. */ - if ((ecs->hit_singlestep_breakpoint - || thread_still_needs_step_over (ecs->event_thread)) - && !use_displaced_stepping (get_regcache_arch (regcache))) + + remove_bp = (ecs->hit_singlestep_breakpoint + || thread_still_needs_step_over (ecs->event_thread)); + remove_wps = (ecs->event_thread->stepping_over_watchpoint + && !target_have_steppable_watchpoint); + + if (remove_bp && !use_displaced_stepping (get_regcache_arch (regcache))) { set_step_over_info (get_regcache_aspace (regcache), - regcache_read_pc (regcache)); + regcache_read_pc (regcache), remove_wps); } + else if (remove_wps) + set_step_over_info (NULL, 0, remove_wps); else clear_step_over_info (); @@ -6055,9 +6021,7 @@ keep_going (struct execution_control_state *ecs) return; } - ecs->event_thread->control.trap_expected - = (ecs->event_thread->stepping_over_breakpoint - || ecs->hit_singlestep_breakpoint); + ecs->event_thread->control.trap_expected = (remove_bp || remove_wps); /* Do not deliver GDB_SIGNAL_TRAP (except when the user explicitly specifies that such a signal should be delivered diff --git a/gdb/infrun.h b/gdb/infrun.h index fb6276b..4d5159e 100644 --- a/gdb/infrun.h +++ b/gdb/infrun.h @@ -120,6 +120,10 @@ extern void insert_step_resume_breakpoint_at_sal (struct gdbarch *, extern int stepping_past_instruction_at (struct address_space *aspace, CORE_ADDR address); +/* Returns true if we're trying to step past an instruction that + triggers a non-steppable watchpoint. */ +extern int stepping_past_nonsteppable_watchpoint (void); + extern void set_step_info (struct frame_info *frame, struct symtab_and_line sal);