Add backend name to Target to enable runtime info to be fed back into TableGen

[dsanders]

Summary

Make it possible to feed runtime information back to tablegen to enable
profile-guided tablegen-eration, detection of untested tablegen definitions, etc.

Being a cross-compiler by nature, LLVM will potentially collect data for multiple
architectures (e.g. when running 'ninja check'). We therefore need a way for
TableGen to figure out what data applies to the backend it is generating at the
time. This patch achieves that by including the name of the 'def X : Target ...'
for the backend in the TargetRegistry.

[dsanders]

ping

[tatyana-krasnukha]

Hi,

Build for ARC fails, fix TargetInfo for this target please.

[dsanders]

In D39742#927383, @tatyana-krasnukha wrote:

Hi,

Build for ARC fails, fix TargetInfo for this target please.

I've updated ARC in r318441. I also had to fix an ambiguous overloaded operator to get ARC to build on my machine. The fix for that is in r318443

include/llvm/Support/TargetRegistry.h

private:
   ArchMatchFnTy ArchMatchFn;
 
   /// Name - The target name.
   const char *Name;
 
   /// ShortDesc - A short description of the target.
   const char *ShortDesc;
 
+  /// BackendName - The name of the backend implementation. This must match the
+  /// name of the 'def X : Target ...' in TableGen.
+  const char *BackendName;
+
   /// HasJIT - Whether this target supports the JIT.
   bool HasJIT;
 
   /// MCAsmInfoCtorFn - Constructor function for this target's MCAsmInfo, if
   /// registered.
   MCAsmInfoCtorFnTy MCAsmInfoCtorFn;
 
   /// MCInstrInfoCtorFn - Constructor function for this target's MCInstrInfo,
public:
   const Target *getNext() const { return Next; }
 
   /// getName - Get the target name.
   const char *getName() const { return Name; }
 
   /// getShortDescription - Get a short description of the target.
   const char *getShortDescription() const { return ShortDesc; }
 
+  /// getBackendName - Get the backend name.
+  const char *getBackendName() const { return BackendName; }
+
   /// @}
   /// @name Feature Predicates
   /// @{
 
   /// hasJIT - Check if this targets supports the just-in-time compilation.
   bool hasJIT() const { return HasJIT; }
 
   /// hasTargetMachine - Check if this target supports code generation.
struct TargetRegistry {
   /// Clients are responsible for ensuring that registration doesn't occur
   /// while another thread is attempting to access the registry. Typically
   /// this is done by initializing all targets at program startup.
   ///
   /// @param T - The target being registered.
   /// @param Name - The target name. This should be a static string.
   /// @param ShortDesc - A short target description. This should be a static
   /// string.
+  /// @param BackendName - The name of the backend. This should be a static
+  /// string that is the same for all targets that share a backend
+  /// implementation and must match the name used in the 'def X : Target ...' in
+  /// TableGen.
   /// @param ArchMatchFn - The arch match checking function for this target.
   /// @param HasJIT - Whether the target supports JIT code
   /// generation.
   static void RegisterTarget(Target &T, const char *Name, const char *ShortDesc,
+                             const char *BackendName,
                              Target::ArchMatchFnTy ArchMatchFn,
                              bool HasJIT = false);
 
   /// RegisterMCAsmInfo - Register a MCAsmInfo implementation for the
   /// given target.
   ///
   /// Clients are responsible for ensuring that registration doesn't occur
   /// while another thread is attempting to access the registry. Typically

 /// }
 /// extern "C" void LLVMInitializeFooTargetInfo() {
 ///   RegisterTarget<Triple::foo> X(getTheFooTarget(), "foo", "Foo
 ///   description");
 /// }
 template <Triple::ArchType TargetArchType = Triple::UnknownArch,
           bool HasJIT = false>
 struct RegisterTarget {
-  RegisterTarget(Target &T, const char *Name, const char *Desc) {
-    TargetRegistry::RegisterTarget(T, Name, Desc, &getArchMatch, HasJIT);
+  RegisterTarget(Target &T, const char *Name, const char *Desc,
+                 const char *BackendName) {
+    TargetRegistry::RegisterTarget(T, Name, Desc, BackendName, &getArchMatch,
+                                   HasJIT);
   }
 
   static bool getArchMatch(Triple::ArchType Arch) {
     return Arch == TargetArchType;
   }
 };
 
 /// RegisterMCAsmInfo - Helper template for registering a target assembly info

lib/Support/TargetRegistry.cpp

if (J != targets().end()) {
     Error = std::string("Cannot choose between targets \"") + I->Name +
             "\" and \"" + J->Name + "\"";
     return nullptr;
   }
 
