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                              ExecutorProcessControl::LookupRequest> {
  45   using MemberSerialization =
  46       SPSArgList<SPSExecutorAddr, SPSRemoteSymbolLookupSet>;
  47
  48 public:
  49   static size_t size(const ExecutorProcessControl::LookupRequest &LR) {
  50     return MemberSerialization::size(ExecutorAddr(LR.Handle), LR.Symbols);
  51   }
  52
  53   static bool serialize(SPSOutputBuffer &OB,
  54                         const ExecutorProcessControl::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 Expected<std::vector<ExecutorSymbolDef>>
  85 EPCGenericDylibManager::lookup(tpctypes::DylibHandle H,
  86                                const SymbolLookupSet &Lookup) {
  87   Expected<std::vector<ExecutorSymbolDef>> Result(
  88       (std::vector<ExecutorSymbolDef>()));
  89   if (auto Err =
  90           EPC.callSPSWrapper<rt::SPSSimpleExecutorDylibManagerLookupSignature>(
  91               SAs.Lookup, Result, SAs.Instance, H, Lookup))
  92     return std::move(Err);
  93   return Result;
  94 }
  95
  96 Expected<std::vector<ExecutorSymbolDef>>
  97 EPCGenericDylibManager::lookup(tpctypes::DylibHandle H,
  98                                const RemoteSymbolLookupSet &Lookup) {
  99   Expected<std::vector<ExecutorSymbolDef>> Result(
 100       (std::vector<ExecutorSymbolDef>()));
 101   if (auto Err =
 102           EPC.callSPSWrapper<rt::SPSSimpleExecutorDylibManagerLookupSignature>(
 103               SAs.Lookup, Result, SAs.Instance, H, Lookup))
 104     return std::move(Err);
 105   return Result;
 106 }
 107
 108 } // end namespace orc
 109 } // end namespace llvm