1 //===--------- LLJIT.cpp - An ORC-based JIT for compiling LLVM IR ---------===//
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 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
10 #include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
11 #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
12 #include "llvm/ExecutionEngine/Orc/OrcError.h"
13 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
14 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
15 #include "llvm/IR/Mangler.h"
16 
17 namespace llvm {
18 namespace orc {
19 
20 Error LLJITBuilderState::prepareForConstruction() {
21 
22   if (!JTMB) {
23     if (auto JTMBOrErr = JITTargetMachineBuilder::detectHost())
24       JTMB = std::move(*JTMBOrErr);
25     else
26       return JTMBOrErr.takeError();
27   }
28 
29   // If the client didn't configure any linker options then auto-configure the
30   // JIT linker.
31   if (!CreateObjectLinkingLayer && JTMB->getCodeModel() == None &&
32       JTMB->getRelocationModel() == None) {
33 
34     auto &TT = JTMB->getTargetTriple();
35     if (TT.isOSBinFormatMachO() &&
36         (TT.getArch() == Triple::aarch64 || TT.getArch() == Triple::x86_64)) {
37 
38       JTMB->setRelocationModel(Reloc::PIC_);
39       JTMB->setCodeModel(CodeModel::Small);
40       CreateObjectLinkingLayer =
41           [](ExecutionSession &ES,
42              const Triple &) -> std::unique_ptr<ObjectLayer> {
43         return std::make_unique<ObjectLinkingLayer>(
44             ES, std::make_unique<jitlink::InProcessMemoryManager>());
45       };
46     }
47   }
48 
49   return Error::success();
50 }
51 
52 LLJIT::~LLJIT() {
53   if (CompileThreads)
54     CompileThreads->wait();
55 }
56 
57 Error LLJIT::defineAbsolute(StringRef Name, JITEvaluatedSymbol Sym) {
58   auto InternedName = ES->intern(Name);
59   SymbolMap Symbols({{InternedName, Sym}});
60   return Main.define(absoluteSymbols(std::move(Symbols)));
61 }
62 
63 Error LLJIT::addIRModule(JITDylib &JD, ThreadSafeModule TSM) {
64   assert(TSM && "Can not add null module");
65 
66   if (auto Err =
67           TSM.withModuleDo([&](Module &M) { return applyDataLayout(M); }))
68     return Err;
69 
70   return TransformLayer->add(JD, std::move(TSM), ES->allocateVModule());
71 }
72 
73 Error LLJIT::addObjectFile(JITDylib &JD, std::unique_ptr<MemoryBuffer> Obj) {
74   assert(Obj && "Can not add null object");
75 
76   return ObjTransformLayer.add(JD, std::move(Obj), ES->allocateVModule());
77 }
78 
79 Expected<JITEvaluatedSymbol> LLJIT::lookupLinkerMangled(JITDylib &JD,
80                                                         StringRef Name) {
81   return ES->lookup(
82       makeJITDylibSearchOrder(&JD, JITDylibLookupFlags::MatchAllSymbols),
83       ES->intern(Name));
84 }
85 
86 std::unique_ptr<ObjectLayer>
87 LLJIT::createObjectLinkingLayer(LLJITBuilderState &S, ExecutionSession &ES) {
88 
89   // If the config state provided an ObjectLinkingLayer factory then use it.
90   if (S.CreateObjectLinkingLayer)
91     return S.CreateObjectLinkingLayer(ES, S.JTMB->getTargetTriple());
92 
93   // Otherwise default to creating an RTDyldObjectLinkingLayer that constructs
94   // a new SectionMemoryManager for each object.
95   auto GetMemMgr = []() { return std::make_unique<SectionMemoryManager>(); };
96   auto ObjLinkingLayer =
97       std::make_unique<RTDyldObjectLinkingLayer>(ES, std::move(GetMemMgr));
98 
99   if (S.JTMB->getTargetTriple().isOSBinFormatCOFF()) {
100     ObjLinkingLayer->setOverrideObjectFlagsWithResponsibilityFlags(true);
101     ObjLinkingLayer->setAutoClaimResponsibilityForObjectSymbols(true);
102   }
103 
104   // FIXME: Explicit conversion to std::unique_ptr<ObjectLayer> added to silence
105   //        errors from some GCC / libstdc++ bots. Remove this conversion (i.e.
106   //        just return ObjLinkingLayer) once those bots are upgraded.
107   return std::unique_ptr<ObjectLayer>(std::move(ObjLinkingLayer));
108 }
109 
110 Expected<std::unique_ptr<IRCompileLayer::IRCompiler>>
111 LLJIT::createCompileFunction(LLJITBuilderState &S,
112                              JITTargetMachineBuilder JTMB) {
113 
114   /// If there is a custom compile function creator set then use it.
115   if (S.CreateCompileFunction)
116     return S.CreateCompileFunction(std::move(JTMB));
117 
118   // Otherwise default to creating a SimpleCompiler, or ConcurrentIRCompiler,
119   // depending on the number of threads requested.
120   if (S.NumCompileThreads > 0)
121     return std::make_unique<ConcurrentIRCompiler>(std::move(JTMB));
122 
123   auto TM = JTMB.createTargetMachine();
124   if (!TM)
125     return TM.takeError();
126 
127   return std::make_unique<TMOwningSimpleCompiler>(std::move(*TM));
128 }
129 
130 LLJIT::LLJIT(LLJITBuilderState &S, Error &Err)
131     : ES(S.ES ? std::move(S.ES) : std::make_unique<ExecutionSession>()),
132       Main(this->ES->createJITDylib("<main>")), DL(""),
133       TT(S.JTMB->getTargetTriple()),
134       ObjLinkingLayer(createObjectLinkingLayer(S, *ES)),
135       ObjTransformLayer(*this->ES, *ObjLinkingLayer), CtorRunner(Main),
136       DtorRunner(Main) {
137 
138   ErrorAsOutParameter _(&Err);
139 
140   if (auto DLOrErr = S.JTMB->getDefaultDataLayoutForTarget())
141     DL = std::move(*DLOrErr);
142   else {
143     Err = DLOrErr.takeError();
144     return;
145   }
146 
147   {
148     auto CompileFunction = createCompileFunction(S, std::move(*S.JTMB));
149     if (!CompileFunction) {
150       Err = CompileFunction.takeError();
151       return;
152     }
153     CompileLayer = std::make_unique<IRCompileLayer>(
154         *ES, ObjTransformLayer, std::move(*CompileFunction));
155     TransformLayer = std::make_unique<IRTransformLayer>(*ES, *CompileLayer);
156   }
157 
158   if (S.NumCompileThreads > 0) {
159     TransformLayer->setCloneToNewContextOnEmit(true);
160     CompileThreads =
161         std::make_unique<ThreadPool>(hardware_concurrency(S.NumCompileThreads));
162     ES->setDispatchMaterialization(
163         [this](JITDylib &JD, std::unique_ptr<MaterializationUnit> MU) {
164           // FIXME: Switch to move capture once we have c++14.
165           auto SharedMU = std::shared_ptr<MaterializationUnit>(std::move(MU));
166           auto Work = [SharedMU, &JD]() { SharedMU->doMaterialize(JD); };
167           CompileThreads->async(std::move(Work));
168         });
169   }
170 }
171 
172 std::string LLJIT::mangle(StringRef UnmangledName) {
173   std::string MangledName;
174   {
175     raw_string_ostream MangledNameStream(MangledName);
176     Mangler::getNameWithPrefix(MangledNameStream, UnmangledName, DL);
177   }
178   return MangledName;
179 }
180 
181 Error LLJIT::applyDataLayout(Module &M) {
182   if (M.getDataLayout().isDefault())
183     M.setDataLayout(DL);
184 
185   if (M.getDataLayout() != DL)
186     return make_error<StringError>(
187         "Added modules have incompatible data layouts",
188         inconvertibleErrorCode());
189 
190   return Error::success();
191 }
192 
193 void LLJIT::recordCtorDtors(Module &M) {
194   CtorRunner.add(getConstructors(M));
195   DtorRunner.add(getDestructors(M));
196 }
197 
198 Error LLLazyJITBuilderState::prepareForConstruction() {
199   if (auto Err = LLJITBuilderState::prepareForConstruction())
200     return Err;
201   TT = JTMB->getTargetTriple();
202   return Error::success();
203 }
204 
205 Error LLLazyJIT::addLazyIRModule(JITDylib &JD, ThreadSafeModule TSM) {
206   assert(TSM && "Can not add null module");
207 
208   if (auto Err = TSM.withModuleDo([&](Module &M) -> Error {
209         if (auto Err = applyDataLayout(M))
210           return Err;
211 
212         recordCtorDtors(M);
213         return Error::success();
214       }))
215     return Err;
216 
217   return CODLayer->add(JD, std::move(TSM), ES->allocateVModule());
218 }
219 
220 LLLazyJIT::LLLazyJIT(LLLazyJITBuilderState &S, Error &Err) : LLJIT(S, Err) {
221 
222   // If LLJIT construction failed then bail out.
223   if (Err)
224     return;
225 
226   ErrorAsOutParameter _(&Err);
227 
228   /// Take/Create the lazy-compile callthrough manager.
229   if (S.LCTMgr)
230     LCTMgr = std::move(S.LCTMgr);
231   else {
232     if (auto LCTMgrOrErr = createLocalLazyCallThroughManager(
233             S.TT, *ES, S.LazyCompileFailureAddr))
234       LCTMgr = std::move(*LCTMgrOrErr);
235     else {
236       Err = LCTMgrOrErr.takeError();
237       return;
238     }
239   }
240 
241   // Take/Create the indirect stubs manager builder.
242   auto ISMBuilder = std::move(S.ISMBuilder);
243 
244   // If none was provided, try to build one.
245   if (!ISMBuilder)
246     ISMBuilder = createLocalIndirectStubsManagerBuilder(S.TT);
247 
248   // No luck. Bail out.
249   if (!ISMBuilder) {
250     Err = make_error<StringError>("Could not construct "
251                                   "IndirectStubsManagerBuilder for target " +
252                                       S.TT.str(),
253                                   inconvertibleErrorCode());
254     return;
255   }
256 
257   // Create the COD layer.
258   CODLayer = std::make_unique<CompileOnDemandLayer>(
259       *ES, *TransformLayer, *LCTMgr, std::move(ISMBuilder));
260 
261   if (S.NumCompileThreads > 0)
262     CODLayer->setCloneToNewContextOnEmit(true);
263 }
264 
265 } // End namespace orc.
266 } // End namespace llvm.
267