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