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
48using namespace lldb;
49using namespace lldb_private;
50
51// Construct a Thread object with given data
52ThreadElfCore::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
57ThreadElfCore::~ThreadElfCore() { DestroyThread(); }
58
59void ThreadElfCore::RefreshStateAfterStop() {
60  GetRegisterContext()->InvalidateIfNeeded(false);
61}
62
63RegisterContextSP ThreadElfCore::GetRegisterContext() {
64  if (!m_reg_context_sp) {
65    m_reg_context_sp = CreateRegisterContextForFrame(nullptr);
66  }
67  return m_reg_context_sp;
68}
69
70RegisterContextSP
71ThreadElfCore::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
239bool 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
250ELFLinuxPrStatus::ELFLinuxPrStatus() {
251  memset(this, 0, sizeof(ELFLinuxPrStatus));
252}
253
254size_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
280Status 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
324ELFLinuxPrPsInfo::ELFLinuxPrPsInfo() {
325  memset(this, 0, sizeof(ELFLinuxPrPsInfo));
326}
327
328size_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
349Status 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
400ELFLinuxSigInfo::ELFLinuxSigInfo() { memset(this, 0, sizeof(ELFLinuxSigInfo)); }
401
402size_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
417Status 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