Have ABI plugins vend llvm MCRegisterInfo data

[labath]

Summary

I was recently surprised to learn that there is a total of 2 (two) users
of the register info definitions contained in the ABI plugins. Yet, the
defitions themselves span nearly 10kLOC.
The two users are:

• dwarf expression pretty printer
• the mechanism for augmenting the register info definitions obtained over gdb-remote protocol (AugmentRegisterInfoViaABI)

Both of these uses need the DWARF an EH register numbers, which is
information that is already available in LLVM. This patch makes it
possible to do so.

It adds a GetMCRegisterInfo method to the ABI class, which every class
is expected to implement. Normally, it should be sufficient to obtain
the definitions from the appropriate llvm::Target object (for which I
provide a utility function), but the subclasses are free to construct it
in any way they deem fit.

We should be able to always get the MCRegisterInfo object from llvm,
with one important exception: if the relevant llvm target was disabled
at compile time. To handle this, I add a mechanism to disable the
compilation of ABI plugins based on the value of LLVM_TARGETS_TO_BUILD
cmake setting. This ensures all our existing are able to create their
MCRegisterInfo objects.

The new MCRegisterInfo api is not used yet, but the intention is to make
use of it in follow-up patches.

[JDevlieghere]

source/Target/ABI.cpp

216 ↗

