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