EIC code displayed by LXR master/​include/​llvm/​ExecutionEngine/​Orc/​Layer.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:43:53

 //===---------------- Layer.h -- Layer interfaces --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Layer interfaces.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_ORC_LAYER_H
 #define LLVM_EXECUTIONENGINE_ORC_LAYER_H
 
 #include "llvm/ExecutionEngine/Orc/Core.h"
 #include "llvm/ExecutionEngine/Orc/Mangling.h"
 #include "llvm/ExecutionEngine/Orc/ThreadSafeModule.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ExtensibleRTTI.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 namespace llvm {
 namespace orc {
 
 /// IRMaterializationUnit is a convenient base class for MaterializationUnits
 /// wrapping LLVM IR. Represents materialization responsibility for all symbols
 /// in the given module. If symbols are overridden by other definitions, then
 /// their linkage is changed to available-externally.
 class IRMaterializationUnit : public MaterializationUnit {
 public:
   using SymbolNameToDefinitionMap = std::map<SymbolStringPtr, GlobalValue *>;
 
   /// Create an IRMaterializationLayer. Scans the module to build the
   /// SymbolFlags and SymbolToDefinition maps.
   IRMaterializationUnit(ExecutionSession &ES,
                         const IRSymbolMapper::ManglingOptions &MO,
                         ThreadSafeModule TSM);
 
   /// Create an IRMaterializationLayer from a module, and pre-existing
   /// SymbolFlags and SymbolToDefinition maps. The maps must provide
   /// entries for each definition in M.
   /// This constructor is useful for delegating work from one
   /// IRMaterializationUnit to another.
   IRMaterializationUnit(ThreadSafeModule TSM, Interface I,
                         SymbolNameToDefinitionMap SymbolToDefinition);
 
   /// Return the ModuleIdentifier as the name for this MaterializationUnit.
   StringRef getName() const override;
 
   /// Return a reference to the contained ThreadSafeModule.
   const ThreadSafeModule &getModule() const { return TSM; }
 
 protected:
   ThreadSafeModule TSM;
   SymbolNameToDefinitionMap SymbolToDefinition;
 
 private:
   static SymbolStringPtr getInitSymbol(ExecutionSession &ES,
                                        const ThreadSafeModule &TSM);
 
   void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
 };
 
 /// Interface for layers that accept LLVM IR.
 class IRLayer {
 public:
   IRLayer(ExecutionSession &ES, const IRSymbolMapper::ManglingOptions *&MO)
       : ES(ES), MO(MO) {}
 
   virtual ~IRLayer();
 
   /// Returns the ExecutionSession for this layer.
   ExecutionSession &getExecutionSession() { return ES; }
 
   /// Get the mangling options for this layer.
   const IRSymbolMapper::ManglingOptions *&getManglingOptions() const {
     return MO;
   }
 
   /// Sets the CloneToNewContextOnEmit flag (false by default).
   ///
   /// When set, IR modules added to this layer will be cloned on to a new
   /// context before emit is called. This can be used by clients who want
   /// to load all IR using one LLVMContext (to save memory via type and
   /// constant uniquing), but want to move Modules to fresh contexts before
   /// compiling them to enable concurrent compilation.
   /// Single threaded clients, or clients who load every module on a new
   /// context, need not set this.
   void setCloneToNewContextOnEmit(bool CloneToNewContextOnEmit) {
     this->CloneToNewContextOnEmit = CloneToNewContextOnEmit;
   }
 
   /// Returns the current value of the CloneToNewContextOnEmit flag.
   bool getCloneToNewContextOnEmit() const { return CloneToNewContextOnEmit; }
 
   /// Add a MaterializatinoUnit representing the given IR to the JITDylib
   /// targeted by the given tracker.
   virtual Error add(ResourceTrackerSP RT, ThreadSafeModule TSM);
 
   /// Adds a MaterializationUnit representing the given IR to the given
   /// JITDylib. If RT is not specif
   Error add(JITDylib &JD, ThreadSafeModule TSM) {
     return add(JD.getDefaultResourceTracker(), std::move(TSM));
   }
 
   /// Emit should materialize the given IR.
   virtual void emit(std::unique_ptr<MaterializationResponsibility> R,
                     ThreadSafeModule TSM) = 0;
 
 private:
   bool CloneToNewContextOnEmit = false;
   ExecutionSession &ES;
   const IRSymbolMapper::ManglingOptions *&MO;
 };
 
 /// MaterializationUnit that materializes modules by calling the 'emit' method
 /// on the given IRLayer.
 class BasicIRLayerMaterializationUnit : public IRMaterializationUnit {
 public:
   BasicIRLayerMaterializationUnit(IRLayer &L,
                                   const IRSymbolMapper::ManglingOptions &MO,
                                   ThreadSafeModule TSM);
 
 private:
   void materialize(std::unique_ptr<MaterializationResponsibility> R) override;
 
   IRLayer &L;
 };
 
 /// Interface for Layers that accept object files.
 class ObjectLayer : public RTTIExtends<ObjectLayer, RTTIRoot> {
 public:
   static char ID;
 
   ObjectLayer(ExecutionSession &ES);
   virtual ~ObjectLayer();
 
   /// Returns the execution session for this layer.
   ExecutionSession &getExecutionSession() { return ES; }
 
   /// Adds a MaterializationUnit for the object file in the given memory buffer
   /// to the JITDylib for the given ResourceTracker.
   virtual Error add(ResourceTrackerSP RT, std::unique_ptr<MemoryBuffer> O,
                     MaterializationUnit::Interface I);
 
   /// Adds a MaterializationUnit for the object file in the given memory buffer
   /// to the JITDylib for the given ResourceTracker. The interface for the
   /// object will be built using the default object interface builder.
   Error add(ResourceTrackerSP RT, std::unique_ptr<MemoryBuffer> O);
 
   /// Adds a MaterializationUnit for the object file in the given memory buffer
   /// to the given JITDylib.
   Error add(JITDylib &JD, std::unique_ptr<MemoryBuffer> O,
             MaterializationUnit::Interface I) {
     return add(JD.getDefaultResourceTracker(), std::move(O), std::move(I));
   }
 
   /// Adds a MaterializationUnit for the object file in the given memory buffer
   /// to the given JITDylib. The interface for the object will be built using
   /// the default object interface builder.
   Error add(JITDylib &JD, std::unique_ptr<MemoryBuffer> O);
 
   /// Emit should materialize the given IR.
   virtual void emit(std::unique_ptr<MaterializationResponsibility> R,
                     std::unique_ptr<MemoryBuffer> O) = 0;
 
 private:
   ExecutionSession &ES;
 };
 
 /// Materializes the given object file (represented by a MemoryBuffer
 /// instance) by calling 'emit' on the given ObjectLayer.
 class BasicObjectLayerMaterializationUnit : public MaterializationUnit {
 public:
   /// Create using the default object interface builder function.
   static Expected<std::unique_ptr<BasicObjectLayerMaterializationUnit>>
   Create(ObjectLayer &L, std::unique_ptr<MemoryBuffer> O);
 
   BasicObjectLayerMaterializationUnit(ObjectLayer &L,
                                       std::unique_ptr<MemoryBuffer> O,
                                       Interface I);
 
   /// Return the buffer's identifier as the name for this MaterializationUnit.
   StringRef getName() const override;
 
 private:
   void materialize(std::unique_ptr<MaterializationResponsibility> R) override;
   void discard(const JITDylib &JD, const SymbolStringPtr &Name) override;
 
   ObjectLayer &L;
   std::unique_ptr<MemoryBuffer> O;
 };
 
 } // End namespace orc
 } // End namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_LAYER_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team