[llvm-branch-commits] [lldb] f603629 - [lldb] Fix SBAPI breakage in SBFrame::GetValueForVariablePath (#218565)
Tobias Hieta via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Sat Sep 5 00:12:39 PDT 2026
Author: Ebuka Ezike
Date: 2026-09-05T09:12:11+02:00
New Revision: f603629d9ec7e00e980813e72c33d7609af622cb
URL: https://github.com/llvm/llvm-project/commit/f603629d9ec7e00e980813e72c33d7609af622cb
DIFF: https://github.com/llvm/llvm-project/commit/f603629d9ec7e00e980813e72c33d7609af622cb.diff
LOG: [lldb] Fix SBAPI breakage in SBFrame::GetValueForVariablePath (#218565)
SBFrame::GetValueForVariablePath added new parameters in commit
80fffd527c20ac8970fbffc37c674caa17faa815.
This caused an ABI break because
the ABI is based on the function's mangled name, which changes when
parameters are added. Existing users depend on the original symbol being
present in the library.
changing the ABI from:
```cpp
// _ZN4lldb7SBFrame23GetValueForVariablePathEPKcNS_16DynamicValueTypeE
lldb::SBFrame::GetValueForVariablePath(char const*, lldb::DynamicValueType)
```
to
```cpp
// _ZN4lldb7SBFrame23GetValueForVariablePathEPKcNS_16DynamicValueTypeENS_7DILModeE`
lldb::SBFrame::GetValueForVariablePath(char const*, lldb::DynamicValueType, lldb::DILMode)
```
Normally, this can be fixed by manually overloading the function from:
```cpp
GetValueForVariablePath(const char *, DynamicValueType, lldb::DILMode = lldb::eDILModeFull);
```
to
```cpp
GetValueForVariablePath(const char *, DynamicValueType);
GetValueForVariablePath(const char *, DynamicValueType, lldb::DILMode mode);
```
with the two-argument overload setting the mode in the implementation.
However, this approach does not work for the Python API because enums
are converted to integers. The four C++ overloads:
```cpp
GetValueForVariablePath(const char *);
GetValueForVariablePath(const char *, lldb::DILMode);
GetValueForVariablePath(const char *, DynamicValueType);
GetValueForVariablePath(const char *, DynamicValueType, lldb::DILMode mode);
```
would appear in python as:
```py
GetValueForVariablePath(str)
GetValueForVariablePath(str, int)
GetValueForVariablePath(str, int)
GetValueForVariablePath(str, int, int)
```
As a result, there is no way to distinguish between `lldb::DILMode` and
`lldb::DynamicValueType` when they are passed as the second parameter.
Existing test did not catch this because there is not test covering
`GetValueForVariablePath(const char *, DynamicValueType)`).
Instead I added an new function called
```cpp
GetValueForVariablePathWithMode(const char*, lldb::DILMode)
GetValueForVariablePathWithMode(const char*, lldb::DILMode, DynamicValueType)
```
and a python helper.
```python
class SBFrame:
def var_with_mode(self, var_path: str, mode: int, use_dynamic: int, /):
...
```
mirroring the existing `SBFrame.var` helper function.
(cherry picked from commit 4e1a982f130bcd329a062e6c458c3d8818b6ddf3)
Added:
Modified:
lldb/bindings/interface/SBFrameExtensions.i
lldb/include/lldb/API/SBFrame.h
lldb/source/API/SBFrame.cpp
lldb/test/API/commands/frame/var-dil/basics/AddressOf/TestFrameVarDILAddressOf.py
lldb/test/API/commands/frame/var-dil/basics/ArraySubscript/TestFrameVarDILArraySubscript.py
lldb/test/API/commands/frame/var-dil/basics/MemberOf/TestFrameVarDILMemberOf.py
lldb/test/API/commands/frame/var-dil/basics/PointerDereference/TestFrameVarDILPointerDereference.py
lldb/test/API/commands/frame/var-dil/expr/Arithmetic/TestFrameVarDILArithmetic.py
lldb/test/API/commands/frame/var-dil/expr/Casts/TestFrameVarDILCast.py
lldb/test/API/functionalities/var_path/TestVarPath.py
lldb/test/API/functionalities/var_path/main.cpp
lldb/tools/lldb-dap/Handler/EvaluateRequestHandler.cpp
lldb/tools/lldb-dap/SourceBreakpoint.cpp
Removed:
################################################################################
diff --git a/lldb/bindings/interface/SBFrameExtensions.i b/lldb/bindings/interface/SBFrameExtensions.i
index 0c79b98b290f2..64ca132d159f5 100644
--- a/lldb/bindings/interface/SBFrameExtensions.i
+++ b/lldb/bindings/interface/SBFrameExtensions.i
@@ -40,10 +40,17 @@ STRING_EXTENSION_OUTSIDE(SBFrame)
def get_statics(self):
return self.GetVariables(False,False,True,False)
- def var(self, var_expr_path):
+ def var(self, var_expr_path, use_dynamic=None):
'''Calls through to lldb.SBFrame.GetValueForVariablePath() and returns
a value that represents the variable expression path'''
- return self.GetValueForVariablePath(var_expr_path)
+ if use_dynamic is None:
+ return self.GetValueForVariablePath(var_expr_path)
+ return self.GetValueForVariablePath(var_expr_path, use_dynamic)
+
+ def var_with_mode(self, var_path: str, mode: int, use_dynamic = None, /):
+ if use_dynamic is None:
+ return self.GetValueForVariablePathWithMode(var_path, mode)
+ return self.GetValueForVariablePathWithMode(var_path, mode, use_dynamic)
def get_registers_access(self):
class registers_access(object):
diff --git a/lldb/include/lldb/API/SBFrame.h b/lldb/include/lldb/API/SBFrame.h
index eaf9a4bfece96..37c85b0732613 100644
--- a/lldb/include/lldb/API/SBFrame.h
+++ b/lldb/include/lldb/API/SBFrame.h
@@ -182,16 +182,19 @@ class LLDB_API SBFrame {
// expression result and is not a constant object like
// SBFrame::EvaluateExpression(...) returns, but a child object of the
// variable value.
- lldb::SBValue
- GetValueForVariablePath(const char *var_expr_cstr,
- DynamicValueType use_dynamic,
- lldb::DILMode mode = lldb::eDILModeFull);
+ lldb::SBValue GetValueForVariablePath(const char *var_path,
+ DynamicValueType use_dynamic);
/// The version that doesn't supply a 'use_dynamic' value will use the
/// target's default.
- lldb::SBValue
- GetValueForVariablePath(const char *var_path,
- lldb::DILMode mode = lldb::eDILModeFull);
+ lldb::SBValue GetValueForVariablePath(const char *var_path);
+
+ lldb::SBValue GetValueForVariablePathWithMode(const char *var_path,
+ lldb::DILMode mode,
+ DynamicValueType use_dynamic);
+
+ lldb::SBValue GetValueForVariablePathWithMode(const char *var_path,
+ lldb::DILMode mode);
/// Find variables, register sets, registers, or persistent variables using
/// the frame as the scope.
diff --git a/lldb/source/API/SBFrame.cpp b/lldb/source/API/SBFrame.cpp
index 9158685f78c04..6debaa12dcfe6 100644
--- a/lldb/source/API/SBFrame.cpp
+++ b/lldb/source/API/SBFrame.cpp
@@ -365,8 +365,7 @@ void SBFrame::Clear() {
m_opaque_sp->Clear();
}
-lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
- lldb::DILMode mode) {
+lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) {
LLDB_INSTRUMENT_VA(this, var_path);
SBValue sb_value;
@@ -380,14 +379,13 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
if (StackFrame *frame = exe_ctx->GetFramePtr()) {
lldb::DynamicValueType use_dynamic =
frame->CalculateTarget()->GetPreferDynamicValue();
- sb_value = GetValueForVariablePath(var_path, use_dynamic, mode);
+ sb_value = GetValueForVariablePath(var_path, use_dynamic);
}
return sb_value;
}
lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
- DynamicValueType use_dynamic,
- lldb::DILMode mode) {
+ DynamicValueType use_dynamic) {
LLDB_INSTRUMENT_VA(this, var_path, use_dynamic);
SBValue sb_value;
@@ -402,6 +400,55 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
return sb_value;
}
+ if (StackFrame *frame = exe_ctx->GetFramePtr()) {
+ VariableSP var_sp;
+ Status error;
+ ValueObjectSP value_sp(frame->GetValueForVariableExpressionPath(
+ var_path, eNoDynamicValues,
+ StackFrame::eExpressionPathOptionCheckPtrVsMember |
+ StackFrame::eExpressionPathOptionsAllowDirectIVarAccess,
+ var_sp, error, lldb::eDILModeFull));
+ sb_value.SetSP(value_sp, use_dynamic);
+ }
+ return sb_value;
+}
+
+lldb::SBValue SBFrame::GetValueForVariablePathWithMode(const char *var_path,
+ lldb::DILMode mode) {
+ LLDB_INSTRUMENT_VA(this, var_path, mode);
+
+ SBValue sb_value;
+ llvm::Expected<StoppedExecutionContext> exe_ctx =
+ GetStoppedExecutionContext(m_opaque_sp);
+ if (!exe_ctx) {
+ LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}");
+ return sb_value;
+ }
+
+ if (StackFrame *frame = exe_ctx->GetFramePtr()) {
+ lldb::DynamicValueType use_dynamic =
+ frame->CalculateTarget()->GetPreferDynamicValue();
+ sb_value = GetValueForVariablePathWithMode(var_path, mode, use_dynamic);
+ }
+ return sb_value;
+}
+
+lldb::SBValue SBFrame::GetValueForVariablePathWithMode(
+ const char *var_path, lldb::DILMode mode, DynamicValueType use_dynamic) {
+ LLDB_INSTRUMENT_VA(this, var_path, mode, use_dynamic);
+
+ SBValue sb_value;
+ if (var_path == nullptr || var_path[0] == '\0') {
+ return sb_value;
+ }
+
+ llvm::Expected<StoppedExecutionContext> exe_ctx =
+ GetStoppedExecutionContext(m_opaque_sp);
+ if (!exe_ctx) {
+ LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}");
+ return sb_value;
+ }
+
if (StackFrame *frame = exe_ctx->GetFramePtr()) {
VariableSP var_sp;
Status error;
diff --git a/lldb/test/API/commands/frame/var-dil/basics/AddressOf/TestFrameVarDILAddressOf.py b/lldb/test/API/commands/frame/var-dil/basics/AddressOf/TestFrameVarDILAddressOf.py
index bfe29370b4704..4d401dadbe064 100644
--- a/lldb/test/API/commands/frame/var-dil/basics/AddressOf/TestFrameVarDILAddressOf.py
+++ b/lldb/test/API/commands/frame/var-dil/basics/AddressOf/TestFrameVarDILAddressOf.py
@@ -39,7 +39,7 @@ def test_frame_var(self):
# Check that '&' is not allowed in simple mode, but allowed in legacy mode
frame = thread.GetFrameAtIndex(0)
- simple = frame.GetValueForVariablePath("&x", lldb.eDILModeSimple)
- legacy = frame.GetValueForVariablePath("&x", lldb.eDILModeLegacy)
+ simple = frame.GetValueForVariablePathWithMode("&x", lldb.eDILModeSimple)
+ legacy = frame.GetValueForVariablePathWithMode("&x", lldb.eDILModeLegacy)
self.assertFailure(simple.GetError())
self.assertSuccess(legacy.GetError())
diff --git a/lldb/test/API/commands/frame/var-dil/basics/ArraySubscript/TestFrameVarDILArraySubscript.py b/lldb/test/API/commands/frame/var-dil/basics/ArraySubscript/TestFrameVarDILArraySubscript.py
index 6f3bbfb970aa4..d0477ac846f70 100644
--- a/lldb/test/API/commands/frame/var-dil/basics/ArraySubscript/TestFrameVarDILArraySubscript.py
+++ b/lldb/test/API/commands/frame/var-dil/basics/ArraySubscript/TestFrameVarDILArraySubscript.py
@@ -89,10 +89,19 @@ def test_subscript(self):
# Check that subscription is not allowed in simple mode, but allowed in legacy mode
frame = thread.GetFrameAtIndex(0)
- simple = frame.GetValueForVariablePath("int_arr[0]", lldb.eDILModeSimple)
- legacy = frame.GetValueForVariablePath("int_arr[0]", lldb.eDILModeLegacy)
+ simple = frame.GetValueForVariablePathWithMode(
+ "int_arr[0]", lldb.eDILModeSimple
+ )
+ simple_other = frame.var_with_mode("int_arr[0]", lldb.eDILModeSimple)
+ legacy = frame.GetValueForVariablePathWithMode(
+ "int_arr[0]", lldb.eDILModeLegacy
+ )
+ legacy_other = frame.var_with_mode("int_arr[0]", lldb.eDILModeLegacy)
+
self.assertFailure(simple.GetError())
+ self.assertFailure(simple_other.GetError())
self.assertSuccess(legacy.GetError())
+ self.assertSuccess(legacy_other.GetError())
def test_subscript_synthetic(self):
self.build()
diff --git a/lldb/test/API/commands/frame/var-dil/basics/MemberOf/TestFrameVarDILMemberOf.py b/lldb/test/API/commands/frame/var-dil/basics/MemberOf/TestFrameVarDILMemberOf.py
index d37ce0bbc4201..91ec777a5d2e4 100644
--- a/lldb/test/API/commands/frame/var-dil/basics/MemberOf/TestFrameVarDILMemberOf.py
+++ b/lldb/test/API/commands/frame/var-dil/basics/MemberOf/TestFrameVarDILMemberOf.py
@@ -52,13 +52,13 @@ def test_frame_var(self):
# Check that '.' is allowed in both simple and legacy modes
frame = thread.GetFrameAtIndex(0)
- simple = frame.GetValueForVariablePath("s.x", lldb.eDILModeSimple)
- legacy = frame.GetValueForVariablePath("s.x", lldb.eDILModeLegacy)
+ simple = frame.GetValueForVariablePathWithMode("s.x", lldb.eDILModeSimple)
+ legacy = frame.GetValueForVariablePathWithMode("s.x", lldb.eDILModeLegacy)
self.assertSuccess(simple.GetError())
self.assertSuccess(legacy.GetError())
# Check that '->' is not allowed in simple mode, but allowed in legacy mode
- simple = frame.GetValueForVariablePath("sp->x", lldb.eDILModeSimple)
- legacy = frame.GetValueForVariablePath("sp->x", lldb.eDILModeLegacy)
+ simple = frame.GetValueForVariablePathWithMode("sp->x", lldb.eDILModeSimple)
+ legacy = frame.GetValueForVariablePathWithMode("sp->x", lldb.eDILModeLegacy)
self.assertFailure(simple.GetError())
self.assertSuccess(legacy.GetError())
diff --git a/lldb/test/API/commands/frame/var-dil/basics/PointerDereference/TestFrameVarDILPointerDereference.py b/lldb/test/API/commands/frame/var-dil/basics/PointerDereference/TestFrameVarDILPointerDereference.py
index e18e18e146a46..0fd7534e07fc6 100644
--- a/lldb/test/API/commands/frame/var-dil/basics/PointerDereference/TestFrameVarDILPointerDereference.py
+++ b/lldb/test/API/commands/frame/var-dil/basics/PointerDereference/TestFrameVarDILPointerDereference.py
@@ -49,7 +49,7 @@ def test_frame_var(self):
# Check that * is not allowed in simple mode, but allowed in legacy mode
frame = thread.GetFrameAtIndex(0)
- simple = frame.GetValueForVariablePath("*p_int0", lldb.eDILModeSimple)
- legacy = frame.GetValueForVariablePath("*p_int0", lldb.eDILModeLegacy)
+ simple = frame.GetValueForVariablePathWithMode("*p_int0", lldb.eDILModeSimple)
+ legacy = frame.GetValueForVariablePathWithMode("*p_int0", lldb.eDILModeLegacy)
self.assertFailure(simple.GetError())
self.assertSuccess(legacy.GetError())
diff --git a/lldb/test/API/commands/frame/var-dil/expr/Arithmetic/TestFrameVarDILArithmetic.py b/lldb/test/API/commands/frame/var-dil/expr/Arithmetic/TestFrameVarDILArithmetic.py
index 7729c1ce23d7d..94268ecf46b27 100644
--- a/lldb/test/API/commands/frame/var-dil/expr/Arithmetic/TestFrameVarDILArithmetic.py
+++ b/lldb/test/API/commands/frame/var-dil/expr/Arithmetic/TestFrameVarDILArithmetic.py
@@ -169,9 +169,9 @@ def test_arithmetic(self):
# Check that binary * is allowed only in full mode
frame = thread.GetFrameAtIndex(0)
- simple = frame.GetValueForVariablePath("x * 2", lldb.eDILModeSimple)
- legacy = frame.GetValueForVariablePath("x * 2", lldb.eDILModeLegacy)
- full = frame.GetValueForVariablePath("x * 2", lldb.eDILModeFull)
+ simple = frame.GetValueForVariablePathWithMode("x * 2", lldb.eDILModeSimple)
+ legacy = frame.GetValueForVariablePathWithMode("x * 2", lldb.eDILModeLegacy)
+ full = frame.GetValueForVariablePathWithMode("x * 2", lldb.eDILModeFull)
self.assertFailure(simple.GetError())
self.assertFailure(legacy.GetError())
self.assertSuccess(full.GetError())
diff --git a/lldb/test/API/commands/frame/var-dil/expr/Casts/TestFrameVarDILCast.py b/lldb/test/API/commands/frame/var-dil/expr/Casts/TestFrameVarDILCast.py
index 567981cd670e9..385623eab1c71 100644
--- a/lldb/test/API/commands/frame/var-dil/expr/Casts/TestFrameVarDILCast.py
+++ b/lldb/test/API/commands/frame/var-dil/expr/Casts/TestFrameVarDILCast.py
@@ -303,8 +303,8 @@ def test_type_cast(self):
# Check that casts are not allowed in both simple and legacy modes
frame = thread.GetFrameAtIndex(0)
- simple = frame.GetValueForVariablePath("(char)a", lldb.eDILModeSimple)
- legacy = frame.GetValueForVariablePath("(char)a", lldb.eDILModeLegacy)
+ simple = frame.GetValueForVariablePathWithMode("(char)a", lldb.eDILModeSimple)
+ legacy = frame.GetValueForVariablePathWithMode("(char)a", lldb.eDILModeLegacy)
self.assertFailure(simple.GetError())
self.assertFailure(legacy.GetError())
diff --git a/lldb/test/API/functionalities/var_path/TestVarPath.py b/lldb/test/API/functionalities/var_path/TestVarPath.py
index 53c45f57f517d..873f659acfcf7 100644
--- a/lldb/test/API/functionalities/var_path/TestVarPath.py
+++ b/lldb/test/API/functionalities/var_path/TestVarPath.py
@@ -100,6 +100,8 @@ def do_test(self):
self.verify_point(frame, "pt_ptr[0]", "Point", 3030, 4040)
self.verify_point(frame, "pt_ptr[1]", "Point", 5050, 6060)
# Test arrays
+ v_helper = frame.var("points")
+ self.assertSuccess(v_helper.GetError(), "Make sure we find 'points'")
v = frame.GetValueForVariablePath("points")
self.assertSuccess(v.GetError(), "Make sure we find 'points'")
self.verify_point(frame, "points[0]", "Point", 1010, 2020)
@@ -121,3 +123,72 @@ def do_test(self):
self.assertTrue(
v.GetError().Fail(), "Make sure we don't find 'pt_sp->not_valid_child'"
)
+
+ @expectedFailureAll(
+ oslist=["windows"],
+ bugnumber="https://github.com/llvm/llvm-project/issues/25037",
+ )
+ def test_frame_var_use_dynamic(self):
+ """Test `SBFrame.GetValueForVariablePath` return the current value and variable type."""
+ self.build()
+ (_, _, thread, _) = lldbutil.run_to_source_breakpoint(
+ self, "// Set a breakpoint here", lldb.SBFileSpec("main.cpp")
+ )
+ frame: lldb.SBFrame = thread.GetFrameAtIndex(0)
+
+ # Verify concrete types.
+ concrete = [
+ ("shape", "Shape"),
+ ("shape_ref", "Shape &"),
+ ("shape_ptr", "Shape *"),
+ ("circle", "Circle"),
+ ("circle_ref", "Circle &"),
+ ("circle_ptr", "Circle *"),
+ ]
+ for name, expected_type in concrete:
+ for dyn_val in (lldb.eNoDynamicValues, lldb.eDynamicDontRunTarget):
+ val: lldb.SBValue = frame.GetValueForVariablePath(name, dyn_val)
+ self.assertSuccess(val.GetError(), f"Make sure we find {name!r}")
+ self.assertEqual(val.GetTypeName(), expected_type)
+
+ # Test the helper.
+ val: lldb.SBValue = frame.var(name, dyn_val)
+ self.assertTrue(val.GetError().Success(), f"Make sure we find {name!r}")
+ self.assertEqual(val.GetTypeName(), expected_type)
+
+ # Verify dynamic types.
+ polymorphic = [
+ ("circle_as_shape_ref", "Shape &", "Circle &"),
+ ("circle_as_shape_ptr", "Shape *", "Circle *"),
+ ("circle_as_drawable_ref", "Drawable &", "Circle &"),
+ ("circle_as_drawable_ptr", "Drawable *", "Circle *"),
+ ]
+ for name, static_type, dynamic_type in polymorphic:
+ static = frame.GetValueForVariablePath(name, lldb.eNoDynamicValues)
+ static_helper: lldb.SBValue = frame.var(name, lldb.eNoDynamicValues)
+ for val in (static, static_helper):
+ self.assertSuccess(val.GetError(), f"find {name!r} (static)")
+ self.assertEqual(static_type, val.GetTypeName())
+ self.assertNotIn("Circle", val.GetTypeName())
+ self.assertFalse(
+ val.GetChildMemberWithName("circle_val").IsValid(),
+ f"{name!r} should not expose circle_val under eNoDynamicValues",
+ )
+
+ dynamic = frame.GetValueForVariablePath(name, lldb.eDynamicDontRunTarget)
+ dynamic_helper: lldb.SBValue = frame.var(name, lldb.eDynamicDontRunTarget)
+ for val in (dynamic, dynamic_helper):
+ self.assertSuccess(val.GetError(), f"find {name!r} (dynamic)")
+ self.assertEqual(
+ dynamic_type,
+ val.GetTypeName(),
+ f"'{name}' should resolve to Circle under eDynamicDontRunTarget",
+ )
+ circle_val = val.GetChildMemberWithName("circle_val")
+ self.assertTrue(
+ circle_val.IsValid(),
+ f"{name!r} should expose circle_val under eDynamicDontRunTarget",
+ )
+
+ # Verify we can fetch the child from the static type.
+ self.assertEqual(circle_val.GetValueAsSigned(), 20)
diff --git a/lldb/test/API/functionalities/var_path/main.cpp b/lldb/test/API/functionalities/var_path/main.cpp
index 0ea19cfcfea53..daf1d95114657 100644
--- a/lldb/test/API/functionalities/var_path/main.cpp
+++ b/lldb/test/API/functionalities/var_path/main.cpp
@@ -1,5 +1,23 @@
#include <memory>
+class Shape {
+public:
+ virtual ~Shape() = default;
+ int shape_val = 10;
+};
+
+class Drawable {
+public:
+ virtual ~Drawable() = default;
+ virtual void draw() = 0;
+};
+
+class Circle : public Shape, public Drawable {
+public:
+ int circle_val = 20;
+ void draw() override {}
+};
+
struct Point {
int x, y;
};
@@ -10,6 +28,21 @@ int main() {
Point *pt_ptr = &points[1];
Point &pt_ref = pt;
std::shared_ptr<Point> pt_sp(new Point{111,222});
+
+ Shape shape{};
+ Shape &shape_ref = shape;
+ Shape *shape_ptr = &shape;
+
+ Circle circle{};
+ Circle &circle_ref = circle;
+ Circle *circle_ptr = &circle;
+
+ Shape &circle_as_shape_ref = circle;
+ Shape *circle_as_shape_ptr = &circle;
+
+ Drawable &circle_as_drawable_ref = circle;
+ Drawable *circle_as_drawable_ptr = &circle;
+
return 0; // Set a breakpoint here
}
diff --git a/lldb/tools/lldb-dap/Handler/EvaluateRequestHandler.cpp b/lldb/tools/lldb-dap/Handler/EvaluateRequestHandler.cpp
index 7537eca72ec25..878905ed5adc2 100644
--- a/lldb/tools/lldb-dap/Handler/EvaluateRequestHandler.cpp
+++ b/lldb/tools/lldb-dap/Handler/EvaluateRequestHandler.cpp
@@ -55,8 +55,8 @@ static lldb::SBValue EvaluateVariableExpression(lldb::SBTarget &target,
// Check if it is a variable or an expression path for a variable. i.e.
// 'foo->bar' finds the 'bar' variable. It is more reliable than the
// expression parser in many cases and it is faster.
- value = frame.GetValueForVariablePath(
- expression_cstr, lldb::eDynamicDontRunTarget, lldb::eDILModeLegacy);
+ value = frame.GetValueForVariablePathWithMode(
+ expression_cstr, lldb::eDILModeLegacy, lldb::eDynamicDontRunTarget);
if (value || !run_as_expression)
return value;
diff --git a/lldb/tools/lldb-dap/SourceBreakpoint.cpp b/lldb/tools/lldb-dap/SourceBreakpoint.cpp
index 233dbff81f337..f8dd75a2ab6c7 100644
--- a/lldb/tools/lldb-dap/SourceBreakpoint.cpp
+++ b/lldb/tools/lldb-dap/SourceBreakpoint.cpp
@@ -397,8 +397,8 @@ bool SourceBreakpoint::BreakpointHitCallback(
// evaluation
const std::string &expr_str = messagePart.text;
const char *expr = expr_str.c_str();
- lldb::SBValue value = frame.GetValueForVariablePath(
- expr, lldb::eDynamicDontRunTarget, lldb::eDILModeLegacy);
+ lldb::SBValue value = frame.GetValueForVariablePathWithMode(
+ expr, lldb::eDILModeLegacy, lldb::eDynamicDontRunTarget);
if (value.GetError().Fail())
value = frame.EvaluateExpression(expr);
output += VariableDescription(
More information about the llvm-branch-commits
mailing list