[Support] Reverted r357058 and r351916, MemoryBlock class now exposes its allocated size instead of requested size.

[mvhooren]

Summary

Renamed member 'Size' to 'AllocatedSize' in MemoryBlock and OwningMemoryBlock in order to provide a hint that the allocated size may be different than the requested size. Comments were added to clarify this point.
Updated the InMemoryBuffer in FileOutputBuffer.cpp to track the requested buffer size.

Recently, MemoryBlock was changed so that its 'Size' member holds the size that was requested with allocateMappedMemory instead of the size that was actually allocated by allocateMappedMemory. The allocated size is usually (much) larger than the requested size.
This caused a large waste of memory, as in 100s of MBs in my use case, because on Windows allocateMappedMemory returns memory with a granularity of 64kb (16 pages) and SectionMemoryManager previously assumed that the blocks were multiples of the page size (4kb) as it would be on Unix/Linux systems, in the worst case causing 60kb of wasted memory for each allocation on Windows.

Also see bug: https://bugs.llvm.org/show_bug.cgi?id=41690

[mvhooren]

I do not have commit access by the way. This is also my first time contributing to llvm :-).

[lhames]

I don't think this is the right solution. MemoryBlock's purpose is to track the allocated memory. What the client does with that memory (including subdividing it) is their business. The client already knows the number of bytes they're requesting, so the fix for fragmentation in SectionMemoryManager should be limited to fixes in SectionMemoryManager.

[mvhooren]

In D61599#1493889, @lhames wrote:

I don't think this is the right solution. MemoryBlock's purpose is to track the allocated memory. What the client does with that memory (including subdividing it) is their business. The client already knows the number of bytes they're requesting, so the fix for fragmentation in SectionMemoryManager should be limited to fixes in SectionMemoryManager.

Yes I agree it would be better if the Size member of MemoryBlock just held the allocated size. This would mean that r357058 and r351916 (and perhaps others) should be reverted.

[lhames]

Yes I agree it would be better if the Size member of MemoryBlock just held the allocated size. This would mean that r357058 and r351916 (and perhaps others) should be reverted.

I agree. To (hopefully) catch all call sites I think we will want to revert, but use your suggested "allocatedSize" name for the method. That should allow us to find and fix any call sites that are making bogus assumptions.

[mvhooren]

In D61599#1494000, @lhames wrote:

Yes I agree it would be better if the Size member of MemoryBlock just held the allocated size. This would mean that r357058 and r351916 (and perhaps others) should be reverted.

I agree. To (hopefully) catch all call sites I think we will want to revert, but use your suggested "allocatedSize" name for the method. That should allow us to find and fix any call sites that are making bogus assumptions.

Alright I will update and resubmit the patch tomorrow.

[lhames]

Great! Thanks so much Machiel!

[andrewng]

In D61599#1493926, @mvhooren wrote:

In D61599#1493889, @lhames wrote:

I don't think this is the right solution. MemoryBlock's purpose is to track the allocated memory. What the client does with that memory (including subdividing it) is their business. The client already knows the number of bytes they're requesting, so the fix for fragmentation in SectionMemoryManager should be limited to fixes in SectionMemoryManager.

Yes I agree it would be better if the Size member of MemoryBlock just held the allocated size. This would mean that r357058 and r351916 (and perhaps others) should be reverted.

By making the Size member be the allocated rather than the requested size effectively reverts those two revisions. To address the issue that r357058 and r351916 fixed, you will need to change the class InMemoryBuffer in FileOutputBuffer.cpp to itself track the requested size rather than use the allocated size from MemoryBlock.

This does seem to be the better solution, given the interface and other usages of MemoryBlock. When I made the change in r357058, I just mirrored the change in r351916, assuming that was the appropriate approach.

Cheers,
Andrew

[mvhooren]

Reverted changes from revisions r357058 and r351916 as discussed. Updated the InMemoryBuffer in FileOutputBuffer.cpp to track the requested buffer size.
The Size member of MemoryBlock and OwningMemoryBlock was renamed to AllocatedSize in order to provide a hint that the allocated size may be different than the requested size. I also added some comments to further clarify this point.
I have checked all the call sites of MemoryBlock::size() and as far as I can tell, FileOutputBuffer is the only location where wrong assumptions were made about the size.

[mvhooren]

Looking at FileOutputBuffer, I wonder why it is using MemoryBlock/allocateMappedMemory at all. It probably should be using something like a WritableMemoryBuffer instead.
I have not changed this because it is a little beyond the scope of this patch, but it might be worth investigating. Perhaps it does have a requirement somewhere that its memory should be page-aligned, but if so it is not obvious from looking at it.

[mvhooren]

Patch was missing context in the diff, updated the patch with full context.

[andrewng]

Some of the changes in "lib/Support/Unix/Memory.inc" don't appear to have been clang formatted.

lib/Support/FileOutputBuffer.cpp

78–82

Minor nit, perhaps bufferSize -> BufSize to match current naming convention?

[mvhooren]

Applied Clang Format to the changed files. Renamed bufferSize -> BufSize to match naming convention..

[andrewng]

In D61599#1497031, @mvhooren wrote:

Applied Clang Format to the changed files. Renamed bufferSize -> BufSize to match naming convention..

I think you may have applied clang-format to the whole file which has introduced quite a few formatting-only changes to your patch. The guidelines are to only clang-format the changed parts of the code, so that it is easier to see the "real" changes. See http://llvm.org/docs/GettingStarted.html#sending-patches for how to achieve this.

Otherwise, it looks fine to me, but probably best to get one of the other reviewers to give the OK too.

[mvhooren]

