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