Separate the stack used for GC from the regular JS stack

This is required to be able to implement concurrent or
incremental garbage collection.

Change-Id: Ib3c5eee3779ca2ee08a57cd3961dbcb0537bbb54
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

15 files changed, 67 insertions, 66 deletions

diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp
index b9408be218..dd8cb177b4 100644
--- a/src/qml/jsruntime/qv4engine.cpp
+++ b/src/qml/jsruntime/qv4engine.cpp
@@ -136,6 +136,7 @@ ExecutionEngine::ExecutionEngine(EvalISelFactory *factory)
     , currentContext(0)
     , bumperPointerAllocator(new WTF::BumpPointerAllocator)
     , jsStack(new WTF::PageAllocation)
+    , gcStack(new WTF::PageAllocation)
     , globalCode(0)
     , v8Engine(0)
     , argumentsAccessors(0)
@@ -188,18 +189,22 @@ ExecutionEngine::ExecutionEngine(EvalISelFactory *factory)
     iselFactory.reset(factory);
 
     // reserve space for the JS stack
-    // we allow it to grow to 2 times JSStackLimit, as we can overshoot due to garbage collection
-    // and ScopedValues allocated outside of JIT'ed methods.
-    *jsStack = WTF::PageAllocation::allocate(2 * JSStackLimit, WTF::OSAllocator::JSVMStackPages,
+    // we allow it to grow to a bit more than JSStackLimit, as we can overshoot due to ScopedValues
+    // allocated outside of JIT'ed methods.
+    *jsStack = WTF::PageAllocation::allocate(JSStackLimit + 256*1024, WTF::OSAllocator::JSVMStackPages,
                                              /* writable */ true, /* executable */ false,
                                              /* includesGuardPages */ true);
     jsStackBase = (Value *)jsStack->base();
 #ifdef V4_USE_VALGRIND
-    VALGRIND_MAKE_MEM_UNDEFINED(jsStackBase, 2*JSStackLimit);
+    VALGRIND_MAKE_MEM_UNDEFINED(jsStackBase, JSStackLimit + 256*1024);
 #endif
 
     jsStackTop = jsStackBase;
 
+    *gcStack = WTF::PageAllocation::allocate(GCStackLimit, WTF::OSAllocator::JSVMStackPages,
+                                             /* writable */ true, /* executable */ false,
+                                             /* includesGuardPages */ true);
+
     exceptionValue = jsAlloca(1);
     globalObject = static_cast<Object *>(jsAlloca(1));
     jsObjects = jsAlloca(NJSObjects);
@@ -493,6 +498,8 @@ ExecutionEngine::~ExecutionEngine()
     delete executableAllocator;
     jsStack->deallocate();
     delete jsStack;
+    gcStack->deallocate();
+    delete gcStack;
     delete [] argumentsAccessors;
 }
 
@@ -930,23 +937,23 @@ void ExecutionEngine::requireArgumentsAccessors(int n)
     }
 }
 
-void ExecutionEngine::markObjects()
+void ExecutionEngine::markObjects(MarkStack *markStack)
 {
-    identifierTable->mark(this);
+    identifierTable->mark(markStack);
 
     for (int i = 0; i < nArgumentsAccessors; ++i) {
         const Property &pd = argumentsAccessors[i];
         if (Heap::FunctionObject *getter = pd.getter())
-            getter->mark(this);
+            getter->mark(markStack);
         if (Heap::FunctionObject *setter = pd.setter())
-            setter->mark(this);
+            setter->mark(markStack);
     }
 
-    classPool->markObjects(this);
+    classPool->markObjects(markStack);
 
     for (QSet<CompiledData::CompilationUnit*>::ConstIterator it = compilationUnits.constBegin(), end = compilationUnits.constEnd();
          it != end; ++it)
-        (*it)->markObjects(this);
+        (*it)->markObjects(markStack);
 }
 
 ReturnedValue ExecutionEngine::throwError(const Value &value)
diff --git a/src/qml/jsruntime/qv4engine_p.h b/src/qml/jsruntime/qv4engine_p.h
index fdfdeada9a..bace8b700b 100644
--- a/src/qml/jsruntime/qv4engine_p.h
+++ b/src/qml/jsruntime/qv4engine_p.h
@@ -108,18 +108,14 @@ public:
 
     WTF::BumpPointerAllocator *bumperPointerAllocator; // Used by Yarr Regex engine.
 
