Changeset 592 for trunk/src/3rdparty/javascriptcore

Timestamp:

Feb 23, 2010, 12:37:34 AM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

3rdparty: JavaScriptCore: Added support for the OS/2 platform (untested).

Location:

trunk/src/3rdparty/javascriptcore/JavaScriptCore

Files:

• interpreter/RegisterFile.cpp (modified) (2 diffs)
• interpreter/RegisterFile.h (modified) (7 diffs)
• jit/JITStubs.cpp (modified) (1 diff)
• runtime/Collector.cpp (modified) (16 diffs)
• runtime/Collector.h (modified) (5 diffs)
• runtime/MarkStackPosix.cpp (modified) (3 diffs)
• wtf/FastMalloc.cpp (modified) (26 diffs)
• wtf/Platform.h (modified) (4 diffs)
• wtf/TCSystemAlloc.cpp (modified) (23 diffs)

trunk/src/3rdparty/javascriptcore/JavaScriptCore/interpreter/RegisterFile.cpp

@@ -37 +37 @@
     munmap(reinterpret_cast<char*>(m_buffer), ((m_max - m_start) + m_maxGlobals) * sizeof(Register));
 #elif HAVE(VIRTUALALLOC)
+
+
+
 #if PLATFORM(WINCE)
     VirtualFree(m_buffer, DWORD(m_commitEnd) - DWORD(m_buffer), MEM_DECOMMIT);
 #endif
     VirtualFree(m_buffer, 0, MEM_RELEASE);
+
 #else
     fastFree(m_buffer);
@@ -51 +55 @@
     while (madvise(m_start, (m_max - m_start) * sizeof(Register), MADV_FREE) == -1 && errno == EAGAIN) { }
 #elif HAVE(VIRTUALALLOC)
+
+
+
+
     VirtualFree(m_start, (m_max - m_start) * sizeof(Register), MEM_DECOMMIT);
     m_commitEnd = m_start;
+
 #endif
     m_maxUsed = m_start;

trunk/src/3rdparty/javascriptcore/JavaScriptCore/interpreter/RegisterFile.h

@@ -42 +42 @@
 #endif
 
+
+
+
+
+
 namespace JSC {
 
@@ -130 +135 @@
         bool grow(Register* newEnd);
         void shrink(Register* newEnd);
-        
+
         void setNumGlobals(size_t numGlobals) { m_numGlobals = numGlobals; }
         int numGlobals() const { return m_numGlobals; }
@@ -136 +141 @@
 
         Register* lastGlobal() const { return m_start - m_numGlobals; }
-        
+
         void markGlobals(MarkStack& markStack, Heap* heap) { heap->markConservatively(markStack, lastGlobal(), m_start); }
         void markCallFrames(MarkStack& markStack, Heap* heap) { heap->markConservatively(markStack, m_start, m_end); }
@@ -185 +190 @@
         }
     #elif HAVE(VIRTUALALLOC)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
         m_buffer = static_cast<Register*>(VirtualAlloc(0, roundUpAllocationSize(bufferLength, commitSize), MEM_RESERVE, PAGE_READWRITE));
         if (!m_buffer) {
@@ -205 +224 @@
         }
         m_commitEnd = reinterpret_cast<Register*>(reinterpret_cast<char*>(m_buffer) + committedSize);