Removed changes done by clang-format that are not related to this patch.

[lhames]

Looks good to me. Thanks so much for all your work on this Machiel!

Do you have commit access? If not I can commit on your behalf.

[lhames]

Formally accepting so Phab does not gripe at me when this gets committed. :)

[mvhooren]

In D61599#1501916, @lhames wrote:

Looks good to me. Thanks so much for all your work on this Machiel!

Do you have commit access? If not I can commit on your behalf.

Thanks for reviewing, and thanks to andrewng as well, sorry about the newbie mistakes.

No, I don't have commit access so if you could commit, that would be great.

[lhames]

Committed in r361195.

include/llvm/Support/Memory.h

namespace sys {
 
   /// This class encapsulates the notion of a memory block which has an address
   /// and a size. It is used by the Memory class (a friend) as the result of
   /// various memory allocation operations.
   /// @see Memory
   /// Memory block abstraction.
   class MemoryBlock {
   public:
-    MemoryBlock() : Address(nullptr), Size(0) { }
-    MemoryBlock(void *addr, size_t size) : Address(addr), Size(size) { }
+    MemoryBlock() : Address(nullptr), AllocatedSize(0) {}
+    MemoryBlock(void *addr, size_t allocatedSize)
+        : Address(addr), AllocatedSize(allocatedSize) {}
     void *base() const { return Address; }
-    size_t size() const { return Size; }
+    /// The size as it was allocated. This is always greater or equal to the
+    /// size that was originally requested.
+    size_t allocatedSize() const { return AllocatedSize; }
   
   private:
     void *Address;    ///< Address of first byte of memory area
-    size_t Size;      ///< Size, in bytes of the memory area
+    size_t AllocatedSize; ///< Size, in bytes of the memory area
     unsigned Flags = 0;
     friend class Memory;
   };
 
   /// This class provides various memory handling functions that manipulate
   /// MemoryBlock instances.
   /// @since 1.4
   /// An abstraction for memory operations.
OwningMemoryBlock& operator=(OwningMemoryBlock &&Other) {
       M = Other.M;
       Other.M = MemoryBlock();
       return *this;
     }
     ~OwningMemoryBlock() {
       Memory::releaseMappedMemory(M);
     }
     void *base() const { return M.base(); }
-    size_t size() const { return M.size(); }
+    /// The size as it was allocated. This is always greater or equal to the
+    /// size that was originally requested.
+    size_t allocatedSize() const { return M.allocatedSize(); }
     MemoryBlock getMemoryBlock() const { return M; }
   private:
     MemoryBlock M;
   };
 
 #ifndef NDEBUG
   /// Debugging output for Memory::ProtectionFlags.
   raw_ostream &operator<<(raw_ostream &OS, const Memory::ProtectionFlags &PF);
 
   /// Debugging output for MemoryBlock.
   raw_ostream &operator<<(raw_ostream &OS, const MemoryBlock &MB);
 #endif // ifndef NDEBUG
   }    // end namespace sys
   }    // end namespace llvm
 
 #endif

lib/ExecutionEngine/JITLink/JITLink.cpp

InProcessMemoryManager::allocate(const SegmentsRequestMap &Request) {
 
   // Local class for allocation.
   class IPMMAlloc : public Allocation {
   public:
     IPMMAlloc(AllocationMap SegBlocks) : SegBlocks(std::move(SegBlocks)) {}
     MutableArrayRef<char> getWorkingMemory(ProtectionFlags Seg) override {
       assert(SegBlocks.count(Seg) && "No allocation for segment");
       return {static_cast<char *>(SegBlocks[Seg].base()),
-              SegBlocks[Seg].size()};
+              SegBlocks[Seg].allocatedSize()};
     }
     JITTargetAddress getTargetMemory(ProtectionFlags Seg) override {
       assert(SegBlocks.count(Seg) && "No allocation for segment");
       return reinterpret_cast<JITTargetAddress>(SegBlocks[Seg].base());
     }
     void finalizeAsync(FinalizeContinuation OnFinalize) override {
       OnFinalize(applyProtections());
     }
     Error deallocate() override {
       for (auto &KV : SegBlocks)
         if (auto EC = sys::Memory::releaseMappedMemory(KV.second))
           return errorCodeToError(EC);
       return Error::success();
     }
 
   private:
     Error applyProtections() {
       for (auto &KV : SegBlocks) {
         auto &Prot = KV.first;
         auto &Block = KV.second;
         if (auto EC = sys::Memory::protectMappedMemory(Block, Prot))
           return errorCodeToError(EC);
         if (Prot & sys::Memory::MF_EXEC)
-          sys::Memory::InvalidateInstructionCache(Block.base(), Block.size());
+          sys::Memory::InvalidateInstructionCache(Block.base(),
+                                                  Block.allocatedSize());
       }
       return Error::success();
     }
 
     AllocationMap SegBlocks;
   };
 
   AllocationMap Blocks;

lib/ExecutionEngine/SectionMemoryManager.cpp

