Home | History | Annotate | Download | only in Orc 
      1 //===- GlobalMappingLayer.h - Run all IR through a functor ------*- 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 // Convenience layer for injecting symbols that will appear in calls to
     11 // findSymbol.
     12 //
     13 //===----------------------------------------------------------------------===//
     14 
     15 #ifndef LLVM_EXECUTIONENGINE_ORC_GLOBALMAPPINGLAYER_H
     16 #define LLVM_EXECUTIONENGINE_ORC_GLOBALMAPPINGLAYER_H
     17 
     18 #include "llvm/ExecutionEngine/JITSymbol.h"
     19 #include <map>
     20 #include <memory>
     21 #include <string>
     22 
     23 namespace llvm {
     24 
     25 class Module;
     26 class JITSymbolResolver;
     27 
     28 namespace orc {
     29 
     30 /// @brief Global mapping layer.
     31 ///
     32 ///   This layer overrides the findSymbol method to first search a local symbol
     33 /// table that the client can define. It can be used to inject new symbol
     34 /// mappings into the JIT. Beware, however: symbols within a single IR module or
     35 /// object file will still resolve locally (via RuntimeDyld's symbol table) -
     36 /// such internal references cannot be overriden via this layer.
     37 template <typename BaseLayerT>
     38 class GlobalMappingLayer {
     39 public:
     40 
     41   /// @brief Handle to an added module.
     42   using ModuleHandleT = typename BaseLayerT::ModuleHandleT;
     43 
     44   /// @brief Construct an GlobalMappingLayer with the given BaseLayer
     45   GlobalMappingLayer(BaseLayerT &BaseLayer) : BaseLayer(BaseLayer) {}
     46 
     47   /// @brief Add the given module to the JIT.
     48   /// @return A handle for the added modules.
     49   Expected<ModuleHandleT>
     50   addModule(std::shared_ptr<Module> M,
     51             std::shared_ptr<JITSymbolResolver> Resolver) {
     52     return BaseLayer.addModule(std::move(M), std::move(Resolver));
     53   }
     54 
     55   /// @brief Remove the module set associated with the handle H.
     56   Error removeModule(ModuleHandleT H) { return BaseLayer.removeModule(H); }
     57 
     58   /// @brief Manually set the address to return for the given symbol.
     59   void setGlobalMapping(const std::string &Name, JITTargetAddress Addr) {
     60     SymbolTable[Name] = Addr;
     61   }
     62 
     63   /// @brief Remove the given symbol from the global mapping.
     64   void eraseGlobalMapping(const std::string &Name) {
     65     SymbolTable.erase(Name);
     66   }
     67 
     68   /// @brief Search for the given named symbol.
     69   ///
     70   ///          This method will first search the local symbol table, returning
     71   ///        any symbol found there. If the symbol is not found in the local
     72   ///        table then this call will be passed through to the base layer.
     73   ///
     74   /// @param Name The name of the symbol to search for.
     75   /// @param ExportedSymbolsOnly If true, search only for exported symbols.
     76   /// @return A handle for the given named symbol, if it exists.
     77   JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
     78     auto I = SymbolTable.find(Name);
     79     if (I != SymbolTable.end())
     80       return JITSymbol(I->second, JITSymbolFlags::Exported);
     81     return BaseLayer.findSymbol(Name, ExportedSymbolsOnly);
     82   }
     83 
     84   /// @brief Get the address of the given symbol in the context of the of the
     85   ///        module represented by the handle H. This call is forwarded to the
     86   ///        base layer's implementation.
     87   /// @param H The handle for the module to search in.
     88   /// @param Name The name of the symbol to search for.
     89   /// @param ExportedSymbolsOnly If true, search only for exported symbols.
     90   /// @return A handle for the given named symbol, if it is found in the
     91   ///         given module.
     92   JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name,
     93                          bool ExportedSymbolsOnly) {
     94     return BaseLayer.findSymbolIn(H, Name, ExportedSymbolsOnly);
     95   }
     96 
     97   /// @brief Immediately emit and finalize the module set represented by the
     98   ///        given handle.
     99   /// @param H Handle for module set to emit/finalize.
    100   Error emitAndFinalize(ModuleHandleT H) {
    101     return BaseLayer.emitAndFinalize(H);
    102   }
    103 
    104 private:
    105   BaseLayerT &BaseLayer;
    106   std::map<std::string, JITTargetAddress> SymbolTable;
    107 };
    108 
    109 } // end namespace orc
    110 } // end namespace llvm
    111 
    112 #endif // LLVM_EXECUTIONENGINE_ORC_GLOBALMAPPINGLAYER_H
    113