xref: /freebsd/contrib/llvm-project/llvm/lib/ExecutionEngine/Orc/LazyReexports.cpp (revision 7fdf597e96a02165cfe22ff357b857d5fa15ed8a) 
1 //===---------- LazyReexports.cpp - Utilities for lazy reexports ----------===//
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/LazyReexports.h"
10 
11 #include "llvm/ExecutionEngine/Orc/OrcABISupport.h"
12 #include "llvm/TargetParser/Triple.h"
13 
14 #define DEBUG_TYPE "orc"
15 
16 namespace llvm {
17 namespace orc {
18 
19 LazyCallThroughManager::LazyCallThroughManager(ExecutionSession &ES,
20                                                ExecutorAddr ErrorHandlerAddr,
21                                                TrampolinePool *TP)
22     : ES(ES), ErrorHandlerAddr(ErrorHandlerAddr), TP(TP) {}
23 
24 Expected<ExecutorAddr> LazyCallThroughManager::getCallThroughTrampoline(
25     JITDylib &SourceJD, SymbolStringPtr SymbolName,
26     NotifyResolvedFunction NotifyResolved) {
27   assert(TP && "TrampolinePool not set");
28 
29   std::lock_guard<std::mutex> Lock(LCTMMutex);
30   auto Trampoline = TP->getTrampoline();
31 
32   if (!Trampoline)
33     return Trampoline.takeError();
34 
35   Reexports[*Trampoline] = ReexportsEntry{&SourceJD, std::move(SymbolName)};
36   Notifiers[*Trampoline] = std::move(NotifyResolved);
37   return *Trampoline;
38 }
39 
40 ExecutorAddr LazyCallThroughManager::reportCallThroughError(Error Err) {
41   ES.reportError(std::move(Err));
42   return ErrorHandlerAddr;
43 }
44 
45 Expected<LazyCallThroughManager::ReexportsEntry>
46 LazyCallThroughManager::findReexport(ExecutorAddr TrampolineAddr) {
47   std::lock_guard<std::mutex> Lock(LCTMMutex);
48   auto I = Reexports.find(TrampolineAddr);
49   if (I == Reexports.end())
50     return createStringError(inconvertibleErrorCode(),
51                              "Missing reexport for trampoline address %p" +
52                                  formatv("{0:x}", TrampolineAddr));
53   return I->second;
54 }
55 
56 Error LazyCallThroughManager::notifyResolved(ExecutorAddr TrampolineAddr,
57                                              ExecutorAddr ResolvedAddr) {
58   NotifyResolvedFunction NotifyResolved;
59   {
60     std::lock_guard<std::mutex> Lock(LCTMMutex);
61     auto I = Notifiers.find(TrampolineAddr);
62     if (I != Notifiers.end()) {
63       NotifyResolved = std::move(I->second);
64       Notifiers.erase(I);
65     }
66   }
67 
68   return NotifyResolved ? NotifyResolved(ResolvedAddr) : Error::success();
69 }
70 
71 void LazyCallThroughManager::resolveTrampolineLandingAddress(
72     ExecutorAddr TrampolineAddr,
73     NotifyLandingResolvedFunction NotifyLandingResolved) {
74 
75   auto Entry = findReexport(TrampolineAddr);
76   if (!Entry)
77     return NotifyLandingResolved(reportCallThroughError(Entry.takeError()));
78 
79   // Declaring SLS and the callback outside of the call to ES.lookup is a
80   // workaround to fix build failures on AIX and on z/OS platforms.
81   SymbolLookupSet SLS({Entry->SymbolName});
82   auto Callback = [this, TrampolineAddr, SymbolName = Entry->SymbolName,
83                    NotifyLandingResolved = std::move(NotifyLandingResolved)](
84                       Expected<SymbolMap> Result) mutable {
85     if (Result) {
86       assert(Result->size() == 1 && "Unexpected result size");
87       assert(Result->count(SymbolName) && "Unexpected result value");
88       ExecutorAddr LandingAddr = (*Result)[SymbolName].getAddress();
89 
90       if (auto Err = notifyResolved(TrampolineAddr, LandingAddr))
91         NotifyLandingResolved(reportCallThroughError(std::move(Err)));
92       else
93         NotifyLandingResolved(LandingAddr);
94     } else {
95       NotifyLandingResolved(reportCallThroughError(Result.takeError()));
96     }
97   };
98 
99   ES.lookup(LookupKind::Static,
100             makeJITDylibSearchOrder(Entry->SourceJD,
101                                     JITDylibLookupFlags::MatchAllSymbols),
102             std::move(SLS), SymbolState::Ready, std::move(Callback),
103             NoDependenciesToRegister);
104 }
105 
106 Expected<std::unique_ptr<LazyCallThroughManager>>
107 createLocalLazyCallThroughManager(const Triple &T, ExecutionSession &ES,
108                                   ExecutorAddr ErrorHandlerAddr) {
109   switch (T.getArch()) {
110   default:
111     return make_error<StringError>(
112         std::string("No callback manager available for ") + T.str(),
113         inconvertibleErrorCode());
114 
115   case Triple::aarch64:
116   case Triple::aarch64_32:
117     return LocalLazyCallThroughManager::Create<OrcAArch64>(ES,
118                                                            ErrorHandlerAddr);
119 
120   case Triple::x86:
121     return LocalLazyCallThroughManager::Create<OrcI386>(ES, ErrorHandlerAddr);
122 
123   case Triple::loongarch64:
124     return LocalLazyCallThroughManager::Create<OrcLoongArch64>(
125         ES, ErrorHandlerAddr);
126 
127   case Triple::mips:
128     return LocalLazyCallThroughManager::Create<OrcMips32Be>(ES,
129                                                             ErrorHandlerAddr);
130 
131   case Triple::mipsel:
132     return LocalLazyCallThroughManager::Create<OrcMips32Le>(ES,
133                                                             ErrorHandlerAddr);
134 
135   case Triple::mips64:
136   case Triple::mips64el:
137     return LocalLazyCallThroughManager::Create<OrcMips64>(ES, ErrorHandlerAddr);
138 
139   case Triple::riscv64:
140     return LocalLazyCallThroughManager::Create<OrcRiscv64>(ES,
141                                                            ErrorHandlerAddr);
142 
143   case Triple::x86_64:
144     if (T.getOS() == Triple::OSType::Win32)
145       return LocalLazyCallThroughManager::Create<OrcX86_64_Win32>(
146           ES, ErrorHandlerAddr);
147     else
148       return LocalLazyCallThroughManager::Create<OrcX86_64_SysV>(
149           ES, ErrorHandlerAddr);
150   }
151 }
152 
153 LazyReexportsMaterializationUnit::LazyReexportsMaterializationUnit(
154     LazyCallThroughManager &LCTManager, IndirectStubsManager &ISManager,
155     JITDylib &SourceJD, SymbolAliasMap CallableAliases, ImplSymbolMap *SrcJDLoc)
156     : MaterializationUnit(extractFlags(CallableAliases)),
157       LCTManager(LCTManager), ISManager(ISManager), SourceJD(SourceJD),
158       CallableAliases(std::move(CallableAliases)), AliaseeTable(SrcJDLoc) {}
159 
160 StringRef LazyReexportsMaterializationUnit::getName() const {
161   return "<Lazy Reexports>";
162 }
163 
164 void LazyReexportsMaterializationUnit::materialize(
165     std::unique_ptr<MaterializationResponsibility> R) {
166   auto RequestedSymbols = R->getRequestedSymbols();
167 
168   SymbolAliasMap RequestedAliases;
169   for (auto &RequestedSymbol : RequestedSymbols) {
170     auto I = CallableAliases.find(RequestedSymbol);
171     assert(I != CallableAliases.end() && "Symbol not found in alias map?");
172     RequestedAliases[I->first] = std::move(I->second);
173     CallableAliases.erase(I);
174   }
175 
176   if (!CallableAliases.empty())
177     if (auto Err = R->replace(lazyReexports(LCTManager, ISManager, SourceJD,
178                                             std::move(CallableAliases),
179                                             AliaseeTable))) {
180       R->getExecutionSession().reportError(std::move(Err));
181       R->failMaterialization();
182       return;
183     }
184 
185   IndirectStubsManager::StubInitsMap StubInits;
186   for (auto &Alias : RequestedAliases) {
187 
188     auto CallThroughTrampoline = LCTManager.getCallThroughTrampoline(
189         SourceJD, Alias.second.Aliasee,
190         [&ISManager = this->ISManager,
191          StubSym = Alias.first](ExecutorAddr ResolvedAddr) -> Error {
192           return ISManager.updatePointer(*StubSym, ResolvedAddr);
193         });
194 
195     if (!CallThroughTrampoline) {
196       SourceJD.getExecutionSession().reportError(
197           CallThroughTrampoline.takeError());
198       R->failMaterialization();
199       return;
200     }
201 
202     StubInits[*Alias.first] =
203         std::make_pair(*CallThroughTrampoline, Alias.second.AliasFlags);
204   }
205 
206   if (AliaseeTable != nullptr && !RequestedAliases.empty())
207     AliaseeTable->trackImpls(RequestedAliases, &SourceJD);
208 
209   if (auto Err = ISManager.createStubs(StubInits)) {
210     SourceJD.getExecutionSession().reportError(std::move(Err));
211     R->failMaterialization();
212     return;
213   }
214 
215   SymbolMap Stubs;
216   for (auto &Alias : RequestedAliases)
217     Stubs[Alias.first] = ISManager.findStub(*Alias.first, false);
218 
219   // No registered dependencies, so these calls cannot fail.
220   cantFail(R->notifyResolved(Stubs));
221   cantFail(R->notifyEmitted({}));
222 }
223 
224 void LazyReexportsMaterializationUnit::discard(const JITDylib &JD,
225                                                const SymbolStringPtr &Name) {
226   assert(CallableAliases.count(Name) &&
227          "Symbol not covered by this MaterializationUnit");
228   CallableAliases.erase(Name);
229 }
230 
231 MaterializationUnit::Interface
232 LazyReexportsMaterializationUnit::extractFlags(const SymbolAliasMap &Aliases) {
233   SymbolFlagsMap SymbolFlags;
234   for (auto &KV : Aliases) {
235     assert(KV.second.AliasFlags.isCallable() &&
236            "Lazy re-exports must be callable symbols");
237     SymbolFlags[KV.first] = KV.second.AliasFlags;
238   }
239   return MaterializationUnit::Interface(std::move(SymbolFlags), nullptr);
240 }
241 
242 } // End namespace orc.
243 } // End namespace llvm.
244