-[IOS8] Project now compiles with iOS 8 and Xcode 6. Fix based in newer JSC versions.

Author: Dario Segura

JavaScriptCore/runtime/ArgumentsIteratorConstructor.cpp

@@ -31,6 +31,7 @@
 #include "JSCJSValueInlines.h"
 #include "JSCellInlines.h"
 #include "JSGlobalObject.h"
+#include "StructureInlines.h" 
 
 namespace JSC {
 

JavaScriptCore/runtime/JSPromiseFunctions.cpp

@@ -34,6 +34,7 @@
 #include "JSPromise.h"
 #include "JSPromiseConstructor.h"
 #include "JSPromiseDeferred.h"
+#include "StructureInlines.h"
 
 namespace JSC {
 

JavaScriptCore/runtime/MapConstructor.cpp

@@ -32,6 +32,7 @@
 #include "JSGlobalObject.h"
 #include "JSMap.h"
 #include "MapPrototype.h"
+#include "StructureInlines.h"
 
 namespace JSC {
 

JavaScriptCore/runtime/MapIteratorConstructor.cpp

@@ -31,6 +31,7 @@
 #include "JSGlobalObject.h"
 #include "JSMapIterator.h"
 #include "MapIteratorPrototype.h"
+#include "StructureInlines.h"
 
 namespace JSC {
 

JavaScriptCore/runtime/SetConstructor.cpp

@@ -33,6 +33,7 @@
 #include "JSSet.h"
 #include "MapData.h"
 #include "SetPrototype.h"
+#include "StructureInlines.h"
 
 namespace JSC {
 

JavaScriptCore/runtime/SetIteratorConstructor.cpp

@@ -31,6 +31,7 @@
 #include "JSGlobalObject.h"
 #include "JSSetIterator.h"
 #include "SetIteratorPrototype.h"
+#include "StructureInlines.h"
 
 namespace JSC {
 

JavaScriptCore/runtime/WeakMapConstructor.cpp

@@ -31,6 +31,7 @@
 #include "JSGlobalObject.h"
 #include "JSWeakMap.h"
 #include "WeakMapPrototype.h"
+#include "StructureInlines.h"
 
 namespace JSC {
 

WTF/wtf/FastMalloc.cpp

@@ -91,6 +91,7 @@
 #include <wtf/StdLibExtras.h>
 
 #if OS(DARWIN)
+#include <mach/mach_init.h>
 #include <malloc/malloc.h>
 #endif
 
@@ -629,28 +630,45 @@ static ALWAYS_INLINE uint32_t freedObjectEndPoison()
 // Configuration
 //-------------------------------------------------------------------
 
-// Not all possible combinations of the following parameters make
-// sense.  In particular, if kMaxSize increases, you may have to
-// increase kNumClasses as well.
-#if OS(DARWIN)
-#    define K_PAGE_SHIFT PAGE_SHIFT
-#    if (K_PAGE_SHIFT == 12)
-#        define K_NUM_CLASSES 68
-#    elif (K_PAGE_SHIFT == 14)
-#        define K_NUM_CLASSES 77
-#    else
-#        error "Unsupported PAGE_SHIFT amount"
-#    endif
-#else
-#    define K_PAGE_SHIFT 12
-#    define K_NUM_CLASSES 68
-#endif
-static const size_t kPageShift  = K_PAGE_SHIFT;
-static const size_t kPageSize   = 1 << kPageShift;
-static const size_t kMaxSize    = 32u * 1024;
-static const size_t kAlignShift = 3;
-static const size_t kAlignment  = 1 << kAlignShift;
-static const size_t kNumClasses = K_NUM_CLASSES;
+//// Not all possible combinations of the following parameters make
+//// sense.  In particular, if kMaxSize increases, you may have to
+//// increase kNumClasses as well.
+//#if OS(DARWIN)
+//#    define K_PAGE_SHIFT PAGE_SHIFT
+//#    if (K_PAGE_SHIFT == 12)
+//#        define K_NUM_CLASSES 68
+//#    elif (K_PAGE_SHIFT == 14)
+//#        define K_NUM_CLASSES 77
+//#    else
+//#        error "Unsupported PAGE_SHIFT amount"
+//#    endif
+//#else
+//#    define K_PAGE_SHIFT 12
+//#    define K_NUM_CLASSES 68
+//#endif
+//static const size_t kPageShift  = K_PAGE_SHIFT;
+//static const size_t kPageSize   = 1 << kPageShift;
+//static const size_t kMaxSize    = 32u * 1024;
+//static const size_t kAlignShift = 3;
+//static const size_t kAlignment  = 1 << kAlignShift;
+//static const size_t kNumClasses = K_NUM_CLASSES;
+    
+    // Type that can hold the length of a run of pages
+    typedef uintptr_t Length;
+    
+    // Not all possible combinations of the following parameters make
+    // sense.  In particular, if kMaxSize increases, you may have to
+    // increase kNumClasses as well.
+#define K_PAGE_SHIFT_MIN 12
+#define K_PAGE_SHIFT_MAX 14
+#define K_NUM_CLASSES_MAX 77
+    static size_t kPageShift  = 0;
+    static size_t kNumClasses = 0;
+    static size_t kPageSize   = 0;
+    static Length kMaxValidPages = 0;
+    static const size_t kMaxSize    = 32u * 1024;
+    static const size_t kAlignShift = 3;
+    static const size_t kAlignment  = 1 << kAlignShift;
 
 // Allocates a big block of memory for the pagemap once we reach more than
 // 128MB
@@ -662,14 +680,14 @@ static const size_t kPageMapBigAllocationThreshold = 128 << 20;
 // should keep this value big because various incarnations of Linux
 // have small limits on the number of mmap() regions per
 // address-space.
-static const size_t kMinSystemAlloc = 1 << (20 - kPageShift);
+static const size_t kMinSystemAlloc = 1 << (20 - K_PAGE_SHIFT_MAX);
 
 // Number of objects to move between a per-thread list and a central
 // list in one shot.  We want this to be not too small so we can
 // amortize the lock overhead for accessing the central list.  Making
 // it too big may temporarily cause unnecessary memory wastage in the
 // per-thread free list until the scavenger cleans up the list.
-static int num_objects_to_move[kNumClasses];
+static int num_objects_to_move[K_NUM_CLASSES_MAX];
 
 // Maximum length we allow a per-thread free-list to have before we
 // move objects from it into the corresponding central free-list.  We
@@ -765,10 +783,10 @@ static inline int ClassIndex(size_t s) {
 }
 
 // Mapping from size class to max size storable in that class
-static size_t class_to_size[kNumClasses];
+static size_t class_to_size[K_NUM_CLASSES_MAX];
 
 // Mapping from size class to number of pages to allocate at a time
-static size_t class_to_pages[kNumClasses];
+static size_t class_to_pages[K_NUM_CLASSES_MAX];
 
 // Hardened singly linked list.  We make this a class to allow compiler to
 // statically prevent mismatching hardened and non-hardened list
@@ -808,12 +826,13 @@ struct TCEntry {
   HardenedSLL head;  // Head of chain of objects.
   HardenedSLL tail;  // Tail of chain of objects.
 };
-// A central cache freelist can have anywhere from 0 to kNumTransferEntries
-// slots to put link list chains into.  To keep memory usage bounded the total
-// number of TCEntries across size classes is fixed.  Currently each size
-// class is initially given one TCEntry which also means that the maximum any
-// one class can have is kNumClasses.
-static const int kNumTransferEntries = kNumClasses;
+    // A central cache freelist can have anywhere from 0 to kNumTransferEntries
+    // slots to put link list chains into.  To keep memory usage bounded the total
+    // number of TCEntries across size classes is fixed.  Currently each size
+    // class is initially given one TCEntry which also means that the maximum any
+    // one class can have is kNumClasses.
+#define K_NUM_TRANSFER_ENTRIES_MAX static_cast<int>(K_NUM_CLASSES_MAX)
+#define kNumTransferEntries static_cast<int>(kNumClasses)
 
 // Note: the following only works for "n"s that fit in 32-bits, but
 // that is fine since we only use it for small sizes.
@@ -917,6 +936,25 @@ static int NumMoveSize(size_t size) {
 
 // Initialize the mapping arrays
 static void InitSizeClasses() {
+#if OS(DARWIN)
+    kPageShift = vm_page_shift;
+    switch (kPageShift) {
+        case 12:
+        kNumClasses = 68;
+        break;
+        case 14:
+        kNumClasses = 77;
+        break;
+        default:
+        CRASH();
+    };
+#else
+    kPageShift = 12;
+    kNumClasses = 68;
+#endif
+    kPageSize = 1 << kPageShift;
+    kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
+    
   // Do some sanity checking on add_amount[]/shift_amount[]/class_array[]
   if (ClassIndex(0) < 0) {
     MESSAGE("Invalid class index %d for size 0\n", ClassIndex(0));
@@ -1144,11 +1182,6 @@ class PageHeapAllocator {
 // Type that can hold a page number
 typedef uintptr_t PageID;
 
-// Type that can hold the length of a run of pages
-typedef uintptr_t Length;
-
-static const Length kMaxValidPages = (~static_cast<Length>(0)) >> kPageShift;
-
 // Convert byte size into pages.  This won't overflow, but may return
 // an unreasonably large value if bytes is huge enough.
 static inline Length pages(size_t bytes) {
@@ -1431,7 +1464,7 @@ class TCMalloc_Central_FreeList {
   // Here we reserve space for TCEntry cache slots.  Since one size class can
   // end up getting all the TCEntries quota in the system we just preallocate
   // sufficient number of entries here.
-  TCEntry tc_slots_[kNumTransferEntries];
+  TCEntry tc_slots_[K_NUM_TRANSFER_ENTRIES_MAX];
 
   // Number of currently used cached entries in tc_slots_.  This variable is
   // updated under a lock but can be read without one.
@@ -1677,16 +1710,16 @@ static const size_t kBitsUnusedOn64Bit = 0;
 // A three-level map for 64-bit machines
 template <> class MapSelector<64> {
  public:
-  typedef TCMalloc_PageMap3<64 - kPageShift - kBitsUnusedOn64Bit> Type;
+  typedef TCMalloc_PageMap3<64 - K_PAGE_SHIFT_MIN - kBitsUnusedOn64Bit> Type;
   typedef PackedCache<64, uint64_t> CacheType;
 };
 #endif
 
 // A two-level map for 32-bit machines
 template <> class MapSelector<32> {
  public:
-  typedef TCMalloc_PageMap2<32 - kPageShift> Type;
-  typedef PackedCache<32 - kPageShift, uint16_t> CacheType;
+  typedef TCMalloc_PageMap2<32 - K_PAGE_SHIFT_MIN> Type;
+  typedef PackedCache<32 - K_PAGE_SHIFT_MIN, uint16_t> CacheType;
 };
 
 // -------------------------------------------------------------------------
@@ -1932,7 +1965,7 @@ void TCMalloc_PageHeap::init()
   scavenge_counter_ = 0;
   // Start scavenging at kMaxPages list
   scavenge_index_ = kMaxPages-1;
-  COMPILE_ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits), valuebits);
+  ASSERT(kNumClasses <= (1 << PageMapCache::kValuebits));
   DLL_Init(&large_.normal, entropy_);
   DLL_Init(&large_.returned, entropy_);
   for (size_t i = 0; i < kMaxPages; i++) {
@@ -2744,7 +2777,7 @@ class TCMalloc_ThreadCache {
   size_t        size_;                  // Combined size of data
   ThreadIdentifier tid_;                // Which thread owns it
   bool          in_setspecific_;           // Called pthread_setspecific?
-  FreeList      list_[kNumClasses];     // Array indexed by size-class
+  FreeList      list_[K_NUM_CLASSES_MAX];     // Array indexed by size-class
 
   // We sample allocations, biased by the size of the allocation
   uint32_t      rnd_;                   // Cheap random number generator
@@ -2812,7 +2845,7 @@ class TCMalloc_ThreadCache {
 
 // Central cache -- a collection of free-lists, one per size-class.
 // We have a separate lock per free-list to reduce contention.
-static TCMalloc_Central_FreeListPadded central_cache[kNumClasses];
+static TCMalloc_Central_FreeListPadded central_cache[K_NUM_CLASSES_MAX];
 
 // Page-level allocator
 static AllocAlignmentInteger pageheap_memory[(sizeof(TCMalloc_PageHeap) + sizeof(AllocAlignmentInteger) - 1) / sizeof(AllocAlignmentInteger)];