1 | //===-- RTDyldMemoryManager.cpp - Memory manager for MC-JIT -----*- 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 | // Interface of the runtime dynamic memory manager base class. |
11 | // |
12 | //===----------------------------------------------------------------------===// |
13 | |
14 | #ifndef LLVM_EXECUTIONENGINE_RTDYLDMEMORYMANAGER_H |
15 | #define LLVM_EXECUTIONENGINE_RTDYLDMEMORYMANAGER_H |
16 | |
17 | #include "llvm-c/ExecutionEngine.h" |
18 | #include "llvm/ExecutionEngine/JITSymbol.h" |
19 | #include "llvm/ExecutionEngine/RuntimeDyld.h" |
20 | #include "llvm/Support/CBindingWrapping.h" |
21 | #include <cstddef> |
22 | #include <cstdint> |
23 | #include <string> |
24 | |
25 | namespace llvm { |
26 | |
27 | class ExecutionEngine; |
28 | |
29 | namespace object { |
30 | class ObjectFile; |
31 | } // end namespace object |
32 | |
33 | class MCJITMemoryManager : public RuntimeDyld::MemoryManager { |
34 | public: |
35 | // Don't hide the notifyObjectLoaded method from RuntimeDyld::MemoryManager. |
36 | using RuntimeDyld::MemoryManager::notifyObjectLoaded; |
37 | |
38 | /// This method is called after an object has been loaded into memory but |
39 | /// before relocations are applied to the loaded sections. The object load |
40 | /// may have been initiated by MCJIT to resolve an external symbol for another |
41 | /// object that is being finalized. In that case, the object about which |
42 | /// the memory manager is being notified will be finalized immediately after |
43 | /// the memory manager returns from this call. |
44 | /// |
45 | /// Memory managers which are preparing code for execution in an external |
46 | /// address space can use this call to remap the section addresses for the |
47 | /// newly loaded object. |
48 | virtual void notifyObjectLoaded(ExecutionEngine *EE, |
49 | const object::ObjectFile &) {} |
50 | |
51 | private: |
52 | void anchor() override; |
53 | }; |
54 | |
55 | // RuntimeDyld clients often want to handle the memory management of |
56 | // what gets placed where. For JIT clients, this is the subset of |
57 | // JITMemoryManager required for dynamic loading of binaries. |
58 | // |
59 | // FIXME: As the RuntimeDyld fills out, additional routines will be needed |
60 | // for the varying types of objects to be allocated. |
61 | class RTDyldMemoryManager : public MCJITMemoryManager, |
62 | public LegacyJITSymbolResolver { |
63 | public: |
64 | RTDyldMemoryManager() = default; |
65 | RTDyldMemoryManager(const RTDyldMemoryManager&) = delete; |
66 | void operator=(const RTDyldMemoryManager&) = delete; |
67 | ~RTDyldMemoryManager() override; |
68 | |
69 | /// Register EH frames in the current process. |
70 | static void registerEHFramesInProcess(uint8_t *Addr, size_t Size); |
71 | |
72 | /// Deregister EH frames in the current proces. |
73 | static void deregisterEHFramesInProcess(uint8_t *Addr, size_t Size); |
74 | |
75 | void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) override; |
76 | void deregisterEHFrames() override; |
77 | |
78 | /// This method returns the address of the specified function or variable in |
79 | /// the current process. |
80 | static uint64_t getSymbolAddressInProcess(const std::string &Name); |
81 | |
82 | /// Legacy symbol lookup - DEPRECATED! Please override findSymbol instead. |
83 | /// |
84 | /// This method returns the address of the specified function or variable. |
85 | /// It is used to resolve symbols during module linking. |
86 | virtual uint64_t getSymbolAddress(const std::string &Name) { |
87 | return getSymbolAddressInProcess(Name); |
88 | } |
89 | |
90 | /// This method returns a RuntimeDyld::SymbolInfo for the specified function |
91 | /// or variable. It is used to resolve symbols during module linking. |
92 | /// |
93 | /// By default this falls back on the legacy lookup method: |
94 | /// 'getSymbolAddress'. The address returned by getSymbolAddress is treated as |
95 | /// a strong, exported symbol, consistent with historical treatment by |
96 | /// RuntimeDyld. |
97 | /// |
98 | /// Clients writing custom RTDyldMemoryManagers are encouraged to override |
99 | /// this method and return a SymbolInfo with the flags set correctly. This is |
100 | /// necessary for RuntimeDyld to correctly handle weak and non-exported symbols. |
101 | JITSymbol findSymbol(const std::string &Name) override { |
102 | return JITSymbol(getSymbolAddress(Name), JITSymbolFlags::Exported); |
103 | } |
104 | |
105 | /// Legacy symbol lookup -- DEPRECATED! Please override |
106 | /// findSymbolInLogicalDylib instead. |
107 | /// |
108 | /// Default to treating all modules as separate. |
109 | virtual uint64_t getSymbolAddressInLogicalDylib(const std::string &Name) { |
110 | return 0; |
111 | } |
112 | |
113 | /// Default to treating all modules as separate. |
114 | /// |
115 | /// By default this falls back on the legacy lookup method: |
116 | /// 'getSymbolAddressInLogicalDylib'. The address returned by |
117 | /// getSymbolAddressInLogicalDylib is treated as a strong, exported symbol, |
118 | /// consistent with historical treatment by RuntimeDyld. |
119 | /// |
120 | /// Clients writing custom RTDyldMemoryManagers are encouraged to override |
121 | /// this method and return a SymbolInfo with the flags set correctly. This is |
122 | /// necessary for RuntimeDyld to correctly handle weak and non-exported symbols. |
123 | JITSymbol |
124 | findSymbolInLogicalDylib(const std::string &Name) override { |
125 | return JITSymbol(getSymbolAddressInLogicalDylib(Name), |
126 | JITSymbolFlags::Exported); |
127 | } |
128 | |
129 | /// This method returns the address of the specified function. As such it is |
130 | /// only useful for resolving library symbols, not code generated symbols. |
131 | /// |
132 | /// If \p AbortOnFailure is false and no function with the given name is |
133 | /// found, this function returns a null pointer. Otherwise, it prints a |
134 | /// message to stderr and aborts. |
135 | /// |
136 | /// This function is deprecated for memory managers to be used with |
137 | /// MCJIT or RuntimeDyld. Use getSymbolAddress instead. |
138 | virtual void *getPointerToNamedFunction(const std::string &Name, |
139 | bool AbortOnFailure = true); |
140 | |
141 | protected: |
142 | struct EHFrame { |
143 | uint8_t *Addr; |
144 | size_t Size; |
145 | }; |
146 | typedef std::vector<EHFrame> EHFrameInfos; |
147 | EHFrameInfos EHFrames; |
148 | |
149 | private: |
150 | void anchor() override; |
151 | }; |
152 | |
153 | // Create wrappers for C Binding types (see CBindingWrapping.h). |
154 | DEFINE_SIMPLE_CONVERSION_FUNCTIONS( |
155 | RTDyldMemoryManager, LLVMMCJITMemoryManagerRef) |
156 | |
157 | } // end namespace llvm |
158 | |
159 | #endif // LLVM_EXECUTIONENGINE_RTDYLDMEMORYMANAGER_H |
160 | |