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