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