vendor/llvm-project/llvmorg-11-init-20887-g2e10b7a39b9vendor/llvm-project/master

43 files changed, 2095 insertions, 6973 deletions

diff --git a/lldb/source/Plugins/ABI/AArch64/ABIAArch64.cpp b/lldb/source/Plugins/ABI/AArch64/ABIAArch64.cpp
new file mode 100644
index 0000000000000..5cf9fb4ad37f9
--- /dev/null
+++ b/lldb/source/Plugins/ABI/AArch64/ABIAArch64.cpp
@@ -0,0 +1,52 @@
+//===-- AArch66.h ---------------------------------------------------------===//
+//
+// 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 "ABIAArch64.h"
+#include "ABIMacOSX_arm64.h"
+#include "ABISysV_arm64.h"
+#include "Utility/ARM64_DWARF_Registers.h"
+#include "lldb/Core/PluginManager.h"
+
+LLDB_PLUGIN_DEFINE(ABIAArch64)
+
+void ABIAArch64::Initialize() {
+  ABISysV_arm64::Initialize();
+  ABIMacOSX_arm64::Initialize();
+}
+
+void ABIAArch64::Terminate() {
+  ABISysV_arm64::Terminate();
+  ABIMacOSX_arm64::Terminate();
+}
+
+std::pair<uint32_t, uint32_t>
+ABIAArch64::GetEHAndDWARFNums(llvm::StringRef name) {
+  if (name == "pc")
+    return {LLDB_INVALID_REGNUM, arm64_dwarf::pc};
+  if (name == "cpsr")
+    return {LLDB_INVALID_REGNUM, arm64_dwarf::cpsr};
+  return MCBasedABI::GetEHAndDWARFNums(name);
+}
+
+uint32_t ABIAArch64::GetGenericNum(llvm::StringRef name) {
+  return llvm::StringSwitch<uint32_t>(name)
+      .Case("pc", LLDB_REGNUM_GENERIC_PC)
+      .Case("lr", LLDB_REGNUM_GENERIC_RA)
+      .Case("sp", LLDB_REGNUM_GENERIC_SP)
+      .Case("fp", LLDB_REGNUM_GENERIC_FP)
+      .Case("cpsr", LLDB_REGNUM_GENERIC_FLAGS)
+      .Case("x0", LLDB_REGNUM_GENERIC_ARG1)
+      .Case("x1", LLDB_REGNUM_GENERIC_ARG2)
+      .Case("x2", LLDB_REGNUM_GENERIC_ARG3)
+      .Case("x3", LLDB_REGNUM_GENERIC_ARG4)
+      .Case("x4", LLDB_REGNUM_GENERIC_ARG5)
+      .Case("x5", LLDB_REGNUM_GENERIC_ARG6)
+      .Case("x6", LLDB_REGNUM_GENERIC_ARG7)
+      .Case("x7", LLDB_REGNUM_GENERIC_ARG8)
+      .Default(LLDB_INVALID_REGNUM);
+}
diff --git a/lldb/source/Plugins/ABI/AArch64/ABIAArch64.h b/lldb/source/Plugins/ABI/AArch64/ABIAArch64.h
new file mode 100644
index 0000000000000..981145e2017e3
--- /dev/null
+++ b/lldb/source/Plugins/ABI/AArch64/ABIAArch64.h
@@ -0,0 +1,32 @@
+//===-- AArch64.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_SOURCE_PLUGINS_ABI_AARCH64_ABIAARCH64_H
+#define LLDB_SOURCE_PLUGINS_ABI_AARCH64_ABIAARCH64_H
+
+#include "lldb/Target/ABI.h"
+
+class ABIAArch64: public lldb_private::MCBasedABI {
+public:
+  static void Initialize();
+  static void Terminate();
+
+protected:
+  std::pair<uint32_t, uint32_t>
+  GetEHAndDWARFNums(llvm::StringRef name) override;
+
+  std::string GetMCName(std::string reg) override {
+    MapRegisterName(reg, "v", "q");
+    return reg;
+  }
+
+  uint32_t GetGenericNum(llvm::StringRef name) override;
+
+  using lldb_private::MCBasedABI::MCBasedABI;
+};
+#endif
diff --git a/lldb/source/Plugins/ABI/AArch64/ABIMacOSX_arm64.cpp b/lldb/source/Plugins/ABI/AArch64/ABIMacOSX_arm64.cpp
new file mode 100644
index 0000000000000..983da26a2a6df
--- /dev/null
+++ b/lldb/source/Plugins/ABI/AArch64/ABIMacOSX_arm64.cpp
@@ -0,0 +1,831 @@
+//===-- ABIMacOSX_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 "ABIMacOSX_arm64.h"
+
+#include <vector>
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/Triple.h"
+
+#include "lldb/Core/Module.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Value.h"
+#include "lldb/Core/ValueObjectConstResult.h"
+#include "lldb/Symbol/UnwindPlan.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
+#include "lldb/Utility/Status.h"
+
+#include "Utility/ARM64_DWARF_Registers.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+static const char *pluginDesc = "Mac OS X ABI for arm64 targets";
+
+size_t ABIMacOSX_arm64::GetRedZoneSize() const { return 128; }
+
+// Static Functions
+
+ABISP
+ABIMacOSX_arm64::CreateInstance(ProcessSP process_sp, const ArchSpec &arch) {
+  const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
+  const llvm::Triple::VendorType vendor_type = arch.GetTriple().getVendor();
+
+  if (vendor_type == llvm::Triple::Apple) {
+    if (arch_type == llvm::Triple::aarch64 ||
+        arch_type == llvm::Triple::aarch64_32) {
+      return ABISP(
+          new ABIMacOSX_arm64(std::move(process_sp), MakeMCRegisterInfo(arch)));
+    }
+  }
+
+  return ABISP();
+}
+
+bool ABIMacOSX_arm64::PrepareTrivialCall(
+    Thread &thread, lldb::addr_t sp, lldb::addr_t func_addr,
+    lldb::addr_t return_addr, llvm::ArrayRef<lldb::addr_t> args) const {
+  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
+  if (!reg_ctx)
+    return false;
+
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
+
+  if (log) {
+    StreamString s;
+    s.Printf("ABISysV_x86_64::PrepareTrivialCall (tid = 0x%" PRIx64
+             ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64
+             ", return_addr = 0x%" PRIx64,
+             thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
+             (uint64_t)return_addr);
+
+    for (size_t i = 0; i < args.size(); ++i)
+      s.Printf(", arg%d = 0x%" PRIx64, static_cast<int>(i + 1), args[i]);
+    s.PutCString(")");
+    log->PutString(s.GetString());
+  }
+
+  const uint32_t pc_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
+      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
+  const uint32_t sp_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
+      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
+  const uint32_t ra_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
+      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA);
+
+  // x0 - x7 contain first 8 simple args
+  if (args.size() > 8) // TODO handle more than 6 arguments
+    return false;
+
+  for (size_t i = 0; i < args.size(); ++i) {
+    const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
+        eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + i);
+    LLDB_LOGF(log, "About to write arg%d (0x%" PRIx64 ") into %s",
+              static_cast<int>(i + 1), args[i], reg_info->name);
+    if (!reg_ctx->WriteRegisterFromUnsigned(reg_info, args[i]))
+      return false;
+  }
+
+  // Set "lr" to the return address
+  if (!reg_ctx->WriteRegisterFromUnsigned(
+          reg_ctx->GetRegisterInfoAtIndex(ra_reg_num), return_addr))
+    return false;
+
+  // Set "sp" to the requested value
+  if (!reg_ctx->WriteRegisterFromUnsigned(
+          reg_ctx->GetRegisterInfoAtIndex(sp_reg_num), sp))
+    return false;
+
+  // Set "pc" to the address requested
+  if (!reg_ctx->WriteRegisterFromUnsigned(
+          reg_ctx->GetRegisterInfoAtIndex(pc_reg_num), func_addr))
+    return false;
+
+  return true;
+}
+
+bool ABIMacOSX_arm64::GetArgumentValues(Thread &thread,
+                                        ValueList &values) const {
+  uint32_t num_values = values.GetSize();
+
+  ExecutionContext exe_ctx(thread.shared_from_this());
+
+  // Extract the register context so we can read arguments from registers
+
+  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
+
+  if (!reg_ctx)
+    return false;
+
+  addr_t sp = 0;
+
+  for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
+    // We currently only support extracting values with Clang QualTypes. Do we
+    // care about others?
+    Value *value = values.GetValueAtIndex(value_idx);
+
+    if (!value)
+      return false;
+
+    CompilerType value_type = value->GetCompilerType();
+    llvm::Optional<uint64_t> bit_size = value_type.GetBitSize(&thread);
+    if (!bit_size)
+      return false;
+
+    bool is_signed = false;
+    size_t bit_width = 0;
+    if (value_type.IsIntegerOrEnumerationType(is_signed)) {
+      bit_width = *bit_size;
+    } else if (value_type.IsPointerOrReferenceType()) {
+      bit_width = *bit_size;
+    } else {
+      // We only handle integer, pointer and reference types currently...
+      return false;
+    }
+
+    if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) {
+      if (value_idx < 8) {
+        // Arguments 1-6 are in x0-x5...
+        const RegisterInfo *reg_info = nullptr;
+        // Search by generic ID first, then fall back to by name
+        uint32_t arg_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
+            eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + value_idx);
+        if (arg_reg_num != LLDB_INVALID_REGNUM) {
+          reg_info = reg_ctx->GetRegisterInfoAtIndex(arg_reg_num);
+        } else {
+          switch (value_idx) {
+          case 0:
+            reg_info = reg_ctx->GetRegisterInfoByName("x0");
+            break;
+          case 1:
+            reg_info = reg_ctx->GetRegisterInfoByName("x1");
+            break;
+          case 2:
+            reg_info = reg_ctx->GetRegisterInfoByName("x2");
+            break;
+          case 3:
+            reg_info = reg_ctx->GetRegisterInfoByName("x3");
+            break;
+          case 4:
+            reg_info = reg_ctx->GetRegisterInfoByName("x4");
+            break;
+          case 5:
+            reg_info = reg_ctx->GetRegisterInfoByName("x5");
+            break;
+          case 6:
+            reg_info = reg_ctx->GetRegisterInfoByName("x6");
+            break;
+          case 7:
+            reg_info = reg_ctx->GetRegisterInfoByName("x7");
+            break;
+          }
+        }
+
+        if (reg_info) {
+          RegisterValue reg_value;
+
+          if (reg_ctx->ReadRegister(reg_info, reg_value)) {
+            if (is_signed)
+              reg_value.SignExtend(bit_width);
+            if (!reg_value.GetScalarValue(value->GetScalar()))
+              return false;
+            continue;
+          }
+        }
+        return false;
+      } else {
+        if (sp == 0) {
+          // Read the stack pointer if we already haven't read it
+          sp = reg_ctx->GetSP(0);
+          if (sp == 0)
+            return false;
+        }
+
+        // Arguments 5 on up are on the stack
+        const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
+        Status error;
+        if (!exe_ctx.GetProcessRef().ReadScalarIntegerFromMemory(
+                sp, arg_byte_size, is_signed, value->GetScalar(), error))
+          return false;
+
+        sp += arg_byte_size;
+        // Align up to the next 8 byte boundary if needed
+        if (sp % 8) {
+          sp >>= 3;
+          sp += 1;
+          sp <<= 3;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+Status
+ABIMacOSX_arm64::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
+                                      lldb::ValueObjectSP &new_value_sp) {
+  Status error;
+  if (!new_value_sp) {
+    error.SetErrorString("Empty value object for return value.");
+    return error;
+  }
+
+  CompilerType return_value_type = new_value_sp->GetCompilerType();
+  if (!return_value_type) {
+    error.SetErrorString("Null clang type for return value.");
+    return error;
+  }
+
+  Thread *thread = frame_sp->GetThread().get();
+
+  RegisterContext *reg_ctx = thread->GetRegisterContext().get();
+
+  if (reg_ctx) {
+    DataExtractor data;
+    Status data_error;
+    const uint64_t byte_size = new_value_sp->GetData(data, data_error);
+    if (data_error.Fail()) {
+      error.SetErrorStringWithFormat(
+          "Couldn't convert return value to raw data: %s",
+          data_error.AsCString());
+      return error;
+    }
+
+    const uint32_t type_flags = return_value_type.GetTypeInfo(nullptr);
+    if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
+      if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
+        // Extract the register context so we can read arguments from registers
+        lldb::offset_t offset = 0;
+        if (byte_size <= 16) {
+          const RegisterInfo *x0_info = reg_ctx->GetRegisterInfoByName("x0", 0);
+          if (byte_size <= 8) {
+            uint64_t raw_value = data.GetMaxU64(&offset, byte_size);
+
+            if (!reg_ctx->WriteRegisterFromUnsigned(x0_info, raw_value))
+              error.SetErrorString("failed to write register x0");
+          } else {
+            uint64_t raw_value = data.GetMaxU64(&offset, 8);
+
+            if (reg_ctx->WriteRegisterFromUnsigned(x0_info, raw_value)) {
+              const RegisterInfo *x1_info =
+                  reg_ctx->GetRegisterInfoByName("x1", 0);
+              raw_value = data.GetMaxU64(&offset, byte_size - offset);
+
+              if (!reg_ctx->WriteRegisterFromUnsigned(x1_info, raw_value))
+                error.SetErrorString("failed to write register x1");
+            }
+          }
+        } else {
+          error.SetErrorString("We don't support returning longer than 128 bit "
+                               "integer values at present.");
+        }
+      } else if (type_flags & eTypeIsFloat) {
+        if (type_flags & eTypeIsComplex) {
+          // Don't handle complex yet.
+          error.SetErrorString(
+              "returning complex float values are not supported");
+        } else {
+          const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
+
+          if (v0_info) {
+            if (byte_size <= 16) {
+              if (byte_size <= RegisterValue::GetMaxByteSize()) {
+                RegisterValue reg_value;
+                error = reg_value.SetValueFromData(v0_info, data, 0, true);
+                if (error.Success()) {
+                  if (!reg_ctx->WriteRegister(v0_info, reg_value))
+                    error.SetErrorString("failed to write register v0");
+                }
+              } else {
+                error.SetErrorStringWithFormat(
+                    "returning float values with a byte size of %" PRIu64
+                    " are not supported",
+                    byte_size);
+              }
+            } else {
+              error.SetErrorString("returning float values longer than 128 "
+                                   "bits are not supported");
+            }
+          } else {
+            error.SetErrorString("v0 register is not available on this target");
+          }
+        }
+      }
+    } else if (type_flags & eTypeIsVector) {
+      if (byte_size > 0) {
+        const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
+
+        if (v0_info) {
+          if (byte_size <= v0_info->byte_size) {
+            RegisterValue reg_value;
+            error = reg_value.SetValueFromData(v0_info, data, 0, true);
+            if (error.Success()) {
+              if (!reg_ctx->WriteRegister(v0_info, reg_value))
+                error.SetErrorString("failed to write register v0");
+            }
+          }
+        }
+      }
+    }
+  } else {
+    error.SetErrorString("no registers are available");
+  }
+
+  return error;
+}
+
+bool ABIMacOSX_arm64::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) {
+  unwind_plan.Clear();
+  unwind_plan.SetRegisterKind(eRegisterKindDWARF);
+
+  uint32_t lr_reg_num = arm64_dwarf::lr;
+  uint32_t sp_reg_num = arm64_dwarf::sp;
+  uint32_t pc_reg_num = arm64_dwarf::pc;
+
+  UnwindPlan::RowSP row(new UnwindPlan::Row);
+
+  // Our previous Call Frame Address is the stack pointer
+  row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
+
+  // Our previous PC is in the LR
+  row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
+
+  unwind_plan.AppendRow(row);
+
+  // All other registers are the same.
+
+  unwind_plan.SetSourceName("arm64 at-func-entry default");
+  unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
+
+  return true;
+}
+
+bool ABIMacOSX_arm64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
+  unwind_plan.Clear();
+  unwind_plan.SetRegisterKind(eRegisterKindDWARF);
+
+  uint32_t fp_reg_num = arm64_dwarf::fp;
+  uint32_t pc_reg_num = arm64_dwarf::pc;
+
+  UnwindPlan::RowSP row(new UnwindPlan::Row);
+  const int32_t ptr_size = 8;
+
+  row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
+  row->SetOffset(0);
+
+  row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
+  row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
+
+  unwind_plan.AppendRow(row);
+  unwind_plan.SetSourceName("arm64-apple-darwin default unwind plan");
+  unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
+  return true;
+}
+
+// AAPCS64 (Procedure Call Standard for the ARM 64-bit Architecture) says
+// registers x19 through x28 and sp are callee preserved. v8-v15 are non-
+// volatile (and specifically only the lower 8 bytes of these regs), the rest
+// of the fp/SIMD registers are volatile.
+//
+// v. https://github.com/ARM-software/abi-aa/blob/master/aapcs64/
+
+// We treat x29 as callee preserved also, else the unwinder won't try to
+// retrieve fp saves.
+
+bool ABIMacOSX_arm64::RegisterIsVolatile(const RegisterInfo *reg_info) {
+  if (reg_info) {
+    const char *name = reg_info->name;
+
+    // Sometimes we'll be called with the "alternate" name for these registers;
+    // recognize them as non-volatile.
+
+    if (name[0] == 'p' && name[1] == 'c') // pc
+      return false;
+    if (name[0] == 'f' && name[1] == 'p') // fp
+      return false;
+    if (name[0] == 's' && name[1] == 'p') // sp
+      return false;
+    if (name[0] == 'l' && name[1] == 'r') // lr
+      return false;
+
+    if (name[0] == 'x') {
+      // Volatile registers: x0-x18, x30 (lr)
+      // Return false for the non-volatile gpr regs, true for everything else
+      switch (name[1]) {
+      case '1':
+        switch (name[2]) {
+        case '9':
+          return false; // x19 is non-volatile
+        default:
+          return true;
+        }
+        break;
+      case '2':
+        switch (name[2]) {
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+          return false; // x20 - 28 are non-volatile
+        case '9':
+          return false; // x29 aka fp treat as non-volatile on Darwin
+        default:
+          return true;
+        }
+      case '3': // x30 aka lr treat as non-volatile
+        if (name[2] == '0')
+          return false;
+        break;
+      default:
+        return true;
+      }
+    } else if (name[0] == 'v' || name[0] == 's' || name[0] == 'd') {
+      // Volatile registers: v0-7, v16-v31
+      // Return false for non-volatile fp/SIMD regs, true for everything else
+      switch (name[1]) {
+      case '8':
+      case '9':
+        return false; // v8-v9 are non-volatile
+      case '1':
+        switch (name[2]) {
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+          return false; // v10-v15 are non-volatile
+        default:
+          return true;
+        }
+      default:
+        return true;
+      }
+    }
+  }
+  return true;
+}
+
+static bool LoadValueFromConsecutiveGPRRegisters(
+    ExecutionContext &exe_ctx, RegisterContext *reg_ctx,
+    const CompilerType &value_type,
+    bool is_return_value, // false => parameter, true => return value
+    uint32_t &NGRN,       // NGRN (see ABI documentation)
+    uint32_t &NSRN,       // NSRN (see ABI documentation)
+    DataExtractor &data) {
+  llvm::Optional<uint64_t> byte_size = value_type.GetByteSize(nullptr);
+  if (!byte_size || *byte_size == 0)
+    return false;
+
+  std::unique_ptr<DataBufferHeap> heap_data_up(
+      new DataBufferHeap(*byte_size, 0));
+  const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
+  Status error;
+
+  CompilerType base_type;
+  const uint32_t homogeneous_count =
+      value_type.IsHomogeneousAggregate(&base_type);
+  if (homogeneous_count > 0 && homogeneous_count <= 8) {
+    // Make sure we have enough registers
+    if (NSRN < 8 && (8 - NSRN) >= homogeneous_count) {
+      if (!base_type)
+        return false;
+      llvm::Optional<uint64_t> base_byte_size = base_type.GetByteSize(nullptr);
+      if (!base_byte_size)
+        return false;
+      uint32_t data_offset = 0;
+
+      for (uint32_t i = 0; i < homogeneous_count; ++i) {
+        char v_name[8];
+        ::snprintf(v_name, sizeof(v_name), "v%u", NSRN);
+        const RegisterInfo *reg_info =
+            reg_ctx->GetRegisterInfoByName(v_name, 0);
+        if (reg_info == nullptr)
+          return false;
+
+        if (*base_byte_size > reg_info->byte_size)
+          return false;
+
+        RegisterValue reg_value;
+
+        if (!reg_ctx->ReadRegister(reg_info, reg_value))
+          return false;
+
+        // Make sure we have enough room in "heap_data_up"
+        if ((data_offset + *base_byte_size) <= heap_data_up->GetByteSize()) {
+          const size_t bytes_copied = reg_value.GetAsMemoryData(
+              reg_info, heap_data_up->GetBytes() + data_offset, *base_byte_size,
+              byte_order, error);
+          if (bytes_copied != *base_byte_size)
+            return false;
+          data_offset += bytes_copied;
+          ++NSRN;
+        } else
+          return false;
+      }
+      data.SetByteOrder(byte_order);
+      data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize());
+      data.SetData(DataBufferSP(heap_data_up.release()));
+      return true;
+    }
+  }
+
+  const size_t max_reg_byte_size = 16;
+  if (*byte_size <= max_reg_byte_size) {
+    size_t bytes_left = *byte_size;
+    uint32_t data_offset = 0;
+    while (data_offset < *byte_size) {
+      if (NGRN >= 8)
+        return false;
+
+      uint32_t reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
+          eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + NGRN);
+      if (reg_num == LLDB_INVALID_REGNUM)
+        return false;
+
+      const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_num);
+      if (reg_info == nullptr)
+        return false;
+
+      RegisterValue reg_value;
+
+      if (!reg_ctx->ReadRegister(reg_info, reg_value))
+        return false;
+
+      const size_t curr_byte_size = std::min<size_t>(8, bytes_left);
+      const size_t bytes_copied = reg_value.GetAsMemoryData(
+          reg_info, heap_data_up->GetBytes() + data_offset, curr_byte_size,
+          byte_order, error);
+      if (bytes_copied == 0)
+        return false;
+      if (bytes_copied >= bytes_left)
+        break;
+      data_offset += bytes_copied;
+      bytes_left -= bytes_copied;
+      ++NGRN;
+    }
+  } else {
+    const RegisterInfo *reg_info = nullptr;
+    if (is_return_value) {
+      // We are assuming we are decoding this immediately after returning from
+      // a function call and that the address of the structure is in x8
+      reg_info = reg_ctx->GetRegisterInfoByName("x8", 0);
+    } else {
+      // We are assuming we are stopped at the first instruction in a function
+      // and that the ABI is being respected so all parameters appear where
+      // they should be (functions with no external linkage can legally violate
+      // the ABI).
+      if (NGRN >= 8)
+        return false;
+
+      uint32_t reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
+          eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + NGRN);
+      if (reg_num == LLDB_INVALID_REGNUM)
+        return false;
+      reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_num);
+      if (reg_info == nullptr)
+        return false;
+      ++NGRN;
+    }
+
+    if (reg_info == nullptr)
+      return false;
+
+    const lldb::addr_t value_addr =
+        reg_ctx->ReadRegisterAsUnsigned(reg_info, LLDB_INVALID_ADDRESS);
+
+    if (value_addr == LLDB_INVALID_ADDRESS)
+      return false;
+
+    if (exe_ctx.GetProcessRef().ReadMemory(
+            value_addr, heap_data_up->GetBytes(), heap_data_up->GetByteSize(),
+            error) != heap_data_up->GetByteSize()) {
+      return false;
+    }
+  }
+
+  data.SetByteOrder(byte_order);
+  data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize());
+  data.SetData(DataBufferSP(heap_data_up.release()));
+  return true;
+}
+
+ValueObjectSP ABIMacOSX_arm64::GetReturnValueObjectImpl(
+    Thread &thread, CompilerType &return_compiler_type) const {
+  ValueObjectSP return_valobj_sp;
+  Value value;
+
+  ExecutionContext exe_ctx(thread.shared_from_this());
+  if (exe_ctx.GetTargetPtr() == nullptr || exe_ctx.GetProcessPtr() == nullptr)
+    return return_valobj_sp;
+
+  // value.SetContext (Value::eContextTypeClangType, return_compiler_type);
+  value.SetCompilerType(return_compiler_type);
+
+  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
+  if (!reg_ctx)
+    return return_valobj_sp;
+
+  llvm::Optional<uint64_t> byte_size =
+      return_compiler_type.GetByteSize(nullptr);
+  if (!byte_size)
+    return return_valobj_sp;
+
+  const uint32_t type_flags = return_compiler_type.GetTypeInfo(nullptr);
+  if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
+    value.SetValueType(Value::eValueTypeScalar);
+
+    bool success = false;
+    if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
+      // Extract the register context so we can read arguments from registers
+      if (*byte_size <= 8) {
+        const RegisterInfo *x0_reg_info =
+            reg_ctx->GetRegisterInfoByName("x0", 0);
+        if (x0_reg_info) {
+          uint64_t raw_value =
+              thread.GetRegisterContext()->ReadRegisterAsUnsigned(x0_reg_info,
+                                                                  0);
+          const bool is_signed = (type_flags & eTypeIsSigned) != 0;
+          switch (*byte_size) {
+          default:
+            break;
+          case 16: // uint128_t
+            // In register x0 and x1
+            {
+              const RegisterInfo *x1_reg_info =
+                  reg_ctx->GetRegisterInfoByName("x1", 0);
+
+              if (x1_reg_info) {
+                if (*byte_size <=
+                    x0_reg_info->byte_size + x1_reg_info->byte_size) {
+                  std::unique_ptr<DataBufferHeap> heap_data_up(
+                      new DataBufferHeap(*byte_size, 0));
+                  const ByteOrder byte_order =
+                      exe_ctx.GetProcessRef().GetByteOrder();
+                  RegisterValue x0_reg_value;
+                  RegisterValue x1_reg_value;
+                  if (reg_ctx->ReadRegister(x0_reg_info, x0_reg_value) &&
+                      reg_ctx->ReadRegister(x1_reg_info, x1_reg_value)) {
+                    Status error;
+                    if (x0_reg_value.GetAsMemoryData(
+                            x0_reg_info, heap_data_up->GetBytes() + 0, 8,
+                            byte_order, error) &&
+                        x1_reg_value.GetAsMemoryData(
+                            x1_reg_info, heap_data_up->GetBytes() + 8, 8,
+                            byte_order, error)) {
+                      DataExtractor data(
+                          DataBufferSP(heap_data_up.release()), byte_order,
+                          exe_ctx.GetProcessRef().GetAddressByteSize());
+
+                      return_valobj_sp = ValueObjectConstResult::Create(
+                          &thread, return_compiler_type, ConstString(""), data);
+                      return return_valobj_sp;
+                    }
+                  }
+                }
+              }
+            }
+            break;
+          case sizeof(uint64_t):
+            if (is_signed)
+              value.GetScalar() = (int64_t)(raw_value);
+            else
+              value.GetScalar() = (uint64_t)(raw_value);
+            success = true;
+            break;
+
+          case sizeof(uint32_t):
+            if (is_signed)
+              value.GetScalar() = (int32_t)(raw_value & UINT32_MAX);
+            else
+              value.GetScalar() = (uint32_t)(raw_value & UINT32_MAX);
+            success = true;
+            break;
+
+          case sizeof(uint16_t):
+            if (is_signed)
+              value.GetScalar() = (int16_t)(raw_value & UINT16_MAX);
+            else
+              value.GetScalar() = (uint16_t)(raw_value & UINT16_MAX);
+            success = true;
+            break;
+
+          case sizeof(uint8_t):
+            if (is_signed)
+              value.GetScalar() = (int8_t)(raw_value & UINT8_MAX);
+            else
+              value.GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
+            success = true;
+            break;
+          }
+        }
+      }
+    } else if (type_flags & eTypeIsFloat) {
+      if (type_flags & eTypeIsComplex) {
+        // Don't handle complex yet.
+      } else {
+        if (*byte_size <= sizeof(long double)) {
+          const RegisterInfo *v0_reg_info =
+              reg_ctx->GetRegisterInfoByName("v0", 0);
+          RegisterValue v0_value;
+          if (reg_ctx->ReadRegister(v0_reg_info, v0_value)) {
+            DataExtractor data;
+            if (v0_value.GetData(data)) {
+              lldb::offset_t offset = 0;
+              if (*byte_size == sizeof(float)) {
+                value.GetScalar() = data.GetFloat(&offset);
+                success = true;
+              } else if (*byte_size == sizeof(double)) {
+                value.GetScalar() = data.GetDouble(&offset);
+                success = true;
+              } else if (*byte_size == sizeof(long double)) {
+                value.GetScalar() = data.GetLongDouble(&offset);
+                success = true;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (success)
+      return_valobj_sp = ValueObjectConstResult::Create(
+          thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
+  } else if (type_flags & eTypeIsVector) {
+    if (*byte_size > 0) {
+
+      const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
+
+      if (v0_info) {
+        if (*byte_size <= v0_info->byte_size) {
+          std::unique_ptr<DataBufferHeap> heap_data_up(
+              new DataBufferHeap(*byte_size, 0));
+          const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
+          RegisterValue reg_value;
+          if (reg_ctx->ReadRegister(v0_info, reg_value)) {
+            Status error;
+            if (reg_value.GetAsMemoryData(v0_info, heap_data_up->GetBytes(),
+                                          heap_data_up->GetByteSize(),
+                                          byte_order, error)) {
+              DataExtractor data(DataBufferSP(heap_data_up.release()),
+                                 byte_order,
+                                 exe_ctx.GetProcessRef().GetAddressByteSize());
+              return_valobj_sp = ValueObjectConstResult::Create(
+                  &thread, return_compiler_type, ConstString(""), data);
+            }
+          }
+        }
+      }
+    }
+  } else if (type_flags & eTypeIsStructUnion || type_flags & eTypeIsClass) {
+    DataExtractor data;
+
+    uint32_t NGRN = 0; // Search ABI docs for NGRN
+    uint32_t NSRN = 0; // Search ABI docs for NSRN
+    const bool is_return_value = true;
+    if (LoadValueFromConsecutiveGPRRegisters(
+            exe_ctx, reg_ctx, return_compiler_type, is_return_value, NGRN, NSRN,
+            data)) {
+      return_valobj_sp = ValueObjectConstResult::Create(
+          &thread, return_compiler_type, ConstString(""), data);
+    }
+  }
+  return return_valobj_sp;
+}
+
+void ABIMacOSX_arm64::Initialize() {
+  PluginManager::RegisterPlugin(GetPluginNameStatic(), pluginDesc,
+                                CreateInstance);
+}
+
+void ABIMacOSX_arm64::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
+}
+
+// PluginInterface protocol
+
+ConstString ABIMacOSX_arm64::GetPluginNameStatic() {
+  static ConstString g_plugin_name("ABIMacOSX_arm64");
+  return g_plugin_name;
+}
+
+uint32_t ABIMacOSX_arm64::GetPluginVersion() { return 1; }
diff --git a/lldb/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.h b/lldb/source/Plugins/ABI/AArch64/ABIMacOSX_arm64.h
index c7a91ba9c4683..fc8ccee92e71e 100644
--- a/lldb/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.h
+++ b/lldb/source/Plugins/ABI/AArch64/ABIMacOSX_arm64.h
@@ -6,14 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_ABIMacOSX_arm64_h_
-#define liblldb_ABIMacOSX_arm64_h_
+#ifndef LLDB_SOURCE_PLUGINS_ABI_AARCH64_ABIMACOSX_ARM64_H
+#define LLDB_SOURCE_PLUGINS_ABI_AARCH64_ABIMACOSX_ARM64_H
 
-#include "lldb/Target/ABI.h"
+#include "Plugins/ABI/AArch64/ABIAArch64.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-private.h"
 
-class ABIMacOSX_arm64 : public lldb_private::ABI {
+class ABIMacOSX_arm64 : public ABIAArch64 {
 public:
   ~ABIMacOSX_arm64() override = default;
 
@@ -42,7 +42,7 @@ public:
   //
   // To work around this, we relax that alignment to be just word-size
   // (8-bytes).
-  // Whitelisting the trap handlers for user space would be easy (_sigtramp) but
+  // Allowing the trap handlers for user space would be easy (_sigtramp) but
   // in other environments there can be a large number of different functions
   // involved in async traps.
   bool CallFrameAddressIsValid(lldb::addr_t cfa) override {
@@ -62,9 +62,6 @@ public:
     return true;
   }
 
-  const lldb_private::RegisterInfo *
-  GetRegisterInfoArray(uint32_t &count) override;
-
   // Static Functions
 
   static void Initialize();
@@ -93,11 +90,7 @@ protected:
                            lldb_private::CompilerType &ast_type) const override;
 
 private:
-  ABIMacOSX_arm64(lldb::ProcessSP process_sp,
-                  std::unique_ptr<llvm::MCRegisterInfo> info_up)
-      : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
-    // Call CreateInstance instead.
-  }
+  using ABIAArch64::ABIAArch64; // Call CreateInstance instead.
 };
 
-#endif // liblldb_ABIMacOSX_arm64_h_
+#endif // LLDB_SOURCE_PLUGINS_ABI_AARCH64_ABIMACOSX_ARM64_H
diff --git a/lldb/source/Plugins/ABI/AArch64/ABISysV_arm64.cpp b/lldb/source/Plugins/ABI/AArch64/ABISysV_arm64.cpp
new file mode 100644
index 0000000000000..831c8aa0d760b
--- /dev/null
+++ b/lldb/source/Plugins/ABI/AArch64/ABISysV_arm64.cpp
@@ -0,0 +1,800 @@
+//===-- ABISysV_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 "ABISysV_arm64.h"
+
+#include <vector>
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/Triple.h"
+
+#include "lldb/Core/Module.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Value.h"
+#include "lldb/Core/ValueObjectConstResult.h"
+#include "lldb/Symbol/UnwindPlan.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "lldb/Utility/Scalar.h"
+#include "lldb/Utility/Status.h"
+
+#include "Utility/ARM64_DWARF_Registers.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+bool ABISysV_arm64::GetPointerReturnRegister(const char *&name) {
+  name = "x0";
+  return true;
+}
+
+size_t ABISysV_arm64::GetRedZoneSize() const { return 128; }
+
+// Static Functions
+
+ABISP
+ABISysV_arm64::CreateInstance(lldb::ProcessSP process_sp, const ArchSpec &arch) {
+  const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
+  const llvm::Triple::VendorType vendor_type = arch.GetTriple().getVendor();
+
+  if (vendor_type != llvm::Triple::Apple) {
+    if (arch_type == llvm::Triple::aarch64 ||
+        arch_type == llvm::Triple::aarch64_32) {
+      return ABISP(
+          new ABISysV_arm64(std::move(process_sp), MakeMCRegisterInfo(arch)));
+    }
+  }
+
+  return ABISP();
+}
+
+bool ABISysV_arm64::PrepareTrivialCall(Thread &thread, addr_t sp,
+                                       addr_t func_addr, addr_t return_addr,
+                                       llvm::ArrayRef<addr_t> args) const {
+  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
+  if (!reg_ctx)
+    return false;
+
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
+
+  if (log) {
+    StreamString s;
+    s.Printf("ABISysV_arm64::PrepareTrivialCall (tid = 0x%" PRIx64
+             ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64
+             ", return_addr = 0x%" PRIx64,
+             thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
+             (uint64_t)return_addr);
+
+    for (size_t i = 0; i < args.size(); ++i)
+      s.Printf(", arg%d = 0x%" PRIx64, static_cast<int>(i + 1), args[i]);
+    s.PutCString(")");
+    log->PutString(s.GetString());
+  }
+
+  // x0 - x7 contain first 8 simple args
+  if (args.size() > 8)
+    return false;
+
+  for (size_t i = 0; i < args.size(); ++i) {
+    const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
+        eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + i);
+    LLDB_LOGF(log, "About to write arg%d (0x%" PRIx64 ") into %s",
+              static_cast<int>(i + 1), args[i], reg_info->name);
+    if (!reg_ctx->WriteRegisterFromUnsigned(reg_info, args[i]))
+      return false;
+  }
+
+  // Set "lr" to the return address
+  if (!reg_ctx->WriteRegisterFromUnsigned(
+          reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
+                                   LLDB_REGNUM_GENERIC_RA),
+          return_addr))
+    return false;
+
+  // Set "sp" to the requested value
+  if (!reg_ctx->WriteRegisterFromUnsigned(
+          reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
+                                   LLDB_REGNUM_GENERIC_SP),
+          sp))
+    return false;
+
+  // Set "pc" to the address requested
+  if (!reg_ctx->WriteRegisterFromUnsigned(
+          reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
+                                   LLDB_REGNUM_GENERIC_PC),
+          func_addr))
+    return false;
+
+  return true;
+}
+
+// TODO: We dont support fp/SIMD arguments in v0-v7
+bool ABISysV_arm64::GetArgumentValues(Thread &thread, ValueList &values) const {
+  uint32_t num_values = values.GetSize();
+
+  ExecutionContext exe_ctx(thread.shared_from_this());
+
+  // Extract the register context so we can read arguments from registers
+
+  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
+
+  if (!reg_ctx)
+    return false;
+
+  addr_t sp = 0;
+
+  for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
+    // We currently only support extracting values with Clang QualTypes. Do we
+    // care about others?
+    Value *value = values.GetValueAtIndex(value_idx);
+
+    if (!value)
+      return false;
+
+    CompilerType value_type = value->GetCompilerType();
+    if (value_type) {
+      bool is_signed = false;
+      size_t bit_width = 0;
+      llvm::Optional<uint64_t> bit_size = value_type.GetBitSize(&thread);
+      if (!bit_size)
+        return false;
+      if (value_type.IsIntegerOrEnumerationType(is_signed)) {
+        bit_width = *bit_size;
+      } else if (value_type.IsPointerOrReferenceType()) {
+        bit_width = *bit_size;
+      } else {
+        // We only handle integer, pointer and reference types currently...
+        return false;
+      }
+
+      if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) {
+        if (value_idx < 8) {
+          // Arguments 1-8 are in x0-x7...
+          const RegisterInfo *reg_info = nullptr;
+          reg_info = reg_ctx->GetRegisterInfo(
+              eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + value_idx);
+
+          if (reg_info) {
+            RegisterValue reg_value;
+
+            if (reg_ctx->ReadRegister(reg_info, reg_value)) {
+              if (is_signed)
+                reg_value.SignExtend(bit_width);
+              if (!reg_value.GetScalarValue(value->GetScalar()))
+                return false;
+              continue;
+            }
+          }
+          return false;
+        } else {
+          // TODO: Verify for stack layout for SysV
+          if (sp == 0) {
+            // Read the stack pointer if we already haven't read it
+            sp = reg_ctx->GetSP(0);
+            if (sp == 0)
+              return false;
+          }
+
+          // Arguments 5 on up are on the stack
+          const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
+          Status error;
+          if (!exe_ctx.GetProcessRef().ReadScalarIntegerFromMemory(
+                  sp, arg_byte_size, is_signed, value->GetScalar(), error))
+            return false;
+
+          sp += arg_byte_size;
+          // Align up to the next 8 byte boundary if needed
+          if (sp % 8) {
+            sp >>= 3;
+            sp += 1;
+            sp <<= 3;
+          }
+        }
+      }
+    }
+  }
+  return true;
+}
+
+Status ABISysV_arm64::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
+                                           lldb::ValueObjectSP &new_value_sp) {
+  Status error;
+  if (!new_value_sp) {
+    error.SetErrorString("Empty value object for return value.");
+    return error;
+  }
+
+  CompilerType return_value_type = new_value_sp->GetCompilerType();
+  if (!return_value_type) {
+    error.SetErrorString("Null clang type for return value.");
+    return error;
+  }
+
+  Thread *thread = frame_sp->GetThread().get();
+
+  RegisterContext *reg_ctx = thread->GetRegisterContext().get();
+
+  if (reg_ctx) {
+    DataExtractor data;
+    Status data_error;
+    const uint64_t byte_size = new_value_sp->GetData(data, data_error);
+    if (data_error.Fail()) {
+      error.SetErrorStringWithFormat(
+          "Couldn't convert return value to raw data: %s",
+          data_error.AsCString());
+      return error;
+    }
+
+    const uint32_t type_flags = return_value_type.GetTypeInfo(nullptr);
+    if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
+      if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
+        // Extract the register context so we can read arguments from registers
+        lldb::offset_t offset = 0;
+        if (byte_size <= 16) {
+          const RegisterInfo *x0_info = reg_ctx->GetRegisterInfo(
+              eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
+          if (byte_size <= 8) {
+            uint64_t raw_value = data.GetMaxU64(&offset, byte_size);
+
+            if (!reg_ctx->WriteRegisterFromUnsigned(x0_info, raw_value))
+              error.SetErrorString("failed to write register x0");
+          } else {
+            uint64_t raw_value = data.GetMaxU64(&offset, 8);
+
+            if (reg_ctx->WriteRegisterFromUnsigned(x0_info, raw_value)) {
+              const RegisterInfo *x1_info = reg_ctx->GetRegisterInfo(
+                  eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG2);
+              raw_value = data.GetMaxU64(&offset, byte_size - offset);
+
+              if (!reg_ctx->WriteRegisterFromUnsigned(x1_info, raw_value))
+                error.SetErrorString("failed to write register x1");
+            }
+          }
+        } else {
+          error.SetErrorString("We don't support returning longer than 128 bit "
+                               "integer values at present.");
+        }
+      } else if (type_flags & eTypeIsFloat) {
+        if (type_flags & eTypeIsComplex) {
+          // Don't handle complex yet.
+          error.SetErrorString(
+              "returning complex float values are not supported");
+        } else {
+          const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
+
+          if (v0_info) {
+            if (byte_size <= 16) {
+              if (byte_size <= RegisterValue::GetMaxByteSize()) {
+                RegisterValue reg_value;
+                error = reg_value.SetValueFromData(v0_info, data, 0, true);
+                if (error.Success()) {
+                  if (!reg_ctx->WriteRegister(v0_info, reg_value))
+                    error.SetErrorString("failed to write register v0");
+                }
+              } else {
+                error.SetErrorStringWithFormat(
+                    "returning float values with a byte size of %" PRIu64
+                    " are not supported",
+                    byte_size);
+              }
+            } else {
+              error.SetErrorString("returning float values longer than 128 "
+                                   "bits are not supported");
+            }
+          } else {
+            error.SetErrorString("v0 register is not available on this target");
+          }
+        }
+      }
+    } else if (type_flags & eTypeIsVector) {
+      if (byte_size > 0) {
+        const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
+
+        if (v0_info) {
+          if (byte_size <= v0_info->byte_size) {
+            RegisterValue reg_value;
+            error = reg_value.SetValueFromData(v0_info, data, 0, true);
+            if (error.Success()) {
+              if (!reg_ctx->WriteRegister(v0_info, reg_value))
+                error.SetErrorString("failed to write register v0");
+            }
+          }
+        }
+      }
+    }
+  } else {
+    error.SetErrorString("no registers are available");
+  }
+
+  return error;
+}
+
+bool ABISysV_arm64::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) {
+  unwind_plan.Clear();
+  unwind_plan.SetRegisterKind(eRegisterKindDWARF);
+
+  uint32_t lr_reg_num = arm64_dwarf::lr;
+  uint32_t sp_reg_num = arm64_dwarf::sp;
+
+  UnwindPlan::RowSP row(new UnwindPlan::Row);
+
+  // Our previous Call Frame Address is the stack pointer
+  row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
+
+  unwind_plan.AppendRow(row);
+  unwind_plan.SetReturnAddressRegister(lr_reg_num);
+
+  // All other registers are the same.
+
+  unwind_plan.SetSourceName("arm64 at-func-entry default");
+  unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
+
+  return true;
+}
+
+bool ABISysV_arm64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
+  unwind_plan.Clear();
+  unwind_plan.SetRegisterKind(eRegisterKindDWARF);
+
+  uint32_t fp_reg_num = arm64_dwarf::fp;
+  uint32_t pc_reg_num = arm64_dwarf::pc;
+
+  UnwindPlan::RowSP row(new UnwindPlan::Row);
+  const int32_t ptr_size = 8;
+
+  row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
+  row->SetOffset(0);
+
+  row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
+  row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
+
+  unwind_plan.AppendRow(row);
+  unwind_plan.SetSourceName("arm64 default unwind plan");
+  unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
+  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
+
+  return true;
+}
+
+// AAPCS64 (Procedure Call Standard for the ARM 64-bit Architecture) says
+// registers x19 through x28 and sp are callee preserved. v8-v15 are non-
+// volatile (and specifically only the lower 8 bytes of these regs), the rest
+// of the fp/SIMD registers are volatile.
+
+// We treat x29 as callee preserved also, else the unwinder won't try to
+// retrieve fp saves.
+
+bool ABISysV_arm64::RegisterIsVolatile(const RegisterInfo *reg_info) {
+  if (reg_info) {
+    const char *name = reg_info->name;
+
+    // Sometimes we'll be called with the "alternate" name for these registers;
+    // recognize them as non-volatile.
+
+    if (name[0] == 'p' && name[1] == 'c') // pc
+      return false;
+    if (name[0] == 'f' && name[1] == 'p') // fp
+      return false;
+    if (name[0] == 's' && name[1] == 'p') // sp
+      return false;
+    if (name[0] == 'l' && name[1] == 'r') // lr
+      return false;
+
+    if (name[0] == 'x' || name[0] == 'r') {
+      // Volatile registers: x0-x18
+      // Although documentation says only x19-28 + sp are callee saved We ll
+      // also have to treat x30 as non-volatile. Each dwarf frame has its own
+      // value of lr. Return false for the non-volatile gpr regs, true for
+      // everything else
+      switch (name[1]) {
+      case '1':
+        switch (name[2]) {
+        case '9':
+          return false; // x19 is non-volatile
+        default:
+          return true;
+        }
+        break;
+      case '2':
+        switch (name[2]) {
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+          return false; // x20 - 28 are non-volatile
+        case '9':
+          return false; // x29 aka fp treat as non-volatile
+        default:
+          return true;
+        }
+      case '3': // x30 (lr) and x31 (sp) treat as non-volatile
+        if (name[2] == '0' || name[2] == '1')
+          return false;
+        break;
+      default:
+        return true; // all volatile cases not handled above fall here.
+      }
+    } else if (name[0] == 'v' || name[0] == 's' || name[0] == 'd') {
+      // Volatile registers: v0-7, v16-v31
+      // Return false for non-volatile fp/SIMD regs, true for everything else
+      switch (name[1]) {
+      case '8':
+      case '9':
+        return false; // v8-v9 are non-volatile
+      case '1':
+        switch (name[2]) {
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+          return false; // v10-v15 are non-volatile
+        default:
+          return true;
+        }
+      default:
+        return true;
+      }
+    }
+  }
+  return true;
+}
+
+static bool LoadValueFromConsecutiveGPRRegisters(
+    ExecutionContext &exe_ctx, RegisterContext *reg_ctx,
+    const CompilerType &value_type,
+    bool is_return_value, // false => parameter, true => return value
+    uint32_t &NGRN,       // NGRN (see ABI documentation)
+    uint32_t &NSRN,       // NSRN (see ABI documentation)
+    DataExtractor &data) {
+  llvm::Optional<uint64_t> byte_size = value_type.GetByteSize(nullptr);
+
+  if (byte_size || *byte_size == 0)
+    return false;
+
+  std::unique_ptr<DataBufferHeap> heap_data_up(
+      new DataBufferHeap(*byte_size, 0));
+  const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
+  Status error;
+
+  CompilerType base_type;
+  const uint32_t homogeneous_count =
+      value_type.IsHomogeneousAggregate(&base_type);
+  if (homogeneous_count > 0 && homogeneous_count <= 8) {
+    // Make sure we have enough registers
+    if (NSRN < 8 && (8 - NSRN) >= homogeneous_count) {
+      if (!base_type)
+        return false;
+      llvm::Optional<uint64_t> base_byte_size = base_type.GetByteSize(nullptr);
+      if (!base_byte_size)
+        return false;
+      uint32_t data_offset = 0;
+
+      for (uint32_t i = 0; i < homogeneous_count; ++i) {
+        char v_name[8];
+        ::snprintf(v_name, sizeof(v_name), "v%u", NSRN);
+        const RegisterInfo *reg_info =
+            reg_ctx->GetRegisterInfoByName(v_name, 0);
+        if (reg_info == nullptr)
+          return false;
+
+        if (*base_byte_size > reg_info->byte_size)
+          return false;
+
+        RegisterValue reg_value;
+
+        if (!reg_ctx->ReadRegister(reg_info, reg_value))
+          return false;
+
+        // Make sure we have enough room in "heap_data_up"
+        if ((data_offset + *base_byte_size) <= heap_data_up->GetByteSize()) {
+          const size_t bytes_copied = reg_value.GetAsMemoryData(
+              reg_info, heap_data_up->GetBytes() + data_offset, *base_byte_size,
+              byte_order, error);
+          if (bytes_copied != *base_byte_size)
+            return false;
+          data_offset += bytes_copied;
+          ++NSRN;
+        } else
+          return false;
+      }
+      data.SetByteOrder(byte_order);
+      data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize());
+      data.SetData(DataBufferSP(heap_data_up.release()));
+      return true;
+    }
+  }
+
+  const size_t max_reg_byte_size = 16;
+  if (*byte_size <= max_reg_byte_size) {
+    size_t bytes_left = *byte_size;
+    uint32_t data_offset = 0;
+    while (data_offset < *byte_size) {
+      if (NGRN >= 8)
+        return false;
+
+      const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
+          eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + NGRN);
+      if (reg_info == nullptr)
+        return false;
+
+      RegisterValue reg_value;
+
+      if (!reg_ctx->ReadRegister(reg_info, reg_value))
+        return false;
+
+      const size_t curr_byte_size = std::min<size_t>(8, bytes_left);
+      const size_t bytes_copied = reg_value.GetAsMemoryData(
+          reg_info, heap_data_up->GetBytes() + data_offset, curr_byte_size,
+          byte_order, error);
+      if (bytes_copied == 0)
+        return false;
+      if (bytes_copied >= bytes_left)
+        break;
+      data_offset += bytes_copied;
+      bytes_left -= bytes_copied;
+      ++NGRN;
+    }
+  } else {
+    const RegisterInfo *reg_info = nullptr;
+    if (is_return_value) {
+      // We are assuming we are decoding this immediately after returning from
+      // a function call and that the address of the structure is in x8
+      reg_info = reg_ctx->GetRegisterInfoByName("x8", 0);
+    } else {
+      // We are assuming we are stopped at the first instruction in a function
+      // and that the ABI is being respected so all parameters appear where
+      // they should be (functions with no external linkage can legally violate
+      // the ABI).
+      if (NGRN >= 8)
+        return false;
+
+      reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
+                                          LLDB_REGNUM_GENERIC_ARG1 + NGRN);
+      if (reg_info == nullptr)
+        return false;
+      ++NGRN;
+    }
+
+    if (reg_info == nullptr)
+      return false;
+
+    const lldb::addr_t value_addr =
+        reg_ctx->ReadRegisterAsUnsigned(reg_info, LLDB_INVALID_ADDRESS);
+
+    if (value_addr == LLDB_INVALID_ADDRESS)
+      return false;
+
+    if (exe_ctx.GetProcessRef().ReadMemory(
+            value_addr, heap_data_up->GetBytes(), heap_data_up->GetByteSize(),
+            error) != heap_data_up->GetByteSize()) {
+      return false;
+    }
+  }
+
+  data.SetByteOrder(byte_order);
+  data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize());
+  data.SetData(DataBufferSP(heap_data_up.release()));
+  return true;
+}
+
+ValueObjectSP ABISysV_arm64::GetReturnValueObjectImpl(
+    Thread &thread, CompilerType &return_compiler_type) const {
+  ValueObjectSP return_valobj_sp;
+  Value value;
+
+  ExecutionContext exe_ctx(thread.shared_from_this());
+  if (exe_ctx.GetTargetPtr() == nullptr || exe_ctx.GetProcessPtr() == nullptr)
+    return return_valobj_sp;
+
+  // value.SetContext (Value::eContextTypeClangType, return_compiler_type);
+  value.SetCompilerType(return_compiler_type);
+
+  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
+  if (!reg_ctx)
+    return return_valobj_sp;
+
+  llvm::Optional<uint64_t> byte_size =
+      return_compiler_type.GetByteSize(nullptr);
+  if (!byte_size)
+    return return_valobj_sp;
+
+  const uint32_t type_flags = return_compiler_type.GetTypeInfo(nullptr);
+  if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
+    value.SetValueType(Value::eValueTypeScalar);
+
+    bool success = false;
+    if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
+      // Extract the register context so we can read arguments from registers
+      if (*byte_size <= 8) {
+        const RegisterInfo *x0_reg_info = nullptr;
+        x0_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
+                                               LLDB_REGNUM_GENERIC_ARG1);
+        if (x0_reg_info) {
+          uint64_t raw_value =
+              thread.GetRegisterContext()->ReadRegisterAsUnsigned(x0_reg_info,
+                                                                  0);
+          const bool is_signed = (type_flags & eTypeIsSigned) != 0;
+          switch (*byte_size) {
+          default:
+            break;
+          case 16: // uint128_t
+            // In register x0 and x1
+            {
+              const RegisterInfo *x1_reg_info = nullptr;
+              x1_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
+                                                     LLDB_REGNUM_GENERIC_ARG2);
+
+              if (x1_reg_info) {
+                if (*byte_size <=
+                    x0_reg_info->byte_size + x1_reg_info->byte_size) {
+                  std::unique_ptr<DataBufferHeap> heap_data_up(
+                      new DataBufferHeap(*byte_size, 0));
+                  const ByteOrder byte_order =
+                      exe_ctx.GetProcessRef().GetByteOrder();
+                  RegisterValue x0_reg_value;
+                  RegisterValue x1_reg_value;
+                  if (reg_ctx->ReadRegister(x0_reg_info, x0_reg_value) &&
+                      reg_ctx->ReadRegister(x1_reg_info, x1_reg_value)) {
+                    Status error;
+                    if (x0_reg_value.GetAsMemoryData(
+                            x0_reg_info, heap_data_up->GetBytes() + 0, 8,
+                            byte_order, error) &&
+                        x1_reg_value.GetAsMemoryData(
+                            x1_reg_info, heap_data_up->GetBytes() + 8, 8,
+                            byte_order, error)) {
+                      DataExtractor data(
+                          DataBufferSP(heap_data_up.release()), byte_order,
+                          exe_ctx.GetProcessRef().GetAddressByteSize());
+
+                      return_valobj_sp = ValueObjectConstResult::Create(
+                          &thread, return_compiler_type, ConstString(""), data);
+                      return return_valobj_sp;
+                    }
+                  }
+                }
+              }
+            }
+            break;
+          case sizeof(uint64_t):
+            if (is_signed)
+              value.GetScalar() = (int64_t)(raw_value);
+            else
+              value.GetScalar() = (uint64_t)(raw_value);
+            success = true;
+            break;
+
+          case sizeof(uint32_t):
+            if (is_signed)
+              value.GetScalar() = (int32_t)(raw_value & UINT32_MAX);
+            else
+              value.GetScalar() = (uint32_t)(raw_value & UINT32_MAX);
+            success = true;
+            break;
+
+          case sizeof(uint16_t):
+            if (is_signed)
+              value.GetScalar() = (int16_t)(raw_value & UINT16_MAX);
+            else
+              value.GetScalar() = (uint16_t)(raw_value & UINT16_MAX);
+            success = true;
+            break;
+
+          case sizeof(uint8_t):
+            if (is_signed)
+              value.GetScalar() = (int8_t)(raw_value & UINT8_MAX);
+            else
+              value.GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
+            success = true;
+            break;
+          }
+        }
+      }
+    } else if (type_flags & eTypeIsFloat) {
+      if (type_flags & eTypeIsComplex) {
+        // Don't handle complex yet.
+      } else {
+        if (*byte_size <= sizeof(long double)) {
+          const RegisterInfo *v0_reg_info =
+              reg_ctx->GetRegisterInfoByName("v0", 0);
+          RegisterValue v0_value;
+          if (reg_ctx->ReadRegister(v0_reg_info, v0_value)) {
+            DataExtractor data;
+            if (v0_value.GetData(data)) {
+              lldb::offset_t offset = 0;
+              if (*byte_size == sizeof(float)) {
+                value.GetScalar() = data.GetFloat(&offset);
+                success = true;
+              } else if (*byte_size == sizeof(double)) {
+                value.GetScalar() = data.GetDouble(&offset);
+                success = true;
+              } else if (*byte_size == sizeof(long double)) {
+                value.GetScalar() = data.GetLongDouble(&offset);
+                success = true;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (success)
+      return_valobj_sp = ValueObjectConstResult::Create(
+          thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
+  } else if (type_flags & eTypeIsVector && *byte_size <= 16) {
+    if (*byte_size > 0) {
+      const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
+
+      if (v0_info) {
+        std::unique_ptr<DataBufferHeap> heap_data_up(
+            new DataBufferHeap(*byte_size, 0));
+        const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
+        RegisterValue reg_value;
+        if (reg_ctx->ReadRegister(v0_info, reg_value)) {
+          Status error;
+          if (reg_value.GetAsMemoryData(v0_info, heap_data_up->GetBytes(),
+                                        heap_data_up->GetByteSize(), byte_order,
+                                        error)) {
+            DataExtractor data(DataBufferSP(heap_data_up.release()), byte_order,
+                               exe_ctx.GetProcessRef().GetAddressByteSize());
+            return_valobj_sp = ValueObjectConstResult::Create(
+                &thread, return_compiler_type, ConstString(""), data);
+          }
+        }
+      }
+    }
+  } else if (type_flags & eTypeIsStructUnion || type_flags & eTypeIsClass ||
+             (type_flags & eTypeIsVector && *byte_size > 16)) {
+    DataExtractor data;
+
+    uint32_t NGRN = 0; // Search ABI docs for NGRN
+    uint32_t NSRN = 0; // Search ABI docs for NSRN
+    const bool is_return_value = true;
+    if (LoadValueFromConsecutiveGPRRegisters(
+            exe_ctx, reg_ctx, return_compiler_type, is_return_value, NGRN, NSRN,
+            data)) {
+      return_valobj_sp = ValueObjectConstResult::Create(
+          &thread, return_compiler_type, ConstString(""), data);
+    }
+  }
+  return return_valobj_sp;
+}
+
+void ABISysV_arm64::Initialize() {
+  PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                "SysV ABI for AArch64 targets", CreateInstance);
+}
+
+void ABISysV_arm64::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
+}
+
+lldb_private::ConstString ABISysV_arm64::GetPluginNameStatic() {
+  static ConstString g_name("SysV-arm64");
+  return g_name;
+}
+
+// PluginInterface protocol
+
+ConstString ABISysV_arm64::GetPluginName() { return GetPluginNameStatic(); }
+
+uint32_t ABISysV_arm64::GetPluginVersion() { return 1; }
diff --git a/lldb/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.h b/lldb/source/Plugins/ABI/AArch64/ABISysV_arm64.h
index 1bf5773e2db3c..aeb74acc38b5d 100644
--- a/lldb/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.h
+++ b/lldb/source/Plugins/ABI/AArch64/ABISysV_arm64.h
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_ABISysV_arm64_h_
-#define liblldb_ABISysV_arm64_h_
+#ifndef LLDB_SOURCE_PLUGINS_ABI_AARCH64_ABISYSV_ARM64_H
+#define LLDB_SOURCE_PLUGINS_ABI_AARCH64_ABISYSV_ARM64_H
 
-#include "lldb/Target/ABI.h"
+#include "Plugins/ABI/AArch64/ABIAArch64.h"
 #include "lldb/lldb-private.h"
 
-class ABISysV_arm64 : public lldb_private::ABI {
+class ABISysV_arm64 : public ABIAArch64 {
 public:
   ~ABISysV_arm64() override = default;
 
@@ -45,7 +45,7 @@ public:
   //
   // To work around this, we relax that alignment to be just word-size
   // (8-bytes).
-  // Whitelisting the trap handlers for user space would be easy (_sigtramp) but
+  // Allowing the trap handlers for user space would be easy (_sigtramp) but
   // in other environments there can be a large number of different functions
   // involved in async traps.
   bool CallFrameAddressIsValid(lldb::addr_t cfa) override {
@@ -65,9 +65,6 @@ public:
     return true;
   }
 
-  const lldb_private::RegisterInfo *
-  GetRegisterInfoArray(uint32_t &count) override;
-
   bool GetPointerReturnRegister(const char *&name) override;
 
   // Static Functions
@@ -92,11 +89,7 @@ protected:
                            lldb_private::CompilerType &ast_type) const override;
 
 private:
-  ABISysV_arm64(lldb::ProcessSP process_sp,
-                std::unique_ptr<llvm::MCRegisterInfo> info_up)
-      : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
-    // Call CreateInstance instead.
-  }
+  using ABIAArch64::ABIAArch64; // Call CreateInstance instead.
 };
 
-#endif // liblldb_ABISysV_arm64_h_
+#endif // LLDB_SOURCE_PLUGINS_ABI_AARCH64_ABISYSV_ARM64_H
diff --git a/lldb/source/Plugins/ABI/SysV-arc/ABISysV_arc.cpp b/lldb/source/Plugins/ABI/ARC/ABISysV_arc.cpp
index 715b5e5d2b95b..a212eef2ab8a6 100644
--- a/lldb/source/Plugins/ABI/SysV-arc/ABISysV_arc.cpp
+++ b/lldb/source/Plugins/ABI/ARC/ABISysV_arc.cpp
@@ -1,4 +1,4 @@
-//===-- ABISysV_arc.cpp ---------------------------------------*- C++ -*-===//
+//===-- ABISysV_arc.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -55,6 +55,8 @@
 using namespace lldb;
 using namespace lldb_private;
 
+LLDB_PLUGIN_DEFINE_ADV(ABISysV_arc, ABIARC)
+
 namespace {
 namespace dwarf {
 enum regnums {
@@ -144,7 +146,7 @@ size_t ABISysV_arc::GetRedZoneSize() const { return 0; }
 bool ABISysV_arc::IsRegisterFileReduced(RegisterContext &reg_ctx) const {
   if (!m_is_reg_file_reduced) {
     const auto *const rf_build_reg = reg_ctx.GetRegisterInfoByName("rf_build");
-    
+
     const auto reg_value = reg_ctx.ReadRegisterAsUnsigned(rf_build_reg,
                                                           /*fail_value*/ 0);
     // RF_BUILD "Number of Entries" bit.
@@ -239,7 +241,7 @@ bool ABISysV_arc::PrepareTrivialCall(Thread &thread, addr_t sp, addr_t pc,
   // Make sure number of parameters matches prototype.
   assert(!prototype.isFunctionVarArg());
   assert(prototype.getFunctionNumParams() == args.size());
-  
+
   const size_t regs_for_args_count = IsRegisterFileReduced(*reg_ctx) ? 4U : 8U;
 
   // Number of arguments passed on stack.
@@ -520,7 +522,7 @@ ValueObjectSP ABISysV_arc::GetReturnValueObjectImpl(Thread &thread,
   // Integer return type.
   else if (retType.isIntegerTy()) {
     size_t byte_size = retType.getPrimitiveSizeInBits();
-    if (1 != byte_size) // For boolian type.
+    if (1 != byte_size) // For boolean type.
       byte_size /= CHAR_BIT;
 
     auto raw_value = ReadRawValue(reg_ctx, byte_size);
diff --git a/lldb/source/Plugins/ABI/SysV-arc/ABISysV_arc.h b/lldb/source/Plugins/ABI/ARC/ABISysV_arc.h
index c4b26a54158c6..3fbe64b4b45b7 100644
--- a/lldb/source/Plugins/ABI/SysV-arc/ABISysV_arc.h
+++ b/lldb/source/Plugins/ABI/ARC/ABISysV_arc.h
@@ -16,7 +16,7 @@
 #include "lldb/Target/ABI.h"
 #include "lldb/lldb-private.h"
 
-class ABISysV_arc : public lldb_private::ABI {
+class ABISysV_arc : public lldb_private::RegInfoBasedABI {
 public:
   ~ABISysV_arc() override = default;
 
@@ -97,7 +97,7 @@ private:
 
   bool IsRegisterFileReduced(lldb_private::RegisterContext &reg_ctx) const;
 
-  using lldb_private::ABI::ABI; // Call CreateInstance instead.
+  using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 
   using RegisterFileFlag = llvm::Optional<bool>;
   mutable RegisterFileFlag m_is_reg_file_reduced;
diff --git a/lldb/source/Plugins/ABI/ARM/ABIARM.cpp b/lldb/source/Plugins/ABI/ARM/ABIARM.cpp
new file mode 100644
index 0000000000000..882c14d386e31
--- /dev/null
+++ b/lldb/source/Plugins/ABI/ARM/ABIARM.cpp
@@ -0,0 +1,24 @@
+//===-- ARM.h -------------------------------------------------------------===//
+//
+// 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 "ABIARM.h"
+#include "ABIMacOSX_arm.h"
+#include "ABISysV_arm.h"
+#include "lldb/Core/PluginManager.h"
+
+LLDB_PLUGIN_DEFINE(ABIARM)
+
+void ABIARM::Initialize() {
+  ABISysV_arm::Initialize();
+  ABIMacOSX_arm::Initialize();
+}
+
+void ABIARM::Terminate() {
+  ABISysV_arm::Terminate();
+  ABIMacOSX_arm::Terminate();
+}
diff --git a/lldb/source/Plugins/ABI/ARM/ABIARM.h b/lldb/source/Plugins/ABI/ARM/ABIARM.h
new file mode 100644
index 0000000000000..7d04f1c9eb0fc
--- /dev/null
+++ b/lldb/source/Plugins/ABI/ARM/ABIARM.h
@@ -0,0 +1,17 @@
+//===-- ARM.h -------------------------------------------------------------===//
+//
+// 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_SOURCE_PLUGINS_ABI_ARM_ABIARM_H
+#define LLDB_SOURCE_PLUGINS_ABI_ARM_ABIARM_H
+
+class ABIARM {
+public:
+  static void Initialize();
+  static void Terminate();
+};
+#endif
diff --git a/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp b/lldb/source/Plugins/ABI/ARM/ABIMacOSX_arm.cpp
index 9dff12bcc7482..ef500cb198a8b 100644
--- a/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp
+++ b/lldb/source/Plugins/ABI/ARM/ABIMacOSX_arm.cpp
@@ -1,4 +1,4 @@
-//===-- ABIMacOSX_arm.cpp ---------------------------------------*- C++ -*-===//
+//===-- ABIMacOSX_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.
diff --git a/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h b/lldb/source/Plugins/ABI/ARM/ABIMacOSX_arm.h
index e512651f86e51..e0fa349eea731 100644
--- a/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h
+++ b/lldb/source/Plugins/ABI/ARM/ABIMacOSX_arm.h
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_ABIMacOSX_arm_h_
-#define liblldb_ABIMacOSX_arm_h_
+#ifndef LLDB_SOURCE_PLUGINS_ABI_ARM_ABIMACOSX_ARM_H
+#define LLDB_SOURCE_PLUGINS_ABI_ARM_ABIMACOSX_ARM_H
 
 #include "lldb/Target/ABI.h"
 #include "lldb/lldb-private.h"
 
-class ABIMacOSX_arm : public lldb_private::ABI {
+class ABIMacOSX_arm : public lldb_private::RegInfoBasedABI {
 public:
   ~ABIMacOSX_arm() override = default;
 
@@ -85,11 +85,7 @@ protected:
                            lldb_private::CompilerType &ast_type) const override;
 
 private:
-  ABIMacOSX_arm(lldb::ProcessSP process_sp,
-                std::unique_ptr<llvm::MCRegisterInfo> info_up)
-      : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
-    // Call CreateInstance instead.
-  }
+  using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
-#endif // liblldb_ABIMacOSX_arm_h_
+#endif // LLDB_SOURCE_PLUGINS_ABI_ARM_ABIMACOSX_ARM_H
diff --git a/lldb/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp b/lldb/source/Plugins/ABI/ARM/ABISysV_arm.cpp
index b6e8f8806829a..1a93bac564f72 100644
--- a/lldb/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp
+++ b/lldb/source/Plugins/ABI/ARM/ABISysV_arm.cpp
@@ -1,4 +1,4 @@
-//===-- ABISysV_arm.cpp -----------------------------------------*- C++ -*-===//
+//===-- ABISysV_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.
@@ -34,6 +34,8 @@
 using namespace lldb;
 using namespace lldb_private;
 
+LLDB_PLUGIN_DEFINE(ABISysV_arm)
+
 static RegisterInfo g_register_infos[] = {
     //  NAME       ALT       SZ OFF ENCODING         FORMAT          EH_FRAME
     //  DWARF               GENERIC                     PROCESS PLUGIN
diff --git a/lldb/source/Plugins/ABI/SysV-arm/ABISysV_arm.h b/lldb/source/Plugins/ABI/ARM/ABISysV_arm.h
index 60fb14be5f7bd..f28f75ce4fe53 100644
--- a/lldb/source/Plugins/ABI/SysV-arm/ABISysV_arm.h
+++ b/lldb/source/Plugins/ABI/ARM/ABISysV_arm.h
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_ABISysV_arm_h_
-#define liblldb_ABISysV_arm_h_
+#ifndef LLDB_SOURCE_PLUGINS_ABI_ARM_ABISYSV_ARM_H
+#define LLDB_SOURCE_PLUGINS_ABI_ARM_ABISYSV_ARM_H
 
 #include "lldb/Target/ABI.h"
 #include "lldb/lldb-private.h"
 
-class ABISysV_arm : public lldb_private::ABI {
+class ABISysV_arm : public lldb_private::RegInfoBasedABI {
 public:
   ~ABISysV_arm() override = default;
 
@@ -85,11 +85,7 @@ protected:
                            lldb_private::CompilerType &ast_type) const override;
 
 private:
-  ABISysV_arm(lldb::ProcessSP process_sp,
-              std::unique_ptr<llvm::MCRegisterInfo> info_up)
-      : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
-    // Call CreateInstance instead.
-  }
+  using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
-#endif // liblldb_ABISysV_arm_h_
+#endif // LLDB_SOURCE_PLUGINS_ABI_ARM_ABISYSV_ARM_H
diff --git a/lldb/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp b/lldb/source/Plugins/ABI/Hexagon/ABISysV_hexagon.cpp
index 34d9258ccb924..32313d4cd815a 100644
--- a/lldb/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp
+++ b/lldb/source/Plugins/ABI/Hexagon/ABISysV_hexagon.cpp
@@ -1,4 +1,4 @@
-//===-- ABISysV_hexagon.cpp -------------------------------------*- C++ -*-===//
+//===-- ABISysV_hexagon.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -32,6 +32,8 @@
 using namespace lldb;
 using namespace lldb_private;
 
+LLDB_PLUGIN_DEFINE_ADV(ABISysV_hexagon, ABIHexagon)
+
 static RegisterInfo g_register_infos[] = {
     // hexagon-core.xml
     {"r00",
diff --git a/lldb/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.h b/lldb/source/Plugins/ABI/Hexagon/ABISysV_hexagon.h
index bef64a22d95f6..d6dab0c2e378a 100644
--- a/lldb/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.h
+++ b/lldb/source/Plugins/ABI/Hexagon/ABISysV_hexagon.h
@@ -7,13 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_ABISysV_hexagon_h_
-#define liblldb_ABISysV_hexagon_h_
+#ifndef LLDB_SOURCE_PLUGINS_ABI_HEXAGON_ABISYSV_HEXAGON_H
+#define LLDB_SOURCE_PLUGINS_ABI_HEXAGON_ABISYSV_HEXAGON_H
 
 #include "lldb/Target/ABI.h"
 #include "lldb/lldb-private.h"
 
-class ABISysV_hexagon : public lldb_private::ABI {
+class ABISysV_hexagon : public lldb_private::RegInfoBasedABI {
 public:
   ~ABISysV_hexagon() override = default;
 
@@ -97,11 +97,7 @@ protected:
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
 private:
-  ABISysV_hexagon(lldb::ProcessSP process_sp,
-                  std::unique_ptr<llvm::MCRegisterInfo> info_up)
-      : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
-    // Call CreateInstance instead.
-  }
+  using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
-#endif // liblldb_ABISysV_hexagon_h_
+#endif // LLDB_SOURCE_PLUGINS_ABI_HEXAGON_ABISYSV_HEXAGON_H
diff --git a/lldb/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp b/lldb/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp
deleted file mode 100644
index ec7588dfb50c9..0000000000000
--- a/lldb/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp
+++ /dev/null
@@ -1,2451 +0,0 @@
-//===-- ABIMacOSX_arm64.cpp -------------------------------------*- 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
-//
-//===----------------------------------------------------------------------===//
-
-#include "ABIMacOSX_arm64.h"
-
-#include <vector>
-
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/Triple.h"
-
-#include "lldb/Core/Module.h"
-#include "lldb/Core/PluginManager.h"
-#include "lldb/Core/Value.h"
-#include "lldb/Core/ValueObjectConstResult.h"
-#include "lldb/Symbol/UnwindPlan.h"
-#include "lldb/Target/Process.h"
-#include "lldb/Target/RegisterContext.h"
-#include "lldb/Target/Target.h"
-#include "lldb/Target/Thread.h"
-#include "lldb/Utility/ConstString.h"
-#include "lldb/Utility/Log.h"
-#include "lldb/Utility/RegisterValue.h"
-#include "lldb/Utility/Scalar.h"
-#include "lldb/Utility/Status.h"
-
-#include "Utility/ARM64_DWARF_Registers.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-static const char *pluginDesc = "Mac OS X ABI for arm64 targets";
-
-static RegisterInfo g_register_infos[] = {
-    //  NAME       ALT       SZ OFF ENCODING          FORMAT
-    //  EH_FRAME             DWARF                  GENERIC
-    //  PROCESS PLUGIN          LLDB NATIVE
-    //  ========== =======   == === =============     ===================
-    //  ===================  ====================== ===========================
-    //  ======================= ======================
-    {"x0",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x0, LLDB_REGNUM_GENERIC_ARG1,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x1",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x1, LLDB_REGNUM_GENERIC_ARG2,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x2",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x2, LLDB_REGNUM_GENERIC_ARG3,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x3",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x3, LLDB_REGNUM_GENERIC_ARG4,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x4",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x4, LLDB_REGNUM_GENERIC_ARG5,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x5",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x5, LLDB_REGNUM_GENERIC_ARG6,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x6",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x6, LLDB_REGNUM_GENERIC_ARG7,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x7",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x7, LLDB_REGNUM_GENERIC_ARG8,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x8",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x8, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x9",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x9, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x10",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x10, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x11",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x11, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x12",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x12, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x13",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x13, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x14",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x14, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x15",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x15, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x16",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x16, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x17",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x17, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x18",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x18, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x19",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x19, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x20",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x20, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x21",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x21, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x22",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x22, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x23",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x23, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x24",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x24, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x25",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x25, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x26",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x26, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x27",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x27, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x28",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x28, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fp",
-     "x29",
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x29, LLDB_REGNUM_GENERIC_FP,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"lr",
-     "x30",
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x30, LLDB_REGNUM_GENERIC_RA,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"sp",
-     "x31",
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x31, LLDB_REGNUM_GENERIC_SP,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"pc",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::pc, LLDB_REGNUM_GENERIC_PC,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"cpsr",
-     "psr",
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::cpsr, LLDB_REGNUM_GENERIC_FLAGS,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-
-    {"v0",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v0, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v1",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v1, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v2",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v2, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v3",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v3, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v4",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v4, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v5",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v5, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v6",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v6, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v7",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v7, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v8",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v8, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v9",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v9, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v10",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v10, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v11",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v11, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v12",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v12, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v13",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v13, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v14",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v14, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v15",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v15, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v16",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v16, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v17",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v17, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v18",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v18, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v19",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v19, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v20",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v20, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v21",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v21, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v22",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v22, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v23",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v23, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v24",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v24, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v25",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v25, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v26",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v26, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v27",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v27, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v28",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v28, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v29",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v29, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v30",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v30, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v31",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v31, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-
-    {"fpsr",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fpcr",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-
-    {"s0",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s1",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s2",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s3",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s4",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s5",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s6",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s7",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s8",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s9",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s10",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s11",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s12",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s13",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s14",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s15",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s16",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s17",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s18",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s19",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s20",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s21",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s22",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s23",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s24",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s25",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s26",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s27",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s28",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s29",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s30",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s31",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-
-    {"d0",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d1",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d2",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d3",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d4",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d5",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d6",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d7",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d8",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d9",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d10",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d11",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d12",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d13",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d14",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d15",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d16",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d17",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d18",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d19",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d20",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d21",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d22",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d23",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d24",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d25",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d26",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d27",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d28",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d29",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d30",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d31",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0}};
-
-static const uint32_t k_num_register_infos =
-    llvm::array_lengthof(g_register_infos);
-static bool g_register_info_names_constified = false;
-
-const lldb_private::RegisterInfo *
-ABIMacOSX_arm64::GetRegisterInfoArray(uint32_t &count) {
-  // Make the C-string names and alt_names for the register infos into const
-  // C-string values by having the ConstString unique the names in the global
-  // constant C-string pool.
-  if (!g_register_info_names_constified) {
-    g_register_info_names_constified = true;
-    for (uint32_t i = 0; i < k_num_register_infos; ++i) {
-      if (g_register_infos[i].name)
-        g_register_infos[i].name =
-            ConstString(g_register_infos[i].name).GetCString();
-      if (g_register_infos[i].alt_name)
-        g_register_infos[i].alt_name =
-            ConstString(g_register_infos[i].alt_name).GetCString();
-    }
-  }
-  count = k_num_register_infos;
-  return g_register_infos;
-}
-
-size_t ABIMacOSX_arm64::GetRedZoneSize() const { return 128; }
-
-// Static Functions
-
-ABISP
-ABIMacOSX_arm64::CreateInstance(ProcessSP process_sp, const ArchSpec &arch) {
-  const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
-  const llvm::Triple::VendorType vendor_type = arch.GetTriple().getVendor();
-
-  if (vendor_type == llvm::Triple::Apple) {
-    if (arch_type == llvm::Triple::aarch64 || 
-        arch_type == llvm::Triple::aarch64_32) {
-      return ABISP(
-          new ABIMacOSX_arm64(std::move(process_sp), MakeMCRegisterInfo(arch)));
-    }
-  }
-
-  return ABISP();
-}
-
-bool ABIMacOSX_arm64::PrepareTrivialCall(
-    Thread &thread, lldb::addr_t sp, lldb::addr_t func_addr,
-    lldb::addr_t return_addr, llvm::ArrayRef<lldb::addr_t> args) const {
-  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
-  if (!reg_ctx)
-    return false;
-
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
-
-  if (log) {
-    StreamString s;
-    s.Printf("ABISysV_x86_64::PrepareTrivialCall (tid = 0x%" PRIx64
-             ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64
-             ", return_addr = 0x%" PRIx64,
-             thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
-             (uint64_t)return_addr);
-
-    for (size_t i = 0; i < args.size(); ++i)
-      s.Printf(", arg%d = 0x%" PRIx64, static_cast<int>(i + 1), args[i]);
-    s.PutCString(")");
-    log->PutString(s.GetString());
-  }
-
-  const uint32_t pc_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
-      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
-  const uint32_t sp_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
-      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
-  const uint32_t ra_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
-      eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA);
-
-  // x0 - x7 contain first 8 simple args
-  if (args.size() > 8) // TODO handle more than 6 arguments
-    return false;
-
-  for (size_t i = 0; i < args.size(); ++i) {
-    const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
-        eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + i);
-    LLDB_LOGF(log, "About to write arg%d (0x%" PRIx64 ") into %s",
-              static_cast<int>(i + 1), args[i], reg_info->name);
-    if (!reg_ctx->WriteRegisterFromUnsigned(reg_info, args[i]))
-      return false;
-  }
-
-  // Set "lr" to the return address
-  if (!reg_ctx->WriteRegisterFromUnsigned(
-          reg_ctx->GetRegisterInfoAtIndex(ra_reg_num), return_addr))
-    return false;
-
-  // Set "sp" to the requested value
-  if (!reg_ctx->WriteRegisterFromUnsigned(
-          reg_ctx->GetRegisterInfoAtIndex(sp_reg_num), sp))
-    return false;
-
-  // Set "pc" to the address requested
-  if (!reg_ctx->WriteRegisterFromUnsigned(
-          reg_ctx->GetRegisterInfoAtIndex(pc_reg_num), func_addr))
-    return false;
-
-  return true;
-}
-
-bool ABIMacOSX_arm64::GetArgumentValues(Thread &thread,
-                                        ValueList &values) const {
-  uint32_t num_values = values.GetSize();
-
-  ExecutionContext exe_ctx(thread.shared_from_this());
-
-  // Extract the register context so we can read arguments from registers
-
-  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
-
-  if (!reg_ctx)
-    return false;
-
-  addr_t sp = 0;
-
-  for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
-    // We currently only support extracting values with Clang QualTypes. Do we
-    // care about others?
-    Value *value = values.GetValueAtIndex(value_idx);
-
-    if (!value)
-      return false;
-
-    CompilerType value_type = value->GetCompilerType();
-    llvm::Optional<uint64_t> bit_size = value_type.GetBitSize(&thread);
-    if (!bit_size)
-      return false;
-
-    bool is_signed = false;
-    size_t bit_width = 0;
-    if (value_type.IsIntegerOrEnumerationType(is_signed)) {
-      bit_width = *bit_size;
-    } else if (value_type.IsPointerOrReferenceType()) {
-      bit_width = *bit_size;
-    } else {
-      // We only handle integer, pointer and reference types currently...
-      return false;
-    }
-
-    if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) {
-      if (value_idx < 8) {
-        // Arguments 1-6 are in x0-x5...
-        const RegisterInfo *reg_info = nullptr;
-        // Search by generic ID first, then fall back to by name
-        uint32_t arg_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
-            eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + value_idx);
-        if (arg_reg_num != LLDB_INVALID_REGNUM) {
-          reg_info = reg_ctx->GetRegisterInfoAtIndex(arg_reg_num);
-        } else {
-          switch (value_idx) {
-          case 0:
-            reg_info = reg_ctx->GetRegisterInfoByName("x0");
-            break;
-          case 1:
-            reg_info = reg_ctx->GetRegisterInfoByName("x1");
-            break;
-          case 2:
-            reg_info = reg_ctx->GetRegisterInfoByName("x2");
-            break;
-          case 3:
-            reg_info = reg_ctx->GetRegisterInfoByName("x3");
-            break;
-          case 4:
-            reg_info = reg_ctx->GetRegisterInfoByName("x4");
-            break;
-          case 5:
-            reg_info = reg_ctx->GetRegisterInfoByName("x5");
-            break;
-          case 6:
-            reg_info = reg_ctx->GetRegisterInfoByName("x6");
-            break;
-          case 7:
-            reg_info = reg_ctx->GetRegisterInfoByName("x7");
-            break;
-          }
-        }
-
-        if (reg_info) {
-          RegisterValue reg_value;
-
-          if (reg_ctx->ReadRegister(reg_info, reg_value)) {
-            if (is_signed)
-              reg_value.SignExtend(bit_width);
-            if (!reg_value.GetScalarValue(value->GetScalar()))
-              return false;
-            continue;
-          }
-        }
-        return false;
-      } else {
-        if (sp == 0) {
-          // Read the stack pointer if we already haven't read it
-          sp = reg_ctx->GetSP(0);
-          if (sp == 0)
-            return false;
-        }
-
-        // Arguments 5 on up are on the stack
-        const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
-        Status error;
-        if (!exe_ctx.GetProcessRef().ReadScalarIntegerFromMemory(
-                sp, arg_byte_size, is_signed, value->GetScalar(), error))
-          return false;
-
-        sp += arg_byte_size;
-        // Align up to the next 8 byte boundary if needed
-        if (sp % 8) {
-          sp >>= 3;
-          sp += 1;
-          sp <<= 3;
-        }
-      }
-    }
-  }
-  return true;
-}
-
-Status
-ABIMacOSX_arm64::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
-                                      lldb::ValueObjectSP &new_value_sp) {
-  Status error;
-  if (!new_value_sp) {
-    error.SetErrorString("Empty value object for return value.");
-    return error;
-  }
-
-  CompilerType return_value_type = new_value_sp->GetCompilerType();
-  if (!return_value_type) {
-    error.SetErrorString("Null clang type for return value.");
-    return error;
-  }
-
-  Thread *thread = frame_sp->GetThread().get();
-
-  RegisterContext *reg_ctx = thread->GetRegisterContext().get();
-
-  if (reg_ctx) {
-    DataExtractor data;
-    Status data_error;
-    const uint64_t byte_size = new_value_sp->GetData(data, data_error);
-    if (data_error.Fail()) {
-      error.SetErrorStringWithFormat(
-          "Couldn't convert return value to raw data: %s",
-          data_error.AsCString());
-      return error;
-    }
-
-    const uint32_t type_flags = return_value_type.GetTypeInfo(nullptr);
-    if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
-      if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
-        // Extract the register context so we can read arguments from registers
-        lldb::offset_t offset = 0;
-        if (byte_size <= 16) {
-          const RegisterInfo *x0_info = reg_ctx->GetRegisterInfoByName("x0", 0);
-          if (byte_size <= 8) {
-            uint64_t raw_value = data.GetMaxU64(&offset, byte_size);
-
-            if (!reg_ctx->WriteRegisterFromUnsigned(x0_info, raw_value))
-              error.SetErrorString("failed to write register x0");
-          } else {
-            uint64_t raw_value = data.GetMaxU64(&offset, 8);
-
-            if (reg_ctx->WriteRegisterFromUnsigned(x0_info, raw_value)) {
-              const RegisterInfo *x1_info =
-                  reg_ctx->GetRegisterInfoByName("x1", 0);
-              raw_value = data.GetMaxU64(&offset, byte_size - offset);
-
-              if (!reg_ctx->WriteRegisterFromUnsigned(x1_info, raw_value))
-                error.SetErrorString("failed to write register x1");
-            }
-          }
-        } else {
-          error.SetErrorString("We don't support returning longer than 128 bit "
-                               "integer values at present.");
-        }
-      } else if (type_flags & eTypeIsFloat) {
-        if (type_flags & eTypeIsComplex) {
-          // Don't handle complex yet.
-          error.SetErrorString(
-              "returning complex float values are not supported");
-        } else {
-          const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
-
-          if (v0_info) {
-            if (byte_size <= 16) {
-              if (byte_size <= RegisterValue::GetMaxByteSize()) {
-                RegisterValue reg_value;
-                error = reg_value.SetValueFromData(v0_info, data, 0, true);
-                if (error.Success()) {
-                  if (!reg_ctx->WriteRegister(v0_info, reg_value))
-                    error.SetErrorString("failed to write register v0");
-                }
-              } else {
-                error.SetErrorStringWithFormat(
-                    "returning float values with a byte size of %" PRIu64
-                    " are not supported",
-                    byte_size);
-              }
-            } else {
-              error.SetErrorString("returning float values longer than 128 "
-                                   "bits are not supported");
-            }
-          } else {
-            error.SetErrorString("v0 register is not available on this target");
-          }
-        }
-      }
-    } else if (type_flags & eTypeIsVector) {
-      if (byte_size > 0) {
-        const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
-
-        if (v0_info) {
-          if (byte_size <= v0_info->byte_size) {
-            RegisterValue reg_value;
-            error = reg_value.SetValueFromData(v0_info, data, 0, true);
-            if (error.Success()) {
-              if (!reg_ctx->WriteRegister(v0_info, reg_value))
-                error.SetErrorString("failed to write register v0");
-            }
-          }
-        }
-      }
-    }
-  } else {
-    error.SetErrorString("no registers are available");
-  }
-
-  return error;
-}
-
-bool ABIMacOSX_arm64::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) {
-  unwind_plan.Clear();
-  unwind_plan.SetRegisterKind(eRegisterKindDWARF);
-
-  uint32_t lr_reg_num = arm64_dwarf::lr;
-  uint32_t sp_reg_num = arm64_dwarf::sp;
-  uint32_t pc_reg_num = arm64_dwarf::pc;
-
-  UnwindPlan::RowSP row(new UnwindPlan::Row);
-
-  // Our previous Call Frame Address is the stack pointer
-  row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
-
-  // Our previous PC is in the LR
-  row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
-
-  unwind_plan.AppendRow(row);
-
-  // All other registers are the same.
-
-  unwind_plan.SetSourceName("arm64 at-func-entry default");
-  unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
-
-  return true;
-}
-
-bool ABIMacOSX_arm64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
-  unwind_plan.Clear();
-  unwind_plan.SetRegisterKind(eRegisterKindDWARF);
-
-  uint32_t fp_reg_num = arm64_dwarf::fp;
-  uint32_t pc_reg_num = arm64_dwarf::pc;
-
-  UnwindPlan::RowSP row(new UnwindPlan::Row);
-  const int32_t ptr_size = 8;
-
-  row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
-  row->SetOffset(0);
-
-  row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
-  row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
-
-  unwind_plan.AppendRow(row);
-  unwind_plan.SetSourceName("arm64-apple-darwin default unwind plan");
-  unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
-  unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
-  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
-  return true;
-}
-
-// AAPCS64 (Procedure Call Standard for the ARM 64-bit Architecture) says
-// registers x19 through x28 and sp are callee preserved. v8-v15 are non-
-// volatile (and specifically only the lower 8 bytes of these regs), the rest
-// of the fp/SIMD registers are volatile.
-//
-// v. https://github.com/ARM-software/software-standards/blob/master/abi/aapcs64/
-
-// We treat x29 as callee preserved also, else the unwinder won't try to
-// retrieve fp saves.
-
-bool ABIMacOSX_arm64::RegisterIsVolatile(const RegisterInfo *reg_info) {
-  if (reg_info) {
-    const char *name = reg_info->name;
-
-    // Sometimes we'll be called with the "alternate" name for these registers;
-    // recognize them as non-volatile.
-
-    if (name[0] == 'p' && name[1] == 'c') // pc
-      return false;
-    if (name[0] == 'f' && name[1] == 'p') // fp
-      return false;
-    if (name[0] == 's' && name[1] == 'p') // sp
-      return false;
-    if (name[0] == 'l' && name[1] == 'r') // lr
-      return false;
-
-    if (name[0] == 'x') {
-      // Volatile registers: x0-x18, x30 (lr)
-      // Return false for the non-volatile gpr regs, true for everything else
-      switch (name[1]) {
-      case '1':
-        switch (name[2]) {
-        case '9':
-          return false; // x19 is non-volatile
-        default:
-          return true;
-        }
-        break;
-      case '2':
-        switch (name[2]) {
-        case '0':
-        case '1':
-        case '2':
-        case '3':
-        case '4':
-        case '5':
-        case '6':
-        case '7':
-        case '8':
-          return false; // x20 - 28 are non-volatile
-        case '9':
-          return false; // x29 aka fp treat as non-volatile on Darwin
-        default:
-          return true;
-        }
-      case '3': // x30 aka lr treat as non-volatile
-        if (name[2] == '0')
-          return false;
-        break;
-      default:
-        return true;
-      }
-    } else if (name[0] == 'v' || name[0] == 's' || name[0] == 'd') {
-      // Volatile registers: v0-7, v16-v31
-      // Return false for non-volatile fp/SIMD regs, true for everything else
-      switch (name[1]) {
-      case '8':
-      case '9':
-        return false; // v8-v9 are non-volatile
-      case '1':
-        switch (name[2]) {
-        case '0':
-        case '1':
-        case '2':
-        case '3':
-        case '4':
-        case '5':
-          return false; // v10-v15 are non-volatile
-        default:
-          return true;
-        }
-      default:
-        return true;
-      }
-    }
-  }
-  return true;
-}
-
-static bool LoadValueFromConsecutiveGPRRegisters(
-    ExecutionContext &exe_ctx, RegisterContext *reg_ctx,
-    const CompilerType &value_type,
-    bool is_return_value, // false => parameter, true => return value
-    uint32_t &NGRN,       // NGRN (see ABI documentation)
-    uint32_t &NSRN,       // NSRN (see ABI documentation)
-    DataExtractor &data) {
-  llvm::Optional<uint64_t> byte_size = value_type.GetByteSize(nullptr);
-  if (!byte_size || *byte_size == 0)
-    return false;
-
-  std::unique_ptr<DataBufferHeap> heap_data_up(
-      new DataBufferHeap(*byte_size, 0));
-  const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
-  Status error;
-
-  CompilerType base_type;
-  const uint32_t homogeneous_count =
-      value_type.IsHomogeneousAggregate(&base_type);
-  if (homogeneous_count > 0 && homogeneous_count <= 8) {
-    // Make sure we have enough registers
-    if (NSRN < 8 && (8 - NSRN) >= homogeneous_count) {
-      if (!base_type)
-        return false;
-      llvm::Optional<uint64_t> base_byte_size = base_type.GetByteSize(nullptr);
-      if (!base_byte_size)
-        return false;
-      uint32_t data_offset = 0;
-
-      for (uint32_t i = 0; i < homogeneous_count; ++i) {
-        char v_name[8];
-        ::snprintf(v_name, sizeof(v_name), "v%u", NSRN);
-        const RegisterInfo *reg_info =
-            reg_ctx->GetRegisterInfoByName(v_name, 0);
-        if (reg_info == nullptr)
-          return false;
-
-        if (*base_byte_size > reg_info->byte_size)
-          return false;
-
-        RegisterValue reg_value;
-
-        if (!reg_ctx->ReadRegister(reg_info, reg_value))
-          return false;
-
-        // Make sure we have enough room in "heap_data_up"
-        if ((data_offset + *base_byte_size) <= heap_data_up->GetByteSize()) {
-          const size_t bytes_copied = reg_value.GetAsMemoryData(
-              reg_info, heap_data_up->GetBytes() + data_offset, *base_byte_size,
-              byte_order, error);
-          if (bytes_copied != *base_byte_size)
-            return false;
-          data_offset += bytes_copied;
-          ++NSRN;
-        } else
-          return false;
-      }
-      data.SetByteOrder(byte_order);
-      data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize());
-      data.SetData(DataBufferSP(heap_data_up.release()));
-      return true;
-    }
-  }
-
-  const size_t max_reg_byte_size = 16;
-  if (*byte_size <= max_reg_byte_size) {
-    size_t bytes_left = *byte_size;
-    uint32_t data_offset = 0;
-    while (data_offset < *byte_size) {
-      if (NGRN >= 8)
-        return false;
-
-      uint32_t reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
-          eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + NGRN);
-      if (reg_num == LLDB_INVALID_REGNUM)
-        return false;
-
-      const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_num);
-      if (reg_info == nullptr)
-        return false;
-
-      RegisterValue reg_value;
-
-      if (!reg_ctx->ReadRegister(reg_info, reg_value))
-        return false;
-
-      const size_t curr_byte_size = std::min<size_t>(8, bytes_left);
-      const size_t bytes_copied = reg_value.GetAsMemoryData(
-          reg_info, heap_data_up->GetBytes() + data_offset, curr_byte_size,
-          byte_order, error);
-      if (bytes_copied == 0)
-        return false;
-      if (bytes_copied >= bytes_left)
-        break;
-      data_offset += bytes_copied;
-      bytes_left -= bytes_copied;
-      ++NGRN;
-    }
-  } else {
-    const RegisterInfo *reg_info = nullptr;
-    if (is_return_value) {
-      // We are assuming we are decoding this immediately after returning from
-      // a function call and that the address of the structure is in x8
-      reg_info = reg_ctx->GetRegisterInfoByName("x8", 0);
-    } else {
-      // We are assuming we are stopped at the first instruction in a function
-      // and that the ABI is being respected so all parameters appear where
-      // they should be (functions with no external linkage can legally violate
-      // the ABI).
-      if (NGRN >= 8)
-        return false;
-
-      uint32_t reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
-          eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + NGRN);
-      if (reg_num == LLDB_INVALID_REGNUM)
-        return false;
-      reg_info = reg_ctx->GetRegisterInfoAtIndex(reg_num);
-      if (reg_info == nullptr)
-        return false;
-      ++NGRN;
-    }
-
-    if (reg_info == nullptr)
-      return false;
-
-    const lldb::addr_t value_addr =
-        reg_ctx->ReadRegisterAsUnsigned(reg_info, LLDB_INVALID_ADDRESS);
-
-    if (value_addr == LLDB_INVALID_ADDRESS)
-      return false;
-
-    if (exe_ctx.GetProcessRef().ReadMemory(
-            value_addr, heap_data_up->GetBytes(), heap_data_up->GetByteSize(),
-            error) != heap_data_up->GetByteSize()) {
-      return false;
-    }
-  }
-
-  data.SetByteOrder(byte_order);
-  data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize());
-  data.SetData(DataBufferSP(heap_data_up.release()));
-  return true;
-}
-
-ValueObjectSP ABIMacOSX_arm64::GetReturnValueObjectImpl(
-    Thread &thread, CompilerType &return_compiler_type) const {
-  ValueObjectSP return_valobj_sp;
-  Value value;
-
-  ExecutionContext exe_ctx(thread.shared_from_this());
-  if (exe_ctx.GetTargetPtr() == nullptr || exe_ctx.GetProcessPtr() == nullptr)
-    return return_valobj_sp;
-
-  // value.SetContext (Value::eContextTypeClangType, return_compiler_type);
-  value.SetCompilerType(return_compiler_type);
-
-  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
-  if (!reg_ctx)
-    return return_valobj_sp;
-
-  llvm::Optional<uint64_t> byte_size =
-      return_compiler_type.GetByteSize(nullptr);
-  if (!byte_size)
-    return return_valobj_sp;
-
-  const uint32_t type_flags = return_compiler_type.GetTypeInfo(nullptr);
-  if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
-    value.SetValueType(Value::eValueTypeScalar);
-
-    bool success = false;
-    if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
-      // Extract the register context so we can read arguments from registers
-      if (*byte_size <= 8) {
-        const RegisterInfo *x0_reg_info =
-            reg_ctx->GetRegisterInfoByName("x0", 0);
-        if (x0_reg_info) {
-          uint64_t raw_value =
-              thread.GetRegisterContext()->ReadRegisterAsUnsigned(x0_reg_info,
-                                                                  0);
-          const bool is_signed = (type_flags & eTypeIsSigned) != 0;
-          switch (*byte_size) {
-          default:
-            break;
-          case 16: // uint128_t
-            // In register x0 and x1
-            {
-              const RegisterInfo *x1_reg_info =
-                  reg_ctx->GetRegisterInfoByName("x1", 0);
-
-              if (x1_reg_info) {
-                if (*byte_size <=
-                    x0_reg_info->byte_size + x1_reg_info->byte_size) {
-                  std::unique_ptr<DataBufferHeap> heap_data_up(
-                      new DataBufferHeap(*byte_size, 0));
-                  const ByteOrder byte_order =
-                      exe_ctx.GetProcessRef().GetByteOrder();
-                  RegisterValue x0_reg_value;
-                  RegisterValue x1_reg_value;
-                  if (reg_ctx->ReadRegister(x0_reg_info, x0_reg_value) &&
-                      reg_ctx->ReadRegister(x1_reg_info, x1_reg_value)) {
-                    Status error;
-                    if (x0_reg_value.GetAsMemoryData(
-                            x0_reg_info, heap_data_up->GetBytes() + 0, 8,
-                            byte_order, error) &&
-                        x1_reg_value.GetAsMemoryData(
-                            x1_reg_info, heap_data_up->GetBytes() + 8, 8,
-                            byte_order, error)) {
-                      DataExtractor data(
-                          DataBufferSP(heap_data_up.release()), byte_order,
-                          exe_ctx.GetProcessRef().GetAddressByteSize());
-
-                      return_valobj_sp = ValueObjectConstResult::Create(
-                          &thread, return_compiler_type, ConstString(""), data);
-                      return return_valobj_sp;
-                    }
-                  }
-                }
-              }
-            }
-            break;
-          case sizeof(uint64_t):
-            if (is_signed)
-              value.GetScalar() = (int64_t)(raw_value);
-            else
-              value.GetScalar() = (uint64_t)(raw_value);
-            success = true;
-            break;
-
-          case sizeof(uint32_t):
-            if (is_signed)
-              value.GetScalar() = (int32_t)(raw_value & UINT32_MAX);
-            else
-              value.GetScalar() = (uint32_t)(raw_value & UINT32_MAX);
-            success = true;
-            break;
-
-          case sizeof(uint16_t):
-            if (is_signed)
-              value.GetScalar() = (int16_t)(raw_value & UINT16_MAX);
-            else
-              value.GetScalar() = (uint16_t)(raw_value & UINT16_MAX);
-            success = true;
-            break;
-
-          case sizeof(uint8_t):
-            if (is_signed)
-              value.GetScalar() = (int8_t)(raw_value & UINT8_MAX);
-            else
-              value.GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
-            success = true;
-            break;
-          }
-        }
-      }
-    } else if (type_flags & eTypeIsFloat) {
-      if (type_flags & eTypeIsComplex) {
-        // Don't handle complex yet.
-      } else {
-        if (*byte_size <= sizeof(long double)) {
-          const RegisterInfo *v0_reg_info =
-              reg_ctx->GetRegisterInfoByName("v0", 0);
-          RegisterValue v0_value;
-          if (reg_ctx->ReadRegister(v0_reg_info, v0_value)) {
-            DataExtractor data;
-            if (v0_value.GetData(data)) {
-              lldb::offset_t offset = 0;
-              if (*byte_size == sizeof(float)) {
-                value.GetScalar() = data.GetFloat(&offset);
-                success = true;
-              } else if (*byte_size == sizeof(double)) {
-                value.GetScalar() = data.GetDouble(&offset);
-                success = true;
-              } else if (*byte_size == sizeof(long double)) {
-                value.GetScalar() = data.GetLongDouble(&offset);
-                success = true;
-              }
-            }
-          }
-        }
-      }
-    }
-
-    if (success)
-      return_valobj_sp = ValueObjectConstResult::Create(
-          thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
-  } else if (type_flags & eTypeIsVector) {
-    if (*byte_size > 0) {
-
-      const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
-
-      if (v0_info) {
-        if (*byte_size <= v0_info->byte_size) {
-          std::unique_ptr<DataBufferHeap> heap_data_up(
-              new DataBufferHeap(*byte_size, 0));
-          const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
-          RegisterValue reg_value;
-          if (reg_ctx->ReadRegister(v0_info, reg_value)) {
-            Status error;
-            if (reg_value.GetAsMemoryData(v0_info, heap_data_up->GetBytes(),
-                                          heap_data_up->GetByteSize(),
-                                          byte_order, error)) {
-              DataExtractor data(DataBufferSP(heap_data_up.release()),
-                                 byte_order,
-                                 exe_ctx.GetProcessRef().GetAddressByteSize());
-              return_valobj_sp = ValueObjectConstResult::Create(
-                  &thread, return_compiler_type, ConstString(""), data);
-            }
-          }
-        }
-      }
-    }
-  } else if (type_flags & eTypeIsStructUnion || type_flags & eTypeIsClass) {
-    DataExtractor data;
-
-    uint32_t NGRN = 0; // Search ABI docs for NGRN
-    uint32_t NSRN = 0; // Search ABI docs for NSRN
-    const bool is_return_value = true;
-    if (LoadValueFromConsecutiveGPRRegisters(
-            exe_ctx, reg_ctx, return_compiler_type, is_return_value, NGRN, NSRN,
-            data)) {
-      return_valobj_sp = ValueObjectConstResult::Create(
-          &thread, return_compiler_type, ConstString(""), data);
-    }
-  }
-  return return_valobj_sp;
-}
-
-void ABIMacOSX_arm64::Initialize() {
-  PluginManager::RegisterPlugin(GetPluginNameStatic(), pluginDesc,
-                                CreateInstance);
-}
-
-void ABIMacOSX_arm64::Terminate() {
-  PluginManager::UnregisterPlugin(CreateInstance);
-}
-
-// PluginInterface protocol
-
-ConstString ABIMacOSX_arm64::GetPluginNameStatic() {
-  static ConstString g_plugin_name("ABIMacOSX_arm64");
-  return g_plugin_name;
-}
-
-uint32_t ABIMacOSX_arm64::GetPluginVersion() { return 1; }
diff --git a/lldb/source/Plugins/ABI/Mips/ABIMips.cpp b/lldb/source/Plugins/ABI/Mips/ABIMips.cpp
new file mode 100644
index 0000000000000..16ef1faf9d9d6
--- /dev/null
+++ b/lldb/source/Plugins/ABI/Mips/ABIMips.cpp
@@ -0,0 +1,24 @@
+//===-- Mips.h ------------------------------------------------------------===//
+//
+// 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 "ABIMips.h"
+#include "ABISysV_mips.h"
+#include "ABISysV_mips64.h"
+#include "lldb/Core/PluginManager.h"
+
+LLDB_PLUGIN_DEFINE(ABIMips)
+
+void ABIMips::Initialize() {
+  ABISysV_mips::Initialize();
+  ABISysV_mips64::Initialize();
+}
+
+void ABIMips::Terminate() {
+  ABISysV_mips::Terminate();
+  ABISysV_mips64::Terminate();
+}
diff --git a/lldb/source/Plugins/ABI/Mips/ABIMips.h b/lldb/source/Plugins/ABI/Mips/ABIMips.h
new file mode 100644
index 0000000000000..dc7704de1c96d
--- /dev/null
+++ b/lldb/source/Plugins/ABI/Mips/ABIMips.h
@@ -0,0 +1,17 @@
+//===-- Mips.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_SOURCE_PLUGINS_ABI_MIPS_ABIMIPS_H
+#define LLDB_SOURCE_PLUGINS_ABI_MIPS_ABIMIPS_H
+
+class ABIMips {
+public:
+  static void Initialize();
+  static void Terminate();
+};
+#endif
diff --git a/lldb/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp b/lldb/source/Plugins/ABI/Mips/ABISysV_mips.cpp
index 416db9f5ae873..d66e0926ad99e 100644
--- a/lldb/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp
+++ b/lldb/source/Plugins/ABI/Mips/ABISysV_mips.cpp
@@ -1,4 +1,4 @@
-//===-- ABISysV_mips.cpp ----------------------------------------*- C++ -*-===//
+//===-- ABISysV_mips.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -32,6 +32,8 @@
 using namespace lldb;
 using namespace lldb_private;
 
+LLDB_PLUGIN_DEFINE(ABISysV_mips)
+
 enum dwarf_regnums {
   dwarf_r0 = 0,
   dwarf_r1,
diff --git a/lldb/source/Plugins/ABI/SysV-mips/ABISysV_mips.h b/lldb/source/Plugins/ABI/Mips/ABISysV_mips.h
index 8143f552fc4d4..715405e7ef977 100644
--- a/lldb/source/Plugins/ABI/SysV-mips/ABISysV_mips.h
+++ b/lldb/source/Plugins/ABI/Mips/ABISysV_mips.h
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_ABISysV_mips_h_
-#define liblldb_ABISysV_mips_h_
+#ifndef LLDB_SOURCE_PLUGINS_ABI_MIPS_ABISYSV_MIPS_H
+#define LLDB_SOURCE_PLUGINS_ABI_MIPS_ABISYSV_MIPS_H
 
 #include "lldb/Target/ABI.h"
 #include "lldb/lldb-private.h"
 
-class ABISysV_mips : public lldb_private::ABI {
+class ABISysV_mips : public lldb_private::RegInfoBasedABI {
 public:
   ~ABISysV_mips() override = default;
 
@@ -87,11 +87,7 @@ protected:
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
 private:
-  ABISysV_mips(lldb::ProcessSP process_sp,
-               std::unique_ptr<llvm::MCRegisterInfo> info_up)
-      : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
-    // Call CreateInstance instead.
-  }
+  using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
-#endif // liblldb_ABISysV_mips_h_
+#endif // LLDB_SOURCE_PLUGINS_ABI_MIPS_ABISYSV_MIPS_H
diff --git a/lldb/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp b/lldb/source/Plugins/ABI/Mips/ABISysV_mips64.cpp
index 72ec0715b6cd5..bb28a50e5f4ab 100644
--- a/lldb/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp
+++ b/lldb/source/Plugins/ABI/Mips/ABISysV_mips64.cpp
@@ -1,4 +1,4 @@
-//===-- ABISysV_mips64.cpp --------------------------------------*- C++ -*-===//
+//===-- ABISysV_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.
@@ -32,6 +32,8 @@
 using namespace lldb;
 using namespace lldb_private;
 
+LLDB_PLUGIN_DEFINE(ABISysV_mips64)
+
 enum dwarf_regnums {
   dwarf_r0 = 0,
   dwarf_r1,
diff --git a/lldb/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.h b/lldb/source/Plugins/ABI/Mips/ABISysV_mips64.h
index 76c3c5413b920..91428216a73a9 100644
--- a/lldb/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.h
+++ b/lldb/source/Plugins/ABI/Mips/ABISysV_mips64.h
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_ABISysV_mips64_h_
-#define liblldb_ABISysV_mips64_h_
+#ifndef LLDB_SOURCE_PLUGINS_ABI_MIPS_ABISYSV_MIPS64_H
+#define LLDB_SOURCE_PLUGINS_ABI_MIPS_ABISYSV_MIPS64_H
 
 #include "lldb/Target/ABI.h"
 #include "lldb/lldb-private.h"
 
-class ABISysV_mips64 : public lldb_private::ABI {
+class ABISysV_mips64 : public lldb_private::RegInfoBasedABI {
 public:
   ~ABISysV_mips64() override = default;
 
@@ -51,7 +51,7 @@ public:
   //
   // To work around this, we relax that alignment to be just word-size
   // (8-bytes).
-  // Whitelisting the trap handlers for user space would be easy (_sigtramp) but
+  // Allowing the trap handlers for user space would be easy (_sigtramp) but
   // in other environments there can be a large number of different functions
   // involved in async traps.
   bool CallFrameAddressIsValid(lldb::addr_t cfa) override {
@@ -100,11 +100,7 @@ protected:
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
 private:
-  ABISysV_mips64(lldb::ProcessSP process_sp,
-                 std::unique_ptr<llvm::MCRegisterInfo> info_up)
-      : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
-    // Call CreateInstance instead.
-  }
+  using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
-#endif // liblldb_ABISysV_mips64_h_
+#endif // LLDB_SOURCE_PLUGINS_ABI_MIPS_ABISYSV_MIPS64_H
diff --git a/lldb/source/Plugins/ABI/PowerPC/ABIPowerPC.cpp b/lldb/source/Plugins/ABI/PowerPC/ABIPowerPC.cpp
new file mode 100644
index 0000000000000..b561e3c93f571
--- /dev/null
+++ b/lldb/source/Plugins/ABI/PowerPC/ABIPowerPC.cpp
@@ -0,0 +1,24 @@
+//===-- PowerPC.h ---------------------------------------------------------===//
+//
+// 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 "ABIPowerPC.h"
+#include "ABISysV_ppc.h"
+#include "ABISysV_ppc64.h"
+#include "lldb/Core/PluginManager.h"
+
+LLDB_PLUGIN_DEFINE(ABIPowerPC)
+
+void ABIPowerPC::Initialize() {
+  ABISysV_ppc::Initialize();
+  ABISysV_ppc64::Initialize();
+}
+
+void ABIPowerPC::Terminate() {
+  ABISysV_ppc::Terminate();
+  ABISysV_ppc64::Terminate();
+}
diff --git a/lldb/source/Plugins/ABI/PowerPC/ABIPowerPC.h b/lldb/source/Plugins/ABI/PowerPC/ABIPowerPC.h
new file mode 100644
index 0000000000000..5e745eae0a422
--- /dev/null
+++ b/lldb/source/Plugins/ABI/PowerPC/ABIPowerPC.h
@@ -0,0 +1,17 @@
+//===-- 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 LLDB_SOURCE_PLUGINS_ABI_POWERPC_ABIPOWERPC_H
+#define LLDB_SOURCE_PLUGINS_ABI_POWERPC_ABIPOWERPC_H
+
+class ABIPowerPC {
+public:
+  static void Initialize();
+  static void Terminate();
+};
+#endif
diff --git a/lldb/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp b/lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc.cpp
index 857b7fee10e3e..6f5eded7b0315 100644
--- a/lldb/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp
+++ b/lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc.cpp
@@ -1,4 +1,4 @@
-//===-- ABISysV_ppc.cpp -----------------------------------------*- C++ -*-===//
+//===-- ABISysV_ppc.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -32,6 +32,8 @@
 using namespace lldb;
 using namespace lldb_private;
 
+LLDB_PLUGIN_DEFINE(ABISysV_ppc)
+
 enum dwarf_regnums {
   dwarf_r0 = 0,
   dwarf_r1,
diff --git a/lldb/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.h b/lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc.h
index 59907c4648ba9..4a586849e5857 100644
--- a/lldb/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.h
+++ b/lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc.h
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_ABISysV_ppc_h_
-#define liblldb_ABISysV_ppc_h_
+#ifndef LLDB_SOURCE_PLUGINS_ABI_POWERPC_ABISYSV_PPC_H
+#define LLDB_SOURCE_PLUGINS_ABI_POWERPC_ABISYSV_PPC_H
 
 #include "lldb/Target/ABI.h"
 #include "lldb/lldb-private.h"
 
-class ABISysV_ppc : public lldb_private::ABI {
+class ABISysV_ppc : public lldb_private::RegInfoBasedABI {
 public:
   ~ABISysV_ppc() override = default;
 
@@ -49,7 +49,7 @@ public:
   //
   // To work around this, we relax that alignment to be just word-size
   // (8-bytes).
-  // Whitelisting the trap handlers for user space would be easy (_sigtramp) but
+  // Allowing the trap handlers for user space would be easy (_sigtramp) but
   // in other environments there can be a large number of different functions
   // involved in async traps.
   bool CallFrameAddressIsValid(lldb::addr_t cfa) override {
@@ -96,11 +96,7 @@ protected:
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
 private:
-  ABISysV_ppc(lldb::ProcessSP process_sp,
-              std::unique_ptr<llvm::MCRegisterInfo> info_up)
-      : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
-    // Call CreateInstance instead.
-  }
+  using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
-#endif // liblldb_ABISysV_ppc_h_
+#endif // LLDB_SOURCE_PLUGINS_ABI_POWERPC_ABISYSV_PPC_H
diff --git a/lldb/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp b/lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc64.cpp
index 935353c38ca42..251ac972fd768 100644
--- a/lldb/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp
+++ b/lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc64.cpp
@@ -1,4 +1,4 @@
-//===-- ABISysV_ppc64.cpp ---------------------------------------*- C++ -*-===//
+//===-- ABISysV_ppc64.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -11,6 +11,7 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 
+#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "Utility/PPC64LE_DWARF_Registers.h"
 #include "Utility/PPC64_DWARF_Registers.h"
 #include "lldb/Core/Module.h"
@@ -19,7 +20,6 @@
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Core/ValueObjectRegister.h"
-#include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
@@ -47,6 +47,8 @@
 using namespace lldb;
 using namespace lldb_private;
 
+LLDB_PLUGIN_DEFINE(ABISysV_ppc64)
+
 const lldb_private::RegisterInfo *
 ABISysV_ppc64::GetRegisterInfoArray(uint32_t &count) {
   if (GetByteOrder() == lldb::eByteOrderLittle) {
@@ -806,10 +808,10 @@ private:
     // case 3: get from GPRs
 
     // first, check if this is a packed struct or not
-    ClangASTContext *ast =
-        llvm::dyn_cast<ClangASTContext>(m_type.GetTypeSystem());
+    TypeSystemClang *ast =
+        llvm::dyn_cast<TypeSystemClang>(m_type.GetTypeSystem());
     if (ast) {
-      clang::RecordDecl *record_decl = ClangASTContext::GetAsRecordDecl(m_type);
+      clang::RecordDecl *record_decl = TypeSystemClang::GetAsRecordDecl(m_type);
 
       if (record_decl) {
         auto attrs = record_decl->attrs();
diff --git a/lldb/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.h b/lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc64.h
index 1b58975dd9d9d..8dcf3ca48b56c 100644
--- a/lldb/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.h
+++ b/lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc64.h
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_ABISysV_ppc64_h_
-#define liblldb_ABISysV_ppc64_h_
+#ifndef LLDB_SOURCE_PLUGINS_ABI_POWERPC_ABISYSV_PPC64_H
+#define LLDB_SOURCE_PLUGINS_ABI_POWERPC_ABISYSV_PPC64_H
 
 #include "lldb/Target/ABI.h"
 #include "lldb/lldb-private.h"
 
-class ABISysV_ppc64 : public lldb_private::ABI {
+class ABISysV_ppc64 : public lldb_private::RegInfoBasedABI {
 public:
   ~ABISysV_ppc64() override = default;
 
@@ -49,7 +49,7 @@ public:
   //
   // To work around this, we relax that alignment to be just word-size
   // (8-bytes).
-  // Whitelisting the trap handlers for user space would be easy (_sigtramp) but
+  // Allowing the trap handlers for user space would be easy (_sigtramp) but
   // in other environments there can be a large number of different functions
   // involved in async traps.
   bool CallFrameAddressIsValid(lldb::addr_t cfa) override {
@@ -96,13 +96,9 @@ protected:
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
 private:
-  ABISysV_ppc64(lldb::ProcessSP process_sp,
-                std::unique_ptr<llvm::MCRegisterInfo> info_up)
-      : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
-    // Call CreateInstance instead.
-  }
+  using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 
   lldb::ByteOrder GetByteOrder() const;
 };
 
-#endif // liblldb_ABISysV_ppc64_h_
+#endif // LLDB_SOURCE_PLUGINS_ABI_POWERPC_ABISYSV_PPC64_H
diff --git a/lldb/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp b/lldb/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp
deleted file mode 100644
index 89a1f2b3cf04d..0000000000000
--- a/lldb/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp
+++ /dev/null
@@ -1,2420 +0,0 @@
-//===-- ABISysV_arm64.cpp ---------------------------------------*- 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
-//
-//===----------------------------------------------------------------------===//
-
-#include "ABISysV_arm64.h"
-
-#include <vector>
-
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/Triple.h"
-
-#include "lldb/Core/Module.h"
-#include "lldb/Core/PluginManager.h"
-#include "lldb/Core/Value.h"
-#include "lldb/Core/ValueObjectConstResult.h"
-#include "lldb/Symbol/UnwindPlan.h"
-#include "lldb/Target/Process.h"
-#include "lldb/Target/RegisterContext.h"
-#include "lldb/Target/Target.h"
-#include "lldb/Target/Thread.h"
-#include "lldb/Utility/ConstString.h"
-#include "lldb/Utility/Log.h"
-#include "lldb/Utility/RegisterValue.h"
-#include "lldb/Utility/Scalar.h"
-#include "lldb/Utility/Status.h"
-
-#include "Utility/ARM64_DWARF_Registers.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-static RegisterInfo g_register_infos[] = {
-    //  NAME       ALT       SZ OFF ENCODING          FORMAT
-    //  EH_FRAME             DWARF                  GENERIC
-    //  PROCESS PLUGIN          LLDB NATIVE
-    //  ========== =======   == === =============     ===================
-    //  ===================  ====================== ===========================
-    //  ======================= ======================
-    {"x0",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x0, LLDB_REGNUM_GENERIC_ARG1,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x1",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x1, LLDB_REGNUM_GENERIC_ARG2,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x2",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x2, LLDB_REGNUM_GENERIC_ARG3,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x3",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x3, LLDB_REGNUM_GENERIC_ARG4,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x4",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x4, LLDB_REGNUM_GENERIC_ARG5,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x5",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x5, LLDB_REGNUM_GENERIC_ARG6,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x6",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x6, LLDB_REGNUM_GENERIC_ARG7,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x7",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x7, LLDB_REGNUM_GENERIC_ARG8,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x8",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x8, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x9",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x9, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x10",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x10, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x11",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x11, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x12",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x12, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x13",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x13, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x14",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x14, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x15",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x15, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x16",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x16, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x17",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x17, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x18",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x18, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x19",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x19, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x20",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x20, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x21",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x21, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x22",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x22, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x23",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x23, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x24",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x24, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x25",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x25, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x26",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x26, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x27",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x27, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"x28",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x28, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fp",
-     "x29",
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x29, LLDB_REGNUM_GENERIC_FP,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"lr",
-     "x30",
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x30, LLDB_REGNUM_GENERIC_RA,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"sp",
-     "x31",
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::x31, LLDB_REGNUM_GENERIC_SP,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"pc",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::pc, LLDB_REGNUM_GENERIC_PC,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"cpsr",
-     "psr",
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::cpsr, LLDB_REGNUM_GENERIC_FLAGS,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-
-    {"v0",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v0, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v1",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v1, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v2",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v2, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v3",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v3, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v4",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v4, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v5",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v5, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v6",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v6, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v7",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v7, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v8",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v8, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v9",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v9, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v10",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v10, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v11",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v11, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v12",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v12, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v13",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v13, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v14",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v14, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v15",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v15, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v16",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v16, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v17",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v17, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v18",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v18, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v19",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v19, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v20",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v20, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v21",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v21, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v22",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v22, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v23",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v23, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v24",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v24, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v25",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v25, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v26",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v26, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v27",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v27, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v28",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v28, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v29",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v29, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v30",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v30, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"v31",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, arm64_dwarf::v31, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-
-    {"fpsr",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fpcr",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-
-    {"s0",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s1",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s2",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s3",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s4",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s5",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s6",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s7",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s8",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s9",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s10",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s11",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s12",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s13",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s14",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s15",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s16",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s17",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s18",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s19",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s20",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s21",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s22",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s23",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s24",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s25",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s26",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s27",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s28",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s29",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s30",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"s31",
-     nullptr,
-     4,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-
-    {"d0",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d1",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d2",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d3",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d4",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d5",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d6",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d7",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d8",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d9",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d10",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d11",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d12",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d13",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d14",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d15",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d16",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d17",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d18",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d19",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d20",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d21",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d22",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d23",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d24",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d25",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d26",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d27",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d28",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d29",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d30",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"d31",
-     nullptr,
-     8,
-     0,
-     eEncodingIEEE754,
-     eFormatFloat,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0}};
-
-static const uint32_t k_num_register_infos =
-    llvm::array_lengthof(g_register_infos);
-static bool g_register_info_names_constified = false;
-
-const lldb_private::RegisterInfo *
-ABISysV_arm64::GetRegisterInfoArray(uint32_t &count) {
-  // Make the C-string names and alt_names for the register infos into const
-  // C-string values by having the ConstString unique the names in the global
-  // constant C-string pool.
-  if (!g_register_info_names_constified) {
-    g_register_info_names_constified = true;
-    for (uint32_t i = 0; i < k_num_register_infos; ++i) {
-      if (g_register_infos[i].name)
-        g_register_infos[i].name =
-            ConstString(g_register_infos[i].name).GetCString();
-      if (g_register_infos[i].alt_name)
-        g_register_infos[i].alt_name =
-            ConstString(g_register_infos[i].alt_name).GetCString();
-    }
-  }
-  count = k_num_register_infos;
-  return g_register_infos;
-}
-
-bool ABISysV_arm64::GetPointerReturnRegister(const char *&name) {
-  name = "x0";
-  return true;
-}
-
-size_t ABISysV_arm64::GetRedZoneSize() const { return 128; }
-
-// Static Functions
-
-ABISP
-ABISysV_arm64::CreateInstance(lldb::ProcessSP process_sp, const ArchSpec &arch) {
-  const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
-  const llvm::Triple::VendorType vendor_type = arch.GetTriple().getVendor();
-
-  if (vendor_type != llvm::Triple::Apple) {
-    if (arch_type == llvm::Triple::aarch64 ||
-        arch_type == llvm::Triple::aarch64_32) {
-      return ABISP(
-          new ABISysV_arm64(std::move(process_sp), MakeMCRegisterInfo(arch)));
-    }
-  }
-
-  return ABISP();
-}
-
-bool ABISysV_arm64::PrepareTrivialCall(Thread &thread, addr_t sp,
-                                       addr_t func_addr, addr_t return_addr,
-                                       llvm::ArrayRef<addr_t> args) const {
-  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
-  if (!reg_ctx)
-    return false;
-
-  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
-
-  if (log) {
-    StreamString s;
-    s.Printf("ABISysV_arm64::PrepareTrivialCall (tid = 0x%" PRIx64
-             ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64
-             ", return_addr = 0x%" PRIx64,
-             thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
-             (uint64_t)return_addr);
-
-    for (size_t i = 0; i < args.size(); ++i)
-      s.Printf(", arg%d = 0x%" PRIx64, static_cast<int>(i + 1), args[i]);
-    s.PutCString(")");
-    log->PutString(s.GetString());
-  }
-
-  // x0 - x7 contain first 8 simple args
-  if (args.size() > 8)
-    return false;
-
-  for (size_t i = 0; i < args.size(); ++i) {
-    const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
-        eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + i);
-    LLDB_LOGF(log, "About to write arg%d (0x%" PRIx64 ") into %s",
-              static_cast<int>(i + 1), args[i], reg_info->name);
-    if (!reg_ctx->WriteRegisterFromUnsigned(reg_info, args[i]))
-      return false;
-  }
-
-  // Set "lr" to the return address
-  if (!reg_ctx->WriteRegisterFromUnsigned(
-          reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
-                                   LLDB_REGNUM_GENERIC_RA),
-          return_addr))
-    return false;
-
-  // Set "sp" to the requested value
-  if (!reg_ctx->WriteRegisterFromUnsigned(
-          reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
-                                   LLDB_REGNUM_GENERIC_SP),
-          sp))
-    return false;
-
-  // Set "pc" to the address requested
-  if (!reg_ctx->WriteRegisterFromUnsigned(
-          reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
-                                   LLDB_REGNUM_GENERIC_PC),
-          func_addr))
-    return false;
-
-  return true;
-}
-
-// TODO: We dont support fp/SIMD arguments in v0-v7
-bool ABISysV_arm64::GetArgumentValues(Thread &thread, ValueList &values) const {
-  uint32_t num_values = values.GetSize();
-
-  ExecutionContext exe_ctx(thread.shared_from_this());
-
-  // Extract the register context so we can read arguments from registers
-
-  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
-
-  if (!reg_ctx)
-    return false;
-
-  addr_t sp = 0;
-
-  for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
-    // We currently only support extracting values with Clang QualTypes. Do we
-    // care about others?
-    Value *value = values.GetValueAtIndex(value_idx);
-
-    if (!value)
-      return false;
-
-    CompilerType value_type = value->GetCompilerType();
-    if (value_type) {
-      bool is_signed = false;
-      size_t bit_width = 0;
-      llvm::Optional<uint64_t> bit_size = value_type.GetBitSize(&thread);
-      if (!bit_size)
-        return false;
-      if (value_type.IsIntegerOrEnumerationType(is_signed)) {
-        bit_width = *bit_size;
-      } else if (value_type.IsPointerOrReferenceType()) {
-        bit_width = *bit_size;
-      } else {
-        // We only handle integer, pointer and reference types currently...
-        return false;
-      }
-
-      if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) {
-        if (value_idx < 8) {
-          // Arguments 1-8 are in x0-x7...
-          const RegisterInfo *reg_info = nullptr;
-          reg_info = reg_ctx->GetRegisterInfo(
-              eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + value_idx);
-
-          if (reg_info) {
-            RegisterValue reg_value;
-
-            if (reg_ctx->ReadRegister(reg_info, reg_value)) {
-              if (is_signed)
-                reg_value.SignExtend(bit_width);
-              if (!reg_value.GetScalarValue(value->GetScalar()))
-                return false;
-              continue;
-            }
-          }
-          return false;
-        } else {
-          // TODO: Verify for stack layout for SysV
-          if (sp == 0) {
-            // Read the stack pointer if we already haven't read it
-            sp = reg_ctx->GetSP(0);
-            if (sp == 0)
-              return false;
-          }
-
-          // Arguments 5 on up are on the stack
-          const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
-          Status error;
-          if (!exe_ctx.GetProcessRef().ReadScalarIntegerFromMemory(
-                  sp, arg_byte_size, is_signed, value->GetScalar(), error))
-            return false;
-
-          sp += arg_byte_size;
-          // Align up to the next 8 byte boundary if needed
-          if (sp % 8) {
-            sp >>= 3;
-            sp += 1;
-            sp <<= 3;
-          }
-        }
-      }
-    }
-  }
-  return true;
-}
-
-Status ABISysV_arm64::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
-                                           lldb::ValueObjectSP &new_value_sp) {
-  Status error;
-  if (!new_value_sp) {
-    error.SetErrorString("Empty value object for return value.");
-    return error;
-  }
-
-  CompilerType return_value_type = new_value_sp->GetCompilerType();
-  if (!return_value_type) {
-    error.SetErrorString("Null clang type for return value.");
-    return error;
-  }
-
-  Thread *thread = frame_sp->GetThread().get();
-
-  RegisterContext *reg_ctx = thread->GetRegisterContext().get();
-
-  if (reg_ctx) {
-    DataExtractor data;
-    Status data_error;
-    const uint64_t byte_size = new_value_sp->GetData(data, data_error);
-    if (data_error.Fail()) {
-      error.SetErrorStringWithFormat(
-          "Couldn't convert return value to raw data: %s",
-          data_error.AsCString());
-      return error;
-    }
-
-    const uint32_t type_flags = return_value_type.GetTypeInfo(nullptr);
-    if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
-      if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
-        // Extract the register context so we can read arguments from registers
-        lldb::offset_t offset = 0;
-        if (byte_size <= 16) {
-          const RegisterInfo *x0_info = reg_ctx->GetRegisterInfo(
-              eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
-          if (byte_size <= 8) {
-            uint64_t raw_value = data.GetMaxU64(&offset, byte_size);
-
-            if (!reg_ctx->WriteRegisterFromUnsigned(x0_info, raw_value))
-              error.SetErrorString("failed to write register x0");
-          } else {
-            uint64_t raw_value = data.GetMaxU64(&offset, 8);
-
-            if (reg_ctx->WriteRegisterFromUnsigned(x0_info, raw_value)) {
-              const RegisterInfo *x1_info = reg_ctx->GetRegisterInfo(
-                  eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG2);
-              raw_value = data.GetMaxU64(&offset, byte_size - offset);
-
-              if (!reg_ctx->WriteRegisterFromUnsigned(x1_info, raw_value))
-                error.SetErrorString("failed to write register x1");
-            }
-          }
-        } else {
-          error.SetErrorString("We don't support returning longer than 128 bit "
-                               "integer values at present.");
-        }
-      } else if (type_flags & eTypeIsFloat) {
-        if (type_flags & eTypeIsComplex) {
-          // Don't handle complex yet.
-          error.SetErrorString(
-              "returning complex float values are not supported");
-        } else {
-          const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
-
-          if (v0_info) {
-            if (byte_size <= 16) {
-              if (byte_size <= RegisterValue::GetMaxByteSize()) {
-                RegisterValue reg_value;
-                error = reg_value.SetValueFromData(v0_info, data, 0, true);
-                if (error.Success()) {
-                  if (!reg_ctx->WriteRegister(v0_info, reg_value))
-                    error.SetErrorString("failed to write register v0");
-                }
-              } else {
-                error.SetErrorStringWithFormat(
-                    "returning float values with a byte size of %" PRIu64
-                    " are not supported",
-                    byte_size);
-              }
-            } else {
-              error.SetErrorString("returning float values longer than 128 "
-                                   "bits are not supported");
-            }
-          } else {
-            error.SetErrorString("v0 register is not available on this target");
-          }
-        }
-      }
-    } else if (type_flags & eTypeIsVector) {
-      if (byte_size > 0) {
-        const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
-
-        if (v0_info) {
-          if (byte_size <= v0_info->byte_size) {
-            RegisterValue reg_value;
-            error = reg_value.SetValueFromData(v0_info, data, 0, true);
-            if (error.Success()) {
-              if (!reg_ctx->WriteRegister(v0_info, reg_value))
-                error.SetErrorString("failed to write register v0");
-            }
-          }
-        }
-      }
-    }
-  } else {
-    error.SetErrorString("no registers are available");
-  }
-
-  return error;
-}
-
-bool ABISysV_arm64::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) {
-  unwind_plan.Clear();
-  unwind_plan.SetRegisterKind(eRegisterKindDWARF);
-
-  uint32_t lr_reg_num = arm64_dwarf::lr;
-  uint32_t sp_reg_num = arm64_dwarf::sp;
-
-  UnwindPlan::RowSP row(new UnwindPlan::Row);
-
-  // Our previous Call Frame Address is the stack pointer
-  row->GetCFAValue().SetIsRegisterPlusOffset(sp_reg_num, 0);
-
-  unwind_plan.AppendRow(row);
-  unwind_plan.SetReturnAddressRegister(lr_reg_num);
-
-  // All other registers are the same.
-
-  unwind_plan.SetSourceName("arm64 at-func-entry default");
-  unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
-  unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
-  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
-
-  return true;
-}
-
-bool ABISysV_arm64::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
-  unwind_plan.Clear();
-  unwind_plan.SetRegisterKind(eRegisterKindDWARF);
-
-  uint32_t fp_reg_num = arm64_dwarf::fp;
-  uint32_t pc_reg_num = arm64_dwarf::pc;
-
-  UnwindPlan::RowSP row(new UnwindPlan::Row);
-  const int32_t ptr_size = 8;
-
-  row->GetCFAValue().SetIsRegisterPlusOffset(fp_reg_num, 2 * ptr_size);
-  row->SetOffset(0);
-
-  row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
-  row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
-
-  unwind_plan.AppendRow(row);
-  unwind_plan.SetSourceName("arm64 default unwind plan");
-  unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
-  unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
-  unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
-
-  return true;
-}
-
-// AAPCS64 (Procedure Call Standard for the ARM 64-bit Architecture) says
-// registers x19 through x28 and sp are callee preserved. v8-v15 are non-
-// volatile (and specifically only the lower 8 bytes of these regs), the rest
-// of the fp/SIMD registers are volatile.
-
-// We treat x29 as callee preserved also, else the unwinder won't try to
-// retrieve fp saves.
-
-bool ABISysV_arm64::RegisterIsVolatile(const RegisterInfo *reg_info) {
-  if (reg_info) {
-    const char *name = reg_info->name;
-
-    // Sometimes we'll be called with the "alternate" name for these registers;
-    // recognize them as non-volatile.
-
-    if (name[0] == 'p' && name[1] == 'c') // pc
-      return false;
-    if (name[0] == 'f' && name[1] == 'p') // fp
-      return false;
-    if (name[0] == 's' && name[1] == 'p') // sp
-      return false;
-    if (name[0] == 'l' && name[1] == 'r') // lr
-      return false;
-
-    if (name[0] == 'x' || name[0] == 'r') {
-      // Volatile registers: x0-x18
-      // Although documentation says only x19-28 + sp are callee saved We ll
-      // also have to treat x30 as non-volatile. Each dwarf frame has its own
-      // value of lr. Return false for the non-volatile gpr regs, true for
-      // everything else
-      switch (name[1]) {
-      case '1':
-        switch (name[2]) {
-        case '9':
-          return false; // x19 is non-volatile
-        default:
-          return true;
-        }
-        break;
-      case '2':
-        switch (name[2]) {
-        case '0':
-        case '1':
-        case '2':
-        case '3':
-        case '4':
-        case '5':
-        case '6':
-        case '7':
-        case '8':
-          return false; // x20 - 28 are non-volatile
-        case '9':
-          return false; // x29 aka fp treat as non-volatile
-        default:
-          return true;
-        }
-      case '3': // x30 (lr) and x31 (sp) treat as non-volatile
-        if (name[2] == '0' || name[2] == '1')
-          return false;
-        break;
-      default:
-        return true; // all volatile cases not handled above fall here.
-      }
-    } else if (name[0] == 'v' || name[0] == 's' || name[0] == 'd') {
-      // Volatile registers: v0-7, v16-v31
-      // Return false for non-volatile fp/SIMD regs, true for everything else
-      switch (name[1]) {
-      case '8':
-      case '9':
-        return false; // v8-v9 are non-volatile
-      case '1':
-        switch (name[2]) {
-        case '0':
-        case '1':
-        case '2':
-        case '3':
-        case '4':
-        case '5':
-          return false; // v10-v15 are non-volatile
-        default:
-          return true;
-        }
-      default:
-        return true;
-      }
-    }
-  }
-  return true;
-}
-
-static bool LoadValueFromConsecutiveGPRRegisters(
-    ExecutionContext &exe_ctx, RegisterContext *reg_ctx,
-    const CompilerType &value_type,
-    bool is_return_value, // false => parameter, true => return value
-    uint32_t &NGRN,       // NGRN (see ABI documentation)
-    uint32_t &NSRN,       // NSRN (see ABI documentation)
-    DataExtractor &data) {
-  llvm::Optional<uint64_t> byte_size = value_type.GetByteSize(nullptr);
-
-  if (byte_size || *byte_size == 0)
-    return false;
-
-  std::unique_ptr<DataBufferHeap> heap_data_up(
-      new DataBufferHeap(*byte_size, 0));
-  const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
-  Status error;
-
-  CompilerType base_type;
-  const uint32_t homogeneous_count =
-      value_type.IsHomogeneousAggregate(&base_type);
-  if (homogeneous_count > 0 && homogeneous_count <= 8) {
-    // Make sure we have enough registers
-    if (NSRN < 8 && (8 - NSRN) >= homogeneous_count) {
-      if (!base_type)
-        return false;
-      llvm::Optional<uint64_t> base_byte_size = base_type.GetByteSize(nullptr);
-      if (!base_byte_size)
-        return false;
-      uint32_t data_offset = 0;
-
-      for (uint32_t i = 0; i < homogeneous_count; ++i) {
-        char v_name[8];
-        ::snprintf(v_name, sizeof(v_name), "v%u", NSRN);
-        const RegisterInfo *reg_info =
-            reg_ctx->GetRegisterInfoByName(v_name, 0);
-        if (reg_info == nullptr)
-          return false;
-
-        if (*base_byte_size > reg_info->byte_size)
-          return false;
-
-        RegisterValue reg_value;
-
-        if (!reg_ctx->ReadRegister(reg_info, reg_value))
-          return false;
-
-        // Make sure we have enough room in "heap_data_up"
-        if ((data_offset + *base_byte_size) <= heap_data_up->GetByteSize()) {
-          const size_t bytes_copied = reg_value.GetAsMemoryData(
-              reg_info, heap_data_up->GetBytes() + data_offset, *base_byte_size,
-              byte_order, error);
-          if (bytes_copied != *base_byte_size)
-            return false;
-          data_offset += bytes_copied;
-          ++NSRN;
-        } else
-          return false;
-      }
-      data.SetByteOrder(byte_order);
-      data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize());
-      data.SetData(DataBufferSP(heap_data_up.release()));
-      return true;
-    }
-  }
-
-  const size_t max_reg_byte_size = 16;
-  if (*byte_size <= max_reg_byte_size) {
-    size_t bytes_left = *byte_size;
-    uint32_t data_offset = 0;
-    while (data_offset < *byte_size) {
-      if (NGRN >= 8)
-        return false;
-
-      const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
-          eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + NGRN);
-      if (reg_info == nullptr)
-        return false;
-
-      RegisterValue reg_value;
-
-      if (!reg_ctx->ReadRegister(reg_info, reg_value))
-        return false;
-
-      const size_t curr_byte_size = std::min<size_t>(8, bytes_left);
-      const size_t bytes_copied = reg_value.GetAsMemoryData(
-          reg_info, heap_data_up->GetBytes() + data_offset, curr_byte_size,
-          byte_order, error);
-      if (bytes_copied == 0)
-        return false;
-      if (bytes_copied >= bytes_left)
-        break;
-      data_offset += bytes_copied;
-      bytes_left -= bytes_copied;
-      ++NGRN;
-    }
-  } else {
-    const RegisterInfo *reg_info = nullptr;
-    if (is_return_value) {
-      // We are assuming we are decoding this immediately after returning from
-      // a function call and that the address of the structure is in x8
-      reg_info = reg_ctx->GetRegisterInfoByName("x8", 0);
-    } else {
-      // We are assuming we are stopped at the first instruction in a function
-      // and that the ABI is being respected so all parameters appear where
-      // they should be (functions with no external linkage can legally violate
-      // the ABI).
-      if (NGRN >= 8)
-        return false;
-
-      reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
-                                          LLDB_REGNUM_GENERIC_ARG1 + NGRN);
-      if (reg_info == nullptr)
-        return false;
-      ++NGRN;
-    }
-
-    if (reg_info == nullptr)
-      return false;
-
-    const lldb::addr_t value_addr =
-        reg_ctx->ReadRegisterAsUnsigned(reg_info, LLDB_INVALID_ADDRESS);
-
-    if (value_addr == LLDB_INVALID_ADDRESS)
-      return false;
-
-    if (exe_ctx.GetProcessRef().ReadMemory(
-            value_addr, heap_data_up->GetBytes(), heap_data_up->GetByteSize(),
-            error) != heap_data_up->GetByteSize()) {
-      return false;
-    }
-  }
-
-  data.SetByteOrder(byte_order);
-  data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize());
-  data.SetData(DataBufferSP(heap_data_up.release()));
-  return true;
-}
-
-ValueObjectSP ABISysV_arm64::GetReturnValueObjectImpl(
-    Thread &thread, CompilerType &return_compiler_type) const {
-  ValueObjectSP return_valobj_sp;
-  Value value;
-
-  ExecutionContext exe_ctx(thread.shared_from_this());
-  if (exe_ctx.GetTargetPtr() == nullptr || exe_ctx.GetProcessPtr() == nullptr)
-    return return_valobj_sp;
-
-  // value.SetContext (Value::eContextTypeClangType, return_compiler_type);
-  value.SetCompilerType(return_compiler_type);
-
-  RegisterContext *reg_ctx = thread.GetRegisterContext().get();
-  if (!reg_ctx)
-    return return_valobj_sp;
-
-  llvm::Optional<uint64_t> byte_size =
-      return_compiler_type.GetByteSize(nullptr);
-  if (!byte_size)
-    return return_valobj_sp;
-
-  const uint32_t type_flags = return_compiler_type.GetTypeInfo(nullptr);
-  if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
-    value.SetValueType(Value::eValueTypeScalar);
-
-    bool success = false;
-    if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
-      // Extract the register context so we can read arguments from registers
-      if (*byte_size <= 8) {
-        const RegisterInfo *x0_reg_info = nullptr;
-        x0_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
-                                               LLDB_REGNUM_GENERIC_ARG1);
-        if (x0_reg_info) {
-          uint64_t raw_value =
-              thread.GetRegisterContext()->ReadRegisterAsUnsigned(x0_reg_info,
-                                                                  0);
-          const bool is_signed = (type_flags & eTypeIsSigned) != 0;
-          switch (*byte_size) {
-          default:
-            break;
-          case 16: // uint128_t
-            // In register x0 and x1
-            {
-              const RegisterInfo *x1_reg_info = nullptr;
-              x1_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
-                                                     LLDB_REGNUM_GENERIC_ARG2);
-
-              if (x1_reg_info) {
-                if (*byte_size <=
-                    x0_reg_info->byte_size + x1_reg_info->byte_size) {
-                  std::unique_ptr<DataBufferHeap> heap_data_up(
-                      new DataBufferHeap(*byte_size, 0));
-                  const ByteOrder byte_order =
-                      exe_ctx.GetProcessRef().GetByteOrder();
-                  RegisterValue x0_reg_value;
-                  RegisterValue x1_reg_value;
-                  if (reg_ctx->ReadRegister(x0_reg_info, x0_reg_value) &&
-                      reg_ctx->ReadRegister(x1_reg_info, x1_reg_value)) {
-                    Status error;
-                    if (x0_reg_value.GetAsMemoryData(
-                            x0_reg_info, heap_data_up->GetBytes() + 0, 8,
-                            byte_order, error) &&
-                        x1_reg_value.GetAsMemoryData(
-                            x1_reg_info, heap_data_up->GetBytes() + 8, 8,
-                            byte_order, error)) {
-                      DataExtractor data(
-                          DataBufferSP(heap_data_up.release()), byte_order,
-                          exe_ctx.GetProcessRef().GetAddressByteSize());
-
-                      return_valobj_sp = ValueObjectConstResult::Create(
-                          &thread, return_compiler_type, ConstString(""), data);
-                      return return_valobj_sp;
-                    }
-                  }
-                }
-              }
-            }
-            break;
-          case sizeof(uint64_t):
-            if (is_signed)
-              value.GetScalar() = (int64_t)(raw_value);
-            else
-              value.GetScalar() = (uint64_t)(raw_value);
-            success = true;
-            break;
-
-          case sizeof(uint32_t):
-            if (is_signed)
-              value.GetScalar() = (int32_t)(raw_value & UINT32_MAX);
-            else
-              value.GetScalar() = (uint32_t)(raw_value & UINT32_MAX);
-            success = true;
-            break;
-
-          case sizeof(uint16_t):
-            if (is_signed)
-              value.GetScalar() = (int16_t)(raw_value & UINT16_MAX);
-            else
-              value.GetScalar() = (uint16_t)(raw_value & UINT16_MAX);
-            success = true;
-            break;
-
-          case sizeof(uint8_t):
-            if (is_signed)
-              value.GetScalar() = (int8_t)(raw_value & UINT8_MAX);
-            else
-              value.GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
-            success = true;
-            break;
-          }
-        }
-      }
-    } else if (type_flags & eTypeIsFloat) {
-      if (type_flags & eTypeIsComplex) {
-        // Don't handle complex yet.
-      } else {
-        if (*byte_size <= sizeof(long double)) {
-          const RegisterInfo *v0_reg_info =
-              reg_ctx->GetRegisterInfoByName("v0", 0);
-          RegisterValue v0_value;
-          if (reg_ctx->ReadRegister(v0_reg_info, v0_value)) {
-            DataExtractor data;
-            if (v0_value.GetData(data)) {
-              lldb::offset_t offset = 0;
-              if (*byte_size == sizeof(float)) {
-                value.GetScalar() = data.GetFloat(&offset);
-                success = true;
-              } else if (*byte_size == sizeof(double)) {
-                value.GetScalar() = data.GetDouble(&offset);
-                success = true;
-              } else if (*byte_size == sizeof(long double)) {
-                value.GetScalar() = data.GetLongDouble(&offset);
-                success = true;
-              }
-            }
-          }
-        }
-      }
-    }
-
-    if (success)
-      return_valobj_sp = ValueObjectConstResult::Create(
-          thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
-  } else if (type_flags & eTypeIsVector && *byte_size <= 16) {
-    if (*byte_size > 0) {
-      const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
-
-      if (v0_info) {
-        std::unique_ptr<DataBufferHeap> heap_data_up(
-            new DataBufferHeap(*byte_size, 0));
-        const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
-        RegisterValue reg_value;
-        if (reg_ctx->ReadRegister(v0_info, reg_value)) {
-          Status error;
-          if (reg_value.GetAsMemoryData(v0_info, heap_data_up->GetBytes(),
-                                        heap_data_up->GetByteSize(), byte_order,
-                                        error)) {
-            DataExtractor data(DataBufferSP(heap_data_up.release()), byte_order,
-                               exe_ctx.GetProcessRef().GetAddressByteSize());
-            return_valobj_sp = ValueObjectConstResult::Create(
-                &thread, return_compiler_type, ConstString(""), data);
-          }
-        }
-      }
-    }
-  } else if (type_flags & eTypeIsStructUnion || type_flags & eTypeIsClass ||
-             (type_flags & eTypeIsVector && *byte_size > 16)) {
-    DataExtractor data;
-
-    uint32_t NGRN = 0; // Search ABI docs for NGRN
-    uint32_t NSRN = 0; // Search ABI docs for NSRN
-    const bool is_return_value = true;
-    if (LoadValueFromConsecutiveGPRRegisters(
-            exe_ctx, reg_ctx, return_compiler_type, is_return_value, NGRN, NSRN,
-            data)) {
-      return_valobj_sp = ValueObjectConstResult::Create(
-          &thread, return_compiler_type, ConstString(""), data);
-    }
-  }
-  return return_valobj_sp;
-}
-
-void ABISysV_arm64::Initialize() {
-  PluginManager::RegisterPlugin(GetPluginNameStatic(),
-                                "SysV ABI for AArch64 targets", CreateInstance);
-}
-
-void ABISysV_arm64::Terminate() {
-  PluginManager::UnregisterPlugin(CreateInstance);
-}
-
-lldb_private::ConstString ABISysV_arm64::GetPluginNameStatic() {
-  static ConstString g_name("SysV-arm64");
-  return g_name;
-}
-
-// PluginInterface protocol
-
-ConstString ABISysV_arm64::GetPluginName() { return GetPluginNameStatic(); }
-
-uint32_t ABISysV_arm64::GetPluginVersion() { return 1; }
diff --git a/lldb/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.cpp b/lldb/source/Plugins/ABI/SystemZ/ABISysV_s390x.cpp
index f4f803a8277d2..eced2adc7591a 100644
--- a/lldb/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.cpp
+++ b/lldb/source/Plugins/ABI/SystemZ/ABISysV_s390x.cpp
@@ -1,4 +1,4 @@
-//===-- ABISysV_s390x.cpp ---------------------------------------*- C++ -*-===//
+//===-- ABISysV_s390x.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -32,6 +32,8 @@
 using namespace lldb;
 using namespace lldb_private;
 
+LLDB_PLUGIN_DEFINE_ADV(ABISysV_s390x, ABISystemZ)
+
 enum dwarf_regnums {
   // General Purpose Registers
   dwarf_r0_s390x = 0,
diff --git a/lldb/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.h b/lldb/source/Plugins/ABI/SystemZ/ABISysV_s390x.h
index 671d6a18260e3..f8f4124656586 100644
--- a/lldb/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.h
+++ b/lldb/source/Plugins/ABI/SystemZ/ABISysV_s390x.h
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_ABISysV_s390x_h_
-#define liblldb_ABISysV_s390x_h_
+#ifndef LLDB_SOURCE_PLUGINS_ABI_SYSTEMZ_ABISYSV_S390X_H
+#define LLDB_SOURCE_PLUGINS_ABI_SYSTEMZ_ABISYSV_S390X_H
 
 #include "lldb/Target/ABI.h"
 #include "lldb/lldb-private.h"
 
-class ABISysV_s390x : public lldb_private::ABI {
+class ABISysV_s390x : public lldb_private::RegInfoBasedABI {
 public:
   ~ABISysV_s390x() override = default;
 
@@ -88,11 +88,7 @@ protected:
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
 private:
-  ABISysV_s390x(lldb::ProcessSP process_sp,
-                std::unique_ptr<llvm::MCRegisterInfo> info_up)
-      : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
-    // Call CreateInstance instead.
-  }
+  using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
-#endif // liblldb_ABISysV_s390x_h_
+#endif // LLDB_SOURCE_PLUGINS_ABI_SYSTEMZ_ABISYSV_S390X_H
diff --git a/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp b/lldb/source/Plugins/ABI/X86/ABIMacOSX_i386.cpp
index 76ebd6476ffda..89112deb2c4a5 100644
--- a/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp
+++ b/lldb/source/Plugins/ABI/X86/ABIMacOSX_i386.cpp
@@ -1,4 +1,4 @@
-//===-- ABIMacOSX_i386.cpp --------------------------------------*- C++ -*-===//
+//===-- ABIMacOSX_i386.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -29,20 +29,7 @@
 using namespace lldb;
 using namespace lldb_private;
 
-enum {
-  ehframe_eax = 0,
-  ehframe_ecx,
-  ehframe_edx,
-  ehframe_ebx,
-  ehframe_ebp, // Different from DWARF the regnums - eh_frame esp/ebp had their
-               // regnums switched on i386 darwin
-  ehframe_esp, // Different from DWARF the regnums - eh_frame esp/ebp had their
-               // regnums switched on i386 darwin
-  ehframe_esi,
-  ehframe_edi,
-  ehframe_eip,
-  ehframe_eflags
-};
+LLDB_PLUGIN_DEFINE(ABIMacOSX_i386)
 
 enum {
   dwarf_eax = 0,
@@ -54,653 +41,8 @@ enum {
   dwarf_esi,
   dwarf_edi,
   dwarf_eip,
-  dwarf_eflags,
-  dwarf_stmm0 = 11,
-  dwarf_stmm1,
-  dwarf_stmm2,
-  dwarf_stmm3,
-  dwarf_stmm4,
-  dwarf_stmm5,
-  dwarf_stmm6,
-  dwarf_stmm7,
-  dwarf_xmm0 = 21,
-  dwarf_xmm1,
-  dwarf_xmm2,
-  dwarf_xmm3,
-  dwarf_xmm4,
-  dwarf_xmm5,
-  dwarf_xmm6,
-  dwarf_xmm7,
-  dwarf_ymm0 = dwarf_xmm0,
-  dwarf_ymm1 = dwarf_xmm1,
-  dwarf_ymm2 = dwarf_xmm2,
-  dwarf_ymm3 = dwarf_xmm3,
-  dwarf_ymm4 = dwarf_xmm4,
-  dwarf_ymm5 = dwarf_xmm5,
-  dwarf_ymm6 = dwarf_xmm6,
-  dwarf_ymm7 = dwarf_xmm7
 };
 
-static RegisterInfo g_register_infos[] = {
-    //  NAME      ALT      SZ OFF ENCODING         FORMAT
-    //  EH_FRAME              DWARF                 GENERIC
-    //  PROCESS PLUGIN        LLDB NATIVE
-    //  ======    =======  == === =============    ============
-    //  ===================== ===================== ============================
-    //  ====================  ======================
-    {"eax",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {ehframe_eax, dwarf_eax, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ebx",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {ehframe_ebx, dwarf_ebx, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ecx",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {ehframe_ecx, dwarf_ecx, LLDB_REGNUM_GENERIC_ARG4, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"edx",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {ehframe_edx, dwarf_edx, LLDB_REGNUM_GENERIC_ARG3, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"esi",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {ehframe_esi, dwarf_esi, LLDB_REGNUM_GENERIC_ARG2, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"edi",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {ehframe_edi, dwarf_edi, LLDB_REGNUM_GENERIC_ARG1, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ebp",
-     "fp",
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {ehframe_ebp, dwarf_ebp, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"esp",
-     "sp",
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {ehframe_esp, dwarf_esp, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"eip",
-     "pc",
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {ehframe_eip, dwarf_eip, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"eflags",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_REGNUM_GENERIC_FLAGS,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"cs",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ss",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ds",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"es",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fs",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"gs",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"stmm0",
-     nullptr,
-     10,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_stmm0, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"stmm1",
-     nullptr,
-     10,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_stmm1, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"stmm2",
-     nullptr,
-     10,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_stmm2, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"stmm3",
-     nullptr,
-     10,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_stmm3, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"stmm4",
-     nullptr,
-     10,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_stmm4, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"stmm5",
-     nullptr,
-     10,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_stmm5, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"stmm6",
-     nullptr,
-     10,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_stmm6, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"stmm7",
-     nullptr,
-     10,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_stmm7, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fctrl",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fstat",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ftag",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fiseg",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fioff",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"foseg",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fooff",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fop",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm0",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_xmm0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm1",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_xmm1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm2",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_xmm2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm3",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_xmm3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm4",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_xmm4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm5",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_xmm5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm6",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_xmm6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm7",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_xmm7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"mxcsr",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm0",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_ymm0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm1",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_ymm1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm2",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_ymm2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm3",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_ymm3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm4",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_ymm4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm5",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_ymm5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm6",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_ymm6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm7",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, dwarf_ymm7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0}};
-
-static const uint32_t k_num_register_infos =
-    llvm::array_lengthof(g_register_infos);
-static bool g_register_info_names_constified = false;
-
-const lldb_private::RegisterInfo *
-ABIMacOSX_i386::GetRegisterInfoArray(uint32_t &count) {
-  // Make the C-string names and alt_names for the register infos into const
-  // C-string values by having the ConstString unique the names in the global
-  // constant C-string pool.
-  if (!g_register_info_names_constified) {
-    g_register_info_names_constified = true;
-    for (uint32_t i = 0; i < k_num_register_infos; ++i) {
-      if (g_register_infos[i].name)
-        g_register_infos[i].name =
-            ConstString(g_register_infos[i].name).GetCString();
-      if (g_register_infos[i].alt_name)
-        g_register_infos[i].alt_name =
-            ConstString(g_register_infos[i].alt_name).GetCString();
-    }
-  }
-  count = k_num_register_infos;
-  return g_register_infos;
-}
-
 size_t ABIMacOSX_i386::GetRedZoneSize() const { return 0; }
 
 // Static Functions
diff --git a/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h b/lldb/source/Plugins/ABI/X86/ABIMacOSX_i386.h
index 50062b84d878d..b8b253144165d 100644
--- a/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h
+++ b/lldb/source/Plugins/ABI/X86/ABIMacOSX_i386.h
@@ -6,14 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_ABIMacOSX_i386_h_
-#define liblldb_ABIMacOSX_i386_h_
+#ifndef LLDB_SOURCE_PLUGINS_ABI_X86_ABIMACOSX_I386_H
+#define LLDB_SOURCE_PLUGINS_ABI_X86_ABIMACOSX_I386_H
 
+#include "Plugins/ABI/X86/ABIX86.h"
 #include "lldb/Core/Value.h"
-#include "lldb/Target/ABI.h"
 #include "lldb/lldb-private.h"
 
-class ABIMacOSX_i386 : public lldb_private::ABI {
+class ABIMacOSX_i386 : public ABIX86 {
 public:
   ~ABIMacOSX_i386() override = default;
 
@@ -45,7 +45,7 @@ public:
   //
   // To work around this, we relax that alignment to be just word-size
   // (4-bytes).
-  // Whitelisting the trap handlers for user space would be easy (_sigtramp) but
+  // Allowing the trap handlers for user space would be easy (_sigtramp) but
   // in other environments there can be a large number of different functions
   // involved in async traps.
   //
@@ -65,9 +65,6 @@ public:
     return pc <= UINT32_MAX;
   }
 
-  const lldb_private::RegisterInfo *
-  GetRegisterInfoArray(uint32_t &count) override;
-
   // Static Functions
 
   static void Initialize();
@@ -91,12 +88,13 @@ protected:
 
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
-private:
-  ABIMacOSX_i386(lldb::ProcessSP process_sp,
-                 std::unique_ptr<llvm::MCRegisterInfo> info_up)
-      : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
-    // Call CreateInstance instead.
+  std::string GetMCName(std::string name) override {
+    MapRegisterName(name, "stmm", "st");
+    return name;
   }
+
+private:
+  using ABIX86::ABIX86; // Call CreateInstance instead.
 };
 
-#endif // liblldb_ABIMacOSX_i386_h_
+#endif // LLDB_SOURCE_PLUGINS_ABI_X86_ABIMACOSX_I386_H
diff --git a/lldb/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp b/lldb/source/Plugins/ABI/X86/ABISysV_i386.cpp
index 69e4cff90ebf2..2ac87d1512e97 100644
--- a/lldb/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp
+++ b/lldb/source/Plugins/ABI/X86/ABISysV_i386.cpp
@@ -1,4 +1,4 @@
-//===----------------------- ABISysV_i386.cpp -------------------*- C++ -*-===//
+//===-- ABISysV_i386.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -31,6 +31,8 @@
 using namespace lldb;
 using namespace lldb_private;
 
+LLDB_PLUGIN_DEFINE(ABISysV_i386)
+
 //   This source file uses the following document as a reference:
 //====================================================================
 //             System V Application Binary Interface
@@ -63,135 +65,8 @@ enum dwarf_regnums {
   dwarf_esi,
   dwarf_edi,
   dwarf_eip,
-  dwarf_eflags,
-
-  dwarf_st0 = 11,
-  dwarf_st1,
-  dwarf_st2,
-  dwarf_st3,
-  dwarf_st4,
-  dwarf_st5,
-  dwarf_st6,
-  dwarf_st7,
-
-  dwarf_xmm0 = 21,
-  dwarf_xmm1,
-  dwarf_xmm2,
-  dwarf_xmm3,
-  dwarf_xmm4,
-  dwarf_xmm5,
-  dwarf_xmm6,
-  dwarf_xmm7,
-  dwarf_ymm0 = dwarf_xmm0,
-  dwarf_ymm1 = dwarf_xmm1,
-  dwarf_ymm2 = dwarf_xmm2,
-  dwarf_ymm3 = dwarf_xmm3,
-  dwarf_ymm4 = dwarf_xmm4,
-  dwarf_ymm5 = dwarf_xmm5,
-  dwarf_ymm6 = dwarf_xmm6,
-  dwarf_ymm7 = dwarf_xmm7,
-
-  dwarf_mm0 = 29,
-  dwarf_mm1,
-  dwarf_mm2,
-  dwarf_mm3,
-  dwarf_mm4,
-  dwarf_mm5,
-  dwarf_mm6,
-  dwarf_mm7,
-
-  dwarf_bnd0 = 101,
-  dwarf_bnd1,
-  dwarf_bnd2,
-  dwarf_bnd3
-};
-
-static RegisterInfo g_register_infos[] = {
-    // clang-format off
-    //NAME       ALT     SZ OFF  ENCODING         FORMAT                 EH_FRAME             DWARF                GENERIC                   PROCESS PLUGIN       LLDB NATIVE           VALUE    INVAL    DYN EXPR SZ
-    //========== ======= == ===  =============    ====================   ===================  ===================  ========================= ===================  ===================   =======  =======  ======== ==
-    {"eax",      nullptr, 4,  0, eEncodingUint,   eFormatHex,           {dwarf_eax,           dwarf_eax,           LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"ebx",      nullptr, 4,  0, eEncodingUint,   eFormatHex,           {dwarf_ebx,           dwarf_ebx,           LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"ecx",      nullptr, 4,  0, eEncodingUint,   eFormatHex,           {dwarf_ecx,           dwarf_ecx,           LLDB_REGNUM_GENERIC_ARG4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"edx",      nullptr, 4,  0, eEncodingUint,   eFormatHex,           {dwarf_edx,           dwarf_edx,           LLDB_REGNUM_GENERIC_ARG3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"esi",      nullptr, 4,  0, eEncodingUint,   eFormatHex,           {dwarf_esi,           dwarf_esi,           LLDB_REGNUM_GENERIC_ARG2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"edi",      nullptr, 4,  0, eEncodingUint,   eFormatHex,           {dwarf_edi,           dwarf_edi,           LLDB_REGNUM_GENERIC_ARG1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"ebp",      "fp",    4,  0, eEncodingUint,   eFormatHex,           {dwarf_ebp,           dwarf_ebp,           LLDB_REGNUM_GENERIC_FP,   LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"esp",      "sp",    4,  0, eEncodingUint,   eFormatHex,           {dwarf_esp,           dwarf_esp,           LLDB_REGNUM_GENERIC_SP,   LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"eip",      "pc",    4,  0, eEncodingUint,   eFormatHex,           {dwarf_eip,           dwarf_eip,           LLDB_REGNUM_GENERIC_PC,   LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"eflags",   nullptr, 4,  0, eEncodingUint,   eFormatHex,           {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_REGNUM_GENERIC_FLAGS,LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"cs",       nullptr, 4,  0, eEncodingUint,   eFormatHex,           {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"ss",       nullptr, 4,  0, eEncodingUint,   eFormatHex,           {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"ds",       nullptr, 4,  0, eEncodingUint,   eFormatHex,           {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"es",       nullptr, 4,  0, eEncodingUint,   eFormatHex,           {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"fs",       nullptr, 4,  0, eEncodingUint,   eFormatHex,           {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"gs",       nullptr, 4,  0, eEncodingUint,   eFormatHex,           {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"st0",      nullptr, 10, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_st0,           LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"st1",      nullptr, 10, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_st1,           LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"st2",      nullptr, 10, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_st2,           LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"st3",      nullptr, 10, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_st3,           LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"st4",      nullptr, 10, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_st4,           LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"st5",      nullptr, 10, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_st5,           LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"st6",      nullptr, 10, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_st6,           LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"st7",      nullptr, 10, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_st7,           LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"fctrl",    nullptr, 4,  0, eEncodingUint,   eFormatHex,           {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"fstat",    nullptr, 4,  0, eEncodingUint,   eFormatHex,           {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"ftag",     nullptr, 4,  0, eEncodingUint,   eFormatHex,           {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"fiseg",    nullptr, 4,  0, eEncodingUint,   eFormatHex,           {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"fioff",    nullptr, 4,  0, eEncodingUint,   eFormatHex,           {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"foseg",    nullptr, 4,  0, eEncodingUint,   eFormatHex,           {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"fooff",    nullptr, 4,  0, eEncodingUint,   eFormatHex,           {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"fop",      nullptr, 4,  0, eEncodingUint,   eFormatHex,           {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"xmm0",     nullptr, 16, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_xmm0,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"xmm1",     nullptr, 16, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_xmm1,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"xmm2",     nullptr, 16, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_xmm2,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"xmm3",     nullptr, 16, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_xmm3,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"xmm4",     nullptr, 16, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_xmm4,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"xmm5",     nullptr, 16, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_xmm5,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"xmm6",     nullptr, 16, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_xmm6,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"xmm7",     nullptr, 16, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_xmm7,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"mxcsr",    nullptr, 4,  0, eEncodingUint,   eFormatHex,           {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"ymm0",     nullptr, 32, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_ymm0,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"ymm1",     nullptr, 32, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_ymm1,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"ymm2",     nullptr, 32, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_ymm2,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"ymm3",     nullptr, 32, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_ymm3,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"ymm4",     nullptr, 32, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_ymm4,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"ymm5",     nullptr, 32, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_ymm5,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"ymm6",     nullptr, 32, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_ymm6,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"ymm7",     nullptr, 32, 0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, dwarf_ymm7,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"bnd0",     nullptr, 16, 0, eEncodingVector, eFormatVectorOfUInt64,{dwarf_bnd0,          dwarf_bnd0,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"bnd1",     nullptr, 16, 0, eEncodingVector, eFormatVectorOfUInt64,{dwarf_bnd1,          dwarf_bnd1,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"bnd2",     nullptr, 16, 0, eEncodingVector, eFormatVectorOfUInt64,{dwarf_bnd2,          dwarf_bnd2,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"bnd3",     nullptr, 16, 0, eEncodingVector, eFormatVectorOfUInt64,{dwarf_bnd3,          dwarf_bnd3,          LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"bndcfgu",  nullptr, 8,  0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0},
-    {"bndstatus",nullptr, 8,  0, eEncodingVector, eFormatVectorOfUInt8, {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, nullptr, nullptr, nullptr, 0}
-    // clang-format on
 };
 
-static const uint32_t k_num_register_infos =
-    llvm::array_lengthof(g_register_infos);
-static bool g_register_info_names_constified = false;
-
-const lldb_private::RegisterInfo *
-ABISysV_i386::GetRegisterInfoArray(uint32_t &count) {
-  // Make the C-string names and alt_names for the register infos into const
-  // C-string values by having the ConstString unique the names in the global
-  // constant C-string pool.
-  if (!g_register_info_names_constified) {
-    g_register_info_names_constified = true;
-    for (uint32_t i = 0; i < k_num_register_infos; ++i) {
-      if (g_register_infos[i].name)
-        g_register_infos[i].name =
-            ConstString(g_register_infos[i].name).GetCString();
-      if (g_register_infos[i].alt_name)
-        g_register_infos[i].alt_name =
-            ConstString(g_register_infos[i].alt_name).GetCString();
-    }
-  }
-  count = k_num_register_infos;
-  return g_register_infos;
-}
-
 // Static Functions
 
 ABISP
diff --git a/lldb/source/Plugins/ABI/SysV-i386/ABISysV_i386.h b/lldb/source/Plugins/ABI/X86/ABISysV_i386.h
index 2362e9adda980..1ebb107d36df7 100644
--- a/lldb/source/Plugins/ABI/SysV-i386/ABISysV_i386.h
+++ b/lldb/source/Plugins/ABI/X86/ABISysV_i386.h
@@ -6,13 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_ABISysV_i386_h_
-#define liblldb_ABISysV_i386_h_
+#ifndef LLDB_SOURCE_PLUGINS_ABI_X86_ABISYSV_I386_H
+#define LLDB_SOURCE_PLUGINS_ABI_X86_ABISYSV_I386_H
 
-#include "lldb/Target/ABI.h"
+#include "Plugins/ABI/X86/ABIX86.h"
 #include "lldb/lldb-private.h"
 
-class ABISysV_i386 : public lldb_private::ABI {
+class ABISysV_i386 : public ABIX86 {
 public:
   ~ABISysV_i386() override = default;
 
@@ -53,7 +53,7 @@ public:
   //
   // To work around this, we relax that alignment to be just word-size
   // (4-bytes).
-  // Whitelisting the trap handlers for user space would be easy (_sigtramp) but
+  // Allowing the trap handlers for user space would be easy (_sigtramp) but
   // in other environments there can be a large number of different functions
   // involved in async traps.
 
@@ -73,9 +73,6 @@ public:
     return (pc <= UINT32_MAX);
   }
 
-  const lldb_private::RegisterInfo *
-  GetRegisterInfoArray(uint32_t &count) override;
-
   // Static Functions
 
   static void Initialize();
@@ -100,11 +97,7 @@ protected:
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
 private:
-  ABISysV_i386(lldb::ProcessSP process_sp,
-               std::unique_ptr<llvm::MCRegisterInfo> info_up)
-      : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
-    // Call CreateInstance instead.
-  }
+  using ABIX86::ABIX86; // Call CreateInstance instead.
 };
 
-#endif // liblldb_ABISysV_i386_h_
+#endif // LLDB_SOURCE_PLUGINS_ABI_X86_ABISYSV_I386_H
diff --git a/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp b/lldb/source/Plugins/ABI/X86/ABISysV_x86_64.cpp
index bf1c48f778e1b..7729e58f85809 100644
--- a/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp
+++ b/lldb/source/Plugins/ABI/X86/ABISysV_x86_64.cpp
@@ -1,4 +1,4 @@
-//===-- ABISysV_x86_64.cpp --------------------------------------*- C++ -*-===//
+//===-- ABISysV_x86_64.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -35,6 +35,8 @@
 using namespace lldb;
 using namespace lldb_private;
 
+LLDB_PLUGIN_DEFINE(ABISysV_x86_64)
+
 enum dwarf_regnums {
   dwarf_rax = 0,
   dwarf_rdx,
@@ -53,162 +55,8 @@ enum dwarf_regnums {
   dwarf_r14,
   dwarf_r15,
   dwarf_rip,
-  dwarf_xmm0,
-  dwarf_xmm1,
-  dwarf_xmm2,
-  dwarf_xmm3,
-  dwarf_xmm4,
-  dwarf_xmm5,
-  dwarf_xmm6,
-  dwarf_xmm7,
-  dwarf_xmm8,
-  dwarf_xmm9,
-  dwarf_xmm10,
-  dwarf_xmm11,
-  dwarf_xmm12,
-  dwarf_xmm13,
-  dwarf_xmm14,
-  dwarf_xmm15,
-  dwarf_stmm0,
-  dwarf_stmm1,
-  dwarf_stmm2,
-  dwarf_stmm3,
-  dwarf_stmm4,
-  dwarf_stmm5,
-  dwarf_stmm6,
-  dwarf_stmm7,
-  dwarf_ymm0,
-  dwarf_ymm1,
-  dwarf_ymm2,
-  dwarf_ymm3,
-  dwarf_ymm4,
-  dwarf_ymm5,
-  dwarf_ymm6,
-  dwarf_ymm7,
-  dwarf_ymm8,
-  dwarf_ymm9,
-  dwarf_ymm10,
-  dwarf_ymm11,
-  dwarf_ymm12,
-  dwarf_ymm13,
-  dwarf_ymm14,
-  dwarf_ymm15,
-  dwarf_bnd0 = 126,
-  dwarf_bnd1,
-  dwarf_bnd2,
-  dwarf_bnd3
-};
-
-static RegisterInfo g_register_infos[] = {
-    // clang-format off
-    // NAME      ALT      SZ OFF  ENCODING         FORMAT                     EH_FRAME                DWARF                     GENERIC                     LLDB                  NATIVE
-    // ========  =======  == ===  =============    ===================        ======================= =====================     =========================== ===================== ======================
-    {"rax",      nullptr,  8,  0, eEncodingUint,   eFormatHex,               {dwarf_rax,              dwarf_rax,                LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"rbx",      nullptr,  8,  0, eEncodingUint,   eFormatHex,               {dwarf_rbx,              dwarf_rbx,                LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"rcx",      "arg4",   8,  0, eEncodingUint,   eFormatHex,               {dwarf_rcx,              dwarf_rcx,                LLDB_REGNUM_GENERIC_ARG4,   LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"rdx",      "arg3",   8,  0, eEncodingUint,   eFormatHex,               {dwarf_rdx,              dwarf_rdx,                LLDB_REGNUM_GENERIC_ARG3,   LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"rsi",      "arg2",   8,  0, eEncodingUint,   eFormatHex,               {dwarf_rsi,              dwarf_rsi,                LLDB_REGNUM_GENERIC_ARG2,   LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"rdi",      "arg1",   8,  0, eEncodingUint,   eFormatHex,               {dwarf_rdi,              dwarf_rdi,                LLDB_REGNUM_GENERIC_ARG1,   LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"rbp",      "fp",     8,  0, eEncodingUint,   eFormatHex,               {dwarf_rbp,              dwarf_rbp,                LLDB_REGNUM_GENERIC_FP,     LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"rsp",      "sp",     8,  0, eEncodingUint,   eFormatHex,               {dwarf_rsp,              dwarf_rsp,                LLDB_REGNUM_GENERIC_SP,     LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"r8",       "arg5",   8,  0, eEncodingUint,   eFormatHex,               {dwarf_r8,               dwarf_r8,                 LLDB_REGNUM_GENERIC_ARG5,   LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"r9",       "arg6",   8,  0, eEncodingUint,   eFormatHex,               {dwarf_r9,               dwarf_r9,                 LLDB_REGNUM_GENERIC_ARG6,   LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"r10",      nullptr,  8,  0, eEncodingUint,   eFormatHex,               {dwarf_r10,              dwarf_r10,                LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"r11",      nullptr,  8,  0, eEncodingUint,   eFormatHex,               {dwarf_r11,              dwarf_r11,                LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"r12",      nullptr,  8,  0, eEncodingUint,   eFormatHex,               {dwarf_r12,              dwarf_r12,                LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"r13",      nullptr,  8,  0, eEncodingUint,   eFormatHex,               {dwarf_r13,              dwarf_r13,                LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"r14",      nullptr,  8,  0, eEncodingUint,   eFormatHex,               {dwarf_r14,              dwarf_r14,                LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"r15",      nullptr,  8,  0, eEncodingUint,   eFormatHex,               {dwarf_r15,              dwarf_r15,                LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"rip",      "pc",     8,  0, eEncodingUint,   eFormatHex,               {dwarf_rip,              dwarf_rip,                LLDB_REGNUM_GENERIC_PC,     LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"rflags",   nullptr,  4,  0, eEncodingUint,   eFormatHex,               {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_REGNUM_GENERIC_FLAGS,  LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"cs",       nullptr,  4,  0, eEncodingUint,   eFormatHex,               {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ss",       nullptr,  4,  0, eEncodingUint,   eFormatHex,               {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ds",       nullptr,  4,  0, eEncodingUint,   eFormatHex,               {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"es",       nullptr,  4,  0, eEncodingUint,   eFormatHex,               {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"fs",       nullptr,  4,  0, eEncodingUint,   eFormatHex,               {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"gs",       nullptr,  4,  0, eEncodingUint,   eFormatHex,               {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"stmm0",    nullptr, 10,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_stmm0,            dwarf_stmm0,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"stmm1",    nullptr, 10,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_stmm1,            dwarf_stmm1,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"stmm2",    nullptr, 10,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_stmm2,            dwarf_stmm2,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"stmm3",    nullptr, 10,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_stmm3,            dwarf_stmm3,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"stmm4",    nullptr, 10,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_stmm4,            dwarf_stmm4,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"stmm5",    nullptr, 10,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_stmm5,            dwarf_stmm5,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"stmm6",    nullptr, 10,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_stmm6,            dwarf_stmm6,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"stmm7",    nullptr, 10,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_stmm7,            dwarf_stmm7,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"fctrl",    nullptr,  4,  0, eEncodingUint,   eFormatHex,               {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"fstat",    nullptr,  4,  0, eEncodingUint,   eFormatHex,               {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ftag",     nullptr,  4,  0, eEncodingUint,   eFormatHex,               {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"fiseg",    nullptr,  4,  0, eEncodingUint,   eFormatHex,               {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"fioff",    nullptr,  4,  0, eEncodingUint,   eFormatHex,               {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"foseg",    nullptr,  4,  0, eEncodingUint,   eFormatHex,               {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"fooff",    nullptr,  4,  0, eEncodingUint,   eFormatHex,               {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"fop",      nullptr,  4,  0, eEncodingUint,   eFormatHex,               {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"xmm0",     nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_xmm0,             dwarf_xmm0,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"xmm1",     nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_xmm1,             dwarf_xmm1,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"xmm2",     nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_xmm2,             dwarf_xmm2,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"xmm3",     nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_xmm3,             dwarf_xmm3,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"xmm4",     nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_xmm4,             dwarf_xmm4,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"xmm5",     nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_xmm5,             dwarf_xmm5,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"xmm6",     nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_xmm6,             dwarf_xmm6,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"xmm7",     nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_xmm7,             dwarf_xmm7,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"xmm8",     nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_xmm8,             dwarf_xmm8,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"xmm9",     nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_xmm9,             dwarf_xmm9,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"xmm10",    nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_xmm10,            dwarf_xmm10,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"xmm11",    nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_xmm11,            dwarf_xmm11,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"xmm12",    nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_xmm12,            dwarf_xmm12,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"xmm13",    nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_xmm13,            dwarf_xmm13,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"xmm14",    nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_xmm14,            dwarf_xmm14,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"xmm15",    nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_xmm15,            dwarf_xmm15,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"mxcsr",    nullptr,  4,  0, eEncodingUint,   eFormatHex,               {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ymm0",     nullptr, 32,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_ymm0,             dwarf_ymm0,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ymm1",     nullptr, 32,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_ymm1,             dwarf_ymm1,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ymm2",     nullptr, 32,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_ymm2,             dwarf_ymm2,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ymm3",     nullptr, 32,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_ymm3,             dwarf_ymm3,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ymm4",     nullptr, 32,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_ymm4,             dwarf_ymm4,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ymm5",     nullptr, 32,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_ymm5,             dwarf_ymm5,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ymm6",     nullptr, 32,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_ymm6,             dwarf_ymm6,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ymm7",     nullptr, 32,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_ymm7,             dwarf_ymm7,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ymm8",     nullptr, 32,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_ymm8,             dwarf_ymm8,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ymm9",     nullptr, 32,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_ymm9,             dwarf_ymm9,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ymm10",    nullptr, 32,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_ymm10,            dwarf_ymm10,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ymm11",    nullptr, 32,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_ymm11,            dwarf_ymm11,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ymm12",    nullptr, 32,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_ymm12,            dwarf_ymm12,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ymm13",    nullptr, 32,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_ymm13,            dwarf_ymm13,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ymm14",    nullptr, 32,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_ymm14,            dwarf_ymm14,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"ymm15",    nullptr, 32,  0, eEncodingVector, eFormatVectorOfUInt8,     {dwarf_ymm15,            dwarf_ymm15,              LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"bnd0",     nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt64,    {dwarf_bnd0,             dwarf_bnd0,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"bnd1",     nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt64,    {dwarf_bnd1,             dwarf_bnd1,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"bnd2",     nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt64,    {dwarf_bnd2,             dwarf_bnd2,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"bnd3",     nullptr, 16,  0, eEncodingVector, eFormatVectorOfUInt64,    {dwarf_bnd3,             dwarf_bnd3,               LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"bndcfgu",  nullptr,  8,  0, eEncodingVector, eFormatVectorOfUInt8,     {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    {"bndstatus",nullptr,  8,  0, eEncodingVector, eFormatVectorOfUInt8,     {LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM,      LLDB_INVALID_REGNUM,        LLDB_INVALID_REGNUM,  LLDB_INVALID_REGNUM},     nullptr,     nullptr,     nullptr,     0},
-    // clang-format on
 };
 
-static const uint32_t k_num_register_infos =
-    llvm::array_lengthof(g_register_infos);
-static bool g_register_info_names_constified = false;
-
-const lldb_private::RegisterInfo *
-ABISysV_x86_64::GetRegisterInfoArray(uint32_t &count) {
-  // Make the C-string names and alt_names for the register infos into const
-  // C-string values by having the ConstString unique the names in the global
-  // constant C-string pool.
-  if (!g_register_info_names_constified) {
-    g_register_info_names_constified = true;
-    for (uint32_t i = 0; i < k_num_register_infos; ++i) {
-      if (g_register_infos[i].name)
-        g_register_infos[i].name =
-            ConstString(g_register_infos[i].name).GetCString();
-      if (g_register_infos[i].alt_name)
-        g_register_infos[i].alt_name =
-            ConstString(g_register_infos[i].alt_name).GetCString();
-    }
-  }
-  count = k_num_register_infos;
-  return g_register_infos;
-}
-
 bool ABISysV_x86_64::GetPointerReturnRegister(const char *&name) {
   name = "rax";
   return true;
@@ -1078,6 +926,21 @@ bool ABISysV_x86_64::RegisterIsCalleeSaved(const RegisterInfo *reg_info) {
   return IsCalleeSaved;
 }
 
+uint32_t ABISysV_x86_64::GetGenericNum(llvm::StringRef name) {
+  return llvm::StringSwitch<uint32_t>(name)
+      .Case("rip", LLDB_REGNUM_GENERIC_PC)
+      .Case("rsp", LLDB_REGNUM_GENERIC_SP)
+      .Case("rbp", LLDB_REGNUM_GENERIC_FP)
+      .Case("rflags", LLDB_REGNUM_GENERIC_FLAGS)
+      .Case("rdi", LLDB_REGNUM_GENERIC_ARG1)
+      .Case("rsi", LLDB_REGNUM_GENERIC_ARG2)
+      .Case("rdx", LLDB_REGNUM_GENERIC_ARG3)
+      .Case("rcx", LLDB_REGNUM_GENERIC_ARG4)
+      .Case("r8", LLDB_REGNUM_GENERIC_ARG5)
+      .Case("r9", LLDB_REGNUM_GENERIC_ARG6)
+      .Default(LLDB_INVALID_REGNUM);
+}
+
 void ABISysV_x86_64::Initialize() {
   PluginManager::RegisterPlugin(
       GetPluginNameStatic(), "System V ABI for x86_64 targets", CreateInstance);
diff --git a/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h b/lldb/source/Plugins/ABI/X86/ABISysV_x86_64.h
index d445d8f4142a5..6dce4ce0f0127 100644
--- a/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h
+++ b/lldb/source/Plugins/ABI/X86/ABISysV_x86_64.h
@@ -6,13 +6,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_ABISysV_x86_64_h_
-#define liblldb_ABISysV_x86_64_h_
+#ifndef LLDB_SOURCE_PLUGINS_ABI_X86_ABISYSV_X86_64_H
+#define LLDB_SOURCE_PLUGINS_ABI_X86_ABISYSV_X86_64_H
 
-#include "lldb/Target/ABI.h"
-#include "lldb/lldb-private.h"
+#include "Plugins/ABI/X86/ABIX86_64.h"
 
-class ABISysV_x86_64 : public lldb_private::ABI {
+class ABISysV_x86_64 : public ABIX86_64 {
 public:
   ~ABISysV_x86_64() override = default;
 
@@ -49,7 +48,7 @@ public:
   //
   // To work around this, we relax that alignment to be just word-size
   // (8-bytes).
-  // Whitelisting the trap handlers for user space would be easy (_sigtramp) but
+  // Allowing the trap handlers for user space would be easy (_sigtramp) but
   // in other environments there can be a large number of different functions
   // involved in async traps.
   bool CallFrameAddressIsValid(lldb::addr_t cfa) override {
@@ -67,9 +66,6 @@ public:
     return true;
   }
 
-  const lldb_private::RegisterInfo *
-  GetRegisterInfoArray(uint32_t &count) override;
-
   bool GetPointerReturnRegister(const char *&name) override;
 
   // Static Functions
@@ -96,13 +92,10 @@ protected:
                              lldb_private::CompilerType &ast_type) const;
 
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
+  uint32_t GetGenericNum(llvm::StringRef reg) override;
 
 private:
-  ABISysV_x86_64(lldb::ProcessSP process_sp,
-                 std::unique_ptr<llvm::MCRegisterInfo> info_up)
-      : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
-    // Call CreateInstance instead.
-  }
+  using ABIX86_64::ABIX86_64; // Call CreateInstance instead.
 };
 
-#endif // liblldb_ABISysV_x86_64_h_
+#endif // LLDB_SOURCE_PLUGINS_ABI_X86_ABISYSV_X86_64_H
diff --git a/lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.cpp b/lldb/source/Plugins/ABI/X86/ABIWindows_x86_64.cpp
index ac24426914e1f..63b670b07277d 100644
--- a/lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.cpp
+++ b/lldb/source/Plugins/ABI/X86/ABIWindows_x86_64.cpp
@@ -1,4 +1,4 @@
-//===-- ABIWindows_x86_64.cpp --------------------------------------*- C++ -*-===//
+//===-- ABIWindows_x86_64.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -33,6 +33,8 @@
 using namespace lldb;
 using namespace lldb_private;
 
+LLDB_PLUGIN_DEFINE(ABIWindows_x86_64)
+
 enum dwarf_regnums {
   dwarf_rax = 0,
   dwarf_rdx,
@@ -97,986 +99,6 @@ enum dwarf_regnums {
   dwarf_bnd3
 };
 
-static RegisterInfo g_register_infos[] = {
-    //  NAME      ALT      SZ OFF ENCODING         FORMAT              EH_FRAME
-    //  DWARF                 GENERIC                     PROCESS PLUGIN
-    //  LLDB NATIVE
-    //  ========  =======  == === =============    ===================
-    //  ======================= =====================
-    //  =========================== ===================== ======================
-    {"rax",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_rax, dwarf_rax, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"rbx",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_rbx, dwarf_rbx, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"rcx",
-     "arg1",
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_rcx, dwarf_rcx, LLDB_REGNUM_GENERIC_ARG1, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"rdx",
-     "arg2",
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_rdx, dwarf_rdx, LLDB_REGNUM_GENERIC_ARG2, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"rsi",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_rsi, dwarf_rsi, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"rdi",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_rdi, dwarf_rdi, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"rbp",
-     "fp",
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_rbp, dwarf_rbp, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"rsp",
-     "sp",
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_rsp, dwarf_rsp, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"r8",
-     "arg3",
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_r8, dwarf_r8, LLDB_REGNUM_GENERIC_ARG3, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"r9",
-     "arg4",
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_r9, dwarf_r9, LLDB_REGNUM_GENERIC_ARG4, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"r10",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_r10, dwarf_r10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"r11",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_r11, dwarf_r11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"r12",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_r12, dwarf_r12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"r13",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_r13, dwarf_r13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"r14",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_r14, dwarf_r14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"r15",
-     nullptr,
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_r15, dwarf_r15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"rip",
-     "pc",
-     8,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {dwarf_rip, dwarf_rip, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"rflags",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_REGNUM_GENERIC_FLAGS,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"cs",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ss",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ds",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"es",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fs",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"gs",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"stmm0",
-     nullptr,
-     10,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_stmm0, dwarf_stmm0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"stmm1",
-     nullptr,
-     10,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_stmm1, dwarf_stmm1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"stmm2",
-     nullptr,
-     10,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_stmm2, dwarf_stmm2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"stmm3",
-     nullptr,
-     10,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_stmm3, dwarf_stmm3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"stmm4",
-     nullptr,
-     10,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_stmm4, dwarf_stmm4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"stmm5",
-     nullptr,
-     10,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_stmm5, dwarf_stmm5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"stmm6",
-     nullptr,
-     10,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_stmm6, dwarf_stmm6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"stmm7",
-     nullptr,
-     10,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_stmm7, dwarf_stmm7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fctrl",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fstat",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ftag",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fiseg",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fioff",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"foseg",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fooff",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"fop",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm0",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_xmm0, dwarf_xmm0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm1",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_xmm1, dwarf_xmm1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm2",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_xmm2, dwarf_xmm2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm3",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_xmm3, dwarf_xmm3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm4",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_xmm4, dwarf_xmm4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm5",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_xmm5, dwarf_xmm5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm6",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_xmm6, dwarf_xmm6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm7",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_xmm7, dwarf_xmm7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm8",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_xmm8, dwarf_xmm8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm9",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_xmm9, dwarf_xmm9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm10",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_xmm10, dwarf_xmm10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm11",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_xmm11, dwarf_xmm11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm12",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_xmm12, dwarf_xmm12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm13",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_xmm13, dwarf_xmm13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm14",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_xmm14, dwarf_xmm14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"xmm15",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_xmm15, dwarf_xmm15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"mxcsr",
-     nullptr,
-     4,
-     0,
-     eEncodingUint,
-     eFormatHex,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm0",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_ymm0, dwarf_ymm0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm1",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_ymm1, dwarf_ymm1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm2",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_ymm2, dwarf_ymm2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm3",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_ymm3, dwarf_ymm3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm4",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_ymm4, dwarf_ymm4, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm5",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_ymm5, dwarf_ymm5, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm6",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_ymm6, dwarf_ymm6, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm7",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_ymm7, dwarf_ymm7, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm8",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_ymm8, dwarf_ymm8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm9",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_ymm9, dwarf_ymm9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm10",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_ymm10, dwarf_ymm10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm11",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_ymm11, dwarf_ymm11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm12",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_ymm12, dwarf_ymm12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm13",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_ymm13, dwarf_ymm13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm14",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_ymm14, dwarf_ymm14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"ymm15",
-     nullptr,
-     32,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {dwarf_ymm15, dwarf_ymm15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"bnd0",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt64,
-     {dwarf_bnd0, dwarf_bnd0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"bnd1",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt64,
-     {dwarf_bnd1, dwarf_bnd1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"bnd2",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt64,
-     {dwarf_bnd2, dwarf_bnd2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"bnd3",
-     nullptr,
-     16,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt64,
-     {dwarf_bnd3, dwarf_bnd3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"bndcfgu",
-     nullptr,
-     8,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0},
-    {"bndstatus",
-     nullptr,
-     8,
-     0,
-     eEncodingVector,
-     eFormatVectorOfUInt8,
-     {LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
-      LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM},
-     nullptr,
-     nullptr,
-     nullptr,
-     0}};
-
-static const uint32_t k_num_register_infos =
-    llvm::array_lengthof(g_register_infos);
-static bool g_register_info_names_constified = false;
-
-const lldb_private::RegisterInfo *
-ABIWindows_x86_64::GetRegisterInfoArray(uint32_t &count) {
-  // Make the C-string names and alt_names for the register infos into const
-  // C-string values by having the ConstString unique the names in the global
-  // constant C-string pool.
-  if (!g_register_info_names_constified) {
-    g_register_info_names_constified = true;
-    for (uint32_t i = 0; i < k_num_register_infos; ++i) {
-      if (g_register_infos[i].name)
-        g_register_infos[i].name =
-            ConstString(g_register_infos[i].name).GetCString();
-      if (g_register_infos[i].alt_name)
-        g_register_infos[i].alt_name =
-            ConstString(g_register_infos[i].alt_name).GetCString();
-    }
-  }
-  count = k_num_register_infos;
-  return g_register_infos;
-}
-
 bool ABIWindows_x86_64::GetPointerReturnRegister(const char *&name) {
   name = "rax";
   return true;
@@ -1777,6 +799,19 @@ bool ABIWindows_x86_64::RegisterIsCalleeSaved(const RegisterInfo *reg_info) {
   return IsCalleeSaved;
 }
 
+uint32_t ABIWindows_x86_64::GetGenericNum(llvm::StringRef reg) {
+  return llvm::StringSwitch<uint32_t>(reg)
+      .Case("rip", LLDB_REGNUM_GENERIC_PC)
+      .Case("rsp", LLDB_REGNUM_GENERIC_SP)
+      .Case("rbp", LLDB_REGNUM_GENERIC_FP)
+      .Case("rflags", LLDB_REGNUM_GENERIC_FLAGS)
+      .Case("rcx", LLDB_REGNUM_GENERIC_ARG1)
+      .Case("rdx", LLDB_REGNUM_GENERIC_ARG2)
+      .Case("r8", LLDB_REGNUM_GENERIC_ARG3)
+      .Case("r9", LLDB_REGNUM_GENERIC_ARG4)
+      .Default(LLDB_INVALID_REGNUM);
+}
+
 void ABIWindows_x86_64::Initialize() {
   PluginManager::RegisterPlugin(
       GetPluginNameStatic(), "Windows ABI for x86_64 targets", CreateInstance);
diff --git a/lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.h b/lldb/source/Plugins/ABI/X86/ABIWindows_x86_64.h
index 2366566d7809d..89fc6e6ca21f4 100644
--- a/lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.h
+++ b/lldb/source/Plugins/ABI/X86/ABIWindows_x86_64.h
@@ -6,13 +6,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef liblldb_ABIWindows_x86_64_h_
-#define liblldb_ABIWindows_x86_64_h_
+#ifndef LLDB_SOURCE_PLUGINS_ABI_X86_ABIWINDOWS_X86_64_H
+#define LLDB_SOURCE_PLUGINS_ABI_X86_ABIWINDOWS_X86_64_H
 
-#include "lldb/Target/ABI.h"
-#include "lldb/lldb-private.h"
+#include "Plugins/ABI/X86/ABIX86_64.h"
 
-class ABIWindows_x86_64 : public lldb_private::ABI {
+class ABIWindows_x86_64 : public ABIX86_64 {
 public:
   ~ABIWindows_x86_64() override = default;
 
@@ -56,9 +55,6 @@ public:
     return true;
   }
 
-  const lldb_private::RegisterInfo *
-  GetRegisterInfoArray(uint32_t &count) override;
-
   bool GetPointerReturnRegister(const char *&name) override;
 
   //------------------------------------------------------------------
@@ -89,13 +85,10 @@ protected:
                              lldb_private::CompilerType &ast_type) const;
 
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
+  uint32_t GetGenericNum(llvm::StringRef reg) override;
 
 private:
-  ABIWindows_x86_64(lldb::ProcessSP process_sp,
-                    std::unique_ptr<llvm::MCRegisterInfo> info_up)
-      : lldb_private::ABI(std::move(process_sp), std::move(info_up)) {
-    // Call CreateInstance instead.
-  }
+  using ABIX86_64::ABIX86_64; // Call CreateInstance instead.
 };
 
-#endif // liblldb_ABISysV_x86_64_h_
+#endif // LLDB_SOURCE_PLUGINS_ABI_X86_ABIWINDOWS_X86_64_H
diff --git a/lldb/source/Plugins/ABI/X86/ABIX86.cpp b/lldb/source/Plugins/ABI/X86/ABIX86.cpp
new file mode 100644
index 0000000000000..bf5ab669417e4
--- /dev/null
+++ b/lldb/source/Plugins/ABI/X86/ABIX86.cpp
@@ -0,0 +1,43 @@
+//===-- X86.h -------------------------------------------------------------===//
+//
+// 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 "ABIX86.h"
+#include "ABIMacOSX_i386.h"
+#include "ABISysV_i386.h"
+#include "ABISysV_x86_64.h"
+#include "ABIWindows_x86_64.h"
+#include "lldb/Core/PluginManager.h"
+
+LLDB_PLUGIN_DEFINE(ABIX86)
+
+void ABIX86::Initialize() {
+  ABIMacOSX_i386::Initialize();
+  ABISysV_i386::Initialize();
+  ABISysV_x86_64::Initialize();
+  ABIWindows_x86_64::Initialize();
+}
+
+void ABIX86::Terminate() {
+  ABIMacOSX_i386::Terminate();
+  ABISysV_i386::Terminate();
+  ABISysV_x86_64::Terminate();
+  ABIWindows_x86_64::Terminate();
+}
+
+uint32_t ABIX86::GetGenericNum(llvm::StringRef name) {
+  return llvm::StringSwitch<uint32_t>(name)
+      .Case("eip", LLDB_REGNUM_GENERIC_PC)
+      .Case("esp", LLDB_REGNUM_GENERIC_SP)
+      .Case("ebp", LLDB_REGNUM_GENERIC_FP)
+      .Case("eflags", LLDB_REGNUM_GENERIC_FLAGS)
+      .Case("edi", LLDB_REGNUM_GENERIC_ARG1)
+      .Case("esi", LLDB_REGNUM_GENERIC_ARG2)
+      .Case("edx", LLDB_REGNUM_GENERIC_ARG3)
+      .Case("ecx", LLDB_REGNUM_GENERIC_ARG4)
+      .Default(LLDB_INVALID_REGNUM);
+}
diff --git a/lldb/source/Plugins/ABI/X86/ABIX86.h b/lldb/source/Plugins/ABI/X86/ABIX86.h
new file mode 100644
index 0000000000000..22521cacf1800
--- /dev/null
+++ b/lldb/source/Plugins/ABI/X86/ABIX86.h
@@ -0,0 +1,24 @@
+//===-- 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 LLDB_SOURCE_PLUGINS_ABI_X86_ABIX86_H
+#define LLDB_SOURCE_PLUGINS_ABI_X86_ABIX86_H
+
+#include "lldb/Target/ABI.h"
+
+class ABIX86 : public lldb_private::MCBasedABI {
+public:
+  static void Initialize();
+  static void Terminate();
+
+  uint32_t GetGenericNum(llvm::StringRef name) override;
+
+private:
+  using lldb_private::MCBasedABI::MCBasedABI;
+};
+#endif
diff --git a/lldb/source/Plugins/ABI/X86/ABIX86_64.h b/lldb/source/Plugins/ABI/X86/ABIX86_64.h
new file mode 100644
index 0000000000000..e65c2d97d897a
--- /dev/null
+++ b/lldb/source/Plugins/ABI/X86/ABIX86_64.h
@@ -0,0 +1,26 @@
+//===-- ABIX86_64.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_SOURCE_PLUGINS_ABI_X86_ABIX86_64_H
+#define LLDB_SOURCE_PLUGINS_ABI_X86_ABIX86_64_H
+
+#include "lldb/Target/ABI.h"
+#include "lldb/lldb-private.h"
+
+class ABIX86_64 : public lldb_private::MCBasedABI {
+protected:
+  std::string GetMCName(std::string name) override {
+    MapRegisterName(name, "stmm", "st");
+    return name;
+  }
+
+private:
+  using lldb_private::MCBasedABI::MCBasedABI;
+};
+
+#endif // LLDB_SOURCE_PLUGINS_ABI_X86_ABIX86_64_H