Oilpan: Don't use guard pages in NaCl

Source/platform/heap/Heap.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 39 matching lines @@
 const size_t blinkPageSize = 1 << blinkPageSizeLog2;
 const size_t blinkPageOffsetMask = blinkPageSize - 1;
 const size_t blinkPageBaseMask = ~blinkPageOffsetMask;
 
 // We allocate pages at random addresses but in groups of
 // blinkPagesPerRegion at a given random address. We group pages to
 // not spread out too much over the address space which would blow
 // away the page tables and lead to bad performance.
 const size_t blinkPagesPerRegion = 10;
 
+// TODO(nya): Replace this with something like #if ENABLE_NACL.
+#if 0
+// NaCl's system page size is 64 KB. This causes a problem in Oilpan's heap
+// layout because Oilpan allocates two guard pages for each blink page
+// (whose size is 128 KB). So we don't use guard pages in NaCl.
+const size_t blinkGuardPageSize = 0;
+#else
+const size_t blinkGuardPageSize = WTF::kSystemPageSize;
+#endif
+
 // Double precision floats are more efficient when 8 byte aligned, so we 8 byte
 // align all allocations even on 32 bit.
 const size_t allocationGranularity = 8;
 const size_t allocationMask = allocationGranularity - 1;
 const size_t objectStartBitMapSize = (blinkPageSize + ((8 * allocationGranularity) - 1)) / (8 * allocationGranularity);
 const size_t reservedForObjectBitMap = ((objectStartBitMapSize + allocationMask) & ~allocationMask);
 const size_t maxHeapObjectSizeLog2 = 27;
 const size_t maxHeapObjectSize = 1 << maxHeapObjectSizeLog2;
 const size_t largeObjectSizeThreshold = blinkPageSize / 2;
 
@@ skipping 221 matching lines @@
         m_next = next;
     }
 
 private:
     FreeListEntry* m_next;
 };
 
 // Blink heap pages are set up with a guard page before and after the payload.
 inline size_t blinkPagePayloadSize()
 {
-    return blinkPageSize - 2 * WTF::kSystemPageSize;
+    return blinkPageSize - 2 * blinkGuardPageSize;
 }
 
 // Blink heap pages are aligned to the Blink heap page size.
 // Therefore, the start of a Blink page can be obtained by
 // rounding down to the Blink page size.
 inline Address roundToBlinkPageStart(Address address)
 {
     return reinterpret_cast<Address>(reinterpret_cast<uintptr_t>(address) & blinkPageBaseMask);
 }
 
@@ skipping 12 matching lines @@
 {
     return !!(*reinterpret_cast<Address*>(objectPointer));
 }
 
 #if ENABLE(ASSERT)
 // Sanity check for a page header address: the address of the page
 // header should be OS page size away from being Blink page size
 // aligned.
 inline bool isPageHeaderAddress(Address address)
 {
-    return !((reinterpret_cast<uintptr_t>(address) & blinkPageOffsetMask) - WTF::kSystemPageSize);
+    return !((reinterpret_cast<uintptr_t>(address) & blinkPageOffsetMask) - blinkGuardPageSize);
 }
 #endif
 
 // BasePage is a base class for NormalPage and LargeObjectPage.
 //
 // - NormalPage is a page whose size is |blinkPageSize|. NormalPage can contain
 //   multiple objects in the page. An object whose size is smaller than
 //   |largeObjectSizeThreshold| is stored in NormalPage.
 //
 // - LargeObjectPage is a page that contains only one object. The object size
@@ skipping 448 matching lines @@
     void freeLargeObjectPage(LargeObjectPage*);
 #if ENABLE(ASSERT)
     bool isConsistentForGC() override { return true; }
 #endif
 private:
     Address doAllocateLargeObjectPage(size_t, size_t gcInfoIndex);
     Address lazySweepPages(size_t, size_t gcInfoIndex) override;
 };
 
 // Mask an address down to the enclosing oilpan heap base page.  All oilpan heap
-// pages are aligned at blinkPageBase plus an OS page size.
+// pages are aligned at blinkPageBase plus the size of a guard size.
 // FIXME: Remove PLATFORM_EXPORT once we get a proper public interface to our
 // typed heaps.  This is only exported to enable tests in HeapTest.cpp.
 PLATFORM_EXPORT inline BasePage* pageFromObject(const void* object)
 {
     Address address = reinterpret_cast<Address>(const_cast<void*>(object));
-    BasePage* page = reinterpret_cast<BasePage*>(blinkPageAddress(address) + WTF::kSystemPageSize);
+    BasePage* page = reinterpret_cast<BasePage*>(blinkPageAddress(address) + blinkGuardPageSize);
     ASSERT(page->contains(address));
     return page;
 }
 
 template<typename T, bool = NeedsAdjustAndMark<T>::value> class ObjectAliveTrait;
 
 template<typename T>
 class ObjectAliveTrait<T, false> {
 public:
     static bool isHeapObjectAlive(T* object)
@@ skipping 572 matching lines @@
     size_t copySize = previousHeader->payloadSize();
     if (copySize > size)
         copySize = size;
     memcpy(address, previous, copySize);
     return address;
 }
 
 } // namespace blink
 
 #endif // Heap_h