garbage collect InternalClass

Internal classes are now allocated and collected through
the GC. As they are important to the deletion of other
objects (because of the vtable pointer living inside the
internal class), they need to get destroyed after regular
objects have been sweeped. Achieve this by using a separate
block allocator for internal class objects.

Our lookups do often contain pointers to internal classes,
so those need to be marked as well, so we don't accidentally
collect them.

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

1 files changed, 39 insertions, 15 deletions

diff --git a/src/qml/memory/qv4mm_p.h b/src/qml/memory/qv4mm_p.h
index ae2153e7c4..bc9b7130c7 100644
--- a/src/qml/memory/qv4mm_p.h
+++ b/src/qml/memory/qv4mm_p.h
@@ -160,37 +160,52 @@ public:
     { return (size + Chunk::SlotSize - 1) & ~(Chunk::SlotSize - 1); }
 
     template<typename ManagedType>
-    inline typename ManagedType::Data *allocManaged(std::size_t size, InternalClass *ic)
+    inline typename ManagedType::Data *allocManaged(std::size_t size, Heap::InternalClass *ic)
     {
         Q_STATIC_ASSERT(std::is_trivial< typename ManagedType::Data >::value);
         size = align(size);
-        Heap::Base *o = allocData(size);
-        o->internalClass = ic;
-        Q_ASSERT(o->internalClass && o->internalClass->vtable);
+        typename ManagedType::Data *d = static_cast<typename ManagedType::Data *>(allocData(size));
+        d->internalClass.set(engine, ic);
+        Q_ASSERT(d->internalClass && d->internalClass->vtable);
         Q_ASSERT(ic->vtable == ManagedType::staticVTable());
-        return static_cast<typename ManagedType::Data *>(o);
+        return d;
+    }
+
+    template<typename ManagedType>
+    inline typename ManagedType::Data *allocManaged(std::size_t size, InternalClass *ic)
+    {
+        return allocManaged<ManagedType>(size, ic->d());
     }
 
     template<typename ManagedType>
     inline typename ManagedType::Data *allocManaged(std::size_t size)
     {
-        return allocManaged<ManagedType>(size, ManagedType::defaultInternalClass(engine));
+        Scope scope(engine);
+        Scoped<InternalClass> ic(scope, ManagedType::defaultInternalClass(engine));
+        return allocManaged<ManagedType>(size, ic);
     }
 
     template <typename ObjectType>
-    typename ObjectType::Data *allocateObject(InternalClass *ic)
+    typename ObjectType::Data *allocateObject(Heap::InternalClass *ic)
     {
         Heap::Object *o = allocObjectWithMemberData(ObjectType::staticVTable(), ic->size);
-        o->internalClass = ic;
-        Q_ASSERT(o->internalClass && o->internalClass->vtable);
-        Q_ASSERT(ic->vtable == ObjectType::staticVTable());
+        o->internalClass.set(engine, ic);
+        Q_ASSERT(o->internalClass.get() && o->vtable());
+        Q_ASSERT(o->vtable() == ObjectType::staticVTable());
         return static_cast<typename ObjectType::Data *>(o);
     }
 
     template <typename ObjectType>
+    typename ObjectType::Data *allocateObject(InternalClass *ic)
+    {
+        return allocateObject<ObjectType>(ic->d());
+    }
+
+    template <typename ObjectType>
     typename ObjectType::Data *allocateObject()
     {
-        InternalClass *ic = ObjectType::defaultInternalClass(engine);
+        Scope scope(engine);
+        Scoped<InternalClass> ic(scope,  ObjectType::defaultInternalClass(engine));
         ic = ic->changeVTable(ObjectType::staticVTable());
         ic = ic->changePrototype(ObjectType::defaultPrototype(engine)->d());
         return allocateObject<ObjectType>(ic);
@@ -200,18 +215,18 @@ public:
     typename ManagedType::Data *allocWithStringData(std::size_t unmanagedSize, Arg1 arg1)
     {
         typename ManagedType::Data *o = reinterpret_cast<typename ManagedType::Data *>(allocString(unmanagedSize));
-        o->internalClass = ManagedType::defaultInternalClass(engine);
+        o->internalClass.set(engine, ManagedType::defaultInternalClass(engine));
         Q_ASSERT(o->internalClass && o->internalClass->vtable);
         o->init(arg1);
         return o;
     }
 
-    template <typename ObjectType>
-    typename ObjectType::Data *allocObject(InternalClass *ic)
+    template <typename ObjectType, typename... Args>
+    typename ObjectType::Data *allocObject(Heap::InternalClass *ic, Args... args)
     {
         Scope scope(engine);
         Scoped<ObjectType> t(scope, allocateObject<ObjectType>(ic));
-        t->d_unchecked()->init();
+        t->d_unchecked()->init(args...);
         return t->d();
     }
 
@@ -253,6 +268,14 @@ public:
     // called when a JS object grows itself. Specifically: Heap::String::append
     void changeUnmanagedHeapSizeUsage(qptrdiff delta) { unmanagedHeapSize += delta; }
 
+    template<typename ManagedType>
+    typename ManagedType::Data *allocIC()
+    {
+        size_t size = align(sizeof(typename ManagedType::Data));
+        Heap::Base *b = *icAllocator.allocate(size, true);
+        return static_cast<typename ManagedType::Data *>(b);
+    }
+
 protected:
     /// expects size to be aligned
     Heap::Base *allocString(std::size_t unmanagedSize);
@@ -270,6 +293,7 @@ public:
     QV4::ExecutionEngine *engine;
     ChunkAllocator *chunkAllocator;
     BlockAllocator blockAllocator;
+    BlockAllocator icAllocator;
     HugeItemAllocator hugeItemAllocator;
     PersistentValueStorage *m_persistentValues;
     PersistentValueStorage *m_weakValues;