Let the memory manager operate on Heap::Base objects, not Managed

Change-Id: Ib5c9b51dbf9c69abeda088094e6348dd545bf3c8
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>

8 files changed, 49 insertions, 46 deletions

diff --git a/src/qml/jsruntime/qv4arraydata.cpp b/src/qml/jsruntime/qv4arraydata.cpp
index 26dce28470..deabfebd79 100644
--- a/src/qml/jsruntime/qv4arraydata.cpp
+++ b/src/qml/jsruntime/qv4arraydata.cpp
@@ -126,15 +126,16 @@ void ArrayData::realloc(Object *o, Type newType, uint requested, bool enforceAtt
     if (enforceAttributes)
         size += alloc*sizeof(PropertyAttributes);
 
+    Scope scope(o->engine());
     ArrayData *newData;
     if (newType < Heap::ArrayData::Sparse) {
-        SimpleArrayData *n = static_cast<SimpleArrayData *>(o->engine()->memoryManager->allocManaged(size));
+        Scoped<SimpleArrayData> n(scope, static_cast<Heap::SimpleArrayData *>(o->engine()->memoryManager->allocManaged(size)));
         new (n->d()) Heap::SimpleArrayData(o->engine());
         n->d()->offset = 0;
         n->len() = d ? static_cast<SimpleArrayData *>(d)->len() : 0;
         newData = n;
     } else {
-        SparseArrayData *n = static_cast<SparseArrayData *>(o->engine()->memoryManager->allocManaged(size));
+        Scoped<SparseArrayData> n(scope, static_cast<Heap::SparseArrayData *>(o->engine()->memoryManager->allocManaged(size)));
         new (n->d()) Heap::SparseArrayData(o->engine());
         newData = n;
     }
diff --git a/src/qml/jsruntime/qv4context.cpp b/src/qml/jsruntime/qv4context.cpp
index fee2be30dc..03858c13e7 100644
--- a/src/qml/jsruntime/qv4context.cpp
+++ b/src/qml/jsruntime/qv4context.cpp
@@ -94,7 +94,7 @@ Heap::CatchContext *ExecutionContext::newCatchContext(String *exceptionVarName,
 Heap::CallContext *ExecutionContext::newQmlContext(FunctionObject *f, Object *qml)
 {
     Scope scope(this);
-    Scoped<CallContext> c(scope, static_cast<CallContext*>(d()->engine->memoryManager->allocManaged(requiredMemoryForExecutionContect(f, 0))));
+    Scoped<CallContext> c(scope, static_cast<Heap::CallContext*>(d()->engine->memoryManager->allocManaged(requiredMemoryForExecutionContect(f, 0))));
     new (c->d()) Heap::CallContext(d()->engine, qml, f);
     return c->d();
 }
diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp
index 8746015ab5..89df57037a 100644
--- a/src/qml/jsruntime/qv4engine.cpp
+++ b/src/qml/jsruntime/qv4engine.cpp
@@ -492,7 +492,8 @@ void ExecutionEngine::enableProfiler()
 
 void ExecutionEngine::initRootContext()
 {
-    GlobalContext *r = static_cast<GlobalContext*>(memoryManager->allocManaged(sizeof(GlobalContext::Data) + sizeof(CallData)));
+    Scope scope(this);
+    Scoped<GlobalContext> r(scope, static_cast<Heap::GlobalContext*>(memoryManager->allocManaged(sizeof(GlobalContext::Data) + sizeof(CallData))));
     new (r->d()) GlobalContext::Data(this);
     r->d()->callData = reinterpret_cast<CallData *>(r->d() + 1);
     r->d()->callData->tag = QV4::Value::_Integer_Type;
diff --git a/src/qml/jsruntime/qv4managed_p.h b/src/qml/jsruntime/qv4managed_p.h
index 8ba6597d0f..b67876bc82 100644
--- a/src/qml/jsruntime/qv4managed_p.h
+++ b/src/qml/jsruntime/qv4managed_p.h
@@ -285,16 +285,6 @@ public:
 
     QString className() const;
 
-    Managed **nextFreeRef() {
-        return reinterpret_cast<Managed **>(this);
-    }
-    Managed *nextFree() {
-        return *reinterpret_cast<Managed **>(this);
-    }
-    void setNextFree(Managed *m) {
-        *reinterpret_cast<Managed **>(this) = m;
-    }
-
     void setVTable(const ManagedVTable *vt);
 
     bool isEqualTo(const Managed *other) const
diff --git a/src/qml/jsruntime/qv4memberdata.cpp b/src/qml/jsruntime/qv4memberdata.cpp
index 50653a0115..92ffc391de 100644
--- a/src/qml/jsruntime/qv4memberdata.cpp
+++ b/src/qml/jsruntime/qv4memberdata.cpp
@@ -53,11 +53,12 @@ Heap::MemberData *MemberData::reallocate(ExecutionEngine *e, Heap::MemberData *o
 
     int newAlloc = qMax((uint)4, 2*idx);
     uint alloc = sizeof(Heap::MemberData) + (newAlloc)*sizeof(Value);
-    MemberData *newMemberData = static_cast<MemberData *>(e->memoryManager->allocManaged(alloc));
+    Scope scope(e);
+    Scoped<MemberData> newMemberData(scope, static_cast<Heap::MemberData *>(e->memoryManager->allocManaged(alloc)));
     if (old)
         memcpy(newMemberData, old, sizeof(Heap::MemberData) + s*sizeof(Value));
     else
-        new (newMemberData) Heap::MemberData(e->memberDataClass);
+        new (newMemberData->d()) Heap::MemberData(e->memberDataClass);
     newMemberData->d()->size = newAlloc;
     return newMemberData->d();
 }
diff --git a/src/qml/jsruntime/qv4mm.cpp b/src/qml/jsruntime/qv4mm.cpp
index d8e3f3d468..f90db63924 100644
--- a/src/qml/jsruntime/qv4mm.cpp
+++ b/src/qml/jsruntime/qv4mm.cpp
@@ -77,7 +77,7 @@ struct MemoryManager::Data
     ExecutionEngine *engine;
 
     enum { MaxItemSize = 512 };
-    Managed *smallItems[MaxItemSize/16];
+    Heap::Base *smallItems[MaxItemSize/16];
     uint nChunks[MaxItemSize/16];
     uint availableItems[MaxItemSize/16];
     uint allocCount[MaxItemSize/16];
@@ -98,8 +98,8 @@ struct MemoryManager::Data
         size_t size;
         void *data;
 
-        Managed *managed() {
-            return reinterpret_cast<Managed *>(&data);
+        Heap::Base *heapObject() {
+            return reinterpret_cast<Heap::Base *>(&data);
         }
     };
 
@@ -172,7 +172,7 @@ MemoryManager::MemoryManager()
 #endif
 }
 
-Managed *MemoryManager::allocData(std::size_t size)
+Heap::Base *MemoryManager::allocData(std::size_t size)
 {
     if (m_d->aggressiveGC)
         runGC();
@@ -199,10 +199,10 @@ Managed *MemoryManager::allocData(std::size_t size)
         item->size = size;
         m_d->largeItems = item;
         m_d->totalLargeItemsAllocated += size;
-        return item->managed();
+        return item->heapObject();
     }
 
-    Managed *m = m_d->smallItems[pos];
+    Heap::Base *m = m_d->smallItems[pos];
     if (m)
         goto found;
 
@@ -232,9 +232,9 @@ Managed *MemoryManager::allocData(std::size_t size)
         char *chunk = (char *)allocation.memory.base();
         char *end = chunk + allocation.memory.size() - size;
 
-        Managed **last = &m_d->smallItems[pos];
+        Heap::Base **last = &m_d->smallItems[pos];
         while (chunk <= end) {
-            Managed *o = reinterpret_cast<Managed *>(chunk);
+            Heap::Base *o = reinterpret_cast<Heap::Base *>(chunk);
             *last = o;
             last = o->nextFreeRef();
             chunk += size;
@@ -368,16 +368,16 @@ void MemoryManager::sweep(bool lastSweep)
     Data::LargeItem *i = m_d->largeItems;
     Data::LargeItem **last = &m_d->largeItems;
     while (i) {
-        Managed *m = i->managed();
-        Q_ASSERT(m->inUse());
-        if (m->markBit()) {
-            m->d()->markBit = 0;
+        Heap::Base *m = i->heapObject();
+        Q_ASSERT(m->inUse);
+        if (m->markBit) {
+            m->markBit = 0;
             last = &i->next;
             i = i->next;
             continue;
         }
-        if (m->internalClass()->vtable->destroy)
-            m->internalClass()->vtable->destroy(m->d());
+        if (m->internalClass->vtable->destroy)
+            m->internalClass->vtable->destroy(m);
 
         *last = i->next;
         free(Q_V4_PROFILE_DEALLOC(m_d->engine, i, i->size + sizeof(Data::LargeItem),
@@ -398,28 +398,28 @@ void MemoryManager::sweep(bool lastSweep)
 void MemoryManager::sweep(char *chunkStart, std::size_t chunkSize, size_t size)
 {
 //    qDebug("chunkStart @ %p, size=%x, pos=%x (%x)", chunkStart, size, size>>4, m_d->smallItems[size >> 4]);
-    Managed **f = &m_d->smallItems[size >> 4];
+    Heap::Base **f = &m_d->smallItems[size >> 4];
 
 #ifdef V4_USE_VALGRIND
     VALGRIND_DISABLE_ERROR_REPORTING;
 #endif
     for (char *chunk = chunkStart, *chunkEnd = chunk + chunkSize - size; chunk <= chunkEnd; chunk += size) {
-        Managed *m = reinterpret_cast<Managed *>(chunk);
+        Heap::Base *m = reinterpret_cast<Heap::Base *>(chunk);
 //        qDebug("chunk @ %p, size = %lu, in use: %s, mark bit: %s",
 //               chunk, m->size, (m->inUse ? "yes" : "no"), (m->markBit ? "true" : "false"));
 
         Q_ASSERT((qintptr) chunk % 16 == 0);
 
-        if (m->inUse()) {
-            if (m->markBit()) {
-                m->d()->markBit = 0;
+        if (m->inUse) {
+            if (m->markBit) {
+                m->markBit = 0;
             } else {
 //                qDebug() << "-- collecting it." << m << *f << m->nextFree();
 #ifdef V4_USE_VALGRIND
                 VALGRIND_ENABLE_ERROR_REPORTING;
 #endif
-                if (m->internalClass()->vtable->destroy)
-                    m->internalClass()->vtable->destroy(m->d());
+                if (m->internalClass->vtable->destroy)
+                    m->internalClass->vtable->destroy(m);
 
                 memset(m, 0, size);
                 m->setNextFree(*f);
diff --git a/src/qml/jsruntime/qv4mm_p.h b/src/qml/jsruntime/qv4mm_p.h
index 57c6870842..829429d790 100644
--- a/src/qml/jsruntime/qv4mm_p.h
+++ b/src/qml/jsruntime/qv4mm_p.h
@@ -83,10 +83,10 @@ public:
     static inline std::size_t align(std::size_t size)
     { return (size + 15) & ~0xf; }
 
-    inline Managed *allocManaged(std::size_t size)
+    inline Heap::Base *allocManaged(std::size_t size)
     {
         size = align(size);
-        Managed *o = allocData(size);
+        Heap::Base *o = allocData(size);
         return o;
     }
 
@@ -94,7 +94,7 @@ public:
     typename ManagedType::Data *alloc()
     {
         Scope scope(engine());
-        Scoped<ManagedType> t(scope, static_cast<ManagedType*>(allocManaged(sizeof(typename ManagedType::Data))));
+        Scoped<ManagedType> t(scope, static_cast<typename ManagedType::Data *>(allocManaged(sizeof(typename ManagedType::Data))));
         (void)new (t->d()) typename ManagedType::Data();
         return t->d();
     }
@@ -103,7 +103,7 @@ public:
     typename ManagedType::Data *alloc(Arg1 arg1)
     {
         Scope scope(engine());
-        Scoped<ManagedType> t(scope, static_cast<ManagedType*>(allocManaged(sizeof(typename ManagedType::Data))));
+        Scoped<ManagedType> t(scope, static_cast<typename ManagedType::Data *>(allocManaged(sizeof(typename ManagedType::Data))));
         (void)new (t->d()) typename ManagedType::Data(arg1);
         return t->d();
     }
@@ -112,7 +112,7 @@ public:
     typename ManagedType::Data *alloc(Arg1 arg1, Arg2 arg2)
     {
         Scope scope(engine());
-        Scoped<ManagedType> t(scope, static_cast<ManagedType*>(allocManaged(sizeof(typename ManagedType::Data))));
+        Scoped<ManagedType> t(scope, static_cast<typename ManagedType::Data *>(allocManaged(sizeof(typename ManagedType::Data))));
         (void)new (t->d()) typename ManagedType::Data(arg1, arg2);
         return t->d();
     }
@@ -121,7 +121,7 @@ public:
     typename ManagedType::Data *alloc(Arg1 arg1, Arg2 arg2, Arg3 arg3)
     {
         Scope scope(engine());
-        Scoped<ManagedType> t(scope, static_cast<ManagedType*>(allocManaged(sizeof(typename ManagedType::Data))));
+        Scoped<ManagedType> t(scope, static_cast<typename ManagedType::Data *>(allocManaged(sizeof(typename ManagedType::Data))));
         (void)new (t->d()) typename ManagedType::Data(arg1, arg2, arg3);
         return t->d();
     }
@@ -130,7 +130,7 @@ public:
     typename ManagedType::Data *alloc(Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
     {
         Scope scope(engine());
-        Scoped<ManagedType> t(scope, static_cast<ManagedType*>(allocManaged(sizeof(typename ManagedType::Data))));
+        Scoped<ManagedType> t(scope, static_cast<typename ManagedType::Data *>(allocManaged(sizeof(typename ManagedType::Data))));
         (void)new (t->d()) typename ManagedType::Data(arg1, arg2, arg3, arg4);
         return t->d();
     }
@@ -139,7 +139,7 @@ public:
     typename ManagedType::Data *alloc(Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5)
     {
         Scope scope(engine());
-        Scoped<ManagedType> t(scope, static_cast<ManagedType*>(allocManaged(sizeof(typename ManagedType::Data))));
+        Scoped<ManagedType> t(scope, static_cast<typename ManagedType::Data *>(allocManaged(sizeof(typename ManagedType::Data))));
         (void)new (t->d()) typename ManagedType::Data(arg1, arg2, arg3, arg4, arg5);
         return t->d();
     }
@@ -162,7 +162,7 @@ public:
 protected:
     /// expects size to be aligned
     // TODO: try to inline
-    Managed *allocData(std::size_t size);
+    Heap::Base *allocData(std::size_t size);
 
 #ifdef DETAILED_MM_STATS
     void willAllocate(std::size_t size);
diff --git a/src/qml/jsruntime/qv4value_p.h b/src/qml/jsruntime/qv4value_p.h
index cbbe88bd76..b242f94f8a 100644
--- a/src/qml/jsruntime/qv4value_p.h
+++ b/src/qml/jsruntime/qv4value_p.h
@@ -76,6 +76,16 @@ struct Q_QML_EXPORT Base {
     inline ReturnedValue asReturnedValue() const;
     inline void mark(QV4::ExecutionEngine *engine);
 
+    Base **nextFreeRef() {
+        return reinterpret_cast<Base **>(this);
+    }
+    Base *nextFree() {
+        return *reinterpret_cast<Base **>(this);
+    }
+    void setNextFree(Base *m) {
+        *reinterpret_cast<Base **>(this) = m;
+    }
+
     void *operator new(size_t, Managed *m) { return m; }
     void *operator new(size_t, Heap::Base *m) { return m; }
     void operator delete(void *, Heap::Base *) {}