lib/ExecutionEngine/JIT/JIT.cpp

   1 //===-- JIT.cpp - LLVM Just in Time Compiler ------------------------------===//
   2 //
   3 // This file implements the top-level support for creating a Just-In-Time
   4 // compiler for the current architecture.
   5 //
   6 //===----------------------------------------------------------------------===//
   7
   8 #include "VM.h"
   9 #include "llvm/Target/TargetMachine.h"
  10 #include "llvm/Target/TargetMachineImpls.h"
  11 #include "llvm/Module.h"
  12 #include "Support/CommandLine.h"
  13
  14 // FIXME: REMOVE THIS
  15 #include "llvm/PassManager.h"
  16
  17 namespace {
  18   cl::opt<std::string>
  19   Arch("march", cl::desc("Architecture: `x86' or `sparc'"), cl::Prefix,
  20        cl::value_desc("machine architecture"));
  21
  22   static std::string DefaultArch =
  23 #if defined(i386) || defined(__i386__) || defined(__x86__)
  24   "x86";
  25 #elif defined(sparc) || defined(__sparc__) || defined(__sparcv9)
  26   "sparc";
  27 #else
  28   "";
  29 #endif
  30 }
  31
  32 /// createJIT - Create an return a new JIT compiler if there is one available
  33 /// for the current target.  Otherwise it returns null.
  34 ///
  35 ExecutionEngine *ExecutionEngine::createJIT(Module *M, unsigned Config) {
  36
  37   TargetMachine* (*TargetMachineAllocator)(unsigned) = 0;
  38   if (Arch == "")
  39     Arch = DefaultArch;
  40
  41   // Allow a command-line switch to override what *should* be the default target
  42   // machine for this platform. This allows for debugging a Sparc JIT on X86 --
  43   // our X86 machines are much faster at recompiling LLVM and linking lli.
  44   if (Arch == "x86") {
  45     TargetMachineAllocator = allocateX86TargetMachine;
  46 #if defined(sparc) || defined(__sparc__) || defined(__sparcv9)
  47   } else if (Arch == "sparc") {
  48     TargetMachineAllocator = allocateSparcTargetMachine;
  49 #endif
  50   }
  51
  52   if (TargetMachineAllocator) {
  53     // Allocate a target...
  54     TargetMachine *Target = (*TargetMachineAllocator)(Config);
  55     assert(Target && "Could not allocate target machine!");
  56
  57     // Create the virtual machine object...
  58     return new VM(M, Target);
  59   } else {
  60     return 0;
  61   }
  62 }
  63
  64 VM::VM(Module *M, TargetMachine *tm) : ExecutionEngine(M), TM(*tm) {
  65   setTargetData(TM.getTargetData());
  66
  67   // Initialize MCE
  68   MCE = createEmitter(*this);
  69
  70   setupPassManager();
  71
  72 #if defined(sparc) || defined(__sparc__) || defined(__sparcv9)
  73   // THIS GOES BEYOND UGLY HACKS
  74   if (TM.getName() == "UltraSparc-Native") {
  75     extern Pass *createPreSelectionPass(TargetMachine &TM);
  76     PassManager PM;
  77     // Specialize LLVM code for this target machine and then
  78     // run basic dataflow optimizations on LLVM code.
  79     PM.add(createPreSelectionPass(TM));
  80     PM.run(*M);
  81   }
  82 #endif
  83
  84   emitGlobals();
  85 }
  86
  87 int VM::run(const std::string &FnName, const std::vector<std::string> &Args) {
  88   Function *F = getModule().getNamedFunction(FnName);
  89   if (F == 0) {
  90     std::cerr << "Could not find function '" << FnName <<"' in module!\n";
  91     return 1;
  92   }
  93
  94   int(*PF)(int, char**) = (int(*)(int, char**))getPointerToFunction(F);
  95   assert(PF != 0 && "Null pointer to function?");
  96
  97   // Build an argv vector...
  98   char **Argv = (char**)CreateArgv(Args);
  99
 100   // Call the main function...
 101   int Result = PF(Args.size(), Argv);
 102
 103   // Run any atexit handlers now!
 104   runAtExitHandlers();
 105   return Result;
 106 }