1 //===-- ThreadMemory.h ------------------------------------------*- 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 #ifndef liblldb_ThreadMemory_h_
11 #define liblldb_ThreadMemory_h_
12 
13 // C Includes
14 // C++ Includes
15 #include <string>
16 
17 // Other libraries and framework includes
18 // Project includes
19 #include "lldb/Target/Thread.h"
20 
21 class ThreadMemory :
22     public lldb_private::Thread
23 {
24 public:
25     ThreadMemory (lldb_private::Process &process,
26                   lldb::tid_t tid,
27                   const lldb::ValueObjectSP &thread_info_valobj_sp);
28 
29     ThreadMemory (lldb_private::Process &process,
30                   lldb::tid_t tid,
31                   const char *name,
32                   const char *queue,
33                   lldb::addr_t register_data_addr);
34 
35     ~ThreadMemory() override;
36 
37     lldb::RegisterContextSP
38     GetRegisterContext() override;
39 
40     lldb::RegisterContextSP
41     CreateRegisterContextForFrame(lldb_private::StackFrame *frame) override;
42 
43     bool
44     CalculateStopInfo() override;
45 
46     const char *
47     GetInfo() override
48     {
49         if (m_backing_thread_sp)
50             m_backing_thread_sp->GetInfo();
51         return nullptr;
52     }
53 
54     const char *
55     GetName() override
56     {
57         if (!m_name.empty())
58             return m_name.c_str();
59         if (m_backing_thread_sp)
60             m_backing_thread_sp->GetName();
61         return nullptr;
62     }
63 
64     const char *
65     GetQueueName() override
66     {
67         if (!m_queue.empty())
68             return m_queue.c_str();
69         if (m_backing_thread_sp)
70             m_backing_thread_sp->GetQueueName();
71         return nullptr;
72     }
73 
74     void
75     WillResume(lldb::StateType resume_state) override;
76 
77     void
78     DidResume() override
79     {
80         if (m_backing_thread_sp)
81             m_backing_thread_sp->DidResume();
82     }
83 
84     lldb::user_id_t
85     GetProtocolID() const override
86     {
87         if (m_backing_thread_sp)
88             return m_backing_thread_sp->GetProtocolID();
89         return Thread::GetProtocolID();
90     }
91 
92     void
93     RefreshStateAfterStop() override;
94 
95     lldb::ValueObjectSP &
96     GetValueObject ()
97     {
98         return m_thread_info_valobj_sp;
99     }
100 
101     void
102     ClearStackFrames() override;
103 
104     void
105     ClearBackingThread() override
106     {
107         m_backing_thread_sp.reset();
108     }
109 
110     bool
111     SetBackingThread(const lldb::ThreadSP &thread_sp) override
112     {
113         //printf ("Thread 0x%llx is being backed by thread 0x%llx\n", GetID(), thread_sp->GetID());
114         m_backing_thread_sp = thread_sp;
115         return (bool)thread_sp;
116     }
117 
118     lldb::ThreadSP
119     GetBackingThread() const override
120     {
121         return m_backing_thread_sp;
122     }
123 
124 protected:
125     bool
126     IsOperatingSystemPluginThread() const override
127     {
128         return true;
129     }
130 
131     // If this memory thread is actually represented by a thread from the
132     // lldb_private::Process subclass, then fill in the thread here and
133     // all APIs will be routed through this thread object. If m_backing_thread_sp
134     // is empty, then this thread is simply in memory with no representation
135     // through the process plug-in.
136     lldb::ThreadSP m_backing_thread_sp;
137     lldb::ValueObjectSP m_thread_info_valobj_sp;
138     std::string m_name;
139     std::string m_queue;
140     lldb::addr_t m_register_data_addr;
141 
142 private:
143     DISALLOW_COPY_AND_ASSIGN (ThreadMemory);
144 };
145 
146 #endif // liblldb_ThreadMemory_h_
147