   return &*I;
 }
 
-void TargetRegistry::RegisterTarget(Target &T,
-                                    const char *Name,
+void TargetRegistry::RegisterTarget(Target &T, const char *Name,
                                     const char *ShortDesc,
+                                    const char *BackendName,
                                     Target::ArchMatchFnTy ArchMatchFn,
                                     bool HasJIT) {
   assert(Name && ShortDesc && ArchMatchFn &&
          "Missing required target information!");
 
   // Check if this target has already been initialized, we allow this as a
   // convenience to some clients.
   if (T.Name)
     return;
          
   // Add to the list of targets.
   T.Next = FirstTarget;
   FirstTarget = &T;
 
   T.Name = Name;
   T.ShortDesc = ShortDesc;
+  T.BackendName = BackendName;
   T.ArchMatchFn = ArchMatchFn;
   T.HasJIT = HasJIT;
 }
 
 static int TargetArraySortFn(const std::pair<StringRef, const Target *> *LHS,
                              const std::pair<StringRef, const Target *> *RHS) {
   return LHS->first.compare(RHS->first);
 }

lib/Target/AArch64/TargetInfo/AArch64TargetInfo.cpp

Target &getTheARM64Target() {
   return TheARM64Target;
 }
 } // namespace llvm
 
 extern "C" void LLVMInitializeAArch64TargetInfo() {
   // Now register the "arm64" name for use with "-march". We don't want it to
   // take possession of the Triple::aarch64 tag though.
   TargetRegistry::RegisterTarget(getTheARM64Target(), "arm64",
-                                 "ARM64 (little endian)",
+                                 "ARM64 (little endian)", "AArch64",
                                  [](Triple::ArchType) { return false; }, true);
 
   RegisterTarget<Triple::aarch64, /*HasJIT=*/true> Z(
-      getTheAArch64leTarget(), "aarch64", "AArch64 (little endian)");
+      getTheAArch64leTarget(), "aarch64", "AArch64 (little endian)", "AArch64");
   RegisterTarget<Triple::aarch64_be, /*HasJIT=*/true> W(
-      getTheAArch64beTarget(), "aarch64_be", "AArch64 (big endian)");
+      getTheAArch64beTarget(), "aarch64_be", "AArch64 (big endian)", "AArch64");
 }

lib/Target/AMDGPU/TargetInfo/AMDGPUTargetInfo.cpp

 Target &llvm::getTheGCNTarget() {
   static Target TheGCNTarget;
   return TheGCNTarget;
 }
 
 /// \brief Extern function to initialize the targets for the AMDGPU backend
 extern "C" void LLVMInitializeAMDGPUTargetInfo() {
   RegisterTarget<Triple::r600, false> R600(getTheAMDGPUTarget(), "r600",
-                                           "AMD GPUs HD2XXX-HD6XXX");
+                                           "AMD GPUs HD2XXX-HD6XXX", "AMDGPU");
   RegisterTarget<Triple::amdgcn, false> GCN(getTheGCNTarget(), "amdgcn",
-                                            "AMD GCN GPUs");
+                                            "AMD GCN GPUs", "AMDGPU");
 }

lib/Target/ARM/TargetInfo/ARMTargetInfo.cpp

 }
 Target &llvm::getTheThumbBETarget() {
   static Target TheThumbBETarget;
   return TheThumbBETarget;
 }
 
 extern "C" void LLVMInitializeARMTargetInfo() {
   RegisterTarget<Triple::arm, /*HasJIT=*/true> X(getTheARMLETarget(), "arm",
-                                                 "ARM");
+                                                 "ARM", "ARM");
   RegisterTarget<Triple::armeb, /*HasJIT=*/true> Y(getTheARMBETarget(), "armeb",
-                                                   "ARM (big endian)");
+                                                   "ARM (big endian)", "ARM");
 
   RegisterTarget<Triple::thumb, /*HasJIT=*/true> A(getTheThumbLETarget(),
-                                                   "thumb", "Thumb");
+                                                   "thumb", "Thumb", "ARM");
   RegisterTarget<Triple::thumbeb, /*HasJIT=*/true> B(
-      getTheThumbBETarget(), "thumbeb", "Thumb (big endian)");
+      getTheThumbBETarget(), "thumbeb", "Thumb (big endian)", "ARM");
 }

