<pre style='margin:0'>
Christopher Nielsen (mascguy) pushed a commit to branch master
in repository macports-ports.

</pre>
<p><a href="https://github.com/macports/macports-ports/commit/a2575d01732589ebaf4bf6e4b151f42cb1c43f45">https://github.com/macports/macports-ports/commit/a2575d01732589ebaf4bf6e4b151f42cb1c43f45</a></p>
<pre style="white-space: pre; background: #F8F8F8"><span style='display:block; white-space:pre;color:#808000;'>commit a2575d01732589ebaf4bf6e4b151f42cb1c43f45
</span>Author: Christopher Chavez <chrischavez@gmx.us>
AuthorDate: Sat Jul 30 11:52:52 2022 -0500

<span style='display:block; white-space:pre;color:#404040;'>    qt(55|56|57|58|59|511|513)-qtwebkit: macOS 11+ fix
</span><span style='display:block; white-space:pre;color:#404040;'>    
</span><span style='display:block; white-space:pre;color:#404040;'>    See: https://trac.macports.org/ticket/62027#comment:49
</span><span style='display:block; white-space:pre;color:#404040;'>    
</span><span style='display:block; white-space:pre;color:#404040;'>    [skip ci]
</span>---
 aqua/qt511/Portfile                                |   7 +-
 .../qt511/files/patch-qtwebkit_fix_page_shift.diff | 384 +++++++++++++++++++++
 aqua/qt513/Portfile                                |   7 +-
 .../qt513/files/patch-qtwebkit_fix_page_shift.diff | 384 +++++++++++++++++++++
 aqua/qt55/Portfile                                 |   7 +-
 aqua/qt55/files/patch-qtwebkit_fix_page_shift.diff | 384 +++++++++++++++++++++
 aqua/qt56/Portfile                                 |   7 +-
 aqua/qt56/files/patch-qtwebkit_fix_page_shift.diff | 384 +++++++++++++++++++++
 aqua/qt57/Portfile                                 |   7 +-
 aqua/qt57/files/patch-qtwebkit_fix_page_shift.diff | 384 +++++++++++++++++++++
 aqua/qt58/Portfile                                 |   7 +-
 aqua/qt58/files/patch-qtwebkit_fix_page_shift.diff | 384 +++++++++++++++++++++
 aqua/qt59/Portfile                                 |   7 +-
 aqua/qt59/files/patch-qtwebkit_fix_page_shift.diff | 384 +++++++++++++++++++++
 14 files changed, 2730 insertions(+), 7 deletions(-)