-    #else 
-        /* 
+#endif
+    #else
+        /*
          * If neither MMAP nor VIRTUALALLOC are available - use fastMalloc instead.
          *
@@ -240 +260 @@
 
 #if !HAVE(MMAP) && HAVE(VIRTUALALLOC)
+
+
+
+
+
+
+
+
+
+
+
         if (newEnd > m_commitEnd) {
             size_t size = roundUpAllocationSize(reinterpret_cast<char*>(newEnd) - reinterpret_cast<char*>(m_commitEnd), commitSize);
@@ -253 +284 @@
         }
 #endif
+
 
         if (newEnd > m_maxUsed)

trunk/src/3rdparty/javascriptcore/JavaScriptCore/jit/JITStubs.cpp

@@ -68 +68 @@
 namespace JSC {
 
-#if PLATFORM(DARWIN) || PLATFORM(WIN_OS)
+#if PLATFORM(DARWIN) || PLATFORM(WIN_OS)
 #define SYMBOL_STRING(name) "_" #name
 #else

trunk/src/3rdparty/javascriptcore/JavaScriptCore/runtime/Collector.cpp

@@ -128 +128 @@
 class Heap::Thread {
 public:
-    Thread(pthread_t pthread, const PlatformThread& platThread, void* base) 
+    Thread(pthread_t pthread, const PlatformThread& platThread, void* base)
         : posixThread(pthread)
         , platformThread(platThread)
@@ -172 +172 @@
     }
 #endif // PLATFORM(SYMBIAN)
-    
+
     memset(&primaryHeap, 0, sizeof(CollectorHeap));
     memset(&numberHeap, 0, sizeof(CollectorHeap));
@@ -239 +239 @@
 
     memset(reinterpret_cast<void*>(address), 0, BLOCK_SIZE);
+
+
+
 #elif PLATFORM(WINCE)
     void* address = VirtualAlloc(NULL, BLOCK_SIZE, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
@@ -312 +315 @@
 
     if (heap.numBlocks > MIN_ARRAY_SIZE && heap.usedBlocks < heap.numBlocks / LOW_WATER_FACTOR) {
-        heap.numBlocks = heap.numBlocks / GROWTH_FACTOR; 
+        heap.numBlocks = heap.numBlocks / GROWTH_FACTOR;
         heap.blocks = static_cast<CollectorBlock**>(fastRealloc(heap.blocks, heap.numBlocks * sizeof(CollectorBlock*)));
     }
@@ -325 +328 @@
 #elif PLATFORM(SYMBIAN)
     userChunk->Free(reinterpret_cast<TAny*>(block));
+
+
 #elif PLATFORM(WINCE)
     VirtualFree(block, 0, MEM_RELEASE);
@@ -361 +366 @@
     // if a large value survives one garbage collection, there is not much point to
     // collecting more frequently as long as it stays alive.
-    // NOTE: we target the primaryHeap unconditionally as JSNumber doesn't modify cost 
+    // NOTE: we target the primaryHeap unconditionally as JSNumber doesn't modify cost
 
     primaryHeap.extraCost += cost;
@@ -629 +634 @@
         );
     return static_cast<void*>(pTib->StackBase);
+
+
+
+
 #elif PLATFORM(QNX)
     return currentThreadStackBaseQNX();
@@ -819 +828 @@
                 }
             }
-          
+
             // Mark the primary heap
             for (size_t block = 0; block < usedPrimaryBlocks; block++) {
@@ -924 +933 @@
     unsigned user_count = x86_THREAD_STATE64_COUNT;
     thread_state_flavor_t flavor = x86_THREAD_STATE64;
-#elif PLATFORM(PPC) 
+#elif PLATFORM(PPC)
     unsigned user_count = PPC_THREAD_STATE_COUNT;
     thread_state_flavor_t flavor = PPC_THREAD_STATE;
@@ -939 +948 @@
     kern_return_t result = thread_get_state(platformThread, flavor, (thread_state_t)&regs, &user_count);
     if (result != KERN_SUCCESS) {
-        WTFReportFatalError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, 
+        WTFReportFatalError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION,
                             "JavaScript garbage collection failed because thread_get_state returned an error (%d). This is probably the result of running inside Rosetta, which is not supported.", result);
         CRASH();
@@ -1024 +1033 @@
 
 #ifndef NDEBUG
-        // Forbid malloc during the mark phase. Marking a thread suspends it, so 
-        // a malloc inside markChildren() would risk a deadlock with a thread that had been 
+        // Forbid malloc during the mark phase. Marking a thread suspends it, so
+        // a malloc inside markChildren() would risk a deadlock with a thread that had been
         // suspended while holding the malloc lock.
         fastMallocForbid();
@@ -1108 +1117 @@
     // SWEEP: delete everything with a zero refcount (garbage) and unmark everything else
     CollectorHeap& heap = heapType == PrimaryHeap ? primaryHeap : numberHeap;
-    
+
     size_t emptyBlocks = 0;
     size_t numLiveObjects = heap.numLiveObjects;
-    
+
     for (size_t block = 0; block < heap.usedBlocks; block++) {
         Block* curBlock = reinterpret_cast<Block*>(heap.blocks[block]);
-        
+
         size_t usedCells = curBlock->usedCells;
         Cell* freeList = curBlock->freeList;
-        
+
         if (usedCells == HeapConstants<heapType>::cellsPerBlock) {
             // special case with a block where all cells are used -- testing indicates this happens often
@@ -1123 +1132 @@
                 if (!curBlock->marked.get(i >> HeapConstants<heapType>::bitmapShift)) {
                     Cell* cell = curBlock->cells + i;
-                    
+
                     if (heapType != NumberHeap) {
                         JSCell* imp = reinterpret_cast<JSCell*>(cell);
                         // special case for allocated but uninitialized object
-                        // (We don't need this check earlier because nothing prior this point 
+                        // (We don't need this check earlier because nothing prior this point
                         // assumes the object has a valid vptr.)
                         if (cell->u.freeCell.zeroIfFree == 0)
                             continue;
-                        
+
                         imp->~JSCell();
                     }
-                    
+
                     --usedCells;
                     --numLiveObjects;
-                    
+
                     // put cell on the free list
                     cell->u.freeCell.zeroIfFree = 0;
@@ -1158 +1167 @@
                         --usedCells;
                         --numLiveObjects;
-                        
+
                         // put cell on the free list
                         cell->u.freeCell.zeroIfFree = 0;
-                        cell->u.freeCell.next = freeList - (cell + 1); 
+                        cell->u.freeCell.next = freeList - (cell + 1);
                         freeList = cell;
                     }
@@ -1167 +1176 @@
             }
         }
-        
+
         curBlock->usedCells = static_cast<uint32_t>(usedCells);
         curBlock->freeList = freeList;
         curBlock->marked.clearAll();
-        
+
         if (!usedCells)
             ++emptyBlocks;
     }
-    
+
     if (heap.numLiveObjects != numLiveObjects)
         heap.firstBlockWithPossibleSpace = 0;
-    
+
     heap.numLiveObjects = numLiveObjects;
     heap.numLiveObjectsAtLastCollect = numLiveObjects;
     heap.extraCost = 0;
-    
+
     if (!emptyBlocks)
         return numLiveObjects;
@@ -1254 +1263 @@
 }
 
-size_t Heap::objectCount() 
-{
-    return primaryHeap.numLiveObjects + numberHeap.numLiveObjects - m_globalData->smallStrings.count(); 
-}
-
-template <HeapType heapType> 
+size_t Heap::objectCount()
+{
+    return primaryHeap.numLiveObjects + numberHeap.numLiveObjects - m_globalData->smallStrings.count();
+}
+
+template <HeapType heapType>
 static void addToStatistics(Heap::Statistics& statistics, const CollectorHeap& heap)
 {

trunk/src/3rdparty/javascriptcore/JavaScriptCore/runtime/Collector.h

@@ -120 +120 @@
         JSGlobalData* globalData() const { return m_globalData; }
         static bool isNumber(JSCell*);
-        
+
         // Iterators for the object heap.
         iterator primaryHeapBegin();
@@ -182 +182 @@
     template<> struct CellSize<sizeof(uint64_t)> { static const size_t m_value = 64; };
 
-#if PLATFORM(WINCE) || PLATFORM(SYMBIAN)
+#if PLATFORM(WINCE) || PLATFORM(SYMBIAN)
     const size_t BLOCK_SIZE = 64 * 1024; // 64k
 #else
@@ -201 +201 @@
     const size_t BITMAP_SIZE = (CELLS_PER_BLOCK + 7) / 8;
     const size_t BITMAP_WORDS = (BITMAP_SIZE + 3) / sizeof(uint32_t);
-  
+
     struct CollectorBitmap {
         uint32_t bits[BITMAP_WORDS];
-        bool get(size_t n) const { return !!(bits[n >> 5] & (1 << (n & 0x1F))); } 
-        void set(size_t n) { bits[n >> 5] |= (1 << (n & 0x1F)); } 
-        void clear(size_t n) { bits[n >> 5] &= ~(1 << (n & 0x1F)); } 
+        bool get(size_t n) const { return !!(bits[n >> 5] & (1 << (n & 0x1F))); }
+        void set(size_t n) { bits[n >> 5] |= (1 << (n & 0x1F)); }
+        void clear(size_t n) { bits[n >> 5] &= ~(1 << (n & 0x1F)); }
         void clearAll() { memset(bits, 0, sizeof(bits)); }
     };
-  
+
     struct CollectorCell {
         union {
@@ -249 +249 @@
         HeapType type;
     };
-    
+
     template <HeapType heapType> struct HeapConstants;
 
@@ -295 +295 @@
     inline void Heap::reportExtraMemoryCost(size_t cost)
     {
-        if (cost > minExtraCostSize) 
-            recordExtraCost(cost / (CELL_SIZE * 2)); 
+        if (cost > minExtraCostSize)
+            recordExtraCost(cost / (CELL_SIZE * 2));
     }
 

trunk/src/3rdparty/javascriptcore/JavaScriptCore/runtime/MarkStackPosix.cpp

@@ -21 +21 @@
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
@@ -55 +55 @@
 void* MarkStack::allocateStack(size_t size)
 {
-#if defined (__SYMBIAN32__)
+#if defined (__SYMBIAN32__)
     return fastMalloc(size);
 #else
@@ -63 +63 @@
 void MarkStack::releaseStack(void* addr, size_t size)
 {
-#if defined (__SYMBIAN32__)
+#if defined (__SYMBIAN32__)
     fastFree(addr);
 #else

trunk/src/3rdparty/javascriptcore/JavaScriptCore/wtf/FastMalloc.cpp

@@ -2 +2 @@
 // All rights reserved.
 // Copyright (C) 2005, 2006, 2007, 2008, 2009 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.
@@ -16 +16 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
-// 
+//
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
@@ -177 +177 @@
 #endif
 
-void* fastZeroedMalloc(size_t n) 
+void* fastZeroedMalloc(size_t n)
 {
     void* result = fastMalloc(n);
@@ -183 +183 @@
     return result;
 }
-    
-TryMallocReturnValue tryFastZeroedMalloc(size_t n) 
+
+TryMallocReturnValue tryFastZeroedMalloc(size_t n)
 {
     void* result;
@@ -198 +198 @@
 
 #include <stdlib.h>
-#if !PLATFORM(WIN_OS)
+#if PLATFORM(WIN_OS)
+    #include "windows.h"
+#elif PLATFORM(OS2)
+    #define INCL_BASE
+    #include <os2.h>
+#else
     #include <pthread.h>
-#else
-    #include "windows.h"
 #endif
 
 namespace WTF {
 
-TryMallocReturnValue tryFastMalloc(size_t n) 
+TryMallocReturnValue tryFastMalloc(size_t n)
 {
     ASSERT(!isForbidden());
@@ -227 +230 @@
 }
 
-void* fastMalloc(size_t n) 
+void* fastMalloc(size_t n)
 {
     ASSERT(!isForbidden());
@@ -346 +349 @@
 
 void releaseFastMallocFreeMemory() { }
-    
+
 FastMallocStatistics fastMallocStatistics()
 {
@@ -422 +425 @@
   }                                                                           \
   using FLAG__namespace_do_not_use_directly_use_DECLARE_##type##_instead::FLAGS_##name
-  
+
 #define DEFINE_int64(name, value, meaning) \
   DEFINE_VARIABLE(int64_t, name, value, meaning)
-  
+
 #define DEFINE_double(name, value, meaning) \
   DEFINE_VARIABLE(double, name, value, meaning)
@@ -1179 +1182 @@
 #if defined(WTF_CHANGES)
 #if PLATFORM(X86_64)
-// On all known X86-64 platforms, the upper 16 bits are always unused and therefore 
+// On all known X86-64 platforms, the upper 16 bits are always unused and therefore
 // can be excluded from the PageMap key.
 // See http://en.wikipedia.org/wiki/X86-64#Virtual_address_space_details
@@ -1276 +1279 @@
       return GetDescriptor(p);
   }
-    
+
   size_t ReturnedBytes() const;
 #endif
@@ -1361 +1364 @@
     }
   }
-  
+
     // Allocate a large span of length == n.  If successful, returns a
   // span of exactly the specified length.  Else, returns NULL.
@@ -1377 +1380 @@
   // Index of last free list we scavenged
   size_t scavenge_index_;
-  
+
 #if defined(WTF_CHANGES) && PLATFORM(DARWIN)
   friend class FastMallocZone;
@@ -1443 +1446 @@
 }
 
-void TCMalloc_PageHeap::scavenge() 
+void TCMalloc_PageHeap::scavenge()
 {
     // If we have to commit memory in the last 5 seconds, it means we don't have enough free committed pages
@@ -1456 +1459 @@
         if (!DLL_IsEmpty(&slist->normal)) {
             // Release the last span on the normal portion of this list
-            Span* s = slist->normal.prev; 
+            Span* s = slist->normal.prev;
             // Only decommit up to a fraction of the free committed pages if pages_allocated_since_last_scavenge_ > 0.
             if ((pagesDecommitted + s->length) * kMaxScavengeAmountFactor > free_committed_pages_)
@@ -1478 +1481 @@
 }
 
-inline bool TCMalloc_PageHeap::shouldContinueScavenging() const 
-{
-    return free_committed_pages_ > kMinimumFreeCommittedPageCount; 
+inline bool TCMalloc_PageHeap::shouldContinueScavenging() const
+{
+    return free_committed_pages_ > kMinimumFreeCommittedPageCount;
 }
 
@@ -1800 +1803 @@
   }
 }
-    
+
 #ifdef WTF_CHANGES
 size_t TCMalloc_PageHeap::ReturnedBytes() const {
@@ -1809 +1812 @@
         result += r_pages << kPageShift;
     }
-    
+
     for (Span* s = large_.returned.next; s != &large_.returned; s = s->next)
         result += s->length << kPageShift;
@@ -2289 +2292 @@
     ::Sleep(seconds * 1000);
 }
+
+
+
+
+
 #endif
 
@@ -2880 +2888 @@
 #endif
   tsd_inited = true;
-    
+
 #if !COMPILER(MSVC)
   // We may have used a fake pthread_t for the main thread.  Fix it.
@@ -3584 +3592 @@
 
 #ifndef WTF_CHANGES
-extern "C" 
+extern "C"
 #else
 #define do_malloc do_malloc<crashOnFailure>
@@ -3626 +3634 @@
 
 #ifndef WTF_CHANGES
-extern "C" 
+extern "C"
 #endif
 void free(void* ptr) {
@@ -3647 +3655 @@
 
 #ifndef WTF_CHANGES
-extern "C" 
+extern "C"
 #else
 template <bool crashOnFailure>
@@ -3667 +3675 @@
 void* calloc(size_t n, size_t elem_size) {
   size_t totalBytes = n * elem_size;
-    
+
   // Protect against overflow
   if (n > 1 && elem_size && (totalBytes / elem_size) != n)
@@ -3700 +3708 @@
 #ifndef WTF_CHANGES
 #ifndef WTF_CHANGES
-extern "C" 
+extern "C"
 #endif
 void cfree(void* ptr) {
@@ -3711 +3719 @@
 
 #ifndef WTF_CHANGES
-extern "C" 
+extern "C"
 #else
 template <bool crashOnFailure>
@@ -4353 +4361 @@
     pageheap->ReleaseFreePages();
 }
-    
+
 FastMallocStatistics fastMallocStatistics()
 {

trunk/src/3rdparty/javascriptcore/JavaScriptCore/wtf/Platform.h

@@ -58 +58 @@
 #endif
 
+
+
+
+
+
+
+
 /* PLATFORM(WINCE) */
 /* Operating system level dependencies for Windows CE that should be used */
