tools/lli/OrcLazyJIT.cpp

   1 //===------ OrcLazyJIT.cpp - Basic Orc-based JIT for lazy execution -------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "OrcLazyJIT.h"
  11 #include "llvm/ExecutionEngine/Orc/OrcTargetSupport.h"
  12 #include "llvm/Support/Debug.h"
  13 #include "llvm/Support/DynamicLibrary.h"
  14 #include <system_error>
  15
  16 using namespace llvm;
  17
  18 namespace {
  19
  20   enum class DumpKind { NoDump, DumpFuncsToStdErr, DumpModsToStdErr,
  21                         DumpModsToDisk };
  22
  23   cl::opt<DumpKind> OrcDumpKind("orc-lazy-debug",
  24                                 cl::desc("Debug dumping for the orc-lazy JIT."),
  25                                 cl::init(DumpKind::NoDump),
  26                                 cl::values(
  27                                   clEnumValN(DumpKind::NoDump, "no-dump",
  28                                              "Don't dump anything."),
  29                                   clEnumValN(DumpKind::DumpFuncsToStdErr,
  30                                              "funcs-to-stderr",
  31                                              "Dump function names to stderr."),
  32                                   clEnumValN(DumpKind::DumpModsToStdErr,
  33                                              "mods-to-stderr",
  34                                              "Dump modules to stderr."),
  35                                   clEnumValN(DumpKind::DumpModsToDisk,
  36                                              "mods-to-disk",
  37                                              "Dump modules to the current "
  38                                              "working directory. (WARNING: "
  39                                              "will overwrite existing files)."),
  40                                   clEnumValEnd));
  41 }
  42
  43 OrcLazyJIT::CallbackManagerBuilder
  44 OrcLazyJIT::createCallbackManagerBuilder(Triple T) {
  45   switch (T.getArch()) {
  46     default: return nullptr;
  47
  48     case Triple::x86_64: {
  49       typedef orc::JITCompileCallbackManager<IRDumpLayerT,
  50                                              orc::OrcX86_64> CCMgrT;
  51       return [](IRDumpLayerT &IRDumpLayer, RuntimeDyld::MemoryManager &MemMgr,
  52                 LLVMContext &Context) {
  53                return llvm::make_unique<CCMgrT>(IRDumpLayer, MemMgr, Context, 0,
  54                                                 64);
  55              };
  56     }
  57   }
  58 }
  59
  60 OrcLazyJIT::TransformFtor OrcLazyJIT::createDebugDumper() {
  61
  62   switch (OrcDumpKind) {
  63   case DumpKind::NoDump:
  64     return [](std::unique_ptr<Module> M) { return std::move(M); };
  65
  66   case DumpKind::DumpFuncsToStdErr:
  67     return [](std::unique_ptr<Module> M) {
  68       dbgs() << "[ ";
  69
  70       for (const auto &F : *M) {
  71         if (F.isDeclaration())
  72           continue;
  73
  74         if (F.hasName())
  75           dbgs() << F.getName() << " ";
  76         else
  77           dbgs() << "<anon> ";
  78       }
  79
  80       dbgs() << "]\n";
  81       return std::move(M);
  82     };
  83
  84   case DumpKind::DumpModsToStdErr:
  85     return [](std::unique_ptr<Module> M) {
  86              dbgs() << "----- Module Start -----\n" << *M
  87                     << "----- Module End -----\n";
  88
  89              return std::move(M);
  90            };
  91
  92   case DumpKind::DumpModsToDisk:
  93     return [](std::unique_ptr<Module> M) {
  94              std::error_code EC;
  95              raw_fd_ostream Out(M->getModuleIdentifier() + ".ll", EC,
  96                                 sys::fs::F_Text);
  97              if (EC) {
  98                errs() << "Couldn't open " << M->getModuleIdentifier()
  99                       << " for dumping.\nError:" << EC.message() << "\n";
 100                exit(1);
 101              }
 102              Out << *M;
 103              return std::move(M);
 104            };
 105   }
 106 }
 107
 108 int llvm::runOrcLazyJIT(std::unique_ptr<Module> M, int ArgC, char* ArgV[]) {
 109   // Add the program's symbols into the JIT's search space.
 110   if (sys::DynamicLibrary::LoadLibraryPermanently(nullptr)) {
 111     errs() << "Error loading program symbols.\n";
 112     return 1;
 113   }
 114
 115   // Grab a target machine and try to build a factory function for the
 116   // target-specific Orc callback manager.
 117   auto TM = std::unique_ptr<TargetMachine>(EngineBuilder().selectTarget());
 118   auto &Context = getGlobalContext();
 119   auto CallbackMgrBuilder =
 120     OrcLazyJIT::createCallbackManagerBuilder(Triple(TM->getTargetTriple()));
 121
 122   // If we couldn't build the factory function then there must not be a callback
 123   // manager for this target. Bail out.
 124   if (!CallbackMgrBuilder) {
 125     errs() << "No callback manager available for target '"
 126            << TM->getTargetTriple() << "'.\n";
 127     return 1;
 128   }
 129
 130   // Everything looks good. Build the JIT.
 131   OrcLazyJIT J(std::move(TM), Context, CallbackMgrBuilder);
 132
 133   // Add the module, look up main and run it.
 134   auto MainHandle = J.addModule(std::move(M));
 135   auto MainSym = J.findSymbolIn(MainHandle, "main");
 136
 137   if (!MainSym) {
 138     errs() << "Could not find main function.\n";
 139     return 1;
 140   }
 141
 142   typedef int (*MainFnPtr)(int, char*[]);
 143   auto Main = OrcLazyJIT::fromTargetAddress<MainFnPtr>(MainSym.getAddress());
 144   return Main(ArgC, ArgV);
 145 }