(On Diff #221540)

Should this return an llvm::Expected instead? I understand it will cause a lot of churn around the call sites, but now if this fails it will trigger an assert in the ABI constructor?

[tatyana-krasnukha]

include/lldb/Target/ABI.h

141 ↗

(On Diff #221540)

Since this and derived class's constructors are protected/private it can make sense to make their parameters r-value and not rely on copy elision.

[labath]

source/Target/ABI.cpp

216 ↗

(On Diff #221540)

Yes, it will, but the idea is that one should call this function only if one is certain that it will succeed (or if he's uncertain, he should at least check the result before passing it to the ABI constructor). As far as I am aware of, there are only two ways that this can fail:

1. we pass it some completely bogus triple
2. llvm was compiled without support for the given triple (this is kind of already covered by the first item, but anyway...)

All ABI plugins check that the archspec is "reasonable" (they at least check the architecture, some also check other fields), so the first case should not occur. And I am excluding the second case here, by making sure the ABI plugin is initialized only if the relevant llvm target is built.

I actually first coded an implementation which did something like if (is_supported(arch_spec)) { if (auto info = MakeMCRegisterInfo(arch_spec)) return ABI(process, info), but then I ditched it in favor of this. I can go back to that if you want (because the current version is not completely ideal either), but I kind of like this one more, because if anything goes wrong, it will be easier to track down the failure. (and it's pretty unlikely that this will only fail in some corner cases, as the only variable here is the ArchSpec, so even the most superficial testing of a given target should uncover any problems here.)

[aprantl]

source/Plugins/ABI/CMakeLists.txt

1 ↗

(On Diff #221540)

This looks like a good idea regardless.

[jasonmolenda]

LGTM.

[JDevlieghere]

Thanks for the explanation. LGTM

[labath]

include/lldb/Target/ABI.h

141 ↗

(On Diff #221540)

Technically, this is not copy elision, since std::move supresses that. :)
But anyway, I generally try to avoid overusing rvalue references as they tend to make one wonder whether there is something funny going on (and in particular with std::unique_ptr, a rvalue reference can have subtly different behavior than a plain object). I also believe the advice given (by some experts at least) since c++11 is to prefer plain objects where that makes sense.

[sylvestre.ledru]

@labath
I am building with AVR as experimental target and this change probably broke the build.

In file included from /home/sylvestre/dev/debian/pkg-llvm/llvm-toolchain/branches/llvm-toolchain-snapshot_10~svn372978/tools/lldb/source/API/SystemInitializerFull.cpp:208:
/home/sylvestre/dev/debian/pkg-llvm/llvm-toolchain/branches/llvm-toolchain-snapshot_10~svn372978/build-llvm/tools/clang/stage2-bins/include/llvm/Config/Targets.def:42:1: error: reference to non-static member function must be called; did you mean to call it with no arguments?
LLVM_TARGET(AVR)
^~~~~~~~~~~~~~~~
/home/sylvestre/dev/debian/pkg-llvm/llvm-toolchain/branches/llvm-toolchain-snapshot_10~svn372978/tools/lldb/source/API/SystemInitializerFull.cpp:207:43: note: expanded from macro 'LLVM_TARGET'
#define LLVM_TARGET(t) LLDB_PROCESS_ ## t(Initialize)
                                          ^~~~~~~~~~
In file included from /home/sylvestre/dev/debian/pkg-llvm/llvm-toolchain/branches/llvm-toolchain-snapshot_10~svn372978/tools/lldb/source/API/SystemInitializerFull.cpp:208:
/home/sylvestre/dev/debian/pkg-llvm/llvm-toolchain/branches/llvm-toolchain-snapshot_10~svn372978/build-llvm/tools/clang/stage2-bins/include/llvm/Config/Targets.def:42:1: error: use of undeclared identifier 'LLDB_PROCESS_AVR'
/home/sylvestre/dev/debian/pkg-llvm/llvm-toolchain/branches/llvm-toolchain-snapshot_10~svn372978/tools/lldb/source/API/SystemInitializerFull.cpp:207:24: note: expanded from macro 'LLVM_TARGET'
#define LLVM_TARGET(t) LLDB_PROCESS_ ## t(Initialize)
                       ^

Could you please have a look?
thanks

[labath]

In D67965#1684297, @sylvestre.ledru wrote:

@labath
I am building with AVR as experimental target and this change probably broke the build.

Could you please have a look?
thanks

Thanks for the heads up. r372998 ought to fix that.

lldb/trunk/include/lldb/Target/ABI.h

 #define liblldb_ABI_h_
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/MC/MCRegisterInfo.h"
 
-// forward define the llvm::Type class
 namespace llvm {
 class Type;
 }
 
 namespace lldb_private {
 
 class ABI : public PluginInterface {
 public:
public:
 
   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 const RegisterInfo *GetRegisterInfoArray(uint32_t &count) = 0;
 
   bool GetRegisterInfoByName(ConstString name, RegisterInfo &info);
 
   bool GetRegisterInfoByKind(lldb::RegisterKind reg_kind, uint32_t reg_num,
                              RegisterInfo &info);
 
   virtual bool GetPointerReturnRegister(const char *&name) { return false; }
 
   static lldb::ABISP FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch);
 
 protected:
-  // Classes that inherit from ABI can see and modify these
-  ABI(lldb::ProcessSP process_sp) {
-    if (process_sp.get())
-        m_process_wp = process_sp;
+  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");
   }
 
+  /// 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);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_ABI_h_

lldb/trunk/source/API/CMakeLists.txt

LINK_LIBS
     lldbUtility
     ${LLDB_ALL_PLUGINS}
   LINK_COMPONENTS
     Support
 
   ${option_install_prefix}
 )
 
+foreach (t ${LLVM_TARGETS_TO_BUILD})
+  set_property(SOURCE SystemInitializerFull.cpp APPEND PROPERTY
+    COMPILE_DEFINITIONS "LLVM_TARGET_${t}_BUILT")
+endforeach()
+
 if (MSVC)
   set_source_files_properties(SBReproducer.cpp PROPERTIES COMPILE_FLAGS /bigobj)
 endif()
 
 if(lldb_python_wrapper)
   add_dependencies(liblldb swig_wrapper)
 
   if (MSVC)

lldb/trunk/source/API/SystemInitializerFull.cpp

#endif
   // Initialize LLVM and Clang
   llvm::InitializeAllTargets();
   llvm::InitializeAllAsmPrinters();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllDisassemblers();
 
   ClangASTContext::Initialize();
 
-  ABIMacOSX_i386::Initialize();
-  ABIMacOSX_arm::Initialize();
+#ifdef LLVM_TARGET_AArch64_BUILT
   ABIMacOSX_arm64::Initialize();
-  ABISysV_arm::Initialize();
   ABISysV_arm64::Initialize();
+#endif
+#ifdef LLVM_TARGET_ARM_BUILT
+  ABIMacOSX_arm::Initialize();
+  ABISysV_arm::Initialize();
+#endif
+#ifdef LLVM_TARGET_Hexagon_BUILT
   ABISysV_hexagon::Initialize();
-  ABISysV_i386::Initialize();
-  ABISysV_x86_64::Initialize();
-  ABISysV_ppc::Initialize();
-  ABISysV_ppc64::Initialize();
+#endif
+#ifdef LLVM_TARGET_Mips_BUILT
   ABISysV_mips::Initialize();
   ABISysV_mips64::Initialize();
+#endif
+#ifdef LLVM_TARGET_PowerPC_BUILT
+  ABISysV_ppc::Initialize();
+  ABISysV_ppc64::Initialize();
+#endif
+#ifdef LLVM_TARGET_SystemZ_BUILT
   ABISysV_s390x::Initialize();
+#endif
+#ifdef LLVM_TARGET_X86_BUILT
+  ABIMacOSX_i386::Initialize();
+  ABISysV_i386::Initialize();
+  ABISysV_x86_64::Initialize();
   ABIWindows_x86_64::Initialize();
+#endif
 
   ArchitectureArm::Initialize();
   ArchitectureMips::Initialize();
   ArchitecturePPC64::Initialize();
 
   DisassemblerLLVMC::Initialize();
 
   JITLoaderGDB::Initialize();
void SystemInitializerFull::Terminate() {
   PluginManager::Terminate();
 
   ClangASTContext::Terminate();
 
   ArchitectureArm::Terminate();
   ArchitectureMips::Terminate();
   ArchitecturePPC64::Terminate();
 
-  ABIMacOSX_i386::Terminate();
-  ABIMacOSX_arm::Terminate();
+#ifdef LLVM_TARGET_AArch64_BUILT
   ABIMacOSX_arm64::Terminate();
-  ABISysV_arm::Terminate();
   ABISysV_arm64::Terminate();
+#endif
+#ifdef LLVM_TARGET_ARM_BUILT
+  ABIMacOSX_arm::Terminate();
+  ABISysV_arm::Terminate();
+#endif
+#ifdef LLVM_TARGET_Hexagon_BUILT
   ABISysV_hexagon::Terminate();
-  ABISysV_i386::Terminate();
-  ABISysV_x86_64::Terminate();
-  ABISysV_ppc::Terminate();
-  ABISysV_ppc64::Terminate();
+#endif
+#ifdef LLVM_TARGET_Mips_BUILT
   ABISysV_mips::Terminate();
   ABISysV_mips64::Terminate();
+#endif
+#ifdef LLVM_TARGET_PowerPC_BUILT
+  ABISysV_ppc::Terminate();
+  ABISysV_ppc64::Terminate();
+#endif
+#ifdef LLVM_TARGET_SystemZ_BUILT
   ABISysV_s390x::Terminate();
+#endif
+#ifdef LLVM_TARGET_X86_BUILT
+  ABIMacOSX_i386::Terminate();
+  ABISysV_i386::Terminate();
+  ABISysV_x86_64::Terminate();
   ABIWindows_x86_64::Terminate();
+#endif
+
   DisassemblerLLVMC::Terminate();
 
   JITLoaderGDB::Terminate();
   ProcessElfCore::Terminate();
   ProcessMachCore::Terminate();
   minidump::ProcessMinidump::Terminate();
   MemoryHistoryASan::Terminate();
   AddressSanitizerRuntime::Terminate();

lldb/trunk/source/Plugins/ABI/CMakeLists.txt

-add_subdirectory(SysV-arm)
+if ("AArch64" IN_LIST LLVM_TARGETS_TO_BUILD)
+  add_subdirectory(MacOSX-arm64)
   add_subdirectory(SysV-arm64)
+endif()
+if ("ARM" IN_LIST LLVM_TARGETS_TO_BUILD)
+  add_subdirectory(MacOSX-arm)
+  add_subdirectory(SysV-arm)
+endif()
+if ("Hexagon" IN_LIST LLVM_TARGETS_TO_BUILD)
   add_subdirectory(SysV-hexagon)
-add_subdirectory(SysV-ppc)
-add_subdirectory(SysV-ppc64)
+endif()
+if ("Mips" IN_LIST LLVM_TARGETS_TO_BUILD)
   add_subdirectory(SysV-mips)
   add_subdirectory(SysV-mips64)
+endif()
+if ("PowerPC" IN_LIST LLVM_TARGETS_TO_BUILD)
+  add_subdirectory(SysV-ppc)
+  add_subdirectory(SysV-ppc64)
+endif()
+if ("SystemZ" IN_LIST LLVM_TARGETS_TO_BUILD)
   add_subdirectory(SysV-s390x)
+endif()
+if ("X86" IN_LIST LLVM_TARGETS_TO_BUILD)
   add_subdirectory(SysV-i386)
   add_subdirectory(SysV-x86_64)
   add_subdirectory(MacOSX-i386)
-add_subdirectory(MacOSX-arm)
-add_subdirectory(MacOSX-arm64)
   add_subdirectory(Windows-x86_64)
+endif()

lldb/trunk/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.h

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) : lldb_private::ABI(process_sp) {
+  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.
   }
 };
 
 #endif // liblldb_ABIMacOSX_arm_h_

lldb/trunk/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp

 ABISP
 ABIMacOSX_arm::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::arm) ||
         (arch_type == llvm::Triple::thumb)) {
-      return ABISP(new ABIMacOSX_arm(process_sp));
+      return ABISP(
+          new ABIMacOSX_arm(std::move(process_sp), MakeMCRegisterInfo(arch)));
     }
   }
 
   return ABISP();
 }
 
 bool ABIMacOSX_arm::PrepareTrivialCall(Thread &thread, addr_t sp,
                                        addr_t function_addr, addr_t return_addr,

lldb/trunk/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.h

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) : lldb_private::ABI(process_sp) {
+  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.
   }
 };
 
 #endif // liblldb_ABIMacOSX_arm64_h_

lldb/trunk/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp

 
 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) {
-      return ABISP(new ABIMacOSX_arm64(process_sp));
+      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/trunk/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.h

 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) : lldb_private::ABI(process_sp) {
+  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.
   }
 };
 
 #endif // liblldb_ABIMacOSX_i386_h_