@@ -224 +231 @@
 /* Makes PLATFORM(WIN) default to PLATFORM(CAIRO) */
 /* FIXME: This should be changed from a blacklist to a whitelist */
-#if !PLATFORM(MAC) && !PLATFORM(QT) && !PLATFORM(WX) && !PLATFORM(CHROMIUM) && !PLATFORM(WINCE) && !PLATFORM(HAIKU)
+#if !PLATFORM(MAC) && !PLATFORM(QT) && !PLATFORM(WX) && !PLATFORM(CHROMIUM) && !PLATFORM(WINCE) && !PLATFORM(HAIKU)
 #define WTF_PLATFORM_CAIRO 1
 #endif
@@ -562 +569 @@
 #if !PLATFORM(WIN_OS) && !PLATFORM(SOLARIS) && !PLATFORM(QNX) \
     && !PLATFORM(SYMBIAN) && !PLATFORM(HAIKU) && !COMPILER(RVCT) && !PLATFORM(AIX) \
-    && !PLATFORM(HPUX)
+    && !PLATFORM(HPUX)
 #define HAVE_TM_GMTOFF 1
 #define HAVE_TM_ZONE 1
 #define HAVE_TIMEGM 1
-#endif     
+#endif
 
 #if PLATFORM(DARWIN)
