Oilpan: Make Oilpan crash at a never-inlined function when hitting OOM

Source/platform/heap/Heap.cpp

 /*
  * 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 152 matching lines @@
     }
 
     Address base() const { return m_base; }
     size_t size() const { return m_size; }
 
 private:
     Address m_base;
     size_t m_size;
 };
 
+// TODO(haraken): Like partitionOutOfMemoryWithLotsOfUncommitedPages(),
+// we should probably have a way to distinguish physical memory OOM from
+// virtual address space OOM.
+static NEVER_INLINE void blinkGCOutOfMemory()
+{
+#if OS(WIN)
+    // Crash at a special address (0x9b)
+    // to be easily distinguished on crash reports.
+    // This is because crash stack traces are inaccurate on Windows and
+    // blinkGCOutOfMemory might be not included in the stack traces.
+    reinterpret_cast<void(*)()>(0x9b)();
+#endif
+
+    // On non-Windows environment, IMMEDIATE_CRASH is sufficient
+    // because blinkGCOutOfMemory will appear in crash stack traces.
+    IMMEDIATE_CRASH();
+}
+
 // A PageMemoryRegion represents a chunk of reserved virtual address
 // space containing a number of blink heap pages. On Windows, reserved
 // virtual address space can only be given back to the system as a
 // whole. The PageMemoryRegion allows us to do that by keeping track
 // of the number of pages using it in order to be able to release all
 // of the virtual address space when there are no more pages using it.
 class PageMemoryRegion : public MemoryRegion {
 public:
     ~PageMemoryRegion()
     {
@@ skipping 58 matching lines @@
         size_t offset = blinkPageAddress(address) - base();
         ASSERT(offset % blinkPageSize == 0);
         return offset / blinkPageSize;
     }
 
     static PageMemoryRegion* allocate(size_t size, unsigned numPages)
     {
         // Round size up to the allocation granularity.
         size = (size + WTF::kPageAllocationGranularityOffsetMask) & WTF::kPageAllocationGranularityBaseMask;
         Address base = static_cast<Address>(WTF::allocPages(nullptr, size, blinkPageSize));
-        RELEASE_ASSERT(base);
+        if (!base)
+            blinkGCOutOfMemory();
         WTF::setSystemPagesInaccessible(base, size);
         return new PageMemoryRegion(base, size, numPages);
     }
 
     bool m_isLargePage;
     bool m_inUse[blinkPagesPerRegion];
     unsigned m_numPages;
 };
 
 // Representation of the memory used for a Blink heap page.
@@ skipping 2565 matching lines @@
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 
 size_t Heap::s_externallyAllocatedBytes = 0;
 size_t Heap::s_externallyAllocatedBytesAlive = 0;
 unsigned Heap::s_requestedUrgentGC = false;
 double Heap::s_markingTimeInLastGC = 0.0;
 
 } // namespace blink