lldb/trunk/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp

 
 // Static Functions
 
 ABISP
 ABIMacOSX_i386::CreateInstance(lldb::ProcessSP process_sp, const ArchSpec &arch) {
   if ((arch.GetTriple().getArch() == llvm::Triple::x86) &&
       (arch.GetTriple().isMacOSX() || arch.GetTriple().isiOS() ||
        arch.GetTriple().isWatchOS())) {
-    return ABISP(new ABIMacOSX_i386(process_sp));
+    return ABISP(
+        new ABIMacOSX_i386(std::move(process_sp), MakeMCRegisterInfo(arch)));
   }
   return ABISP();
 }
 
 bool ABIMacOSX_i386::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();

lldb/trunk/source/Plugins/ABI/SysV-arm/ABISysV_arm.h

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) : lldb_private::ABI(process_sp) {
+  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.
   }
 };
 
 #endif // liblldb_ABISysV_arm_h_

lldb/trunk/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp

 ABISP
 ABISysV_arm::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::arm) ||
         (arch_type == llvm::Triple::thumb)) {
-      return ABISP(new ABISysV_arm(process_sp));
+      return ABISP(
+          new ABISysV_arm(std::move(process_sp), MakeMCRegisterInfo(arch)));
     }
   }
 
   return ABISP();
 }
 
 bool ABISysV_arm::PrepareTrivialCall(Thread &thread, addr_t sp,
                                      addr_t function_addr, addr_t return_addr,

lldb/trunk/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.h

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) : lldb_private::ABI(process_sp) {
+  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.
   }
 };
 
 #endif // liblldb_ABISysV_arm64_h_

