Rename OS(DARWIN) to OS(MACOSX).

Source/wtf/FastMalloc.cpp

 // Copyright (c) 2005, 2007, Google Inc.
 // All rights reserved.
 // Copyright (C) 2005, 2006, 2007, 2008, 2009, 2011 Apple Inc. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 64 matching lines @@
 //   goes from about 1100 ns to about 300 ns.
 
 #include "config.h"
 #include "wtf/FastMalloc.h"
 
 #include "wtf/Assertions.h"
 #include "wtf/CPU.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/UnusedParam.h"
 
-#if OS(DARWIN)
+#if OS(MACOSX)
 #include <AvailabilityMacros.h>
 #endif
 
 #include <limits>
 #if OS(WINDOWS)
 #include <windows.h>
 #else
 #include <pthread.h>
 #endif
 #include <stdlib.h>
@@ skipping 102 matching lines @@
     size_t len = strlen(src) + 1;
     char* dup = static_cast<char*>(fastMalloc(len));
     memcpy(dup, src, len);
     return dup;
 }
 
 } // namespace WTF
 
 #if FORCE_SYSTEM_MALLOC
 
-#if OS(DARWIN)
+#if OS(MACOSX)
 #include <malloc/malloc.h>
 #elif OS(WINDOWS)
 #include <malloc.h>
 #endif
 
 namespace WTF {
 
 size_t fastMallocGoodSize(size_t bytes)
 {
-#if OS(DARWIN)
+#if OS(MACOSX)
     return malloc_good_size(bytes);
 #else
     return bytes;
 #endif
 }
 
 void* fastMalloc(size_t n)
 {
     ASSERT(!isForbidden());
 
@@ skipping 33 matching lines @@
 void releaseFastMallocFreeMemory() { }
 
 FastMallocStatistics fastMallocStatistics()
 {
     FastMallocStatistics statistics = { 0, 0, 0 };
     return statistics;
 }
 
 } // namespace WTF
 
-#if OS(DARWIN)
+#if OS(MACOSX)
 // This symbol is present in the JavaScriptCore exports file even when FastMalloc is disabled.
 // It will never be used in this case, so it's type and value are less interesting than its presence.
 extern "C"  const int jscore_fastmalloc_introspection = 0;
 #endif
 
 #else // FORCE_SYSTEM_MALLOC
 
 #include "Compiler.h"
 #include "TCPackedCache.h"
 #include "TCPageMap.h"
 #include "TCSpinLock.h"
 #include "TCSystemAlloc.h"
 #include <algorithm>
 #include <errno.h>
 #include <pthread.h>
 #include <stdarg.h>
 #include <stddef.h>
 #if OS(UNIX)
 #include <unistd.h>
 #endif
 #if OS(WINDOWS)
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
 #endif
 #include <windows.h>
 #endif
 
-#if OS(DARWIN)
+#if OS(MACOSX)
 #include "MallocZoneSupport.h"
 #include "wtf/HashSet.h"
 #include "wtf/Vector.h"
 #else
 #include "wtf/CurrentTime.h"
 #endif
 
 #if HAVE(DISPATCH_H)
 #include <dispatch/dispatch.h>
 #endif
 
 #ifdef __has_include
 #if __has_include(<System/pthread_machdep.h>)
 
 #include <System/pthread_machdep.h>
 
 #endif
 #endif
 
 #ifndef PRIuS
 #define PRIuS "zu"
 #endif
 
 // Calling pthread_getspecific through a global function pointer is faster than a normal
 // call to the function on Mac OS X, and it's used in performance-critical code. So we
 // use a function pointer. But that's not necessarily faster on other platforms, and we had
 // problems with this technique on Windows, so we'll do this only on Mac OS X.
-#if OS(DARWIN)
+#if OS(MACOSX)
 #if !USE(PTHREAD_GETSPECIFIC_DIRECT)
 static void* (*pthread_getspecific_function_pointer)(pthread_key_t) = pthread_getspecific;
 #define pthread_getspecific(key) pthread_getspecific_function_pointer(key)
 #else
 #define pthread_getspecific(key) _pthread_getspecific_direct(key)
 #define pthread_setspecific(key, val) _pthread_setspecific_direct(key, (val))
 #endif
 #endif
 
 #define DEFINE_VARIABLE(type, name, value, meaning) \
@@ skipping 17 matching lines @@
 #define realloc fastRealloc
 
 #define MESSAGE LOG_ERROR
 #define CHECK_CONDITION ASSERT
 
 static const char kLLHardeningMask = 0;
 template <unsigned> struct EntropySource;
 template <> struct EntropySource<4> {
     static uint32_t value()
     {
-#if OS(DARWIN)
+#if OS(MACOSX)
         return arc4random();
 #else
         return static_cast<uint32_t>(static_cast<uintptr_t>(currentTime() * 10000) ^ reinterpret_cast<uintptr_t>(&kLLHardeningMask));
 #endif
     }
 };
 
 template <> struct EntropySource<8> {
     static uint64_t value()
     {
@@ skipping 554 matching lines @@
 
   void Delete(T* p) {
     HardenedSLL new_head = HardenedSLL::create(p);
     SLL_SetNext(new_head, free_list_, entropy_);
     free_list_ = new_head;
     inuse_--;
   }
 
   int inuse() const { return inuse_; }
 
-#if OS(DARWIN)
+#if OS(MACOSX)
   template <class Recorder>
   void recordAdministrativeRegions(Recorder& recorder, const RemoteMemoryReader& reader)
   {
       for (HardenedSLL adminAllocation = allocated_regions_; adminAllocation; adminAllocation.setValue(reader.nextEntryInHardenedLinkedList(reinterpret_cast<void**>(adminAllocation.value()), entropy_)))
           recorder.recordRegion(reinterpret_cast<vm_address_t>(adminAllocation.value()), kAllocIncrement);
   }
 #endif
 };
 
 // -------------------------------------------------------------------------
@@ skipping 313 matching lines @@
 // to be exactly 64 bytes.
 template <> class TCMalloc_Central_FreeListPadded_Template<0> : public TCMalloc_Central_FreeList {
 };
 
 typedef TCMalloc_Central_FreeListPadded_Template<sizeof(TCMalloc_Central_FreeList) % 64> TCMalloc_Central_FreeListPadded;
 
 #if COMPILER(CLANG) && defined(__has_warning)
 #pragma clang diagnostic pop
 #endif
 
-#if OS(DARWIN)
+#if OS(MACOSX)
 struct Span;
 class TCMalloc_PageHeap;
 class TCMalloc_ThreadCache;
 template <typename T> class PageHeapAllocator;
 
 class FastMallocZone {
 public:
     static void init();
 
     static kern_return_t enumerate(task_t, void*, unsigned typeMmask, vm_address_t zoneAddress, memory_reader_t, vm_range_recorder_t);
@@ skipping 297 matching lines @@
   // IncrementalScavenge(n) is called whenever n pages are freed.
   void IncrementalScavenge(Length n);
 #endif
 
   // Number of pages to deallocate before doing more scavenging
   int64_t scavenge_counter_;
 
   // Index of last free list we scavenged
   size_t scavenge_index_;
 
-#if OS(DARWIN)
+#if OS(MACOSX)
   friend class FastMallocZone;
 #endif
 
 #if USE_BACKGROUND_THREAD_TO_SCAVENGE_MEMORY
   void initializeScavenger();
   ALWAYS_INLINE void signalScavenger();
   void scavenge();
   ALWAYS_INLINE bool shouldScavenge() const;
 
 #if HAVE(DISPATCH_H) || OS(WINDOWS)
@@ skipping 1482 matching lines @@
     span_allocator.Init(entropy);
     span_allocator.New(); // Reduce cache conflicts
     span_allocator.New(); // Reduce cache conflicts
     stacktrace_allocator.Init(entropy);
     DLL_Init(&sampled_objects, entropy);
     for (size_t i = 0; i < kNumClasses; ++i) {
       central_cache[i].Init(i, entropy);
     }
     pageheap->init();
     phinited = 1;
-#if OS(DARWIN)
+#if OS(MACOSX)
     FastMallocZone::init();
 #endif
   }
 }
 
 inline TCMalloc_ThreadCache* TCMalloc_ThreadCache::NewHeap(ThreadIdentifier tid, uintptr_t entropy) {
   // Create the heap and add it to the linked list
   TCMalloc_ThreadCache *heap = threadheap_allocator.New();
   heap->Init(tid, entropy);
   heap->next_ = thread_heaps;
@@ skipping 449 matching lines @@
         const int tc_length = central_cache[cl].tc_length();
 
         statistics.freeListBytes += ByteSizeForClass(cl) * (length + tc_length);
     }
     for (TCMalloc_ThreadCache* threadCache = thread_heaps; threadCache ; threadCache = threadCache->next_)
         statistics.freeListBytes += threadCache->Size();
 
     return statistics;
 }
 
-#if OS(DARWIN)
+#if OS(MACOSX)
 
 template <typename T>
 T* RemoteMemoryReader::nextEntryInHardenedLinkedList(T** remoteAddress, uintptr_t entropy) const
 {
     T** localAddress = (*this)(remoteAddress);
     if (!localAddress)
         return 0;
     T* hardenedNext = *localAddress;
     if (!hardenedNext || hardenedNext == (void*)entropy)
         return 0;
@@ skipping 309 matching lines @@
     m_zone.introspect = &jscore_fastmalloc_introspection;
     malloc_zone_register(&m_zone);
 }
 
 
 void FastMallocZone::init()
 {
     static FastMallocZone zone(pageheap, &thread_heaps, static_cast<TCMalloc_Central_FreeListPadded*>(central_cache), &span_allocator, &threadheap_allocator);
 }
 
-#endif // OS(DARWIN)
+#endif // OS(MACOSX)
 
 } // namespace WTF
 
 #endif // FORCE_SYSTEM_MALLOC