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
  23 // FIXME: REMOVE THIS
  24 #include "llvm/PassManager.h"
  25
  26 #if !defined(ENABLE_X86_JIT) && !defined(ENABLE_SPARC_JIT)
  27 #define NO_JITS_ENABLED
  28 #endif
  29
  30 namespace {
  31   enum ArchName { x86, Sparc };
  32
  33 #ifndef NO_JITS_ENABLED
  34   cl::opt<ArchName>
  35   Arch("march", cl::desc("Architecture to JIT to:"), cl::Prefix,
  36        cl::values(
  37 #ifdef ENABLE_X86_JIT
  38                   clEnumVal(x86, "  IA-32 (Pentium and above)"),
  39 #endif
  40 #ifdef ENABLE_SPARC_JIT
  41                   clEnumValN(Sparc, "sparc", "  Sparc-V9"),
  42 #endif
  43                   0),
  44 #if defined(ENABLE_X86_JIT)
  45   cl::init(x86)
  46 #elif defined(ENABLE_SPARC_JIT)
  47   cl::init(Sparc)
  48 #endif
  49        );
  50 #endif /* NO_JITS_ENABLED */
  51 }
  52
  53 /// create - Create an return a new JIT compiler if there is one available
  54 /// for the current target.  Otherwise, return null.
  55 ///
  56 ExecutionEngine *VM::create(ModuleProvider *MP) {
  57   TargetMachine* (*TargetMachineAllocator)(const Module &) = 0;
  58
  59   // Allow a command-line switch to override what *should* be the default target
  60   // machine for this platform. This allows for debugging a Sparc JIT on X86 --
  61   // our X86 machines are much faster at recompiling LLVM and linking LLI.
  62 #ifndef NO_JITS_ENABLED
  63
  64   switch (Arch) {
  65 #ifdef ENABLE_X86_JIT
  66   case x86:
  67     TargetMachineAllocator = allocateX86TargetMachine;
  68     break;
  69 #endif
  70 #ifdef ENABLE_SPARC_JIT
  71   case Sparc:
  72     TargetMachineAllocator = allocateSparcTargetMachine;
  73     break;
  74 #endif
  75   default:
  76     assert(0 && "-march flag not supported on this host!");
  77   }
  78 #else
  79   return 0;
  80 #endif
  81
  82   // Allocate a target...
  83   TargetMachine *Target = TargetMachineAllocator(*MP->getModule());
  84   assert(Target && "Could not allocate target machine!");
  85
  86   // Create the virtual machine object...
  87   return new VM(MP, Target);
  88 }
  89
  90 VM::VM(ModuleProvider *MP, TargetMachine *tm) : ExecutionEngine(MP), TM(*tm),
  91   PM(MP)
  92 {
  93   setTargetData(TM.getTargetData());
  94
  95   // Initialize MCE
  96   MCE = createEmitter(*this);
  97
  98   setupPassManager();
  99
 100 #ifdef ENABLE_SPARC_JIT
 101   // THIS GOES BEYOND UGLY HACKS
 102   if (TM.getName() == "UltraSparc-Native") {
 103     extern Pass *createPreSelectionPass(TargetMachine &TM);
 104     PassManager PM;
 105     // Specialize LLVM code for this target machine and then
 106     // run basic dataflow optimizations on LLVM code.
 107     PM.add(createPreSelectionPass(TM));
 108     // We cannot utilize function-at-a-time loading here because PreSelection
 109     // is a ModulePass.
 110     MP->materializeModule();
 111     PM.run(*MP->getModule());
 112   }
 113 #endif
 114
 115   emitGlobals();
 116 }
 117
 118 /// run - Start execution with the specified function and arguments.
 119 ///
 120 GenericValue VM::run(Function *F, const std::vector<GenericValue> &ArgValues)
 121 {
 122   assert (F && "Function *F was null at entry to run()");
 123
 124   int (*PF)(int, char **, const char **) =
 125     (int(*)(int, char **, const char **))getPointerToFunction(F);
 126   assert(PF != 0 && "Pointer to fn's code was null after getPointerToFunction");
 127
 128   // Call the function.
 129   int ExitCode = PF(ArgValues[0].IntVal, (char **) GVTOP (ArgValues[1]),
 130                     (const char **) GVTOP (ArgValues[2]));
 131
 132   // Run any atexit handlers now!
 133   runAtExitHandlers();
 134
 135   GenericValue rv;
 136   rv.IntVal = ExitCode;
 137   return rv;
 138 }