lldb/trunk/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp

 
 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) {
-      return ABISP(new ABISysV_arm64(process_sp));
+      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,

lldb/trunk/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.h

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) : lldb_private::ABI(process_sp) {
+  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.
   }
 };
 
 #endif // liblldb_ABISysV_hexagon_h_

lldb/trunk/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp

 */
 size_t ABISysV_hexagon::GetRedZoneSize() const { return 0; }
 
 // Static Functions
 
 ABISP
 ABISysV_hexagon::CreateInstance(lldb::ProcessSP process_sp, const ArchSpec &arch) {
   if (arch.GetTriple().getArch() == llvm::Triple::hexagon) {
-    return ABISP(new ABISysV_hexagon(process_sp));
+    return ABISP(
+        new ABISysV_hexagon(std::move(process_sp), MakeMCRegisterInfo(arch)));
   }
   return ABISP();
 }
 
 bool ABISysV_hexagon::PrepareTrivialCall(Thread &thread, lldb::addr_t sp,
                                          lldb::addr_t pc, lldb::addr_t ra,
                                          llvm::ArrayRef<addr_t> args) const {
   // we don't use the traditional trivial call specialized for jit

lldb/trunk/source/Plugins/ABI/SysV-i386/ABISysV_i386.h

 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) : lldb_private::ABI(process_sp) {
+  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.
   }
 };
 
 #endif // liblldb_ABISysV_i386_h_

