[lldb] Introduce "RegInfoBasedABI"

[labath]

Summary

This patch creates a new subclass of the ABI class in order to abstract away the
mechanism in which we "augment" register information. This enables alternate
augmentation strategies to be introduced.

All existing ABI classes have been modified to inherit from RegInfoBasedABI, but
they will be refactored in subsequent patches.

[stella.stamenova]

Either this change or D74475 broke the windows bot and I suspect it's not D74475:

http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/13719

lldb/include/lldb/Target/ABI.h

virtual lldb::addr_t FixCodeAddress(lldb::addr_t pc) {
     // Some targets might use bits in a code address to indicate a mode switch.
     // ARM uses bit zero to signify a code address is thumb, so any ARM ABI
     // plug-ins would strip those bits.
     return pc;
   }
 
   llvm::MCRegisterInfo &GetMCRegisterInfo() { return *m_mc_register_info_up; }
 
-  virtual void AugmentRegisterInfo(RegisterInfo &info);
+  virtual void AugmentRegisterInfo(RegisterInfo &info) = 0;
 
   virtual bool GetPointerReturnRegister(const char *&name) { return false; }
 
   static lldb::ABISP FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch);
 
 protected:
   ABI(lldb::ProcessSP process_sp, std::unique_ptr<llvm::MCRegisterInfo> info_up)
       : m_process_wp(process_sp), m_mc_register_info_up(std::move(info_up)) {
     assert(m_mc_register_info_up && "ABI must have MCRegisterInfo");
   }
 
-  bool GetRegisterInfoByName(ConstString name, RegisterInfo &info);
-
-  virtual const RegisterInfo *GetRegisterInfoArray(uint32_t &count) = 0;
-
   /// Utility function to construct a MCRegisterInfo using the ArchSpec triple.
   /// Plugins wishing to customize the construction can construct the
   /// MCRegisterInfo themselves.
   static std::unique_ptr<llvm::MCRegisterInfo>
   MakeMCRegisterInfo(const ArchSpec &arch);
 
   lldb::ProcessWP m_process_wp;
   std::unique_ptr<llvm::MCRegisterInfo> m_mc_register_info_up;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(ABI);
 };
 
+class RegInfoBasedABI : public ABI {
+public:
+  void AugmentRegisterInfo(RegisterInfo &info) override;
+
+protected:
+  using ABI::ABI;
+
+  bool GetRegisterInfoByName(ConstString name, RegisterInfo &info);
+
+  virtual const RegisterInfo *GetRegisterInfoArray(uint32_t &count) = 0;
+};
+
 } // namespace lldb_private
 
 #endif // liblldb_ABI_h_

lldb/source/Plugins/ABI/AArch64/ABIMacOSX_arm64.h

 //===-- ABIMacOSX_arm64.h ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ABIMacOSX_arm64_h_
 #define liblldb_ABIMacOSX_arm64_h_
 
 #include "lldb/Target/ABI.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-private.h"
 
