|
| 1 | +//===--- LLJITWithLazyReexports.cpp - LLJIT example with custom laziness --===// |
| 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/LLJIT.h" |
| 26 | +#include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h" |
| 27 | +#include "llvm/ExecutionEngine/Orc/OrcABISupport.h" |
| 28 | +#include "llvm/ExecutionEngine/Orc/TPCIndirectionUtils.h" |
| 29 | +#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h" |
| 30 | +#include "llvm/Support/InitLLVM.h" |
| 31 | +#include "llvm/Support/TargetSelect.h" |
| 32 | +#include "llvm/Support/raw_ostream.h" |
| 33 | + |
| 34 | +#include "../ExampleModules.h" |
| 35 | + |
| 36 | +#include <future> |
| 37 | + |
| 38 | +using namespace llvm; |
| 39 | +using namespace llvm::orc; |
| 40 | + |
| 41 | +ExitOnError ExitOnErr; |
| 42 | + |
| 43 | +// Example IR modules. |
| 44 | +// |
| 45 | +// Note that in the conditionally compiled modules, FooMod and BarMod, functions |
| 46 | +// have been given an _body suffix. This is to ensure that their names do not |
| 47 | +// clash with their lazy-reexports. |
| 48 | +// For clients who do not wish to rename function bodies (e.g. because they want |
| 49 | +// to re-use cached objects between static and JIT compiles) techniques exist to |
| 50 | +// avoid renaming. See the lazy-reexports section of the ORCv2 design doc. |
| 51 | + |
| 52 | +const llvm::StringRef FooMod = |
| 53 | + R"( |
| 54 | + define i32 @foo_body() { |
| 55 | + entry: |
| 56 | + ret i32 1 |
| 57 | + } |
| 58 | +)"; |
| 59 | + |
| 60 | +const llvm::StringRef BarMod = |
| 61 | + R"( |
| 62 | + define i32 @bar_body() { |
| 63 | + entry: |
| 64 | + ret i32 2 |
| 65 | + } |
| 66 | +)"; |
| 67 | + |
| 68 | +const llvm::StringRef MainMod = |
| 69 | + R"( |
| 70 | +
|
| 71 | + define i32 @entry(i32 %argc) { |
| 72 | + entry: |
| 73 | + %and = and i32 %argc, 1 |
| 74 | + %tobool = icmp eq i32 %and, 0 |
| 75 | + br i1 %tobool, label %if.end, label %if.then |
| 76 | +
|
| 77 | + if.then: ; preds = %entry |
| 78 | + %call = tail call i32 @foo() #2 |
| 79 | + br label %return |
| 80 | +
|
| 81 | + if.end: ; preds = %entry |
| 82 | + %call1 = tail call i32 @bar() #2 |
| 83 | + br label %return |
| 84 | +
|
| 85 | + return: ; preds = %if.end, %if.then |
| 86 | + %retval.0 = phi i32 [ %call, %if.then ], [ %call1, %if.end ] |
| 87 | + ret i32 %retval.0 |
| 88 | + } |
| 89 | +
|
| 90 | + declare i32 @foo() |
| 91 | + declare i32 @bar() |
| 92 | +)"; |
| 93 | + |
| 94 | +static void *reenter(void *Ctx, void *TrampolineAddr) { |
| 95 | + std::promise<void *> LandingAddressP; |
| 96 | + auto LandingAddressF = LandingAddressP.get_future(); |
| 97 | + |
| 98 | + auto *TPCIU = static_cast<TPCIndirectionUtils *>(Ctx); |
| 99 | + TPCIU->getLazyCallThroughManager().resolveTrampolineLandingAddress( |
| 100 | + pointerToJITTargetAddress(TrampolineAddr), |
| 101 | + [&](JITTargetAddress LandingAddress) { |
| 102 | + LandingAddressP.set_value( |
| 103 | + jitTargetAddressToPointer<void *>(LandingAddress)); |
| 104 | + }); |
| 105 | + return LandingAddressF.get(); |
| 106 | +} |
| 107 | + |
| 108 | +cl::list<std::string> InputArgv(cl::Positional, |
| 109 | + cl::desc("<program arguments>...")); |
| 110 | + |
| 111 | +int main(int argc, char *argv[]) { |
| 112 | + // Initialize LLVM. |
| 113 | + InitLLVM X(argc, argv); |
| 114 | + |
| 115 | + InitializeNativeTarget(); |
| 116 | + InitializeNativeTargetAsmPrinter(); |
| 117 | + |
| 118 | + cl::ParseCommandLineOptions(argc, argv, "LLJITWithLazyReexports"); |
| 119 | + ExitOnErr.setBanner(std::string(argv[0]) + ": "); |
| 120 | + |
| 121 | + // (1) Create LLJIT instance. |
| 122 | + auto J = ExitOnErr(LLJITBuilder().create()); |
| 123 | + |
| 124 | + // (2) Install transform to print modules as they are compiled: |
| 125 | + J->getIRTransformLayer().setTransform( |
| 126 | + [](ThreadSafeModule TSM, |
| 127 | + const MaterializationResponsibility &R) -> Expected<ThreadSafeModule> { |
| 128 | + TSM.withModuleDo([](Module &M) { dbgs() << "---Compiling---\n" << M; }); |
| 129 | + return std::move(TSM); // Not a redundant move: fix build on gcc-7.5 |
| 130 | + }); |
| 131 | + |
| 132 | + // (3) Create stubs and call-through managers: |
| 133 | + |
| 134 | + auto TPC = ExitOnErr(SelfTargetProcessControl::Create()); |
| 135 | + auto TPCIU = ExitOnErr(TPCIndirectionUtils::Create(*TPC)); |
| 136 | + ExitOnErr(TPCIU->writeResolverBlock(pointerToJITTargetAddress(&reenter), |
| 137 | + pointerToJITTargetAddress(TPCIU.get()))); |
| 138 | + TPCIU->createLazyCallThroughManager(J->getExecutionSession(), 0); |
| 139 | + auto ISM = TPCIU->createIndirectStubsManager(); |
| 140 | + |
| 141 | + // (4) Add modules. |
| 142 | + ExitOnErr(J->addIRModule(ExitOnErr(parseExampleModule(FooMod, "foo-mod")))); |
| 143 | + ExitOnErr(J->addIRModule(ExitOnErr(parseExampleModule(BarMod, "bar-mod")))); |
| 144 | + ExitOnErr(J->addIRModule(ExitOnErr(parseExampleModule(MainMod, "main-mod")))); |
| 145 | + |
| 146 | + // (5) Add lazy reexports. |
| 147 | + MangleAndInterner Mangle(J->getExecutionSession(), J->getDataLayout()); |
| 148 | + SymbolAliasMap ReExports( |
| 149 | + {{Mangle("foo"), |
| 150 | + {Mangle("foo_body"), |
| 151 | + JITSymbolFlags::Exported | JITSymbolFlags::Callable}}, |
| 152 | + {Mangle("bar"), |
| 153 | + {Mangle("bar_body"), |
| 154 | + JITSymbolFlags::Exported | JITSymbolFlags::Callable}}}); |
| 155 | + ExitOnErr(J->getMainJITDylib().define( |
| 156 | + lazyReexports(TPCIU->getLazyCallThroughManager(), *ISM, |
| 157 | + J->getMainJITDylib(), std::move(ReExports)))); |
| 158 | + |
| 159 | + // (6) Dump the ExecutionSession state. |
| 160 | + dbgs() << "---Session state---\n"; |
| 161 | + J->getExecutionSession().dump(dbgs()); |
| 162 | + dbgs() << "\n"; |
| 163 | + |
| 164 | + // (7) Execute the JIT'd main function and pass the example's command line |
| 165 | + // arguments unmodified. This should cause either ExampleMod1 or ExampleMod2 |
| 166 | + // to be compiled, and either "1" or "2" returned depending on the number of |
| 167 | + // arguments passed. |
| 168 | + |
| 169 | + // Look up the JIT'd function, cast it to a function pointer, then call it. |
| 170 | + auto EntrySym = ExitOnErr(J->lookup("entry")); |
| 171 | + auto *Entry = (int (*)(int))EntrySym.getAddress(); |
| 172 | + |
| 173 | + int Result = Entry(argc); |
| 174 | + outs() << "---Result---\n" |
| 175 | + << "entry(" << argc << ") = " << Result << "\n"; |
| 176 | + |
| 177 | + return 0; |
| 178 | +} |
0 commit comments