1 //===-- ExecutionContext.cpp ------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "lldb/Target/ExecutionContext.h"
11 #include "lldb/Target/ExecutionContextScope.h"
12 #include "lldb/Target/Process.h"
13 #include "lldb/Target/StackFrame.h"
14 #include "lldb/Target/Target.h"
15 #include "lldb/Target/Thread.h"
16 #include "lldb/Utility/State.h"
17
18 using namespace lldb_private;
19
ExecutionContext()20 ExecutionContext::ExecutionContext()
21 : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {}
22
ExecutionContext(const ExecutionContext & rhs)23 ExecutionContext::ExecutionContext(const ExecutionContext &rhs)
24 : m_target_sp(rhs.m_target_sp), m_process_sp(rhs.m_process_sp),
25 m_thread_sp(rhs.m_thread_sp), m_frame_sp(rhs.m_frame_sp) {}
26
ExecutionContext(const lldb::TargetSP & target_sp,bool get_process)27 ExecutionContext::ExecutionContext(const lldb::TargetSP &target_sp,
28 bool get_process)
29 : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {
30 if (target_sp)
31 SetContext(target_sp, get_process);
32 }
33
ExecutionContext(const lldb::ProcessSP & process_sp)34 ExecutionContext::ExecutionContext(const lldb::ProcessSP &process_sp)
35 : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {
36 if (process_sp)
37 SetContext(process_sp);
38 }
39
ExecutionContext(const lldb::ThreadSP & thread_sp)40 ExecutionContext::ExecutionContext(const lldb::ThreadSP &thread_sp)
41 : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {
42 if (thread_sp)
43 SetContext(thread_sp);
44 }
45
ExecutionContext(const lldb::StackFrameSP & frame_sp)46 ExecutionContext::ExecutionContext(const lldb::StackFrameSP &frame_sp)
47 : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {
48 if (frame_sp)
49 SetContext(frame_sp);
50 }
51
ExecutionContext(const lldb::TargetWP & target_wp,bool get_process)52 ExecutionContext::ExecutionContext(const lldb::TargetWP &target_wp,
53 bool get_process)
54 : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {
55 lldb::TargetSP target_sp(target_wp.lock());
56 if (target_sp)
57 SetContext(target_sp, get_process);
58 }
59
ExecutionContext(const lldb::ProcessWP & process_wp)60 ExecutionContext::ExecutionContext(const lldb::ProcessWP &process_wp)
61 : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {
62 lldb::ProcessSP process_sp(process_wp.lock());
63 if (process_sp)
64 SetContext(process_sp);
65 }
66
ExecutionContext(const lldb::ThreadWP & thread_wp)67 ExecutionContext::ExecutionContext(const lldb::ThreadWP &thread_wp)
68 : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {
69 lldb::ThreadSP thread_sp(thread_wp.lock());
70 if (thread_sp)
71 SetContext(thread_sp);
72 }
73
ExecutionContext(const lldb::StackFrameWP & frame_wp)74 ExecutionContext::ExecutionContext(const lldb::StackFrameWP &frame_wp)
75 : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {
76 lldb::StackFrameSP frame_sp(frame_wp.lock());
77 if (frame_sp)
78 SetContext(frame_sp);
79 }
80
ExecutionContext(Target * t,bool fill_current_process_thread_frame)81 ExecutionContext::ExecutionContext(Target *t,
82 bool fill_current_process_thread_frame)
83 : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {
84 if (t) {
85 m_target_sp = t->shared_from_this();
86 if (fill_current_process_thread_frame) {
87 m_process_sp = t->GetProcessSP();
88 if (m_process_sp) {
89 m_thread_sp = m_process_sp->GetThreadList().GetSelectedThread();
90 if (m_thread_sp)
91 m_frame_sp = m_thread_sp->GetSelectedFrame();
92 }
93 }
94 }
95 }
96
ExecutionContext(Process * process,Thread * thread,StackFrame * frame)97 ExecutionContext::ExecutionContext(Process *process, Thread *thread,
98 StackFrame *frame)
99 : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {
100 if (process) {
101 m_process_sp = process->shared_from_this();
102 m_target_sp = process->GetTarget().shared_from_this();
103 }
104 if (thread)
105 m_thread_sp = thread->shared_from_this();
106 if (frame)
107 m_frame_sp = frame->shared_from_this();
108 }
109
ExecutionContext(const ExecutionContextRef & exe_ctx_ref)110 ExecutionContext::ExecutionContext(const ExecutionContextRef &exe_ctx_ref)
111 : m_target_sp(exe_ctx_ref.GetTargetSP()),
112 m_process_sp(exe_ctx_ref.GetProcessSP()),
113 m_thread_sp(exe_ctx_ref.GetThreadSP()),
114 m_frame_sp(exe_ctx_ref.GetFrameSP()) {}
115
ExecutionContext(const ExecutionContextRef * exe_ctx_ref_ptr,bool thread_and_frame_only_if_stopped)116 ExecutionContext::ExecutionContext(const ExecutionContextRef *exe_ctx_ref_ptr,
117 bool thread_and_frame_only_if_stopped)
118 : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {
119 if (exe_ctx_ref_ptr) {
120 m_target_sp = exe_ctx_ref_ptr->GetTargetSP();
121 m_process_sp = exe_ctx_ref_ptr->GetProcessSP();
122 if (!thread_and_frame_only_if_stopped ||
123 (m_process_sp && StateIsStoppedState(m_process_sp->GetState(), true))) {
124 m_thread_sp = exe_ctx_ref_ptr->GetThreadSP();
125 m_frame_sp = exe_ctx_ref_ptr->GetFrameSP();
126 }
127 }
128 }
129
ExecutionContext(const ExecutionContextRef * exe_ctx_ref_ptr,std::unique_lock<std::recursive_mutex> & lock)130 ExecutionContext::ExecutionContext(const ExecutionContextRef *exe_ctx_ref_ptr,
131 std::unique_lock<std::recursive_mutex> &lock)
132 : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {
133 if (exe_ctx_ref_ptr) {
134 m_target_sp = exe_ctx_ref_ptr->GetTargetSP();
135 if (m_target_sp) {
136 lock = std::unique_lock<std::recursive_mutex>(m_target_sp->GetAPIMutex());
137
138 m_process_sp = exe_ctx_ref_ptr->GetProcessSP();
139 m_thread_sp = exe_ctx_ref_ptr->GetThreadSP();
140 m_frame_sp = exe_ctx_ref_ptr->GetFrameSP();
141 }
142 }
143 }
144
ExecutionContext(const ExecutionContextRef & exe_ctx_ref,std::unique_lock<std::recursive_mutex> & lock)145 ExecutionContext::ExecutionContext(const ExecutionContextRef &exe_ctx_ref,
146 std::unique_lock<std::recursive_mutex> &lock)
147 : m_target_sp(exe_ctx_ref.GetTargetSP()), m_process_sp(), m_thread_sp(),
148 m_frame_sp() {
149 if (m_target_sp) {
150 lock = std::unique_lock<std::recursive_mutex>(m_target_sp->GetAPIMutex());
151
152 m_process_sp = exe_ctx_ref.GetProcessSP();
153 m_thread_sp = exe_ctx_ref.GetThreadSP();
154 m_frame_sp = exe_ctx_ref.GetFrameSP();
155 }
156 }
157
ExecutionContext(ExecutionContextScope * exe_scope_ptr)158 ExecutionContext::ExecutionContext(ExecutionContextScope *exe_scope_ptr)
159 : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {
160 if (exe_scope_ptr)
161 exe_scope_ptr->CalculateExecutionContext(*this);
162 }
163
ExecutionContext(ExecutionContextScope & exe_scope_ref)164 ExecutionContext::ExecutionContext(ExecutionContextScope &exe_scope_ref) {
165 exe_scope_ref.CalculateExecutionContext(*this);
166 }
167
Clear()168 void ExecutionContext::Clear() {
169 m_target_sp.reset();
170 m_process_sp.reset();
171 m_thread_sp.reset();
172 m_frame_sp.reset();
173 }
174
175 ExecutionContext::~ExecutionContext() = default;
176
GetAddressByteSize() const177 uint32_t ExecutionContext::GetAddressByteSize() const {
178 if (m_target_sp && m_target_sp->GetArchitecture().IsValid())
179 return m_target_sp->GetArchitecture().GetAddressByteSize();
180 if (m_process_sp)
181 return m_process_sp->GetAddressByteSize();
182 return sizeof(void *);
183 }
184
GetByteOrder() const185 lldb::ByteOrder ExecutionContext::GetByteOrder() const {
186 if (m_target_sp && m_target_sp->GetArchitecture().IsValid())
187 m_target_sp->GetArchitecture().GetByteOrder();
188 if (m_process_sp)
189 m_process_sp->GetByteOrder();
190 return endian::InlHostByteOrder();
191 }
192
GetRegisterContext() const193 RegisterContext *ExecutionContext::GetRegisterContext() const {
194 if (m_frame_sp)
195 return m_frame_sp->GetRegisterContext().get();
196 else if (m_thread_sp)
197 return m_thread_sp->GetRegisterContext().get();
198 return nullptr;
199 }
200
GetTargetPtr() const201 Target *ExecutionContext::GetTargetPtr() const {
202 if (m_target_sp)
203 return m_target_sp.get();
204 if (m_process_sp)
205 return &m_process_sp->GetTarget();
206 return nullptr;
207 }
208
GetProcessPtr() const209 Process *ExecutionContext::GetProcessPtr() const {
210 if (m_process_sp)
211 return m_process_sp.get();
212 if (m_target_sp)
213 return m_target_sp->GetProcessSP().get();
214 return nullptr;
215 }
216
GetBestExecutionContextScope() const217 ExecutionContextScope *ExecutionContext::GetBestExecutionContextScope() const {
218 if (m_frame_sp)
219 return m_frame_sp.get();
220 if (m_thread_sp)
221 return m_thread_sp.get();
222 if (m_process_sp)
223 return m_process_sp.get();
224 return m_target_sp.get();
225 }
226
GetTargetRef() const227 Target &ExecutionContext::GetTargetRef() const {
228 #if defined(LLDB_CONFIGURATION_DEBUG) || defined(LLDB_CONFIGURATION_RELEASE)
229 assert(m_target_sp);
230 #endif
231 return *m_target_sp;
232 }
233
GetProcessRef() const234 Process &ExecutionContext::GetProcessRef() const {
235 #if defined(LLDB_CONFIGURATION_DEBUG) || defined(LLDB_CONFIGURATION_RELEASE)
236 assert(m_process_sp);
237 #endif
238 return *m_process_sp;
239 }
240
GetThreadRef() const241 Thread &ExecutionContext::GetThreadRef() const {
242 #if defined(LLDB_CONFIGURATION_DEBUG) || defined(LLDB_CONFIGURATION_RELEASE)
243 assert(m_thread_sp);
244 #endif
245 return *m_thread_sp;
246 }
247
GetFrameRef() const248 StackFrame &ExecutionContext::GetFrameRef() const {
249 #if defined(LLDB_CONFIGURATION_DEBUG) || defined(LLDB_CONFIGURATION_RELEASE)
250 assert(m_frame_sp);
251 #endif
252 return *m_frame_sp;
253 }
254
SetTargetSP(const lldb::TargetSP & target_sp)255 void ExecutionContext::SetTargetSP(const lldb::TargetSP &target_sp) {
256 m_target_sp = target_sp;
257 }
258
SetProcessSP(const lldb::ProcessSP & process_sp)259 void ExecutionContext::SetProcessSP(const lldb::ProcessSP &process_sp) {
260 m_process_sp = process_sp;
261 }
262
SetThreadSP(const lldb::ThreadSP & thread_sp)263 void ExecutionContext::SetThreadSP(const lldb::ThreadSP &thread_sp) {
264 m_thread_sp = thread_sp;
265 }
266
SetFrameSP(const lldb::StackFrameSP & frame_sp)267 void ExecutionContext::SetFrameSP(const lldb::StackFrameSP &frame_sp) {
268 m_frame_sp = frame_sp;
269 }
270
SetTargetPtr(Target * target)271 void ExecutionContext::SetTargetPtr(Target *target) {
272 if (target)
273 m_target_sp = target->shared_from_this();
274 else
275 m_target_sp.reset();
276 }
277
SetProcessPtr(Process * process)278 void ExecutionContext::SetProcessPtr(Process *process) {
279 if (process)
280 m_process_sp = process->shared_from_this();
281 else
282 m_process_sp.reset();
283 }
284
SetThreadPtr(Thread * thread)285 void ExecutionContext::SetThreadPtr(Thread *thread) {
286 if (thread)
287 m_thread_sp = thread->shared_from_this();
288 else
289 m_thread_sp.reset();
290 }
291
SetFramePtr(StackFrame * frame)292 void ExecutionContext::SetFramePtr(StackFrame *frame) {
293 if (frame)
294 m_frame_sp = frame->shared_from_this();
295 else
296 m_frame_sp.reset();
297 }
298
SetContext(const lldb::TargetSP & target_sp,bool get_process)299 void ExecutionContext::SetContext(const lldb::TargetSP &target_sp,
300 bool get_process) {
301 m_target_sp = target_sp;
302 if (get_process && target_sp)
303 m_process_sp = target_sp->GetProcessSP();
304 else
305 m_process_sp.reset();
306 m_thread_sp.reset();
307 m_frame_sp.reset();
308 }
309
SetContext(const lldb::ProcessSP & process_sp)310 void ExecutionContext::SetContext(const lldb::ProcessSP &process_sp) {
311 m_process_sp = process_sp;
312 if (process_sp)
313 m_target_sp = process_sp->GetTarget().shared_from_this();
314 else
315 m_target_sp.reset();
316 m_thread_sp.reset();
317 m_frame_sp.reset();
318 }
319
SetContext(const lldb::ThreadSP & thread_sp)320 void ExecutionContext::SetContext(const lldb::ThreadSP &thread_sp) {
321 m_frame_sp.reset();
322 m_thread_sp = thread_sp;
323 if (thread_sp) {
324 m_process_sp = thread_sp->GetProcess();
325 if (m_process_sp)
326 m_target_sp = m_process_sp->GetTarget().shared_from_this();
327 else
328 m_target_sp.reset();
329 } else {
330 m_target_sp.reset();
331 m_process_sp.reset();
332 }
333 }
334
SetContext(const lldb::StackFrameSP & frame_sp)335 void ExecutionContext::SetContext(const lldb::StackFrameSP &frame_sp) {
336 m_frame_sp = frame_sp;
337 if (frame_sp) {
338 m_thread_sp = frame_sp->CalculateThread();
339 if (m_thread_sp) {
340 m_process_sp = m_thread_sp->GetProcess();
341 if (m_process_sp)
342 m_target_sp = m_process_sp->GetTarget().shared_from_this();
343 else
344 m_target_sp.reset();
345 } else {
346 m_target_sp.reset();
347 m_process_sp.reset();
348 }
349 } else {
350 m_target_sp.reset();
351 m_process_sp.reset();
352 m_thread_sp.reset();
353 }
354 }
355
operator =(const ExecutionContext & rhs)356 ExecutionContext &ExecutionContext::operator=(const ExecutionContext &rhs) {
357 if (this != &rhs) {
358 m_target_sp = rhs.m_target_sp;
359 m_process_sp = rhs.m_process_sp;
360 m_thread_sp = rhs.m_thread_sp;
361 m_frame_sp = rhs.m_frame_sp;
362 }
363 return *this;
364 }
365
operator ==(const ExecutionContext & rhs) const366 bool ExecutionContext::operator==(const ExecutionContext &rhs) const {
367 // Check that the frame shared pointers match, or both are valid and their
368 // stack IDs match since sometimes we get new objects that represent the same
369 // frame within a thread.
370 if ((m_frame_sp == rhs.m_frame_sp) ||
371 (m_frame_sp && rhs.m_frame_sp &&
372 m_frame_sp->GetStackID() == rhs.m_frame_sp->GetStackID())) {
373 // Check that the thread shared pointers match, or both are valid and their
374 // thread IDs match since sometimes we get new objects that represent the
375 // same thread within a process.
376 if ((m_thread_sp == rhs.m_thread_sp) ||
377 (m_thread_sp && rhs.m_thread_sp &&
378 m_thread_sp->GetID() == rhs.m_thread_sp->GetID())) {
379 // Processes and targets don't change much
380 return m_process_sp == rhs.m_process_sp && m_target_sp == rhs.m_target_sp;
381 }
382 }
383 return false;
384 }
385
operator !=(const ExecutionContext & rhs) const386 bool ExecutionContext::operator!=(const ExecutionContext &rhs) const {
387 return !(*this == rhs);
388 }
389
HasTargetScope() const390 bool ExecutionContext::HasTargetScope() const {
391 return ((bool)m_target_sp && m_target_sp->IsValid());
392 }
393
HasProcessScope() const394 bool ExecutionContext::HasProcessScope() const {
395 return (HasTargetScope() && ((bool)m_process_sp && m_process_sp->IsValid()));
396 }
397
HasThreadScope() const398 bool ExecutionContext::HasThreadScope() const {
399 return (HasProcessScope() && ((bool)m_thread_sp && m_thread_sp->IsValid()));
400 }
401
HasFrameScope() const402 bool ExecutionContext::HasFrameScope() const {
403 return HasThreadScope() && m_frame_sp;
404 }
405
ExecutionContextRef()406 ExecutionContextRef::ExecutionContextRef()
407 : m_target_wp(), m_process_wp(), m_thread_wp(),
408 m_tid(LLDB_INVALID_THREAD_ID), m_stack_id() {}
409
ExecutionContextRef(const ExecutionContext * exe_ctx)410 ExecutionContextRef::ExecutionContextRef(const ExecutionContext *exe_ctx)
411 : m_target_wp(), m_process_wp(), m_thread_wp(),
412 m_tid(LLDB_INVALID_THREAD_ID), m_stack_id() {
413 if (exe_ctx)
414 *this = *exe_ctx;
415 }
416
ExecutionContextRef(const ExecutionContext & exe_ctx)417 ExecutionContextRef::ExecutionContextRef(const ExecutionContext &exe_ctx)
418 : m_target_wp(), m_process_wp(), m_thread_wp(),
419 m_tid(LLDB_INVALID_THREAD_ID), m_stack_id() {
420 *this = exe_ctx;
421 }
422
ExecutionContextRef(Target * target,bool adopt_selected)423 ExecutionContextRef::ExecutionContextRef(Target *target, bool adopt_selected)
424 : m_target_wp(), m_process_wp(), m_thread_wp(),
425 m_tid(LLDB_INVALID_THREAD_ID), m_stack_id() {
426 SetTargetPtr(target, adopt_selected);
427 }
428
ExecutionContextRef(const ExecutionContextRef & rhs)429 ExecutionContextRef::ExecutionContextRef(const ExecutionContextRef &rhs)
430 : m_target_wp(rhs.m_target_wp), m_process_wp(rhs.m_process_wp),
431 m_thread_wp(rhs.m_thread_wp), m_tid(rhs.m_tid),
432 m_stack_id(rhs.m_stack_id) {}
433
434 ExecutionContextRef &ExecutionContextRef::
operator =(const ExecutionContextRef & rhs)435 operator=(const ExecutionContextRef &rhs) {
436 if (this != &rhs) {
437 m_target_wp = rhs.m_target_wp;
438 m_process_wp = rhs.m_process_wp;
439 m_thread_wp = rhs.m_thread_wp;
440 m_tid = rhs.m_tid;
441 m_stack_id = rhs.m_stack_id;
442 }
443 return *this;
444 }
445
446 ExecutionContextRef &ExecutionContextRef::
operator =(const ExecutionContext & exe_ctx)447 operator=(const ExecutionContext &exe_ctx) {
448 m_target_wp = exe_ctx.GetTargetSP();
449 m_process_wp = exe_ctx.GetProcessSP();
450 lldb::ThreadSP thread_sp(exe_ctx.GetThreadSP());
451 m_thread_wp = thread_sp;
452 if (thread_sp)
453 m_tid = thread_sp->GetID();
454 else
455 m_tid = LLDB_INVALID_THREAD_ID;
456 lldb::StackFrameSP frame_sp(exe_ctx.GetFrameSP());
457 if (frame_sp)
458 m_stack_id = frame_sp->GetStackID();
459 else
460 m_stack_id.Clear();
461 return *this;
462 }
463
Clear()464 void ExecutionContextRef::Clear() {
465 m_target_wp.reset();
466 m_process_wp.reset();
467 ClearThread();
468 ClearFrame();
469 }
470
471 ExecutionContextRef::~ExecutionContextRef() = default;
472
SetTargetSP(const lldb::TargetSP & target_sp)473 void ExecutionContextRef::SetTargetSP(const lldb::TargetSP &target_sp) {
474 m_target_wp = target_sp;
475 }
476
SetProcessSP(const lldb::ProcessSP & process_sp)477 void ExecutionContextRef::SetProcessSP(const lldb::ProcessSP &process_sp) {
478 if (process_sp) {
479 m_process_wp = process_sp;
480 SetTargetSP(process_sp->GetTarget().shared_from_this());
481 } else {
482 m_process_wp.reset();
483 m_target_wp.reset();
484 }
485 }
486
SetThreadSP(const lldb::ThreadSP & thread_sp)487 void ExecutionContextRef::SetThreadSP(const lldb::ThreadSP &thread_sp) {
488 if (thread_sp) {
489 m_thread_wp = thread_sp;
490 m_tid = thread_sp->GetID();
491 SetProcessSP(thread_sp->GetProcess());
492 } else {
493 ClearThread();
494 m_process_wp.reset();
495 m_target_wp.reset();
496 }
497 }
498
SetFrameSP(const lldb::StackFrameSP & frame_sp)499 void ExecutionContextRef::SetFrameSP(const lldb::StackFrameSP &frame_sp) {
500 if (frame_sp) {
501 m_stack_id = frame_sp->GetStackID();
502 SetThreadSP(frame_sp->GetThread());
503 } else {
504 ClearFrame();
505 ClearThread();
506 m_process_wp.reset();
507 m_target_wp.reset();
508 }
509 }
510
SetTargetPtr(Target * target,bool adopt_selected)511 void ExecutionContextRef::SetTargetPtr(Target *target, bool adopt_selected) {
512 Clear();
513 if (target) {
514 lldb::TargetSP target_sp(target->shared_from_this());
515 if (target_sp) {
516 m_target_wp = target_sp;
517 if (adopt_selected) {
518 lldb::ProcessSP process_sp(target_sp->GetProcessSP());
519 if (process_sp) {
520 m_process_wp = process_sp;
521 if (process_sp) {
522 // Only fill in the thread and frame if our process is stopped
523 // Don't just check the state, since we might be in the middle of
524 // resuming.
525 Process::StopLocker stop_locker;
526
527 if (stop_locker.TryLock(&process_sp->GetRunLock()) &&
528 StateIsStoppedState(process_sp->GetState(), true)) {
529 lldb::ThreadSP thread_sp(
530 process_sp->GetThreadList().GetSelectedThread());
531 if (!thread_sp)
532 thread_sp = process_sp->GetThreadList().GetThreadAtIndex(0);
533
534 if (thread_sp) {
535 SetThreadSP(thread_sp);
536 lldb::StackFrameSP frame_sp(thread_sp->GetSelectedFrame());
537 if (!frame_sp)
538 frame_sp = thread_sp->GetStackFrameAtIndex(0);
539 if (frame_sp)
540 SetFrameSP(frame_sp);
541 }
542 }
543 }
544 }
545 }
546 }
547 }
548 }
549
SetProcessPtr(Process * process)550 void ExecutionContextRef::SetProcessPtr(Process *process) {
551 if (process) {
552 SetProcessSP(process->shared_from_this());
553 } else {
554 m_process_wp.reset();
555 m_target_wp.reset();
556 }
557 }
558
SetThreadPtr(Thread * thread)559 void ExecutionContextRef::SetThreadPtr(Thread *thread) {
560 if (thread) {
561 SetThreadSP(thread->shared_from_this());
562 } else {
563 ClearThread();
564 m_process_wp.reset();
565 m_target_wp.reset();
566 }
567 }
568
SetFramePtr(StackFrame * frame)569 void ExecutionContextRef::SetFramePtr(StackFrame *frame) {
570 if (frame)
571 SetFrameSP(frame->shared_from_this());
572 else
573 Clear();
574 }
575
GetTargetSP() const576 lldb::TargetSP ExecutionContextRef::GetTargetSP() const {
577 lldb::TargetSP target_sp(m_target_wp.lock());
578 if (target_sp && !target_sp->IsValid())
579 target_sp.reset();
580 return target_sp;
581 }
582
GetProcessSP() const583 lldb::ProcessSP ExecutionContextRef::GetProcessSP() const {
584 lldb::ProcessSP process_sp(m_process_wp.lock());
585 if (process_sp && !process_sp->IsValid())
586 process_sp.reset();
587 return process_sp;
588 }
589
GetThreadSP() const590 lldb::ThreadSP ExecutionContextRef::GetThreadSP() const {
591 lldb::ThreadSP thread_sp(m_thread_wp.lock());
592
593 if (m_tid != LLDB_INVALID_THREAD_ID) {
594 // We check if the thread has been destroyed in cases where clients might
595 // still have shared pointer to a thread, but the thread is not valid
596 // anymore (not part of the process)
597 if (!thread_sp || !thread_sp->IsValid()) {
598 lldb::ProcessSP process_sp(GetProcessSP());
599 if (process_sp && process_sp->IsValid()) {
600 thread_sp = process_sp->GetThreadList().FindThreadByID(m_tid);
601 m_thread_wp = thread_sp;
602 }
603 }
604 }
605
606 // Check that we aren't about to return an invalid thread sp. We might
607 // return a nullptr thread_sp, but don't return an invalid one.
608
609 if (thread_sp && !thread_sp->IsValid())
610 thread_sp.reset();
611
612 return thread_sp;
613 }
614
GetFrameSP() const615 lldb::StackFrameSP ExecutionContextRef::GetFrameSP() const {
616 if (m_stack_id.IsValid()) {
617 lldb::ThreadSP thread_sp(GetThreadSP());
618 if (thread_sp)
619 return thread_sp->GetFrameWithStackID(m_stack_id);
620 }
621 return lldb::StackFrameSP();
622 }
623
624 ExecutionContext
Lock(bool thread_and_frame_only_if_stopped) const625 ExecutionContextRef::Lock(bool thread_and_frame_only_if_stopped) const {
626 return ExecutionContext(this, thread_and_frame_only_if_stopped);
627 }
628