LLVM  10.0.0svn
GlobalMappingLayer.h
Go to the documentation of this file.
1 //===- GlobalMappingLayer.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 // Convenience layer for injecting symbols that will appear in calls to
10 // findSymbol.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_EXECUTIONENGINE_ORC_GLOBALMAPPINGLAYER_H
15 #define LLVM_EXECUTIONENGINE_ORC_GLOBALMAPPINGLAYER_H
16 
18 #include <map>
19 #include <memory>
20 #include <string>
21 
22 namespace llvm {
23 
24 class Module;
25 class JITSymbolResolver;
26 
27 namespace orc {
28 
29 /// Global mapping layer.
30 ///
31 /// This layer overrides the findSymbol method to first search a local symbol
32 /// table that the client can define. It can be used to inject new symbol
33 /// mappings into the JIT. Beware, however: symbols within a single IR module or
34 /// object file will still resolve locally (via RuntimeDyld's symbol table) -
35 /// such internal references cannot be overriden via this layer.
36 template <typename BaseLayerT>
38 public:
39 
40  /// Handle to an added module.
41  using ModuleHandleT = typename BaseLayerT::ModuleHandleT;
42 
43  /// Construct an GlobalMappingLayer with the given BaseLayer
44  GlobalMappingLayer(BaseLayerT &BaseLayer) : BaseLayer(BaseLayer) {}
45 
46  /// Add the given module to the JIT.
47  /// @return A handle for the added modules.
49  addModule(std::shared_ptr<Module> M,
50  std::shared_ptr<JITSymbolResolver> Resolver) {
51  return BaseLayer.addModule(std::move(M), std::move(Resolver));
52  }
53 
54  /// Remove the module set associated with the handle H.
55  Error removeModule(ModuleHandleT H) { return BaseLayer.removeModule(H); }
56 
57  /// Manually set the address to return for the given symbol.
58  void setGlobalMapping(const std::string &Name, JITTargetAddress Addr) {
59  SymbolTable[Name] = Addr;
60  }
61 
62  /// Remove the given symbol from the global mapping.
63  void eraseGlobalMapping(const std::string &Name) {
64  SymbolTable.erase(Name);
65  }
66 
67  /// Search for the given named symbol.
68  ///
69  /// This method will first search the local symbol table, returning
70  /// any symbol found there. If the symbol is not found in the local
71  /// table then this call will be passed through to the base layer.
72  ///
73  /// @param Name The name of the symbol to search for.
74  /// @param ExportedSymbolsOnly If true, search only for exported symbols.
75  /// @return A handle for the given named symbol, if it exists.
76  JITSymbol findSymbol(const std::string &Name, bool ExportedSymbolsOnly) {
77  auto I = SymbolTable.find(Name);
78  if (I != SymbolTable.end())
79  return JITSymbol(I->second, JITSymbolFlags::Exported);
80  return BaseLayer.findSymbol(Name, ExportedSymbolsOnly);
81  }
82 
83  /// Get the address of the given symbol in the context of the of the
84  /// module represented by the handle H. This call is forwarded to the
85  /// base layer's implementation.
86  /// @param H The handle for the module to search in.
87  /// @param Name The name of the symbol to search for.
88  /// @param ExportedSymbolsOnly If true, search only for exported symbols.
89  /// @return A handle for the given named symbol, if it is found in the
90  /// given module.
91  JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name,
92  bool ExportedSymbolsOnly) {
93  return BaseLayer.findSymbolIn(H, Name, ExportedSymbolsOnly);
94  }
95 
96  /// Immediately emit and finalize the module set represented by the
97  /// given handle.
98  /// @param H Handle for module set to emit/finalize.
100  return BaseLayer.emitAndFinalize(H);
101  }
102 
103 private:
104  BaseLayerT &BaseLayer;
105  std::map<std::string, JITTargetAddress> SymbolTable;
106 };
107 
108 } // end namespace orc
109 } // end namespace llvm
110 
111 #endif // LLVM_EXECUTIONENGINE_ORC_GLOBALMAPPINGLAYER_H
Represents a symbol in the JIT.
Definition: JITSymbol.h:219
This class represents lattice values for constants.
Definition: AllocatorList.h:23
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
Expected< ModuleHandleT > addModule(std::shared_ptr< Module > M, std::shared_ptr< JITSymbolResolver > Resolver)
Add the given module to the JIT.
Tagged union holding either a T or a Error.
Definition: yaml2obj.h:21
typename BaseLayerT::ModuleHandleT ModuleHandleT
Handle to an added module.
GlobalMappingLayer(BaseLayerT &BaseLayer)
Construct an GlobalMappingLayer with the given BaseLayer.
uint64_t JITTargetAddress
Represents an address in the target process&#39;s address space.
Definition: JITSymbol.h:41
void eraseGlobalMapping(const std::string &Name)
Remove the given symbol from the global mapping.
#define H(x, y, z)
Definition: MD5.cpp:57
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:1863
Error emitAndFinalize(ModuleHandleT H)
Immediately emit and finalize the module set represented by the given handle.
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.
Error removeModule(ModuleHandleT H)
Remove the module set associated with the handle H.
#define I(x, y, z)
Definition: MD5.cpp:58
JITSymbol findSymbolIn(ModuleHandleT H, const std::string &Name, bool ExportedSymbolsOnly)
Get the address of the given symbol in the context of the of the module represented by the handle H...
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157