LLVM  4.0.0
GlobalMappingLayer.h
Go to the documentation of this file.
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 
19 #include <map>
20 
21 namespace llvm {
22 namespace orc {
23 
24 /// @brief Global mapping layer.
25 ///
26 /// This layer overrides the findSymbol method to first search a local symbol
27 /// table that the client can define. It can be used to inject new symbol
28 /// mappings into the JIT. Beware, however: symbols within a single IR module or
29 /// object file will still resolve locally (via RuntimeDyld's symbol table) -
30 /// such internal references cannot be overriden via this layer.
31 template <typename BaseLayerT>
33 public:
34  /// @brief Handle to a set of added modules.
35  typedef typename BaseLayerT::ModuleSetHandleT ModuleSetHandleT;
36 
37  /// @brief Construct an GlobalMappingLayer with the given BaseLayer
38  GlobalMappingLayer(BaseLayerT &BaseLayer) : BaseLayer(BaseLayer) {}
39 
40  /// @brief Add the given module set to the JIT.
41  /// @return A handle for the added modules.
42  template <typename ModuleSetT, typename MemoryManagerPtrT,
43  typename SymbolResolverPtrT>
45  MemoryManagerPtrT MemMgr,
46  SymbolResolverPtrT Resolver) {
47  return BaseLayer.addModuleSet(std::move(Ms), std::move(MemMgr),
48  std::move(Resolver));
49  }
50 
51  /// @brief Remove the module set associated with the handle H.
52  void removeModuleSet(ModuleSetHandleT H) { BaseLayer.removeModuleSet(H); }
53 
54  /// @brief Manually set the address to return for the given symbol.
55  void setGlobalMapping(const std::string &Name, JITTargetAddress Addr) {
56  SymbolTable[Name] = Addr;
57  }
58 
59  /// @brief Remove the given symbol from the global mapping.
60  void eraseGlobalMapping(const std::string &Name) {
61  SymbolTable.erase(Name);
62  }
63 
64  /// @brief Search for the given named symbol.
65  ///
66  /// This method will first search the local symbol table, returning
67  /// any symbol found there. If the symbol is not found in the local
68  /// table then this call will be passed through to the base layer.
69  ///
70  /// @param Name The name of the symbol to search for.
71  /// @param ExportedSymbolsOnly If true, search only for exported symbols.
72  /// @return A handle for the given named symbol, if it exists.
73  JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
74  auto I = SymbolTable.find(Name);
75  if (I != SymbolTable.end())
76  return JITSymbol(I->second, JITSymbolFlags::Exported);
77  return BaseLayer.findSymbol(Name, ExportedSymbolsOnly);
78  }
79 
80  /// @brief Get the address of the given symbol in the context of the set of
81  /// modules represented by the handle H. This call is forwarded to the
82  /// base layer's implementation.
83  /// @param H The handle for the module set to search in.
84  /// @param Name The name of the symbol to search for.
85  /// @param ExportedSymbolsOnly If true, search only for exported symbols.
86  /// @return A handle for the given named symbol, if it is found in the
87  /// given module set.
89  bool ExportedSymbolsOnly) {
90  return BaseLayer.findSymbolIn(H, Name, ExportedSymbolsOnly);
91  }
92 
93  /// @brief Immediately emit and finalize the module set represented by the
94  /// given handle.
95  /// @param H Handle for module set to emit/finalize.
97  BaseLayer.emitAndFinalize(H);
98  }
99 
100 private:
101  BaseLayerT &BaseLayer;
102  std::map<std::string, JITTargetAddress> SymbolTable;
103 };
104 
105 } // End namespace orc.
106 } // End namespace llvm.
107 
108 #endif // LLVM_EXECUTIONENGINE_ORC_GLOBALMAPPINGLAYER_H
Represents a symbol in the JIT.
Definition: JITSymbol.h:113
JITSymbol findSymbolIn(ModuleSetHandleT H, const std::string &Name, bool ExportedSymbolsOnly)
Get the address of the given symbol in the context of the set of modules represented by the handle H...
ModuleSetHandleT addModuleSet(ModuleSetT Ms, MemoryManagerPtrT MemMgr, SymbolResolverPtrT Resolver)
Add the given module set to the JIT.
BaseLayerT::ModuleSetHandleT ModuleSetHandleT
Handle to a set of added modules.
GlobalMappingLayer(BaseLayerT &BaseLayer)
Construct an GlobalMappingLayer with the given BaseLayer.
void eraseGlobalMapping(const std::string &Name)
Remove the given symbol from the global mapping.
#define H(x, y, z)
Definition: MD5.cpp:53
void emitAndFinalize(ModuleSetHandleT H)
Immediately emit and finalize the module set represented by the given handle.
uint64_t JITTargetAddress
Represents an address in the target process's address space.
Definition: JITSymbol.h:33
void setGlobalMapping(const std::string &Name, JITTargetAddress Addr)
Manually set the address to return for the given symbol.
JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly)
Search for the given named symbol.
void removeModuleSet(ModuleSetHandleT H)
Remove the module set associated with the handle H.
#define I(x, y, z)
Definition: MD5.cpp:54