From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2126) id 2F9693858D33; Fri, 8 Mar 2024 17:56:32 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 2F9693858D33 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1709920592; bh=ZSyP3lAxwjPi1AHHv4EqxjbkFKbmxocg2gvnkfCVga8=; h=From:To:Subject:Date:From; b=F3ISLvaT18WXRgOQRvLmEhTyBTkD/jLUX5qvDhfOjdcKsuQy0T38Kzku06tTddXpH A4Mfr2ylRa1SzenNWWLkVsy6HGBKQ89muQg3/nHPeKL+LrGeLdS0x/OB3wNPBUxMak bG10jU5rXJe2ffoCoOkB5x7Fb4Z7jfuil5xBgwbE= Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable From: Tom Tromey To: gdb-cvs@sourceware.org Subject: [binutils-gdb] Add return value to DAP scope X-Act-Checkin: binutils-gdb X-Git-Author: Tom Tromey X-Git-Refname: refs/heads/master X-Git-Oldrev: 99761c5ab53e11105b6067bc4314e74bb066006c X-Git-Newrev: 2755241d02d7f129848adb6d76316b8116f346f8 Message-Id: <20240308175632.2F9693858D33@sourceware.org> Date: Fri, 8 Mar 2024 17:56:32 +0000 (GMT) List-Id: https://sourceware.org/git/gitweb.cgi?p=3Dbinutils-gdb.git;h=3D2755241d02d7= f129848adb6d76316b8116f346f8 commit 2755241d02d7f129848adb6d76316b8116f346f8 Author: Tom Tromey Date: Mon Feb 12 10:12:26 2024 -0700 Add return value to DAP scope =20 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. =20 This patch changes gdb to follow this convention. =20 Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=3D31341 Reviewed-By: K=C3=A9vin Le Gouguec Diff: --- 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/even= ts.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 @@ =20 import gdb =20 +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"] =3D [x.number for x in event.breakpoints] + if hasattr(event, "details") and "finish-value" in event.details: + set_finish_value(event.details["finish-value"]) =20 global _expected_pause global _expected_stop_reason diff --git a/gdb/python/lib/gdb/dap/scopes.py b/gdb/python/lib/gdb/dap/scop= es.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 =3D {} =20 =20 +# 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 =3D 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 =3D {} + global _last_return_value + _last_return_value =3D None =20 =20 gdb.events.cont.connect(clear_scopes) =20 =20 +@in_gdb_thread +def set_finish_value(val): + """Set the current 'finish' value on a stop.""" + global _last_return_value + _last_return_value =3D 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"] =3D self.hint # How would we know? result["expensive"] =3D False - result["namedVariables"] =3D len(self.var_list) + result["namedVariables"] =3D self.child_count() if self.line is not None: result["line"] =3D self.line # FIXME construct a Source object @@ -93,6 +108,22 @@ class _ScopeReference(BaseReference): return symbol_value(self.var_list[idx], self.frame) =20 =20 +# 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 =3D=3D 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): =20 @request("scopes") def scopes(*, frameId: int, **extra): + global _last_return_value global frame_to_scope if frameId in frame_to_scope: scopes =3D frame_to_scope[frameId] @@ -120,10 +152,13 @@ def scopes(*, frameId: int, **extra): args =3D tuple(frame.frame_args() or ()) if args: scopes.append(_ScopeReference("Arguments", "arguments", frame,= args)) + has_return_value =3D frameId =3D=3D 0 and _last_return_value is no= t None # Make sure to handle the None case as well as the empty # iterator case. locs =3D 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] =3D 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 =3D q; + return val; +} + +int +main () +{ + int q =3D 23; + return function_breakpoint_here (q).x - q; +} diff --git a/gdb/testsuite/gdb.dap/step-out.exp b/gdb/testsuite/gdb.dap/ste= p-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] =3D=3D -1} { + return +} + +if {[dap_initialize] =3D=3D ""} { + 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] =3D=3D ""} { + return +} +dap_wait_for_event_and_check "inferior started" thread "body reason" start= ed + +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] =3D=3D 2} "two scopes" + +lassign $scopes scope reg_scope +gdb_assert {[dict get $scope name] =3D=3D "Locals"} "scope is locals" +gdb_assert {[dict get $scope presentationHint] =3D=3D "locals"} \ + "locals presentation hint" +gdb_assert {[dict get $scope namedVariables] =3D=3D 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] =3D=3D "(return)"} \ + "variable is return value" + +dap_shutdown