webkitgtk-2.4.11webkitgtk-2.4.11

1 files changed, 60 insertions, 25 deletions

diff --git a/Source/JavaScriptCore/heap/CopiedBlock.h b/Source/JavaScriptCore/heap/CopiedBlock.h
index dd3b44532..6d59aa6bc 100644
--- a/Source/JavaScriptCore/heap/CopiedBlock.h
+++ b/Source/JavaScriptCore/heap/CopiedBlock.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011, 2015 Apple Inc. All rights reserved.
+ * Copyright (C) 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
@@ -26,24 +26,25 @@
 #ifndef CopiedBlock_h
 #define CopiedBlock_h
 
+#include "BlockAllocator.h"
 #include "CopyWorkList.h"
+#include "HeapBlock.h"
 #include "JSCJSValue.h"
 #include "Options.h"
-#include <wtf/DoublyLinkedList.h>
-#include <wtf/Lock.h>
+#include <wtf/Atomics.h>
+#include <wtf/OwnPtr.h>
+#include <wtf/PassOwnPtr.h>
 
 namespace JSC {
 
 class CopiedSpace;
 
-class CopiedBlock : public DoublyLinkedListNode<CopiedBlock> {
-    friend class WTF::DoublyLinkedListNode<CopiedBlock>;
+class CopiedBlock : public HeapBlock<CopiedBlock> {
     friend class CopiedSpace;
     friend class CopiedAllocator;
 public:
-    static CopiedBlock* create(Heap&, size_t = blockSize);
-    static CopiedBlock* createNoZeroFill(Heap&, size_t = blockSize);
-    static void destroy(Heap&, CopiedBlock*);
+    static CopiedBlock* create(DeadBlock*);
+    static CopiedBlock* createNoZeroFill(DeadBlock*);
 
     void pin();
     bool isPinned();
@@ -53,7 +54,8 @@ public:
     void didPromote();
 
     unsigned liveBytes();
-    void reportLiveBytes(LockHolder&, JSCell*, CopyToken, unsigned);
+    bool shouldReportLiveBytes(SpinLockHolder&, JSCell* owner);
+    void reportLiveBytes(SpinLockHolder&, JSCell*, CopyToken, unsigned);
     void reportLiveBytesDuringCopying(unsigned);
     void didSurviveGC();
     void didEvacuateBytes(unsigned);
@@ -83,21 +85,16 @@ public:
 
     bool hasWorkList();
     CopyWorkList& workList();
-    Lock& workListLock() { return m_workListLock; }
+    SpinLock& workListLock() { return m_workListLock; }
 
 private:
-    CopiedBlock(size_t);
+    CopiedBlock(Region*);
     void zeroFillWilderness(); // Can be called at any time to zero-fill to the end of the block.
 
     void checkConsistency();
 
-    CopiedBlock* m_prev;
-    CopiedBlock* m_next;
-
-    size_t m_capacity;
-
-    Lock m_workListLock;
-    std::unique_ptr<CopyWorkList> m_workList;
+    SpinLock m_workListLock;
+    OwnPtr<CopyWorkList> m_workList;
 
     size_t m_remaining;
     bool m_isPinned : 1;
@@ -108,17 +105,55 @@ private:
 #endif
 };
 
+inline CopiedBlock* CopiedBlock::createNoZeroFill(DeadBlock* block)
+{
+    Region* region = block->region();
+    return new(NotNull, block) CopiedBlock(region);
+}
+
+inline CopiedBlock* CopiedBlock::create(DeadBlock* block)
+{
+    CopiedBlock* newBlock = createNoZeroFill(block);
+    newBlock->zeroFillWilderness();
+    return newBlock;
+}
+
+inline void CopiedBlock::zeroFillWilderness()
+{
+#if USE(JSVALUE64)
+    memset(wilderness(), 0, wildernessSize());
+#else
+    JSValue emptyValue;
+    JSValue* limit = reinterpret_cast_ptr<JSValue*>(wildernessEnd());
+    for (JSValue* currentValue = reinterpret_cast_ptr<JSValue*>(wilderness()); currentValue < limit; currentValue++)
+        *currentValue = emptyValue;
+#endif
+}
+
+inline CopiedBlock::CopiedBlock(Region* region)
+    : HeapBlock<CopiedBlock>(region)
+    , m_remaining(payloadCapacity())
+    , m_isPinned(false)
+    , m_isOld(false)
+    , m_liveBytes(0)
+#ifndef NDEBUG
+    , m_liveObjects(0)
+#endif
+{
+    m_workListLock.Init();
+    ASSERT(is8ByteAligned(reinterpret_cast<void*>(m_remaining)));
+}
+
 inline void CopiedBlock::didSurviveGC()
 {
     checkConsistency();
-    ASSERT(isOld());
     m_liveBytes = 0;
 #ifndef NDEBUG
     m_liveObjects = 0;
 #endif
     m_isPinned = false;
     if (m_workList)
-        m_workList = nullptr;
+        m_workList.clear();
 }
 
 inline void CopiedBlock::didEvacuateBytes(unsigned bytes)
@@ -149,7 +184,7 @@ inline void CopiedBlock::pin()
 {
     m_isPinned = true;
     if (m_workList)
-        m_workList = nullptr;
+        m_workList.clear();
 }
 
 inline bool CopiedBlock::isPinned()
@@ -169,7 +204,7 @@ inline void CopiedBlock::didPromote()
 
 inline bool CopiedBlock::isOversize()
 {
-    return m_capacity != blockSize;
+    return region()->isCustomSize();
 }
 
 inline unsigned CopiedBlock::liveBytes()
@@ -180,12 +215,12 @@ inline unsigned CopiedBlock::liveBytes()
 
 inline char* CopiedBlock::payload()
 {
-    return reinterpret_cast<char*>(this) + WTF::roundUpToMultipleOf<sizeof(double)>(sizeof(CopiedBlock));
+    return reinterpret_cast<char*>(this) + ((sizeof(CopiedBlock) + 7) & ~7);
 }
 
 inline char* CopiedBlock::payloadEnd()
 {
-    return reinterpret_cast<char*>(this) + m_capacity;
+    return reinterpret_cast<char*>(this) + region()->blockSize();
 }
 
 inline size_t CopiedBlock::payloadCapacity()
@@ -230,7 +265,7 @@ inline size_t CopiedBlock::size()
 
 inline size_t CopiedBlock::capacity()
 {
-    return m_capacity;
+    return region()->blockSize();
 }
 
 inline bool CopiedBlock::hasWorkList()