llvm/lib/ExecutionEngine/Orc/LazyReexports.cpp

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