Added errno (or GetLastError code) to crash dump when systemAllocPages fails.

third_party/WebKit/Source/wtf/PageAllocator.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 19 matching lines @@
 
 #include "wtf/PageAllocator.h"
 
 #include "wtf/AddressSpaceRandomization.h"
 #include "wtf/Assertions.h"
 
 #include <limits.h>
 
 #if OS(POSIX)
 
+#include <errno.h>
 #include <sys/mman.h>
 
 #ifndef MADV_FREE
 #define MADV_FREE MADV_DONTNEED
 #endif
 
 #ifndef MAP_ANONYMOUS
 #define MAP_ANONYMOUS MAP_ANON
 #endif
 
 // On POSIX memmap uses a nearby address if the hint address is blocked.
 static const bool kHintIsAdvisory = true;
+static uint32_t allocPageErrorCode = 0;
 
 #elif OS(WIN)
 
 #include <windows.h>
 
 // VirtualAlloc will fail if allocation at the hint address is blocked.
 static const bool kHintIsAdvisory = false;
+static uint32_t allocPageErrorCode = ERROR_SUCCESS;
 
 #else
 #error Unknown OS
 #endif // OS(POSIX)
 
 namespace WTF {
 
 // This internal function wraps the OS-specific page allocation call. The
 // behavior of the hint address is determined by the kHintIsAdvisory constant.
 // If true, a non-zero hint is advisory and the returned address may differ from
 // the hint. If false, the hint is mandatory and a successful allocation will
 // not differ from the hint.
 static void* systemAllocPages(void* hint, size_t len, PageAccessibilityConfiguration pageAccessibility)
 {
     ASSERT(!(len & kPageAllocationGranularityOffsetMask));
     ASSERT(!(reinterpret_cast<uintptr_t>(hint) & kPageAllocationGranularityOffsetMask));
     void* ret;
 #if OS(WIN)
     DWORD accessFlag = pageAccessibility == PageAccessible ? PAGE_READWRITE : PAGE_NOACCESS;
     ret = VirtualAlloc(hint, len, MEM_RESERVE | MEM_COMMIT, accessFlag);
+    allocPageErrorCode = !ret ? GetLastError() : ERROR_SUCCESS;
 #else
     int accessFlag = pageAccessibility == PageAccessible ? (PROT_READ | PROT_WRITE) : PROT_NONE;
     ret = mmap(hint, len, accessFlag, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
-    if (ret == MAP_FAILED)
+    if (ret == MAP_FAILED) {
+        allocPageErrorCode = errno;
         ret = 0;
+    } else {
+        allocPageErrorCode = 0;
+    }
 #endif
     return ret;
 }
 
 // Trims base to given length and alignment. Windows returns null on failure and frees base.
 static void* trimMapping(void *base, size_t baseLen, size_t trimLen, uintptr_t align, PageAccessibilityConfiguration pageAccessibility)
 {
     size_t preSlack = reinterpret_cast<uintptr_t>(base) & (align - 1);
     if (preSlack)
         preSlack = align - preSlack;
@@ skipping 160 matching lines @@
     if (discardVirtualMemory)
         ret = discardVirtualMemory(addr, len);
     // DiscardVirtualMemory is buggy in Win10 SP0, so fall back to MEM_RESET on failure.
     if (ret) {
         void* ret = VirtualAlloc(addr, len, MEM_RESET, PAGE_READWRITE);
         RELEASE_ASSERT(ret);
     }
 #endif
 }
 
+uint32_t getAllocPageErrorCode()
+{
+    return allocPageErrorCode;
+}
+
 } // namespace WTF