llvm/lib/ExecutionEngine/Orc/EPCGenericDylibManager.cpp

   1 //===------- EPCGenericDylibManager.cpp -- Dylib management via EPC -------===//
   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/EPCGenericDylibManager.h"
  10
  11 #include "llvm/ExecutionEngine/Orc/Core.h"
  12 #include "llvm/ExecutionEngine/Orc/Shared/OrcRTBridge.h"
  13 #include "llvm/ExecutionEngine/Orc/Shared/SimpleRemoteEPCUtils.h"
  14
  15 namespace llvm {
  16 namespace orc {
  17 namespace shared {
  18
  19 template <>
  20 class SPSSerializationTraits<SPSRemoteSymbolLookupSetElement,
  21                              SymbolLookupSet::value_type> {
  22 public:
  23   static size_t size(const SymbolLookupSet::value_type &V) {
  24     return SPSArgList<SPSString, bool>::size(
  25         *V.first, V.second == SymbolLookupFlags::RequiredSymbol);
  26   }
  27
  28   static bool serialize(SPSOutputBuffer &OB,
  29                         const SymbolLookupSet::value_type &V) {
  30     return SPSArgList<SPSString, bool>::serialize(
  31         OB, *V.first, V.second == SymbolLookupFlags::RequiredSymbol);
  32   }
  33 };
  34
  35 template <>
  36 class TrivialSPSSequenceSerialization<SPSRemoteSymbolLookupSetElement,
  37                                       SymbolLookupSet> {
  38 public:
  39   static constexpr bool available = true;
  40 };
  41
  42 template <>
  43 class SPSSerializationTraits<SPSRemoteSymbolLookup,
  44                              DylibManager::LookupRequest> {
  45   using MemberSerialization =
  46       SPSArgList<SPSExecutorAddr, SPSRemoteSymbolLookupSet>;
  47
  48 public:
  49   static size_t size(const DylibManager::LookupRequest &LR) {
  50     return MemberSerialization::size(ExecutorAddr(LR.Handle), LR.Symbols);
  51   }
  52
  53   static bool serialize(SPSOutputBuffer &OB,
  54                         const DylibManager::LookupRequest &LR) {
  55     return MemberSerialization::serialize(OB, ExecutorAddr(LR.Handle),
  56                                           LR.Symbols);
  57   }
  58 };
  59
  60 } // end namespace shared
  61
  62 Expected<EPCGenericDylibManager>
  63 EPCGenericDylibManager::CreateWithDefaultBootstrapSymbols(
  64     ExecutorProcessControl &EPC) {
  65   SymbolAddrs SAs;
  66   if (auto Err = EPC.getBootstrapSymbols(
  67           {{SAs.Instance, rt::SimpleExecutorDylibManagerInstanceName},
  68            {SAs.Open, rt::SimpleExecutorDylibManagerOpenWrapperName},
  69            {SAs.Lookup, rt::SimpleExecutorDylibManagerLookupWrapperName}}))
  70     return std::move(Err);
  71   return EPCGenericDylibManager(EPC, std::move(SAs));
  72 }
  73
  74 Expected<tpctypes::DylibHandle> EPCGenericDylibManager::open(StringRef Path,
  75                                                              uint64_t Mode) {
  76   Expected<tpctypes::DylibHandle> H((ExecutorAddr()));
  77   if (auto Err =
  78           EPC.callSPSWrapper<rt::SPSSimpleExecutorDylibManagerOpenSignature>(
  79               SAs.Open, H, SAs.Instance, Path, Mode))
  80     return std::move(Err);
  81   return H;
  82 }
  83
  84 void EPCGenericDylibManager::lookupAsync(tpctypes::DylibHandle H,
  85                                          const SymbolLookupSet &Lookup,
  86                                          SymbolLookupCompleteFn Complete) {
  87   EPC.callSPSWrapperAsync<rt::SPSSimpleExecutorDylibManagerLookupSignature>(
  88       SAs.Lookup,
  89       [Complete = std::move(Complete)](
  90           Error SerializationErr,
  91           Expected<std::vector<ExecutorSymbolDef>> Result) mutable {
  92         if (SerializationErr) {
  93           cantFail(Result.takeError());
  94           Complete(std::move(SerializationErr));
  95           return;
  96         }
  97         Complete(std::move(Result));
  98       },
  99       SAs.Instance, H, Lookup);
 100 }
 101
 102 void EPCGenericDylibManager::lookupAsync(tpctypes::DylibHandle H,
 103                                          const RemoteSymbolLookupSet &Lookup,
 104                                          SymbolLookupCompleteFn Complete) {
 105   EPC.callSPSWrapperAsync<rt::SPSSimpleExecutorDylibManagerLookupSignature>(
 106       SAs.Lookup,
 107       [Complete = std::move(Complete)](
 108           Error SerializationErr,
 109           Expected<std::vector<ExecutorSymbolDef>> Result) mutable {
 110         if (SerializationErr) {
 111           cantFail(Result.takeError());
 112           Complete(std::move(SerializationErr));
 113           return;
 114         }
 115         Complete(std::move(Result));
 116       },
 117       SAs.Instance, H, Lookup);
 118 }
 119
 120 } // end namespace orc
 121 } // end namespace llvm