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