From 9be92f8ead1294cc1931fe68c13dbaa8c5945423 Mon Sep 17 00:00:00 2001 From: Felipe de Azevedo Piovezan Date: Mon, 4 Aug 2025 08:32:20 -0700 Subject: [PATCH 1/9] [lldb] Guard SBFrame/SBThread methods against running processes 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. --- lldb/include/lldb/API/SBFrame.h | 4 + lldb/include/lldb/Host/ProcessRunLock.h | 5 + lldb/include/lldb/Target/ExecutionContext.h | 9 +- lldb/source/API/SBFrame.cpp | 529 ++++++++++-------- lldb/source/API/SBThread.cpp | 329 ++++++----- lldb/source/Target/ExecutionContext.cpp | 12 +- .../python_api/run_locker/TestRunLocker.py | 4 +- 7 files changed, 508 insertions(+), 384 deletions(-) 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 +#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 &locker) - : ExecutionContext(&exe_ctx_ref, locker) {} + std::unique_lock &locker, + ProcessRunLock::ProcessRunLocker &stop_locker) + : ExecutionContext(&exe_ctx_ref, locker, stop_locker) {} ExecutionContext(const ExecutionContextRef *exe_ctx_ref, - std::unique_lock &locker); + std::unique_lock &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..96891fee61e73 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 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 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(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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 lock; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock); + Process::StopLocker stop_locker; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - 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())) { + if (stop_locker.IsLocked()) { + StackFrame *frame = nullptr; + Target *target = exe_ctx.GetTargetPtr(); + Process *process = exe_ctx.GetProcessPtr(); + if (target && process) { frame = exe_ctx.GetFramePtr(); if (frame) { VariableList variable_list; @@ -699,7 +715,10 @@ SBThread SBFrame::GetThread() const { LLDB_INSTRUMENT_VA(this); std::unique_lock 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 SBThread(); ThreadSP thread_sp(exe_ctx.GetThreadSP()); SBThread sb_thread(thread_sp); @@ -711,17 +730,17 @@ const char *SBFrame::Disassemble() const { LLDB_INSTRUMENT_VA(this); std::unique_lock 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 nullptr; Target *target = exe_ctx.GetTargetPtr(); Process *process = exe_ctx.GetProcessPtr(); if (!target || !process) return nullptr; - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&process->GetRunLock())) { - if (auto *frame = exe_ctx.GetFramePtr()) - return ConstString(frame->Disassemble()).GetCString(); - } + if (auto *frame = exe_ctx.GetFramePtr()) + return ConstString(frame->Disassemble()).GetCString(); return nullptr; } @@ -732,7 +751,10 @@ SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics, SBValueList value_list; std::unique_lock 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_list; StackFrame *frame = exe_ctx.GetFramePtr(); Target *target = exe_ctx.GetTargetPtr(); @@ -762,7 +784,12 @@ lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals, use_dynamic); std::unique_lock 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()) { + SBValueList empty_list; + return empty_list; + } Target *target = exe_ctx.GetTargetPtr(); const bool include_runtime_support_values = @@ -782,27 +809,26 @@ SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) { SBValueList value_list; std::unique_lock 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()) { - StackFrame *frame = nullptr; - Target *target = exe_ctx.GetTargetPtr(); + StackFrame *frame = nullptr; + Target *target = exe_ctx.GetTargetPtr(); - const bool statics = options.GetIncludeStatics(); - const bool arguments = options.GetIncludeArguments(); - const bool recognized_arguments = + const bool statics = options.GetIncludeStatics(); + const bool arguments = options.GetIncludeArguments(); + const bool recognized_arguments = options.GetIncludeRecognizedArguments(SBTarget(exe_ctx.GetTargetSP())); - const bool locals = options.GetIncludeLocals(); - const bool in_scope_only = options.GetInScopeOnly(); - const bool include_runtime_support_values = - options.GetIncludeRuntimeSupportValues(); - const lldb::DynamicValueType use_dynamic = options.GetUseDynamic(); - + const bool locals = options.GetIncludeLocals(); + const bool in_scope_only = options.GetInScopeOnly(); + const bool include_runtime_support_values = + options.GetIncludeRuntimeSupportValues(); + const lldb::DynamicValueType use_dynamic = options.GetUseDynamic(); - std::set variable_set; - Process *process = exe_ctx.GetProcessPtr(); - if (target && process) { - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&process->GetRunLock())) { + std::set variable_set; + Process *process = exe_ctx.GetProcessPtr(); + if (target && process) { frame = exe_ctx.GetFramePtr(); if (frame) { Debugger &dbg = process->GetTarget().GetDebugger(); @@ -893,14 +919,14 @@ SBValueList SBFrame::GetRegisters() { SBValueList value_list; std::unique_lock 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()) { - 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())) { + StackFrame *frame = nullptr; + Target *target = exe_ctx.GetTargetPtr(); + Process *process = exe_ctx.GetProcessPtr(); + if (target && process) { frame = exe_ctx.GetFramePtr(); if (frame) { RegisterContextSP reg_ctx(frame->GetRegisterContext()); @@ -924,14 +950,13 @@ SBValue SBFrame::FindRegister(const char *name) { SBValue result; ValueObjectSP value_sp; std::unique_lock lock; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock); - - 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())) { + Process::StopLocker stop_locker; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + if (stop_locker.IsLocked()) { + StackFrame *frame = nullptr; + Target *target = exe_ctx.GetTargetPtr(); + Process *process = exe_ctx.GetProcessPtr(); + if (target && process) { frame = exe_ctx.GetFramePtr(); if (frame) { RegisterContextSP reg_ctx(frame->GetRegisterContext()); @@ -954,7 +979,10 @@ SBError SBFrame::GetDescriptionWithFormat(const SBFormat &format, Stream &strm = output.ref(); std::unique_lock 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 "Process is not stopped"; StackFrame *frame = nullptr; Target *target = exe_ctx.GetTargetPtr(); @@ -967,13 +995,10 @@ SBError SBFrame::GetDescriptionWithFormat(const SBFormat &format, } if (target && process) { - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&process->GetRunLock())) { - frame = exe_ctx.GetFramePtr(); - if (frame && - frame->DumpUsingFormat(strm, format.GetFormatEntrySP().get())) { - return error; - } + frame = exe_ctx.GetFramePtr(); + if (frame && + frame->DumpUsingFormat(strm, format.GetFormatEntrySP().get())) { + return error; } } error.SetErrorStringWithFormat( @@ -989,20 +1014,21 @@ bool SBFrame::GetDescription(SBStream &description) { Stream &strm = description.ref(); std::unique_lock 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()) { + strm.PutCString("Error: process is not stopped."); + return true; + } StackFrame *frame; 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) { - frame->DumpUsingSettingsFormat(&strm); - } + frame = exe_ctx.GetFramePtr(); + if (frame) { + frame->DumpUsingSettingsFormat(&strm); } - } else strm.PutCString("No value"); @@ -1013,7 +1039,10 @@ SBValue SBFrame::EvaluateExpression(const char *expr) { LLDB_INSTRUMENT_VA(this, expr); std::unique_lock 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 CreateProcessIsRunningExprEvalError(); StackFrame *frame = exe_ctx.GetFramePtr(); Target *target = exe_ctx.GetTargetPtr(); @@ -1044,7 +1073,10 @@ SBFrame::EvaluateExpression(const char *expr, options.SetUnwindOnError(true); options.SetIgnoreBreakpoints(true); std::unique_lock 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 CreateProcessIsRunningExprEvalError(); StackFrame *frame = exe_ctx.GetFramePtr(); Target *target = exe_ctx.GetTargetPtr(); @@ -1064,7 +1096,10 @@ SBValue SBFrame::EvaluateExpression(const char *expr, SBExpressionOptions options; std::unique_lock 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 CreateProcessIsRunningExprEvalError(); options.SetFetchDynamicValue(fetch_dynamic_value); options.SetUnwindOnError(unwind_on_error); @@ -1080,6 +1115,16 @@ SBValue SBFrame::EvaluateExpression(const char *expr, return EvaluateExpression(expr, options); } +lldb::SBValue SBFrame::CreateProcessIsRunningExprEvalError() { + auto error = Status::FromErrorString("can't evaluate expressions when the " + "process is running."); + ValueObjectSP expr_value_sp = + ValueObjectConstResult::Create(nullptr, std::move(error)); + SBValue expr_result; + expr_result.SetSP(expr_value_sp, false); + return expr_result; +} + lldb::SBValue SBFrame::EvaluateExpression(const char *expr, const SBExpressionOptions &options) { LLDB_INSTRUMENT_VA(this, expr, options); @@ -1095,15 +1140,15 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr, ValueObjectSP expr_value_sp; std::unique_lock 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()) { - StackFrame *frame = nullptr; - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); + 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())) { + if (target && process) { frame = exe_ctx.GetFramePtr(); if (frame) { std::unique_ptr stack_trace; @@ -1121,18 +1166,13 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr, expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue()); } } else { - Status error; - error = Status::FromErrorString("can't evaluate expressions when the " - "process is running."); - expr_value_sp = ValueObjectConstResult::Create(nullptr, std::move(error)); - expr_result.SetSP(expr_value_sp, false); - } - } else { Status error; error = Status::FromErrorString("sbframe object is not valid."); expr_value_sp = ValueObjectConstResult::Create(nullptr, std::move(error)); expr_result.SetSP(expr_value_sp, false); - } + } + } else + expr_result = CreateProcessIsRunningExprEvalError(); if (expr_result.GetError().Success()) LLDB_LOGF(expr_log, @@ -1153,7 +1193,10 @@ SBStructuredData SBFrame::GetLanguageSpecificData() const { SBStructuredData sb_data; std::unique_lock 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_data; StackFrame *frame = exe_ctx.GetFramePtr(); if (!frame) return sb_data; @@ -1173,18 +1216,18 @@ bool SBFrame::IsInlined() const { LLDB_INSTRUMENT_VA(this); std::unique_lock 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; 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) - return frame->IsInlined(); - } + frame = exe_ctx.GetFramePtr(); + if (frame) + return frame->IsInlined(); } return false; } @@ -1199,7 +1242,10 @@ bool SBFrame::IsArtificial() const { LLDB_INSTRUMENT_VA(this); std::unique_lock 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; if (StackFrame *frame = exe_ctx.GetFramePtr()) return frame->IsArtificial(); @@ -1211,7 +1257,10 @@ bool SBFrame::IsHidden() const { LLDB_INSTRUMENT_VA(this); std::unique_lock 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; if (StackFrame *frame = exe_ctx.GetFramePtr()) return frame->IsHidden(); @@ -1229,18 +1278,18 @@ lldb::LanguageType SBFrame::GuessLanguage() const { LLDB_INSTRUMENT_VA(this); std::unique_lock 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 eLanguageTypeUnknown; 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) { - return frame->GuessLanguage().AsLanguageType(); - } + frame = exe_ctx.GetFramePtr(); + if (frame) { + return frame->GuessLanguage().AsLanguageType(); } } return eLanguageTypeUnknown; @@ -1251,18 +1300,18 @@ const char *SBFrame::GetFunctionName() const { const char *name = nullptr; std::unique_lock 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 name; 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) - return frame->GetFunctionName(); - } + frame = exe_ctx.GetFramePtr(); + if (frame) + return frame->GetFunctionName(); } return name; } @@ -1273,18 +1322,18 @@ const char *SBFrame::GetDisplayFunctionName() { const char *name = nullptr; std::unique_lock 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 name; 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) - return frame->GetDisplayFunctionName(); - } + frame = exe_ctx.GetFramePtr(); + if (frame) + return frame->GetDisplayFunctionName(); } return name; } diff --git a/lldb/source/API/SBThread.cpp b/lldb/source/API/SBThread.cpp index 74bc66c4f16f1..17d10e4dc2c2b 100644 --- a/lldb/source/API/SBThread.cpp +++ b/lldb/source/API/SBThread.cpp @@ -91,15 +91,15 @@ lldb::SBQueue SBThread::GetQueue() const { SBQueue sb_queue; QueueSP queue_sp; std::unique_lock 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 SBQueue(); if (exe_ctx.HasThreadScope()) { - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { - queue_sp = exe_ctx.GetThreadPtr()->GetQueue(); - if (queue_sp) { - sb_queue.SetQueue(queue_sp); - } + queue_sp = exe_ctx.GetThreadPtr()->GetQueue(); + if (queue_sp) { + sb_queue.SetQueue(queue_sp); } } @@ -114,14 +114,15 @@ SBThread::operator bool() const { LLDB_INSTRUMENT_VA(this); std::unique_lock 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 m_opaque_sp->GetThreadSP().get() != nullptr; + return m_opaque_sp->GetThreadSP().get() != nullptr; } // Without a valid target & process, this thread can't be valid. return false; @@ -138,13 +139,13 @@ StopReason SBThread::GetStopReason() { StopReason reason = eStopReasonInvalid; std::unique_lock 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 reason; if (exe_ctx.HasThreadScope()) { - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { - return exe_ctx.GetThreadPtr()->GetStopReason(); - } + return exe_ctx.GetThreadPtr()->GetStopReason(); } return reason; @@ -154,11 +155,10 @@ size_t SBThread::GetStopReasonDataCount() { LLDB_INSTRUMENT_VA(this); std::unique_lock lock; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock); - - if (exe_ctx.HasThreadScope()) { - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + Process::StopLocker stop_locker; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + if (stop_locker.IsLocked()) { + if (exe_ctx.HasThreadScope()) { StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo(); if (stop_info_sp) { StopReason reason = stop_info_sp->GetStopReason(); @@ -215,11 +215,10 @@ uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) { LLDB_INSTRUMENT_VA(this, idx); std::unique_lock lock; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock); - - if (exe_ctx.HasThreadScope()) { - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + Process::StopLocker stop_locker; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + if (stop_locker.IsLocked()) { + if (exe_ctx.HasThreadScope()) { Thread *thread = exe_ctx.GetThreadPtr(); StopInfoSP stop_info_sp = thread->GetStopInfo(); if (stop_info_sp) { @@ -290,7 +289,10 @@ bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) { Stream &strm = stream.ref(); std::unique_lock 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; if (!exe_ctx.HasThreadScope()) return false; @@ -312,7 +314,10 @@ SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) { SBThreadCollection threads; std::unique_lock 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 SBThreadCollection(); if (!exe_ctx.HasThreadScope()) return SBThreadCollection(); @@ -333,7 +338,10 @@ size_t SBThread::GetStopDescription(char *dst, size_t dst_len) { LLDB_INSTRUMENT_VA(this, dst, dst_len); std::unique_lock 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 0; if (dst) *dst = 0; @@ -341,10 +349,6 @@ size_t SBThread::GetStopDescription(char *dst, size_t dst_len) { if (!exe_ctx.HasThreadScope()) return 0; - Process::StopLocker stop_locker; - if (!stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) - return 0; - std::string thread_stop_desc = exe_ctx.GetThreadPtr()->GetStopDescription(); if (thread_stop_desc.empty()) return 0; @@ -362,15 +366,15 @@ SBValue SBThread::GetStopReturnValue() { ValueObjectSP return_valobj_sp; std::unique_lock 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 SBValue(); if (exe_ctx.HasThreadScope()) { - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { - StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo(); - if (stop_info_sp) { - return_valobj_sp = StopInfo::GetReturnValueObject(stop_info_sp); - } + StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo(); + if (stop_info_sp) { + return_valobj_sp = StopInfo::GetReturnValueObject(stop_info_sp); } } @@ -403,32 +407,30 @@ const char *SBThread::GetName() const { LLDB_INSTRUMENT_VA(this); std::unique_lock 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 nullptr; if (!exe_ctx.HasThreadScope()) return nullptr; - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) - return ConstString(exe_ctx.GetThreadPtr()->GetName()).GetCString(); - - return nullptr; + return ConstString(exe_ctx.GetThreadPtr()->GetName()).GetCString(); } const char *SBThread::GetQueueName() const { LLDB_INSTRUMENT_VA(this); std::unique_lock 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 nullptr; if (!exe_ctx.HasThreadScope()) return nullptr; - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) - return ConstString(exe_ctx.GetThreadPtr()->GetQueueName()).GetCString(); - - return nullptr; + return ConstString(exe_ctx.GetThreadPtr()->GetQueueName()).GetCString(); } lldb::queue_id_t SBThread::GetQueueID() const { @@ -436,13 +438,13 @@ lldb::queue_id_t SBThread::GetQueueID() const { queue_id_t id = LLDB_INVALID_QUEUE_ID; std::unique_lock 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 id; if (exe_ctx.HasThreadScope()) { - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { - id = exe_ctx.GetThreadPtr()->GetQueueID(); - } + id = exe_ctx.GetThreadPtr()->GetQueueID(); } return id; @@ -453,11 +455,10 @@ bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) { bool success = false; std::unique_lock lock; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock); - - if (exe_ctx.HasThreadScope()) { - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + Process::StopLocker stop_locker; + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + if (stop_locker.IsLocked()) { + if (exe_ctx.HasThreadScope()) { Thread *thread = exe_ctx.GetThreadPtr(); StructuredData::ObjectSP info_root_sp = thread->GetExtendedInfo(); if (info_root_sp) { @@ -495,7 +496,12 @@ bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) { return success; } -static Status ResumeNewPlan(ExecutionContext &exe_ctx, ThreadPlan *new_plan) { +static Status ResumeNewPlan(ExecutionContext &exe_ctx, ThreadPlan *new_plan, + Process::StopLocker stop_lock) { + { + assert(stop_lock.IsLocked()); + auto to_unlock = std::move(stop_lock); + } Process *process = exe_ctx.GetProcessPtr(); if (!process) return Status::FromErrorString("No process in SBThread::ResumeNewPlan"); @@ -530,7 +536,10 @@ void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) { LLDB_INSTRUMENT_VA(this, stop_other_threads, error); std::unique_lock 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; if (!exe_ctx.HasThreadScope()) { error = Status::FromErrorString("this SBThread object is invalid"); @@ -555,7 +564,7 @@ void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) { true, abort_other_plans, stop_other_threads, new_plan_status); } } - error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); + error = ResumeNewPlan(exe_ctx, new_plan_sp.get(), std::move(stop_locker)); } void SBThread::StepInto(lldb::RunMode stop_other_threads) { @@ -577,7 +586,10 @@ void SBThread::StepInto(const char *target_name, uint32_t end_line, LLDB_INSTRUMENT_VA(this, target_name, end_line, error, stop_other_threads); std::unique_lock 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; if (!exe_ctx.HasThreadScope()) { error = Status::FromErrorString("this SBThread object is invalid"); @@ -618,7 +630,7 @@ void SBThread::StepInto(const char *target_name, uint32_t end_line, } if (new_plan_status.Success()) - error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); + error = ResumeNewPlan(exe_ctx, new_plan_sp.get(), std::move(stop_locker)); else error = Status::FromErrorString(new_plan_status.AsCString()); } @@ -634,7 +646,10 @@ void SBThread::StepOut(SBError &error) { LLDB_INSTRUMENT_VA(this, error); std::unique_lock 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; if (!exe_ctx.HasThreadScope()) { error = Status::FromErrorString("this SBThread object is invalid"); @@ -653,7 +668,7 @@ void SBThread::StepOut(SBError &error) { eVoteNoOpinion, 0, new_plan_status, avoid_no_debug)); if (new_plan_status.Success()) - error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); + error = ResumeNewPlan(exe_ctx, new_plan_sp.get(), std::move(stop_locker)); else error = Status::FromErrorString(new_plan_status.AsCString()); } @@ -669,7 +684,10 @@ void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) { LLDB_INSTRUMENT_VA(this, sb_frame, error); std::unique_lock 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; if (!sb_frame.IsValid()) { error = Status::FromErrorString("passed invalid SBFrame object"); @@ -697,7 +715,7 @@ void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) { eVoteNoOpinion, frame_sp->GetFrameIndex(), new_plan_status)); if (new_plan_status.Success()) - error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); + error = ResumeNewPlan(exe_ctx, new_plan_sp.get(), std::move(stop_locker)); else error = Status::FromErrorString(new_plan_status.AsCString()); } @@ -713,7 +731,10 @@ void SBThread::StepInstruction(bool step_over, SBError &error) { LLDB_INSTRUMENT_VA(this, step_over, error); std::unique_lock 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; if (!exe_ctx.HasThreadScope()) { error = Status::FromErrorString("this SBThread object is invalid"); @@ -726,7 +747,7 @@ void SBThread::StepInstruction(bool step_over, SBError &error) { step_over, false, true, new_plan_status)); if (new_plan_status.Success()) - error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); + error = ResumeNewPlan(exe_ctx, new_plan_sp.get(), std::move(stop_locker)); else error = Status::FromErrorString(new_plan_status.AsCString()); } @@ -742,7 +763,10 @@ void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) { LLDB_INSTRUMENT_VA(this, addr, error); std::unique_lock 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; if (!exe_ctx.HasThreadScope()) { error = Status::FromErrorString("this SBThread object is invalid"); @@ -761,7 +785,7 @@ void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) { abort_other_plans, target_addr, stop_other_threads, new_plan_status)); if (new_plan_status.Success()) - error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); + error = ResumeNewPlan(exe_ctx, new_plan_sp.get(), std::move(stop_locker)); else error = Status::FromErrorString(new_plan_status.AsCString()); } @@ -774,7 +798,10 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame, char path[PATH_MAX]; std::unique_lock 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_error; StackFrameSP frame_sp(sb_frame.GetFrameSP()); @@ -875,7 +902,8 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame, frame_sp->GetFrameIndex(), new_plan_status)); if (new_plan_status.Success()) - sb_error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); + sb_error = + ResumeNewPlan(exe_ctx, new_plan_sp.get(), std::move(stop_locker)); else sb_error = Status::FromErrorString(new_plan_status.AsCString()); } @@ -908,7 +936,10 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name, SBError error; std::unique_lock 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 error; if (!exe_ctx.HasThreadScope()) { error = Status::FromErrorString("this SBThread object is invalid"); @@ -931,7 +962,7 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name, return error; if (new_plan_status.Success()) - error = ResumeNewPlan(exe_ctx, new_plan_sp.get()); + error = ResumeNewPlan(exe_ctx, new_plan_sp.get(), std::move(stop_locker)); else error = Status::FromErrorString(new_plan_status.AsCString()); @@ -944,7 +975,10 @@ SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) { SBError sb_error; std::unique_lock 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_error; if (!exe_ctx.HasThreadScope()) { sb_error = Status::FromErrorString("this SBThread object is invalid"); @@ -964,7 +998,10 @@ SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) { SBError sb_error; std::unique_lock 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_error; if (exe_ctx.HasThreadScope()) { Thread *thread = exe_ctx.GetThreadPtr(); @@ -981,7 +1018,10 @@ SBError SBThread::UnwindInnermostExpression() { SBError sb_error; std::unique_lock 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_error; if (exe_ctx.HasThreadScope()) { Thread *thread = exe_ctx.GetThreadPtr(); @@ -1004,17 +1044,17 @@ bool SBThread::Suspend(SBError &error) { LLDB_INSTRUMENT_VA(this, error); std::unique_lock 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()) { + error = Status::FromErrorString("process is running"); + return false; + } bool result = false; if (exe_ctx.HasThreadScope()) { - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { - exe_ctx.GetThreadPtr()->SetResumeState(eStateSuspended); - result = true; - } else { - error = Status::FromErrorString("process is running"); - } + exe_ctx.GetThreadPtr()->SetResumeState(eStateSuspended); + result = true; } else error = Status::FromErrorString("this SBThread object is invalid"); return result; @@ -1031,18 +1071,18 @@ bool SBThread::Resume(SBError &error) { LLDB_INSTRUMENT_VA(this, error); std::unique_lock 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()) { + error = Status::FromErrorString("process is running"); + return false; + } bool result = false; if (exe_ctx.HasThreadScope()) { - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { - const bool override_suspend = true; - exe_ctx.GetThreadPtr()->SetResumeState(eStateRunning, override_suspend); - result = true; - } else { - error = Status::FromErrorString("process is running"); - } + const bool override_suspend = true; + exe_ctx.GetThreadPtr()->SetResumeState(eStateRunning, override_suspend); + result = true; } else error = Status::FromErrorString("this SBThread object is invalid"); return result; @@ -1052,7 +1092,10 @@ bool SBThread::IsSuspended() { LLDB_INSTRUMENT_VA(this); std::unique_lock 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; if (exe_ctx.HasThreadScope()) return exe_ctx.GetThreadPtr()->GetResumeState() == eStateSuspended; @@ -1063,7 +1106,10 @@ bool SBThread::IsStopped() { LLDB_INSTRUMENT_VA(this); std::unique_lock 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; if (exe_ctx.HasThreadScope()) return StateIsStoppedState(exe_ctx.GetThreadPtr()->GetState(), true); @@ -1075,7 +1121,10 @@ SBProcess SBThread::GetProcess() { SBProcess sb_process; std::unique_lock 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 SBProcess(); if (exe_ctx.HasThreadScope()) { // Have to go up to the target so we can get a shared pointer to our @@ -1091,13 +1140,13 @@ uint32_t SBThread::GetNumFrames() { uint32_t num_frames = 0; std::unique_lock 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 0; if (exe_ctx.HasThreadScope()) { - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { - num_frames = exe_ctx.GetThreadPtr()->GetStackFrameCount(); - } + num_frames = exe_ctx.GetThreadPtr()->GetStackFrameCount(); } return num_frames; @@ -1109,14 +1158,14 @@ SBFrame SBThread::GetFrameAtIndex(uint32_t idx) { SBFrame sb_frame; StackFrameSP frame_sp; std::unique_lock 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 SBFrame(); if (exe_ctx.HasThreadScope()) { - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { - frame_sp = exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(idx); - sb_frame.SetFrameSP(frame_sp); - } + frame_sp = exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(idx); + sb_frame.SetFrameSP(frame_sp); } return sb_frame; @@ -1128,15 +1177,15 @@ lldb::SBFrame SBThread::GetSelectedFrame() { SBFrame sb_frame; StackFrameSP frame_sp; std::unique_lock 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 SBFrame(); if (exe_ctx.HasThreadScope()) { - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { - frame_sp = - exe_ctx.GetThreadPtr()->GetSelectedFrame(SelectMostRelevantFrame); - sb_frame.SetFrameSP(frame_sp); - } + frame_sp = + exe_ctx.GetThreadPtr()->GetSelectedFrame(SelectMostRelevantFrame); + sb_frame.SetFrameSP(frame_sp); } return sb_frame; @@ -1148,17 +1197,17 @@ lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) { SBFrame sb_frame; StackFrameSP frame_sp; std::unique_lock 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 SBFrame(); if (exe_ctx.HasThreadScope()) { - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { - Thread *thread = exe_ctx.GetThreadPtr(); - frame_sp = thread->GetStackFrameAtIndex(idx); - if (frame_sp) { - thread->SetSelectedFrame(frame_sp.get()); - sb_frame.SetFrameSP(frame_sp); - } + Thread *thread = exe_ctx.GetThreadPtr(); + frame_sp = thread->GetStackFrameAtIndex(idx); + if (frame_sp) { + thread->SetSelectedFrame(frame_sp.get()); + sb_frame.SetFrameSP(frame_sp); } } @@ -1203,7 +1252,10 @@ bool SBThread::GetStatus(SBStream &status) const { Stream &strm = status.ref(); std::unique_lock 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; if (exe_ctx.HasThreadScope()) { exe_ctx.GetThreadPtr()->GetStatus(strm, 0, 1, 1, true, @@ -1226,7 +1278,10 @@ bool SBThread::GetDescription(SBStream &description, bool stop_format) const { Stream &strm = description.ref(); std::unique_lock 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; if (exe_ctx.HasThreadScope()) { exe_ctx.GetThreadPtr()->DumpUsingSettingsFormat( @@ -1248,7 +1303,10 @@ SBError SBThread::GetDescriptionWithFormat(const SBFormat &format, } std::unique_lock 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 error; if (exe_ctx.HasThreadScope()) { if (exe_ctx.GetThreadPtr()->DumpUsingFormat( @@ -1268,11 +1326,10 @@ SBThread SBThread::GetExtendedBacktraceThread(const char *type) { LLDB_INSTRUMENT_VA(this, type); std::unique_lock lock; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock); - SBThread sb_origin_thread; - Process::StopLocker stop_locker; - if (stop_locker.TryLock(&exe_ctx.GetProcessPtr()->GetRunLock())) { + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + SBThread sb_origin_thread; + if (stop_locker.IsLocked()) { if (exe_ctx.HasThreadScope()) { ThreadSP real_thread(exe_ctx.GetThreadSP()); if (real_thread) { diff --git a/lldb/source/Target/ExecutionContext.cpp b/lldb/source/Target/ExecutionContext.cpp index 3f54ea55c9c81..cef21f7ff6d78 100644 --- a/lldb/source/Target/ExecutionContext.cpp +++ b/lldb/source/Target/ExecutionContext.cpp @@ -125,8 +125,10 @@ ExecutionContext::ExecutionContext(const ExecutionContextRef *exe_ctx_ref_ptr, } } -ExecutionContext::ExecutionContext(const ExecutionContextRef *exe_ctx_ref_ptr, - std::unique_lock &lock) +ExecutionContext::ExecutionContext( + const ExecutionContextRef *exe_ctx_ref_ptr, + std::unique_lock &lock, + ProcessRunLock::ProcessRunLocker &stop_locker) : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() { if (exe_ctx_ref_ptr) { m_target_sp = exe_ctx_ref_ptr->GetTargetSP(); @@ -134,8 +136,10 @@ ExecutionContext::ExecutionContext(const ExecutionContextRef *exe_ctx_ref_ptr, lock = std::unique_lock(m_target_sp->GetAPIMutex()); m_process_sp = exe_ctx_ref_ptr->GetProcessSP(); - m_thread_sp = exe_ctx_ref_ptr->GetThreadSP(); - m_frame_sp = exe_ctx_ref_ptr->GetFrameSP(); + if (m_process_sp && stop_locker.TryLock(&m_process_sp->GetRunLock())) { + m_thread_sp = exe_ctx_ref_ptr->GetThreadSP(); + m_frame_sp = exe_ctx_ref_ptr->GetFrameSP(); + } } } } diff --git a/lldb/test/API/python_api/run_locker/TestRunLocker.py b/lldb/test/API/python_api/run_locker/TestRunLocker.py index b7b4941214e86..d525bbf6b406f 100644 --- a/lldb/test/API/python_api/run_locker/TestRunLocker.py +++ b/lldb/test/API/python_api/run_locker/TestRunLocker.py @@ -107,4 +107,6 @@ def runlocker_test(self, stop_at_entry): "script var = lldb.frame.EvaluateExpression('SomethingToCall()'); var.GetError().GetCString()", result, ) - self.assertIn("sbframe object is not valid", result.GetOutput()) + self.assertIn( + "can't evaluate expressions when the process is running", result.GetOutput() + ) From 37da24439225699f422f8cb5dc7121497e1634ee Mon Sep 17 00:00:00 2001 From: Felipe de Azevedo Piovezan Date: Tue, 5 Aug 2025 11:13:22 -0700 Subject: [PATCH 2/9] fixup! Address review comments --- lldb/include/lldb/API/SBFrame.h | 4 +- lldb/include/lldb/Target/ExecutionContext.h | 23 +++++++---- lldb/source/API/SBFrame.cpp | 2 + lldb/source/API/SBThread.cpp | 32 +++++++++------ lldb/source/Target/ExecutionContext.cpp | 45 +++++++++++++++------ 5 files changed, 72 insertions(+), 34 deletions(-) diff --git a/lldb/include/lldb/API/SBFrame.h b/lldb/include/lldb/API/SBFrame.h index 35198068814d0..08de0605b3240 100644 --- a/lldb/include/lldb/API/SBFrame.h +++ b/lldb/include/lldb/API/SBFrame.h @@ -233,8 +233,8 @@ 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. + /// Return an SBValue containing an error message that warns the process is + /// not currently stopped. static SBValue CreateProcessIsRunningExprEvalError(); lldb::ExecutionContextRefSP m_opaque_sp; diff --git a/lldb/include/lldb/Target/ExecutionContext.h b/lldb/include/lldb/Target/ExecutionContext.h index ae6051f576fac..63e305f0106a1 100644 --- a/lldb/include/lldb/Target/ExecutionContext.h +++ b/lldb/include/lldb/Target/ExecutionContext.h @@ -316,16 +316,25 @@ class ExecutionContext { ExecutionContext(const ExecutionContextRef *exe_ctx_ref, bool thread_and_frame_only_if_stopped = false); - // 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. + /// These two variants take in an API lock and a process run lock. + /// If the ExecutionContextRef has a Target, the API lock will be acquired. + /// If the ExecutionContextRef also has a Process, an attempt to acquire + /// ProcessRunLock is made. If successful (i.e. the Process is stopped), frame + /// and thread information might be available. + /// As a corollary, if the ProcessRunLocker has been locked, this + /// ExecutionContext contains non-null Process and Target pointers. + /// If a Status object is provided, it will be updated if the + /// ExecutionContextRef/Process/Target are null, or if the process is running. ExecutionContext(const ExecutionContextRef &exe_ctx_ref, - std::unique_lock &locker, - ProcessRunLock::ProcessRunLocker &stop_locker) - : ExecutionContext(&exe_ctx_ref, locker, stop_locker) {} + std::unique_lock &api_lock, + ProcessRunLock::ProcessRunLocker &stop_locker, + Status *status = nullptr) + : ExecutionContext(&exe_ctx_ref, api_lock, stop_locker, status) {} ExecutionContext(const ExecutionContextRef *exe_ctx_ref, - std::unique_lock &locker, - ProcessRunLock::ProcessRunLocker &stop_locker); + std::unique_lock &api_lock, + ProcessRunLock::ProcessRunLocker &stop_locker, + Status *status = nullptr); // 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 96891fee61e73..08946eddf7d96 100644 --- a/lldb/source/API/SBFrame.cpp +++ b/lldb/source/API/SBFrame.cpp @@ -97,6 +97,8 @@ bool SBFrame::IsValid() const { } SBFrame::operator bool() const { LLDB_INSTRUMENT_VA(this); + if (!m_opaque_sp) + return false; std::unique_lock lock; Process::StopLocker stop_locker; diff --git a/lldb/source/API/SBThread.cpp b/lldb/source/API/SBThread.cpp index 17d10e4dc2c2b..506981eb13008 100644 --- a/lldb/source/API/SBThread.cpp +++ b/lldb/source/API/SBThread.cpp @@ -112,6 +112,8 @@ bool SBThread::IsValid() const { } SBThread::operator bool() const { LLDB_INSTRUMENT_VA(this); + if (!m_opaque_sp) + return false; std::unique_lock lock; Process::StopLocker stop_locker; @@ -537,7 +539,7 @@ void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) { std::unique_lock lock; Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); if (!stop_locker.IsLocked()) return; @@ -587,7 +589,7 @@ void SBThread::StepInto(const char *target_name, uint32_t end_line, std::unique_lock lock; Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); if (!stop_locker.IsLocked()) return; @@ -647,7 +649,7 @@ void SBThread::StepOut(SBError &error) { std::unique_lock lock; Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); if (!stop_locker.IsLocked()) return; @@ -685,7 +687,7 @@ void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) { std::unique_lock lock; Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); if (!stop_locker.IsLocked()) return; @@ -732,7 +734,7 @@ void SBThread::StepInstruction(bool step_over, SBError &error) { std::unique_lock lock; Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); if (!stop_locker.IsLocked()) return; @@ -764,7 +766,7 @@ void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) { std::unique_lock lock; Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); if (!stop_locker.IsLocked()) return; @@ -799,7 +801,8 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame, std::unique_lock lock; Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, + &sb_error.ref()); if (!stop_locker.IsLocked()) return sb_error; @@ -937,7 +940,7 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name, std::unique_lock lock; Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); if (!stop_locker.IsLocked()) return error; @@ -976,7 +979,8 @@ SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) { std::unique_lock lock; Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, + &sb_error.ref()); if (!stop_locker.IsLocked()) return sb_error; @@ -999,7 +1003,8 @@ SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) { std::unique_lock lock; Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, + &sb_error.ref()); if (!stop_locker.IsLocked()) return sb_error; @@ -1019,7 +1024,8 @@ SBError SBThread::UnwindInnermostExpression() { std::unique_lock lock; Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, + &sb_error.ref()); if (!stop_locker.IsLocked()) return sb_error; @@ -1045,7 +1051,7 @@ bool SBThread::Suspend(SBError &error) { std::unique_lock lock; Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); if (!stop_locker.IsLocked()) { error = Status::FromErrorString("process is running"); return false; @@ -1072,7 +1078,7 @@ bool SBThread::Resume(SBError &error) { std::unique_lock lock; Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); if (!stop_locker.IsLocked()) { error = Status::FromErrorString("process is running"); return false; diff --git a/lldb/source/Target/ExecutionContext.cpp b/lldb/source/Target/ExecutionContext.cpp index cef21f7ff6d78..bc9540314d03f 100644 --- a/lldb/source/Target/ExecutionContext.cpp +++ b/lldb/source/Target/ExecutionContext.cpp @@ -12,6 +12,7 @@ #include "lldb/Target/StackFrame.h" #include "lldb/Target/Target.h" #include "lldb/Target/Thread.h" +#include "lldb/Utility/LLDBLog.h" #include "lldb/Utility/State.h" using namespace lldb_private; @@ -127,21 +128,41 @@ ExecutionContext::ExecutionContext(const ExecutionContextRef *exe_ctx_ref_ptr, ExecutionContext::ExecutionContext( const ExecutionContextRef *exe_ctx_ref_ptr, - std::unique_lock &lock, - ProcessRunLock::ProcessRunLocker &stop_locker) + std::unique_lock &api_lock, + ProcessRunLock::ProcessRunLocker &stop_locker, Status *status) : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() { - if (exe_ctx_ref_ptr) { - m_target_sp = exe_ctx_ref_ptr->GetTargetSP(); - if (m_target_sp) { - lock = std::unique_lock(m_target_sp->GetAPIMutex()); + auto set_status = [&](const char *msg) { + if (status) + *status = Status::FromErrorString(msg); + }; + + if (!exe_ctx_ref_ptr) { + set_status("ExecutionContext created with an empty ExecutionContextRef"); + return; + } - m_process_sp = exe_ctx_ref_ptr->GetProcessSP(); - if (m_process_sp && stop_locker.TryLock(&m_process_sp->GetRunLock())) { - m_thread_sp = exe_ctx_ref_ptr->GetThreadSP(); - m_frame_sp = exe_ctx_ref_ptr->GetFrameSP(); - } - } + m_target_sp = exe_ctx_ref_ptr->GetTargetSP(); + if (!m_target_sp) { + set_status("ExecutionContext created with a null target"); + return; } + + api_lock = std::unique_lock(m_target_sp->GetAPIMutex()); + m_process_sp = exe_ctx_ref_ptr->GetProcessSP(); + if (!m_process_sp) { + set_status("ExecutionContext created with a null process"); + return; + } + + if (!stop_locker.TryLock(&m_process_sp->GetRunLock())) { + const char *msg = "ExecutionContext created with a running process"; + set_status(msg); + LLDB_LOG(GetLog(LLDBLog::API), msg); + return; + } + + m_thread_sp = exe_ctx_ref_ptr->GetThreadSP(); + m_frame_sp = exe_ctx_ref_ptr->GetFrameSP(); } ExecutionContext::ExecutionContext(ExecutionContextScope *exe_scope_ptr) From 66e610526b2b19840891e0b47e34ae41b3eabc29 Mon Sep 17 00:00:00 2001 From: Felipe de Azevedo Piovezan Date: Tue, 5 Aug 2025 13:12:45 -0700 Subject: [PATCH 3/9] fixup! Fix linux buildbot issue --- lldb/source/API/SBThread.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/lldb/source/API/SBThread.cpp b/lldb/source/API/SBThread.cpp index 506981eb13008..5b9ff0f5b2abf 100644 --- a/lldb/source/API/SBThread.cpp +++ b/lldb/source/API/SBThread.cpp @@ -339,15 +339,15 @@ SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) { size_t SBThread::GetStopDescription(char *dst, size_t dst_len) { LLDB_INSTRUMENT_VA(this, dst, dst_len); + if (dst) + *dst = 0; + std::unique_lock lock; Process::StopLocker stop_locker; ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); if (!stop_locker.IsLocked()) return 0; - if (dst) - *dst = 0; - if (!exe_ctx.HasThreadScope()) return 0; From 69bf651b43966bd314c019cef0a0cea98e43d6ae Mon Sep 17 00:00:00 2001 From: Felipe de Azevedo Piovezan Date: Fri, 8 Aug 2025 08:43:26 -0700 Subject: [PATCH 4/9] fixup! Create all-or-nothing factory method --- lldb/include/lldb/API/SBError.h | 1 + lldb/include/lldb/Host/ProcessRunLock.h | 8 + lldb/include/lldb/Target/ExecutionContext.h | 66 +- lldb/source/API/SBFrame.cpp | 863 ++++++++------------ lldb/source/API/SBThread.cpp | 545 ++++++------ lldb/source/Target/ExecutionContext.cpp | 73 +- 6 files changed, 727 insertions(+), 829 deletions(-) diff --git a/lldb/include/lldb/API/SBError.h b/lldb/include/lldb/API/SBError.h index 58b45ebd793af..6a4a39c4db314 100644 --- a/lldb/include/lldb/API/SBError.h +++ b/lldb/include/lldb/API/SBError.h @@ -87,6 +87,7 @@ class LLDB_API SBError { friend class SBDebugger; friend class SBFile; friend class SBFormat; + friend class SBFrame; friend class SBHostOS; friend class SBPlatform; friend class SBProcess; diff --git a/lldb/include/lldb/Host/ProcessRunLock.h b/lldb/include/lldb/Host/ProcessRunLock.h index 5efa46154a61e..27d10942ddb4c 100644 --- a/lldb/include/lldb/Host/ProcessRunLock.h +++ b/lldb/include/lldb/Host/ProcessRunLock.h @@ -44,6 +44,14 @@ class ProcessRunLock { ProcessRunLocker(ProcessRunLocker &&other) : m_lock(other.m_lock) { other.m_lock = nullptr; } + ProcessRunLocker &operator=(ProcessRunLocker &&other) { + if (this != &other) { + Unlock(); + m_lock = other.m_lock; + other.m_lock = nullptr; + } + return *this; + } ~ProcessRunLocker() { Unlock(); } diff --git a/lldb/include/lldb/Target/ExecutionContext.h b/lldb/include/lldb/Target/ExecutionContext.h index 63e305f0106a1..f7e0b7c5e4d63 100644 --- a/lldb/include/lldb/Target/ExecutionContext.h +++ b/lldb/include/lldb/Target/ExecutionContext.h @@ -316,25 +316,6 @@ class ExecutionContext { ExecutionContext(const ExecutionContextRef *exe_ctx_ref, bool thread_and_frame_only_if_stopped = false); - /// These two variants take in an API lock and a process run lock. - /// If the ExecutionContextRef has a Target, the API lock will be acquired. - /// If the ExecutionContextRef also has a Process, an attempt to acquire - /// ProcessRunLock is made. If successful (i.e. the Process is stopped), frame - /// and thread information might be available. - /// As a corollary, if the ProcessRunLocker has been locked, this - /// ExecutionContext contains non-null Process and Target pointers. - /// If a Status object is provided, it will be updated if the - /// ExecutionContextRef/Process/Target are null, or if the process is running. - ExecutionContext(const ExecutionContextRef &exe_ctx_ref, - std::unique_lock &api_lock, - ProcessRunLock::ProcessRunLocker &stop_locker, - Status *status = nullptr) - : ExecutionContext(&exe_ctx_ref, api_lock, stop_locker, status) {} - - ExecutionContext(const ExecutionContextRef *exe_ctx_ref, - std::unique_lock &api_lock, - ProcessRunLock::ProcessRunLocker &stop_locker, - Status *status = nullptr); // Create execution contexts from execution context scopes ExecutionContext(ExecutionContextScope *exe_scope); ExecutionContext(ExecutionContextScope &exe_scope); @@ -578,6 +559,53 @@ class ExecutionContext { lldb::StackFrameSP m_frame_sp; ///< The stack frame in thread. }; +/// A wrapper class representing an execution context with non-null Target +/// and Process pointers, a locked API mutex and a locked ProcessRunLock. +/// The locks are private by design: to unlock them, destroy the +/// CompleteExecutionContext. +struct CompleteExecutionContext : ExecutionContext { + CompleteExecutionContext(lldb::TargetSP &target_sp, + lldb::ProcessSP &process_sp, + lldb::ThreadSP &thread_sp, + lldb::StackFrameSP &frame_sp, + std::unique_lock api_lock, + ProcessRunLock::ProcessRunLocker stop_locker) + : m_api_lock(std::move(api_lock)), m_stop_locker(std::move(stop_locker)) { + assert(target_sp); + assert(process_sp); + assert(m_api_lock.owns_lock()); + assert(m_stop_locker.IsLocked()); + SetTargetSP(target_sp); + SetProcessSP(process_sp); + SetThreadSP(thread_sp); + SetFrameSP(frame_sp); + } + + /// Transfers ownership of the locks from `other` to `this`, making `other` + /// unusable. + CompleteExecutionContext(CompleteExecutionContext &&other) + : CompleteExecutionContext(other.m_target_sp, other.m_process_sp, + other.m_thread_sp, other.m_frame_sp, + std::move(other.m_api_lock), + std::move(other.m_stop_locker)) { + other.Clear(); + } + + /// Clears this context, unlocking the ProcessRunLock and returning the + /// locked API lock. Like after a move operation, this object is no longer + /// usable. + [[nodiscard]] std::unique_lock ClearAndGetAPILock(); + +private: + std::unique_lock m_api_lock; + ProcessRunLock::ProcessRunLocker m_stop_locker; +}; + +llvm::Expected +GetCompleteExecutionContext(const ExecutionContextRef *exe_ctx_ref_ptr); +llvm::Expected +GetCompleteExecutionContext(const lldb::ExecutionContextRefSP &exe_ctx_ref_ptr); + } // namespace lldb_private #endif // LLDB_TARGET_EXECUTIONCONTEXT_H diff --git a/lldb/source/API/SBFrame.cpp b/lldb/source/API/SBFrame.cpp index 08946eddf7d96..2af8b0be5c0a5 100644 --- a/lldb/source/API/SBFrame.cpp +++ b/lldb/source/API/SBFrame.cpp @@ -97,235 +97,176 @@ bool SBFrame::IsValid() const { } SBFrame::operator bool() const { LLDB_INSTRUMENT_VA(this); - if (!m_opaque_sp) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return false; - - std::unique_lock 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) { - return GetFrameSP().get() != nullptr; } - // Without a target & process we can't have a valid stack frame. - return false; + return GetFrameSP().get() != nullptr; } SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const { LLDB_INSTRUMENT_VA(this, resolve_scope); SBSymbolContext sb_sym_ctx; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return sb_sym_ctx; - SymbolContextItem scope = static_cast(resolve_scope); - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); - if (target && process) { - if (StackFrame *frame = exe_ctx.GetFramePtr()) - sb_sym_ctx = frame->GetSymbolContext(scope); } + SymbolContextItem scope = static_cast(resolve_scope); + if (StackFrame *frame = exe_ctx->GetFramePtr()) + sb_sym_ctx = frame->GetSymbolContext(scope); + return sb_sym_ctx; } SBModule SBFrame::GetModule() const { LLDB_INSTRUMENT_VA(this); - SBModule sb_module; - ModuleSP module_sp; - std::unique_lock 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) { - frame = exe_ctx.GetFramePtr(); - if (frame) { - module_sp = frame->GetSymbolContext(eSymbolContextModule).module_sp; - sb_module.SetSP(module_sp); - } + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return SBModule(); } + ModuleSP module_sp; + StackFrame *frame = exe_ctx->GetFramePtr(); + if (!frame) + return SBModule(); + + SBModule sb_module; + module_sp = frame->GetSymbolContext(eSymbolContextModule).module_sp; + sb_module.SetSP(module_sp); return sb_module; } SBCompileUnit SBFrame::GetCompileUnit() const { LLDB_INSTRUMENT_VA(this); - SBCompileUnit sb_comp_unit; - std::unique_lock 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) { - frame = exe_ctx.GetFramePtr(); - if (frame) { - sb_comp_unit.reset( - frame->GetSymbolContext(eSymbolContextCompUnit).comp_unit); - } + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return SBCompileUnit(); } - return sb_comp_unit; + if (StackFrame *frame = exe_ctx->GetFramePtr()) + return SBCompileUnit( + frame->GetSymbolContext(eSymbolContextCompUnit).comp_unit); + return SBCompileUnit(); } SBFunction SBFrame::GetFunction() const { LLDB_INSTRUMENT_VA(this); - SBFunction sb_function; - std::unique_lock 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) { - frame = exe_ctx.GetFramePtr(); - if (frame) { - sb_function.reset( - frame->GetSymbolContext(eSymbolContextFunction).function); - } + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return SBFunction(); } - return sb_function; + if (StackFrame *frame = exe_ctx->GetFramePtr()) + return SBFunction(frame->GetSymbolContext(eSymbolContextFunction).function); + return SBFunction(); } SBSymbol SBFrame::GetSymbol() const { LLDB_INSTRUMENT_VA(this); - SBSymbol sb_symbol; - std::unique_lock 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) { - frame = exe_ctx.GetFramePtr(); - if (frame) { - sb_symbol.reset(frame->GetSymbolContext(eSymbolContextSymbol).symbol); - } + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return SBSymbol(); } - return sb_symbol; + if (StackFrame *frame = exe_ctx->GetFramePtr()) + return SBSymbol(frame->GetSymbolContext(eSymbolContextSymbol).symbol); + return SBSymbol(); } SBBlock SBFrame::GetBlock() const { LLDB_INSTRUMENT_VA(this); - SBBlock sb_block; - std::unique_lock 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) { - frame = exe_ctx.GetFramePtr(); - if (frame) - sb_block.SetPtr(frame->GetSymbolContext(eSymbolContextBlock).block); + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return SBBlock(); } - return sb_block; + + if (StackFrame *frame = exe_ctx->GetFramePtr()) + return SBBlock(frame->GetSymbolContext(eSymbolContextBlock).block); + return SBBlock(); } SBBlock SBFrame::GetFrameBlock() const { LLDB_INSTRUMENT_VA(this); - SBBlock sb_block; - std::unique_lock 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) { - frame = exe_ctx.GetFramePtr(); - if (frame) - sb_block.SetPtr(frame->GetFrameBlock()); + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return SBBlock(); } - return sb_block; + + if (StackFrame *frame = exe_ctx->GetFramePtr()) + return SBBlock(frame->GetFrameBlock()); + return SBBlock(); } SBLineEntry SBFrame::GetLineEntry() const { LLDB_INSTRUMENT_VA(this); - SBLineEntry sb_line_entry; - std::unique_lock 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) { - frame = exe_ctx.GetFramePtr(); - if (frame) { - sb_line_entry.SetLineEntry( - frame->GetSymbolContext(eSymbolContextLineEntry).line_entry); - } + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return SBLineEntry(); } - return sb_line_entry; + + if (StackFrame *frame = exe_ctx->GetFramePtr()) + return SBLineEntry( + &frame->GetSymbolContext(eSymbolContextLineEntry).line_entry); + return SBLineEntry(); } uint32_t SBFrame::GetFrameID() const { LLDB_INSTRUMENT_VA(this); - uint32_t frame_idx = UINT32_MAX; + constexpr uint32_t error_frame_idx = UINT32_MAX; - std::unique_lock 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) - frame_idx = frame->GetFrameIndex(); + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return error_frame_idx; + } - return frame_idx; + if (StackFrame *frame = exe_ctx->GetFramePtr()) + return frame->GetFrameIndex(); + return error_frame_idx; } lldb::addr_t SBFrame::GetCFA() const { LLDB_INSTRUMENT_VA(this); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return LLDB_INVALID_ADDRESS; + } - StackFrame *frame = exe_ctx.GetFramePtr(); - if (frame) + if (StackFrame *frame = exe_ctx->GetFramePtr()) return frame->GetStackID().GetCallFrameAddress(); return LLDB_INVALID_ADDRESS; } @@ -334,114 +275,86 @@ addr_t SBFrame::GetPC() const { LLDB_INSTRUMENT_VA(this); addr_t addr = LLDB_INVALID_ADDRESS; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return addr; - - StackFrame *frame = nullptr; - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); - if (target && process) { - frame = exe_ctx.GetFramePtr(); - if (frame) { - addr = frame->GetFrameCodeAddress().GetOpcodeLoadAddress( - target, AddressClass::eCode); - } } + Target *target = exe_ctx->GetTargetPtr(); + if (StackFrame *frame = exe_ctx->GetFramePtr()) + return frame->GetFrameCodeAddress().GetOpcodeLoadAddress( + target, AddressClass::eCode); + return addr; } bool SBFrame::SetPC(addr_t new_pc) { LLDB_INSTRUMENT_VA(this, new_pc); - bool ret_val = false; - std::unique_lock 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) { - if (StackFrame *frame = exe_ctx.GetFramePtr()) { - if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) { - ret_val = reg_ctx_sp->SetPC(new_pc); - } - } + constexpr bool error_ret_val = false; + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return error_ret_val; } - return ret_val; + if (StackFrame *frame = exe_ctx->GetFramePtr()) + if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) + return reg_ctx_sp->SetPC(new_pc); + + return error_ret_val; } addr_t SBFrame::GetSP() const { LLDB_INSTRUMENT_VA(this); - addr_t addr = LLDB_INVALID_ADDRESS; - std::unique_lock 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) { - if (StackFrame *frame = exe_ctx.GetFramePtr()) { - if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) { - addr = reg_ctx_sp->GetSP(); - } - } + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return LLDB_INVALID_ADDRESS; } - return addr; + if (StackFrame *frame = exe_ctx->GetFramePtr()) + if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) + return reg_ctx_sp->GetSP(); + + return LLDB_INVALID_ADDRESS; } addr_t SBFrame::GetFP() const { LLDB_INSTRUMENT_VA(this); - addr_t addr = LLDB_INVALID_ADDRESS; - std::unique_lock 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) { - if (StackFrame *frame = exe_ctx.GetFramePtr()) { - if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) { - addr = reg_ctx_sp->GetFP(); - } - } + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return LLDB_INVALID_ADDRESS; } - return addr; + if (StackFrame *frame = exe_ctx->GetFramePtr()) + if (RegisterContextSP reg_ctx_sp = frame->GetRegisterContext()) + return reg_ctx_sp->GetFP(); + + return LLDB_INVALID_ADDRESS; } SBAddress SBFrame::GetPCAddress() const { LLDB_INSTRUMENT_VA(this); - SBAddress sb_addr; - std::unique_lock 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) { - frame = exe_ctx.GetFramePtr(); - if (frame) - sb_addr.SetAddress(frame->GetFrameCodeAddress()); + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return SBAddress(); } - return sb_addr; + + if (StackFrame *frame = exe_ctx->GetFramePtr()) + return SBAddress(frame->GetFrameCodeAddress()); + return SBAddress(); } void SBFrame::Clear() { @@ -454,15 +367,14 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) { LLDB_INSTRUMENT_VA(this, var_path); SBValue sb_value; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return sb_value; + } - StackFrame *frame = exe_ctx.GetFramePtr(); - Target *target = exe_ctx.GetTargetPtr(); - if (frame && target) { + if (StackFrame *frame = exe_ctx->GetFramePtr()) { lldb::DynamicValueType use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue(); sb_value = GetValueForVariablePath(var_path, use_dynamic); @@ -479,27 +391,22 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path, return sb_value; } - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return sb_value; + } - StackFrame *frame = nullptr; - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); - if (target && process) { - 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); - } + 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)); + sb_value.SetSP(value_sp, use_dynamic); } return sb_value; } @@ -507,21 +414,19 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path, SBValue SBFrame::FindVariable(const char *name) { LLDB_INSTRUMENT_VA(this, name); - SBValue value; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) - return value; + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return SBValue(); + } - StackFrame *frame = exe_ctx.GetFramePtr(); - Target *target = exe_ctx.GetTargetPtr(); - if (frame && target) { + if (StackFrame *frame = exe_ctx->GetFramePtr()) { lldb::DynamicValueType use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue(); - value = FindVariable(name, use_dynamic); + return FindVariable(name, use_dynamic); } - return value; + return SBValue(); } SBValue SBFrame::FindVariable(const char *name, @@ -535,26 +440,17 @@ SBValue SBFrame::FindVariable(const char *name, return sb_value; } - ValueObjectSP value_sp; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return sb_value; - - StackFrame *frame = nullptr; - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); - if (target && process) { - frame = exe_ctx.GetFramePtr(); - if (frame) { - value_sp = frame->FindVariable(ConstString(name)); - - if (value_sp) - sb_value.SetSP(value_sp, use_dynamic); - } } + if (StackFrame *frame = exe_ctx->GetFramePtr()) + if (ValueObjectSP value_sp = frame->FindVariable(ConstString(name))) + sb_value.SetSP(value_sp, use_dynamic); + return sb_value; } @@ -562,15 +458,14 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type) { LLDB_INSTRUMENT_VA(this, name, value_type); SBValue value; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return value; + } - StackFrame *frame = exe_ctx.GetFramePtr(); - Target *target = exe_ctx.GetTargetPtr(); - if (frame && target) { + if (StackFrame *frame = exe_ctx->GetFramePtr()) { lldb::DynamicValueType use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue(); value = FindValue(name, value_type, use_dynamic); @@ -589,17 +484,17 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type, } ValueObjectSP value_sp; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - - if (stop_locker.IsLocked()) { - StackFrame *frame = nullptr; - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); - if (target && process) { - frame = exe_ctx.GetFramePtr(); - if (frame) { + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return value_sp; + } else { + Target *target = exe_ctx->GetTargetPtr(); + Process *process = exe_ctx->GetProcessPtr(); + if (target && process) { // FIXME: this check is redundant. + if (StackFrame *frame = exe_ctx->GetFramePtr()) { VariableList variable_list; switch (value_type) { @@ -716,13 +611,14 @@ bool SBFrame::operator!=(const SBFrame &rhs) const { SBThread SBFrame::GetThread() const { LLDB_INSTRUMENT_VA(this); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return SBThread(); + } - ThreadSP thread_sp(exe_ctx.GetThreadSP()); + ThreadSP thread_sp(exe_ctx->GetThreadSP()); SBThread sb_thread(thread_sp); return sb_thread; @@ -731,17 +627,14 @@ SBThread SBFrame::GetThread() const { const char *SBFrame::Disassemble() const { LLDB_INSTRUMENT_VA(this); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) - return nullptr; - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); - if (!target || !process) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return nullptr; + } - if (auto *frame = exe_ctx.GetFramePtr()) + if (auto *frame = exe_ctx->GetFramePtr()) return ConstString(frame->Disassemble()).GetCString(); return nullptr; @@ -752,15 +645,15 @@ SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics, LLDB_INSTRUMENT_VA(this, arguments, locals, statics, in_scope_only); SBValueList value_list; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return value_list; + } - StackFrame *frame = exe_ctx.GetFramePtr(); - Target *target = exe_ctx.GetTargetPtr(); - if (frame && target) { + if (StackFrame *frame = exe_ctx->GetFramePtr()) { + Target *target = exe_ctx->GetTargetPtr(); lldb::DynamicValueType use_dynamic = frame->CalculateTarget()->GetPreferDynamicValue(); const bool include_runtime_support_values = @@ -785,17 +678,16 @@ lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals, LLDB_INSTRUMENT_VA(this, arguments, locals, statics, in_scope_only, use_dynamic); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) { - SBValueList empty_list; - return empty_list; + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return SBValueList(); } - Target *target = exe_ctx.GetTargetPtr(); + Target *target = exe_ctx->GetTargetPtr(); const bool include_runtime_support_values = - target ? target->GetDisplayRuntimeSupportValues() : false; + target->GetDisplayRuntimeSupportValues(); SBVariablesOptions options; options.SetIncludeArguments(arguments); options.SetIncludeLocals(locals); @@ -810,18 +702,16 @@ SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) { LLDB_INSTRUMENT_VA(this, options); SBValueList value_list; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (stop_locker.IsLocked()) { - - StackFrame *frame = nullptr; - Target *target = exe_ctx.GetTargetPtr(); - + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return SBValueList(); + } else { const bool statics = options.GetIncludeStatics(); const bool arguments = options.GetIncludeArguments(); const bool recognized_arguments = - options.GetIncludeRecognizedArguments(SBTarget(exe_ctx.GetTargetSP())); + options.GetIncludeRecognizedArguments(SBTarget(exe_ctx->GetTargetSP())); const bool locals = options.GetIncludeLocals(); const bool in_scope_only = options.GetInScopeOnly(); const bool include_runtime_support_values = @@ -829,10 +719,9 @@ SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) { const lldb::DynamicValueType use_dynamic = options.GetUseDynamic(); std::set variable_set; - Process *process = exe_ctx.GetProcessPtr(); - if (target && process) { - frame = exe_ctx.GetFramePtr(); - if (frame) { + Process *process = exe_ctx->GetProcessPtr(); + if (process) { // FIXME: this check is redundant. + if (StackFrame *frame = exe_ctx->GetFramePtr()) { Debugger &dbg = process->GetTarget().GetDebugger(); VariableList *variable_list = nullptr; Status var_error; @@ -920,17 +809,16 @@ SBValueList SBFrame::GetRegisters() { LLDB_INSTRUMENT_VA(this); SBValueList value_list; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (stop_locker.IsLocked()) { - - StackFrame *frame = nullptr; - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); - if (target && process) { - frame = exe_ctx.GetFramePtr(); - if (frame) { + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return SBValueList(); + } else { + Target *target = exe_ctx->GetTargetPtr(); + Process *process = exe_ctx->GetProcessPtr(); + if (target && process) { // FIXME: this check is redundant. + if (StackFrame *frame = exe_ctx->GetFramePtr()) { RegisterContextSP reg_ctx(frame->GetRegisterContext()); if (reg_ctx) { const uint32_t num_sets = reg_ctx->GetRegisterSetCount(); @@ -951,16 +839,16 @@ SBValue SBFrame::FindRegister(const char *name) { SBValue result; ValueObjectSP value_sp; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (stop_locker.IsLocked()) { - StackFrame *frame = nullptr; - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); - if (target && process) { - frame = exe_ctx.GetFramePtr(); - if (frame) { + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return SBValue(); + } else { + Target *target = exe_ctx->GetTargetPtr(); + Process *process = exe_ctx->GetProcessPtr(); + if (target && process) { // FIXME: this check is redundant. + if (StackFrame *frame = exe_ctx->GetFramePtr()) { RegisterContextSP reg_ctx(frame->GetRegisterContext()); if (reg_ctx) { if (const RegisterInfo *reg_info = @@ -980,15 +868,11 @@ SBError SBFrame::GetDescriptionWithFormat(const SBFormat &format, SBStream &output) { Stream &strm = output.ref(); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) - return "Process is not stopped"; + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) + return Status::FromError(exe_ctx.takeError()); - StackFrame *frame = nullptr; - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); SBError error; if (!format) { @@ -996,13 +880,9 @@ SBError SBFrame::GetDescriptionWithFormat(const SBFormat &format, return error; } - if (target && process) { - frame = exe_ctx.GetFramePtr(); - if (frame && - frame->DumpUsingFormat(strm, format.GetFormatEntrySP().get())) { - return error; - } - } + if (StackFrame *frame = exe_ctx->GetFramePtr(); + frame && frame->DumpUsingFormat(strm, format.GetFormatEntrySP().get())) + return error; error.SetErrorStringWithFormat( "It was not possible to generate a frame " "description with the given format string '%s'", @@ -1015,24 +895,16 @@ bool SBFrame::GetDescription(SBStream &description) { Stream &strm = description.ref(); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) { + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); strm.PutCString("Error: process is not stopped."); return true; } - StackFrame *frame; - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); - if (target && process) { - frame = exe_ctx.GetFramePtr(); - if (frame) { - frame->DumpUsingSettingsFormat(&strm); - } - } else - strm.PutCString("No value"); + if (StackFrame *frame = exe_ctx->GetFramePtr()) + frame->DumpUsingSettingsFormat(&strm); return true; } @@ -1040,25 +912,24 @@ bool SBFrame::GetDescription(SBStream &description) { SBValue SBFrame::EvaluateExpression(const char *expr) { LLDB_INSTRUMENT_VA(this, expr); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return CreateProcessIsRunningExprEvalError(); + } - StackFrame *frame = exe_ctx.GetFramePtr(); - Target *target = exe_ctx.GetTargetPtr(); SBExpressionOptions options; - if (frame && target) { + StackFrame *frame = exe_ctx->GetFramePtr(); + if (frame) { lldb::DynamicValueType fetch_dynamic_value = frame->CalculateTarget()->GetPreferDynamicValue(); options.SetFetchDynamicValue(fetch_dynamic_value); } options.SetUnwindOnError(true); options.SetIgnoreBreakpoints(true); - SourceLanguage language; - if (target) - language = target->GetLanguage(); + Target *target = exe_ctx->GetTargetPtr(); + SourceLanguage language = target->GetLanguage(); if (!language && frame) language = frame->GetLanguage(); options.SetLanguage((SBSourceLanguageName)language.name, language.version); @@ -1074,17 +945,16 @@ SBFrame::EvaluateExpression(const char *expr, options.SetFetchDynamicValue(fetch_dynamic_value); options.SetUnwindOnError(true); options.SetIgnoreBreakpoints(true); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return CreateProcessIsRunningExprEvalError(); + } - StackFrame *frame = exe_ctx.GetFramePtr(); - Target *target = exe_ctx.GetTargetPtr(); - SourceLanguage language; - if (target) - language = target->GetLanguage(); + StackFrame *frame = exe_ctx->GetFramePtr(); + Target *target = exe_ctx->GetTargetPtr(); + SourceLanguage language = target->GetLanguage(); if (!language && frame) language = frame->GetLanguage(); options.SetLanguage((SBSourceLanguageName)language.name, language.version); @@ -1097,20 +967,19 @@ SBValue SBFrame::EvaluateExpression(const char *expr, LLDB_INSTRUMENT_VA(this, expr, fetch_dynamic_value, unwind_on_error); SBExpressionOptions options; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return CreateProcessIsRunningExprEvalError(); + } options.SetFetchDynamicValue(fetch_dynamic_value); options.SetUnwindOnError(unwind_on_error); options.SetIgnoreBreakpoints(true); - StackFrame *frame = exe_ctx.GetFramePtr(); - Target *target = exe_ctx.GetTargetPtr(); - SourceLanguage language; - if (target) - language = target->GetLanguage(); + StackFrame *frame = exe_ctx->GetFramePtr(); + Target *target = exe_ctx->GetTargetPtr(); + SourceLanguage language = target->GetLanguage(); if (!language && frame) language = frame->GetLanguage(); options.SetLanguage((SBSourceLanguageName)language.name, language.version); @@ -1141,18 +1010,16 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr, ValueObjectSP expr_value_sp; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (stop_locker.IsLocked()) { - - StackFrame *frame = nullptr; - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); - - if (target && process) { - frame = exe_ctx.GetFramePtr(); - if (frame) { + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + expr_result = CreateProcessIsRunningExprEvalError(); + } else { + Target *target = exe_ctx->GetTargetPtr(); + Process *process = exe_ctx->GetProcessPtr(); + if (target && process) { // FIXME: this check is redundant. + if (StackFrame *frame = exe_ctx->GetFramePtr()) { std::unique_ptr stack_trace; if (target->GetDisplayExpressionsInCrashlogs()) { StreamString frame_description; @@ -1173,8 +1040,7 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr, expr_value_sp = ValueObjectConstResult::Create(nullptr, std::move(error)); expr_result.SetSP(expr_value_sp, false); } - } else - expr_result = CreateProcessIsRunningExprEvalError(); + } if (expr_result.GetError().Success()) LLDB_LOGF(expr_log, @@ -1194,12 +1060,13 @@ SBStructuredData SBFrame::GetLanguageSpecificData() const { LLDB_INSTRUMENT_VA(this); SBStructuredData sb_data; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return sb_data; - StackFrame *frame = exe_ctx.GetFramePtr(); + } + StackFrame *frame = exe_ctx->GetFramePtr(); if (!frame) return sb_data; @@ -1217,20 +1084,15 @@ bool SBFrame::IsInlined() { bool SBFrame::IsInlined() const { LLDB_INSTRUMENT_VA(this); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return false; - - StackFrame *frame = nullptr; - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); - if (target && process) { - frame = exe_ctx.GetFramePtr(); - if (frame) - return frame->IsInlined(); } + + if (StackFrame *frame = exe_ctx->GetFramePtr()) + return frame->IsInlined(); return false; } @@ -1243,13 +1105,14 @@ bool SBFrame::IsArtificial() { bool SBFrame::IsArtificial() const { LLDB_INSTRUMENT_VA(this); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return false; + } - if (StackFrame *frame = exe_ctx.GetFramePtr()) + if (StackFrame *frame = exe_ctx->GetFramePtr()) return frame->IsArtificial(); return false; @@ -1258,13 +1121,14 @@ bool SBFrame::IsArtificial() const { bool SBFrame::IsHidden() const { LLDB_INSTRUMENT_VA(this); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return false; + } - if (StackFrame *frame = exe_ctx.GetFramePtr()) + if (StackFrame *frame = exe_ctx->GetFramePtr()) return frame->IsHidden(); return false; @@ -1279,63 +1143,44 @@ const char *SBFrame::GetFunctionName() { lldb::LanguageType SBFrame::GuessLanguage() const { LLDB_INSTRUMENT_VA(this); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return eLanguageTypeUnknown; - - StackFrame *frame = nullptr; - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); - if (target && process) { - frame = exe_ctx.GetFramePtr(); - if (frame) { - return frame->GuessLanguage().AsLanguageType(); - } } + + if (StackFrame *frame = exe_ctx->GetFramePtr()) + return frame->GuessLanguage().AsLanguageType(); return eLanguageTypeUnknown; } const char *SBFrame::GetFunctionName() const { LLDB_INSTRUMENT_VA(this); - const char *name = nullptr; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) - return name; - - StackFrame *frame = nullptr; - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); - if (target && process) { - frame = exe_ctx.GetFramePtr(); - if (frame) - return frame->GetFunctionName(); + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return nullptr; } - return name; + + if (StackFrame *frame = exe_ctx->GetFramePtr()) + return frame->GetFunctionName(); + return nullptr; } const char *SBFrame::GetDisplayFunctionName() { LLDB_INSTRUMENT_VA(this); - const char *name = nullptr; - - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) - return name; - - StackFrame *frame = nullptr; - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); - if (target && process) { - frame = exe_ctx.GetFramePtr(); - if (frame) - return frame->GetDisplayFunctionName(); + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); + return nullptr; } - return name; + + if (StackFrame *frame = exe_ctx->GetFramePtr()) + return frame->GetDisplayFunctionName(); + return nullptr; } diff --git a/lldb/source/API/SBThread.cpp b/lldb/source/API/SBThread.cpp index 5b9ff0f5b2abf..bc0d0e9b55ee5 100644 --- a/lldb/source/API/SBThread.cpp +++ b/lldb/source/API/SBThread.cpp @@ -90,14 +90,15 @@ lldb::SBQueue SBThread::GetQueue() const { SBQueue sb_queue; QueueSP queue_sp; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return SBQueue(); + } - if (exe_ctx.HasThreadScope()) { - queue_sp = exe_ctx.GetThreadPtr()->GetQueue(); + if (exe_ctx->HasThreadScope()) { + queue_sp = exe_ctx->GetThreadPtr()->GetQueue(); if (queue_sp) { sb_queue.SetQueue(queue_sp); } @@ -115,19 +116,14 @@ SBThread::operator bool() const { if (!m_opaque_sp) return false; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return false; - - Target *target = exe_ctx.GetTargetPtr(); - Process *process = exe_ctx.GetProcessPtr(); - if (target && process) { - return m_opaque_sp->GetThreadSP().get() != nullptr; } - // Without a valid target & process, this thread can't be valid. - return false; + + return m_opaque_sp->GetThreadSP().get() != nullptr; } void SBThread::Clear() { @@ -140,28 +136,27 @@ StopReason SBThread::GetStopReason() { LLDB_INSTRUMENT_VA(this); StopReason reason = eStopReasonInvalid; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return reason; - - if (exe_ctx.HasThreadScope()) { - return exe_ctx.GetThreadPtr()->GetStopReason(); } + if (exe_ctx->HasThreadScope()) + return exe_ctx->GetThreadPtr()->GetStopReason(); + return reason; } size_t SBThread::GetStopReasonDataCount() { LLDB_INSTRUMENT_VA(this); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (stop_locker.IsLocked()) { - if (exe_ctx.HasThreadScope()) { - StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo(); + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (exe_ctx) { + if (exe_ctx->HasThreadScope()) { + StopInfoSP stop_info_sp = exe_ctx->GetThreadPtr()->GetStopInfo(); if (stop_info_sp) { StopReason reason = stop_info_sp->GetStopReason(); switch (reason) { @@ -181,7 +176,7 @@ size_t SBThread::GetStopReasonDataCount() { case eStopReasonBreakpoint: { break_id_t site_id = stop_info_sp->GetValue(); lldb::BreakpointSiteSP bp_site_sp( - exe_ctx.GetProcessPtr()->GetBreakpointSiteList().FindByID( + exe_ctx->GetProcessPtr()->GetBreakpointSiteList().FindByID( site_id)); if (bp_site_sp) return bp_site_sp->GetNumberOfConstituents() * 2; @@ -209,6 +204,9 @@ size_t SBThread::GetStopReasonDataCount() { } } } + } else { + llvm::consumeError(exe_ctx.takeError()); + return 0; } return 0; } @@ -216,12 +214,11 @@ size_t SBThread::GetStopReasonDataCount() { uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) { LLDB_INSTRUMENT_VA(this, idx); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (stop_locker.IsLocked()) { - if (exe_ctx.HasThreadScope()) { - Thread *thread = exe_ctx.GetThreadPtr(); + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (exe_ctx) { + if (exe_ctx->HasThreadScope()) { + Thread *thread = exe_ctx->GetThreadPtr(); StopInfoSP stop_info_sp = thread->GetStopInfo(); if (stop_info_sp) { StopReason reason = stop_info_sp->GetStopReason(); @@ -242,7 +239,7 @@ uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) { case eStopReasonBreakpoint: { break_id_t site_id = stop_info_sp->GetValue(); lldb::BreakpointSiteSP bp_site_sp( - exe_ctx.GetProcessPtr()->GetBreakpointSiteList().FindByID( + exe_ctx->GetProcessPtr()->GetBreakpointSiteList().FindByID( site_id)); if (bp_site_sp) { uint32_t bp_index = idx / 2; @@ -281,6 +278,9 @@ uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) { } } } + } else { + llvm::consumeError(exe_ctx.takeError()); + return 0; } return 0; } @@ -290,16 +290,17 @@ bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) { Stream &strm = stream.ref(); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return false; + } - if (!exe_ctx.HasThreadScope()) + if (!exe_ctx->HasThreadScope()) return false; - StopInfoSP stop_info = exe_ctx.GetThreadPtr()->GetStopInfo(); + StopInfoSP stop_info = exe_ctx->GetThreadPtr()->GetStopInfo(); StructuredData::ObjectSP info = stop_info->GetExtendedInfo(); if (!info) return false; @@ -315,18 +316,19 @@ SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) { SBThreadCollection threads; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return SBThreadCollection(); + } - if (!exe_ctx.HasThreadScope()) + if (!exe_ctx->HasThreadScope()) return SBThreadCollection(); - ProcessSP process_sp = exe_ctx.GetProcessSP(); + ProcessSP process_sp = exe_ctx->GetProcessSP(); - StopInfoSP stop_info = exe_ctx.GetThreadPtr()->GetStopInfo(); + StopInfoSP stop_info = exe_ctx->GetThreadPtr()->GetStopInfo(); StructuredData::ObjectSP info = stop_info->GetExtendedInfo(); if (!info) return threads; @@ -342,16 +344,17 @@ size_t SBThread::GetStopDescription(char *dst, size_t dst_len) { if (dst) *dst = 0; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return 0; + } - if (!exe_ctx.HasThreadScope()) + if (!exe_ctx->HasThreadScope()) return 0; - std::string thread_stop_desc = exe_ctx.GetThreadPtr()->GetStopDescription(); + std::string thread_stop_desc = exe_ctx->GetThreadPtr()->GetStopDescription(); if (thread_stop_desc.empty()) return 0; @@ -367,14 +370,15 @@ SBValue SBThread::GetStopReturnValue() { LLDB_INSTRUMENT_VA(this); ValueObjectSP return_valobj_sp; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return SBValue(); + } - if (exe_ctx.HasThreadScope()) { - StopInfoSP stop_info_sp = exe_ctx.GetThreadPtr()->GetStopInfo(); + if (exe_ctx->HasThreadScope()) { + StopInfoSP stop_info_sp = exe_ctx->GetThreadPtr()->GetStopInfo(); if (stop_info_sp) { return_valobj_sp = StopInfo::GetReturnValueObject(stop_info_sp); } @@ -408,45 +412,48 @@ uint32_t SBThread::GetIndexID() const { const char *SBThread::GetName() const { LLDB_INSTRUMENT_VA(this); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return nullptr; + } - if (!exe_ctx.HasThreadScope()) + if (!exe_ctx->HasThreadScope()) return nullptr; - return ConstString(exe_ctx.GetThreadPtr()->GetName()).GetCString(); + return ConstString(exe_ctx->GetThreadPtr()->GetName()).GetCString(); } const char *SBThread::GetQueueName() const { LLDB_INSTRUMENT_VA(this); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return nullptr; + } - if (!exe_ctx.HasThreadScope()) + if (!exe_ctx->HasThreadScope()) return nullptr; - return ConstString(exe_ctx.GetThreadPtr()->GetQueueName()).GetCString(); + return ConstString(exe_ctx->GetThreadPtr()->GetQueueName()).GetCString(); } lldb::queue_id_t SBThread::GetQueueID() const { LLDB_INSTRUMENT_VA(this); queue_id_t id = LLDB_INVALID_QUEUE_ID; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return id; + } - if (exe_ctx.HasThreadScope()) { - id = exe_ctx.GetThreadPtr()->GetQueueID(); + if (exe_ctx->HasThreadScope()) { + id = exe_ctx->GetThreadPtr()->GetQueueID(); } return id; @@ -456,12 +463,11 @@ bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) { LLDB_INSTRUMENT_VA(this, path, strm); bool success = false; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (stop_locker.IsLocked()) { - if (exe_ctx.HasThreadScope()) { - Thread *thread = exe_ctx.GetThreadPtr(); + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (exe_ctx) { + if (exe_ctx->HasThreadScope()) { + Thread *thread = exe_ctx->GetThreadPtr(); StructuredData::ObjectSP info_root_sp = thread->GetExtendedInfo(); if (info_root_sp) { StructuredData::ObjectSP node = @@ -493,21 +499,16 @@ bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) { } } } + } else { + llvm::consumeError(exe_ctx.takeError()); + return success; } return success; } -static Status ResumeNewPlan(ExecutionContext &exe_ctx, ThreadPlan *new_plan, - Process::StopLocker stop_lock) { - { - assert(stop_lock.IsLocked()); - auto to_unlock = std::move(stop_lock); - } - Process *process = exe_ctx.GetProcessPtr(); - if (!process) - return Status::FromErrorString("No process in SBThread::ResumeNewPlan"); - +static Status ResumeNewPlan(CompleteExecutionContext exe_ctx, + ThreadPlan *new_plan) { Thread *thread = exe_ctx.GetThreadPtr(); if (!thread) return Status::FromErrorString("No thread in SBThread::ResumeNewPlan"); @@ -520,8 +521,12 @@ static Status ResumeNewPlan(ExecutionContext &exe_ctx, ThreadPlan *new_plan, } // Why do we need to set the current thread by ID here??? + Process *process = exe_ctx.GetProcessPtr(); process->GetThreadList().SetSelectedThreadByID(thread->GetID()); + // Release the run lock but keep the API lock. + std::unique_lock api_lock = + exe_ctx.ClearAndGetAPILock(); if (process->GetTarget().GetDebugger().GetAsyncExecution()) return process->Resume(); return process->ResumeSynchronous(nullptr); @@ -537,18 +542,19 @@ void SBThread::StepOver(lldb::RunMode stop_other_threads) { void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) { LLDB_INSTRUMENT_VA(this, stop_other_threads, error); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + error = Status::FromError(exe_ctx.takeError()); return; + } - if (!exe_ctx.HasThreadScope()) { + if (!exe_ctx->HasThreadScope()) { error = Status::FromErrorString("this SBThread object is invalid"); return; } - Thread *thread = exe_ctx.GetThreadPtr(); + Thread *thread = exe_ctx->GetThreadPtr(); bool abort_other_plans = false; StackFrameSP frame_sp(thread->GetStackFrameAtIndex(0)); @@ -566,7 +572,7 @@ void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) { true, abort_other_plans, stop_other_threads, new_plan_status); } } - error = ResumeNewPlan(exe_ctx, new_plan_sp.get(), std::move(stop_locker)); + error = ResumeNewPlan(std::move(*exe_ctx), new_plan_sp.get()); } void SBThread::StepInto(lldb::RunMode stop_other_threads) { @@ -587,20 +593,21 @@ void SBThread::StepInto(const char *target_name, uint32_t end_line, SBError &error, lldb::RunMode stop_other_threads) { LLDB_INSTRUMENT_VA(this, target_name, end_line, error, stop_other_threads); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + error = Status::FromError(exe_ctx.takeError()); return; + } - if (!exe_ctx.HasThreadScope()) { + if (!exe_ctx->HasThreadScope()) { error = Status::FromErrorString("this SBThread object is invalid"); return; } bool abort_other_plans = false; - Thread *thread = exe_ctx.GetThreadPtr(); + Thread *thread = exe_ctx->GetThreadPtr(); StackFrameSP frame_sp(thread->GetStackFrameAtIndex(0)); ThreadPlanSP new_plan_sp; Status new_plan_status; @@ -632,7 +639,7 @@ void SBThread::StepInto(const char *target_name, uint32_t end_line, } if (new_plan_status.Success()) - error = ResumeNewPlan(exe_ctx, new_plan_sp.get(), std::move(stop_locker)); + error = ResumeNewPlan(std::move(*exe_ctx), new_plan_sp.get()); else error = Status::FromErrorString(new_plan_status.AsCString()); } @@ -647,13 +654,14 @@ void SBThread::StepOut() { void SBThread::StepOut(SBError &error) { LLDB_INSTRUMENT_VA(this, error); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + error = Status::FromError(exe_ctx.takeError()); return; + } - if (!exe_ctx.HasThreadScope()) { + if (!exe_ctx->HasThreadScope()) { error = Status::FromErrorString("this SBThread object is invalid"); return; } @@ -661,7 +669,7 @@ void SBThread::StepOut(SBError &error) { bool abort_other_plans = false; bool stop_other_threads = false; - Thread *thread = exe_ctx.GetThreadPtr(); + Thread *thread = exe_ctx->GetThreadPtr(); const LazyBool avoid_no_debug = eLazyBoolCalculate; Status new_plan_status; @@ -670,7 +678,7 @@ void SBThread::StepOut(SBError &error) { eVoteNoOpinion, 0, new_plan_status, avoid_no_debug)); if (new_plan_status.Success()) - error = ResumeNewPlan(exe_ctx, new_plan_sp.get(), std::move(stop_locker)); + error = ResumeNewPlan(std::move(*exe_ctx), new_plan_sp.get()); else error = Status::FromErrorString(new_plan_status.AsCString()); } @@ -685,11 +693,12 @@ void SBThread::StepOutOfFrame(SBFrame &sb_frame) { void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) { LLDB_INSTRUMENT_VA(this, sb_frame, error); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + error = Status::FromError(exe_ctx.takeError()); return; + } if (!sb_frame.IsValid()) { error = Status::FromErrorString("passed invalid SBFrame object"); @@ -698,14 +707,14 @@ void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) { StackFrameSP frame_sp(sb_frame.GetFrameSP()); - if (!exe_ctx.HasThreadScope()) { + if (!exe_ctx->HasThreadScope()) { error = Status::FromErrorString("this SBThread object is invalid"); return; } bool abort_other_plans = false; bool stop_other_threads = false; - Thread *thread = exe_ctx.GetThreadPtr(); + Thread *thread = exe_ctx->GetThreadPtr(); if (sb_frame.GetThread().GetThreadID() != thread->GetID()) { error = Status::FromErrorString("passed a frame from another thread"); return; @@ -717,7 +726,7 @@ void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) { eVoteNoOpinion, frame_sp->GetFrameIndex(), new_plan_status)); if (new_plan_status.Success()) - error = ResumeNewPlan(exe_ctx, new_plan_sp.get(), std::move(stop_locker)); + error = ResumeNewPlan(std::move(*exe_ctx), new_plan_sp.get()); else error = Status::FromErrorString(new_plan_status.AsCString()); } @@ -732,24 +741,25 @@ void SBThread::StepInstruction(bool step_over) { void SBThread::StepInstruction(bool step_over, SBError &error) { LLDB_INSTRUMENT_VA(this, step_over, error); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + error = Status::FromError(exe_ctx.takeError()); return; + } - if (!exe_ctx.HasThreadScope()) { + if (!exe_ctx->HasThreadScope()) { error = Status::FromErrorString("this SBThread object is invalid"); return; } - Thread *thread = exe_ctx.GetThreadPtr(); + Thread *thread = exe_ctx->GetThreadPtr(); Status new_plan_status; ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForStepSingleInstruction( step_over, false, true, new_plan_status)); if (new_plan_status.Success()) - error = ResumeNewPlan(exe_ctx, new_plan_sp.get(), std::move(stop_locker)); + error = ResumeNewPlan(std::move(*exe_ctx), new_plan_sp.get()); else error = Status::FromErrorString(new_plan_status.AsCString()); } @@ -764,13 +774,14 @@ void SBThread::RunToAddress(lldb::addr_t addr) { void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) { LLDB_INSTRUMENT_VA(this, addr, error); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + error = Status::FromError(exe_ctx.takeError()); return; + } - if (!exe_ctx.HasThreadScope()) { + if (!exe_ctx->HasThreadScope()) { error = Status::FromErrorString("this SBThread object is invalid"); return; } @@ -780,14 +791,14 @@ void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) { Address target_addr(addr); - Thread *thread = exe_ctx.GetThreadPtr(); + Thread *thread = exe_ctx->GetThreadPtr(); Status new_plan_status; ThreadPlanSP new_plan_sp(thread->QueueThreadPlanForRunToAddress( abort_other_plans, target_addr, stop_other_threads, new_plan_status)); if (new_plan_status.Success()) - error = ResumeNewPlan(exe_ctx, new_plan_sp.get(), std::move(stop_locker)); + error = ResumeNewPlan(std::move(*exe_ctx), new_plan_sp.get()); else error = Status::FromErrorString(new_plan_status.AsCString()); } @@ -799,18 +810,16 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame, SBError sb_error; char path[PATH_MAX]; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, - &sb_error.ref()); - if (!stop_locker.IsLocked()) - return sb_error; + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) + return Status::FromError(exe_ctx.takeError()); StackFrameSP frame_sp(sb_frame.GetFrameSP()); - if (exe_ctx.HasThreadScope()) { - Target *target = exe_ctx.GetTargetPtr(); - Thread *thread = exe_ctx.GetThreadPtr(); + if (exe_ctx->HasThreadScope()) { + Target *target = exe_ctx->GetTargetPtr(); + Thread *thread = exe_ctx->GetThreadPtr(); if (line == 0) { sb_error = Status::FromErrorString("invalid line argument"); @@ -905,8 +914,7 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame, frame_sp->GetFrameIndex(), new_plan_status)); if (new_plan_status.Success()) - sb_error = - ResumeNewPlan(exe_ctx, new_plan_sp.get(), std::move(stop_locker)); + sb_error = ResumeNewPlan(std::move(*exe_ctx), new_plan_sp.get()); else sb_error = Status::FromErrorString(new_plan_status.AsCString()); } @@ -938,18 +946,17 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name, SBError error; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); - if (!stop_locker.IsLocked()) - return error; + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) + return Status::FromError(exe_ctx.takeError()); - if (!exe_ctx.HasThreadScope()) { + if (!exe_ctx->HasThreadScope()) { error = Status::FromErrorString("this SBThread object is invalid"); return error; } - Thread *thread = exe_ctx.GetThreadPtr(); + Thread *thread = exe_ctx->GetThreadPtr(); Status new_plan_status; StructuredData::ObjectSP obj_sp = args_data.m_impl_up->GetObjectSP(); @@ -965,7 +972,7 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name, return error; if (new_plan_status.Success()) - error = ResumeNewPlan(exe_ctx, new_plan_sp.get(), std::move(stop_locker)); + error = ResumeNewPlan(std::move(*exe_ctx), new_plan_sp.get()); else error = Status::FromErrorString(new_plan_status.AsCString()); @@ -977,19 +984,17 @@ SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) { SBError sb_error; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, - &sb_error.ref()); - if (!stop_locker.IsLocked()) - return sb_error; + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) + return Status::FromError(exe_ctx.takeError()); - if (!exe_ctx.HasThreadScope()) { + if (!exe_ctx->HasThreadScope()) { sb_error = Status::FromErrorString("this SBThread object is invalid"); return sb_error; } - Thread *thread = exe_ctx.GetThreadPtr(); + Thread *thread = exe_ctx->GetThreadPtr(); Status err = thread->JumpToLine(file_spec.ref(), line, true); sb_error.SetError(std::move(err)); @@ -1001,15 +1006,13 @@ SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) { SBError sb_error; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, - &sb_error.ref()); - if (!stop_locker.IsLocked()) - return sb_error; + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) + return Status::FromError(exe_ctx.takeError()); - if (exe_ctx.HasThreadScope()) { - Thread *thread = exe_ctx.GetThreadPtr(); + if (exe_ctx->HasThreadScope()) { + Thread *thread = exe_ctx->GetThreadPtr(); sb_error.SetError( thread->ReturnFromFrame(frame.GetFrameSP(), return_value.GetSP())); } @@ -1022,15 +1025,13 @@ SBError SBThread::UnwindInnermostExpression() { SBError sb_error; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, - &sb_error.ref()); - if (!stop_locker.IsLocked()) - return sb_error; + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) + return Status::FromError(exe_ctx.takeError()); - if (exe_ctx.HasThreadScope()) { - Thread *thread = exe_ctx.GetThreadPtr(); + if (exe_ctx->HasThreadScope()) { + Thread *thread = exe_ctx->GetThreadPtr(); sb_error.SetError(thread->UnwindInnermostExpression()); if (sb_error.Success()) thread->SetSelectedFrameByIndex(0, false); @@ -1049,17 +1050,16 @@ bool SBThread::Suspend() { bool SBThread::Suspend(SBError &error) { LLDB_INSTRUMENT_VA(this, error); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); - if (!stop_locker.IsLocked()) { - error = Status::FromErrorString("process is running"); + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + error = Status::FromError(exe_ctx.takeError()); return false; } bool result = false; - if (exe_ctx.HasThreadScope()) { - exe_ctx.GetThreadPtr()->SetResumeState(eStateSuspended); + if (exe_ctx->HasThreadScope()) { + exe_ctx->GetThreadPtr()->SetResumeState(eStateSuspended); result = true; } else error = Status::FromErrorString("this SBThread object is invalid"); @@ -1076,18 +1076,18 @@ bool SBThread::Resume() { bool SBThread::Resume(SBError &error) { LLDB_INSTRUMENT_VA(this, error); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker, &error.ref()); - if (!stop_locker.IsLocked()) { + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); error = Status::FromErrorString("process is running"); return false; } bool result = false; - if (exe_ctx.HasThreadScope()) { + if (exe_ctx->HasThreadScope()) { const bool override_suspend = true; - exe_ctx.GetThreadPtr()->SetResumeState(eStateRunning, override_suspend); + exe_ctx->GetThreadPtr()->SetResumeState(eStateRunning, override_suspend); result = true; } else error = Status::FromErrorString("this SBThread object is invalid"); @@ -1097,28 +1097,30 @@ bool SBThread::Resume(SBError &error) { bool SBThread::IsSuspended() { LLDB_INSTRUMENT_VA(this); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return false; + } - if (exe_ctx.HasThreadScope()) - return exe_ctx.GetThreadPtr()->GetResumeState() == eStateSuspended; + if (exe_ctx->HasThreadScope()) + return exe_ctx->GetThreadPtr()->GetResumeState() == eStateSuspended; return false; } bool SBThread::IsStopped() { LLDB_INSTRUMENT_VA(this); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return false; + } - if (exe_ctx.HasThreadScope()) - return StateIsStoppedState(exe_ctx.GetThreadPtr()->GetState(), true); + if (exe_ctx->HasThreadScope()) + return StateIsStoppedState(exe_ctx->GetThreadPtr()->GetState(), true); return false; } @@ -1126,16 +1128,17 @@ SBProcess SBThread::GetProcess() { LLDB_INSTRUMENT_VA(this); SBProcess sb_process; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return SBProcess(); + } - if (exe_ctx.HasThreadScope()) { + if (exe_ctx->HasThreadScope()) { // Have to go up to the target so we can get a shared pointer to our // process... - sb_process.SetSP(exe_ctx.GetProcessSP()); + sb_process.SetSP(exe_ctx->GetProcessSP()); } return sb_process; @@ -1144,33 +1147,32 @@ SBProcess SBThread::GetProcess() { uint32_t SBThread::GetNumFrames() { LLDB_INSTRUMENT_VA(this); - uint32_t num_frames = 0; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return 0; - - if (exe_ctx.HasThreadScope()) { - num_frames = exe_ctx.GetThreadPtr()->GetStackFrameCount(); } - return num_frames; + if (exe_ctx->HasThreadScope()) + return exe_ctx->GetThreadPtr()->GetStackFrameCount(); + + return 0; } SBFrame SBThread::GetFrameAtIndex(uint32_t idx) { LLDB_INSTRUMENT_VA(this, idx); SBFrame sb_frame; - StackFrameSP frame_sp; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return SBFrame(); + } - if (exe_ctx.HasThreadScope()) { - frame_sp = exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(idx); + if (exe_ctx->HasThreadScope()) { + StackFrameSP frame_sp = exe_ctx->GetThreadPtr()->GetStackFrameAtIndex(idx); sb_frame.SetFrameSP(frame_sp); } @@ -1181,16 +1183,16 @@ lldb::SBFrame SBThread::GetSelectedFrame() { LLDB_INSTRUMENT_VA(this); SBFrame sb_frame; - StackFrameSP frame_sp; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return SBFrame(); + } - if (exe_ctx.HasThreadScope()) { - frame_sp = - exe_ctx.GetThreadPtr()->GetSelectedFrame(SelectMostRelevantFrame); + if (exe_ctx->HasThreadScope()) { + StackFrameSP frame_sp = + exe_ctx->GetThreadPtr()->GetSelectedFrame(SelectMostRelevantFrame); sb_frame.SetFrameSP(frame_sp); } @@ -1202,14 +1204,15 @@ lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) { SBFrame sb_frame; StackFrameSP frame_sp; - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return SBFrame(); + } - if (exe_ctx.HasThreadScope()) { - Thread *thread = exe_ctx.GetThreadPtr(); + if (exe_ctx->HasThreadScope()) { + Thread *thread = exe_ctx->GetThreadPtr(); frame_sp = thread->GetStackFrameAtIndex(idx); if (frame_sp) { thread->SetSelectedFrame(frame_sp.get()); @@ -1257,15 +1260,16 @@ bool SBThread::GetStatus(SBStream &status) const { Stream &strm = status.ref(); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return false; + } - if (exe_ctx.HasThreadScope()) { - exe_ctx.GetThreadPtr()->GetStatus(strm, 0, 1, 1, true, - /*show_hidden=*/true); + if (exe_ctx->HasThreadScope()) { + exe_ctx->GetThreadPtr()->GetStatus(strm, 0, 1, 1, true, + /*show_hidden=*/true); } else strm.PutCString("No status"); @@ -1283,14 +1287,15 @@ bool SBThread::GetDescription(SBStream &description, bool stop_format) const { Stream &strm = description.ref(); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return false; + } - if (exe_ctx.HasThreadScope()) { - exe_ctx.GetThreadPtr()->DumpUsingSettingsFormat( + if (exe_ctx->HasThreadScope()) { + exe_ctx->GetThreadPtr()->DumpUsingSettingsFormat( strm, LLDB_INVALID_THREAD_ID, stop_format); } else strm.PutCString("No value"); @@ -1308,14 +1313,15 @@ SBError SBThread::GetDescriptionWithFormat(const SBFormat &format, return error; } - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); - if (!stop_locker.IsLocked()) + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); + if (!exe_ctx) { + llvm::consumeError(exe_ctx.takeError()); return error; + } - if (exe_ctx.HasThreadScope()) { - if (exe_ctx.GetThreadPtr()->DumpUsingFormat( + if (exe_ctx->HasThreadScope()) { + if (exe_ctx->GetThreadPtr()->DumpUsingFormat( strm, LLDB_INVALID_THREAD_ID, format.GetFormatEntrySP().get())) { return error; } @@ -1331,16 +1337,15 @@ SBError SBThread::GetDescriptionWithFormat(const SBFormat &format, SBThread SBThread::GetExtendedBacktraceThread(const char *type) { LLDB_INSTRUMENT_VA(this, type); - std::unique_lock lock; - Process::StopLocker stop_locker; - ExecutionContext exe_ctx(m_opaque_sp.get(), lock, stop_locker); + llvm::Expected exe_ctx = + GetCompleteExecutionContext(m_opaque_sp); SBThread sb_origin_thread; - if (stop_locker.IsLocked()) { - if (exe_ctx.HasThreadScope()) { - ThreadSP real_thread(exe_ctx.GetThreadSP()); + if (exe_ctx) { + if (exe_ctx->HasThreadScope()) { + ThreadSP real_thread(exe_ctx->GetThreadSP()); if (real_thread) { ConstString type_const(type); - Process *process = exe_ctx.GetProcessPtr(); + Process *process = exe_ctx->GetProcessPtr(); if (process) { SystemRuntime *runtime = process->GetSystemRuntime(); if (runtime) { @@ -1356,6 +1361,8 @@ SBThread SBThread::GetExtendedBacktraceThread(const char *type) { } } } + } else { + llvm::consumeError(exe_ctx.takeError()); } return sb_origin_thread; diff --git a/lldb/source/Target/ExecutionContext.cpp b/lldb/source/Target/ExecutionContext.cpp index bc9540314d03f..c56d3c949f56b 100644 --- a/lldb/source/Target/ExecutionContext.cpp +++ b/lldb/source/Target/ExecutionContext.cpp @@ -14,6 +14,7 @@ #include "lldb/Target/Thread.h" #include "lldb/Utility/LLDBLog.h" #include "lldb/Utility/State.h" +#include using namespace lldb_private; @@ -126,43 +127,51 @@ ExecutionContext::ExecutionContext(const ExecutionContextRef *exe_ctx_ref_ptr, } } -ExecutionContext::ExecutionContext( - const ExecutionContextRef *exe_ctx_ref_ptr, - std::unique_lock &api_lock, - ProcessRunLock::ProcessRunLocker &stop_locker, Status *status) - : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() { - auto set_status = [&](const char *msg) { - if (status) - *status = Status::FromErrorString(msg); - }; - - if (!exe_ctx_ref_ptr) { - set_status("ExecutionContext created with an empty ExecutionContextRef"); - return; - } +llvm::Expected +lldb_private::GetCompleteExecutionContext( + const lldb::ExecutionContextRefSP &exe_ctx_ref_ptr) { + return GetCompleteExecutionContext(exe_ctx_ref_ptr.get()); +} - m_target_sp = exe_ctx_ref_ptr->GetTargetSP(); - if (!m_target_sp) { - set_status("ExecutionContext created with a null target"); - return; - } +llvm::Expected +lldb_private::GetCompleteExecutionContext( + const ExecutionContextRef *exe_ctx_ref_ptr) { + if (!exe_ctx_ref_ptr) + return llvm::createStringError( + "ExecutionContext created with an empty ExecutionContextRef"); - api_lock = std::unique_lock(m_target_sp->GetAPIMutex()); - m_process_sp = exe_ctx_ref_ptr->GetProcessSP(); - if (!m_process_sp) { - set_status("ExecutionContext created with a null process"); - return; - } + lldb::TargetSP target_sp = exe_ctx_ref_ptr->GetTargetSP(); + if (!target_sp) + return llvm::createStringError( + "ExecutionContext created with a null target"); - if (!stop_locker.TryLock(&m_process_sp->GetRunLock())) { - const char *msg = "ExecutionContext created with a running process"; - set_status(msg); - LLDB_LOG(GetLog(LLDBLog::API), msg); - return; + auto api_lock = + std::unique_lock(target_sp->GetAPIMutex()); + + auto process_sp = exe_ctx_ref_ptr->GetProcessSP(); + if (!process_sp) + return llvm::createStringError( + "ExecutionContext created with a null process"); + + ProcessRunLock::ProcessRunLocker stop_locker; + if (!stop_locker.TryLock(&process_sp->GetRunLock())) { + auto *error_msg = + "Attempted to create an ExecutionContext with a running process"; + LLDB_LOG(GetLog(LLDBLog::API), error_msg); + return llvm::createStringError(error_msg); } - m_thread_sp = exe_ctx_ref_ptr->GetThreadSP(); - m_frame_sp = exe_ctx_ref_ptr->GetFrameSP(); + auto thread_sp = exe_ctx_ref_ptr->GetThreadSP(); + auto frame_sp = exe_ctx_ref_ptr->GetFrameSP(); + return CompleteExecutionContext(target_sp, process_sp, thread_sp, frame_sp, + std::move(api_lock), std::move(stop_locker)); +} + +std::unique_lock +CompleteExecutionContext::ClearAndGetAPILock() { + Clear(); + m_stop_locker = ProcessRunLock::ProcessRunLocker(); + return std::move(m_api_lock); } ExecutionContext::ExecutionContext(ExecutionContextScope *exe_scope_ptr) From ef8362bcdc17a3b34b58aa79cc04b9f2902ce9ca Mon Sep 17 00:00:00 2001 From: Felipe de Azevedo Piovezan Date: Fri, 8 Aug 2025 10:28:39 -0700 Subject: [PATCH 5/9] fixup! Rename CompleteExecutionContext -> StoppedExecutionContext --- lldb/include/lldb/Target/ExecutionContext.h | 34 ++-- lldb/source/API/SBFrame.cpp | 168 ++++++++++---------- lldb/source/API/SBThread.cpp | 150 ++++++++--------- lldb/source/Target/ExecutionContext.cpp | 16 +- 4 files changed, 184 insertions(+), 184 deletions(-) diff --git a/lldb/include/lldb/Target/ExecutionContext.h b/lldb/include/lldb/Target/ExecutionContext.h index f7e0b7c5e4d63..d79ab8a3910b1 100644 --- a/lldb/include/lldb/Target/ExecutionContext.h +++ b/lldb/include/lldb/Target/ExecutionContext.h @@ -562,14 +562,14 @@ class ExecutionContext { /// A wrapper class representing an execution context with non-null Target /// and Process pointers, a locked API mutex and a locked ProcessRunLock. /// The locks are private by design: to unlock them, destroy the -/// CompleteExecutionContext. -struct CompleteExecutionContext : ExecutionContext { - CompleteExecutionContext(lldb::TargetSP &target_sp, - lldb::ProcessSP &process_sp, - lldb::ThreadSP &thread_sp, - lldb::StackFrameSP &frame_sp, - std::unique_lock api_lock, - ProcessRunLock::ProcessRunLocker stop_locker) +/// StoppedExecutionContext. +struct StoppedExecutionContext : ExecutionContext { + StoppedExecutionContext(lldb::TargetSP &target_sp, + lldb::ProcessSP &process_sp, + lldb::ThreadSP &thread_sp, + lldb::StackFrameSP &frame_sp, + std::unique_lock api_lock, + ProcessRunLock::ProcessRunLocker stop_locker) : m_api_lock(std::move(api_lock)), m_stop_locker(std::move(stop_locker)) { assert(target_sp); assert(process_sp); @@ -583,11 +583,11 @@ struct CompleteExecutionContext : ExecutionContext { /// Transfers ownership of the locks from `other` to `this`, making `other` /// unusable. - CompleteExecutionContext(CompleteExecutionContext &&other) - : CompleteExecutionContext(other.m_target_sp, other.m_process_sp, - other.m_thread_sp, other.m_frame_sp, - std::move(other.m_api_lock), - std::move(other.m_stop_locker)) { + StoppedExecutionContext(StoppedExecutionContext &&other) + : StoppedExecutionContext(other.m_target_sp, other.m_process_sp, + other.m_thread_sp, other.m_frame_sp, + std::move(other.m_api_lock), + std::move(other.m_stop_locker)) { other.Clear(); } @@ -601,10 +601,10 @@ struct CompleteExecutionContext : ExecutionContext { ProcessRunLock::ProcessRunLocker m_stop_locker; }; -llvm::Expected -GetCompleteExecutionContext(const ExecutionContextRef *exe_ctx_ref_ptr); -llvm::Expected -GetCompleteExecutionContext(const lldb::ExecutionContextRefSP &exe_ctx_ref_ptr); +llvm::Expected +GetStoppedExecutionContext(const ExecutionContextRef *exe_ctx_ref_ptr); +llvm::Expected +GetStoppedExecutionContext(const lldb::ExecutionContextRefSP &exe_ctx_ref_ptr); } // namespace lldb_private diff --git a/lldb/source/API/SBFrame.cpp b/lldb/source/API/SBFrame.cpp index 2af8b0be5c0a5..f4dcab704e948 100644 --- a/lldb/source/API/SBFrame.cpp +++ b/lldb/source/API/SBFrame.cpp @@ -97,8 +97,8 @@ bool SBFrame::IsValid() const { } SBFrame::operator bool() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return false; @@ -112,8 +112,8 @@ SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const { SBSymbolContext sb_sym_ctx; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return sb_sym_ctx; @@ -129,8 +129,8 @@ SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const { SBModule SBFrame::GetModule() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBModule(); @@ -150,8 +150,8 @@ SBModule SBFrame::GetModule() const { SBCompileUnit SBFrame::GetCompileUnit() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBCompileUnit(); @@ -166,8 +166,8 @@ SBCompileUnit SBFrame::GetCompileUnit() const { SBFunction SBFrame::GetFunction() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBFunction(); @@ -181,8 +181,8 @@ SBFunction SBFrame::GetFunction() const { SBSymbol SBFrame::GetSymbol() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBSymbol(); @@ -196,8 +196,8 @@ SBSymbol SBFrame::GetSymbol() const { SBBlock SBFrame::GetBlock() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBBlock(); @@ -211,8 +211,8 @@ SBBlock SBFrame::GetBlock() const { SBBlock SBFrame::GetFrameBlock() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBBlock(); @@ -226,8 +226,8 @@ SBBlock SBFrame::GetFrameBlock() const { SBLineEntry SBFrame::GetLineEntry() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBLineEntry(); @@ -244,8 +244,8 @@ uint32_t SBFrame::GetFrameID() const { constexpr uint32_t error_frame_idx = UINT32_MAX; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return error_frame_idx; @@ -259,8 +259,8 @@ uint32_t SBFrame::GetFrameID() const { lldb::addr_t SBFrame::GetCFA() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return LLDB_INVALID_ADDRESS; @@ -275,8 +275,8 @@ addr_t SBFrame::GetPC() const { LLDB_INSTRUMENT_VA(this); addr_t addr = LLDB_INVALID_ADDRESS; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return addr; @@ -294,8 +294,8 @@ bool SBFrame::SetPC(addr_t new_pc) { LLDB_INSTRUMENT_VA(this, new_pc); constexpr bool error_ret_val = false; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return error_ret_val; @@ -311,8 +311,8 @@ bool SBFrame::SetPC(addr_t new_pc) { addr_t SBFrame::GetSP() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return LLDB_INVALID_ADDRESS; @@ -328,8 +328,8 @@ addr_t SBFrame::GetSP() const { addr_t SBFrame::GetFP() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return LLDB_INVALID_ADDRESS; @@ -345,8 +345,8 @@ addr_t SBFrame::GetFP() const { SBAddress SBFrame::GetPCAddress() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBAddress(); @@ -367,8 +367,8 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) { LLDB_INSTRUMENT_VA(this, var_path); SBValue sb_value; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return sb_value; @@ -391,8 +391,8 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path, return sb_value; } - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return sb_value; @@ -414,8 +414,8 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path, SBValue SBFrame::FindVariable(const char *name) { LLDB_INSTRUMENT_VA(this, name); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBValue(); @@ -440,8 +440,8 @@ SBValue SBFrame::FindVariable(const char *name, return sb_value; } - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return sb_value; @@ -458,8 +458,8 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type) { LLDB_INSTRUMENT_VA(this, name, value_type); SBValue value; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return value; @@ -484,8 +484,8 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type, } ValueObjectSP value_sp; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); @@ -611,8 +611,8 @@ bool SBFrame::operator!=(const SBFrame &rhs) const { SBThread SBFrame::GetThread() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBThread(); @@ -627,8 +627,8 @@ SBThread SBFrame::GetThread() const { const char *SBFrame::Disassemble() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return nullptr; @@ -645,8 +645,8 @@ SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics, LLDB_INSTRUMENT_VA(this, arguments, locals, statics, in_scope_only); SBValueList value_list; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return value_list; @@ -678,8 +678,8 @@ lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals, LLDB_INSTRUMENT_VA(this, arguments, locals, statics, in_scope_only, use_dynamic); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBValueList(); @@ -702,8 +702,8 @@ SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) { LLDB_INSTRUMENT_VA(this, options); SBValueList value_list; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBValueList(); @@ -809,8 +809,8 @@ SBValueList SBFrame::GetRegisters() { LLDB_INSTRUMENT_VA(this); SBValueList value_list; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBValueList(); @@ -839,8 +839,8 @@ SBValue SBFrame::FindRegister(const char *name) { SBValue result; ValueObjectSP value_sp; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBValue(); @@ -868,8 +868,8 @@ SBError SBFrame::GetDescriptionWithFormat(const SBFormat &format, SBStream &output) { Stream &strm = output.ref(); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) return Status::FromError(exe_ctx.takeError()); @@ -895,8 +895,8 @@ bool SBFrame::GetDescription(SBStream &description) { Stream &strm = description.ref(); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); strm.PutCString("Error: process is not stopped."); @@ -912,8 +912,8 @@ bool SBFrame::GetDescription(SBStream &description) { SBValue SBFrame::EvaluateExpression(const char *expr) { LLDB_INSTRUMENT_VA(this, expr); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return CreateProcessIsRunningExprEvalError(); @@ -945,8 +945,8 @@ SBFrame::EvaluateExpression(const char *expr, options.SetFetchDynamicValue(fetch_dynamic_value); options.SetUnwindOnError(true); options.SetIgnoreBreakpoints(true); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return CreateProcessIsRunningExprEvalError(); @@ -967,8 +967,8 @@ SBValue SBFrame::EvaluateExpression(const char *expr, LLDB_INSTRUMENT_VA(this, expr, fetch_dynamic_value, unwind_on_error); SBExpressionOptions options; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return CreateProcessIsRunningExprEvalError(); @@ -1010,8 +1010,8 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr, ValueObjectSP expr_value_sp; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); expr_result = CreateProcessIsRunningExprEvalError(); @@ -1060,8 +1060,8 @@ SBStructuredData SBFrame::GetLanguageSpecificData() const { LLDB_INSTRUMENT_VA(this); SBStructuredData sb_data; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return sb_data; @@ -1084,8 +1084,8 @@ bool SBFrame::IsInlined() { bool SBFrame::IsInlined() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return false; @@ -1105,8 +1105,8 @@ bool SBFrame::IsArtificial() { bool SBFrame::IsArtificial() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return false; @@ -1121,8 +1121,8 @@ bool SBFrame::IsArtificial() const { bool SBFrame::IsHidden() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return false; @@ -1143,8 +1143,8 @@ const char *SBFrame::GetFunctionName() { lldb::LanguageType SBFrame::GuessLanguage() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return eLanguageTypeUnknown; @@ -1158,8 +1158,8 @@ lldb::LanguageType SBFrame::GuessLanguage() const { const char *SBFrame::GetFunctionName() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return nullptr; @@ -1173,8 +1173,8 @@ const char *SBFrame::GetFunctionName() const { const char *SBFrame::GetDisplayFunctionName() { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return nullptr; diff --git a/lldb/source/API/SBThread.cpp b/lldb/source/API/SBThread.cpp index bc0d0e9b55ee5..28ef1729f31fe 100644 --- a/lldb/source/API/SBThread.cpp +++ b/lldb/source/API/SBThread.cpp @@ -90,8 +90,8 @@ lldb::SBQueue SBThread::GetQueue() const { SBQueue sb_queue; QueueSP queue_sp; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBQueue(); @@ -116,8 +116,8 @@ SBThread::operator bool() const { if (!m_opaque_sp) return false; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return false; @@ -136,8 +136,8 @@ StopReason SBThread::GetStopReason() { LLDB_INSTRUMENT_VA(this); StopReason reason = eStopReasonInvalid; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return reason; @@ -152,8 +152,8 @@ StopReason SBThread::GetStopReason() { size_t SBThread::GetStopReasonDataCount() { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (exe_ctx) { if (exe_ctx->HasThreadScope()) { StopInfoSP stop_info_sp = exe_ctx->GetThreadPtr()->GetStopInfo(); @@ -214,8 +214,8 @@ size_t SBThread::GetStopReasonDataCount() { uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) { LLDB_INSTRUMENT_VA(this, idx); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (exe_ctx) { if (exe_ctx->HasThreadScope()) { Thread *thread = exe_ctx->GetThreadPtr(); @@ -290,8 +290,8 @@ bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) { Stream &strm = stream.ref(); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return false; @@ -316,8 +316,8 @@ SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) { SBThreadCollection threads; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBThreadCollection(); @@ -344,8 +344,8 @@ size_t SBThread::GetStopDescription(char *dst, size_t dst_len) { if (dst) *dst = 0; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return 0; @@ -370,8 +370,8 @@ SBValue SBThread::GetStopReturnValue() { LLDB_INSTRUMENT_VA(this); ValueObjectSP return_valobj_sp; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBValue(); @@ -412,8 +412,8 @@ uint32_t SBThread::GetIndexID() const { const char *SBThread::GetName() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return nullptr; @@ -428,8 +428,8 @@ const char *SBThread::GetName() const { const char *SBThread::GetQueueName() const { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return nullptr; @@ -445,8 +445,8 @@ lldb::queue_id_t SBThread::GetQueueID() const { LLDB_INSTRUMENT_VA(this); queue_id_t id = LLDB_INVALID_QUEUE_ID; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return id; @@ -463,8 +463,8 @@ bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) { LLDB_INSTRUMENT_VA(this, path, strm); bool success = false; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (exe_ctx) { if (exe_ctx->HasThreadScope()) { Thread *thread = exe_ctx->GetThreadPtr(); @@ -507,7 +507,7 @@ bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) { return success; } -static Status ResumeNewPlan(CompleteExecutionContext exe_ctx, +static Status ResumeNewPlan(StoppedExecutionContext exe_ctx, ThreadPlan *new_plan) { Thread *thread = exe_ctx.GetThreadPtr(); if (!thread) @@ -542,8 +542,8 @@ void SBThread::StepOver(lldb::RunMode stop_other_threads) { void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) { LLDB_INSTRUMENT_VA(this, stop_other_threads, error); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { error = Status::FromError(exe_ctx.takeError()); return; @@ -593,8 +593,8 @@ void SBThread::StepInto(const char *target_name, uint32_t end_line, SBError &error, lldb::RunMode stop_other_threads) { LLDB_INSTRUMENT_VA(this, target_name, end_line, error, stop_other_threads); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { error = Status::FromError(exe_ctx.takeError()); return; @@ -654,8 +654,8 @@ void SBThread::StepOut() { void SBThread::StepOut(SBError &error) { LLDB_INSTRUMENT_VA(this, error); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { error = Status::FromError(exe_ctx.takeError()); return; @@ -693,8 +693,8 @@ void SBThread::StepOutOfFrame(SBFrame &sb_frame) { void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) { LLDB_INSTRUMENT_VA(this, sb_frame, error); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { error = Status::FromError(exe_ctx.takeError()); return; @@ -741,8 +741,8 @@ void SBThread::StepInstruction(bool step_over) { void SBThread::StepInstruction(bool step_over, SBError &error) { LLDB_INSTRUMENT_VA(this, step_over, error); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { error = Status::FromError(exe_ctx.takeError()); return; @@ -774,8 +774,8 @@ void SBThread::RunToAddress(lldb::addr_t addr) { void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) { LLDB_INSTRUMENT_VA(this, addr, error); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { error = Status::FromError(exe_ctx.takeError()); return; @@ -810,8 +810,8 @@ SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame, SBError sb_error; char path[PATH_MAX]; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) return Status::FromError(exe_ctx.takeError()); @@ -946,8 +946,8 @@ SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name, SBError error; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) return Status::FromError(exe_ctx.takeError()); @@ -984,8 +984,8 @@ SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) { SBError sb_error; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) return Status::FromError(exe_ctx.takeError()); @@ -1006,8 +1006,8 @@ SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) { SBError sb_error; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) return Status::FromError(exe_ctx.takeError()); @@ -1025,8 +1025,8 @@ SBError SBThread::UnwindInnermostExpression() { SBError sb_error; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) return Status::FromError(exe_ctx.takeError()); @@ -1050,8 +1050,8 @@ bool SBThread::Suspend() { bool SBThread::Suspend(SBError &error) { LLDB_INSTRUMENT_VA(this, error); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { error = Status::FromError(exe_ctx.takeError()); return false; @@ -1076,8 +1076,8 @@ bool SBThread::Resume() { bool SBThread::Resume(SBError &error) { LLDB_INSTRUMENT_VA(this, error); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); error = Status::FromErrorString("process is running"); @@ -1097,8 +1097,8 @@ bool SBThread::Resume(SBError &error) { bool SBThread::IsSuspended() { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return false; @@ -1112,8 +1112,8 @@ bool SBThread::IsSuspended() { bool SBThread::IsStopped() { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return false; @@ -1128,8 +1128,8 @@ SBProcess SBThread::GetProcess() { LLDB_INSTRUMENT_VA(this); SBProcess sb_process; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBProcess(); @@ -1147,8 +1147,8 @@ SBProcess SBThread::GetProcess() { uint32_t SBThread::GetNumFrames() { LLDB_INSTRUMENT_VA(this); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return 0; @@ -1164,8 +1164,8 @@ SBFrame SBThread::GetFrameAtIndex(uint32_t idx) { LLDB_INSTRUMENT_VA(this, idx); SBFrame sb_frame; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBFrame(); @@ -1183,8 +1183,8 @@ lldb::SBFrame SBThread::GetSelectedFrame() { LLDB_INSTRUMENT_VA(this); SBFrame sb_frame; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBFrame(); @@ -1204,8 +1204,8 @@ lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) { SBFrame sb_frame; StackFrameSP frame_sp; - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return SBFrame(); @@ -1260,8 +1260,8 @@ bool SBThread::GetStatus(SBStream &status) const { Stream &strm = status.ref(); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return false; @@ -1287,8 +1287,8 @@ bool SBThread::GetDescription(SBStream &description, bool stop_format) const { Stream &strm = description.ref(); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return false; @@ -1313,8 +1313,8 @@ SBError SBThread::GetDescriptionWithFormat(const SBFormat &format, return error; } - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { llvm::consumeError(exe_ctx.takeError()); return error; @@ -1337,8 +1337,8 @@ SBError SBThread::GetDescriptionWithFormat(const SBFormat &format, SBThread SBThread::GetExtendedBacktraceThread(const char *type) { LLDB_INSTRUMENT_VA(this, type); - llvm::Expected exe_ctx = - GetCompleteExecutionContext(m_opaque_sp); + llvm::Expected exe_ctx = + GetStoppedExecutionContext(m_opaque_sp); SBThread sb_origin_thread; if (exe_ctx) { if (exe_ctx->HasThreadScope()) { diff --git a/lldb/source/Target/ExecutionContext.cpp b/lldb/source/Target/ExecutionContext.cpp index c56d3c949f56b..d2bc4b3cfd99c 100644 --- a/lldb/source/Target/ExecutionContext.cpp +++ b/lldb/source/Target/ExecutionContext.cpp @@ -127,14 +127,14 @@ ExecutionContext::ExecutionContext(const ExecutionContextRef *exe_ctx_ref_ptr, } } -llvm::Expected -lldb_private::GetCompleteExecutionContext( +llvm::Expected +lldb_private::GetStoppedExecutionContext( const lldb::ExecutionContextRefSP &exe_ctx_ref_ptr) { - return GetCompleteExecutionContext(exe_ctx_ref_ptr.get()); + return GetStoppedExecutionContext(exe_ctx_ref_ptr.get()); } -llvm::Expected -lldb_private::GetCompleteExecutionContext( +llvm::Expected +lldb_private::GetStoppedExecutionContext( const ExecutionContextRef *exe_ctx_ref_ptr) { if (!exe_ctx_ref_ptr) return llvm::createStringError( @@ -163,12 +163,12 @@ lldb_private::GetCompleteExecutionContext( auto thread_sp = exe_ctx_ref_ptr->GetThreadSP(); auto frame_sp = exe_ctx_ref_ptr->GetFrameSP(); - return CompleteExecutionContext(target_sp, process_sp, thread_sp, frame_sp, - std::move(api_lock), std::move(stop_locker)); + return StoppedExecutionContext(target_sp, process_sp, thread_sp, frame_sp, + std::move(api_lock), std::move(stop_locker)); } std::unique_lock -CompleteExecutionContext::ClearAndGetAPILock() { +StoppedExecutionContext::ClearAndGetAPILock() { Clear(); m_stop_locker = ProcessRunLock::ProcessRunLocker(); return std::move(m_api_lock); From 415afe07bd04cf79d09fca6bb8410497f682f6e7 Mon Sep 17 00:00:00 2001 From: Felipe de Azevedo Piovezan Date: Fri, 8 Aug 2025 10:46:11 -0700 Subject: [PATCH 6/9] fixup! Move logging to call sites --- lldb/source/API/SBThread.cpp | 50 ++++++++++++------------- lldb/source/Target/ExecutionContext.cpp | 9 ++--- 2 files changed, 28 insertions(+), 31 deletions(-) diff --git a/lldb/source/API/SBThread.cpp b/lldb/source/API/SBThread.cpp index 28ef1729f31fe..cc69b1ee4286d 100644 --- a/lldb/source/API/SBThread.cpp +++ b/lldb/source/API/SBThread.cpp @@ -93,7 +93,7 @@ lldb::SBQueue SBThread::GetQueue() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBQueue(); } @@ -119,7 +119,7 @@ SBThread::operator bool() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return false; } @@ -139,7 +139,7 @@ StopReason SBThread::GetStopReason() { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return reason; } @@ -205,7 +205,7 @@ size_t SBThread::GetStopReasonDataCount() { } } } else { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return 0; } return 0; @@ -279,7 +279,7 @@ uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) { } } } else { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return 0; } return 0; @@ -293,7 +293,7 @@ bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return false; } @@ -319,7 +319,7 @@ SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBThreadCollection(); } @@ -347,7 +347,7 @@ size_t SBThread::GetStopDescription(char *dst, size_t dst_len) { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return 0; } @@ -373,7 +373,7 @@ SBValue SBThread::GetStopReturnValue() { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBValue(); } @@ -415,7 +415,7 @@ const char *SBThread::GetName() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return nullptr; } @@ -431,7 +431,7 @@ const char *SBThread::GetQueueName() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return nullptr; } @@ -448,7 +448,7 @@ lldb::queue_id_t SBThread::GetQueueID() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return id; } @@ -500,7 +500,7 @@ bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) { } } } else { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return success; } @@ -1079,7 +1079,7 @@ bool SBThread::Resume(SBError &error) { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); error = Status::FromErrorString("process is running"); return false; } @@ -1100,7 +1100,7 @@ bool SBThread::IsSuspended() { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return false; } @@ -1115,7 +1115,7 @@ bool SBThread::IsStopped() { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return false; } @@ -1131,7 +1131,7 @@ SBProcess SBThread::GetProcess() { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBProcess(); } @@ -1150,7 +1150,7 @@ uint32_t SBThread::GetNumFrames() { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return 0; } @@ -1167,7 +1167,7 @@ SBFrame SBThread::GetFrameAtIndex(uint32_t idx) { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBFrame(); } @@ -1186,7 +1186,7 @@ lldb::SBFrame SBThread::GetSelectedFrame() { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBFrame(); } @@ -1207,7 +1207,7 @@ lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBFrame(); } @@ -1263,7 +1263,7 @@ bool SBThread::GetStatus(SBStream &status) const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return false; } @@ -1290,7 +1290,7 @@ bool SBThread::GetDescription(SBStream &description, bool stop_format) const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return false; } @@ -1316,7 +1316,7 @@ SBError SBThread::GetDescriptionWithFormat(const SBFormat &format, llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return error; } @@ -1362,7 +1362,7 @@ SBThread SBThread::GetExtendedBacktraceThread(const char *type) { } } } else { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); } return sb_origin_thread; diff --git a/lldb/source/Target/ExecutionContext.cpp b/lldb/source/Target/ExecutionContext.cpp index d2bc4b3cfd99c..831521ce6a92d 100644 --- a/lldb/source/Target/ExecutionContext.cpp +++ b/lldb/source/Target/ExecutionContext.cpp @@ -154,12 +154,9 @@ lldb_private::GetStoppedExecutionContext( "ExecutionContext created with a null process"); ProcessRunLock::ProcessRunLocker stop_locker; - if (!stop_locker.TryLock(&process_sp->GetRunLock())) { - auto *error_msg = - "Attempted to create an ExecutionContext with a running process"; - LLDB_LOG(GetLog(LLDBLog::API), error_msg); - return llvm::createStringError(error_msg); - } + if (!stop_locker.TryLock(&process_sp->GetRunLock())) + return llvm::createStringError( + "Attempted to create an ExecutionContext with a running process"); auto thread_sp = exe_ctx_ref_ptr->GetThreadSP(); auto frame_sp = exe_ctx_ref_ptr->GetFrameSP(); From ce9225bd346784d3a0813b917788861c0c48494d Mon Sep 17 00:00:00 2001 From: Felipe de Azevedo Piovezan Date: Fri, 8 Aug 2025 10:53:30 -0700 Subject: [PATCH 7/9] fixup! Move logging to call sites --- lldb/source/API/SBFrame.cpp | 82 ++++++++++++++++++------------------- 1 file changed, 41 insertions(+), 41 deletions(-) diff --git a/lldb/source/API/SBFrame.cpp b/lldb/source/API/SBFrame.cpp index f4dcab704e948..b12cfceacd75d 100644 --- a/lldb/source/API/SBFrame.cpp +++ b/lldb/source/API/SBFrame.cpp @@ -100,7 +100,7 @@ SBFrame::operator bool() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return false; } @@ -115,7 +115,7 @@ SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return sb_sym_ctx; } @@ -132,7 +132,7 @@ SBModule SBFrame::GetModule() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBModule(); } @@ -153,7 +153,7 @@ SBCompileUnit SBFrame::GetCompileUnit() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBCompileUnit(); } @@ -169,7 +169,7 @@ SBFunction SBFrame::GetFunction() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBFunction(); } @@ -184,7 +184,7 @@ SBSymbol SBFrame::GetSymbol() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBSymbol(); } @@ -199,7 +199,7 @@ SBBlock SBFrame::GetBlock() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBBlock(); } @@ -214,7 +214,7 @@ SBBlock SBFrame::GetFrameBlock() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBBlock(); } @@ -229,7 +229,7 @@ SBLineEntry SBFrame::GetLineEntry() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBLineEntry(); } @@ -247,7 +247,7 @@ uint32_t SBFrame::GetFrameID() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return error_frame_idx; } @@ -262,7 +262,7 @@ lldb::addr_t SBFrame::GetCFA() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return LLDB_INVALID_ADDRESS; } @@ -278,7 +278,7 @@ addr_t SBFrame::GetPC() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return addr; } @@ -297,7 +297,7 @@ bool SBFrame::SetPC(addr_t new_pc) { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return error_ret_val; } @@ -314,7 +314,7 @@ addr_t SBFrame::GetSP() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return LLDB_INVALID_ADDRESS; } @@ -331,7 +331,7 @@ addr_t SBFrame::GetFP() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return LLDB_INVALID_ADDRESS; } @@ -348,7 +348,7 @@ SBAddress SBFrame::GetPCAddress() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBAddress(); } @@ -370,7 +370,7 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return sb_value; } @@ -394,7 +394,7 @@ lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path, llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return sb_value; } @@ -417,7 +417,7 @@ SBValue SBFrame::FindVariable(const char *name) { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBValue(); } @@ -443,7 +443,7 @@ SBValue SBFrame::FindVariable(const char *name, llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return sb_value; } @@ -461,7 +461,7 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type) { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return value; } @@ -488,7 +488,7 @@ SBValue SBFrame::FindValue(const char *name, ValueType value_type, GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return value_sp; } else { Target *target = exe_ctx->GetTargetPtr(); @@ -614,7 +614,7 @@ SBThread SBFrame::GetThread() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBThread(); } @@ -630,7 +630,7 @@ const char *SBFrame::Disassemble() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return nullptr; } @@ -648,7 +648,7 @@ SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics, llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return value_list; } @@ -681,7 +681,7 @@ lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals, llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBValueList(); } @@ -705,7 +705,7 @@ SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBValueList(); } else { const bool statics = options.GetIncludeStatics(); @@ -812,7 +812,7 @@ SBValueList SBFrame::GetRegisters() { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBValueList(); } else { Target *target = exe_ctx->GetTargetPtr(); @@ -842,7 +842,7 @@ SBValue SBFrame::FindRegister(const char *name) { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return SBValue(); } else { Target *target = exe_ctx->GetTargetPtr(); @@ -898,7 +898,7 @@ bool SBFrame::GetDescription(SBStream &description) { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); strm.PutCString("Error: process is not stopped."); return true; } @@ -915,7 +915,7 @@ SBValue SBFrame::EvaluateExpression(const char *expr) { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return CreateProcessIsRunningExprEvalError(); } @@ -948,7 +948,7 @@ SBFrame::EvaluateExpression(const char *expr, llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return CreateProcessIsRunningExprEvalError(); } @@ -970,7 +970,7 @@ SBValue SBFrame::EvaluateExpression(const char *expr, llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return CreateProcessIsRunningExprEvalError(); } @@ -1013,7 +1013,7 @@ lldb::SBValue SBFrame::EvaluateExpression(const char *expr, llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); expr_result = CreateProcessIsRunningExprEvalError(); } else { Target *target = exe_ctx->GetTargetPtr(); @@ -1063,7 +1063,7 @@ SBStructuredData SBFrame::GetLanguageSpecificData() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return sb_data; } StackFrame *frame = exe_ctx->GetFramePtr(); @@ -1087,7 +1087,7 @@ bool SBFrame::IsInlined() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return false; } @@ -1108,7 +1108,7 @@ bool SBFrame::IsArtificial() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return false; } @@ -1124,7 +1124,7 @@ bool SBFrame::IsHidden() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return false; } @@ -1146,7 +1146,7 @@ lldb::LanguageType SBFrame::GuessLanguage() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return eLanguageTypeUnknown; } @@ -1161,7 +1161,7 @@ const char *SBFrame::GetFunctionName() const { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return nullptr; } @@ -1176,7 +1176,7 @@ const char *SBFrame::GetDisplayFunctionName() { llvm::Expected exe_ctx = GetStoppedExecutionContext(m_opaque_sp); if (!exe_ctx) { - llvm::consumeError(exe_ctx.takeError()); + LLDB_LOG_ERROR(GetLog(LLDBLog::API), exe_ctx.takeError(), "{0}"); return nullptr; } From 12f7a574b518b5a8a65b79db2aa1f3b250bed125 Mon Sep 17 00:00:00 2001 From: Felipe de Azevedo Piovezan Date: Fri, 8 Aug 2025 11:24:58 -0700 Subject: [PATCH 8/9] fixup! Rename ClearAndGetAPILock to Destroy --- lldb/include/lldb/Target/ExecutionContext.h | 2 +- lldb/source/API/SBThread.cpp | 3 +-- lldb/source/Target/ExecutionContext.cpp | 3 +-- 3 files changed, 3 insertions(+), 5 deletions(-) diff --git a/lldb/include/lldb/Target/ExecutionContext.h b/lldb/include/lldb/Target/ExecutionContext.h index d79ab8a3910b1..a0b064a51cec4 100644 --- a/lldb/include/lldb/Target/ExecutionContext.h +++ b/lldb/include/lldb/Target/ExecutionContext.h @@ -594,7 +594,7 @@ struct StoppedExecutionContext : ExecutionContext { /// Clears this context, unlocking the ProcessRunLock and returning the /// locked API lock. Like after a move operation, this object is no longer /// usable. - [[nodiscard]] std::unique_lock ClearAndGetAPILock(); + [[nodiscard]] std::unique_lock Destroy(); private: std::unique_lock m_api_lock; diff --git a/lldb/source/API/SBThread.cpp b/lldb/source/API/SBThread.cpp index cc69b1ee4286d..b07611d388fb6 100644 --- a/lldb/source/API/SBThread.cpp +++ b/lldb/source/API/SBThread.cpp @@ -525,8 +525,7 @@ static Status ResumeNewPlan(StoppedExecutionContext exe_ctx, process->GetThreadList().SetSelectedThreadByID(thread->GetID()); // Release the run lock but keep the API lock. - std::unique_lock api_lock = - exe_ctx.ClearAndGetAPILock(); + std::unique_lock api_lock = exe_ctx.Destroy(); if (process->GetTarget().GetDebugger().GetAsyncExecution()) return process->Resume(); return process->ResumeSynchronous(nullptr); diff --git a/lldb/source/Target/ExecutionContext.cpp b/lldb/source/Target/ExecutionContext.cpp index 831521ce6a92d..fe0e64c841cc1 100644 --- a/lldb/source/Target/ExecutionContext.cpp +++ b/lldb/source/Target/ExecutionContext.cpp @@ -164,8 +164,7 @@ lldb_private::GetStoppedExecutionContext( std::move(api_lock), std::move(stop_locker)); } -std::unique_lock -StoppedExecutionContext::ClearAndGetAPILock() { +std::unique_lock StoppedExecutionContext::Destroy() { Clear(); m_stop_locker = ProcessRunLock::ProcessRunLocker(); return std::move(m_api_lock); From b1889dfd7754dc1c910744850017c639c5c6ddc9 Mon Sep 17 00:00:00 2001 From: Felipe de Azevedo Piovezan Date: Fri, 8 Aug 2025 11:25:17 -0700 Subject: [PATCH 9/9] fixup! Fix lowercase in error message --- lldb/source/Target/ExecutionContext.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lldb/source/Target/ExecutionContext.cpp b/lldb/source/Target/ExecutionContext.cpp index fe0e64c841cc1..7dc847e097bf8 100644 --- a/lldb/source/Target/ExecutionContext.cpp +++ b/lldb/source/Target/ExecutionContext.cpp @@ -156,7 +156,7 @@ lldb_private::GetStoppedExecutionContext( ProcessRunLock::ProcessRunLocker stop_locker; if (!stop_locker.TryLock(&process_sp->GetRunLock())) return llvm::createStringError( - "Attempted to create an ExecutionContext with a running process"); + "attempted to create an ExecutionContext with a running process"); auto thread_sp = exe_ctx_ref_ptr->GetThreadSP(); auto frame_sp = exe_ctx_ref_ptr->GetFrameSP();