lib/Target/BPF/TargetInfo/BPFTargetInfo.cpp

 Target &getTheBPFTarget() {
   static Target TheBPFTarget;
   return TheBPFTarget;
 }
 } // namespace llvm
 
 extern "C" void LLVMInitializeBPFTargetInfo() {
   TargetRegistry::RegisterTarget(getTheBPFTarget(), "bpf", "BPF (host endian)",
-                                 [](Triple::ArchType) { return false; }, true);
-  RegisterTarget<Triple::bpfel, /*HasJIT=*/true> X(getTheBPFleTarget(), "bpfel",
-                                                   "BPF (little endian)");
+                                 "BPF", [](Triple::ArchType) { return false; },
+                                 true);
+  RegisterTarget<Triple::bpfel, /*HasJIT=*/true> X(
+      getTheBPFleTarget(), "bpfel", "BPF (little endian)", "BPF");
   RegisterTarget<Triple::bpfeb, /*HasJIT=*/true> Y(getTheBPFbeTarget(), "bpfeb",
-                                                   "BPF (big endian)");
+                                                   "BPF (big endian)", "BPF");
 }

lib/Target/Hexagon/TargetInfo/HexagonTargetInfo.cpp

 using namespace llvm;
 
 Target &llvm::getTheHexagonTarget() {
   static Target TheHexagonTarget;
   return TheHexagonTarget;
 }
 
 extern "C" void LLVMInitializeHexagonTargetInfo() {
-  RegisterTarget<Triple::hexagon, /*HasJIT=*/false> X(getTheHexagonTarget(),
-                                                      "hexagon", "Hexagon");
+  RegisterTarget<Triple::hexagon, /*HasJIT=*/false> X(
+      getTheHexagonTarget(), "hexagon", "Hexagon", "Hexagon");
 }

lib/Target/Lanai/TargetInfo/LanaiTargetInfo.cpp

 namespace llvm {
 Target &getTheLanaiTarget() {
   static Target TheLanaiTarget;
   return TheLanaiTarget;
 }
 } // namespace llvm
 
 extern "C" void LLVMInitializeLanaiTargetInfo() {
-  RegisterTarget<Triple::lanai> X(getTheLanaiTarget(), "lanai", "Lanai");
+  RegisterTarget<Triple::lanai> X(getTheLanaiTarget(), "lanai", "Lanai",
+                                  "Lanai");
 }

lib/Target/MSP430/TargetInfo/MSP430TargetInfo.cpp

 
 Target &llvm::getTheMSP430Target() {
   static Target TheMSP430Target;
   return TheMSP430Target;
 }
 
 extern "C" void LLVMInitializeMSP430TargetInfo() {
   RegisterTarget<Triple::msp430> X(getTheMSP430Target(), "msp430",
-                                   "MSP430 [experimental]");
+                                   "MSP430 [experimental]", "MSP430");
 }

lib/Target/Mips/TargetInfo/MipsTargetInfo.cpp

 Target &llvm::getTheMips64elTarget() {
   static Target TheMips64elTarget;
   return TheMips64elTarget;
 }
 
 extern "C" void LLVMInitializeMipsTargetInfo() {
   RegisterTarget<Triple::mips,
                  /*HasJIT=*/true>
-      X(getTheMipsTarget(), "mips", "Mips");
+      X(getTheMipsTarget(), "mips", "Mips", "Mips");
 
   RegisterTarget<Triple::mipsel,
                  /*HasJIT=*/true>
-      Y(getTheMipselTarget(), "mipsel", "Mipsel");
+      Y(getTheMipselTarget(), "mipsel", "Mipsel", "Mips");
 
   RegisterTarget<Triple::mips64,
                  /*HasJIT=*/true>
-      A(getTheMips64Target(), "mips64", "Mips64 [experimental]");
+      A(getTheMips64Target(), "mips64", "Mips64 [experimental]", "Mips");
 
   RegisterTarget<Triple::mips64el,
                  /*HasJIT=*/true>
-      B(getTheMips64elTarget(), "mips64el", "Mips64el [experimental]");
+      B(getTheMips64elTarget(), "mips64el", "Mips64el [experimental]", "Mips");
 }

lib/Target/NVPTX/TargetInfo/NVPTXTargetInfo.cpp

 }
 Target &llvm::getTheNVPTXTarget64() {
   static Target TheNVPTXTarget64;
   return TheNVPTXTarget64;
 }
 
 extern "C" void LLVMInitializeNVPTXTargetInfo() {
   RegisterTarget<Triple::nvptx> X(getTheNVPTXTarget32(), "nvptx",
-                                  "NVIDIA PTX 32-bit");
+                                  "NVIDIA PTX 32-bit", "NVPTX");
   RegisterTarget<Triple::nvptx64> Y(getTheNVPTXTarget64(), "nvptx64",
-                                    "NVIDIA PTX 64-bit");
+                                    "NVIDIA PTX 64-bit", "NVPTX");
 }

