1 //===-- ThreadMemory.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 "Plugins/Process/Utility/ThreadMemory.h"
11 #include "lldb/Target/OperatingSystem.h"
12 #include "lldb/Target/RegisterContext.h"
13 #include "lldb/Target/Process.h"
14 #include "lldb/Target/StopInfo.h"
15 #include "lldb/Target/Unwind.h"
16 #include "Plugins/Process/Utility/RegisterContextThreadMemory.h"
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 
21 ThreadMemory::ThreadMemory (Process &process,
22                             tid_t tid,
23                             const ValueObjectSP &thread_info_valobj_sp) :
24     Thread (process, tid),
25     m_backing_thread_sp (),
26     m_thread_info_valobj_sp (thread_info_valobj_sp),
27     m_name(),
28     m_queue()
29 {
30 }
31 
32 
33 ThreadMemory::ThreadMemory (Process &process,
34                             lldb::tid_t tid,
35                             const char *name,
36                             const char *queue,
37                             lldb::addr_t register_data_addr) :
38     Thread (process, tid),
39     m_backing_thread_sp (),
40     m_thread_info_valobj_sp (),
41     m_name(),
42     m_queue(),
43     m_register_data_addr (register_data_addr)
44 {
45     if (name)
46         m_name = name;
47     if (queue)
48         m_queue = queue;
49 }
50 
51 
52 ThreadMemory::~ThreadMemory()
53 {
54     DestroyThread();
55 }
56 
57 void
58 ThreadMemory::WillResume (StateType resume_state)
59 {
60     if (m_backing_thread_sp)
61         m_backing_thread_sp->WillResume(resume_state);
62 }
63 
64 void
65 ThreadMemory::ClearStackFrames ()
66 {
67     if (m_backing_thread_sp)
68         m_backing_thread_sp->ClearStackFrames();
69     Thread::ClearStackFrames();
70 }
71 
72 RegisterContextSP
73 ThreadMemory::GetRegisterContext ()
74 {
75     if (!m_reg_context_sp)
76         m_reg_context_sp.reset (new RegisterContextThreadMemory (*this, m_register_data_addr));
77     return m_reg_context_sp;
78 }
79 
80 RegisterContextSP
81 ThreadMemory::CreateRegisterContextForFrame (StackFrame *frame)
82 {
83     RegisterContextSP reg_ctx_sp;
84     uint32_t concrete_frame_idx = 0;
85 
86     if (frame)
87         concrete_frame_idx = frame->GetConcreteFrameIndex ();
88 
89     if (concrete_frame_idx == 0)
90     {
91         reg_ctx_sp = GetRegisterContext ();
92     }
93     else
94     {
95         Unwind *unwinder = GetUnwinder ();
96         if (unwinder)
97             reg_ctx_sp = unwinder->CreateRegisterContextForFrame (frame);
98     }
99     return reg_ctx_sp;
100 }
101 
102 bool
103 ThreadMemory::CalculateStopInfo ()
104 {
105     if (m_backing_thread_sp)
106     {
107         lldb::StopInfoSP backing_stop_info_sp (m_backing_thread_sp->GetPrivateStopInfo());
108         if (backing_stop_info_sp)
109         {
110             backing_stop_info_sp->SetThread (shared_from_this());
111             SetStopInfo (backing_stop_info_sp);
112             return true;
113         }
114     }
115     else
116     {
117         ProcessSP process_sp (GetProcess());
118 
119         if (process_sp)
120         {
121             OperatingSystem *os = process_sp->GetOperatingSystem ();
122             if (os)
123             {
124                 SetStopInfo (os->CreateThreadStopReason (this));
125                 return true;
126             }
127         }
128     }
129     return false;
130 }
131 
132 void
133 ThreadMemory::RefreshStateAfterStop()
134 {
135     if (m_backing_thread_sp)
136         return m_backing_thread_sp->RefreshStateAfterStop();
137 
138     if (m_reg_context_sp)
139         m_reg_context_sp->InvalidateAllRegisters();
140 }
141