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