@@ -599 +606 @@
 #endif
 #define HAVE_VIRTUALALLOC 1
+
+
+
+
+
+
+
+
+
 
 #elif PLATFORM(SYMBIAN)

trunk/src/3rdparty/javascriptcore/JavaScriptCore/wtf/TCSystemAlloc.cpp

@@ -1 +1 @@
 // Copyright (c) 2005, 2007, Google Inc.
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
-// 
+//
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ -15 +15 @@
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
-// 
+//
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
@@ -50 +50 @@
 #if PLATFORM(WIN_OS)
 #include "windows.h"
+
+
+
 #else
 #include <errno.h>
@@ -90 +93 @@
 #if HAVE(MMAP)
 static bool use_mmap = true;
-#endif 
+#endif
 
 #if HAVE(VIRTUALALLOC)
@@ -118 +121 @@
 static void* TrySbrk(size_t size, size_t *actual_size, size_t alignment) {
   size = ((size + alignment - 1) / alignment) * alignment;
-  
+
   // could theoretically return the "extra" bytes here, but this
   // is simple and correct.
-  if (actual_size) 
+  if (actual_size)
     *actual_size = size;
-    
+
   void* result = sbrk(size);
   if (result == reinterpret_cast<void*>(-1)) {
@@ -165 +168 @@
   if (alignment < pagesize) alignment = pagesize;
   size = ((size + alignment - 1) / alignment) * alignment;
-  
+
   // could theoretically return the "extra" bytes here, but this
   // is simple and correct.
-  if (actual_size) 
+  if (actual_size)
     *actual_size = size;
-    
+
   // Ask for extra memory if alignment > pagesize
   size_t extra = 0;
@@ -211 +214 @@
   // Enforce page alignment
   if (pagesize == 0) {
+
+
+
     SYSTEM_INFO system_info;
     GetSystemInfo(&system_info);
     pagesize = system_info.dwPageSize;
+
   }
 
@@ -221 +228 @@
   // could theoretically return the "extra" bytes here, but this
   // is simple and correct.
-  if (actual_size) 
+  if (actual_size)
     *actual_size = size;
-    
+
   // Ask for extra memory if alignment > pagesize
   size_t extra = 0;
@@ -229 +236 @@
     extra = alignment - pagesize;
   }
+
+
+
+
   void* result = VirtualAlloc(NULL, size + extra,
-                              MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN, 
+                              MEM_RESERVE | MEM_COMMIT | MEM_TOP_DOWN,
                               PAGE_READWRITE);
+
 
   if (result == NULL) {
@@ -248 +260 @@
   // is decommit, since Windows only lets you free the whole allocation.
   if (adjust > 0) {
+
+
+
     VirtualFree(reinterpret_cast<void*>(ptr), adjust, MEM_DECOMMIT);
+
   }
   if (adjust < extra) {
+
+
+
     VirtualFree(reinterpret_cast<void*>(ptr + adjust + size), extra-adjust, MEM_DECOMMIT);
+
   }
 
@@ -258 +278 @@
 }
 
-#endif /* HAVE(MMAP) */
+#endif /* HAVE() */
 
 #ifndef WTF_CHANGES
@@ -266 +286 @@
   static off_t physmem_limit; // maximum physical address allowed
   static int physmem_fd;      // file descriptor for /dev/mem
-  
+
   // Check if we should use /dev/mem allocation.  Note that it may take
   // a while to get this flag initialized, so meanwhile we fall back to
@@ -276 +296 @@
     return NULL;
   }
