1 //===- GlobalMappingLayer.h - Run all IR through a functor ------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Convenience layer for injecting symbols that will appear in calls to
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_EXECUTIONENGINE_ORC_GLOBALMAPPINGLAYER_H
16 #define LLVM_EXECUTIONENGINE_ORC_GLOBALMAPPINGLAYER_H
18 #include "llvm/ExecutionEngine/JITSymbol.h"
26 class JITSymbolResolver;
30 /// @brief Global mapping layer.
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 {
41 /// @brief Handle to an added module.
42 using ModuleHandleT = typename BaseLayerT::ModuleHandleT;
44 /// @brief Construct an GlobalMappingLayer with the given BaseLayer
45 GlobalMappingLayer(BaseLayerT &BaseLayer) : BaseLayer(BaseLayer) {}
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));
55 /// @brief Remove the module set associated with the handle H.
56 Error removeModule(ModuleHandleT H) { return BaseLayer.removeModule(H); }
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;
63 /// @brief Remove the given symbol from the global mapping.
64 void eraseGlobalMapping(const std::string &Name) {
65 SymbolTable.erase(Name);
68 /// @brief Search for the given named symbol.
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.
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);
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
92 JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name,
93 bool ExportedSymbolsOnly) {
94 return BaseLayer.findSymbolIn(H, Name, ExportedSymbolsOnly);
97 /// @brief Immediately emit and finalize the module set represented by the
99 /// @param H Handle for module set to emit/finalize.
100 Error emitAndFinalize(ModuleHandleT H) {
101 return BaseLayer.emitAndFinalize(H);
105 BaseLayerT &BaseLayer;
106 std::map<std::string, JITTargetAddress> SymbolTable;
109 } // end namespace orc
110 } // end namespace llvm
112 #endif // LLVM_EXECUTIONENGINE_ORC_GLOBALMAPPINGLAYER_H