-class ABIMacOSX_arm64 : public lldb_private::ABI {
+class ABIMacOSX_arm64 : public lldb_private::RegInfoBasedABI {
 public:
   ~ABIMacOSX_arm64() override = default;
 
   size_t GetRedZoneSize() const override;
 
   bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,
                           lldb::addr_t functionAddress,
                           lldb::addr_t returnAddress,
SetReturnValueObject(lldb::StackFrameSP &frame_sp,
                        lldb::ValueObjectSP &new_value) override;
 
 protected:
   lldb::ValueObjectSP
   GetReturnValueObjectImpl(lldb_private::Thread &thread,
                            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 lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
 #endif // liblldb_ABIMacOSX_arm64_h_

lldb/source/Plugins/ABI/AArch64/ABISysV_arm64.h

 //===-- ABISysV_arm64.h ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ABISysV_arm64_h_
 #define liblldb_ABISysV_arm64_h_
 
 #include "lldb/Target/ABI.h"
 #include "lldb/lldb-private.h"
 
-class ABISysV_arm64 : public lldb_private::ABI {
+class ABISysV_arm64 : public lldb_private::RegInfoBasedABI {
 public:
   ~ABISysV_arm64() override = default;
 
   size_t GetRedZoneSize() const override;
 
   bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,
                           lldb::addr_t functionAddress,
                           lldb::addr_t returnAddress,
public:
   uint32_t GetPluginVersion() override;
 
 protected:
   lldb::ValueObjectSP
   GetReturnValueObjectImpl(lldb_private::Thread &thread,
                            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 lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
 #endif // liblldb_ABISysV_arm64_h_

lldb/source/Plugins/ABI/ARC/ABISysV_arc.h

 
 // Other libraries and framework includes
 #include <llvm/ADT/Optional.h>
 
 // Project includes
 #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;
 
   size_t GetRedZoneSize() const override;
 
   bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,
                           lldb::addr_t functionAddress,
                           lldb::addr_t returnAddress,

 
 private:
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   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;
 };
 
 #endif // liblldb_ABISysV_arc_h_

lldb/source/Plugins/ABI/ARM/ABIMacOSX_arm.h

 //===-- ABIMacOSX_arm.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ABIMacOSX_arm_h_
 #define liblldb_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;
 
   size_t GetRedZoneSize() const override;
 
   bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,
                           lldb::addr_t func_addr, lldb::addr_t returnAddress,
                           llvm::ArrayRef<lldb::addr_t> args) const override;
public:
   uint32_t GetPluginVersion() override;
 
 protected:
   lldb::ValueObjectSP
   GetReturnValueObjectImpl(lldb_private::Thread &thread,
                            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_

lldb/source/Plugins/ABI/ARM/ABISysV_arm.h

 //===-- ABISysV_arm.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ABISysV_arm_h_
 #define liblldb_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;
 
   size_t GetRedZoneSize() const override;
 
   bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,
                           lldb::addr_t func_addr, lldb::addr_t returnAddress,
                           llvm::ArrayRef<lldb::addr_t> args) const override;
public:
   uint32_t GetPluginVersion() override;
 
 protected:
   lldb::ValueObjectSP
   GetReturnValueObjectImpl(lldb_private::Thread &thread,
                            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_

lldb/source/Plugins/ABI/Hexagon/ABISysV_hexagon.h

 //===-- ABISysV_hexagon.h ----------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ABISysV_hexagon_h_
 #define liblldb_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;
 
   size_t GetRedZoneSize() const override;
 
   bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,
                           lldb::addr_t functionAddress,
                           lldb::addr_t returnAddress,
protected:
 
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   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_

lldb/source/Plugins/ABI/Mips/ABISysV_mips.h

 //===-- ABISysV_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 liblldb_ABISysV_mips_h_
 #define liblldb_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;
 
   size_t GetRedZoneSize() const override;
 
   bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,
                           lldb::addr_t functionAddress,
                           lldb::addr_t returnAddress,
protected:
 
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   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_

lldb/source/Plugins/ABI/Mips/ABISysV_mips64.h

 //===-- ABISysV_mips64.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ABISysV_mips64_h_
 #define liblldb_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;
 
   size_t GetRedZoneSize() const override;
 
   bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,
                           lldb::addr_t functionAddress,
                           lldb::addr_t returnAddress,
protected:
 
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   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_

lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc.h

 //===-- ABISysV_ppc.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ABISysV_ppc_h_
 #define liblldb_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;
 
   size_t GetRedZoneSize() const override;
 
   bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,
                           lldb::addr_t functionAddress,
                           lldb::addr_t returnAddress,
protected:
 
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   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_

lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc64.h

 //===-- ABISysV_ppc64.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ABISysV_ppc64_h_
 #define liblldb_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;
 
   size_t GetRedZoneSize() const override;
 
   bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,
                           lldb::addr_t functionAddress,
                           lldb::addr_t returnAddress,
protected:
 
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   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_

lldb/source/Plugins/ABI/SystemZ/ABISysV_s390x.h

 //===-- ABISysV_s390x.h -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ABISysV_s390x_h_
 #define liblldb_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;
 
   size_t GetRedZoneSize() const override;
 
   bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,
                           lldb::addr_t functionAddress,
                           lldb::addr_t returnAddress,
protected:
 
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   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_

lldb/source/Plugins/ABI/X86/ABIMacOSX_i386.h

 //===-- ABIMacOSX_i386.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ABIMacOSX_i386_h_
 #define liblldb_ABIMacOSX_i386_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 lldb_private::RegInfoBasedABI {
 public:
   ~ABIMacOSX_i386() override = default;
 
   size_t GetRedZoneSize() const override;
 
   bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,
                           lldb::addr_t func_addr, lldb::addr_t return_addr,
                           llvm::ArrayRef<lldb::addr_t> args) const override;

 protected:
   lldb::ValueObjectSP
   GetReturnValueObjectImpl(lldb_private::Thread &thread,
                            lldb_private::CompilerType &ast_type) const override;
 
   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.
-  }
+  using lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
 #endif // liblldb_ABIMacOSX_i386_h_

lldb/source/Plugins/ABI/X86/ABISysV_i386.h

 //===------------------- ABISysV_i386.h -------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ABISysV_i386_h_
 #define liblldb_ABISysV_i386_h_
 
 #include "lldb/Target/ABI.h"
 #include "lldb/lldb-private.h"
 
-class ABISysV_i386 : public lldb_private::ABI {
+class ABISysV_i386 : public lldb_private::RegInfoBasedABI {
 public:
   ~ABISysV_i386() override = default;
 
   size_t GetRedZoneSize() const override {
     return 0; // There is no red zone for i386 Architecture
   }
 
   bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,

 protected:
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   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 lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
 #endif // liblldb_ABISysV_i386_h_

lldb/source/Plugins/ABI/X86/ABISysV_x86_64.h

 //===-- ABISysV_x86_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 liblldb_ABISysV_x86_64_h_
 #define liblldb_ABISysV_x86_64_h_
 
 #include "lldb/Target/ABI.h"
 #include "lldb/lldb-private.h"
 
-class ABISysV_x86_64 : public lldb_private::ABI {
+class ABISysV_x86_64 : public lldb_private::RegInfoBasedABI {
 public:
   ~ABISysV_x86_64() override = default;
 
   size_t GetRedZoneSize() const override;
 
   bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,
                           lldb::addr_t functionAddress,
                           lldb::addr_t returnAddress,
protected:
 
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
 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 lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
 #endif // liblldb_ABISysV_x86_64_h_

lldb/source/Plugins/ABI/X86/ABIWindows_x86_64.h

 //===-- ABIWindows_x86_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 liblldb_ABIWindows_x86_64_h_
 #define liblldb_ABIWindows_x86_64_h_
 
 #include "lldb/Target/ABI.h"
 #include "lldb/lldb-private.h"
 
-class ABIWindows_x86_64 : public lldb_private::ABI {
+class ABIWindows_x86_64 : public lldb_private::RegInfoBasedABI {
 public:
   ~ABIWindows_x86_64() override = default;
 
   size_t GetRedZoneSize() const override;
 
   bool PrepareTrivialCall(lldb_private::Thread &thread, lldb::addr_t sp,
                           lldb::addr_t functionAddress,
                           lldb::addr_t returnAddress,
protected:
 
   lldb::ValueObjectSP
   GetReturnValueObjectSimple(lldb_private::Thread &thread,
                              lldb_private::CompilerType &ast_type) const;
 
   bool RegisterIsCalleeSaved(const lldb_private::RegisterInfo *reg_info);
 
 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 lldb_private::RegInfoBasedABI::RegInfoBasedABI; // Call CreateInstance instead.
 };
 
 #endif // liblldb_ABISysV_x86_64_h_

lldb/source/Target/ABI.cpp

if (abi_sp)
       return abi_sp;
   }
   abi_sp.reset();
   return abi_sp;
 }
 
 ABI::~ABI() = default;
 
-bool ABI::GetRegisterInfoByName(ConstString name, RegisterInfo &info) {
+bool RegInfoBasedABI::GetRegisterInfoByName(ConstString name, RegisterInfo &info) {
   uint32_t count = 0;
   const RegisterInfo *register_info_array = GetRegisterInfoArray(count);
   if (register_info_array) {
     const char *unique_name_cstr = name.GetCString();
     uint32_t i;
     for (i = 0; i < count; ++i) {
       if (register_info_array[i].name == unique_name_cstr) {
         info = register_info_array[i];
if (!target) {
     return nullptr;
   }
   std::unique_ptr<llvm::MCRegisterInfo> info_up(
       target->createMCRegInfo(triple));
   assert(info_up);
   return info_up;
 }
 
-void ABI::AugmentRegisterInfo(RegisterInfo &info) {
+void RegInfoBasedABI::AugmentRegisterInfo(RegisterInfo &info) {
   if (info.kinds[eRegisterKindEHFrame] != LLDB_INVALID_REGNUM &&
       info.kinds[eRegisterKindDWARF] != LLDB_INVALID_REGNUM)
     return;
 
   RegisterInfo abi_info;
   if (!GetRegisterInfoByName(ConstString(info.name), abi_info))
     return;
 
   if (info.kinds[eRegisterKindEHFrame] == LLDB_INVALID_REGNUM)
     info.kinds[eRegisterKindEHFrame] = abi_info.kinds[eRegisterKindEHFrame];
   if (info.kinds[eRegisterKindDWARF] == LLDB_INVALID_REGNUM)
     info.kinds[eRegisterKindDWARF] = abi_info.kinds[eRegisterKindDWARF];
   if (info.kinds[eRegisterKindGeneric] == LLDB_INVALID_REGNUM)
     info.kinds[eRegisterKindGeneric] = abi_info.kinds[eRegisterKindGeneric];
 }