lib/Target/PowerPC/TargetInfo/PowerPCTargetInfo.cpp

 }
 Target &llvm::getThePPC64LETarget() {
   static Target ThePPC64LETarget;
   return ThePPC64LETarget;
 }
 
 extern "C" void LLVMInitializePowerPCTargetInfo() {
   RegisterTarget<Triple::ppc, /*HasJIT=*/true> X(getThePPC32Target(), "ppc32",
-                                                 "PowerPC 32");
+                                                 "PowerPC 32", "PPC");
 
   RegisterTarget<Triple::ppc64, /*HasJIT=*/true> Y(getThePPC64Target(), "ppc64",
-                                                   "PowerPC 64");
+                                                   "PowerPC 64", "PPC");
 
   RegisterTarget<Triple::ppc64le, /*HasJIT=*/true> Z(
-      getThePPC64LETarget(), "ppc64le", "PowerPC 64 LE");
+      getThePPC64LETarget(), "ppc64le", "PowerPC 64 LE", "PPC");
 }

lib/Target/Sparc/TargetInfo/SparcTargetInfo.cpp

 }
 Target &llvm::getTheSparcelTarget() {
   static Target TheSparcelTarget;
   return TheSparcelTarget;
 }
 
 extern "C" void LLVMInitializeSparcTargetInfo() {
   RegisterTarget<Triple::sparc, /*HasJIT=*/true> X(getTheSparcTarget(), "sparc",
-                                                   "Sparc");
-  RegisterTarget<Triple::sparcv9, /*HasJIT=*/true> Y(getTheSparcV9Target(),
-                                                     "sparcv9", "Sparc V9");
-  RegisterTarget<Triple::sparcel, /*HasJIT=*/true> Z(getTheSparcelTarget(),
-                                                     "sparcel", "Sparc LE");
+                                                   "Sparc", "Sparc");
+  RegisterTarget<Triple::sparcv9, /*HasJIT=*/true> Y(
+      getTheSparcV9Target(), "sparcv9", "Sparc V9", "Sparc");
+  RegisterTarget<Triple::sparcel, /*HasJIT=*/true> Z(
+      getTheSparcelTarget(), "sparcel", "Sparc LE", "Sparc");
 }

lib/Target/SystemZ/TargetInfo/SystemZTargetInfo.cpp

 using namespace llvm;
 
 Target &llvm::getTheSystemZTarget() {
   static Target TheSystemZTarget;
   return TheSystemZTarget;
 }
 
 extern "C" void LLVMInitializeSystemZTargetInfo() {
-  RegisterTarget<Triple::systemz, /*HasJIT=*/true> X(getTheSystemZTarget(),
-                                                     "systemz", "SystemZ");
+  RegisterTarget<Triple::systemz, /*HasJIT=*/true> X(
+      getTheSystemZTarget(), "systemz", "SystemZ", "SystemZ");
 }

lib/Target/X86/TargetInfo/X86TargetInfo.cpp

 }
 Target &llvm::getTheX86_64Target() {
   static Target TheX86_64Target;
   return TheX86_64Target;
 }
 
 extern "C" void LLVMInitializeX86TargetInfo() {
   RegisterTarget<Triple::x86, /*HasJIT=*/true> X(
-      getTheX86_32Target(), "x86", "32-bit X86: Pentium-Pro and above");
+      getTheX86_32Target(), "x86", "32-bit X86: Pentium-Pro and above", "X86");
 
   RegisterTarget<Triple::x86_64, /*HasJIT=*/true> Y(
-      getTheX86_64Target(), "x86-64", "64-bit X86: EM64T and AMD64");
+      getTheX86_64Target(), "x86-64", "64-bit X86: EM64T and AMD64", "X86");
 }

lib/Target/XCore/TargetInfo/XCoreTargetInfo.cpp

 using namespace llvm;
 
 Target &llvm::getTheXCoreTarget() {
   static Target TheXCoreTarget;
   return TheXCoreTarget;
 }
 
 extern "C" void LLVMInitializeXCoreTargetInfo() {
-  RegisterTarget<Triple::xcore> X(getTheXCoreTarget(), "xcore", "XCore");
+  RegisterTarget<Triple::xcore> X(getTheXCoreTarget(), "xcore", "XCore",
+                                  "XCore");
 }