LLDB mainline
ExecutionContext.h
Go to the documentation of this file.
1//===-- ExecutionContext.h --------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLDB_TARGET_EXECUTIONCONTEXT_H
10#define LLDB_TARGET_EXECUTIONCONTEXT_H
11
12#include <mutex>
13
14#include "lldb/Target/StackID.h"
15#include "lldb/lldb-private.h"
16
17namespace lldb_private {
18
19//===----------------------------------------------------------------------===//
20/// Execution context objects refer to objects in the execution of the program
21/// that is being debugged. The consist of one or more of the following
22/// objects: target, process, thread, and frame. Many objects in the debugger
23/// need to track different executions contexts. For example, a local function
24/// variable might have an execution context that refers to a stack frame. A
25/// global or static variable might refer to a target since a stack frame
26/// isn't required in order to evaluate a global or static variable (a process
27/// isn't necessarily needed for a global variable since we might be able to
28/// read the variable value from a data section in one of the object files in
29/// a target). There are two types of objects that hold onto execution
30/// contexts: ExecutionContextRef and ExecutionContext. Both of these objects
31/// are described below.
32///
33/// Not all objects in an ExecutionContext objects will be valid. If you want
34/// to refer strongly (ExecutionContext) or weakly (ExecutionContextRef) to a
35/// process, then only the process and target references will be valid. For
36/// threads, only the thread, process and target references will be filled in.
37/// For frames, all of the objects will be filled in.
38///
39/// These classes are designed to be used as baton objects that get passed to
40/// a wide variety of functions that require execution contexts.
41//===----------------------------------------------------------------------===//
42
43/// \class ExecutionContextRef ExecutionContext.h
44/// "lldb/Target/ExecutionContext.h"
45/// A class that holds a weak reference to an execution context.
46///
47/// ExecutionContextRef objects are designed to hold onto an execution context
48/// that might change over time. For example, if an object wants to refer to a
49/// stack frame, it should hold onto an ExecutionContextRef to a frame object.
50/// The backing object that represents the stack frame might change over time
51/// and instances of this object can track the logical object that refers to a
52/// frame even if it does change.
53///
54/// These objects also don't keep execution objects around longer than they
55/// should since they use weak pointers. For example if an object refers to a
56/// stack frame and a stack frame is no longer in a thread, then a
57/// ExecutionContextRef object that refers to that frame will not be able to
58/// get a shared pointer to those objects since they are no longer around.
59///
60/// ExecutionContextRef objects can also be used as objects in classes that
61/// want to track a "previous execution context". Since the weak references to
62/// the execution objects (target, process, thread and frame) don't keep these
63/// objects around, they are safe to keep around.
64///
65/// The general rule of thumb is all long lived objects that want to refer to
66/// execution contexts should use ExecutionContextRef objects. The
67/// ExecutionContext class is used to temporarily get shared pointers to any
68/// execution context objects that are still around so they are guaranteed to
69/// exist during a function that requires the objects. ExecutionContext
70/// objects should NOT be used for long term storage since they will keep
71/// objects alive with extra shared pointer references to these objects.
73public:
74 /// Default Constructor.
76
77 /// Copy Constructor.
79
80 /// Construct using an ExecutionContext object that might be nullptr.
81 ///
82 /// If \a exe_ctx_ptr is valid, then make weak references to any valid
83 /// objects in the ExecutionContext, otherwise no weak references to any
84 /// execution context objects will be made.
85 ExecutionContextRef(const ExecutionContext *exe_ctx_ptr);
86
87 /// Construct using an ExecutionContext object.
88 ///
89 /// Make weak references to any valid objects in the ExecutionContext.
91
92 /// Construct using the target and all the selected items inside of it (the
93 /// process and its selected thread, and the thread's selected frame). If
94 /// there is no selected thread, default to the first thread If there is no
95 /// selected frame, default to the first frame.
96 ExecutionContextRef(Target *target, bool adopt_selected);
97
98 /// Construct using an execution context scope.
99 ///
100 /// If the ExecutionContextScope object is valid and refers to a frame, make
101 /// weak references too the frame, thread, process and target. If the
102 /// ExecutionContextScope object is valid and refers to a thread, make weak
103 /// references too the thread, process and target. If the
104 /// ExecutionContextScope object is valid and refers to a process, make weak
105 /// references too the process and target. If the ExecutionContextScope
106 /// object is valid and refers to a target, make weak references too the
107 /// target.
109
110 /// Construct using an execution context scope.
111 ///
112 /// If the ExecutionContextScope object refers to a frame, make weak
113 /// references too the frame, thread, process and target. If the
114 /// ExecutionContextScope object refers to a thread, make weak references
115 /// too the thread, process and target. If the ExecutionContextScope object
116 /// refers to a process, make weak references too the process and target. If
117 /// the ExecutionContextScope object refers to a target, make weak
118 /// references too the target.
120
122
123 /// Assignment operator
124 ///
125 /// Copy all weak references in \a rhs.
127
128 /// Assignment operator from a ExecutionContext
129 ///
130 /// Make weak references to any strongly referenced objects in \a exe_ctx.
132
133 /// Clear the object's state.
134 ///
135 /// Sets the process and thread to nullptr, and the frame index to an
136 /// invalid value.
137 void Clear();
138
139 /// Set accessor that creates a weak reference to the target referenced in
140 /// \a target_sp.
141 ///
142 /// If \a target_sp is valid this object will create a weak reference to
143 /// that object, otherwise any previous target weak reference contained in
144 /// this object will be reset.
145 ///
146 /// Only the weak reference to the target will be updated, no other weak
147 /// references will be modified. If you want this execution context to make
148 /// a weak reference to the target's process, use the
149 /// ExecutionContextRef::SetContext() functions.
150 ///
151 /// \see ExecutionContextRef::SetContext(const lldb::TargetSP &, bool)
152 void SetTargetSP(const lldb::TargetSP &target_sp);
153
154 /// Set accessor that creates a weak reference to the process referenced in
155 /// \a process_sp.
156 ///
157 /// If \a process_sp is valid this object will create a weak reference to
158 /// that object, otherwise any previous process weak reference contained in
159 /// this object will be reset.
160 ///
161 /// Only the weak reference to the process will be updated, no other weak
162 /// references will be modified. If you want this execution context to make
163 /// a weak reference to the target, use the
164 /// ExecutionContextRef::SetContext() functions.
165 ///
166 /// \see ExecutionContextRef::SetContext(const lldb::ProcessSP &)
167 void SetProcessSP(const lldb::ProcessSP &process_sp);
168
169 /// Set accessor that creates a weak reference to the thread referenced in
170 /// \a thread_sp.
171 ///
172 /// If \a thread_sp is valid this object will create a weak reference to
173 /// that object, otherwise any previous thread weak reference contained in
174 /// this object will be reset.
175 ///
176 /// Only the weak reference to the thread will be updated, no other weak
177 /// references will be modified. If you want this execution context to make
178 /// a weak reference to the thread's process and target, use the
179 /// ExecutionContextRef::SetContext() functions.
180 ///
181 /// \see ExecutionContextRef::SetContext(const lldb::ThreadSP &)
182 void SetThreadSP(const lldb::ThreadSP &thread_sp);
183
184 /// Set accessor that creates a weak reference to the frame referenced in \a
185 /// frame_sp.
186 ///
187 /// If \a frame_sp is valid this object will create a weak reference to that
188 /// object, otherwise any previous frame weak reference contained in this
189 /// object will be reset.
190 ///
191 /// Only the weak reference to the frame will be updated, no other weak
192 /// references will be modified. If you want this execution context to make
193 /// a weak reference to the frame's thread, process and target, use the
194 /// ExecutionContextRef::SetContext() functions.
195 ///
196 /// \see ExecutionContextRef::SetContext(const lldb::StackFrameSP &)
197 void SetFrameSP(const lldb::StackFrameSP &frame_sp);
198
199 void SetTargetPtr(Target *target, bool adopt_selected);
200
201 void SetProcessPtr(Process *process);
202
203 void SetThreadPtr(Thread *thread);
204
205 void SetFramePtr(StackFrame *frame);
206
207 /// Get accessor that creates a strong reference from the weak target
208 /// reference contained in this object.
209 ///
210 /// \returns
211 /// A shared pointer to a target that is not guaranteed to be valid.
213
214 /// Get accessor that creates a strong reference from the weak process
215 /// reference contained in this object.
216 ///
217 /// \returns
218 /// A shared pointer to a process that is not guaranteed to be valid.
220
221 /// Get accessor that creates a strong reference from the weak thread
222 /// reference contained in this object.
223 ///
224 /// \returns
225 /// A shared pointer to a thread that is not guaranteed to be valid.
227
228 /// Get accessor that creates a strong reference from the weak frame
229 /// reference contained in this object.
230 ///
231 /// \returns
232 /// A shared pointer to a frame that is not guaranteed to be valid.
234
235 /// Create an ExecutionContext object from this object.
236 ///
237 /// Create strong references to any execution context objects that are still
238 /// valid. Any of the returned shared pointers in the ExecutionContext
239 /// objects is not guaranteed to be valid. \returns
240 /// An execution context object that has strong references to
241 /// any valid weak references in this object.
242 ExecutionContext Lock(bool thread_and_frame_only_if_stopped) const;
243
244 /// Returns true if this object has a weak reference to a thread. The return
245 /// value is only an indication of whether this object has a weak reference
246 /// and does not indicate whether the weak reference is valid or not.
247 bool HasThreadRef() const { return m_tid != LLDB_INVALID_THREAD_ID; }
248
249 /// Returns true if this object has a weak reference to a frame. The return
250 /// value is only an indication of whether this object has a weak reference
251 /// and does not indicate whether the weak reference is valid or not.
252 bool HasFrameRef() const { return m_stack_id.IsValid(); }
253
254 void ClearThread() {
255 m_thread_wp.reset();
257 }
258
260
261protected:
262 // Member variables
263 lldb::TargetWP m_target_wp; ///< A weak reference to a target
264 lldb::ProcessWP m_process_wp; ///< A weak reference to a process
265 mutable lldb::ThreadWP m_thread_wp; ///< A weak reference to a thread
266 lldb::tid_t m_tid = LLDB_INVALID_THREAD_ID; ///< The thread ID that this
267 ///< object refers to in case the
268 /// backing object changes
269 StackID m_stack_id; ///< The stack ID that this object refers to in case the
270 ///backing object changes
271};
272
273/// \class ExecutionContext ExecutionContext.h
274/// "lldb/Target/ExecutionContext.h"
275/// A class that contains an execution context.
276///
277/// This baton object can be passed into any function that requires a context
278/// that specifies a target, process, thread and frame. These objects are
279/// designed to be used for short term execution context object storage while
280/// a function might be trying to evaluate something that requires a thread or
281/// frame. ExecutionContextRef objects can be used to initialize one of these
282/// objects to turn the weak execution context object references to the
283/// target, process, thread and frame into strong references (shared pointers)
284/// so that functions can guarantee that these objects won't go away in the
285/// middle of a function.
286///
287/// ExecutionContext objects should be used as short lived objects (typically
288/// on the stack) in order to lock down an execution context for local use and
289/// for passing down to other functions that also require specific contexts.
290/// They should NOT be used for long term storage, for long term storage use
291/// ExecutionContextRef objects.
293public:
294 /// Default Constructor.
296
297 // Copy constructor
299
300 // Adopt the target and optionally its current context.
301 ExecutionContext(Target *t, bool fill_current_process_thread_frame = true);
302
303 // Create execution contexts from shared pointers
304 ExecutionContext(const lldb::TargetSP &target_sp, bool get_process);
305 ExecutionContext(const lldb::ProcessSP &process_sp);
306 ExecutionContext(const lldb::ThreadSP &thread_sp);
307 ExecutionContext(const lldb::StackFrameSP &frame_sp);
308
309 // Create execution contexts from weak pointers
310 ExecutionContext(const lldb::TargetWP &target_wp, bool get_process);
311 ExecutionContext(const lldb::ProcessWP &process_wp);
312 ExecutionContext(const lldb::ThreadWP &thread_wp);
313 ExecutionContext(const lldb::StackFrameWP &frame_wp);
314 ExecutionContext(const ExecutionContextRef &exe_ctx_ref);
315 ExecutionContext(const ExecutionContextRef *exe_ctx_ref,
316 bool thread_and_frame_only_if_stopped = false);
317
318 // These two variants take in a locker, and grab the target, lock the API
319 // mutex into locker, then fill in the rest of the shared pointers.
320 ExecutionContext(const ExecutionContextRef &exe_ctx_ref,
321 std::unique_lock<std::recursive_mutex> &locker);
322 ExecutionContext(const ExecutionContextRef *exe_ctx_ref,
323 std::unique_lock<std::recursive_mutex> &locker);
324 // Create execution contexts from execution context scopes
327
328 /// Construct with process, thread, and frame index.
329 ///
330 /// Initialize with process \a p, thread \a t, and frame index \a f.
331 ///
332 /// \param[in] process
333 /// The process for this execution context.
334 ///
335 /// \param[in] thread
336 /// The thread for this execution context.
337 ///
338 /// \param[in] frame
339 /// The frame index for this execution context.
340 ExecutionContext(Process *process, Thread *thread = nullptr,
341 StackFrame *frame = nullptr);
342
344
346
347 bool operator==(const ExecutionContext &rhs) const;
348
349 bool operator!=(const ExecutionContext &rhs) const;
350
351 /// Clear the object's state.
352 ///
353 /// Sets the process and thread to nullptr, and the frame index to an
354 /// invalid value.
355 void Clear();
356
358
360
361 uint32_t GetAddressByteSize() const;
362
364
365 /// Returns a pointer to the target object.
366 ///
367 /// The returned pointer might be nullptr. Calling HasTargetScope(),
368 /// HasProcessScope(), HasThreadScope(), or HasFrameScope() can help to pre-
369 /// validate this pointer so that this accessor can freely be used without
370 /// having to check for nullptr each time.
371 ///
372 /// \see ExecutionContext::HasTargetScope() const @see
373 /// ExecutionContext::HasProcessScope() const @see
374 /// ExecutionContext::HasThreadScope() const @see
375 /// ExecutionContext::HasFrameScope() const
376 Target *GetTargetPtr() const;
377
378 /// Returns a pointer to the process object.
379 ///
380 /// The returned pointer might be nullptr. Calling HasProcessScope(),
381 /// HasThreadScope(), or HasFrameScope() can help to pre-validate this
382 /// pointer so that this accessor can freely be used without having to check
383 /// for nullptr each time.
384 ///
385 /// \see ExecutionContext::HasProcessScope() const @see
386 /// ExecutionContext::HasThreadScope() const @see
387 /// ExecutionContext::HasFrameScope() const
388 Process *GetProcessPtr() const;
389
390 /// Returns a pointer to the thread object.
391 ///
392 /// The returned pointer might be nullptr. Calling HasThreadScope() or
393 /// HasFrameScope() can help to pre-validate this pointer so that this
394 /// accessor can freely be used without having to check for nullptr each
395 /// time.
396 ///
397 /// \see ExecutionContext::HasThreadScope() const @see
398 /// ExecutionContext::HasFrameScope() const
399 Thread *GetThreadPtr() const { return m_thread_sp.get(); }
400
401 /// Returns a pointer to the frame object.
402 ///
403 /// The returned pointer might be nullptr. Calling HasFrameScope(), can help
404 /// to pre-validate this pointer so that this accessor can freely be used
405 /// without having to check for nullptr each time.
406 ///
407 /// \see ExecutionContext::HasFrameScope() const
408 StackFrame *GetFramePtr() const { return m_frame_sp.get(); }
409
410 /// Returns a reference to the target object.
411 ///
412 /// Clients should call HasTargetScope(), HasProcessScope(),
413 /// HasThreadScope(), or HasFrameScope() prior to calling this function to
414 /// ensure that this ExecutionContext object contains a valid target.
415 ///
416 /// \see ExecutionContext::HasTargetScope() const @see
417 /// ExecutionContext::HasProcessScope() const @see
418 /// ExecutionContext::HasThreadScope() const @see
419 /// ExecutionContext::HasFrameScope() const
420 Target &GetTargetRef() const;
421
422 /// Returns a reference to the process object.
423 ///
424 /// Clients should call HasProcessScope(), HasThreadScope(), or
425 /// HasFrameScope() prior to calling this function to ensure that this
426 /// ExecutionContext object contains a valid target.
427 ///
428 /// \see ExecutionContext::HasProcessScope() const @see
429 /// ExecutionContext::HasThreadScope() const @see
430 /// ExecutionContext::HasFrameScope() const
431 Process &GetProcessRef() const;
432
433 /// Returns a reference to the thread object.
434 ///
435 /// Clients should call HasThreadScope(), or HasFrameScope() prior to
436 /// calling this function to ensure that this ExecutionContext object
437 /// contains a valid target.
438 ///
439 /// \see ExecutionContext::HasThreadScope() const @see
440 /// ExecutionContext::HasFrameScope() const
441 Thread &GetThreadRef() const;
442
443 /// Returns a reference to the thread object.
444 ///
445 /// Clients should call HasFrameScope() prior to calling this function to
446 /// ensure that this ExecutionContext object contains a valid target.
447 ///
448 /// \see ExecutionContext::HasFrameScope() const
449 StackFrame &GetFrameRef() const;
450
451 /// Get accessor to get the target shared pointer.
452 ///
453 /// The returned shared pointer is not guaranteed to be valid.
454 const lldb::TargetSP &GetTargetSP() const { return m_target_sp; }
455
456 /// Get accessor to get the process shared pointer.
457 ///
458 /// The returned shared pointer is not guaranteed to be valid.
459 const lldb::ProcessSP &GetProcessSP() const { return m_process_sp; }
460
461 /// Get accessor to get the thread shared pointer.
462 ///
463 /// The returned shared pointer is not guaranteed to be valid.
464 const lldb::ThreadSP &GetThreadSP() const { return m_thread_sp; }
465
466 /// Get accessor to get the frame shared pointer.
467 ///
468 /// The returned shared pointer is not guaranteed to be valid.
469 const lldb::StackFrameSP &GetFrameSP() const { return m_frame_sp; }
470
471 /// Set accessor to set only the target shared pointer.
472 void SetTargetSP(const lldb::TargetSP &target_sp);
473
474 /// Set accessor to set only the process shared pointer.
475 void SetProcessSP(const lldb::ProcessSP &process_sp);
476
477 /// Set accessor to set only the thread shared pointer.
478 void SetThreadSP(const lldb::ThreadSP &thread_sp);
479
480 /// Set accessor to set only the frame shared pointer.
481 void SetFrameSP(const lldb::StackFrameSP &frame_sp);
482
483 /// Set accessor to set only the target shared pointer from a target
484 /// pointer.
485 void SetTargetPtr(Target *target);
486
487 /// Set accessor to set only the process shared pointer from a process
488 /// pointer.
489 void SetProcessPtr(Process *process);
490
491 /// Set accessor to set only the thread shared pointer from a thread
492 /// pointer.
493 void SetThreadPtr(Thread *thread);
494
495 /// Set accessor to set only the frame shared pointer from a frame pointer.
496 void SetFramePtr(StackFrame *frame);
497
498 // Set the execution context using a target shared pointer.
499 //
500 // If "target_sp" is valid, sets the target context to match and if
501 // "get_process" is true, sets the process shared pointer if the target
502 // currently has a process.
503 void SetContext(const lldb::TargetSP &target_sp, bool get_process);
504
505 // Set the execution context using a process shared pointer.
506 //
507 // If "process_sp" is valid, then set the process and target in this context.
508 // Thread and frame contexts will be cleared. If "process_sp" is not valid,
509 // all shared pointers are reset.
510 void SetContext(const lldb::ProcessSP &process_sp);
511
512 // Set the execution context using a thread shared pointer.
513 //
514 // If "thread_sp" is valid, then set the thread, process and target in this
515 // context. The frame context will be cleared. If "thread_sp" is not valid,
516 // all shared pointers are reset.
517 void SetContext(const lldb::ThreadSP &thread_sp);
518
519 // Set the execution context using a frame shared pointer.
520 //
521 // If "frame_sp" is valid, then set the frame, thread, process and target in
522 // this context If "frame_sp" is not valid, all shared pointers are reset.
523 void SetContext(const lldb::StackFrameSP &frame_sp);
524
525 /// Returns true the ExecutionContext object contains a valid target.
526 ///
527 /// This function can be called after initializing an ExecutionContext
528 /// object, and if it returns true, calls to GetTargetPtr() and
529 /// GetTargetRef() do not need to be checked for validity.
530 bool HasTargetScope() const;
531
532 /// Returns true the ExecutionContext object contains a valid target and
533 /// process.
534 ///
535 /// This function can be called after initializing an ExecutionContext
536 /// object, and if it returns true, calls to GetTargetPtr() and
537 /// GetTargetRef(), GetProcessPtr(), and GetProcessRef(), do not need to be
538 /// checked for validity.
539 bool HasProcessScope() const;
540
541 /// Returns true the ExecutionContext object contains a valid target,
542 /// process, and thread.
543 ///
544 /// This function can be called after initializing an ExecutionContext
545 /// object, and if it returns true, calls to GetTargetPtr(), GetTargetRef(),
546 /// GetProcessPtr(), GetProcessRef(), GetThreadPtr(), and GetThreadRef() do
547 /// not need to be checked for validity.
548 bool HasThreadScope() const;
549
550 /// Returns true the ExecutionContext object contains a valid target,
551 /// process, thread and frame.
552 ///
553 /// This function can be called after initializing an ExecutionContext
554 /// object, and if it returns true, calls to GetTargetPtr(), GetTargetRef(),
555 /// GetProcessPtr(), GetProcessRef(), GetThreadPtr(), GetThreadRef(),
556 /// GetFramePtr(), and GetFrameRef() do not need to be checked for validity.
557 bool HasFrameScope() const;
558
559protected:
560 // Member variables
561 lldb::TargetSP m_target_sp; ///< The target that owns the process/thread/frame
562 lldb::ProcessSP m_process_sp; ///< The process that owns the thread/frame
563 lldb::ThreadSP m_thread_sp; ///< The thread that owns the frame
564 lldb::StackFrameSP m_frame_sp; ///< The stack frame in thread.
565};
566
567} // namespace lldb_private
568
569#endif // LLDB_TARGET_EXECUTIONCONTEXT_H
Execution context objects refer to objects in the execution of the program that is being debugged.
ExecutionContextRef(const ExecutionContextRef &rhs)
Copy Constructor.
StackID m_stack_id
The stack ID that this object refers to in case the backing object changes.
bool HasFrameRef() const
Returns true if this object has a weak reference to a frame.
ExecutionContext Lock(bool thread_and_frame_only_if_stopped) const
Create an ExecutionContext object from this object.
void SetThreadSP(const lldb::ThreadSP &thread_sp)
Set accessor that creates a weak reference to the thread referenced in thread_sp.
void Clear()
Clear the object's state.
lldb::StackFrameSP GetFrameSP() const
Get accessor that creates a strong reference from the weak frame reference contained in this object.
lldb::ProcessWP m_process_wp
A weak reference to a process.
ExecutionContextRef(ExecutionContextScope *exe_scope)
Construct using an execution context scope.
lldb::ThreadSP GetThreadSP() const
Get accessor that creates a strong reference from the weak thread reference contained in this object.
void SetFrameSP(const lldb::StackFrameSP &frame_sp)
Set accessor that creates a weak reference to the frame referenced in frame_sp.
lldb::tid_t m_tid
The thread ID that this object refers to in case the backing object changes.
lldb::TargetSP GetTargetSP() const
Get accessor that creates a strong reference from the weak target reference contained in this object.
bool HasThreadRef() const
Returns true if this object has a weak reference to a thread.
void SetTargetPtr(Target *target, bool adopt_selected)
lldb::ProcessSP GetProcessSP() const
Get accessor that creates a strong reference from the weak process reference contained in this object...
ExecutionContextRef & operator=(const ExecutionContextRef &rhs)
Assignment operator.
void SetProcessPtr(Process *process)
void SetFramePtr(StackFrame *frame)
ExecutionContextRef()
Default Constructor.
void SetTargetSP(const lldb::TargetSP &target_sp)
Set accessor that creates a weak reference to the target referenced in target_sp.
lldb::TargetWP m_target_wp
A weak reference to a target.
void SetProcessSP(const lldb::ProcessSP &process_sp)
Set accessor that creates a weak reference to the process referenced in process_sp.
lldb::ThreadWP m_thread_wp
A weak reference to a thread.
ExecutionContextRef(ExecutionContextScope &exe_scope)
Construct using an execution context scope.
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
void SetFrameSP(const lldb::StackFrameSP &frame_sp)
Set accessor to set only the frame shared pointer.
bool HasThreadScope() const
Returns true the ExecutionContext object contains a valid target, process, and thread.
void SetProcessPtr(Process *process)
Set accessor to set only the process shared pointer from a process pointer.
bool HasProcessScope() const
Returns true the ExecutionContext object contains a valid target and process.
ExecutionContextScope * GetBestExecutionContextScope() const
ExecutionContext(const ExecutionContext &rhs)
const lldb::TargetSP & GetTargetSP() const
Get accessor to get the target shared pointer.
void Clear()
Clear the object's state.
ExecutionContext()
Default Constructor.
const lldb::ProcessSP & GetProcessSP() const
Get accessor to get the process shared pointer.
void SetProcessSP(const lldb::ProcessSP &process_sp)
Set accessor to set only the process shared pointer.
lldb::StackFrameSP m_frame_sp
The stack frame in thread.
bool operator==(const ExecutionContext &rhs) const
void SetThreadPtr(Thread *thread)
Set accessor to set only the thread shared pointer from a thread pointer.
lldb::ByteOrder GetByteOrder() const
void SetTargetPtr(Target *target)
Set accessor to set only the target shared pointer from a target pointer.
lldb::TargetSP m_target_sp
The target that owns the process/thread/frame.
StackFrame * GetFramePtr() const
Returns a pointer to the frame object.
const lldb::StackFrameSP & GetFrameSP() const
Get accessor to get the frame shared pointer.
Process & GetProcessRef() const
Returns a reference to the process object.
void SetContext(const lldb::TargetSP &target_sp, bool get_process)
void SetTargetSP(const lldb::TargetSP &target_sp)
Set accessor to set only the target shared pointer.
Target * GetTargetPtr() const
Returns a pointer to the target object.
const lldb::ThreadSP & GetThreadSP() const
Get accessor to get the thread shared pointer.
void SetThreadSP(const lldb::ThreadSP &thread_sp)
Set accessor to set only the thread shared pointer.
bool HasTargetScope() const
Returns true the ExecutionContext object contains a valid target.
StackFrame & GetFrameRef() const
Returns a reference to the thread object.
bool HasFrameScope() const
Returns true the ExecutionContext object contains a valid target, process, thread and frame.
lldb::ThreadSP m_thread_sp
The thread that owns the frame.
lldb::ProcessSP m_process_sp
The process that owns the thread/frame.
bool operator!=(const ExecutionContext &rhs) const
Target & GetTargetRef() const
Returns a reference to the target object.
void SetFramePtr(StackFrame *frame)
Set accessor to set only the frame shared pointer from a frame pointer.
ExecutionContext & operator=(const ExecutionContext &rhs)
Process * GetProcessPtr() const
Returns a pointer to the process object.
Thread & GetThreadRef() const
Returns a reference to the thread object.
RegisterContext * GetRegisterContext() const
Thread * GetThreadPtr() const
Returns a pointer to the thread object.
A plug-in interface definition class for debugging a process.
Definition: Process.h:340
This base class provides an interface to stack frames.
Definition: StackFrame.h:42
bool IsValid() const
Definition: StackID.h:47
#define LLDB_INVALID_THREAD_ID
Definition: lldb-defines.h:90
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
std::weak_ptr< lldb_private::StackFrame > StackFrameWP
Definition: lldb-forward.h:413
std::shared_ptr< lldb_private::StackFrame > StackFrameSP
Definition: lldb-forward.h:412
std::shared_ptr< lldb_private::Thread > ThreadSP
Definition: lldb-forward.h:438
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:381
ByteOrder
Byte ordering definitions.
std::weak_ptr< lldb_private::Process > ProcessWP
Definition: lldb-forward.h:384
std::weak_ptr< lldb_private::Target > TargetWP
Definition: lldb-forward.h:437
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:436
std::weak_ptr< lldb_private::Thread > ThreadWP
Definition: lldb-forward.h:439
uint64_t tid_t
Definition: lldb-types.h:82