-  
+
   if (!initialized) {
     physmem_fd = open("/dev/mem", O_RDWR);
@@ -287 +307 @@
     initialized = true;
   }
-  
+
   // Enforce page alignment
   if (pagesize == 0) pagesize = getpagesize();
   if (alignment < pagesize) alignment = pagesize;
   size = ((size + alignment - 1) / alignment) * alignment;
-    
+
   // could theoretically return the "extra" bytes here, but this
   // is simple and correct.
   if (actual_size)
     *actual_size = size;
-    
+
   // Ask for extra memory if alignment > pagesize
   size_t extra = 0;
@@ -303 +323 @@
     extra = alignment - pagesize;
   }
-  
+
   // check to see if we have any memory left
   if (physmem_limit != 0 && physmem_base + size + extra > physmem_limit) {
@@ -316 +336 @@
   }
   uintptr_t ptr = reinterpret_cast<uintptr_t>(result);
-  
+
   // Adjust the return memory so it is aligned
   size_t adjust = 0;
@@ -322 +342 @@
     adjust = alignment - (ptr & (alignment - 1));
   }
-  
+
   // Return the unused virtual memory to the system
   if (adjust > 0) {
@@ -330 +350 @@
     munmap(reinterpret_cast<char*>(ptr + adjust + size), extra - adjust);
   }
-  
+
   ptr += adjust;
   physmem_base += adjust + size;
-  
+
   return reinterpret_cast<void*>(ptr);
 }
@@ -341 +361 @@
   // Discard requests that overflow
   if (size + alignment < size) return NULL;
-    
+
   SpinLockHolder lock_holder(&spinlock);
 
@@ -357 +377 @@
     }
 #endif
-    
+
 #if HAVE(SBRK)
     if (use_sbrk && !sbrk_failure) {
@@ -365 +385 @@
 #endif
 
-#if HAVE(MMAP)    
+#if HAVE(MMAP)
     if (use_mmap && !mmap_failure) {
       void* result = TryMmap(size, actual_size, alignment);
@@ -452 +472 @@
 void TCMalloc_SystemRelease(void* start, size_t length)
 {
+
+
+
+
     if (VirtualFree(start, length, MEM_DECOMMIT))
         return;
+
 
     // The decommit may fail if the memory region consists of allocations
@@ -492 +517 @@
 void TCMalloc_SystemCommit(void* start, size_t length)
 {
+
+
+
+
     if (VirtualAlloc(start, length, MEM_COMMIT, PAGE_READWRITE) == start)
         return;
+
 
     // The commit may fail if the memory region consists of allocations