Start moving QArrayData's size and data pointer to the main class

This requires that the allocation functions return two pointers: the d
pointer and the pointer to the actual data.

Ported QArrayDataPointer & SimpleVector to the inlined size & data.

For now, the size and offset members are not yet removed from
QArrayData, to let QVector, QByteArray and QString compile unmodified.

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

1 files changed, 45 insertions, 36 deletions

diff --git a/src/corelib/tools/qarraydata.h b/src/corelib/tools/qarraydata.h
index 56d61340f0..6cf0ea1cb6 100644
--- a/src/corelib/tools/qarraydata.h
+++ b/src/corelib/tools/qarraydata.h
@@ -41,11 +41,14 @@
 #ifndef QARRAYDATA_H
 #define QARRAYDATA_H
 
-#include <QtCore/qrefcount.h>
+#include <QtCore/qpair.h>
+#include <QtCore/qatomic.h>
 #include <string.h>
 
 QT_BEGIN_NAMESPACE
 
+template <class T> struct QTypedArrayData;
+
 struct Q_CORE_EXPORT QArrayData
 {
     enum ArrayOption {
@@ -169,10 +172,12 @@ struct Q_CORE_EXPORT QArrayData
 #if defined(Q_CC_GNU)
     __attribute__((__malloc__))
 #endif
-    static QArrayData *allocate(size_t objectSize, size_t alignment,
+    static void *allocate(QArrayData **pdata, size_t objectSize, size_t alignment,
             size_t capacity, ArrayOptions options = DefaultAllocationFlags) noexcept;
     Q_REQUIRED_RESULT static QArrayData *reallocateUnaligned(QArrayData *data, size_t objectSize,
             size_t newCapacity, ArrayOptions newOptions = DefaultAllocationFlags) noexcept;
+    Q_REQUIRED_RESULT static QPair<QArrayData *, void *> reallocateUnaligned(QArrayData *data, void *dataPointer,
+            size_t objectSize, size_t newCapacity, ArrayOptions newOptions = DefaultAllocationFlags) Q_DECL_NOTHROW;
     Q_REQUIRED_RESULT static QArrayData *prepareRawData(ArrayOptions options = ArrayOptions(RawDataType))
         Q_DECL_NOTHROW;
     static void deallocate(QArrayData *data, size_t objectSize,
@@ -190,6 +195,23 @@ struct Q_CORE_EXPORT QArrayData
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(QArrayData::ArrayOptions)
 
+template <class T, size_t N>
+struct QStaticArrayData
+{
+    // static arrays are of type RawDataType
+    QArrayData header;
+    T data[N];
+};
+
+// Support for returning QArrayDataPointer<T> from functions
+template <class T>
+struct QArrayDataPointerRef
+{
+    QTypedArrayData<T> *ptr;
+    T *data;
+    uint size;
+};
+
 template <class T>
 struct QTypedArrayData
     : QArrayData
@@ -282,27 +304,26 @@ struct QTypedArrayData
 
     class AlignmentDummy { QArrayData header; T data; };
 
-    Q_REQUIRED_RESULT static QTypedArrayData *allocate(size_t capacity,
+    Q_REQUIRED_RESULT static QPair<QTypedArrayData *, T *> allocate(size_t capacity,
             ArrayOptions options = DefaultAllocationFlags)
     {
         Q_STATIC_ASSERT(sizeof(QTypedArrayData) == sizeof(QArrayData));
-        void *result = QArrayData::allocate(sizeof(T),
-                    alignof(AlignmentDummy), capacity, options);
+        QArrayData *d;
+        void *result = QArrayData::allocate(&d, sizeof(T), alignof(AlignmentDummy), capacity, options);
 #if (defined(Q_CC_GNU) && Q_CC_GNU >= 407) || QT_HAS_BUILTIN(__builtin_assume_aligned)
         result = __builtin_assume_aligned(result, Q_ALIGNOF(AlignmentDummy));
 #endif
-        return static_cast<QTypedArrayData *>(result);
+        return qMakePair(static_cast<QTypedArrayData *>(d), static_cast<T *>(result));
     }
 
-    static QTypedArrayData *reallocateUnaligned(QTypedArrayData *data, size_t capacity,
+    static QPair<QTypedArrayData *, T *>
+    reallocateUnaligned(QTypedArrayData *data, T *dataPointer, size_t capacity,
             ArrayOptions options = DefaultAllocationFlags)
     {
         Q_STATIC_ASSERT(sizeof(QTypedArrayData) == sizeof(QArrayData));
-        void *result = QArrayData::reallocateUnaligned(data, sizeof(T), capacity, options);
-#if (defined(Q_CC_GNU) && Q_CC_GNU >= 407) || QT_HAS_BUILTIN(__builtin_assume_aligned)
-        result =__builtin_assume_aligned(result, Q_ALIGNOF(AlignmentDummy));
-#endif
-        return static_cast<QTypedArrayData *>(result);
+        QPair<QArrayData *, void *> pair =
+                QArrayData::reallocateUnaligned(data, dataPointer, sizeof(T), capacity, options);
+        return qMakePair(static_cast<QTypedArrayData *>(pair.first), static_cast<T *>(pair.second));
     }
 
     static void deallocate(QArrayData *data)
@@ -311,17 +332,18 @@ struct QTypedArrayData
         QArrayData::deallocate(data, sizeof(T), alignof(AlignmentDummy));
     }
 
-    static QTypedArrayData *fromRawData(const T *data, size_t n,
+    static QArrayDataPointerRef<T> fromRawData(const T *data, size_t n,
             ArrayOptions options = DefaultRawFlags)
     {
         Q_STATIC_ASSERT(sizeof(QTypedArrayData) == sizeof(QArrayData));
-        QTypedArrayData *result = static_cast<QTypedArrayData *>(prepareRawData(options));
-        if (result) {
-            Q_ASSERT(!result->isShared()); // No shared empty, please!
-
-            result->offset = reinterpret_cast<const char *>(data)
-                - reinterpret_cast<const char *>(result);
-            result->size = int(n);
+        QArrayDataPointerRef<T> result = {
+            static_cast<QTypedArrayData *>(prepareRawData(options)), const_cast<T *>(data), uint(n)
+        };
+        if (result.ptr) {
+            Q_ASSERT(!result.ptr->isShared()); // No shared empty, please!
+            result.ptr->offset = reinterpret_cast<const char *>(data)
+                - reinterpret_cast<const char *>(result.ptr);
+            result.ptr->size = int(n);
         }
         return result;
     }
@@ -345,21 +367,6 @@ struct QTypedArrayData
     }
 };
 
-template <class T, size_t N>
-struct QStaticArrayData
-{
-    // static arrays are of type RawDataType
-    QArrayData header;
-    T data[N];
-};
-
-// Support for returning QArrayDataPointer<T> from functions
-template <class T>
-struct QArrayDataPointerRef
-{
-    QTypedArrayData<T> *ptr;
-};
-
 #define Q_STATIC_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(size, offset) \
     { Q_BASIC_ATOMIC_INITIALIZER(-1), QArrayData::StaticDataFlags, size, 0, offset } \
     /**/
@@ -412,7 +419,9 @@ struct QArrayDataPointerRef
                                                                                 \
     QArrayDataPointerRef<Type> ref =                                            \
         { static_cast<QTypedArrayData<Type> *>(                                 \
-            const_cast<QArrayData *>(&literal.header)) };                       \
+            const_cast<QArrayData *>(&literal.header)),                         \
+          const_cast<Type *>(literal.data),                                     \
+          Size };                                                               \
     /**/
 
 namespace QtPrivate {