Allow for specification of which JIT to run on the commandline.

`lli -march=x86' or `lli -march=sparc' will forcefully select the JIT even on a
different platform. Running lli without the -march option will select the JIT
for the platform that it's currently running on.

Pro: can test Sparc JIT (debug printing mode) on X86 -- faster to compile/link
LLVM source base to test changes.
Con: Linking lli on x86 now pulls in all the Sparc libs -> longer link time
(but X86 can bear it, right?)

In the future, perhaps this should be a ./configure option to enable/disable
target JITting...


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@6360 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 48 insertions, 11 deletions

diff --git a/lib/ExecutionEngine/JIT/JIT.cpp b/lib/ExecutionEngine/JIT/JIT.cpp
index 05aa934a85..95d7331f8c 100644
--- a/lib/ExecutionEngine/JIT/JIT.cpp
+++ b/lib/ExecutionEngine/JIT/JIT.cpp
@@ -9,28 +9,65 @@
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetMachineImpls.h"
 #include "llvm/Module.h"
+#include "Support/CommandLine.h"
+
+namespace {
+  cl::opt<std::string>
+  Arch("march", cl::desc("Architecture: `x86' or `sparc'"), cl::Prefix,
+       cl::value_desc("machine architecture"));
+  
+  static std::string DefaultArch = 
+#if defined(i386) || defined(__i386__) || defined(__x86__)
+  "x86";
+#elif defined(sparc) || defined(__sparc__) || defined(__sparcv9)
+  "sparc";
+#else
+  "";
+#endif
+
+}
 
 
 /// createJIT - Create an return a new JIT compiler if there is one available
 /// for the current target.  Otherwise it returns null.
 ///
 ExecutionEngine *ExecutionEngine::createJIT(Module *M, unsigned Config) {
-  // FIXME: This should be controlled by which subdirectory gets linked in!
-#if !defined(i386) && !defined(__i386__) && !defined(__x86__)
-  return 0;
-#endif
-  // Allocate a target... in the future this will be controllable on the
-  // command line.
-  TargetMachine *Target = allocateX86TargetMachine(Config);
-  assert(Target && "Could not allocate X86 target machine!");
+  
+  TargetMachine* (*TargetMachineAllocator)(unsigned) = 0;
+  if (Arch == "")
+    Arch = DefaultArch;
+
+  // 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.
+  if (Arch == "x86") {
+    TargetMachineAllocator = allocateX86TargetMachine;
+  } else if (Arch == "sparc") {
+    TargetMachineAllocator = allocateSparcTargetMachine;
+  }
+
+  if (TargetMachineAllocator) {
+    // Allocate a target...
+    TargetMachine *Target = (*TargetMachineAllocator)(Config);
+    assert(Target && "Could not allocate target machine!");
 
-  // Create the virtual machine object...
-  return new VM(M, Target);
+    // Create the virtual machine object...
+    return new VM(M, Target);
+  } else {
+    return 0;
+  }
 }
 
 VM::VM(Module *M, TargetMachine *tm) : ExecutionEngine(M), TM(*tm) {
   setTargetData(TM.getTargetData());
-  MCE = createEmitter(*this);  // Initialize MCE
+
+  // Initialize MCE
+  if (Arch == "x86") {
+    MCE = createX86Emitter(*this);
+  } else if (Arch == "sparc") {
+    MCE = createSparcEmitter(*this);
+  }
+
   setupPassManager();
   registerCallback();
   emitGlobals();