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
}
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
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
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
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__(
@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]
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
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>. */
+
+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;
+}
--- /dev/null
+# 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 <http://www.gnu.org/licenses/>.
+
+# 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
projects / thirdparty / binutils-gdb.git / commitdiff