lldb/trunk/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp

 }
 
 // Static Functions
 
 ABISP
 ABISysV_i386::CreateInstance(lldb::ProcessSP process_sp, const ArchSpec &arch) {
   if (arch.GetTriple().getVendor() != llvm::Triple::Apple) {
     if (arch.GetTriple().getArch() == llvm::Triple::x86) {
-      return ABISP(new ABISysV_i386(process_sp));
+      return ABISP(
+          new ABISysV_i386(std::move(process_sp), MakeMCRegisterInfo(arch)));
     }
   }
   return ABISP();
 }
 
 bool ABISysV_i386::PrepareTrivialCall(Thread &thread, addr_t sp,
                                       addr_t func_addr, addr_t return_addr,
                                       llvm::ArrayRef<addr_t> args) const {

lldb/trunk/source/Plugins/ABI/SysV-mips/ABISysV_mips.h

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) : lldb_private::ABI(process_sp) {
+  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.
   }
 };
 
 #endif // liblldb_ABISysV_mips_h_

lldb/trunk/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp

 
 // Static Functions
 
 ABISP
 ABISysV_mips::CreateInstance(lldb::ProcessSP process_sp, const ArchSpec &arch) {
   const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
   if ((arch_type == llvm::Triple::mips) ||
       (arch_type == llvm::Triple::mipsel)) {
-    return ABISP(new ABISysV_mips(process_sp));
+    return ABISP(
+        new ABISysV_mips(std::move(process_sp), MakeMCRegisterInfo(arch)));
   }
   return ABISP();
 }
 
 bool ABISysV_mips::PrepareTrivialCall(Thread &thread, addr_t sp,
                                       addr_t func_addr, addr_t return_addr,
                                       llvm::ArrayRef<addr_t> args) const {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));

lldb/trunk/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.h

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) : lldb_private::ABI(process_sp) {
+  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.
   }
 };
 
 #endif // liblldb_ABISysV_mips64_h_

lldb/trunk/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp

 
 size_t ABISysV_mips64::GetRedZoneSize() const { return 0; }
 
 // Static Functions
 
 ABISP
 ABISysV_mips64::CreateInstance(lldb::ProcessSP process_sp, const ArchSpec &arch) {
   if (arch.GetTriple().isMIPS64())
-    return ABISP(new ABISysV_mips64(process_sp));
+    return ABISP(
+        new ABISysV_mips64(std::move(process_sp), MakeMCRegisterInfo(arch)));
   return ABISP();
 }
 
 bool ABISysV_mips64::PrepareTrivialCall(Thread &thread, addr_t sp,
                                         addr_t func_addr, addr_t return_addr,
                                         llvm::ArrayRef<addr_t> args) const {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 

lldb/trunk/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.h

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) : lldb_private::ABI(process_sp) {
+  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.
   }
 };
 
 #endif // liblldb_ABISysV_ppc_h_

