1 //===-- ThreadElfCore.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 "lldb/Target/RegisterContext.h"
11 #include "lldb/Target/StopInfo.h"
12 #include "lldb/Target/Target.h"
13 #include "lldb/Target/Unwind.h"
14 #include "lldb/Utility/DataExtractor.h"
15 #include "lldb/Utility/Log.h"
16 
17 #include "Plugins/Process/Utility/RegisterContextFreeBSD_i386.h"
18 #include "Plugins/Process/Utility/RegisterContextFreeBSD_mips64.h"
19 #include "Plugins/Process/Utility/RegisterContextFreeBSD_powerpc.h"
20 #include "Plugins/Process/Utility/RegisterContextFreeBSD_x86_64.h"
21 #include "Plugins/Process/Utility/RegisterContextLinux_i386.h"
22 #include "Plugins/Process/Utility/RegisterContextLinux_s390x.h"
23 #include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
24 #include "Plugins/Process/Utility/RegisterContextOpenBSD_i386.h"
25 #include "Plugins/Process/Utility/RegisterContextOpenBSD_x86_64.h"
26 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm.h"
27 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h"
28 #include "ProcessElfCore.h"
29 #include "RegisterContextPOSIXCore_arm.h"
30 #include "RegisterContextPOSIXCore_arm64.h"
31 #include "RegisterContextPOSIXCore_mips64.h"
32 #include "RegisterContextPOSIXCore_powerpc.h"
33 #include "RegisterContextPOSIXCore_s390x.h"
34 #include "RegisterContextPOSIXCore_x86_64.h"
35 #include "ThreadElfCore.h"
36 
37 using namespace lldb;
38 using namespace lldb_private;
39 
40 //----------------------------------------------------------------------
41 // Construct a Thread object with given data
42 //----------------------------------------------------------------------
43 ThreadElfCore::ThreadElfCore(Process &process, const ThreadData &td)
44     : Thread(process, td.tid), m_thread_name(td.name), m_thread_reg_ctx_sp(),
45       m_signo(td.signo), m_gpregset_data(td.gpregset),
46       m_fpregset_data(td.fpregset), m_vregset_data(td.vregset) {}
47 
48 ThreadElfCore::~ThreadElfCore() { DestroyThread(); }
49 
50 void ThreadElfCore::RefreshStateAfterStop() {
51   GetRegisterContext()->InvalidateIfNeeded(false);
52 }
53 
54 void ThreadElfCore::ClearStackFrames() {
55   Unwind *unwinder = GetUnwinder();
56   if (unwinder)
57     unwinder->Clear();
58   Thread::ClearStackFrames();
59 }
60 
61 RegisterContextSP ThreadElfCore::GetRegisterContext() {
62   if (m_reg_context_sp.get() == NULL) {
63     m_reg_context_sp = CreateRegisterContextForFrame(NULL);
64   }
65   return m_reg_context_sp;
66 }
67 
68 RegisterContextSP
69 ThreadElfCore::CreateRegisterContextForFrame(StackFrame *frame) {
70   RegisterContextSP reg_ctx_sp;
71   uint32_t concrete_frame_idx = 0;
72   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
73 
74   if (frame)
75     concrete_frame_idx = frame->GetConcreteFrameIndex();
76 
77   if (concrete_frame_idx == 0) {
78     if (m_thread_reg_ctx_sp)
79       return m_thread_reg_ctx_sp;
80 
81     ProcessElfCore *process = static_cast<ProcessElfCore *>(GetProcess().get());
82     ArchSpec arch = process->GetArchitecture();
83     RegisterInfoInterface *reg_interface = NULL;
84 
85     switch (arch.GetTriple().getOS()) {
86     case llvm::Triple::FreeBSD: {
87       switch (arch.GetMachine()) {
88       case llvm::Triple::aarch64:
89         reg_interface = new RegisterInfoPOSIX_arm64(arch);
90         break;
91       case llvm::Triple::arm:
92         reg_interface = new RegisterInfoPOSIX_arm(arch);
93         break;
94       case llvm::Triple::ppc:
95         reg_interface = new RegisterContextFreeBSD_powerpc32(arch);
96         break;
97       case llvm::Triple::ppc64:
98         reg_interface = new RegisterContextFreeBSD_powerpc64(arch);
99         break;
100       case llvm::Triple::mips64:
101         reg_interface = new RegisterContextFreeBSD_mips64(arch);
102         break;
103       case llvm::Triple::x86:
104         reg_interface = new RegisterContextFreeBSD_i386(arch);
105         break;
106       case llvm::Triple::x86_64:
107         reg_interface = new RegisterContextFreeBSD_x86_64(arch);
108         break;
109       default:
110         break;
111       }
112       break;
113     }
114 
115     case llvm::Triple::Linux: {
116       switch (arch.GetMachine()) {
117       case llvm::Triple::arm:
118         reg_interface = new RegisterInfoPOSIX_arm(arch);
119         break;
120       case llvm::Triple::aarch64:
121         reg_interface = new RegisterInfoPOSIX_arm64(arch);
122         break;
123       case llvm::Triple::systemz:
124         reg_interface = new RegisterContextLinux_s390x(arch);
125         break;
126       case llvm::Triple::x86:
127         reg_interface = new RegisterContextLinux_i386(arch);
128         break;
129       case llvm::Triple::x86_64:
130         reg_interface = new RegisterContextLinux_x86_64(arch);
131         break;
132       default:
133         break;
134       }
135       break;
136     }
137 
138     case llvm::Triple::OpenBSD: {
139       switch (arch.GetMachine()) {
140       case llvm::Triple::aarch64:
141         reg_interface = new RegisterInfoPOSIX_arm64(arch);
142         break;
143       case llvm::Triple::arm:
144         reg_interface = new RegisterInfoPOSIX_arm(arch);
145         break;
146       case llvm::Triple::x86:
147 	reg_interface = new RegisterContextOpenBSD_i386(arch);
148 	break;
149       case llvm::Triple::x86_64:
150         reg_interface = new RegisterContextOpenBSD_x86_64(arch);
151         break;
152       default:
153         break;
154       }
155       break;
156     }
157 
158     default:
159       break;
160     }
161 
162     if (!reg_interface) {
163       if (log)
164         log->Printf("elf-core::%s:: Architecture(%d) or OS(%d) not supported",
165                     __FUNCTION__, arch.GetMachine(), arch.GetTriple().getOS());
166       assert(false && "Architecture or OS not supported");
167     }
168 
169     switch (arch.GetMachine()) {
170     case llvm::Triple::aarch64:
171       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_arm64(
172           *this, reg_interface, m_gpregset_data, m_fpregset_data));
173       break;
174     case llvm::Triple::arm:
175       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_arm(
176           *this, reg_interface, m_gpregset_data, m_fpregset_data));
177       break;
178     case llvm::Triple::mips64:
179       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_mips64(
180           *this, reg_interface, m_gpregset_data, m_fpregset_data));
181       break;
182     case llvm::Triple::ppc:
183     case llvm::Triple::ppc64:
184       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_powerpc(
185           *this, reg_interface, m_gpregset_data, m_fpregset_data,
186           m_vregset_data));
187       break;
188     case llvm::Triple::systemz:
189       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_s390x(
190           *this, reg_interface, m_gpregset_data, m_fpregset_data));
191       break;
192     case llvm::Triple::x86:
193     case llvm::Triple::x86_64:
194       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_x86_64(
195           *this, reg_interface, m_gpregset_data, m_fpregset_data));
196       break;
197     default:
198       break;
199     }
200 
201     reg_ctx_sp = m_thread_reg_ctx_sp;
202   } else if (m_unwinder_ap.get()) {
203     reg_ctx_sp = m_unwinder_ap->CreateRegisterContextForFrame(frame);
204   }
205   return reg_ctx_sp;
206 }
207 
208 bool ThreadElfCore::CalculateStopInfo() {
209   ProcessSP process_sp(GetProcess());
210   if (process_sp) {
211     SetStopInfo(StopInfo::CreateStopReasonWithSignal(*this, m_signo));
212     return true;
213   }
214   return false;
215 }
216 
217 //----------------------------------------------------------------
218 // Parse PRSTATUS from NOTE entry
219 //----------------------------------------------------------------
220 ELFLinuxPrStatus::ELFLinuxPrStatus() {
221   memset(this, 0, sizeof(ELFLinuxPrStatus));
222 }
223 
224 Error ELFLinuxPrStatus::Parse(DataExtractor &data, ArchSpec &arch) {
225   Error error;
226   if (GetSize(arch) > data.GetByteSize()) {
227     error.SetErrorStringWithFormat(
228         "NT_PRSTATUS size should be %zu, but the remaining bytes are: %" PRIu64,
229         GetSize(arch), data.GetByteSize());
230     return error;
231   }
232 
233   // Read field by field to correctly account for endianess
234   // of both the core dump and the platform running lldb.
235   offset_t offset = 0;
236   si_signo = data.GetU32(&offset);
237   si_code = data.GetU32(&offset);
238   si_errno = data.GetU32(&offset);
239 
240   pr_cursig = data.GetU16(&offset);
241   offset += 2; // pad
242 
243   pr_sigpend = data.GetPointer(&offset);
244   pr_sighold = data.GetPointer(&offset);
245 
246   pr_pid = data.GetU32(&offset);
247   pr_ppid = data.GetU32(&offset);
248   pr_pgrp = data.GetU32(&offset);
249   pr_sid = data.GetU32(&offset);
250 
251   pr_utime.tv_sec = data.GetPointer(&offset);
252   pr_utime.tv_usec = data.GetPointer(&offset);
253 
254   pr_stime.tv_sec = data.GetPointer(&offset);
255   pr_stime.tv_usec = data.GetPointer(&offset);
256 
257   pr_cutime.tv_sec = data.GetPointer(&offset);
258   pr_cutime.tv_usec = data.GetPointer(&offset);
259 
260   pr_cstime.tv_sec = data.GetPointer(&offset);
261   pr_cstime.tv_usec = data.GetPointer(&offset);
262 
263 
264   return error;
265 }
266 
267 //----------------------------------------------------------------
268 // Parse PRPSINFO from NOTE entry
269 //----------------------------------------------------------------
270 ELFLinuxPrPsInfo::ELFLinuxPrPsInfo() {
271   memset(this, 0, sizeof(ELFLinuxPrPsInfo));
272 }
273 
274 Error ELFLinuxPrPsInfo::Parse(DataExtractor &data, ArchSpec &arch) {
275   Error error;
276   ByteOrder byteorder = data.GetByteOrder();
277   if (GetSize(arch) > data.GetByteSize()) {
278     error.SetErrorStringWithFormat(
279         "NT_PRPSINFO size should be %zu, but the remaining bytes are: %" PRIu64,
280         GetSize(arch), data.GetByteSize());
281     return error;
282   }
283   size_t size = 0;
284   offset_t offset = 0;
285 
286   pr_state = data.GetU8(&offset);
287   pr_sname = data.GetU8(&offset);
288   pr_zomb = data.GetU8(&offset);
289   pr_nice = data.GetU8(&offset);
290   if (data.GetAddressByteSize() == 8) {
291     // Word align the next field on 64 bit.
292     offset += 4;
293   }
294 
295   pr_flag = data.GetPointer(&offset);
296 
297   // 16 bit on 32 bit platforms, 32 bit on 64 bit platforms
298   pr_uid = data.GetMaxU64(&offset, data.GetAddressByteSize() >> 1);
299   pr_gid = data.GetMaxU64(&offset, data.GetAddressByteSize() >> 1);
300 
301   pr_pid = data.GetU32(&offset);
302   pr_ppid = data.GetU32(&offset);
303   pr_pgrp = data.GetU32(&offset);
304   pr_sid = data.GetU32(&offset);
305 
306   size = 16;
307   data.ExtractBytes(offset, size, byteorder, pr_fname);
308   offset += size;
309 
310   size = 80;
311   data.ExtractBytes(offset, size, byteorder, pr_psargs);
312   offset += size;
313 
314   return error;
315 }
316 
317 //----------------------------------------------------------------
318 // Parse SIGINFO from NOTE entry
319 //----------------------------------------------------------------
320 ELFLinuxSigInfo::ELFLinuxSigInfo() {
321   memset(this, 0, sizeof(ELFLinuxSigInfo));
322 }
323 
324 Error ELFLinuxSigInfo::Parse(DataExtractor &data, const ArchSpec &arch) {
325   Error error;
326   if (GetSize(arch) > data.GetByteSize()) {
327     error.SetErrorStringWithFormat(
328         "NT_SIGINFO size should be %zu, but the remaining bytes are: %" PRIu64,
329         GetSize(arch), data.GetByteSize());
330     return error;
331   }
332 
333   // Parsing from a 32 bit ELF core file, and populating/reusing the structure
334   // properly, because the struct is for the 64 bit version
335   offset_t offset = 0;
336   si_signo = data.GetU32(&offset);
337   si_code = data.GetU32(&offset);
338   si_errno = data.GetU32(&offset);
339 
340   return error;
341 }
342