llvm/examples/OrcV2Examples/LLJITWithTargetProcessControl/LLJITWithTargetProcessControl.cpp

   1 //===- LLJITWithExecutorProcessControl.cpp - LLJIT example with EPC utils -===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // In this example we will use the lazy re-exports utility to lazily compile
  10 // IR modules. We will do this in seven steps:
  11 //
  12 // 1. Create an LLJIT instance.
  13 // 2. Install a transform so that we can see what is being compiled.
  14 // 3. Create an indirect stubs manager and lazy call-through manager.
  15 // 4. Add two modules that will be conditionally compiled, plus a main module.
  16 // 5. Add lazy-rexports of the symbols in the conditionally compiled modules.
  17 // 6. Dump the ExecutionSession state to see the symbol table prior to
  18 //    executing any code.
  19 // 7. Verify that only modules containing executed code are compiled.
  20 //
  21 //===----------------------------------------------------------------------===//
  22
  23 #include "llvm/ADT/StringMap.h"
  24 #include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
  25 #include "llvm/ExecutionEngine/Orc/EPCDynamicLibrarySearchGenerator.h"
  26 #include "llvm/ExecutionEngine/Orc/EPCIndirectionUtils.h"
  27 #include "llvm/ExecutionEngine/Orc/ExecutorProcessControl.h"
  28 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
  29 #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
  30 #include "llvm/ExecutionEngine/Orc/OrcABISupport.h"
  31 #include "llvm/Support/InitLLVM.h"
  32 #include "llvm/Support/TargetSelect.h"
  33 #include "llvm/Support/raw_ostream.h"
  34
  35 #include "../ExampleModules.h"
  36
  37 #include <future>
  38
  39 using namespace llvm;
  40 using namespace llvm::orc;
  41
  42 ExitOnError ExitOnErr;
  43
  44 // Example IR modules.
  45 //
  46 // Note that in the conditionally compiled modules, FooMod and BarMod, functions
  47 // have been given an _body suffix. This is to ensure that their names do not
  48 // clash with their lazy-reexports.
  49 // For clients who do not wish to rename function bodies (e.g. because they want
  50 // to re-use cached objects between static and JIT compiles) techniques exist to
  51 // avoid renaming. See the lazy-reexports section of the ORCv2 design doc.
  52
  53 const llvm::StringRef FooMod =
  54     R"(
  55   declare i32 @return1()
  56
  57   define i32 @foo_body() {
  58   entry:
  59     %0 = call i32 @return1()
  60     ret i32 %0
  61   }
  62 )";
  63
  64 const llvm::StringRef BarMod =
  65     R"(
  66   declare i32 @return2()
  67
  68   define i32 @bar_body() {
  69   entry:
  70     %0 = call i32 @return2()
  71     ret i32 %0
  72   }
  73 )";
  74
  75 const llvm::StringRef MainMod =
  76     R"(
  77
  78   define i32 @entry(i32 %argc) {
  79   entry:
  80     %and = and i32 %argc, 1
  81     %tobool = icmp eq i32 %and, 0
  82     br i1 %tobool, label %if.end, label %if.then
  83
  84   if.then:                                          ; preds = %entry
  85     %call = tail call i32 @foo() #2
  86     br label %return
  87
  88   if.end:                                           ; preds = %entry
  89     %call1 = tail call i32 @bar() #2
  90     br label %return
  91
  92   return:                                           ; preds = %if.end, %if.then
  93     %retval.0 = phi i32 [ %call, %if.then ], [ %call1, %if.end ]
  94     ret i32 %retval.0
  95   }
  96
  97   declare i32 @foo()
  98   declare i32 @bar()
  99 )";
 100
 101 extern "C" int32_t return1() { return 1; }
 102 extern "C" int32_t return2() { return 2; }
 103
 104 static void *reenter(void *Ctx, void *TrampolineAddr) {
 105   std::promise<void *> LandingAddressP;
 106   auto LandingAddressF = LandingAddressP.get_future();
 107
 108   auto *EPCIU = static_cast<EPCIndirectionUtils *>(Ctx);
 109   EPCIU->getLazyCallThroughManager().resolveTrampolineLandingAddress(
 110       pointerToJITTargetAddress(TrampolineAddr),
 111       [&](JITTargetAddress LandingAddress) {
 112         LandingAddressP.set_value(
 113             jitTargetAddressToPointer<void *>(LandingAddress));
 114       });
 115   return LandingAddressF.get();
 116 }
 117
 118 static void reportErrorAndExit() {
 119   errs() << "Unable to lazily compile function. Exiting.\n";
 120   exit(1);
 121 }
 122
 123 cl::list<std::string> InputArgv(cl::Positional,
 124                                 cl::desc("<program arguments>..."));
 125
 126 int main(int argc, char *argv[]) {
 127   // Initialize LLVM.
 128   InitLLVM X(argc, argv);
 129
 130   InitializeNativeTarget();
 131   InitializeNativeTargetAsmPrinter();
 132
 133   cl::ParseCommandLineOptions(argc, argv, "LLJITWithLazyReexports");
 134   ExitOnErr.setBanner(std::string(argv[0]) + ": ");
 135
 136   // (1) Create LLJIT instance.
 137   auto EPC = ExitOnErr(SelfExecutorProcessControl::Create());
 138   auto J = ExitOnErr(
 139       LLJITBuilder().setExecutorProcessControl(std::move(EPC)).create());
 140
 141   // (2) Install transform to print modules as they are compiled:
 142   J->getIRTransformLayer().setTransform(
 143       [](ThreadSafeModule TSM,
 144          const MaterializationResponsibility &R) -> Expected<ThreadSafeModule> {
 145         TSM.withModuleDo([](Module &M) { dbgs() << "---Compiling---\n" << M; });
 146         return std::move(TSM); // Not a redundant move: fix build on gcc-7.5
 147       });
 148
 149   // (3) Create stubs and call-through managers:
 150   auto EPCIU = ExitOnErr(EPCIndirectionUtils::Create(*EPC));
 151   ExitOnErr(EPCIU->writeResolverBlock(pointerToJITTargetAddress(&reenter),
 152                                       pointerToJITTargetAddress(EPCIU.get())));
 153   EPCIU->createLazyCallThroughManager(
 154       J->getExecutionSession(), pointerToJITTargetAddress(&reportErrorAndExit));
 155   auto ISM = EPCIU->createIndirectStubsManager();
 156   J->getMainJITDylib().addGenerator(
 157       ExitOnErr(EPCDynamicLibrarySearchGenerator::GetForTargetProcess(
 158           J->getExecutionSession())));
 159
 160   // (4) Add modules.
 161   ExitOnErr(J->addIRModule(ExitOnErr(parseExampleModule(FooMod, "foo-mod"))));
 162   ExitOnErr(J->addIRModule(ExitOnErr(parseExampleModule(BarMod, "bar-mod"))));
 163   ExitOnErr(J->addIRModule(ExitOnErr(parseExampleModule(MainMod, "main-mod"))));
 164
 165   // (5) Add lazy reexports.
 166   MangleAndInterner Mangle(J->getExecutionSession(), J->getDataLayout());
 167   SymbolAliasMap ReExports(
 168       {{Mangle("foo"),
 169         {Mangle("foo_body"),
 170          JITSymbolFlags::Exported | JITSymbolFlags::Callable}},
 171        {Mangle("bar"),
 172         {Mangle("bar_body"),
 173          JITSymbolFlags::Exported | JITSymbolFlags::Callable}}});
 174   ExitOnErr(J->getMainJITDylib().define(
 175       lazyReexports(EPCIU->getLazyCallThroughManager(), *ISM,
 176                     J->getMainJITDylib(), std::move(ReExports))));
 177
 178   // (6) Dump the ExecutionSession state.
 179   dbgs() << "---Session state---\n";
 180   J->getExecutionSession().dump(dbgs());
 181   dbgs() << "\n";
 182
 183   // (7) Execute the JIT'd main function and pass the example's command line
 184   // arguments unmodified. This should cause either ExampleMod1 or ExampleMod2
 185   // to be compiled, and either "1" or "2" returned depending on the number of
 186   // arguments passed.
 187
 188   // Look up the JIT'd function, cast it to a function pointer, then call it.
 189   auto EntrySym = ExitOnErr(J->lookup("entry"));
 190   auto *Entry = (int (*)(int))EntrySym.getAddress();
 191
 192   int Result = Entry(argc);
 193   outs() << "---Result---\n"
 194          << "entry(" << argc << ") = " << Result << "\n";
 195
 196   return 0;
 197 }