lldb/trunk/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp

 
 size_t ABISysV_ppc::GetRedZoneSize() const { return 224; }
 
 // Static Functions
 
 ABISP
 ABISysV_ppc::CreateInstance(lldb::ProcessSP process_sp, const ArchSpec &arch) {
   if (arch.GetTriple().getArch() == llvm::Triple::ppc) {
-     return ABISP(new ABISysV_ppc(process_sp));
+    return ABISP(
+        new ABISysV_ppc(std::move(process_sp), MakeMCRegisterInfo(arch)));
   }
   return ABISP();
 }
 
 bool ABISysV_ppc::PrepareTrivialCall(Thread &thread, addr_t sp,
                                      addr_t func_addr, addr_t return_addr,
                                      llvm::ArrayRef<addr_t> args) const {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));

lldb/trunk/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.h

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) : lldb_private::ABI(process_sp) {
+  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.
   }
 
   lldb::ByteOrder GetByteOrder() const;
 };
 
 #endif // liblldb_ABISysV_ppc64_h_

lldb/trunk/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp

 }
 
 // Static Functions
 
 ABISP
 ABISysV_ppc64::CreateInstance(lldb::ProcessSP process_sp,
                               const ArchSpec &arch) {
   if (arch.GetTriple().isPPC64())
-    return ABISP(new ABISysV_ppc64(process_sp));
+    return ABISP(
+        new ABISysV_ppc64(std::move(process_sp), MakeMCRegisterInfo(arch)));
   return ABISP();
 }
 
 bool ABISysV_ppc64::PrepareTrivialCall(Thread &thread, addr_t sp,
                                        addr_t func_addr, addr_t return_addr,
                                        llvm::ArrayRef<addr_t> args) const {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 

lldb/trunk/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.h

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) : lldb_private::ABI(process_sp) {
+  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.
   }
 };
 
 #endif // liblldb_ABISysV_s390x_h_

lldb/trunk/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.cpp

 
 size_t ABISysV_s390x::GetRedZoneSize() const { return 0; }
 
 // Static Functions
 
 ABISP
 ABISysV_s390x::CreateInstance(lldb::ProcessSP process_sp, const ArchSpec &arch) {
   if (arch.GetTriple().getArch() == llvm::Triple::systemz) {
-    return ABISP(new ABISysV_s390x(process_sp));
+    return ABISP(new ABISysV_s390x(std::move(process_sp), MakeMCRegisterInfo(arch)));
   }
   return ABISP();
 }
 
 bool ABISysV_s390x::PrepareTrivialCall(Thread &thread, addr_t sp,
                                        addr_t func_addr, addr_t return_addr,
                                        llvm::ArrayRef<addr_t> args) const {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));

lldb/trunk/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h

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) : lldb_private::ABI(process_sp) {
+  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.
   }
 };
 
 #endif // liblldb_ABISysV_x86_64_h_

lldb/trunk/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp

if (arch_type == llvm::Triple::x86_64) {
     case llvm::Triple::OSType::TvOS:
     case llvm::Triple::OSType::WatchOS:
       switch (os_env) {
       case llvm::Triple::EnvironmentType::MacABI:
       case llvm::Triple::EnvironmentType::Simulator:
       case llvm::Triple::EnvironmentType::UnknownEnvironment:
         // UnknownEnvironment is needed for older compilers that don't
         // support the simulator environment.
-        return ABISP(new ABISysV_x86_64(process_sp));
+        return ABISP(new ABISysV_x86_64(std::move(process_sp),
+                                        MakeMCRegisterInfo(arch)));
       default:
         return ABISP();
       }
     case llvm::Triple::OSType::Darwin:
     case llvm::Triple::OSType::FreeBSD:
     case llvm::Triple::OSType::Linux:
     case llvm::Triple::OSType::MacOSX:
     case llvm::Triple::OSType::NetBSD:
     case llvm::Triple::OSType::Solaris:
     case llvm::Triple::OSType::UnknownOS:
-      return ABISP(new ABISysV_x86_64(process_sp));
+      return ABISP(
+          new ABISysV_x86_64(std::move(process_sp), MakeMCRegisterInfo(arch)));
     default:
       return ABISP();
     }
   }
   return ABISP();
 }
 
 bool ABISysV_x86_64::PrepareTrivialCall(Thread &thread, addr_t sp,

lldb/trunk/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.h

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) : lldb_private::ABI(process_sp) {
+  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.
   }
 };
 
 #endif // liblldb_ABISysV_x86_64_h_

