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_mips.h"
23 #include "Plugins/Process/Utility/RegisterContextLinux_mips64.h"
24 #include "Plugins/Process/Utility/RegisterContextLinux_s390x.h"
25 #include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
26 #include "Plugins/Process/Utility/RegisterContextNetBSD_x86_64.h"
27 #include "Plugins/Process/Utility/RegisterContextOpenBSD_i386.h"
28 #include "Plugins/Process/Utility/RegisterContextOpenBSD_x86_64.h"
29 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm.h"
30 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h"
31 #include "Plugins/Process/Utility/RegisterInfoPOSIX_ppc64le.h"
32 #include "ProcessElfCore.h"
33 #include "RegisterContextPOSIXCore_arm.h"
34 #include "RegisterContextPOSIXCore_arm64.h"
35 #include "RegisterContextPOSIXCore_mips64.h"
36 #include "RegisterContextPOSIXCore_powerpc.h"
37 #include "RegisterContextPOSIXCore_ppc64le.h"
38 #include "RegisterContextPOSIXCore_s390x.h"
39 #include "RegisterContextPOSIXCore_x86_64.h"
40 #include "ThreadElfCore.h"
41 
42 using namespace lldb;
43 using namespace lldb_private;
44 
45 //----------------------------------------------------------------------
46 // Construct a Thread object with given data
47 //----------------------------------------------------------------------
48 ThreadElfCore::ThreadElfCore(Process &process, const ThreadData &td)
49     : Thread(process, td.tid), m_thread_name(td.name), m_thread_reg_ctx_sp(),
50       m_signo(td.signo), m_gpregset_data(td.gpregset),
51       m_fpregset_data(td.fpregset), m_vregset_data(td.vregset),
52       m_regsets_data(td.regsets) {}
53 
54 ThreadElfCore::~ThreadElfCore() { DestroyThread(); }
55 
56 void ThreadElfCore::RefreshStateAfterStop() {
57   GetRegisterContext()->InvalidateIfNeeded(false);
58 }
59 
60 void ThreadElfCore::ClearStackFrames() {
61   Unwind *unwinder = GetUnwinder();
62   if (unwinder)
63     unwinder->Clear();
64   Thread::ClearStackFrames();
65 }
66 
67 RegisterContextSP ThreadElfCore::GetRegisterContext() {
68   if (m_reg_context_sp.get() == NULL) {
69     m_reg_context_sp = CreateRegisterContextForFrame(NULL);
70   }
71   return m_reg_context_sp;
72 }
73 
74 RegisterContextSP
75 ThreadElfCore::CreateRegisterContextForFrame(StackFrame *frame) {
76   RegisterContextSP reg_ctx_sp;
77   uint32_t concrete_frame_idx = 0;
78   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
79 
80   if (frame)
81     concrete_frame_idx = frame->GetConcreteFrameIndex();
82 
83   if (concrete_frame_idx == 0) {
84     if (m_thread_reg_ctx_sp)
85       return m_thread_reg_ctx_sp;
86 
87     ProcessElfCore *process = static_cast<ProcessElfCore *>(GetProcess().get());
88     ArchSpec arch = process->GetArchitecture();
89     RegisterInfoInterface *reg_interface = NULL;
90 
91     switch (arch.GetTriple().getOS()) {
92     case llvm::Triple::FreeBSD: {
93       switch (arch.GetMachine()) {
94       case llvm::Triple::aarch64:
95         reg_interface = new RegisterInfoPOSIX_arm64(arch);
96         break;
97       case llvm::Triple::arm:
98         reg_interface = new RegisterInfoPOSIX_arm(arch);
99         break;
100       case llvm::Triple::ppc:
101         reg_interface = new RegisterContextFreeBSD_powerpc32(arch);
102         break;
103       case llvm::Triple::ppc64:
104         reg_interface = new RegisterContextFreeBSD_powerpc64(arch);
105         break;
106       case llvm::Triple::mips64:
107         reg_interface = new RegisterContextFreeBSD_mips64(arch);
108         break;
109       case llvm::Triple::x86:
110         reg_interface = new RegisterContextFreeBSD_i386(arch);
111         break;
112       case llvm::Triple::x86_64:
113         reg_interface = new RegisterContextFreeBSD_x86_64(arch);
114         break;
115       default:
116         break;
117       }
118       break;
119     }
120 
121     case llvm::Triple::NetBSD: {
122       switch (arch.GetMachine()) {
123       case llvm::Triple::x86_64:
124         reg_interface = new RegisterContextNetBSD_x86_64(arch);
125         break;
126       default:
127         break;
128       }
129       break;
130     }
131 
132     case llvm::Triple::Linux: {
133       switch (arch.GetMachine()) {
134       case llvm::Triple::arm:
135         reg_interface = new RegisterInfoPOSIX_arm(arch);
136         break;
137       case llvm::Triple::aarch64:
138         reg_interface = new RegisterInfoPOSIX_arm64(arch);
139         break;
140       case llvm::Triple::mipsel:
141       case llvm::Triple::mips:
142         reg_interface = new RegisterContextLinux_mips(arch);
143         break;
144       case llvm::Triple::mips64el:
145       case llvm::Triple::mips64:
146         reg_interface = new RegisterContextLinux_mips64(arch);
147         break;
148       case llvm::Triple::ppc64le:
149         reg_interface = new RegisterInfoPOSIX_ppc64le(arch);
150         break;
151       case llvm::Triple::systemz:
152         reg_interface = new RegisterContextLinux_s390x(arch);
153         break;
154       case llvm::Triple::x86:
155         reg_interface = new RegisterContextLinux_i386(arch);
156         break;
157       case llvm::Triple::x86_64:
158         reg_interface = new RegisterContextLinux_x86_64(arch);
159         break;
160       default:
161         break;
162       }
163       break;
164     }
165 
166     case llvm::Triple::OpenBSD: {
167       switch (arch.GetMachine()) {
168       case llvm::Triple::aarch64:
169         reg_interface = new RegisterInfoPOSIX_arm64(arch);
170         break;
171       case llvm::Triple::arm:
172         reg_interface = new RegisterInfoPOSIX_arm(arch);
173         break;
174       case llvm::Triple::x86:
175         reg_interface = new RegisterContextOpenBSD_i386(arch);
176         break;
177       case llvm::Triple::x86_64:
178         reg_interface = new RegisterContextOpenBSD_x86_64(arch);
179         break;
180       default:
181         break;
182       }
183       break;
184     }
185 
186     default:
187       break;
188     }
189 
190     if (!reg_interface) {
191       if (log)
192         log->Printf("elf-core::%s:: Architecture(%d) or OS(%d) not supported",
193                     __FUNCTION__, arch.GetMachine(), arch.GetTriple().getOS());
194       assert(false && "Architecture or OS not supported");
195     }
196 
197     switch (arch.GetMachine()) {
198     case llvm::Triple::aarch64:
199       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_arm64(
200           *this, reg_interface, m_gpregset_data, m_fpregset_data));
201       break;
202     case llvm::Triple::arm:
203       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_arm(
204           *this, reg_interface, m_gpregset_data, m_fpregset_data));
205       break;
206     case llvm::Triple::mipsel:
207     case llvm::Triple::mips:
208       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_mips64(
209          *this, reg_interface, m_gpregset_data, m_fpregset_data));
210       break;
211     case llvm::Triple::mips64:
212     case llvm::Triple::mips64el:
213       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_mips64(
214           *this, reg_interface, m_gpregset_data, m_fpregset_data));
215       break;
216     case llvm::Triple::ppc:
217     case llvm::Triple::ppc64:
218       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_powerpc(
219           *this, reg_interface, m_gpregset_data, m_fpregset_data,
220           m_vregset_data));
221       break;
222     case llvm::Triple::ppc64le:
223       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_ppc64le(
224           *this, reg_interface, m_regsets_data));
225       break;
226     case llvm::Triple::systemz:
227       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_s390x(
228           *this, reg_interface, m_gpregset_data, m_fpregset_data));
229       break;
230     case llvm::Triple::x86:
231     case llvm::Triple::x86_64:
232       m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_x86_64(
233           *this, reg_interface, m_gpregset_data, m_fpregset_data));
234       break;
235     default:
236       break;
237     }
238 
239     reg_ctx_sp = m_thread_reg_ctx_sp;
240   } else if (m_unwinder_ap.get()) {
241     reg_ctx_sp = m_unwinder_ap->CreateRegisterContextForFrame(frame);
242   }
243   return reg_ctx_sp;
244 }
245 
246 bool ThreadElfCore::CalculateStopInfo() {
247   ProcessSP process_sp(GetProcess());
248   if (process_sp) {
249     SetStopInfo(StopInfo::CreateStopReasonWithSignal(*this, m_signo));
250     return true;
251   }
252   return false;
253 }
254 
255 //----------------------------------------------------------------
256 // Parse PRSTATUS from NOTE entry
257 //----------------------------------------------------------------
258 ELFLinuxPrStatus::ELFLinuxPrStatus() {
259   memset(this, 0, sizeof(ELFLinuxPrStatus));
260 }
261 
262 size_t ELFLinuxPrStatus::GetSize(const lldb_private::ArchSpec &arch) {
263   constexpr size_t mips_linux_pr_status_size_o32 = 96;
264   constexpr size_t mips_linux_pr_status_size_n32 = 72;
265   if (arch.IsMIPS()) {
266     std::string abi = arch.GetTargetABI();
267     assert(!abi.empty() && "ABI is not set");
268     if (!abi.compare("n64"))
269       return sizeof(ELFLinuxPrStatus);
270     else if (!abi.compare("o32"))
271       return mips_linux_pr_status_size_o32;
272     // N32 ABI
273     return mips_linux_pr_status_size_n32;
274   }
275   switch (arch.GetCore()) {
276   case lldb_private::ArchSpec::eCore_s390x_generic:
277   case lldb_private::ArchSpec::eCore_x86_64_x86_64:
278   case lldb_private::ArchSpec::eCore_ppc64le_generic:
279     return sizeof(ELFLinuxPrStatus);
280   case lldb_private::ArchSpec::eCore_x86_32_i386:
281   case lldb_private::ArchSpec::eCore_x86_32_i486:
282     return 72;
283   default:
284     return 0;
285   }
286 }
287 
288 Status ELFLinuxPrStatus::Parse(const DataExtractor &data,
289                                const ArchSpec &arch) {
290   Status error;
291   if (GetSize(arch) > data.GetByteSize()) {
292     error.SetErrorStringWithFormat(
293         "NT_PRSTATUS size should be %zu, but the remaining bytes are: %" PRIu64,
294         GetSize(arch), data.GetByteSize());
295     return error;
296   }
297 
298   // Read field by field to correctly account for endianess
299   // of both the core dump and the platform running lldb.
300   offset_t offset = 0;
301   si_signo = data.GetU32(&offset);
302   si_code = data.GetU32(&offset);
303   si_errno = data.GetU32(&offset);
304 
305   pr_cursig = data.GetU16(&offset);
306   offset += 2; // pad
307 
308   pr_sigpend = data.GetPointer(&offset);
309   pr_sighold = data.GetPointer(&offset);
310 
311   pr_pid = data.GetU32(&offset);
312   pr_ppid = data.GetU32(&offset);
313   pr_pgrp = data.GetU32(&offset);
314   pr_sid = data.GetU32(&offset);
315 
316   pr_utime.tv_sec = data.GetPointer(&offset);
317   pr_utime.tv_usec = data.GetPointer(&offset);
318 
319   pr_stime.tv_sec = data.GetPointer(&offset);
320   pr_stime.tv_usec = data.GetPointer(&offset);
321 
322   pr_cutime.tv_sec = data.GetPointer(&offset);
323   pr_cutime.tv_usec = data.GetPointer(&offset);
324 
325   pr_cstime.tv_sec = data.GetPointer(&offset);
326   pr_cstime.tv_usec = data.GetPointer(&offset);
327 
328   return error;
329 }
330 
331 //----------------------------------------------------------------
332 // Parse PRPSINFO from NOTE entry
333 //----------------------------------------------------------------
334 ELFLinuxPrPsInfo::ELFLinuxPrPsInfo() {
335   memset(this, 0, sizeof(ELFLinuxPrPsInfo));
336 }
337 
338 size_t ELFLinuxPrPsInfo::GetSize(const lldb_private::ArchSpec &arch) {
339   constexpr size_t mips_linux_pr_psinfo_size_o32_n32 = 128;
340   if (arch.IsMIPS()) {
341     uint8_t address_byte_size = arch.GetAddressByteSize();
342     if (address_byte_size == 8)
343       return sizeof(ELFLinuxPrPsInfo);
344     return mips_linux_pr_psinfo_size_o32_n32;
345   }
346 
347   switch (arch.GetCore()) {
348   case lldb_private::ArchSpec::eCore_s390x_generic:
349   case lldb_private::ArchSpec::eCore_x86_64_x86_64:
350     return sizeof(ELFLinuxPrPsInfo);
351   case lldb_private::ArchSpec::eCore_x86_32_i386:
352   case lldb_private::ArchSpec::eCore_x86_32_i486:
353     return 124;
354   default:
355     return 0;
356   }
357 }
358 
359 Status ELFLinuxPrPsInfo::Parse(const DataExtractor &data,
360                                const ArchSpec &arch) {
361   Status error;
362   ByteOrder byteorder = data.GetByteOrder();
363   if (GetSize(arch) > data.GetByteSize()) {
364     error.SetErrorStringWithFormat(
365         "NT_PRPSINFO size should be %zu, but the remaining bytes are: %" PRIu64,
366         GetSize(arch), data.GetByteSize());
367     return error;
368   }
369   size_t size = 0;
370   offset_t offset = 0;
371 
372   pr_state = data.GetU8(&offset);
373   pr_sname = data.GetU8(&offset);
374   pr_zomb = data.GetU8(&offset);
375   pr_nice = data.GetU8(&offset);
376   if (data.GetAddressByteSize() == 8) {
377     // Word align the next field on 64 bit.
378     offset += 4;
379   }
380 
381   pr_flag = data.GetPointer(&offset);
382 
383   if (arch.IsMIPS()) {
384     // The pr_uid and pr_gid is always 32 bit irrespective of platforms
385     pr_uid = data.GetU32(&offset);
386     pr_gid = data.GetU32(&offset);
387   } else {
388   // 16 bit on 32 bit platforms, 32 bit on 64 bit platforms
389   pr_uid = data.GetMaxU64(&offset, data.GetAddressByteSize() >> 1);
390   pr_gid = data.GetMaxU64(&offset, data.GetAddressByteSize() >> 1);
391   }
392 
393   pr_pid = data.GetU32(&offset);
394   pr_ppid = data.GetU32(&offset);
395   pr_pgrp = data.GetU32(&offset);
396   pr_sid = data.GetU32(&offset);
397 
398   size = 16;
399   data.ExtractBytes(offset, size, byteorder, pr_fname);
400   offset += size;
401 
402   size = 80;
403   data.ExtractBytes(offset, size, byteorder, pr_psargs);
404   offset += size;
405 
406   return error;
407 }
408 
409 //----------------------------------------------------------------
410 // Parse SIGINFO from NOTE entry
411 //----------------------------------------------------------------
412 ELFLinuxSigInfo::ELFLinuxSigInfo() { memset(this, 0, sizeof(ELFLinuxSigInfo)); }
413 
414 size_t ELFLinuxSigInfo::GetSize(const lldb_private::ArchSpec &arch) {
415   if (arch.IsMIPS())
416     return sizeof(ELFLinuxSigInfo);
417   switch (arch.GetCore()) {
418   case lldb_private::ArchSpec::eCore_x86_64_x86_64:
419     return sizeof(ELFLinuxSigInfo);
420   case lldb_private::ArchSpec::eCore_s390x_generic:
421   case lldb_private::ArchSpec::eCore_x86_32_i386:
422   case lldb_private::ArchSpec::eCore_x86_32_i486:
423     return 12;
424   default:
425     return 0;
426   }
427 }
428 
429 Status ELFLinuxSigInfo::Parse(const DataExtractor &data, const ArchSpec &arch) {
430   Status error;
431   if (GetSize(arch) > data.GetByteSize()) {
432     error.SetErrorStringWithFormat(
433         "NT_SIGINFO size should be %zu, but the remaining bytes are: %" PRIu64,
434         GetSize(arch), data.GetByteSize());
435     return error;
436   }
437 
438   // Parsing from a 32 bit ELF core file, and populating/reusing the structure
439   // properly, because the struct is for the 64 bit version
440   offset_t offset = 0;
441   si_signo = data.GetU32(&offset);
442   si_code = data.GetU32(&offset);
443   si_errno = data.GetU32(&offset);
444 
445   return error;
446 }
447