diff options
Diffstat (limited to 'src/qml/jsruntime/qv4lookup_p.h')
| -rw-r--r-- | src/qml/jsruntime/qv4lookup_p.h | 184 |
1 files changed, 124 insertions, 60 deletions
diff --git a/src/qml/jsruntime/qv4lookup_p.h b/src/qml/jsruntime/qv4lookup_p.h index aab6b66597..258184cd37 100644 --- a/src/qml/jsruntime/qv4lookup_p.h +++ b/src/qml/jsruntime/qv4lookup_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 QV4LOOKUP_H #define QV4LOOKUP_H @@ -50,18 +14,28 @@ // We mean it. // -#include "qv4global_p.h" -#include "qv4runtime_p.h" #include "qv4engine_p.h" -#include "qv4context_p.h" #include "qv4object_p.h" #include "qv4internalclass_p.h" +#include "qv4qmlcontext_p.h" +#include <private/qqmltypewrapper_p.h> +#include <private/qv4mm_p.h> QT_BEGIN_NAMESPACE namespace QV4 { -struct Q_QML_PRIVATE_EXPORT Lookup { +namespace Heap { + struct QObjectMethod; +} + +template <typename T, int PhantomTag> +using HeapObjectWrapper = WriteBarrier::HeapObjectWrapper<T, PhantomTag>; + +// Note: We cannot hide the copy ctor and assignment operator of this class because it needs to +// be trivially copyable. But you should never ever copy it. There are refcounted members +// in there. +struct Q_QML_EXPORT Lookup { union { ReturnedValue (*getter)(Lookup *l, ExecutionEngine *engine, const Value &object); ReturnedValue (*globalGetter)(Lookup *l, ExecutionEngine *engine); @@ -78,7 +52,7 @@ struct Q_QML_PRIVATE_EXPORT Lookup { quintptr unused2; } markDef; struct { - Heap::InternalClass *ic; + HeapObjectWrapper<Heap::InternalClass, 0> ic; quintptr unused; uint index; uint offset; @@ -89,8 +63,8 @@ struct Q_QML_PRIVATE_EXPORT Lookup { const Value *data; } protoLookup; struct { - Heap::InternalClass *ic; - Heap::InternalClass *ic2; + HeapObjectWrapper<Heap::InternalClass, 1> ic; + HeapObjectWrapper<Heap::InternalClass, 2> ic2; uint offset; uint offset2; } objectLookupTwoClasses; @@ -103,12 +77,12 @@ struct Q_QML_PRIVATE_EXPORT Lookup { struct { // Make sure the next two values are in sync with protoLookup quintptr protoId; - Heap::Object *proto; + HeapObjectWrapper<Heap::Object, 3> proto; const Value *data; quintptr type; } primitiveLookup; struct { - Heap::InternalClass *newClass; + HeapObjectWrapper<Heap::InternalClass, 4> newClass; quintptr protoId; uint offset; uint unused; @@ -120,13 +94,25 @@ struct Q_QML_PRIVATE_EXPORT Lookup { uint unused; } indexedLookup; struct { - Heap::InternalClass *ic; - Heap::InternalClass *qmlTypeIc; // only used when lookup goes through QQmlTypeWrapper - QQmlPropertyCache *propertyCache; - QQmlPropertyData *propertyData; + HeapObjectWrapper<Heap::InternalClass, 5> ic; + HeapObjectWrapper<Heap::InternalClass, 6> qmlTypeIc; // only used when lookup goes through QQmlTypeWrapper + const QQmlPropertyCache *propertyCache; + const QQmlPropertyData *propertyData; } qobjectLookup; struct { - Heap::InternalClass *ic; + HeapObjectWrapper<Heap::InternalClass, 7> ic; + HeapObjectWrapper<Heap::QObjectMethod, 8> method; + const QQmlPropertyCache *propertyCache; + const QQmlPropertyData *propertyData; + } qobjectMethodLookup; + struct { + quintptr isConstant; // This is a bool, encoded as 0 or 1. Both values are ignored by gc + quintptr metaObject; // a (const QMetaObject* & 1) or nullptr + int coreIndex; + int notifyIndex; + } qobjectFallbackLookup; + struct { + HeapObjectWrapper<Heap::InternalClass, 9> ic; quintptr metaObject; // a (const QMetaObject* & 1) or nullptr const QtPrivate::QMetaTypeInterface *metaType; // cannot use QMetaType; class must be trivial quint16 coreIndex; @@ -139,7 +125,7 @@ struct Q_QML_PRIVATE_EXPORT Lookup { int scriptIndex; } qmlContextScriptLookup; struct { - Heap::Base *singletonObject; + HeapObjectWrapper<Heap::Base, 10> singletonObject; quintptr unused2; QV4::ReturnedValue singletonValue; } qmlContextSingletonLookup; @@ -156,20 +142,24 @@ struct Q_QML_PRIVATE_EXPORT Lookup { ReturnedValue (*getterTrampoline)(Lookup *l, ExecutionEngine *engine); } qmlContextGlobalLookup; struct { - Heap::Object *qmlTypeWrapper; + HeapObjectWrapper<Heap::Base, 11> qmlTypeWrapper; quintptr unused2; } qmlTypeLookup; struct { - Heap::InternalClass *ic; + HeapObjectWrapper<Heap::InternalClass, 12> ic; quintptr unused; ReturnedValue encodedEnumValue; + const QtPrivate::QMetaTypeInterface *metaType; } qmlEnumValueLookup; struct { - Heap::InternalClass *ic; - Heap::Object *qmlScopedEnumWrapper; + HeapObjectWrapper<Heap::InternalClass, 13> ic; + HeapObjectWrapper<Heap::Object, 14> qmlScopedEnumWrapper; } qmlScopedEnumWrapperLookup; }; - uint nameIndex; + + uint nameIndex: 28; // Same number of bits we store in the compilation unit for name indices + uint forCall: 1; // Whether we are looking up a value in order to call it right away + uint reserved: 3; ReturnedValue resolveGetter(ExecutionEngine *engine, const Object *object); ReturnedValue resolvePrimitiveGetter(ExecutionEngine *engine, const Value &object); @@ -179,6 +169,7 @@ struct Q_QML_PRIVATE_EXPORT Lookup { static ReturnedValue getterGeneric(Lookup *l, ExecutionEngine *engine, const Value &object); static ReturnedValue getterTwoClasses(Lookup *l, ExecutionEngine *engine, const Value &object); static ReturnedValue getterFallback(Lookup *l, ExecutionEngine *engine, const Value &object); + static ReturnedValue getterFallbackAsVariant(Lookup *l, ExecutionEngine *engine, const Value &object); static ReturnedValue getter0MemberData(Lookup *l, ExecutionEngine *engine, const Value &object); static ReturnedValue getter0Inline(Lookup *l, ExecutionEngine *engine, const Value &object); @@ -191,6 +182,9 @@ struct Q_QML_PRIVATE_EXPORT Lookup { static ReturnedValue getterProtoAccessor(Lookup *l, ExecutionEngine *engine, const Value &object); static ReturnedValue getterProtoAccessorTwoClasses(Lookup *l, ExecutionEngine *engine, const Value &object); static ReturnedValue getterIndexed(Lookup *l, ExecutionEngine *engine, const Value &object); + static ReturnedValue getterQObject(Lookup *l, ExecutionEngine *engine, const Value &object); + static ReturnedValue getterQObjectAsVariant(Lookup *l, ExecutionEngine *engine, const Value &object); + static ReturnedValue getterQObjectMethod(Lookup *l, ExecutionEngine *engine, const Value &object); static ReturnedValue primitiveGetterProto(Lookup *l, ExecutionEngine *engine, const Value &object); static ReturnedValue primitiveGetterAccessor(Lookup *l, ExecutionEngine *engine, const Value &object); @@ -204,10 +198,13 @@ struct Q_QML_PRIVATE_EXPORT Lookup { static bool setterGeneric(Lookup *l, ExecutionEngine *engine, Value &object, const Value &value); Q_NEVER_INLINE static bool setterTwoClasses(Lookup *l, ExecutionEngine *engine, Value &object, const Value &value); static bool setterFallback(Lookup *l, ExecutionEngine *engine, Value &object, const Value &value); + static bool setterFallbackAsVariant(Lookup *l, ExecutionEngine *engine, Value &object, const Value &value); static bool setter0MemberData(Lookup *l, ExecutionEngine *engine, Value &object, const Value &value); static bool setter0Inline(Lookup *l, ExecutionEngine *engine, Value &object, const Value &value); static bool setter0setter0(Lookup *l, ExecutionEngine *engine, Value &object, const Value &value); static bool setterInsert(Lookup *l, ExecutionEngine *engine, Value &object, const Value &value); + static bool setterQObject(Lookup *l, ExecutionEngine *engine, Value &object, const Value &value); + static bool setterQObjectAsVariant(Lookup *l, ExecutionEngine *engine, Value &object, const Value &value); static bool arrayLengthSetter(Lookup *l, ExecutionEngine *engine, Value &object, const Value &value); void markObjects(MarkStack *stack) { @@ -217,8 +214,24 @@ struct Q_QML_PRIVATE_EXPORT Lookup { markDef.h2->mark(stack); } - void clear() { - memset(&markDef, 0, sizeof(markDef)); + void releasePropertyCache() + { + if (getter == getterQObject + || getter == QQmlTypeWrapper::lookupSingletonProperty + || setter == setterQObject + || qmlContextPropertyGetter == QQmlContextWrapper::lookupScopeObjectProperty + || qmlContextPropertyGetter == QQmlContextWrapper::lookupContextObjectProperty + || getter == getterQObjectAsVariant + || setter == setterQObjectAsVariant) { + if (const QQmlPropertyCache *pc = qobjectLookup.propertyCache) + pc->release(); + } else if (getter == getterQObjectMethod + || getter == QQmlTypeWrapper::lookupSingletonMethod + || qmlContextPropertyGetter == QQmlContextWrapper::lookupScopeObjectMethod + || qmlContextPropertyGetter == QQmlContextWrapper::lookupContextObjectMethod) { + if (const QQmlPropertyCache *pc = qobjectMethodLookup.propertyCache) + pc->release(); + } } }; @@ -227,6 +240,57 @@ Q_STATIC_ASSERT(std::is_standard_layout<Lookup>::value); // across 32-bit and 64-bit (matters when cross-compiling). Q_STATIC_ASSERT(offsetof(Lookup, getter) == 0); +inline void setupQObjectLookup( + Lookup *lookup, const QQmlData *ddata, const QQmlPropertyData *propertyData) +{ + lookup->releasePropertyCache(); + Q_ASSERT(!ddata->propertyCache.isNull()); + lookup->qobjectLookup.propertyCache = ddata->propertyCache.data(); + lookup->qobjectLookup.propertyCache->addref(); + lookup->qobjectLookup.propertyData = propertyData; +} + +inline void setupQObjectLookup( + Lookup *lookup, const QQmlData *ddata, const QQmlPropertyData *propertyData, + const Object *self) +{ + setupQObjectLookup(lookup, ddata, propertyData); + lookup->qobjectLookup.ic.set(self->engine(), self->internalClass()); +} + + +inline void setupQObjectLookup( + Lookup *lookup, const QQmlData *ddata, const QQmlPropertyData *propertyData, + const Object *self, const Object *qmlType) +{ + setupQObjectLookup(lookup, ddata, propertyData, self); + lookup->qobjectLookup.qmlTypeIc.set(self->engine(), qmlType->internalClass()); +} + +// template parameter is an ugly trick to avoid pulling in the QObjectMethod header here +template<typename QObjectMethod = Heap::QObjectMethod> +inline void setupQObjectMethodLookup( + Lookup *lookup, const QQmlData *ddata, const QQmlPropertyData *propertyData, + const Object *self, QObjectMethod *method) +{ + lookup->releasePropertyCache(); + Q_ASSERT(!ddata->propertyCache.isNull()); + auto engine = self->engine(); + lookup->qobjectMethodLookup.method.set(engine, method); + lookup->qobjectMethodLookup.ic.set(engine, self->internalClass()); + lookup->qobjectMethodLookup.propertyCache = ddata->propertyCache.data(); + lookup->qobjectMethodLookup.propertyCache->addref(); + lookup->qobjectMethodLookup.propertyData = propertyData; +} + +inline bool qualifiesForMethodLookup(const QQmlPropertyData *propertyData) +{ + return propertyData->isFunction() + && !propertyData->isSignalHandler() // TODO: Optimize SignalHandler, too + && !propertyData->isVMEFunction() // Handled by QObjectLookup + && !propertyData->isVarProperty(); +} + } QT_END_NAMESPACE |