From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id DBFC738582A7 for ; Tue, 5 Mar 2024 15:40:50 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org DBFC738582A7 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org DBFC738582A7 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1709653256; cv=none; b=UA5Y4INPlRq8uCQe8wjtpyrzsxL9demI2oRT/ZI2UNPBOypl1o8wg+GOd48d+chfn6UYYiviFPzj6Otvo+rm8bxEzzd/0l1VuFdulRIzkhATazQh2OVe8IkyKanSIM6D2hQ5BpHdrf2WJgtseYIAUXFswVXP4LRbDYknsQnih8U= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1709653256; c=relaxed/simple; bh=fAB2zp8M4UcZFhFvF3QodK0TCmgqGDtWPXrRS2n70dI=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=Z8agrNlaOGebMFcNv84Ph8u57sBcrwZYjcPsKkdj+FGngVjnvOy+b4GgMaeloYdA5oCPZdB7TZZMmuAL0uTfzqHfJg5ulslKAcrb1vrq3Sk/1qlEcz0Sc+naNwprQa6WmriJeo4ZIIyCzKKJNFSbeV0CNIA5ijynU89SPhRRXNk= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1709653250; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=PEUA6AknhVUyR8gwohKF5TcuBzu7YDfJ4ez3sWwC+UU=; b=ASo5WnMbmdsq9qBBQiJcgylDPGgw0l6oaKQz+MpLP6+uz9z9Um+dC/BNdL2BGIWul+KFyv R+vuVveM2j9pBElwDu8nTHgFUwLBrH3KbCpMrljqJ+QZHTA/2xXaX/yHETHCuHxzrmpr5i 9r41gCvn+DCtXHH6KH+fTYTJBJq9lEU= Received: from mail-ej1-f70.google.com (mail-ej1-f70.google.com [209.85.218.70]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-624-B6mIHwRyO5CoLk6Bi6qThg-1; Tue, 05 Mar 2024 10:40:49 -0500 X-MC-Unique: B6mIHwRyO5CoLk6Bi6qThg-1 Received: by mail-ej1-f70.google.com with SMTP id a640c23a62f3a-a45acc7f07cso41189866b.2 for ; Tue, 05 Mar 2024 07:40:49 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1709653246; x=1710258046; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=PEUA6AknhVUyR8gwohKF5TcuBzu7YDfJ4ez3sWwC+UU=; b=LGOjybaFNToNwCfXjEf5aLOwuYYxeBTncvNCH9N4Wa/d7KpoQFUKE6PVMtHxKsUK1o riMx7JuG5MxoRvUQSfXdX17+SfEtxhxUcfernc2AxJykQ0oOiIgysQhIwm0PzmrzI3G3 Kp8BT//s7ABra5VdpBt4yCgT82hlVS5pMMSIyp/Z8OYTTNKVMs8/I8k/NTVUotJg4+Ad CcQh7iViwgBL89rDIDgO34Kb6n6ZIVb5Q92ZGHw2vZZCDS0kkQijd/Lc/jHvDjAMZ27g gWLUZYrO3RcswVMYv2LkEQw0/5HZZxFhzkow5gIFYCg9FHJB339A5BVg4pVn3b9pX4ZF 34aw== X-Gm-Message-State: AOJu0YzeuaM3a4ClpzLxGkwgq4yk2gxyVEVbML3e/tCSun2LosnvXTGw tZrmhNBTLc4cgv74a7hO745Oz5reWOfF6l72yK0Vl1T0oxCUr8LvFSImXhWHQZdCPyzpIhXTGia qgxI0woLZX+pabvTnDwVv4MDagQoMxxWr0/6pnR7jzKpfejQIUPfIwp6rbbW//+bUozGhUV8hTL u7lco2Vn4MEkwb1BYoukdRXxQh90BU5Q8IxigT528hdkA= X-Received: by 2002:a17:906:c7c3:b0:a3f:1b49:c92b with SMTP id dc3-20020a170906c7c300b00a3f1b49c92bmr9035103ejb.48.1709653245946; Tue, 05 Mar 2024 07:40:45 -0800 (PST) X-Google-Smtp-Source: AGHT+IETQIj3UxJ+SgFKVAY0p2vVZhD+c9kwSQoVOh7mmkX8Y1NZ2HhOt1R8voZPh7QgRmkc+7vDng== X-Received: by 2002:a17:906:c7c3:b0:a3f:1b49:c92b with SMTP id dc3-20020a170906c7c300b00a3f1b49c92bmr9035066ejb.48.1709653245215; Tue, 05 Mar 2024 07:40:45 -0800 (PST) Received: from localhost (185.223.159.143.dyn.plus.net. [143.159.223.185]) by smtp.gmail.com with ESMTPSA id l2-20020a170906644200b00a45abeb7d12sm619467ejn.109.2024.03.05.07.40.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 05 Mar 2024 07:40:45 -0800 (PST) From: Andrew Burgess To: gdb-patches@sourceware.org Cc: Andrew Burgess , Eli Zaretskii Subject: [PATCHv11 4/5] gdb: introduce unwind-on-timeout setting Date: Tue, 5 Mar 2024 15:40:37 +0000 Message-Id: <5e78fa824262121dd972ff7740545c254e555d23.1709653159.git.aburgess@redhat.com> X-Mailer: git-send-email 2.25.4 In-Reply-To: References: MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset="US-ASCII"; x-default=true X-Spam-Status: No, score=-12.3 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H4,RCVD_IN_MSPIKE_WL,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 List-Id: Now that inferior function calls can timeout (see the recent introduction of direct-call-timeout and indirect-call-timeout), this commit adds a new setting unwind-on-timeout. This new setting is just like the existing unwindonsignal and unwind-on-terminating-exception, but the new setting will cause GDB to unwind the stack if an inferior function call times out. The existing inferior function call timeout tests have been updated to cover the new setting. Reviewed-By: Eli Zaretskii --- gdb/NEWS | 9 +++ gdb/doc/gdb.texinfo | 31 ++++++-- gdb/infcall.c | 78 +++++++++++++++++-- gdb/testsuite/gdb.base/infcall-timeout.exp | 63 ++++++++++----- .../infcall-from-bp-cond-timeout.exp | 69 ++++++++++------ 5 files changed, 194 insertions(+), 56 deletions(-) diff --git a/gdb/NEWS b/gdb/NEWS index b98822f28b1..d6139ed5001 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -65,6 +65,15 @@ show indirect-call-timeout ignored, GDB will wait indefinitely for an inferior function to complete, unless interrupted by the user using Ctrl-C. +set unwind-on-timeout on|off +show unwind-on-timeout + These commands control whether GDB should unwind the stack when a + timeout occurs during an inferior function call. The default is + off, in which case the inferior will remain in the frame where the + timeout occurred. When on, GDB will unwind the stack removing the + dummy frame that was added for the inferior call, and restoring the + inferior state to how it was before the inferior call started. + * New features in the GDB remote stub, GDBserver ** The --remote-debug and --event-loop-debug command line options diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index 6b98a960442..0c53f1254f1 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -20946,6 +20946,22 @@ Show the current setting of stack unwinding in the functions called by @value{GDBN}. +@anchor{set unwind-on-timeout} +@item set unwind-on-timeout +@kindex set unwind-on-timeout +@cindex unwind stack in called functions when timing out +@cindex call dummy stack unwinding on timeout. +Set unwinding of the stack if a function called from @value{GDBN} +times out. If set to @code{off} (the default), @value{GDBN} stops in +the frame where the timeout occurred. If set to @code{on}, +@value{GDBN} unwinds the stack it created for the call and restores +the context to what it was before the call. + +@item show unwind-on-timeout +@kindex show unwind-on-timeout +Show whether @value{GDBN} will unwind the stack if a function called +from @value{GDBN} times out. + @item set may-call-functions @kindex set may-call-functions @cindex disabling calling functions in the program @@ -20977,11 +20993,11 @@ If a called function is interrupted for any reason, including hitting a breakpoint, or triggering a watchpoint, and the stack is not unwound -due to @code{set unwind-on-terminating-exception on} or @code{set -unwindonsignal on} (@pxref{stack unwind settings}), -then the dummy-frame, created by @value{GDBN} to facilitate the call -to the program function, will be visible in the backtrace, for example -frame @code{#3} in the following backtrace: +due to @code{set unwind-on-terminating-exception on}, @code{set +unwind-on-timeout on}, or @code{set unwindonsignal on} (@pxref{stack +unwind settings}), then the dummy-frame, created by @value{GDBN} to +facilitate the call to the program function, will be visible in the +backtrace, for example frame @code{#3} in the following backtrace: @smallexample (@value{GDBP}) backtrace @@ -21006,6 +21022,11 @@ from @value{GDBN}. If the timeout expires and the function call is still ongoing, then @value{GDBN} will interrupt the program. +If a function called from @value{GDBN} is interrupted by a timeout, +then by default the inferior is left in the frame where the timeout +occurred, this behaviour can be adjusted with @samp{set +unwind-on-timeout} (@pxref{set unwind-on-timeout}). + For targets that don't support asynchronous execution (@pxref{Background Execution}) then timeouts for functions called from @value{GDBN} are not supported, the timeout settings described below diff --git a/gdb/infcall.c b/gdb/infcall.c index 7dc1324023f..bbe906420d1 100644 --- a/gdb/infcall.c +++ b/gdb/infcall.c @@ -218,6 +218,27 @@ show_unwind_on_terminating_exception_p (struct ui_file *file, int from_tty, value); } +/* This boolean tells GDB what to do if an inferior function, called from + GDB, times out. If true, GDB unwinds the stack and restores the context + to what it was before the call. When false, GDB leaves the thread as it + is at the point of the timeout. + + The default is to stop in the frame where the timeout occurred. */ + +static bool unwind_on_timeout_p = false; + +/* Implement 'show unwind-on-timeout'. */ + +static void +show_unwind_on_timeout_p (struct ui_file *file, int from_tty, + struct cmd_list_element *c, const char *value) +{ + gdb_printf (file, + _("Unwinding of stack if a timeout occurs " + "while in a call dummy is %s.\n"), + value); +} + /* Perform the standard coercions that are specified for arguments to be passed to C, Ada or Fortran functions. @@ -574,6 +595,16 @@ struct call_thread_fsm : public thread_fsm bool should_stop (struct thread_info *thread) override; bool should_notify_stop () override; + + /* Record that this thread timed out while performing an infcall. */ + void timed_out () + { + m_timed_out = true; + } + +private: + /* Set true if the thread timed out while performing an infcall. */ + bool m_timed_out = false; }; /* Allocate a new call_thread_fsm object. */ @@ -649,7 +680,8 @@ call_thread_fsm::should_notify_stop () infcall_debug_printf ("inferior call didn't complete fully"); - if (stopped_by_random_signal && unwind_on_signal_p) + if ((stopped_by_random_signal && unwind_on_signal_p) + || (m_timed_out && unwind_on_timeout_p)) { infcall_debug_printf ("unwind-on-signal is on, don't notify"); return false; @@ -742,6 +774,9 @@ struct infcall_timer_controller infcall_debug_printf ("Stopping thread %s", m_thread->ptid.to_string ().c_str ()); + call_thread_fsm *fsm + = gdb::checked_static_cast (m_thread->thread_fsm ()); + fsm->timed_out (); target_stop (m_thread->ptid); } }; @@ -1749,14 +1784,27 @@ When the function is done executing, GDB will silently stop."), /* A timeout results in a signal being sent to the inferior. */ gdb_assert (stopped_by_random_signal); - /* Indentation is weird here. A later patch is going to move the - following block into an if/else, so I'm leaving the indentation - here to minimise the later patch. + if (unwind_on_timeout_p) + { + /* The user wants the context restored. */ + + /* We must get back to the frame we were before the + dummy call. */ + dummy_frame_pop (dummy_id, call_thread.get ()); - Also, the error message used below refers to 'set - unwind-on-timeout' which doesn't exist yet. This will be added - in a later commit, I'm leaving this in for now to minimise the - churn caused by the commit that adds unwind-on-timeout. */ + /* We also need to restore inferior status to that before the + dummy call. */ + restore_infcall_control_state (inf_status.release ()); + + error (_("\ +The program being debugged timed out while in a function called from GDB.\n\ +GDB has restored the context to what it was before the call.\n\ +To change this behavior use \"set unwind-on-timeout off\".\n\ +Evaluation of the expression containing the function\n\ +(%s) will be abandoned."), + name.c_str ()); + } + else { /* The user wants to stay in the frame where we stopped (default). Discard inferior status, we're not at the same @@ -1882,6 +1930,20 @@ The default is to unwind the frame."), show_unwind_on_terminating_exception_p, &setlist, &showlist); + add_setshow_boolean_cmd ("unwind-on-timeout", no_class, + &unwind_on_timeout_p, _("\ +Set unwinding of stack if a timeout occurs while in a call dummy."), _("\ +Show unwinding of stack if a timeout occurs while in a call dummy."), + _("\ +The unwind on timeout flag lets the user determine what gdb should do if\n\ +gdb times out while in a function called from gdb. If set, gdb unwinds\n\ +the stack and restores the context to what it was before the call. If\n\ +unset, gdb leaves the inferior in the frame where the timeout occurred.\n\ +The default is to stop in the frame where the timeout occurred."), + NULL, + show_unwind_on_timeout_p, + &setlist, &showlist); + add_setshow_uinteger_cmd ("direct-call-timeout", no_class, &direct_call_timeout, _("\ Set the timeout, for direct calls to inferior function calls."), _("\ diff --git a/gdb/testsuite/gdb.base/infcall-timeout.exp b/gdb/testsuite/gdb.base/infcall-timeout.exp index e6a03b2ac6b..ad4dbe3b415 100644 --- a/gdb/testsuite/gdb.base/infcall-timeout.exp +++ b/gdb/testsuite/gdb.base/infcall-timeout.exp @@ -28,7 +28,11 @@ if { [build_executable "failed to prepare" ${binfile} "${srcfile}" \ # then adjust the direct-call-timeout, and make an inferior function # call that will never return. GDB should eventually timeout and stop # the inferior. -proc run_test { target_async target_non_stop non_stop } { +# +# When UNWIND is "off" the inferior wil be left in the frame where the +# timeout occurs, otherwise, when UNWIND is "on", GDB should unwind +# back to the frame where the inferior call was made. +proc run_test { target_async target_non_stop non_stop unwind } { save_vars { ::GDBFLAGS } { append ::GDBFLAGS \ " -ex \"maint set target-non-stop $target_non_stop\"" @@ -45,28 +49,43 @@ proc run_test { target_async target_non_stop non_stop } { } gdb_test_no_output "set direct-call-timeout 5" + gdb_test_no_output "set unwind-on-timeout $unwind" + + if { $unwind } { + gdb_test "print function_that_never_returns ()" \ + [multi_line \ + "The program being debugged timed out while in a function called from GDB\\." \ + "GDB has restored the context to what it was before the call\\." \ + "To change this behavior use \"set unwind-on-timeout off\"\\." \ + "Evaluation of the expression containing the function" \ + "\\(function_that_never_returns\\) will be abandoned\\."] - # When non-stop mode is off we get slightly different output from GDB. - if { ([target_info gdb_protocol] == "remote" - || [target_info gdb_protocol] == "extended-remote") - && !$target_non_stop } { - set stopped_line_pattern "Program received signal SIGINT, Interrupt\\." + gdb_test "bt" \ + "#0\\s+main \\(\\).*" } else { - set stopped_line_pattern "Program stopped\\." - } + # When non-stop mode is off we get slightly different output from GDB. + if { ([target_info gdb_protocol] == "remote" + || [target_info gdb_protocol] == "extended-remote") + && !$target_non_stop } { + set stopped_line_pattern "Program received signal SIGINT, Interrupt\\." + } else { + set stopped_line_pattern "Program stopped\\." + } - gdb_test "print function_that_never_returns ()" \ - [multi_line \ - $stopped_line_pattern \ - ".*" \ - "The program being debugged timed out while in a function called from GDB\\." \ - "GDB remains in the frame where the timeout occurred\\." \ - "To change this behavior use \"set unwind-on-timeout on\"\\." \ - "Evaluation of the expression containing the function" \ - "\\(function_that_never_returns\\) will be abandoned\\." \ - "When the function is done executing, GDB will silently stop\\."] - - gdb_test "bt" ".* function_that_never_returns .*.*" + gdb_test "print function_that_never_returns ()" \ + [multi_line \ + $stopped_line_pattern \ + ".*" \ + "The program being debugged timed out while in a function called from GDB\\." \ + "GDB remains in the frame where the timeout occurred\\." \ + "To change this behavior use \"set unwind-on-timeout on\"\\." \ + "Evaluation of the expression containing the function" \ + "\\(function_that_never_returns\\) will be abandoned\\." \ + "When the function is done executing, GDB will silently stop\\."] + + gdb_test "bt" \ + ".* function_that_never_returns .*.*" + } } foreach_with_prefix target_async { "on" "off" } { @@ -88,7 +107,9 @@ foreach_with_prefix target_async { "on" "off" } { continue } - run_test $target_async $target_non_stop $non_stop + foreach_with_prefix unwind { "on" "off" } { + run_test $target_async $target_non_stop $non_stop $unwind + } } } } diff --git a/gdb/testsuite/gdb.threads/infcall-from-bp-cond-timeout.exp b/gdb/testsuite/gdb.threads/infcall-from-bp-cond-timeout.exp index 67dabce66ee..8f17f13d97a 100644 --- a/gdb/testsuite/gdb.threads/infcall-from-bp-cond-timeout.exp +++ b/gdb/testsuite/gdb.threads/infcall-from-bp-cond-timeout.exp @@ -41,7 +41,12 @@ set segfault_line [gdb_get_line_number "Segfault here"] # thread, on which the inferior call relies, either hits a breakpoint # (when OTHER_THREAD_BP is true), or crashes (when OTHER_THREAD_BP is # false). -proc run_test { target_async target_non_stop non_stop other_thread_bp } { +# +# When UNWIND is "on" GDB will unwind the thread which performed the +# inferior function call back to the state where the inferior call was +# made (when the inferior call times out). Otherwise, when UNWIND is +# "off", the inferior is left in the frame where the timeout occurred. +proc run_test { target_async target_non_stop non_stop other_thread_bp unwind } { save_vars { ::GDBFLAGS } { append ::GDBFLAGS " -ex \"maint set target-non-stop $target_non_stop\"" append ::GDBFLAGS " -ex \"maint non-stop $non_stop\"" @@ -72,6 +77,7 @@ proc run_test { target_async target_non_stop non_stop other_thread_bp } { # for this timeout. For now though, we just hope 5 seconds is # enough. gdb_test_no_output "set indirect-call-timeout 5" + gdb_test_no_output "set unwind-on-timeout $unwind" gdb_breakpoint \ "${::srcfile}:${::cond_bp_line} if (condition_func ())" @@ -92,27 +98,43 @@ proc run_test { target_async target_non_stop non_stop other_thread_bp } { "get number for segfault breakpoint"] } - # When non-stop mode is off we get slightly different output from GDB. - if { ([target_info gdb_protocol] == "remote" - || [target_info gdb_protocol] == "extended-remote") - && !$target_non_stop} { - set stopped_line_pattern "Thread ${::decimal} \"\[^\r\n\"\]+\" received signal SIGINT, Interrupt\\." + if { $unwind } { + gdb_test "continue" \ + [multi_line \ + "Error in testing condition for breakpoint ${bp_num}:" \ + "The program being debugged timed out while in a function called from GDB\\." \ + "GDB has restored the context to what it was before the call\\." \ + "To change this behavior use \"set unwind-on-timeout off\"\\." \ + "Evaluation of the expression containing the function" \ + "\\(condition_func\\) will be abandoned\\." \ + "" \ + "Thread ${::decimal}\[^\r\n\]*hit Breakpoint ${bp_num}, \[^\r\n\]+" \ + "\[^\r\n\]+ Conditional breakpoint here\\. \[^\r\n\]+"] \ + "expected timeout waiting for inferior call to complete" } else { - set stopped_line_pattern "Thread ${::decimal} \"\[^\r\n\"\]+\" stopped\\." - } + # When non-stop mode is off we get slightly different output from GDB. + if { ([target_info gdb_protocol] == "remote" + || [target_info gdb_protocol] == "extended-remote") + && !$target_non_stop} { + set stopped_line_pattern \ + "Thread ${::decimal} \"\[^\r\n\"\]+\" received signal SIGINT, Interrupt\\." + } else { + set stopped_line_pattern "Thread ${::decimal} \"\[^\r\n\"\]+\" stopped\\." + } - gdb_test "continue" \ - [multi_line \ - $stopped_line_pattern \ - ".*" \ - "Error in testing condition for breakpoint ${bp_num}:" \ - "The program being debugged timed out while in a function called from GDB\\." \ - "GDB remains in the frame where the timeout occurred\\." \ - "To change this behavior use \"set unwind-on-timeout on\"\\." \ - "Evaluation of the expression containing the function" \ - "\\(condition_func\\) will be abandoned\\." \ - "When the function is done executing, GDB will silently stop\\."] \ - "expected timeout waiting for inferior call to complete" + gdb_test "continue" \ + [multi_line \ + "$stopped_line_pattern" \ + ".*" \ + "Error in testing condition for breakpoint ${bp_num}:" \ + "The program being debugged timed out while in a function called from GDB\\." \ + "GDB remains in the frame where the timeout occurred\\." \ + "To change this behavior use \"set unwind-on-timeout on\"\\." \ + "Evaluation of the expression containing the function" \ + "\\(condition_func\\) will be abandoned\\." \ + "When the function is done executing, GDB will silently stop\\."] \ + "expected timeout waiting for inferior call to complete" + } # Remember that other thread that either crashed (with a segfault) # or hit a breakpoint? Now that the inferior call has timed out, @@ -158,8 +180,11 @@ foreach_with_prefix target_async {"on" "off" } { # disabled. continue } - foreach_with_prefix other_thread_bp { true false } { - run_test $target_async $target_non_stop $non_stop $other_thread_bp + foreach_with_prefix unwind {"off" "on"} { + foreach_with_prefix other_thread_bp { true false } { + run_test $target_async $target_non_stop $non_stop \ + $other_thread_bp $unwind + } } } } -- 2.25.4