From patchwork Thu May 21 23:19:03 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Pedro Alves X-Patchwork-Id: 6875 Received: (qmail 93162 invoked by alias); 21 May 2015 23:25:51 -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 93153 invoked by uid 89); 21 May 2015 23:25:50 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.4 required=5.0 tests=AWL, BAYES_00, KAM_LAZY_DOMAIN_SECURITY, SPF_HELO_PASS, T_RP_MATCHES_RCVD autolearn=no 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; Thu, 21 May 2015 23:25:50 +0000 Received: from int-mx13.intmail.prod.int.phx2.redhat.com (int-mx13.intmail.prod.int.phx2.redhat.com [10.5.11.26]) by mx1.redhat.com (Postfix) with ESMTPS id 6D4D78F01F for ; Thu, 21 May 2015 23:19:23 +0000 (UTC) Received: from brno.lan (ovpn01.gateway.prod.ext.ams2.redhat.com [10.39.146.11]) by int-mx13.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id t4LNJEJ5027592 for ; Thu, 21 May 2015 19:19:22 -0400 From: Pedro Alves To: gdb-patches@sourceware.org Subject: [PATCH 07/18] Misc switch_back_to_stepped_thread cleanups Date: Fri, 22 May 2015 00:19:03 +0100 Message-Id: <1432250354-2721-8-git-send-email-palves@redhat.com> In-Reply-To: <1432250354-2721-1-git-send-email-palves@redhat.com> References: <1432250354-2721-1-git-send-email-palves@redhat.com> Several misc cleanups that prepare the tail end of this function, the part that actually re-resumes the stepped thread. The most non-obvious would be the currently_stepping change, I guess. That's because it isn't ever correct to pass step=1 to target_resume on software single-step targets, and currently_stepping works at a conceptual higher level, it returns step=true even on software step targets. It doesn't really matter on hardware step targets, as the breakpoint will be hit immediately, but it's just wrong on software step targets. I tested it against my x86 software single-step branch, and it indeed fixes failed assertions (that catch spurious PTRACE_SINGLESTEP requests) there. gdb/ChangeLog: 2015-05-21 Pedro Alves * infrun.c (switch_back_to_stepped_thread): Use ecs->ptid instead of inferior_ptid. If the stepped thread vanished, return 0 instead of resuming here. Use reset_ecs. Print the prev_pc and the current stop_pc in log message. Clear trap_expected if the thread advanced. Don't pass currently_stepping to do_target_resume. v4: ChangeLog typo fixed. --- gdb/infrun.c | 33 ++++++++++++++++++--------------- 1 file changed, 18 insertions(+), 15 deletions(-) diff --git a/gdb/infrun.c b/gdb/infrun.c index 2c8a963..55a6622 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -5711,7 +5711,7 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs) { /* Ignore threads of processes we're not resuming. */ if (!sched_multi - && ptid_get_pid (tp->ptid) != ptid_get_pid (inferior_ptid)) + && ptid_get_pid (tp->ptid) != ptid_get_pid (ecs->ptid)) continue; /* When stepping over a breakpoint, we lock all threads @@ -5775,19 +5775,17 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs) "stepped thread, it has vanished\n"); delete_thread (tp->ptid); - keep_going (ecs); - return 1; + return 0; } if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: switching back to stepped thread\n"); - ecs->event_thread = tp; - ecs->ptid = tp->ptid; - context_switch (ecs->ptid); + reset_ecs (ecs, tp); + switch_to_thread (tp->ptid); - stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid)); + stop_pc = regcache_read_pc (get_thread_regcache (tp->ptid)); frame = get_current_frame (); gdbarch = get_frame_arch (frame); @@ -5811,23 +5809,28 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs) if (debug_infrun) fprintf_unfiltered (gdb_stdlog, - "infrun: expected thread advanced also\n"); + "infrun: expected thread advanced also " + "(%s -> %s)\n", + paddress (target_gdbarch (), tp->prev_pc), + paddress (target_gdbarch (), stop_pc)); /* Clear the info of the previous step-over, as it's no - longer valid. It's what keep_going would do too, if - we called it. Must do this before trying to insert - the sss breakpoint, otherwise if we were previously - trying to step over this exact address in another - thread, the breakpoint ends up not installed. */ + longer valid (if the thread was trying to step over a + breakpoint, it has already succeeded). It's what + keep_going would do too, if we called it. Do this + before trying to insert the sss breakpoint, otherwise + if we were previously trying to step over this exact + address in another thread, the breakpoint is + skipped. */ clear_step_over_info (); + tp->control.trap_expected = 0; insert_single_step_breakpoint (get_frame_arch (frame), get_frame_address_space (frame), stop_pc); resume_ptid = user_visible_resume_ptid (tp->control.stepping_command); - do_target_resume (resume_ptid, - currently_stepping (tp), GDB_SIGNAL_0); + do_target_resume (resume_ptid, 0, GDB_SIGNAL_0); prepare_to_wait (ecs); } else