-    enum { JSStackLimit = 4*1024*1024 };
+    enum {
+        JSStackLimit = 4*1024*1024,
+        GCStackLimit = 2*1024*1024
+    };
     WTF::PageAllocation *jsStack;
     Value *jsStackBase;
 
-    void pushForGC(Heap::Base *m) {
-        *jsStackTop = m;
-        ++jsStackTop;
-    }
-    Heap::Base *popForGC() {
-        --jsStackTop;
-        return jsStackTop->m();
-    }
+    WTF::PageAllocation *gcStack;
 
     QML_NEARLY_ALWAYS_INLINE Value *jsAlloca(int nValues) {
         Value *ptr = jsStackTop;
@@ -446,7 +442,7 @@ public:
 
     void requireArgumentsAccessors(int n);
 
-    void markObjects();
+    void markObjects(MarkStack *markStack);
 
     void initRootContext();
 
@@ -541,7 +537,7 @@ inline ExecutionContext *ExecutionEngine::parentContext(ExecutionContext *contex
 }
 
 inline
-void Heap::Base::mark(QV4::ExecutionEngine *engine)
+void Heap::Base::mark(QV4::MarkStack *markStack)
 {
     Q_ASSERT(inUse());
     const HeapItem *h = reinterpret_cast<const HeapItem *>(this);
@@ -552,15 +548,15 @@ void Heap::Base::mark(QV4::ExecutionEngine *engine)
     quintptr bit = Chunk::bitForIndex(index);
     if (!(*bitmap & bit)) {
         *bitmap |= bit;
-        engine->pushForGC(this);
+        markStack->push(this);
     }
 }
 
-inline void Value::mark(ExecutionEngine *e)
+inline void Value::mark(MarkStack *markStack)
 {
     Heap::Base *o = heapObject();
     if (o)
-        o->mark(e);
+        o->mark(markStack);
 }
 
 #define CHECK_STACK_LIMITS(v4, scope) if ((v4)->checkStackLimits(scope)) return; \
diff --git a/src/qml/jsruntime/qv4identifiertable_p.h b/src/qml/jsruntime/qv4identifiertable_p.h
index 89af5db731..b0b08f1e54 100644
--- a/src/qml/jsruntime/qv4identifiertable_p.h
+++ b/src/qml/jsruntime/qv4identifiertable_p.h
@@ -93,14 +93,14 @@ public:
 
     Heap::String *stringFromIdentifier(Identifier *i);
 
-    void mark(ExecutionEngine *e) {
+    void mark(MarkStack *markStack) {
         for (int i = 0; i < alloc; ++i) {
             Heap::String *entry = entries[i];
             if (!entry || entry->isMarked())
                 continue;
             entry->setMarkBit();
             Q_ASSERT(entry->vtable()->markObjects);
-            entry->vtable()->markObjects(entry, e);
+            entry->vtable()->markObjects(entry, markStack);
         }
     }
 };
diff --git a/src/qml/jsruntime/qv4internalclass.cpp b/src/qml/jsruntime/qv4internalclass.cpp
index 9b18a5566e..3d9a672f2f 100644
--- a/src/qml/jsruntime/qv4internalclass.cpp
+++ b/src/qml/jsruntime/qv4internalclass.cpp
@@ -388,9 +388,9 @@ void InternalClass::destroy()
     }
 }
 
-void InternalClassPool::markObjects(ExecutionEngine *engine)
+void InternalClassPool::markObjects(MarkStack *markStack)
 {
-    Q_UNUSED(engine);
+    Q_UNUSED(markStack);
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/jsruntime/qv4internalclass_p.h b/src/qml/jsruntime/qv4internalclass_p.h
index 1d8ef4b0fb..a29ce5b5ff 100644
--- a/src/qml/jsruntime/qv4internalclass_p.h
+++ b/src/qml/jsruntime/qv4internalclass_p.h
@@ -291,7 +291,7 @@ inline uint InternalClass::find(const String *string)
 
 struct InternalClassPool : public QQmlJS::MemoryPool
 {
-    void markObjects(ExecutionEngine *engine);
+    void markObjects(MarkStack *markStack);
 };
 
 }
