LLVM  4.0.0
SectionMemoryManager.cpp
Go to the documentation of this file.
1 //===- SectionMemoryManager.cpp - Memory manager for MCJIT/RtDyld *- 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 // This file implements the section-based memory manager used by the MCJIT
11 // execution engine and RuntimeDyld
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/Config/config.h"
18 #include "llvm/Support/Process.h"
19 
20 namespace llvm {
21 
23  unsigned Alignment,
24  unsigned SectionID,
26  bool IsReadOnly) {
27  if (IsReadOnly)
28  return allocateSection(RODataMem, Size, Alignment);
29  return allocateSection(RWDataMem, Size, Alignment);
30 }
31 
33  unsigned Alignment,
34  unsigned SectionID,
36  return allocateSection(CodeMem, Size, Alignment);
37 }
38 
39 uint8_t *SectionMemoryManager::allocateSection(MemoryGroup &MemGroup,
40  uintptr_t Size,
41  unsigned Alignment) {
42  if (!Alignment)
43  Alignment = 16;
44 
45  assert(!(Alignment & (Alignment - 1)) && "Alignment must be a power of two.");
46 
47  uintptr_t RequiredSize = Alignment * ((Size + Alignment - 1)/Alignment + 1);
48  uintptr_t Addr = 0;
49 
50  // Look in the list of free memory regions and use a block there if one
51  // is available.
52  for (FreeMemBlock &FreeMB : MemGroup.FreeMem) {
53  if (FreeMB.Free.size() >= RequiredSize) {
54  Addr = (uintptr_t)FreeMB.Free.base();
55  uintptr_t EndOfBlock = Addr + FreeMB.Free.size();
56  // Align the address.
57  Addr = (Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1);
58 
59  if (FreeMB.PendingPrefixIndex == (unsigned)-1) {
60  // The part of the block we're giving out to the user is now pending
61  MemGroup.PendingMem.push_back(sys::MemoryBlock((void *)Addr, Size));
62 
63  // Remember this pending block, such that future allocations can just
64  // modify it rather than creating a new one
65  FreeMB.PendingPrefixIndex = MemGroup.PendingMem.size() - 1;
66  } else {
67  sys::MemoryBlock &PendingMB = MemGroup.PendingMem[FreeMB.PendingPrefixIndex];
68  PendingMB = sys::MemoryBlock(PendingMB.base(), Addr + Size - (uintptr_t)PendingMB.base());
69  }
70 
71  // Remember how much free space is now left in this block
72  FreeMB.Free = sys::MemoryBlock((void *)(Addr + Size), EndOfBlock - Addr - Size);
73  return (uint8_t*)Addr;
74  }
75  }
76 
77  // No pre-allocated free block was large enough. Allocate a new memory region.
78  // Note that all sections get allocated as read-write. The permissions will
79  // be updated later based on memory group.
80  //
81  // FIXME: It would be useful to define a default allocation size (or add
82  // it as a constructor parameter) to minimize the number of allocations.
83  //
84  // FIXME: Initialize the Near member for each memory group to avoid
85  // interleaving.
86  std::error_code ec;
87  sys::MemoryBlock MB = sys::Memory::allocateMappedMemory(RequiredSize,
88  &MemGroup.Near,
91  ec);
92  if (ec) {
93  // FIXME: Add error propagation to the interface.
94  return nullptr;
95  }
96 
97  // Save this address as the basis for our next request
98  MemGroup.Near = MB;
99 
100  // Remember that we allocated this memory
101  MemGroup.AllocatedMem.push_back(MB);
102  Addr = (uintptr_t)MB.base();
103  uintptr_t EndOfBlock = Addr + MB.size();
104 
105  // Align the address.
106  Addr = (Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1);
107 
108  // The part of the block we're giving out to the user is now pending
109  MemGroup.PendingMem.push_back(sys::MemoryBlock((void *)Addr, Size));
110 
111  // The allocateMappedMemory may allocate much more memory than we need. In
112  // this case, we store the unused memory as a free memory block.
113  unsigned FreeSize = EndOfBlock-Addr-Size;
114  if (FreeSize > 16) {
115  FreeMemBlock FreeMB;
116  FreeMB.Free = sys::MemoryBlock((void*)(Addr + Size), FreeSize);
117  FreeMB.PendingPrefixIndex = (unsigned)-1;
118  MemGroup.FreeMem.push_back(FreeMB);
119  }
120 
121  // Return aligned address
122  return (uint8_t*)Addr;
123 }
124 
125 bool SectionMemoryManager::finalizeMemory(std::string *ErrMsg)
126 {
127  // FIXME: Should in-progress permissions be reverted if an error occurs?
128  std::error_code ec;
129 
130  // Make code memory executable.
131  ec = applyMemoryGroupPermissions(CodeMem,
133  if (ec) {
134  if (ErrMsg) {
135  *ErrMsg = ec.message();
136  }
137  return true;
138  }
139 
140  // Make read-only data memory read-only.
141  ec = applyMemoryGroupPermissions(RODataMem,
143  if (ec) {
144  if (ErrMsg) {
145  *ErrMsg = ec.message();
146  }
147  return true;
148  }
149 
150  // Read-write data memory already has the correct permissions
151 
152  // Some platforms with separate data cache and instruction cache require
153  // explicit cache flush, otherwise JIT code manipulations (like resolved
154  // relocations) will get to the data cache but not to the instruction cache.
156 
157  return false;
158 }
159 
161  static const size_t PageSize = sys::Process::getPageSize();
162 
163  size_t StartOverlap =
164  (PageSize - ((uintptr_t)M.base() % PageSize)) % PageSize;
165 
166  size_t TrimmedSize = M.size();
167  TrimmedSize -= StartOverlap;
168  TrimmedSize -= TrimmedSize % PageSize;
169 
170  sys::MemoryBlock Trimmed((void *)((uintptr_t)M.base() + StartOverlap), TrimmedSize);
171 
172  assert(((uintptr_t)Trimmed.base() % PageSize) == 0);
173  assert((Trimmed.size() % PageSize) == 0);
174  assert(M.base() <= Trimmed.base() && Trimmed.size() <= M.size());
175 
176  return Trimmed;
177 }
178 
179 
180 std::error_code
181 SectionMemoryManager::applyMemoryGroupPermissions(MemoryGroup &MemGroup,
182  unsigned Permissions) {
183  for (sys::MemoryBlock &MB : MemGroup.PendingMem)
184  if (std::error_code EC = sys::Memory::protectMappedMemory(MB, Permissions))
185  return EC;
186 
187  MemGroup.PendingMem.clear();
188 
189  // Now go through free blocks and trim any of them that don't span the entire
190  // page because one of the pending blocks may have overlapped it.
191  for (FreeMemBlock &FreeMB : MemGroup.FreeMem) {
192  FreeMB.Free = trimBlockToPageSize(FreeMB.Free);
193  // We cleared the PendingMem list, so all these pointers are now invalid
194  FreeMB.PendingPrefixIndex = (unsigned)-1;
195  }
196 
197  // Remove all blocks which are now empty
198  MemGroup.FreeMem.erase(
199  remove_if(MemGroup.FreeMem,
200  [](FreeMemBlock &FreeMB) { return FreeMB.Free.size() == 0; }),
201  MemGroup.FreeMem.end());
202 
203  return std::error_code();
204 }
205 
206 void SectionMemoryManager::invalidateInstructionCache() {
207  for (sys::MemoryBlock &Block : CodeMem.PendingMem)
208  sys::Memory::InvalidateInstructionCache(Block.base(), Block.size());
209 }
210 
211 SectionMemoryManager::~SectionMemoryManager() {
212  for (MemoryGroup *Group : {&CodeMem, &RWDataMem, &RODataMem}) {
213  for (sys::MemoryBlock &Block : Group->AllocatedMem)
214  sys::Memory::releaseMappedMemory(Block);
215  }
216 }
217 
218 } // namespace llvm
auto remove_if(R &&Range, UnaryPredicate P) -> decltype(std::begin(Range))
Provide wrappers to std::remove_if which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:776
static MemoryBlock allocateMappedMemory(size_t NumBytes, const MemoryBlock *const NearBlock, unsigned Flags, std::error_code &EC)
This method allocates a block of memory that is suitable for loading dynamically generated code (e...
virtual void invalidateInstructionCache()
Invalidate instruction cache for code sections.
static cl::opt< int > PageSize("imp-null-check-page-size", cl::desc("The page size of the target in bytes"), cl::init(4096))
uint8_t * allocateCodeSection(uintptr_t Size, unsigned Alignment, unsigned SectionID, StringRef SectionName) override
Allocates a memory block of (at least) the given size suitable for executable code.
uint8_t * allocateDataSection(uintptr_t Size, unsigned Alignment, unsigned SectionID, StringRef SectionName, bool isReadOnly) override
Allocates a memory block of (at least) the given size suitable for executable code.
static unsigned getPageSize()
size_t size() const
Definition: Memory.h:34
static sys::MemoryBlock trimBlockToPageSize(sys::MemoryBlock M)
This class encapsulates the notion of a memory block which has an address and a size.
Definition: Memory.h:29
void * base() const
Definition: Memory.h:33
Provides a library for accessing information about this process and other processes on the operating ...
bool finalizeMemory(std::string *ErrMsg=nullptr) override
Update section-specific memory permissions and other attributes.
const char SectionName[]
Definition: AMDGPUPTNote.h:24
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
static std::error_code protectMappedMemory(const MemoryBlock &Block, unsigned Flags)
This method sets the protection flags for a block of memory to the state specified by /p Flags...