From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 19914 invoked by alias); 9 Sep 2015 10:36:00 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 19702 invoked by uid 89); 9 Sep 2015 10:36:00 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.1 required=5.0 tests=AWL,BAYES_20,KAM_LAZY_DOMAIN_SECURITY,T_RP_MATCHES_RCVD autolearn=no version=3.3.2 X-HELO: mga03.intel.com Received: from mga03.intel.com (HELO mga03.intel.com) (134.134.136.65) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 09 Sep 2015 10:35:52 +0000 Received: from orsmga002.jf.intel.com ([10.7.209.21]) by orsmga103.jf.intel.com with ESMTP; 09 Sep 2015 03:35:15 -0700 X-ExtLoop1: 1 Received: from irvmail001.ir.intel.com ([163.33.26.43]) by orsmga002.jf.intel.com with ESMTP; 09 Sep 2015 03:35:13 -0700 Received: from ulvlx001.iul.intel.com (ulvlx001.iul.intel.com [172.28.207.17]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id t89AZCg2004745; Wed, 9 Sep 2015 11:35:12 +0100 Received: from ulvlx001.iul.intel.com (localhost [127.0.0.1]) by ulvlx001.iul.intel.com with ESMTP id t89AZCFI000591; Wed, 9 Sep 2015 12:35:12 +0200 Received: (from mmetzger@localhost) by ulvlx001.iul.intel.com with œ id t89AZC5n000587; Wed, 9 Sep 2015 12:35:12 +0200 From: Markus Metzger To: palves@redhat.com Cc: gdb-patches@sourceware.org Subject: [PATCH 09/17] btrace: resume all requested threads Date: Wed, 09 Sep 2015 10:36:00 -0000 Message-Id: <1441794909-32718-10-git-send-email-markus.t.metzger@intel.com> In-Reply-To: <1441794909-32718-1-git-send-email-markus.t.metzger@intel.com> References: <1441794909-32718-1-git-send-email-markus.t.metzger@intel.com> X-IsSubscribed: yes X-SW-Source: 2015-09/txt/msg00114.txt.bz2 The record targets are implicitly schedlocked. They only step the current thread and keep other threads where they are. Change record btrace to step all requested threads in to_resume. For maintenance and debugging, we keep the old behaviour when the target below is not non-stop. Enable with "maint set target-non-stop on". 2015-09-09 Markus Metzger gdb/ * record-btrace.c (record_btrace_resume_thread): A move request overwrites a previous move request. (record_btrace_find_resume_thread): Removed. (record_btrace_resume): Resume all requested threads. --- gdb/record-btrace.c | 73 ++++++++++++++++++++++++++--------------------------- 1 file changed, 36 insertions(+), 37 deletions(-) diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c index 0ce8825..64c8132 100644 --- a/gdb/record-btrace.c +++ b/gdb/record-btrace.c @@ -1699,31 +1699,14 @@ record_btrace_resume_thread (struct thread_info *tp, btinfo = &tp->btrace; - if ((btinfo->flags & BTHR_MOVE) != 0) - error (_("Thread already moving.")); - /* Fetch the latest branch trace. */ btrace_fetch (tp); - /* A resume request overwrites a preceding stop request. */ - btinfo->flags &= ~BTHR_STOP; + /* A resume request overwrites a preceding resume or stop request. */ + btinfo->flags &= ~(BTHR_MOVE | BTHR_STOP); btinfo->flags |= flag; } -/* Find the thread to resume given a PTID. */ - -static struct thread_info * -record_btrace_find_resume_thread (ptid_t ptid) -{ - struct thread_info *tp; - - /* When asked to resume everything, we pick the current thread. */ - if (ptid_equal (minus_one_ptid, ptid) || ptid_is_pid (ptid)) - ptid = inferior_ptid; - - return find_thread_ptid (ptid); -} - /* Start replaying a thread. */ static struct btrace_insn_iterator * @@ -1865,30 +1848,50 @@ static void record_btrace_resume (struct target_ops *ops, ptid_t ptid, int step, enum gdb_signal signal) { - struct thread_info *tp, *other; + struct thread_info *tp; enum btrace_thread_flag flag; + ptid_t orig_ptid; DEBUG ("resume %s: %s%s", target_pid_to_str (ptid), execution_direction == EXEC_REVERSE ? "reverse-" : "", step ? "step" : "cont"); - /* Store the execution direction of the last resume. */ + orig_ptid = ptid; + + /* Store the execution direction of the last resume. + + If there is more than one to_resume call, we have to rely on infrun + to not change the execution direction in-between. */ record_btrace_resume_exec_dir = execution_direction; - tp = record_btrace_find_resume_thread (ptid); - if (tp == NULL) - error (_("Cannot find thread to resume.")); + /* For non-stop targets... */ + if (!target_is_non_stop_p ()) + { + /* ...we pick the current thread when asked to resume an entire process + or everything. */ + if (ptid_equal (minus_one_ptid, ptid) || ptid_is_pid (ptid)) + ptid = inferior_ptid; + + tp = find_thread_ptid (ptid); + if (tp == NULL) + error (_("Cannot find thread to resume.")); + + /* ...and we stop replaying other threads if the thread to resume is not + replaying. */ + if (!btrace_is_replaying (tp) && execution_direction != EXEC_REVERSE) + ALL_NON_EXITED_THREADS (tp) + record_btrace_stop_replaying (tp); + } - /* Stop replaying other threads if the thread to resume is not replaying. */ - if (!btrace_is_replaying (tp) && execution_direction != EXEC_REVERSE) - ALL_NON_EXITED_THREADS (other) - record_btrace_stop_replaying (other); + /* As long as we're not replaying, just forward the request. - /* As long as we're not replaying, just forward the request. */ + For non-stop targets this means that no thread is replaying. In order to + make progress, we may need to explicitly move replaying threads to the end + of their execution history. */ if (!record_btrace_is_replaying (ops) && execution_direction != EXEC_REVERSE) { ops = ops->beneath; - return ops->to_resume (ops, ptid, step, signal); + return ops->to_resume (ops, orig_ptid, step, signal); } /* Compute the btrace thread flag for the requested move. */ @@ -1897,15 +1900,11 @@ record_btrace_resume (struct target_ops *ops, ptid_t ptid, int step, else flag = execution_direction == EXEC_REVERSE ? BTHR_RSTEP : BTHR_STEP; - /* At the moment, we only move a single thread. We could also move - all threads in parallel by single-stepping each resumed thread - until the first runs into an event. - When we do that, we would want to continue all other threads. - For now, just resume one thread to not confuse to_wait. */ - record_btrace_resume_thread (tp, flag); - /* We just indicate the resume intent here. The actual stepping happens in record_btrace_wait below. */ + ALL_NON_EXITED_THREADS (tp) + if (ptid_match (tp->ptid, ptid)) + record_btrace_resume_thread (tp, flag); /* Async support. */ if (target_can_async_p ()) -- 1.8.3.1