diff --git a/src/qml/jsruntime/qv4managed_p.h b/src/qml/jsruntime/qv4managed_p.h
index 3dc54b13da..9ecc4bd087 100644
--- a/src/qml/jsruntime/qv4managed_p.h
+++ b/src/qml/jsruntime/qv4managed_p.h
@@ -209,7 +209,7 @@ public:
     bool markBit() const { return d()->isMarked(); }
 
     static void destroy(Heap::Base *) {}
-    static void markObjects(Heap::Base *, ExecutionEngine *) {}
+    static void markObjects(Heap::Base *, MarkStack *) {}
 
     Q_ALWAYS_INLINE Heap::Base *heapObject() const {
         return m();
diff --git a/src/qml/jsruntime/qv4objectiterator.cpp b/src/qml/jsruntime/qv4objectiterator.cpp
index 59115dfe21..3427ee89fe 100644
--- a/src/qml/jsruntime/qv4objectiterator.cpp
+++ b/src/qml/jsruntime/qv4objectiterator.cpp
@@ -177,10 +177,10 @@ ReturnedValue ObjectIterator::nextPropertyNameAsString()
 
 DEFINE_OBJECT_VTABLE(ForEachIteratorObject);
 
-void ForEachIteratorObject::markObjects(Heap::Base *that, ExecutionEngine *e)
+void ForEachIteratorObject::markObjects(Heap::Base *that, MarkStack *markStack)
 {
     ForEachIteratorObject::Data *o = static_cast<ForEachIteratorObject::Data *>(that);
-    o->workArea[0].mark(e);
-    o->workArea[1].mark(e);
-    Object::markObjects(that, e);
+    o->workArea[0].mark(markStack);
+    o->workArea[1].mark(markStack);
+    Object::markObjects(that, markStack);
 }
diff --git a/src/qml/jsruntime/qv4objectiterator_p.h b/src/qml/jsruntime/qv4objectiterator_p.h
index 98e94a95ea..6168d59914 100644
--- a/src/qml/jsruntime/qv4objectiterator_p.h
+++ b/src/qml/jsruntime/qv4objectiterator_p.h
@@ -129,7 +129,7 @@ struct ForEachIteratorObject: Object {
     ReturnedValue nextPropertyName() { return d()->it().nextPropertyNameAsString(); }
 
 protected:
-    static void markObjects(Heap::Base *that, ExecutionEngine *e);
+    static void markObjects(Heap::Base *that, MarkStack *markStack);
 };
 
 inline
diff --git a/src/qml/jsruntime/qv4persistent.cpp b/src/qml/jsruntime/qv4persistent.cpp
index de82bf835f..0b31c971f9 100644
--- a/src/qml/jsruntime/qv4persistent.cpp
+++ b/src/qml/jsruntime/qv4persistent.cpp
@@ -215,17 +215,15 @@ void PersistentValueStorage::free(Value *v)
         freePage(p);
 }
 
-void PersistentValueStorage::mark(ExecutionEngine *e)
+void PersistentValueStorage::mark(MarkStack *markStack)
 {
-    Value *markBase = e->jsStackTop;
-
     Page *p = static_cast<Page *>(firstPage);
     while (p) {
         for (int i = 0; i < kEntriesPerPage; ++i) {
             if (Managed *m = p->values[i].as<Managed>())
-                m->mark(e);
+                m->mark(markStack);
         }
-        e->memoryManager->drainMarkStack(markBase);
+        markStack->drain();
 
         p = p->header.next;
     }
@@ -384,11 +382,11 @@ void WeakValue::allocVal(ExecutionEngine *engine)
     val = engine->memoryManager->m_weakValues->allocate();
 }
 
-void WeakValue::markOnce(ExecutionEngine *e)
+void WeakValue::markOnce(MarkStack *markStack)
 {
     if (!val)
         return;
-    val->mark(e);
+    val->mark(markStack);
 }
 
 void WeakValue::free()
diff --git a/src/qml/jsruntime/qv4persistent_p.h b/src/qml/jsruntime/qv4persistent_p.h
index c1cd1f34df..1f838f5531 100644
--- a/src/qml/jsruntime/qv4persistent_p.h
+++ b/src/qml/jsruntime/qv4persistent_p.h
@@ -65,7 +65,7 @@ struct Q_QML_EXPORT PersistentValueStorage
     Value *allocate();
     static void free(Value *e);
 
