diff options
| author | Greg Clayton <gclayton@apple.com> | 2012-02-17 07:49:44 +0000 |
|---|---|---|
| committer | Greg Clayton <gclayton@apple.com> | 2012-02-17 07:49:44 +0000 |
| commit | cc4d0146b4f5edf4cebf06697f52959409136591 (patch) | |
| tree | 9aa64046056d513eb1e506b126f89584e8ef9aee | |
| parent | dd19169988da4fca1149852c67019e448f13c75f (diff) | |
| download | bcm5719-llvm-cc4d0146b4f5edf4cebf06697f52959409136591.tar.gz bcm5719-llvm-cc4d0146b4f5edf4cebf06697f52959409136591.zip | |
This checking is part one of trying to add some threading safety to our
internals. The first part of this is to use a new class:
lldb_private::ExecutionContextRef
This class holds onto weak pointers to the target, process, thread and frame
and it also contains the thread ID and frame Stack ID in case the thread and
frame objects go away and come back as new objects that represent the same
logical thread/frame.
ExecutionContextRef objcets have accessors to access shared pointers for
the target, process, thread and frame which might return NULL if the backing
object is no longer available. This allows for references to persistent program
state without needing to hold a shared pointer to each object and potentially
keeping that object around for longer than it needs to be.
You can also "Lock" and ExecutionContextRef (which contains weak pointers)
object into an ExecutionContext (which contains strong, or shared pointers)
with code like
ExecutionContext exe_ctx (my_obj->GetExectionContextRef().Lock());
llvm-svn: 150801
23 files changed, 1289 insertions, 730 deletions
diff --git a/lldb/include/lldb/Core/FormatNavigator.h b/lldb/include/lldb/Core/FormatNavigator.h index 4e80ec6d0a7..a7390a85275 100644 --- a/lldb/include/lldb/Core/FormatNavigator.h +++ b/lldb/include/lldb/Core/FormatNavigator.h @@ -487,8 +487,7 @@ protected: log->Printf("going to an Objective-C dynamic scanning"); if (!process_sp) return false; - Process* process = process_sp.get(); - ObjCLanguageRuntime* runtime = process->GetObjCLanguageRuntime(); + ObjCLanguageRuntime* runtime = process_sp->GetObjCLanguageRuntime(); if (runtime == NULL) { if (log) @@ -640,8 +639,7 @@ protected: return false; if (log) log->Printf("this is an ObjC 'id', let's do dynamic search"); - Process* process = process_sp.get(); - ObjCLanguageRuntime* runtime = process->GetObjCLanguageRuntime(); + ObjCLanguageRuntime* runtime = process_sp->GetObjCLanguageRuntime(); if (runtime == NULL) { if (log) @@ -751,7 +749,7 @@ protected: } } - lldb::ProcessSP process_sp = valobj.GetUpdatePoint().GetProcessSP(); + lldb::ProcessSP process_sp = valobj.GetProcessSP(); if (use_dynamic != lldb::eNoDynamicValues && ClangASTType::GetMinimumLanguage(valobj.GetClangAST(), valobj.GetClangType()) == lldb::eLanguageTypeObjC) diff --git a/lldb/include/lldb/Core/ValueObject.h b/lldb/include/lldb/Core/ValueObject.h index 90161a3e4d5..566d9e59ddf 100644 --- a/lldb/include/lldb/Core/ValueObject.h +++ b/lldb/include/lldb/Core/ValueObject.h @@ -338,7 +338,7 @@ public: }; - class EvaluationPoint : public ExecutionContextScope + class EvaluationPoint { public: @@ -350,25 +350,19 @@ public: ~EvaluationPoint (); - const lldb::TargetSP & - GetTargetSP () const + const ExecutionContextRef & + GetExecutionContextRef() const { - return m_target_sp; + return m_exe_ctx_ref; } - - const lldb::ProcessSP & - GetProcessSP () const - { - return m_process_sp; - } - + // Set the EvaluationPoint to the values in exe_scope, // Return true if the Evaluation Point changed. // Since the ExecutionContextScope is always going to be valid currently, // the Updated Context will also always be valid. - bool - SetContext (ExecutionContextScope *exe_scope); +// bool +// SetContext (ExecutionContextScope *exe_scope); void SetIsConstant () @@ -442,39 +436,14 @@ public: } - // If this EvaluationPoint is created without a target, then we could have it - // hand out a NULL ExecutionContextScope. But then everybody would have to check that before - // calling through it, which is annoying. So instead, we make the EvaluationPoint BE an - // ExecutionContextScope, and it hands out the right things. - virtual Target *CalculateTarget (); - - virtual Process *CalculateProcess (); - - virtual Thread *CalculateThread (); - - virtual StackFrame *CalculateStackFrame (); - - virtual void CalculateExecutionContext (ExecutionContext &exe_ctx); - private: bool - SyncWithProcessState () - { - ExecutionContextScope *exe_scope; - return SyncWithProcessState(exe_scope); - } - - bool - SyncWithProcessState (ExecutionContextScope *&exe_scope); + SyncWithProcessState (); - bool m_needs_update; - bool m_first_update; - - lldb::TargetSP m_target_sp; - lldb::ProcessSP m_process_sp; - lldb::user_id_t m_thread_id; - StackID m_stack_id; - ProcessModID m_mod_id; // This is the stop id when this ValueObject was last evaluated. + ProcessModID m_mod_id; // This is the stop id when this ValueObject was last evaluated. + ExecutionContextRef m_exe_ctx_ref; + bool m_needs_update; + bool m_first_update; }; const EvaluationPoint & @@ -489,12 +458,36 @@ public: return m_update_point; } - ExecutionContextScope * - GetExecutionContextScope () + const ExecutionContextRef & + GetExecutionContextRef() const { - return &m_update_point; + return m_update_point.GetExecutionContextRef(); } - + + lldb::TargetSP + GetTargetSP() const + { + return m_update_point.GetExecutionContextRef().GetTargetSP(); + } + + lldb::ProcessSP + GetProcessSP() const + { + return m_update_point.GetExecutionContextRef().GetProcessSP(); + } + + lldb::ThreadSP + GetThreadSP() const + { + return m_update_point.GetExecutionContextRef().GetThreadSP(); + } + + lldb::StackFrameSP + GetFrameSP() const + { + return m_update_point.GetExecutionContextRef().GetFrameSP(); + } + void SetNeedsUpdate (); diff --git a/lldb/include/lldb/Target/ExecutionContext.h b/lldb/include/lldb/Target/ExecutionContext.h index 4022fee2792..37162091c8e 100644 --- a/lldb/include/lldb/Target/ExecutionContext.h +++ b/lldb/include/lldb/Target/ExecutionContext.h @@ -12,9 +12,122 @@ #define liblldb_ExecutionContext_h_ #include "lldb/lldb-private.h" +#include "lldb/Target/StackID.h" namespace lldb_private { +class ExecutionContextRef +{ +public: + //------------------------------------------------------------------ + /// Default Constructor. + /// + /// Initialize with NULL process and thread, and invalid frame + /// index. + //------------------------------------------------------------------ + ExecutionContextRef(); + + ExecutionContextRef (const ExecutionContextRef &rhs); + + ExecutionContextRef (const ExecutionContext *exe_ctx); + + ExecutionContextRef (const ExecutionContext &exe_ctx); + + ExecutionContextRef & + operator =(const ExecutionContextRef &rhs); + + ExecutionContextRef & + operator =(const ExecutionContext &exe_ctx); + + // Init using the target and all the selected items inside of it + // (the process and its selected thread, and the thread's selected + // frame). If there is no selected thread, default to the first thread + // If there is no selected frame, default to the first frame. + ExecutionContextRef (Target *target, bool adopt_selected); + + ExecutionContextRef (ExecutionContextScope *exe_scope); + + ExecutionContextRef (ExecutionContextScope &exe_scope); + + ~ExecutionContextRef(); + //------------------------------------------------------------------ + /// Clear the object's state. + /// + /// Sets the process and thread to NULL, and the frame index to an + /// invalid value. + //------------------------------------------------------------------ + void + Clear (); + + void + SetTargetSP (const lldb::TargetSP &target_sp); + + void + SetProcessSP (const lldb::ProcessSP &process_sp); + + void + SetThreadSP (const lldb::ThreadSP &thread_sp); + + void + SetFrameSP (const lldb::StackFrameSP &frame_sp); + + void + SetTargetPtr (Target* target, bool adopt_selected); + + void + SetProcessPtr (Process *process); + + void + SetThreadPtr (Thread *thread); + + void + SetFramePtr (StackFrame *frame); + + lldb::TargetSP + GetTargetSP () const + { + return m_target_wp.lock(); + } + + lldb::ProcessSP + GetProcessSP () const + { + return m_process_wp.lock(); + } + + lldb::ThreadSP + GetThreadSP () const; + + lldb::StackFrameSP + GetFrameSP () const; + + ExecutionContext + Lock () const; + + bool + HasThreadRef () const + { + return m_tid != LLDB_INVALID_THREAD_ID; + } + + bool + HasFrameRef () const + { + return m_stack_id.IsValid(); + } + +protected: + //------------------------------------------------------------------ + // Member variables + //------------------------------------------------------------------ + lldb::TargetWP m_target_wp; ///< The target that owns the process/thread/frame + lldb::ProcessWP m_process_wp; ///< The process that owns the thread/frame + mutable lldb::ThreadWP m_thread_wp; ///< The thread that owns the frame + mutable lldb::StackFrameWP m_frame_wp; ///< The stack frame in thread. + lldb::tid_t m_tid; + StackID m_stack_id; +}; + //---------------------------------------------------------------------- /// @class ExecutionContext ExecutionContext.h "lldb/Target/ExecutionContext.h" /// @brief A class that contains an execution context. @@ -41,10 +154,27 @@ public: ExecutionContext (const ExecutionContext &rhs); + ExecutionContext (Target* t, bool fill_current_process_thread_frame = true); + + ExecutionContext (const lldb::TargetSP &target_sp, bool get_process); + ExecutionContext (const lldb::ProcessSP &process_sp); + ExecutionContext (const lldb::ThreadSP &thread_sp); + ExecutionContext (const lldb::StackFrameSP &frame_sp); + ExecutionContext (const ExecutionContextRef &exe_ctx_ref); + ExecutionContext (const ExecutionContextRef *exe_ctx_ref); + ExecutionContext (ExecutionContextScope *exe_scope); + ExecutionContext (ExecutionContextScope &exe_scope); + + ExecutionContext & operator =(const ExecutionContext &rhs); - ExecutionContext (Target* t, bool fill_current_process_thread_frame = true); + bool + operator ==(const ExecutionContext &rhs) const; + + bool + operator !=(const ExecutionContext &rhs) const; + //------------------------------------------------------------------ /// Construct with process, thread, and frame index. /// @@ -64,10 +194,6 @@ public: StackFrame * frame = NULL); - ExecutionContext (ExecutionContextScope *exe_scope); - - ExecutionContext (ExecutionContextScope &exe_scope); - ~ExecutionContext(); //------------------------------------------------------------------ /// Clear the object's state. @@ -84,6 +210,9 @@ public: ExecutionContextScope * GetBestExecutionContextScope () const; + uint32_t + GetAddressByteSize() const; + Target * GetTargetPtr () const; @@ -115,25 +244,25 @@ public: GetFrameRef () const; const lldb::TargetSP & - GetTargetSP () + GetTargetSP () const { return m_target_sp; } const lldb::ProcessSP & - GetProcessSP () + GetProcessSP () const { return m_process_sp; } const lldb::ThreadSP & - GetThreadSP () + GetThreadSP () const { return m_thread_sp; } const lldb::StackFrameSP & - GetFrameSP () + GetFrameSP () const { return m_frame_sp; } @@ -162,6 +291,47 @@ public: void SetFramePtr (StackFrame *frame); + //------------------------------------------------------------------ + // Set the execution context using a target shared pointer. + // + // If "target_sp" is valid, sets the target context to match and + // if "get_process" is true, sets the process shared pointer if + // the target currently has a process. + //------------------------------------------------------------------ + void + SetContext (const lldb::TargetSP &target_sp, bool get_process); + + //------------------------------------------------------------------ + // Set the execution context using a process shared pointer. + // + // If "process_sp" is valid, then set the process and target in this + // context. Thread and frame contexts will be cleared. + // If "process_sp" is not valid, all shared pointers are reset. + //------------------------------------------------------------------ + void + SetContext (const lldb::ProcessSP &process_sp); + + //------------------------------------------------------------------ + // Set the execution context using a thread shared pointer. + // + // If "thread_sp" is valid, then set the thread, process and target + // in this context. The frame context will be cleared. + // If "thread_sp" is not valid, all shared pointers are reset. + //------------------------------------------------------------------ + void + SetContext (const lldb::ThreadSP &thread_sp); + + //------------------------------------------------------------------ + // Set the execution context using a thread shared pointer. + // + // If "frame_sp" is valid, then set the frame, thread, process and + // target in this context + // If "frame_sp" is not valid, all shared pointers are reset. + //------------------------------------------------------------------ + void + SetContext (const lldb::StackFrameSP &frame_sp); + + protected: //------------------------------------------------------------------ // Member variables @@ -171,7 +341,6 @@ protected: lldb::ThreadSP m_thread_sp; ///< The thread that owns the frame lldb::StackFrameSP m_frame_sp; ///< The stack frame in thread. }; - } // namespace lldb_private #endif // liblldb_ExecutionContext_h_ diff --git a/lldb/include/lldb/Target/StackFrameList.h b/lldb/include/lldb/Target/StackFrameList.h index d37f9257f95..db22a405ed1 100644 --- a/lldb/include/lldb/Target/StackFrameList.h +++ b/lldb/include/lldb/Target/StackFrameList.h @@ -43,7 +43,7 @@ public: GetFrameWithConcreteFrameIndex (uint32_t unwind_idx); lldb::StackFrameSP - GetFrameWithStackID (StackID &stack_id); + GetFrameWithStackID (const StackID &stack_id); // Mark a stack frame as the current frame uint32_t diff --git a/lldb/include/lldb/Target/StackID.h b/lldb/include/lldb/Target/StackID.h index cac57da0114..15f24dd4725 100644 --- a/lldb/include/lldb/Target/StackID.h +++ b/lldb/include/lldb/Target/StackID.h @@ -84,12 +84,9 @@ public: } bool - IsValid () + IsValid () const { - if (m_pc == LLDB_INVALID_ADDRESS && m_cfa == LLDB_INVALID_ADDRESS) - return false; - else - return true; + return m_pc != LLDB_INVALID_ADDRESS || m_cfa != LLDB_INVALID_ADDRESS; } void diff --git a/lldb/include/lldb/Target/Thread.h b/lldb/include/lldb/Target/Thread.h index a704dfd90d8..1ec196bb4c4 100644 --- a/lldb/include/lldb/Target/Thread.h +++ b/lldb/include/lldb/Target/Thread.h @@ -339,7 +339,7 @@ public: GetFrameWithConcreteFrameIndex (uint32_t unwind_idx); virtual lldb::StackFrameSP - GetFrameWithStackID(StackID &stack_id) + GetFrameWithStackID (const StackID &stack_id) { return GetStackFrameList().GetFrameWithStackID (stack_id); } diff --git a/lldb/include/lldb/lldb-forward.h b/lldb/include/lldb/lldb-forward.h index 3c2d2a1e26a..97ca12fb574 100644 --- a/lldb/include/lldb/lldb-forward.h +++ b/lldb/include/lldb/lldb-forward.h @@ -84,6 +84,8 @@ class Error; class Event; class EventData; class ExecutionContext; +class ExecutionContextRef; +class ExecutionContextRefLocker; class ExecutionContextScope; class FileSpec; class FileSpecList; diff --git a/lldb/source/API/SBValue.cpp b/lldb/source/API/SBValue.cpp index 7eb56a806a3..d4d2c06a448 100644 --- a/lldb/source/API/SBValue.cpp +++ b/lldb/source/API/SBValue.cpp @@ -175,10 +175,10 @@ SBValue::IsInScope () lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); result = value_sp->IsInScope (); } } @@ -197,10 +197,10 @@ SBValue::GetValue () lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); cstr = value_sp->GetValueAsCString (); } } @@ -249,10 +249,10 @@ SBValue::GetObjectDescription () lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); cstr = value_sp->GetObjectDescription (); } } @@ -296,10 +296,10 @@ SBValue::GetValueDidChange () lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); result = value_sp->GetValueDidChange (); } } @@ -317,10 +317,10 @@ SBValue::GetSummary () lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); cstr = value_sp->GetSummaryAsCString(); } } @@ -342,10 +342,10 @@ SBValue::GetLocation () lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); cstr = value_sp->GetLocationAsCString(); } } @@ -367,10 +367,10 @@ SBValue::SetValueFromCString (const char *value_str) lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); success = value_sp->SetValueFromCString (value_str); } } @@ -384,12 +384,16 @@ SBValue::GetTypeFormat () lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); - if (value_sp->UpdateValueIfNeeded(true)) + TargetSP target_sp(value_sp->GetTargetSP()); + if (target_sp) { - lldb::TypeFormatImplSP format_sp = value_sp->GetValueFormat(); - if (format_sp) - format.SetSP(format_sp); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); + if (value_sp->UpdateValueIfNeeded(true)) + { + lldb::TypeFormatImplSP format_sp = value_sp->GetValueFormat(); + if (format_sp) + format.SetSP(format_sp); + } } } return format; @@ -402,12 +406,16 @@ SBValue::GetTypeSummary () lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); - if (value_sp->UpdateValueIfNeeded(true)) + TargetSP target_sp(value_sp->GetTargetSP()); + if (target_sp) { - lldb::TypeSummaryImplSP summary_sp = value_sp->GetSummaryFormat(); - if (summary_sp) - summary.SetSP(summary_sp); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); + if (value_sp->UpdateValueIfNeeded(true)) + { + lldb::TypeSummaryImplSP summary_sp = value_sp->GetSummaryFormat(); + if (summary_sp) + summary.SetSP(summary_sp); + } } } return summary; @@ -420,15 +428,19 @@ SBValue::GetTypeFilter () lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); - if (value_sp->UpdateValueIfNeeded(true)) + TargetSP target_sp(value_sp->GetTargetSP()); + if (target_sp) { - lldb::SyntheticChildrenSP synthetic_sp = value_sp->GetSyntheticChildren(); - - if (synthetic_sp && !synthetic_sp->IsScripted()) + Mutex::Locker api_locker (target_sp->GetAPIMutex()); + if (value_sp->UpdateValueIfNeeded(true)) { - TypeFilterImplSP filter_sp = std::tr1::static_pointer_cast<TypeFilterImpl>(synthetic_sp); - filter.SetSP(filter_sp); + lldb::SyntheticChildrenSP synthetic_sp = value_sp->GetSyntheticChildren(); + + if (synthetic_sp && !synthetic_sp->IsScripted()) + { + TypeFilterImplSP filter_sp = std::tr1::static_pointer_cast<TypeFilterImpl>(synthetic_sp); + filter.SetSP(filter_sp); + } } } } @@ -442,15 +454,19 @@ SBValue::GetTypeSynthetic () lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); - if (value_sp->UpdateValueIfNeeded(true)) + TargetSP target_sp(value_sp->GetTargetSP()); + if (target_sp) { - lldb::SyntheticChildrenSP children_sp = value_sp->GetSyntheticChildren(); - - if (children_sp && children_sp->IsScripted()) + Mutex::Locker api_locker (target_sp->GetAPIMutex()); + if (value_sp->UpdateValueIfNeeded(true)) { - TypeSyntheticImplSP synth_sp = std::tr1::static_pointer_cast<TypeSyntheticImpl>(children_sp); - synthetic.SetSP(synth_sp); + lldb::SyntheticChildrenSP children_sp = value_sp->GetSyntheticChildren(); + + if (children_sp && children_sp->IsScripted()) + { + TypeSyntheticImplSP synth_sp = std::tr1::static_pointer_cast<TypeSyntheticImpl>(children_sp); + synthetic.SetSP(synth_sp); + } } } } @@ -504,18 +520,23 @@ SBValue::CreateValueFromExpression (const char *name, const char* expression) lldb::ValueObjectSP new_value_sp; if (value_sp) { - value_sp->GetUpdatePoint().GetTargetSP()->EvaluateExpression (expression, - value_sp->GetExecutionContextScope()->CalculateStackFrame(), - eExecutionPolicyOnlyWhenNeeded, - false, // coerce to id - true, // unwind on error - true, // keep in memory - eNoDynamicValues, - new_value_sp); - if (new_value_sp) + ExecutionContext exe_ctx (value_sp->GetExecutionContextRef()); + Target* target = exe_ctx.GetTargetPtr(); + if (target) { - new_value_sp->SetName(ConstString(name)); - sb_value.SetSP(new_value_sp); + target->EvaluateExpression (expression, + exe_ctx.GetFramePtr(), + eExecutionPolicyOnlyWhenNeeded, + false, // coerce to id + true, // unwind on error + true, // keep in memory + eNoDynamicValues, + new_value_sp); + if (new_value_sp) + { + new_value_sp->SetName(ConstString(name)); + sb_value.SetSP(new_value_sp); + } } } LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); @@ -545,13 +566,14 @@ SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, SBType s lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&address,sizeof(lldb::addr_t))); - ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create (value_sp->GetExecutionContextScope(), + ExecutionContext exe_ctx (value_sp->GetExecutionContextRef()); + ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), pointee_type_impl_sp->GetASTContext(), pointee_type_impl_sp->GetOpaqueQualType(), ConstString(name), buffer, lldb::endian::InlHostByteOrder(), - GetTarget().GetProcess().GetAddressByteSize())); + exe_ctx.GetAddressByteSize())); if (ptr_result_valobj_sp) { @@ -583,7 +605,9 @@ SBValue::CreateValueFromData (const char* name, SBData data, SBType type) lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - new_value_sp = ValueObjectConstResult::Create (value_sp->GetExecutionContextScope(), + ExecutionContext exe_ctx (value_sp->GetExecutionContextRef()); + + new_value_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), type.m_opaque_sp->GetASTContext() , type.m_opaque_sp->GetOpaqueQualType(), ConstString(name), @@ -610,7 +634,11 @@ SBValue::GetChildAtIndex (uint32_t idx) lldb::DynamicValueType use_dynamic = eNoDynamicValues; lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) - use_dynamic = value_sp->GetUpdatePoint().GetTargetSP()->GetPreferDynamicValue(); + { + TargetSP target_sp(value_sp->GetTargetSP()); + if (target_sp) + use_dynamic = target_sp->GetPreferDynamicValue(); + } return GetChildAtIndex (idx, use_dynamic, can_create_synthetic); } @@ -622,10 +650,10 @@ SBValue::GetChildAtIndex (uint32_t idx, lldb::DynamicValueType use_dynamic, bool lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); const bool can_create = true; child_sp = value_sp->GetChildAtIndex (idx, can_create); if (can_create_synthetic && !child_sp) @@ -667,10 +695,10 @@ SBValue::GetIndexOfChildWithName (const char *name) lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); idx = value_sp->GetIndexOfChildWithName (ConstString(name)); } @@ -693,7 +721,7 @@ SBValue::GetChildMemberWithName (const char *name) if (value_sp) { lldb::DynamicValueType use_dynamic_value = eNoDynamicValues; - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { Mutex::Locker api_locker (target_sp->GetAPIMutex()); @@ -714,7 +742,7 @@ SBValue::GetChildMemberWithName (const char *name, lldb::DynamicValueType use_dy lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { Mutex::Locker api_locker (target_sp->GetAPIMutex()); @@ -746,10 +774,10 @@ SBValue::GetDynamicValue (lldb::DynamicValueType use_dynamic) lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); return SBValue (value_sp->GetDynamicValue(use_dynamic)); } } @@ -763,10 +791,10 @@ SBValue::GetStaticValue () lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); return SBValue(value_sp->GetStaticValue()); } } @@ -780,10 +808,10 @@ SBValue::IsDynamic() lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); return value_sp->IsDynamic(); } } @@ -797,10 +825,10 @@ SBValue::GetValueForExpressionPath(const char* expr_path) lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); // using default values for all the fancy options, just do it if you can child_sp = value_sp->GetValueForExpressionPath(expr_path); } @@ -822,10 +850,10 @@ SBValue::GetValueAsSigned(SBError& error, int64_t fail_value) lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); Scalar scalar; if (value_sp->ResolveValue (scalar)) return scalar.GetRawBits64(fail_value); @@ -846,10 +874,10 @@ SBValue::GetValueAsUnsigned(SBError& error, uint64_t fail_value) lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); Scalar scalar; if (value_sp->ResolveValue (scalar)) return scalar.GetRawBits64(fail_value); @@ -869,10 +897,10 @@ SBValue::GetValueAsSigned(int64_t fail_value) lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); Scalar scalar; if (value_sp->ResolveValue (scalar)) return scalar.GetRawBits64(fail_value); @@ -887,10 +915,10 @@ SBValue::GetValueAsUnsigned(uint64_t fail_value) lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); Scalar scalar; if (value_sp->ResolveValue (scalar)) return scalar.GetRawBits64(fail_value); @@ -907,10 +935,10 @@ SBValue::GetNumChildren () lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); num_children = value_sp->GetNumChildren(); } @@ -931,10 +959,10 @@ SBValue::Dereference () lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); Error error; sb_value = value_sp->Dereference (error); @@ -955,10 +983,10 @@ SBValue::TypeIsPointerType () lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); is_ptr_type = value_sp->IsPointerType(); } @@ -978,10 +1006,10 @@ SBValue::GetOpaqueType() lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp(value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp(value_sp->GetTargetSP()); if (target_sp) { - Mutex::Locker api_locker (value_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); return value_sp->GetClangType(); } @@ -997,7 +1025,7 @@ SBValue::GetTarget() lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - target_sp = value_sp->GetUpdatePoint().GetTargetSP(); + target_sp = value_sp->GetTargetSP(); sb_target.SetSP (target_sp); } LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); @@ -1019,7 +1047,7 @@ SBValue::GetProcess() lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - process_sp = value_sp->GetUpdatePoint().GetProcessSP(); + process_sp = value_sp->GetProcessSP(); if (process_sp) sb_process.SetSP (process_sp); } @@ -1042,11 +1070,8 @@ SBValue::GetThread() lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - if (value_sp->GetExecutionContextScope()) - { - thread_sp = value_sp->GetExecutionContextScope()->CalculateThread()->shared_from_this(); - sb_thread.SetThread(thread_sp); - } + thread_sp = value_sp->GetThreadSP(); + sb_thread.SetThread(thread_sp); } LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); if (log) @@ -1067,11 +1092,8 @@ SBValue::GetFrame() lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - if (value_sp->GetExecutionContextScope()) - { - frame_sp = value_sp->GetExecutionContextScope()->CalculateStackFrame()->shared_from_this(); - sb_frame.SetFrameSP (frame_sp); - } + frame_sp = value_sp->GetFrameSP(); + sb_frame.SetFrameSP (frame_sp); } LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); if (log) @@ -1162,10 +1184,10 @@ SBValue::AddressOf() lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - Target* target = value_sp->GetUpdatePoint().GetTargetSP().get(); - if (target) + TargetSP target_sp (value_sp->GetTargetSP()); + if (target_sp) { - Mutex::Locker api_locker (target->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); Error error; sb_value = value_sp->AddressOf (error); } @@ -1184,10 +1206,10 @@ SBValue::GetLoadAddress() lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - Target* target = value_sp->GetUpdatePoint().GetTargetSP().get(); - if (target) + TargetSP target_sp (value_sp->GetTargetSP()); + if (target_sp) { - Mutex::Locker api_locker (target->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); const bool scalar_is_load_address = true; AddressType addr_type; value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type); @@ -1200,7 +1222,7 @@ SBValue::GetLoadAddress() { Address addr; module->ResolveFileAddress(value, addr); - value = addr.GetLoadAddress(value_sp->GetUpdatePoint().GetTargetSP().get()); + value = addr.GetLoadAddress(target_sp.get()); } } else if (addr_type == eAddressTypeHost || addr_type == eAddressTypeInvalid) @@ -1221,11 +1243,11 @@ SBValue::GetAddress() lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - Target* target = value_sp->GetUpdatePoint().GetTargetSP().get(); - if (target) + TargetSP target_sp (value_sp->GetTargetSP()); + if (target_sp) { lldb::addr_t value = LLDB_INVALID_ADDRESS; - Mutex::Locker api_locker (target->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); const bool scalar_is_load_address = true; AddressType addr_type; value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type); @@ -1240,7 +1262,7 @@ SBValue::GetAddress() // no need to check the return value on this.. if it can actually do the resolve // addr will be in the form (section,offset), otherwise it will simply be returned // as (NULL, value) - addr.SetLoadAddress(value, target); + addr.SetLoadAddress(value, target_sp.get()); } } } @@ -1258,11 +1280,11 @@ SBValue::GetPointeeData (uint32_t item_idx, lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - Target* target = value_sp->GetUpdatePoint().GetTargetSP().get(); - if (target) + TargetSP target_sp (value_sp->GetTargetSP()); + if (target_sp) { DataExtractorSP data_sp(new DataExtractor()); - Mutex::Locker api_locker (target->GetAPIMutex()); + Mutex::Locker api_locker (target_sp->GetAPIMutex()); value_sp->GetPointeeData(*data_sp, item_idx, item_count); if (data_sp->GetByteSize() > 0) *sb_data = data_sp; @@ -1286,7 +1308,7 @@ SBValue::GetData () lldb::ValueObjectSP value_sp(GetSP()); if (value_sp) { - TargetSP target_sp (value_sp->GetUpdatePoint().GetTargetSP()); + TargetSP target_sp (value_sp->GetTargetSP()); if (target_sp) { Mutex::Locker api_locker (target_sp->GetAPIMutex()); diff --git a/lldb/source/Core/Debugger.cpp b/lldb/source/Core/Debugger.cpp index 7f768e9ec41..0c17ca9735b 100644 --- a/lldb/source/Core/Debugger.cpp +++ b/lldb/source/Core/Debugger.cpp @@ -1394,7 +1394,7 @@ Debugger::FormatPrompt if (index_higher < 0) index_higher = valobj->GetNumChildren() - 1; - uint32_t max_num_children = target->GetUpdatePoint().GetTargetSP()->GetMaximumNumberOfChildrenToDisplay(); + uint32_t max_num_children = target->GetTargetSP()->GetMaximumNumberOfChildrenToDisplay(); for (;index_lower<=index_higher;index_lower++) { diff --git a/lldb/source/Core/FormatClasses.cpp b/lldb/source/Core/FormatClasses.cpp index ded4938568b..d59da37c487 100644 --- a/lldb/source/Core/FormatClasses.cpp +++ b/lldb/source/Core/FormatClasses.cpp @@ -85,8 +85,7 @@ StringSummaryFormat::FormatObject(lldb::ValueObjectSP object) return "NULL"; StreamString s; - ExecutionContext exe_ctx; - object->GetExecutionContextScope()->CalculateExecutionContext(exe_ctx); + ExecutionContext exe_ctx (object->GetExecutionContextRef()); SymbolContext sc; StackFrame *frame = exe_ctx.GetFramePtr(); if (frame) @@ -237,8 +236,7 @@ SyntheticArrayView::GetDescription() #ifndef LLDB_DISABLE_PYTHON -TypeSyntheticImpl::FrontEnd::FrontEnd(std::string pclass, - lldb::ValueObjectSP be) : +TypeSyntheticImpl::FrontEnd::FrontEnd(std::string pclass, lldb::ValueObjectSP be) : SyntheticChildrenFrontEnd(be), m_python_class(pclass) { @@ -249,7 +247,7 @@ TypeSyntheticImpl::FrontEnd::FrontEnd(std::string pclass, return; } - m_interpreter = m_backend->GetUpdatePoint().GetTargetSP()->GetDebugger().GetCommandInterpreter().GetScriptInterpreter(); + m_interpreter = m_backend->GetTargetSP()->GetDebugger().GetCommandInterpreter().GetScriptInterpreter(); if (m_interpreter == NULL) m_wrapper = NULL; diff --git a/lldb/source/Core/ValueObject.cpp b/lldb/source/Core/ValueObject.cpp index 9182979fd40..0c75affd1bd 100644 --- a/lldb/source/Core/ValueObject.cpp +++ b/lldb/source/Core/ValueObject.cpp @@ -353,10 +353,7 @@ ValueObject::ResolveValue (Scalar &scalar) { if (UpdateValueIfNeeded(false)) // make sure that you are up to date before returning anything { - ExecutionContext exe_ctx; - ExecutionContextScope *exe_scope = GetExecutionContextScope(); - if (exe_scope) - exe_scope->CalculateExecutionContext(exe_ctx); + ExecutionContext exe_ctx (GetExecutionContextRef()); Value tmp_value(m_value); scalar = tmp_value.ResolveValue(&exe_ctx, GetClangAST ()); if (scalar.IsValid()) @@ -516,8 +513,7 @@ ValueObject::CreateChildAtIndex (uint32_t idx, bool synthetic_array_member, int3 clang_type_t clang_type = GetClangType(); clang_type_t child_clang_type; - ExecutionContext exe_ctx; - GetExecutionContextScope()->CalculateExecutionContext (exe_ctx); + ExecutionContext exe_ctx (GetExecutionContextRef()); child_clang_type = ClangASTContext::GetChildClangTypeAtIndex (&exe_ctx, clang_ast, @@ -594,49 +590,47 @@ ValueObject::GetSummaryAsCString () GetClangAST(), &elem_or_pointee_clang_type)); - ExecutionContextScope *exe_scope = GetExecutionContextScope(); - if (exe_scope) + if (ClangASTContext::IsFunctionPointerType (clang_type)) { - if (ClangASTContext::IsFunctionPointerType (clang_type)) + AddressType func_ptr_address_type = eAddressTypeInvalid; + addr_t func_ptr_address = GetPointerValue (&func_ptr_address_type); + if (func_ptr_address != 0 && func_ptr_address != LLDB_INVALID_ADDRESS) { - AddressType func_ptr_address_type = eAddressTypeInvalid; - addr_t func_ptr_address = GetPointerValue (&func_ptr_address_type); - if (func_ptr_address != 0 && func_ptr_address != LLDB_INVALID_ADDRESS) + switch (func_ptr_address_type) { - switch (func_ptr_address_type) + case eAddressTypeInvalid: + case eAddressTypeFile: + break; + + case eAddressTypeLoad: { - case eAddressTypeInvalid: - case eAddressTypeFile: - break; + ExecutionContext exe_ctx (GetExecutionContextRef()); - case eAddressTypeLoad: + Address so_addr; + Target *target = exe_ctx.GetTargetPtr(); + if (target && target->GetSectionLoadList().IsEmpty() == false) { - Address so_addr; - Target *target = exe_scope->CalculateTarget(); - if (target && target->GetSectionLoadList().IsEmpty() == false) + if (target->GetSectionLoadList().ResolveLoadAddress(func_ptr_address, so_addr)) { - if (target->GetSectionLoadList().ResolveLoadAddress(func_ptr_address, so_addr)) - { - so_addr.Dump (&sstr, - exe_scope, - Address::DumpStyleResolvedDescription, - Address::DumpStyleSectionNameOffset); - } + so_addr.Dump (&sstr, + exe_ctx.GetBestExecutionContextScope(), + Address::DumpStyleResolvedDescription, + Address::DumpStyleSectionNameOffset); } } - break; - - case eAddressTypeHost: - break; } - } - if (sstr.GetSize() > 0) - { - m_summary_str.assign (1, '('); - m_summary_str.append (sstr.GetData(), sstr.GetSize()); - m_summary_str.append (1, ')'); + break; + + case eAddressTypeHost: + break; } } + if (sstr.GetSize() > 0) + { + m_summary_str.assign (1, '('); + m_summary_str.append (sstr.GetData(), sstr.GetSize()); + m_summary_str.append (1, ')'); + } } } } @@ -720,9 +714,6 @@ ValueObject::GetPointeeData (DataExtractor& data, AddressType addr_type; lldb::addr_t addr = IsPointerType() ? GetPointerValue(&addr_type) : GetAddressOf(true, &addr_type); - ExecutionContextScope *exe_scope = GetExecutionContextScope(); - - switch (addr_type) { case eAddressTypeFile: @@ -732,27 +723,25 @@ ValueObject::GetPointeeData (DataExtractor& data, { Address so_addr; module->ResolveFileAddress(addr, so_addr); - if (exe_scope) + ExecutionContext exe_ctx (GetExecutionContextRef()); + Target* target = exe_ctx.GetTargetPtr(); + if (target) { - Target* target = exe_scope->CalculateTarget(); - if (target) + heap_buf_ptr->SetByteSize(bytes); + size_t bytes_read = target->ReadMemory(so_addr, false, heap_buf_ptr->GetBytes(), bytes, error); + if (error.Success()) { - heap_buf_ptr->SetByteSize(bytes); - size_t bytes_read = target->ReadMemory(so_addr, false, heap_buf_ptr->GetBytes(), bytes, error); - if (error.Success()) - { - data.SetData(data_sp); - return bytes_read; - } + data.SetData(data_sp); + return bytes_read; } } } } break; case eAddressTypeLoad: - if (exe_scope) { - Process *process = exe_scope->CalculateProcess(); + ExecutionContext exe_ctx (GetExecutionContextRef()); + Process *process = exe_ctx.GetProcessPtr(); if (process) { heap_buf_ptr->SetByteSize(bytes); @@ -784,8 +773,7 @@ size_t ValueObject::GetData (DataExtractor& data) { UpdateValueIfNeeded(false); - ExecutionContext exe_ctx; - GetExecutionContextScope()->CalculateExecutionContext(exe_ctx); + ExecutionContext exe_ctx (GetExecutionContextRef()); Error error = m_value.GetValueAsData(&exe_ctx, GetClangAST(), data, 0, GetModule()); if (error.Fail()) return 0; @@ -820,15 +808,17 @@ strlen_or_inf (const char* str, } void -ValueObject::ReadPointedString(Stream& s, - Error& error, - uint32_t max_length, - bool honor_array, - Format item_format) +ValueObject::ReadPointedString (Stream& s, + Error& error, + uint32_t max_length, + bool honor_array, + Format item_format) { - - if (max_length == 0) - max_length = GetUpdatePoint().GetTargetSP()->GetMaximumSizeOfStringSummary(); + ExecutionContext exe_ctx (GetExecutionContextRef()); + Target* target = exe_ctx.GetTargetPtr(); + + if (target && max_length == 0) + max_length = target->GetMaximumSizeOfStringSummary(); clang_type_t clang_type = GetClangType(); clang_type_t elem_or_pointee_clang_type; @@ -838,129 +828,124 @@ ValueObject::ReadPointedString(Stream& s, if (type_flags.AnySet (ClangASTContext::eTypeIsArray | ClangASTContext::eTypeIsPointer) && ClangASTContext::IsCharType (elem_or_pointee_clang_type)) { - ExecutionContextScope *exe_scope = GetExecutionContextScope(); - if (exe_scope) + if (target == NULL) + { + s << "<no target to read from>"; + } + else + { + addr_t cstr_address = LLDB_INVALID_ADDRESS; + AddressType cstr_address_type = eAddressTypeInvalid; + + size_t cstr_len = 0; + bool capped_data = false; + if (type_flags.Test (ClangASTContext::eTypeIsArray)) + { + // We have an array + cstr_len = ClangASTContext::GetArraySize (clang_type); + if (cstr_len > max_length) + { + capped_data = true; + cstr_len = max_length; + } + cstr_address = GetAddressOf (true, &cstr_address_type); + } + else + { + // We have a pointer + cstr_address = GetPointerValue (&cstr_address_type); + } + if (cstr_address != 0 && cstr_address != LLDB_INVALID_ADDRESS) { - Target *target = exe_scope->CalculateTarget(); - if (target == NULL) + Address cstr_so_addr (NULL, cstr_address); + DataExtractor data; + size_t bytes_read = 0; + if (cstr_len > 0 && honor_array) { - s << "<no target to read from>"; + // I am using GetPointeeData() here to abstract the fact that some ValueObjects are actually frozen pointers in the host + // but the pointed-to data lives in the debuggee, and GetPointeeData() automatically takes care of this + GetPointeeData(data, 0, cstr_len); + + if ((bytes_read = data.GetByteSize()) > 0) + { + s << '"'; + data.Dump (&s, + 0, // Start offset in "data" + item_format, + 1, // Size of item (1 byte for a char!) + bytes_read, // How many bytes to print? + UINT32_MAX, // num per line + LLDB_INVALID_ADDRESS,// base address + 0, // bitfield bit size + 0); // bitfield bit offset + if (capped_data) + s << "..."; + s << '"'; + } } else { - addr_t cstr_address = LLDB_INVALID_ADDRESS; - AddressType cstr_address_type = eAddressTypeInvalid; + cstr_len = max_length; + const size_t k_max_buf_size = 64; + + size_t offset = 0; - size_t cstr_len = 0; - bool capped_data = false; - if (type_flags.Test (ClangASTContext::eTypeIsArray)) + int cstr_len_displayed = -1; + bool capped_cstr = false; + // I am using GetPointeeData() here to abstract the fact that some ValueObjects are actually frozen pointers in the host + // but the pointed-to data lives in the debuggee, and GetPointeeData() automatically takes care of this + while ((bytes_read = GetPointeeData(data, offset, k_max_buf_size)) > 0) { - // We have an array - cstr_len = ClangASTContext::GetArraySize (clang_type); - if (cstr_len > max_length) + const char *cstr = data.PeekCStr(0); + size_t len = strlen_or_inf (cstr, k_max_buf_size, k_max_buf_size+1); + if (len > k_max_buf_size) + len = k_max_buf_size; + if (cstr && cstr_len_displayed < 0) + s << '"'; + + if (cstr_len_displayed < 0) + cstr_len_displayed = len; + + if (len == 0) + break; + cstr_len_displayed += len; + if (len > bytes_read) + len = bytes_read; + if (len > cstr_len) + len = cstr_len; + + data.Dump (&s, + 0, // Start offset in "data" + item_format, + 1, // Size of item (1 byte for a char!) + len, // How many bytes to print? + UINT32_MAX, // num per line + LLDB_INVALID_ADDRESS,// base address + 0, // bitfield bit size + 0); // bitfield bit offset + + if (len < k_max_buf_size) + break; + + if (len >= cstr_len) { - capped_data = true; - cstr_len = max_length; + capped_cstr = true; + break; } - cstr_address = GetAddressOf (true, &cstr_address_type); + + cstr_len -= len; + offset += len; } - else + + if (cstr_len_displayed >= 0) { - // We have a pointer - cstr_address = GetPointerValue (&cstr_address_type); - } - if (cstr_address != 0 && cstr_address != LLDB_INVALID_ADDRESS) - { - Address cstr_so_addr (NULL, cstr_address); - DataExtractor data; - size_t bytes_read = 0; - if (cstr_len > 0 && honor_array) - { - // I am using GetPointeeData() here to abstract the fact that some ValueObjects are actually frozen pointers in the host - // but the pointed-to data lives in the debuggee, and GetPointeeData() automatically takes care of this - GetPointeeData(data, 0, cstr_len); - - if ((bytes_read = data.GetByteSize()) > 0) - { - s << '"'; - data.Dump (&s, - 0, // Start offset in "data" - item_format, - 1, // Size of item (1 byte for a char!) - bytes_read, // How many bytes to print? - UINT32_MAX, // num per line - LLDB_INVALID_ADDRESS,// base address - 0, // bitfield bit size - 0); // bitfield bit offset - if (capped_data) - s << "..."; - s << '"'; - } - } - else - { - cstr_len = max_length; - const size_t k_max_buf_size = 64; - - size_t offset = 0; - - int cstr_len_displayed = -1; - bool capped_cstr = false; - // I am using GetPointeeData() here to abstract the fact that some ValueObjects are actually frozen pointers in the host - // but the pointed-to data lives in the debuggee, and GetPointeeData() automatically takes care of this - while ((bytes_read = GetPointeeData(data, offset, k_max_buf_size)) > 0) - { - const char *cstr = data.PeekCStr(0); - size_t len = strlen_or_inf (cstr, k_max_buf_size, k_max_buf_size+1); - if (len > k_max_buf_size) - len = k_max_buf_size; - if (cstr && cstr_len_displayed < 0) - s << '"'; - - if (cstr_len_displayed < 0) - cstr_len_displayed = len; - - if (len == 0) - break; - cstr_len_displayed += len; - if (len > bytes_read) - len = bytes_read; - if (len > cstr_len) - len = cstr_len; - - data.Dump (&s, - 0, // Start offset in "data" - item_format, - 1, // Size of item (1 byte for a char!) - len, // How many bytes to print? - UINT32_MAX, // num per line - LLDB_INVALID_ADDRESS,// base address - 0, // bitfield bit size - 0); // bitfield bit offset - - if (len < k_max_buf_size) - break; - - if (len >= cstr_len) - { - capped_cstr = true; - break; - } - - cstr_len -= len; - offset += len; - } - - if (cstr_len_displayed >= 0) - { - s << '"'; - if (capped_cstr) - s << "..."; - } - } + s << '"'; + if (capped_cstr) + s << "..."; } } } + } } else { @@ -979,11 +964,8 @@ ValueObject::GetObjectDescription () if (!m_object_desc_str.empty()) return m_object_desc_str.c_str(); - ExecutionContextScope *exe_scope = GetExecutionContextScope(); - if (exe_scope == NULL) - return NULL; - - Process *process = exe_scope->CalculateProcess(); + ExecutionContext exe_ctx (GetExecutionContextRef()); + Process *process = exe_ctx.GetProcessPtr(); if (process == NULL) return NULL; @@ -1053,6 +1035,7 @@ ValueObject::GetValueAsCString () } } StreamString sstr; + ExecutionContext exe_ctx (GetExecutionContextRef()); if (ClangASTType::DumpTypeValue (GetClangAST(), // The clang AST clang_type, // The clang type to display &sstr, @@ -1062,7 +1045,7 @@ ValueObject::GetValueAsCString () GetByteSize(), // Byte size of item in "m_data" GetBitfieldBitSize(), // Bitfield bit size GetBitfieldBitOffset(), - GetExecutionContextScope())) // Bitfield bit offset + exe_ctx.GetBestExecutionContextScope())) // Bitfield bit offset m_value_str.swap(sstr.GetString()); else { @@ -1089,8 +1072,19 @@ ValueObject::GetValueAsCString () my_format = reg_info->format; } + ExecutionContext exe_ctx (GetExecutionContextRef()); + StreamString reg_sstr; - m_data.Dump(®_sstr, 0, my_format, reg_info->byte_size, 1, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0, GetExecutionContextScope()); + m_data.Dump (®_sstr, + 0, + my_format, + reg_info->byte_size, + 1, + UINT32_MAX, + LLDB_INVALID_ADDRESS, + 0, + 0, + exe_ctx.GetBestExecutionContextScope()); m_value_str.swap(reg_sstr.GetString()); } } @@ -1492,24 +1486,25 @@ ValueObject::SetValueFromCString (const char *value_str) { switch (value_type) { - case Value::eValueTypeLoadAddress: + case Value::eValueTypeLoadAddress: { // If it is a load address, then the scalar value is the storage location // of the data, and we have to shove this value down to that load location. - ProcessSP process_sp = GetUpdatePoint().GetProcessSP(); - if (process_sp) + ExecutionContext exe_ctx (GetExecutionContextRef()); + Process *process = exe_ctx.GetProcessPtr(); + if (process) { addr_t target_addr = m_value.GetScalar().GetRawBits64(LLDB_INVALID_ADDRESS); - size_t bytes_written = process_sp->WriteScalarToMemory (target_addr, - new_scalar, - byte_size, - error); + size_t bytes_written = process->WriteScalarToMemory (target_addr, + new_scalar, + byte_size, + error); if (!error.Success() || bytes_written != byte_size) return false; } } break; - case Value::eValueTypeHostAddress: + case Value::eValueTypeHostAddress: { // If it is a host address, then we stuff the scalar as a DataBuffer into the Value's data. DataExtractor new_data; @@ -1520,18 +1515,18 @@ ValueObject::SetValueFromCString (const char *value_str) bool success = new_scalar.GetData(new_data); if (success) { - new_data.CopyByteOrderedData(0, - byte_size, - const_cast<uint8_t *>(m_data.GetDataStart()), - byte_size, - m_data.GetByteOrder()); + new_data.CopyByteOrderedData (0, + byte_size, + const_cast<uint8_t *>(m_data.GetDataStart()), + byte_size, + m_data.GetByteOrder()); } m_value.GetScalar() = (uintptr_t)m_data.GetDataStart(); } break; - case Value::eValueTypeFileAddress: - case Value::eValueTypeScalar: + case Value::eValueTypeFileAddress: + case Value::eValueTypeScalar: break; } } @@ -1896,39 +1891,39 @@ ValueObject::CalculateDynamicValue (DynamicValueType use_dynamic) if (!m_dynamic_value && !IsDynamic()) { - Process *process = m_update_point.GetProcessSP().get(); - bool worth_having_dynamic_value = false; - - - // FIXME: Process should have some kind of "map over Runtimes" so we don't have to - // hard code this everywhere. - LanguageType known_type = GetObjectRuntimeLanguage(); - if (known_type != eLanguageTypeUnknown && known_type != eLanguageTypeC) - { - LanguageRuntime *runtime = process->GetLanguageRuntime (known_type); - if (runtime) - worth_having_dynamic_value = runtime->CouldHaveDynamicValue(*this); - } - else + ExecutionContext exe_ctx (GetExecutionContextRef()); + Process *process = exe_ctx.GetProcessPtr(); + if (process) { - LanguageRuntime *cpp_runtime = process->GetLanguageRuntime (eLanguageTypeC_plus_plus); - if (cpp_runtime) - worth_having_dynamic_value = cpp_runtime->CouldHaveDynamicValue(*this); + bool worth_having_dynamic_value = false; + - if (!worth_having_dynamic_value) + // FIXME: Process should have some kind of "map over Runtimes" so we don't have to + // hard code this everywhere. + LanguageType known_type = GetObjectRuntimeLanguage(); + if (known_type != eLanguageTypeUnknown && known_type != eLanguageTypeC) { - LanguageRuntime *objc_runtime = process->GetLanguageRuntime (eLanguageTypeObjC); - if (objc_runtime) - worth_having_dynamic_value = objc_runtime->CouldHaveDynamicValue(*this); + LanguageRuntime *runtime = process->GetLanguageRuntime (known_type); + if (runtime) + worth_having_dynamic_value = runtime->CouldHaveDynamicValue(*this); + } + else + { + LanguageRuntime *cpp_runtime = process->GetLanguageRuntime (eLanguageTypeC_plus_plus); + if (cpp_runtime) + worth_having_dynamic_value = cpp_runtime->CouldHaveDynamicValue(*this); + + if (!worth_having_dynamic_value) + { + LanguageRuntime *objc_runtime = process->GetLanguageRuntime (eLanguageTypeObjC); + if (objc_runtime) + worth_having_dynamic_value = objc_runtime->CouldHaveDynamicValue(*this); + } } - } - - if (worth_having_dynamic_value) - m_dynamic_value = new ValueObjectDynamicValue (*this, use_dynamic); -// if (worth_having_dynamic_value) -// printf ("Adding dynamic value %s (%p) to (%p) - manager %p.\n", m_name.GetCString(), m_dynamic_value, this, m_manager); - + if (worth_having_dynamic_value) + m_dynamic_value = new ValueObjectDynamicValue (*this, use_dynamic); + } } } @@ -3029,7 +3024,8 @@ ValueObject::DumpValueObject (/*strstr(typeName, "id") == typeName ||*/ ClangASTType::GetMinimumLanguage(valobj->GetClangAST(), valobj->GetClangType()) == eLanguageTypeObjC)) { - Process* process = valobj->GetUpdatePoint().GetProcessSP().get(); + ExecutionContext exe_ctx (valobj->GetExecutionContextRef()); + Process *process = exe_ctx.GetProcessPtr(); if (process == NULL) s.Printf(", dynamic type: unknown) "); else @@ -3179,9 +3175,9 @@ ValueObject::DumpValueObject if (print_children && (!entry || entry->DoesPrintChildren() || !sum_cstr)) { - ValueObjectSP synth_valobj = valobj->GetSyntheticValue(use_synth ? - eUseSyntheticFilter : - eNoSyntheticFilter); + ValueObjectSP synth_valobj = valobj->GetSyntheticValue (use_synth ? + eUseSyntheticFilter : + eNoSyntheticFilter); uint32_t num_children = synth_valobj->GetNumChildren(); bool print_dotdotdot = false; if (num_children) @@ -3198,7 +3194,7 @@ ValueObject::DumpValueObject s.IndentMore(); } - uint32_t max_num_children = valobj->GetUpdatePoint().GetTargetSP()->GetMaximumNumberOfChildrenToDisplay(); + uint32_t max_num_children = valobj->GetTargetSP()->GetMaximumNumberOfChildrenToDisplay(); if (num_children > max_num_children && !ignore_cap) { @@ -3234,7 +3230,10 @@ ValueObject::DumpValueObject { if (print_dotdotdot) { - valobj->GetUpdatePoint().GetTargetSP()->GetDebugger().GetCommandInterpreter().ChildrenTruncated(); + ExecutionContext exe_ctx (valobj->GetExecutionContextRef()); + Target *target = exe_ctx.GetTargetPtr(); + if (target) + target->GetDebugger().GetCommandInterpreter().ChildrenTruncated(); s.Indent("...\n"); } s.IndentLess(); @@ -3278,27 +3277,21 @@ ValueObject::CreateConstantValue (const ConstString &name) if (UpdateValueIfNeeded(false) && m_error.Success()) { - ExecutionContextScope *exe_scope = GetExecutionContextScope(); - if (exe_scope) - { - ExecutionContext exe_ctx; - exe_scope->CalculateExecutionContext(exe_ctx); - - clang::ASTContext *ast = GetClangAST (); - - DataExtractor data; - data.SetByteOrder (m_data.GetByteOrder()); - data.SetAddressByteSize(m_data.GetAddressByteSize()); - - m_error = m_value.GetValueAsData (&exe_ctx, ast, data, 0, GetModule()); - - valobj_sp = ValueObjectConstResult::Create (exe_scope, - ast, - GetClangType(), - name, - data, - GetAddressOf()); - } + ExecutionContext exe_ctx (GetExecutionContextRef()); + clang::ASTContext *ast = GetClangAST (); + + DataExtractor data; + data.SetByteOrder (m_data.GetByteOrder()); + data.SetAddressByteSize(m_data.GetAddressByteSize()); + + m_error = m_value.GetValueAsData (&exe_ctx, ast, data, 0, GetModule()); + + valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), + ast, + GetClangType(), + name, + data, + GetAddressOf()); } if (!valobj_sp) @@ -3332,8 +3325,7 @@ ValueObject::Dereference (Error &error) clang_type_t clang_type = GetClangType(); clang_type_t child_clang_type; - ExecutionContext exe_ctx; - GetExecutionContextScope()->CalculateExecutionContext (exe_ctx); + ExecutionContext exe_ctx (GetExecutionContextRef()); child_clang_type = ClangASTContext::GetChildClangTypeAtIndex (&exe_ctx, clang_ast, @@ -3421,7 +3413,8 @@ ValueObject::AddressOf (Error &error) { std::string name (1, '&'); name.append (m_name.AsCString("")); - m_addr_of_valobj_sp = ValueObjectConstResult::Create (GetExecutionContextScope(), + ExecutionContext exe_ctx (GetExecutionContextRef()); + m_addr_of_valobj_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), ast, ClangASTContext::CreatePointerType (ast, clang_type), ConstString (name.c_str()), @@ -3452,8 +3445,8 @@ ValueObject::CastPointerType (const char *name, ClangASTType &clang_ast_type) if (ptr_value != LLDB_INVALID_ADDRESS) { Address ptr_addr (NULL, ptr_value); - - valobj_sp = ValueObjectMemory::Create (GetExecutionContextScope(), + ExecutionContext exe_ctx (GetExecutionContextRef()); + valobj_sp = ValueObjectMemory::Create (exe_ctx.GetBestExecutionContextScope(), name, ptr_addr, clang_ast_type); @@ -3471,8 +3464,8 @@ ValueObject::CastPointerType (const char *name, TypeSP &type_sp) if (ptr_value != LLDB_INVALID_ADDRESS) { Address ptr_addr (NULL, ptr_value); - - valobj_sp = ValueObjectMemory::Create (GetExecutionContextScope(), + ExecutionContext exe_ctx (GetExecutionContextRef()); + valobj_sp = ValueObjectMemory::Create (exe_ctx.GetBestExecutionContextScope(), name, ptr_addr, type_sp); @@ -3481,73 +3474,63 @@ ValueObject::CastPointerType (const char *name, TypeSP &type_sp) } ValueObject::EvaluationPoint::EvaluationPoint () : - ExecutionContextScope(), - m_thread_id (LLDB_INVALID_UID), - m_mod_id () + m_mod_id(), + m_exe_ctx_ref(), + m_needs_update (true), + m_first_update (true) { } ValueObject::EvaluationPoint::EvaluationPoint (ExecutionContextScope *exe_scope, bool use_selected): - ExecutionContextScope (), + m_mod_id(), + m_exe_ctx_ref(), m_needs_update (true), - m_first_update (true), - m_thread_id (LLDB_INVALID_THREAD_ID), - m_mod_id () - + m_first_update (true) { - ExecutionContext exe_ctx; - - if (exe_scope) - exe_scope->CalculateExecutionContext(exe_ctx); - Target *target = exe_ctx.GetTargetPtr(); - if (target != NULL) + ExecutionContext exe_ctx(exe_scope); + TargetSP target_sp (exe_ctx.GetTargetSP()); + if (target_sp) { - m_target_sp = target->shared_from_this(); - m_process_sp = exe_ctx.GetProcessSP(); - if (!m_process_sp) - m_process_sp = target->GetProcessSP(); + m_exe_ctx_ref.SetTargetSP (target_sp); + ProcessSP process_sp (exe_ctx.GetProcessSP()); + if (!process_sp) + process_sp = target_sp->GetProcessSP(); - if (m_process_sp) + if (process_sp) { - m_mod_id = m_process_sp->GetModID(); + m_mod_id = process_sp->GetModID(); + m_exe_ctx_ref.SetProcessSP (process_sp); - Thread *thread = exe_ctx.GetThreadPtr(); + ThreadSP thread_sp (exe_ctx.GetThreadSP()); - if (thread == NULL) + if (!thread_sp) { if (use_selected) - thread = m_process_sp->GetThreadList().GetSelectedThread().get(); + thread_sp = process_sp->GetThreadList().GetSelectedThread(); } - if (thread != NULL) + if (thread_sp) { - m_thread_id = thread->GetIndexID(); + m_exe_ctx_ref.SetThreadSP(thread_sp); - StackFrame *frame = exe_ctx.GetFramePtr(); - if (frame == NULL) + StackFrameSP frame_sp (exe_ctx.GetFrameSP()); + if (!frame_sp) { if (use_selected) - { - frame = thread->GetSelectedFrame().get(); - if (frame) - m_stack_id = frame->GetStackID(); - } + frame_sp = thread_sp->GetSelectedFrame(); } - else - m_stack_id = frame->GetStackID(); + if (frame_sp) + m_exe_ctx_ref.SetFrameSP(frame_sp); } } } } ValueObject::EvaluationPoint::EvaluationPoint (const ValueObject::EvaluationPoint &rhs) : - m_needs_update(true), - m_first_update(true), - m_target_sp (rhs.m_target_sp), - m_process_sp (rhs.m_process_sp), - m_thread_id (rhs.m_thread_id), - m_stack_id (rhs.m_stack_id), - m_mod_id () + m_mod_id(), + m_exe_ctx_ref(rhs.m_exe_ctx_ref), + m_needs_update (true), + m_first_update (true) { } @@ -3555,49 +3538,6 @@ ValueObject::EvaluationPoint::~EvaluationPoint () { } -Target * -ValueObject::EvaluationPoint::CalculateTarget () -{ - return m_target_sp.get(); -} - -Process * -ValueObject::EvaluationPoint::CalculateProcess () -{ - return m_process_sp.get(); -} - -Thread * -ValueObject::EvaluationPoint::CalculateThread () -{ - ExecutionContextScope *exe_scope; - SyncWithProcessState(exe_scope); - if (exe_scope) - return exe_scope->CalculateThread(); - else - return NULL; -} - -StackFrame * -ValueObject::EvaluationPoint::CalculateStackFrame () -{ - ExecutionContextScope *exe_scope; - SyncWithProcessState(exe_scope); - if (exe_scope) - return exe_scope->CalculateStackFrame(); - else - return NULL; -} - -void -ValueObject::EvaluationPoint::CalculateExecutionContext (ExecutionContext &exe_ctx) -{ - ExecutionContextScope *exe_scope; - SyncWithProcessState(exe_scope); - if (exe_scope) - return exe_scope->CalculateExecutionContext (exe_ctx); -} - // This function checks the EvaluationPoint against the current process state. If the current // state matches the evaluation point, or the evaluation point is already invalid, then we return // false, meaning "no change". If the current state is different, we update our state, and return @@ -3606,23 +3546,22 @@ ValueObject::EvaluationPoint::CalculateExecutionContext (ExecutionContext &exe_c // exe_scope will be set to the current execution context scope. bool -ValueObject::EvaluationPoint::SyncWithProcessState(ExecutionContextScope *&exe_scope) +ValueObject::EvaluationPoint::SyncWithProcessState() { // Start with the target, if it is NULL, then we're obviously not going to get any further: - exe_scope = m_target_sp.get(); + ExecutionContext exe_ctx(m_exe_ctx_ref.Lock()); - if (exe_scope == NULL) + if (exe_ctx.GetTargetPtr() == NULL) return false; // If we don't have a process nothing can change. - if (!m_process_sp) + Process *process = exe_ctx.GetProcessPtr(); + if (process == NULL) return false; - exe_scope = m_process_sp.get(); - // If our stop id is the current stop ID, nothing has changed: - ProcessModID current_mod_id = m_process_sp->GetModID(); + ProcessModID current_mod_id = process->GetModID(); // If the current stop id is 0, either we haven't run yet, or the process state has been cleared. // In either case, we aren't going to be able to sync with the process state. @@ -3651,26 +3590,27 @@ ValueObject::EvaluationPoint::SyncWithProcessState(ExecutionContextScope *&exe_s // That way we'll be sure to return a valid exe_scope. // If we used to have a thread or a frame but can't find it anymore, then mark ourselves as invalid. - if (m_thread_id != LLDB_INVALID_THREAD_ID) + if (m_exe_ctx_ref.HasThreadRef()) { - Thread *our_thread = m_process_sp->GetThreadList().FindThreadByIndexID (m_thread_id).get(); - if (our_thread == NULL) - { - SetInvalid(); - } - else + ThreadSP thread_sp (m_exe_ctx_ref.GetThreadSP()); + if (thread_sp) { - exe_scope = our_thread; - - if (m_stack_id.IsValid()) + if (m_exe_ctx_ref.HasFrameRef()) { - StackFrame *our_frame = our_thread->GetFrameWithStackID (m_stack_id).get(); - if (our_frame == NULL) + StackFrameSP frame_sp (m_exe_ctx_ref.GetFrameSP()); + if (!frame_sp) + { + // We used to have a frame, but now it is gone SetInvalid(); - else - exe_scope = our_frame; + } } } + else + { + // We used to have a thread, but now it is gone + SetInvalid(); + } + } return changed; } @@ -3678,110 +3618,111 @@ ValueObject::EvaluationPoint::SyncWithProcessState(ExecutionContextScope *&exe_s void ValueObject::EvaluationPoint::SetUpdated () { - if (m_process_sp) - m_mod_id = m_process_sp->GetModID(); + ProcessSP process_sp(m_exe_ctx_ref.GetProcessSP()); + if (process_sp) + m_mod_id = process_sp->GetModID(); m_first_update = false; m_needs_update = false; } -bool -ValueObject::EvaluationPoint::SetContext (ExecutionContextScope *exe_scope) -{ - if (!IsValid()) - return false; - - bool needs_update = false; - - // The target has to be non-null, and the - Target *target = exe_scope->CalculateTarget(); - if (target != NULL) - { - Target *old_target = m_target_sp.get(); - assert (target == old_target); - Process *process = exe_scope->CalculateProcess(); - if (process != NULL) - { - // FOR NOW - assume you can't update variable objects across process boundaries. - Process *old_process = m_process_sp.get(); - assert (process == old_process); - ProcessModID current_mod_id = process->GetModID(); - if (m_mod_id != current_mod_id) - { - needs_update = true; - m_mod_id = current_mod_id; - } - // See if we're switching the thread or stack context. If no thread is given, this is - // being evaluated in a global context. - Thread *thread = exe_scope->CalculateThread(); - if (thread != NULL) - { - user_id_t new_thread_index = thread->GetIndexID(); - if (new_thread_index != m_thread_id) - { - needs_update = true; - m_thread_id = new_thread_index; - m_stack_id.Clear(); - } - - StackFrame *new_frame = exe_scope->CalculateStackFrame(); - if (new_frame != NULL) - { - if (new_frame->GetStackID() != m_stack_id) - { - needs_update = true; - m_stack_id = new_frame->GetStackID(); - } - } - else - { - m_stack_id.Clear(); - needs_update = true; - } - } - else - { - // If this had been given a thread, and now there is none, we should update. - // Otherwise we don't have to do anything. - if (m_thread_id != LLDB_INVALID_UID) - { - m_thread_id = LLDB_INVALID_UID; - m_stack_id.Clear(); - needs_update = true; - } - } - } - else - { - // If there is no process, then we don't need to update anything. - // But if we're switching from having a process to not, we should try to update. - if (m_process_sp.get() != NULL) - { - needs_update = true; - m_process_sp.reset(); - m_thread_id = LLDB_INVALID_UID; - m_stack_id.Clear(); - } - } - } - else - { - // If there's no target, nothing can change so we don't need to update anything. - // But if we're switching from having a target to not, we should try to update. - if (m_target_sp.get() != NULL) - { - needs_update = true; - m_target_sp.reset(); - m_process_sp.reset(); - m_thread_id = LLDB_INVALID_UID; - m_stack_id.Clear(); - } - } - if (!m_needs_update) - m_needs_update = needs_update; - - return needs_update; -} +//bool +//ValueObject::EvaluationPoint::SetContext (ExecutionContextScope *exe_scope) +//{ +// if (!IsValid()) +// return false; +// +// bool needs_update = false; +// +// // The target has to be non-null, and the +// Target *target = exe_scope->CalculateTarget(); +// if (target != NULL) +// { +// Target *old_target = m_target_sp.get(); +// assert (target == old_target); +// Process *process = exe_scope->CalculateProcess(); +// if (process != NULL) +// { +// // FOR NOW - assume you can't update variable objects across process boundaries. +// Process *old_process = m_process_sp.get(); +// assert (process == old_process); +// ProcessModID current_mod_id = process->GetModID(); +// if (m_mod_id != current_mod_id) +// { +// needs_update = true; +// m_mod_id = current_mod_id; +// } +// // See if we're switching the thread or stack context. If no thread is given, this is +// // being evaluated in a global context. +// Thread *thread = exe_scope->CalculateThread(); +// if (thread != NULL) +// { +// user_id_t new_thread_index = thread->GetIndexID(); +// if (new_thread_index != m_thread_id) +// { +// needs_update = true; +// m_thread_id = new_thread_index; +// m_stack_id.Clear(); +// } +// +// StackFrame *new_frame = exe_scope->CalculateStackFrame(); +// if (new_frame != NULL) +// { +// if (new_frame->GetStackID() != m_stack_id) +// { +// needs_update = true; +// m_stack_id = new_frame->GetStackID(); +// } +// } +// else +// { +// m_stack_id.Clear(); +// needs_update = true; +// } +// } +// else +// { +// // If this had been given a thread, and now there is none, we should update. +// // Otherwise we don't have to do anything. +// if (m_thread_id != LLDB_INVALID_UID) +// { +// m_thread_id = LLDB_INVALID_UID; +// m_stack_id.Clear(); +// needs_update = true; +// } +// } +// } +// else +// { +// // If there is no process, then we don't need to update anything. +// // But if we're switching from having a process to not, we should try to update. +// if (m_process_sp.get() != NULL) +// { +// needs_update = true; +// m_process_sp.reset(); +// m_thread_id = LLDB_INVALID_UID; +// m_stack_id.Clear(); +// } +// } +// } +// else +// { +// // If there's no target, nothing can change so we don't need to update anything. +// // But if we're switching from having a target to not, we should try to update. +// if (m_target_sp.get() != NULL) +// { +// needs_update = true; +// m_target_sp.reset(); +// m_process_sp.reset(); +// m_thread_id = LLDB_INVALID_UID; +// m_stack_id.Clear(); +// } +// } +// if (!m_needs_update) +// m_needs_update = needs_update; +// +// return needs_update; +//} void ValueObject::ClearUserVisibleData() diff --git a/lldb/source/Core/ValueObjectChild.cpp b/lldb/source/Core/ValueObjectChild.cpp index 92532a3e52c..eb247904742 100644 --- a/lldb/source/Core/ValueObjectChild.cpp +++ b/lldb/source/Core/ValueObjectChild.cpp @@ -129,10 +129,13 @@ ValueObjectChild::UpdateValue () switch (addr_type) { case eAddressTypeFile: - if (m_update_point.GetProcessSP().get() != NULL && m_update_point.GetProcessSP()->IsAlive() == true) - m_value.SetValueType (Value::eValueTypeLoadAddress); - else - m_value.SetValueType(Value::eValueTypeFileAddress); + { + lldb::ProcessSP process_sp (GetProcessSP()); + if (process_sp && process_sp->IsAlive() == true) + m_value.SetValueType (Value::eValueTypeLoadAddress); + else + m_value.SetValueType(Value::eValueTypeFileAddress); + } break; case eAddressTypeLoad: m_value.SetValueType (Value::eValueTypeLoadAddress); @@ -186,7 +189,7 @@ ValueObjectChild::UpdateValue () if (m_error.Success()) { - ExecutionContext exe_ctx (GetExecutionContextScope()); + ExecutionContext exe_ctx (GetExecutionContextRef().Lock()); m_error = m_value.GetValueAsData (&exe_ctx, GetClangAST (), m_data, 0, GetModule()); } } diff --git a/lldb/source/Core/ValueObjectConstResultImpl.cpp b/lldb/source/Core/ValueObjectConstResultImpl.cpp index 31646b4ca0b..731f3938e28 100644 --- a/lldb/source/Core/ValueObjectConstResultImpl.cpp +++ b/lldb/source/Core/ValueObjectConstResultImpl.cpp @@ -53,13 +53,14 @@ ValueObjectConstResultImpl::DerefOnTarget() if (m_load_addr_backend.get() == NULL) { lldb::addr_t tgt_address = m_impl_backend->GetPointerValue(); - m_load_addr_backend = ValueObjectConstResult::Create (m_impl_backend->GetExecutionContextScope(), + ExecutionContext exe_ctx (m_impl_backend->GetExecutionContextRef()); + m_load_addr_backend = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), m_impl_backend->GetClangAST(), m_impl_backend->GetClangType(), m_impl_backend->GetName(), tgt_address, eAddressTypeLoad, - m_impl_backend->GetUpdatePoint().GetProcessSP()->GetAddressByteSize()); + exe_ctx.GetAddressByteSize()); } return m_load_addr_backend; } @@ -107,8 +108,7 @@ ValueObjectConstResultImpl::CreateChildAtIndex (uint32_t idx, bool synthetic_arr lldb::clang_type_t clang_type = m_impl_backend->GetClangType(); lldb::clang_type_t child_clang_type; - ExecutionContext exe_ctx; - m_impl_backend->GetExecutionContextScope()->CalculateExecutionContext (exe_ctx); + ExecutionContext exe_ctx (m_impl_backend->GetExecutionContextRef()); child_clang_type = ClangASTContext::GetChildClangTypeAtIndex (&exe_ctx, clang_ast, @@ -184,14 +184,14 @@ ValueObjectConstResultImpl::AddressOf (Error &error) std::string new_name("&"); new_name.append(m_impl_backend->GetName().AsCString("")); - - m_address_of_backend = ValueObjectConstResult::Create(m_impl_backend->GetExecutionContextScope(), - type.GetASTContext(), - type.GetPointerType(), - ConstString(new_name.c_str()), - buffer, - lldb::endian::InlHostByteOrder(), - m_impl_backend->GetExecutionContextScope()->CalculateProcess()->GetAddressByteSize()); + ExecutionContext exe_ctx (m_impl_backend->GetExecutionContextRef()); + m_address_of_backend = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), + type.GetASTContext(), + type.GetPointerType(), + ConstString(new_name.c_str()), + buffer, + lldb::endian::InlHostByteOrder(), + exe_ctx.GetAddressByteSize()); m_address_of_backend->GetValue().SetValueType(Value::eValueTypeScalar); m_address_of_backend->GetValue().GetScalar() = m_live_address; diff --git a/lldb/source/Core/ValueObjectDynamicValue.cpp b/lldb/source/Core/ValueObjectDynamicValue.cpp index 5ea7993411b..e608ce9bb70 100644 --- a/lldb/source/Core/ValueObjectDynamicValue.cpp +++ b/lldb/source/Core/ValueObjectDynamicValue.cpp @@ -117,7 +117,7 @@ ValueObjectCast::UpdateValue () // say we are changed if our location has changed. SetValueDidChange (m_value.GetValueType() != old_value.GetValueType() || m_value.GetScalar() != old_value.GetScalar()); } - ExecutionContext exe_ctx (GetExecutionContextScope()); + ExecutionContext exe_ctx (GetExecutionContextRef()); m_error = m_value.GetValueAsData(&exe_ctx, GetClangAST(), m_data, 0, GetModule()); SetValueDidChange (m_parent->GetValueDidChange()); return true; @@ -235,7 +235,7 @@ ValueObjectDynamicValue::UpdateValue () return true; } - ExecutionContext exe_ctx (GetExecutionContextScope()); + ExecutionContext exe_ctx (GetExecutionContextRef()); Target *target = exe_ctx.GetTargetPtr(); if (target) { @@ -244,7 +244,7 @@ ValueObjectDynamicValue::UpdateValue () } // First make sure our Type and/or Address haven't changed: - Process *process = m_update_point.GetProcessSP().get(); + Process *process = exe_ctx.GetProcessPtr(); if (!process) return false; @@ -311,7 +311,8 @@ ValueObjectDynamicValue::UpdateValue () // We've moved, so we should be fine... m_address = dynamic_address; - lldb::addr_t load_address = m_address.GetLoadAddress(m_update_point.GetTargetSP().get()); + lldb::TargetSP target_sp (GetTargetSP()); + lldb::addr_t load_address = m_address.GetLoadAddress(target_sp.get()); m_value.GetScalar() = load_address; } diff --git a/lldb/source/Core/ValueObjectMemory.cpp b/lldb/source/Core/ValueObjectMemory.cpp index 5d9406e02f2..9f26a460864 100644 --- a/lldb/source/Core/ValueObjectMemory.cpp +++ b/lldb/source/Core/ValueObjectMemory.cpp @@ -64,7 +64,8 @@ ValueObjectMemory::ValueObjectMemory (ExecutionContextScope *exe_scope, assert (m_type_sp.get() != NULL); SetName (ConstString(name)); m_value.SetContext(Value::eContextTypeLLDBType, m_type_sp.get()); - lldb::addr_t load_address = m_address.GetLoadAddress(m_update_point.GetTargetSP().get()); + TargetSP target_sp (GetTargetSP()); + lldb::addr_t load_address = m_address.GetLoadAddress(target_sp.get()); if (load_address != LLDB_INVALID_ADDRESS) { m_value.SetValueType(Value::eValueTypeLoadAddress); @@ -99,9 +100,11 @@ ValueObjectMemory::ValueObjectMemory (ExecutionContextScope *exe_scope, assert (m_clang_type.GetASTContext()); assert (m_clang_type.GetOpaqueQualType()); + TargetSP target_sp (GetTargetSP()); + SetName (ConstString(name)); m_value.SetContext(Value::eContextTypeClangType, m_clang_type.GetOpaqueQualType()); - lldb::addr_t load_address = m_address.GetLoadAddress(m_update_point.GetTargetSP().get()); + lldb::addr_t load_address = m_address.GetLoadAddress (target_sp.get()); if (load_address != LLDB_INVALID_ADDRESS) { m_value.SetValueType(Value::eValueTypeLoadAddress); @@ -183,7 +186,7 @@ ValueObjectMemory::UpdateValue () SetValueIsValid (false); m_error.Clear(); - ExecutionContext exe_ctx (GetExecutionContextScope()); + ExecutionContext exe_ctx (GetExecutionContextRef()); Target *target = exe_ctx.GetTargetPtr(); if (target) diff --git a/lldb/source/Core/ValueObjectRegister.cpp b/lldb/source/Core/ValueObjectRegister.cpp index 40e4d89a070..f0896094eaf 100644 --- a/lldb/source/Core/ValueObjectRegister.cpp +++ b/lldb/source/Core/ValueObjectRegister.cpp @@ -77,8 +77,8 @@ bool ValueObjectRegisterContext::UpdateValue () { m_error.Clear(); - ExecutionContextScope *exe_scope = GetExecutionContextScope(); - StackFrame *frame = exe_scope->CalculateStackFrame(); + ExecutionContext exe_ctx(GetExecutionContextRef()); + StackFrame *frame = exe_ctx.GetFramePtr(); if (frame) m_reg_ctx_sp = frame->GetRegisterContext(); else @@ -102,7 +102,10 @@ ValueObjectRegisterContext::CreateChildAtIndex (uint32_t idx, bool synthetic_arr const uint32_t num_children = GetNumChildren(); if (idx < num_children) - new_valobj = new ValueObjectRegisterSet(GetExecutionContextScope(), m_reg_ctx_sp, idx); + { + ExecutionContext exe_ctx(GetExecutionContextRef()); + new_valobj = new ValueObjectRegisterSet(exe_ctx.GetBestExecutionContextScope(), m_reg_ctx_sp, idx); + } return new_valobj; } @@ -174,8 +177,8 @@ ValueObjectRegisterSet::UpdateValue () { m_error.Clear(); SetValueDidChange (false); - ExecutionContextScope *exe_scope = GetExecutionContextScope(); - StackFrame *frame = exe_scope->CalculateStackFrame(); + ExecutionContext exe_ctx(GetExecutionContextRef()); + StackFrame *frame = exe_ctx.GetFramePtr(); if (frame == NULL) m_reg_ctx_sp.reset(); else @@ -355,8 +358,8 @@ bool ValueObjectRegister::UpdateValue () { m_error.Clear(); - ExecutionContextScope *exe_scope = GetExecutionContextScope(); - StackFrame *frame = exe_scope->CalculateStackFrame(); + ExecutionContext exe_ctx(GetExecutionContextRef()); + StackFrame *frame = exe_ctx.GetFramePtr(); if (frame == NULL) { m_reg_ctx_sp.reset(); diff --git a/lldb/source/Core/ValueObjectVariable.cpp b/lldb/source/Core/ValueObjectVariable.cpp index 181324db251..24f189d9f95 100644 --- a/lldb/source/Core/ValueObjectVariable.cpp +++ b/lldb/source/Core/ValueObjectVariable.cpp @@ -127,7 +127,7 @@ ValueObjectVariable::UpdateValue () else { lldb::addr_t loclist_base_load_addr = LLDB_INVALID_ADDRESS; - ExecutionContext exe_ctx (GetExecutionContextScope()); + ExecutionContext exe_ctx (GetExecutionContextRef()); Target *target = exe_ctx.GetTargetPtr(); if (target) @@ -242,15 +242,27 @@ ValueObjectVariable::UpdateValue () bool ValueObjectVariable::IsInScope () { - ExecutionContextScope *exe_scope = GetExecutionContextScope(); - if (!exe_scope) - return true; - - StackFrame *frame = exe_scope->CalculateStackFrame(); - if (!frame) - return true; + const ExecutionContextRef &exe_ctx_ref = GetExecutionContextRef(); + if (exe_ctx_ref.HasFrameRef()) + { + ExecutionContext exe_ctx (exe_ctx_ref); + StackFrame *frame = exe_ctx.GetFramePtr(); + if (frame) + { + return m_variable_sp->IsInScope (frame); + } + else + { + // This ValueObject had a frame at one time, but now we + // can't locate it, so return false since we probably aren't + // in scope. + return false; + } + } + // We have a variable that wasn't tied to a frame, which + // means it is a global and is always in scope. + return true; - return m_variable_sp->IsInScope (frame); } Module * diff --git a/lldb/source/Interpreter/ScriptInterpreterPython.cpp b/lldb/source/Interpreter/ScriptInterpreterPython.cpp index 71b7162102a..0aefdaa3fa2 100644 --- a/lldb/source/Interpreter/ScriptInterpreterPython.cpp +++ b/lldb/source/Interpreter/ScriptInterpreterPython.cpp @@ -1330,7 +1330,8 @@ ScriptInterpreterPython::CreateSyntheticScriptedProvider (std::string class_name if (!valobj.get()) return NULL; - Target *target = valobj->GetUpdatePoint().GetTargetSP().get(); + ExecutionContext exe_ctx (valobj->GetExecutionContextRef()); + Target *target = exe_ctx.GetTargetPtr(); if (!target) return NULL; @@ -1448,7 +1449,8 @@ ScriptInterpreterPython::CallPythonScriptFunction (const char *python_function_n if (!valobj.get()) return "<no object>"; - Target *target = valobj->GetUpdatePoint().GetTargetSP().get(); + ExecutionContext exe_ctx (valobj->GetExecutionContextRef()); + Target *target = exe_ctx.GetTargetPtr(); if (!target) return "<no target>"; diff --git a/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp b/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp index 27f80cb3cb5..b8cf0d50120 100644 --- a/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp +++ b/lldb/source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp @@ -65,9 +65,11 @@ ItaniumABILanguageRuntime::GetDynamicTypeAndAddress (ValueObject &in_value, lldb::addr_t original_ptr = in_value.GetPointerValue(&address_type); if (original_ptr == LLDB_INVALID_ADDRESS) return false; - - Target *target = in_value.GetUpdatePoint().GetTargetSP().get(); - Process *process = in_value.GetUpdatePoint().GetProcessSP().get(); + + ExecutionContext exe_ctx (in_value.GetExecutionContextRef()); + + Target *target = exe_ctx.GetTargetPtr(); + Process *process = exe_ctx.GetProcessPtr(); char memory_buffer[16]; DataExtractor data(memory_buffer, sizeof(memory_buffer), diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp index 43c9aa60442..eaae268eb59 100644 --- a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.cpp @@ -39,22 +39,23 @@ using namespace lldb; using namespace lldb_private; bool -AppleObjCRuntime::GetObjectDescription (Stream &str, ValueObject &object) +AppleObjCRuntime::GetObjectDescription (Stream &str, ValueObject &valobj) { bool is_signed; // ObjC objects can only be pointers, but we extend this to integer types because an expression might just // result in an address, and we should try that to see if the address is an ObjC object. - if (!(object.IsPointerType() || object.IsIntegerType(is_signed))) + if (!(valobj.IsPointerType() || valobj.IsIntegerType(is_signed))) return NULL; // Make the argument list: we pass one arg, the address of our pointer, to the print function. Value val; - if (!object.ResolveValue(val.GetScalar())) + if (!valobj.ResolveValue(val.GetScalar())) return NULL; - - return GetObjectDescription(str, val, object.GetExecutionContextScope()); + + ExecutionContext exe_ctx (valobj.GetExecutionContextRef()); + return GetObjectDescription(str, val, exe_ctx.GetBestExecutionContextScope()); } bool diff --git a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp index e3341c95a27..618ccf295fa 100644 --- a/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp +++ b/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp @@ -237,8 +237,9 @@ AppleObjCRuntimeV2::GetDynamicTypeAndAddress (ValueObject &in_value, Address &address) { // The Runtime is attached to a particular process, you shouldn't pass in a value from another process. - assert (in_value.GetUpdatePoint().GetProcessSP().get() == m_process); - + assert (in_value.GetProcessSP().get() == m_process); + assert (m_process != NULL); + // Make sure we can have a dynamic value before starting... if (CouldHaveDynamicValue (in_value)) { @@ -309,10 +310,10 @@ AppleObjCRuntimeV2::GetDynamicTypeAndAddress (ValueObject &in_value, // If the class address didn't point into the binary, or // it points into the right section but there wasn't a symbol // there, try to look it up by calling the class method in the target. - ExecutionContextScope *exe_scope = in_value.GetExecutionContextScope(); - Thread *thread_to_use; - if (exe_scope) - thread_to_use = exe_scope->CalculateThread(); + + ExecutionContext exe_ctx (in_value.GetExecutionContextRef()); + + Thread *thread_to_use = exe_ctx.GetThreadPtr(); if (thread_to_use == NULL) thread_to_use = m_process->GetThreadList().GetSelectedThread().get(); @@ -592,15 +593,20 @@ AppleObjCRuntimeV2::GetISA(ValueObject& valobj) if (IsTaggedPointer(isa_pointer)) return g_objc_Tagged_ISA; - uint8_t pointer_size = valobj.GetUpdatePoint().GetProcessSP()->GetAddressByteSize(); + ExecutionContext exe_ctx (valobj.GetExecutionContextRef()); + + Process *process = exe_ctx.GetProcessPtr(); + if (process) + { + uint8_t pointer_size = process->GetAddressByteSize(); - Error error; - ObjCLanguageRuntime::ObjCISA isa = - valobj.GetUpdatePoint().GetProcessSP()->ReadUnsignedIntegerFromMemory(isa_pointer, - pointer_size, - 0, - error); - return isa; + Error error; + return process->ReadUnsignedIntegerFromMemory (isa_pointer, + pointer_size, + 0, + error); + } + return 0; } // TODO: should we have a transparent_kvo parameter here to say if we diff --git a/lldb/source/Target/ExecutionContext.cpp b/lldb/source/Target/ExecutionContext.cpp index 8360d1addcf..6cce08a093b 100644 --- a/lldb/source/Target/ExecutionContext.cpp +++ b/lldb/source/Target/ExecutionContext.cpp @@ -25,24 +25,51 @@ ExecutionContext::ExecutionContext() : } ExecutionContext::ExecutionContext (const ExecutionContext &rhs) : - m_target_sp (rhs.m_target_sp), + m_target_sp(rhs.m_target_sp), m_process_sp(rhs.m_process_sp), - m_thread_sp (rhs.m_thread_sp), - m_frame_sp (rhs.m_frame_sp) + m_thread_sp(rhs.m_thread_sp), + m_frame_sp(rhs.m_frame_sp) { } -ExecutionContext & -ExecutionContext::operator =(const ExecutionContext &rhs) +ExecutionContext::ExecutionContext (const lldb::TargetSP &target_sp, bool get_process) : + m_target_sp (), + m_process_sp (), + m_thread_sp (), + m_frame_sp () { - if (this != &rhs) - { - m_target_sp = rhs.m_target_sp; - m_process_sp = rhs.m_process_sp; - m_thread_sp = rhs.m_thread_sp; - m_frame_sp = rhs.m_frame_sp; - } - return *this; + if (target_sp) + SetContext (target_sp, get_process); +} + +ExecutionContext::ExecutionContext (const lldb::ProcessSP &process_sp) : + m_target_sp (), + m_process_sp (), + m_thread_sp (), + m_frame_sp () +{ + if (process_sp) + SetContext (process_sp); +} + +ExecutionContext::ExecutionContext (const lldb::ThreadSP &thread_sp) : + m_target_sp (), + m_process_sp (), + m_thread_sp (), + m_frame_sp () +{ + if (thread_sp) + SetContext (thread_sp); +} + +ExecutionContext::ExecutionContext (const lldb::StackFrameSP &frame_sp) : + m_target_sp (), + m_process_sp (), + m_thread_sp (), + m_frame_sp () +{ + if (frame_sp) + SetContext (frame_sp); } ExecutionContext::ExecutionContext (Target* t, bool fill_current_process_thread_frame) : @@ -73,19 +100,39 @@ ExecutionContext::ExecutionContext(Process* process, Thread *thread, StackFrame m_target_sp = process->GetTarget().shared_from_this(); } -ExecutionContext::ExecutionContext (ExecutionContextScope *exe_scope_ptr) +ExecutionContext::ExecutionContext (const ExecutionContextRef &exe_ctx_ref) : + m_target_sp (exe_ctx_ref.GetTargetSP()), + m_process_sp (exe_ctx_ref.GetProcessSP()), + m_thread_sp (exe_ctx_ref.GetThreadSP()), + m_frame_sp (exe_ctx_ref.GetFrameSP()) { - if (exe_scope_ptr) - exe_scope_ptr->CalculateExecutionContext (*this); - else +} + +ExecutionContext::ExecutionContext (const ExecutionContextRef *exe_ctx_ref_ptr) : + m_target_sp (), + m_process_sp (), + m_thread_sp (), + m_frame_sp () +{ + if (exe_ctx_ref_ptr) { - m_target_sp.reset(); - m_process_sp.reset(); - m_thread_sp.reset(); - m_frame_sp.reset(); + m_target_sp = exe_ctx_ref_ptr->GetTargetSP(); + m_process_sp = exe_ctx_ref_ptr->GetProcessSP(); + m_thread_sp = exe_ctx_ref_ptr->GetThreadSP(); + m_frame_sp = exe_ctx_ref_ptr->GetFrameSP(); } } +ExecutionContext::ExecutionContext (ExecutionContextScope *exe_scope_ptr) : + m_target_sp (), + m_process_sp (), + m_thread_sp (), + m_frame_sp () +{ + if (exe_scope_ptr) + exe_scope_ptr->CalculateExecutionContext (*this); +} + ExecutionContext::ExecutionContext (ExecutionContextScope &exe_scope_ref) { exe_scope_ref.CalculateExecutionContext (*this); @@ -104,6 +151,17 @@ ExecutionContext::~ExecutionContext() { } +uint32_t +ExecutionContext::GetAddressByteSize() const +{ + if (m_target_sp && m_target_sp->GetArchitecture().IsValid()) + m_target_sp->GetArchitecture().GetAddressByteSize(); + if (m_process_sp) + m_process_sp->GetAddressByteSize(); + return sizeof(void *); +} + + RegisterContext * ExecutionContext::GetRegisterContext () const @@ -235,3 +293,351 @@ ExecutionContext::SetFramePtr (StackFrame *frame) m_frame_sp.reset(); } +void +ExecutionContext::SetContext (const lldb::TargetSP &target_sp, bool get_process) +{ + m_target_sp = target_sp; + if (get_process && target_sp) + m_process_sp = target_sp->GetProcessSP(); + else + m_process_sp.reset(); + m_thread_sp.reset(); + m_frame_sp.reset(); +} + +void +ExecutionContext::SetContext (const lldb::ProcessSP &process_sp) +{ + m_process_sp = process_sp; + if (process_sp) + m_target_sp = process_sp->GetTarget().shared_from_this(); + else + m_target_sp.reset(); + m_thread_sp.reset(); + m_frame_sp.reset(); +} + +void +ExecutionContext::SetContext (const lldb::ThreadSP &thread_sp) +{ + m_frame_sp.reset(); + m_thread_sp = thread_sp; + if (thread_sp) + { + m_process_sp = thread_sp->GetProcess().shared_from_this(); + if (m_process_sp) + m_target_sp = m_process_sp->GetTarget().shared_from_this(); + else + m_target_sp.reset(); + } + else + { + m_target_sp.reset(); + m_process_sp.reset(); + } +} + +void +ExecutionContext::SetContext (const lldb::StackFrameSP &frame_sp) +{ + m_frame_sp = frame_sp; + if (frame_sp) + { + m_thread_sp = frame_sp->GetThread().shared_from_this(); + if (m_thread_sp) + { + m_process_sp = m_thread_sp->GetProcess().shared_from_this(); + if (m_process_sp) + m_target_sp = m_process_sp->GetTarget().shared_from_this(); + else + m_target_sp.reset(); + } + else + { + m_target_sp.reset(); + m_process_sp.reset(); + } + } + else + { + m_target_sp.reset(); + m_process_sp.reset(); + m_thread_sp.reset(); + } +} + +ExecutionContext & +ExecutionContext::operator =(const ExecutionContext &rhs) +{ + if (this != &rhs) + { + m_target_sp = rhs.m_target_sp; + m_process_sp = rhs.m_process_sp; + m_thread_sp = rhs.m_thread_sp; + m_frame_sp = rhs.m_frame_sp; + } + return *this; +} + +bool +ExecutionContext::operator ==(const ExecutionContext &rhs) const +{ + // Check that the frame shared pointers match, or both are valid and their stack + // IDs match since sometimes we get new objects that represent the same + // frame within a thread. + if ((m_frame_sp == rhs.m_frame_sp) || (m_frame_sp && rhs.m_frame_sp && m_frame_sp->GetStackID() == rhs.m_frame_sp->GetStackID())) + { + // Check that the thread shared pointers match, or both are valid and + // their thread IDs match since sometimes we get new objects that + // represent the same thread within a process. + if ((m_thread_sp == rhs.m_thread_sp) || (m_thread_sp && rhs.m_thread_sp && m_thread_sp->GetID() == rhs.m_thread_sp->GetID())) + { + // Processes and targets don't change much + return m_process_sp == rhs.m_process_sp && m_target_sp == rhs.m_target_sp; + } + } + return false; +} + +bool +ExecutionContext::operator !=(const ExecutionContext &rhs) const +{ + return !(*this == rhs); +} + + +ExecutionContextRef::ExecutionContextRef() : + m_target_wp (), + m_process_wp (), + m_thread_wp (), + m_frame_wp (), + m_tid(LLDB_INVALID_THREAD_ID), + m_stack_id () +{ +} + +ExecutionContextRef::ExecutionContextRef (const ExecutionContext *exe_ctx) : + m_target_wp (), + m_process_wp (), + m_thread_wp (), + m_frame_wp (), + m_tid(LLDB_INVALID_THREAD_ID), + m_stack_id () +{ + if (exe_ctx) + *this = *exe_ctx; +} + +ExecutionContextRef::ExecutionContextRef (const ExecutionContext &exe_ctx) : + m_target_wp (), + m_process_wp (), + m_thread_wp (), + m_frame_wp (), + m_tid(LLDB_INVALID_THREAD_ID), + m_stack_id () +{ + *this = exe_ctx; +} + + +ExecutionContextRef::ExecutionContextRef (Target *target, bool adopt_selected) : + m_target_wp(), + m_process_wp(), + m_thread_wp(), + m_frame_wp(), + m_tid(LLDB_INVALID_THREAD_ID), + m_stack_id () +{ + SetTargetPtr (target, adopt_selected); +} + + + + +ExecutionContextRef::ExecutionContextRef (const ExecutionContextRef &rhs) : + m_target_wp (rhs.m_target_wp), + m_process_wp(rhs.m_process_wp), + m_thread_wp (rhs.m_thread_wp), + m_frame_wp (rhs.m_frame_wp), + m_tid (rhs.m_tid), + m_stack_id (rhs.m_stack_id) +{ +} + +ExecutionContextRef & +ExecutionContextRef::operator =(const ExecutionContextRef &rhs) +{ + if (this != &rhs) + { + m_target_wp = rhs.m_target_wp; + m_process_wp = rhs.m_process_wp; + m_thread_wp = rhs.m_thread_wp; + m_frame_wp = rhs.m_frame_wp; + m_tid = rhs.m_tid; + m_stack_id = rhs.m_stack_id; + } + return *this; +} + +ExecutionContextRef & +ExecutionContextRef::operator =(const ExecutionContext &exe_ctx) +{ + m_target_wp = exe_ctx.GetTargetSP(); + m_process_wp = exe_ctx.GetProcessSP(); + SetThreadSP (exe_ctx.GetThreadSP()); + SetFrameSP (exe_ctx.GetFrameSP()); + return *this; +} + +void +ExecutionContextRef::Clear() +{ + m_target_wp.reset(); + m_process_wp.reset(); + m_thread_wp.reset(); + m_frame_wp.reset(); + m_tid = LLDB_INVALID_THREAD_ID; + m_stack_id.Clear(); +} + +ExecutionContextRef::~ExecutionContextRef() +{ +} + +void +ExecutionContextRef::SetTargetSP (const lldb::TargetSP &target_sp) +{ + m_target_wp = target_sp; +} + +void +ExecutionContextRef::SetProcessSP (const lldb::ProcessSP &process_sp) +{ + m_process_wp = process_sp; +} + +void +ExecutionContextRef::SetThreadSP (const lldb::ThreadSP &thread_sp) +{ + m_thread_wp = thread_sp; + if (thread_sp) + m_tid = thread_sp->GetID(); + else + m_tid = LLDB_INVALID_THREAD_ID; +} + +void +ExecutionContextRef::SetFrameSP (const lldb::StackFrameSP &frame_sp) +{ + m_frame_wp = frame_sp; + if (frame_sp) + m_stack_id = frame_sp->GetStackID(); + else + m_stack_id.Clear(); +} + +void +ExecutionContextRef::SetTargetPtr (Target* target, bool adopt_selected) +{ + Clear(); + if (target) + { + lldb::TargetSP target_sp (target->shared_from_this()); + if (target_sp) + { + m_target_wp = target_sp; + if (adopt_selected) + { + lldb::ProcessSP process_sp (target_sp->GetProcessSP()); + if (process_sp) + { + m_process_wp = process_sp; + if (process_sp) + { + lldb::ThreadSP thread_sp (process_sp->GetThreadList().GetSelectedThread()); + if (!thread_sp) + thread_sp = process_sp->GetThreadList().GetThreadAtIndex(0); + + if (thread_sp) + { + SetThreadSP (thread_sp); + lldb::StackFrameSP frame_sp (thread_sp->GetSelectedFrame()); + if (!frame_sp) + frame_sp = thread_sp->GetStackFrameAtIndex(0); + if (frame_sp) + SetFrameSP (frame_sp); + } + } + } + } + } + } +} + +void +ExecutionContextRef::SetProcessPtr (Process *process) +{ + if (process) + m_process_wp = process->shared_from_this(); + else + m_process_wp.reset(); +} + +void +ExecutionContextRef::SetThreadPtr (Thread *thread) +{ + if (thread) + m_thread_wp = thread->shared_from_this(); + else + m_thread_wp.reset(); +} + +void +ExecutionContextRef::SetFramePtr (StackFrame *frame) +{ + if (frame) + m_frame_wp = frame->shared_from_this(); + else + m_frame_wp.reset(); +} + + +lldb::ThreadSP +ExecutionContextRef::GetThreadSP () const +{ + lldb::ThreadSP thread_sp (m_thread_wp.lock()); + if (!thread_sp && m_tid != LLDB_INVALID_THREAD_ID) + { + lldb::ProcessSP process_sp(GetProcessSP()); + if (process_sp) + { + thread_sp = process_sp->GetThreadList().FindThreadByID(m_tid); + m_thread_wp = thread_sp; + } + } + return thread_sp; +} + +lldb::StackFrameSP +ExecutionContextRef::GetFrameSP () const +{ + lldb::StackFrameSP frame_sp (m_frame_wp.lock()); + if (!frame_sp && m_stack_id.IsValid()) + { + lldb::ThreadSP thread_sp (GetThreadSP()); + if (thread_sp) + { + frame_sp = thread_sp->GetFrameWithStackID (m_stack_id); + m_frame_wp = frame_sp; + } + } + return frame_sp; +} + +ExecutionContext +ExecutionContextRef::Lock () const +{ + return ExecutionContext(this); +} + + diff --git a/lldb/source/Target/StackFrameList.cpp b/lldb/source/Target/StackFrameList.cpp index 76f74f1533c..b69cad2f9c5 100644 --- a/lldb/source/Target/StackFrameList.cpp +++ b/lldb/source/Target/StackFrameList.cpp @@ -332,7 +332,7 @@ StackFrameList::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx) } StackFrameSP -StackFrameList::GetFrameWithStackID (StackID &stack_id) +StackFrameList::GetFrameWithStackID (const StackID &stack_id) { uint32_t frame_idx = 0; StackFrameSP frame_sp; |
