xref: /freebsd/contrib/llvm-project/llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp (revision 77013d11e6483b970af25e13c9b892075742f7e5) 
1 //===---- ExecutionUtils.cpp - Utilities for executing functions in Orc ---===//
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/ExecutionUtils.h"
10 
11 #include "llvm/ExecutionEngine/Orc/Layer.h"
12 #include "llvm/IR/Constants.h"
13 #include "llvm/IR/Function.h"
14 #include "llvm/IR/GlobalVariable.h"
15 #include "llvm/IR/Module.h"
16 #include "llvm/Object/MachOUniversal.h"
17 #include "llvm/Support/FormatVariadic.h"
18 #include "llvm/Support/TargetRegistry.h"
19 #include "llvm/Target/TargetMachine.h"
20 
21 namespace llvm {
22 namespace orc {
23 
24 CtorDtorIterator::CtorDtorIterator(const GlobalVariable *GV, bool End)
25   : InitList(
26       GV ? dyn_cast_or_null<ConstantArray>(GV->getInitializer()) : nullptr),
27     I((InitList && End) ? InitList->getNumOperands() : 0) {
28 }
29 
30 bool CtorDtorIterator::operator==(const CtorDtorIterator &Other) const {
31   assert(InitList == Other.InitList && "Incomparable iterators.");
32   return I == Other.I;
33 }
34 
35 bool CtorDtorIterator::operator!=(const CtorDtorIterator &Other) const {
36   return !(*this == Other);
37 }
38 
39 CtorDtorIterator& CtorDtorIterator::operator++() {
40   ++I;
41   return *this;
42 }
43 
44 CtorDtorIterator CtorDtorIterator::operator++(int) {
45   CtorDtorIterator Temp = *this;
46   ++I;
47   return Temp;
48 }
49 
50 CtorDtorIterator::Element CtorDtorIterator::operator*() const {
51   ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(I));
52   assert(CS && "Unrecognized type in llvm.global_ctors/llvm.global_dtors");
53 
54   Constant *FuncC = CS->getOperand(1);
55   Function *Func = nullptr;
56 
57   // Extract function pointer, pulling off any casts.
58   while (FuncC) {
59     if (Function *F = dyn_cast_or_null<Function>(FuncC)) {
60       Func = F;
61       break;
62     } else if (ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(FuncC)) {
63       if (CE->isCast())
64         FuncC = dyn_cast_or_null<ConstantExpr>(CE->getOperand(0));
65       else
66         break;
67     } else {
68       // This isn't anything we recognize. Bail out with Func left set to null.
69       break;
70     }
71   }
72 
73   auto *Priority = cast<ConstantInt>(CS->getOperand(0));
74   Value *Data = CS->getNumOperands() == 3 ? CS->getOperand(2) : nullptr;
75   if (Data && !isa<GlobalValue>(Data))
76     Data = nullptr;
77   return Element(Priority->getZExtValue(), Func, Data);
78 }
79 
80 iterator_range<CtorDtorIterator> getConstructors(const Module &M) {
81   const GlobalVariable *CtorsList = M.getNamedGlobal("llvm.global_ctors");
82   return make_range(CtorDtorIterator(CtorsList, false),
83                     CtorDtorIterator(CtorsList, true));
84 }
85 
86 iterator_range<CtorDtorIterator> getDestructors(const Module &M) {
87   const GlobalVariable *DtorsList = M.getNamedGlobal("llvm.global_dtors");
88   return make_range(CtorDtorIterator(DtorsList, false),
89                     CtorDtorIterator(DtorsList, true));
90 }
91 
92 bool StaticInitGVIterator::isStaticInitGlobal(GlobalValue &GV) {
93   if (GV.isDeclaration())
94     return false;
95 
96   if (GV.hasName() && (GV.getName() == "llvm.global_ctors" ||
97                        GV.getName() == "llvm.global_dtors"))
98     return true;
99 
100   if (ObjFmt == Triple::MachO) {
101     // FIXME: These section checks are too strict: We should match first and
102     // second word split by comma.
103     if (GV.hasSection() &&
104         (GV.getSection().startswith("__DATA,__objc_classlist") ||
105          GV.getSection().startswith("__DATA,__objc_selrefs")))
106       return true;
107   }
108 
109   return false;
110 }
111 
112 void CtorDtorRunner::add(iterator_range<CtorDtorIterator> CtorDtors) {
113   if (CtorDtors.empty())
114     return;
115 
116   MangleAndInterner Mangle(
117       JD.getExecutionSession(),
118       (*CtorDtors.begin()).Func->getParent()->getDataLayout());
119 
120   for (auto CtorDtor : CtorDtors) {
121     assert(CtorDtor.Func && CtorDtor.Func->hasName() &&
122            "Ctor/Dtor function must be named to be runnable under the JIT");
123 
124     // FIXME: Maybe use a symbol promoter here instead.
125     if (CtorDtor.Func->hasLocalLinkage()) {
126       CtorDtor.Func->setLinkage(GlobalValue::ExternalLinkage);
127       CtorDtor.Func->setVisibility(GlobalValue::HiddenVisibility);
128     }
129 
130     if (CtorDtor.Data && cast<GlobalValue>(CtorDtor.Data)->isDeclaration()) {
131       dbgs() << "  Skipping because why now?\n";
132       continue;
133     }
134 
135     CtorDtorsByPriority[CtorDtor.Priority].push_back(
136         Mangle(CtorDtor.Func->getName()));
137   }
138 }
139 
140 Error CtorDtorRunner::run() {
141   using CtorDtorTy = void (*)();
142 
143   SymbolLookupSet LookupSet;
144   for (auto &KV : CtorDtorsByPriority)
145     for (auto &Name : KV.second)
146       LookupSet.add(Name);
147   assert(!LookupSet.containsDuplicates() &&
148          "Ctor/Dtor list contains duplicates");
149 
150   auto &ES = JD.getExecutionSession();
151   if (auto CtorDtorMap = ES.lookup(
152           makeJITDylibSearchOrder(&JD, JITDylibLookupFlags::MatchAllSymbols),
153           std::move(LookupSet))) {
154     for (auto &KV : CtorDtorsByPriority) {
155       for (auto &Name : KV.second) {
156         assert(CtorDtorMap->count(Name) && "No entry for Name");
157         auto CtorDtor = reinterpret_cast<CtorDtorTy>(
158             static_cast<uintptr_t>((*CtorDtorMap)[Name].getAddress()));
159         CtorDtor();
160       }
161     }
162     CtorDtorsByPriority.clear();
163     return Error::success();
164   } else
165     return CtorDtorMap.takeError();
166 }
167 
168 void LocalCXXRuntimeOverridesBase::runDestructors() {
169   auto& CXXDestructorDataPairs = DSOHandleOverride;
170   for (auto &P : CXXDestructorDataPairs)
171     P.first(P.second);
172   CXXDestructorDataPairs.clear();
173 }
174 
175 int LocalCXXRuntimeOverridesBase::CXAAtExitOverride(DestructorPtr Destructor,
176                                                     void *Arg,
177                                                     void *DSOHandle) {
178   auto& CXXDestructorDataPairs =
179     *reinterpret_cast<CXXDestructorDataPairList*>(DSOHandle);
180   CXXDestructorDataPairs.push_back(std::make_pair(Destructor, Arg));
181   return 0;
182 }
183 
184 Error LocalCXXRuntimeOverrides::enable(JITDylib &JD,
185                                         MangleAndInterner &Mangle) {
186   SymbolMap RuntimeInterposes;
187   RuntimeInterposes[Mangle("__dso_handle")] =
188     JITEvaluatedSymbol(toTargetAddress(&DSOHandleOverride),
189                        JITSymbolFlags::Exported);
190   RuntimeInterposes[Mangle("__cxa_atexit")] =
191     JITEvaluatedSymbol(toTargetAddress(&CXAAtExitOverride),
192                        JITSymbolFlags::Exported);
193 
194   return JD.define(absoluteSymbols(std::move(RuntimeInterposes)));
195 }
196 
197 void ItaniumCXAAtExitSupport::registerAtExit(void (*F)(void *), void *Ctx,
198                                              void *DSOHandle) {
199   std::lock_guard<std::mutex> Lock(AtExitsMutex);
200   AtExitRecords[DSOHandle].push_back({F, Ctx});
201 }
202 
203 void ItaniumCXAAtExitSupport::runAtExits(void *DSOHandle) {
204   std::vector<AtExitRecord> AtExitsToRun;
205 
206   {
207     std::lock_guard<std::mutex> Lock(AtExitsMutex);
208     auto I = AtExitRecords.find(DSOHandle);
209     if (I != AtExitRecords.end()) {
210       AtExitsToRun = std::move(I->second);
211       AtExitRecords.erase(I);
212     }
213   }
214 
215   while (!AtExitsToRun.empty()) {
216     AtExitsToRun.back().F(AtExitsToRun.back().Ctx);
217     AtExitsToRun.pop_back();
218   }
219 }
220 
221 DynamicLibrarySearchGenerator::DynamicLibrarySearchGenerator(
222     sys::DynamicLibrary Dylib, char GlobalPrefix, SymbolPredicate Allow)
223     : Dylib(std::move(Dylib)), Allow(std::move(Allow)),
224       GlobalPrefix(GlobalPrefix) {}
225 
226 Expected<std::unique_ptr<DynamicLibrarySearchGenerator>>
227 DynamicLibrarySearchGenerator::Load(const char *FileName, char GlobalPrefix,
228                                     SymbolPredicate Allow) {
229   std::string ErrMsg;
230   auto Lib = sys::DynamicLibrary::getPermanentLibrary(FileName, &ErrMsg);
231   if (!Lib.isValid())
232     return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
233   return std::make_unique<DynamicLibrarySearchGenerator>(
234       std::move(Lib), GlobalPrefix, std::move(Allow));
235 }
236 
237 Error DynamicLibrarySearchGenerator::tryToGenerate(
238     LookupState &LS, LookupKind K, JITDylib &JD,
239     JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &Symbols) {
240   orc::SymbolMap NewSymbols;
241 
242   bool HasGlobalPrefix = (GlobalPrefix != '\0');
243 
244   for (auto &KV : Symbols) {
245     auto &Name = KV.first;
246 
247     if ((*Name).empty())
248       continue;
249 
250     if (Allow && !Allow(Name))
251       continue;
252 
253     if (HasGlobalPrefix && (*Name).front() != GlobalPrefix)
254       continue;
255 
256     std::string Tmp((*Name).data() + HasGlobalPrefix,
257                     (*Name).size() - HasGlobalPrefix);
258     if (void *Addr = Dylib.getAddressOfSymbol(Tmp.c_str())) {
259       NewSymbols[Name] = JITEvaluatedSymbol(
260           static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(Addr)),
261           JITSymbolFlags::Exported);
262     }
263   }
264 
265   if (NewSymbols.empty())
266     return Error::success();
267 
268   return JD.define(absoluteSymbols(std::move(NewSymbols)));
269 }
270 
271 Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>>
272 StaticLibraryDefinitionGenerator::Load(ObjectLayer &L, const char *FileName) {
273   auto ArchiveBuffer = errorOrToExpected(MemoryBuffer::getFile(FileName));
274 
275   if (!ArchiveBuffer)
276     return ArchiveBuffer.takeError();
277 
278   return Create(L, std::move(*ArchiveBuffer));
279 }
280 
281 Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>>
282 StaticLibraryDefinitionGenerator::Load(ObjectLayer &L, const char *FileName,
283                                        const Triple &TT) {
284   auto B = object::createBinary(FileName);
285   if (!B)
286     return B.takeError();
287 
288   // If this is a regular archive then create an instance from it.
289   if (isa<object::Archive>(B->getBinary()))
290     return Create(L, std::move(B->takeBinary().second));
291 
292   // If this is a universal binary then search for a slice matching the given
293   // Triple.
294   if (auto *UB = cast<object::MachOUniversalBinary>(B->getBinary())) {
295     for (const auto &Obj : UB->objects()) {
296       auto ObjTT = Obj.getTriple();
297       if (ObjTT.getArch() == TT.getArch() &&
298           ObjTT.getSubArch() == TT.getSubArch() &&
299           (TT.getVendor() == Triple::UnknownVendor ||
300            ObjTT.getVendor() == TT.getVendor())) {
301         // We found a match. Create an instance from a buffer covering this
302         // slice.
303         auto SliceBuffer = MemoryBuffer::getFileSlice(FileName, Obj.getSize(),
304                                                       Obj.getOffset());
305         if (!SliceBuffer)
306           return make_error<StringError>(
307               Twine("Could not create buffer for ") + TT.str() + " slice of " +
308                   FileName + ": [ " + formatv("{0:x}", Obj.getOffset()) +
309                   " .. " + formatv("{0:x}", Obj.getOffset() + Obj.getSize()) +
310                   ": " + SliceBuffer.getError().message(),
311               SliceBuffer.getError());
312         return Create(L, std::move(*SliceBuffer));
313       }
314     }
315 
316     return make_error<StringError>(Twine("Universal binary ") + FileName +
317                                        " does not contain a slice for " +
318                                        TT.str(),
319                                    inconvertibleErrorCode());
320   }
321 
322   return make_error<StringError>(Twine("Unrecognized file type for ") +
323                                      FileName,
324                                  inconvertibleErrorCode());
325 }
326 
327 Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>>
328 StaticLibraryDefinitionGenerator::Create(
329     ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer) {
330   Error Err = Error::success();
331 
332   std::unique_ptr<StaticLibraryDefinitionGenerator> ADG(
333       new StaticLibraryDefinitionGenerator(L, std::move(ArchiveBuffer), Err));
334 
335   if (Err)
336     return std::move(Err);
337 
338   return std::move(ADG);
339 }
340 
341 Error StaticLibraryDefinitionGenerator::tryToGenerate(
342     LookupState &LS, LookupKind K, JITDylib &JD,
343     JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &Symbols) {
344 
345   // Don't materialize symbols from static archives unless this is a static
346   // lookup.
347   if (K != LookupKind::Static)
348     return Error::success();
349 
350   // Bail out early if we've already freed the archive.
351   if (!Archive)
352     return Error::success();
353 
354   DenseSet<std::pair<StringRef, StringRef>> ChildBufferInfos;
355 
356   for (const auto &KV : Symbols) {
357     const auto &Name = KV.first;
358     auto Child = Archive->findSym(*Name);
359     if (!Child)
360       return Child.takeError();
361     if (*Child == None)
362       continue;
363     auto ChildBuffer = (*Child)->getMemoryBufferRef();
364     if (!ChildBuffer)
365       return ChildBuffer.takeError();
366     ChildBufferInfos.insert(
367         {ChildBuffer->getBuffer(), ChildBuffer->getBufferIdentifier()});
368   }
369 
370   for (auto ChildBufferInfo : ChildBufferInfos) {
371     MemoryBufferRef ChildBufferRef(ChildBufferInfo.first,
372                                    ChildBufferInfo.second);
373 
374     if (auto Err = L.add(JD, MemoryBuffer::getMemBuffer(ChildBufferRef, false)))
375       return Err;
376   }
377 
378   return Error::success();
379 }
380 
381 StaticLibraryDefinitionGenerator::StaticLibraryDefinitionGenerator(
382     ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer, Error &Err)
383     : L(L), ArchiveBuffer(std::move(ArchiveBuffer)),
384       Archive(std::make_unique<object::Archive>(*this->ArchiveBuffer, Err)) {}
385 
386 } // End namespace orc.
387 } // End namespace llvm.
388