case AllocationPurpose::RWData:
       return RWDataMem;
     }
     llvm_unreachable("Unknown SectionMemoryManager::AllocationPurpose");
   }();
 
   // Look in the list of free memory regions and use a block there if one
   // is available.
   for (FreeMemBlock &FreeMB : MemGroup.FreeMem) {
-    if (FreeMB.Free.size() >= RequiredSize) {
+    if (FreeMB.Free.allocatedSize() >= RequiredSize) {
       Addr = (uintptr_t)FreeMB.Free.base();
-      uintptr_t EndOfBlock = Addr + FreeMB.Free.size();
+      uintptr_t EndOfBlock = Addr + FreeMB.Free.allocatedSize();
       // Align the address.
       Addr = (Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1);
 
       if (FreeMB.PendingPrefixIndex == (unsigned)-1) {
         // The part of the block we're giving out to the user is now pending
         MemGroup.PendingMem.push_back(sys::MemoryBlock((void *)Addr, Size));
 
         // Remember this pending block, such that future allocations can just
uint8_t *SectionMemoryManager::allocateSection(
   }
 
   // Save this address as the basis for our next request
   MemGroup.Near = MB;
 
   // Remember that we allocated this memory
   MemGroup.AllocatedMem.push_back(MB);
   Addr = (uintptr_t)MB.base();
-  uintptr_t EndOfBlock = Addr + MB.size();
+  uintptr_t EndOfBlock = Addr + MB.allocatedSize();
 
   // Align the address.
   Addr = (Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1);
 
   // The part of the block we're giving out to the user is now pending
   MemGroup.PendingMem.push_back(sys::MemoryBlock((void *)Addr, Size));
 
   // The allocateMappedMemory may allocate much more memory than we need. In

 }
 
 static sys::MemoryBlock trimBlockToPageSize(sys::MemoryBlock M) {
   static const size_t PageSize = sys::Process::getPageSizeEstimate();
 
   size_t StartOverlap =
       (PageSize - ((uintptr_t)M.base() % PageSize)) % PageSize;
 
-  size_t TrimmedSize = M.size();
+  size_t TrimmedSize = M.allocatedSize();
   TrimmedSize -= StartOverlap;
   TrimmedSize -= TrimmedSize % PageSize;
 
   sys::MemoryBlock Trimmed((void *)((uintptr_t)M.base() + StartOverlap),
                            TrimmedSize);
 
   assert(((uintptr_t)Trimmed.base() % PageSize) == 0);
-  assert((Trimmed.size() % PageSize) == 0);
-  assert(M.base() <= Trimmed.base() && Trimmed.size() <= M.size());
+  assert((Trimmed.allocatedSize() % PageSize) == 0);
+  assert(M.base() <= Trimmed.base() &&
+         Trimmed.allocatedSize() <= M.allocatedSize());
 
   return Trimmed;
 }
 
 std::error_code
 SectionMemoryManager::applyMemoryGroupPermissions(MemoryGroup &MemGroup,
                                                   unsigned Permissions) {
   for (sys::MemoryBlock &MB : MemGroup.PendingMem)
     if (std::error_code EC = MMapper.protectMappedMemory(MB, Permissions))
       return EC;
 
   MemGroup.PendingMem.clear();
 
   // Now go through free blocks and trim any of them that don't span the entire
   // page because one of the pending blocks may have overlapped it.
   for (FreeMemBlock &FreeMB : MemGroup.FreeMem) {
     FreeMB.Free = trimBlockToPageSize(FreeMB.Free);
     // We cleared the PendingMem list, so all these pointers are now invalid
     FreeMB.PendingPrefixIndex = (unsigned)-1;
   }
 
   // Remove all blocks which are now empty
-  MemGroup.FreeMem.erase(
-      remove_if(MemGroup.FreeMem,
-                [](FreeMemBlock &FreeMB) { return FreeMB.Free.size() == 0; }),
+  MemGroup.FreeMem.erase(remove_if(MemGroup.FreeMem,
+                                   [](FreeMemBlock &FreeMB) {
+                                     return FreeMB.Free.allocatedSize() == 0;
+                                   }),
                          MemGroup.FreeMem.end());
 
   return std::error_code();
 }
 
 void SectionMemoryManager::invalidateInstructionCache() {
   for (sys::MemoryBlock &Block : CodeMem.PendingMem)
-    sys::Memory::InvalidateInstructionCache(Block.base(), Block.size());
+    sys::Memory::InvalidateInstructionCache(Block.base(),
+                                            Block.allocatedSize());
 }
 
 SectionMemoryManager::~SectionMemoryManager() {
   for (MemoryGroup *Group : {&CodeMem, &RWDataMem, &RODataMem}) {
     for (sys::MemoryBlock &Block : Group->AllocatedMem)
       MMapper.releaseMappedMemory(Block);
   }
 }
 
 SectionMemoryManager::MemoryMapper::~MemoryMapper() {}
 
 void SectionMemoryManager::anchor() {}
 
 namespace {
 // Trivial implementation of SectionMemoryManager::MemoryMapper that just calls
 // into sys::Memory.
 class DefaultMMapper final : public SectionMemoryManager::MemoryMapper {
 public:
   sys::MemoryBlock
   allocateMappedMemory(SectionMemoryManager::AllocationPurpose Purpose,
                        size_t NumBytes, const sys::MemoryBlock *const NearBlock,
                        unsigned Flags, std::error_code &EC) override {
-    // allocateMappedMemory calls mmap(2). We round up a request size
-    // to page size to get extra space for free.
-    static const size_t PageSize = sys::Process::getPageSizeEstimate();
-    size_t ReqBytes = (NumBytes + PageSize - 1) & ~(PageSize - 1);
-    return sys::Memory::allocateMappedMemory(ReqBytes, NearBlock, Flags, EC);
+    return sys::Memory::allocateMappedMemory(NumBytes, NearBlock, Flags, EC);
   }
 
   std::error_code protectMappedMemory(const sys::MemoryBlock &Block,
                                       unsigned Flags) override {
     return sys::Memory::protectMappedMemory(Block, Flags);
   }
 
   std::error_code releaseMappedMemory(sys::MemoryBlock &M) override {

lib/Support/FileOutputBuffer.cpp

private:
   std::unique_ptr<fs::mapped_file_region> Buffer;
   fs::TempFile Temp;
 };
 
 // A FileOutputBuffer which keeps data in memory and writes to the final
 // output file on commit(). This is used only when we cannot use OnDiskBuffer.
 class InMemoryBuffer : public FileOutputBuffer {
 public:
-  InMemoryBuffer(StringRef Path, MemoryBlock Buf, unsigned Mode)
-      : FileOutputBuffer(Path), Buffer(Buf), Mode(Mode) {}
+  InMemoryBuffer(StringRef Path, MemoryBlock Buf, std::size_t BufSize,
+                 unsigned Mode)
+      : FileOutputBuffer(Path), Buffer(Buf), BufferSize(BufSize),
+        Mode(Mode) {}
 
   uint8_t *getBufferStart() const override { return (uint8_t *)Buffer.base(); }
 
   uint8_t *getBufferEnd() const override {
-    return (uint8_t *)Buffer.base() + Buffer.size();
+    return (uint8_t *)Buffer.base() + BufferSize;
   }
 
-  size_t getBufferSize() const override { return Buffer.size(); }
+  size_t getBufferSize() const override { return BufferSize; }
 
   Error commit() override {
     if (FinalPath == "-") {
-      llvm::outs() << StringRef((const char *)Buffer.base(), Buffer.size());
+      llvm::outs() << StringRef((const char *)Buffer.base(), BufferSize);
       llvm::outs().flush();
       return Error::success();
     }
 
     using namespace sys::fs;
     int FD;
     std::error_code EC;
     if (auto EC =
             openFileForWrite(FinalPath, FD, CD_CreateAlways, OF_None, Mode))
       return errorCodeToError(EC);
     raw_fd_ostream OS(FD, /*shouldClose=*/true, /*unbuffered=*/true);
-    OS << StringRef((const char *)Buffer.base(), Buffer.size());
+    OS << StringRef((const char *)Buffer.base(), BufferSize);
     return Error::success();
   }
 
 private:
+  // Buffer may actually contain a larger memory block than BufferSize
   OwningMemoryBlock Buffer;
+  size_t BufferSize;
   unsigned Mode;
 };
 } // namespace
 
 static Expected<std::unique_ptr<InMemoryBuffer>>
 createInMemoryBuffer(StringRef Path, size_t Size, unsigned Mode) {
   std::error_code EC;
   MemoryBlock MB = Memory::allocateMappedMemory(
       Size, nullptr, sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC);
   if (EC)
     return errorCodeToError(EC);
-  return llvm::make_unique<InMemoryBuffer>(Path, MB, Mode);
+  return llvm::make_unique<InMemoryBuffer>(Path, MB, Size, Mode);
 }
 
 static Expected<std::unique_ptr<FileOutputBuffer>>
 createOnDiskBuffer(StringRef Path, size_t Size, unsigned Mode) {
   Expected<fs::TempFile> FileOrErr =
       fs::TempFile::create(Path + ".tmp%%%%%%%", Mode);
   if (!FileOrErr)
     return FileOrErr.takeError();

lib/Support/Memory.cpp

raw_ostream &operator<<(raw_ostream &OS, const Memory::ProtectionFlags &PF) {
 
   return OS << (PF & Memory::MF_READ ? 'R' : '-')
             << (PF & Memory::MF_WRITE ? 'W' : '-')
             << (PF & Memory::MF_EXEC ? 'X' : '-');
 }
 
 raw_ostream &operator<<(raw_ostream &OS, const MemoryBlock &MB) {
   return OS << "[ " << MB.base() << " .. "
-            << (void *)((char *)MB.base() + MB.size()) << " ] (" << MB.size()
-            << " bytes)";
+            << (void *)((char *)MB.base() + MB.allocatedSize()) << " ] ("
+            << MB.allocatedSize() << " bytes)";
 }
 
 } // end namespace sys
 } // end namespace llvm
 
 #endif // ifndef NDEBUG

lib/Support/Unix/Memory.inc

Memory::allocateMappedMemory(size_t NumBytes,
   int Protect = getPosixProtectionFlags(PFlags);
 
 #if defined(__NetBSD__) && defined(PROT_MPROTECT)
   Protect |= PROT_MPROTECT(PROT_READ | PROT_WRITE | PROT_EXEC);
 #endif
 
   // Use any near hint and the page size to set a page-aligned starting address
   uintptr_t Start = NearBlock ? reinterpret_cast<uintptr_t>(NearBlock->base()) +
-                                      NearBlock->size() : 0;
+                                      NearBlock->allocatedSize() : 0;
   static const size_t PageSize = Process::getPageSizeEstimate();
+  const size_t NumPages = (NumBytes+PageSize-1)/PageSize;
+
   if (Start && Start % PageSize)
     Start += PageSize - Start % PageSize;
 
   // FIXME: Handle huge page requests (MF_HUGE_HINT).
-  void *Addr = ::mmap(reinterpret_cast<void *>(Start), NumBytes, Protect,
+  void *Addr = ::mmap(reinterpret_cast<void *>(Start), PageSize*NumPages, Protect,
                       MMFlags, fd, 0);
   if (Addr == MAP_FAILED) {
     if (NearBlock) //Try again without a near hint
       return allocateMappedMemory(NumBytes, nullptr, PFlags, EC);
 
     EC = std::error_code(errno, std::generic_category());
     return MemoryBlock();
   }
 
   MemoryBlock Result;
   Result.Address = Addr;
-  Result.Size = NumBytes;
+  Result.AllocatedSize = PageSize*NumPages;
   Result.Flags = PFlags;
 
   // Rely on protectMappedMemory to invalidate instruction cache.
   if (PFlags & MF_EXEC) {
     EC = Memory::protectMappedMemory (Result, PFlags);
     if (EC != std::error_code())
       return MemoryBlock();
   }
 
   return Result;
 }
 
 std::error_code
 Memory::releaseMappedMemory(MemoryBlock &M) {
-  if (M.Address == nullptr || M.Size == 0)
+  if (M.Address == nullptr || M.AllocatedSize == 0)
     return std::error_code();
 
-  if (0 != ::munmap(M.Address, M.Size))
+  if (0 != ::munmap(M.Address, M.AllocatedSize))
     return std::error_code(errno, std::generic_category());
 
   M.Address = nullptr;
-  M.Size = 0;
+  M.AllocatedSize = 0;
 
   return std::error_code();
 }
 
 std::error_code
 Memory::protectMappedMemory(const MemoryBlock &M, unsigned Flags) {
   static const size_t PageSize = Process::getPageSizeEstimate();
-  if (M.Address == nullptr || M.Size == 0)
+  if (M.Address == nullptr || M.AllocatedSize == 0)
     return std::error_code();
 
   if (!Flags)
     return std::error_code(EINVAL, std::generic_category());
 
   int Protect = getPosixProtectionFlags(Flags);
   uintptr_t Start = alignAddr((uint8_t *)M.Address - PageSize + 1, PageSize);
-  uintptr_t End = alignAddr((uint8_t *)M.Address + M.Size, PageSize);
+  uintptr_t End = alignAddr((uint8_t *)M.Address + M.AllocatedSize, PageSize);
 
   bool InvalidateCache = (Flags & MF_EXEC);
 
 #if defined(__arm__) || defined(__aarch64__)
   // Certain ARM implementations treat icache clear instruction as a memory read,
   // and CPU segfaults on trying to clear cache on !PROT_READ page.  Therefore we need
   // to temporarily add PROT_READ for the sake of flushing the instruction caches.
   if (InvalidateCache && !(Protect & PROT_READ)) {
     int Result = ::mprotect((void *)Start, End - Start, Protect | PROT_READ);
     if (Result != 0)
       return std::error_code(errno, std::generic_category());
 
-    Memory::InvalidateInstructionCache(M.Address, M.Size);
+    Memory::InvalidateInstructionCache(M.Address, M.AllocatedSize);
     InvalidateCache = false;
   }
 #endif
 
   int Result = ::mprotect((void *)Start, End - Start, Protect);
 
   if (Result != 0)
     return std::error_code(errno, std::generic_category());
 
   if (InvalidateCache)
-    Memory::InvalidateInstructionCache(M.Address, M.Size);
+    Memory::InvalidateInstructionCache(M.Address, M.AllocatedSize);
 
   return std::error_code();
 }
 
 /// InvalidateInstructionCache - Before the JIT can run a block of code
 /// that has been emitted it must invalidate the instruction cache on some
 /// platforms.
 void Memory::InvalidateInstructionCache(const void *Addr,

lib/Support/Windows/Memory.inc

if ((Flags & MF_HUGE_HINT) && LargePageGranularity > 0) {
     AllocType |= MEM_LARGE_PAGES;
     HugePages = true;
     Granularity = LargePageGranularity;
   }
 
   size_t NumBlocks = (NumBytes + Granularity - 1) / Granularity;
 
   uintptr_t Start = NearBlock ? reinterpret_cast<uintptr_t>(NearBlock->base()) +
-                                NearBlock->size()
+                                NearBlock->allocatedSize()
                            : 0;
 
   // If the requested address is not aligned to the allocation granularity,
   // round up to get beyond NearBlock. VirtualAlloc would have rounded down.
   if (Start && Start % Granularity != 0)
     Start += Granularity - Start % Granularity;
 
   DWORD Protect = getWindowsProtectionFlags(Flags);
 
   size_t AllocSize = NumBlocks * Granularity;
   void *PA = ::VirtualAlloc(reinterpret_cast<void *>(Start),
                             AllocSize, AllocType, Protect);
   if (PA == NULL) {
     if (NearBlock || HugePages) {
       // Try again without the NearBlock hint and without large memory pages
       return allocateMappedMemory(NumBytes, NULL, Flags & ~MF_HUGE_HINT, EC);
     }
     EC = mapWindowsError(::GetLastError());
     return MemoryBlock();
   }
 
   MemoryBlock Result;
   Result.Address = PA;
-  Result.Size = NumBytes;
+  Result.AllocatedSize = AllocSize;
   Result.Flags = (Flags & ~MF_HUGE_HINT) | (HugePages ? MF_HUGE_HINT : 0);
 
   if (Flags & MF_EXEC)
     Memory::InvalidateInstructionCache(Result.Address, AllocSize);
 
   return Result;
 }
 
   std::error_code Memory::releaseMappedMemory(MemoryBlock &M) {
-  if (M.Address == 0 || M.Size == 0)
+  if (M.Address == 0 || M.AllocatedSize == 0)
     return std::error_code();
 
   if (!VirtualFree(M.Address, 0, MEM_RELEASE))
     return mapWindowsError(::GetLastError());
 
   M.Address = 0;
-  M.Size = 0;
+  M.AllocatedSize = 0;
 
   return std::error_code();
 }
 
   std::error_code Memory::protectMappedMemory(const MemoryBlock &M,
                                        unsigned Flags) {
-  if (M.Address == 0 || M.Size == 0)
+  if (M.Address == 0 || M.AllocatedSize == 0)
     return std::error_code();
 
   DWORD Protect = getWindowsProtectionFlags(Flags);
 
   DWORD OldFlags;
-  if (!VirtualProtect(M.Address, M.Size, Protect, &OldFlags))
+  if (!VirtualProtect(M.Address, M.AllocatedSize, Protect, &OldFlags))
     return mapWindowsError(::GetLastError());
 
   if (Flags & MF_EXEC)
-    Memory::InvalidateInstructionCache(M.Address, M.Size);
+    Memory::InvalidateInstructionCache(M.Address, M.AllocatedSize);
 
   return std::error_code();
 }
 
 /// InvalidateInstructionCache - Before the JIT can run a block of code
 /// that has been emitted it must invalidate the instruction cache on some
 /// platforms.
 void Memory::InvalidateInstructionCache(
     const void *Addr, size_t Len) {
   FlushInstructionCache(GetCurrentProcess(), Addr, Len);
 }
 
 } // namespace sys
 } // namespace llvm

tools/llvm-rtdyld/llvm-rtdyld.cpp

for (WorklistT::iterator I = Worklist.begin(), E = Worklist.end();
     auto LoadAddr = Dyld.getSectionLoadAddress((*Tmp)->SectionID);
 
     if (LoadAddr != static_cast<uint64_t>(
           reinterpret_cast<uintptr_t>((*Tmp)->MB.base()))) {
       // A section will have a LoadAddr of 0 if it wasn't loaded for whatever
       // reason (e.g. zero byte COFF sections). Don't include those sections in
       // the allocation map.
       if (LoadAddr != 0)
-        AlreadyAllocated[LoadAddr] = (*Tmp)->MB.size();
+        AlreadyAllocated[LoadAddr] = (*Tmp)->MB.allocatedSize();
       Worklist.erase(Tmp);
     }
   }
 
   // If the -target-addr-end option wasn't explicitly passed, then set it to a
   // sensible default based on the target triple.
   if (TargetAddrEnd.getNumOccurrences() == 0) {
     if (TargetTriple.isArch16Bit())
       TargetAddrEnd = (1ULL << 16) - 1;
     else if (TargetTriple.isArch32Bit())
       TargetAddrEnd = (1ULL << 32) - 1;
     // TargetAddrEnd already has a sensible default for 64-bit systems, so
     // there's nothing to do in the 64-bit case.
   }
 
   // Process any elements remaining in the worklist.
   while (!Worklist.empty()) {
     auto *CurEntry = Worklist.front();
     Worklist.pop_front();
 
     uint64_t NextSectionAddr = TargetAddrStart;
 
     for (const auto &Alloc : AlreadyAllocated)
-      if (NextSectionAddr + CurEntry->MB.size() + TargetSectionSep <= Alloc.first)
+      if (NextSectionAddr + CurEntry->MB.allocatedSize() + TargetSectionSep <=
+          Alloc.first)
         break;
       else
         NextSectionAddr = Alloc.first + Alloc.second + TargetSectionSep;
 
     Dyld.mapSectionAddress(CurEntry->MB.base(), NextSectionAddr);
-    AlreadyAllocated[NextSectionAddr] = CurEntry->MB.size();
+    AlreadyAllocated[NextSectionAddr] = CurEntry->MB.allocatedSize();
   }
 
   // Add dummy symbols to the memory manager.
   for (const auto &Mapping : DummySymbolMappings) {
     size_t EqualsIdx = Mapping.find_first_of('=');
 
     if (EqualsIdx == StringRef::npos)
       report_fatal_error("Invalid dummy symbol specification '" + Mapping +

unittests/Support/MemoryTest.cpp

protected:
   }
 
   // Returns true if the memory blocks overlap
   bool doesOverlap(MemoryBlock M1, MemoryBlock M2) {
     if (M1.base() == M2.base())
       return true;
 
     if (M1.base() > M2.base())
-      return (unsigned char *)M2.base() + M2.size() > M1.base();
+      return (unsigned char *)M2.base() + M2.allocatedSize() > M1.base();
 
-    return (unsigned char *)M1.base() + M1.size() > M2.base();
+    return (unsigned char *)M1.base() + M1.allocatedSize() > M2.base();
   }
 
   unsigned Flags;
   size_t   PageSize;
 };
 
 // MPROTECT prevents W+X mmaps
 #define CHECK_UNSUPPORTED() \
   do { \
     if ((Flags & Memory::MF_WRITE) && (Flags & Memory::MF_EXEC) && \
         IsMPROTECT()) \
       return; \
   } while (0)
 
 TEST_P(MappedMemoryTest, AllocAndRelease) {
   CHECK_UNSUPPORTED();
   std::error_code EC;
   MemoryBlock M1 = Memory::allocateMappedMemory(sizeof(int), nullptr, Flags,EC);
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(sizeof(int), M1.size());
+  EXPECT_LE(sizeof(int), M1.allocatedSize());
 
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 }
 
 TEST_P(MappedMemoryTest, AllocAndReleaseHuge) {
   CHECK_UNSUPPORTED();
   std::error_code EC;
   MemoryBlock M1 = Memory::allocateMappedMemory(
       sizeof(int), nullptr, Flags | Memory::MF_HUGE_HINT, EC);
   EXPECT_EQ(std::error_code(), EC);
 
   // Test large/huge memory pages. In the worst case, 4kb pages should be
   // returned, if large pages aren't available.
 
   EXPECT_NE((void *)nullptr, M1.base());
-  EXPECT_LE(sizeof(int), M1.size());
+  EXPECT_LE(sizeof(int), M1.allocatedSize());
 
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 }
 
 TEST_P(MappedMemoryTest, MultipleAllocAndRelease) {
   CHECK_UNSUPPORTED();
   std::error_code EC;
   MemoryBlock M1 = Memory::allocateMappedMemory(16, nullptr, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
   MemoryBlock M2 = Memory::allocateMappedMemory(64, nullptr, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
   MemoryBlock M3 = Memory::allocateMappedMemory(32, nullptr, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(16U, M1.size());
+  EXPECT_LE(16U, M1.allocatedSize());
   EXPECT_NE((void*)nullptr, M2.base());
-  EXPECT_LE(64U, M2.size());
+  EXPECT_LE(64U, M2.allocatedSize());
   EXPECT_NE((void*)nullptr, M3.base());
-  EXPECT_LE(32U, M3.size());
+  EXPECT_LE(32U, M3.allocatedSize());
 
   EXPECT_FALSE(doesOverlap(M1, M2));
   EXPECT_FALSE(doesOverlap(M2, M3));
   EXPECT_FALSE(doesOverlap(M1, M3));
 
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
   MemoryBlock M4 = Memory::allocateMappedMemory(16, nullptr, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
   EXPECT_NE((void*)nullptr, M4.base());
-  EXPECT_LE(16U, M4.size());
+  EXPECT_LE(16U, M4.allocatedSize());
   EXPECT_FALSE(Memory::releaseMappedMemory(M4));
   EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 }
 
 TEST_P(MappedMemoryTest, BasicWrite) {
   // This test applies only to readable and writeable combinations
   if (Flags &&
       !((Flags & Memory::MF_READ) && (Flags & Memory::MF_WRITE)))
     return;
   CHECK_UNSUPPORTED();
 
   std::error_code EC;
   MemoryBlock M1 = Memory::allocateMappedMemory(sizeof(int), nullptr, Flags,EC);
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(sizeof(int), M1.size());
+  EXPECT_LE(sizeof(int), M1.allocatedSize());
 
   int *a = (int*)M1.base();
   *a = 1;
   EXPECT_EQ(1, *a);
 
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 }
 
MemoryBlock M3 = Memory::allocateMappedMemory(4 * sizeof(int), nullptr, Flags,
                                                 EC);
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_FALSE(doesOverlap(M1, M2));
   EXPECT_FALSE(doesOverlap(M2, M3));
   EXPECT_FALSE(doesOverlap(M1, M3));
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(1U * sizeof(int), M1.size());
+  EXPECT_LE(1U * sizeof(int), M1.allocatedSize());
   EXPECT_NE((void*)nullptr, M2.base());
-  EXPECT_LE(8U * sizeof(int), M2.size());
+  EXPECT_LE(8U * sizeof(int), M2.allocatedSize());
   EXPECT_NE((void*)nullptr, M3.base());
-  EXPECT_LE(4U * sizeof(int), M3.size());
+  EXPECT_LE(4U * sizeof(int), M3.allocatedSize());
 
   int *x = (int*)M1.base();
   *x = 1;
 
   int *y = (int*)M2.base();
   for (int i = 0; i < 8; i++) {
     y[i] = i;
   }
 
   int *z = (int*)M3.base();
   *z = 42;
 
   EXPECT_EQ(1, *x);
   EXPECT_EQ(7, y[7]);
   EXPECT_EQ(42, *z);
 
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
 
   MemoryBlock M4 = Memory::allocateMappedMemory(64 * sizeof(int), nullptr,
                                                 Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
   EXPECT_NE((void*)nullptr, M4.base());
-  EXPECT_LE(64U * sizeof(int), M4.size());
+  EXPECT_LE(64U * sizeof(int), M4.allocatedSize());
   x = (int*)M4.base();
   *x = 4;
   EXPECT_EQ(4, *x);
   EXPECT_FALSE(Memory::releaseMappedMemory(M4));
 
   // Verify that M2 remains unaffected by other activity
   for (int i = 0; i < 8; i++) {
     EXPECT_EQ(i, y[i]);
TEST_P(MappedMemoryTest, EnabledWrite) {
   MemoryBlock M2 = Memory::allocateMappedMemory(8 * sizeof(int), nullptr, Flags,
                                                 EC);
   EXPECT_EQ(std::error_code(), EC);
   MemoryBlock M3 = Memory::allocateMappedMemory(4 * sizeof(int), nullptr, Flags,
                                                 EC);
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(2U * sizeof(int), M1.size());
+  EXPECT_LE(2U * sizeof(int), M1.allocatedSize());
   EXPECT_NE((void*)nullptr, M2.base());
-  EXPECT_LE(8U * sizeof(int), M2.size());
+  EXPECT_LE(8U * sizeof(int), M2.allocatedSize());
   EXPECT_NE((void*)nullptr, M3.base());
-  EXPECT_LE(4U * sizeof(int), M3.size());
+  EXPECT_LE(4U * sizeof(int), M3.allocatedSize());
 
   EXPECT_FALSE(Memory::protectMappedMemory(M1, getTestableEquivalent(Flags)));
   EXPECT_FALSE(Memory::protectMappedMemory(M2, getTestableEquivalent(Flags)));
   EXPECT_FALSE(Memory::protectMappedMemory(M3, getTestableEquivalent(Flags)));
 
   EXPECT_FALSE(doesOverlap(M1, M2));
   EXPECT_FALSE(doesOverlap(M2, M3));
   EXPECT_FALSE(doesOverlap(M1, M3));
TEST_P(MappedMemoryTest, EnabledWrite) {
 
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
   EXPECT_EQ(6, y[6]);
 
   MemoryBlock M4 = Memory::allocateMappedMemory(16, nullptr, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
   EXPECT_NE((void*)nullptr, M4.base());
-  EXPECT_LE(16U, M4.size());
+  EXPECT_LE(16U, M4.allocatedSize());
   EXPECT_EQ(std::error_code(),
             Memory::protectMappedMemory(M4, getTestableEquivalent(Flags)));
   x = (int*)M4.base();
   *x = 4;
   EXPECT_EQ(4, *x);
   EXPECT_FALSE(Memory::releaseMappedMemory(M4));
   EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 }
 
 TEST_P(MappedMemoryTest, SuccessiveNear) {
   CHECK_UNSUPPORTED();
   std::error_code EC;
   MemoryBlock M1 = Memory::allocateMappedMemory(16, nullptr, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
   MemoryBlock M2 = Memory::allocateMappedMemory(64, &M1, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
   MemoryBlock M3 = Memory::allocateMappedMemory(32, &M2, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(16U, M1.size());
+  EXPECT_LE(16U, M1.allocatedSize());
   EXPECT_NE((void*)nullptr, M2.base());
-  EXPECT_LE(64U, M2.size());
+  EXPECT_LE(64U, M2.allocatedSize());
   EXPECT_NE((void*)nullptr, M3.base());
-  EXPECT_LE(32U, M3.size());
+  EXPECT_LE(32U, M3.allocatedSize());
 
   EXPECT_FALSE(doesOverlap(M1, M2));
   EXPECT_FALSE(doesOverlap(M2, M3));
   EXPECT_FALSE(doesOverlap(M1, M3));
 
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
   EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 }
 
 TEST_P(MappedMemoryTest, DuplicateNear) {
   CHECK_UNSUPPORTED();
   std::error_code EC;
   MemoryBlock Near((void*)(3*PageSize), 16);
   MemoryBlock M1 = Memory::allocateMappedMemory(16, &Near, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
   MemoryBlock M2 = Memory::allocateMappedMemory(64, &Near, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
   MemoryBlock M3 = Memory::allocateMappedMemory(32, &Near, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(16U, M1.size());
+  EXPECT_LE(16U, M1.allocatedSize());
   EXPECT_NE((void*)nullptr, M2.base());
-  EXPECT_LE(64U, M2.size());
+  EXPECT_LE(64U, M2.allocatedSize());
   EXPECT_NE((void*)nullptr, M3.base());
-  EXPECT_LE(32U, M3.size());
+  EXPECT_LE(32U, M3.allocatedSize());
 
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
   EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 }
 
 TEST_P(MappedMemoryTest, ZeroNear) {
   CHECK_UNSUPPORTED();
   std::error_code EC;
   MemoryBlock Near(nullptr, 0);
   MemoryBlock M1 = Memory::allocateMappedMemory(16, &Near, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
   MemoryBlock M2 = Memory::allocateMappedMemory(64, &Near, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
   MemoryBlock M3 = Memory::allocateMappedMemory(32, &Near, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(16U, M1.size());
+  EXPECT_LE(16U, M1.allocatedSize());
   EXPECT_NE((void*)nullptr, M2.base());
-  EXPECT_LE(64U, M2.size());
+  EXPECT_LE(64U, M2.allocatedSize());
   EXPECT_NE((void*)nullptr, M3.base());
-  EXPECT_LE(32U, M3.size());
+  EXPECT_LE(32U, M3.allocatedSize());
 
   EXPECT_FALSE(doesOverlap(M1, M2));
   EXPECT_FALSE(doesOverlap(M2, M3));
   EXPECT_FALSE(doesOverlap(M1, M3));
 
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
   EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 }
 
 TEST_P(MappedMemoryTest, ZeroSizeNear) {
   CHECK_UNSUPPORTED();
   std::error_code EC;
   MemoryBlock Near((void*)(4*PageSize), 0);
   MemoryBlock M1 = Memory::allocateMappedMemory(16, &Near, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
   MemoryBlock M2 = Memory::allocateMappedMemory(64, &Near, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
   MemoryBlock M3 = Memory::allocateMappedMemory(32, &Near, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(16U, M1.size());
+  EXPECT_LE(16U, M1.allocatedSize());
   EXPECT_NE((void*)nullptr, M2.base());
-  EXPECT_LE(64U, M2.size());
+  EXPECT_LE(64U, M2.allocatedSize());
   EXPECT_NE((void*)nullptr, M3.base());
-  EXPECT_LE(32U, M3.size());
+  EXPECT_LE(32U, M3.allocatedSize());
 
   EXPECT_FALSE(doesOverlap(M1, M2));
   EXPECT_FALSE(doesOverlap(M2, M3));
   EXPECT_FALSE(doesOverlap(M1, M3));
 
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
   EXPECT_FALSE(Memory::releaseMappedMemory(M2));
 }
 
 TEST_P(MappedMemoryTest, UnalignedNear) {
   CHECK_UNSUPPORTED();
   std::error_code EC;
   MemoryBlock Near((void*)(2*PageSize+5), 0);
   MemoryBlock M1 = Memory::allocateMappedMemory(15, &Near, Flags, EC);
   EXPECT_EQ(std::error_code(), EC);
 
   EXPECT_NE((void*)nullptr, M1.base());
-  EXPECT_LE(sizeof(int), M1.size());
+  EXPECT_LE(sizeof(int), M1.allocatedSize());
 
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
 }
 
 // Note that Memory::MF_WRITE is not supported exclusively across
 // operating systems and architectures and can imply MF_READ|MF_WRITE
 unsigned MemoryFlags[] = {
                            Memory::MF_READ,