| //===---------------- 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 |