-    void mark(ExecutionEngine *e);
+    void mark(MarkStack *markStack);
 
     struct Iterator {
         Iterator(void *p, int idx);
@@ -203,7 +203,7 @@ public:
     bool isNullOrUndefined() const { return !val || val->isNullOrUndefined(); }
     void clear() { free(); }
 
-    void markOnce(ExecutionEngine *e);
+    void markOnce(MarkStack *markStack);
 
 private:
     Value *val;
diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index 4f6c179026..2ac2b0b64d 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -539,7 +539,7 @@ ReturnedValue QObjectWrapper::wrap_slowPath(ExecutionEngine *engine, QObject *ob
     }
 }
 
-void QObjectWrapper::markWrapper(QObject *object, ExecutionEngine *engine)
+void QObjectWrapper::markWrapper(QObject *object, MarkStack *markStack)
 {
     if (QQmlData::wasDeleted(object))
         return;
@@ -548,10 +548,10 @@ void QObjectWrapper::markWrapper(QObject *object, ExecutionEngine *engine)
     if (!ddata)
         return;
 
-    if (ddata->jsEngineId == engine->m_engineId)
-        ddata->jsWrapper.markOnce(engine);
-    else  if (engine->m_multiplyWrappedQObjects && ddata->hasTaintedV4Object)
-        engine->m_multiplyWrappedQObjects->mark(object, engine);
+    if (ddata->jsEngineId == markStack->engine->m_engineId)
+        ddata->jsWrapper.markOnce(markStack);
+    else  if (markStack->engine->m_multiplyWrappedQObjects && ddata->hasTaintedV4Object)
+        markStack->engine->m_multiplyWrappedQObjects->mark(object, markStack);
 }
 
 ReturnedValue QObjectWrapper::getProperty(ExecutionEngine *engine, QObject *object, int propertyIndex, bool captureRequired)
@@ -938,36 +938,36 @@ void QObjectWrapper::method_disconnect(const BuiltinFunction *, Scope &scope, Ca
     RETURN_UNDEFINED();
 }
 
-static void markChildQObjectsRecursively(QObject *parent, QV4::ExecutionEngine *e)
+static void markChildQObjectsRecursively(QObject *parent, QV4::MarkStack *markStack)
 {
     const QObjectList &children = parent->children();
     for (int i = 0; i < children.count(); ++i) {
         QObject *child = children.at(i);
         if (!child)
             continue;
-        QObjectWrapper::markWrapper(child, e);
-        markChildQObjectsRecursively(child, e);
+        QObjectWrapper::markWrapper(child, markStack);
+        markChildQObjectsRecursively(child, markStack);
     }
 }
 
-void QObjectWrapper::markObjects(Heap::Base *that, QV4::ExecutionEngine *e)
+void QObjectWrapper::markObjects(Heap::Base *that, QV4::MarkStack *markStack)
 {
     QObjectWrapper::Data *This = static_cast<QObjectWrapper::Data *>(that);
 
     if (QObject *o = This->object()) {
         QQmlVMEMetaObject *vme = QQmlVMEMetaObject::get(o);
         if (vme)
-            vme->mark(e);
+            vme->mark(markStack);
 
         // Children usually don't need to be marked, the gc keeps them alive.
         // But in the rare case of a "floating" QObject without a parent that
         // _gets_ marked (we've been called here!) then we also need to
         // propagate the marking down to the children recursively.
         if (!o->parent())
-            markChildQObjectsRecursively(o, e);
+            markChildQObjectsRecursively(o, markStack);
     }
 
-    QV4::Object::markObjects(that, e);
+    QV4::Object::markObjects(that, markStack);
 }
 
 void QObjectWrapper::destroyObject(bool lastCall)
@@ -2066,12 +2066,12 @@ void MultiplyWrappedQObjectMap::remove(QObject *key)
     erase(it);
 }
 
-void MultiplyWrappedQObjectMap::mark(QObject *key, ExecutionEngine *engine)
+void MultiplyWrappedQObjectMap::mark(QObject *key, MarkStack *markStack)
 {
     Iterator it = find(key);
     if (it == end())
         return;
-    it->markOnce(engine);
+    it->markOnce(markStack);
 }
 
 void MultiplyWrappedQObjectMap::removeDestroyedObject(QObject *object)