lldb/trunk/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.cpp

 //------------------------------------------------------------------
 // Static Functions
 //------------------------------------------------------------------
 
 ABISP
 ABIWindows_x86_64::CreateInstance(lldb::ProcessSP process_sp, const ArchSpec &arch) {
   if (arch.GetTriple().getArch() == llvm::Triple::x86_64 &&
       arch.GetTriple().isOSWindows()) {
-    return ABISP(new ABIWindows_x86_64(process_sp));
+    return ABISP(
+        new ABIWindows_x86_64(std::move(process_sp), MakeMCRegisterInfo(arch)));
   }
   return ABISP();
 }
 
 bool ABIWindows_x86_64::PrepareTrivialCall(Thread &thread, addr_t sp,
                                            addr_t func_addr, addr_t return_addr,
                                            llvm::ArrayRef<addr_t> args) const {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));

lldb/trunk/source/Target/ABI.cpp

 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
+#include "lldb/Utility/Log.h"
+#include "llvm/Support/TargetRegistry.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 ABISP
 ABI::FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch) {
   ABISP abi_sp;
   ABICreateInstance create_callback;
bool ABI::GetFallbackRegisterLocation(
   // retrievable at this frame.
   if (RegisterIsVolatile(reg_info)) {
     unwind_regloc.SetUndefined();
     return true;
   }
 
   return false;
 }
+
+std::unique_ptr<llvm::MCRegisterInfo> ABI::MakeMCRegisterInfo(const ArchSpec &arch) {
+  std::string triple = arch.GetTriple().getTriple();
+  std::string lookup_error;
+  const llvm::Target *target =
+      llvm::TargetRegistry::lookupTarget(triple, lookup_error);
+  if (!target) {
+    LLDB_LOG(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS),
+             "Failed to create an llvm target for {0}: {1}", triple,
+             lookup_error);
+    return nullptr;
+  }
+  std::unique_ptr<llvm::MCRegisterInfo> info_up(
+      target->createMCRegInfo(triple));
+  assert(info_up);
+  return info_up;
+}

lldb/trunk/tools/lldb-test/CMakeLists.txt

LINK_LIBS
     lldbUtility
     ${LLDB_ALL_PLUGINS}
     ${host_lib}
 
   LINK_COMPONENTS
     Support
   )
   
+foreach (t ${LLVM_TARGETS_TO_BUILD})
+  set_property(SOURCE SystemInitializerTest.cpp APPEND PROPERTY
+    COMPILE_DEFINITIONS "LLVM_TARGET_${t}_BUILT")
+endforeach()
+
 include_directories(${LLDB_SOURCE_DIR}/source)

lldb/trunk/tools/lldb-test/SystemInitializerTest.cpp

 #include "Plugins/ABI/SysV-hexagon/ABISysV_hexagon.h"
 #include "Plugins/ABI/SysV-i386/ABISysV_i386.h"
 #include "Plugins/ABI/SysV-mips/ABISysV_mips.h"
 #include "Plugins/ABI/SysV-mips64/ABISysV_mips64.h"
 #include "Plugins/ABI/SysV-ppc/ABISysV_ppc.h"
 #include "Plugins/ABI/SysV-ppc64/ABISysV_ppc64.h"
 #include "Plugins/ABI/SysV-s390x/ABISysV_s390x.h"
 #include "Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h"
+#include "Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.h"
 #include "Plugins/Architecture/Arm/ArchitectureArm.h"
 #include "Plugins/Architecture/PPC64/ArchitecturePPC64.h"
 #include "Plugins/Disassembler/llvm/DisassemblerLLVMC.h"
 #include "Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.h"
 #include "Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h"
 #include "Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h"
 #include "Plugins/DynamicLoader/Static/DynamicLoaderStatic.h"
 #include "Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h"
