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
ThreadElfCore(Process & process,const ThreadData & td)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
~ThreadElfCore()57 ThreadElfCore::~ThreadElfCore() { DestroyThread(); }
58
RefreshStateAfterStop()59 void ThreadElfCore::RefreshStateAfterStop() {
60 GetRegisterContext()->InvalidateIfNeeded(false);
61 }
62
GetRegisterContext()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
CreateRegisterContextForFrame(StackFrame * frame)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
CalculateStopInfo()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
ELFLinuxPrStatus()250 ELFLinuxPrStatus::ELFLinuxPrStatus() {
251 memset(this, 0, sizeof(ELFLinuxPrStatus));
252 }
253
GetSize(const lldb_private::ArchSpec & arch)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
Parse(const DataExtractor & data,const ArchSpec & arch)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
ELFLinuxPrPsInfo()324 ELFLinuxPrPsInfo::ELFLinuxPrPsInfo() {
325 memset(this, 0, sizeof(ELFLinuxPrPsInfo));
326 }
327
GetSize(const lldb_private::ArchSpec & arch)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
Parse(const DataExtractor & data,const ArchSpec & arch)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
ELFLinuxSigInfo()400 ELFLinuxSigInfo::ELFLinuxSigInfo() { memset(this, 0, sizeof(ELFLinuxSigInfo)); }
401
GetSize(const lldb_private::ArchSpec & arch)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
Parse(const DataExtractor & data,const ArchSpec & arch)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