| //===-- ExecutionContext.h --------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| /// Execution context objects refer to objects in the execution of the |
| /// program that is being debugged. The consist of one or more of the |
| /// following objects: target, process, thread, and frame. Many objects |
| /// in the debugger need to track different executions contexts. For |
| /// example, a local function variable might have an execution context |
| /// that refers to a stack frame. A global or static variable might |
| /// refer to a target since a stack frame isn't required in order to |
| /// evaluate a global or static variable (a process isn't necessarily |
| /// needed for a global variable since we might be able to read the |
| /// variable value from a data section in one of the object files in |
| /// a target). There are two types of objects that hold onto execution |
| /// contexts: ExecutionContextRef and ExecutionContext. Both of these |
| /// objects are deascribed below. |
| /// |
| /// Not all objects in an ExectionContext objects will be valid. If you want |
| /// to refer stronly (ExectionContext) or weakly (ExectionContextRef) to |
| /// a process, then only the process and target references will be valid. |
| /// For threads, only the thread, process and target references will be |
| /// filled in. For frames, all of the objects will be filled in. |
| /// |
| /// These classes are designed to be used as baton objects that get passed |
| /// to a wide variety of functions that require execution contexts. |
| //===----------------------------------------------------------------------===// |
| |
| |
| |
| #ifndef liblldb_ExecutionContext_h_ |
| #define liblldb_ExecutionContext_h_ |
| |
| #include "lldb/lldb-private.h" |
| #include "lldb/Target/StackID.h" |
| |
| namespace lldb_private { |
| |
| //---------------------------------------------------------------------- |
| /// @class ExecutionContextRef ExecutionContext.h "lldb/Target/ExecutionContext.h" |
| /// @brief A class that holds a weak reference to an execution context. |
| /// |
| /// ExecutionContextRef objects are designed to hold onto an execution |
| /// context that might change over time. For example, if an object wants |
| /// to refer to a stack frame, it should hold onto an ExecutionContextRef |
| /// to a frame object. The backing object that represents the stack frame |
| /// might change over time and instaces of this object can track the logical |
| /// object that refers to a frame even if it does change. |
| /// |
| /// These objects also don't keep execution objects around longer than they |
| /// should since they use weak pointers. For example if an object refers |
| /// to a stack frame and a stack frame is no longer in a thread, then a |
| /// ExecutionContextRef object that refers to that frame will not be able |
| /// to get a shared pointer to those objects since they are no longer around. |
| /// |
| /// ExecutionContextRef objects can also be used as objects in classes |
| /// that want to track a "previous execution context". Since the weak |
| /// references to the execution objects (target, process, thread and frame) |
| /// don't keep these objects around, they are safe to keep around. |
| /// |
| /// The general rule of thumb is all long lived objects that want to |
| /// refer to execution contexts should use ExecutionContextRef objcts. |
| /// The ExecutionContext class is used to temporarily get shared |
| /// pointers to any execution context objects that are still around |
| /// so they are guaranteed to exist during a function that requires the |
| /// objects. ExecutionContext objects should NOT be used for long term |
| /// storage since they will keep objects alive with extra shared pointer |
| /// references to these objects. |
| //---------------------------------------------------------------------- |
| class ExecutionContextRef |
| { |
| public: |
| //------------------------------------------------------------------ |
| /// Default Constructor. |
| //------------------------------------------------------------------ |
| ExecutionContextRef(); |
| |
| //------------------------------------------------------------------ |
| /// Copy Constructor. |
| //------------------------------------------------------------------ |
| ExecutionContextRef (const ExecutionContextRef &rhs); |
| |
| //------------------------------------------------------------------ |
| /// Construct using an ExecutionContext object that might be NULL. |
| /// |
| /// If \a exe_ctx_ptr is valid, then make weak references to any |
| /// valid objects in the ExecutionContext, othewise no weak |
| /// references to any execution context objects will be made. |
| //------------------------------------------------------------------ |
| ExecutionContextRef (const ExecutionContext *exe_ctx_ptr); |
| |
| //------------------------------------------------------------------ |
| /// Construct using an ExecutionContext object. |
| /// |
| /// Make weak references to any valid objects in the ExecutionContext. |
| //------------------------------------------------------------------ |
| ExecutionContextRef (const ExecutionContext &exe_ctx); |
| |
| //------------------------------------------------------------------ |
| /// Assignment operator |
| /// |
| /// Copy all weak refernces in \a rhs. |
| //------------------------------------------------------------------ |
| ExecutionContextRef & |
| operator =(const ExecutionContextRef &rhs); |
| |
| //------------------------------------------------------------------ |
| /// Assignment operator from a ExecutionContext |
| /// |
| /// Make weak refernces to any stringly referenced objects in \a exe_ctx. |
| //------------------------------------------------------------------ |
| ExecutionContextRef & |
| operator =(const ExecutionContext &exe_ctx); |
| |
| //------------------------------------------------------------------ |
| /// Construct 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); |
| |
| //------------------------------------------------------------------ |
| /// Construct using an execution context scope. |
| /// |
| /// If the ExecutionContextScope object is valid and refers to a frame, |
| /// make weak refernces too the frame, thread, process and target. |
| /// If the ExecutionContextScope object is valid and refers to a thread, |
| /// make weak refernces too the thread, process and target. |
| /// If the ExecutionContextScope object is valid and refers to a process, |
| /// make weak refernces too the process and target. |
| /// If the ExecutionContextScope object is valid and refers to a target, |
| /// make weak refernces too the target. |
| //------------------------------------------------------------------ |
| ExecutionContextRef (ExecutionContextScope *exe_scope); |
| |
| //------------------------------------------------------------------ |
| /// Construct using an execution context scope. |
| /// |
| /// If the ExecutionContextScope object refers to a frame, |
| /// make weak refernces too the frame, thread, process and target. |
| /// If the ExecutionContextScope object refers to a thread, |
| /// make weak refernces too the thread, process and target. |
| /// If the ExecutionContextScope object refers to a process, |
| /// make weak refernces too the process and target. |
| /// If the ExecutionContextScope object refers to a target, |
| /// make weak refernces too the target. |
| //------------------------------------------------------------------ |
| 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 (); |
| |
| //------------------------------------------------------------------ |
| /// Set accessor that creates a weak reference to the target |
| /// referenced in \a target_sp. |
| /// |
| /// If \a target_sp is valid this object will create a weak |
| /// reference to that object, otherwise any previous target weak |
| /// reference contained in this object will be reset. |
| /// |
| /// Only the weak reference to the target will be updated, no other |
| /// weak references will be modified. If you want this execution |
| /// context to make a weak reference to the target's process, use |
| /// the ExecutionContextRef::SetContext() functions. |
| /// |
| /// @see ExecutionContextRef::SetContext(const lldb::TargetSP &, bool) |
| //------------------------------------------------------------------ |
| void |
| SetTargetSP (const lldb::TargetSP &target_sp); |
| |
| //------------------------------------------------------------------ |
| /// Set accessor that creates a weak reference to the process |
| /// referenced in \a process_sp. |
| /// |
| /// If \a process_sp is valid this object will create a weak |
| /// reference to that object, otherwise any previous process weak |
| /// reference contained in this object will be reset. |
| /// |
| /// Only the weak reference to the process will be updated, no other |
| /// weak references will be modified. If you want this execution |
| /// context to make a weak reference to the target, use the |
| /// ExecutionContextRef::SetContext() functions. |
| /// |
| /// @see ExecutionContextRef::SetContext(const lldb::ProcessSP &) |
| //------------------------------------------------------------------ |
| void |
| SetProcessSP (const lldb::ProcessSP &process_sp); |
| |
| //------------------------------------------------------------------ |
| /// Set accessor that creates a weak reference to the thread |
| /// referenced in \a thread_sp. |
| /// |
| /// If \a thread_sp is valid this object will create a weak |
| /// reference to that object, otherwise any previous thread weak |
| /// reference contained in this object will be reset. |
| /// |
| /// Only the weak reference to the thread will be updated, no other |
| /// weak references will be modified. If you want this execution |
| /// context to make a weak reference to the thread's process and |
| /// target, use the ExecutionContextRef::SetContext() functions. |
| /// |
| /// @see ExecutionContextRef::SetContext(const lldb::ThreadSP &) |
| //------------------------------------------------------------------ |
| void |
| SetThreadSP (const lldb::ThreadSP &thread_sp); |
| |
| //------------------------------------------------------------------ |
| /// Set accessor that creates a weak reference to the frame |
| /// referenced in \a frame_sp. |
| /// |
| /// If \a frame_sp is valid this object will create a weak |
| /// reference to that object, otherwise any previous frame weak |
| /// reference contained in this object will be reset. |
| /// |
| /// Only the weak reference to the frame will be updated, no other |
| /// weak references will be modified. If you want this execution |
| /// context to make a weak reference to the frame's thread, process |
| /// and target, use the ExecutionContextRef::SetContext() functions. |
| /// |
| /// @see ExecutionContextRef::SetContext(const lldb::StackFrameSP &) |
| //------------------------------------------------------------------ |
| 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); |
| |
| //------------------------------------------------------------------ |
| /// Get accessor that creates a strong reference from the weak target |
| /// reference contained in this object. |
| /// |
| /// @returns |
| /// A shared pointer to a target that is not guaranteed to be valid. |
| //------------------------------------------------------------------ |
| lldb::TargetSP |
| GetTargetSP () const |
| { |
| return m_target_wp.lock(); |
| } |
| |
| //------------------------------------------------------------------ |
| /// Get accessor that creates a strong reference from the weak process |
| /// reference contained in this object. |
| /// |
| /// @returns |
| /// A shared pointer to a process that is not guaranteed to be valid. |
| //------------------------------------------------------------------ |
| lldb::ProcessSP |
| GetProcessSP () const |
| { |
| return m_process_wp.lock(); |
| } |
| |
| //------------------------------------------------------------------ |
| /// Get accessor that creates a strong reference from the weak thread |
| /// reference contained in this object. |
| /// |
| /// @returns |
| /// A shared pointer to a thread that is not guaranteed to be valid. |
| //------------------------------------------------------------------ |
| lldb::ThreadSP |
| GetThreadSP () const; |
| |
| //------------------------------------------------------------------ |
| /// Get accessor that creates a strong reference from the weak frame |
| /// reference contained in this object. |
| /// |
| /// @returns |
| /// A shared pointer to a frame that is not guaranteed to be valid. |
| //------------------------------------------------------------------ |
| lldb::StackFrameSP |
| GetFrameSP () const; |
| |
| //------------------------------------------------------------------ |
| /// Create an ExecutionContext object from this object. |
| /// |
| /// Create strong references to any execution context objects that |
| /// are still valid. Any of the returned shared pointers in the |
| /// ExecutionContext objects is not guaranteed to be valid. |
| /// @returns |
| /// An execution context object that has strong references to |
| /// any valid weak references in this object. |
| //------------------------------------------------------------------ |
| ExecutionContext |
| Lock () const; |
| |
| //------------------------------------------------------------------ |
| /// Returns true if this object has a weak reference to a thread. |
| /// The return value is only an indication of wether this object has |
| /// a weak reference and does not indicate wether the weak rerference |
| /// is valid or not. |
| //------------------------------------------------------------------ |
| bool |
| HasThreadRef () const |
| { |
| return m_tid != LLDB_INVALID_THREAD_ID; |
| } |
| |
| //------------------------------------------------------------------ |
| /// Returns true if this object has a weak reference to a frame. |
| /// The return value is only an indication of wether this object has |
| /// a weak reference and does not indicate wether the weak rerference |
| /// is valid or not. |
| //------------------------------------------------------------------ |
| bool |
| HasFrameRef () const |
| { |
| return m_stack_id.IsValid(); |
| } |
| |
| void |
| ClearThread () |
| { |
| m_thread_wp.reset(); |
| m_tid = LLDB_INVALID_THREAD_ID; |
| } |
| |
| void |
| ClearFrame () |
| { |
| m_stack_id.Clear(); |
| m_frame_wp.reset(); |
| } |
| |
| protected: |
| //------------------------------------------------------------------ |
| // Member variables |
| //------------------------------------------------------------------ |
| lldb::TargetWP m_target_wp; ///< A weak reference to a target |
| lldb::ProcessWP m_process_wp; ///< A weak reference to a process |
| mutable lldb::ThreadWP m_thread_wp; ///< A weak reference to a thread |
| mutable lldb::StackFrameWP m_frame_wp; ///< A weak reference to a frame |
| lldb::tid_t m_tid; ///< The thread ID that this object refers to in case the backing object changes |
| StackID m_stack_id; ///< The stack ID that this object refers to in case the backing object changes |
| }; |
| |
| //---------------------------------------------------------------------- |
| /// @class ExecutionContext ExecutionContext.h "lldb/Target/ExecutionContext.h" |
| /// @brief A class that contains an execution context. |
| /// |
| /// This baton object can be passed into any function that requires |
| /// a context that specifies a target, process, thread and frame. |
| /// These objects are designed to be used for short term execution |
| /// context object storage while a function might be trying to evaluate |
| /// something that requires a thread or frame. ExecutionContextRef |
| /// objects can be used to initialize one of these objects to turn |
| /// the weak execution context object references to the target, process, |
| /// thread and frame into strong references (shared pointers) so that |
| /// functions can guarantee that these objects won't go away in the |
| /// middle of a function. |
| /// |
| /// ExecutionContext objects should be used as short lived objects |
| /// (typically on the stack) in order to lock down an execution context |
| /// for local use and for passing down to other functions that also |
| /// require specific contexts. They should NOT be used for long term |
| /// storage, for long term storage use ExecutionContextRef objects. |
| //---------------------------------------------------------------------- |
| class ExecutionContext |
| { |
| public: |
| //------------------------------------------------------------------ |
| /// Default Constructor. |
| //------------------------------------------------------------------ |
| ExecutionContext(); |
| |
| //------------------------------------------------------------------ |
| // Copy constructor |
| //------------------------------------------------------------------ |
| ExecutionContext (const ExecutionContext &rhs); |
| |
| //------------------------------------------------------------------ |
| // Adopt the target and optionally its current context. |
| //------------------------------------------------------------------ |
| ExecutionContext (Target* t, bool fill_current_process_thread_frame = true); |
| |
| //------------------------------------------------------------------ |
| // Create execution contexts from shared pointers |
| //------------------------------------------------------------------ |
| 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); |
| //------------------------------------------------------------------ |
| // Create execution contexts from weak pointers |
| //------------------------------------------------------------------ |
| ExecutionContext (const lldb::TargetWP &target_wp, bool get_process); |
| ExecutionContext (const lldb::ProcessWP &process_wp); |
| ExecutionContext (const lldb::ThreadWP &thread_wp); |
| ExecutionContext (const lldb::StackFrameWP &frame_wp); |
| ExecutionContext (const ExecutionContextRef &exe_ctx_ref); |
| ExecutionContext (const ExecutionContextRef *exe_ctx_ref); |
| //------------------------------------------------------------------ |
| // Create execution contexts from execution context scopes |
| //------------------------------------------------------------------ |
| ExecutionContext (ExecutionContextScope *exe_scope); |
| ExecutionContext (ExecutionContextScope &exe_scope); |
| |
| |
| ExecutionContext & |
| operator =(const ExecutionContext &rhs); |
| |
| bool |
| operator ==(const ExecutionContext &rhs) const; |
| |
| bool |
| operator !=(const ExecutionContext &rhs) const; |
| |
| //------------------------------------------------------------------ |
| /// Construct with process, thread, and frame index. |
| /// |
| /// Initialize with process \a p, thread \a t, and frame index \a f. |
| /// |
| /// @param[in] process |
| /// The process for this execution context. |
| /// |
| /// @param[in] thread |
| /// The thread for this execution context. |
| /// |
| /// @param[in] frame |
| /// The frame index for this execution context. |
| //------------------------------------------------------------------ |
| ExecutionContext (Process* process, |
| Thread *thread = NULL, |
| StackFrame * frame = NULL); |
| |
| |
| ~ExecutionContext(); |
| //------------------------------------------------------------------ |
| /// Clear the object's state. |
| /// |
| /// Sets the process and thread to NULL, and the frame index to an |
| /// invalid value. |
| //------------------------------------------------------------------ |
| void |
| Clear (); |
| |
| RegisterContext * |
| GetRegisterContext () const; |
| |
| ExecutionContextScope * |
| GetBestExecutionContextScope () const; |
| |
| uint32_t |
| GetAddressByteSize() const; |
| |
| //------------------------------------------------------------------ |
| /// Returns a pointer to the target object. |
| /// |
| /// The returned pointer might be NULL. Calling HasTargetScope(), |
| /// HasProcessScope(), HasThreadScope(), or HasFrameScope() |
| /// can help to pre-validate this pointer so that this accessor can |
| /// freely be used without having to check for NULL each time. |
| /// |
| /// @see ExecutionContext::HasTargetScope() const |
| /// @see ExecutionContext::HasProcessScope() const |
| /// @see ExecutionContext::HasThreadScope() const |
| /// @see ExecutionContext::HasFrameScope() const |
| //------------------------------------------------------------------ |
| Target * |
| GetTargetPtr () const; |
| |
| //------------------------------------------------------------------ |
| /// Returns a pointer to the process object. |
| /// |
| /// The returned pointer might be NULL. Calling HasProcessScope(), |
| /// HasThreadScope(), or HasFrameScope() can help to pre-validate |
| /// this pointer so that this accessor can freely be used without |
| /// having to check for NULL each time. |
| /// |
| /// @see ExecutionContext::HasProcessScope() const |
| /// @see ExecutionContext::HasThreadScope() const |
| /// @see ExecutionContext::HasFrameScope() const |
| //------------------------------------------------------------------ |
| Process * |
| GetProcessPtr () const; |
| |
| //------------------------------------------------------------------ |
| /// Returns a pointer to the thread object. |
| /// |
| /// The returned pointer might be NULL. Calling HasThreadScope() or |
| /// HasFrameScope() can help to pre-validate this pointer so that |
| /// this accessor can freely be used without having to check for |
| /// NULL each time. |
| /// |
| /// @see ExecutionContext::HasThreadScope() const |
| /// @see ExecutionContext::HasFrameScope() const |
| //------------------------------------------------------------------ |
| Thread * |
| GetThreadPtr () const |
| { |
| return m_thread_sp.get(); |
| } |
| |
| //------------------------------------------------------------------ |
| /// Returns a pointer to the frame object. |
| /// |
| /// The returned pointer might be NULL. Calling HasFrameScope(), |
| /// can help to pre-validate this pointer so that this accessor can |
| /// freely be used without having to check for NULL each time. |
| /// |
| /// @see ExecutionContext::HasFrameScope() const |
| //------------------------------------------------------------------ |
| StackFrame * |
| GetFramePtr () const |
| { |
| return m_frame_sp.get(); |
| } |
| |
| //------------------------------------------------------------------ |
| /// Returns a reference to the target object. |
| /// |
| /// Clients should call HasTargetScope(), HasProcessScope(), |
| /// HasThreadScope(), or HasFrameScope() prior to calling this |
| /// function to ensure that this ExecutionContext object contains |
| /// a valid target. |
| /// |
| /// @see ExecutionContext::HasTargetScope() const |
| /// @see ExecutionContext::HasProcessScope() const |
| /// @see ExecutionContext::HasThreadScope() const |
| /// @see ExecutionContext::HasFrameScope() const |
| //------------------------------------------------------------------ |
| Target & |
| GetTargetRef () const; |
| |
| //------------------------------------------------------------------ |
| /// Returns a reference to the process object. |
| /// |
| /// Clients should call HasProcessScope(), HasThreadScope(), or |
| /// HasFrameScope() prior to calling this function to ensure that |
| /// this ExecutionContext object contains a valid target. |
| /// |
| /// @see ExecutionContext::HasProcessScope() const |
| /// @see ExecutionContext::HasThreadScope() const |
| /// @see ExecutionContext::HasFrameScope() const |
| //------------------------------------------------------------------ |
| Process & |
| GetProcessRef () const; |
| |
| //------------------------------------------------------------------ |
| /// Returns a reference to the thread object. |
| /// |
| /// Clients should call HasThreadScope(), or HasFrameScope() prior |
| /// to calling this function to ensure that this ExecutionContext |
| /// object contains a valid target. |
| /// |
| /// @see ExecutionContext::HasThreadScope() const |
| /// @see ExecutionContext::HasFrameScope() const |
| //------------------------------------------------------------------ |
| Thread & |
| GetThreadRef () const; |
| |
| //------------------------------------------------------------------ |
| /// Returns a reference to the thread object. |
| /// |
| /// Clients should call HasFrameScope() prior to calling this |
| /// function to ensure that this ExecutionContext object contains |
| /// a valid target. |
| /// |
| /// @see ExecutionContext::HasFrameScope() const |
| //------------------------------------------------------------------ |
| StackFrame & |
| GetFrameRef () const; |
| |
| //------------------------------------------------------------------ |
| /// Get accessor to get the target shared pointer. |
| /// |
| /// The returned shared pointer is not guaranteed to be valid. |
| //------------------------------------------------------------------ |
| const lldb::TargetSP & |
| GetTargetSP () const |
| { |
| return m_target_sp; |
| } |
| |
| //------------------------------------------------------------------ |
| /// Get accessor to get the process shared pointer. |
| /// |
| /// The returned shared pointer is not guaranteed to be valid. |
| //------------------------------------------------------------------ |
| const lldb::ProcessSP & |
| GetProcessSP () const |
| { |
| return m_process_sp; |
| } |
| |
| //------------------------------------------------------------------ |
| /// Get accessor to get the thread shared pointer. |
| /// |
| /// The returned shared pointer is not guaranteed to be valid. |
| //------------------------------------------------------------------ |
| const lldb::ThreadSP & |
| GetThreadSP () const |
| { |
| return m_thread_sp; |
| } |
| |
| //------------------------------------------------------------------ |
| /// Get accessor to get the frame shared pointer. |
| /// |
| /// The returned shared pointer is not guaranteed to be valid. |
| //------------------------------------------------------------------ |
| const lldb::StackFrameSP & |
| GetFrameSP () const |
| { |
| return m_frame_sp; |
| } |
| |
| //------------------------------------------------------------------ |
| /// Set accessor to set only the target shared pointer. |
| //------------------------------------------------------------------ |
| void |
| SetTargetSP (const lldb::TargetSP &target_sp); |
| |
| //------------------------------------------------------------------ |
| /// Set accessor to set only the process shared pointer. |
| //------------------------------------------------------------------ |
| void |
| SetProcessSP (const lldb::ProcessSP &process_sp); |
| |
| //------------------------------------------------------------------ |
| /// Set accessor to set only the thread shared pointer. |
| //------------------------------------------------------------------ |
| void |
| SetThreadSP (const lldb::ThreadSP &thread_sp); |
| |
| //------------------------------------------------------------------ |
| /// Set accessor to set only the frame shared pointer. |
| //------------------------------------------------------------------ |
| void |
| SetFrameSP (const lldb::StackFrameSP &frame_sp); |
| |
| //------------------------------------------------------------------ |
| /// Set accessor to set only the target shared pointer from a target |
| /// pointer. |
| //------------------------------------------------------------------ |
| void |
| SetTargetPtr (Target* target); |
| |
| //------------------------------------------------------------------ |
| /// Set accessor to set only the process shared pointer from a |
| /// process pointer. |
| //------------------------------------------------------------------ |
| void |
| SetProcessPtr (Process *process); |
| |
| //------------------------------------------------------------------ |
| /// Set accessor to set only the thread shared pointer from a thread |
| /// pointer. |
| //------------------------------------------------------------------ |
| void |
| SetThreadPtr (Thread *thread); |
| |
| //------------------------------------------------------------------ |
| /// Set accessor to set only the frame shared pointer from a frame |
| /// pointer. |
| //------------------------------------------------------------------ |
| 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 frame 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); |
| |
| //------------------------------------------------------------------ |
| /// Returns true the ExecutionContext object contains a valid |
| /// target. |
| /// |
| /// This function can be called after initializing an ExecutionContext |
| /// object, and if it returns true, calls to GetTargetPtr() and |
| /// GetTargetRef() do not need to be checked for validity. |
| //------------------------------------------------------------------ |
| bool |
| HasTargetScope () const |
| { |
| return m_target_sp; |
| } |
| |
| //------------------------------------------------------------------ |
| /// Returns true the ExecutionContext object contains a valid |
| /// target and process. |
| /// |
| /// This function can be called after initializing an ExecutionContext |
| /// object, and if it returns true, calls to GetTargetPtr() and |
| /// GetTargetRef(), GetProcessPtr(), and GetProcessRef(), do not |
| /// need to be checked for validity. |
| //------------------------------------------------------------------ |
| bool |
| HasProcessScope () const |
| { |
| return m_target_sp && m_process_sp; |
| } |
| |
| //------------------------------------------------------------------ |
| /// Returns true the ExecutionContext object contains a valid |
| /// target, process, and thread. |
| /// |
| /// This function can be called after initializing an ExecutionContext |
| /// object, and if it returns true, calls to GetTargetPtr(), |
| /// GetTargetRef(), GetProcessPtr(), GetProcessRef(), GetThreadPtr(), |
| /// and GetThreadRef() do not need to be checked for validity. |
| //------------------------------------------------------------------ |
| bool |
| HasThreadScope () const |
| { |
| return m_target_sp && m_process_sp && m_thread_sp; |
| } |
| |
| //------------------------------------------------------------------ |
| /// Returns true the ExecutionContext object contains a valid |
| /// target, process, thread and frame. |
| /// |
| /// This function can be called after initializing an ExecutionContext |
| /// object, and if it returns true, calls to GetTargetPtr(), |
| /// GetTargetRef(), GetProcessPtr(), GetProcessRef(), GetThreadPtr(), |
| /// GetThreadRef(), GetFramePtr(), and GetFrameRef() do not need |
| /// to be checked for validity. |
| //------------------------------------------------------------------ |
| bool |
| HasFrameScope () const |
| { |
| return m_target_sp && m_process_sp && m_thread_sp && m_frame_sp; |
| } |
| |
| protected: |
| //------------------------------------------------------------------ |
| // Member variables |
| //------------------------------------------------------------------ |
| lldb::TargetSP m_target_sp; ///< The target that owns the process/thread/frame |
| lldb::ProcessSP m_process_sp; ///< The process that owns the thread/frame |
| 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_ |