#endif
   // Initialize LLVM and Clang
   llvm::InitializeAllTargets();
   llvm::InitializeAllAsmPrinters();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllDisassemblers();
 
   ClangASTContext::Initialize();
 
-  ABIMacOSX_i386::Initialize();
-  ABIMacOSX_arm::Initialize();
+#ifdef LLVM_TARGET_AArch64_BUILT
   ABIMacOSX_arm64::Initialize();
-  ABISysV_arm::Initialize();
   ABISysV_arm64::Initialize();
+#endif
+#ifdef LLVM_TARGET_ARM_BUILT
+  ABIMacOSX_arm::Initialize();
+  ABISysV_arm::Initialize();
+#endif
+#ifdef LLVM_TARGET_Hexagon_BUILT
   ABISysV_hexagon::Initialize();
-  ABISysV_i386::Initialize();
-  ABISysV_x86_64::Initialize();
-  ABISysV_ppc::Initialize();
-  ABISysV_ppc64::Initialize();
+#endif
+#ifdef LLVM_TARGET_Mips_BUILT
   ABISysV_mips::Initialize();
   ABISysV_mips64::Initialize();
+#endif
+#ifdef LLVM_TARGET_PowerPC_BUILT
+  ABISysV_ppc::Initialize();
+  ABISysV_ppc64::Initialize();
+#endif
+#ifdef LLVM_TARGET_SystemZ_BUILT
   ABISysV_s390x::Initialize();
+#endif
+#ifdef LLVM_TARGET_X86_BUILT
+  ABIMacOSX_i386::Initialize();
+  ABISysV_i386::Initialize();
+  ABISysV_x86_64::Initialize();
+  ABIWindows_x86_64::Initialize();
+#endif
 
   ArchitectureArm::Initialize();
   ArchitecturePPC64::Initialize();
 
   DisassemblerLLVMC::Initialize();
 
   JITLoaderGDB::Initialize();
   ProcessElfCore::Initialize();
void SystemInitializerTest::Terminate() {
 
   Debugger::SettingsTerminate();
 
   // Terminate and unload and loaded system or user LLDB plug-ins
   PluginManager::Terminate();
 
   ClangASTContext::Terminate();
 
-  ABIMacOSX_i386::Terminate();
-  ABIMacOSX_arm::Terminate();
+#ifdef LLVM_TARGET_AArch64_BUILT
   ABIMacOSX_arm64::Terminate();
-  ABISysV_arm::Terminate();
   ABISysV_arm64::Terminate();
+#endif
+#ifdef LLVM_TARGET_ARM_BUILT
+  ABIMacOSX_arm::Terminate();
+  ABISysV_arm::Terminate();
+#endif
+#ifdef LLVM_TARGET_Hexagon_BUILT
   ABISysV_hexagon::Terminate();
-  ABISysV_i386::Terminate();
-  ABISysV_x86_64::Terminate();
-  ABISysV_ppc::Terminate();
-  ABISysV_ppc64::Terminate();
+#endif
+#ifdef LLVM_TARGET_Mips_BUILT
   ABISysV_mips::Terminate();
   ABISysV_mips64::Terminate();
+#endif
+#ifdef LLVM_TARGET_PowerPC_BUILT
+  ABISysV_ppc::Terminate();
+  ABISysV_ppc64::Terminate();
+#endif
+#ifdef LLVM_TARGET_SystemZ_BUILT
   ABISysV_s390x::Terminate();
+#endif
+#ifdef LLVM_TARGET_X86_BUILT
+  ABIMacOSX_i386::Terminate();
+  ABISysV_i386::Terminate();
+  ABISysV_x86_64::Terminate();
+  ABIWindows_x86_64::Terminate();
+#endif
+
   DisassemblerLLVMC::Terminate();
 
   JITLoaderGDB::Terminate();
   ProcessElfCore::Terminate();
   minidump::ProcessMinidump::Terminate();
   MemoryHistoryASan::Terminate();
   AddressSanitizerRuntime::Terminate();
   ThreadSanitizerRuntime::Terminate();