diff --git a/src/qml/jsruntime/qv4qobjectwrapper_p.h b/src/qml/jsruntime/qv4qobjectwrapper_p.h
index c031a40211..dbb4a153e4 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper_p.h
+++ b/src/qml/jsruntime/qv4qobjectwrapper_p.h
@@ -171,7 +171,7 @@ struct Q_QML_EXPORT QObjectWrapper : public Object
     static bool setQmlProperty(ExecutionEngine *engine, QQmlContextData *qmlContext, QObject *object, String *name, RevisionMode revisionMode, const Value &value);
 
     static ReturnedValue wrap(ExecutionEngine *engine, QObject *object);
-    static void markWrapper(QObject *object, ExecutionEngine *engine);
+    static void markWrapper(QObject *object, MarkStack *markStack);
 
     using Object::get;
 
@@ -195,7 +195,7 @@ protected:
     static bool put(Managed *m, String *name, const Value &value);
     static PropertyAttributes query(const Managed *, String *name);
     static void advanceIterator(Managed *m, ObjectIterator *it, Value *name, uint *index, Property *p, PropertyAttributes *attributes);
-    static void markObjects(Heap::Base *that, QV4::ExecutionEngine *e);
+    static void markObjects(Heap::Base *that, QV4::MarkStack *markStack);
 
     static void method_connect(const BuiltinFunction *, Scope &scope, CallData *callData);
     static void method_disconnect(const BuiltinFunction *, Scope &scope, CallData *callData);
@@ -295,7 +295,7 @@ public:
     ReturnedValue value(QObject *key) const { return QHash<QObject*, QV4::WeakValue>::value(key).value(); }
     Iterator erase(Iterator it);
     void remove(QObject *key);
-    void mark(QObject *key, ExecutionEngine *engine);
+    void mark(QObject *key, MarkStack *markStack);
 
 private Q_SLOTS:
     void removeDestroyedObject(QObject*);
diff --git a/src/qml/jsruntime/qv4string.cpp b/src/qml/jsruntime/qv4string.cpp
index cde2131aab..71f85c2d71 100644
--- a/src/qml/jsruntime/qv4string.cpp
+++ b/src/qml/jsruntime/qv4string.cpp
@@ -54,12 +54,12 @@ using namespace QV4;
 
 DEFINE_MANAGED_VTABLE(String);
 
-void String::markObjects(Heap::Base *that, ExecutionEngine *e)
+void String::markObjects(Heap::Base *that, MarkStack *markStack)
 {
     String::Data *s = static_cast<String::Data *>(that);
     if (s->largestSubLength) {
-        s->left->mark(e);
-        s->right->mark(e);
+        s->left->mark(markStack);
+        s->right->mark(markStack);
     }
 }
 
diff --git a/src/qml/jsruntime/qv4string_p.h b/src/qml/jsruntime/qv4string_p.h
index 5b0fd292d6..71e55cbcd4 100644
--- a/src/qml/jsruntime/qv4string_p.h
+++ b/src/qml/jsruntime/qv4string_p.h
@@ -204,7 +204,7 @@ struct Q_QML_PRIVATE_EXPORT String : public Managed {
     Identifier *identifier() const { return d()->identifier; }
 
 protected:
-    static void markObjects(Heap::Base *that, ExecutionEngine *e);
+    static void markObjects(Heap::Base *that, MarkStack *markStack);
     static bool isEqualTo(Managed *that, Managed *o);
     static uint getLength(const Managed *m);
 #endif
diff --git a/src/qml/jsruntime/qv4value_p.h b/src/qml/jsruntime/qv4value_p.h
index 11d75dde99..56b4ec44a2 100644
--- a/src/qml/jsruntime/qv4value_p.h
+++ b/src/qml/jsruntime/qv4value_p.h
@@ -475,7 +475,7 @@ public:
     // Section 9.12
     bool sameValue(Value other) const;
 
-    inline void mark(ExecutionEngine *e);
+    inline void mark(MarkStack *markStack);
 
     Value &operator =(const ScopedValue &v);
     Value &operator=(ReturnedValue v) { _val = v; return *this; }