1 files changed, 81 insertions, 59 deletions

diff --git a/src/qml/jsruntime/qv4internalclass_p.h b/src/qml/jsruntime/qv4internalclass_p.h
index b2fe0c8aa9..56ce787859 100644
--- a/src/qml/jsruntime/qv4internalclass_p.h
+++ b/src/qml/jsruntime/qv4internalclass_p.h
@@ -1,41 +1,5 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the QtQml module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU Lesser General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU Lesser
-** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPL3 included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or (at your option) the GNU General
-** Public license version 3 or any later version approved by the KDE Free
-** Qt Foundation. The licenses are as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-2.0.html and
-** https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 #ifndef QV4INTERNALCLASS_H
 #define QV4INTERNALCLASS_H
 
@@ -53,6 +17,8 @@
 #include "qv4global_p.h"
 
 #include <QHash>
+#include <QVarLengthArray>
+#include <climits> // for UINT_MAX
 #include <private/qv4propertykey_p.h>
 #include <private/qv4heap_p.h>
 
@@ -88,7 +54,6 @@ struct PropertyHash
 
     void addEntry(const Entry &entry, int classSize);
     Entry *lookup(PropertyKey identifier) const;
-    int removeIdentifier(PropertyKey identifier, int classSize);
     void detach(bool grow, int classSize);
 };
 
