Imported WebKit commit 42d95198c30c2d1a94a5081181aad0b2be7c316c (http://svn.webkit.org/repository/webkit/trunk@128206)

This includes the rewrite of the configure part of the build system which should fix the QtQuick2 detection
and allow for further simplifications in the future

1 files changed, 65 insertions, 274 deletions

diff --git a/Source/JavaScriptCore/heap/MarkStack.h b/Source/JavaScriptCore/heap/MarkStack.h
index 54ae1cb02..0245e4be5 100644
--- a/Source/JavaScriptCore/heap/MarkStack.h
+++ b/Source/JavaScriptCore/heap/MarkStack.h
@@ -26,25 +26,6 @@
 #ifndef MarkStack_h
 #define MarkStack_h
 
-#include "CopiedSpace.h"
-#include "HandleTypes.h"
-#include "JSValue.h"
-#include "Options.h"
-#include "Register.h"
-#include "UnconditionalFinalizer.h"
-#include "VTableSpectrum.h"
-#include "WeakReferenceHarvester.h"
-#include <wtf/DataLog.h>
-#include <wtf/Forward.h>
-#include <wtf/HashMap.h>
-#include <wtf/HashSet.h>
-#include <wtf/Noncopyable.h>
-#include <wtf/OSAllocator.h>
-#include <wtf/PageBlock.h>
-#include <wtf/TCSpinLock.h>
-#include <wtf/text/StringHash.h>
-#include <wtf/Vector.h>
-
 #if ENABLE(OBJECT_MARK_LOGGING)
 #define MARK_LOG_MESSAGE0(message) dataLog(message)
 #define MARK_LOG_MESSAGE1(message, arg1) dataLog(message, arg1)
@@ -69,276 +50,86 @@
 #define MARK_LOG_CHILD(visitor, child) do { } while (false)
 #endif
 
-namespace JSC {
-
-    class ConservativeRoots;
-    class JSGlobalData;
-    class MarkStack;
-    class GCThreadSharedData;
-    class ParallelModeEnabler;
-    class Register;
-    class SlotVisitor;
-    template<typename T> class WriteBarrierBase;
-    template<typename T> class JITWriteBarrier;
-    
-    struct MarkStackSegment {
-        MarkStackSegment* m_previous;
-#if !ASSERT_DISABLED
-        size_t m_top;
-#endif
-        
-        const JSCell** data()
-        {
-            return bitwise_cast<const JSCell**>(this + 1);
-        }
-        
-        static size_t capacityFromSize(size_t size)
-        {
-            return (size - sizeof(MarkStackSegment)) / sizeof(const JSCell*);
-        }
-        
-        static size_t sizeFromCapacity(size_t capacity)
-        {
-            return sizeof(MarkStackSegment) + capacity * sizeof(const JSCell*);
-        }
-    };
-
-    class MarkStackSegmentAllocator {
-    public:
-        MarkStackSegmentAllocator();
-        ~MarkStackSegmentAllocator();
-        
-        MarkStackSegment* allocate();
-        void release(MarkStackSegment*);
-        
-        void shrinkReserve();
-        
-    private:
-        SpinLock m_lock;
-        MarkStackSegment* m_nextFreeSegment;
-    };
-
-    class MarkStackArray {
-    public:
-        MarkStackArray(MarkStackSegmentAllocator&);
-        ~MarkStackArray();
-
-        void append(const JSCell*);
-
-        bool canRemoveLast();
-        const JSCell* removeLast();
-        bool refill();
-        
-        bool isEmpty();
-        
-        void donateSomeCellsTo(MarkStackArray& other);
-        
-        void stealSomeCellsFrom(MarkStackArray& other, size_t idleThreadCount);
-
-        size_t size();
-
-    private:
-        MarkStackSegment* m_topSegment;
-        
-        JS_EXPORT_PRIVATE void expand();
-        
-        MarkStackSegmentAllocator& m_allocator;
-
-        size_t m_segmentCapacity;
-        size_t m_top;
-        size_t m_numberOfPreviousSegments;
-        
-        size_t postIncTop()
-        {
-            size_t result = m_top++;
-            ASSERT(result == m_topSegment->m_top++);
-            return result;
-        }
-        
-        size_t preDecTop()
-        {
-            size_t result = --m_top;
-            ASSERT(result == --m_topSegment->m_top);
-            return result;
-        }
-        
-        void setTopForFullSegment()
-        {
-            ASSERT(m_topSegment->m_top == m_segmentCapacity);
-            m_top = m_segmentCapacity;
-        }
-        
-        void setTopForEmptySegment()
-        {
-            ASSERT(!m_topSegment->m_top);
-            m_top = 0;
-        }
-        
-        size_t top()
-        {
-            ASSERT(m_top == m_topSegment->m_top);
-            return m_top;
-        }
-        
-#if ASSERT_DISABLED
-        void validatePrevious() { }
-#else
-        void validatePrevious()
-        {
-            unsigned count = 0;
-            for (MarkStackSegment* current = m_topSegment->m_previous; current; current = current->m_previous)
-                count++;
-            ASSERT(count == m_numberOfPreviousSegments);
-        }
-#endif
-    };
-
-    class MarkStack {
-        WTF_MAKE_NONCOPYABLE(MarkStack);
-        friend class HeapRootVisitor; // Allowed to mark a JSValue* or JSCell** directly.
-
-    public:
-        MarkStack(GCThreadSharedData&);
-        ~MarkStack();
-
-        void append(ConservativeRoots&);
-        
-        template<typename T> void append(JITWriteBarrier<T>*);
-        template<typename T> void append(WriteBarrierBase<T>*);
-        void appendValues(WriteBarrierBase<Unknown>*, size_t count);
-        
-        template<typename T>
-        void appendUnbarrieredPointer(T**);
-        void appendUnbarrieredValue(JSValue*);
-        
-        void addOpaqueRoot(void*);
-        bool containsOpaqueRoot(void*);
-        int opaqueRootCount();
-
-        GCThreadSharedData& sharedData() { return m_shared; }
-        bool isEmpty() { return m_stack.isEmpty(); }
-
-        void setup();
-        void reset();
-
-        size_t visitCount() const { return m_visitCount; }
-
-#if ENABLE(SIMPLE_HEAP_PROFILING)
-        VTableSpectrum m_visitedTypeCounts;
-#endif
-
-        void addWeakReferenceHarvester(WeakReferenceHarvester*);
-        void addUnconditionalFinalizer(UnconditionalFinalizer*);
-
-#if ENABLE(OBJECT_MARK_LOGGING)
-        inline void resetChildCount() { m_logChildCount = 0; }
-        inline unsigned childCount() { return m_logChildCount; }
-        inline void incrementChildCount() { m_logChildCount++; }
-#endif
+#include <wtf/StdLibExtras.h>
+#include <wtf/TCSpinLock.h>
 
-    protected:
-        JS_EXPORT_PRIVATE static void validate(JSCell*);
+namespace JSC {
 
-        void append(JSValue*);
-        void append(JSValue*, size_t count);
-        void append(JSCell**);
+class JSCell;
 
-        void internalAppend(JSCell*);
-        void internalAppend(JSValue);
-        void internalAppend(JSValue*);
-        
-        JS_EXPORT_PRIVATE void mergeOpaqueRoots();
-        
-        void mergeOpaqueRootsIfNecessary()
-        {
-            if (m_opaqueRoots.isEmpty())
-                return;
-            mergeOpaqueRoots();
-        }
-        
-        void mergeOpaqueRootsIfProfitable()
-        {
-            if (static_cast<unsigned>(m_opaqueRoots.size()) < Options::opaqueRootMergeThreshold())
-                return;
-            mergeOpaqueRoots();
-        }
-        
-        MarkStackArray m_stack;
-        HashSet<void*> m_opaqueRoots; // Handle-owning data structures not visible to the garbage collector.
-        
+struct MarkStackSegment {
+    MarkStackSegment* m_previous;
 #if !ASSERT_DISABLED
-    public:
-        bool m_isCheckingForDefaultMarkViolation;
-        bool m_isDraining;
+    size_t m_top;
 #endif
-    protected:
-        friend class ParallelModeEnabler;
         
-        size_t m_visitCount;
-        bool m_isInParallelMode;
-        
-        GCThreadSharedData& m_shared;
-
-        bool m_shouldHashConst; // Local per-thread copy of shared flag for performance reasons
-        typedef HashMap<StringImpl*, JSValue> UniqueStringMap;
-        UniqueStringMap m_uniqueStrings;
-
-#if ENABLE(OBJECT_MARK_LOGGING)
-        unsigned m_logChildCount;
-#endif
-    };
-
-    inline void MarkStackArray::append(const JSCell* cell)
+    const JSCell** data()
     {
-        if (m_top == m_segmentCapacity)
-            expand();
-        m_topSegment->data()[postIncTop()] = cell;
+        return bitwise_cast<const JSCell**>(this + 1);
     }
-
-    inline bool MarkStackArray::canRemoveLast()
+    
+    static size_t capacityFromSize(size_t size)
     {
-        return !!m_top;
+        return (size - sizeof(MarkStackSegment)) / sizeof(const JSCell*);
     }
-
-    inline const JSCell* MarkStackArray::removeLast()
+    
+    static size_t sizeFromCapacity(size_t capacity)
     {
-        return m_topSegment->data()[preDecTop()];
+        return sizeof(MarkStackSegment) + capacity * sizeof(const JSCell*);
     }
+};
 
-    inline bool MarkStackArray::isEmpty()
-    {
-        if (m_top)
-            return false;
-        if (m_topSegment->m_previous) {
-            ASSERT(m_topSegment->m_previous->m_top == m_segmentCapacity);
-            return false;
-        }
-        return true;
-    }
+class MarkStackSegmentAllocator {
+public:
+    MarkStackSegmentAllocator();
+    ~MarkStackSegmentAllocator();
+    
+    MarkStackSegment* allocate();
+    void release(MarkStackSegment*);
+    
+    void shrinkReserve();
+    
+private:
+    SpinLock m_lock;
+    MarkStackSegment* m_nextFreeSegment;
+};
 
-    inline size_t MarkStackArray::size()
-    {
-        return m_top + m_segmentCapacity * m_numberOfPreviousSegments;
-    }
+class MarkStackArray {
+public:
+    MarkStackArray(MarkStackSegmentAllocator&);
+    ~MarkStackArray();
 
-    class ParallelModeEnabler {
-    public:
-        ParallelModeEnabler(MarkStack& stack)
-            : m_stack(stack)
-        {
-            ASSERT(!m_stack.m_isInParallelMode);
-            m_stack.m_isInParallelMode = true;
-        }
-        
-        ~ParallelModeEnabler()
-        {
-            ASSERT(m_stack.m_isInParallelMode);
-            m_stack.m_isInParallelMode = false;
-        }
-        
-    private:
-        MarkStack& m_stack;
-    };
+    void append(const JSCell*);
+
+    bool canRemoveLast();
+    const JSCell* removeLast();
+    bool refill();
+    
+    void donateSomeCellsTo(MarkStackArray& other);
+    void stealSomeCellsFrom(MarkStackArray& other, size_t idleThreadCount);
+
+    size_t size();
+    bool isEmpty();
+
+private:
+    JS_EXPORT_PRIVATE void expand();
+    
+    size_t postIncTop();
+    size_t preDecTop();
+    void setTopForFullSegment();
+    void setTopForEmptySegment();
+    size_t top();
+    
+    void validatePrevious();
+
+    MarkStackSegment* m_topSegment;
+    MarkStackSegmentAllocator& m_allocator;
+
+    size_t m_segmentCapacity;
+    size_t m_top;
+    size_t m_numberOfPreviousSegments;
+   
+};
 
 } // namespace JSC