lib/ExecutionEngine/JIT/JIT.cpp

   1 //===-- JIT.cpp - LLVM Just-In-Time Compiler ------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the top-level support for creating a Just-In-Time
  11 // compiler for the current architecture.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "VM.h"
  16 #include "llvm/Module.h"
  17 #include "llvm/ModuleProvider.h"
  18 #include "llvm/ExecutionEngine/GenericValue.h"
  19 #include "llvm/Target/TargetMachine.h"
  20 #include "llvm/Target/TargetMachineImpls.h"
  21 #include "Support/CommandLine.h"
  22 using namespace llvm;
  23
  24 #if !defined(ENABLE_X86_JIT) && !defined(ENABLE_SPARC_JIT)
  25 #define NO_JITS_ENABLED
  26 #endif
  27
  28 namespace {
  29   enum ArchName { x86, Sparc };
  30
  31 #ifndef NO_JITS_ENABLED
  32   cl::opt<ArchName>
  33   Arch("march", cl::desc("Architecture to JIT to:"), cl::Prefix,
  34        cl::values(
  35 #ifdef ENABLE_X86_JIT
  36                   clEnumVal(x86, "  IA-32 (Pentium and above)"),
  37 #endif
  38 #ifdef ENABLE_SPARC_JIT
  39                   clEnumValN(Sparc, "sparc", "  Sparc-V9"),
  40 #endif
  41                   0),
  42 #if defined(ENABLE_X86_JIT)
  43   cl::init(x86)
  44 #elif defined(ENABLE_SPARC_JIT)
  45   cl::init(Sparc)
  46 #endif
  47        );
  48 #endif /* NO_JITS_ENABLED */
  49 }
  50
  51 /// create - Create an return a new JIT compiler if there is one available
  52 /// for the current target.  Otherwise, return null.
  53 ///
  54 ExecutionEngine *VM::create(ModuleProvider *MP) {
  55   TargetMachine* (*TargetMachineAllocator)(const Module &) = 0;
  56
  57   // Allow a command-line switch to override what *should* be the default target
  58   // machine for this platform. This allows for debugging a Sparc JIT on X86 --
  59   // our X86 machines are much faster at recompiling LLVM and linking LLI.
  60 #ifndef NO_JITS_ENABLED
  61
  62   switch (Arch) {
  63 #ifdef ENABLE_X86_JIT
  64   case x86:
  65     TargetMachineAllocator = allocateX86TargetMachine;
  66     break;
  67 #endif
  68 #ifdef ENABLE_SPARC_JIT
  69   case Sparc:
  70     TargetMachineAllocator = allocateSparcTargetMachine;
  71     break;
  72 #endif
  73   default:
  74     assert(0 && "-march flag not supported on this host!");
  75   }
  76 #else
  77   return 0;
  78 #endif
  79
  80   // Allocate a target...
  81   TargetMachine *Target = TargetMachineAllocator(*MP->getModule());
  82   assert(Target && "Could not allocate target machine!");
  83
  84   // If the target supports JIT code generation, return a new JIT now.
  85   if (TargetJITInfo *TJ = Target->getJITInfo())
  86     return new VM(MP, *Target, *TJ);
  87   return 0;
  88 }
  89
  90 VM::VM(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji)
  91   : ExecutionEngine(MP), TM(tm), TJI(tji), PM(MP) {
  92   setTargetData(TM.getTargetData());
  93
  94   // Initialize MCE
  95   MCE = createEmitter(*this);
  96
  97   setupPassManager();
  98
  99   emitGlobals();
 100 }
 101
 102 /// run - Start execution with the specified function and arguments.
 103 ///
 104 GenericValue VM::run(Function *F, const std::vector<GenericValue> &ArgValues)
 105 {
 106   assert (F && "Function *F was null at entry to run()");
 107
 108   int (*PF)(int, char **, const char **) =
 109     (int(*)(int, char **, const char **))getPointerToFunction(F);
 110   assert(PF != 0 && "Pointer to fn's code was null after getPointerToFunction");
 111
 112   // Call the function.
 113   int ExitCode = PF(ArgValues[0].IntVal, (char **) GVTOP (ArgValues[1]),
 114                     (const char **) GVTOP (ArgValues[2]));
 115
 116   // Run any atexit handlers now!
 117   runAtExitHandlers();
 118
 119   GenericValue rv;
 120   rv.IntVal = ExitCode;
 121   return rv;
 122 }