llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-lldb
Author: Felipe de Azevedo Piovezan (felipepiovezan)
<details>
<summary>Changes</summary>
Prior to this patch, SBFrame/SBThread methods exhibit racy behavior if called
while the process is running, because they do not lock the
`Process::RetRunLock` mutex. If they did, they would fail, correctly
identifying that the process is not running.
Some methods _attempt_ to protect against this with the pattern:
```
ExecutionContext exe_ctx(m_opaque_sp.get(), lock); // this is a different lock
Process *process = exe_ctx.GetProcessPtr();
if (process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock()))
.... do work ...
```
However, this is also racy: the constructor of `ExecutionContext` will access
the frame list, which is something that can only be done once the process is
stopped.
With this patch:
1. The constructor of `ExecutionContext` now expects a `ProcessRunLock` as an
argument. It attempts to lock the run lock, and only fills in information about
frames and threads if the lock can be acquired. Callers of the constructor are
expected to check the lock.
2. All uses of ExecutionContext are adjusted to conform to the above.
3. The SBThread.cpp-defined helper function ResumeNewPlan now expects a locked
ProcessRunLock as _proof_ that the execution is stopped. It will unlock the
mutex prior to resuming the process.
This commit exposes many opportunities for early-returns, but these would
increase the diff of this patch and distract from the important changes, so we
opt not to do it here.
---
Patch is 65.73 KiB, truncated to 20.00 KiB below, full version:
https://github.com/llvm/llvm-project/pull/152020.diff
7 Files Affected:
- (modified) lldb/include/lldb/API/SBFrame.h (+4)
- (modified) lldb/include/lldb/Host/ProcessRunLock.h (+5)
- (modified) lldb/include/lldb/Target/ExecutionContext.h (+6-3)
- (modified) lldb/source/API/SBFrame.cpp (+291-242)
- (modified) lldb/source/API/SBThread.cpp (+193-136)
- (modified) lldb/source/Target/ExecutionContext.cpp (+8-4)
- (modified) lldb/test/API/python_api/run_locker/TestRunLocker.py (+1-1)
``````````diff
diff --git a/lldb/include/lldb/API/SBFrame.h b/lldb/include/lldb/API/SBFrame.h
index 3635ee5a537ad..35198068814d0 100644
--- a/lldb/include/lldb/API/SBFrame.h
+++ b/lldb/include/lldb/API/SBFrame.h
@@ -233,6 +233,10 @@ class LLDB_API SBFrame {
void SetFrameSP(const lldb::StackFrameSP &lldb_object_sp);
+ /// Return an SBValue with an error message warning that the process is not
+ /// currently stopped.
+ static SBValue CreateProcessIsRunningExprEvalError();
+
lldb::ExecutionContextRefSP m_opaque_sp;
};
diff --git a/lldb/include/lldb/Host/ProcessRunLock.h
b/lldb/include/lldb/Host/ProcessRunLock.h
index 94683673024d5..5efa46154a61e 100644
--- a/lldb/include/lldb/Host/ProcessRunLock.h
+++ b/lldb/include/lldb/Host/ProcessRunLock.h
@@ -41,9 +41,14 @@ class ProcessRunLock {
class ProcessRunLocker {
public:
ProcessRunLocker() = default;
+ ProcessRunLocker(ProcessRunLocker &&other) : m_lock(other.m_lock) {
+ other.m_lock = nullptr;
+ }
~ProcessRunLocker() { Unlock(); }
+ bool IsLocked() const { return m_lock; }
+
// Try to lock the read lock, but only do so if there are no writers.
bool TryLock(ProcessRunLock *lock) {
if (m_lock) {
diff --git a/lldb/include/lldb/Target/ExecutionContext.h
b/lldb/include/lldb/Target/ExecutionContext.h
index aebd0d5308e72..ae6051f576fac 100644
--- a/lldb/include/lldb/Target/ExecutionContext.h
+++ b/lldb/include/lldb/Target/ExecutionContext.h
@@ -11,6 +11,7 @@
#include <mutex>
+#include "lldb/Host/ProcessRunLock.h"
#include "lldb/Target/StackID.h"
#include "lldb/lldb-private.h"
@@ -318,11 +319,13 @@ class ExecutionContext {
// These two variants take in a locker, and grab the target, lock the API
// mutex into locker, then fill in the rest of the shared pointers.
ExecutionContext(const ExecutionContextRef &exe_ctx_ref,
- std::unique_lock<std::recursive_mutex> &locker)
- : ExecutionContext(&exe_ctx_ref, locker) {}
+ std::unique_lock<std::recursive_mutex> &locker,
+ ProcessRunLock::ProcessRunLocker &stop_locker)
+ : ExecutionContext(&exe_ctx_ref, locker, stop_locker) {}
ExecutionContext(const ExecutionContextRef *exe_ctx_ref,
- std::unique_lock<std::recursive_mutex> &locker);
+ std::unique_lock<std::recursive_mutex> &locker,
+ ProcessRunLock::ProcessRunLocker &stop_locker);
// Create execution contexts from execution context scopes
ExecutionContext(ExecutionContextScope *exe_scope);
ExecutionContext(ExecutionContextScope &exe_scope);
diff --git a/lldb/source/API/SBFrame.cpp b/lldb/source/API/SBFrame.cpp
index 5b69cf1ee2641..b6fd5e7d3524b 100644
--- a/lldb/source/API/SBFrame.cpp
+++ b/lldb/source/API/SBFrame.cpp
@@ -99,14 +99,15 @@ SBFrame::operator bool() const {
LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return false;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
- Process::StopLocker stop_locker;
- if (stop_locker.TryLock(&process->GetRunLock()))
- return GetFrameSP().get() != nullptr;
+ return GetFrameSP().get() != nullptr;
}
// Without a target & process we can't have a valid stack frame.
@@ -118,16 +119,16 @@ SBSymbolContext SBFrame::GetSymbolContext(uint32_t
resolve_scope) const {
SBSymbolContext sb_sym_ctx;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return sb_sym_ctx;
SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
- Process::StopLocker stop_locker;
- if (stop_locker.TryLock(&process->GetRunLock())) {
- if (StackFrame *frame = exe_ctx.GetFramePtr())
- sb_sym_ctx = frame->GetSymbolContext(scope);
- }
+ if (StackFrame *frame = exe_ctx.GetFramePtr())
+ sb_sym_ctx = frame->GetSymbolContext(scope);
}
return sb_sym_ctx;
@@ -139,19 +140,19 @@ SBModule SBFrame::GetModule() const {
SBModule sb_module;
ModuleSP module_sp;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return sb_module;
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
- Process::StopLocker stop_locker;
- if (stop_locker.TryLock(&process->GetRunLock())) {
- frame = exe_ctx.GetFramePtr();
- if (frame) {
- module_sp = frame->GetSymbolContext(eSymbolContextModule).module_sp;
- sb_module.SetSP(module_sp);
- }
+ frame = exe_ctx.GetFramePtr();
+ if (frame) {
+ module_sp = frame->GetSymbolContext(eSymbolContextModule).module_sp;
+ sb_module.SetSP(module_sp);
}
}
@@ -163,19 +164,19 @@ SBCompileUnit SBFrame::GetCompileUnit() const {
SBCompileUnit sb_comp_unit;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return sb_comp_unit;
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
- Process::StopLocker stop_locker;
- if (stop_locker.TryLock(&process->GetRunLock())) {
- frame = exe_ctx.GetFramePtr();
- if (frame) {
- sb_comp_unit.reset(
- frame->GetSymbolContext(eSymbolContextCompUnit).comp_unit);
- }
+ frame = exe_ctx.GetFramePtr();
+ if (frame) {
+ sb_comp_unit.reset(
+ frame->GetSymbolContext(eSymbolContextCompUnit).comp_unit);
}
}
@@ -187,19 +188,19 @@ SBFunction SBFrame::GetFunction() const {
SBFunction sb_function;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return sb_function;
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
- Process::StopLocker stop_locker;
- if (stop_locker.TryLock(&process->GetRunLock())) {
- frame = exe_ctx.GetFramePtr();
- if (frame) {
- sb_function.reset(
- frame->GetSymbolContext(eSymbolContextFunction).function);
- }
+ frame = exe_ctx.GetFramePtr();
+ if (frame) {
+ sb_function.reset(
+ frame->GetSymbolContext(eSymbolContextFunction).function);
}
}
@@ -211,18 +212,18 @@ SBSymbol SBFrame::GetSymbol() const {
SBSymbol sb_symbol;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return sb_symbol;
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
- Process::StopLocker stop_locker;
- if (stop_locker.TryLock(&process->GetRunLock())) {
- frame = exe_ctx.GetFramePtr();
- if (frame) {
- sb_symbol.reset(frame->GetSymbolContext(eSymbolContextSymbol).symbol);
- }
+ frame = exe_ctx.GetFramePtr();
+ if (frame) {
+ sb_symbol.reset(frame->GetSymbolContext(eSymbolContextSymbol).symbol);
}
}
@@ -234,18 +235,18 @@ SBBlock SBFrame::GetBlock() const {
SBBlock sb_block;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return sb_block;
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
- Process::StopLocker stop_locker;
- if (stop_locker.TryLock(&process->GetRunLock())) {
- frame = exe_ctx.GetFramePtr();
- if (frame)
- sb_block.SetPtr(frame->GetSymbolContext(eSymbolContextBlock).block);
- }
+ frame = exe_ctx.GetFramePtr();
+ if (frame)
+ sb_block.SetPtr(frame->GetSymbolContext(eSymbolContextBlock).block);
}
return sb_block;
}
@@ -255,18 +256,18 @@ SBBlock SBFrame::GetFrameBlock() const {
SBBlock sb_block;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return sb_block;
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
- Process::StopLocker stop_locker;
- if (stop_locker.TryLock(&process->GetRunLock())) {
- frame = exe_ctx.GetFramePtr();
- if (frame)
- sb_block.SetPtr(frame->GetFrameBlock());
- }
+ frame = exe_ctx.GetFramePtr();
+ if (frame)
+ sb_block.SetPtr(frame->GetFrameBlock());
}
return sb_block;
}
@@ -276,19 +277,19 @@ SBLineEntry SBFrame::GetLineEntry() const {
SBLineEntry sb_line_entry;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return sb_line_entry;
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
- Process::StopLocker stop_locker;
- if (stop_locker.TryLock(&process->GetRunLock())) {
- frame = exe_ctx.GetFramePtr();
- if (frame) {
- sb_line_entry.SetLineEntry(
- frame->GetSymbolContext(eSymbolContextLineEntry).line_entry);
- }
+ frame = exe_ctx.GetFramePtr();
+ if (frame) {
+ sb_line_entry.SetLineEntry(
+ frame->GetSymbolContext(eSymbolContextLineEntry).line_entry);
}
}
return sb_line_entry;
@@ -300,7 +301,10 @@ uint32_t SBFrame::GetFrameID() const {
uint32_t frame_idx = UINT32_MAX;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return frame_idx;
StackFrame *frame = exe_ctx.GetFramePtr();
if (frame)
@@ -313,7 +317,10 @@ lldb::addr_t SBFrame::GetCFA() const {
LLDB_INSTRUMENT_VA(this);
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return LLDB_INVALID_ADDRESS;
StackFrame *frame = exe_ctx.GetFramePtr();
if (frame)
@@ -326,19 +333,19 @@ addr_t SBFrame::GetPC() const {
addr_t addr = LLDB_INVALID_ADDRESS;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return addr;
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
- Process::StopLocker stop_locker;
- if (stop_locker.TryLock(&process->GetRunLock())) {
- frame = exe_ctx.GetFramePtr();
- if (frame) {
- addr = frame->GetFrameCodeAddress().GetOpcodeLoadAddress(
- target, AddressClass::eCode);
- }
+ frame = exe_ctx.GetFramePtr();
+ if (frame) {
+ addr = frame->GetFrameCodeAddress().GetOpcodeLoadAddress(
+ target, AddressClass::eCode);
}
}
@@ -350,17 +357,17 @@ bool SBFrame::SetPC(addr_t new_pc) {
bool ret_val = false;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return ret_val;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
- Process::StopLocker stop_locker;
- if (stop_locker.TryLock(&process->GetRunLock())) {
- if (StackFrame *frame = exe_ctx.GetFramePtr()) {
- if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) {
- ret_val = reg_ctx_sp->SetPC(new_pc);
- }
+ if (StackFrame *frame = exe_ctx.GetFramePtr()) {
+ if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) {
+ ret_val = reg_ctx_sp->SetPC(new_pc);
}
}
}
@@ -373,17 +380,17 @@ addr_t SBFrame::GetSP() const {
addr_t addr = LLDB_INVALID_ADDRESS;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return addr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
- Process::StopLocker stop_locker;
- if (stop_locker.TryLock(&process->GetRunLock())) {
- if (StackFrame *frame = exe_ctx.GetFramePtr()) {
- if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) {
- addr = reg_ctx_sp->GetSP();
- }
+ if (StackFrame *frame = exe_ctx.GetFramePtr()) {
+ if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) {
+ addr = reg_ctx_sp->GetSP();
}
}
}
@@ -396,17 +403,17 @@ addr_t SBFrame::GetFP() const {
addr_t addr = LLDB_INVALID_ADDRESS;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return addr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
- Process::StopLocker stop_locker;
- if (stop_locker.TryLock(&process->GetRunLock())) {
- if (StackFrame *frame = exe_ctx.GetFramePtr()) {
- if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) {
- addr = reg_ctx_sp->GetFP();
- }
+ if (StackFrame *frame = exe_ctx.GetFramePtr()) {
+ if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) {
+ addr = reg_ctx_sp->GetFP();
}
}
}
@@ -419,18 +426,18 @@ SBAddress SBFrame::GetPCAddress() const {
SBAddress sb_addr;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return sb_addr;
StackFrame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
- Process::StopLocker stop_locker;
- if (stop_locker.TryLock(&process->GetRunLock())) {
- frame = exe_ctx.GetFramePtr();
- if (frame)
- sb_addr.SetAddress(frame->GetFrameCodeAddress());
- }
+ frame = exe_ctx.GetFramePtr();
+ if (frame)
+ sb_addr.SetAddress(frame->GetFrameCodeAddress());
}
return sb_addr;
}
@@ -446,7 +453,10 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char
*var_path) {
SBValue sb_value;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return sb_value;
StackFrame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
@@ -468,25 +478,25 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char
*var_path,
}
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return sb_value;
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
- Process::StopLocker stop_locker;
- if (stop_locker.TryLock(&process->GetRunLock())) {
- frame = exe_ctx.GetFramePtr();
- if (frame) {
- VariableSP var_sp;
- Status error;
- ValueObjectSP value_sp(frame->GetValueForVariableExpressionPath(
- var_path, eNoDynamicValues,
- StackFrame::eExpressionPathOptionCheckPtrVsMember |
- StackFrame::eExpressionPathOptionsAllowDirectIVarAccess,
- var_sp, error));
- sb_value.SetSP(value_sp, use_dynamic);
- }
+ frame = exe_ctx.GetFramePtr();
+ if (frame) {
+ VariableSP var_sp;
+ Status error;
+ ValueObjectSP value_sp(frame->GetValueForVariableExpressionPath(
+ var_path, eNoDynamicValues,
+ StackFrame::eExpressionPathOptionCheckPtrVsMember |
+ StackFrame::eExpressionPathOptionsAllowDirectIVarAccess,
+ var_sp, error));
+ sb_value.SetSP(value_sp, use_dynamic);
}
}
return sb_value;
@@ -497,7 +507,10 @@ SBValue SBFrame::FindVariable(const char *name) {
SBValue value;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return value;
StackFrame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
@@ -522,21 +535,21 @@ SBValue SBFrame::FindVariable(const char *name,
ValueObjectSP value_sp;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return sb_value;
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
- Process::StopLocker stop_locker;
- if (stop_locker.TryLock(&process->GetRunLock())) {
- frame = exe_ctx.GetFramePtr();
- if (frame) {
- value_sp = frame->FindVariable(ConstString(name));
+ frame = exe_ctx.GetFramePtr();
+ if (frame) {
+ value_sp = frame->FindVariable(ConstString(name));
- if (value_sp)
- sb_value.SetSP(value_sp, use_dynamic);
- }
+ if (value_sp)
+ sb_value.SetSP(value_sp, use_dynamic);
}
}
@@ -548,7 +561,10 @@ SBValue SBFrame::FindValue(const char *name, ValueType
value_type) {
SBValue value;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker);
+ if (!stop_locker.IsLocked())
+ return value;
StackFrame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
@@ -572,14 +588,14 @@ SBValue SBFrame::FindValue(const char *name, ValueType
value_type,
ValueObjectSP value_sp;
std::unique_lock<std::recursive_mutex> lock;
- ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
+ Process::StopLocker stop_locker;
+ Executi...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/152020
_______________________________________________
lldb-commits mailing list
lldb-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
