|
147
|
1 //===--- JITLinkMemoryManager.cpp - JITLinkMemoryManager implementation ---===//
|
|
|
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 #include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
|
|
|
11 #include "llvm/Support/Process.h"
|
|
|
12
|
|
|
13 namespace llvm {
|
|
|
14 namespace jitlink {
|
|
|
15
|
|
|
16 JITLinkMemoryManager::~JITLinkMemoryManager() = default;
|
|
|
17 JITLinkMemoryManager::Allocation::~Allocation() = default;
|
|
|
18
|
|
|
19 Expected<std::unique_ptr<JITLinkMemoryManager::Allocation>>
|
|
|
20 InProcessMemoryManager::allocate(const SegmentsRequestMap &Request) {
|
|
|
21
|
|
|
22 using AllocationMap = DenseMap<unsigned, sys::MemoryBlock>;
|
|
|
23
|
|
|
24 // Local class for allocation.
|
|
|
25 class IPMMAlloc : public Allocation {
|
|
|
26 public:
|
|
|
27 IPMMAlloc(AllocationMap SegBlocks) : SegBlocks(std::move(SegBlocks)) {}
|
|
|
28 MutableArrayRef<char> getWorkingMemory(ProtectionFlags Seg) override {
|
|
|
29 assert(SegBlocks.count(Seg) && "No allocation for segment");
|
|
|
30 return {static_cast<char *>(SegBlocks[Seg].base()),
|
|
|
31 SegBlocks[Seg].allocatedSize()};
|
|
|
32 }
|
|
|
33 JITTargetAddress getTargetMemory(ProtectionFlags Seg) override {
|
|
|
34 assert(SegBlocks.count(Seg) && "No allocation for segment");
|
|
|
35 return reinterpret_cast<JITTargetAddress>(SegBlocks[Seg].base());
|
|
|
36 }
|
|
|
37 void finalizeAsync(FinalizeContinuation OnFinalize) override {
|
|
|
38 OnFinalize(applyProtections());
|
|
|
39 }
|
|
|
40 Error deallocate() override {
|
|
|
41 for (auto &KV : SegBlocks)
|
|
|
42 if (auto EC = sys::Memory::releaseMappedMemory(KV.second))
|
|
|
43 return errorCodeToError(EC);
|
|
|
44 return Error::success();
|
|
|
45 }
|
|
|
46
|
|
|
47 private:
|
|
|
48 Error applyProtections() {
|
|
|
49 for (auto &KV : SegBlocks) {
|
|
|
50 auto &Prot = KV.first;
|
|
|
51 auto &Block = KV.second;
|
|
|
52 if (auto EC = sys::Memory::protectMappedMemory(Block, Prot))
|
|
|
53 return errorCodeToError(EC);
|
|
|
54 if (Prot & sys::Memory::MF_EXEC)
|
|
|
55 sys::Memory::InvalidateInstructionCache(Block.base(),
|
|
|
56 Block.allocatedSize());
|
|
|
57 }
|
|
|
58 return Error::success();
|
|
|
59 }
|
|
|
60
|
|
|
61 AllocationMap SegBlocks;
|
|
|
62 };
|
|
|
63
|
|
|
64 AllocationMap Blocks;
|
|
|
65 const sys::Memory::ProtectionFlags ReadWrite =
|
|
|
66 static_cast<sys::Memory::ProtectionFlags>(sys::Memory::MF_READ |
|
|
|
67 sys::Memory::MF_WRITE);
|
|
|
68
|
|
|
69 for (auto &KV : Request) {
|
|
|
70 auto &Seg = KV.second;
|
|
|
71
|
|
|
72 if (Seg.getContentAlignment() > sys::Process::getPageSizeEstimate())
|
|
|
73 return make_error<StringError>("Cannot request higher than page "
|
|
|
74 "alignment",
|
|
|
75 inconvertibleErrorCode());
|
|
|
76
|
|
|
77 if (sys::Process::getPageSizeEstimate() % Seg.getContentAlignment() != 0)
|
|
|
78 return make_error<StringError>("Page size is not a multiple of "
|
|
|
79 "alignment",
|
|
|
80 inconvertibleErrorCode());
|
|
|
81
|
|
|
82 uint64_t ZeroFillStart =
|
|
|
83 alignTo(Seg.getContentSize(), Seg.getZeroFillAlignment());
|
|
|
84 uint64_t SegmentSize = ZeroFillStart + Seg.getZeroFillSize();
|
|
|
85
|
|
|
86 std::error_code EC;
|
|
|
87 auto SegMem =
|
|
|
88 sys::Memory::allocateMappedMemory(SegmentSize, nullptr, ReadWrite, EC);
|
|
|
89
|
|
|
90 if (EC)
|
|
|
91 return errorCodeToError(EC);
|
|
|
92
|
|
|
93 // Zero out the zero-fill memory.
|
|
|
94 memset(static_cast<char *>(SegMem.base()) + ZeroFillStart, 0,
|
|
|
95 Seg.getZeroFillSize());
|
|
|
96
|
|
|
97 // Record the block for this segment.
|
|
|
98 Blocks[KV.first] = std::move(SegMem);
|
|
|
99 }
|
|
|
100 return std::unique_ptr<InProcessMemoryManager::Allocation>(
|
|
|
101 new IPMMAlloc(std::move(Blocks)));
|
|
|
102 }
|
|
|
103
|
|
|
104 } // end namespace jitlink
|
|
|
105 } // end namespace llvm
|
