include/llvm/ExecutionEngine/Orc/IRTransformLayer.h

   1 //===- IRTransformLayer.h - Run all IR through a functor --------*- C++ -*-===//
   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 // Run all IR passed in through a user supplied functor.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef LLVM_EXECUTIONENGINE_ORC_IRTRANSFORMLAYER_H
  14 #define LLVM_EXECUTIONENGINE_ORC_IRTRANSFORMLAYER_H
  15
  16 #include "llvm/ExecutionEngine/JITSymbol.h"
  17 #include "llvm/ExecutionEngine/Orc/Layer.h"
  18 #include <memory>
  19 #include <string>
  20
  21 namespace llvm {
  22 class Module;
  23 namespace orc {
  24
  25 /// A layer that applies a transform to emitted modules.
  26 /// The transform function is responsible for locking the ThreadSafeContext
  27 /// before operating on the module.
  28 class IRTransformLayer : public IRLayer {
  29 public:
  30   using TransformFunction = std::function<Expected<ThreadSafeModule>(
  31       ThreadSafeModule, const MaterializationResponsibility &R)>;
  32
  33   IRTransformLayer(ExecutionSession &ES, IRLayer &BaseLayer,
  34                    TransformFunction Transform = identityTransform);
  35
  36   void setTransform(TransformFunction Transform) {
  37     this->Transform = std::move(Transform);
  38   }
  39
  40   void emit(MaterializationResponsibility R, ThreadSafeModule TSM) override;
  41
  42   static ThreadSafeModule
  43   identityTransform(ThreadSafeModule TSM,
  44                     const MaterializationResponsibility &R) {
  45     return TSM;
  46   }
  47
  48 private:
  49   IRLayer &BaseLayer;
  50   TransformFunction Transform;
  51 };
  52
  53 /// IR mutating layer.
  54 ///
  55 ///   This layer applies a user supplied transform to each module that is added,
  56 /// then adds the transformed module to the layer below.
  57 template <typename BaseLayerT, typename TransformFtor>
  58 class LegacyIRTransformLayer {
  59 public:
  60
  61   /// Construct an LegacyIRTransformLayer with the given BaseLayer
  62   LLVM_ATTRIBUTE_DEPRECATED(
  63       LegacyIRTransformLayer(BaseLayerT &BaseLayer,
  64                              TransformFtor Transform = TransformFtor()),
  65       "ORCv1 layers (layers with the 'Legacy' prefix) are deprecated. Please "
  66       "use "
  67       "the ORCv2 IRTransformLayer instead");
  68
  69   /// Legacy layer constructor with deprecation acknowledgement.
  70   LegacyIRTransformLayer(ORCv1DeprecationAcknowledgement, BaseLayerT &BaseLayer,
  71                          TransformFtor Transform = TransformFtor())
  72       : BaseLayer(BaseLayer), Transform(std::move(Transform)) {}
  73
  74   /// Apply the transform functor to the module, then add the module to
  75   ///        the layer below, along with the memory manager and symbol resolver.
  76   ///
  77   /// @return A handle for the added modules.
  78   Error addModule(VModuleKey K, std::unique_ptr<Module> M) {
  79     return BaseLayer.addModule(std::move(K), Transform(std::move(M)));
  80   }
  81
  82   /// Remove the module associated with the VModuleKey K.
  83   Error removeModule(VModuleKey K) { return BaseLayer.removeModule(K); }
  84
  85   /// Search for the given named symbol.
  86   /// @param Name The name of the symbol to search for.
  87   /// @param ExportedSymbolsOnly If true, search only for exported symbols.
  88   /// @return A handle for the given named symbol, if it exists.
  89   JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
  90     return BaseLayer.findSymbol(Name, ExportedSymbolsOnly);
  91   }
  92
  93   /// Get the address of the given symbol in the context of the module
  94   ///        represented by the VModuleKey K. This call is forwarded to the base
  95   ///        layer's implementation.
  96   /// @param K The VModuleKey for the module to search in.
  97   /// @param Name The name of the symbol to search for.
  98   /// @param ExportedSymbolsOnly If true, search only for exported symbols.
  99   /// @return A handle for the given named symbol, if it is found in the
 100   ///         given module.
 101   JITSymbol findSymbolIn(VModuleKey K, const std::string &Name,
 102                          bool ExportedSymbolsOnly) {
 103     return BaseLayer.findSymbolIn(K, Name, ExportedSymbolsOnly);
 104   }
 105
 106   /// Immediately emit and finalize the module represented by the given
 107   ///        VModuleKey.
 108   /// @param K The VModuleKey for the module to emit/finalize.
 109   Error emitAndFinalize(VModuleKey K) { return BaseLayer.emitAndFinalize(K); }
 110
 111   /// Access the transform functor directly.
 112   TransformFtor& getTransform() { return Transform; }
 113
 114   /// Access the mumate functor directly.
 115   const TransformFtor& getTransform() const { return Transform; }
 116
 117 private:
 118   BaseLayerT &BaseLayer;
 119   TransformFtor Transform;
 120 };
 121
 122 template <typename BaseLayerT, typename TransformFtor>
 123 LegacyIRTransformLayer<BaseLayerT, TransformFtor>::LegacyIRTransformLayer(
 124     BaseLayerT &BaseLayer, TransformFtor Transform)
 125     : BaseLayer(BaseLayer), Transform(std::move(Transform)) {}
 126
 127 } // end namespace orc
 128 } // end namespace llvm
 129
 130 #endif // LLVM_EXECUTIONENGINE_ORC_IRTRANSFORMLAYER_H