1 files changed, 0 insertions, 616 deletions
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/FreeBSDThread.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/FreeBSDThread.cpp
deleted file mode 100644
index 896f68eadfe1..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/FreeBSDThread.cpp
+++ /dev/null
@@ -1,616 +0,0 @@
-//===-- FreeBSDThread.cpp -------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <errno.h>
-#include <pthread.h>
-#include <pthread_np.h>
-#include <stdlib.h>
-#include <sys/sysctl.h>
-#include <sys/types.h>
-#include <sys/user.h>
-
-#include "FreeBSDThread.h"
-#include "POSIXStopInfo.h"
-#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
-#include "Plugins/Process/Utility/RegisterContextFreeBSD_i386.h"
-#include "Plugins/Process/Utility/RegisterContextFreeBSD_mips64.h"
-#include "Plugins/Process/Utility/RegisterContextFreeBSD_powerpc.h"
-#include "Plugins/Process/Utility/RegisterContextFreeBSD_x86_64.h"
-#include "Plugins/Process/Utility/RegisterInfoPOSIX_arm.h"
-#include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h"
-#include "ProcessFreeBSD.h"
-#include "ProcessMonitor.h"
-#include "RegisterContextPOSIXProcessMonitor_arm.h"
-#include "RegisterContextPOSIXProcessMonitor_arm64.h"
-#include "RegisterContextPOSIXProcessMonitor_mips64.h"
-#include "RegisterContextPOSIXProcessMonitor_powerpc.h"
-#include "RegisterContextPOSIXProcessMonitor_x86.h"
-#include "lldb/Breakpoint/BreakpointLocation.h"
-#include "lldb/Breakpoint/Watchpoint.h"
-#include "lldb/Core/Debugger.h"
-#include "lldb/Host/Host.h"
-#include "lldb/Host/HostInfo.h"
-#include "lldb/Host/HostNativeThread.h"
-#include "lldb/Target/Process.h"
-#include "lldb/Target/StopInfo.h"
-#include "lldb/Target/Target.h"
-#include "lldb/Target/ThreadSpec.h"
-#include "lldb/Target/UnixSignals.h"
-#include "lldb/Target/Unwind.h"
-#include "lldb/Utility/State.h"
-#include "llvm/ADT/SmallString.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-FreeBSDThread::FreeBSDThread(Process &process, lldb::tid_t tid)
-    : Thread(process, tid), m_frame_up(), m_breakpoint(),
-      m_thread_name_valid(false), m_thread_name(), m_posix_thread(nullptr) {
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
-  LLDB_LOGV(log, "tid = {0}", tid);
-
-  // Set the current watchpoints for this thread.
-  Target &target = GetProcess()->GetTarget();
-  const WatchpointList &wp_list = target.GetWatchpointList();
-  size_t wp_size = wp_list.GetSize();
-
-  for (uint32_t wp_idx = 0; wp_idx < wp_size; wp_idx++) {
-    lldb::WatchpointSP wp = wp_list.GetByIndex(wp_idx);
-    if (wp.get() && wp->IsEnabled()) {
-      // This watchpoint as been enabled; obviously this "new" thread has been
-      // created since that watchpoint was enabled.  Since the
-      // POSIXBreakpointProtocol has yet to be initialized, its
-      // m_watchpoints_initialized member will be FALSE.  Attempting to read
-      // the debug status register to determine if a watchpoint has been hit
-      // would result in the zeroing of that register. Since the active debug
-      // registers would have been cloned when this thread was created, simply
-      // force the m_watchpoints_initized member to TRUE and avoid resetting
-      // dr6 and dr7.
-      GetPOSIXBreakpointProtocol()->ForceWatchpointsInitialized();
-    }
-  }
-}
-
-FreeBSDThread::~FreeBSDThread() { DestroyThread(); }
-
-ProcessMonitor &FreeBSDThread::GetMonitor() {
-  ProcessSP base = GetProcess();
-  ProcessFreeBSD &process = static_cast<ProcessFreeBSD &>(*base);
-  return process.GetMonitor();
-}
-
-void FreeBSDThread::RefreshStateAfterStop() {
-  // Invalidate all registers in our register context. We don't set "force" to
-  // true because the stop reply packet might have had some register values
-  // that were expedited and these will already be copied into the register
-  // context by the time this function gets called. The KDPRegisterContext
-  // class has been made smart enough to detect when it needs to invalidate
-  // which registers are valid by putting hooks in the register read and
-  // register supply functions where they check the process stop ID and do the
-  // right thing. if (StateIsStoppedState(GetState())
-  {
-    const bool force = false;
-    GetRegisterContext()->InvalidateIfNeeded(force);
-  }
-}
-
-const char *FreeBSDThread::GetInfo() { return nullptr; }
-
-void FreeBSDThread::SetName(const char *name) {
-  m_thread_name_valid = (name && name[0]);
-  if (m_thread_name_valid)
-    m_thread_name.assign(name);
-  else
-    m_thread_name.clear();
-}
-
-const char *FreeBSDThread::GetName() {
-  if (!m_thread_name_valid) {
-    m_thread_name.clear();
-    int pid = GetProcess()->GetID();
-
-    struct kinfo_proc *kp = nullptr, *nkp;
-    size_t len = 0;
-    int error;
-    int ctl[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID | KERN_PROC_INC_THREAD,
-                  pid};
-
-    while (1) {
-      error = sysctl(ctl, 4, kp, &len, nullptr, 0);
-      if (kp == nullptr || (error != 0 && errno == ENOMEM)) {
-        // Add extra space in case threads are added before next call.
-        len += sizeof(*kp) + len / 10;
-        nkp = (struct kinfo_proc *)realloc(kp, len);
-        if (nkp == nullptr) {
-          free(kp);
-          return nullptr;
-        }
-        kp = nkp;
-        continue;
-      }
-      if (error != 0)
-        len = 0;
-      break;
-    }
-
-    for (size_t i = 0; i < len / sizeof(*kp); i++) {
-      if (kp[i].ki_tid == (lwpid_t)GetID()) {
-        m_thread_name.append(kp[i].ki_tdname,
-                             kp[i].ki_tdname + strlen(kp[i].ki_tdname));
-        break;
-      }
-    }
-    free(kp);
-    m_thread_name_valid = true;
-  }
-
-  if (m_thread_name.empty())
-    return nullptr;
-  return m_thread_name.c_str();
-}
-
-lldb::RegisterContextSP FreeBSDThread::GetRegisterContext() {
-  if (!m_reg_context_sp) {
-    m_posix_thread = nullptr;
-
-    RegisterInfoInterface *reg_interface = nullptr;
-    const ArchSpec &target_arch = GetProcess()->GetTarget().GetArchitecture();
-
-    switch (target_arch.GetMachine()) {
-    case llvm::Triple::aarch64:
-      break;
-    case llvm::Triple::arm:
-      reg_interface = new RegisterInfoPOSIX_arm(target_arch);
-      break;
-    case llvm::Triple::ppc:
-#ifndef __powerpc64__
-      reg_interface = new RegisterContextFreeBSD_powerpc32(target_arch);
-      break;
-#endif
-    case llvm::Triple::ppc64:
-      reg_interface = new RegisterContextFreeBSD_powerpc64(target_arch);
-      break;
-    case llvm::Triple::mips64:
-      reg_interface = new RegisterContextFreeBSD_mips64(target_arch);
-      break;
-    case llvm::Triple::x86:
-      reg_interface = new RegisterContextFreeBSD_i386(target_arch);
-      break;
-    case llvm::Triple::x86_64:
-      reg_interface = new RegisterContextFreeBSD_x86_64(target_arch);
-      break;
-    default:
-      llvm_unreachable("CPU not supported");
-    }
-
-    switch (target_arch.GetMachine()) {
-    case llvm::Triple::aarch64: {
-      RegisterContextPOSIXProcessMonitor_arm64 *reg_ctx =
-          new RegisterContextPOSIXProcessMonitor_arm64(
-              *this, std::make_unique<RegisterInfoPOSIX_arm64>(target_arch));
-      m_posix_thread = reg_ctx;
-      m_reg_context_sp.reset(reg_ctx);
-      break;
-    }
-    case llvm::Triple::arm: {
-      RegisterContextPOSIXProcessMonitor_arm *reg_ctx =
-          new RegisterContextPOSIXProcessMonitor_arm(*this, 0, reg_interface);
-      m_posix_thread = reg_ctx;
-      m_reg_context_sp.reset(reg_ctx);
-      break;
-    }
-    case llvm::Triple::mips64: {
-      RegisterContextPOSIXProcessMonitor_mips64 *reg_ctx =
-          new RegisterContextPOSIXProcessMonitor_mips64(*this, 0,
-                                                        reg_interface);
-      m_posix_thread = reg_ctx;
-      m_reg_context_sp.reset(reg_ctx);
-      break;
-    }
-    case llvm::Triple::ppc:
-    case llvm::Triple::ppc64: {
-      RegisterContextPOSIXProcessMonitor_powerpc *reg_ctx =
-          new RegisterContextPOSIXProcessMonitor_powerpc(*this, 0,
-                                                         reg_interface);
-      m_posix_thread = reg_ctx;
-      m_reg_context_sp.reset(reg_ctx);
-      break;
-    }
-    case llvm::Triple::x86:
-    case llvm::Triple::x86_64: {
-      RegisterContextPOSIXProcessMonitor_x86_64 *reg_ctx =
-          new RegisterContextPOSIXProcessMonitor_x86_64(*this, 0,
-                                                        reg_interface);
-      m_posix_thread = reg_ctx;
-      m_reg_context_sp.reset(reg_ctx);
-      break;
-    }
-    default:
-      break;
-    }
-  }
-  return m_reg_context_sp;
-}
-
-lldb::RegisterContextSP
-FreeBSDThread::CreateRegisterContextForFrame(lldb_private::StackFrame *frame) {
-  lldb::RegisterContextSP reg_ctx_sp;
-  uint32_t concrete_frame_idx = 0;
-
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
-  LLDB_LOGV(log, "called");
-
-  if (frame)
-    concrete_frame_idx = frame->GetConcreteFrameIndex();
-
-  if (concrete_frame_idx == 0)
-    reg_ctx_sp = GetRegisterContext();
-  else {
-    reg_ctx_sp = GetUnwinder().CreateRegisterContextForFrame(frame);
-  }
-
-  return reg_ctx_sp;
-}
-
-lldb::addr_t FreeBSDThread::GetThreadPointer() {
-  ProcessMonitor &monitor = GetMonitor();
-  addr_t addr;
-  if (monitor.ReadThreadPointer(GetID(), addr))
-    return addr;
-  else
-    return LLDB_INVALID_ADDRESS;
-}
-
-bool FreeBSDThread::CalculateStopInfo() {
-  SetStopInfo(m_stop_info_sp);
-  return true;
-}
-
-void FreeBSDThread::DidStop() {
-  // Don't set the thread state to stopped unless we really stopped.
-}
-
-void FreeBSDThread::WillResume(lldb::StateType resume_state) {
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
-  LLDB_LOGF(log, "tid %" PRIu64 " resume_state = %s", GetID(),
-            lldb_private::StateAsCString(resume_state));
-  ProcessSP process_sp(GetProcess());
-  ProcessFreeBSD *process = static_cast<ProcessFreeBSD *>(process_sp.get());
-  int signo = GetResumeSignal();
-  bool signo_valid = process->GetUnixSignals()->SignalIsValid(signo);
-
-  switch (resume_state) {
-  case eStateSuspended:
-  case eStateStopped:
-    process->m_suspend_tids.push_back(GetID());
-    break;
-  case eStateRunning:
-    process->m_run_tids.push_back(GetID());
-    if (signo_valid)
-      process->m_resume_signo = signo;
-    break;
-  case eStateStepping:
-    process->m_step_tids.push_back(GetID());
-    if (signo_valid)
-      process->m_resume_signo = signo;
-    break;
-  default:
-    break;
-  }
-}
-
-bool FreeBSDThread::Resume() {
-  lldb::StateType resume_state = GetResumeState();
-  ProcessMonitor &monitor = GetMonitor();
-  bool status;
-
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
-  LLDB_LOGF(log, "FreeBSDThread::%s (), resume_state = %s", __FUNCTION__,
-            StateAsCString(resume_state));
-
-  switch (resume_state) {
-  default:
-    assert(false && "Unexpected state for resume!");
-    status = false;
-    break;
-
-  case lldb::eStateRunning:
-    SetState(resume_state);
-    status = monitor.Resume(GetID(), GetResumeSignal());
-    break;
-
-  case lldb::eStateStepping:
-    SetState(resume_state);
-    status = monitor.SingleStep(GetID(), GetResumeSignal());
-    break;
-  case lldb::eStateStopped:
-  case lldb::eStateSuspended:
-    status = true;
-    break;
-  }
-
-  return status;
-}
-
-void FreeBSDThread::Notify(const ProcessMessage &message) {
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
-  LLDB_LOGF(log, "FreeBSDThread::%s () message kind = '%s' for tid %" PRIu64,
-            __FUNCTION__, message.PrintKind(), GetID());
-
-  switch (message.GetKind()) {
-  default:
-    assert(false && "Unexpected message kind!");
-    break;
-
-  case ProcessMessage::eExitMessage:
-    // Nothing to be done.
-    break;
-
-  case ProcessMessage::eLimboMessage:
-    LimboNotify(message);
-    break;
-
-  case ProcessMessage::eCrashMessage:
-  case ProcessMessage::eSignalMessage:
-    SignalNotify(message);
-    break;
-
-  case ProcessMessage::eSignalDeliveredMessage:
-    SignalDeliveredNotify(message);
-    break;
-
-  case ProcessMessage::eTraceMessage:
-    TraceNotify(message);
-    break;
-
-  case ProcessMessage::eBreakpointMessage:
-    BreakNotify(message);
-    break;
-
-  case ProcessMessage::eWatchpointMessage:
-    WatchNotify(message);
-    break;
-
-  case ProcessMessage::eExecMessage:
-    ExecNotify(message);
-    break;
-  }
-}
-
-bool FreeBSDThread::EnableHardwareWatchpoint(Watchpoint *wp) {
-  bool wp_set = false;
-  if (wp) {
-    addr_t wp_addr = wp->GetLoadAddress();
-    size_t wp_size = wp->GetByteSize();
-    bool wp_read = wp->WatchpointRead();
-    bool wp_write = wp->WatchpointWrite();
-    uint32_t wp_hw_index = wp->GetHardwareIndex();
-    POSIXBreakpointProtocol *reg_ctx = GetPOSIXBreakpointProtocol();
-    if (reg_ctx)
-      wp_set = reg_ctx->SetHardwareWatchpointWithIndex(
-          wp_addr, wp_size, wp_read, wp_write, wp_hw_index);
-  }
-  return wp_set;
-}
-
-bool FreeBSDThread::DisableHardwareWatchpoint(Watchpoint *wp) {
-  bool result = false;
-  if (wp) {
-    lldb::RegisterContextSP reg_ctx_sp = GetRegisterContext();
-    if (reg_ctx_sp.get())
-      result = reg_ctx_sp->ClearHardwareWatchpoint(wp->GetHardwareIndex());
-  }
-  return result;
-}
-
-uint32_t FreeBSDThread::NumSupportedHardwareWatchpoints() {
-  lldb::RegisterContextSP reg_ctx_sp = GetRegisterContext();
-  if (reg_ctx_sp.get())
-    return reg_ctx_sp->NumSupportedHardwareWatchpoints();
-  return 0;
-}
-
-uint32_t FreeBSDThread::FindVacantWatchpointIndex() {
-  uint32_t hw_index = LLDB_INVALID_INDEX32;
-  uint32_t num_hw_wps = NumSupportedHardwareWatchpoints();
-  uint32_t wp_idx;
-  POSIXBreakpointProtocol *reg_ctx = GetPOSIXBreakpointProtocol();
-  if (reg_ctx) {
-    for (wp_idx = 0; wp_idx < num_hw_wps; wp_idx++) {
-      if (reg_ctx->IsWatchpointVacant(wp_idx)) {
-        hw_index = wp_idx;
-        break;
-      }
-    }
-  }
-  return hw_index;
-}
-
-void FreeBSDThread::BreakNotify(const ProcessMessage &message) {
-  bool status;
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
-
-  assert(GetRegisterContext());
-  status = GetPOSIXBreakpointProtocol()->UpdateAfterBreakpoint();
-  assert(status && "Breakpoint update failed!");
-
-  // With our register state restored, resolve the breakpoint object
-  // corresponding to our current PC.
-  assert(GetRegisterContext());
-  lldb::addr_t pc = GetRegisterContext()->GetPC();
-  LLDB_LOGF(log, "FreeBSDThread::%s () PC=0x%8.8" PRIx64, __FUNCTION__, pc);
-  lldb::BreakpointSiteSP bp_site(
-      GetProcess()->GetBreakpointSiteList().FindByAddress(pc));
-
-  // If the breakpoint is for this thread, then we'll report the hit, but if it
-  // is for another thread, we create a stop reason with should_stop=false.  If
-  // there is no breakpoint location, then report an invalid stop reason. We
-  // don't need to worry about stepping over the breakpoint here, that will be
-  // taken care of when the thread resumes and notices that there's a
-  // breakpoint under the pc.
-  if (bp_site) {
-    lldb::break_id_t bp_id = bp_site->GetID();
-    // If we have an operating system plug-in, we might have set a thread
-    // specific breakpoint using the operating system thread ID, so we can't
-    // make any assumptions about the thread ID so we must always report the
-    // breakpoint regardless of the thread.
-    if (bp_site->ValidForThisThread(this) ||
-        GetProcess()->GetOperatingSystem() != nullptr)
-      SetStopInfo(StopInfo::CreateStopReasonWithBreakpointSiteID(*this, bp_id));
-    else {
-      const bool should_stop = false;
-      SetStopInfo(StopInfo::CreateStopReasonWithBreakpointSiteID(*this, bp_id,
-                                                                 should_stop));
-    }
-  } else
-    SetStopInfo(StopInfoSP());
-}
-
-void FreeBSDThread::WatchNotify(const ProcessMessage &message) {
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
-
-  lldb::addr_t halt_addr = message.GetHWAddress();
-  LLDB_LOGF(log,
-            "FreeBSDThread::%s () Hardware Watchpoint Address = 0x%8.8" PRIx64,
-            __FUNCTION__, halt_addr);
-
-  POSIXBreakpointProtocol *reg_ctx = GetPOSIXBreakpointProtocol();
-  if (reg_ctx) {
-    uint32_t num_hw_wps = reg_ctx->NumSupportedHardwareWatchpoints();
-    uint32_t wp_idx;
-    for (wp_idx = 0; wp_idx < num_hw_wps; wp_idx++) {
-      if (reg_ctx->IsWatchpointHit(wp_idx)) {
-        // Clear the watchpoint hit here
-        reg_ctx->ClearWatchpointHits();
-        break;
-      }
-    }
-
-    if (wp_idx == num_hw_wps)
-      return;
-
-    Target &target = GetProcess()->GetTarget();
-    lldb::addr_t wp_monitor_addr = reg_ctx->GetWatchpointAddress(wp_idx);
-    const WatchpointList &wp_list = target.GetWatchpointList();
-    lldb::WatchpointSP wp_sp = wp_list.FindByAddress(wp_monitor_addr);
-
-    assert(wp_sp.get() && "No watchpoint found");
-    SetStopInfo(
-        StopInfo::CreateStopReasonWithWatchpointID(*this, wp_sp->GetID()));
-  }
-}
-
-void FreeBSDThread::TraceNotify(const ProcessMessage &message) {
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
-
-  // Try to resolve the breakpoint object corresponding to the current PC.
-  assert(GetRegisterContext());
-  lldb::addr_t pc = GetRegisterContext()->GetPC();
-  LLDB_LOGF(log, "FreeBSDThread::%s () PC=0x%8.8" PRIx64, __FUNCTION__, pc);
-  lldb::BreakpointSiteSP bp_site(
-      GetProcess()->GetBreakpointSiteList().FindByAddress(pc));
-
-  // If the current pc is a breakpoint site then set the StopInfo to
-  // Breakpoint. Otherwise, set the StopInfo to Watchpoint or Trace. If we have
-  // an operating system plug-in, we might have set a thread specific
-  // breakpoint using the operating system thread ID, so we can't make any
-  // assumptions about the thread ID so we must always report the breakpoint
-  // regardless of the thread.
-  if (bp_site && (bp_site->ValidForThisThread(this) ||
-                  GetProcess()->GetOperatingSystem() != nullptr))
-    SetStopInfo(StopInfo::CreateStopReasonWithBreakpointSiteID(
-        *this, bp_site->GetID()));
-  else {
-    POSIXBreakpointProtocol *reg_ctx = GetPOSIXBreakpointProtocol();
-    if (reg_ctx) {
-      uint32_t num_hw_wps = reg_ctx->NumSupportedHardwareWatchpoints();
-      uint32_t wp_idx;
-      for (wp_idx = 0; wp_idx < num_hw_wps; wp_idx++) {
-        if (reg_ctx->IsWatchpointHit(wp_idx)) {
-          WatchNotify(message);
-          return;
-        }
-      }
-    }
-    SetStopInfo(StopInfo::CreateStopReasonToTrace(*this));
-  }
-}
-
-void FreeBSDThread::LimboNotify(const ProcessMessage &message) {
-  SetStopInfo(lldb::StopInfoSP(new POSIXLimboStopInfo(*this)));
-}
-
-void FreeBSDThread::SignalNotify(const ProcessMessage &message) {
-  int signo = message.GetSignal();
-  if (message.GetKind() == ProcessMessage::eCrashMessage) {
-    std::string stop_description = GetCrashReasonString(
-        message.GetCrashReason(), message.GetFaultAddress());
-    SetStopInfo(StopInfo::CreateStopReasonWithSignal(
-        *this, signo, stop_description.c_str()));
-  } else {
-    SetStopInfo(StopInfo::CreateStopReasonWithSignal(*this, signo));
-  }
-}
-
-void FreeBSDThread::SignalDeliveredNotify(const ProcessMessage &message) {
-  int signo = message.GetSignal();
-  SetStopInfo(StopInfo::CreateStopReasonWithSignal(*this, signo));
-}
-
-unsigned FreeBSDThread::GetRegisterIndexFromOffset(unsigned offset) {
-  unsigned reg = LLDB_INVALID_REGNUM;
-  ArchSpec arch = HostInfo::GetArchitecture();
-
-  switch (arch.GetMachine()) {
-  default:
-    llvm_unreachable("CPU type not supported!");
-    break;
-
-  case llvm::Triple::aarch64:
-  case llvm::Triple::arm:
-  case llvm::Triple::mips64:
-  case llvm::Triple::ppc:
-  case llvm::Triple::ppc64:
-  case llvm::Triple::x86:
-  case llvm::Triple::x86_64: {
-    POSIXBreakpointProtocol *reg_ctx = GetPOSIXBreakpointProtocol();
-    reg = reg_ctx->GetRegisterIndexFromOffset(offset);
-  } break;
-  }
-  return reg;
-}
-
-void FreeBSDThread::ExecNotify(const ProcessMessage &message) {
-  SetStopInfo(StopInfo::CreateStopReasonWithExec(*this));
-}
-
-const char *FreeBSDThread::GetRegisterName(unsigned reg) {
-  const char *name = nullptr;
-  ArchSpec arch = HostInfo::GetArchitecture();
-
-  switch (arch.GetMachine()) {
-  default:
-    assert(false && "CPU type not supported!");
-    break;
-
-  case llvm::Triple::aarch64:
-  case llvm::Triple::arm:
-  case llvm::Triple::mips64:
-  case llvm::Triple::ppc:
-  case llvm::Triple::ppc64:
-  case llvm::Triple::x86:
-  case llvm::Triple::x86_64:
-    name = GetRegisterContext()->GetRegisterName(reg);
-    break;
-  }
-  return name;
-}
-
-const char *FreeBSDThread::GetRegisterNameFromOffset(unsigned offset) {
-  return GetRegisterName(GetRegisterIndexFromOffset(offset));
-}