include/llvm/ExecutionEngine/Orc/LogicalDylib.h

   1 //===--- LogicalDylib.h - Simulates dylib-style symbol lookup ---*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Simulates symbol resolution inside a dylib.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_EXECUTIONENGINE_ORC_LOGICALDYLIB_H
  15 #define LLVM_EXECUTIONENGINE_ORC_LOGICALDYLIB_H
  16
  17 #include "llvm/ExecutionEngine/Orc/JITSymbol.h"
  18 #include <string>
  19 #include <vector>
  20
  21 namespace llvm {
  22 namespace orc {
  23
  24 template <typename BaseLayerT,
  25           typename LogicalModuleResources,
  26           typename LogicalDylibResources>
  27 class LogicalDylib {
  28 public:
  29   typedef typename BaseLayerT::ModuleSetHandleT BaseLayerModuleSetHandleT;
  30 private:
  31
  32   typedef std::vector<BaseLayerModuleSetHandleT> BaseLayerHandleList;
  33
  34   struct LogicalModule {
  35     // Make this move-only to ensure they don't get duplicated across moves of
  36     // LogicalDylib or anything like that.
  37     LogicalModule(LogicalModule &&RHS)
  38         : Resources(std::move(RHS.Resources)),
  39           BaseLayerHandles(std::move(RHS.BaseLayerHandles)) {}
  40     LogicalModule() = default;
  41     LogicalModuleResources Resources;
  42     BaseLayerHandleList BaseLayerHandles;
  43   };
  44   typedef std::vector<LogicalModule> LogicalModuleList;
  45
  46 public:
  47
  48   typedef typename BaseLayerHandleList::iterator BaseLayerHandleIterator;
  49   typedef typename LogicalModuleList::iterator LogicalModuleHandle;
  50
  51   LogicalDylib(BaseLayerT &BaseLayer) : BaseLayer(BaseLayer) {}
  52
  53   ~LogicalDylib() {
  54     for (auto &LM : LogicalModules)
  55       for (auto BLH : LM.BaseLayerHandles)
  56         BaseLayer.removeModuleSet(BLH);
  57   }
  58
  59   // If possible, remove this and ~LogicalDylib once the work in the dtor is
  60   // moved to members (eg: self-unregistering base layer handles).
  61   LogicalDylib(LogicalDylib &&RHS)
  62       : BaseLayer(std::move(RHS.BaseLayer)),
  63         LogicalModules(std::move(RHS.LogicalModules)),
  64         DylibResources(std::move(RHS.DylibResources)) {}
  65
  66   LogicalModuleHandle createLogicalModule() {
  67     LogicalModules.push_back(LogicalModule());
  68     return std::prev(LogicalModules.end());
  69   }
  70
  71   void addToLogicalModule(LogicalModuleHandle LMH,
  72                           BaseLayerModuleSetHandleT BaseLayerHandle) {
  73     LMH->BaseLayerHandles.push_back(BaseLayerHandle);
  74   }
  75
  76   LogicalModuleResources& getLogicalModuleResources(LogicalModuleHandle LMH) {
  77     return LMH->Resources;
  78   }
  79
  80   BaseLayerHandleIterator moduleHandlesBegin(LogicalModuleHandle LMH) {
  81     return LMH->BaseLayerHandles.begin();
  82   }
  83
  84   BaseLayerHandleIterator moduleHandlesEnd(LogicalModuleHandle LMH) {
  85     return LMH->BaseLayerHandles.end();
  86   }
  87
  88   JITSymbol findSymbolInLogicalModule(LogicalModuleHandle LMH,
  89                                       const std::string &Name,
  90                                       bool ExportedSymbolsOnly) {
  91
  92     if (auto StubSym = LMH->Resources.findSymbol(Name, ExportedSymbolsOnly))
  93       return StubSym;
  94
  95     for (auto BLH : LMH->BaseLayerHandles)
  96       if (auto Symbol = BaseLayer.findSymbolIn(BLH, Name, ExportedSymbolsOnly))
  97         return Symbol;
  98     return nullptr;
  99   }
 100
 101   JITSymbol findSymbolInternally(LogicalModuleHandle LMH,
 102                                  const std::string &Name) {
 103     if (auto Symbol = findSymbolInLogicalModule(LMH, Name, false))
 104       return Symbol;
 105
 106     for (auto LMI = LogicalModules.begin(), LME = LogicalModules.end();
 107            LMI != LME; ++LMI) {
 108       if (LMI != LMH)
 109         if (auto Symbol = findSymbolInLogicalModule(LMI, Name, false))
 110           return Symbol;
 111     }
 112
 113     return nullptr;
 114   }
 115
 116   JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
 117     for (auto LMI = LogicalModules.begin(), LME = LogicalModules.end();
 118          LMI != LME; ++LMI)
 119       if (auto Sym = findSymbolInLogicalModule(LMI, Name, ExportedSymbolsOnly))
 120         return Sym;
 121     return nullptr;
 122   }
 123
 124   LogicalDylibResources& getDylibResources() { return DylibResources; }
 125
 126 protected:
 127   BaseLayerT BaseLayer;
 128   LogicalModuleList LogicalModules;
 129   LogicalDylibResources DylibResources;
 130 };
 131
 132 } // End namespace orc.
 133 } // End namespace llvm.
 134
 135 #endif // LLVM_EXECUTIONENGINE_ORC_LOGICALDYLIB_H