contrib/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 void LazyCallThroughManager::NotifyResolvedFunction::anchor() {}
  20
  21 LazyCallThroughManager::LazyCallThroughManager(
  22     ExecutionSession &ES, JITTargetAddress ErrorHandlerAddr,
  23     std::unique_ptr<TrampolinePool> TP)
  24     : ES(ES), ErrorHandlerAddr(ErrorHandlerAddr), TP(std::move(TP)) {}
  25
  26 Expected<JITTargetAddress> LazyCallThroughManager::getCallThroughTrampoline(
  27     JITDylib &SourceJD, SymbolStringPtr SymbolName,
  28     std::shared_ptr<NotifyResolvedFunction> NotifyResolved) {
  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] = std::make_pair(&SourceJD, std::move(SymbolName));
  36   Notifiers[*Trampoline] = std::move(NotifyResolved);
  37   return *Trampoline;
  38 }
  39
  40 JITTargetAddress
  41 LazyCallThroughManager::callThroughToSymbol(JITTargetAddress TrampolineAddr) {
  42   JITDylib *SourceJD = nullptr;
  43   SymbolStringPtr SymbolName;
  44
  45   {
  46     std::lock_guard<std::mutex> Lock(LCTMMutex);
  47     auto I = Reexports.find(TrampolineAddr);
  48     if (I == Reexports.end())
  49       return ErrorHandlerAddr;
  50     SourceJD = I->second.first;
  51     SymbolName = I->second.second;
  52   }
  53
  54   auto LookupResult =
  55       ES.lookup(JITDylibSearchList({{SourceJD, true}}), SymbolName);
  56
  57   if (!LookupResult) {
  58     ES.reportError(LookupResult.takeError());
  59     return ErrorHandlerAddr;
  60   }
  61
  62   auto ResolvedAddr = LookupResult->getAddress();
  63
  64   std::shared_ptr<NotifyResolvedFunction> NotifyResolved = nullptr;
  65   {
  66     std::lock_guard<std::mutex> Lock(LCTMMutex);
  67     auto I = Notifiers.find(TrampolineAddr);
  68     if (I != Notifiers.end()) {
  69       NotifyResolved = I->second;
  70       Notifiers.erase(I);
  71     }
  72   }
  73
  74   if (NotifyResolved) {
  75     if (auto Err = (*NotifyResolved)(*SourceJD, SymbolName, ResolvedAddr)) {
  76       ES.reportError(std::move(Err));
  77       return ErrorHandlerAddr;
  78     }
  79   }
  80
  81   return ResolvedAddr;
  82 }
  83
  84 Expected<std::unique_ptr<LazyCallThroughManager>>
  85 createLocalLazyCallThroughManager(const Triple &T, ExecutionSession &ES,
  86                                   JITTargetAddress ErrorHandlerAddr) {
  87   switch (T.getArch()) {
  88   default:
  89     return make_error<StringError>(
  90         std::string("No callback manager available for ") + T.str(),
  91         inconvertibleErrorCode());
  92
  93   case Triple::aarch64:
  94     return LocalLazyCallThroughManager::Create<OrcAArch64>(ES,
  95                                                            ErrorHandlerAddr);
  96
  97   case Triple::x86:
  98     return LocalLazyCallThroughManager::Create<OrcI386>(ES, ErrorHandlerAddr);
  99
 100   case Triple::mips:
 101     return LocalLazyCallThroughManager::Create<OrcMips32Be>(ES,
 102                                                             ErrorHandlerAddr);
 103
 104   case Triple::mipsel:
 105     return LocalLazyCallThroughManager::Create<OrcMips32Le>(ES,
 106                                                             ErrorHandlerAddr);
 107
 108   case Triple::mips64:
 109   case Triple::mips64el:
 110     return LocalLazyCallThroughManager::Create<OrcMips64>(ES, ErrorHandlerAddr);
 111
 112   case Triple::x86_64:
 113     if (T.getOS() == Triple::OSType::Win32)
 114       return LocalLazyCallThroughManager::Create<OrcX86_64_Win32>(
 115           ES, ErrorHandlerAddr);
 116     else
 117       return LocalLazyCallThroughManager::Create<OrcX86_64_SysV>(
 118           ES, ErrorHandlerAddr);
 119   }
 120 }
 121
 122 LazyReexportsMaterializationUnit::LazyReexportsMaterializationUnit(
 123     LazyCallThroughManager &LCTManager, IndirectStubsManager &ISManager,
 124     JITDylib &SourceJD, SymbolAliasMap CallableAliases, VModuleKey K)
 125     : MaterializationUnit(extractFlags(CallableAliases), std::move(K)),
 126       LCTManager(LCTManager), ISManager(ISManager), SourceJD(SourceJD),
 127       CallableAliases(std::move(CallableAliases)),
 128       NotifyResolved(LazyCallThroughManager::createNotifyResolvedFunction(
 129           [&ISManager](JITDylib &JD, const SymbolStringPtr &SymbolName,
 130                        JITTargetAddress ResolvedAddr) {
 131             return ISManager.updatePointer(*SymbolName, ResolvedAddr);
 132           })) {}
 133
 134 StringRef LazyReexportsMaterializationUnit::getName() const {
 135   return "<Lazy Reexports>";
 136 }
 137
 138 void LazyReexportsMaterializationUnit::materialize(
 139     MaterializationResponsibility R) {
 140   auto RequestedSymbols = R.getRequestedSymbols();
 141
 142   SymbolAliasMap RequestedAliases;
 143   for (auto &RequestedSymbol : RequestedSymbols) {
 144     auto I = CallableAliases.find(RequestedSymbol);
 145     assert(I != CallableAliases.end() && "Symbol not found in alias map?");
 146     RequestedAliases[I->first] = std::move(I->second);
 147     CallableAliases.erase(I);
 148   }
 149
 150   if (!CallableAliases.empty())
 151     R.replace(lazyReexports(LCTManager, ISManager, SourceJD,
 152                             std::move(CallableAliases)));
 153
 154   IndirectStubsManager::StubInitsMap StubInits;
 155   for (auto &Alias : RequestedAliases) {
 156
 157     auto CallThroughTrampoline = LCTManager.getCallThroughTrampoline(
 158         SourceJD, Alias.second.Aliasee, NotifyResolved);
 159
 160     if (!CallThroughTrampoline) {
 161       SourceJD.getExecutionSession().reportError(
 162           CallThroughTrampoline.takeError());
 163       R.failMaterialization();
 164       return;
 165     }
 166
 167     StubInits[*Alias.first] =
 168         std::make_pair(*CallThroughTrampoline, Alias.second.AliasFlags);
 169   }
 170
 171   if (auto Err = ISManager.createStubs(StubInits)) {
 172     SourceJD.getExecutionSession().reportError(std::move(Err));
 173     R.failMaterialization();
 174     return;
 175   }
 176
 177   SymbolMap Stubs;
 178   for (auto &Alias : RequestedAliases)
 179     Stubs[Alias.first] = ISManager.findStub(*Alias.first, false);
 180
 181   R.notifyResolved(Stubs);
 182   R.notifyEmitted();
 183 }
 184
 185 void LazyReexportsMaterializationUnit::discard(const JITDylib &JD,
 186                                                const SymbolStringPtr &Name) {
 187   assert(CallableAliases.count(Name) &&
 188          "Symbol not covered by this MaterializationUnit");
 189   CallableAliases.erase(Name);
 190 }
 191
 192 SymbolFlagsMap
 193 LazyReexportsMaterializationUnit::extractFlags(const SymbolAliasMap &Aliases) {
 194   SymbolFlagsMap SymbolFlags;
 195   for (auto &KV : Aliases) {
 196     assert(KV.second.AliasFlags.isCallable() &&
 197            "Lazy re-exports must be callable symbols");
 198     SymbolFlags[KV.first] = KV.second.AliasFlags;
 199   }
 200   return SymbolFlags;
 201 }
 202
 203 } // End namespace orc.
 204 } // End namespace llvm.