1 //===-- JITLinkMemoryManager.h - JITLink mem manager interface --*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 // Contains the JITLinkMemoryManager interface.
11 //===----------------------------------------------------------------------===//
13 #ifndef LLVM_EXECUTIONENGINE_JITLINK_JITLINKMEMORYMANAGER_H
14 #define LLVM_EXECUTIONENGINE_JITLINK_JITLINKMEMORYMANAGER_H
16 #include "llvm/ADT/DenseMap.h"
17 #include "llvm/ExecutionEngine/JITSymbol.h"
18 #include "llvm/Support/Error.h"
19 #include "llvm/Support/Memory.h"
20 #include "llvm/Support/MSVCErrorWorkarounds.h"
28 /// Manages allocations of JIT memory.
30 /// Instances of this class may be accessed concurrently from multiple threads
31 /// and their implemetations should include any necessary synchronization.
32 class JITLinkMemoryManager {
34 using ProtectionFlags = sys::Memory::ProtectionFlags;
36 class SegmentRequest {
38 SegmentRequest() = default;
39 SegmentRequest(uint64_t Alignment, size_t ContentSize,
40 uint64_t ZeroFillSize)
41 : Alignment(Alignment), ContentSize(ContentSize),
42 ZeroFillSize(ZeroFillSize) {
43 assert(isPowerOf2_32(Alignment) && "Alignment must be power of 2");
45 uint64_t getAlignment() const { return Alignment; }
46 size_t getContentSize() const { return ContentSize; }
47 uint64_t getZeroFillSize() const { return ZeroFillSize; }
49 uint64_t Alignment = 0;
50 size_t ContentSize = 0;
51 uint64_t ZeroFillSize = 0;
54 using SegmentsRequestMap = DenseMap<unsigned, SegmentRequest>;
56 /// Represents an allocation created by the memory manager.
58 /// An allocation object is responsible for allocating and owning jit-linker
59 /// working and target memory, and for transfering from working to target
64 using FinalizeContinuation = std::function<void(Error)>;
66 virtual ~Allocation();
68 /// Should return the address of linker working memory for the segment with
69 /// the given protection flags.
70 virtual MutableArrayRef<char> getWorkingMemory(ProtectionFlags Seg) = 0;
72 /// Should return the final address in the target process where the segment
74 virtual JITTargetAddress getTargetMemory(ProtectionFlags Seg) = 0;
76 /// Should transfer from working memory to target memory, and release
78 virtual void finalizeAsync(FinalizeContinuation OnFinalize) = 0;
80 /// Calls finalizeAsync and waits for completion.
82 std::promise<MSVCPError> FinalizeResultP;
83 auto FinalizeResultF = FinalizeResultP.get_future();
85 [&](Error Err) { FinalizeResultP.set_value(std::move(Err)); });
86 return FinalizeResultF.get();
89 /// Should deallocate target memory.
90 virtual Error deallocate() = 0;
93 virtual ~JITLinkMemoryManager();
95 /// Create an Allocation object.
96 virtual Expected<std::unique_ptr<Allocation>>
97 allocate(const SegmentsRequestMap &Request) = 0;
100 /// A JITLinkMemoryManager that allocates in-process memory.
101 class InProcessMemoryManager : public JITLinkMemoryManager {
103 Expected<std::unique_ptr<Allocation>>
104 allocate(const SegmentsRequestMap &Request) override;
107 } // end namespace jitlink
108 } // end namespace llvm
110 #endif // LLVM_EXECUTIONENGINE_JITLINK_JITLINK_H