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/TPCDynamicLibrarySearchGenerator.h"
29 #include "llvm/ExecutionEngine/Orc/TPCIndirectionUtils.h"
30 #include "llvm/ExecutionEngine/Orc/TargetProcessControl.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
return1()101 extern "C" int32_t return1() { return 1; }
return2()102 extern "C" int32_t return2() { return 2; }
103
reenter(void * Ctx,void * TrampolineAddr)104 static void *reenter(void *Ctx, void *TrampolineAddr) {
105 std::promise<void *> LandingAddressP;
106 auto LandingAddressF = LandingAddressP.get_future();
107
108 auto *TPCIU = static_cast<TPCIndirectionUtils *>(Ctx);
109 TPCIU->getLazyCallThroughManager().resolveTrampolineLandingAddress(
110 pointerToJITTargetAddress(TrampolineAddr),
111 [&](JITTargetAddress LandingAddress) {
112 LandingAddressP.set_value(
113 jitTargetAddressToPointer<void *>(LandingAddress));
114 });
115 return LandingAddressF.get();
116 }
117
reportErrorAndExit()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
main(int argc,char * argv[])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 TPC = ExitOnErr(SelfTargetProcessControl::Create());
138 auto J = ExitOnErr(LLJITBuilder().setTargetProcessControl(*TPC).create());
139
140 // (2) Install transform to print modules as they are compiled:
141 J->getIRTransformLayer().setTransform(
142 [](ThreadSafeModule TSM,
143 const MaterializationResponsibility &R) -> Expected<ThreadSafeModule> {
144 TSM.withModuleDo([](Module &M) { dbgs() << "---Compiling---\n" << M; });
145 return std::move(TSM); // Not a redundant move: fix build on gcc-7.5
146 });
147
148 // (3) Create stubs and call-through managers:
149 auto TPCIU = ExitOnErr(TPCIndirectionUtils::Create(*TPC));
150 ExitOnErr(TPCIU->writeResolverBlock(pointerToJITTargetAddress(&reenter),
151 pointerToJITTargetAddress(TPCIU.get())));
152 TPCIU->createLazyCallThroughManager(
153 J->getExecutionSession(), pointerToJITTargetAddress(&reportErrorAndExit));
154 auto ISM = TPCIU->createIndirectStubsManager();
155 J->getMainJITDylib().addGenerator(
156 ExitOnErr(TPCDynamicLibrarySearchGenerator::GetForTargetProcess(*TPC)));
157
158 // (4) Add modules.
159 ExitOnErr(J->addIRModule(ExitOnErr(parseExampleModule(FooMod, "foo-mod"))));
160 ExitOnErr(J->addIRModule(ExitOnErr(parseExampleModule(BarMod, "bar-mod"))));
161 ExitOnErr(J->addIRModule(ExitOnErr(parseExampleModule(MainMod, "main-mod"))));
162
163 // (5) Add lazy reexports.
164 MangleAndInterner Mangle(J->getExecutionSession(), J->getDataLayout());
165 SymbolAliasMap ReExports(
166 {{Mangle("foo"),
167 {Mangle("foo_body"),
168 JITSymbolFlags::Exported | JITSymbolFlags::Callable}},
169 {Mangle("bar"),
170 {Mangle("bar_body"),
171 JITSymbolFlags::Exported | JITSymbolFlags::Callable}}});
172 ExitOnErr(J->getMainJITDylib().define(
173 lazyReexports(TPCIU->getLazyCallThroughManager(), *ISM,
174 J->getMainJITDylib(), std::move(ReExports))));
175
176 // (6) Dump the ExecutionSession state.
177 dbgs() << "---Session state---\n";
178 J->getExecutionSession().dump(dbgs());
179 dbgs() << "\n";
180
181 // (7) Execute the JIT'd main function and pass the example's command line
182 // arguments unmodified. This should cause either ExampleMod1 or ExampleMod2
183 // to be compiled, and either "1" or "2" returned depending on the number of
184 // arguments passed.
185
186 // Look up the JIT'd function, cast it to a function pointer, then call it.
187 auto EntrySym = ExitOnErr(J->lookup("entry"));
188 auto *Entry = (int (*)(int))EntrySym.getAddress();
189
190 int Result = Entry(argc);
191 outs() << "---Result---\n"
192 << "entry(" << argc << ") = " << Result << "\n";
193
194 return 0;
195 }
196