43 files changed, 2118 insertions, 6031 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 de9036fbfe56..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/FreeBSDThread.cpp
+++ /dev/null
@@ -1,615 +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:
-    case llvm::Triple::arm:
-      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, std::make_unique<RegisterInfoPOSIX_arm>(target_arch));
-      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));
-}
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/FreeBSDThread.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/FreeBSDThread.h
deleted file mode 100644
index 774ffb511bc6..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/FreeBSDThread.h
+++ /dev/null
@@ -1,111 +0,0 @@
-//===-- FreeBSDThread.h -----------------------------------------*- C++ -*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_FreeBSDThread_H_
-#define liblldb_FreeBSDThread_H_
-
-#include <memory>
-#include <string>
-
-#include "RegisterContextPOSIX.h"
-#include "lldb/Target/Thread.h"
-
-class ProcessMessage;
-class ProcessMonitor;
-class POSIXBreakpointProtocol;
-
-// @class FreeBSDThread
-// Abstraction of a FreeBSD thread.
-class FreeBSDThread : public lldb_private::Thread {
-public:
-  // Constructors and destructors
-  FreeBSDThread(lldb_private::Process &process, lldb::tid_t tid);
-
-  virtual ~FreeBSDThread();
-
-  // POSIXThread
-  void RefreshStateAfterStop() override;
-
-  // This notifies the thread when a private stop occurs.
-  void DidStop() override;
-
-  const char *GetInfo() override;
-
-  void SetName(const char *name) override;
-
-  const char *GetName() override;
-
-  lldb::RegisterContextSP GetRegisterContext() override;
-
-  lldb::RegisterContextSP
-  CreateRegisterContextForFrame(lldb_private::StackFrame *frame) override;
-
-  lldb::addr_t GetThreadPointer() override;
-
-  // These functions provide a mapping from the register offset
-  // back to the register index or name for use in debugging or log
-  // output.
-
-  unsigned GetRegisterIndexFromOffset(unsigned offset);
-
-  const char *GetRegisterName(unsigned reg);
-
-  const char *GetRegisterNameFromOffset(unsigned offset);
-
-  // These methods form a specialized interface to POSIX threads.
-  //
-  bool Resume();
-
-  void Notify(const ProcessMessage &message);
-
-  // These methods provide an interface to watchpoints
-  //
-  bool EnableHardwareWatchpoint(lldb_private::Watchpoint *wp);
-
-  bool DisableHardwareWatchpoint(lldb_private::Watchpoint *wp);
-
-  uint32_t NumSupportedHardwareWatchpoints();
-
-  uint32_t FindVacantWatchpointIndex();
-
-protected:
-  POSIXBreakpointProtocol *GetPOSIXBreakpointProtocol() {
-    if (!m_reg_context_sp)
-      m_reg_context_sp = GetRegisterContext();
-    return m_posix_thread;
-  }
-
-  std::unique_ptr<lldb_private::StackFrame> m_frame_up;
-
-  lldb::BreakpointSiteSP m_breakpoint;
-
-  bool m_thread_name_valid;
-  std::string m_thread_name;
-  POSIXBreakpointProtocol *m_posix_thread;
-
-  ProcessMonitor &GetMonitor();
-
-  bool CalculateStopInfo() override;
-
-  void BreakNotify(const ProcessMessage &message);
-  void WatchNotify(const ProcessMessage &message);
-  virtual void TraceNotify(const ProcessMessage &message);
-  void LimboNotify(const ProcessMessage &message);
-  void SignalNotify(const ProcessMessage &message);
-  void SignalDeliveredNotify(const ProcessMessage &message);
-  void CrashNotify(const ProcessMessage &message);
-  void ExitNotify(const ProcessMessage &message);
-  void ExecNotify(const ProcessMessage &message);
-
-  // FreeBSDThread internal API.
-
-  // POSIXThread override
-  virtual void WillResume(lldb::StateType resume_state) override;
-};
-
-#endif // #ifndef liblldb_FreeBSDThread_H_
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSDRemote/NativeProcessFreeBSD.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeProcessFreeBSD.cpp
index 163093c2ab1f..5961ff4439db 100644
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSDRemote/NativeProcessFreeBSD.cpp
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeProcessFreeBSD.cpp
@@ -213,8 +213,9 @@ void NativeProcessFreeBSD::MonitorSIGTRAP(lldb::pid_t pid) {
       llvm::Error error = t.CopyWatchpointsFrom(
           static_cast<NativeThreadFreeBSD &>(*GetCurrentThread()));
       if (error) {
-        LLDB_LOG(log, "failed to copy watchpoints to new thread {0}: {1}",
-                 info.pl_lwpid, llvm::toString(std::move(error)));
+        LLDB_LOG_ERROR(log, std::move(error),
+                       "failed to copy watchpoints to new thread {1}: {0}",
+                       info.pl_lwpid);
         SetState(StateType::eStateInvalid);
         return;
       }
@@ -264,19 +265,35 @@ void NativeProcessFreeBSD::MonitorSIGTRAP(lldb::pid_t pid) {
 
     switch (info.pl_siginfo.si_code) {
     case TRAP_BRKPT:
+      LLDB_LOG(log, "SIGTRAP/TRAP_BRKPT: si_addr: {0}",
+               info.pl_siginfo.si_addr);
+
       if (thread) {
-        thread->SetStoppedByBreakpoint();
+        auto thread_info =
+            m_threads_stepping_with_breakpoint.find(thread->GetID());
+        if (thread_info != m_threads_stepping_with_breakpoint.end()) {
+          thread->SetStoppedByTrace();
+          Status brkpt_error = RemoveBreakpoint(thread_info->second);
+          if (brkpt_error.Fail())
+            LLDB_LOG(log, "pid = {0} remove stepping breakpoint: {1}",
+                     thread_info->first, brkpt_error);
+          m_threads_stepping_with_breakpoint.erase(thread_info);
+        } else
+          thread->SetStoppedByBreakpoint();
         FixupBreakpointPCAsNeeded(*thread);
       }
       SetState(StateType::eStateStopped, true);
       return;
     case TRAP_TRACE:
+      LLDB_LOG(log, "SIGTRAP/TRAP_TRACE: si_addr: {0}",
+               info.pl_siginfo.si_addr);
+
       if (thread) {
         auto &regctx = static_cast<NativeRegisterContextFreeBSD &>(
             thread->GetRegisterContext());
         uint32_t wp_index = LLDB_INVALID_INDEX32;
-        Status error =
-            regctx.GetWatchpointHitIndex(wp_index, LLDB_INVALID_ADDRESS);
+        Status error = regctx.GetWatchpointHitIndex(
+            wp_index, reinterpret_cast<uintptr_t>(info.pl_siginfo.si_addr));
         if (error.Fail())
           LLDB_LOG(log,
                    "received error while checking for watchpoint hits, pid = "
@@ -354,6 +371,27 @@ Status NativeProcessFreeBSD::PtraceWrapper(int req, lldb::pid_t pid, void *addr,
   return error;
 }
 
+llvm::Expected<llvm::ArrayRef<uint8_t>>
+NativeProcessFreeBSD::GetSoftwareBreakpointTrapOpcode(size_t size_hint) {
+  static const uint8_t g_arm_opcode[] = {0xfe, 0xde, 0xff, 0xe7};
+  static const uint8_t g_thumb_opcode[] = {0x01, 0xde};
+
+  switch (GetArchitecture().GetMachine()) {
+  case llvm::Triple::arm:
+    switch (size_hint) {
+    case 2:
+      return llvm::makeArrayRef(g_thumb_opcode);
+    case 4:
+      return llvm::makeArrayRef(g_arm_opcode);
+    default:
+      return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                     "Unrecognised trap opcode size hint!");
+    }
+  default:
+    return NativeProcessProtocol::GetSoftwareBreakpointTrapOpcode(size_hint);
+  }
+}
+
 Status NativeProcessFreeBSD::Resume(const ResumeActionList &resume_actions) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
   LLDB_LOG(log, "pid {0}", GetID());
@@ -623,9 +661,8 @@ size_t NativeProcessFreeBSD::UpdateThreads() { return m_threads.size(); }
 Status NativeProcessFreeBSD::SetBreakpoint(lldb::addr_t addr, uint32_t size,
                                            bool hardware) {
   if (hardware)
-    return Status("NativeProcessFreeBSD does not support hardware breakpoints");
-  else
-    return SetSoftwareBreakpoint(addr, size);
+    return SetHardwareBreakpoint(addr, size);
+  return SetSoftwareBreakpoint(addr, size);
 }
 
 Status NativeProcessFreeBSD::GetLoadedModuleFileSpec(const char *module_path,
@@ -878,3 +915,7 @@ Status NativeProcessFreeBSD::ReinitializeThreads() {
 
   return error;
 }
+
+bool NativeProcessFreeBSD::SupportHardwareSingleStepping() const {
+  return !m_arch.IsMIPS();
+}
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSDRemote/NativeProcessFreeBSD.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeProcessFreeBSD.h
index 3c7a9400f9c4..ceffc370ca33 100644
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSDRemote/NativeProcessFreeBSD.h
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeProcessFreeBSD.h
@@ -10,6 +10,8 @@
 #define liblldb_NativeProcessFreeBSD_H_
 
 #include "Plugins/Process/POSIX/NativeProcessELF.h"
+#include "Plugins/Process/Utility/NativeProcessSoftwareSingleStep.h"
+
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
@@ -25,7 +27,8 @@ namespace process_freebsd {
 /// for debugging.
 ///
 /// Changes in the inferior process state are broadcasted.
-class NativeProcessFreeBSD : public NativeProcessELF {
+class NativeProcessFreeBSD : public NativeProcessELF,
+                             private NativeProcessSoftwareSingleStep {
 public:
   class Factory : public NativeProcessProtocol::Factory {
   public:
@@ -84,6 +87,12 @@ public:
   static Status PtraceWrapper(int req, lldb::pid_t pid, void *addr = nullptr,
                               int data = 0, int *result = nullptr);
 
+  bool SupportHardwareSingleStepping() const;
+
+protected:
+  llvm::Expected<llvm::ArrayRef<uint8_t>>
+  GetSoftwareBreakpointTrapOpcode(size_t size_hint) override;
+
 private:
   MainLoop::SignalHandleUP m_sigchld_handle;
   ArchSpec m_arch;
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD.cpp
index ac3cc4fe788a..3d744f773a26 100644
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD.cpp
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD.cpp
@@ -8,7 +8,7 @@
 
 #include "NativeRegisterContextFreeBSD.h"
 
-#include "Plugins/Process/FreeBSDRemote/NativeProcessFreeBSD.h"
+#include "Plugins/Process/FreeBSD/NativeProcessFreeBSD.h"
 
 #include "lldb/Host/common/NativeProcessProtocol.h"
 
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD.h
index 0000484beac9..0000484beac9 100644
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD.h
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD.h
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm.cpp
new file mode 100644
index 000000000000..c4ee3773eaeb
--- /dev/null
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm.cpp
@@ -0,0 +1,202 @@
+//===-- NativeRegisterContextFreeBSD_arm.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
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__arm__)
+
+#include "NativeRegisterContextFreeBSD_arm.h"
+
+#include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Status.h"
+
+#include "Plugins/Process/FreeBSD/NativeProcessFreeBSD.h"
+#include "Plugins/Process/Utility/RegisterInfoPOSIX_arm.h"
+
+// clang-format off
+#include <sys/param.h>
+#include <sys/ptrace.h>
+#include <sys/types.h>
+// clang-format on
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::process_freebsd;
+
+NativeRegisterContextFreeBSD *
+NativeRegisterContextFreeBSD::CreateHostNativeRegisterContextFreeBSD(
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
+  return new NativeRegisterContextFreeBSD_arm(target_arch, native_thread);
+}
+
+NativeRegisterContextFreeBSD_arm::NativeRegisterContextFreeBSD_arm(
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
+    : NativeRegisterContextRegisterInfo(
+          native_thread, new RegisterInfoPOSIX_arm(target_arch)) {}
+
+RegisterInfoPOSIX_arm &
+NativeRegisterContextFreeBSD_arm::GetRegisterInfo() const {
+  return static_cast<RegisterInfoPOSIX_arm &>(*m_register_info_interface_up);
+}
+
+uint32_t NativeRegisterContextFreeBSD_arm::GetRegisterSetCount() const {
+  return GetRegisterInfo().GetRegisterSetCount();
+}
+
+const RegisterSet *
+NativeRegisterContextFreeBSD_arm::GetRegisterSet(uint32_t set_index) const {
+  return GetRegisterInfo().GetRegisterSet(set_index);
+}
+
+uint32_t NativeRegisterContextFreeBSD_arm::GetUserRegisterCount() const {
+  uint32_t count = 0;
+  for (uint32_t set_index = 0; set_index < GetRegisterSetCount(); ++set_index)
+    count += GetRegisterSet(set_index)->num_registers;
+  return count;
+}
+
+Status NativeRegisterContextFreeBSD_arm::ReadRegisterSet(uint32_t set) {
+  switch (set) {
+  case RegisterInfoPOSIX_arm::GPRegSet:
+    return NativeProcessFreeBSD::PtraceWrapper(PT_GETREGS, m_thread.GetID(),
+                                               m_reg_data.data());
+  case RegisterInfoPOSIX_arm::FPRegSet:
+    return NativeProcessFreeBSD::PtraceWrapper(
+        PT_GETVFPREGS, m_thread.GetID(),
+        m_reg_data.data() + sizeof(RegisterInfoPOSIX_arm::GPR));
+  }
+  llvm_unreachable("NativeRegisterContextFreeBSD_arm::ReadRegisterSet");
+}
+
+Status NativeRegisterContextFreeBSD_arm::WriteRegisterSet(uint32_t set) {
+  switch (set) {
+  case RegisterInfoPOSIX_arm::GPRegSet:
+    return NativeProcessFreeBSD::PtraceWrapper(PT_SETREGS, m_thread.GetID(),
+                                               m_reg_data.data());
+  case RegisterInfoPOSIX_arm::FPRegSet:
+    return NativeProcessFreeBSD::PtraceWrapper(
+        PT_SETVFPREGS, m_thread.GetID(),
+        m_reg_data.data() + sizeof(RegisterInfoPOSIX_arm::GPR));
+  }
+  llvm_unreachable("NativeRegisterContextFreeBSD_arm::WriteRegisterSet");
+}
+
+Status
+NativeRegisterContextFreeBSD_arm::ReadRegister(const RegisterInfo *reg_info,
+                                               RegisterValue &reg_value) {
+  Status error;
+
+  if (!reg_info) {
+    error.SetErrorString("reg_info NULL");
+    return error;
+  }
+
+  const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
+
+  if (reg == LLDB_INVALID_REGNUM)
+    return Status("no lldb regnum for %s", reg_info && reg_info->name
+                                               ? reg_info->name
+                                               : "<unknown register>");
+
+  uint32_t set = GetRegisterInfo().GetRegisterSetFromRegisterIndex(reg);
+  error = ReadRegisterSet(set);
+  if (error.Fail())
+    return error;
+
+  assert(reg_info->byte_offset + reg_info->byte_size <= m_reg_data.size());
+  reg_value.SetBytes(m_reg_data.data() + reg_info->byte_offset,
+                     reg_info->byte_size, endian::InlHostByteOrder());
+  return error;
+}
+
+Status NativeRegisterContextFreeBSD_arm::WriteRegister(
+    const RegisterInfo *reg_info, const RegisterValue &reg_value) {
+  Status error;
+
+  if (!reg_info)
+    return Status("reg_info NULL");
+
+  const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
+
+  if (reg == LLDB_INVALID_REGNUM)
+    return Status("no lldb regnum for %s", reg_info && reg_info->name
+                                               ? reg_info->name
+                                               : "<unknown register>");
+
+  uint32_t set = GetRegisterInfo().GetRegisterSetFromRegisterIndex(reg);
+  error = ReadRegisterSet(set);
+  if (error.Fail())
+    return error;
+
+  assert(reg_info->byte_offset + reg_info->byte_size <= m_reg_data.size());
+  ::memcpy(m_reg_data.data() + reg_info->byte_offset, reg_value.GetBytes(),
+           reg_info->byte_size);
+
+  return WriteRegisterSet(set);
+}
+
+Status NativeRegisterContextFreeBSD_arm::ReadAllRegisterValues(
+    lldb::DataBufferSP &data_sp) {
+  Status error;
+
+  error = ReadRegisterSet(RegisterInfoPOSIX_arm::GPRegSet);
+  if (error.Fail())
+    return error;
+
+  error = ReadRegisterSet(RegisterInfoPOSIX_arm::FPRegSet);
+  if (error.Fail())
+    return error;
+
+  data_sp.reset(new DataBufferHeap(m_reg_data.size(), 0));
+  uint8_t *dst = data_sp->GetBytes();
+  ::memcpy(dst, m_reg_data.data(), m_reg_data.size());
+
+  return error;
+}
+
+Status NativeRegisterContextFreeBSD_arm::WriteAllRegisterValues(
+    const lldb::DataBufferSP &data_sp) {
+  Status error;
+
+  if (!data_sp) {
+    error.SetErrorStringWithFormat(
+        "NativeRegisterContextFreeBSD_arm::%s invalid data_sp provided",
+        __FUNCTION__);
+    return error;
+  }
+
+  if (data_sp->GetByteSize() != m_reg_data.size()) {
+    error.SetErrorStringWithFormat(
+        "NativeRegisterContextFreeBSD_arm::%s data_sp contained mismatched "
+        "data size, expected %" PRIu64 ", actual %" PRIu64,
+        __FUNCTION__, m_reg_data.size(), data_sp->GetByteSize());
+    return error;
+  }
+
+  uint8_t *src = data_sp->GetBytes();
+  if (src == nullptr) {
+    error.SetErrorStringWithFormat("NativeRegisterContextFreeBSD_arm::%s "
+                                   "DataBuffer::GetBytes() returned a null "
+                                   "pointer",
+                                   __FUNCTION__);
+    return error;
+  }
+  ::memcpy(m_reg_data.data(), src, m_reg_data.size());
+
+  error = WriteRegisterSet(RegisterInfoPOSIX_arm::GPRegSet);
+  if (error.Fail())
+    return error;
+
+  return WriteRegisterSet(RegisterInfoPOSIX_arm::FPRegSet);
+}
+
+llvm::Error NativeRegisterContextFreeBSD_arm::CopyHardwareWatchpointsFrom(
+    NativeRegisterContextFreeBSD &source) {
+  return llvm::Error::success();
+}
+
+#endif // defined (__arm__)
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm.h
new file mode 100644
index 000000000000..4be75b958fc1
--- /dev/null
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm.h
@@ -0,0 +1,68 @@
+//===-- NativeRegisterContextFreeBSD_arm.h ----------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__arm__)
+
+#ifndef lldb_NativeRegisterContextFreeBSD_arm_h
+#define lldb_NativeRegisterContextFreeBSD_arm_h
+
+// clang-format off
+#include <sys/types.h>
+#include <machine/reg.h>
+#include <machine/vfp.h>
+// clang-format on
+
+#include "Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD.h"
+#include "Plugins/Process/Utility/RegisterInfoPOSIX_arm.h"
+
+#include <array>
+
+namespace lldb_private {
+namespace process_freebsd {
+
+class NativeProcessFreeBSD;
+
+class NativeRegisterContextFreeBSD_arm : public NativeRegisterContextFreeBSD {
+public:
+  NativeRegisterContextFreeBSD_arm(const ArchSpec &target_arch,
+                                   NativeThreadProtocol &native_thread);
+
+  uint32_t GetRegisterSetCount() const override;
+
+  uint32_t GetUserRegisterCount() const override;
+
+  const RegisterSet *GetRegisterSet(uint32_t set_index) const override;
+
+  Status ReadRegister(const RegisterInfo *reg_info,
+                      RegisterValue &reg_value) override;
+
+  Status WriteRegister(const RegisterInfo *reg_info,
+                       const RegisterValue &reg_value) override;
+
+  Status ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
+
+  Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
+
+  llvm::Error
+  CopyHardwareWatchpointsFrom(NativeRegisterContextFreeBSD &source) override;
+
+private:
+  std::array<uint8_t, sizeof(reg) + sizeof(vfp_state)> m_reg_data;
+
+  Status ReadRegisterSet(uint32_t set);
+  Status WriteRegisterSet(uint32_t set);
+
+  RegisterInfoPOSIX_arm &GetRegisterInfo() const;
+};
+
+} // namespace process_freebsd
+} // namespace lldb_private
+
+#endif // #ifndef lldb_NativeRegisterContextFreeBSD_arm_h
+
+#endif // defined (__arm__)
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm64.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm64.cpp
new file mode 100644
index 000000000000..e98e0a8a0caa
--- /dev/null
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm64.cpp
@@ -0,0 +1,288 @@
+//===-- NativeRegisterContextFreeBSD_arm64.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
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__aarch64__)
+
+#include "NativeRegisterContextFreeBSD_arm64.h"
+
+#include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Status.h"
+
+#include "Plugins/Process/FreeBSD/NativeProcessFreeBSD.h"
+#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
+#include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h"
+
+// clang-format off
+#include <sys/param.h>
+#include <sys/ptrace.h>
+#include <sys/types.h>
+// clang-format on
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::process_freebsd;
+
+NativeRegisterContextFreeBSD *
+NativeRegisterContextFreeBSD::CreateHostNativeRegisterContextFreeBSD(
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
+  return new NativeRegisterContextFreeBSD_arm64(target_arch, native_thread);
+}
+
+NativeRegisterContextFreeBSD_arm64::NativeRegisterContextFreeBSD_arm64(
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
+    : NativeRegisterContextRegisterInfo(
+          native_thread, new RegisterInfoPOSIX_arm64(target_arch))
+#ifdef LLDB_HAS_FREEBSD_WATCHPOINT
+      ,
+      m_read_dbreg(false)
+#endif
+{
+  GetRegisterInfo().ConfigureVectorRegisterInfos(
+      RegisterInfoPOSIX_arm64::eVectorQuadwordAArch64);
+  ::memset(&m_hwp_regs, 0, sizeof(m_hwp_regs));
+  ::memset(&m_hbp_regs, 0, sizeof(m_hbp_regs));
+}
+
+RegisterInfoPOSIX_arm64 &
+NativeRegisterContextFreeBSD_arm64::GetRegisterInfo() const {
+  return static_cast<RegisterInfoPOSIX_arm64 &>(*m_register_info_interface_up);
+}
+
+uint32_t NativeRegisterContextFreeBSD_arm64::GetRegisterSetCount() const {
+  return GetRegisterInfo().GetRegisterSetCount();
+}
+
+const RegisterSet *
+NativeRegisterContextFreeBSD_arm64::GetRegisterSet(uint32_t set_index) const {
+  return GetRegisterInfo().GetRegisterSet(set_index);
+}
+
+uint32_t NativeRegisterContextFreeBSD_arm64::GetUserRegisterCount() const {
+  uint32_t count = 0;
+  for (uint32_t set_index = 0; set_index < GetRegisterSetCount(); ++set_index)
+    count += GetRegisterSet(set_index)->num_registers;
+  return count;
+}
+
+Status NativeRegisterContextFreeBSD_arm64::ReadRegisterSet(uint32_t set) {
+  switch (set) {
+  case RegisterInfoPOSIX_arm64::GPRegSet:
+    return NativeProcessFreeBSD::PtraceWrapper(PT_GETREGS, m_thread.GetID(),
+                                               m_reg_data.data());
+  case RegisterInfoPOSIX_arm64::FPRegSet:
+    return NativeProcessFreeBSD::PtraceWrapper(
+        PT_GETFPREGS, m_thread.GetID(),
+        m_reg_data.data() + sizeof(RegisterInfoPOSIX_arm64::GPR));
+  case RegisterInfoPOSIX_arm64::SVERegSet:
+    return Status("not supported");
+  }
+  llvm_unreachable("NativeRegisterContextFreeBSD_arm64::ReadRegisterSet");
+}
+
+Status NativeRegisterContextFreeBSD_arm64::WriteRegisterSet(uint32_t set) {
+  switch (set) {
+  case RegisterInfoPOSIX_arm64::GPRegSet:
+    return NativeProcessFreeBSD::PtraceWrapper(PT_SETREGS, m_thread.GetID(),
+                                               m_reg_data.data());
+  case RegisterInfoPOSIX_arm64::FPRegSet:
+    return NativeProcessFreeBSD::PtraceWrapper(
+        PT_SETFPREGS, m_thread.GetID(),
+        m_reg_data.data() + sizeof(RegisterInfoPOSIX_arm64::GPR));
+  case RegisterInfoPOSIX_arm64::SVERegSet:
+    return Status("not supported");
+  }
+  llvm_unreachable("NativeRegisterContextFreeBSD_arm64::WriteRegisterSet");
+}
+
+Status
+NativeRegisterContextFreeBSD_arm64::ReadRegister(const RegisterInfo *reg_info,
+                                                 RegisterValue &reg_value) {
+  Status error;
+
+  if (!reg_info) {
+    error.SetErrorString("reg_info NULL");
+    return error;
+  }
+
+  const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
+
+  if (reg == LLDB_INVALID_REGNUM)
+    return Status("no lldb regnum for %s", reg_info && reg_info->name
+                                               ? reg_info->name
+                                               : "<unknown register>");
+
+  uint32_t set = GetRegisterInfo().GetRegisterSetFromRegisterIndex(reg);
+  error = ReadRegisterSet(set);
+  if (error.Fail())
+    return error;
+
+  assert(reg_info->byte_offset + reg_info->byte_size <= m_reg_data.size());
+  reg_value.SetBytes(m_reg_data.data() + reg_info->byte_offset,
+                     reg_info->byte_size, endian::InlHostByteOrder());
+  return error;
+}
+
+Status NativeRegisterContextFreeBSD_arm64::WriteRegister(
+    const RegisterInfo *reg_info, const RegisterValue &reg_value) {
+  Status error;
+
+  if (!reg_info)
+    return Status("reg_info NULL");
+
+  const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
+
+  if (reg == LLDB_INVALID_REGNUM)
+    return Status("no lldb regnum for %s", reg_info && reg_info->name
+                                               ? reg_info->name
+                                               : "<unknown register>");
+
+  uint32_t set = GetRegisterInfo().GetRegisterSetFromRegisterIndex(reg);
+  error = ReadRegisterSet(set);
+  if (error.Fail())
+    return error;
+
+  assert(reg_info->byte_offset + reg_info->byte_size <= m_reg_data.size());
+  ::memcpy(m_reg_data.data() + reg_info->byte_offset, reg_value.GetBytes(),
+           reg_info->byte_size);
+
+  return WriteRegisterSet(set);
+}
+
+Status NativeRegisterContextFreeBSD_arm64::ReadAllRegisterValues(
+    lldb::DataBufferSP &data_sp) {
+  Status error;
+
+  error = ReadRegisterSet(RegisterInfoPOSIX_arm64::GPRegSet);
+  if (error.Fail())
+    return error;
+
+  error = ReadRegisterSet(RegisterInfoPOSIX_arm64::FPRegSet);
+  if (error.Fail())
+    return error;
+
+  data_sp.reset(new DataBufferHeap(m_reg_data.size(), 0));
+  uint8_t *dst = data_sp->GetBytes();
+  ::memcpy(dst, m_reg_data.data(), m_reg_data.size());
+
+  return error;
+}
+
+Status NativeRegisterContextFreeBSD_arm64::WriteAllRegisterValues(
+    const lldb::DataBufferSP &data_sp) {
+  Status error;
+
+  if (!data_sp) {
+    error.SetErrorStringWithFormat(
+        "NativeRegisterContextFreeBSD_arm64::%s invalid data_sp provided",
+        __FUNCTION__);
+    return error;
+  }
+
+  if (data_sp->GetByteSize() != m_reg_data.size()) {
+    error.SetErrorStringWithFormat(
+        "NativeRegisterContextFreeBSD_arm64::%s data_sp contained mismatched "
+        "data size, expected %" PRIu64 ", actual %" PRIu64,
+        __FUNCTION__, m_reg_data.size(), data_sp->GetByteSize());
+    return error;
+  }
+
+  uint8_t *src = data_sp->GetBytes();
+  if (src == nullptr) {
+    error.SetErrorStringWithFormat("NativeRegisterContextFreeBSD_arm64::%s "
+                                   "DataBuffer::GetBytes() returned a null "
+                                   "pointer",
+                                   __FUNCTION__);
+    return error;
+  }
+  ::memcpy(m_reg_data.data(), src, m_reg_data.size());
+
+  error = WriteRegisterSet(RegisterInfoPOSIX_arm64::GPRegSet);
+  if (error.Fail())
+    return error;
+
+  return WriteRegisterSet(RegisterInfoPOSIX_arm64::FPRegSet);
+}
+
+llvm::Error NativeRegisterContextFreeBSD_arm64::CopyHardwareWatchpointsFrom(
+    NativeRegisterContextFreeBSD &source) {
+#ifdef LLDB_HAS_FREEBSD_WATCHPOINT
+  auto &r_source = static_cast<NativeRegisterContextFreeBSD_arm64 &>(source);
+  llvm::Error error = r_source.ReadHardwareDebugInfo();
+  if (error)
+    return error;
+
+  m_dbreg = r_source.m_dbreg;
+  m_hbp_regs = r_source.m_hbp_regs;
+  m_hwp_regs = r_source.m_hwp_regs;
+  m_max_hbp_supported = r_source.m_max_hbp_supported;
+  m_max_hwp_supported = r_source.m_max_hwp_supported;
+  m_read_dbreg = true;
+
+  // on FreeBSD this writes both breakpoints and watchpoints
+  return WriteHardwareDebugRegs(eDREGTypeWATCH);
+#else
+  return llvm::Error::success();
+#endif
+}
+
+llvm::Error NativeRegisterContextFreeBSD_arm64::ReadHardwareDebugInfo() {
+#ifdef LLDB_HAS_FREEBSD_WATCHPOINT
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_REGISTERS));
+
+  // we're fully stateful, so no need to reread control registers ever
+  if (m_read_dbreg)
+    return llvm::Error::success();
+
+  Status res = NativeProcessFreeBSD::PtraceWrapper(PT_GETDBREGS,
+                                                   m_thread.GetID(), &m_dbreg);
+  if (res.Fail())
+    return res.ToError();
+
+  LLDB_LOG(log, "m_dbreg read: debug_ver={0}, nbkpts={1}, nwtpts={2}",
+           m_dbreg.db_debug_ver, m_dbreg.db_nbkpts, m_dbreg.db_nwtpts);
+  m_max_hbp_supported = m_dbreg.db_nbkpts;
+  m_max_hwp_supported = m_dbreg.db_nwtpts;
+  assert(m_max_hbp_supported <= m_hbp_regs.size());
+  assert(m_max_hwp_supported <= m_hwp_regs.size());
+
+  m_read_dbreg = true;
+  return llvm::Error::success();
+#else
+  return llvm::createStringError(
+      llvm::inconvertibleErrorCode(),
+      "Hardware breakpoints/watchpoints require FreeBSD 14.0");
+#endif
+}
+
+llvm::Error
+NativeRegisterContextFreeBSD_arm64::WriteHardwareDebugRegs(DREGType) {
+#ifdef LLDB_HAS_FREEBSD_WATCHPOINT
+  assert(m_read_dbreg && "dbregs must be read before writing them back");
+
+  // copy data from m_*_regs to m_dbreg before writing it back
+  for (uint32_t i = 0; i < m_max_hbp_supported; i++) {
+    m_dbreg.db_breakregs[i].dbr_addr = m_hbp_regs[i].address;
+    m_dbreg.db_breakregs[i].dbr_ctrl = m_hbp_regs[i].control;
+  }
+  for (uint32_t i = 0; i < m_max_hwp_supported; i++) {
+    m_dbreg.db_watchregs[i].dbw_addr = m_hwp_regs[i].address;
+    m_dbreg.db_watchregs[i].dbw_ctrl = m_hwp_regs[i].control;
+  }
+
+  return NativeProcessFreeBSD::PtraceWrapper(PT_SETDBREGS, m_thread.GetID(),
+                                             &m_dbreg)
+      .ToError();
+#else
+  return llvm::createStringError(
+      llvm::inconvertibleErrorCode(),
+      "Hardware breakpoints/watchpoints require FreeBSD 14.0");
+#endif
+}
+
+#endif // defined (__aarch64__)
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm64.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm64.h
new file mode 100644
index 000000000000..a230f8fed48a
--- /dev/null
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm64.h
@@ -0,0 +1,86 @@
+//===-- NativeRegisterContextFreeBSD_arm64.h --------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__aarch64__)
+
+#ifndef lldb_NativeRegisterContextFreeBSD_arm64_h
+#define lldb_NativeRegisterContextFreeBSD_arm64_h
+
+// clang-format off
+#include <sys/types.h>
+#include <sys/param.h>
+#include <machine/reg.h>
+// clang-format on
+
+#include "Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD.h"
+#include "Plugins/Process/Utility/NativeRegisterContextDBReg_arm64.h"
+#include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h"
+
+#include <array>
+
+#if __FreeBSD_version >= 1300139
+#  define LLDB_HAS_FREEBSD_WATCHPOINT 1
+#endif
+
+namespace lldb_private {
+namespace process_freebsd {
+
+class NativeProcessFreeBSD;
+
+class NativeRegisterContextFreeBSD_arm64
+    : public NativeRegisterContextFreeBSD,
+      public NativeRegisterContextDBReg_arm64 {
+public:
+  NativeRegisterContextFreeBSD_arm64(const ArchSpec &target_arch,
+                                     NativeThreadProtocol &native_thread);
+
+  uint32_t GetRegisterSetCount() const override;
+
+  uint32_t GetUserRegisterCount() const override;
+
+  const RegisterSet *GetRegisterSet(uint32_t set_index) const override;
+
+  Status ReadRegister(const RegisterInfo *reg_info,
+                      RegisterValue &reg_value) override;
+
+  Status WriteRegister(const RegisterInfo *reg_info,
+                       const RegisterValue &reg_value) override;
+
+  Status ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
+
+  Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
+
+  llvm::Error
+  CopyHardwareWatchpointsFrom(NativeRegisterContextFreeBSD &source) override;
+
+private:
+  // Due to alignment, FreeBSD reg/fpreg are a few bytes larger than
+  // LLDB's GPR/FPU structs.  However, all fields have matching offsets
+  // and sizes, so we do not have to worry about these (and we have
+  // a unittest to assert that).
+  std::array<uint8_t, sizeof(reg) + sizeof(fpreg)> m_reg_data;
+#ifdef LLDB_HAS_FREEBSD_WATCHPOINT
+  dbreg m_dbreg;
+  bool m_read_dbreg;
+#endif
+
+  Status ReadRegisterSet(uint32_t set);
+  Status WriteRegisterSet(uint32_t set);
+
+  llvm::Error ReadHardwareDebugInfo() override;
+  llvm::Error WriteHardwareDebugRegs(DREGType hwbType) override;
+
+  RegisterInfoPOSIX_arm64 &GetRegisterInfo() const;
+};
+
+} // namespace process_freebsd
+} // namespace lldb_private
+
+#endif // #ifndef lldb_NativeRegisterContextFreeBSD_arm64_h
+
+#endif // defined (__aarch64__)
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_mips64.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_mips64.cpp
new file mode 100644
index 000000000000..8e722c09314c
--- /dev/null
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_mips64.cpp
@@ -0,0 +1,186 @@
+//===-- NativeRegisterContextFreeBSD_mips64.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
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__mips64__)
+
+#include "NativeRegisterContextFreeBSD_mips64.h"
+
+#include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Status.h"
+
+#include "Plugins/Process/FreeBSD/NativeProcessFreeBSD.h"
+
+// clang-format off
+#include <sys/param.h>
+#include <sys/ptrace.h>
+#include <sys/types.h>
+// clang-format on
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::process_freebsd;
+
+NativeRegisterContextFreeBSD *
+NativeRegisterContextFreeBSD::CreateHostNativeRegisterContextFreeBSD(
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
+  return new NativeRegisterContextFreeBSD_mips64(target_arch, native_thread);
+}
+
+NativeRegisterContextFreeBSD_mips64::NativeRegisterContextFreeBSD_mips64(
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
+    : NativeRegisterContextRegisterInfo(
+          native_thread, new RegisterContextFreeBSD_mips64(target_arch)) {}
+
+RegisterContextFreeBSD_mips64 &
+NativeRegisterContextFreeBSD_mips64::GetRegisterInfo() const {
+  return static_cast<RegisterContextFreeBSD_mips64 &>(
+      *m_register_info_interface_up);
+}
+
+uint32_t NativeRegisterContextFreeBSD_mips64::GetRegisterSetCount() const {
+  return GetRegisterInfo().GetRegisterSetCount();
+}
+
+const RegisterSet *
+NativeRegisterContextFreeBSD_mips64::GetRegisterSet(uint32_t set_index) const {
+  return GetRegisterInfo().GetRegisterSet(set_index);
+}
+
+uint32_t NativeRegisterContextFreeBSD_mips64::GetUserRegisterCount() const {
+  uint32_t count = 0;
+  for (uint32_t set_index = 0; set_index < GetRegisterSetCount(); ++set_index)
+    count += GetRegisterSet(set_index)->num_registers;
+  return count;
+}
+
+Status NativeRegisterContextFreeBSD_mips64::ReadRegisterSet(RegSetKind set) {
+  switch (set) {
+  case GPRegSet:
+    return NativeProcessFreeBSD::PtraceWrapper(PT_GETREGS, m_thread.GetID(),
+                                               m_reg_data.data());
+  }
+  llvm_unreachable("NativeRegisterContextFreeBSD_mips64::ReadRegisterSet");
+}
+
+Status NativeRegisterContextFreeBSD_mips64::WriteRegisterSet(RegSetKind set) {
+  switch (set) {
+  case GPRegSet:
+    return NativeProcessFreeBSD::PtraceWrapper(PT_SETREGS, m_thread.GetID(),
+                                               m_reg_data.data());
+  }
+  llvm_unreachable("NativeRegisterContextFreeBSD_mips64::WriteRegisterSet");
+}
+
+Status
+NativeRegisterContextFreeBSD_mips64::ReadRegister(const RegisterInfo *reg_info,
+                                                  RegisterValue &reg_value) {
+  Status error;
+
+  if (!reg_info) {
+    error.SetErrorString("reg_info NULL");
+    return error;
+  }
+
+  const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
+
+  if (reg == LLDB_INVALID_REGNUM)
+    return Status("no lldb regnum for %s", reg_info && reg_info->name
+                                               ? reg_info->name
+                                               : "<unknown register>");
+
+  RegSetKind set = GPRegSet;
+  error = ReadRegisterSet(set);
+  if (error.Fail())
+    return error;
+
+  assert(reg_info->byte_offset + reg_info->byte_size <= m_reg_data.size());
+  reg_value.SetBytes(m_reg_data.data() + reg_info->byte_offset,
+                     reg_info->byte_size, endian::InlHostByteOrder());
+  return error;
+}
+
+Status NativeRegisterContextFreeBSD_mips64::WriteRegister(
+    const RegisterInfo *reg_info, const RegisterValue &reg_value) {
+  Status error;
+
+  if (!reg_info)
+    return Status("reg_info NULL");
+
+  const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
+
+  if (reg == LLDB_INVALID_REGNUM)
+    return Status("no lldb regnum for %s", reg_info && reg_info->name
+                                               ? reg_info->name
+                                               : "<unknown register>");
+
+  RegSetKind set = GPRegSet;
+  error = ReadRegisterSet(set);
+  if (error.Fail())
+    return error;
+
+  assert(reg_info->byte_offset + reg_info->byte_size <= m_reg_data.size());
+  ::memcpy(m_reg_data.data() + reg_info->byte_offset, reg_value.GetBytes(),
+           reg_info->byte_size);
+
+  return WriteRegisterSet(set);
+}
+
+Status NativeRegisterContextFreeBSD_mips64::ReadAllRegisterValues(
+    lldb::DataBufferSP &data_sp) {
+  Status error;
+
+  error = ReadRegisterSet(GPRegSet);
+  if (error.Fail())
+    return error;
+
+  data_sp.reset(new DataBufferHeap(m_reg_data.size(), 0));
+  uint8_t *dst = data_sp->GetBytes();
+  ::memcpy(dst, m_reg_data.data(), m_reg_data.size());
+
+  return error;
+}
+
+Status NativeRegisterContextFreeBSD_mips64::WriteAllRegisterValues(
+    const lldb::DataBufferSP &data_sp) {
+  Status error;
+
+  if (!data_sp) {
+    error.SetErrorStringWithFormat(
+        "NativeRegisterContextFreeBSD_mips64::%s invalid data_sp provided",
+        __FUNCTION__);
+    return error;
+  }
+
+  if (data_sp->GetByteSize() != m_reg_data.size()) {
+    error.SetErrorStringWithFormat(
+        "NativeRegisterContextFreeBSD_mips64::%s data_sp contained mismatched "
+        "data size, expected %" PRIu64 ", actual %" PRIu64,
+        __FUNCTION__, m_reg_data.size(), data_sp->GetByteSize());
+    return error;
+  }
+
+  uint8_t *src = data_sp->GetBytes();
+  if (src == nullptr) {
+    error.SetErrorStringWithFormat("NativeRegisterContextFreeBSD_mips64::%s "
+                                   "DataBuffer::GetBytes() returned a null "
+                                   "pointer",
+                                   __FUNCTION__);
+    return error;
+  }
+  ::memcpy(m_reg_data.data(), src, m_reg_data.size());
+
+  return WriteRegisterSet(GPRegSet);
+}
+
+llvm::Error NativeRegisterContextFreeBSD_mips64::CopyHardwareWatchpointsFrom(
+    NativeRegisterContextFreeBSD &source) {
+  return llvm::Error::success();
+}
+
+#endif // defined (__mips64__)
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_mips64.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_mips64.h
new file mode 100644
index 000000000000..6a3eb86a9231
--- /dev/null
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_mips64.h
@@ -0,0 +1,71 @@
+//===-- NativeRegisterContextFreeBSD_mips64.h -------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__mips64__)
+
+#ifndef lldb_NativeRegisterContextFreeBSD_mips64_h
+#define lldb_NativeRegisterContextFreeBSD_mips64_h
+
+// clang-format off
+#include <sys/types.h>
+#include <machine/reg.h>
+// clang-format on
+
+#include "Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD.h"
+#include "Plugins/Process/Utility/RegisterContextFreeBSD_mips64.h"
+
+#include <array>
+
+namespace lldb_private {
+namespace process_freebsd {
+
+class NativeProcessFreeBSD;
+
+class NativeRegisterContextFreeBSD_mips64
+    : public NativeRegisterContextFreeBSD {
+public:
+  NativeRegisterContextFreeBSD_mips64(const ArchSpec &target_arch,
+                                      NativeThreadProtocol &native_thread);
+
+  uint32_t GetRegisterSetCount() const override;
+
+  uint32_t GetUserRegisterCount() const override;
+
+  const RegisterSet *GetRegisterSet(uint32_t set_index) const override;
+
+  Status ReadRegister(const RegisterInfo *reg_info,
+                      RegisterValue &reg_value) override;
+
+  Status WriteRegister(const RegisterInfo *reg_info,
+                       const RegisterValue &reg_value) override;
+
+  Status ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
+
+  Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
+
+  llvm::Error
+  CopyHardwareWatchpointsFrom(NativeRegisterContextFreeBSD &source) override;
+
+private:
+  enum RegSetKind {
+    GPRegSet,
+  };
+  std::array<uint8_t, sizeof(reg)> m_reg_data;
+
+  Status ReadRegisterSet(RegSetKind set);
+  Status WriteRegisterSet(RegSetKind set);
+
+  RegisterContextFreeBSD_mips64 &GetRegisterInfo() const;
+};
+
+} // namespace process_freebsd
+} // namespace lldb_private
+
+#endif // #ifndef lldb_NativeRegisterContextFreeBSD_mips64_h
+
+#endif // defined (__mips64__)
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_powerpc.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_powerpc.cpp
new file mode 100644
index 000000000000..5b5d44a308b1
--- /dev/null
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_powerpc.cpp
@@ -0,0 +1,289 @@
+//===-- NativeRegisterContextFreeBSD_powerpc.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
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__powerpc__)
+
+#include "NativeRegisterContextFreeBSD_powerpc.h"
+
+#include "lldb/Host/HostInfo.h"
+#include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Status.h"
+
+#include "Plugins/Process/FreeBSD/NativeProcessFreeBSD.h"
+// for register enum definitions
+#include "Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h"
+
+// clang-format off
+#include <sys/param.h>
+#include <sys/ptrace.h>
+#include <sys/types.h>
+// clang-format on
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::process_freebsd;
+
+static const uint32_t g_gpr_regnums[] = {
+    gpr_r0_powerpc,  gpr_r1_powerpc,  gpr_r2_powerpc,  gpr_r3_powerpc,
+    gpr_r4_powerpc,  gpr_r5_powerpc,  gpr_r6_powerpc,  gpr_r7_powerpc,
+    gpr_r8_powerpc,  gpr_r9_powerpc,  gpr_r10_powerpc, gpr_r11_powerpc,
+    gpr_r12_powerpc, gpr_r13_powerpc, gpr_r14_powerpc, gpr_r15_powerpc,
+    gpr_r16_powerpc, gpr_r17_powerpc, gpr_r18_powerpc, gpr_r19_powerpc,
+    gpr_r20_powerpc, gpr_r21_powerpc, gpr_r22_powerpc, gpr_r23_powerpc,
+    gpr_r24_powerpc, gpr_r25_powerpc, gpr_r26_powerpc, gpr_r27_powerpc,
+    gpr_r28_powerpc, gpr_r29_powerpc, gpr_r30_powerpc, gpr_r31_powerpc,
+    gpr_lr_powerpc,  gpr_cr_powerpc,  gpr_xer_powerpc, gpr_ctr_powerpc,
+    gpr_pc_powerpc,
+};
+
+static const uint32_t g_fpr_regnums[] = {
+    fpr_f0_powerpc,    fpr_f1_powerpc,  fpr_f2_powerpc,  fpr_f3_powerpc,
+    fpr_f4_powerpc,    fpr_f5_powerpc,  fpr_f6_powerpc,  fpr_f7_powerpc,
+    fpr_f8_powerpc,    fpr_f9_powerpc,  fpr_f10_powerpc, fpr_f11_powerpc,
+    fpr_f12_powerpc,   fpr_f13_powerpc, fpr_f14_powerpc, fpr_f15_powerpc,
+    fpr_f16_powerpc,   fpr_f17_powerpc, fpr_f18_powerpc, fpr_f19_powerpc,
+    fpr_f20_powerpc,   fpr_f21_powerpc, fpr_f22_powerpc, fpr_f23_powerpc,
+    fpr_f24_powerpc,   fpr_f25_powerpc, fpr_f26_powerpc, fpr_f27_powerpc,
+    fpr_f28_powerpc,   fpr_f29_powerpc, fpr_f30_powerpc, fpr_f31_powerpc,
+    fpr_fpscr_powerpc,
+};
+
+// Number of register sets provided by this context.
+enum { k_num_register_sets = 2 };
+
+static const RegisterSet g_reg_sets_powerpc[k_num_register_sets] = {
+    {"General Purpose Registers", "gpr", k_num_gpr_registers_powerpc,
+     g_gpr_regnums},
+    {"Floating Point Registers", "fpr", k_num_fpr_registers_powerpc,
+     g_fpr_regnums},
+};
+
+NativeRegisterContextFreeBSD *
+NativeRegisterContextFreeBSD::CreateHostNativeRegisterContextFreeBSD(
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
+  return new NativeRegisterContextFreeBSD_powerpc(target_arch, native_thread);
+}
+
+static RegisterInfoInterface *
+CreateRegisterInfoInterface(const ArchSpec &target_arch) {
+  if (HostInfo::GetArchitecture().GetAddressByteSize() == 4) {
+    return new RegisterContextFreeBSD_powerpc32(target_arch);
+  } else {
+    assert((HostInfo::GetArchitecture().GetAddressByteSize() == 8) &&
+           "Register setting path assumes this is a 64-bit host");
+    return new RegisterContextFreeBSD_powerpc64(target_arch);
+  }
+}
+
+NativeRegisterContextFreeBSD_powerpc::NativeRegisterContextFreeBSD_powerpc(
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
+    : NativeRegisterContextRegisterInfo(
+          native_thread, CreateRegisterInfoInterface(target_arch)) {}
+
+RegisterContextFreeBSD_powerpc &
+NativeRegisterContextFreeBSD_powerpc::GetRegisterInfo() const {
+  return static_cast<RegisterContextFreeBSD_powerpc &>(
+      *m_register_info_interface_up);
+}
+
+uint32_t NativeRegisterContextFreeBSD_powerpc::GetRegisterSetCount() const {
+  return k_num_register_sets;
+}
+
+const RegisterSet *
+NativeRegisterContextFreeBSD_powerpc::GetRegisterSet(uint32_t set_index) const {
+  switch (GetRegisterInfoInterface().GetTargetArchitecture().GetMachine()) {
+  case llvm::Triple::ppc:
+    return &g_reg_sets_powerpc[set_index];
+  default:
+    llvm_unreachable("Unhandled target architecture.");
+  }
+}
+
+llvm::Optional<NativeRegisterContextFreeBSD_powerpc::RegSetKind>
+NativeRegisterContextFreeBSD_powerpc::GetSetForNativeRegNum(
+    uint32_t reg_num) const {
+  switch (GetRegisterInfoInterface().GetTargetArchitecture().GetMachine()) {
+  case llvm::Triple::ppc:
+    if (reg_num >= k_first_gpr_powerpc && reg_num <= k_last_gpr_powerpc)
+      return GPRegSet;
+    if (reg_num >= k_first_fpr && reg_num <= k_last_fpr)
+      return FPRegSet;
+    break;
+  default:
+    llvm_unreachable("Unhandled target architecture.");
+  }
+
+  llvm_unreachable("Register does not belong to any register set");
+}
+
+uint32_t NativeRegisterContextFreeBSD_powerpc::GetUserRegisterCount() const {
+  uint32_t count = 0;
+  for (uint32_t set_index = 0; set_index < GetRegisterSetCount(); ++set_index)
+    count += GetRegisterSet(set_index)->num_registers;
+  return count;
+}
+
+Status NativeRegisterContextFreeBSD_powerpc::ReadRegisterSet(RegSetKind set) {
+  switch (set) {
+  case GPRegSet:
+    return NativeProcessFreeBSD::PtraceWrapper(PT_GETREGS, m_thread.GetID(),
+                                               m_reg_data.data());
+  case FPRegSet:
+    return NativeProcessFreeBSD::PtraceWrapper(PT_GETFPREGS, m_thread.GetID(),
+                                               m_reg_data.data() + sizeof(reg));
+  }
+  llvm_unreachable("NativeRegisterContextFreeBSD_powerpc::ReadRegisterSet");
+}
+
+Status NativeRegisterContextFreeBSD_powerpc::WriteRegisterSet(RegSetKind set) {
+  switch (set) {
+  case GPRegSet:
+    return NativeProcessFreeBSD::PtraceWrapper(PT_SETREGS, m_thread.GetID(),
+                                               m_reg_data.data());
+  case FPRegSet:
+    return NativeProcessFreeBSD::PtraceWrapper(PT_SETFPREGS, m_thread.GetID(),
+                                               m_reg_data.data() + sizeof(reg));
+  }
+  llvm_unreachable("NativeRegisterContextFreeBSD_powerpc::WriteRegisterSet");
+}
+
+Status
+NativeRegisterContextFreeBSD_powerpc::ReadRegister(const RegisterInfo *reg_info,
+                                                   RegisterValue &reg_value) {
+  Status error;
+
+  if (!reg_info) {
+    error.SetErrorString("reg_info NULL");
+    return error;
+  }
+
+  const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
+
+  if (reg == LLDB_INVALID_REGNUM)
+    return Status("no lldb regnum for %s", reg_info && reg_info->name
+                                               ? reg_info->name
+                                               : "<unknown register>");
+
+  llvm::Optional<RegSetKind> opt_set = GetSetForNativeRegNum(reg);
+  if (!opt_set) {
+    // This is likely an internal register for lldb use only and should not be
+    // directly queried.
+    error.SetErrorStringWithFormat("register \"%s\" is in unrecognized set",
+                                   reg_info->name);
+    return error;
+  }
+
+  RegSetKind set = opt_set.getValue();
+  error = ReadRegisterSet(set);
+  if (error.Fail())
+    return error;
+
+  assert(reg_info->byte_offset + reg_info->byte_size <= m_reg_data.size());
+  reg_value.SetBytes(m_reg_data.data() + reg_info->byte_offset,
+                     reg_info->byte_size, endian::InlHostByteOrder());
+  return error;
+}
+
+Status NativeRegisterContextFreeBSD_powerpc::WriteRegister(
+    const RegisterInfo *reg_info, const RegisterValue &reg_value) {
+  Status error;
+
+  if (!reg_info)
+    return Status("reg_info NULL");
+
+  const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
+
+  if (reg == LLDB_INVALID_REGNUM)
+    return Status("no lldb regnum for %s", reg_info && reg_info->name
+                                               ? reg_info->name
+                                               : "<unknown register>");
+
+  llvm::Optional<RegSetKind> opt_set = GetSetForNativeRegNum(reg);
+  if (!opt_set) {
+    // This is likely an internal register for lldb use only and should not be
+    // directly queried.
+    error.SetErrorStringWithFormat("register \"%s\" is in unrecognized set",
+                                   reg_info->name);
+    return error;
+  }
+
+  RegSetKind set = opt_set.getValue();
+  error = ReadRegisterSet(set);
+  if (error.Fail())
+    return error;
+
+  assert(reg_info->byte_offset + reg_info->byte_size <= m_reg_data.size());
+  ::memcpy(m_reg_data.data() + reg_info->byte_offset, reg_value.GetBytes(),
+           reg_info->byte_size);
+
+  return WriteRegisterSet(set);
+}
+
+Status NativeRegisterContextFreeBSD_powerpc::ReadAllRegisterValues(
+    lldb::DataBufferSP &data_sp) {
+  Status error;
+
+  error = ReadRegisterSet(GPRegSet);
+  if (error.Fail())
+    return error;
+
+  error = ReadRegisterSet(FPRegSet);
+  if (error.Fail())
+    return error;
+
+  data_sp.reset(new DataBufferHeap(m_reg_data.size(), 0));
+  uint8_t *dst = data_sp->GetBytes();
+  ::memcpy(dst, m_reg_data.data(), m_reg_data.size());
+
+  return error;
+}
+
+Status NativeRegisterContextFreeBSD_powerpc::WriteAllRegisterValues(
+    const lldb::DataBufferSP &data_sp) {
+  Status error;
+
+  if (!data_sp) {
+    error.SetErrorStringWithFormat(
+        "NativeRegisterContextFreeBSD_powerpc::%s invalid data_sp provided",
+        __FUNCTION__);
+    return error;
+  }
+
+  if (data_sp->GetByteSize() != m_reg_data.size()) {
+    error.SetErrorStringWithFormat(
+        "NativeRegisterContextFreeBSD_powerpc::%s data_sp contained mismatched "
+        "data size, expected %zu, actual %" PRIu64,
+        __FUNCTION__, m_reg_data.size(), data_sp->GetByteSize());
+    return error;
+  }
+
+  uint8_t *src = data_sp->GetBytes();
+  if (src == nullptr) {
+    error.SetErrorStringWithFormat("NativeRegisterContextFreeBSD_powerpc::%s "
+                                   "DataBuffer::GetBytes() returned a null "
+                                   "pointer",
+                                   __FUNCTION__);
+    return error;
+  }
+  ::memcpy(m_reg_data.data(), src, m_reg_data.size());
+
+  error = WriteRegisterSet(GPRegSet);
+  if (error.Fail())
+    return error;
+
+  return WriteRegisterSet(FPRegSet);
+}
+
+llvm::Error NativeRegisterContextFreeBSD_powerpc::CopyHardwareWatchpointsFrom(
+    NativeRegisterContextFreeBSD &source) {
+  return llvm::Error::success();
+}
+
+#endif // defined (__powerpc__)
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_powerpc.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_powerpc.h
new file mode 100644
index 000000000000..884c25988ce1
--- /dev/null
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_powerpc.h
@@ -0,0 +1,74 @@
+//===-- NativeRegisterContextFreeBSD_powerpc.h ------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__powerpc__)
+
+#ifndef lldb_NativeRegisterContextFreeBSD_powerpc_h
+#define lldb_NativeRegisterContextFreeBSD_powerpc_h
+
+// clang-format off
+#include <sys/types.h>
+#include <machine/reg.h>
+// clang-format on
+
+#include "Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD.h"
+#include "Plugins/Process/Utility/RegisterContextFreeBSD_powerpc.h"
+
+#include <array>
+
+namespace lldb_private {
+namespace process_freebsd {
+
+class NativeProcessFreeBSD;
+
+class NativeRegisterContextFreeBSD_powerpc
+    : public NativeRegisterContextFreeBSD {
+public:
+  NativeRegisterContextFreeBSD_powerpc(const ArchSpec &target_arch,
+                                       NativeThreadProtocol &native_thread);
+
+  uint32_t GetRegisterSetCount() const override;
+
+  uint32_t GetUserRegisterCount() const override;
+
+  const RegisterSet *GetRegisterSet(uint32_t set_index) const override;
+
+  Status ReadRegister(const RegisterInfo *reg_info,
+                      RegisterValue &reg_value) override;
+
+  Status WriteRegister(const RegisterInfo *reg_info,
+                       const RegisterValue &reg_value) override;
+
+  Status ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
+
+  Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
+
+  llvm::Error
+  CopyHardwareWatchpointsFrom(NativeRegisterContextFreeBSD &source) override;
+
+private:
+  enum RegSetKind {
+    GPRegSet,
+    FPRegSet,
+  };
+  std::array<uint8_t, sizeof(reg) + sizeof(fpreg)> m_reg_data;
+
+  llvm::Optional<RegSetKind> GetSetForNativeRegNum(uint32_t reg_num) const;
+
+  Status ReadRegisterSet(RegSetKind set);
+  Status WriteRegisterSet(RegSetKind set);
+
+  RegisterContextFreeBSD_powerpc &GetRegisterInfo() const;
+};
+
+} // namespace process_freebsd
+} // namespace lldb_private
+
+#endif // #ifndef lldb_NativeRegisterContextFreeBSD_powerpc_h
+
+#endif // defined (__powerpc__)
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_x86_64.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_x86_64.cpp
index d5052e7d1b3a..d5052e7d1b3a 100644
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_x86_64.cpp
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_x86_64.cpp
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_x86_64.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_x86_64.h
index 673cffd6e849..efd0f91f77b9 100644
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_x86_64.h
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_x86_64.h
@@ -20,9 +20,9 @@
 
 #include <array>
 
-#include "Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD.h"
+#include "Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD.h"
 #include "Plugins/Process/Utility/RegisterContext_x86.h"
-#include "Plugins/Process/Utility/NativeRegisterContextWatchpoint_x86.h"
+#include "Plugins/Process/Utility/NativeRegisterContextDBReg_x86.h"
 #include "Plugins/Process/Utility/lldb-x86-register-enums.h"
 
 #define LLDB_INVALID_XSAVE_OFFSET UINT32_MAX
@@ -34,7 +34,7 @@ class NativeProcessFreeBSD;
 
 class NativeRegisterContextFreeBSD_x86_64
     : public NativeRegisterContextFreeBSD,
-      public NativeRegisterContextWatchpoint_x86 {
+      public NativeRegisterContextDBReg_x86 {
 public:
   NativeRegisterContextFreeBSD_x86_64(const ArchSpec &target_arch,
                                       NativeThreadProtocol &native_thread);
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSDRemote/NativeThreadFreeBSD.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeThreadFreeBSD.cpp
index 43494871be07..63be12fc7b2b 100644
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSDRemote/NativeThreadFreeBSD.cpp
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeThreadFreeBSD.cpp
@@ -46,6 +46,11 @@ Status NativeThreadFreeBSD::Resume() {
   if (!ret.Success())
     return ret;
   ret = NativeProcessFreeBSD::PtraceWrapper(PT_CLEARSTEP, GetID());
+  // we can get EINVAL if the architecture in question does not support
+  // hardware single-stepping -- that's fine, we have nothing to clear
+  // then
+  if (ret.GetError() == EINVAL)
+    ret.Clear();
   if (ret.Success())
     SetRunning();
   return ret;
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSDRemote/NativeThreadFreeBSD.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeThreadFreeBSD.h
index 4e997b3fb4bb..249d2486b4f7 100644
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSDRemote/NativeThreadFreeBSD.h
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/NativeThreadFreeBSD.h
@@ -11,7 +11,7 @@
 
 #include "lldb/Host/common/NativeThreadProtocol.h"
 
-#include "Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD.h"
+#include "Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD.h"
 
 #include <csignal>
 #include <map>
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/POSIXStopInfo.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/POSIXStopInfo.cpp
deleted file mode 100644
index 4e6f3afda0ab..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/POSIXStopInfo.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-//===-- POSIXStopInfo.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 "POSIXStopInfo.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-//===----------------------------------------------------------------------===//
-// POSIXLimboStopInfo
-
-POSIXLimboStopInfo::~POSIXLimboStopInfo() {}
-
-lldb::StopReason POSIXLimboStopInfo::GetStopReason() const {
-  return lldb::eStopReasonThreadExiting;
-}
-
-const char *POSIXLimboStopInfo::GetDescription() { return "thread exiting"; }
-
-bool POSIXLimboStopInfo::ShouldStop(Event *event_ptr) { return false; }
-
-bool POSIXLimboStopInfo::ShouldNotify(Event *event_ptr) { return false; }
-
-//===----------------------------------------------------------------------===//
-// POSIXNewThreadStopInfo
-
-POSIXNewThreadStopInfo::~POSIXNewThreadStopInfo() {}
-
-lldb::StopReason POSIXNewThreadStopInfo::GetStopReason() const {
-  return lldb::eStopReasonNone;
-}
-
-const char *POSIXNewThreadStopInfo::GetDescription() {
-  return "thread spawned";
-}
-
-bool POSIXNewThreadStopInfo::ShouldStop(Event *event_ptr) { return false; }
-
-bool POSIXNewThreadStopInfo::ShouldNotify(Event *event_ptr) { return false; }
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/POSIXStopInfo.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/POSIXStopInfo.h
deleted file mode 100644
index 5a022c485b68..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/POSIXStopInfo.h
+++ /dev/null
@@ -1,66 +0,0 @@
-//===-- POSIXStopInfo.h -----------------------------------------*- C++ -*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_POSIXStopInfo_H_
-#define liblldb_POSIXStopInfo_H_
-
-#include "FreeBSDThread.h"
-#include "Plugins/Process/POSIX/CrashReason.h"
-#include "lldb/Target/StopInfo.h"
-#include <string>
-
-//===----------------------------------------------------------------------===//
-/// \class POSIXStopInfo
-/// Simple base class for all POSIX-specific StopInfo objects.
-///
-class POSIXStopInfo : public lldb_private::StopInfo {
-public:
-  POSIXStopInfo(lldb_private::Thread &thread, uint32_t status)
-      : StopInfo(thread, status) {}
-};
-
-//===----------------------------------------------------------------------===//
-/// \class POSIXLimboStopInfo
-/// Represents the stop state of a process ready to exit.
-///
-class POSIXLimboStopInfo : public POSIXStopInfo {
-public:
-  POSIXLimboStopInfo(FreeBSDThread &thread) : POSIXStopInfo(thread, 0) {}
-
-  ~POSIXLimboStopInfo();
-
-  lldb::StopReason GetStopReason() const override;
-
-  const char *GetDescription() override;
-
-  bool ShouldStop(lldb_private::Event *event_ptr) override;
-
-  bool ShouldNotify(lldb_private::Event *event_ptr) override;
-};
-
-//===----------------------------------------------------------------------===//
-/// \class POSIXNewThreadStopInfo
-/// Represents the stop state of process when a new thread is spawned.
-///
-
-class POSIXNewThreadStopInfo : public POSIXStopInfo {
-public:
-  POSIXNewThreadStopInfo(FreeBSDThread &thread) : POSIXStopInfo(thread, 0) {}
-
-  ~POSIXNewThreadStopInfo();
-
-  lldb::StopReason GetStopReason() const override;
-
-  const char *GetDescription() override;
-
-  bool ShouldStop(lldb_private::Event *event_ptr) override;
-
-  bool ShouldNotify(lldb_private::Event *event_ptr) override;
-};
-
-#endif
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp
deleted file mode 100644
index a1fe45b84ca2..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp
+++ /dev/null
@@ -1,1080 +0,0 @@
-//===-- ProcessFreeBSD.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 <machine/elf.h>
-
-#include <mutex>
-#include <unordered_map>
-
-#include "lldb/Core/PluginManager.h"
-#include "lldb/Host/FileSystem.h"
-#include "lldb/Host/Host.h"
-#include "lldb/Symbol/ObjectFile.h"
-#include "lldb/Target/DynamicLoader.h"
-#include "lldb/Target/Target.h"
-#include "lldb/Utility/RegisterValue.h"
-#include "lldb/Utility/State.h"
-
-#include "FreeBSDThread.h"
-#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
-#include "Plugins/Process/Utility/FreeBSDSignals.h"
-#include "Plugins/Process/Utility/InferiorCallPOSIX.h"
-#include "ProcessFreeBSD.h"
-#include "ProcessMonitor.h"
-
-#include "lldb/Breakpoint/BreakpointLocation.h"
-#include "lldb/Breakpoint/Watchpoint.h"
-#include "lldb/Core/Module.h"
-#include "lldb/Core/ModuleSpec.h"
-#include "lldb/Core/PluginManager.h"
-#include "lldb/Host/Host.h"
-#include "lldb/Symbol/ObjectFile.h"
-#include "lldb/Target/DynamicLoader.h"
-#include "lldb/Target/Platform.h"
-#include "lldb/Target/Target.h"
-#include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/FileSpec.h"
-#include "lldb/Utility/State.h"
-
-#include "lldb/Host/posix/Fcntl.h"
-
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Threading.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-LLDB_PLUGIN_DEFINE(ProcessFreeBSD)
-
-namespace {
-UnixSignalsSP &GetFreeBSDSignals() {
-  static UnixSignalsSP s_freebsd_signals_sp(new FreeBSDSignals());
-  return s_freebsd_signals_sp;
-}
-}
-
-// Static functions.
-
-lldb::ProcessSP
-ProcessFreeBSD::CreateInstance(lldb::TargetSP target_sp,
-                               lldb::ListenerSP listener_sp,
-                               const FileSpec *crash_file_path,
-                               bool can_connect) {
-  lldb::ProcessSP process_sp;
-  if (crash_file_path == NULL && !can_connect)
-    process_sp.reset(
-        new ProcessFreeBSD(target_sp, listener_sp, GetFreeBSDSignals()));
-  return process_sp;
-}
-
-void ProcessFreeBSD::Initialize() {
-  static llvm::once_flag g_once_flag;
-
-  llvm::call_once(g_once_flag, []() {
-    PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                  GetPluginDescriptionStatic(), CreateInstance);
-  });
-}
-
-lldb_private::ConstString ProcessFreeBSD::GetPluginNameStatic() {
-  static ConstString g_name("freebsd");
-  return g_name;
-}
-
-const char *ProcessFreeBSD::GetPluginDescriptionStatic() {
-  return "Process plugin for FreeBSD";
-}
-
-// ProcessInterface protocol.
-
-lldb_private::ConstString ProcessFreeBSD::GetPluginName() {
-  return GetPluginNameStatic();
-}
-
-uint32_t ProcessFreeBSD::GetPluginVersion() { return 1; }
-
-void ProcessFreeBSD::Terminate() {}
-
-Status ProcessFreeBSD::DoDetach(bool keep_stopped) {
-  Status error;
-  if (keep_stopped) {
-    error.SetErrorString("Detaching with keep_stopped true is not currently "
-                         "supported on FreeBSD.");
-    return error;
-  }
-
-  error = m_monitor->Detach(GetID());
-
-  if (error.Success())
-    SetPrivateState(eStateDetached);
-
-  return error;
-}
-
-Status ProcessFreeBSD::DoResume() {
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
-
-  SetPrivateState(eStateRunning);
-
-  std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
-  bool do_step = false;
-  bool software_single_step = !SupportHardwareSingleStepping();
-
-  for (tid_collection::const_iterator t_pos = m_run_tids.begin(),
-                                      t_end = m_run_tids.end();
-       t_pos != t_end; ++t_pos) {
-    m_monitor->ThreadSuspend(*t_pos, false);
-  }
-  for (tid_collection::const_iterator t_pos = m_step_tids.begin(),
-                                      t_end = m_step_tids.end();
-       t_pos != t_end; ++t_pos) {
-    m_monitor->ThreadSuspend(*t_pos, false);
-    do_step = true;
-    if (software_single_step) {
-      Status error = SetupSoftwareSingleStepping(*t_pos);
-      if (error.Fail())
-        return error;
-    }
-  }
-  for (tid_collection::const_iterator t_pos = m_suspend_tids.begin(),
-                                      t_end = m_suspend_tids.end();
-       t_pos != t_end; ++t_pos) {
-    m_monitor->ThreadSuspend(*t_pos, true);
-    // XXX Cannot PT_CONTINUE properly with suspended threads.
-    do_step = true;
-  }
-
-  LLDB_LOGF(log, "process %" PRIu64 " resuming (%s)", GetID(),
-            do_step ? "step" : "continue");
-  if (do_step && !software_single_step)
-    m_monitor->SingleStep(GetID(), m_resume_signo);
-  else
-    m_monitor->Resume(GetID(), m_resume_signo);
-
-  return Status();
-}
-
-bool ProcessFreeBSD::DoUpdateThreadList(ThreadList &old_thread_list,
-                                        ThreadList &new_thread_list) {
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
-  LLDB_LOGF(log, "ProcessFreeBSD::%s (pid = %" PRIu64 ")", __FUNCTION__,
-            GetID());
-
-  std::vector<lldb::pid_t> tds;
-  if (!GetMonitor().GetCurrentThreadIDs(tds)) {
-    return false;
-  }
-
-  ThreadList old_thread_list_copy(old_thread_list);
-  for (size_t i = 0; i < tds.size(); ++i) {
-    tid_t tid = tds[i];
-    ThreadSP thread_sp(old_thread_list_copy.RemoveThreadByID(tid, false));
-    if (!thread_sp) {
-      thread_sp.reset(new FreeBSDThread(*this, tid));
-      LLDB_LOGF(log, "ProcessFreeBSD::%s new tid = %" PRIu64, __FUNCTION__,
-                tid);
-    } else {
-      LLDB_LOGF(log, "ProcessFreeBSD::%s existing tid = %" PRIu64, __FUNCTION__,
-                tid);
-    }
-    new_thread_list.AddThread(thread_sp);
-  }
-  for (size_t i = 0; i < old_thread_list_copy.GetSize(false); ++i) {
-    ThreadSP old_thread_sp(old_thread_list_copy.GetThreadAtIndex(i, false));
-    if (old_thread_sp) {
-      LLDB_LOGF(log, "ProcessFreeBSD::%s remove tid", __FUNCTION__);
-    }
-  }
-
-  return true;
-}
-
-Status ProcessFreeBSD::WillResume() {
-  m_resume_signo = 0;
-  m_suspend_tids.clear();
-  m_run_tids.clear();
-  m_step_tids.clear();
-  return Process::WillResume();
-}
-
-void ProcessFreeBSD::SendMessage(const ProcessMessage &message) {
-  std::lock_guard<std::recursive_mutex> guard(m_message_mutex);
-
-  switch (message.GetKind()) {
-  case ProcessMessage::eInvalidMessage:
-    return;
-
-  case ProcessMessage::eAttachMessage:
-    SetPrivateState(eStateStopped);
-    return;
-
-  case ProcessMessage::eLimboMessage:
-  case ProcessMessage::eExitMessage:
-    SetExitStatus(message.GetExitStatus(), NULL);
-    break;
-
-  case ProcessMessage::eSignalMessage:
-  case ProcessMessage::eSignalDeliveredMessage:
-  case ProcessMessage::eBreakpointMessage:
-  case ProcessMessage::eTraceMessage:
-  case ProcessMessage::eWatchpointMessage:
-  case ProcessMessage::eCrashMessage:
-    SetPrivateState(eStateStopped);
-    break;
-
-  case ProcessMessage::eNewThreadMessage:
-    llvm_unreachable("eNewThreadMessage unexpected on FreeBSD");
-    break;
-
-  case ProcessMessage::eExecMessage:
-    SetPrivateState(eStateStopped);
-    break;
-  }
-
-  m_message_queue.push(message);
-}
-
-// Constructors and destructors.
-
-ProcessFreeBSD::ProcessFreeBSD(lldb::TargetSP target_sp,
-                               lldb::ListenerSP listener_sp,
-                               UnixSignalsSP &unix_signals_sp)
-    : Process(target_sp, listener_sp, unix_signals_sp),
-      m_byte_order(endian::InlHostByteOrder()), m_monitor(NULL), m_module(NULL),
-      m_message_mutex(), m_exit_now(false), m_seen_initial_stop(),
-      m_resume_signo(0) {
-  // FIXME: Putting this code in the ctor and saving the byte order in a
-  // member variable is a hack to avoid const qual issues in GetByteOrder.
-  lldb::ModuleSP module = GetTarget().GetExecutableModule();
-  if (module && module->GetObjectFile())
-    m_byte_order = module->GetObjectFile()->GetByteOrder();
-}
-
-ProcessFreeBSD::~ProcessFreeBSD() { delete m_monitor; }
-
-// Process protocol.
-void ProcessFreeBSD::Finalize() {
-  Process::Finalize();
-
-  if (m_monitor)
-    m_monitor->StopMonitor();
-}
-
-bool ProcessFreeBSD::CanDebug(lldb::TargetSP target_sp,
-                              bool plugin_specified_by_name) {
-  // For now we are just making sure the file exists for a given module
-  ModuleSP exe_module_sp(target_sp->GetExecutableModule());
-  if (exe_module_sp.get())
-    return FileSystem::Instance().Exists(exe_module_sp->GetFileSpec());
-  // If there is no executable module, we return true since we might be
-  // preparing to attach.
-  return true;
-}
-
-Status
-ProcessFreeBSD::DoAttachToProcessWithID(lldb::pid_t pid,
-                                        const ProcessAttachInfo &attach_info) {
-  Status error;
-  assert(m_monitor == NULL);
-
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
-  LLDB_LOGV(log, "pid = {0}", GetID());
-
-  m_monitor = new ProcessMonitor(this, pid, error);
-
-  if (!error.Success())
-    return error;
-
-  PlatformSP platform_sp(GetTarget().GetPlatform());
-  assert(platform_sp.get());
-  if (!platform_sp)
-    return error; // FIXME: Detatch?
-
-  // Find out what we can about this process
-  ProcessInstanceInfo process_info;
-  platform_sp->GetProcessInfo(pid, process_info);
-
-  // Resolve the executable module
-  ModuleSP exe_module_sp;
-  FileSpecList executable_search_paths(
-      Target::GetDefaultExecutableSearchPaths());
-  ModuleSpec exe_module_spec(process_info.GetExecutableFile(),
-                             GetTarget().GetArchitecture());
-  error = platform_sp->ResolveExecutable(
-      exe_module_spec, exe_module_sp,
-      executable_search_paths.GetSize() ? &executable_search_paths : NULL);
-  if (!error.Success())
-    return error;
-
-  // Fix the target architecture if necessary
-  const ArchSpec &module_arch = exe_module_sp->GetArchitecture();
-  if (module_arch.IsValid() &&
-      !GetTarget().GetArchitecture().IsExactMatch(module_arch))
-    GetTarget().SetArchitecture(module_arch);
-
-  // Initialize the target module list
-  GetTarget().SetExecutableModule(exe_module_sp, eLoadDependentsYes);
-
-  SetSTDIOFileDescriptor(m_monitor->GetTerminalFD());
-
-  SetID(pid);
-
-  return error;
-}
-
-Status ProcessFreeBSD::WillLaunch(Module *module) {
-  Status error;
-  return error;
-}
-
-FileSpec
-ProcessFreeBSD::GetFileSpec(const lldb_private::FileAction *file_action,
-                            const FileSpec &default_file_spec,
-                            const FileSpec &dbg_pts_file_spec) {
-  FileSpec file_spec{};
-
-  if (file_action && file_action->GetAction() == FileAction::eFileActionOpen) {
-    file_spec = file_action->GetFileSpec();
-    // By default the stdio paths passed in will be pseudo-terminal (/dev/pts).
-    // If so, convert to using a different default path instead to redirect I/O
-    // to the debugger console. This should also handle user overrides to
-    // /dev/null or a different file.
-    if (!file_spec || file_spec == dbg_pts_file_spec)
-      file_spec = default_file_spec;
-  }
-  return file_spec;
-}
-
-Status ProcessFreeBSD::DoLaunch(Module *module,
-                                ProcessLaunchInfo &launch_info) {
-  Status error;
-  assert(m_monitor == NULL);
-
-  FileSpec working_dir = launch_info.GetWorkingDirectory();
-  if (working_dir) {
-    FileSystem::Instance().Resolve(working_dir);
-    if (!FileSystem::Instance().IsDirectory(working_dir.GetPath())) {
-      error.SetErrorStringWithFormat("No such file or directory: %s",
-                                   working_dir.GetCString());
-      return error;
-    }
-  }
-
-  SetPrivateState(eStateLaunching);
-
-  const lldb_private::FileAction *file_action;
-
-  // Default of empty will mean to use existing open file descriptors
-  FileSpec stdin_file_spec{};
-  FileSpec stdout_file_spec{};
-  FileSpec stderr_file_spec{};
-
-  const FileSpec dbg_pts_file_spec{launch_info.GetPTY().GetSecondaryName()};
-
-  file_action = launch_info.GetFileActionForFD(STDIN_FILENO);
-  stdin_file_spec =
-      GetFileSpec(file_action, stdin_file_spec, dbg_pts_file_spec);
-
-  file_action = launch_info.GetFileActionForFD(STDOUT_FILENO);
-  stdout_file_spec =
-      GetFileSpec(file_action, stdout_file_spec, dbg_pts_file_spec);
-
-  file_action = launch_info.GetFileActionForFD(STDERR_FILENO);
-  stderr_file_spec =
-      GetFileSpec(file_action, stderr_file_spec, dbg_pts_file_spec);
-
-  m_monitor = new ProcessMonitor(
-      this, module, launch_info.GetArguments().GetConstArgumentVector(),
-      launch_info.GetEnvironment(), stdin_file_spec, stdout_file_spec,
-      stderr_file_spec, working_dir, launch_info, error);
-
-  m_module = module;
-
-  if (!error.Success())
-    return error;
-
-  int terminal = m_monitor->GetTerminalFD();
-  if (terminal >= 0) {
-// The reader thread will close the file descriptor when done, so we pass it a
-// copy.
-#ifdef F_DUPFD_CLOEXEC
-    int stdio = fcntl(terminal, F_DUPFD_CLOEXEC, 0);
-    if (stdio == -1) {
-      error.SetErrorToErrno();
-      return error;
-    }
-#else
-    // Special case when F_DUPFD_CLOEXEC does not exist (Debian kFreeBSD)
-    int stdio = fcntl(terminal, F_DUPFD, 0);
-    if (stdio == -1) {
-      error.SetErrorToErrno();
-      return error;
-    }
-    stdio = fcntl(terminal, F_SETFD, FD_CLOEXEC);
-    if (stdio == -1) {
-      error.SetErrorToErrno();
-      return error;
-    }
-#endif
-    SetSTDIOFileDescriptor(stdio);
-  }
-
-  SetID(m_monitor->GetPID());
-  return error;
-}
-
-void ProcessFreeBSD::DidLaunch() {}
-
-addr_t ProcessFreeBSD::GetImageInfoAddress() {
-  Target *target = &GetTarget();
-  ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile();
-  Address addr = obj_file->GetImageInfoAddress(target);
-
-  if (addr.IsValid())
-    return addr.GetLoadAddress(target);
-  return LLDB_INVALID_ADDRESS;
-}
-
-Status ProcessFreeBSD::DoHalt(bool &caused_stop) {
-  Status error;
-
-  if (IsStopped()) {
-    caused_stop = false;
-  } else if (kill(GetID(), SIGSTOP)) {
-    caused_stop = false;
-    error.SetErrorToErrno();
-  } else {
-    caused_stop = true;
-  }
-  return error;
-}
-
-Status ProcessFreeBSD::DoSignal(int signal) {
-  Status error;
-
-  if (kill(GetID(), signal))
-    error.SetErrorToErrno();
-
-  return error;
-}
-
-Status ProcessFreeBSD::DoDestroy() {
-  Status error;
-
-  if (!HasExited()) {
-    assert(m_monitor);
-    m_exit_now = true;
-    if (GetID() == LLDB_INVALID_PROCESS_ID) {
-      error.SetErrorString("invalid process id");
-      return error;
-    }
-    if (!m_monitor->Kill()) {
-      error.SetErrorToErrno();
-      return error;
-    }
-
-    SetPrivateState(eStateExited);
-  }
-
-  return error;
-}
-
-void ProcessFreeBSD::DoDidExec() {
-  Target *target = &GetTarget();
-  if (target) {
-    PlatformSP platform_sp(target->GetPlatform());
-    assert(platform_sp.get());
-    if (platform_sp) {
-      ProcessInstanceInfo process_info;
-      platform_sp->GetProcessInfo(GetID(), process_info);
-      ModuleSP exe_module_sp;
-      ModuleSpec exe_module_spec(process_info.GetExecutableFile(),
-                                 target->GetArchitecture());
-      FileSpecList executable_search_paths(
-          Target::GetDefaultExecutableSearchPaths());
-      Status error = platform_sp->ResolveExecutable(
-          exe_module_spec, exe_module_sp,
-          executable_search_paths.GetSize() ? &executable_search_paths : NULL);
-      if (!error.Success())
-        return;
-      target->SetExecutableModule(exe_module_sp, eLoadDependentsYes);
-    }
-  }
-}
-
-bool ProcessFreeBSD::AddThreadForInitialStopIfNeeded(lldb::tid_t stop_tid) {
-  bool added_to_set = false;
-  ThreadStopSet::iterator it = m_seen_initial_stop.find(stop_tid);
-  if (it == m_seen_initial_stop.end()) {
-    m_seen_initial_stop.insert(stop_tid);
-    added_to_set = true;
-  }
-  return added_to_set;
-}
-
-bool ProcessFreeBSD::WaitingForInitialStop(lldb::tid_t stop_tid) {
-  return (m_seen_initial_stop.find(stop_tid) == m_seen_initial_stop.end());
-}
-
-FreeBSDThread *
-ProcessFreeBSD::CreateNewFreeBSDThread(lldb_private::Process &process,
-                                       lldb::tid_t tid) {
-  return new FreeBSDThread(process, tid);
-}
-
-void ProcessFreeBSD::RefreshStateAfterStop() {
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
-  LLDB_LOGV(log, "message_queue size = {0}", m_message_queue.size());
-
-  std::lock_guard<std::recursive_mutex> guard(m_message_mutex);
-
-  // This method used to only handle one message.  Changing it to loop allows
-  // it to handle the case where we hit a breakpoint while handling a different
-  // breakpoint.
-  while (!m_message_queue.empty()) {
-    ProcessMessage &message = m_message_queue.front();
-
-    // Resolve the thread this message corresponds to and pass it along.
-    lldb::tid_t tid = message.GetTID();
-    LLDB_LOGV(log, " message_queue size = {0}, pid = {1}",
-              m_message_queue.size(), tid);
-
-    m_thread_list.RefreshStateAfterStop();
-
-    FreeBSDThread *thread = static_cast<FreeBSDThread *>(
-        GetThreadList().FindThreadByID(tid, false).get());
-    if (thread)
-      thread->Notify(message);
-
-    if (message.GetKind() == ProcessMessage::eExitMessage) {
-      // FIXME: We should tell the user about this, but the limbo message is
-      // probably better for that.
-      LLDB_LOG(log, "removing thread, tid = {0}", tid);
-      std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
-
-      ThreadSP thread_sp = m_thread_list.RemoveThreadByID(tid, false);
-      thread_sp.reset();
-      m_seen_initial_stop.erase(tid);
-    }
-
-    m_message_queue.pop();
-  }
-}
-
-bool ProcessFreeBSD::IsAlive() {
-  StateType state = GetPrivateState();
-  return state != eStateDetached && state != eStateExited &&
-         state != eStateInvalid && state != eStateUnloaded;
-}
-
-size_t ProcessFreeBSD::DoReadMemory(addr_t vm_addr, void *buf, size_t size,
-                                    Status &error) {
-  assert(m_monitor);
-  return m_monitor->ReadMemory(vm_addr, buf, size, error);
-}
-
-size_t ProcessFreeBSD::DoWriteMemory(addr_t vm_addr, const void *buf,
-                                     size_t size, Status &error) {
-  assert(m_monitor);
-  return m_monitor->WriteMemory(vm_addr, buf, size, error);
-}
-
-addr_t ProcessFreeBSD::DoAllocateMemory(size_t size, uint32_t permissions,
-                                        Status &error) {
-  addr_t allocated_addr = LLDB_INVALID_ADDRESS;
-
-  unsigned prot = 0;
-  if (permissions & lldb::ePermissionsReadable)
-    prot |= eMmapProtRead;
-  if (permissions & lldb::ePermissionsWritable)
-    prot |= eMmapProtWrite;
-  if (permissions & lldb::ePermissionsExecutable)
-    prot |= eMmapProtExec;
-
-  if (InferiorCallMmap(this, allocated_addr, 0, size, prot,
-                       eMmapFlagsAnon | eMmapFlagsPrivate, -1, 0)) {
-    m_addr_to_mmap_size[allocated_addr] = size;
-    error.Clear();
-  } else {
-    allocated_addr = LLDB_INVALID_ADDRESS;
-    error.SetErrorStringWithFormat(
-        "unable to allocate %zu bytes of memory with permissions %s", size,
-        GetPermissionsAsCString(permissions));
-  }
-
-  return allocated_addr;
-}
-
-Status ProcessFreeBSD::DoDeallocateMemory(lldb::addr_t addr) {
-  Status error;
-  MMapMap::iterator pos = m_addr_to_mmap_size.find(addr);
-  if (pos != m_addr_to_mmap_size.end() &&
-      InferiorCallMunmap(this, addr, pos->second))
-    m_addr_to_mmap_size.erase(pos);
-  else
-    error.SetErrorStringWithFormat("unable to deallocate memory at 0x%" PRIx64,
-                                   addr);
-
-  return error;
-}
-
-size_t
-ProcessFreeBSD::GetSoftwareBreakpointTrapOpcode(BreakpointSite *bp_site) {
-  static const uint8_t g_aarch64_opcode[] = {0x00, 0x00, 0x20, 0xD4};
-  static const uint8_t g_i386_opcode[] = {0xCC};
-
-  ArchSpec arch = GetTarget().GetArchitecture();
-  const uint8_t *opcode = NULL;
-  size_t opcode_size = 0;
-
-  switch (arch.GetMachine()) {
-  default:
-    assert(false && "CPU type not supported!");
-    break;
-
-  case llvm::Triple::arm: {
-    // The ARM reference recommends the use of 0xe7fddefe and 0xdefe but the
-    // linux kernel does otherwise.
-    static const uint8_t g_arm_breakpoint_opcode[] = {0xf0, 0x01, 0xf0, 0xe7};
-    static const uint8_t g_thumb_breakpoint_opcode[] = {0x01, 0xde};
-
-    lldb::BreakpointLocationSP bp_loc_sp(bp_site->GetOwnerAtIndex(0));
-    AddressClass addr_class = AddressClass::eUnknown;
-
-    if (bp_loc_sp)
-      addr_class = bp_loc_sp->GetAddress().GetAddressClass();
-
-    if (addr_class == AddressClass::eCodeAlternateISA ||
-        (addr_class == AddressClass::eUnknown &&
-         bp_loc_sp->GetAddress().GetOffset() & 1)) {
-      opcode = g_thumb_breakpoint_opcode;
-      opcode_size = sizeof(g_thumb_breakpoint_opcode);
-    } else {
-      opcode = g_arm_breakpoint_opcode;
-      opcode_size = sizeof(g_arm_breakpoint_opcode);
-    }
-  } break;
-  case llvm::Triple::aarch64:
-    opcode = g_aarch64_opcode;
-    opcode_size = sizeof(g_aarch64_opcode);
-    break;
-
-  case llvm::Triple::x86:
-  case llvm::Triple::x86_64:
-    opcode = g_i386_opcode;
-    opcode_size = sizeof(g_i386_opcode);
-    break;
-  }
-
-  bp_site->SetTrapOpcode(opcode, opcode_size);
-  return opcode_size;
-}
-
-Status ProcessFreeBSD::EnableBreakpointSite(BreakpointSite *bp_site) {
-  if (bp_site->HardwareRequired())
-    return Status("Hardware breakpoints are not supported.");
-
-  return EnableSoftwareBreakpoint(bp_site);
-}
-
-Status ProcessFreeBSD::DisableBreakpointSite(BreakpointSite *bp_site) {
-  return DisableSoftwareBreakpoint(bp_site);
-}
-
-Status ProcessFreeBSD::EnableWatchpoint(Watchpoint *wp, bool notify) {
-  Status error;
-  if (wp) {
-    user_id_t watchID = wp->GetID();
-    addr_t addr = wp->GetLoadAddress();
-    Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
-    LLDB_LOGF(log, "ProcessFreeBSD::EnableWatchpoint(watchID = %" PRIu64 ")",
-              watchID);
-    if (wp->IsEnabled()) {
-      LLDB_LOGF(log,
-                "ProcessFreeBSD::EnableWatchpoint(watchID = %" PRIu64
-                ") addr = 0x%8.8" PRIx64 ": watchpoint already enabled.",
-                watchID, (uint64_t)addr);
-      return error;
-    }
-
-    // Try to find a vacant watchpoint slot in the inferiors' main thread
-    uint32_t wp_hw_index = LLDB_INVALID_INDEX32;
-    std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
-    FreeBSDThread *thread = static_cast<FreeBSDThread *>(
-        m_thread_list.GetThreadAtIndex(0, false).get());
-
-    if (thread)
-      wp_hw_index = thread->FindVacantWatchpointIndex();
-
-    if (wp_hw_index == LLDB_INVALID_INDEX32) {
-      error.SetErrorString("Setting hardware watchpoint failed.");
-    } else {
-      wp->SetHardwareIndex(wp_hw_index);
-      bool wp_enabled = true;
-      uint32_t thread_count = m_thread_list.GetSize(false);
-      for (uint32_t i = 0; i < thread_count; ++i) {
-        thread = static_cast<FreeBSDThread *>(
-            m_thread_list.GetThreadAtIndex(i, false).get());
-        if (thread)
-          wp_enabled &= thread->EnableHardwareWatchpoint(wp);
-        else
-          wp_enabled = false;
-      }
-      if (wp_enabled) {
-        wp->SetEnabled(true, notify);
-        return error;
-      } else {
-        // Watchpoint enabling failed on at least one of the threads so roll
-        // back all of them
-        DisableWatchpoint(wp, false);
-        error.SetErrorString("Setting hardware watchpoint failed");
-      }
-    }
-  } else
-    error.SetErrorString("Watchpoint argument was NULL.");
-  return error;
-}
-
-Status ProcessFreeBSD::DisableWatchpoint(Watchpoint *wp, bool notify) {
-  Status error;
-  if (wp) {
-    user_id_t watchID = wp->GetID();
-    addr_t addr = wp->GetLoadAddress();
-    Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
-    LLDB_LOGF(log, "ProcessFreeBSD::DisableWatchpoint(watchID = %" PRIu64 ")",
-              watchID);
-    if (!wp->IsEnabled()) {
-      LLDB_LOGF(log,
-                "ProcessFreeBSD::DisableWatchpoint(watchID = %" PRIu64
-                ") addr = 0x%8.8" PRIx64 ": watchpoint already disabled.",
-                watchID, (uint64_t)addr);
-      // This is needed (for now) to keep watchpoints disabled correctly
-      wp->SetEnabled(false, notify);
-      return error;
-    }
-
-    if (wp->IsHardware()) {
-      bool wp_disabled = true;
-      std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
-      uint32_t thread_count = m_thread_list.GetSize(false);
-      for (uint32_t i = 0; i < thread_count; ++i) {
-        FreeBSDThread *thread = static_cast<FreeBSDThread *>(
-            m_thread_list.GetThreadAtIndex(i, false).get());
-        if (thread)
-          wp_disabled &= thread->DisableHardwareWatchpoint(wp);
-        else
-          wp_disabled = false;
-      }
-      if (wp_disabled) {
-        wp->SetHardwareIndex(LLDB_INVALID_INDEX32);
-        wp->SetEnabled(false, notify);
-        return error;
-      } else
-        error.SetErrorString("Disabling hardware watchpoint failed");
-    }
-  } else
-    error.SetErrorString("Watchpoint argument was NULL.");
-  return error;
-}
-
-Status ProcessFreeBSD::GetWatchpointSupportInfo(uint32_t &num) {
-  Status error;
-  std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
-  FreeBSDThread *thread = static_cast<FreeBSDThread *>(
-      m_thread_list.GetThreadAtIndex(0, false).get());
-  if (thread)
-    num = thread->NumSupportedHardwareWatchpoints();
-  else
-    error.SetErrorString("Process does not exist.");
-  return error;
-}
-
-Status ProcessFreeBSD::GetWatchpointSupportInfo(uint32_t &num, bool &after) {
-  Status error = GetWatchpointSupportInfo(num);
-  // Watchpoints trigger and halt the inferior after the corresponding
-  // instruction has been executed.
-  after = true;
-  return error;
-}
-
-uint32_t ProcessFreeBSD::UpdateThreadListIfNeeded() {
-  std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
-  // Do not allow recursive updates.
-  return m_thread_list.GetSize(false);
-}
-
-ByteOrder ProcessFreeBSD::GetByteOrder() const {
-  // FIXME: We should be able to extract this value directly.  See comment in
-  // ProcessFreeBSD().
-  return m_byte_order;
-}
-
-size_t ProcessFreeBSD::PutSTDIN(const char *buf, size_t len, Status &error) {
-  ssize_t status;
-  if ((status = write(m_monitor->GetTerminalFD(), buf, len)) < 0) {
-    error.SetErrorToErrno();
-    return 0;
-  }
-  return status;
-}
-
-// Utility functions.
-
-bool ProcessFreeBSD::HasExited() {
-  switch (GetPrivateState()) {
-  default:
-    break;
-
-  case eStateDetached:
-  case eStateExited:
-    return true;
-  }
-
-  return false;
-}
-
-bool ProcessFreeBSD::IsStopped() {
-  switch (GetPrivateState()) {
-  default:
-    break;
-
-  case eStateStopped:
-  case eStateCrashed:
-  case eStateSuspended:
-    return true;
-  }
-
-  return false;
-}
-
-bool ProcessFreeBSD::IsAThreadRunning() {
-  bool is_running = false;
-  std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
-  uint32_t thread_count = m_thread_list.GetSize(false);
-  for (uint32_t i = 0; i < thread_count; ++i) {
-    FreeBSDThread *thread = static_cast<FreeBSDThread *>(
-        m_thread_list.GetThreadAtIndex(i, false).get());
-    StateType thread_state = thread->GetState();
-    if (thread_state == eStateRunning || thread_state == eStateStepping) {
-      is_running = true;
-      break;
-    }
-  }
-  return is_running;
-}
-
-lldb_private::DataExtractor ProcessFreeBSD::GetAuxvData() {
-  // If we're the local platform, we can ask the host for auxv data.
-  PlatformSP platform_sp = GetTarget().GetPlatform();
-  assert(platform_sp && platform_sp->IsHost());
-
-  int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_AUXV, (int)m_process->GetID()};
-  size_t auxv_size = AT_COUNT * sizeof(Elf_Auxinfo);
-  DataBufferSP buf_sp(new DataBufferHeap(auxv_size, 0));
-
-  if (::sysctl(mib, 4, buf_sp->GetBytes(), &auxv_size, NULL, 0) != 0) {
-    perror("sysctl failed on auxv");
-    buf_sp.reset();
-  }
-
-  return DataExtractor(buf_sp, GetByteOrder(), GetAddressByteSize());
-}
-
-struct EmulatorBaton {
-  ProcessFreeBSD *m_process;
-  RegisterContext *m_reg_context;
-
-  // eRegisterKindDWARF -> RegisterValue
-  std::unordered_map<uint32_t, RegisterValue> m_register_values;
-
-  EmulatorBaton(ProcessFreeBSD *process, RegisterContext *reg_context)
-      : m_process(process), m_reg_context(reg_context) {}
-};
-
-static size_t ReadMemoryCallback(EmulateInstruction *instruction, void *baton,
-                                 const EmulateInstruction::Context &context,
-                                 lldb::addr_t addr, void *dst, size_t length) {
-  EmulatorBaton *emulator_baton = static_cast<EmulatorBaton *>(baton);
-
-  Status error;
-  size_t bytes_read =
-      emulator_baton->m_process->DoReadMemory(addr, dst, length, error);
-  if (!error.Success())
-    bytes_read = 0;
-  return bytes_read;
-}
-
-static bool ReadRegisterCallback(EmulateInstruction *instruction, void *baton,
-                                 const RegisterInfo *reg_info,
-                                 RegisterValue &reg_value) {
-  EmulatorBaton *emulator_baton = static_cast<EmulatorBaton *>(baton);
-
-  auto it = emulator_baton->m_register_values.find(
-      reg_info->kinds[eRegisterKindDWARF]);
-  if (it != emulator_baton->m_register_values.end()) {
-    reg_value = it->second;
-    return true;
-  }
-
-  // The emulator only fills in the dwarf register numbers (and in some cases
-  // the generic register numbers). Get the full register info from the
-  // register context based on the dwarf register numbers.
-  const RegisterInfo *full_reg_info =
-      emulator_baton->m_reg_context->GetRegisterInfo(
-          eRegisterKindDWARF, reg_info->kinds[eRegisterKindDWARF]);
-
-  bool error =
-      emulator_baton->m_reg_context->ReadRegister(full_reg_info, reg_value);
-  return error;
-}
-
-static bool WriteRegisterCallback(EmulateInstruction *instruction, void *baton,
-                                  const EmulateInstruction::Context &context,
-                                  const RegisterInfo *reg_info,
-                                  const RegisterValue &reg_value) {
-  EmulatorBaton *emulator_baton = static_cast<EmulatorBaton *>(baton);
-  emulator_baton->m_register_values[reg_info->kinds[eRegisterKindDWARF]] =
-      reg_value;
-  return true;
-}
-
-static size_t WriteMemoryCallback(EmulateInstruction *instruction, void *baton,
-                                  const EmulateInstruction::Context &context,
-                                  lldb::addr_t addr, const void *dst,
-                                  size_t length) {
-  return length;
-}
-
-bool ProcessFreeBSD::SingleStepBreakpointHit(
-    void *baton, lldb_private::StoppointCallbackContext *context,
-    lldb::user_id_t break_id, lldb::user_id_t break_loc_id) {
-  return false;
-}
-
-Status ProcessFreeBSD::SetSoftwareSingleStepBreakpoint(lldb::tid_t tid,
-                                                       lldb::addr_t addr) {
-  Status error;
-
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
-  if (log) {
-    LLDB_LOGF(log, "ProcessFreeBSD::%s addr = 0x%" PRIx64, __FUNCTION__, addr);
-    LLDB_LOGF(log, "SoftwareBreakpoint::%s addr = 0x%" PRIx64, __FUNCTION__,
-              addr);
-  }
-
-  // Validate the address.
-  if (addr == LLDB_INVALID_ADDRESS)
-    return Status("ProcessFreeBSD::%s invalid load address specified.",
-                  __FUNCTION__);
-
-  Breakpoint *const sw_step_break =
-      m_process->GetTarget().CreateBreakpoint(addr, true, false).get();
-  sw_step_break->SetCallback(SingleStepBreakpointHit, this, true);
-  sw_step_break->SetBreakpointKind("software-single-step");
-
-  LLDB_LOGF(log, "ProcessFreeBSD::%s addr = 0x%" PRIx64 " -- SUCCESS",
-            __FUNCTION__, addr);
-
-  m_threads_stepping_with_breakpoint.insert({tid, sw_step_break->GetID()});
-  return Status();
-}
-
-bool ProcessFreeBSD::IsSoftwareStepBreakpoint(lldb::tid_t tid) {
-  ThreadSP thread = GetThreadList().FindThreadByID(tid);
-  if (!thread)
-    return false;
-
-  assert(thread->GetRegisterContext());
-  lldb::addr_t stop_pc = thread->GetRegisterContext()->GetPC();
-
-  const auto &iter = m_threads_stepping_with_breakpoint.find(tid);
-  if (iter == m_threads_stepping_with_breakpoint.end())
-    return false;
-
-  lldb::break_id_t bp_id = iter->second;
-  BreakpointSP bp = GetTarget().GetBreakpointByID(bp_id);
-  if (!bp)
-    return false;
-
-  BreakpointLocationSP bp_loc = bp->FindLocationByAddress(stop_pc);
-  if (!bp_loc)
-    return false;
-
-  GetTarget().RemoveBreakpointByID(bp_id);
-  m_threads_stepping_with_breakpoint.erase(tid);
-  return true;
-}
-
-bool ProcessFreeBSD::SupportHardwareSingleStepping() const {
-  lldb_private::ArchSpec arch = GetTarget().GetArchitecture();
-  if (arch.GetMachine() == llvm::Triple::arm || arch.IsMIPS())
-    return false;
-  return true;
-}
-
-Status ProcessFreeBSD::SetupSoftwareSingleStepping(lldb::tid_t tid) {
-  std::unique_ptr<EmulateInstruction> emulator_up(
-      EmulateInstruction::FindPlugin(GetTarget().GetArchitecture(),
-                                     eInstructionTypePCModifying, nullptr));
-
-  if (emulator_up == nullptr)
-    return Status("Instruction emulator not found!");
-
-  FreeBSDThread *thread = static_cast<FreeBSDThread *>(
-      m_thread_list.FindThreadByID(tid, false).get());
-  if (thread == NULL)
-    return Status("Thread not found not found!");
-
-  lldb::RegisterContextSP register_context_sp = thread->GetRegisterContext();
-
-  EmulatorBaton baton(this, register_context_sp.get());
-  emulator_up->SetBaton(&baton);
-  emulator_up->SetReadMemCallback(&ReadMemoryCallback);
-  emulator_up->SetReadRegCallback(&ReadRegisterCallback);
-  emulator_up->SetWriteMemCallback(&WriteMemoryCallback);
-  emulator_up->SetWriteRegCallback(&WriteRegisterCallback);
-
-  if (!emulator_up->ReadInstruction())
-    return Status("Read instruction failed!");
-
-  bool emulation_result =
-      emulator_up->EvaluateInstruction(eEmulateInstructionOptionAutoAdvancePC);
-  const RegisterInfo *reg_info_pc = register_context_sp->GetRegisterInfo(
-      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
-  auto pc_it =
-      baton.m_register_values.find(reg_info_pc->kinds[eRegisterKindDWARF]);
-
-  lldb::addr_t next_pc;
-  if (emulation_result) {
-    assert(pc_it != baton.m_register_values.end() &&
-           "Emulation was successful but PC wasn't updated");
-    next_pc = pc_it->second.GetAsUInt64();
-  } else if (pc_it == baton.m_register_values.end()) {
-    // Emulate instruction failed and it haven't changed PC. Advance PC with
-    // the size of the current opcode because the emulation of all
-    // PC modifying instruction should be successful. The failure most
-    // likely caused by a not supported instruction which don't modify PC.
-    next_pc =
-        register_context_sp->GetPC() + emulator_up->GetOpcode().GetByteSize();
-  } else {
-    // The instruction emulation failed after it modified the PC. It is an
-    // unknown error where we can't continue because the next instruction is
-    // modifying the PC but we don't  know how.
-    return Status("Instruction emulation failed unexpectedly");
-  }
-
-  SetSoftwareSingleStepBreakpoint(tid, next_pc);
-  return Status();
-}
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.h
deleted file mode 100644
index b60bcd279021..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.h
+++ /dev/null
@@ -1,221 +0,0 @@
-//===-- ProcessFreeBSD.h ------------------------------------------*- C++
-//-*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_ProcessFreeBSD_H_
-#define liblldb_ProcessFreeBSD_H_
-
-#include "Plugins/Process/POSIX/ProcessMessage.h"
-#include "lldb/Target/Process.h"
-#include "lldb/Target/ThreadList.h"
-#include <mutex>
-#include <queue>
-#include <set>
-
-class ProcessMonitor;
-class FreeBSDThread;
-
-class ProcessFreeBSD : public lldb_private::Process {
-
-public:
-  // Static functions.
-  static lldb::ProcessSP
-  CreateInstance(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
-                 const lldb_private::FileSpec *crash_file_path,
-                 bool can_connect);
-
-  static void Initialize();
-
-  static void Terminate();
-
-  static lldb_private::ConstString GetPluginNameStatic();
-
-  static const char *GetPluginDescriptionStatic();
-
-  // Constructors and destructors
-  ProcessFreeBSD(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
-                 lldb::UnixSignalsSP &unix_signals_sp);
-
-  ~ProcessFreeBSD();
-
-  virtual lldb_private::Status WillResume() override;
-
-  // PluginInterface protocol
-  virtual lldb_private::ConstString GetPluginName() override;
-
-  virtual uint32_t GetPluginVersion() override;
-
-public:
-  // Process protocol.
-  void Finalize() override;
-
-  bool CanDebug(lldb::TargetSP target_sp,
-                bool plugin_specified_by_name) override;
-
-  lldb_private::Status WillLaunch(lldb_private::Module *module) override;
-
-  lldb_private::Status DoAttachToProcessWithID(
-      lldb::pid_t pid,
-      const lldb_private::ProcessAttachInfo &attach_info) override;
-
-  lldb_private::Status
-  DoLaunch(lldb_private::Module *exe_module,
-           lldb_private::ProcessLaunchInfo &launch_info) override;
-
-  void DidLaunch() override;
-
-  lldb_private::Status DoResume() override;
-
-  lldb_private::Status DoHalt(bool &caused_stop) override;
-
-  lldb_private::Status DoDetach(bool keep_stopped) override;
-
-  lldb_private::Status DoSignal(int signal) override;
-
-  lldb_private::Status DoDestroy() override;
-
-  void DoDidExec() override;
-
-  void RefreshStateAfterStop() override;
-
-  bool IsAlive() override;
-
-  size_t DoReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
-                      lldb_private::Status &error) override;
-
-  size_t DoWriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size,
-                       lldb_private::Status &error) override;
-
-  lldb::addr_t DoAllocateMemory(size_t size, uint32_t permissions,
-                                lldb_private::Status &error) override;
-
-  lldb_private::Status DoDeallocateMemory(lldb::addr_t ptr) override;
-
-  virtual size_t
-  GetSoftwareBreakpointTrapOpcode(lldb_private::BreakpointSite *bp_site);
-
-  lldb_private::Status
-  EnableBreakpointSite(lldb_private::BreakpointSite *bp_site) override;
-
-  lldb_private::Status
-  DisableBreakpointSite(lldb_private::BreakpointSite *bp_site) override;
-
-  lldb_private::Status EnableWatchpoint(lldb_private::Watchpoint *wp,
-                                        bool notify = true) override;
-
-  lldb_private::Status DisableWatchpoint(lldb_private::Watchpoint *wp,
-                                         bool notify = true) override;
-
-  lldb_private::Status GetWatchpointSupportInfo(uint32_t &num) override;
-
-  lldb_private::Status GetWatchpointSupportInfo(uint32_t &num,
-                                                bool &after) override;
-
-  virtual uint32_t UpdateThreadListIfNeeded();
-
-  bool DoUpdateThreadList(lldb_private::ThreadList &old_thread_list,
-                          lldb_private::ThreadList &new_thread_list) override;
-
-  virtual lldb::ByteOrder GetByteOrder() const;
-
-  lldb::addr_t GetImageInfoAddress() override;
-
-  size_t PutSTDIN(const char *buf, size_t len,
-                  lldb_private::Status &error) override;
-
-  lldb_private::DataExtractor GetAuxvData() override;
-
-  // ProcessFreeBSD internal API.
-
-  /// Registers the given message with this process.
-  virtual void SendMessage(const ProcessMessage &message);
-
-  ProcessMonitor &GetMonitor() {
-    assert(m_monitor);
-    return *m_monitor;
-  }
-
-  lldb_private::FileSpec
-  GetFileSpec(const lldb_private::FileAction *file_action,
-              const lldb_private::FileSpec &default_file_spec,
-              const lldb_private::FileSpec &dbg_pts_file_spec);
-
-  /// Adds the thread to the list of threads for which we have received the
-  /// initial stopping signal.
-  /// The \p stop_tid parameter indicates the thread which the stop happened
-  /// for.
-  bool AddThreadForInitialStopIfNeeded(lldb::tid_t stop_tid);
-
-  bool WaitingForInitialStop(lldb::tid_t stop_tid);
-
-  virtual FreeBSDThread *CreateNewFreeBSDThread(lldb_private::Process &process,
-                                                lldb::tid_t tid);
-
-  static bool SingleStepBreakpointHit(
-      void *baton, lldb_private::StoppointCallbackContext *context,
-      lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
-
-  lldb_private::Status SetupSoftwareSingleStepping(lldb::tid_t tid);
-
-  lldb_private::Status SetSoftwareSingleStepBreakpoint(lldb::tid_t tid,
-                                                       lldb::addr_t addr);
-
-  bool IsSoftwareStepBreakpoint(lldb::tid_t tid);
-
-  bool SupportHardwareSingleStepping() const;
-
-  typedef std::vector<lldb::tid_t> tid_collection;
-  tid_collection &GetStepTids() { return m_step_tids; }
-
-protected:
-  static const size_t MAX_TRAP_OPCODE_SIZE = 8;
-
-  /// Target byte order.
-  lldb::ByteOrder m_byte_order;
-
-  /// Process monitor;
-  ProcessMonitor *m_monitor;
-
-  /// The module we are executing.
-  lldb_private::Module *m_module;
-
-  /// Message queue notifying this instance of inferior process state changes.
-  std::recursive_mutex m_message_mutex;
-  std::queue<ProcessMessage> m_message_queue;
-
-  /// Drive any exit events to completion.
-  bool m_exit_now;
-
-  /// Returns true if the process has exited.
-  bool HasExited();
-
-  /// Returns true if the process is stopped.
-  bool IsStopped();
-
-  /// Returns true if at least one running is currently running
-  bool IsAThreadRunning();
-
-  typedef std::map<lldb::addr_t, lldb::addr_t> MMapMap;
-  MMapMap m_addr_to_mmap_size;
-
-  typedef std::set<lldb::tid_t> ThreadStopSet;
-  /// Every thread begins with a stop signal. This keeps track
-  /// of the threads for which we have received the stop signal.
-  ThreadStopSet m_seen_initial_stop;
-
-  friend class FreeBSDThread;
-
-  tid_collection m_suspend_tids;
-  tid_collection m_run_tids;
-  tid_collection m_step_tids;
-  std::map<lldb::tid_t, lldb::break_id_t> m_threads_stepping_with_breakpoint;
-
-  int m_resume_signo;
-};
-
-#endif // liblldb_ProcessFreeBSD_H_
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp
deleted file mode 100644
index 0738cced44ab..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp
+++ /dev/null
@@ -1,1424 +0,0 @@
-//===-- ProcessMonitor.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 <poll.h>
-#include <signal.h>
-#include <stdint.h>
-#include <string.h>
-#include <sys/ptrace.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <unistd.h>
-
-#include "lldb/Host/Host.h"
-#include "lldb/Host/PseudoTerminal.h"
-#include "lldb/Host/ThreadLauncher.h"
-#include "lldb/Target/RegisterContext.h"
-#include "lldb/Target/Thread.h"
-#include "lldb/Target/UnixSignals.h"
-#include "lldb/Utility/RegisterValue.h"
-#include "lldb/Utility/Scalar.h"
-#include "lldb/Utility/Status.h"
-#include "llvm/Support/Errno.h"
-
-#include "FreeBSDThread.h"
-#include "Plugins/Process/POSIX/CrashReason.h"
-#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
-#include "ProcessFreeBSD.h"
-#include "ProcessMonitor.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-// Wrapper for ptrace to catch errors and log calls.
-
-const char *Get_PT_IO_OP(int op) {
-  switch (op) {
-  case PIOD_READ_D:
-    return "READ_D";
-  case PIOD_WRITE_D:
-    return "WRITE_D";
-  case PIOD_READ_I:
-    return "READ_I";
-  case PIOD_WRITE_I:
-    return "WRITE_I";
-  default:
-    return "Unknown op";
-  }
-}
-
-// Wrapper for ptrace to catch errors and log calls. Note that ptrace sets
-// errno on error because -1 is reserved as a valid result.
-extern long PtraceWrapper(int req, lldb::pid_t pid, void *addr, int data,
-                          const char *reqName, const char *file, int line) {
-  long int result;
-
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
-
-  if (log) {
-    LLDB_LOGF(log,
-              "ptrace(%s, %" PRIu64 ", %p, %x) called from file %s line %d",
-              reqName, pid, addr, data, file, line);
-    if (req == PT_IO) {
-      struct ptrace_io_desc *pi = (struct ptrace_io_desc *)addr;
-
-      LLDB_LOGF(log, "PT_IO: op=%s offs=%zx size=%zu",
-                Get_PT_IO_OP(pi->piod_op), (size_t)pi->piod_offs, pi->piod_len);
-    }
-  }
-
-  // PtraceDisplayBytes(req, data);
-
-  errno = 0;
-  result = ptrace(req, pid, (caddr_t)addr, data);
-
-  // PtraceDisplayBytes(req, data);
-
-  if (log && errno != 0) {
-    const char *str;
-    switch (errno) {
-    case ESRCH:
-      str = "ESRCH";
-      break;
-    case EINVAL:
-      str = "EINVAL";
-      break;
-    case EBUSY:
-      str = "EBUSY";
-      break;
-    case EPERM:
-      str = "EPERM";
-      break;
-    default:
-      str = "<unknown>";
-    }
-    LLDB_LOGF(log, "ptrace() failed; errno=%d (%s)", errno, str);
-  }
-
-  if (log) {
-#ifdef __amd64__
-    if (req == PT_GETREGS) {
-      struct reg *r = (struct reg *)addr;
-
-      LLDB_LOGF(log, "PT_GETREGS: rip=0x%lx rsp=0x%lx rbp=0x%lx rax=0x%lx",
-                r->r_rip, r->r_rsp, r->r_rbp, r->r_rax);
-    }
-    if (req == PT_GETDBREGS || req == PT_SETDBREGS) {
-      struct dbreg *r = (struct dbreg *)addr;
-      char setget = (req == PT_GETDBREGS) ? 'G' : 'S';
-
-      for (int i = 0; i <= 7; i++)
-        LLDB_LOGF(log, "PT_%cETDBREGS: dr[%d]=0x%lx", setget, i, r->dr[i]);
-    }
-#endif
-  }
-
-  return result;
-}
-
-// Wrapper for ptrace when logging is not required. Sets errno to 0 prior to
-// calling ptrace.
-extern long PtraceWrapper(int req, lldb::pid_t pid, void *addr, int data) {
-  long result = 0;
-  errno = 0;
-  result = ptrace(req, pid, (caddr_t)addr, data);
-  return result;
-}
-
-#define PTRACE(req, pid, addr, data)                                           \
-  PtraceWrapper((req), (pid), (addr), (data), #req, __FILE__, __LINE__)
-
-// Static implementations of ProcessMonitor::ReadMemory and
-// ProcessMonitor::WriteMemory.  This enables mutual recursion between these
-// functions without needed to go thru the thread funnel.
-
-static size_t DoReadMemory(lldb::pid_t pid, lldb::addr_t vm_addr, void *buf,
-                           size_t size, Status &error) {
-  struct ptrace_io_desc pi_desc;
-
-  pi_desc.piod_op = PIOD_READ_D;
-  pi_desc.piod_offs = (void *)vm_addr;
-  pi_desc.piod_addr = buf;
-  pi_desc.piod_len = size;
-
-  if (PTRACE(PT_IO, pid, (caddr_t)&pi_desc, 0) < 0) {
-    error.SetErrorToErrno();
-    return 0;
-  }
-  return pi_desc.piod_len;
-}
-
-static size_t DoWriteMemory(lldb::pid_t pid, lldb::addr_t vm_addr,
-                            const void *buf, size_t size, Status &error) {
-  struct ptrace_io_desc pi_desc;
-
-  pi_desc.piod_op = PIOD_WRITE_D;
-  pi_desc.piod_offs = (void *)vm_addr;
-  pi_desc.piod_addr = const_cast<void *>(buf);
-  pi_desc.piod_len = size;
-
-  if (PTRACE(PT_IO, pid, (caddr_t)&pi_desc, 0) < 0) {
-    error.SetErrorToErrno();
-    return 0;
-  }
-  return pi_desc.piod_len;
-}
-
-// Simple helper function to ensure flags are enabled on the given file
-// descriptor.
-static bool EnsureFDFlags(int fd, int flags, Status &error) {
-  int status;
-
-  if ((status = fcntl(fd, F_GETFL)) == -1) {
-    error.SetErrorToErrno();
-    return false;
-  }
-
-  if (fcntl(fd, F_SETFL, status | flags) == -1) {
-    error.SetErrorToErrno();
-    return false;
-  }
-
-  return true;
-}
-
-/// \class Operation
-/// Represents a ProcessMonitor operation.
-///
-/// Under FreeBSD, it is not possible to ptrace() from any other thread but
-/// the one that spawned or attached to the process from the start.
-/// Therefore, when a ProcessMonitor is asked to deliver or change the state
-/// of an inferior process the operation must be "funneled" to a specific
-/// thread to perform the task.  The Operation class provides an abstract base
-/// for all services the ProcessMonitor must perform via the single virtual
-/// function Execute, thus encapsulating the code that needs to run in the
-/// privileged context.
-class Operation {
-public:
-  virtual ~Operation() {}
-  virtual void Execute(ProcessMonitor *monitor) = 0;
-};
-
-/// \class ReadOperation
-/// Implements ProcessMonitor::ReadMemory.
-class ReadOperation : public Operation {
-public:
-  ReadOperation(lldb::addr_t addr, void *buff, size_t size, Status &error,
-                size_t &result)
-      : m_addr(addr), m_buff(buff), m_size(size), m_error(error),
-        m_result(result) {}
-
-  void Execute(ProcessMonitor *monitor) override;
-
-private:
-  lldb::addr_t m_addr;
-  void *m_buff;
-  size_t m_size;
-  Status &m_error;
-  size_t &m_result;
-};
-
-void ReadOperation::Execute(ProcessMonitor *monitor) {
-  lldb::pid_t pid = monitor->GetPID();
-
-  m_result = DoReadMemory(pid, m_addr, m_buff, m_size, m_error);
-}
-
-/// \class WriteOperation
-/// Implements ProcessMonitor::WriteMemory.
-class WriteOperation : public Operation {
-public:
-  WriteOperation(lldb::addr_t addr, const void *buff, size_t size,
-                 Status &error, size_t &result)
-      : m_addr(addr), m_buff(buff), m_size(size), m_error(error),
-        m_result(result) {}
-
-  void Execute(ProcessMonitor *monitor) override;
-
-private:
-  lldb::addr_t m_addr;
-  const void *m_buff;
-  size_t m_size;
-  Status &m_error;
-  size_t &m_result;
-};
-
-void WriteOperation::Execute(ProcessMonitor *monitor) {
-  lldb::pid_t pid = monitor->GetPID();
-
-  m_result = DoWriteMemory(pid, m_addr, m_buff, m_size, m_error);
-}
-
-/// \class ReadRegOperation
-/// Implements ProcessMonitor::ReadRegisterValue.
-class ReadRegOperation : public Operation {
-public:
-  ReadRegOperation(lldb::tid_t tid, unsigned offset, unsigned size,
-                   RegisterValue &value, bool &result)
-      : m_tid(tid), m_offset(offset), m_size(size), m_value(value),
-        m_result(result) {}
-
-  void Execute(ProcessMonitor *monitor);
-
-private:
-  lldb::tid_t m_tid;
-  unsigned m_offset;
-  unsigned m_size;
-  RegisterValue &m_value;
-  bool &m_result;
-};
-
-void ReadRegOperation::Execute(ProcessMonitor *monitor) {
-  struct reg regs;
-  int rc;
-
-  if ((rc = PTRACE(PT_GETREGS, m_tid, (caddr_t)&regs, 0)) < 0) {
-    m_result = false;
-  } else {
-    // 'struct reg' contains only 32- or 64-bit register values.  Punt on
-    // others.  Also, not all entries may be uintptr_t sized, such as 32-bit
-    // processes on powerpc64 (probably the same for i386 on amd64)
-    if (m_size == sizeof(uint32_t))
-      m_value = *(uint32_t *)(((caddr_t)&regs) + m_offset);
-    else if (m_size == sizeof(uint64_t))
-      m_value = *(uint64_t *)(((caddr_t)&regs) + m_offset);
-    else
-      memcpy((void *)&m_value, (((caddr_t)&regs) + m_offset), m_size);
-    m_result = true;
-  }
-}
-
-/// \class WriteRegOperation
-/// Implements ProcessMonitor::WriteRegisterValue.
-class WriteRegOperation : public Operation {
-public:
-  WriteRegOperation(lldb::tid_t tid, unsigned offset,
-                    const RegisterValue &value, bool &result)
-      : m_tid(tid), m_offset(offset), m_value(value), m_result(result) {}
-
-  void Execute(ProcessMonitor *monitor) override;
-
-private:
-  lldb::tid_t m_tid;
-  unsigned m_offset;
-  const RegisterValue &m_value;
-  bool &m_result;
-};
-
-void WriteRegOperation::Execute(ProcessMonitor *monitor) {
-  struct reg regs;
-
-  if (PTRACE(PT_GETREGS, m_tid, (caddr_t)&regs, 0) < 0) {
-    m_result = false;
-    return;
-  }
-  *(uintptr_t *)(((caddr_t)&regs) + m_offset) =
-      (uintptr_t)m_value.GetAsUInt64();
-  if (PTRACE(PT_SETREGS, m_tid, (caddr_t)&regs, 0) < 0)
-    m_result = false;
-  else
-    m_result = true;
-}
-
-/// \class ReadDebugRegOperation
-/// Implements ProcessMonitor::ReadDebugRegisterValue.
-class ReadDebugRegOperation : public Operation {
-public:
-  ReadDebugRegOperation(lldb::tid_t tid, unsigned offset, unsigned size,
-                        RegisterValue &value, bool &result)
-      : m_tid(tid), m_offset(offset), m_size(size), m_value(value),
-        m_result(result) {}
-
-  void Execute(ProcessMonitor *monitor) override;
-
-private:
-  lldb::tid_t m_tid;
-  unsigned m_offset;
-  unsigned m_size;
-  RegisterValue &m_value;
-  bool &m_result;
-};
-
-void ReadDebugRegOperation::Execute(ProcessMonitor *monitor) {
-  struct dbreg regs;
-  int rc;
-
-  if ((rc = PTRACE(PT_GETDBREGS, m_tid, (caddr_t)&regs, 0)) < 0) {
-    m_result = false;
-  } else {
-    if (m_size == sizeof(uintptr_t))
-      m_value = *(uintptr_t *)(((caddr_t)&regs) + m_offset);
-    else
-      memcpy((void *)&m_value, (((caddr_t)&regs) + m_offset), m_size);
-    m_result = true;
-  }
-}
-
-/// \class WriteDebugRegOperation
-/// Implements ProcessMonitor::WriteDebugRegisterValue.
-class WriteDebugRegOperation : public Operation {
-public:
-  WriteDebugRegOperation(lldb::tid_t tid, unsigned offset,
-                         const RegisterValue &value, bool &result)
-      : m_tid(tid), m_offset(offset), m_value(value), m_result(result) {}
-
-  void Execute(ProcessMonitor *monitor) override;
-
-private:
-  lldb::tid_t m_tid;
-  unsigned m_offset;
-  const RegisterValue &m_value;
-  bool &m_result;
-};
-
-void WriteDebugRegOperation::Execute(ProcessMonitor *monitor) {
-  struct dbreg regs;
-
-  if (PTRACE(PT_GETDBREGS, m_tid, (caddr_t)&regs, 0) < 0) {
-    m_result = false;
-    return;
-  }
-  *(uintptr_t *)(((caddr_t)&regs) + m_offset) =
-      (uintptr_t)m_value.GetAsUInt64();
-  if (PTRACE(PT_SETDBREGS, m_tid, (caddr_t)&regs, 0) < 0)
-    m_result = false;
-  else
-    m_result = true;
-}
-
-/// \class ReadGPROperation
-/// Implements ProcessMonitor::ReadGPR.
-class ReadGPROperation : public Operation {
-public:
-  ReadGPROperation(lldb::tid_t tid, void *buf, bool &result)
-      : m_tid(tid), m_buf(buf), m_result(result) {}
-
-  void Execute(ProcessMonitor *monitor) override;
-
-private:
-  lldb::tid_t m_tid;
-  void *m_buf;
-  bool &m_result;
-};
-
-void ReadGPROperation::Execute(ProcessMonitor *monitor) {
-  int rc;
-
-  errno = 0;
-  rc = PTRACE(PT_GETREGS, m_tid, (caddr_t)m_buf, 0);
-  if (errno != 0)
-    m_result = false;
-  else
-    m_result = true;
-}
-
-/// \class ReadFPROperation
-/// Implements ProcessMonitor::ReadFPR.
-class ReadFPROperation : public Operation {
-public:
-  ReadFPROperation(lldb::tid_t tid, void *buf, bool &result)
-      : m_tid(tid), m_buf(buf), m_result(result) {}
-
-  void Execute(ProcessMonitor *monitor) override;
-
-private:
-  lldb::tid_t m_tid;
-  void *m_buf;
-  bool &m_result;
-};
-
-void ReadFPROperation::Execute(ProcessMonitor *monitor) {
-  if (PTRACE(PT_GETFPREGS, m_tid, (caddr_t)m_buf, 0) < 0)
-    m_result = false;
-  else
-    m_result = true;
-}
-
-/// \class WriteGPROperation
-/// Implements ProcessMonitor::WriteGPR.
-class WriteGPROperation : public Operation {
-public:
-  WriteGPROperation(lldb::tid_t tid, void *buf, bool &result)
-      : m_tid(tid), m_buf(buf), m_result(result) {}
-
-  void Execute(ProcessMonitor *monitor) override;
-
-private:
-  lldb::tid_t m_tid;
-  void *m_buf;
-  bool &m_result;
-};
-
-void WriteGPROperation::Execute(ProcessMonitor *monitor) {
-  if (PTRACE(PT_SETREGS, m_tid, (caddr_t)m_buf, 0) < 0)
-    m_result = false;
-  else
-    m_result = true;
-}
-
-/// \class WriteFPROperation
-/// Implements ProcessMonitor::WriteFPR.
-class WriteFPROperation : public Operation {
-public:
-  WriteFPROperation(lldb::tid_t tid, void *buf, bool &result)
-      : m_tid(tid), m_buf(buf), m_result(result) {}
-
-  void Execute(ProcessMonitor *monitor) override;
-
-private:
-  lldb::tid_t m_tid;
-  void *m_buf;
-  bool &m_result;
-};
-
-void WriteFPROperation::Execute(ProcessMonitor *monitor) {
-  if (PTRACE(PT_SETFPREGS, m_tid, (caddr_t)m_buf, 0) < 0)
-    m_result = false;
-  else
-    m_result = true;
-}
-
-/// \class ResumeOperation
-/// Implements ProcessMonitor::Resume.
-class ResumeOperation : public Operation {
-public:
-  ResumeOperation(uint32_t signo, bool &result)
-      : m_signo(signo), m_result(result) {}
-
-  void Execute(ProcessMonitor *monitor) override;
-
-private:
-  uint32_t m_signo;
-  bool &m_result;
-};
-
-void ResumeOperation::Execute(ProcessMonitor *monitor) {
-  lldb::pid_t pid = monitor->GetPID();
-  int data = 0;
-
-  if (m_signo != LLDB_INVALID_SIGNAL_NUMBER)
-    data = m_signo;
-
-  if (PTRACE(PT_CONTINUE, pid, (caddr_t)1, data)) {
-    Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
-    LLDB_LOG(log, "ResumeOperation ({0}) failed: {1}", pid,
-             llvm::sys::StrError(errno));
-    m_result = false;
-  } else
-    m_result = true;
-}
-
-/// \class SingleStepOperation
-/// Implements ProcessMonitor::SingleStep.
-class SingleStepOperation : public Operation {
-public:
-  SingleStepOperation(uint32_t signo, bool &result)
-      : m_signo(signo), m_result(result) {}
-
-  void Execute(ProcessMonitor *monitor) override;
-
-private:
-  uint32_t m_signo;
-  bool &m_result;
-};
-
-void SingleStepOperation::Execute(ProcessMonitor *monitor) {
-  lldb::pid_t pid = monitor->GetPID();
-  int data = 0;
-
-  if (m_signo != LLDB_INVALID_SIGNAL_NUMBER)
-    data = m_signo;
-
-  if (PTRACE(PT_STEP, pid, NULL, data))
-    m_result = false;
-  else
-    m_result = true;
-}
-
-/// \class LwpInfoOperation
-/// Implements ProcessMonitor::GetLwpInfo.
-class LwpInfoOperation : public Operation {
-public:
-  LwpInfoOperation(lldb::tid_t tid, void *info, bool &result, int &ptrace_err)
-      : m_tid(tid), m_info(info), m_result(result), m_err(ptrace_err) {}
-
-  void Execute(ProcessMonitor *monitor) override;
-
-private:
-  lldb::tid_t m_tid;
-  void *m_info;
-  bool &m_result;
-  int &m_err;
-};
-
-void LwpInfoOperation::Execute(ProcessMonitor *monitor) {
-  struct ptrace_lwpinfo plwp;
-
-  if (PTRACE(PT_LWPINFO, m_tid, (caddr_t)&plwp, sizeof(plwp))) {
-    m_result = false;
-    m_err = errno;
-  } else {
-    memcpy(m_info, &plwp, sizeof(plwp));
-    m_result = true;
-  }
-}
-
-/// \class ThreadSuspendOperation
-/// Implements ProcessMonitor::ThreadSuspend.
-class ThreadSuspendOperation : public Operation {
-public:
-  ThreadSuspendOperation(lldb::tid_t tid, bool suspend, bool &result)
-      : m_tid(tid), m_suspend(suspend), m_result(result) {}
-
-  void Execute(ProcessMonitor *monitor) override;
-
-private:
-  lldb::tid_t m_tid;
-  bool m_suspend;
-  bool &m_result;
-};
-
-void ThreadSuspendOperation::Execute(ProcessMonitor *monitor) {
-  m_result = !PTRACE(m_suspend ? PT_SUSPEND : PT_RESUME, m_tid, NULL, 0);
-}
-
-/// \class EventMessageOperation
-/// Implements ProcessMonitor::GetEventMessage.
-class EventMessageOperation : public Operation {
-public:
-  EventMessageOperation(lldb::tid_t tid, unsigned long *message, bool &result)
-      : m_tid(tid), m_message(message), m_result(result) {}
-
-  void Execute(ProcessMonitor *monitor) override;
-
-private:
-  lldb::tid_t m_tid;
-  unsigned long *m_message;
-  bool &m_result;
-};
-
-void EventMessageOperation::Execute(ProcessMonitor *monitor) {
-  struct ptrace_lwpinfo plwp;
-
-  if (PTRACE(PT_LWPINFO, m_tid, (caddr_t)&plwp, sizeof(plwp)))
-    m_result = false;
-  else {
-    if (plwp.pl_flags & PL_FLAG_FORKED) {
-      *m_message = plwp.pl_child_pid;
-      m_result = true;
-    } else
-      m_result = false;
-  }
-}
-
-/// \class KillOperation
-/// Implements ProcessMonitor::Kill.
-class KillOperation : public Operation {
-public:
-  KillOperation(bool &result) : m_result(result) {}
-
-  void Execute(ProcessMonitor *monitor) override;
-
-private:
-  bool &m_result;
-};
-
-void KillOperation::Execute(ProcessMonitor *monitor) {
-  lldb::pid_t pid = monitor->GetPID();
-
-  if (PTRACE(PT_KILL, pid, NULL, 0))
-    m_result = false;
-  else
-    m_result = true;
-}
-
-/// \class DetachOperation
-/// Implements ProcessMonitor::Detach.
-class DetachOperation : public Operation {
-public:
-  DetachOperation(Status &result) : m_error(result) {}
-
-  void Execute(ProcessMonitor *monitor) override;
-
-private:
-  Status &m_error;
-};
-
-void DetachOperation::Execute(ProcessMonitor *monitor) {
-  lldb::pid_t pid = monitor->GetPID();
-
-  if (PTRACE(PT_DETACH, pid, NULL, 0) < 0)
-    m_error.SetErrorToErrno();
-}
-
-ProcessMonitor::OperationArgs::OperationArgs(ProcessMonitor *monitor)
-    : m_monitor(monitor) {
-  sem_init(&m_semaphore, 0, 0);
-}
-
-ProcessMonitor::OperationArgs::~OperationArgs() { sem_destroy(&m_semaphore); }
-
-ProcessMonitor::LaunchArgs::LaunchArgs(ProcessMonitor *monitor,
-                                       lldb_private::Module *module,
-                                       char const **argv, Environment env,
-                                       const FileSpec &stdin_file_spec,
-                                       const FileSpec &stdout_file_spec,
-                                       const FileSpec &stderr_file_spec,
-                                       const FileSpec &working_dir)
-    : OperationArgs(monitor), m_module(module), m_argv(argv),
-      m_env(std::move(env)), m_stdin_file_spec(stdin_file_spec),
-      m_stdout_file_spec(stdout_file_spec),
-      m_stderr_file_spec(stderr_file_spec), m_working_dir(working_dir) {}
-
-ProcessMonitor::LaunchArgs::~LaunchArgs() {}
-
-ProcessMonitor::AttachArgs::AttachArgs(ProcessMonitor *monitor, lldb::pid_t pid)
-    : OperationArgs(monitor), m_pid(pid) {}
-
-ProcessMonitor::AttachArgs::~AttachArgs() {}
-
-/// The basic design of the ProcessMonitor is built around two threads.
-///
-/// One thread (@see SignalThread) simply blocks on a call to waitpid()
-/// looking for changes in the debugee state.  When a change is detected a
-/// ProcessMessage is sent to the associated ProcessFreeBSD instance.  This
-/// thread "drives" state changes in the debugger.
-///
-/// The second thread (@see OperationThread) is responsible for two things 1)
-/// launching or attaching to the inferior process, and then 2) servicing
-/// operations such as register reads/writes, stepping, etc.  See the comments
-/// on the Operation class for more info as to why this is needed.
-ProcessMonitor::ProcessMonitor(
-    ProcessFreeBSD *process, Module *module, const char *argv[],
-    Environment env, const FileSpec &stdin_file_spec,
-    const FileSpec &stdout_file_spec, const FileSpec &stderr_file_spec,
-    const FileSpec &working_dir,
-    const lldb_private::ProcessLaunchInfo & /* launch_info */,
-    lldb_private::Status &error)
-    : m_process(static_cast<ProcessFreeBSD *>(process)),
-      m_operation_thread(), m_monitor_thread(), m_pid(LLDB_INVALID_PROCESS_ID), m_terminal_fd(-1), m_operation(0) {
-  using namespace std::placeholders;
-
-  std::unique_ptr<LaunchArgs> args(
-      new LaunchArgs(this, module, argv, std::move(env), stdin_file_spec,
-                     stdout_file_spec, stderr_file_spec, working_dir));
-
-  sem_init(&m_operation_pending, 0, 0);
-  sem_init(&m_operation_done, 0, 0);
-
-  StartLaunchOpThread(args.get(), error);
-  if (!error.Success())
-    return;
-
-  if (llvm::sys::RetryAfterSignal(-1, sem_wait, &args->m_semaphore) == -1) {
-    error.SetErrorToErrno();
-    return;
-  }
-
-  // Check that the launch was a success.
-  if (!args->m_error.Success()) {
-    StopOpThread();
-    error = args->m_error;
-    return;
-  }
-
-  // Finally, start monitoring the child process for change in state.
-  llvm::Expected<lldb_private::HostThread> monitor_thread =
-    Host::StartMonitoringChildProcess(
-      std::bind(&ProcessMonitor::MonitorCallback, this, _1, _2, _3, _4),
-      GetPID(), true);
-  if (!monitor_thread || !monitor_thread->IsJoinable()) {
-    error.SetErrorToGenericError();
-    error.SetErrorString("Process launch failed.");
-    return;
-  }
-  m_monitor_thread = *monitor_thread;
-}
-
-ProcessMonitor::ProcessMonitor(ProcessFreeBSD *process, lldb::pid_t pid,
-                               lldb_private::Status &error)
-    : m_process(static_cast<ProcessFreeBSD *>(process)),
-      m_operation_thread(), m_monitor_thread(), m_pid(pid), m_terminal_fd(-1), m_operation(0) {
-  using namespace std::placeholders;
-
-  sem_init(&m_operation_pending, 0, 0);
-  sem_init(&m_operation_done, 0, 0);
-
-  std::unique_ptr<AttachArgs> args(new AttachArgs(this, pid));
-
-  StartAttachOpThread(args.get(), error);
-  if (!error.Success())
-    return;
-
-  if (llvm::sys::RetryAfterSignal(-1, sem_wait, &args->m_semaphore) == -1) {
-    error.SetErrorToErrno();
-    return;
-  }
-
-  // Check that the attach was a success.
-  if (!args->m_error.Success()) {
-    StopOpThread();
-    error = args->m_error;
-    return;
-  }
-
-  // Finally, start monitoring the child process for change in state.
-  llvm::Expected<lldb_private::HostThread> monitor_thread =
-    Host::StartMonitoringChildProcess(
-      std::bind(&ProcessMonitor::MonitorCallback, this, _1, _2, _3, _4),
-      GetPID(), true);
-  if (!monitor_thread || !monitor_thread->IsJoinable()) {
-    error.SetErrorToGenericError();
-    error.SetErrorString("Process attach failed.");
-    return;
-  }
-  m_monitor_thread = *monitor_thread;
-}
-
-ProcessMonitor::~ProcessMonitor() { StopMonitor(); }
-
-// Thread setup and tear down.
-void ProcessMonitor::StartLaunchOpThread(LaunchArgs *args, Status &error) {
-  static const char *g_thread_name = "freebsd.op";
-
-  if (m_operation_thread && m_operation_thread->IsJoinable())
-    return;
-
-  llvm::Expected<lldb_private::HostThread> operation_thread =
-    ThreadLauncher::LaunchThread(g_thread_name, LaunchOpThread, args);
-  if (operation_thread)
-    m_operation_thread = *operation_thread;
-  else
-    error = operation_thread.takeError();
-}
-
-void *ProcessMonitor::LaunchOpThread(void *arg) {
-  LaunchArgs *args = static_cast<LaunchArgs *>(arg);
-
-  if (!Launch(args)) {
-    sem_post(&args->m_semaphore);
-    return NULL;
-  }
-
-  ServeOperation(args);
-  return NULL;
-}
-
-bool ProcessMonitor::Launch(LaunchArgs *args) {
-  ProcessMonitor *monitor = args->m_monitor;
-  ProcessFreeBSD &process = monitor->GetProcess();
-  const char **argv = args->m_argv;
-  const FileSpec &stdin_file_spec = args->m_stdin_file_spec;
-  const FileSpec &stdout_file_spec = args->m_stdout_file_spec;
-  const FileSpec &stderr_file_spec = args->m_stderr_file_spec;
-  const FileSpec &working_dir = args->m_working_dir;
-
-  PseudoTerminal terminal;
-
-  // Propagate the environment if one is not supplied.
-  Environment::Envp envp =
-      (args->m_env.empty() ? Host::GetEnvironment() : args->m_env).getEnvp();
-
-  llvm::Expected<lldb::pid_t> pid = terminal.Fork();
-  if (!pid) {
-    args->m_error = pid.takeError();
-    goto FINISH;
-  }
-
-  // Recognized child exit status codes.
-  enum {
-    ePtraceFailed = 1,
-    eDupStdinFailed,
-    eDupStdoutFailed,
-    eDupStderrFailed,
-    eChdirFailed,
-    eExecFailed,
-    eSetGidFailed
-  };
-
-  // Child process.
-  if (*pid == 0) {
-    // Trace this process.
-    if (PTRACE(PT_TRACE_ME, 0, NULL, 0) < 0)
-      exit(ePtraceFailed);
-
-    // terminal has already dupped the tty descriptors to stdin/out/err. This
-    // closes original fd from which they were copied (and avoids leaking
-    // descriptors to the debugged process.
-    terminal.CloseSecondaryFileDescriptor();
-
-    // Do not inherit setgid powers.
-    if (setgid(getgid()) != 0)
-      exit(eSetGidFailed);
-
-    // Let us have our own process group.
-    setpgid(0, 0);
-
-    // Dup file descriptors if needed.
-    //
-    // FIXME: If two or more of the paths are the same we needlessly open
-    // the same file multiple times.
-    if (stdin_file_spec)
-      if (!DupDescriptor(stdin_file_spec, STDIN_FILENO, O_RDONLY))
-        exit(eDupStdinFailed);
-
-    if (stdout_file_spec)
-      if (!DupDescriptor(stdout_file_spec, STDOUT_FILENO, O_WRONLY | O_CREAT))
-        exit(eDupStdoutFailed);
-
-    if (stderr_file_spec)
-      if (!DupDescriptor(stderr_file_spec, STDERR_FILENO, O_WRONLY | O_CREAT))
-        exit(eDupStderrFailed);
-
-    // Change working directory
-    if (working_dir && 0 != ::chdir(working_dir.GetCString()))
-      exit(eChdirFailed);
-
-    // Execute.  We should never return.
-    execve(argv[0], const_cast<char *const *>(argv), envp);
-    exit(eExecFailed);
-  }
-
-  // Wait for the child process to to trap on its call to execve.
-  ::pid_t wpid;
-  int status;
-  if ((wpid = waitpid(*pid, &status, 0)) < 0) {
-    args->m_error.SetErrorToErrno();
-    goto FINISH;
-  } else if (WIFEXITED(status)) {
-    // open, dup or execve likely failed for some reason.
-    args->m_error.SetErrorToGenericError();
-    switch (WEXITSTATUS(status)) {
-    case ePtraceFailed:
-      args->m_error.SetErrorString("Child ptrace failed.");
-      break;
-    case eDupStdinFailed:
-      args->m_error.SetErrorString("Child open stdin failed.");
-      break;
-    case eDupStdoutFailed:
-      args->m_error.SetErrorString("Child open stdout failed.");
-      break;
-    case eDupStderrFailed:
-      args->m_error.SetErrorString("Child open stderr failed.");
-      break;
-    case eChdirFailed:
-      args->m_error.SetErrorString("Child failed to set working directory.");
-      break;
-    case eExecFailed:
-      args->m_error.SetErrorString("Child exec failed.");
-      break;
-    case eSetGidFailed:
-      args->m_error.SetErrorString("Child setgid failed.");
-      break;
-    default:
-      args->m_error.SetErrorString("Child returned unknown exit status.");
-      break;
-    }
-    goto FINISH;
-  }
-  assert(WIFSTOPPED(status) && wpid == (::pid_t)*pid &&
-         "Could not sync with inferior process.");
-
-#ifdef notyet
-  // Have the child raise an event on exit.  This is used to keep the child in
-  // limbo until it is destroyed.
-  if (PTRACE(PTRACE_SETOPTIONS, *pid, NULL, PTRACE_O_TRACEEXIT) < 0) {
-    args->m_error.SetErrorToErrno();
-    goto FINISH;
-  }
-#endif
-  // Release the master terminal descriptor and pass it off to the
-  // ProcessMonitor instance.  Similarly stash the inferior pid.
-  monitor->m_terminal_fd = terminal.ReleasePrimaryFileDescriptor();
-  monitor->m_pid = *pid;
-
-  // Set the terminal fd to be in non blocking mode (it simplifies the
-  // implementation of ProcessFreeBSD::GetSTDOUT to have a non-blocking
-  // descriptor to read from).
-  if (!EnsureFDFlags(monitor->m_terminal_fd, O_NONBLOCK, args->m_error))
-    goto FINISH;
-
-  process.SendMessage(ProcessMessage::Attach(*pid));
-
-FINISH:
-  return args->m_error.Success();
-}
-
-void ProcessMonitor::StartAttachOpThread(AttachArgs *args,
-                                         lldb_private::Status &error) {
-  static const char *g_thread_name = "freebsd.op";
-
-  if (m_operation_thread && m_operation_thread->IsJoinable())
-    return;
-
-  llvm::Expected<lldb_private::HostThread> operation_thread =
-    ThreadLauncher::LaunchThread(g_thread_name, AttachOpThread, args);
-  if (operation_thread)
-    m_operation_thread = *operation_thread;
-  else
-    error = operation_thread.takeError();
-}
-
-void *ProcessMonitor::AttachOpThread(void *arg) {
-  AttachArgs *args = static_cast<AttachArgs *>(arg);
-
-  Attach(args);
-
-  ServeOperation(args);
-  return NULL;
-}
-
-void ProcessMonitor::Attach(AttachArgs *args) {
-  lldb::pid_t pid = args->m_pid;
-
-  ProcessMonitor *monitor = args->m_monitor;
-  ProcessFreeBSD &process = monitor->GetProcess();
-
-  if (pid <= 1) {
-    args->m_error.SetErrorToGenericError();
-    args->m_error.SetErrorString("Attaching to process 1 is not allowed.");
-    return;
-  }
-
-  // Attach to the requested process.
-  if (PTRACE(PT_ATTACH, pid, NULL, 0) < 0) {
-    args->m_error.SetErrorToErrno();
-    return;
-  }
-
-  int status;
-  if ((status = waitpid(pid, NULL, 0)) < 0) {
-    args->m_error.SetErrorToErrno();
-    return;
-  }
-
-  process.SendMessage(ProcessMessage::Attach(pid));
-}
-
-size_t
-ProcessMonitor::GetCurrentThreadIDs(std::vector<lldb::tid_t> &thread_ids) {
-  lwpid_t *tids;
-  int tdcnt;
-
-  thread_ids.clear();
-
-  tdcnt = PTRACE(PT_GETNUMLWPS, m_pid, NULL, 0);
-  if (tdcnt <= 0)
-    return 0;
-  tids = (lwpid_t *)malloc(tdcnt * sizeof(*tids));
-  if (tids == NULL)
-    return 0;
-  if (PTRACE(PT_GETLWPLIST, m_pid, (void *)tids, tdcnt) < 0) {
-    free(tids);
-    return 0;
-  }
-  thread_ids = std::vector<lldb::tid_t>(tids, tids + tdcnt);
-  free(tids);
-  return thread_ids.size();
-}
-
-bool ProcessMonitor::MonitorCallback(ProcessMonitor *monitor, lldb::pid_t pid,
-                                     bool exited, int signal, int status) {
-  ProcessMessage message;
-  ProcessFreeBSD *process = monitor->m_process;
-  assert(process);
-  bool stop_monitoring;
-  struct ptrace_lwpinfo plwp;
-  int ptrace_err;
-
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
-
-  if (exited) {
-    LLDB_LOGF(log, "ProcessMonitor::%s() got exit signal, tid = %" PRIu64,
-              __FUNCTION__, pid);
-    message = ProcessMessage::Exit(pid, status);
-    process->SendMessage(message);
-    return pid == process->GetID();
-  }
-
-  if (!monitor->GetLwpInfo(pid, &plwp, ptrace_err))
-    stop_monitoring = true; // pid is gone.  Bail.
-  else {
-    switch (plwp.pl_siginfo.si_signo) {
-    case SIGTRAP:
-      message = MonitorSIGTRAP(monitor, &plwp.pl_siginfo, plwp.pl_lwpid);
-      break;
-
-    default:
-      message = MonitorSignal(monitor, &plwp.pl_siginfo, plwp.pl_lwpid);
-      break;
-    }
-
-    process->SendMessage(message);
-    stop_monitoring = message.GetKind() == ProcessMessage::eExitMessage;
-  }
-
-  return stop_monitoring;
-}
-
-ProcessMessage ProcessMonitor::MonitorSIGTRAP(ProcessMonitor *monitor,
-                                              const siginfo_t *info,
-                                              lldb::tid_t tid) {
-  ProcessMessage message;
-
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
-
-  assert(monitor);
-  assert(info && info->si_signo == SIGTRAP && "Unexpected child signal!");
-
-  switch (info->si_code) {
-  default:
-    assert(false && "Unexpected SIGTRAP code!");
-    break;
-
-  case (SIGTRAP /* | (PTRACE_EVENT_EXIT << 8) */): {
-    // The inferior process is about to exit.  Maintain the process in a state
-    // of "limbo" until we are explicitly commanded to detach, destroy, resume,
-    // etc.
-    unsigned long data = 0;
-    if (!monitor->GetEventMessage(tid, &data))
-      data = -1;
-    LLDB_LOGF(log,
-              "ProcessMonitor::%s() received exit? event, data = %lx, tid "
-              "= %" PRIu64,
-              __FUNCTION__, data, tid);
-    message = ProcessMessage::Limbo(tid, (data >> 8));
-    break;
-  }
-
-  case 0:
-  case TRAP_TRACE:
-#ifdef TRAP_CAP
-  // Map TRAP_CAP to a trace trap in the absense of a more specific handler.
-  case TRAP_CAP:
-#endif
-    LLDB_LOGF(log,
-              "ProcessMonitor::%s() received trace event, tid = %" PRIu64
-              "  : si_code = %d",
-              __FUNCTION__, tid, info->si_code);
-    message = ProcessMessage::Trace(tid);
-    break;
-
-  case SI_KERNEL:
-  case TRAP_BRKPT:
-    if (monitor->m_process->IsSoftwareStepBreakpoint(tid)) {
-      LLDB_LOGF(log,
-                "ProcessMonitor::%s() received sw single step breakpoint "
-                "event, tid = %" PRIu64,
-                __FUNCTION__, tid);
-      message = ProcessMessage::Trace(tid);
-    } else {
-      LLDB_LOGF(
-          log, "ProcessMonitor::%s() received breakpoint event, tid = %" PRIu64,
-          __FUNCTION__, tid);
-      message = ProcessMessage::Break(tid);
-    }
-    break;
-  }
-
-  return message;
-}
-
-ProcessMessage ProcessMonitor::MonitorSignal(ProcessMonitor *monitor,
-                                             const siginfo_t *info,
-                                             lldb::tid_t tid) {
-  ProcessMessage message;
-  int signo = info->si_signo;
-
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
-
-  // POSIX says that process behaviour is undefined after it ignores a SIGFPE,
-  // SIGILL, SIGSEGV, or SIGBUS *unless* that signal was generated by a kill(2)
-  // or raise(3).  Similarly for tgkill(2) on FreeBSD.
-  //
-  // IOW, user generated signals never generate what we consider to be a
-  // "crash".
-  //
-  // Similarly, ACK signals generated by this monitor.
-  if (info->si_code == SI_USER) {
-    LLDB_LOGF(log,
-              "ProcessMonitor::%s() received signal %s with code %s, pid = %d",
-              __FUNCTION__,
-              monitor->m_process->GetUnixSignals()->GetSignalAsCString(signo),
-              "SI_USER", info->si_pid);
-    if (info->si_pid == getpid())
-      return ProcessMessage::SignalDelivered(tid, signo);
-    else
-      return ProcessMessage::Signal(tid, signo);
-  }
-
-  LLDB_LOGF(log, "ProcessMonitor::%s() received signal %s", __FUNCTION__,
-            monitor->m_process->GetUnixSignals()->GetSignalAsCString(signo));
-
-  switch (signo) {
-  case SIGSEGV:
-  case SIGILL:
-  case SIGFPE:
-  case SIGBUS:
-    lldb::addr_t fault_addr = reinterpret_cast<lldb::addr_t>(info->si_addr);
-    const auto reason = GetCrashReason(*info);
-    if (reason != CrashReason::eInvalidCrashReason) {
-      return ProcessMessage::Crash(tid, reason, signo, fault_addr);
-    } // else; Use atleast si_signo info for other si_code
-  }
-
-  // Everything else is "normal" and does not require any special action on our
-  // part.
-  return ProcessMessage::Signal(tid, signo);
-}
-
-void ProcessMonitor::ServeOperation(OperationArgs *args) {
-  ProcessMonitor *monitor = args->m_monitor;
-
-  // We are finised with the arguments and are ready to go.  Sync with the
-  // parent thread and start serving operations on the inferior.
-  sem_post(&args->m_semaphore);
-
-  for (;;) {
-    // wait for next pending operation
-    sem_wait(&monitor->m_operation_pending);
-
-    monitor->m_operation->Execute(monitor);
-
-    // notify calling thread that operation is complete
-    sem_post(&monitor->m_operation_done);
-  }
-}
-
-void ProcessMonitor::DoOperation(Operation *op) {
-  std::lock_guard<std::mutex> guard(m_operation_mutex);
-
-  m_operation = op;
-
-  // notify operation thread that an operation is ready to be processed
-  sem_post(&m_operation_pending);
-
-  // wait for operation to complete
-  sem_wait(&m_operation_done);
-}
-
-size_t ProcessMonitor::ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
-                                  Status &error) {
-  size_t result;
-  ReadOperation op(vm_addr, buf, size, error, result);
-  DoOperation(&op);
-  return result;
-}
-
-size_t ProcessMonitor::WriteMemory(lldb::addr_t vm_addr, const void *buf,
-                                   size_t size, lldb_private::Status &error) {
-  size_t result;
-  WriteOperation op(vm_addr, buf, size, error, result);
-  DoOperation(&op);
-  return result;
-}
-
-bool ProcessMonitor::ReadRegisterValue(lldb::tid_t tid, unsigned offset,
-                                       const char *reg_name, unsigned size,
-                                       RegisterValue &value) {
-  bool result;
-  ReadRegOperation op(tid, offset, size, value, result);
-  DoOperation(&op);
-  return result;
-}
-
-bool ProcessMonitor::WriteRegisterValue(lldb::tid_t tid, unsigned offset,
-                                        const char *reg_name,
-                                        const RegisterValue &value) {
-  bool result;
-  WriteRegOperation op(tid, offset, value, result);
-  DoOperation(&op);
-  return result;
-}
-
-bool ProcessMonitor::ReadDebugRegisterValue(
-    lldb::tid_t tid, unsigned offset, const char *reg_name, unsigned size,
-    lldb_private::RegisterValue &value) {
-  bool result;
-  ReadDebugRegOperation op(tid, offset, size, value, result);
-  DoOperation(&op);
-  return result;
-}
-
-bool ProcessMonitor::WriteDebugRegisterValue(
-    lldb::tid_t tid, unsigned offset, const char *reg_name,
-    const lldb_private::RegisterValue &value) {
-  bool result;
-  WriteDebugRegOperation op(tid, offset, value, result);
-  DoOperation(&op);
-  return result;
-}
-
-bool ProcessMonitor::ReadGPR(lldb::tid_t tid, void *buf, size_t buf_size) {
-  bool result;
-  ReadGPROperation op(tid, buf, result);
-  DoOperation(&op);
-  return result;
-}
-
-bool ProcessMonitor::ReadFPR(lldb::tid_t tid, void *buf, size_t buf_size) {
-  bool result;
-  ReadFPROperation op(tid, buf, result);
-  DoOperation(&op);
-  return result;
-}
-
-bool ProcessMonitor::ReadRegisterSet(lldb::tid_t tid, void *buf,
-                                     size_t buf_size, unsigned int regset) {
-  return false;
-}
-
-bool ProcessMonitor::WriteGPR(lldb::tid_t tid, void *buf, size_t buf_size) {
-  bool result;
-  WriteGPROperation op(tid, buf, result);
-  DoOperation(&op);
-  return result;
-}
-
-bool ProcessMonitor::WriteFPR(lldb::tid_t tid, void *buf, size_t buf_size) {
-  bool result;
-  WriteFPROperation op(tid, buf, result);
-  DoOperation(&op);
-  return result;
-}
-
-bool ProcessMonitor::WriteRegisterSet(lldb::tid_t tid, void *buf,
-                                      size_t buf_size, unsigned int regset) {
-  return false;
-}
-
-bool ProcessMonitor::ReadThreadPointer(lldb::tid_t tid, lldb::addr_t &value) {
-  return false;
-}
-
-bool ProcessMonitor::Resume(lldb::tid_t unused, uint32_t signo) {
-  bool result;
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
-
-  if (log) {
-    const char *signame =
-        m_process->GetUnixSignals()->GetSignalAsCString(signo);
-    if (signame == nullptr)
-      signame = "<none>";
-    LLDB_LOGF(log,
-              "ProcessMonitor::%s() resuming pid %" PRIu64 " with signal %s",
-              __FUNCTION__, GetPID(), signame);
-  }
-  ResumeOperation op(signo, result);
-  DoOperation(&op);
-  LLDB_LOGF(log, "ProcessMonitor::%s() resuming result = %s", __FUNCTION__,
-            result ? "true" : "false");
-  return result;
-}
-
-bool ProcessMonitor::SingleStep(lldb::tid_t unused, uint32_t signo) {
-  bool result;
-  SingleStepOperation op(signo, result);
-  DoOperation(&op);
-  return result;
-}
-
-bool ProcessMonitor::Kill() {
-  bool result;
-  KillOperation op(result);
-  DoOperation(&op);
-  return result;
-}
-
-bool ProcessMonitor::GetLwpInfo(lldb::tid_t tid, void *lwpinfo,
-                                int &ptrace_err) {
-  bool result;
-  LwpInfoOperation op(tid, lwpinfo, result, ptrace_err);
-  DoOperation(&op);
-  return result;
-}
-
-bool ProcessMonitor::ThreadSuspend(lldb::tid_t tid, bool suspend) {
-  bool result;
-  ThreadSuspendOperation op(tid, suspend, result);
-  DoOperation(&op);
-  return result;
-}
-
-bool ProcessMonitor::GetEventMessage(lldb::tid_t tid, unsigned long *message) {
-  bool result;
-  EventMessageOperation op(tid, message, result);
-  DoOperation(&op);
-  return result;
-}
-
-lldb_private::Status ProcessMonitor::Detach(lldb::tid_t tid) {
-  lldb_private::Status error;
-  if (tid != LLDB_INVALID_THREAD_ID) {
-    DetachOperation op(error);
-    DoOperation(&op);
-  }
-  return error;
-}
-
-bool ProcessMonitor::DupDescriptor(const FileSpec &file_spec, int fd,
-                                   int flags) {
-  int target_fd = llvm::sys::RetryAfterSignal(-1, open,
-      file_spec.GetCString(), flags, 0666);
-
-  if (target_fd == -1)
-    return false;
-
-  if (dup2(target_fd, fd) == -1)
-    return false;
-
-  return (close(target_fd) == -1) ? false : true;
-}
-
-void ProcessMonitor::StopMonitoringChildProcess() {
-  if (m_monitor_thread && m_monitor_thread->IsJoinable()) {
-    m_monitor_thread->Cancel();
-    m_monitor_thread->Join(nullptr);
-    m_monitor_thread->Reset();
-  }
-}
-
-void ProcessMonitor::StopMonitor() {
-  StopMonitoringChildProcess();
-  StopOpThread();
-  sem_destroy(&m_operation_pending);
-  sem_destroy(&m_operation_done);
-  if (m_terminal_fd >= 0) {
-    close(m_terminal_fd);
-    m_terminal_fd = -1;
-  }
-}
-
-// FIXME: On Linux, when a new thread is created, we receive to notifications,
-// (1) a SIGTRAP|PTRACE_EVENT_CLONE from the main process thread with the child
-// thread id as additional information, and (2) a SIGSTOP|SI_USER from the new
-// child thread indicating that it has is stopped because we attached. We have
-// no guarantee of the order in which these arrive, but we need both before we
-// are ready to proceed.  We currently keep a list of threads which have sent
-// the initial SIGSTOP|SI_USER event.  Then when we receive the
-// SIGTRAP|PTRACE_EVENT_CLONE notification, if the initial stop has not
-// occurred we call ProcessMonitor::WaitForInitialTIDStop() to wait for it.
-//
-// Right now, the above logic is in ProcessPOSIX, so we need a definition of
-// this function in the FreeBSD ProcessMonitor implementation even if it isn't
-// logically needed.
-//
-// We really should figure out what actually happens on FreeBSD and move the
-// Linux-specific logic out of ProcessPOSIX as needed.
-
-bool ProcessMonitor::WaitForInitialTIDStop(lldb::tid_t tid) { return true; }
-
-void ProcessMonitor::StopOpThread() {
-  if (m_operation_thread && m_operation_thread->IsJoinable()) {
-    m_operation_thread->Cancel();
-    m_operation_thread->Join(nullptr);
-    m_operation_thread->Reset();
-  }
-}
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.h
deleted file mode 100644
index c5edfc0be95a..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.h
+++ /dev/null
@@ -1,279 +0,0 @@
-//===-- ProcessMonitor.h -------------------------------------- -*- C++ -*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_ProcessMonitor_H_
-#define liblldb_ProcessMonitor_H_
-
-#include <semaphore.h>
-#include <signal.h>
-
-#include <mutex>
-
-#include "lldb/Host/HostThread.h"
-#include "lldb/Utility/FileSpec.h"
-#include "lldb/lldb-types.h"
-
-namespace lldb_private {
-class Status;
-class Module;
-class Scalar;
-} // End lldb_private namespace.
-
-class ProcessFreeBSD;
-class Operation;
-
-/// \class ProcessMonitor
-/// Manages communication with the inferior (debugee) process.
-///
-/// Upon construction, this class prepares and launches an inferior process
-/// for debugging.
-///
-/// Changes in the inferior process state are propagated to the associated
-/// ProcessFreeBSD instance by calling ProcessFreeBSD::SendMessage with the
-/// appropriate ProcessMessage events.
-///
-/// A purposely minimal set of operations are provided to interrogate and change
-/// the inferior process state.
-class ProcessMonitor {
-public:
-  /// Launches an inferior process ready for debugging.  Forms the
-  /// implementation of Process::DoLaunch.
-  ProcessMonitor(ProcessFreeBSD *process, lldb_private::Module *module,
-                 char const *argv[], lldb_private::Environment env,
-                 const lldb_private::FileSpec &stdin_file_spec,
-                 const lldb_private::FileSpec &stdout_file_spec,
-                 const lldb_private::FileSpec &stderr_file_spec,
-                 const lldb_private::FileSpec &working_dir,
-                 const lldb_private::ProcessLaunchInfo &launch_info,
-                 lldb_private::Status &error);
-
-  ProcessMonitor(ProcessFreeBSD *process, lldb::pid_t pid,
-                 lldb_private::Status &error);
-
-  ~ProcessMonitor();
-
-  /// Provides the process number of debugee.
-  lldb::pid_t GetPID() const { return m_pid; }
-
-  /// Returns the process associated with this ProcessMonitor.
-  ProcessFreeBSD &GetProcess() { return *m_process; }
-
-  /// Returns a file descriptor to the controlling terminal of the inferior
-  /// process.
-  ///
-  /// Reads from this file descriptor yield both the standard output and
-  /// standard error of this debugee.  Even if stderr and stdout were
-  /// redirected on launch it may still happen that data is available on this
-  /// descriptor (if the inferior process opens /dev/tty, for example). This
-  /// descriptor is closed after a call to StopMonitor().
-  ///
-  /// If this monitor was attached to an existing process this method returns
-  /// -1.
-  int GetTerminalFD() const { return m_terminal_fd; }
-
-  /// Reads \p size bytes from address @vm_adder in the inferior process
-  /// address space.
-  ///
-  /// This method is provided to implement Process::DoReadMemory.
-  size_t ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
-                    lldb_private::Status &error);
-
-  /// Writes \p size bytes from address \p vm_adder in the inferior process
-  /// address space.
-  ///
-  /// This method is provided to implement Process::DoWriteMemory.
-  size_t WriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size,
-                     lldb_private::Status &error);
-
-  /// Reads the contents from the register identified by the given
-  /// (architecture dependent) offset.
-  ///
-  /// This method is provided for use by RegisterContextFreeBSD derivatives.
-  bool ReadRegisterValue(lldb::tid_t tid, unsigned offset, const char *reg_name,
-                         unsigned size, lldb_private::RegisterValue &value);
-
-  /// Writes the given value to the register identified by the given
-  /// (architecture dependent) offset.
-  ///
-  /// This method is provided for use by RegisterContextFreeBSD derivatives.
-  bool WriteRegisterValue(lldb::tid_t tid, unsigned offset,
-                          const char *reg_name,
-                          const lldb_private::RegisterValue &value);
-
-  /// Reads the contents from the debug register identified by the given
-  /// (architecture dependent) offset.
-  ///
-  /// This method is provided for use by RegisterContextFreeBSD derivatives.
-  bool ReadDebugRegisterValue(lldb::tid_t tid, unsigned offset,
-                              const char *reg_name, unsigned size,
-                              lldb_private::RegisterValue &value);
-
-  /// Writes the given value to the debug register identified by the given
-  /// (architecture dependent) offset.
-  ///
-  /// This method is provided for use by RegisterContextFreeBSD derivatives.
-  bool WriteDebugRegisterValue(lldb::tid_t tid, unsigned offset,
-                               const char *reg_name,
-                               const lldb_private::RegisterValue &value);
-  /// Reads all general purpose registers into the specified buffer.
-  bool ReadGPR(lldb::tid_t tid, void *buf, size_t buf_size);
-
-  /// Reads all floating point registers into the specified buffer.
-  bool ReadFPR(lldb::tid_t tid, void *buf, size_t buf_size);
-
-  /// Reads the specified register set into the specified buffer.
-  ///
-  /// This method is provided for use by RegisterContextFreeBSD derivatives.
-  bool ReadRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size,
-                       unsigned int regset);
-
-  /// Writes all general purpose registers into the specified buffer.
-  bool WriteGPR(lldb::tid_t tid, void *buf, size_t buf_size);
-
-  /// Writes all floating point registers into the specified buffer.
-  bool WriteFPR(lldb::tid_t tid, void *buf, size_t buf_size);
-
-  /// Writes the specified register set into the specified buffer.
-  ///
-  /// This method is provided for use by RegisterContextFreeBSD derivatives.
-  bool WriteRegisterSet(lldb::tid_t tid, void *buf, size_t buf_size,
-                        unsigned int regset);
-
-  /// Reads the value of the thread-specific pointer for a given thread ID.
-  bool ReadThreadPointer(lldb::tid_t tid, lldb::addr_t &value);
-
-  /// Returns current thread IDs in process
-  size_t GetCurrentThreadIDs(std::vector<lldb::tid_t> &thread_ids);
-
-  /// Writes a ptrace_lwpinfo structure corresponding to the given thread ID
-  /// to the memory region pointed to by \p lwpinfo.
-  bool GetLwpInfo(lldb::tid_t tid, void *lwpinfo, int &error_no);
-
-  /// Suspends or unsuspends a thread prior to process resume or step.
-  bool ThreadSuspend(lldb::tid_t tid, bool suspend);
-
-  /// Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG)
-  /// corresponding to the given thread IDto the memory pointed to by @p
-  /// message.
-  bool GetEventMessage(lldb::tid_t tid, unsigned long *message);
-
-  /// Resumes the process.  If \p signo is anything but
-  /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the process.
-  bool Resume(lldb::tid_t unused, uint32_t signo);
-
-  /// Single steps the process.  If \p signo is anything but
-  /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the process.
-  bool SingleStep(lldb::tid_t unused, uint32_t signo);
-
-  /// Terminate the traced process.
-  bool Kill();
-
-  lldb_private::Status Detach(lldb::tid_t tid);
-
-  void StopMonitor();
-
-  // Waits for the initial stop message from a new thread.
-  bool WaitForInitialTIDStop(lldb::tid_t tid);
-
-private:
-  ProcessFreeBSD *m_process;
-
-  llvm::Optional<lldb_private::HostThread> m_operation_thread;
-  llvm::Optional<lldb_private::HostThread> m_monitor_thread;
-  lldb::pid_t m_pid;
-
-  int m_terminal_fd;
-
-  // current operation which must be executed on the privileged thread
-  Operation *m_operation;
-  std::mutex m_operation_mutex;
-
-  // semaphores notified when Operation is ready to be processed and when
-  // the operation is complete.
-  sem_t m_operation_pending;
-  sem_t m_operation_done;
-
-  struct OperationArgs {
-    OperationArgs(ProcessMonitor *monitor);
-
-    ~OperationArgs();
-
-    ProcessMonitor *m_monitor;   // The monitor performing the attach.
-    sem_t m_semaphore;           // Posted to once operation complete.
-    lldb_private::Status m_error; // Set if process operation failed.
-  };
-
-  /// \class LauchArgs
-  ///
-  /// Simple structure to pass data to the thread responsible for launching a
-  /// child process.
-  struct LaunchArgs : OperationArgs {
-    LaunchArgs(ProcessMonitor *monitor, lldb_private::Module *module,
-               char const **argv, lldb_private::Environment env,
-               const lldb_private::FileSpec &stdin_file_spec,
-               const lldb_private::FileSpec &stdout_file_spec,
-               const lldb_private::FileSpec &stderr_file_spec,
-               const lldb_private::FileSpec &working_dir);
-
-    ~LaunchArgs();
-
-    lldb_private::Module *m_module; // The executable image to launch.
-    char const **m_argv;            // Process arguments.
-    lldb_private::Environment m_env;                // Process environment.
-    const lldb_private::FileSpec m_stdin_file_spec; // Redirect stdin or empty.
-    const lldb_private::FileSpec
-        m_stdout_file_spec; // Redirect stdout or empty.
-    const lldb_private::FileSpec
-        m_stderr_file_spec;                     // Redirect stderr or empty.
-    const lldb_private::FileSpec m_working_dir; // Working directory or empty.
-  };
-
-  void StartLaunchOpThread(LaunchArgs *args, lldb_private::Status &error);
-
-  static void *LaunchOpThread(void *arg);
-
-  static bool Launch(LaunchArgs *args);
-
-  struct AttachArgs : OperationArgs {
-    AttachArgs(ProcessMonitor *monitor, lldb::pid_t pid);
-
-    ~AttachArgs();
-
-    lldb::pid_t m_pid; // pid of the process to be attached.
-  };
-
-  void StartAttachOpThread(AttachArgs *args, lldb_private::Status &error);
-
-  static void *AttachOpThread(void *args);
-
-  static void Attach(AttachArgs *args);
-
-  static void ServeOperation(OperationArgs *args);
-
-  static bool DupDescriptor(const lldb_private::FileSpec &file_spec, int fd,
-                            int flags);
-
-  static bool MonitorCallback(ProcessMonitor *monitor, lldb::pid_t pid,
-                              bool exited, int signal, int status);
-
-  static ProcessMessage MonitorSIGTRAP(ProcessMonitor *monitor,
-                                       const siginfo_t *info, lldb::pid_t pid);
-
-  static ProcessMessage MonitorSignal(ProcessMonitor *monitor,
-                                      const siginfo_t *info, lldb::pid_t pid);
-
-  void DoOperation(Operation *op);
-
-  /// Stops the child monitor thread.
-  void StopMonitoringChildProcess();
-
-  /// Stops the operation thread used to attach/launch a process.
-  void StopOpThread();
-};
-
-#endif // #ifndef liblldb_ProcessMonitor_H_
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIX.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIX.h
deleted file mode 100644
index cf52a065232c..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIX.h
+++ /dev/null
@@ -1,63 +0,0 @@
-//===-- RegisterContextPOSIX.h --------------------------------*- C++ -*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_RegisterContextPOSIX_H_
-#define liblldb_RegisterContextPOSIX_H_
-
-#include "Plugins/Process/Utility/RegisterInfoInterface.h"
-#include "lldb/Target/RegisterContext.h"
-#include "lldb/Utility/ArchSpec.h"
-
-/// \class POSIXBreakpointProtocol
-///
-/// Extends RegisterClass with a few virtual operations useful on POSIX.
-class POSIXBreakpointProtocol {
-public:
-  POSIXBreakpointProtocol() { m_watchpoints_initialized = false; }
-  virtual ~POSIXBreakpointProtocol() {}
-
-  /// Updates the register state of the associated thread after hitting a
-  /// breakpoint (if that make sense for the architecture).  Default
-  /// implementation simply returns true for architectures which do not
-  /// require any update.
-  ///
-  /// \return
-  ///    True if the operation succeeded and false otherwise.
-  virtual bool UpdateAfterBreakpoint() = 0;
-
-  /// Determines the index in lldb's register file given a kernel byte offset.
-  virtual unsigned GetRegisterIndexFromOffset(unsigned offset) = 0;
-
-  // Checks to see if a watchpoint specified by hw_index caused the inferior
-  // to stop.
-  virtual bool IsWatchpointHit(uint32_t hw_index) = 0;
-
-  // Resets any watchpoints that have been hit.
-  virtual bool ClearWatchpointHits() = 0;
-
-  // Returns the watchpoint address associated with a watchpoint hardware
-  // index.
-  virtual lldb::addr_t GetWatchpointAddress(uint32_t hw_index) = 0;
-
-  virtual bool IsWatchpointVacant(uint32_t hw_index) = 0;
-
-  virtual bool SetHardwareWatchpointWithIndex(lldb::addr_t addr, size_t size,
-                                              bool read, bool write,
-                                              uint32_t hw_index) = 0;
-
-  // From lldb_private::RegisterContext
-  virtual uint32_t NumSupportedHardwareWatchpoints() = 0;
-
-  // Force m_watchpoints_initialized to TRUE
-  void ForceWatchpointsInitialized() { m_watchpoints_initialized = true; }
-
-protected:
-  bool m_watchpoints_initialized;
-};
-
-#endif // #ifndef liblldb_RegisterContextPOSIX_H_
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm.cpp
deleted file mode 100644
index afb92e848466..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm.cpp
+++ /dev/null
@@ -1,260 +0,0 @@
-//===-- RegisterContextPOSIXProcessMonitor_arm.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 "lldb/Target/Thread.h"
-#include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/RegisterValue.h"
-
-#include "ProcessFreeBSD.h"
-#include "ProcessMonitor.h"
-#include "RegisterContextPOSIXProcessMonitor_arm.h"
-#include "Plugins/Process/Utility/RegisterContextPOSIX_arm.h"
-#include "Plugins/Process/Utility/lldb-arm-register-enums.h"
-
-using namespace lldb_private;
-using namespace lldb;
-
-#define REG_CONTEXT_SIZE (GetGPRSize())
-
-RegisterContextPOSIXProcessMonitor_arm::RegisterContextPOSIXProcessMonitor_arm(
-    lldb_private::Thread &thread,
-    std::unique_ptr<RegisterInfoPOSIX_arm> register_info)
-    : RegisterContextPOSIX_arm(thread, std::move(register_info)) {}
-
-ProcessMonitor &RegisterContextPOSIXProcessMonitor_arm::GetMonitor() {
-  ProcessSP base = CalculateProcess();
-  ProcessFreeBSD *process = static_cast<ProcessFreeBSD *>(base.get());
-  return process->GetMonitor();
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::ReadGPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.ReadGPR(m_thread.GetID(), &m_gpr_arm, GetGPRSize());
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::ReadFPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.ReadFPR(m_thread.GetID(), &m_fpr, sizeof(m_fpr));
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::WriteGPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.WriteGPR(m_thread.GetID(), &m_gpr_arm, GetGPRSize());
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::WriteFPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.WriteFPR(m_thread.GetID(), &m_fpr, sizeof(m_fpr));
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::ReadRegister(
-    const unsigned reg, RegisterValue &value) {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.ReadRegisterValue(m_thread.GetID(), GetRegisterOffset(reg),
-                                   GetRegisterName(reg), GetRegisterSize(reg),
-                                   value);
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::WriteRegister(
-    const unsigned reg, const RegisterValue &value) {
-  unsigned reg_to_write = reg;
-  RegisterValue value_to_write = value;
-
-  // Check if this is a subregister of a full register.
-  const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
-  if (reg_info->invalidate_regs &&
-      (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM)) {
-    RegisterValue full_value;
-    uint32_t full_reg = reg_info->invalidate_regs[0];
-    const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg);
-
-    // Read the full register.
-    if (ReadRegister(full_reg_info, full_value)) {
-      Status error;
-      ByteOrder byte_order = GetByteOrder();
-      uint8_t dst[RegisterValue::kMaxRegisterByteSize];
-
-      // Get the bytes for the full register.
-      const uint32_t dest_size = full_value.GetAsMemoryData(
-          full_reg_info, dst, sizeof(dst), byte_order, error);
-      if (error.Success() && dest_size) {
-        uint8_t src[RegisterValue::kMaxRegisterByteSize];
-
-        // Get the bytes for the source data.
-        const uint32_t src_size = value.GetAsMemoryData(
-            reg_info, src, sizeof(src), byte_order, error);
-        if (error.Success() && src_size && (src_size < dest_size)) {
-          // Copy the src bytes to the destination.
-          memcpy(dst + (reg_info->byte_offset & 0x1), src, src_size);
-          // Set this full register as the value to write.
-          value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
-          value_to_write.SetType(full_reg_info);
-          reg_to_write = full_reg;
-        }
-      }
-    }
-  }
-
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.WriteRegisterValue(
-      m_thread.GetID(), GetRegisterOffset(reg_to_write),
-      GetRegisterName(reg_to_write), value_to_write);
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::ReadRegister(
-    const RegisterInfo *reg_info, RegisterValue &value) {
-  if (!reg_info)
-    return false;
-
-  const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
-
-  if (IsFPR(reg)) {
-    if (!ReadFPR())
-      return false;
-  } else {
-    return ReadRegister(reg, value);
-  }
-
-  // Get pointer to m_fpr variable and set the data from it.
-  assert(reg_info->byte_offset < sizeof m_fpr);
-  uint8_t *src = (uint8_t *)&m_fpr + reg_info->byte_offset;
-  switch (reg_info->byte_size) {
-  case 2:
-    value.SetUInt16(*(uint16_t *)src);
-    return true;
-  case 4:
-    value.SetUInt32(*(uint32_t *)src);
-    return true;
-  case 8:
-    value.SetUInt64(*(uint64_t *)src);
-    return true;
-  default:
-    assert(false && "Unhandled data size.");
-    return false;
-  }
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::WriteRegister(
-    const RegisterInfo *reg_info, const RegisterValue &value) {
-  const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
-
-  if (IsGPR(reg)) {
-    return WriteRegister(reg, value);
-  } else if (IsFPR(reg)) {
-    return WriteFPR();
-  }
-
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::ReadAllRegisterValues(
-    DataBufferSP &data_sp) {
-  bool success = false;
-  data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
-  if (ReadGPR() && ReadFPR()) {
-    uint8_t *dst = data_sp->GetBytes();
-    success = dst != 0;
-
-    if (success) {
-      ::memcpy(dst, &m_gpr_arm, GetGPRSize());
-      dst += GetGPRSize();
-      ::memcpy(dst, &m_fpr, sizeof(m_fpr));
-    }
-  }
-  return success;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::WriteAllRegisterValues(
-    const DataBufferSP &data_sp) {
-  bool success = false;
-  if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) {
-    uint8_t *src = data_sp->GetBytes();
-    if (src) {
-      ::memcpy(&m_gpr_arm, src, GetGPRSize());
-
-      if (WriteGPR()) {
-        src += GetGPRSize();
-        ::memcpy(&m_fpr, src, sizeof(m_fpr));
-
-        success = WriteFPR();
-      }
-    }
-  }
-  return success;
-}
-
-uint32_t RegisterContextPOSIXProcessMonitor_arm::SetHardwareWatchpoint(
-    addr_t addr, size_t size, bool read, bool write) {
-  const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
-  uint32_t hw_index;
-
-  for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index) {
-    if (IsWatchpointVacant(hw_index))
-      return SetHardwareWatchpointWithIndex(addr, size, read, write, hw_index);
-  }
-
-  return LLDB_INVALID_INDEX32;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::ClearHardwareWatchpoint(
-    uint32_t hw_index) {
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::HardwareSingleStep(bool enable) {
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::UpdateAfterBreakpoint() {
-  lldb::addr_t pc;
-
-  if ((pc = GetPC()) == LLDB_INVALID_ADDRESS)
-    return false;
-
-  return true;
-}
-
-unsigned RegisterContextPOSIXProcessMonitor_arm::GetRegisterIndexFromOffset(
-    unsigned offset) {
-  unsigned reg;
-  for (reg = 0; reg < k_num_registers_arm; reg++) {
-    if (GetRegisterInfo()[reg].byte_offset == offset)
-      break;
-  }
-  assert(reg < k_num_registers_arm && "Invalid register offset.");
-  return reg;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::IsWatchpointHit(
-    uint32_t hw_index) {
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::ClearWatchpointHits() {
-  return false;
-}
-
-addr_t RegisterContextPOSIXProcessMonitor_arm::GetWatchpointAddress(
-    uint32_t hw_index) {
-  return LLDB_INVALID_ADDRESS;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::IsWatchpointVacant(
-    uint32_t hw_index) {
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm::SetHardwareWatchpointWithIndex(
-    addr_t addr, size_t size, bool read, bool write, uint32_t hw_index) {
-  return false;
-}
-
-uint32_t
-RegisterContextPOSIXProcessMonitor_arm::NumSupportedHardwareWatchpoints() {
-  return 0;
-}
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm.h
deleted file mode 100644
index bb455841dff1..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm.h
+++ /dev/null
@@ -1,80 +0,0 @@
-//===-- RegisterContextPOSIXProcessMonitor_arm.h --------------*- C++ -*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_RegisterContextPOSIXProcessMonitor_arm_H_
-#define liblldb_RegisterContextPOSIXProcessMonitor_arm_H_
-
-#include "Plugins/Process/Utility/RegisterContextPOSIX_arm.h"
-#include "RegisterContextPOSIX.h"
-
-class RegisterContextPOSIXProcessMonitor_arm : public RegisterContextPOSIX_arm,
-                                               public POSIXBreakpointProtocol {
-public:
-  RegisterContextPOSIXProcessMonitor_arm(
-      lldb_private::Thread &thread,
-      std::unique_ptr<RegisterInfoPOSIX_arm> register_info);
-
-protected:
-  bool ReadGPR() override;
-
-  bool ReadFPR() override;
-
-  bool WriteGPR() override;
-
-  bool WriteFPR() override;
-
-  // lldb_private::RegisterContext
-  bool ReadRegister(const unsigned reg, lldb_private::RegisterValue &value);
-
-  bool WriteRegister(const unsigned reg,
-                     const lldb_private::RegisterValue &value);
-
-  bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
-                    lldb_private::RegisterValue &value) override;
-
-  bool WriteRegister(const lldb_private::RegisterInfo *reg_info,
-                     const lldb_private::RegisterValue &value) override;
-
-  bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
-
-  bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
-
-  uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read,
-                                 bool write) override;
-
-  bool ClearHardwareWatchpoint(uint32_t hw_index) override;
-
-  bool HardwareSingleStep(bool enable) override;
-
-  // POSIXBreakpointProtocol
-  bool UpdateAfterBreakpoint() override;
-
-  unsigned GetRegisterIndexFromOffset(unsigned offset) override;
-
-  bool IsWatchpointHit(uint32_t hw_index) override;
-
-  bool ClearWatchpointHits() override;
-
-  lldb::addr_t GetWatchpointAddress(uint32_t hw_index) override;
-
-  bool IsWatchpointVacant(uint32_t hw_index) override;
-
-  bool SetHardwareWatchpointWithIndex(lldb::addr_t addr, size_t size, bool read,
-                                      bool write, uint32_t hw_index) override;
-
-  uint32_t NumSupportedHardwareWatchpoints() override;
-
-private:
-  RegisterInfoPOSIX_arm::GPR m_gpr_arm;
-
-  RegisterInfoPOSIX_arm::FPU m_fpr;
-
-  ProcessMonitor &GetMonitor();
-};
-
-#endif
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm64.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm64.cpp
deleted file mode 100644
index 39ae0b9b9e7f..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm64.cpp
+++ /dev/null
@@ -1,267 +0,0 @@
-//===-- RegisterContextPOSIXProcessMonitor_arm64.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 "lldb/Target/Thread.h"
-#include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/RegisterValue.h"
-
-#include "Plugins/Process/Utility/RegisterContextPOSIX_arm64.h"
-#include "ProcessFreeBSD.h"
-#include "ProcessMonitor.h"
-#include "RegisterContextPOSIXProcessMonitor_arm64.h"
-
-#define REG_CONTEXT_SIZE (GetGPRSize())
-
-using namespace lldb;
-using namespace lldb_private;
-
-RegisterContextPOSIXProcessMonitor_arm64::
-    RegisterContextPOSIXProcessMonitor_arm64(
-        lldb_private::Thread &thread,
-        std::unique_ptr<RegisterInfoPOSIX_arm64> register_info)
-    : RegisterContextPOSIX_arm64(thread, std::move(register_info)) {
-  ::memset(&m_gpr_arm64, 0, sizeof m_gpr_arm64);
-  ::memset(&m_fpr, 0, sizeof m_fpr);
-}
-
-ProcessMonitor &RegisterContextPOSIXProcessMonitor_arm64::GetMonitor() {
-  lldb::ProcessSP base = CalculateProcess();
-  ProcessFreeBSD *process = static_cast<ProcessFreeBSD *>(base.get());
-  return process->GetMonitor();
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::ReadGPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.ReadGPR(m_thread.GetID(), &m_gpr_arm64, GetGPRSize());
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::ReadFPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.ReadFPR(m_thread.GetID(), &m_fpr, sizeof m_fpr);
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::WriteGPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.WriteGPR(m_thread.GetID(), &m_gpr_arm64, GetGPRSize());
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::WriteFPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.WriteFPR(m_thread.GetID(), &m_fpr, sizeof m_fpr);
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::ReadRegister(
-    const unsigned reg, lldb_private::RegisterValue &value) {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.ReadRegisterValue(m_thread.GetID(), GetRegisterOffset(reg),
-                                   GetRegisterName(reg), GetRegisterSize(reg),
-                                   value);
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::WriteRegister(
-    const unsigned reg, const lldb_private::RegisterValue &value) {
-  unsigned reg_to_write = reg;
-  lldb_private::RegisterValue value_to_write = value;
-
-  // Check if this is a subregister of a full register.
-  const lldb_private::RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
-  if (reg_info->invalidate_regs &&
-      (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM)) {
-    lldb_private::RegisterValue full_value;
-    uint32_t full_reg = reg_info->invalidate_regs[0];
-    const lldb_private::RegisterInfo *full_reg_info =
-        GetRegisterInfoAtIndex(full_reg);
-
-    // Read the full register.
-    if (ReadRegister(full_reg_info, full_value)) {
-      lldb_private::Status error;
-      lldb::ByteOrder byte_order = GetByteOrder();
-      uint8_t dst[lldb_private::RegisterValue::kMaxRegisterByteSize];
-
-      // Get the bytes for the full register.
-      const uint32_t dest_size = full_value.GetAsMemoryData(
-          full_reg_info, dst, sizeof(dst), byte_order, error);
-      if (error.Success() && dest_size) {
-        uint8_t src[lldb_private::RegisterValue::kMaxRegisterByteSize];
-
-        // Get the bytes for the source data.
-        const uint32_t src_size = value.GetAsMemoryData(
-            reg_info, src, sizeof(src), byte_order, error);
-        if (error.Success() && src_size && (src_size < dest_size)) {
-          // Copy the src bytes to the destination.
-          ::memcpy(dst + (reg_info->byte_offset & 0x1), src, src_size);
-          // Set this full register as the value to write.
-          value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
-          value_to_write.SetType(full_reg_info);
-          reg_to_write = full_reg;
-        }
-      }
-    }
-  }
-
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.WriteRegisterValue(
-      m_thread.GetID(), GetRegisterOffset(reg_to_write),
-      GetRegisterName(reg_to_write), value_to_write);
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::ReadRegister(
-    const lldb_private::RegisterInfo *reg_info,
-    lldb_private::RegisterValue &value) {
-  if (!reg_info)
-    return false;
-
-  const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
-
-  if (IsFPR(reg)) {
-    if (!ReadFPR())
-      return false;
-  } else {
-    uint32_t full_reg = reg;
-    bool is_subreg = reg_info->invalidate_regs &&
-                     (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM);
-
-    if (is_subreg) {
-      // Read the full aligned 64-bit register.
-      full_reg = reg_info->invalidate_regs[0];
-    }
-    return ReadRegister(full_reg, value);
-  }
-
-  // Get pointer to m_fpr variable and set the data from it.
-  assert(reg_info->byte_offset < sizeof m_fpr);
-  uint8_t *src = (uint8_t *)&m_fpr + reg_info->byte_offset;
-  switch (reg_info->byte_size) {
-  case 2:
-    value.SetUInt16(*(uint16_t *)src);
-    return true;
-  case 4:
-    value.SetUInt32(*(uint32_t *)src);
-    return true;
-  case 8:
-    value.SetUInt64(*(uint64_t *)src);
-    return true;
-  default:
-    assert(false && "Unhandled data size.");
-    return false;
-  }
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::WriteRegister(
-    const lldb_private::RegisterInfo *reg_info,
-    const lldb_private::RegisterValue &value) {
-  const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB];
-
-  if (IsGPR(reg))
-    return WriteRegister(reg, value);
-
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::ReadAllRegisterValues(
-    lldb::DataBufferSP &data_sp) {
-  bool success = false;
-  data_sp.reset(new lldb_private::DataBufferHeap(REG_CONTEXT_SIZE, 0));
-  if (ReadGPR() && ReadFPR()) {
-    uint8_t *dst = data_sp->GetBytes();
-    success = dst != 0;
-
-    if (success) {
-      ::memcpy(dst, &m_gpr_arm64, GetGPRSize());
-      dst += GetGPRSize();
-      ::memcpy(dst, &m_fpr, sizeof m_fpr);
-    }
-  }
-  return success;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::WriteAllRegisterValues(
-    const lldb::DataBufferSP &data_sp) {
-  bool success = false;
-  if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) {
-    uint8_t *src = data_sp->GetBytes();
-    if (src) {
-      ::memcpy(&m_gpr_arm64, src, GetGPRSize());
-      if (WriteGPR()) {
-        src += GetGPRSize();
-        ::memcpy(&m_fpr, src, sizeof m_fpr);
-        success = WriteFPR();
-      }
-    }
-  }
-  return success;
-}
-
-uint32_t RegisterContextPOSIXProcessMonitor_arm64::SetHardwareWatchpoint(
-    lldb::addr_t addr, size_t size, bool read, bool write) {
-  const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
-  uint32_t hw_index;
-
-  for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index) {
-    if (IsWatchpointVacant(hw_index))
-      return SetHardwareWatchpointWithIndex(addr, size, read, write, hw_index);
-  }
-
-  return LLDB_INVALID_INDEX32;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::ClearHardwareWatchpoint(
-    uint32_t hw_index) {
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::HardwareSingleStep(bool enable) {
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::UpdateAfterBreakpoint() {
-  if (GetPC() == LLDB_INVALID_ADDRESS)
-    return false;
-
-  return true;
-}
-
-unsigned RegisterContextPOSIXProcessMonitor_arm64::GetRegisterIndexFromOffset(
-    unsigned offset) {
-  unsigned reg;
-  for (reg = 0; reg < GetRegisterCount(); reg++) {
-    if (GetRegisterInfo()[reg].byte_offset == offset)
-      break;
-  }
-  assert(reg < GetRegisterCount() && "Invalid register offset.");
-  return reg;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::IsWatchpointHit(
-    uint32_t hw_index) {
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::ClearWatchpointHits() {
-  return false;
-}
-
-lldb::addr_t RegisterContextPOSIXProcessMonitor_arm64::GetWatchpointAddress(
-    uint32_t hw_index) {
-  return LLDB_INVALID_ADDRESS;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::IsWatchpointVacant(
-    uint32_t hw_index) {
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_arm64::SetHardwareWatchpointWithIndex(
-    lldb::addr_t addr, size_t size, bool read, bool write, uint32_t hw_index) {
-  return false;
-}
-
-uint32_t
-RegisterContextPOSIXProcessMonitor_arm64::NumSupportedHardwareWatchpoints() {
-  return 0;
-}
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm64.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm64.h
deleted file mode 100644
index dcae1d46de9b..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_arm64.h
+++ /dev/null
@@ -1,82 +0,0 @@
-//===-- RegisterContextPOSIXProcessMonitor_arm64.h --------------*- C++ -*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_RegisterContextPOSIXProcessMonitor_arm64_H_
-#define liblldb_RegisterContextPOSIXProcessMonitor_arm64_H_
-
-#include "Plugins/Process/Utility/RegisterContextPOSIX_arm64.h"
-#include "RegisterContextPOSIX.h"
-
-class RegisterContextPOSIXProcessMonitor_arm64
-    : public RegisterContextPOSIX_arm64,
-      public POSIXBreakpointProtocol {
-public:
-  RegisterContextPOSIXProcessMonitor_arm64(
-      lldb_private::Thread &thread,
-      std::unique_ptr<RegisterInfoPOSIX_arm64> register_info);
-
-protected:
-  bool ReadGPR() override;
-
-  bool ReadFPR() override;
-
-  bool WriteGPR() override;
-
-  bool WriteFPR() override;
-
-  // lldb_private::RegisterContext
-  bool ReadRegister(const unsigned reg, lldb_private::RegisterValue &value);
-
-  bool WriteRegister(const unsigned reg,
-                     const lldb_private::RegisterValue &value);
-
-  bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
-                    lldb_private::RegisterValue &value) override;
-
-  bool WriteRegister(const lldb_private::RegisterInfo *reg_info,
-                     const lldb_private::RegisterValue &value) override;
-
-  bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
-
-  bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
-
-  uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read,
-                                 bool write) override;
-
-  bool ClearHardwareWatchpoint(uint32_t hw_index) override;
-
-  bool HardwareSingleStep(bool enable) override;
-
-  // POSIXBreakpointProtocol
-  bool UpdateAfterBreakpoint() override;
-
-  unsigned GetRegisterIndexFromOffset(unsigned offset) override;
-
-  bool IsWatchpointHit(uint32_t hw_index) override;
-
-  bool ClearWatchpointHits() override;
-
-  lldb::addr_t GetWatchpointAddress(uint32_t hw_index) override;
-
-  bool IsWatchpointVacant(uint32_t hw_index) override;
-
-  bool SetHardwareWatchpointWithIndex(lldb::addr_t addr, size_t size, bool read,
-                                      bool write, uint32_t hw_index) override;
-
-  uint32_t NumSupportedHardwareWatchpoints() override;
-
-private:
-  RegisterInfoPOSIX_arm64::GPR m_gpr_arm64; // 64-bit general purpose registers.
-
-  RegisterInfoPOSIX_arm64::FPU
-      m_fpr; // floating-point registers including extended register sets.
-
-  ProcessMonitor &GetMonitor();
-};
-
-#endif
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_mips64.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_mips64.cpp
deleted file mode 100644
index 23c76f234c8e..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_mips64.cpp
+++ /dev/null
@@ -1,262 +0,0 @@
-//===-- RegisterContextPOSIXProcessMonitor_mips64.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 "lldb/Target/Thread.h"
-#include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/RegisterValue.h"
-
-#include "Plugins/Process/Utility/RegisterContextPOSIX_mips64.h"
-#include "ProcessFreeBSD.h"
-#include "ProcessMonitor.h"
-#include "RegisterContextPOSIXProcessMonitor_mips64.h"
-
-using namespace lldb_private;
-using namespace lldb;
-
-#define REG_CONTEXT_SIZE (GetGPRSize())
-
-RegisterContextPOSIXProcessMonitor_mips64::
-    RegisterContextPOSIXProcessMonitor_mips64(
-        Thread &thread, uint32_t concrete_frame_idx,
-        lldb_private::RegisterInfoInterface *register_info)
-    : RegisterContextPOSIX_mips64(thread, concrete_frame_idx, register_info) {}
-
-ProcessMonitor &RegisterContextPOSIXProcessMonitor_mips64::GetMonitor() {
-  ProcessSP base = CalculateProcess();
-  ProcessFreeBSD *process = static_cast<ProcessFreeBSD *>(base.get());
-  return process->GetMonitor();
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::ReadGPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.ReadGPR(m_thread.GetID(), &m_gpr_mips64, GetGPRSize());
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::ReadFPR() {
-  // XXX not yet implemented
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::WriteGPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.WriteGPR(m_thread.GetID(), &m_gpr_mips64, GetGPRSize());
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::WriteFPR() {
-  // XXX not yet implemented
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::ReadRegister(
-    const unsigned reg, RegisterValue &value) {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.ReadRegisterValue(m_thread.GetID(), GetRegisterOffset(reg),
-                                   GetRegisterName(reg), GetRegisterSize(reg),
-                                   value);
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::WriteRegister(
-    const unsigned reg, const RegisterValue &value) {
-  unsigned reg_to_write = reg;
-  RegisterValue value_to_write = value;
-
-  // Check if this is a subregister of a full register.
-  const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
-  if (reg_info->invalidate_regs &&
-      (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM)) {
-    RegisterValue full_value;
-    uint32_t full_reg = reg_info->invalidate_regs[0];
-    const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg);
-
-    // Read the full register.
-    if (ReadRegister(full_reg_info, full_value)) {
-      Status error;
-      ByteOrder byte_order = GetByteOrder();
-      uint8_t dst[RegisterValue::kMaxRegisterByteSize];
-
-      // Get the bytes for the full register.
-      const uint32_t dest_size = full_value.GetAsMemoryData(
-          full_reg_info, dst, sizeof(dst), byte_order, error);
-      if (error.Success() && dest_size) {
-        uint8_t src[RegisterValue::kMaxRegisterByteSize];
-
-        // Get the bytes for the source data.
-        const uint32_t src_size = value.GetAsMemoryData(
-            reg_info, src, sizeof(src), byte_order, error);
-        if (error.Success() && src_size && (src_size < dest_size)) {
-          // Copy the src bytes to the destination.
-          memcpy(dst + (reg_info->byte_offset & 0x1), src, src_size);
-          // Set this full register as the value to write.
-          value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
-          value_to_write.SetType(full_reg_info);
-          reg_to_write = full_reg;
-        }
-      }
-    }
-  }
-
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.WriteRegisterValue(
-      m_thread.GetID(), GetRegisterOffset(reg_to_write),
-      GetRegisterName(reg_to_write), value_to_write);
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::ReadRegister(
-    const RegisterInfo *reg_info, RegisterValue &value) {
-  if (!reg_info)
-    return false;
-
-  const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
-
-  if (IsFPR(reg)) {
-    if (!ReadFPR())
-      return false;
-  } else {
-    uint32_t full_reg = reg;
-    bool is_subreg = reg_info->invalidate_regs &&
-                     (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM);
-
-    if (is_subreg) {
-      // Read the full aligned 64-bit register.
-      full_reg = reg_info->invalidate_regs[0];
-    }
-
-    bool success = ReadRegister(full_reg, value);
-
-    if (success) {
-      // If our read was not aligned (for ah,bh,ch,dh), shift our returned
-      // value one byte to the right.
-      if (is_subreg && (reg_info->byte_offset & 0x1))
-        value.SetUInt64(value.GetAsUInt64() >> 8);
-
-      // If our return byte size was greater than the return value reg size,
-      // then use the type specified by reg_info rather than the uint64_t
-      // default
-      if (value.GetByteSize() > reg_info->byte_size)
-        value.SetType(reg_info);
-    }
-    return success;
-  }
-
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::WriteRegister(
-    const RegisterInfo *reg_info, const RegisterValue &value) {
-  const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
-
-  if (IsGPR(reg))
-    return WriteRegister(reg, value);
-
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::ReadAllRegisterValues(
-    DataBufferSP &data_sp) {
-  bool success = false;
-  data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
-  if (ReadGPR() && ReadFPR()) {
-    uint8_t *dst = data_sp->GetBytes();
-    success = dst != 0;
-
-    if (success) {
-      ::memcpy(dst, &m_gpr_mips64, GetGPRSize());
-    }
-  }
-  return success;
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::WriteAllRegisterValues(
-    const DataBufferSP &data_sp) {
-  bool success = false;
-  if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) {
-    uint8_t *src = data_sp->GetBytes();
-    if (src) {
-      ::memcpy(&m_gpr_mips64, src, GetGPRSize());
-
-      if (WriteGPR()) {
-        src += GetGPRSize();
-      }
-    }
-  }
-  return success;
-}
-
-uint32_t RegisterContextPOSIXProcessMonitor_mips64::SetHardwareWatchpoint(
-    addr_t addr, size_t size, bool read, bool write) {
-  const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
-  uint32_t hw_index;
-
-  for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index) {
-    if (IsWatchpointVacant(hw_index))
-      return SetHardwareWatchpointWithIndex(addr, size, read, write, hw_index);
-  }
-
-  return LLDB_INVALID_INDEX32;
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::ClearHardwareWatchpoint(
-    uint32_t hw_index) {
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::HardwareSingleStep(
-    bool enable) {
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::UpdateAfterBreakpoint() {
-  // PC points one byte past the int3 responsible for the breakpoint.
-  lldb::addr_t pc;
-
-  if ((pc = GetPC()) == LLDB_INVALID_ADDRESS)
-    return false;
-
-  SetPC(pc - 1);
-  return true;
-}
-
-unsigned RegisterContextPOSIXProcessMonitor_mips64::GetRegisterIndexFromOffset(
-    unsigned offset) {
-  unsigned reg;
-  for (reg = 0; reg < k_num_registers_mips64; reg++) {
-    if (GetRegisterInfo()[reg].byte_offset == offset)
-      break;
-  }
-  assert(reg < k_num_registers_mips64 && "Invalid register offset.");
-  return reg;
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::IsWatchpointHit(
-    uint32_t hw_index) {
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::ClearWatchpointHits() {
-  return false;
-}
-
-addr_t RegisterContextPOSIXProcessMonitor_mips64::GetWatchpointAddress(
-    uint32_t hw_index) {
-  return LLDB_INVALID_ADDRESS;
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::IsWatchpointVacant(
-    uint32_t hw_index) {
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_mips64::SetHardwareWatchpointWithIndex(
-    addr_t addr, size_t size, bool read, bool write, uint32_t hw_index) {
-  return false;
-}
-
-uint32_t
-RegisterContextPOSIXProcessMonitor_mips64::NumSupportedHardwareWatchpoints() {
-  return 0;
-}
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_mips64.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_mips64.h
deleted file mode 100644
index be404cc08c34..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_mips64.h
+++ /dev/null
@@ -1,82 +0,0 @@
-//===-- RegisterContextPOSIXProcessMonitor_mips64.h -------------*- C++ -*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_RegisterContextPOSIXProcessMonitor_mips64_H_
-#define liblldb_RegisterContextPOSIXProcessMonitor_mips64_H_
-
-#include "Plugins/Process/Utility/RegisterContextPOSIX_mips64.h"
-#include "Plugins/Process/Utility/lldb-mips-freebsd-register-enums.h"
-#include "RegisterContextPOSIX.h"
-
-class ProcessMonitor;
-
-class RegisterContextPOSIXProcessMonitor_mips64
-    : public RegisterContextPOSIX_mips64,
-      public POSIXBreakpointProtocol {
-public:
-  RegisterContextPOSIXProcessMonitor_mips64(
-      lldb_private::Thread &thread, uint32_t concrete_frame_idx,
-      lldb_private::RegisterInfoInterface *register_info);
-
-protected:
-  bool ReadGPR() override;
-
-  bool ReadFPR() override;
-
-  bool WriteGPR() override;
-
-  bool WriteFPR() override;
-
-  // lldb_private::RegisterContext
-  bool ReadRegister(const unsigned reg, lldb_private::RegisterValue &value);
-
-  bool WriteRegister(const unsigned reg,
-                     const lldb_private::RegisterValue &value);
-
-  bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
-                    lldb_private::RegisterValue &value) override;
-
-  bool WriteRegister(const lldb_private::RegisterInfo *reg_info,
-                     const lldb_private::RegisterValue &value) override;
-
-  bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
-
-  bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
-
-  uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read,
-                                 bool write) override;
-
-  bool ClearHardwareWatchpoint(uint32_t hw_index) override;
-
-  bool HardwareSingleStep(bool enable) override;
-
-  // POSIXBreakpointProtocol
-  bool UpdateAfterBreakpoint() override;
-
-  unsigned GetRegisterIndexFromOffset(unsigned offset) override;
-
-  bool IsWatchpointHit(uint32_t hw_index) override;
-
-  bool ClearWatchpointHits() override;
-
-  lldb::addr_t GetWatchpointAddress(uint32_t hw_index) override;
-
-  bool IsWatchpointVacant(uint32_t hw_index) override;
-
-  bool SetHardwareWatchpointWithIndex(lldb::addr_t addr, size_t size, bool read,
-                                      bool write, uint32_t hw_index) override;
-
-  uint32_t NumSupportedHardwareWatchpoints() override;
-
-private:
-  uint64_t 
-  m_gpr_mips64[lldb_private::k_num_gpr_registers_mips64]; // general purpose registers.
-  ProcessMonitor &GetMonitor();
-};
-
-#endif
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_powerpc.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_powerpc.cpp
deleted file mode 100644
index f8342775a81b..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_powerpc.cpp
+++ /dev/null
@@ -1,274 +0,0 @@
-//===-- RegisterContextPOSIXProcessMonitor_powerpc.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 "lldb/Target/Thread.h"
-#include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/RegisterValue.h"
-
-#include "ProcessFreeBSD.h"
-#include "ProcessMonitor.h"
-#include "RegisterContextPOSIXProcessMonitor_powerpc.h"
-#include "Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h"
-
-using namespace lldb_private;
-using namespace lldb;
-
-#define REG_CONTEXT_SIZE (GetGPRSize())
-
-RegisterContextPOSIXProcessMonitor_powerpc::
-    RegisterContextPOSIXProcessMonitor_powerpc(
-        Thread &thread, uint32_t concrete_frame_idx,
-        lldb_private::RegisterInfoInterface *register_info)
-    : RegisterContextPOSIX_powerpc(thread, concrete_frame_idx, register_info) {}
-
-ProcessMonitor &RegisterContextPOSIXProcessMonitor_powerpc::GetMonitor() {
-  ProcessSP base = CalculateProcess();
-  ProcessFreeBSD *process = static_cast<ProcessFreeBSD *>(base.get());
-  return process->GetMonitor();
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::ReadGPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.ReadGPR(m_thread.GetID(), &m_gpr_powerpc, GetGPRSize());
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::ReadFPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.ReadFPR(m_thread.GetID(), &m_fpr_powerpc,
-                         sizeof(m_fpr_powerpc));
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::ReadVMX() {
-  // XXX: Need a way to read/write process VMX registers with ptrace.
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::WriteGPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.WriteGPR(m_thread.GetID(), &m_gpr_powerpc, GetGPRSize());
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::WriteFPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.WriteFPR(m_thread.GetID(), &m_fpr_powerpc,
-                          sizeof(m_fpr_powerpc));
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::WriteVMX() {
-  // XXX: Need a way to read/write process VMX registers with ptrace.
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::ReadRegister(
-    const unsigned reg, RegisterValue &value) {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.ReadRegisterValue(m_thread.GetID(), GetRegisterOffset(reg),
-                                   GetRegisterName(reg), GetRegisterSize(reg),
-                                   value);
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::WriteRegister(
-    const unsigned reg, const RegisterValue &value) {
-  unsigned reg_to_write = reg;
-  RegisterValue value_to_write = value;
-
-  // Check if this is a subregister of a full register.
-  const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
-  if (reg_info->invalidate_regs &&
-      (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM)) {
-    RegisterValue full_value;
-    uint32_t full_reg = reg_info->invalidate_regs[0];
-    const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg);
-
-    // Read the full register.
-    if (ReadRegister(full_reg_info, full_value)) {
-      Status error;
-      ByteOrder byte_order = GetByteOrder();
-      uint8_t dst[RegisterValue::kMaxRegisterByteSize];
-
-      // Get the bytes for the full register.
-      const uint32_t dest_size = full_value.GetAsMemoryData(
-          full_reg_info, dst, sizeof(dst), byte_order, error);
-      if (error.Success() && dest_size) {
-        uint8_t src[RegisterValue::kMaxRegisterByteSize];
-
-        // Get the bytes for the source data.
-        const uint32_t src_size = value.GetAsMemoryData(
-            reg_info, src, sizeof(src), byte_order, error);
-        if (error.Success() && src_size && (src_size < dest_size)) {
-          // Copy the src bytes to the destination.
-          memcpy(dst + (reg_info->byte_offset & 0x1), src, src_size);
-          // Set this full register as the value to write.
-          value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
-          value_to_write.SetType(full_reg_info);
-          reg_to_write = full_reg;
-        }
-      }
-    }
-  }
-
-  ProcessMonitor &monitor = GetMonitor();
-  // Account for the fact that 32-bit targets on powerpc64 really use 64-bit
-  // registers in ptrace, but expose here 32-bit registers with a higher
-  // offset.
-  uint64_t offset = GetRegisterOffset(reg_to_write);
-  offset &= ~(sizeof(uintptr_t) - 1);
-  return monitor.WriteRegisterValue(
-      m_thread.GetID(), offset, GetRegisterName(reg_to_write), value_to_write);
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::ReadRegister(
-    const RegisterInfo *reg_info, RegisterValue &value) {
-  if (!reg_info)
-    return false;
-
-  const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
-
-  if (IsFPR(reg)) {
-    if (!ReadFPR())
-      return false;
-    uint8_t *src = (uint8_t *)&m_fpr_powerpc + reg_info->byte_offset;
-    value.SetUInt64(*(uint64_t *)src);
-  } else if (IsGPR(reg)) {
-    bool success = ReadRegister(reg, value);
-
-    if (success) {
-      // If our return byte size was greater than the return value reg size,
-      // then use the type specified by reg_info rather than the uint64_t
-      // default
-      if (value.GetByteSize() > reg_info->byte_size)
-        value.SetType(reg_info);
-    }
-    return success;
-  }
-
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::WriteRegister(
-    const RegisterInfo *reg_info, const RegisterValue &value) {
-  const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
-
-  if (IsGPR(reg)) {
-    return WriteRegister(reg, value);
-  } else if (IsFPR(reg)) {
-    assert(reg_info->byte_offset < sizeof(m_fpr_powerpc));
-    uint8_t *dst = (uint8_t *)&m_fpr_powerpc + reg_info->byte_offset;
-    *(uint64_t *)dst = value.GetAsUInt64();
-    return WriteFPR();
-  }
-
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::ReadAllRegisterValues(
-    DataBufferSP &data_sp) {
-  bool success = false;
-  data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
-  if (ReadGPR() && ReadFPR()) {
-    uint8_t *dst = data_sp->GetBytes();
-    success = dst != 0;
-
-    if (success) {
-      ::memcpy(dst, &m_gpr_powerpc, GetGPRSize());
-      dst += GetGPRSize();
-    }
-  }
-  return success;
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::WriteAllRegisterValues(
-    const DataBufferSP &data_sp) {
-  bool success = false;
-  if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) {
-    uint8_t *src = data_sp->GetBytes();
-    if (src) {
-      ::memcpy(&m_gpr_powerpc, src, GetGPRSize());
-
-      if (WriteGPR()) {
-        src += GetGPRSize();
-        ::memcpy(&m_fpr_powerpc, src, sizeof(m_fpr_powerpc));
-
-        success = WriteFPR();
-      }
-    }
-  }
-  return success;
-}
-
-uint32_t RegisterContextPOSIXProcessMonitor_powerpc::SetHardwareWatchpoint(
-    addr_t addr, size_t size, bool read, bool write) {
-  const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
-  uint32_t hw_index;
-
-  for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index) {
-    if (IsWatchpointVacant(hw_index))
-      return SetHardwareWatchpointWithIndex(addr, size, read, write, hw_index);
-  }
-
-  return LLDB_INVALID_INDEX32;
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::ClearHardwareWatchpoint(
-    uint32_t hw_index) {
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::HardwareSingleStep(
-    bool enable) {
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::UpdateAfterBreakpoint() {
-  lldb::addr_t pc;
-
-  if ((pc = GetPC()) == LLDB_INVALID_ADDRESS)
-    return false;
-
-  return true;
-}
-
-unsigned RegisterContextPOSIXProcessMonitor_powerpc::GetRegisterIndexFromOffset(
-    unsigned offset) {
-  unsigned reg;
-  for (reg = 0; reg < k_num_registers_powerpc; reg++) {
-    if (GetRegisterInfo()[reg].byte_offset == offset)
-      break;
-  }
-  assert(reg < k_num_registers_powerpc && "Invalid register offset.");
-  return reg;
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::IsWatchpointHit(
-    uint32_t hw_index) {
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::ClearWatchpointHits() {
-  return false;
-}
-
-addr_t RegisterContextPOSIXProcessMonitor_powerpc::GetWatchpointAddress(
-    uint32_t hw_index) {
-  return LLDB_INVALID_ADDRESS;
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::IsWatchpointVacant(
-    uint32_t hw_index) {
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_powerpc::SetHardwareWatchpointWithIndex(
-    addr_t addr, size_t size, bool read, bool write, uint32_t hw_index) {
-  return false;
-}
-
-uint32_t
-RegisterContextPOSIXProcessMonitor_powerpc::NumSupportedHardwareWatchpoints() {
-  return 0;
-}
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_powerpc.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_powerpc.h
deleted file mode 100644
index 328db4479ce6..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_powerpc.h
+++ /dev/null
@@ -1,84 +0,0 @@
-//===-- RegisterContextPOSIXProcessMonitor_powerpc.h -------------*- C++
-//-*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_RegisterContextPOSIXProcessMonitor_powerpc_H_
-#define liblldb_RegisterContextPOSIXProcessMonitor_powerpc_H_
-
-#include "Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h"
-#include "RegisterContextPOSIX.h"
-
-class RegisterContextPOSIXProcessMonitor_powerpc
-    : public RegisterContextPOSIX_powerpc,
-      public POSIXBreakpointProtocol {
-public:
-  RegisterContextPOSIXProcessMonitor_powerpc(
-      lldb_private::Thread &thread, uint32_t concrete_frame_idx,
-      lldb_private::RegisterInfoInterface *register_info);
-
-protected:
-  bool IsVMX();
-
-  bool ReadGPR() override;
-
-  bool ReadFPR() override;
-
-  bool ReadVMX() override;
-
-  bool WriteGPR() override;
-
-  bool WriteFPR() override;
-
-  bool WriteVMX() override;
-
-  // lldb_private::RegisterContext
-  bool ReadRegister(const unsigned reg, lldb_private::RegisterValue &value);
-
-  bool WriteRegister(const unsigned reg,
-                     const lldb_private::RegisterValue &value);
-
-  bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
-                    lldb_private::RegisterValue &value) override;
-
-  bool WriteRegister(const lldb_private::RegisterInfo *reg_info,
-                     const lldb_private::RegisterValue &value) override;
-
-  bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
-
-  bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
-
-  uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read,
-                                 bool write) override;
-
-  bool ClearHardwareWatchpoint(uint32_t hw_index) override;
-
-  bool HardwareSingleStep(bool enable) override;
-
-  // POSIXBreakpointProtocol
-  bool UpdateAfterBreakpoint() override;
-
-  unsigned GetRegisterIndexFromOffset(unsigned offset) override;
-
-  bool IsWatchpointHit(uint32_t hw_index) override;
-
-  bool ClearWatchpointHits() override;
-
-  lldb::addr_t GetWatchpointAddress(uint32_t hw_index) override;
-
-  bool IsWatchpointVacant(uint32_t hw_index) override;
-
-  bool SetHardwareWatchpointWithIndex(lldb::addr_t addr, size_t size, bool read,
-                                      bool write, uint32_t hw_index) override;
-
-  uint32_t NumSupportedHardwareWatchpoints() override;
-
-private:
-  ProcessMonitor &GetMonitor();
-};
-
-#endif
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_x86.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_x86.cpp
deleted file mode 100644
index b1739e1e3bd8..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_x86.cpp
+++ /dev/null
@@ -1,613 +0,0 @@
-//===-- RegisterContextPOSIXProcessMonitor_x86.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 "lldb/Target/Thread.h"
-#include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/RegisterValue.h"
-
-#include "Plugins/Process/FreeBSD/ProcessFreeBSD.h"
-#include "Plugins/Process/FreeBSD/ProcessMonitor.h"
-#include "RegisterContextPOSIXProcessMonitor_x86.h"
-
-using namespace lldb_private;
-using namespace lldb;
-
-// Support ptrace extensions even when compiled without required kernel support
-#ifndef NT_X86_XSTATE
-#define NT_X86_XSTATE 0x202
-#endif
-
-#define REG_CONTEXT_SIZE (GetGPRSize() + sizeof(FPR))
-
-static uint32_t size_and_rw_bits(size_t size, bool read, bool write) {
-  uint32_t rw;
-
-  if (read)
-    rw = 0x3; // READ or READ/WRITE
-  else if (write)
-    rw = 0x1; // WRITE
-  else
-    assert(0 && "read and write cannot both be false");
-
-  switch (size) {
-  case 1:
-    return rw;
-  case 2:
-    return (0x1 << 2) | rw;
-  case 4:
-    return (0x3 << 2) | rw;
-  case 8:
-    return (0x2 << 2) | rw;
-  default:
-    assert(0 && "invalid size, must be one of 1, 2, 4, or 8");
-    return 0; // Unreachable. Just to silence compiler.
-  }
-}
-
-RegisterContextPOSIXProcessMonitor_x86_64::
-    RegisterContextPOSIXProcessMonitor_x86_64(
-        Thread &thread, uint32_t concrete_frame_idx,
-        lldb_private::RegisterInfoInterface *register_info)
-    : RegisterContextPOSIX_x86(thread, concrete_frame_idx, register_info) {
-  // Store byte offset of fctrl (i.e. first register of FPR) wrt 'UserArea'
-  const RegisterInfo *reg_info_fctrl = GetRegisterInfoByName("fctrl");
-  m_fctrl_offset_in_userarea = reg_info_fctrl->byte_offset;
-
-  m_iovec.iov_base = &m_fpr.xsave;
-  m_iovec.iov_len = sizeof(m_fpr.xsave);
-}
-
-ProcessMonitor &RegisterContextPOSIXProcessMonitor_x86_64::GetMonitor() {
-  ProcessSP base = CalculateProcess();
-  ProcessFreeBSD *process = static_cast<ProcessFreeBSD *>(base.get());
-  return process->GetMonitor();
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::ReadGPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.ReadGPR(m_thread.GetID(), &m_gpr_x86_64, GetGPRSize());
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::ReadFPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  if (GetFPRType() == eFXSAVE)
-    return monitor.ReadFPR(m_thread.GetID(), &m_fpr.fxsave,
-                           sizeof(m_fpr.fxsave));
-
-  if (GetFPRType() == eXSAVE)
-    return monitor.ReadRegisterSet(m_thread.GetID(), &m_iovec,
-                                   sizeof(m_fpr.xsave), NT_X86_XSTATE);
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::WriteGPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  return monitor.WriteGPR(m_thread.GetID(), &m_gpr_x86_64, GetGPRSize());
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::WriteFPR() {
-  ProcessMonitor &monitor = GetMonitor();
-  if (GetFPRType() == eFXSAVE)
-    return monitor.WriteFPR(m_thread.GetID(), &m_fpr.fxsave,
-                            sizeof(m_fpr.fxsave));
-
-  if (GetFPRType() == eXSAVE)
-    return monitor.WriteRegisterSet(m_thread.GetID(), &m_iovec,
-                                    sizeof(m_fpr.xsave), NT_X86_XSTATE);
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::ReadRegister(
-    const unsigned reg, RegisterValue &value) {
-  ProcessMonitor &monitor = GetMonitor();
-
-#if defined(__FreeBSD__)
-  if (reg >= m_reg_info.first_dr)
-    return monitor.ReadDebugRegisterValue(
-        m_thread.GetID(), GetRegisterOffset(reg), GetRegisterName(reg),
-        GetRegisterSize(reg), value);
-#endif
-  return monitor.ReadRegisterValue(m_thread.GetID(), GetRegisterOffset(reg),
-                                   GetRegisterName(reg), GetRegisterSize(reg),
-                                   value);
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::WriteRegister(
-    const unsigned reg, const RegisterValue &value) {
-  unsigned reg_to_write = reg;
-  RegisterValue value_to_write = value;
-
-  // Check if this is a subregister of a full register.
-  const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg);
-  if (reg_info->invalidate_regs &&
-      (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM)) {
-    RegisterValue full_value;
-    uint32_t full_reg = reg_info->invalidate_regs[0];
-    const RegisterInfo *full_reg_info = GetRegisterInfoAtIndex(full_reg);
-
-    // Read the full register.
-    if (ReadRegister(full_reg_info, full_value)) {
-      Status error;
-      ByteOrder byte_order = GetByteOrder();
-      uint8_t dst[RegisterValue::kMaxRegisterByteSize];
-
-      // Get the bytes for the full register.
-      const uint32_t dest_size = full_value.GetAsMemoryData(
-          full_reg_info, dst, sizeof(dst), byte_order, error);
-      if (error.Success() && dest_size) {
-        uint8_t src[RegisterValue::kMaxRegisterByteSize];
-
-        // Get the bytes for the source data.
-        const uint32_t src_size = value.GetAsMemoryData(
-            reg_info, src, sizeof(src), byte_order, error);
-        if (error.Success() && src_size && (src_size < dest_size)) {
-          // Copy the src bytes to the destination.
-          memcpy(dst + (reg_info->byte_offset & 0x1), src, src_size);
-          // Set this full register as the value to write.
-          value_to_write.SetBytes(dst, full_value.GetByteSize(), byte_order);
-          value_to_write.SetType(full_reg_info);
-          reg_to_write = full_reg;
-        }
-      }
-    }
-  }
-
-  ProcessMonitor &monitor = GetMonitor();
-#if defined(__FreeBSD__)
-  if (reg >= m_reg_info.first_dr)
-    return monitor.WriteDebugRegisterValue(
-        m_thread.GetID(), GetRegisterOffset(reg_to_write),
-        GetRegisterName(reg_to_write), value_to_write);
-#endif
-  return monitor.WriteRegisterValue(
-      m_thread.GetID(), GetRegisterOffset(reg_to_write),
-      GetRegisterName(reg_to_write), value_to_write);
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::ReadRegister(
-    const RegisterInfo *reg_info, RegisterValue &value) {
-  if (!reg_info)
-    return false;
-
-  const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
-
-  if (IsFPR(reg, GetFPRType())) {
-    if (!ReadFPR())
-      return false;
-  } else {
-    uint32_t full_reg = reg;
-    bool is_subreg = reg_info->invalidate_regs &&
-                     (reg_info->invalidate_regs[0] != LLDB_INVALID_REGNUM);
-
-    if (is_subreg) {
-      // Read the full aligned 64-bit register.
-      full_reg = reg_info->invalidate_regs[0];
-    }
-
-    bool success = ReadRegister(full_reg, value);
-
-    if (success) {
-      // If our read was not aligned (for ah,bh,ch,dh), shift our returned
-      // value one byte to the right.
-      if (is_subreg && (reg_info->byte_offset & 0x1))
-        value.SetUInt64(value.GetAsUInt64() >> 8);
-
-      // If our return byte size was greater than the return value reg size,
-      // then use the type specified by reg_info rather than the uint64_t
-      // default
-      if (value.GetByteSize() > reg_info->byte_size)
-        value.SetType(reg_info);
-    }
-    return success;
-  }
-
-  if (reg_info->encoding == eEncodingVector) {
-    ByteOrder byte_order = GetByteOrder();
-
-    if (byte_order != ByteOrder::eByteOrderInvalid) {
-      if (reg >= m_reg_info.first_st && reg <= m_reg_info.last_st)
-        value.SetBytes(m_fpr.fxsave.stmm[reg - m_reg_info.first_st].bytes,
-                       reg_info->byte_size, byte_order);
-      if (reg >= m_reg_info.first_mm && reg <= m_reg_info.last_mm)
-        value.SetBytes(m_fpr.fxsave.stmm[reg - m_reg_info.first_mm].bytes,
-                       reg_info->byte_size, byte_order);
-      if (reg >= m_reg_info.first_xmm && reg <= m_reg_info.last_xmm)
-        value.SetBytes(m_fpr.fxsave.xmm[reg - m_reg_info.first_xmm].bytes,
-                       reg_info->byte_size, byte_order);
-      if (reg >= m_reg_info.first_ymm && reg <= m_reg_info.last_ymm) {
-        // Concatenate ymm using the register halves in xmm.bytes and
-        // ymmh.bytes
-        if (GetFPRType() == eXSAVE && CopyXSTATEtoYMM(reg, byte_order))
-          value.SetBytes(m_ymm_set.ymm[reg - m_reg_info.first_ymm].bytes,
-                         reg_info->byte_size, byte_order);
-        else
-          return false;
-      }
-      return value.GetType() == RegisterValue::eTypeBytes;
-    }
-    return false;
-  }
-
-  // Get pointer to m_fpr.fxsave variable and set the data from it. Byte
-  // offsets of all registers are calculated wrt 'UserArea' structure. However,
-  // ReadFPR() reads fpu registers {using ptrace(PT_GETFPREGS,..)} and stores
-  // them in 'm_fpr' (of type FPR structure). To extract values of fpu
-  // registers, m_fpr should be read at byte offsets calculated wrt to FPR
-  // structure.
-
-  // Since, FPR structure is also one of the member of UserArea structure.
-  // byte_offset(fpu wrt FPR) = byte_offset(fpu wrt UserArea) -
-  // byte_offset(fctrl wrt UserArea)
-  assert((reg_info->byte_offset - m_fctrl_offset_in_userarea) < sizeof(m_fpr));
-  uint8_t *src =
-      (uint8_t *)&m_fpr + reg_info->byte_offset - m_fctrl_offset_in_userarea;
-  switch (reg_info->byte_size) {
-  case 1:
-    value.SetUInt8(*(uint8_t *)src);
-    return true;
-  case 2:
-    value.SetUInt16(*(uint16_t *)src);
-    return true;
-  case 4:
-    value.SetUInt32(*(uint32_t *)src);
-    return true;
-  case 8:
-    value.SetUInt64(*(uint64_t *)src);
-    return true;
-  default:
-    assert(false && "Unhandled data size.");
-    return false;
-  }
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::WriteRegister(
-    const RegisterInfo *reg_info, const RegisterValue &value) {
-  const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
-
-  if (IsGPR(reg))
-    return WriteRegister(reg, value);
-
-  if (IsFPR(reg, GetFPRType())) {
-    if (reg_info->encoding == eEncodingVector) {
-      if (reg >= m_reg_info.first_st && reg <= m_reg_info.last_st)
-        ::memcpy(m_fpr.fxsave.stmm[reg - m_reg_info.first_st].bytes,
-                 value.GetBytes(), value.GetByteSize());
-
-      if (reg >= m_reg_info.first_mm && reg <= m_reg_info.last_mm)
-        ::memcpy(m_fpr.fxsave.stmm[reg - m_reg_info.first_mm].bytes,
-                 value.GetBytes(), value.GetByteSize());
-
-      if (reg >= m_reg_info.first_xmm && reg <= m_reg_info.last_xmm)
-        ::memcpy(m_fpr.fxsave.xmm[reg - m_reg_info.first_xmm].bytes,
-                 value.GetBytes(), value.GetByteSize());
-
-      if (reg >= m_reg_info.first_ymm && reg <= m_reg_info.last_ymm) {
-        if (GetFPRType() != eXSAVE)
-          return false; // the target processor does not support AVX
-
-        // Store ymm register content, and split into the register halves in
-        // xmm.bytes and ymmh.bytes
-        ::memcpy(m_ymm_set.ymm[reg - m_reg_info.first_ymm].bytes,
-                 value.GetBytes(), value.GetByteSize());
-        if (false == CopyYMMtoXSTATE(reg, GetByteOrder()))
-          return false;
-      }
-    } else {
-      // Get pointer to m_fpr.fxsave variable and set the data to it. Byte
-      // offsets of all registers are calculated wrt 'UserArea' structure.
-      // However, WriteFPR() takes m_fpr (of type FPR structure) and writes
-      // only fpu registers using ptrace(PT_SETFPREGS,..) API. Hence fpu
-      // registers should be written in m_fpr at byte offsets calculated wrt
-      // FPR structure.
-
-      // Since, FPR structure is also one of the member of UserArea structure.
-      // byte_offset(fpu wrt FPR) = byte_offset(fpu wrt UserArea) -
-      // byte_offset(fctrl wrt UserArea)
-      assert((reg_info->byte_offset - m_fctrl_offset_in_userarea) <
-             sizeof(m_fpr));
-      uint8_t *dst = (uint8_t *)&m_fpr + reg_info->byte_offset -
-                     m_fctrl_offset_in_userarea;
-      switch (reg_info->byte_size) {
-      case 1:
-        *(uint8_t *)dst = value.GetAsUInt8();
-        break;
-      case 2:
-        *(uint16_t *)dst = value.GetAsUInt16();
-        break;
-      case 4:
-        *(uint32_t *)dst = value.GetAsUInt32();
-        break;
-      case 8:
-        *(uint64_t *)dst = value.GetAsUInt64();
-        break;
-      default:
-        assert(false && "Unhandled data size.");
-        return false;
-      }
-    }
-
-    if (WriteFPR()) {
-      if (IsAVX(reg))
-        return CopyYMMtoXSTATE(reg, GetByteOrder());
-      return true;
-    }
-  }
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::ReadAllRegisterValues(
-    DataBufferSP &data_sp) {
-  bool success = false;
-  data_sp.reset(new DataBufferHeap(REG_CONTEXT_SIZE, 0));
-  if (ReadGPR() && ReadFPR()) {
-    uint8_t *dst = data_sp->GetBytes();
-    success = dst != 0;
-
-    if (success) {
-      ::memcpy(dst, &m_gpr_x86_64, GetGPRSize());
-      dst += GetGPRSize();
-      if (GetFPRType() == eFXSAVE)
-        ::memcpy(dst, &m_fpr.fxsave, sizeof(m_fpr.fxsave));
-    }
-
-    if (GetFPRType() == eXSAVE) {
-      ByteOrder byte_order = GetByteOrder();
-
-      // Assemble the YMM register content from the register halves.
-      for (uint32_t reg = m_reg_info.first_ymm;
-           success && reg <= m_reg_info.last_ymm; ++reg)
-        success = CopyXSTATEtoYMM(reg, byte_order);
-
-      if (success) {
-        // Copy the extended register state including the assembled ymm
-        // registers.
-        ::memcpy(dst, &m_fpr, sizeof(m_fpr));
-      }
-    }
-  }
-  return success;
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::WriteAllRegisterValues(
-    const DataBufferSP &data_sp) {
-  bool success = false;
-  if (data_sp && data_sp->GetByteSize() == REG_CONTEXT_SIZE) {
-    uint8_t *src = data_sp->GetBytes();
-    if (src) {
-      ::memcpy(&m_gpr_x86_64, src, GetGPRSize());
-
-      if (WriteGPR()) {
-        src += GetGPRSize();
-        if (GetFPRType() == eFXSAVE)
-          ::memcpy(&m_fpr.fxsave, src, sizeof(m_fpr.fxsave));
-        if (GetFPRType() == eXSAVE)
-          ::memcpy(&m_fpr.xsave, src, sizeof(m_fpr.xsave));
-
-        success = WriteFPR();
-        if (success) {
-          if (GetFPRType() == eXSAVE) {
-            ByteOrder byte_order = GetByteOrder();
-
-            // Parse the YMM register content from the register halves.
-            for (uint32_t reg = m_reg_info.first_ymm;
-                 success && reg <= m_reg_info.last_ymm; ++reg)
-              success = CopyYMMtoXSTATE(reg, byte_order);
-          }
-        }
-      }
-    }
-  }
-  return success;
-}
-
-uint32_t RegisterContextPOSIXProcessMonitor_x86_64::SetHardwareWatchpoint(
-    addr_t addr, size_t size, bool read, bool write) {
-  const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
-  uint32_t hw_index;
-
-  for (hw_index = 0; hw_index < num_hw_watchpoints; ++hw_index) {
-    if (IsWatchpointVacant(hw_index))
-      return SetHardwareWatchpointWithIndex(addr, size, read, write, hw_index);
-  }
-
-  return LLDB_INVALID_INDEX32;
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::ClearHardwareWatchpoint(
-    uint32_t hw_index) {
-  if (hw_index < NumSupportedHardwareWatchpoints()) {
-    RegisterValue current_dr7_bits;
-
-    if (ReadRegister(m_reg_info.first_dr + 7, current_dr7_bits)) {
-      uint64_t new_dr7_bits =
-          current_dr7_bits.GetAsUInt64() & ~(3 << (2 * hw_index));
-
-      if (WriteRegister(m_reg_info.first_dr + 7, RegisterValue(new_dr7_bits)))
-        return true;
-    }
-  }
-
-  return false;
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::HardwareSingleStep(
-    bool enable) {
-  enum { TRACE_BIT = 0x100 };
-  uint64_t rflags;
-
-  if ((rflags = ReadRegisterAsUnsigned(m_reg_info.gpr_flags, -1UL)) == -1UL)
-    return false;
-
-  if (enable) {
-    if (rflags & TRACE_BIT)
-      return true;
-
-    rflags |= TRACE_BIT;
-  } else {
-    if (!(rflags & TRACE_BIT))
-      return false;
-
-    rflags &= ~TRACE_BIT;
-  }
-
-  return WriteRegisterFromUnsigned(m_reg_info.gpr_flags, rflags);
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::UpdateAfterBreakpoint() {
-  // PC points one byte past the int3 responsible for the breakpoint.
-  lldb::addr_t pc;
-
-  if ((pc = GetPC()) == LLDB_INVALID_ADDRESS)
-    return false;
-
-  SetPC(pc - 1);
-  return true;
-}
-
-unsigned RegisterContextPOSIXProcessMonitor_x86_64::GetRegisterIndexFromOffset(
-    unsigned offset) {
-  unsigned reg;
-  for (reg = 0; reg < m_reg_info.num_registers; reg++) {
-    if (GetRegisterInfo()[reg].byte_offset == offset)
-      break;
-  }
-  assert(reg < m_reg_info.num_registers && "Invalid register offset.");
-  return reg;
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::IsWatchpointHit(
-    uint32_t hw_index) {
-  bool is_hit = false;
-
-  if (m_watchpoints_initialized == false) {
-    // Reset the debug status and debug control registers
-    RegisterValue zero_bits = RegisterValue(uint64_t(0));
-    if (!WriteRegister(m_reg_info.first_dr + 6, zero_bits) ||
-        !WriteRegister(m_reg_info.first_dr + 7, zero_bits))
-      assert(false && "Could not initialize watchpoint registers");
-    m_watchpoints_initialized = true;
-  }
-
-  if (hw_index < NumSupportedHardwareWatchpoints()) {
-    RegisterValue value;
-
-    if (ReadRegister(m_reg_info.first_dr + 6, value)) {
-      uint64_t val = value.GetAsUInt64();
-      is_hit = val & (1 << hw_index);
-    }
-  }
-
-  return is_hit;
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::ClearWatchpointHits() {
-  return WriteRegister(m_reg_info.first_dr + 6, RegisterValue((uint64_t)0));
-}
-
-addr_t RegisterContextPOSIXProcessMonitor_x86_64::GetWatchpointAddress(
-    uint32_t hw_index) {
-  addr_t wp_monitor_addr = LLDB_INVALID_ADDRESS;
-
-  if (hw_index < NumSupportedHardwareWatchpoints()) {
-    if (!IsWatchpointVacant(hw_index)) {
-      RegisterValue value;
-
-      if (ReadRegister(m_reg_info.first_dr + hw_index, value))
-        wp_monitor_addr = value.GetAsUInt64();
-    }
-  }
-
-  return wp_monitor_addr;
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::IsWatchpointVacant(
-    uint32_t hw_index) {
-  bool is_vacant = false;
-  RegisterValue value;
-
-  assert(hw_index < NumSupportedHardwareWatchpoints());
-
-  if (m_watchpoints_initialized == false) {
-    // Reset the debug status and debug control registers
-    RegisterValue zero_bits = RegisterValue(uint64_t(0));
-    if (!WriteRegister(m_reg_info.first_dr + 6, zero_bits) ||
-        !WriteRegister(m_reg_info.first_dr + 7, zero_bits))
-      assert(false && "Could not initialize watchpoint registers");
-    m_watchpoints_initialized = true;
-  }
-
-  if (ReadRegister(m_reg_info.first_dr + 7, value)) {
-    uint64_t val = value.GetAsUInt64();
-    is_vacant = (val & (3 << 2 * hw_index)) == 0;
-  }
-
-  return is_vacant;
-}
-
-bool RegisterContextPOSIXProcessMonitor_x86_64::SetHardwareWatchpointWithIndex(
-    addr_t addr, size_t size, bool read, bool write, uint32_t hw_index) {
-  const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
-
-  if (num_hw_watchpoints == 0 || hw_index >= num_hw_watchpoints)
-    return false;
-
-  if (!(size == 1 || size == 2 || size == 4 || size == 8))
-    return false;
-
-  if (read == false && write == false)
-    return false;
-
-  if (!IsWatchpointVacant(hw_index))
-    return false;
-
-  // Set both dr7 (debug control register) and dri (debug address register).
-
-  // dr7{7-0} encodes the local/global enable bits:
-  //  global enable --. .-- local enable
-  //                  | |
-  //                  v v
-  //      dr0 -> bits{1-0}
-  //      dr1 -> bits{3-2}
-  //      dr2 -> bits{5-4}
-  //      dr3 -> bits{7-6}
-  //
-  // dr7{31-16} encodes the rw/len bits:
-  //  b_x+3, b_x+2, b_x+1, b_x
-  //      where bits{x+1, x} => rw
-  //            0b00: execute, 0b01: write, 0b11: read-or-write,
-  //            0b10: io read-or-write (unused)
-  //      and bits{x+3, x+2} => len
-  //            0b00: 1-byte, 0b01: 2-byte, 0b11: 4-byte, 0b10: 8-byte
-  //
-  //      dr0 -> bits{19-16}
-  //      dr1 -> bits{23-20}
-  //      dr2 -> bits{27-24}
-  //      dr3 -> bits{31-28}
-  if (hw_index < num_hw_watchpoints) {
-    RegisterValue current_dr7_bits;
-
-    if (ReadRegister(m_reg_info.first_dr + 7, current_dr7_bits)) {
-      uint64_t new_dr7_bits =
-          current_dr7_bits.GetAsUInt64() |
-          (1 << (2 * hw_index) |
-           size_and_rw_bits(size, read, write) << (16 + 4 * hw_index));
-
-      if (WriteRegister(m_reg_info.first_dr + hw_index, RegisterValue(addr)) &&
-          WriteRegister(m_reg_info.first_dr + 7, RegisterValue(new_dr7_bits)))
-        return true;
-    }
-  }
-
-  return false;
-}
-
-uint32_t
-RegisterContextPOSIXProcessMonitor_x86_64::NumSupportedHardwareWatchpoints() {
-  // Available debug address registers: dr0, dr1, dr2, dr3
-  return 4;
-}
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_x86.h b/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_x86.h
deleted file mode 100644
index 1afb366eeba3..000000000000
--- a/contrib/llvm-project/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIXProcessMonitor_x86.h
+++ /dev/null
@@ -1,81 +0,0 @@
-//===-- RegisterContextPOSIXProcessMonitor_x86.h ----------------*- C++ -*-===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_RegisterContextPOSIXProcessMonitor_x86_H_
-#define liblldb_RegisterContextPOSIXProcessMonitor_x86_H_
-
-#include "Plugins/Process/Utility/RegisterContextPOSIX_x86.h"
-#include "RegisterContextPOSIX.h"
-#include <sys/uio.h>
-
-class RegisterContextPOSIXProcessMonitor_x86_64
-    : public RegisterContextPOSIX_x86,
-      public POSIXBreakpointProtocol {
-public:
-  RegisterContextPOSIXProcessMonitor_x86_64(
-      lldb_private::Thread &thread, uint32_t concrete_frame_idx,
-      lldb_private::RegisterInfoInterface *register_info);
-
-protected:
-  bool ReadGPR() override;
-
-  bool ReadFPR() override;
-
-  bool WriteGPR() override;
-
-  bool WriteFPR() override;
-
-  // lldb_private::RegisterContext
-  bool ReadRegister(const unsigned reg, lldb_private::RegisterValue &value);
-
-  bool WriteRegister(const unsigned reg,
-                     const lldb_private::RegisterValue &value);
-
-  bool ReadRegister(const lldb_private::RegisterInfo *reg_info,
-                    lldb_private::RegisterValue &value) override;
-
-  bool WriteRegister(const lldb_private::RegisterInfo *reg_info,
-                     const lldb_private::RegisterValue &value) override;
-
-  bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
-
-  bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
-
-  uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read,
-                                 bool write) override;
-
-  bool ClearHardwareWatchpoint(uint32_t hw_index) override;
-
-  bool HardwareSingleStep(bool enable) override;
-
-  // POSIXBreakpointProtocol
-  bool UpdateAfterBreakpoint() override;
-
-  unsigned GetRegisterIndexFromOffset(unsigned offset) override;
-
-  bool IsWatchpointHit(uint32_t hw_index) override;
-
-  bool ClearWatchpointHits() override;
-
-  lldb::addr_t GetWatchpointAddress(uint32_t hw_index) override;
-
-  bool IsWatchpointVacant(uint32_t hw_index) override;
-
-  bool SetHardwareWatchpointWithIndex(lldb::addr_t addr, size_t size, bool read,
-                                      bool write, uint32_t hw_index) override;
-
-  uint32_t NumSupportedHardwareWatchpoints() override;
-
-private:
-  ProcessMonitor &GetMonitor();
-  uint32_t
-      m_fctrl_offset_in_userarea; // Offset of 'fctrl' in 'UserArea' Structure
-  struct iovec m_iovec;
-};
-
-#endif
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD_x86_64.h b/contrib/llvm-project/lldb/source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD_x86_64.h
index d20fd67cdc5d..31005952dd75 100644
--- a/contrib/llvm-project/lldb/source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD_x86_64.h
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD_x86_64.h
@@ -22,7 +22,7 @@
 
 #include "Plugins/Process/NetBSD/NativeRegisterContextNetBSD.h"
 #include "Plugins/Process/Utility/RegisterContext_x86.h"
-#include "Plugins/Process/Utility/NativeRegisterContextWatchpoint_x86.h"
+#include "Plugins/Process/Utility/NativeRegisterContextDBReg_x86.h"
 #include "Plugins/Process/Utility/lldb-x86-register-enums.h"
 
 namespace lldb_private {
@@ -32,7 +32,7 @@ class NativeProcessNetBSD;
 
 class NativeRegisterContextNetBSD_x86_64
     : public NativeRegisterContextNetBSD,
-      public NativeRegisterContextWatchpoint_x86 {
+      public NativeRegisterContextDBReg_x86 {
 public:
   NativeRegisterContextNetBSD_x86_64(const ArchSpec &target_arch,
                                      NativeThreadProtocol &native_thread);
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeProcessSoftwareSingleStep.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeProcessSoftwareSingleStep.cpp
new file mode 100644
index 000000000000..ee5295bf6565
--- /dev/null
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeProcessSoftwareSingleStep.cpp
@@ -0,0 +1,182 @@
+//===-- NativeProcessSoftwareSingleStep.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 "NativeProcessSoftwareSingleStep.h"
+
+#include "lldb/Core/EmulateInstruction.h"
+#include "lldb/Host/common/NativeRegisterContext.h"
+#include "lldb/Utility/RegisterValue.h"
+
+#include <unordered_map>
+
+using namespace lldb;
+using namespace lldb_private;
+
+namespace {
+
+struct EmulatorBaton {
+  NativeProcessProtocol &m_process;
+  NativeRegisterContext &m_reg_context;
+
+  // eRegisterKindDWARF -> RegsiterValue
+  std::unordered_map<uint32_t, RegisterValue> m_register_values;
+
+  EmulatorBaton(NativeProcessProtocol &process,
+                NativeRegisterContext &reg_context)
+      : m_process(process), m_reg_context(reg_context) {}
+};
+
+} // anonymous namespace
+
+static size_t ReadMemoryCallback(EmulateInstruction *instruction, void *baton,
+                                 const EmulateInstruction::Context &context,
+                                 lldb::addr_t addr, void *dst, size_t length) {
+  EmulatorBaton *emulator_baton = static_cast<EmulatorBaton *>(baton);
+
+  size_t bytes_read;
+  emulator_baton->m_process.ReadMemory(addr, dst, length, bytes_read);
+  return bytes_read;
+}
+
+static bool ReadRegisterCallback(EmulateInstruction *instruction, void *baton,
+                                 const RegisterInfo *reg_info,
+                                 RegisterValue &reg_value) {
+  EmulatorBaton *emulator_baton = static_cast<EmulatorBaton *>(baton);
+
+  auto it = emulator_baton->m_register_values.find(
+      reg_info->kinds[eRegisterKindDWARF]);
+  if (it != emulator_baton->m_register_values.end()) {
+    reg_value = it->second;
+    return true;
+  }
+
+  // The emulator only fill in the dwarf regsiter numbers (and in some case the
+  // generic register numbers). Get the full register info from the register
+  // context based on the dwarf register numbers.
+  const RegisterInfo *full_reg_info =
+      emulator_baton->m_reg_context.GetRegisterInfo(
+          eRegisterKindDWARF, reg_info->kinds[eRegisterKindDWARF]);
+
+  Status error =
+      emulator_baton->m_reg_context.ReadRegister(full_reg_info, reg_value);
+  if (error.Success())
+    return true;
+
+  return false;
+}
+
+static bool WriteRegisterCallback(EmulateInstruction *instruction, void *baton,
+                                  const EmulateInstruction::Context &context,
+                                  const RegisterInfo *reg_info,
+                                  const RegisterValue &reg_value) {
+  EmulatorBaton *emulator_baton = static_cast<EmulatorBaton *>(baton);
+  emulator_baton->m_register_values[reg_info->kinds[eRegisterKindDWARF]] =
+      reg_value;
+  return true;
+}
+
+static size_t WriteMemoryCallback(EmulateInstruction *instruction, void *baton,
+                                  const EmulateInstruction::Context &context,
+                                  lldb::addr_t addr, const void *dst,
+                                  size_t length) {
+  return length;
+}
+
+static lldb::addr_t ReadFlags(NativeRegisterContext &regsiter_context) {
+  const RegisterInfo *flags_info = regsiter_context.GetRegisterInfo(
+      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FLAGS);
+  return regsiter_context.ReadRegisterAsUnsigned(flags_info,
+                                                 LLDB_INVALID_ADDRESS);
+}
+
+Status NativeProcessSoftwareSingleStep::SetupSoftwareSingleStepping(
+    NativeThreadProtocol &thread) {
+  Status error;
+  NativeProcessProtocol &process = thread.GetProcess();
+  NativeRegisterContext &register_context = thread.GetRegisterContext();
+  const ArchSpec &arch = process.GetArchitecture();
+
+  std::unique_ptr<EmulateInstruction> emulator_up(
+      EmulateInstruction::FindPlugin(arch, eInstructionTypePCModifying,
+                                     nullptr));
+
+  if (emulator_up == nullptr)
+    return Status("Instruction emulator not found!");
+
+  EmulatorBaton baton(process, register_context);
+  emulator_up->SetBaton(&baton);
+  emulator_up->SetReadMemCallback(&ReadMemoryCallback);
+  emulator_up->SetReadRegCallback(&ReadRegisterCallback);
+  emulator_up->SetWriteMemCallback(&WriteMemoryCallback);
+  emulator_up->SetWriteRegCallback(&WriteRegisterCallback);
+
+  if (!emulator_up->ReadInstruction())
+    return Status("Read instruction failed!");
+
+  bool emulation_result =
+      emulator_up->EvaluateInstruction(eEmulateInstructionOptionAutoAdvancePC);
+
+  const RegisterInfo *reg_info_pc = register_context.GetRegisterInfo(
+      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
+  const RegisterInfo *reg_info_flags = register_context.GetRegisterInfo(
+      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FLAGS);
+
+  auto pc_it =
+      baton.m_register_values.find(reg_info_pc->kinds[eRegisterKindDWARF]);
+  auto flags_it =
+      baton.m_register_values.find(reg_info_flags->kinds[eRegisterKindDWARF]);
+
+  lldb::addr_t next_pc;
+  lldb::addr_t next_flags;
+  if (emulation_result) {
+    assert(pc_it != baton.m_register_values.end() &&
+           "Emulation was successfull but PC wasn't updated");
+    next_pc = pc_it->second.GetAsUInt64();
+
+    if (flags_it != baton.m_register_values.end())
+      next_flags = flags_it->second.GetAsUInt64();
+    else
+      next_flags = ReadFlags(register_context);
+  } else if (pc_it == baton.m_register_values.end()) {
+    // Emulate instruction failed and it haven't changed PC. Advance PC with
+    // the size of the current opcode because the emulation of all
+    // PC modifying instruction should be successful. The failure most
+    // likely caused by a not supported instruction which don't modify PC.
+    next_pc = register_context.GetPC() + emulator_up->GetOpcode().GetByteSize();
+    next_flags = ReadFlags(register_context);
+  } else {
+    // The instruction emulation failed after it modified the PC. It is an
+    // unknown error where we can't continue because the next instruction is
+    // modifying the PC but we don't  know how.
+    return Status("Instruction emulation failed unexpectedly.");
+  }
+
+  int size_hint = 0;
+  if (arch.GetMachine() == llvm::Triple::arm) {
+    if (next_flags & 0x20) {
+      // Thumb mode
+      size_hint = 2;
+    } else {
+      // Arm mode
+      size_hint = 4;
+    }
+  } else if (arch.IsMIPS() || arch.GetTriple().isPPC64())
+    size_hint = 4;
+  error = process.SetBreakpoint(next_pc, size_hint, /*hardware=*/false);
+
+  // If setting the breakpoint fails because next_pc is out of the address
+  // space, ignore it and let the debugee segfault.
+  if (error.GetError() == EIO || error.GetError() == EFAULT) {
+    return Status();
+  } else if (error.Fail())
+    return error;
+
+  m_threads_stepping_with_breakpoint.insert({thread.GetID(), next_pc});
+
+  return Status();
+}
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeProcessSoftwareSingleStep.h b/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeProcessSoftwareSingleStep.h
new file mode 100644
index 000000000000..f9435b7a84ba
--- /dev/null
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeProcessSoftwareSingleStep.h
@@ -0,0 +1,31 @@
+//===-- NativeProcessSoftwareSingleStep.h -----------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef lldb_NativeProcessSoftwareSingleStep_h
+#define lldb_NativeProcessSoftwareSingleStep_h
+
+#include "lldb/Host/common/NativeProcessProtocol.h"
+#include "lldb/Host/common/NativeThreadProtocol.h"
+
+#include <map>
+
+namespace lldb_private {
+
+class NativeProcessSoftwareSingleStep {
+public:
+  Status SetupSoftwareSingleStepping(NativeThreadProtocol &thread);
+
+protected:
+  // List of thread ids stepping with a breakpoint with the address of
+  // the relevan breakpoint
+  std::map<lldb::tid_t, lldb::addr_t> m_threads_stepping_with_breakpoint;
+};
+
+} // namespace lldb_private
+
+#endif // #ifndef lldb_NativeProcessSoftwareSingleStep_h
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeRegisterContextDBReg_arm64.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeRegisterContextDBReg_arm64.cpp
new file mode 100644
index 000000000000..5c05baf71764
--- /dev/null
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeRegisterContextDBReg_arm64.cpp
@@ -0,0 +1,466 @@
+//===-- NativeRegisterContextDBReg_arm64.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 "NativeRegisterContextDBReg_arm64.h"
+
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+
+using namespace lldb_private;
+
+// E (bit 0), used to enable breakpoint/watchpoint
+constexpr uint32_t g_enable_bit = 1;
+// PAC (bits 2:1): 0b10
+constexpr uint32_t g_pac_bits = (2 << 1);
+
+// Returns appropriate control register bits for the specified size
+static constexpr inline uint64_t GetSizeBits(int size) {
+  // BAS (bits 12:5) hold a bit-mask of addresses to watch
+  // e.g. 0b00000001 means 1 byte at address
+  //      0b00000011 means 2 bytes (addr..addr+1)
+  //      ...
+  //      0b11111111 means 8 bytes (addr..addr+7)
+  return ((1 << size) - 1) << 5;
+}
+
+uint32_t NativeRegisterContextDBReg_arm64::NumSupportedHardwareBreakpoints() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
+  llvm::Error error = ReadHardwareDebugInfo();
+  if (error) {
+    LLDB_LOG_ERROR(log, std::move(error),
+                   "failed to read debug registers: {0}");
+    return 0;
+  }
+
+  return m_max_hbp_supported;
+}
+
+uint32_t
+NativeRegisterContextDBReg_arm64::SetHardwareBreakpoint(lldb::addr_t addr,
+                                                        size_t size) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
+  LLDB_LOG(log, "addr: {0:x}, size: {1:x}", addr, size);
+
+  // Read hardware breakpoint and watchpoint information.
+  llvm::Error error = ReadHardwareDebugInfo();
+  if (error) {
+    LLDB_LOG_ERROR(
+        log, std::move(error),
+        "unable to set breakpoint: failed to read debug registers: {0}");
+    return LLDB_INVALID_INDEX32;
+  }
+
+  uint32_t control_value = 0, bp_index = 0;
+
+  // Check if size has a valid hardware breakpoint length.
+  if (size != 4)
+    return LLDB_INVALID_INDEX32; // Invalid size for a AArch64 hardware
+                                 // breakpoint
+
+  // Check 4-byte alignment for hardware breakpoint target address.
+  if (addr & 0x03)
+    return LLDB_INVALID_INDEX32; // Invalid address, should be 4-byte aligned.
+
+  // Setup control value
+  control_value = g_enable_bit | g_pac_bits | GetSizeBits(size);
+
+  // Iterate over stored breakpoints and find a free bp_index
+  bp_index = LLDB_INVALID_INDEX32;
+  for (uint32_t i = 0; i < m_max_hbp_supported; i++) {
+    if (!BreakpointIsEnabled(i))
+      bp_index = i; // Mark last free slot
+    else if (m_hbp_regs[i].address == addr)
+      return LLDB_INVALID_INDEX32; // We do not support duplicate breakpoints.
+  }
+
+  if (bp_index == LLDB_INVALID_INDEX32)
+    return LLDB_INVALID_INDEX32;
+
+  // Update breakpoint in local cache
+  m_hbp_regs[bp_index].real_addr = addr;
+  m_hbp_regs[bp_index].address = addr;
+  m_hbp_regs[bp_index].control = control_value;
+
+  // PTRACE call to set corresponding hardware breakpoint register.
+  error = WriteHardwareDebugRegs(eDREGTypeBREAK);
+
+  if (error) {
+    m_hbp_regs[bp_index].address = 0;
+    m_hbp_regs[bp_index].control &= ~1;
+
+    LLDB_LOG_ERROR(
+        log, std::move(error),
+        "unable to set breakpoint: failed to write debug registers: {0}");
+    return LLDB_INVALID_INDEX32;
+  }
+
+  return bp_index;
+}
+
+bool NativeRegisterContextDBReg_arm64::ClearHardwareBreakpoint(
+    uint32_t hw_idx) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
+  LLDB_LOG(log, "hw_idx: {0}", hw_idx);
+
+  // Read hardware breakpoint and watchpoint information.
+  llvm::Error error = ReadHardwareDebugInfo();
+  if (error) {
+    LLDB_LOG_ERROR(
+        log, std::move(error),
+        "unable to clear breakpoint: failed to read debug registers: {0}");
+    return false;
+  }
+
+  if (hw_idx >= m_max_hbp_supported)
+    return false;
+
+  // Create a backup we can revert to in case of failure.
+  lldb::addr_t tempAddr = m_hbp_regs[hw_idx].address;
+  uint32_t tempControl = m_hbp_regs[hw_idx].control;
+
+  m_hbp_regs[hw_idx].control &= ~g_enable_bit;
+  m_hbp_regs[hw_idx].address = 0;
+
+  // PTRACE call to clear corresponding hardware breakpoint register.
+  error = WriteHardwareDebugRegs(eDREGTypeBREAK);
+
+  if (error) {
+    m_hbp_regs[hw_idx].control = tempControl;
+    m_hbp_regs[hw_idx].address = tempAddr;
+
+    LLDB_LOG_ERROR(
+        log, std::move(error),
+        "unable to clear breakpoint: failed to write debug registers: {0}");
+    return false;
+  }
+
+  return true;
+}
+
+Status NativeRegisterContextDBReg_arm64::GetHardwareBreakHitIndex(
+    uint32_t &bp_index, lldb::addr_t trap_addr) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
+
+  LLDB_LOGF(log, "NativeRegisterContextDBReg_arm64::%s()", __FUNCTION__);
+
+  lldb::addr_t break_addr;
+
+  for (bp_index = 0; bp_index < m_max_hbp_supported; ++bp_index) {
+    break_addr = m_hbp_regs[bp_index].address;
+
+    if (BreakpointIsEnabled(bp_index) && trap_addr == break_addr) {
+      m_hbp_regs[bp_index].hit_addr = trap_addr;
+      return Status();
+    }
+  }
+
+  bp_index = LLDB_INVALID_INDEX32;
+  return Status();
+}
+
+Status NativeRegisterContextDBReg_arm64::ClearAllHardwareBreakpoints() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
+
+  LLDB_LOGF(log, "NativeRegisterContextDBReg_arm64::%s()", __FUNCTION__);
+
+  // Read hardware breakpoint and watchpoint information.
+  llvm::Error error = ReadHardwareDebugInfo();
+  if (error)
+    return Status(std::move(error));
+
+  for (uint32_t i = 0; i < m_max_hbp_supported; i++) {
+    if (BreakpointIsEnabled(i)) {
+      // Create a backup we can revert to in case of failure.
+      lldb::addr_t tempAddr = m_hbp_regs[i].address;
+      uint32_t tempControl = m_hbp_regs[i].control;
+
+      // Clear watchpoints in local cache
+      m_hbp_regs[i].control &= ~g_enable_bit;
+      m_hbp_regs[i].address = 0;
+
+      // Ptrace call to update hardware debug registers
+      error = WriteHardwareDebugRegs(eDREGTypeBREAK);
+
+      if (error) {
+        m_hbp_regs[i].control = tempControl;
+        m_hbp_regs[i].address = tempAddr;
+
+        return Status(std::move(error));
+      }
+    }
+  }
+
+  return Status();
+}
+
+bool NativeRegisterContextDBReg_arm64::BreakpointIsEnabled(uint32_t bp_index) {
+  if ((m_hbp_regs[bp_index].control & g_enable_bit) != 0)
+    return true;
+  else
+    return false;
+}
+
+uint32_t NativeRegisterContextDBReg_arm64::NumSupportedHardwareWatchpoints() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+  llvm::Error error = ReadHardwareDebugInfo();
+  if (error) {
+    LLDB_LOG_ERROR(log, std::move(error),
+                   "failed to read debug registers: {0}");
+    return 0;
+  }
+
+  return m_max_hwp_supported;
+}
+
+uint32_t NativeRegisterContextDBReg_arm64::SetHardwareWatchpoint(
+    lldb::addr_t addr, size_t size, uint32_t watch_flags) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+  LLDB_LOG(log, "addr: {0:x}, size: {1:x} watch_flags: {2:x}", addr, size,
+           watch_flags);
+
+  // Read hardware breakpoint and watchpoint information.
+  llvm::Error error = ReadHardwareDebugInfo();
+  if (error) {
+    LLDB_LOG_ERROR(
+        log, std::move(error),
+        "unable to set watchpoint: failed to read debug registers: {0}");
+    return LLDB_INVALID_INDEX32;
+  }
+
+  uint32_t control_value = 0, wp_index = 0;
+  lldb::addr_t real_addr = addr;
+
+  // Check if we are setting watchpoint other than read/write/access Also
+  // update watchpoint flag to match AArch64 write-read bit configuration.
+  switch (watch_flags) {
+  case 1:
+    watch_flags = 2;
+    break;
+  case 2:
+    watch_flags = 1;
+    break;
+  case 3:
+    break;
+  default:
+    return LLDB_INVALID_INDEX32;
+  }
+
+  // Check if size has a valid hardware watchpoint length.
+  if (size != 1 && size != 2 && size != 4 && size != 8)
+    return LLDB_INVALID_INDEX32;
+
+  // Check 8-byte alignment for hardware watchpoint target address. Below is a
+  // hack to recalculate address and size in order to make sure we can watch
+  // non 8-byte aligned addresses as well.
+  if (addr & 0x07) {
+    uint8_t watch_mask = (addr & 0x07) + size;
+
+    if (watch_mask > 0x08)
+      return LLDB_INVALID_INDEX32;
+    else if (watch_mask <= 0x02)
+      size = 2;
+    else if (watch_mask <= 0x04)
+      size = 4;
+    else
+      size = 8;
+
+    addr = addr & (~0x07);
+  }
+
+  // Setup control value
+  control_value = g_enable_bit | g_pac_bits | GetSizeBits(size);
+  control_value |= watch_flags << 3;
+
+  // Iterate over stored watchpoints and find a free wp_index
+  wp_index = LLDB_INVALID_INDEX32;
+  for (uint32_t i = 0; i < m_max_hwp_supported; i++) {
+    if (!WatchpointIsEnabled(i))
+      wp_index = i; // Mark last free slot
+    else if (m_hwp_regs[i].address == addr) {
+      return LLDB_INVALID_INDEX32; // We do not support duplicate watchpoints.
+    }
+  }
+
+  if (wp_index == LLDB_INVALID_INDEX32)
+    return LLDB_INVALID_INDEX32;
+
+  // Update watchpoint in local cache
+  m_hwp_regs[wp_index].real_addr = real_addr;
+  m_hwp_regs[wp_index].address = addr;
+  m_hwp_regs[wp_index].control = control_value;
+
+  // PTRACE call to set corresponding watchpoint register.
+  error = WriteHardwareDebugRegs(eDREGTypeWATCH);
+
+  if (error) {
+    m_hwp_regs[wp_index].address = 0;
+    m_hwp_regs[wp_index].control &= ~g_enable_bit;
+
+    LLDB_LOG_ERROR(
+        log, std::move(error),
+        "unable to set watchpoint: failed to write debug registers: {0}");
+    return LLDB_INVALID_INDEX32;
+  }
+
+  return wp_index;
+}
+
+bool NativeRegisterContextDBReg_arm64::ClearHardwareWatchpoint(
+    uint32_t wp_index) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+  LLDB_LOG(log, "wp_index: {0}", wp_index);
+
+  // Read hardware breakpoint and watchpoint information.
+  llvm::Error error = ReadHardwareDebugInfo();
+  if (error) {
+    LLDB_LOG_ERROR(
+        log, std::move(error),
+        "unable to clear watchpoint: failed to read debug registers: {0}");
+    return false;
+  }
+
+  if (wp_index >= m_max_hwp_supported)
+    return false;
+
+  // Create a backup we can revert to in case of failure.
+  lldb::addr_t tempAddr = m_hwp_regs[wp_index].address;
+  uint32_t tempControl = m_hwp_regs[wp_index].control;
+
+  // Update watchpoint in local cache
+  m_hwp_regs[wp_index].control &= ~g_enable_bit;
+  m_hwp_regs[wp_index].address = 0;
+
+  // Ptrace call to update hardware debug registers
+  error = WriteHardwareDebugRegs(eDREGTypeWATCH);
+
+  if (error) {
+    m_hwp_regs[wp_index].control = tempControl;
+    m_hwp_regs[wp_index].address = tempAddr;
+
+    LLDB_LOG_ERROR(
+        log, std::move(error),
+        "unable to clear watchpoint: failed to write debug registers: {0}");
+    return false;
+  }
+
+  return true;
+}
+
+Status NativeRegisterContextDBReg_arm64::ClearAllHardwareWatchpoints() {
+  // Read hardware breakpoint and watchpoint information.
+  llvm::Error error = ReadHardwareDebugInfo();
+  if (error)
+    return Status(std::move(error));
+
+  for (uint32_t i = 0; i < m_max_hwp_supported; i++) {
+    if (WatchpointIsEnabled(i)) {
+      // Create a backup we can revert to in case of failure.
+      lldb::addr_t tempAddr = m_hwp_regs[i].address;
+      uint32_t tempControl = m_hwp_regs[i].control;
+
+      // Clear watchpoints in local cache
+      m_hwp_regs[i].control &= ~g_enable_bit;
+      m_hwp_regs[i].address = 0;
+
+      // Ptrace call to update hardware debug registers
+      error = WriteHardwareDebugRegs(eDREGTypeWATCH);
+
+      if (error) {
+        m_hwp_regs[i].control = tempControl;
+        m_hwp_regs[i].address = tempAddr;
+
+        return Status(std::move(error));
+      }
+    }
+  }
+
+  return Status();
+}
+
+uint32_t
+NativeRegisterContextDBReg_arm64::GetWatchpointSize(uint32_t wp_index) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+  LLDB_LOG(log, "wp_index: {0}", wp_index);
+
+  switch ((m_hwp_regs[wp_index].control >> 5) & 0xff) {
+  case 0x01:
+    return 1;
+  case 0x03:
+    return 2;
+  case 0x0f:
+    return 4;
+  case 0xff:
+    return 8;
+  default:
+    return 0;
+  }
+}
+
+bool NativeRegisterContextDBReg_arm64::WatchpointIsEnabled(uint32_t wp_index) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+  LLDB_LOG(log, "wp_index: {0}", wp_index);
+
+  if ((m_hwp_regs[wp_index].control & g_enable_bit) != 0)
+    return true;
+  else
+    return false;
+}
+
+Status NativeRegisterContextDBReg_arm64::GetWatchpointHitIndex(
+    uint32_t &wp_index, lldb::addr_t trap_addr) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+  LLDB_LOG(log, "wp_index: {0}, trap_addr: {1:x}", wp_index, trap_addr);
+
+  // Read hardware breakpoint and watchpoint information.
+  llvm::Error error = ReadHardwareDebugInfo();
+  if (error)
+    return Status(std::move(error));
+
+  uint32_t watch_size;
+  lldb::addr_t watch_addr;
+
+  for (wp_index = 0; wp_index < m_max_hwp_supported; ++wp_index) {
+    watch_size = GetWatchpointSize(wp_index);
+    watch_addr = m_hwp_regs[wp_index].address;
+
+    if (WatchpointIsEnabled(wp_index) && trap_addr >= watch_addr &&
+        trap_addr < watch_addr + watch_size) {
+      m_hwp_regs[wp_index].hit_addr = trap_addr;
+      return Status();
+    }
+  }
+
+  wp_index = LLDB_INVALID_INDEX32;
+  return Status();
+}
+
+lldb::addr_t
+NativeRegisterContextDBReg_arm64::GetWatchpointAddress(uint32_t wp_index) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+  LLDB_LOG(log, "wp_index: {0}", wp_index);
+
+  if (wp_index >= m_max_hwp_supported)
+    return LLDB_INVALID_ADDRESS;
+
+  if (WatchpointIsEnabled(wp_index))
+    return m_hwp_regs[wp_index].real_addr;
+  return LLDB_INVALID_ADDRESS;
+}
+
+lldb::addr_t
+NativeRegisterContextDBReg_arm64::GetWatchpointHitAddress(uint32_t wp_index) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
+  LLDB_LOG(log, "wp_index: {0}", wp_index);
+
+  if (wp_index >= m_max_hwp_supported)
+    return LLDB_INVALID_ADDRESS;
+
+  if (WatchpointIsEnabled(wp_index))
+    return m_hwp_regs[wp_index].hit_addr;
+  return LLDB_INVALID_ADDRESS;
+}
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeRegisterContextDBReg_arm64.h b/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeRegisterContextDBReg_arm64.h
new file mode 100644
index 000000000000..12ef5571f64c
--- /dev/null
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeRegisterContextDBReg_arm64.h
@@ -0,0 +1,79 @@
+//===-- NativeRegisterContextDBReg_arm64.h ----------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef lldb_NativeRegisterContextDBReg_arm64_h
+#define lldb_NativeRegisterContextDBReg_arm64_h
+
+#include "Plugins/Process/Utility/NativeRegisterContextRegisterInfo.h"
+
+#include <array>
+
+namespace lldb_private {
+
+class NativeRegisterContextDBReg_arm64
+    : public virtual NativeRegisterContextRegisterInfo {
+public:
+  uint32_t NumSupportedHardwareBreakpoints() override;
+
+  uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
+
+  bool ClearHardwareBreakpoint(uint32_t hw_idx) override;
+
+  Status ClearAllHardwareBreakpoints() override;
+
+  Status GetHardwareBreakHitIndex(uint32_t &bp_index,
+                                  lldb::addr_t trap_addr) override;
+
+  bool BreakpointIsEnabled(uint32_t bp_index);
+
+  uint32_t NumSupportedHardwareWatchpoints() override;
+
+  uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size,
+                                 uint32_t watch_flags) override;
+
+  bool ClearHardwareWatchpoint(uint32_t hw_index) override;
+
+  Status ClearAllHardwareWatchpoints() override;
+
+  Status GetWatchpointHitIndex(uint32_t &wp_index,
+                               lldb::addr_t trap_addr) override;
+
+  lldb::addr_t GetWatchpointHitAddress(uint32_t wp_index) override;
+
+  lldb::addr_t GetWatchpointAddress(uint32_t wp_index) override;
+
+  uint32_t GetWatchpointSize(uint32_t wp_index);
+
+  bool WatchpointIsEnabled(uint32_t wp_index);
+
+  // Debug register type select
+  enum DREGType { eDREGTypeWATCH = 0, eDREGTypeBREAK };
+
+protected:
+  // Debug register info for hardware breakpoints and watchpoints management.
+  struct DREG {
+    lldb::addr_t address;  // Breakpoint/watchpoint address value.
+    lldb::addr_t hit_addr; // Address at which last watchpoint trigger exception
+                           // occurred.
+    lldb::addr_t real_addr; // Address value that should cause target to stop.
+    uint32_t control;       // Breakpoint/watchpoint control value.
+  };
+
+  std::array<struct DREG, 16> m_hbp_regs; // hardware breakpoints
+  std::array<struct DREG, 16> m_hwp_regs; // hardware watchpoints
+
+  uint32_t m_max_hbp_supported;
+  uint32_t m_max_hwp_supported;
+
+  virtual llvm::Error ReadHardwareDebugInfo() = 0;
+  virtual llvm::Error WriteHardwareDebugRegs(DREGType hwbType) = 0;
+};
+
+} // namespace lldb_private
+
+#endif // #ifndef lldb_NativeRegisterContextDBReg_arm64_h
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeRegisterContextWatchpoint_x86.cpp b/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeRegisterContextDBReg_x86.cpp
index 0f57f2ed3f35..56c1757ee89d 100644
--- a/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeRegisterContextWatchpoint_x86.cpp
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeRegisterContextDBReg_x86.cpp
@@ -1,4 +1,4 @@
-//===-- NativeRegisterContextWatchpoint_x86.cpp ---------------------------===//
+//===-- NativeRegisterContextDBReg_x86.cpp --------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "NativeRegisterContextWatchpoint_x86.h"
+#include "NativeRegisterContextDBReg_x86.h"
 
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
@@ -80,7 +80,7 @@ static inline uint64_t GetWatchControlBitmask(uint32_t wp_index) {
 // Bit mask for control bits regarding all watchpoints.
 static constexpr uint64_t watchpoint_all_control_bit_mask = 0xFFFF00FF;
 
-const RegisterInfo *NativeRegisterContextWatchpoint_x86::GetDR(int num) const {
+const RegisterInfo *NativeRegisterContextDBReg_x86::GetDR(int num) const {
   assert(num >= 0 && num <= 7);
   switch (GetRegisterInfoInterface().GetTargetArchitecture().GetMachine()) {
   case llvm::Triple::x86:
@@ -92,8 +92,8 @@ const RegisterInfo *NativeRegisterContextWatchpoint_x86::GetDR(int num) const {
   }
 }
 
-Status NativeRegisterContextWatchpoint_x86::IsWatchpointHit(uint32_t wp_index,
-                                                            bool &is_hit) {
+Status NativeRegisterContextDBReg_x86::IsWatchpointHit(uint32_t wp_index,
+                                                       bool &is_hit) {
   if (wp_index >= NumSupportedHardwareWatchpoints())
     return Status("Watchpoint index out of range");
 
@@ -107,8 +107,9 @@ Status NativeRegisterContextWatchpoint_x86::IsWatchpointHit(uint32_t wp_index,
   return error;
 }
 
-Status NativeRegisterContextWatchpoint_x86::GetWatchpointHitIndex(
-    uint32_t &wp_index, lldb::addr_t trap_addr) {
+Status
+NativeRegisterContextDBReg_x86::GetWatchpointHitIndex(uint32_t &wp_index,
+                                                      lldb::addr_t trap_addr) {
   uint32_t num_hw_wps = NumSupportedHardwareWatchpoints();
   for (wp_index = 0; wp_index < num_hw_wps; ++wp_index) {
     bool is_hit;
@@ -124,9 +125,8 @@ Status NativeRegisterContextWatchpoint_x86::GetWatchpointHitIndex(
   return Status();
 }
 
-Status
-NativeRegisterContextWatchpoint_x86::IsWatchpointVacant(uint32_t wp_index,
-                                                        bool &is_vacant) {
+Status NativeRegisterContextDBReg_x86::IsWatchpointVacant(uint32_t wp_index,
+                                                          bool &is_vacant) {
   if (wp_index >= NumSupportedHardwareWatchpoints())
     return Status("Watchpoint index out of range");
 
@@ -140,7 +140,7 @@ NativeRegisterContextWatchpoint_x86::IsWatchpointVacant(uint32_t wp_index,
   return error;
 }
 
-Status NativeRegisterContextWatchpoint_x86::SetHardwareWatchpointWithIndex(
+Status NativeRegisterContextDBReg_x86::SetHardwareWatchpointWithIndex(
     lldb::addr_t addr, size_t size, uint32_t watch_flags, uint32_t wp_index) {
 
   if (wp_index >= NumSupportedHardwareWatchpoints())
@@ -202,7 +202,7 @@ Status NativeRegisterContextWatchpoint_x86::SetHardwareWatchpointWithIndex(
   return error;
 }
 
-bool NativeRegisterContextWatchpoint_x86::ClearHardwareWatchpoint(
+bool NativeRegisterContextDBReg_x86::ClearHardwareWatchpoint(
     uint32_t wp_index) {
   if (wp_index >= NumSupportedHardwareWatchpoints())
     return false;
@@ -217,8 +217,7 @@ bool NativeRegisterContextWatchpoint_x86::ClearHardwareWatchpoint(
       .Success();
 }
 
-Status
-NativeRegisterContextWatchpoint_x86::ClearWatchpointHit(uint32_t wp_index) {
+Status NativeRegisterContextDBReg_x86::ClearWatchpointHit(uint32_t wp_index) {
   if (wp_index >= NumSupportedHardwareWatchpoints())
     return Status("Watchpoint index out of range");
 
@@ -231,7 +230,7 @@ NativeRegisterContextWatchpoint_x86::ClearWatchpointHit(uint32_t wp_index) {
       GetDR(6), RegisterValue(dr6.GetAsUInt64() & ~GetStatusBit(wp_index)));
 }
 
-Status NativeRegisterContextWatchpoint_x86::ClearAllHardwareWatchpoints() {
+Status NativeRegisterContextDBReg_x86::ClearAllHardwareWatchpoints() {
   RegisterValue dr7;
   Status error = ReadRegister(GetDR(7), dr7);
   if (error.Fail())
@@ -241,7 +240,7 @@ Status NativeRegisterContextWatchpoint_x86::ClearAllHardwareWatchpoints() {
       RegisterValue(dr7.GetAsUInt64() & ~watchpoint_all_control_bit_mask));
 }
 
-uint32_t NativeRegisterContextWatchpoint_x86::SetHardwareWatchpoint(
+uint32_t NativeRegisterContextDBReg_x86::SetHardwareWatchpoint(
     lldb::addr_t addr, size_t size, uint32_t watch_flags) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
   const uint32_t num_hw_watchpoints = NumSupportedHardwareWatchpoints();
@@ -254,7 +253,7 @@ uint32_t NativeRegisterContextWatchpoint_x86::SetHardwareWatchpoint(
         return wp_index;
     }
     if (error.Fail() && log) {
-      LLDB_LOGF(log, "NativeRegisterContextWatchpoint_x86::%s Error: %s",
+      LLDB_LOGF(log, "NativeRegisterContextDBReg_x86::%s Error: %s",
                 __FUNCTION__, error.AsCString());
     }
   }
@@ -262,7 +261,7 @@ uint32_t NativeRegisterContextWatchpoint_x86::SetHardwareWatchpoint(
 }
 
 lldb::addr_t
-NativeRegisterContextWatchpoint_x86::GetWatchpointAddress(uint32_t wp_index) {
+NativeRegisterContextDBReg_x86::GetWatchpointAddress(uint32_t wp_index) {
   if (wp_index >= NumSupportedHardwareWatchpoints())
     return LLDB_INVALID_ADDRESS;
   RegisterValue drN;
@@ -271,8 +270,7 @@ NativeRegisterContextWatchpoint_x86::GetWatchpointAddress(uint32_t wp_index) {
   return drN.GetAsUInt64();
 }
 
-uint32_t
-NativeRegisterContextWatchpoint_x86::NumSupportedHardwareWatchpoints() {
+uint32_t NativeRegisterContextDBReg_x86::NumSupportedHardwareWatchpoints() {
   // Available debug address registers: dr0, dr1, dr2, dr3
   return 4;
 }
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeRegisterContextWatchpoint_x86.h b/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeRegisterContextDBReg_x86.h
index cfb8900a4fd2..c0c6ce29eab5 100644
--- a/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeRegisterContextWatchpoint_x86.h
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/Utility/NativeRegisterContextDBReg_x86.h
@@ -1,4 +1,4 @@
-//===-- NativeRegisterContextWatchpoint_x86.h -------------------*- C++ -*-===//
+//===-- NativeRegisterContextDBReg_x86.h ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,14 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef lldb_NativeRegisterContextWatchpoint_x86_h
-#define lldb_NativeRegisterContextWatchpoint_x86_h
+#ifndef lldb_NativeRegisterContextDBReg_x86_h
+#define lldb_NativeRegisterContextDBReg_x86_h
 
 #include "Plugins/Process/Utility/NativeRegisterContextRegisterInfo.h"
 
 namespace lldb_private {
 
-class NativeRegisterContextWatchpoint_x86
+class NativeRegisterContextDBReg_x86
     : public virtual NativeRegisterContextRegisterInfo {
 public:
   Status IsWatchpointHit(uint32_t wp_index, bool &is_hit) override;
@@ -45,4 +45,4 @@ public:
 
 } // namespace lldb_private
 
-#endif // #ifndef lldb_NativeRegisterContextWatchpoint_x86_h
+#endif // #ifndef lldb_NativeRegisterContextDBReg_x86_h
diff --git a/contrib/llvm-project/lldb/source/Plugins/Process/Utility/RegisterInfos_powerpc.h b/contrib/llvm-project/lldb/source/Plugins/Process/Utility/RegisterInfos_powerpc.h
index 51be31f8e028..90863dfdb090 100644
--- a/contrib/llvm-project/lldb/source/Plugins/Process/Utility/RegisterInfos_powerpc.h
+++ b/contrib/llvm-project/lldb/source/Plugins/Process/Utility/RegisterInfos_powerpc.h
@@ -10,8 +10,8 @@
 
 // Computes the offset of the given GPR in the user data area.
 #define GPR_OFFSET(regname) (offsetof(GPR, regname))
-#define FPR_OFFSET(regname) (offsetof(FPR, regname))
-#define VMX_OFFSET(regname) (offsetof(VMX, regname))
+#define FPR_OFFSET(regname) (sizeof(GPR) + offsetof(FPR, regname))
+#define VMX_OFFSET(regname) (sizeof(GPR) + sizeof(FPR) + offsetof(VMX, regname))
 #define GPR_SIZE(regname) (sizeof(((GPR *)NULL)->regname))
 
 #ifdef DECLARE_REGISTER_INFOS_POWERPC_STRUCT