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 
19 ExecutionContext::ExecutionContext()
20     : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp() {}
21 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
163 ExecutionContext::ExecutionContext(ExecutionContextScope &exe_scope_ref) {
164   exe_scope_ref.CalculateExecutionContext(*this);
165 }
166 
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 
176 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 
184 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 
192 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 
200 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 
208 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 
216 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 
226 Target &ExecutionContext::GetTargetRef() const {
227   assert(m_target_sp);
228   return *m_target_sp;
229 }
230 
231 Process &ExecutionContext::GetProcessRef() const {
232   assert(m_process_sp);
233   return *m_process_sp;
234 }
235 
236 Thread &ExecutionContext::GetThreadRef() const {
237   assert(m_thread_sp);
238   return *m_thread_sp;
239 }
240 
241 StackFrame &ExecutionContext::GetFrameRef() const {
242   assert(m_frame_sp);
243   return *m_frame_sp;
244 }
245 
246 void ExecutionContext::SetTargetSP(const lldb::TargetSP &target_sp) {
247   m_target_sp = target_sp;
248 }
249 
250 void ExecutionContext::SetProcessSP(const lldb::ProcessSP &process_sp) {
251   m_process_sp = process_sp;
252 }
253 
254 void ExecutionContext::SetThreadSP(const lldb::ThreadSP &thread_sp) {
255   m_thread_sp = thread_sp;
256 }
257 
258 void ExecutionContext::SetFrameSP(const lldb::StackFrameSP &frame_sp) {
259   m_frame_sp = frame_sp;
260 }
261 
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 
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 
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 
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 
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 
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 
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 
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 
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 
357 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 
377 bool ExecutionContext::operator!=(const ExecutionContext &rhs) const {
378   return !(*this == rhs);
379 }
380 
381 bool ExecutionContext::HasTargetScope() const {
382   return ((bool)m_target_sp && m_target_sp->IsValid());
383 }
384 
385 bool ExecutionContext::HasProcessScope() const {
386   return (HasTargetScope() && ((bool)m_process_sp && m_process_sp->IsValid()));
387 }
388 
389 bool ExecutionContext::HasThreadScope() const {
390   return (HasProcessScope() && ((bool)m_thread_sp && m_thread_sp->IsValid()));
391 }
392 
393 bool ExecutionContext::HasFrameScope() const {
394   return HasThreadScope() && m_frame_sp;
395 }
396 
397 ExecutionContextRef::ExecutionContextRef()
398     : m_target_wp(), m_process_wp(), m_thread_wp(), m_stack_id() {}
399 
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 
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 
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 
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::
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::
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 
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 
463 void ExecutionContextRef::SetTargetSP(const lldb::TargetSP &target_sp) {
464   m_target_wp = target_sp;
465 }
466 
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 
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 
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 
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 
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 
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 
559 void ExecutionContextRef::SetFramePtr(StackFrame *frame) {
560   if (frame)
561     SetFrameSP(frame->shared_from_this());
562   else
563     Clear();
564 }
565 
566 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 
573 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 
580 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 
605 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
615 ExecutionContextRef::Lock(bool thread_and_frame_only_if_stopped) const {
616   return ExecutionContext(this, thread_and_frame_only_if_stopped);
617 }
618