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 : public lldb_private::Thread {
22 public:
23   ThreadMemory(lldb_private::Process &process, lldb::tid_t tid,
24                const lldb::ValueObjectSP &thread_info_valobj_sp);
25 
26   ThreadMemory(lldb_private::Process &process, lldb::tid_t tid,
27                const char *name, const char *queue,
28                lldb::addr_t register_data_addr);
29 
30   ~ThreadMemory() override;
31 
32   lldb::RegisterContextSP GetRegisterContext() override;
33 
34   lldb::RegisterContextSP
35   CreateRegisterContextForFrame(lldb_private::StackFrame *frame) override;
36 
37   bool CalculateStopInfo() override;
38 
39   const char *GetInfo() override {
40     if (m_backing_thread_sp)
41       m_backing_thread_sp->GetInfo();
42     return nullptr;
43   }
44 
45   const char *GetName() override {
46     if (!m_name.empty())
47       return m_name.c_str();
48     if (m_backing_thread_sp)
49       m_backing_thread_sp->GetName();
50     return nullptr;
51   }
52 
53   const char *GetQueueName() override {
54     if (!m_queue.empty())
55       return m_queue.c_str();
56     if (m_backing_thread_sp)
57       m_backing_thread_sp->GetQueueName();
58     return nullptr;
59   }
60 
61   void WillResume(lldb::StateType resume_state) override;
62 
63   void DidResume() override {
64     if (m_backing_thread_sp)
65       m_backing_thread_sp->DidResume();
66   }
67 
68   lldb::user_id_t GetProtocolID() const override {
69     if (m_backing_thread_sp)
70       return m_backing_thread_sp->GetProtocolID();
71     return Thread::GetProtocolID();
72   }
73 
74   void RefreshStateAfterStop() override;
75 
76   lldb::ValueObjectSP &GetValueObject() { return m_thread_info_valobj_sp; }
77 
78   void ClearStackFrames() override;
79 
80   void ClearBackingThread() override { m_backing_thread_sp.reset(); }
81 
82   bool SetBackingThread(const lldb::ThreadSP &thread_sp) override {
83     // printf ("Thread 0x%llx is being backed by thread 0x%llx\n", GetID(),
84     // thread_sp->GetID());
85     m_backing_thread_sp = thread_sp;
86     return (bool)thread_sp;
87   }
88 
89   lldb::ThreadSP GetBackingThread() const override {
90     return m_backing_thread_sp;
91   }
92 
93 protected:
94   bool IsOperatingSystemPluginThread() const override { return true; }
95 
96   // If this memory thread is actually represented by a thread from the
97   // lldb_private::Process subclass, then fill in the thread here and
98   // all APIs will be routed through this thread object. If m_backing_thread_sp
99   // is empty, then this thread is simply in memory with no representation
100   // through the process plug-in.
101   lldb::ThreadSP m_backing_thread_sp;
102   lldb::ValueObjectSP m_thread_info_valobj_sp;
103   std::string m_name;
104   std::string m_queue;
105   lldb::addr_t m_register_data_addr;
106 
107 private:
108   DISALLOW_COPY_AND_ASSIGN(ThreadMemory);
109 };
110 
111 #endif // liblldb_ThreadMemory_h_
112