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
ThreadElfCore(Process & process,const ThreadData & td)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
~ThreadElfCore()54 ThreadElfCore::~ThreadElfCore() { DestroyThread(); }
55
RefreshStateAfterStop()56 void ThreadElfCore::RefreshStateAfterStop() {
57 GetRegisterContext()->InvalidateIfNeeded(false);
58 }
59
GetRegisterContext()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
CreateRegisterContextForFrame(StackFrame * frame)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
CalculateStopInfo()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
ELFLinuxPrStatus()239 ELFLinuxPrStatus::ELFLinuxPrStatus() {
240 memset(this, 0, sizeof(ELFLinuxPrStatus));
241 }
242
GetSize(const lldb_private::ArchSpec & arch)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
Parse(const DataExtractor & data,const ArchSpec & arch)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
ELFLinuxPrPsInfo()313 ELFLinuxPrPsInfo::ELFLinuxPrPsInfo() {
314 memset(this, 0, sizeof(ELFLinuxPrPsInfo));
315 }
316
GetSize(const lldb_private::ArchSpec & arch)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
Parse(const DataExtractor & data,const ArchSpec & arch)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
ELFLinuxSigInfo()389 ELFLinuxSigInfo::ELFLinuxSigInfo() { memset(this, 0, sizeof(ELFLinuxSigInfo)); }
390
GetSize(const lldb_private::ArchSpec & arch)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
Parse(const DataExtractor & data,const ArchSpec & arch)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