From patchwork Thu Mar 7 13:28:45 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Metzger, Markus T" X-Patchwork-Id: 86932 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id C1866385783E for ; Thu, 7 Mar 2024 13:30:59 +0000 (GMT) X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from mgamail.intel.com (mgamail.intel.com [192.198.163.15]) by sourceware.org (Postfix) with ESMTPS id 20B6F3857837 for ; Thu, 7 Mar 2024 13:29:07 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 20B6F3857837 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=intel.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=intel.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 20B6F3857837 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=192.198.163.15 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1709818152; cv=none; b=xn5A+zpCAybZ1xjoYrQTXilEuiV9SaO8AzVVz6ZgrOgO/2wkoLi60acWPj6NZ8gBRid94j0VL2t16lfmA23ST/E1/a5Y87MzJTNeFvNUclaHE2MFMGzYQmPBH14An3c6WIPG0vJ7Sr2RWUzN0+NwsulZVVvwCFX5shV6dgqyqG0= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1709818152; c=relaxed/simple; bh=95xM3Xqn4JU0Dlo/r7vmhOoh2Wqn9M1IGoA0qj23nl4=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=SFFszrx0i2biAzMu/vE2NQaMoxruuVCkY5tX4P4djUYm/3KAW0Ftblj2hqm759b6xyawpDV2isbQmcCg6A62dPzddu7dvQbJgJJWBPXrUr5d1XTKfbtW9dZBH8D3QlciPxE108FjJIrsVg3CLhERbh+sGox4wUhbMoKO2WhllDs= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1709818147; x=1741354147; h=from:to:subject:date:message-id:in-reply-to:references: mime-version:content-transfer-encoding; bh=95xM3Xqn4JU0Dlo/r7vmhOoh2Wqn9M1IGoA0qj23nl4=; b=h/+DV2iGNnK8oDisA1v2bEopxNdpZAULLjw3Oi8QQRRpE2tcjYzCbOyI TvgmCTNXxxCMoJOAdKMj7oHvzO3pgPTa6MMo9epentNhCJBUMxZUO9RXi N8Tc3V5yrNN7IwHjrnVHWXfBRkFgm+q9QegAYsYw6dQKUgsrptKKCsZOT Cdigc9kPf5znwx50ElBWp8lVS0Vm/VaHqerXwzPoIDxavIFwM0eWOvvtt 2n05YSvGl04icShHd02wRauALXxkcO2yyaGZSIgZ2reLHMt7unvLoT1we 6V5dN2eIsy91EjP6RrsEc33hI/o718o5hlQSPDAYbjWLbovy1UApH8+Mv Q==; X-IronPort-AV: E=McAfee;i="6600,9927,11005"; a="4654444" X-IronPort-AV: E=Sophos;i="6.07,211,1708416000"; d="scan'208";a="4654444" Received: from fmviesa007.fm.intel.com ([10.60.135.147]) by fmvoesa109.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Mar 2024 05:29:06 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.07,211,1708416000"; d="scan'208";a="10010168" Received: from gkldtt-dev-004.igk.intel.com (HELO localhost) ([10.123.221.202]) by fmviesa007-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Mar 2024 05:29:05 -0800 From: Markus Metzger To: gdb-patches@sourceware.org Subject: [PATCH 6/6] gdb, btrace, infrun: per-inferior run-control Date: Thu, 7 Mar 2024 13:28:45 +0000 Message-Id: <20240307132845.2909415-7-markus.t.metzger@intel.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20240307132845.2909415-1-markus.t.metzger@intel.com> References: <20240307132845.2909415-1-markus.t.metzger@intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-10.2 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, SPF_HELO_NONE, SPF_NONE, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces+patchwork=sourceware.org@sourceware.org While recording is already per inferior, run-control isn't. As soon as any thread in any inferior is replaying, no other inferior can be resumed. This is controlled by many calls to record_is_replaying(minus_one_ptid). Instead of minus_one_ptid, pass the ptid of the inferior to be checked. --- gdb/infrun.c | 17 ++++++++------ gdb/record-btrace.c | 26 +++++---------------- gdb/testsuite/gdb.btrace/multi-inferior.c | 10 +++++++- gdb/testsuite/gdb.btrace/multi-inferior.exp | 19 +++++++++++++++ 4 files changed, 44 insertions(+), 28 deletions(-) diff --git a/gdb/infrun.c b/gdb/infrun.c index d9ab69723b8..b3f7f7aa19d 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -2400,7 +2400,8 @@ user_visible_resume_ptid (int step) resume_ptid = inferior_ptid; } else if ((scheduler_mode == schedlock_replay) - && target_record_will_replay (minus_one_ptid, execution_direction)) + && target_record_will_replay (ptid_t (inferior_ptid.pid ()), + execution_direction)) { /* User-settable 'scheduler' mode requires solo thread resume in replay mode. */ @@ -3110,15 +3111,17 @@ clear_proceed_status (int step) This is a convenience feature to not require the user to explicitly stop replaying the other threads. We're assuming that the user's intent is to resume tracing the recorded process. */ + ptid_t resume_ptid = user_visible_resume_ptid (step); if (!non_stop && scheduler_mode == schedlock_replay - && target_record_is_replaying (minus_one_ptid) - && !target_record_will_replay (user_visible_resume_ptid (step), - execution_direction)) - target_record_stop_replaying (); + && target_record_is_replaying (ptid_t (resume_ptid.pid ())) + && !target_record_will_replay (resume_ptid, execution_direction)) + { + target_record_stop_replaying (); + resume_ptid = user_visible_resume_ptid (step); + } if (!non_stop && inferior_ptid != null_ptid) { - ptid_t resume_ptid = user_visible_resume_ptid (step); process_stratum_target *resume_target = user_visible_resume_target (resume_ptid); @@ -3197,7 +3200,7 @@ schedlock_applies (struct thread_info *tp) || (scheduler_mode == schedlock_step && tp->control.stepping_command) || (scheduler_mode == schedlock_replay - && target_record_will_replay (minus_one_ptid, + && target_record_will_replay (ptid_t (tp->inf->pid), execution_direction))); } diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c index 8b20ab53ca7..cf0b894e344 100644 --- a/gdb/record-btrace.c +++ b/gdb/record-btrace.c @@ -122,7 +122,6 @@ class record_btrace_target final : public target_ops ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override; void stop (ptid_t) override; - void update_thread_list () override; bool thread_alive (ptid_t ptid) override; void goto_record_begin () override; void goto_record_end () override; @@ -2160,7 +2159,7 @@ record_btrace_target::resume (ptid_t ptid, int step, enum gdb_signal signal) make progress, we may need to explicitly move replaying threads to the end of their execution history. */ if ((::execution_direction != EXEC_REVERSE) - && !record_is_replaying (minus_one_ptid)) + && !record_is_replaying (ptid_t (ptid.pid ()))) { this->beneath ()->resume (ptid, step, signal); return; @@ -2543,7 +2542,7 @@ record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status, /* As long as we're not replaying, just forward the request. */ if ((::execution_direction != EXEC_REVERSE) - && !record_is_replaying (minus_one_ptid)) + && !record_is_replaying (ptid_t (ptid.pid ()))) { return this->beneath ()->wait (ptid, status, options); } @@ -2664,7 +2663,7 @@ record_btrace_target::stop (ptid_t ptid) /* As long as we're not replaying, just forward the request. */ if ((::execution_direction != EXEC_REVERSE) - && !record_is_replaying (minus_one_ptid)) + && !record_is_replaying (ptid_t (ptid.pid ()))) { this->beneath ()->stop (ptid); } @@ -2694,7 +2693,7 @@ record_btrace_target::can_execute_reverse () bool record_btrace_target::stopped_by_sw_breakpoint () { - if (record_is_replaying (minus_one_ptid)) + if (record_is_replaying (ptid_t (inferior_ptid.pid ()))) { struct thread_info *tp = inferior_thread (); @@ -2709,7 +2708,7 @@ record_btrace_target::stopped_by_sw_breakpoint () bool record_btrace_target::stopped_by_hw_breakpoint () { - if (record_is_replaying (minus_one_ptid)) + if (record_is_replaying (ptid_t (inferior_ptid.pid ()))) { struct thread_info *tp = inferior_thread (); @@ -2719,26 +2718,13 @@ record_btrace_target::stopped_by_hw_breakpoint () return this->beneath ()->stopped_by_hw_breakpoint (); } -/* The update_thread_list method of target record-btrace. */ - -void -record_btrace_target::update_thread_list () -{ - /* We don't add or remove threads during replay. */ - if (record_is_replaying (minus_one_ptid)) - return; - - /* Forward the request. */ - this->beneath ()->update_thread_list (); -} - /* The thread_alive method of target record-btrace. */ bool record_btrace_target::thread_alive (ptid_t ptid) { /* We don't add or remove threads during replay. */ - if (record_is_replaying (minus_one_ptid)) + if (record_is_replaying (ptid_t (ptid.pid ()))) return true; /* Forward the request. */ diff --git a/gdb/testsuite/gdb.btrace/multi-inferior.c b/gdb/testsuite/gdb.btrace/multi-inferior.c index fb4ffc22a17..6f1052a7f25 100644 --- a/gdb/testsuite/gdb.btrace/multi-inferior.c +++ b/gdb/testsuite/gdb.btrace/multi-inferior.c @@ -15,8 +15,16 @@ You should have received a copy of the GNU General Public License along with this program. If not, see . */ +static int +fun (void) +{ + int x = fun (); /* fun.1 */ + return x; /* fun.2 */ +} + int main (void) { - return 0; + int x = fun (); /* main.1 */ + return x; /* main.2 */ } diff --git a/gdb/testsuite/gdb.btrace/multi-inferior.exp b/gdb/testsuite/gdb.btrace/multi-inferior.exp index 174d38364a4..df7f423a088 100644 --- a/gdb/testsuite/gdb.btrace/multi-inferior.exp +++ b/gdb/testsuite/gdb.btrace/multi-inferior.exp @@ -39,6 +39,8 @@ with_test_prefix "inferior 1" { } gdb_test_no_output "record btrace" + gdb_test "step 4" "fun\.1.*" + gdb_test "reverse-step" "fun\.1.*" } with_test_prefix "inferior 2" { @@ -51,4 +53,21 @@ with_test_prefix "inferior 2" { } gdb_test_no_output "record btrace" + gdb_test "step 4" "fun\.1.*" + gdb_test "reverse-step" "fun\.1.*" + + gdb_test "info record" "Replay in progress.*" + gdb_test "record stop" "Process record is stopped.*" + + gdb_test "step" "fun\.1.*" +} + +with_test_prefix "inferior 1" { + gdb_test "inferior 1" "Switching to inferior 1.*" + + gdb_test "info record" "Replay in progress.*" + gdb_test "reverse-finish" "fun\.1.*" + gdb_test "record goto end" "fun\.1.*" + gdb_test "step 2" "fun\.1.*" + gdb_test "reverse-step 3" }