Don't use empty values anymore to store internal freelists

Simply encode them as integers. That works just as well, and
allows removing the indexed empty values.

This is helpful, to swap the internal representations of undefined
and empty values, which in turn will simplify an implementation of
correct handling of uninitialized variables (through let/const).

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

5 files changed, 37 insertions, 69 deletions

diff --git a/src/qml/jsruntime/qv4arraydata.cpp b/src/qml/jsruntime/qv4arraydata.cpp
index 02e9d682db..6718f2637c 100644
--- a/src/qml/jsruntime/qv4arraydata.cpp
+++ b/src/qml/jsruntime/qv4arraydata.cpp
@@ -105,13 +105,6 @@ QT_WARNING_SUPPRESS_GCC_TAUTOLOGICAL_COMPARE_OFF
 Q_STATIC_ASSERT(sizeof(Heap::ArrayData) == sizeof(Heap::SimpleArrayData));
 Q_STATIC_ASSERT(sizeof(Heap::ArrayData) == sizeof(Heap::SparseArrayData));
 
-static Q_ALWAYS_INLINE void storeValue(ReturnedValue *target, uint value)
-{
-    Value v;
-    v.setEmpty(value);
-    *target = v.asReturnedValue();
-}
-
 void Heap::ArrayData::markObjects(Heap::Base *base, MarkStack *stack)
 {
     ArrayData *a = static_cast<ArrayData *>(base);
@@ -200,7 +193,7 @@ void ArrayData::realloc(Object *o, Type newType, uint requested, bool enforceAtt
 
     Heap::SparseArrayData *sparse = static_cast<Heap::SparseArrayData *>(newData->d());
 
-    ReturnedValue *lastFree;
+    Value *lastFree;
     if (d && d->type() == Heap::ArrayData::Sparse) {
         Heap::SparseArrayData *old = static_cast<Heap::SparseArrayData *>(d->d());
         sparse->sparse = old->sparse;
@@ -209,29 +202,29 @@ void ArrayData::realloc(Object *o, Type newType, uint requested, bool enforceAtt
     } else {
         sparse->sparse = new SparseArray;
         lastFree = &sparse->sparse->freeList;
-        storeValue(lastFree, 0);
+        *lastFree = Encode(0);
         for (uint i = 0; i < toCopy; ++i) {
             if (!sparse->values[i].isEmpty()) {
                 SparseArrayNode *n = sparse->sparse->insert(i);
                 n->value = i;
             } else {
-                storeValue(lastFree, i);
+                *lastFree = Encode(i);
                 sparse->values.values[i].setEmpty();
-                lastFree = &sparse->values.values[i].rawValueRef();
+                lastFree = &sparse->values.values[i];
             }
         }
     }
 
     if (toCopy < sparse->values.alloc) {
         for (uint i = toCopy; i < sparse->values.alloc; ++i) {
-            storeValue(lastFree, i);
+            *lastFree = Encode(i);
             sparse->values.values[i].setEmpty();
-            lastFree = &sparse->values.values[i].rawValueRef();
+            lastFree = &sparse->values.values[i];
         }
     }
-    storeValue(lastFree, UINT_MAX);
+    *lastFree = Encode(-1);
 
-    Q_ASSERT(Value::fromReturnedValue(sparse->sparse->freeList).isEmpty());
+    Q_ASSERT(sparse->sparse->freeList.isInteger());
     // ### Could explicitly free the old data
 }
 
@@ -373,12 +366,12 @@ void SparseArrayData::free(Heap::ArrayData *d, uint idx)
     Value *v = d->values.values + idx;
     if (d->attrs && d->attrs[idx].isAccessor()) {
         // double slot, free both. Order is important, so we have a double slot for allocation again afterwards.
-        v[1].setEmpty(Value::fromReturnedValue(d->sparse->freeList).emptyValue());
-        v[0].setEmpty(idx + 1);
+        v[1] = d->sparse->freeList;
+        v[0] = Encode(idx + 1);
     } else {
-        v->setEmpty(Value::fromReturnedValue(d->sparse->freeList).emptyValue());
+        *v = d->sparse->freeList;
     }
-    d->sparse->freeList = Primitive::emptyValue(idx).asReturnedValue();
+    d->sparse->freeList = Encode(idx);
     if (d->attrs)
         d->attrs[idx].clear();
 }
@@ -395,36 +388,34 @@ uint SparseArrayData::allocate(Object *o, bool doubleSlot)
     Q_ASSERT(o->d()->arrayData->type == Heap::ArrayData::Sparse);
     Heap::SimpleArrayData *dd = o->d()->arrayData.cast<Heap::SimpleArrayData>();
     if (doubleSlot) {
-        ReturnedValue *last = &dd->sparse->freeList;
+        Value *last = &dd->sparse->freeList;
         while (1) {
-            if (Value::fromReturnedValue(*last).value() == UINT_MAX) {
+            if (last->int_32() == -1) {
                 reallocate(o, dd->values.alloc + 2, true);
                 dd = o->d()->arrayData.cast<Heap::SimpleArrayData>();
                 last = &dd->sparse->freeList;
-                Q_ASSERT(Value::fromReturnedValue(*last).value() != UINT_MAX);
+                Q_ASSERT(last->int_32() != -1);
             }
 
-            Q_ASSERT(dd->values[Value::fromReturnedValue(*last).value()].value() != Value::fromReturnedValue(*last).value());
-            if (dd->values[Value::fromReturnedValue(*last).value()].value() == (Value::fromReturnedValue(*last).value() + 1)) {
+            Q_ASSERT(dd->values[static_cast<uint>(last->int_32())].int_32() != last->int_32());
+            if (dd->values[static_cast<uint>(last->int_32())].int_32() == last->int_32() + 1) {
                 // found two slots in a row
-                uint idx = Value::fromReturnedValue(*last).emptyValue();
-                Value lastV = Value::fromReturnedValue(*last);
-                lastV.setEmpty(dd->values[lastV.emptyValue() + 1].value());
-                *last = lastV.rawValue();
+                uint idx = static_cast<uint>(last->int_32());
+                *last = Encode(dd->values[static_cast<uint>(last->int_32()) + 1].int_32());
                 dd->attrs[idx] = Attr_Accessor;
                 return idx;
             }
-            last = &dd->values.values[Value::fromReturnedValue(*last).value()].rawValueRef();
+            last = &dd->values.values[last->int_32()];
         }
     } else {
-        if (Value::fromReturnedValue(dd->sparse->freeList).value() == UINT_MAX) {
+        if (dd->sparse->freeList.int_32() == -1) {
             reallocate(o, dd->values.alloc + 1, false);
             dd = o->d()->arrayData.cast<Heap::SimpleArrayData>();
         }
-        uint idx = Value::fromReturnedValue(dd->sparse->freeList).value();
-        Q_ASSERT(idx != UINT_MAX);
-        dd->sparse->freeList = dd->values[idx].asReturnedValue();
-        Q_ASSERT(Value::fromReturnedValue(dd->sparse->freeList).isEmpty());
+        Q_ASSERT(dd->sparse->freeList.int_32() != -1);
+        uint idx = static_cast<uint>(dd->sparse->freeList.int_32());
+        dd->sparse->freeList = dd->values[idx];
+        Q_ASSERT(dd->sparse->freeList.isInteger());
         if (dd->attrs)
             dd->attrs[idx] = Attr_Data;
         return idx;
@@ -479,14 +470,14 @@ bool SparseArrayData::del(Object *o, uint index)
 
     if (isAccessor) {
         // free up both indices
-        dd->values.values[pidx + 1].setEmpty(Value::fromReturnedValue(dd->sparse->freeList).emptyValue());
-        dd->values.values[pidx].setEmpty(pidx + 1);
+        dd->values.values[pidx + 1] = dd->sparse->freeList;
+        dd->values.values[pidx] = Encode(pidx + 1);
     } else {
         Q_ASSERT(dd->type == Heap::ArrayData::Sparse);
-        dd->values.values[pidx].setEmpty(Value::fromReturnedValue(dd->sparse->freeList).emptyValue());
+        dd->values.values[pidx] = dd->sparse->freeList;
     }
 
-    dd->sparse->freeList = Primitive::emptyValue(pidx).asReturnedValue();
+    dd->sparse->freeList = Encode(pidx);
     dd->sparse->erase(n);
     return true;
 }
diff --git a/src/qml/jsruntime/qv4persistent.cpp b/src/qml/jsruntime/qv4persistent.cpp
index 7fc74173e3..f8bc28160e 100644
--- a/src/qml/jsruntime/qv4persistent.cpp
+++ b/src/qml/jsruntime/qv4persistent.cpp
@@ -98,9 +98,9 @@ Page *allocatePage(PersistentValueStorage *storage)
     p->header.freeList = 0;
     insertInFront(storage, p);
     for (int i = 0; i < kEntriesPerPage - 1; ++i) {
-        p->values[i].setEmpty(i + 1);
+        p->values[i] = Encode(i + 1);
     }
-    p->values[kEntriesPerPage - 1].setEmpty(-1);
+    p->values[kEntriesPerPage - 1] = Encode(-1);
 
     return p;
 }
@@ -226,7 +226,7 @@ void PersistentValueStorage::free(Value *v)
 
     Page *p = getPage(v);
 
-    v->setEmpty(p->header.freeList);
+    *v = Encode(p->header.freeList);
     p->header.freeList = v - p->values;
     if (!--p->header.refCount)
         freePage(p);
diff --git a/src/qml/jsruntime/qv4sparsearray.cpp b/src/qml/jsruntime/qv4sparsearray.cpp
index 2a3e28bf63..8930c9a94d 100644
--- a/src/qml/jsruntime/qv4sparsearray.cpp
+++ b/src/qml/jsruntime/qv4sparsearray.cpp
@@ -395,7 +395,7 @@ void SparseArray::freeTree(SparseArrayNode *root, int alignment)
 SparseArray::SparseArray()
     : numEntries(0)
 {
-    freeList = Primitive::emptyValue(UINT_MAX).asReturnedValue();
+    freeList = Encode(-1);
     header.p = 0;
     header.left = nullptr;
     header.right = nullptr;
diff --git a/src/qml/jsruntime/qv4sparsearray_p.h b/src/qml/jsruntime/qv4sparsearray_p.h
index 51869b259f..c1e50c8dcf 100644
--- a/src/qml/jsruntime/qv4sparsearray_p.h
+++ b/src/qml/jsruntime/qv4sparsearray_p.h
@@ -52,6 +52,7 @@
 //
 
 #include "qv4global_p.h"
+#include "qv4value_p.h"
 #include <QtCore/qlist.h>
 
 //#define Q_MAP_DEBUG
@@ -151,7 +152,7 @@ struct Q_QML_EXPORT SparseArray
 
     SparseArray(const SparseArray &other);
 
-    ReturnedValue freeList;
+    Value freeList;
 private:
     SparseArray &operator=(const SparseArray &other);
 
diff --git a/src/qml/jsruntime/qv4value_p.h b/src/qml/jsruntime/qv4value_p.h
index d2d19f005e..a27ae9c9a6 100644
--- a/src/qml/jsruntime/qv4value_p.h
+++ b/src/qml/jsruntime/qv4value_p.h
@@ -185,23 +185,7 @@ public:
 
     QML_NEARLY_ALWAYS_INLINE void setEmpty()
     {
-        setTagValue(quint32(ValueTypeInternal::Empty), value());
-    }
-
-    QML_NEARLY_ALWAYS_INLINE void setEmpty(int i)
-    {
-        setTagValue(quint32(ValueTypeInternal::Empty), quint32(i));
-    }
-
-    QML_NEARLY_ALWAYS_INLINE void setEmpty(quint32 i)
-    {
-        setTagValue(quint32(ValueTypeInternal::Empty), i);
-    }
-
-    QML_NEARLY_ALWAYS_INLINE quint32 emptyValue()
-    {
-        Q_ASSERT(isEmpty());
-        return quint32(value());
+        setTagValue(quint32(ValueTypeInternal::Empty), 0);
     }
 
     // ### Fix for 32 bit (easiest solution is to set highest bit to 1 for mananged/undefined/integercompatible
@@ -612,7 +596,6 @@ ReturnedValue Heap::Base::asReturnedValue() const
 struct Q_QML_PRIVATE_EXPORT Primitive : public Value
 {
     inline static Primitive emptyValue();
-    inline static Primitive emptyValue(uint v);
     static inline Primitive fromBoolean(bool b);
     static inline Primitive fromInt32(int i);
     inline static Primitive undefinedValue();
@@ -638,14 +621,7 @@ inline Primitive Primitive::undefinedValue()
 inline Primitive Primitive::emptyValue()
 {
     Primitive v;
-    v.setEmpty(0);
-    return v;
-}
-
-inline Primitive Primitive::emptyValue(uint e)
-{
-    Primitive v;
-    v.setEmpty(e);
+    v.setEmpty();
     return v;
 }