@@ -158,7 +123,7 @@ struct SharedInternalClassDataPrivate<PropertyAttributes> {
         : refcount(1),
           m_alloc(0),
           m_size(0),
-          data(nullptr),
+          m_data(nullptr),
           m_engine(engine)
     { }
     SharedInternalClassDataPrivate(const SharedInternalClassDataPrivate<PropertyAttributes> &other);
@@ -168,12 +133,14 @@ struct SharedInternalClassDataPrivate<PropertyAttributes> {
 
     void grow();
 
+    void markIfNecessary(const PropertyAttributes &) {}
+
     uint alloc() const { return m_alloc; }
     uint size() const { return m_size; }
     void setSize(uint s) { m_size = s; }
 
-    PropertyAttributes at(uint i) { Q_ASSERT(data && i < m_alloc); return data[i]; }
-    void set(uint i, PropertyAttributes t) { Q_ASSERT(data && i < m_alloc); data[i] = t; }
+    PropertyAttributes at(uint i) const { Q_ASSERT(i < m_alloc); return data(i); }
+    void set(uint i, PropertyAttributes t) { Q_ASSERT(i < m_alloc); setData(i, t); }
 
     void mark(MarkStack *) {}
 
@@ -181,23 +148,49 @@ struct SharedInternalClassDataPrivate<PropertyAttributes> {
 private:
     uint m_alloc;
     uint m_size;
-    PropertyAttributes *data;
+
+    enum {
+        SizeOfAttributesPointer = sizeof(PropertyAttributes *),
+        SizeOfAttributes = sizeof(PropertyAttributes),
+        NumAttributesInPointer = SizeOfAttributesPointer / SizeOfAttributes,
+    };
+
+    static_assert(NumAttributesInPointer > 0);
+
+    PropertyAttributes data(uint i) const {
+        return m_alloc > NumAttributesInPointer ? m_data[i] : m_inlineData[i];
+    }
+
+    void setData(uint i, PropertyAttributes t) {
+        if (m_alloc > NumAttributesInPointer)
+            m_data[i] = t;
+        else
+            m_inlineData[i] = t;
+    }
+
+    union {
+        PropertyAttributes *m_data;
+        PropertyAttributes m_inlineData[NumAttributesInPointer];
+    };
     ExecutionEngine *m_engine;
 };
 
 template<>
 struct SharedInternalClassDataPrivate<PropertyKey> {
-    SharedInternalClassDataPrivate(ExecutionEngine *e) : refcount(1), engine(e), data(nullptr) {}
+    SharedInternalClassDataPrivate(ExecutionEngine *e) : refcount(1), engine(e) {}
     SharedInternalClassDataPrivate(const SharedInternalClassDataPrivate &other);
     SharedInternalClassDataPrivate(const SharedInternalClassDataPrivate &other, uint pos, PropertyKey value);
     ~SharedInternalClassDataPrivate() {}
 
+    template<typename StringOrSymbol = Heap::StringOrSymbol>
+    void markIfNecessary(const PropertyKey &value);
+
     void grow();
     uint alloc() const;
     uint size() const;
     void setSize(uint s);
 
-    PropertyKey at(uint i);
+    PropertyKey at(uint i) const;
     void set(uint i, PropertyKey t);
 
     void mark(MarkStack *s);
@@ -205,9 +198,20 @@ struct SharedInternalClassDataPrivate<PropertyKey> {
     int refcount = 1;
 private:
     ExecutionEngine *engine;
-    Heap::MemberData *data;
+    WriteBarrier::Pointer<Heap::MemberData> data;
 };
 
+template<typename StringOrSymbol>
+void QV4::SharedInternalClassDataPrivate<PropertyKey>::markIfNecessary(const PropertyKey &value)
+{
+    QV4::WriteBarrier::markCustom(engine, [&](QV4::MarkStack *stack) {
+        if constexpr (QV4::WriteBarrier::isInsertionBarrier) {
+            if (auto s = value.asStringOrSymbol<StringOrSymbol>())
+                s->mark(stack);
+        }
+    });
+}
+
 template <typename T>
 struct SharedInternalClassData {
     using Private = SharedInternalClassDataPrivate<T>;
@@ -235,6 +239,7 @@ struct SharedInternalClassData {
     }
 
     void add(uint pos, T value) {
+        d->markIfNecessary(value);
         if (pos < d->size()) {
             Q_ASSERT(d->refcount > 1);
             // need to detach
@@ -256,6 +261,7 @@ struct SharedInternalClassData {
 
     void set(uint pos, T value) {
         Q_ASSERT(pos < d->size());
+        d->markIfNecessary(value);
         if (d->refcount > 1) {
             // need to detach
             Private *dd = new Private(*d);
@@ -288,24 +294,35 @@ struct InternalClassTransition
     int flags;
     enum {
         // range 0-0xff is reserved for attribute changes
-        NotExtensible = 0x100,
-        VTableChange = 0x200,
-        PrototypeChange = 0x201,
-        ProtoClass = 0x202,
-        Sealed = 0x203,
-        Frozen = 0x204
+        StructureChange = 0x100,
+        NotExtensible   = StructureChange | (1 << 0),
+        VTableChange    = StructureChange | (1 << 1),
+        PrototypeChange = StructureChange | (1 << 2),
+        ProtoClass      = StructureChange | (1 << 3),
+        Sealed          = StructureChange | (1 << 4),
+        Frozen          = StructureChange | (1 << 5),
+        Locked          = StructureChange | (1 << 6),
     };
 
     bool operator==(const InternalClassTransition &other) const
     { return id == other.id && flags == other.flags; }
 
     bool operator<(const InternalClassTransition &other) const
-    { return id < other.id || (id == other.id && flags < other.flags); }
+    { return flags < other.flags || (flags == other.flags && id < other.id); }
 };
 
 namespace Heap {
 
 struct InternalClass : Base {
+    enum Flag {
+        NotExtensible = 1 << 0,
+        Sealed        = 1 << 1,
+        Frozen        = 1 << 2,
+        UsedAsProto   = 1 << 3,
+        Locked        = 1 << 4,
+    };
+    enum { MaxRedundantTransitions = 255 };
+
     ExecutionEngine *engine;
     const VTable *vtable;
     quintptr protoId; // unique across the engine, gets changed whenever the proto chain changes
@@ -317,21 +334,26 @@ struct InternalClass : Base {
     SharedInternalClassData<PropertyAttributes> propertyData;
 
     typedef InternalClassTransition Transition;
-    std::vector<Transition> transitions;
+    QVarLengthArray<Transition, 1> transitions;
     InternalClassTransition &lookupOrInsertTransition(const InternalClassTransition &t);
 
     uint size;
-    bool extensible;
-    bool isSealed;
-    bool isFrozen;
-    bool isUsedAsProto;
+    quint8 numRedundantTransitions;
+    quint8 flags;
+
+    bool isExtensible() const { return !(flags & NotExtensible); }
+    bool isSealed() const { return flags & Sealed; }
+    bool isFrozen() const { return flags & Frozen; }
+    bool isUsedAsProto() const { return flags & UsedAsProto; }
+    bool isLocked() const { return flags & Locked; }
 
     void init(ExecutionEngine *engine);
     void init(InternalClass *other);
     void destroy();
 
-    Q_QML_PRIVATE_EXPORT QString keyAt(uint index) const;
+    Q_QML_EXPORT ReturnedValue keyAt(uint index) const;
     Q_REQUIRED_RESULT InternalClass *nonExtensible();
+    Q_REQUIRED_RESULT InternalClass *locked();
 
     static void addMember(QV4::Object *object, PropertyKey id, PropertyAttributes data, InternalClassEntry *entry);
     Q_REQUIRED_RESULT InternalClass *addMember(PropertyKey identifier, PropertyAttributes data, InternalClassEntry *entry = nullptr);