<span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt511/Portfile b/aqua/qt511/Portfile
</span><span style='display:block; white-space:pre;color:#808080;'>index f436d89f177..30fd739f2b0 100644
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>--- a/aqua/qt511/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt511/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -632,7 +632,7 @@ array set modules {
</span>         {"Qt WebKit" "Qt WebKit Widgets"}
         "community support only (use Qt WebEngine)"
         "variant overrides: "
<span style='display:block; white-space:pre;background:#ffe0e0;'>-        "revision 3"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        "revision 4"
</span>         "License: "
     }
     qtwebkit-examples {
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -1423,6 +1423,11 @@ foreach {module module_info} [array get modules] {
</span>                 # see https://bugs.webkit.org/show_bug.cgi?id=171612
                 patchfiles-append patch-qtwebkit_fix_icu.diff
 
<span style='display:block; white-space:pre;background:#e0ffe0;'>+                # backport upstream WebKit changes to avoid
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # error: "Unsupported PAGE_SHIFT amount"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # see https://trac.macports.org/ticket/62027#comment:49
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                patchfiles-append patch-qtwebkit_fix_page_shift.diff
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span>                 # work around https://trac.macports.org/ticket/60975
                 patchfiles-append patch-webkit_XPathGrammar.y.diff
                 patchfiles-append patch-webkit_makegrammar.pl.diff
<span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt511/files/patch-qtwebkit_fix_page_shift.diff b/aqua/qt511/files/patch-qtwebkit_fix_page_shift.diff
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 00000000000..113b9df3175
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt511/files/patch-qtwebkit_fix_page_shift.diff
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,384 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Upstream-Status: Backport (from upstream WebKit)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+https://bugs.webkit.org/show_bug.cgi?id=129370
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+https://trac.webkit.org/changeset?old=164727&old_path=webkit%2Ftrunk%2FSource%2FWTF%2Fwtf%2FFastMalloc.cpp&new=164742&new_path=webkit%2Ftrunk%2FSource%2FWTF%2Fwtf%2FFastMalloc.cpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Index: trunk/Source/WTF/wtf/FastMalloc.cpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+===================================================================
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- Source/WTF/wtf/FastMalloc.cpp  (revision 164727)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ Source/WTF/wtf/FastMalloc.cpp  (revision 164742)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -92,4 +92,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <mach/mach_init.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #include <malloc/malloc.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -630,26 +631,20 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ //-------------------------------------------------------------------
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++// Type that can hold the length of a run of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef uintptr_t Length;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Not all possible combinations of the following parameters make
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // sense.  In particular, if kMaxSize increases, you may have to
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // increase kNumClasses as well.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_PAGE_SHIFT PAGE_SHIFT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    if (K_PAGE_SHIFT == 12)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        define K_NUM_CLASSES 68
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    elif (K_PAGE_SHIFT == 14)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        define K_NUM_CLASSES 77
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        error "Unsupported PAGE_SHIFT amount"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_PAGE_SHIFT 12
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_NUM_CLASSES 68
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kPageShift  = K_PAGE_SHIFT;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kPageSize   = 1 << kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_PAGE_SHIFT_MIN 12
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_PAGE_SHIFT_MAX 14
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_NUM_CLASSES_MAX 77
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kPageShift  = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kNumClasses = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kPageSize   = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static Length kMaxValidPages = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kMaxSize    = 32u * 1024;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kAlignShift = 3;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kAlignment  = 1 << kAlignShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kNumClasses = K_NUM_CLASSES;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Allocates a big block of memory for the pagemap once we reach more than
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -663,5 +658,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // have small limits on the number of mmap() regions per
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // address-space.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kMinSystemAlloc = 1 << (20 - kPageShift);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static const size_t kMinSystemAlloc = 1 << (20 - K_PAGE_SHIFT_MAX);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Number of objects to move between a per-thread list and a central
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -670,5 +665,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // it too big may temporarily cause unnecessary memory wastage in the
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // per-thread free list until the scavenger cleans up the list.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static int num_objects_to_move[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static int num_objects_to_move[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Maximum length we allow a per-thread free-list to have before we
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -766,8 +761,8 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Mapping from size class to max size storable in that class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static size_t class_to_size[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t class_to_size[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Mapping from size class to number of pages to allocate at a time
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static size_t class_to_pages[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t class_to_pages[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Hardened singly linked list.  We make this a class to allow compiler to
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -814,5 +809,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // class is initially given one TCEntry which also means that the maximum any
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // one class can have is kNumClasses.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const int kNumTransferEntries = kNumClasses;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_NUM_TRANSFER_ENTRIES_MAX static_cast<int>(K_NUM_CLASSES_MAX)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define kNumTransferEntries static_cast<int>(kNumClasses)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Note: the following only works for "n"s that fit in 32-bits, but
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -918,4 +914,23 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Initialize the mapping arrays
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void InitSizeClasses() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageShift = vm_page_shift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  switch (kPageShift) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  case 12:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    kNumClasses = 68;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  case 14:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    kNumClasses = 77;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  default:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    CRASH();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageShift = 12;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kNumClasses = 68;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageSize = 1 << kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Do some sanity checking on add_amount[]/shift_amount[]/class_array[]
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (ClassIndex(0) < 0) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1145,12 +1160,8 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ typedef uintptr_t PageID;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-// Type that can hold the length of a run of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-typedef uintptr_t Length;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const Length kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Convert byte size into pages.  This won't overflow, but may return
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // an unreasonably large value if bytes is huge enough.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline Length pages(size_t bytes) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   return (bytes >> kPageShift) +
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+       ((bytes & (kPageSize - 1)) > 0 ? 1 : 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1160,4 +1171,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // allocated
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static size_t AllocationSize(size_t bytes) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (bytes > kMaxSize) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     // Large object: we allocate an integral number of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1432,5 +1444,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // end up getting all the TCEntries quota in the system we just preallocate
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // sufficient number of entries here.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  TCEntry tc_slots_[kNumTransferEntries];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  TCEntry tc_slots_[K_NUM_TRANSFER_ENTRIES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Number of currently used cached entries in tc_slots_.  This variable is
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1654,5 +1666,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <int BITS> class MapSelector {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap3<BITS-kPageShift> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap3<BITS-K_PAGE_SHIFT_MIN> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   typedef PackedCache<BITS, uint64_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1672,5 +1684,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <> class MapSelector<64> {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap3<64 - kPageShift - kBitsUnusedOn64Bit> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap3<64 - K_PAGE_SHIFT_MIN - kBitsUnusedOn64Bit> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   typedef PackedCache<64, uint64_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1680,6 +1692,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <> class MapSelector<32> {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap2<32 - kPageShift> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef PackedCache<32 - kPageShift, uint16_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap2<32 - K_PAGE_SHIFT_MIN> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef PackedCache<32 - K_PAGE_SHIFT_MIN, uint16_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1778,4 +1790,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Return number of free bytes in heap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   uint64_t FreeBytes() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     return (static_cast<uint64_t>(free_pages_) << kPageShift);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1913,4 +1926,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::init()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pagemap_.init(MetaDataAlloc);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pagemap_cache_ = PageMapCache(0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1927,5 +1942,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Start scavenging at kMaxPages list
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   scavenge_index_ = kMaxPages-1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  COMPILE_ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits), valuebits);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Init(&large_.normal, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Init(&large_.returned, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2068,4 +2083,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::scavenge()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t pagesToRelease = min_free_committed_pages_since_last_scavenge_ * kScavengePercentage;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t targetPageCount = std::max<size_t>(kMinimumFreeCommittedPageCount, free_committed_pages_ - pagesToRelease);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2229,4 +2245,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ inline void TCMalloc_PageHeap::Carve(Span* span, Length n, bool released) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(n > 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Remove(span, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2265,4 +2282,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static ALWAYS_INLINE void mergeDecommittedStates(Span* destination, Span* other)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     if (destination->decommitted && !other->decommitted) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         TCMalloc_SystemRelease(reinterpret_cast<void*>(other->start << kPageShift),
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2368,4 +2386,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if !USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::IncrementalScavenge(Length n) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Fast path; not yet time to release memory
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   scavenge_counter_ -= n;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2429,4 +2448,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #ifdef WTF_CHANGES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ size_t TCMalloc_PageHeap::ReturnedBytes() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t result = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     for (unsigned s = 0; s < kMaxPages; s++) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2444,4 +2464,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #ifndef WTF_CHANGES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static double PagesToMB(uint64_t pages) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   return (pages << kPageShift) / 1048576.0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2510,4 +2531,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ bool TCMalloc_PageHeap::GrowHeap(Length n) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(kMaxPages >= kMinSystemAlloc);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (n > kMaxValidPages) return false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2606,4 +2628,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::ReleaseFreeList(Span* list, Span* returned) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Walk backwards through list so that when we push these
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // spans on the "returned" list, we preserve the order.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2739,5 +2762,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ThreadIdentifier tid_;                // Which thread owns it
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   bool          in_setspecific_;           // Called pthread_setspecific?
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  FreeList      list_[kNumClasses];     // Array indexed by size-class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  FreeList      list_[K_NUM_CLASSES_MAX];     // Array indexed by size-class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // We sample allocations, biased by the size of the allocation
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2795,4 +2818,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   void enumerateFreeObjects(Finder& finder, const Reader& reader)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++      ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+       for (unsigned sizeClass = 0; sizeClass < kNumClasses; sizeClass++)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+           list_[sizeClass].enumerateFreeObjects(finder, reader);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2807,5 +2831,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Central cache -- a collection of free-lists, one per size-class.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // We have a separate lock per free-list to reduce contention.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static TCMalloc_Central_FreeListPadded central_cache[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static TCMalloc_Central_FreeListPadded central_cache[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Page-level allocator
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2963,4 +2987,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_Central_FreeList::Init(size_t cl, uintptr_t entropy) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   lock_.Init();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_class_ = cl;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2987,4 +3012,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE void TCMalloc_Central_FreeList::ReleaseToSpans(HardenedSLL object) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   const PageID p = reinterpret_cast<uintptr_t>(object.value()) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   Span* span = pageheap->GetDescriptor(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3033,4 +3059,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE bool TCMalloc_Central_FreeList::EvictRandomSizeClass(
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t locked_size_class, bool force) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   static int race_counter = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   int t = race_counter++;  // Updated without a lock, but who cares.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3048,4 +3075,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ bool TCMalloc_Central_FreeList::MakeCacheSpace() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Is there room in the cache?
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (used_slots_ < cache_size_) return true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3102,4 +3130,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_Central_FreeList::InsertRange(HardenedSLL start, HardenedSLL end, int N) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   SpinLockHolder h(&lock_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (N == num_objects_to_move[size_class_] &&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3184,4 +3213,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Fetch memory from the system and add to the central cache freelist.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE void TCMalloc_Central_FreeList::Populate() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Release central list lock while operating on pageheap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   lock_.Unlock();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3270,4 +3300,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Init(ThreadIdentifier tid, uintptr_t entropy) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_ = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   next_ = NULL;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3292,4 +3323,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Cleanup() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Put unused memory back into central cache
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   for (size_t cl = 0; cl < kNumClasses; ++cl) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3366,4 +3398,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Release idle memory to the central cache
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ inline void TCMalloc_ThreadCache::Scavenge() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // If the low-water mark for the free list is L, it means we would
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // not have had to allocate anything from the central cache even if
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3658,4 +3691,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Print() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   for (size_t cl = 0; cl < kNumClasses; ++cl) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     MESSAGE("      %5" PRIuS " : %4d len; %4d lo\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3679,4 +3713,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Get stats into "r".  Also get per-size-class counts if class_count != NULL
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void ExtractStats(TCMallocStats* r, uint64_t* class_count) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   r->central_bytes = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   r->transfer_bytes = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3716,4 +3751,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // WRITE stats to "out"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void DumpStats(TCMalloc_Printer* out, int level) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   TCMallocStats stats;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   uint64_t class_count[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4004,4 +4040,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if !ASSERT_DISABLED
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline bool CheckCachedSizeClass(void *ptr) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   PageID p = reinterpret_cast<uintptr_t>(ptr) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_t cached_value = pageheap->GetSizeClassIfCached(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4018,4 +4055,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline void* SpanToMallocResult(Span *span) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT_SPAN_COMMITTED(span);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pageheap->CacheSizeClass(span->start, 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4071,4 +4109,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (ptr == NULL) return;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(pageheap != NULL);  // Should not call free() before malloc()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   const PageID p = reinterpret_cast<uintptr_t>(ptr) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   Span* span = pageheap->GetDescriptor(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4122,4 +4161,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(align > 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (pageheap == NULL) TCMalloc_ThreadCache::InitModule();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Allocate at least one byte to avoid boundary conditions below
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4441,4 +4481,7 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     new_size += Internal::ValidationBufferSize;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(pageheap != NULL);  // Should not call realloc() before malloc()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Get the size of the old entry
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4660,4 +4703,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ FastMallocStatistics fastMallocStatistics()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     FastMallocStatistics statistics;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4681,4 +4725,7 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ size_t fastMallocSize(const void* ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  if (pageheap == NULL) TCMalloc_ThreadCache::InitModule();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if ENABLE(WTF_MALLOC_VALIDATION)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     return Internal::fastMallocValidationHeader(const_cast<void*>(ptr))->m_size;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4792,4 +4839,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     int visit(void* ptr) const
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         if (!ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+             return 1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4839,4 +4887,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     void recordPendingRegions()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         bool recordRegionsContainingPointers = m_typeMask & MALLOC_PTR_REGION_RANGE_TYPE;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         bool recordAllocations = m_typeMask & MALLOC_PTR_IN_USE_RANGE_TYPE;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4887,4 +4937,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     int visit(void* ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         if (!ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+             return 1;
</span><span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt513/Portfile b/aqua/qt513/Portfile
</span><span style='display:block; white-space:pre;color:#808080;'>index 49232682dc8..387dac6c2cd 100755
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>--- a/aqua/qt513/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt513/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -632,7 +632,7 @@ array set modules {
</span>         {"Qt WebKit" "Qt WebKit Widgets"}
         "community support only (use Qt WebEngine)"
         "variant overrides: "
<span style='display:block; white-space:pre;background:#ffe0e0;'>-        "revision 1"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        "revision 2"
</span>         "License: "
     }
     qtwebkit-examples {
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -1426,6 +1426,11 @@ foreach {module module_info} [array get modules] {
</span>                 # see https://bugs.webkit.org/show_bug.cgi?id=171612
                 patchfiles-append patch-qtwebkit_fix_icu.diff
 
<span style='display:block; white-space:pre;background:#e0ffe0;'>+                # backport upstream WebKit changes to avoid
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # error: "Unsupported PAGE_SHIFT amount"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # see https://trac.macports.org/ticket/62027#comment:49
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                patchfiles-append patch-qtwebkit_fix_page_shift.diff
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span>                 # qtwebkit uses
                 #    glx
                 #    libXcomposite
<span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt513/files/patch-qtwebkit_fix_page_shift.diff b/aqua/qt513/files/patch-qtwebkit_fix_page_shift.diff
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 00000000000..113b9df3175
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt513/files/patch-qtwebkit_fix_page_shift.diff
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,384 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Upstream-Status: Backport (from upstream WebKit)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+https://bugs.webkit.org/show_bug.cgi?id=129370
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+https://trac.webkit.org/changeset?old=164727&old_path=webkit%2Ftrunk%2FSource%2FWTF%2Fwtf%2FFastMalloc.cpp&new=164742&new_path=webkit%2Ftrunk%2FSource%2FWTF%2Fwtf%2FFastMalloc.cpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Index: trunk/Source/WTF/wtf/FastMalloc.cpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+===================================================================
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- Source/WTF/wtf/FastMalloc.cpp  (revision 164727)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ Source/WTF/wtf/FastMalloc.cpp  (revision 164742)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -92,4 +92,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <mach/mach_init.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #include <malloc/malloc.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -630,26 +631,20 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ //-------------------------------------------------------------------
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++// Type that can hold the length of a run of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef uintptr_t Length;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Not all possible combinations of the following parameters make
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // sense.  In particular, if kMaxSize increases, you may have to
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // increase kNumClasses as well.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_PAGE_SHIFT PAGE_SHIFT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    if (K_PAGE_SHIFT == 12)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        define K_NUM_CLASSES 68
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    elif (K_PAGE_SHIFT == 14)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        define K_NUM_CLASSES 77
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        error "Unsupported PAGE_SHIFT amount"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_PAGE_SHIFT 12
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_NUM_CLASSES 68
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kPageShift  = K_PAGE_SHIFT;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kPageSize   = 1 << kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_PAGE_SHIFT_MIN 12
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_PAGE_SHIFT_MAX 14
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_NUM_CLASSES_MAX 77
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kPageShift  = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kNumClasses = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kPageSize   = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static Length kMaxValidPages = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kMaxSize    = 32u * 1024;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kAlignShift = 3;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kAlignment  = 1 << kAlignShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kNumClasses = K_NUM_CLASSES;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Allocates a big block of memory for the pagemap once we reach more than
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -663,5 +658,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // have small limits on the number of mmap() regions per
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // address-space.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kMinSystemAlloc = 1 << (20 - kPageShift);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static const size_t kMinSystemAlloc = 1 << (20 - K_PAGE_SHIFT_MAX);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Number of objects to move between a per-thread list and a central
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -670,5 +665,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // it too big may temporarily cause unnecessary memory wastage in the
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // per-thread free list until the scavenger cleans up the list.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static int num_objects_to_move[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static int num_objects_to_move[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Maximum length we allow a per-thread free-list to have before we
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -766,8 +761,8 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Mapping from size class to max size storable in that class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static size_t class_to_size[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t class_to_size[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Mapping from size class to number of pages to allocate at a time
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static size_t class_to_pages[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t class_to_pages[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Hardened singly linked list.  We make this a class to allow compiler to
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -814,5 +809,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // class is initially given one TCEntry which also means that the maximum any
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // one class can have is kNumClasses.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const int kNumTransferEntries = kNumClasses;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_NUM_TRANSFER_ENTRIES_MAX static_cast<int>(K_NUM_CLASSES_MAX)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define kNumTransferEntries static_cast<int>(kNumClasses)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Note: the following only works for "n"s that fit in 32-bits, but
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -918,4 +914,23 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Initialize the mapping arrays
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void InitSizeClasses() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageShift = vm_page_shift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  switch (kPageShift) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  case 12:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    kNumClasses = 68;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  case 14:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    kNumClasses = 77;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  default:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    CRASH();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageShift = 12;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kNumClasses = 68;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageSize = 1 << kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Do some sanity checking on add_amount[]/shift_amount[]/class_array[]
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (ClassIndex(0) < 0) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1145,12 +1160,8 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ typedef uintptr_t PageID;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-// Type that can hold the length of a run of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-typedef uintptr_t Length;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const Length kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Convert byte size into pages.  This won't overflow, but may return
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // an unreasonably large value if bytes is huge enough.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline Length pages(size_t bytes) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   return (bytes >> kPageShift) +
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+       ((bytes & (kPageSize - 1)) > 0 ? 1 : 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1160,4 +1171,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // allocated
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static size_t AllocationSize(size_t bytes) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (bytes > kMaxSize) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     // Large object: we allocate an integral number of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1432,5 +1444,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // end up getting all the TCEntries quota in the system we just preallocate
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // sufficient number of entries here.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  TCEntry tc_slots_[kNumTransferEntries];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  TCEntry tc_slots_[K_NUM_TRANSFER_ENTRIES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Number of currently used cached entries in tc_slots_.  This variable is
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1654,5 +1666,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <int BITS> class MapSelector {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap3<BITS-kPageShift> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap3<BITS-K_PAGE_SHIFT_MIN> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   typedef PackedCache<BITS, uint64_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1672,5 +1684,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <> class MapSelector<64> {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap3<64 - kPageShift - kBitsUnusedOn64Bit> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap3<64 - K_PAGE_SHIFT_MIN - kBitsUnusedOn64Bit> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   typedef PackedCache<64, uint64_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1680,6 +1692,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <> class MapSelector<32> {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap2<32 - kPageShift> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef PackedCache<32 - kPageShift, uint16_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap2<32 - K_PAGE_SHIFT_MIN> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef PackedCache<32 - K_PAGE_SHIFT_MIN, uint16_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1778,4 +1790,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Return number of free bytes in heap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   uint64_t FreeBytes() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     return (static_cast<uint64_t>(free_pages_) << kPageShift);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1913,4 +1926,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::init()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pagemap_.init(MetaDataAlloc);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pagemap_cache_ = PageMapCache(0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1927,5 +1942,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Start scavenging at kMaxPages list
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   scavenge_index_ = kMaxPages-1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  COMPILE_ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits), valuebits);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Init(&large_.normal, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Init(&large_.returned, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2068,4 +2083,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::scavenge()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t pagesToRelease = min_free_committed_pages_since_last_scavenge_ * kScavengePercentage;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t targetPageCount = std::max<size_t>(kMinimumFreeCommittedPageCount, free_committed_pages_ - pagesToRelease);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2229,4 +2245,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ inline void TCMalloc_PageHeap::Carve(Span* span, Length n, bool released) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(n > 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Remove(span, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2265,4 +2282,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static ALWAYS_INLINE void mergeDecommittedStates(Span* destination, Span* other)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     if (destination->decommitted && !other->decommitted) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         TCMalloc_SystemRelease(reinterpret_cast<void*>(other->start << kPageShift),
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2368,4 +2386,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if !USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::IncrementalScavenge(Length n) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Fast path; not yet time to release memory
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   scavenge_counter_ -= n;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2429,4 +2448,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #ifdef WTF_CHANGES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ size_t TCMalloc_PageHeap::ReturnedBytes() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t result = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     for (unsigned s = 0; s < kMaxPages; s++) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2444,4 +2464,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #ifndef WTF_CHANGES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static double PagesToMB(uint64_t pages) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   return (pages << kPageShift) / 1048576.0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2510,4 +2531,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ bool TCMalloc_PageHeap::GrowHeap(Length n) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(kMaxPages >= kMinSystemAlloc);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (n > kMaxValidPages) return false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2606,4 +2628,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::ReleaseFreeList(Span* list, Span* returned) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Walk backwards through list so that when we push these
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // spans on the "returned" list, we preserve the order.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2739,5 +2762,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ThreadIdentifier tid_;                // Which thread owns it
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   bool          in_setspecific_;           // Called pthread_setspecific?
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  FreeList      list_[kNumClasses];     // Array indexed by size-class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  FreeList      list_[K_NUM_CLASSES_MAX];     // Array indexed by size-class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // We sample allocations, biased by the size of the allocation
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2795,4 +2818,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   void enumerateFreeObjects(Finder& finder, const Reader& reader)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++      ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+       for (unsigned sizeClass = 0; sizeClass < kNumClasses; sizeClass++)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+           list_[sizeClass].enumerateFreeObjects(finder, reader);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2807,5 +2831,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Central cache -- a collection of free-lists, one per size-class.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // We have a separate lock per free-list to reduce contention.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static TCMalloc_Central_FreeListPadded central_cache[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static TCMalloc_Central_FreeListPadded central_cache[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Page-level allocator
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2963,4 +2987,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_Central_FreeList::Init(size_t cl, uintptr_t entropy) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   lock_.Init();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_class_ = cl;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2987,4 +3012,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE void TCMalloc_Central_FreeList::ReleaseToSpans(HardenedSLL object) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   const PageID p = reinterpret_cast<uintptr_t>(object.value()) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   Span* span = pageheap->GetDescriptor(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3033,4 +3059,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE bool TCMalloc_Central_FreeList::EvictRandomSizeClass(
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t locked_size_class, bool force) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   static int race_counter = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   int t = race_counter++;  // Updated without a lock, but who cares.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3048,4 +3075,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ bool TCMalloc_Central_FreeList::MakeCacheSpace() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Is there room in the cache?
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (used_slots_ < cache_size_) return true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3102,4 +3130,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_Central_FreeList::InsertRange(HardenedSLL start, HardenedSLL end, int N) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   SpinLockHolder h(&lock_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (N == num_objects_to_move[size_class_] &&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3184,4 +3213,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Fetch memory from the system and add to the central cache freelist.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE void TCMalloc_Central_FreeList::Populate() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Release central list lock while operating on pageheap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   lock_.Unlock();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3270,4 +3300,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Init(ThreadIdentifier tid, uintptr_t entropy) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_ = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   next_ = NULL;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3292,4 +3323,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Cleanup() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Put unused memory back into central cache
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   for (size_t cl = 0; cl < kNumClasses; ++cl) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3366,4 +3398,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Release idle memory to the central cache
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ inline void TCMalloc_ThreadCache::Scavenge() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // If the low-water mark for the free list is L, it means we would
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // not have had to allocate anything from the central cache even if
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3658,4 +3691,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Print() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   for (size_t cl = 0; cl < kNumClasses; ++cl) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     MESSAGE("      %5" PRIuS " : %4d len; %4d lo\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3679,4 +3713,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Get stats into "r".  Also get per-size-class counts if class_count != NULL
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void ExtractStats(TCMallocStats* r, uint64_t* class_count) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   r->central_bytes = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   r->transfer_bytes = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3716,4 +3751,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // WRITE stats to "out"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void DumpStats(TCMalloc_Printer* out, int level) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   TCMallocStats stats;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   uint64_t class_count[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4004,4 +4040,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if !ASSERT_DISABLED
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline bool CheckCachedSizeClass(void *ptr) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   PageID p = reinterpret_cast<uintptr_t>(ptr) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_t cached_value = pageheap->GetSizeClassIfCached(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4018,4 +4055,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline void* SpanToMallocResult(Span *span) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT_SPAN_COMMITTED(span);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pageheap->CacheSizeClass(span->start, 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4071,4 +4109,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (ptr == NULL) return;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(pageheap != NULL);  // Should not call free() before malloc()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   const PageID p = reinterpret_cast<uintptr_t>(ptr) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   Span* span = pageheap->GetDescriptor(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4122,4 +4161,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(align > 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (pageheap == NULL) TCMalloc_ThreadCache::InitModule();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Allocate at least one byte to avoid boundary conditions below
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4441,4 +4481,7 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     new_size += Internal::ValidationBufferSize;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(pageheap != NULL);  // Should not call realloc() before malloc()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Get the size of the old entry
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4660,4 +4703,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ FastMallocStatistics fastMallocStatistics()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     FastMallocStatistics statistics;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4681,4 +4725,7 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ size_t fastMallocSize(const void* ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  if (pageheap == NULL) TCMalloc_ThreadCache::InitModule();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if ENABLE(WTF_MALLOC_VALIDATION)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     return Internal::fastMallocValidationHeader(const_cast<void*>(ptr))->m_size;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4792,4 +4839,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     int visit(void* ptr) const
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         if (!ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+             return 1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4839,4 +4887,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     void recordPendingRegions()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         bool recordRegionsContainingPointers = m_typeMask & MALLOC_PTR_REGION_RANGE_TYPE;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         bool recordAllocations = m_typeMask & MALLOC_PTR_IN_USE_RANGE_TYPE;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4887,4 +4937,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     int visit(void* ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         if (!ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+             return 1;
</span><span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt55/Portfile b/aqua/qt55/Portfile
</span><span style='display:block; white-space:pre;color:#808080;'>index 1f4ae03cd86..151cd3eb3fb 100644
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>--- a/aqua/qt55/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt55/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -470,7 +470,7 @@ array set modules {
</span>         {"Qt WebKit" "Qt WebKit Widgets"}
         "community support only (use Qt WebEngine)"
         "variant overrides: "
<span style='display:block; white-space:pre;background:#ffe0e0;'>-        "revision 6"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        "revision 7"
</span>         "License: "
     }
     qtwebkit-examples {
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -1296,6 +1296,11 @@ foreach {module module_info} [array get modules] {
</span> 
                 # see https://bugs.webkit.org/show_bug.cgi?id=171612
                 patchfiles-append patch-qtwebkit_fix_icu.diff
<span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # backport upstream WebKit changes to avoid
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # error: "Unsupported PAGE_SHIFT amount"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # see https://trac.macports.org/ticket/62027#comment:49
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                patchfiles-append patch-qtwebkit_fix_page_shift.diff
</span>             }
 
             # special case
<span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt55/files/patch-qtwebkit_fix_page_shift.diff b/aqua/qt55/files/patch-qtwebkit_fix_page_shift.diff
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 00000000000..113b9df3175
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt55/files/patch-qtwebkit_fix_page_shift.diff
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,384 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Upstream-Status: Backport (from upstream WebKit)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+https://bugs.webkit.org/show_bug.cgi?id=129370
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+https://trac.webkit.org/changeset?old=164727&old_path=webkit%2Ftrunk%2FSource%2FWTF%2Fwtf%2FFastMalloc.cpp&new=164742&new_path=webkit%2Ftrunk%2FSource%2FWTF%2Fwtf%2FFastMalloc.cpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Index: trunk/Source/WTF/wtf/FastMalloc.cpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+===================================================================
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- Source/WTF/wtf/FastMalloc.cpp  (revision 164727)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ Source/WTF/wtf/FastMalloc.cpp  (revision 164742)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -92,4 +92,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <mach/mach_init.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #include <malloc/malloc.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -630,26 +631,20 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ //-------------------------------------------------------------------
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++// Type that can hold the length of a run of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef uintptr_t Length;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Not all possible combinations of the following parameters make
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // sense.  In particular, if kMaxSize increases, you may have to
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // increase kNumClasses as well.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_PAGE_SHIFT PAGE_SHIFT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    if (K_PAGE_SHIFT == 12)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        define K_NUM_CLASSES 68
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    elif (K_PAGE_SHIFT == 14)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        define K_NUM_CLASSES 77
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        error "Unsupported PAGE_SHIFT amount"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_PAGE_SHIFT 12
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_NUM_CLASSES 68
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kPageShift  = K_PAGE_SHIFT;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kPageSize   = 1 << kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_PAGE_SHIFT_MIN 12
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_PAGE_SHIFT_MAX 14
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_NUM_CLASSES_MAX 77
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kPageShift  = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kNumClasses = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kPageSize   = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static Length kMaxValidPages = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kMaxSize    = 32u * 1024;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kAlignShift = 3;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kAlignment  = 1 << kAlignShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kNumClasses = K_NUM_CLASSES;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Allocates a big block of memory for the pagemap once we reach more than
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -663,5 +658,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // have small limits on the number of mmap() regions per
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // address-space.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kMinSystemAlloc = 1 << (20 - kPageShift);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static const size_t kMinSystemAlloc = 1 << (20 - K_PAGE_SHIFT_MAX);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Number of objects to move between a per-thread list and a central
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -670,5 +665,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // it too big may temporarily cause unnecessary memory wastage in the
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // per-thread free list until the scavenger cleans up the list.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static int num_objects_to_move[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static int num_objects_to_move[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Maximum length we allow a per-thread free-list to have before we
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -766,8 +761,8 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Mapping from size class to max size storable in that class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static size_t class_to_size[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t class_to_size[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Mapping from size class to number of pages to allocate at a time
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static size_t class_to_pages[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t class_to_pages[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Hardened singly linked list.  We make this a class to allow compiler to
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -814,5 +809,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // class is initially given one TCEntry which also means that the maximum any
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // one class can have is kNumClasses.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const int kNumTransferEntries = kNumClasses;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_NUM_TRANSFER_ENTRIES_MAX static_cast<int>(K_NUM_CLASSES_MAX)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define kNumTransferEntries static_cast<int>(kNumClasses)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Note: the following only works for "n"s that fit in 32-bits, but
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -918,4 +914,23 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Initialize the mapping arrays
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void InitSizeClasses() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageShift = vm_page_shift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  switch (kPageShift) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  case 12:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    kNumClasses = 68;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  case 14:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    kNumClasses = 77;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  default:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    CRASH();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageShift = 12;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kNumClasses = 68;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageSize = 1 << kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Do some sanity checking on add_amount[]/shift_amount[]/class_array[]
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (ClassIndex(0) < 0) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1145,12 +1160,8 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ typedef uintptr_t PageID;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-// Type that can hold the length of a run of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-typedef uintptr_t Length;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const Length kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Convert byte size into pages.  This won't overflow, but may return
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // an unreasonably large value if bytes is huge enough.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline Length pages(size_t bytes) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   return (bytes >> kPageShift) +
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+       ((bytes & (kPageSize - 1)) > 0 ? 1 : 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1160,4 +1171,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // allocated
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static size_t AllocationSize(size_t bytes) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (bytes > kMaxSize) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     // Large object: we allocate an integral number of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1432,5 +1444,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // end up getting all the TCEntries quota in the system we just preallocate
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // sufficient number of entries here.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  TCEntry tc_slots_[kNumTransferEntries];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  TCEntry tc_slots_[K_NUM_TRANSFER_ENTRIES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Number of currently used cached entries in tc_slots_.  This variable is
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1654,5 +1666,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <int BITS> class MapSelector {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap3<BITS-kPageShift> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap3<BITS-K_PAGE_SHIFT_MIN> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   typedef PackedCache<BITS, uint64_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1672,5 +1684,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <> class MapSelector<64> {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap3<64 - kPageShift - kBitsUnusedOn64Bit> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap3<64 - K_PAGE_SHIFT_MIN - kBitsUnusedOn64Bit> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   typedef PackedCache<64, uint64_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1680,6 +1692,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <> class MapSelector<32> {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap2<32 - kPageShift> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef PackedCache<32 - kPageShift, uint16_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap2<32 - K_PAGE_SHIFT_MIN> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef PackedCache<32 - K_PAGE_SHIFT_MIN, uint16_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1778,4 +1790,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Return number of free bytes in heap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   uint64_t FreeBytes() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     return (static_cast<uint64_t>(free_pages_) << kPageShift);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1913,4 +1926,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::init()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pagemap_.init(MetaDataAlloc);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pagemap_cache_ = PageMapCache(0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1927,5 +1942,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Start scavenging at kMaxPages list
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   scavenge_index_ = kMaxPages-1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  COMPILE_ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits), valuebits);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Init(&large_.normal, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Init(&large_.returned, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2068,4 +2083,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::scavenge()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t pagesToRelease = min_free_committed_pages_since_last_scavenge_ * kScavengePercentage;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t targetPageCount = std::max<size_t>(kMinimumFreeCommittedPageCount, free_committed_pages_ - pagesToRelease);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2229,4 +2245,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ inline void TCMalloc_PageHeap::Carve(Span* span, Length n, bool released) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(n > 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Remove(span, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2265,4 +2282,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static ALWAYS_INLINE void mergeDecommittedStates(Span* destination, Span* other)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     if (destination->decommitted && !other->decommitted) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         TCMalloc_SystemRelease(reinterpret_cast<void*>(other->start << kPageShift),
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2368,4 +2386,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if !USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::IncrementalScavenge(Length n) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Fast path; not yet time to release memory
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   scavenge_counter_ -= n;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2429,4 +2448,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #ifdef WTF_CHANGES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ size_t TCMalloc_PageHeap::ReturnedBytes() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t result = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     for (unsigned s = 0; s < kMaxPages; s++) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2444,4 +2464,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #ifndef WTF_CHANGES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static double PagesToMB(uint64_t pages) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   return (pages << kPageShift) / 1048576.0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2510,4 +2531,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ bool TCMalloc_PageHeap::GrowHeap(Length n) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(kMaxPages >= kMinSystemAlloc);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (n > kMaxValidPages) return false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2606,4 +2628,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::ReleaseFreeList(Span* list, Span* returned) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Walk backwards through list so that when we push these
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // spans on the "returned" list, we preserve the order.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2739,5 +2762,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ThreadIdentifier tid_;                // Which thread owns it
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   bool          in_setspecific_;           // Called pthread_setspecific?
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  FreeList      list_[kNumClasses];     // Array indexed by size-class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  FreeList      list_[K_NUM_CLASSES_MAX];     // Array indexed by size-class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // We sample allocations, biased by the size of the allocation
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2795,4 +2818,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   void enumerateFreeObjects(Finder& finder, const Reader& reader)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++      ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+       for (unsigned sizeClass = 0; sizeClass < kNumClasses; sizeClass++)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+           list_[sizeClass].enumerateFreeObjects(finder, reader);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2807,5 +2831,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Central cache -- a collection of free-lists, one per size-class.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // We have a separate lock per free-list to reduce contention.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static TCMalloc_Central_FreeListPadded central_cache[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static TCMalloc_Central_FreeListPadded central_cache[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Page-level allocator
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2963,4 +2987,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_Central_FreeList::Init(size_t cl, uintptr_t entropy) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   lock_.Init();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_class_ = cl;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2987,4 +3012,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE void TCMalloc_Central_FreeList::ReleaseToSpans(HardenedSLL object) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   const PageID p = reinterpret_cast<uintptr_t>(object.value()) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   Span* span = pageheap->GetDescriptor(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3033,4 +3059,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE bool TCMalloc_Central_FreeList::EvictRandomSizeClass(
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t locked_size_class, bool force) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   static int race_counter = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   int t = race_counter++;  // Updated without a lock, but who cares.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3048,4 +3075,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ bool TCMalloc_Central_FreeList::MakeCacheSpace() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Is there room in the cache?
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (used_slots_ < cache_size_) return true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3102,4 +3130,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_Central_FreeList::InsertRange(HardenedSLL start, HardenedSLL end, int N) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   SpinLockHolder h(&lock_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (N == num_objects_to_move[size_class_] &&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3184,4 +3213,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Fetch memory from the system and add to the central cache freelist.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE void TCMalloc_Central_FreeList::Populate() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Release central list lock while operating on pageheap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   lock_.Unlock();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3270,4 +3300,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Init(ThreadIdentifier tid, uintptr_t entropy) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_ = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   next_ = NULL;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3292,4 +3323,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Cleanup() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Put unused memory back into central cache
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   for (size_t cl = 0; cl < kNumClasses; ++cl) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3366,4 +3398,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Release idle memory to the central cache
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ inline void TCMalloc_ThreadCache::Scavenge() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // If the low-water mark for the free list is L, it means we would
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // not have had to allocate anything from the central cache even if
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3658,4 +3691,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Print() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   for (size_t cl = 0; cl < kNumClasses; ++cl) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     MESSAGE("      %5" PRIuS " : %4d len; %4d lo\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3679,4 +3713,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Get stats into "r".  Also get per-size-class counts if class_count != NULL
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void ExtractStats(TCMallocStats* r, uint64_t* class_count) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   r->central_bytes = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   r->transfer_bytes = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3716,4 +3751,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // WRITE stats to "out"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void DumpStats(TCMalloc_Printer* out, int level) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   TCMallocStats stats;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   uint64_t class_count[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4004,4 +4040,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if !ASSERT_DISABLED
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline bool CheckCachedSizeClass(void *ptr) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   PageID p = reinterpret_cast<uintptr_t>(ptr) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_t cached_value = pageheap->GetSizeClassIfCached(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4018,4 +4055,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline void* SpanToMallocResult(Span *span) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT_SPAN_COMMITTED(span);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pageheap->CacheSizeClass(span->start, 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4071,4 +4109,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (ptr == NULL) return;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(pageheap != NULL);  // Should not call free() before malloc()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   const PageID p = reinterpret_cast<uintptr_t>(ptr) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   Span* span = pageheap->GetDescriptor(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4122,4 +4161,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(align > 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (pageheap == NULL) TCMalloc_ThreadCache::InitModule();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Allocate at least one byte to avoid boundary conditions below
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4441,4 +4481,7 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     new_size += Internal::ValidationBufferSize;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(pageheap != NULL);  // Should not call realloc() before malloc()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Get the size of the old entry
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4660,4 +4703,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ FastMallocStatistics fastMallocStatistics()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     FastMallocStatistics statistics;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4681,4 +4725,7 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ size_t fastMallocSize(const void* ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  if (pageheap == NULL) TCMalloc_ThreadCache::InitModule();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if ENABLE(WTF_MALLOC_VALIDATION)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     return Internal::fastMallocValidationHeader(const_cast<void*>(ptr))->m_size;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4792,4 +4839,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     int visit(void* ptr) const
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         if (!ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+             return 1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4839,4 +4887,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     void recordPendingRegions()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         bool recordRegionsContainingPointers = m_typeMask & MALLOC_PTR_REGION_RANGE_TYPE;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         bool recordAllocations = m_typeMask & MALLOC_PTR_IN_USE_RANGE_TYPE;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4887,4 +4937,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     int visit(void* ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         if (!ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+             return 1;
</span><span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt56/Portfile b/aqua/qt56/Portfile
</span><span style='display:block; white-space:pre;color:#808080;'>index fd5f4349c2a..340bb40efd8 100644
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>--- a/aqua/qt56/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt56/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -491,7 +491,7 @@ array set modules {
</span>         {"Qt WebKit" "Qt WebKit Widgets"}
         "community support only (use Qt WebEngine)"
         "variant overrides: "
<span style='display:block; white-space:pre;background:#ffe0e0;'>-        "revision 3"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        "revision 4"
</span>         "License: "
     }
     qtwebkit-examples {
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -1332,6 +1332,11 @@ foreach {module module_info} [array get modules] {
</span> 
                 # see https://bugs.webkit.org/show_bug.cgi?id=171612
                 patchfiles-append patch-qtwebkit_fix_icu.diff
<span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # backport upstream WebKit changes to avoid
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # error: "Unsupported PAGE_SHIFT amount"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # see https://trac.macports.org/ticket/62027#comment:49
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                patchfiles-append patch-qtwebkit_fix_page_shift.diff
</span>             }
 
             # special case
<span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt56/files/patch-qtwebkit_fix_page_shift.diff b/aqua/qt56/files/patch-qtwebkit_fix_page_shift.diff
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 00000000000..113b9df3175
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt56/files/patch-qtwebkit_fix_page_shift.diff
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,384 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Upstream-Status: Backport (from upstream WebKit)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+https://bugs.webkit.org/show_bug.cgi?id=129370
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+https://trac.webkit.org/changeset?old=164727&old_path=webkit%2Ftrunk%2FSource%2FWTF%2Fwtf%2FFastMalloc.cpp&new=164742&new_path=webkit%2Ftrunk%2FSource%2FWTF%2Fwtf%2FFastMalloc.cpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Index: trunk/Source/WTF/wtf/FastMalloc.cpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+===================================================================
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- Source/WTF/wtf/FastMalloc.cpp  (revision 164727)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ Source/WTF/wtf/FastMalloc.cpp  (revision 164742)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -92,4 +92,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <mach/mach_init.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #include <malloc/malloc.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -630,26 +631,20 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ //-------------------------------------------------------------------
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++// Type that can hold the length of a run of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef uintptr_t Length;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Not all possible combinations of the following parameters make
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // sense.  In particular, if kMaxSize increases, you may have to
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // increase kNumClasses as well.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_PAGE_SHIFT PAGE_SHIFT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    if (K_PAGE_SHIFT == 12)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        define K_NUM_CLASSES 68
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    elif (K_PAGE_SHIFT == 14)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        define K_NUM_CLASSES 77
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        error "Unsupported PAGE_SHIFT amount"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_PAGE_SHIFT 12
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_NUM_CLASSES 68
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kPageShift  = K_PAGE_SHIFT;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kPageSize   = 1 << kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_PAGE_SHIFT_MIN 12
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_PAGE_SHIFT_MAX 14
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_NUM_CLASSES_MAX 77
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kPageShift  = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kNumClasses = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kPageSize   = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static Length kMaxValidPages = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kMaxSize    = 32u * 1024;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kAlignShift = 3;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kAlignment  = 1 << kAlignShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kNumClasses = K_NUM_CLASSES;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Allocates a big block of memory for the pagemap once we reach more than
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -663,5 +658,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // have small limits on the number of mmap() regions per
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // address-space.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kMinSystemAlloc = 1 << (20 - kPageShift);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static const size_t kMinSystemAlloc = 1 << (20 - K_PAGE_SHIFT_MAX);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Number of objects to move between a per-thread list and a central
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -670,5 +665,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // it too big may temporarily cause unnecessary memory wastage in the
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // per-thread free list until the scavenger cleans up the list.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static int num_objects_to_move[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static int num_objects_to_move[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Maximum length we allow a per-thread free-list to have before we
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -766,8 +761,8 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Mapping from size class to max size storable in that class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static size_t class_to_size[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t class_to_size[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Mapping from size class to number of pages to allocate at a time
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static size_t class_to_pages[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t class_to_pages[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Hardened singly linked list.  We make this a class to allow compiler to
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -814,5 +809,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // class is initially given one TCEntry which also means that the maximum any
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // one class can have is kNumClasses.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const int kNumTransferEntries = kNumClasses;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_NUM_TRANSFER_ENTRIES_MAX static_cast<int>(K_NUM_CLASSES_MAX)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define kNumTransferEntries static_cast<int>(kNumClasses)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Note: the following only works for "n"s that fit in 32-bits, but
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -918,4 +914,23 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Initialize the mapping arrays
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void InitSizeClasses() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageShift = vm_page_shift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  switch (kPageShift) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  case 12:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    kNumClasses = 68;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  case 14:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    kNumClasses = 77;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  default:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    CRASH();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageShift = 12;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kNumClasses = 68;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageSize = 1 << kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Do some sanity checking on add_amount[]/shift_amount[]/class_array[]
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (ClassIndex(0) < 0) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1145,12 +1160,8 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ typedef uintptr_t PageID;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-// Type that can hold the length of a run of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-typedef uintptr_t Length;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const Length kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Convert byte size into pages.  This won't overflow, but may return
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // an unreasonably large value if bytes is huge enough.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline Length pages(size_t bytes) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   return (bytes >> kPageShift) +
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+       ((bytes & (kPageSize - 1)) > 0 ? 1 : 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1160,4 +1171,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // allocated
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static size_t AllocationSize(size_t bytes) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (bytes > kMaxSize) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     // Large object: we allocate an integral number of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1432,5 +1444,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // end up getting all the TCEntries quota in the system we just preallocate
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // sufficient number of entries here.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  TCEntry tc_slots_[kNumTransferEntries];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  TCEntry tc_slots_[K_NUM_TRANSFER_ENTRIES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Number of currently used cached entries in tc_slots_.  This variable is
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1654,5 +1666,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <int BITS> class MapSelector {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap3<BITS-kPageShift> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap3<BITS-K_PAGE_SHIFT_MIN> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   typedef PackedCache<BITS, uint64_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1672,5 +1684,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <> class MapSelector<64> {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap3<64 - kPageShift - kBitsUnusedOn64Bit> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap3<64 - K_PAGE_SHIFT_MIN - kBitsUnusedOn64Bit> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   typedef PackedCache<64, uint64_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1680,6 +1692,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <> class MapSelector<32> {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap2<32 - kPageShift> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef PackedCache<32 - kPageShift, uint16_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap2<32 - K_PAGE_SHIFT_MIN> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef PackedCache<32 - K_PAGE_SHIFT_MIN, uint16_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1778,4 +1790,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Return number of free bytes in heap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   uint64_t FreeBytes() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     return (static_cast<uint64_t>(free_pages_) << kPageShift);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1913,4 +1926,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::init()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pagemap_.init(MetaDataAlloc);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pagemap_cache_ = PageMapCache(0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1927,5 +1942,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Start scavenging at kMaxPages list
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   scavenge_index_ = kMaxPages-1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  COMPILE_ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits), valuebits);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Init(&large_.normal, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Init(&large_.returned, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2068,4 +2083,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::scavenge()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t pagesToRelease = min_free_committed_pages_since_last_scavenge_ * kScavengePercentage;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t targetPageCount = std::max<size_t>(kMinimumFreeCommittedPageCount, free_committed_pages_ - pagesToRelease);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2229,4 +2245,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ inline void TCMalloc_PageHeap::Carve(Span* span, Length n, bool released) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(n > 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Remove(span, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2265,4 +2282,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static ALWAYS_INLINE void mergeDecommittedStates(Span* destination, Span* other)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     if (destination->decommitted && !other->decommitted) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         TCMalloc_SystemRelease(reinterpret_cast<void*>(other->start << kPageShift),
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2368,4 +2386,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if !USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::IncrementalScavenge(Length n) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Fast path; not yet time to release memory
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   scavenge_counter_ -= n;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2429,4 +2448,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #ifdef WTF_CHANGES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ size_t TCMalloc_PageHeap::ReturnedBytes() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t result = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     for (unsigned s = 0; s < kMaxPages; s++) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2444,4 +2464,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #ifndef WTF_CHANGES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static double PagesToMB(uint64_t pages) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   return (pages << kPageShift) / 1048576.0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2510,4 +2531,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ bool TCMalloc_PageHeap::GrowHeap(Length n) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(kMaxPages >= kMinSystemAlloc);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (n > kMaxValidPages) return false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2606,4 +2628,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::ReleaseFreeList(Span* list, Span* returned) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Walk backwards through list so that when we push these
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // spans on the "returned" list, we preserve the order.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2739,5 +2762,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ThreadIdentifier tid_;                // Which thread owns it
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   bool          in_setspecific_;           // Called pthread_setspecific?
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  FreeList      list_[kNumClasses];     // Array indexed by size-class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  FreeList      list_[K_NUM_CLASSES_MAX];     // Array indexed by size-class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // We sample allocations, biased by the size of the allocation
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2795,4 +2818,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   void enumerateFreeObjects(Finder& finder, const Reader& reader)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++      ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+       for (unsigned sizeClass = 0; sizeClass < kNumClasses; sizeClass++)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+           list_[sizeClass].enumerateFreeObjects(finder, reader);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2807,5 +2831,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Central cache -- a collection of free-lists, one per size-class.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // We have a separate lock per free-list to reduce contention.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static TCMalloc_Central_FreeListPadded central_cache[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static TCMalloc_Central_FreeListPadded central_cache[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Page-level allocator
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2963,4 +2987,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_Central_FreeList::Init(size_t cl, uintptr_t entropy) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   lock_.Init();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_class_ = cl;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2987,4 +3012,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE void TCMalloc_Central_FreeList::ReleaseToSpans(HardenedSLL object) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   const PageID p = reinterpret_cast<uintptr_t>(object.value()) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   Span* span = pageheap->GetDescriptor(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3033,4 +3059,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE bool TCMalloc_Central_FreeList::EvictRandomSizeClass(
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t locked_size_class, bool force) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   static int race_counter = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   int t = race_counter++;  // Updated without a lock, but who cares.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3048,4 +3075,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ bool TCMalloc_Central_FreeList::MakeCacheSpace() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Is there room in the cache?
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (used_slots_ < cache_size_) return true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3102,4 +3130,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_Central_FreeList::InsertRange(HardenedSLL start, HardenedSLL end, int N) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   SpinLockHolder h(&lock_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (N == num_objects_to_move[size_class_] &&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3184,4 +3213,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Fetch memory from the system and add to the central cache freelist.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE void TCMalloc_Central_FreeList::Populate() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Release central list lock while operating on pageheap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   lock_.Unlock();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3270,4 +3300,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Init(ThreadIdentifier tid, uintptr_t entropy) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_ = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   next_ = NULL;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3292,4 +3323,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Cleanup() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Put unused memory back into central cache
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   for (size_t cl = 0; cl < kNumClasses; ++cl) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3366,4 +3398,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Release idle memory to the central cache
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ inline void TCMalloc_ThreadCache::Scavenge() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // If the low-water mark for the free list is L, it means we would
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // not have had to allocate anything from the central cache even if
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3658,4 +3691,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Print() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   for (size_t cl = 0; cl < kNumClasses; ++cl) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     MESSAGE("      %5" PRIuS " : %4d len; %4d lo\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3679,4 +3713,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Get stats into "r".  Also get per-size-class counts if class_count != NULL
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void ExtractStats(TCMallocStats* r, uint64_t* class_count) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   r->central_bytes = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   r->transfer_bytes = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3716,4 +3751,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // WRITE stats to "out"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void DumpStats(TCMalloc_Printer* out, int level) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   TCMallocStats stats;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   uint64_t class_count[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4004,4 +4040,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if !ASSERT_DISABLED
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline bool CheckCachedSizeClass(void *ptr) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   PageID p = reinterpret_cast<uintptr_t>(ptr) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_t cached_value = pageheap->GetSizeClassIfCached(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4018,4 +4055,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline void* SpanToMallocResult(Span *span) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT_SPAN_COMMITTED(span);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pageheap->CacheSizeClass(span->start, 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4071,4 +4109,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (ptr == NULL) return;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(pageheap != NULL);  // Should not call free() before malloc()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   const PageID p = reinterpret_cast<uintptr_t>(ptr) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   Span* span = pageheap->GetDescriptor(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4122,4 +4161,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(align > 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (pageheap == NULL) TCMalloc_ThreadCache::InitModule();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Allocate at least one byte to avoid boundary conditions below
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4441,4 +4481,7 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     new_size += Internal::ValidationBufferSize;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(pageheap != NULL);  // Should not call realloc() before malloc()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Get the size of the old entry
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4660,4 +4703,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ FastMallocStatistics fastMallocStatistics()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     FastMallocStatistics statistics;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4681,4 +4725,7 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ size_t fastMallocSize(const void* ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  if (pageheap == NULL) TCMalloc_ThreadCache::InitModule();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if ENABLE(WTF_MALLOC_VALIDATION)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     return Internal::fastMallocValidationHeader(const_cast<void*>(ptr))->m_size;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4792,4 +4839,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     int visit(void* ptr) const
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         if (!ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+             return 1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4839,4 +4887,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     void recordPendingRegions()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         bool recordRegionsContainingPointers = m_typeMask & MALLOC_PTR_REGION_RANGE_TYPE;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         bool recordAllocations = m_typeMask & MALLOC_PTR_IN_USE_RANGE_TYPE;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4887,4 +4937,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     int visit(void* ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         if (!ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+             return 1;
</span><span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt57/Portfile b/aqua/qt57/Portfile
</span><span style='display:block; white-space:pre;color:#808080;'>index 47f521ae1f3..a8e6bd7801f 100644
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>--- a/aqua/qt57/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt57/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -583,7 +583,7 @@ array set modules {
</span>         {"Qt WebKit" "Qt WebKit Widgets"}
         "community support only (use Qt WebEngine)"
         "variant overrides: "
<span style='display:block; white-space:pre;background:#ffe0e0;'>-        "revision 3"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        "revision 4"
</span>         "License: "
     }
     qtwebkit-examples {
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -1405,6 +1405,11 @@ foreach {module module_info} [array get modules] {
</span> 
                 # see https://bugs.webkit.org/show_bug.cgi?id=171612
                 patchfiles-append patch-qtwebkit_fix_icu.diff
<span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # backport upstream WebKit changes to avoid
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # error: "Unsupported PAGE_SHIFT amount"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # see https://trac.macports.org/ticket/62027#comment:49
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                patchfiles-append patch-qtwebkit_fix_page_shift.diff
</span>             }
 
             # special case
<span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt57/files/patch-qtwebkit_fix_page_shift.diff b/aqua/qt57/files/patch-qtwebkit_fix_page_shift.diff
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 00000000000..113b9df3175
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt57/files/patch-qtwebkit_fix_page_shift.diff
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,384 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Upstream-Status: Backport (from upstream WebKit)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+https://bugs.webkit.org/show_bug.cgi?id=129370
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+https://trac.webkit.org/changeset?old=164727&old_path=webkit%2Ftrunk%2FSource%2FWTF%2Fwtf%2FFastMalloc.cpp&new=164742&new_path=webkit%2Ftrunk%2FSource%2FWTF%2Fwtf%2FFastMalloc.cpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Index: trunk/Source/WTF/wtf/FastMalloc.cpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+===================================================================
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- Source/WTF/wtf/FastMalloc.cpp  (revision 164727)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ Source/WTF/wtf/FastMalloc.cpp  (revision 164742)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -92,4 +92,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <mach/mach_init.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #include <malloc/malloc.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -630,26 +631,20 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ //-------------------------------------------------------------------
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++// Type that can hold the length of a run of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef uintptr_t Length;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Not all possible combinations of the following parameters make
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // sense.  In particular, if kMaxSize increases, you may have to
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // increase kNumClasses as well.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_PAGE_SHIFT PAGE_SHIFT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    if (K_PAGE_SHIFT == 12)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        define K_NUM_CLASSES 68
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    elif (K_PAGE_SHIFT == 14)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        define K_NUM_CLASSES 77
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        error "Unsupported PAGE_SHIFT amount"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_PAGE_SHIFT 12
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_NUM_CLASSES 68
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kPageShift  = K_PAGE_SHIFT;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kPageSize   = 1 << kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_PAGE_SHIFT_MIN 12
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_PAGE_SHIFT_MAX 14
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_NUM_CLASSES_MAX 77
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kPageShift  = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kNumClasses = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kPageSize   = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static Length kMaxValidPages = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kMaxSize    = 32u * 1024;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kAlignShift = 3;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kAlignment  = 1 << kAlignShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kNumClasses = K_NUM_CLASSES;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Allocates a big block of memory for the pagemap once we reach more than
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -663,5 +658,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // have small limits on the number of mmap() regions per
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // address-space.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kMinSystemAlloc = 1 << (20 - kPageShift);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static const size_t kMinSystemAlloc = 1 << (20 - K_PAGE_SHIFT_MAX);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Number of objects to move between a per-thread list and a central
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -670,5 +665,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // it too big may temporarily cause unnecessary memory wastage in the
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // per-thread free list until the scavenger cleans up the list.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static int num_objects_to_move[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static int num_objects_to_move[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Maximum length we allow a per-thread free-list to have before we
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -766,8 +761,8 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Mapping from size class to max size storable in that class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static size_t class_to_size[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t class_to_size[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Mapping from size class to number of pages to allocate at a time
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static size_t class_to_pages[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t class_to_pages[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Hardened singly linked list.  We make this a class to allow compiler to
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -814,5 +809,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // class is initially given one TCEntry which also means that the maximum any
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // one class can have is kNumClasses.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const int kNumTransferEntries = kNumClasses;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_NUM_TRANSFER_ENTRIES_MAX static_cast<int>(K_NUM_CLASSES_MAX)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define kNumTransferEntries static_cast<int>(kNumClasses)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Note: the following only works for "n"s that fit in 32-bits, but
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -918,4 +914,23 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Initialize the mapping arrays
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void InitSizeClasses() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageShift = vm_page_shift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  switch (kPageShift) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  case 12:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    kNumClasses = 68;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  case 14:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    kNumClasses = 77;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  default:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    CRASH();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageShift = 12;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kNumClasses = 68;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageSize = 1 << kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Do some sanity checking on add_amount[]/shift_amount[]/class_array[]
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (ClassIndex(0) < 0) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1145,12 +1160,8 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ typedef uintptr_t PageID;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-// Type that can hold the length of a run of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-typedef uintptr_t Length;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const Length kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Convert byte size into pages.  This won't overflow, but may return
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // an unreasonably large value if bytes is huge enough.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline Length pages(size_t bytes) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   return (bytes >> kPageShift) +
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+       ((bytes & (kPageSize - 1)) > 0 ? 1 : 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1160,4 +1171,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // allocated
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static size_t AllocationSize(size_t bytes) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (bytes > kMaxSize) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     // Large object: we allocate an integral number of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1432,5 +1444,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // end up getting all the TCEntries quota in the system we just preallocate
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // sufficient number of entries here.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  TCEntry tc_slots_[kNumTransferEntries];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  TCEntry tc_slots_[K_NUM_TRANSFER_ENTRIES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Number of currently used cached entries in tc_slots_.  This variable is
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1654,5 +1666,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <int BITS> class MapSelector {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap3<BITS-kPageShift> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap3<BITS-K_PAGE_SHIFT_MIN> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   typedef PackedCache<BITS, uint64_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1672,5 +1684,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <> class MapSelector<64> {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap3<64 - kPageShift - kBitsUnusedOn64Bit> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap3<64 - K_PAGE_SHIFT_MIN - kBitsUnusedOn64Bit> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   typedef PackedCache<64, uint64_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1680,6 +1692,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <> class MapSelector<32> {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap2<32 - kPageShift> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef PackedCache<32 - kPageShift, uint16_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap2<32 - K_PAGE_SHIFT_MIN> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef PackedCache<32 - K_PAGE_SHIFT_MIN, uint16_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1778,4 +1790,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Return number of free bytes in heap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   uint64_t FreeBytes() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     return (static_cast<uint64_t>(free_pages_) << kPageShift);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1913,4 +1926,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::init()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pagemap_.init(MetaDataAlloc);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pagemap_cache_ = PageMapCache(0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1927,5 +1942,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Start scavenging at kMaxPages list
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   scavenge_index_ = kMaxPages-1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  COMPILE_ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits), valuebits);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Init(&large_.normal, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Init(&large_.returned, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2068,4 +2083,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::scavenge()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t pagesToRelease = min_free_committed_pages_since_last_scavenge_ * kScavengePercentage;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t targetPageCount = std::max<size_t>(kMinimumFreeCommittedPageCount, free_committed_pages_ - pagesToRelease);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2229,4 +2245,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ inline void TCMalloc_PageHeap::Carve(Span* span, Length n, bool released) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(n > 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Remove(span, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2265,4 +2282,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static ALWAYS_INLINE void mergeDecommittedStates(Span* destination, Span* other)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     if (destination->decommitted && !other->decommitted) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         TCMalloc_SystemRelease(reinterpret_cast<void*>(other->start << kPageShift),
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2368,4 +2386,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if !USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::IncrementalScavenge(Length n) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Fast path; not yet time to release memory
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   scavenge_counter_ -= n;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2429,4 +2448,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #ifdef WTF_CHANGES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ size_t TCMalloc_PageHeap::ReturnedBytes() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t result = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     for (unsigned s = 0; s < kMaxPages; s++) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2444,4 +2464,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #ifndef WTF_CHANGES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static double PagesToMB(uint64_t pages) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   return (pages << kPageShift) / 1048576.0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2510,4 +2531,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ bool TCMalloc_PageHeap::GrowHeap(Length n) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(kMaxPages >= kMinSystemAlloc);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (n > kMaxValidPages) return false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2606,4 +2628,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::ReleaseFreeList(Span* list, Span* returned) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Walk backwards through list so that when we push these
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // spans on the "returned" list, we preserve the order.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2739,5 +2762,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ThreadIdentifier tid_;                // Which thread owns it
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   bool          in_setspecific_;           // Called pthread_setspecific?
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  FreeList      list_[kNumClasses];     // Array indexed by size-class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  FreeList      list_[K_NUM_CLASSES_MAX];     // Array indexed by size-class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // We sample allocations, biased by the size of the allocation
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2795,4 +2818,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   void enumerateFreeObjects(Finder& finder, const Reader& reader)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++      ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+       for (unsigned sizeClass = 0; sizeClass < kNumClasses; sizeClass++)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+           list_[sizeClass].enumerateFreeObjects(finder, reader);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2807,5 +2831,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Central cache -- a collection of free-lists, one per size-class.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // We have a separate lock per free-list to reduce contention.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static TCMalloc_Central_FreeListPadded central_cache[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static TCMalloc_Central_FreeListPadded central_cache[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Page-level allocator
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2963,4 +2987,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_Central_FreeList::Init(size_t cl, uintptr_t entropy) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   lock_.Init();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_class_ = cl;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2987,4 +3012,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE void TCMalloc_Central_FreeList::ReleaseToSpans(HardenedSLL object) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   const PageID p = reinterpret_cast<uintptr_t>(object.value()) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   Span* span = pageheap->GetDescriptor(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3033,4 +3059,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE bool TCMalloc_Central_FreeList::EvictRandomSizeClass(
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t locked_size_class, bool force) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   static int race_counter = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   int t = race_counter++;  // Updated without a lock, but who cares.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3048,4 +3075,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ bool TCMalloc_Central_FreeList::MakeCacheSpace() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Is there room in the cache?
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (used_slots_ < cache_size_) return true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3102,4 +3130,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_Central_FreeList::InsertRange(HardenedSLL start, HardenedSLL end, int N) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   SpinLockHolder h(&lock_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (N == num_objects_to_move[size_class_] &&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3184,4 +3213,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Fetch memory from the system and add to the central cache freelist.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE void TCMalloc_Central_FreeList::Populate() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Release central list lock while operating on pageheap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   lock_.Unlock();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3270,4 +3300,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Init(ThreadIdentifier tid, uintptr_t entropy) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_ = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   next_ = NULL;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3292,4 +3323,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Cleanup() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Put unused memory back into central cache
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   for (size_t cl = 0; cl < kNumClasses; ++cl) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3366,4 +3398,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Release idle memory to the central cache
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ inline void TCMalloc_ThreadCache::Scavenge() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // If the low-water mark for the free list is L, it means we would
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // not have had to allocate anything from the central cache even if
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3658,4 +3691,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Print() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   for (size_t cl = 0; cl < kNumClasses; ++cl) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     MESSAGE("      %5" PRIuS " : %4d len; %4d lo\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3679,4 +3713,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Get stats into "r".  Also get per-size-class counts if class_count != NULL
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void ExtractStats(TCMallocStats* r, uint64_t* class_count) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   r->central_bytes = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   r->transfer_bytes = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3716,4 +3751,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // WRITE stats to "out"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void DumpStats(TCMalloc_Printer* out, int level) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   TCMallocStats stats;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   uint64_t class_count[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4004,4 +4040,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if !ASSERT_DISABLED
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline bool CheckCachedSizeClass(void *ptr) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   PageID p = reinterpret_cast<uintptr_t>(ptr) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_t cached_value = pageheap->GetSizeClassIfCached(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4018,4 +4055,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline void* SpanToMallocResult(Span *span) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT_SPAN_COMMITTED(span);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pageheap->CacheSizeClass(span->start, 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4071,4 +4109,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (ptr == NULL) return;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(pageheap != NULL);  // Should not call free() before malloc()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   const PageID p = reinterpret_cast<uintptr_t>(ptr) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   Span* span = pageheap->GetDescriptor(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4122,4 +4161,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(align > 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (pageheap == NULL) TCMalloc_ThreadCache::InitModule();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Allocate at least one byte to avoid boundary conditions below
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4441,4 +4481,7 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     new_size += Internal::ValidationBufferSize;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(pageheap != NULL);  // Should not call realloc() before malloc()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Get the size of the old entry
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4660,4 +4703,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ FastMallocStatistics fastMallocStatistics()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     FastMallocStatistics statistics;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4681,4 +4725,7 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ size_t fastMallocSize(const void* ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  if (pageheap == NULL) TCMalloc_ThreadCache::InitModule();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if ENABLE(WTF_MALLOC_VALIDATION)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     return Internal::fastMallocValidationHeader(const_cast<void*>(ptr))->m_size;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4792,4 +4839,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     int visit(void* ptr) const
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         if (!ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+             return 1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4839,4 +4887,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     void recordPendingRegions()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         bool recordRegionsContainingPointers = m_typeMask & MALLOC_PTR_REGION_RANGE_TYPE;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         bool recordAllocations = m_typeMask & MALLOC_PTR_IN_USE_RANGE_TYPE;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4887,4 +4937,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     int visit(void* ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         if (!ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+             return 1;
</span><span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt58/Portfile b/aqua/qt58/Portfile
</span><span style='display:block; white-space:pre;color:#808080;'>index 798e40c7493..629ca9823fb 100644
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>--- a/aqua/qt58/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt58/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -596,7 +596,7 @@ array set modules {
</span>         {"Qt WebKit" "Qt WebKit Widgets"}
         "community support only (use Qt WebEngine)"
         "variant overrides: "
<span style='display:block; white-space:pre;background:#ffe0e0;'>-        "revision 3"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        "revision 4"
</span>         "License: "
     }
     qtwebkit-examples {
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -1382,6 +1382,11 @@ foreach {module module_info} [array get modules] {
</span> 
                 # see https://bugs.webkit.org/show_bug.cgi?id=171612
                 patchfiles-append patch-qtwebkit_fix_icu.diff
<span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # backport upstream WebKit changes to avoid
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # error: "Unsupported PAGE_SHIFT amount"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # see https://trac.macports.org/ticket/62027#comment:49
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                patchfiles-append patch-qtwebkit_fix_page_shift.diff
</span>             }
 
             # special case
<span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt58/files/patch-qtwebkit_fix_page_shift.diff b/aqua/qt58/files/patch-qtwebkit_fix_page_shift.diff
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 00000000000..113b9df3175
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt58/files/patch-qtwebkit_fix_page_shift.diff
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,384 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Upstream-Status: Backport (from upstream WebKit)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+https://bugs.webkit.org/show_bug.cgi?id=129370
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+https://trac.webkit.org/changeset?old=164727&old_path=webkit%2Ftrunk%2FSource%2FWTF%2Fwtf%2FFastMalloc.cpp&new=164742&new_path=webkit%2Ftrunk%2FSource%2FWTF%2Fwtf%2FFastMalloc.cpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Index: trunk/Source/WTF/wtf/FastMalloc.cpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+===================================================================
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- Source/WTF/wtf/FastMalloc.cpp  (revision 164727)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ Source/WTF/wtf/FastMalloc.cpp  (revision 164742)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -92,4 +92,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <mach/mach_init.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #include <malloc/malloc.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -630,26 +631,20 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ //-------------------------------------------------------------------
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++// Type that can hold the length of a run of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef uintptr_t Length;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Not all possible combinations of the following parameters make
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // sense.  In particular, if kMaxSize increases, you may have to
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // increase kNumClasses as well.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_PAGE_SHIFT PAGE_SHIFT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    if (K_PAGE_SHIFT == 12)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        define K_NUM_CLASSES 68
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    elif (K_PAGE_SHIFT == 14)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        define K_NUM_CLASSES 77
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        error "Unsupported PAGE_SHIFT amount"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_PAGE_SHIFT 12
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_NUM_CLASSES 68
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kPageShift  = K_PAGE_SHIFT;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kPageSize   = 1 << kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_PAGE_SHIFT_MIN 12
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_PAGE_SHIFT_MAX 14
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_NUM_CLASSES_MAX 77
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kPageShift  = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kNumClasses = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kPageSize   = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static Length kMaxValidPages = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kMaxSize    = 32u * 1024;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kAlignShift = 3;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kAlignment  = 1 << kAlignShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kNumClasses = K_NUM_CLASSES;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Allocates a big block of memory for the pagemap once we reach more than
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -663,5 +658,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // have small limits on the number of mmap() regions per
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // address-space.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kMinSystemAlloc = 1 << (20 - kPageShift);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static const size_t kMinSystemAlloc = 1 << (20 - K_PAGE_SHIFT_MAX);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Number of objects to move between a per-thread list and a central
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -670,5 +665,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // it too big may temporarily cause unnecessary memory wastage in the
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // per-thread free list until the scavenger cleans up the list.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static int num_objects_to_move[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static int num_objects_to_move[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Maximum length we allow a per-thread free-list to have before we
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -766,8 +761,8 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Mapping from size class to max size storable in that class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static size_t class_to_size[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t class_to_size[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Mapping from size class to number of pages to allocate at a time
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static size_t class_to_pages[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t class_to_pages[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Hardened singly linked list.  We make this a class to allow compiler to
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -814,5 +809,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // class is initially given one TCEntry which also means that the maximum any
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // one class can have is kNumClasses.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const int kNumTransferEntries = kNumClasses;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_NUM_TRANSFER_ENTRIES_MAX static_cast<int>(K_NUM_CLASSES_MAX)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define kNumTransferEntries static_cast<int>(kNumClasses)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Note: the following only works for "n"s that fit in 32-bits, but
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -918,4 +914,23 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Initialize the mapping arrays
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void InitSizeClasses() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageShift = vm_page_shift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  switch (kPageShift) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  case 12:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    kNumClasses = 68;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  case 14:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    kNumClasses = 77;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  default:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    CRASH();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageShift = 12;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kNumClasses = 68;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageSize = 1 << kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Do some sanity checking on add_amount[]/shift_amount[]/class_array[]
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (ClassIndex(0) < 0) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1145,12 +1160,8 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ typedef uintptr_t PageID;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-// Type that can hold the length of a run of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-typedef uintptr_t Length;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const Length kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Convert byte size into pages.  This won't overflow, but may return
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // an unreasonably large value if bytes is huge enough.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline Length pages(size_t bytes) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   return (bytes >> kPageShift) +
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+       ((bytes & (kPageSize - 1)) > 0 ? 1 : 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1160,4 +1171,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // allocated
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static size_t AllocationSize(size_t bytes) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (bytes > kMaxSize) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     // Large object: we allocate an integral number of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1432,5 +1444,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // end up getting all the TCEntries quota in the system we just preallocate
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // sufficient number of entries here.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  TCEntry tc_slots_[kNumTransferEntries];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  TCEntry tc_slots_[K_NUM_TRANSFER_ENTRIES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Number of currently used cached entries in tc_slots_.  This variable is
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1654,5 +1666,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <int BITS> class MapSelector {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap3<BITS-kPageShift> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap3<BITS-K_PAGE_SHIFT_MIN> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   typedef PackedCache<BITS, uint64_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1672,5 +1684,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <> class MapSelector<64> {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap3<64 - kPageShift - kBitsUnusedOn64Bit> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap3<64 - K_PAGE_SHIFT_MIN - kBitsUnusedOn64Bit> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   typedef PackedCache<64, uint64_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1680,6 +1692,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <> class MapSelector<32> {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap2<32 - kPageShift> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef PackedCache<32 - kPageShift, uint16_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap2<32 - K_PAGE_SHIFT_MIN> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef PackedCache<32 - K_PAGE_SHIFT_MIN, uint16_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1778,4 +1790,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Return number of free bytes in heap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   uint64_t FreeBytes() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     return (static_cast<uint64_t>(free_pages_) << kPageShift);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1913,4 +1926,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::init()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pagemap_.init(MetaDataAlloc);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pagemap_cache_ = PageMapCache(0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1927,5 +1942,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Start scavenging at kMaxPages list
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   scavenge_index_ = kMaxPages-1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  COMPILE_ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits), valuebits);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Init(&large_.normal, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Init(&large_.returned, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2068,4 +2083,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::scavenge()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t pagesToRelease = min_free_committed_pages_since_last_scavenge_ * kScavengePercentage;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t targetPageCount = std::max<size_t>(kMinimumFreeCommittedPageCount, free_committed_pages_ - pagesToRelease);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2229,4 +2245,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ inline void TCMalloc_PageHeap::Carve(Span* span, Length n, bool released) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(n > 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Remove(span, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2265,4 +2282,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static ALWAYS_INLINE void mergeDecommittedStates(Span* destination, Span* other)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     if (destination->decommitted && !other->decommitted) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         TCMalloc_SystemRelease(reinterpret_cast<void*>(other->start << kPageShift),
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2368,4 +2386,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if !USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::IncrementalScavenge(Length n) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Fast path; not yet time to release memory
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   scavenge_counter_ -= n;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2429,4 +2448,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #ifdef WTF_CHANGES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ size_t TCMalloc_PageHeap::ReturnedBytes() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t result = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     for (unsigned s = 0; s < kMaxPages; s++) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2444,4 +2464,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #ifndef WTF_CHANGES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static double PagesToMB(uint64_t pages) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   return (pages << kPageShift) / 1048576.0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2510,4 +2531,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ bool TCMalloc_PageHeap::GrowHeap(Length n) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(kMaxPages >= kMinSystemAlloc);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (n > kMaxValidPages) return false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2606,4 +2628,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::ReleaseFreeList(Span* list, Span* returned) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Walk backwards through list so that when we push these
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // spans on the "returned" list, we preserve the order.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2739,5 +2762,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ThreadIdentifier tid_;                // Which thread owns it
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   bool          in_setspecific_;           // Called pthread_setspecific?
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  FreeList      list_[kNumClasses];     // Array indexed by size-class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  FreeList      list_[K_NUM_CLASSES_MAX];     // Array indexed by size-class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // We sample allocations, biased by the size of the allocation
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2795,4 +2818,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   void enumerateFreeObjects(Finder& finder, const Reader& reader)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++      ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+       for (unsigned sizeClass = 0; sizeClass < kNumClasses; sizeClass++)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+           list_[sizeClass].enumerateFreeObjects(finder, reader);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2807,5 +2831,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Central cache -- a collection of free-lists, one per size-class.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // We have a separate lock per free-list to reduce contention.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static TCMalloc_Central_FreeListPadded central_cache[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static TCMalloc_Central_FreeListPadded central_cache[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Page-level allocator
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2963,4 +2987,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_Central_FreeList::Init(size_t cl, uintptr_t entropy) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   lock_.Init();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_class_ = cl;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2987,4 +3012,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE void TCMalloc_Central_FreeList::ReleaseToSpans(HardenedSLL object) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   const PageID p = reinterpret_cast<uintptr_t>(object.value()) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   Span* span = pageheap->GetDescriptor(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3033,4 +3059,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE bool TCMalloc_Central_FreeList::EvictRandomSizeClass(
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t locked_size_class, bool force) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   static int race_counter = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   int t = race_counter++;  // Updated without a lock, but who cares.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3048,4 +3075,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ bool TCMalloc_Central_FreeList::MakeCacheSpace() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Is there room in the cache?
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (used_slots_ < cache_size_) return true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3102,4 +3130,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_Central_FreeList::InsertRange(HardenedSLL start, HardenedSLL end, int N) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   SpinLockHolder h(&lock_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (N == num_objects_to_move[size_class_] &&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3184,4 +3213,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Fetch memory from the system and add to the central cache freelist.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE void TCMalloc_Central_FreeList::Populate() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Release central list lock while operating on pageheap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   lock_.Unlock();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3270,4 +3300,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Init(ThreadIdentifier tid, uintptr_t entropy) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_ = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   next_ = NULL;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3292,4 +3323,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Cleanup() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Put unused memory back into central cache
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   for (size_t cl = 0; cl < kNumClasses; ++cl) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3366,4 +3398,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Release idle memory to the central cache
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ inline void TCMalloc_ThreadCache::Scavenge() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // If the low-water mark for the free list is L, it means we would
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // not have had to allocate anything from the central cache even if
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3658,4 +3691,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Print() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   for (size_t cl = 0; cl < kNumClasses; ++cl) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     MESSAGE("      %5" PRIuS " : %4d len; %4d lo\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3679,4 +3713,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Get stats into "r".  Also get per-size-class counts if class_count != NULL
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void ExtractStats(TCMallocStats* r, uint64_t* class_count) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   r->central_bytes = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   r->transfer_bytes = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3716,4 +3751,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // WRITE stats to "out"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void DumpStats(TCMalloc_Printer* out, int level) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   TCMallocStats stats;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   uint64_t class_count[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4004,4 +4040,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if !ASSERT_DISABLED
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline bool CheckCachedSizeClass(void *ptr) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   PageID p = reinterpret_cast<uintptr_t>(ptr) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_t cached_value = pageheap->GetSizeClassIfCached(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4018,4 +4055,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline void* SpanToMallocResult(Span *span) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT_SPAN_COMMITTED(span);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pageheap->CacheSizeClass(span->start, 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4071,4 +4109,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (ptr == NULL) return;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(pageheap != NULL);  // Should not call free() before malloc()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   const PageID p = reinterpret_cast<uintptr_t>(ptr) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   Span* span = pageheap->GetDescriptor(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4122,4 +4161,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(align > 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (pageheap == NULL) TCMalloc_ThreadCache::InitModule();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Allocate at least one byte to avoid boundary conditions below
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4441,4 +4481,7 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     new_size += Internal::ValidationBufferSize;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(pageheap != NULL);  // Should not call realloc() before malloc()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Get the size of the old entry
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4660,4 +4703,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ FastMallocStatistics fastMallocStatistics()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     FastMallocStatistics statistics;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4681,4 +4725,7 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ size_t fastMallocSize(const void* ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  if (pageheap == NULL) TCMalloc_ThreadCache::InitModule();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if ENABLE(WTF_MALLOC_VALIDATION)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     return Internal::fastMallocValidationHeader(const_cast<void*>(ptr))->m_size;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4792,4 +4839,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     int visit(void* ptr) const
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         if (!ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+             return 1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4839,4 +4887,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     void recordPendingRegions()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         bool recordRegionsContainingPointers = m_typeMask & MALLOC_PTR_REGION_RANGE_TYPE;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         bool recordAllocations = m_typeMask & MALLOC_PTR_IN_USE_RANGE_TYPE;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4887,4 +4937,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     int visit(void* ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         if (!ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+             return 1;
</span><span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt59/Portfile b/aqua/qt59/Portfile
</span><span style='display:block; white-space:pre;color:#808080;'>index ad2755ffe45..50aa2d3862d 100644
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>--- a/aqua/qt59/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt59/Portfile
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -615,7 +615,7 @@ array set modules {
</span>         {"Qt WebKit" "Qt WebKit Widgets"}
         "community support only (use Qt WebEngine)"
         "variant overrides: "
<span style='display:block; white-space:pre;background:#ffe0e0;'>-        "revision 3"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+        "revision 4"
</span>         "License: "
     }
     qtwebkit-examples {
<span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -1412,6 +1412,11 @@ foreach {module module_info} [array get modules] {
</span> 
                 # see https://bugs.webkit.org/show_bug.cgi?id=171612
                 patchfiles-append patch-qtwebkit_fix_icu.diff
<span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # backport upstream WebKit changes to avoid
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # error: "Unsupported PAGE_SHIFT amount"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                # see https://trac.macports.org/ticket/62027#comment:49
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+                patchfiles-append patch-qtwebkit_fix_page_shift.diff
</span>             }
 
             # special case
<span style='display:block; white-space:pre;color:#808080;'>diff --git a/aqua/qt59/files/patch-qtwebkit_fix_page_shift.diff b/aqua/qt59/files/patch-qtwebkit_fix_page_shift.diff
</span>new file mode 100644
<span style='display:block; white-space:pre;color:#808080;'>index 00000000000..113b9df3175
</span><span style='display:block; white-space:pre;background:#ffe0e0;'>--- /dev/null
</span><span style='display:block; white-space:pre;background:#e0e0ff;'>+++ b/aqua/qt59/files/patch-qtwebkit_fix_page_shift.diff
</span><span style='display:block; white-space:pre;background:#e0e0e0;'>@@ -0,0 +1,384 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Upstream-Status: Backport (from upstream WebKit)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+https://bugs.webkit.org/show_bug.cgi?id=129370
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+https://trac.webkit.org/changeset?old=164727&old_path=webkit%2Ftrunk%2FSource%2FWTF%2Fwtf%2FFastMalloc.cpp&new=164742&new_path=webkit%2Ftrunk%2FSource%2FWTF%2Fwtf%2FFastMalloc.cpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+Index: trunk/Source/WTF/wtf/FastMalloc.cpp
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+===================================================================
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+--- Source/WTF/wtf/FastMalloc.cpp  (revision 164727)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++++ Source/WTF/wtf/FastMalloc.cpp  (revision 164742)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -92,4 +92,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#include <mach/mach_init.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #include <malloc/malloc.h>
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -630,26 +631,20 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ //-------------------------------------------------------------------
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++// Type that can hold the length of a run of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++typedef uintptr_t Length;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Not all possible combinations of the following parameters make
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // sense.  In particular, if kMaxSize increases, you may have to
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // increase kNumClasses as well.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_PAGE_SHIFT PAGE_SHIFT
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    if (K_PAGE_SHIFT == 12)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        define K_NUM_CLASSES 68
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    elif (K_PAGE_SHIFT == 14)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        define K_NUM_CLASSES 77
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#        error "Unsupported PAGE_SHIFT amount"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_PAGE_SHIFT 12
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#    define K_NUM_CLASSES 68
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kPageShift  = K_PAGE_SHIFT;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kPageSize   = 1 << kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_PAGE_SHIFT_MIN 12
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_PAGE_SHIFT_MAX 14
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_NUM_CLASSES_MAX 77
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kPageShift  = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kNumClasses = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t kPageSize   = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static Length kMaxValidPages = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kMaxSize    = 32u * 1024;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kAlignShift = 3;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static const size_t kAlignment  = 1 << kAlignShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kNumClasses = K_NUM_CLASSES;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Allocates a big block of memory for the pagemap once we reach more than
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -663,5 +658,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // have small limits on the number of mmap() regions per
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // address-space.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const size_t kMinSystemAlloc = 1 << (20 - kPageShift);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static const size_t kMinSystemAlloc = 1 << (20 - K_PAGE_SHIFT_MAX);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Number of objects to move between a per-thread list and a central
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -670,5 +665,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // it too big may temporarily cause unnecessary memory wastage in the
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // per-thread free list until the scavenger cleans up the list.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static int num_objects_to_move[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static int num_objects_to_move[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Maximum length we allow a per-thread free-list to have before we
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -766,8 +761,8 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Mapping from size class to max size storable in that class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static size_t class_to_size[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t class_to_size[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Mapping from size class to number of pages to allocate at a time
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static size_t class_to_pages[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static size_t class_to_pages[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Hardened singly linked list.  We make this a class to allow compiler to
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -814,5 +809,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // class is initially given one TCEntry which also means that the maximum any
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // one class can have is kNumClasses.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const int kNumTransferEntries = kNumClasses;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define K_NUM_TRANSFER_ENTRIES_MAX static_cast<int>(K_NUM_CLASSES_MAX)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#define kNumTransferEntries static_cast<int>(kNumClasses)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Note: the following only works for "n"s that fit in 32-bits, but
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -918,4 +914,23 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Initialize the mapping arrays
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void InitSizeClasses() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#if OS(DARWIN)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageShift = vm_page_shift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  switch (kPageShift) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  case 12:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    kNumClasses = 68;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  case 14:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    kNumClasses = 77;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    break;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  default:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    CRASH();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#else
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageShift = 12;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kNumClasses = 68;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++#endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kPageSize = 1 << kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Do some sanity checking on add_amount[]/shift_amount[]/class_array[]
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (ClassIndex(0) < 0) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1145,12 +1160,8 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ typedef uintptr_t PageID;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-// Type that can hold the length of a run of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-typedef uintptr_t Length;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static const Length kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Convert byte size into pages.  This won't overflow, but may return
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // an unreasonably large value if bytes is huge enough.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline Length pages(size_t bytes) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   return (bytes >> kPageShift) +
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+       ((bytes & (kPageSize - 1)) > 0 ? 1 : 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1160,4 +1171,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // allocated
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static size_t AllocationSize(size_t bytes) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (bytes > kMaxSize) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     // Large object: we allocate an integral number of pages
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1432,5 +1444,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // end up getting all the TCEntries quota in the system we just preallocate
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // sufficient number of entries here.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  TCEntry tc_slots_[kNumTransferEntries];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  TCEntry tc_slots_[K_NUM_TRANSFER_ENTRIES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Number of currently used cached entries in tc_slots_.  This variable is
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1654,5 +1666,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <int BITS> class MapSelector {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap3<BITS-kPageShift> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap3<BITS-K_PAGE_SHIFT_MIN> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   typedef PackedCache<BITS, uint64_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1672,5 +1684,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <> class MapSelector<64> {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap3<64 - kPageShift - kBitsUnusedOn64Bit> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap3<64 - K_PAGE_SHIFT_MIN - kBitsUnusedOn64Bit> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   typedef PackedCache<64, uint64_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1680,6 +1692,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ template <> class MapSelector<32> {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+  public:
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef TCMalloc_PageMap2<32 - kPageShift> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  typedef PackedCache<32 - kPageShift, uint16_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef TCMalloc_PageMap2<32 - K_PAGE_SHIFT_MIN> Type;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  typedef PackedCache<32 - K_PAGE_SHIFT_MIN, uint16_t> CacheType;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ };
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1778,4 +1790,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Return number of free bytes in heap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   uint64_t FreeBytes() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     return (static_cast<uint64_t>(free_pages_) << kPageShift);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1913,4 +1926,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::init()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pagemap_.init(MetaDataAlloc);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pagemap_cache_ = PageMapCache(0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -1927,5 +1942,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Start scavenging at kMaxPages list
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   scavenge_index_ = kMaxPages-1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  COMPILE_ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits), valuebits);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits));
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Init(&large_.normal, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Init(&large_.returned, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2068,4 +2083,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::scavenge()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t pagesToRelease = min_free_committed_pages_since_last_scavenge_ * kScavengePercentage;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t targetPageCount = std::max<size_t>(kMinimumFreeCommittedPageCount, free_committed_pages_ - pagesToRelease);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2229,4 +2245,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ inline void TCMalloc_PageHeap::Carve(Span* span, Length n, bool released) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(n > 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   DLL_Remove(span, entropy_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2265,4 +2282,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static ALWAYS_INLINE void mergeDecommittedStates(Span* destination, Span* other)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     if (destination->decommitted && !other->decommitted) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         TCMalloc_SystemRelease(reinterpret_cast<void*>(other->start << kPageShift),
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2368,4 +2386,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if !USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::IncrementalScavenge(Length n) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Fast path; not yet time to release memory
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   scavenge_counter_ -= n;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2429,4 +2448,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #ifdef WTF_CHANGES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ size_t TCMalloc_PageHeap::ReturnedBytes() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t result = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     for (unsigned s = 0; s < kMaxPages; s++) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2444,4 +2464,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #ifndef WTF_CHANGES
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static double PagesToMB(uint64_t pages) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   return (pages << kPageShift) / 1048576.0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ }
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2510,4 +2531,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ bool TCMalloc_PageHeap::GrowHeap(Length n) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(kMaxPages >= kMinSystemAlloc);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (n > kMaxValidPages) return false;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2606,4 +2628,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_PageHeap::ReleaseFreeList(Span* list, Span* returned) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Walk backwards through list so that when we push these
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // spans on the "returned" list, we preserve the order.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2739,5 +2762,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ThreadIdentifier tid_;                // Which thread owns it
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   bool          in_setspecific_;           // Called pthread_setspecific?
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-  FreeList      list_[kNumClasses];     // Array indexed by size-class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  FreeList      list_[K_NUM_CLASSES_MAX];     // Array indexed by size-class
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // We sample allocations, biased by the size of the allocation
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2795,4 +2818,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   void enumerateFreeObjects(Finder& finder, const Reader& reader)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++      ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+       for (unsigned sizeClass = 0; sizeClass < kNumClasses; sizeClass++)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+           list_[sizeClass].enumerateFreeObjects(finder, reader);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2807,5 +2831,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Central cache -- a collection of free-lists, one per size-class.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // We have a separate lock per free-list to reduce contention.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+-static TCMalloc_Central_FreeListPadded central_cache[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++static TCMalloc_Central_FreeListPadded central_cache[K_NUM_CLASSES_MAX];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Page-level allocator
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2963,4 +2987,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_Central_FreeList::Init(size_t cl, uintptr_t entropy) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   lock_.Init();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_class_ = cl;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -2987,4 +3012,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE void TCMalloc_Central_FreeList::ReleaseToSpans(HardenedSLL object) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   const PageID p = reinterpret_cast<uintptr_t>(object.value()) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   Span* span = pageheap->GetDescriptor(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3033,4 +3059,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE bool TCMalloc_Central_FreeList::EvictRandomSizeClass(
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     size_t locked_size_class, bool force) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   static int race_counter = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   int t = race_counter++;  // Updated without a lock, but who cares.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3048,4 +3075,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ bool TCMalloc_Central_FreeList::MakeCacheSpace() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Is there room in the cache?
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (used_slots_ < cache_size_) return true;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3102,4 +3130,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_Central_FreeList::InsertRange(HardenedSLL start, HardenedSLL end, int N) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   SpinLockHolder h(&lock_);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (N == num_objects_to_move[size_class_] &&
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3184,4 +3213,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Fetch memory from the system and add to the central cache freelist.
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ ALWAYS_INLINE void TCMalloc_Central_FreeList::Populate() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Release central list lock while operating on pageheap
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   lock_.Unlock();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3270,4 +3300,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Init(ThreadIdentifier tid, uintptr_t entropy) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_ = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   next_ = NULL;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3292,4 +3323,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Cleanup() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Put unused memory back into central cache
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   for (size_t cl = 0; cl < kNumClasses; ++cl) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3366,4 +3398,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Release idle memory to the central cache
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ inline void TCMalloc_ThreadCache::Scavenge() {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // If the low-water mark for the free list is L, it means we would
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // not have had to allocate anything from the central cache even if
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3658,4 +3691,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ void TCMalloc_ThreadCache::Print() const {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   for (size_t cl = 0; cl < kNumClasses; ++cl) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     MESSAGE("      %5" PRIuS " : %4d len; %4d lo\n",
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3679,4 +3713,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // Get stats into "r".  Also get per-size-class counts if class_count != NULL
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void ExtractStats(TCMallocStats* r, uint64_t* class_count) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   r->central_bytes = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   r->transfer_bytes = 0;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -3716,4 +3751,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ // WRITE stats to "out"
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static void DumpStats(TCMalloc_Printer* out, int level) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   TCMallocStats stats;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   uint64_t class_count[kNumClasses];
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4004,4 +4040,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if !ASSERT_DISABLED
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline bool CheckCachedSizeClass(void *ptr) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   PageID p = reinterpret_cast<uintptr_t>(ptr) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   size_t cached_value = pageheap->GetSizeClassIfCached(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4018,4 +4055,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ static inline void* SpanToMallocResult(Span *span) {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT_SPAN_COMMITTED(span);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   pageheap->CacheSizeClass(span->start, 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4071,4 +4109,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (ptr == NULL) return;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(pageheap != NULL);  // Should not call free() before malloc()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   const PageID p = reinterpret_cast<uintptr_t>(ptr) >> kPageShift;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   Span* span = pageheap->GetDescriptor(p);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4122,4 +4161,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   ASSERT(align > 0);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   if (pageheap == NULL) TCMalloc_ThreadCache::InitModule();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Allocate at least one byte to avoid boundary conditions below
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4441,4 +4481,7 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     new_size += Internal::ValidationBufferSize;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #endif
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(pageheap != NULL);  // Should not call realloc() before malloc()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+   // Get the size of the old entry
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4660,4 +4703,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ FastMallocStatistics fastMallocStatistics()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++    ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     FastMallocStatistics statistics;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ 
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4681,4 +4725,7 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ size_t fastMallocSize(const void* ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  if (pageheap == NULL) TCMalloc_ThreadCache::InitModule();
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++  ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+ #if ENABLE(WTF_MALLOC_VALIDATION)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     return Internal::fastMallocValidationHeader(const_cast<void*>(ptr))->m_size;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4792,4 +4839,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     int visit(void* ptr) const
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         if (!ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+             return 1;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4839,4 +4887,6 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     void recordPendingRegions()
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         bool recordRegionsContainingPointers = m_typeMask & MALLOC_PTR_REGION_RANGE_TYPE;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         bool recordAllocations = m_typeMask & MALLOC_PTR_IN_USE_RANGE_TYPE;
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+@@ -4887,4 +4937,5 @@
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     int visit(void* ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+     {
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>++        ASSERT(kPageShift && kNumClasses && kPageSize);
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+         if (!ptr)
</span><span style='display:block; white-space:pre;background:#e0ffe0;'>+             return 1;
</span></pre><pre style='margin:0'>

</pre>