Goodbye macro hell, hello nice clean simple extensible code. This change

also gives the JIT the ability to dynamically load targets. e.g.

lli -load libparisc.so -march=parisc foo.bc

llvm-svn: 14750

1 files changed, 13 insertions, 55 deletions

diff --git a/llvm/lib/ExecutionEngine/JIT/TargetSelect.cpp b/llvm/lib/ExecutionEngine/JIT/TargetSelect.cpp
index 4d79990e88b..a14b365b61e 100644
--- a/llvm/lib/ExecutionEngine/JIT/TargetSelect.cpp
+++ b/llvm/lib/ExecutionEngine/JIT/TargetSelect.cpp
@@ -19,69 +19,29 @@
 #include "llvm/Module.h"
 #include "llvm/ModuleProvider.h"
 #include "llvm/Target/TargetMachine.h"
-#include "llvm/Target/TargetMachineImpls.h"
-#include "Support/CommandLine.h"
+#include "llvm/Target/TargetMachineRegistry.h"
+#include <iostream>
 using namespace llvm;
 
-#if !defined(ENABLE_X86_JIT) && !defined(ENABLE_SPARC_JIT)
-#define NO_JITS_ENABLED
-#endif
-
-namespace {
-  enum ArchName { x86, SparcV9 };
-
-#ifndef NO_JITS_ENABLED
-  cl::opt<ArchName>
-  Arch("march", cl::desc("Architecture to JIT to:"), cl::Prefix,
-       cl::values(
-#ifdef ENABLE_X86_JIT
-                  clEnumVal(x86, "  IA-32 (Pentium and above)"),
-#endif
-#ifdef ENABLE_SPARC_JIT
-                  clEnumValN(SparcV9, "sparcv9", "  Sparc-V9"),
-#endif
-                  0),
-#if defined(ENABLE_X86_JIT)
-  cl::init(x86)
-#elif defined(ENABLE_SPARC_JIT)
-  cl::init(SparcV9)
-#endif
-       );
-#endif /* NO_JITS_ENABLED */
-}
+static cl::opt<const TargetMachineRegistry::Entry*, false, TargetNameParser>
+MArch("march", cl::desc("Architecture to generate assembly for:"));
 
 /// create - Create an return a new JIT compiler if there is one available
 /// for the current target.  Otherwise, return null.
 ///
 ExecutionEngine *JIT::create(ModuleProvider *MP, IntrinsicLowering *IL) {
-  TargetMachine* (*TargetMachineAllocator)(const Module &,
-                                           IntrinsicLowering *IL) = 0;
-
-  // Allow a command-line switch to override what *should* be the default target
-  // machine for this platform. This allows for debugging a Sparc JIT on X86 --
-  // our X86 machines are much faster at recompiling LLVM and linking LLI.
-#ifndef NO_JITS_ENABLED
-
-  switch (Arch) {
-#ifdef ENABLE_X86_JIT
-  case x86:
-    TargetMachineAllocator = allocateX86TargetMachine;
-    break;
-#endif
-#ifdef ENABLE_SPARC_JIT
-  case SparcV9:
-    TargetMachineAllocator = allocateSparcV9TargetMachine;
-    break;
-#endif
-  default:
-    assert(0 && "-march flag not supported on this host!");
+  if (MArch == 0) {
+    std::string Error;
+    MArch = TargetMachineRegistry::getClosestTargetForJIT(Error);
+    if (MArch == 0) return 0;
+  } else if (MArch->JITMatchQualityFn() == 0) {
+    std::cerr << "WARNING: This target JIT is not designed for the host you are"
+              << " running.  If bad things happen, please choose a different "
+              << "-march switch.\n";
   }
-#else
-  return 0;
-#endif
 
   // Allocate a target...
-  TargetMachine *Target = TargetMachineAllocator(*MP->getModule(), IL);
+  TargetMachine *Target = MArch->CtorFn(*MP->getModule(), IL);
   assert(Target && "Could not allocate target machine!");
 
   // If the target supports JIT code generation, return a new JIT now.
@@ -89,5 +49,3 @@ ExecutionEngine *JIT::create(ModuleProvider *MP, IntrinsicLowering *IL) {
     return new JIT(MP, *Target, *TJ);
   return 0;
 }
-
-