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 #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 case llvm::Triple::arm:
86 break;
87 case llvm::Triple::ppc:
88 reg_interface = new RegisterContextFreeBSD_powerpc32(arch);
89 break;
90 case llvm::Triple::ppc64:
91 reg_interface = new RegisterContextFreeBSD_powerpc64(arch);
92 break;
93 case llvm::Triple::mips64:
94 reg_interface = new RegisterContextFreeBSD_mips64(arch);
95 break;
96 case llvm::Triple::x86:
97 reg_interface = new RegisterContextFreeBSD_i386(arch);
98 break;
99 case llvm::Triple::x86_64:
100 reg_interface = new RegisterContextFreeBSD_x86_64(arch);
101 break;
102 default:
103 break;
104 }
105 break;
106 }
107
108 case llvm::Triple::NetBSD: {
109 switch (arch.GetMachine()) {
110 case llvm::Triple::aarch64:
111 break;
112 case llvm::Triple::x86_64:
113 reg_interface = new RegisterContextNetBSD_x86_64(arch);
114 break;
115 default:
116 break;
117 }
118 break;
119 }
120
121 case llvm::Triple::Linux: {
122 switch (arch.GetMachine()) {
123 case llvm::Triple::aarch64:
124 break;
125 case llvm::Triple::mipsel:
126 case llvm::Triple::mips:
127 reg_interface = new RegisterContextLinux_mips(arch);
128 break;
129 case llvm::Triple::mips64el:
130 case llvm::Triple::mips64:
131 reg_interface = new RegisterContextLinux_mips64(arch);
132 break;
133 case llvm::Triple::ppc64le:
134 reg_interface = new RegisterInfoPOSIX_ppc64le(arch);
135 break;
136 case llvm::Triple::systemz:
137 reg_interface = new RegisterContextLinux_s390x(arch);
138 break;
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 = std::make_shared<RegisterContextCorePOSIX_arm64>(
181 *this, std::make_unique<RegisterInfoPOSIX_arm64>(arch),
182 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 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 case llvm::Triple::x86:
213 case llvm::Triple::x86_64:
214 m_thread_reg_ctx_sp = std::make_shared<RegisterContextCorePOSIX_x86_64>(
215 *this, reg_interface, m_gpregset_data, m_notes);
216 break;
217 default:
218 break;
219 }
220
221 reg_ctx_sp = m_thread_reg_ctx_sp;
222 } else {
223 reg_ctx_sp = GetUnwinder().CreateRegisterContextForFrame(frame);
224 }
225 return reg_ctx_sp;
226 }
227
CalculateStopInfo()228 bool ThreadElfCore::CalculateStopInfo() {
229 ProcessSP process_sp(GetProcess());
230 if (process_sp) {
231 SetStopInfo(StopInfo::CreateStopReasonWithSignal(*this, m_signo));
232 return true;
233 }
234 return false;
235 }
236
237 // Parse PRSTATUS from NOTE entry
ELFLinuxPrStatus()238 ELFLinuxPrStatus::ELFLinuxPrStatus() {
239 memset(this, 0, sizeof(ELFLinuxPrStatus));
240 }
241
GetSize(const lldb_private::ArchSpec & arch)242 size_t ELFLinuxPrStatus::GetSize(const lldb_private::ArchSpec &arch) {
243 constexpr size_t mips_linux_pr_status_size_o32 = 96;
244 constexpr size_t mips_linux_pr_status_size_n32 = 72;
245 constexpr size_t num_ptr_size_members = 10;
246 if (arch.IsMIPS()) {
247 std::string abi = arch.GetTargetABI();
248 assert(!abi.empty() && "ABI is not set");
249 if (!abi.compare("n64"))
250 return sizeof(ELFLinuxPrStatus);
251 else if (!abi.compare("o32"))
252 return mips_linux_pr_status_size_o32;
253 // N32 ABI
254 return mips_linux_pr_status_size_n32;
255 }
256 switch (arch.GetCore()) {
257 case lldb_private::ArchSpec::eCore_x86_32_i386:
258 case lldb_private::ArchSpec::eCore_x86_32_i486:
259 return 72;
260 default:
261 if (arch.GetAddressByteSize() == 8)
262 return sizeof(ELFLinuxPrStatus);
263 else
264 return sizeof(ELFLinuxPrStatus) - num_ptr_size_members * 4;
265 }
266 }
267
Parse(const DataExtractor & data,const ArchSpec & arch)268 Status ELFLinuxPrStatus::Parse(const DataExtractor &data,
269 const ArchSpec &arch) {
270 Status error;
271 if (GetSize(arch) > data.GetByteSize()) {
272 error.SetErrorStringWithFormat(
273 "NT_PRSTATUS size should be %zu, but the remaining bytes are: %" PRIu64,
274 GetSize(arch), data.GetByteSize());
275 return error;
276 }
277
278 // Read field by field to correctly account for endianess of both the core
279 // dump and the platform running lldb.
280 offset_t offset = 0;
281 si_signo = data.GetU32(&offset);
282 si_code = data.GetU32(&offset);
283 si_errno = data.GetU32(&offset);
284
285 pr_cursig = data.GetU16(&offset);
286 offset += 2; // pad
287
288 pr_sigpend = data.GetAddress(&offset);
289 pr_sighold = data.GetAddress(&offset);
290
291 pr_pid = data.GetU32(&offset);
292 pr_ppid = data.GetU32(&offset);
293 pr_pgrp = data.GetU32(&offset);
294 pr_sid = data.GetU32(&offset);
295
296 pr_utime.tv_sec = data.GetAddress(&offset);
297 pr_utime.tv_usec = data.GetAddress(&offset);
298
299 pr_stime.tv_sec = data.GetAddress(&offset);
300 pr_stime.tv_usec = data.GetAddress(&offset);
301
302 pr_cutime.tv_sec = data.GetAddress(&offset);
303 pr_cutime.tv_usec = data.GetAddress(&offset);
304
305 pr_cstime.tv_sec = data.GetAddress(&offset);
306 pr_cstime.tv_usec = data.GetAddress(&offset);
307
308 return error;
309 }
310
311 // Parse PRPSINFO from NOTE entry
ELFLinuxPrPsInfo()312 ELFLinuxPrPsInfo::ELFLinuxPrPsInfo() {
313 memset(this, 0, sizeof(ELFLinuxPrPsInfo));
314 }
315
GetSize(const lldb_private::ArchSpec & arch)316 size_t ELFLinuxPrPsInfo::GetSize(const lldb_private::ArchSpec &arch) {
317 constexpr size_t mips_linux_pr_psinfo_size_o32_n32 = 128;
318 if (arch.IsMIPS()) {
319 uint8_t address_byte_size = arch.GetAddressByteSize();
320 if (address_byte_size == 8)
321 return sizeof(ELFLinuxPrPsInfo);
322 return mips_linux_pr_psinfo_size_o32_n32;
323 }
324
325 switch (arch.GetCore()) {
326 case lldb_private::ArchSpec::eCore_s390x_generic:
327 case lldb_private::ArchSpec::eCore_x86_64_x86_64:
328 return sizeof(ELFLinuxPrPsInfo);
329 case lldb_private::ArchSpec::eCore_x86_32_i386:
330 case lldb_private::ArchSpec::eCore_x86_32_i486:
331 return 124;
332 default:
333 return 0;
334 }
335 }
336
Parse(const DataExtractor & data,const ArchSpec & arch)337 Status ELFLinuxPrPsInfo::Parse(const DataExtractor &data,
338 const ArchSpec &arch) {
339 Status error;
340 ByteOrder byteorder = data.GetByteOrder();
341 if (GetSize(arch) > data.GetByteSize()) {
342 error.SetErrorStringWithFormat(
343 "NT_PRPSINFO size should be %zu, but the remaining bytes are: %" PRIu64,
344 GetSize(arch), data.GetByteSize());
345 return error;
346 }
347 size_t size = 0;
348 offset_t offset = 0;
349
350 pr_state = data.GetU8(&offset);
351 pr_sname = data.GetU8(&offset);
352 pr_zomb = data.GetU8(&offset);
353 pr_nice = data.GetU8(&offset);
354 if (data.GetAddressByteSize() == 8) {
355 // Word align the next field on 64 bit.
356 offset += 4;
357 }
358
359 pr_flag = data.GetAddress(&offset);
360
361 if (arch.IsMIPS()) {
362 // The pr_uid and pr_gid is always 32 bit irrespective of platforms
363 pr_uid = data.GetU32(&offset);
364 pr_gid = data.GetU32(&offset);
365 } else {
366 // 16 bit on 32 bit platforms, 32 bit on 64 bit platforms
367 pr_uid = data.GetMaxU64(&offset, data.GetAddressByteSize() >> 1);
368 pr_gid = data.GetMaxU64(&offset, data.GetAddressByteSize() >> 1);
369 }
370
371 pr_pid = data.GetU32(&offset);
372 pr_ppid = data.GetU32(&offset);
373 pr_pgrp = data.GetU32(&offset);
374 pr_sid = data.GetU32(&offset);
375
376 size = 16;
377 data.ExtractBytes(offset, size, byteorder, pr_fname);
378 offset += size;
379
380 size = 80;
381 data.ExtractBytes(offset, size, byteorder, pr_psargs);
382 offset += size;
383
384 return error;
385 }
386
387 // Parse SIGINFO from NOTE entry
ELFLinuxSigInfo()388 ELFLinuxSigInfo::ELFLinuxSigInfo() { memset(this, 0, sizeof(ELFLinuxSigInfo)); }
389
GetSize(const lldb_private::ArchSpec & arch)390 size_t ELFLinuxSigInfo::GetSize(const lldb_private::ArchSpec &arch) {
391 if (arch.IsMIPS())
392 return sizeof(ELFLinuxSigInfo);
393 switch (arch.GetCore()) {
394 case lldb_private::ArchSpec::eCore_x86_64_x86_64:
395 return sizeof(ELFLinuxSigInfo);
396 case lldb_private::ArchSpec::eCore_s390x_generic:
397 case lldb_private::ArchSpec::eCore_x86_32_i386:
398 case lldb_private::ArchSpec::eCore_x86_32_i486:
399 return 12;
400 default:
401 return 0;
402 }
403 }
404
Parse(const DataExtractor & data,const ArchSpec & arch)405 Status ELFLinuxSigInfo::Parse(const DataExtractor &data, const ArchSpec &arch) {
406 Status error;
407 if (GetSize(arch) > data.GetByteSize()) {
408 error.SetErrorStringWithFormat(
409 "NT_SIGINFO size should be %zu, but the remaining bytes are: %" PRIu64,
410 GetSize(arch), data.GetByteSize());
411 return error;
412 }
413
414 // Parsing from a 32 bit ELF core file, and populating/reusing the structure
415 // properly, because the struct is for the 64 bit version
416 offset_t offset = 0;
417 si_signo = data.GetU32(&offset);
418 si_code = data.GetU32(&offset);
419 si_errno = data.GetU32(&offset);
420
421 return error;
422 }
423