From patchwork Tue Feb 13 16:58:53 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Tromey X-Patchwork-Id: 85673 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 C95C43858033 for ; Tue, 13 Feb 2024 16:59:33 +0000 (GMT) X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from mail-il1-x132.google.com (mail-il1-x132.google.com [IPv6:2607:f8b0:4864:20::132]) by sourceware.org (Postfix) with ESMTPS id 6388C3858011 for ; Tue, 13 Feb 2024 16:58:58 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 6388C3858011 Authentication-Results: sourceware.org; dmarc=pass (p=quarantine dis=none) header.from=adacore.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=adacore.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 6388C3858011 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2607:f8b0:4864:20::132 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1707843540; cv=none; b=GLPmZs0DGYtzhJFkrMjfrLKPKUpTNs+MWupL/SjkTsDCCtISFj5p4wFLo22/7RBiJnEZlkZb6CAfXGt8eKMEkGy775mihDHtmyLWxn0/HFnJQqUMb+7P31uQ/Mr8YGIgV+BxqOH14YkTHdrEQyryVWoqm5s94KZIt5SaVlXNsrs= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1707843540; c=relaxed/simple; bh=/U2nV7aasO1xW/CwJfSH54FRmAaCPA/q71ZzMTSyDp8=; h=DKIM-Signature:From:Date:Subject:MIME-Version:Message-Id:To; b=I/ffttj44HBVD0IJalja9vuMGypZhAexqGrkmqC/xhdJni4R1w70TGfngnsfQBdhK2f13/d7N/qlN3jboCMrwdefqqN4+e0VmKcE1Y6ADuqcHFW76qL3lNzpIr+wfeXOK1xW07Wf/61J40p83IFHepzYtw7Eg3r6cLRcKIpQ37Y= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-il1-x132.google.com with SMTP id e9e14a558f8ab-363b8429f03so13072995ab.1 for ; Tue, 13 Feb 2024 08:58:58 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=adacore.com; s=google; t=1707843537; x=1708448337; darn=sourceware.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=CVCM/3yQOmOY94rA+5MPWraRPT/APmT6Nkrfcz7BQ1Y=; b=Mjq90O8AfyYd7jYGAgiBOG1ffDGjIbTJKsWJ3ovDNUCvIV2f7bf4tDVGuCadK5AXVx 4yAgUvU6Oi217FVp0yjuNPvhHFhyRSt0jMllLpAN0f2YUJCLiJvqohXO10tKr/13J69z vrts//GRpAlapNnSz+729X8SNkfEXu5pHcB3WQJOQICSmB2uGvL6Him57aaW3TPsxWkL /bgSRT++FlTHZt+0YagsGx5/+HJZ7svzWUV1/AAZd0dLkpK0MVWhPF4nugQPD9crkByR kWVub25mulM6hVkuKph5M3tD7wOLi6xZ4TGazpf8bIz30O6IC4wVBMUD50Uh3bzcVAQG 5bxw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1707843537; x=1708448337; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=CVCM/3yQOmOY94rA+5MPWraRPT/APmT6Nkrfcz7BQ1Y=; b=rniJVNaaqD+bPnMiy9KfXduj2Dm0A/xYy3ZeQtEqqE2iP9JrFjKpbcb7D3cxMOY2NN jxRXIhV/R9sUZ8SD9QZWKT2mLIkhlr7f98J6wJN0cM6Sa2aXIDfA2fjULsx1q5gQhc5b Ll3LbfIciqL4rzZY0xegFNyd3P3rTu3A2fGKF/v6a36MWi7Gnf9doY0Iji/wrCgayitj 5au4GOwMo/sHhEKMEYvV3T8EKpCWnQ01bDFmDD7OacZP9somxmkSoYIeZt7LtaYamG55 CPdYoSzBfUoRmnrWRHhJ+qBvw05Bi3gj3xfRfMA1c98uUC+AhAJUmphxQnwEBUJZW2nn FZKw== X-Gm-Message-State: AOJu0YzRg0Ca3m6kMRxcrzxOEkd3YhPLWPYnsAt5pQxwH2Op8RSkupem 7nmwAbPVLAUwmobG/UMp09AyyVUDUD9erAwz0CK6Qjhyp8vufrpJvA81by2w9gZek54kFB3s9v4 = X-Google-Smtp-Source: AGHT+IFhumvzG5ChwyCgPhWtthSL+IDe3K2/muCzVRZhSooT7LqDezqqM73IcM2eItf/aLe9MI9FTg== X-Received: by 2002:a05:6e02:cd3:b0:363:e8f4:eb4f with SMTP id c19-20020a056e020cd300b00363e8f4eb4fmr227485ilj.3.1707843537611; Tue, 13 Feb 2024 08:58:57 -0800 (PST) Received: from localhost.localdomain (71-211-170-195.hlrn.qwest.net. [71.211.170.195]) by smtp.gmail.com with ESMTPSA id bn29-20020a056e02339d00b00363c664cfeasm2622692ilb.61.2024.02.13.08.58.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 13 Feb 2024 08:58:57 -0800 (PST) From: Tom Tromey Date: Tue, 13 Feb 2024 09:58:53 -0700 Subject: [PATCH v2 1/2] Export "finish" return value to Python MIME-Version: 1.0 Message-Id: <20240213-dap-finish-v2-1-d507b889d735@adacore.com> References: <20240213-dap-finish-v2-0-d507b889d735@adacore.com> In-Reply-To: <20240213-dap-finish-v2-0-d507b889d735@adacore.com> To: gdb-patches@sourceware.org Cc: Eli Zaretskii X-Mailer: b4 0.12.4 X-Spam-Status: No, score=-11.0 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, 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 This patch changes the Python "stop" event emission code to also add the function return value, if it is known. This happens when the stop comes from a "finish" command and when the value can be fetched. The test is in the next patch. Reviewed-By: Eli Zaretskii --- gdb/doc/python.texi | 6 ++++++ gdb/infcmd.c | 17 ----------------- gdb/python/py-stopevent.c | 23 ++++++++++++++++++++++- gdb/thread-fsm.h | 19 +++++++++++++++++++ 4 files changed, 47 insertions(+), 18 deletions(-) diff --git a/gdb/doc/python.texi b/gdb/doc/python.texi index ece9038844c..21a84fabb34 100644 --- a/gdb/doc/python.texi +++ b/gdb/doc/python.texi @@ -3813,6 +3813,12 @@ corresponding MI output (@pxref{GDB/MI Async Records}). A dictionary was used for this (rather than adding attributes directly to the event object) so that the MI keys could be used unchanged. + +When a @code{StopEvent} results from a @code{finish} command, it will +also hold the return value from the function, if that is available. +This will be an entry named @samp{return-value} in the @code{details} +dictionary. The value of this entry will be a @code{gdb.Value} +object. @end defvar Emits @code{gdb.SignalEvent}, which extends @code{gdb.StopEvent}. diff --git a/gdb/infcmd.c b/gdb/infcmd.c index 4e17a6b0629..68f64f0d2b3 100644 --- a/gdb/infcmd.c +++ b/gdb/infcmd.c @@ -1484,23 +1484,6 @@ get_return_value (struct symbol *func_symbol, struct value *function) return value; } -/* The captured function return value/type and its position in the - value history. */ - -struct return_value_info -{ - /* The captured return value. May be NULL if we weren't able to - retrieve it. See get_return_value. */ - struct value *value; - - /* The return type. In some cases, we'll not be able extract the - return value, but we always know the type. */ - struct type *type; - - /* If we captured a value, this is the value history index. */ - int value_history_index; -}; - /* Helper for print_return_value. */ static void diff --git a/gdb/python/py-stopevent.c b/gdb/python/py-stopevent.c index 61d93727b31..fcaebe26f13 100644 --- a/gdb/python/py-stopevent.c +++ b/gdb/python/py-stopevent.c @@ -20,6 +20,7 @@ #include "defs.h" #include "py-stopevent.h" #include "py-uiout.h" +#include "thread-fsm.h" gdbpy_ref<> create_stop_event_object (PyTypeObject *py_type, const gdbpy_ref<> &dict) @@ -45,6 +46,7 @@ static gdbpy_ref<> py_print_bpstat (bpstat *bs, enum gdb_signal stop_signal) { py_ui_out uiout; + struct value *return_value = nullptr; try { @@ -55,6 +57,10 @@ py_print_bpstat (bpstat *bs, enum gdb_signal stop_signal) { async_reply_reason reason = tp->thread_fsm ()->async_reply_reason (); uiout.field_string ("reason", async_reason_lookup (reason)); + + return_value_info *rvinfo = tp->thread_fsm ()->return_value (); + if (rvinfo != nullptr && rvinfo->value != nullptr) + return_value = rvinfo->value; } if (stop_signal != GDB_SIGNAL_0 && stop_signal != GDB_SIGNAL_TRAP) @@ -73,7 +79,22 @@ py_print_bpstat (bpstat *bs, enum gdb_signal stop_signal) return nullptr; } - return uiout.result (); + gdbpy_ref<> dict = uiout.result (); + if (dict == nullptr) + return nullptr; + + /* This has to be done separately to avoid error issues, and because + there's no API to add generic Python objects to a py_ui_out. */ + if (return_value != nullptr) + { + gdbpy_ref<> val (value_to_value_object (return_value)); + if (val == nullptr) + return nullptr; + if (PyDict_SetItemString (dict.get (), "finish-value", val.get ()) < 0) + return nullptr; + } + + return dict; } /* Callback observers when a stop event occurs. This function will create a diff --git a/gdb/thread-fsm.h b/gdb/thread-fsm.h index 90abb5c27f6..ed117719c0d 100644 --- a/gdb/thread-fsm.h +++ b/gdb/thread-fsm.h @@ -23,6 +23,25 @@ struct return_value_info; struct thread_fsm_ops; +struct type; +struct value; + +/* The captured function return value/type and its position in the + value history. */ + +struct return_value_info +{ + /* The captured return value. May be NULL if we weren't able to + retrieve it. See get_return_value. */ + struct value *value; + + /* The return type. In some cases, we'll not be able extract the + return value, but we always know the type. */ + struct type *type; + + /* If we captured a value, this is the value history index. */ + int value_history_index; +}; /* A thread finite-state machine structure contains the necessary info and callbacks to manage the state machine protocol of a thread's From patchwork Tue Feb 13 16:58:54 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Tom Tromey X-Patchwork-Id: 85674 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 B76B63858038 for ; Tue, 13 Feb 2024 17:00:01 +0000 (GMT) X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from mail-il1-x12a.google.com (mail-il1-x12a.google.com [IPv6:2607:f8b0:4864:20::12a]) by sourceware.org (Postfix) with ESMTPS id 079C238582B1 for ; Tue, 13 Feb 2024 16:58:59 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 079C238582B1 Authentication-Results: sourceware.org; dmarc=pass (p=quarantine dis=none) header.from=adacore.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=adacore.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 079C238582B1 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2607:f8b0:4864:20::12a ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1707843542; cv=none; b=mK1Ivw0Zg7SRX9dIMjUcRwDKlE/11OdFePFtXzDw9cASg8ylz0/ExWCYpgOSlhsk0OjhJ9WHDpbj/WZPqhue7g59hEa+ufNtaTpYSm0I11nk16xdx8uw/POPvK4xblhIJ++vSVduzUnss7/b8uFHotMkXaq/wVuWL9u3eYL4RVU= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1707843542; c=relaxed/simple; bh=gtZieoAAY3cYaduhjvVDybIfd/Rnq49GiU1bvZcIA0Y=; h=DKIM-Signature:From:Date:Subject:MIME-Version:Message-Id:To; b=owB0jS6hhu8TbE3ZqBWAHP7CA39RtxgceKRR8O/VuAbiRx3wsZiwV0E+MRBjNfD6pRfoO3t6GdR9Y0NT6DPzMa9G52ZOejKv/+Svpn/v+gQuaV7K3opXwH3Gvn5YwJLmDhoeQMGCw9bfn/DItU01bk03HdARoFXgZKQmVTRUPPs= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-il1-x12a.google.com with SMTP id e9e14a558f8ab-36423c819a3so1341415ab.0 for ; Tue, 13 Feb 2024 08:58:58 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=adacore.com; s=google; t=1707843538; x=1708448338; darn=sourceware.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=wHu9UzevIALHAE+l2ad0clvjNaRa1tsE5xrPJVFQx5s=; b=Tk6uHn84d7fYiAG8/wndDMYcXAEyAUWLHZpbYiRKWlq5umobY6LXaPJorCoLHUHMco aKprmiP67ZqFG6bPan0dFGoMGYnsDuqIxG0k2FLP+ZNskFK64osMx9za7XMRkoCsckUl l7fbTgxnMdl2pyPtAI73yMB5mYKwnrw6QifrbK7r2A+03ec9zFGRbFp+wdX9KKvhZphK BvoOSSErO3oxG6QLRt0sooVFu0wowlVXsQF+ZZs8xd7iw2bpPVVUuSUOQ/AN0PLFPXcl QpYohw0apqQlb/rx4NaS5rmqeplkmTi1C2w2/1vROVubbZqrRIX6CgTfaG4EMo0cj+hS 2NSA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1707843538; x=1708448338; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=wHu9UzevIALHAE+l2ad0clvjNaRa1tsE5xrPJVFQx5s=; b=KH1+H9/HSOwaPqjwj3Xdaq99VqaeVfJMoSuvSDKlcI+3w0NWq+0De+yvvaMvIVlVFv BGouTdMsrEBcpQK2jm5JmwWuQbD91ZTbvbxmFYKxir6/1zWgGdkFuceRGEQFZLs9MFfo aZz/RqkQH36al1b7xeIYlqckh/3yAtX9H/a+BWo8KABFJIzrNut2vw3Rj3buv0Qc2jCi 3Yoe6HMOcGOuhi2bldGzEYmu8QghOZurVlR9JkxKU2aMBIzBUmDUajyjD5n//scHVwQJ utmUrszY6pfeJRD/Tc8S3DvCNBMfXRPgWbB+F9qXn0kCnOBDTOBiAW4TYR1GrJR7kKue H2qA== X-Gm-Message-State: AOJu0YzeA3dMhFoHl/zUvsFi2KKUZZU8mkAA/iPkjF4cIAvpeoJd2O3P bG19+ap6JUFkdJmF24UsuouzjPQeAM9wWAPuIfOZmNrdNIE/mHL/X4l+nNlvF5ZZlxsZDUW4PZY = X-Google-Smtp-Source: AGHT+IFuGBdUeFRjf5tbcVr7eRicFeJOaoJugF07FvzgGfJH/a+jHDQug+cREWYr4cCjQscOXre98A== X-Received: by 2002:a05:6e02:1bca:b0:363:b695:5d5a with SMTP id x10-20020a056e021bca00b00363b6955d5amr310447ilv.18.1707843538179; Tue, 13 Feb 2024 08:58:58 -0800 (PST) Received: from localhost.localdomain (71-211-170-195.hlrn.qwest.net. [71.211.170.195]) by smtp.gmail.com with ESMTPSA id bn29-20020a056e02339d00b00363c664cfeasm2622692ilb.61.2024.02.13.08.58.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 13 Feb 2024 08:58:57 -0800 (PST) From: Tom Tromey Date: Tue, 13 Feb 2024 09:58:54 -0700 Subject: [PATCH v2 2/2] Add return value to DAP scope MIME-Version: 1.0 Message-Id: <20240213-dap-finish-v2-2-d507b889d735@adacore.com> References: <20240213-dap-finish-v2-0-d507b889d735@adacore.com> In-Reply-To: <20240213-dap-finish-v2-0-d507b889d735@adacore.com> To: gdb-patches@sourceware.org Cc: =?utf-8?q?K=C3=A9vin_Le_Gouguec?= X-Mailer: b4 0.12.4 X-Spam-Status: No, score=-11.2 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, 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 A bug report in the DAP specification repository pointed out that it is typical for DAP implementations to put a function's return value into the outermost scope. This patch changes gdb to follow this convention. Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=31341 Reviewed-By: Kévin Le Gouguec --- gdb/python/lib/gdb/dap/events.py | 3 ++ gdb/python/lib/gdb/dap/scopes.py | 39 +++++++++++++++++- gdb/testsuite/gdb.dap/step-out.c | 36 +++++++++++++++++ gdb/testsuite/gdb.dap/step-out.exp | 82 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 158 insertions(+), 2 deletions(-) diff --git a/gdb/python/lib/gdb/dap/events.py b/gdb/python/lib/gdb/dap/events.py index 41302229ee5..928f23fd3ff 100644 --- a/gdb/python/lib/gdb/dap/events.py +++ b/gdb/python/lib/gdb/dap/events.py @@ -15,6 +15,7 @@ import gdb +from .scopes import set_finish_value from .server import send_event from .startup import exec_and_log, in_gdb_thread, log from .modules import is_module, make_module @@ -218,6 +219,8 @@ def _on_stop(event): } if isinstance(event, gdb.BreakpointEvent): obj["hitBreakpointIds"] = [x.number for x in event.breakpoints] + if hasattr(event, "details") and "finish-value" in event.details: + set_finish_value(event.details["finish-value"]) global _expected_pause global _expected_stop_reason diff --git a/gdb/python/lib/gdb/dap/scopes.py b/gdb/python/lib/gdb/dap/scopes.py index ff553259ea9..be2c382b40b 100644 --- a/gdb/python/lib/gdb/dap/scopes.py +++ b/gdb/python/lib/gdb/dap/scopes.py @@ -25,17 +25,32 @@ from .varref import BaseReference frame_to_scope = {} +# If the most recent stop was due to a 'finish', and the return value +# could be computed, then this holds that value. Otherwise it holds +# None. +_last_return_value = None + + # When the inferior is re-started, we erase all scope references. See # the section "Lifetime of Objects References" in the spec. @in_gdb_thread def clear_scopes(event): global frame_to_scope frame_to_scope = {} + global _last_return_value + _last_return_value = None gdb.events.cont.connect(clear_scopes) +@in_gdb_thread +def set_finish_value(val): + """Set the current 'finish' value on a stop.""" + global _last_return_value + _last_return_value = val + + # A helper function to compute the value of a symbol. SYM is either a # gdb.Symbol, or an object implementing the SymValueWrapper interface. # FRAME is a frame wrapper, as produced by a frame filter. Returns a @@ -76,7 +91,7 @@ class _ScopeReference(BaseReference): result["presentationHint"] = self.hint # How would we know? result["expensive"] = False - result["namedVariables"] = len(self.var_list) + result["namedVariables"] = self.child_count() if self.line is not None: result["line"] = self.line # FIXME construct a Source object @@ -93,6 +108,22 @@ class _ScopeReference(BaseReference): return symbol_value(self.var_list[idx], self.frame) +# A _ScopeReference that prepends the most recent return value. Note +# that this object is only created if such a value actually exists. +class _FinishScopeReference(_ScopeReference): + def __init__(self, *args): + super().__init__(*args) + + def child_count(self): + return super().child_count() + 1 + + def fetch_one_child(self, idx): + if idx == 0: + global _last_return_value + return ("(return)", _last_return_value) + return super().fetch_one_child(idx - 1) + + class _RegisterReference(_ScopeReference): def __init__(self, name, frame): super().__init__( @@ -109,6 +140,7 @@ class _RegisterReference(_ScopeReference): @request("scopes") def scopes(*, frameId: int, **extra): + global _last_return_value global frame_to_scope if frameId in frame_to_scope: scopes = frame_to_scope[frameId] @@ -120,10 +152,13 @@ def scopes(*, frameId: int, **extra): args = tuple(frame.frame_args() or ()) if args: scopes.append(_ScopeReference("Arguments", "arguments", frame, args)) + has_return_value = frameId == 0 and _last_return_value is not None # Make sure to handle the None case as well as the empty # iterator case. locs = tuple(frame.frame_locals() or ()) - if locs: + if has_return_value: + scopes.append(_FinishScopeReference("Locals", "locals", frame, locs)) + elif locs: scopes.append(_ScopeReference("Locals", "locals", frame, locs)) scopes.append(_RegisterReference("Registers", frame)) frame_to_scope[frameId] = scopes diff --git a/gdb/testsuite/gdb.dap/step-out.c b/gdb/testsuite/gdb.dap/step-out.c new file mode 100644 index 00000000000..8c7e6942342 --- /dev/null +++ b/gdb/testsuite/gdb.dap/step-out.c @@ -0,0 +1,36 @@ +/* Copyright 2024 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +struct result +{ + int x; +}; + +struct result +function_breakpoint_here (int q) +{ + struct result val; + val.x = q; + return val; +} + +int +main () +{ + int q = 23; + return function_breakpoint_here (q).x - q; +} diff --git a/gdb/testsuite/gdb.dap/step-out.exp b/gdb/testsuite/gdb.dap/step-out.exp new file mode 100644 index 00000000000..757f4ebdaca --- /dev/null +++ b/gdb/testsuite/gdb.dap/step-out.exp @@ -0,0 +1,82 @@ +# Copyright 2024 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + +# Test that stepOut puts the return value in scope. + +require allow_dap_tests + +load_lib dap-support.exp + +standard_testfile + +if {[build_executable ${testfile}.exp $testfile] == -1} { + return +} + +if {[dap_initialize] == ""} { + return +} + +set obj [dap_check_request_and_response "set breakpoint on function" \ + setFunctionBreakpoints \ + {o breakpoints [a [o name [s function_breakpoint_here]]]}] +set fn_bpno [dap_get_breakpoint_number $obj] + +dap_check_request_and_response "configurationDone" configurationDone + +if {[dap_launch $testfile] == ""} { + return +} +dap_wait_for_event_and_check "inferior started" thread "body reason" started + +dap_wait_for_event_and_check "stopped at function breakpoint" stopped \ + "body reason" breakpoint \ + "body hitBreakpointIds" $fn_bpno + +dap_check_request_and_response "return from function" stepOut \ + {o threadId [i 1]} +dap_wait_for_event_and_check "stopped after return" stopped \ + "body reason" step + +set bt [lindex [dap_check_request_and_response "backtrace" stackTrace \ + {o threadId [i 1]}] \ + 0] +set frame_id [dict get [lindex [dict get $bt body stackFrames] 0] id] + +set scopes [dap_check_request_and_response "get scopes" scopes \ + [format {o frameId [i %d]} $frame_id]] +set scopes [dict get [lindex $scopes 0] body scopes] + +gdb_assert {[llength $scopes] == 2} "two scopes" + +lassign $scopes scope reg_scope +gdb_assert {[dict get $scope name] == "Locals"} "scope is locals" +gdb_assert {[dict get $scope presentationHint] == "locals"} \ + "locals presentation hint" +gdb_assert {[dict get $scope namedVariables] == 2} "two vars in scope" + +set num [dict get $scope variablesReference] +set refs [lindex [dap_check_request_and_response "fetch arguments" \ + "variables" \ + [format {o variablesReference [i %d]} $num]] \ + 0] +set varlist [lindex [dict get $refs body variables] 0] + +gdb_assert {[dict get $varlist variablesReference] > 0} \ + "variable has children" +gdb_assert {[dict get $varlist name] == "(return)"} \ + "variable is return value" + +dap_shutdown