1 files changed, 51 insertions, 25 deletions

diff --git a/src/qml/qml/qqmldata_p.h b/src/qml/qml/qqmldata_p.h
index 7ccab5746d..e271598c2d 100644
--- a/src/qml/qml/qqmldata_p.h
+++ b/src/qml/qml/qqmldata_p.h
@@ -53,7 +53,7 @@
 
 #include <private/qtqmlglobal_p.h>
 #include <private/qobject_p.h>
-
+#include <private/qqmlpropertyindex_p.h>
 #include <private/qv4value_p.h>
 #include <private/qv4persistent_p.h>
 #include <qjsengine.h>
@@ -63,7 +63,6 @@ QT_BEGIN_NAMESPACE
 template <class Key, class T> class QHash;
 class QQmlEngine;
 class QQmlGuardImpl;
-class QQmlCompiledData;
 class QQmlAbstractBinding;
 class QQmlBoundSignal;
 class QQmlContext;
@@ -72,6 +71,13 @@ class QQmlContextData;
 class QQmlNotifier;
 class QQmlDataExtended;
 class QQmlNotifierEndpoint;
+
+namespace QV4 {
+namespace CompiledData {
+struct CompilationUnit;
+}
+}
+
 // This class is structured in such a way, that simply zero'ing it is the
 // default state for elemental object allocations.  This is crucial in the
 // workings of the QQmlInstruction::CreateSimpleObject instruction.
@@ -123,14 +129,16 @@ public:
     quint32 parentFrozen:1;
     quint32 dummy:21;
 
-    // When bindingBitsSize < 32, we store the binding bit flags inside
-    // bindingBitsValue. When we need more than 32 bits, we allocated
+    // When bindingBitsSize < sizeof(ptr), we store the binding bit flags inside
+    // bindingBitsValue. When we need more than sizeof(ptr) bits, we allocated
     // sufficient space and use bindingBits to point to it.
     int bindingBitsSize;
+    typedef quintptr BindingBitsType;
     union {
-        quint32 *bindingBits;
-        quint32 bindingBitsValue;
+        BindingBitsType *bindingBits;
+        BindingBitsType bindingBitsValue;
     };
+    enum { MaxInlineBits = sizeof(BindingBitsType) * 8 };
 
     struct NotifyList {
         quint64 connectionMask;
@@ -168,7 +176,7 @@ public:
     void clearBindingBit(int);
     void setBindingBit(QObject *obj, int);
 
-    inline bool hasPendingBindingBit(int) const;
+    inline bool hasPendingBindingBit(int index) const;
     void setPendingBindingBit(QObject *obj, int);
     void clearPendingBindingBit(int);
 
@@ -179,10 +187,10 @@ public:
 
     struct DeferredData {
         unsigned int deferredIdx;
-        QQmlCompiledData *compiledData;//Not always the same as the other compiledData
+        QV4::CompiledData::CompilationUnit *compilationUnit;//Not always the same as the other compilation unit
         QQmlContextData *context;//Could be either context or outerContext
     };
-    QQmlCompiledData *compiledData;
+    QV4::CompiledData::CompilationUnit *compilationUnit;
     DeferredData *deferredData;
 
     QV4::WeakValue jsWrapper;
@@ -199,8 +207,7 @@ public:
         } else if (priv->declarativeData) {
             return static_cast<QQmlData *>(priv->declarativeData);
         } else if (create) {
-            priv->declarativeData = new QQmlData;
-            return static_cast<QQmlData *>(priv->declarativeData);
+            return createQQmlData(priv);
         } else {
             return 0;
         }
@@ -221,15 +228,36 @@ public:
     static void markAsDeleted(QObject *);
     static void setQueuedForDeletion(QObject *);
 
-    static inline void flushPendingBinding(QObject *, int coreIndex);
+    static inline void flushPendingBinding(QObject *, QQmlPropertyIndex propertyIndex);
 
-    static QQmlPropertyCache *ensurePropertyCache(QJSEngine *engine, QObject *object);
+    static QQmlPropertyCache *ensurePropertyCache(QJSEngine *engine, QObject *object)
+    {
+        Q_ASSERT(engine);
+        QQmlData *ddata = QQmlData::get(object, /*create*/true);
+        if (Q_LIKELY(ddata->propertyCache))
+            return ddata->propertyCache;
+        return createPropertyCache(engine, object);
+    }
 
 private:
     // For attachedProperties
     mutable QQmlDataExtended *extendedData;
 
-    void flushPendingBindingImpl(int coreIndex);
+    Q_NEVER_INLINE static QQmlData *createQQmlData(QObjectPrivate *priv);
+    Q_NEVER_INLINE static QQmlPropertyCache *createPropertyCache(QJSEngine *engine, QObject *object);
+
+    void flushPendingBindingImpl(QQmlPropertyIndex index);
+
+    Q_ALWAYS_INLINE bool hasBitSet(int bit) const
+    {
+        if (bindingBitsSize <= bit)
+            return false;
+
+        if (bindingBitsSize == MaxInlineBits)
+            return bindingBitsValue & (BindingBitsType(1) << bit);
+        else
+            return bindingBits[bit / MaxInlineBits] & (BindingBitsType(1) << (bit % MaxInlineBits));
+    }
 };
 
 bool QQmlData::wasDeleted(QObject *object)
@@ -275,27 +303,25 @@ inline bool QQmlData::signalHasEndpoint(int index) const
 
 bool QQmlData::hasBindingBit(int coreIndex) const
 {
-    int bit = coreIndex * 2;
+    Q_ASSERT(coreIndex >= 0);
+    Q_ASSERT(coreIndex <= 0xffff);
 
-    return bindingBitsSize > bit &&
-           ((bindingBitsSize == 32) ? (bindingBitsValue & (1 << bit)) :
-                                      (bindingBits[bit / 32] & (1 << (bit % 32))));
+    return hasBitSet(coreIndex * 2);
 }
 
 bool QQmlData::hasPendingBindingBit(int coreIndex) const
 {
-    int bit = coreIndex * 2 + 1;
+    Q_ASSERT(coreIndex >= 0);
+    Q_ASSERT(coreIndex <= 0xffff);
 
-    return bindingBitsSize > bit &&
-           ((bindingBitsSize == 32) ? (bindingBitsValue & (1 << bit)) :
-                                      (bindingBits[bit / 32] & (1 << (bit % 32))));
+    return hasBitSet(coreIndex * 2 + 1);
 }
 
-void QQmlData::flushPendingBinding(QObject *o, int coreIndex)
+void QQmlData::flushPendingBinding(QObject *o, QQmlPropertyIndex propertyIndex)
 {
     QQmlData *data = QQmlData::get(o, false);
-    if (data && data->hasPendingBindingBit(coreIndex))
-        data->flushPendingBindingImpl(coreIndex);
+    if (data && data->hasPendingBindingBit(propertyIndex.coreIndex()))
+        data->flushPendingBindingImpl(propertyIndex);
 }
 
 QT_END_NAMESPACE