moc: move the StringData creation into qt_create_metaobjectdata()

This removes the last file-scope static variable by moving the
stringdata into a merged MetaObjectContents resulting structure. We now
only have two class-scope private static inline member template
variables. It also removes the wish to merge the strings' integer data
into the regular uint array, since effectively they are now merged.

Eventually, this should lead to moving the strings into the XxxxData
classes so moc doesn't have to collect them early. I don't have a
solution for this yet but have some ideas.

I've left the StringData class behind because I've found it useful for
QMetaObjectBuilder::toCode().

Generated code for QDeviceClosedNotifier (qtextstream.cpp), c++filt'ered:

        .section        .rodata,"a",@progbits
QDeviceClosedNotifier::qt_staticMetaObjectStaticContent<(anonymous namespace)::qt_meta_tag_ZN21QDeviceClosedNotifierE_t>:
        .long   13                              # 0xd
        .long   0                               # 0x0
        .long   0                               # 0x0
        .long   0                               # 0x0
        .long   1                               # 0x1
        .long   14                              # 0xe
        .long   0                               # 0x0
        .long   0                               # 0x0
        .long   0                               # 0x0
        .long   0                               # 0x0
        .long   0                               # 0x0
        .long   0                               # 0x0
        .long   0                               # 0x0
        .long   0                               # 0x0
        .long   1                               # 0x1
        .long   0                               # 0x0
        .long   20                              # 0x14
        .long   2                               # 0x2
        .long   10                              # 0xa
        .long   1                               # 0x1
        .long   43                              # 0x2b
        .long   0                               # 0x0
        .long   24                              # 0x18
        .long   21                              # 0x15
        .long   46                              # 0x2e
        .long   11                              # 0xb
        .long   58                              # 0x3a
        .long   0                               # 0x0
        .asciz  "QDeviceClosedNotifier\000flushStream\000"
        .zero   1

        .section        .data.rel.ro,"aw",@progbits
QDeviceClosedNotifier::qt_staticMetaObjectRelocatingContent<(anonymous namespace)::qt_meta_tag_ZN21QDeviceClosedNotifierE_t>:
        .quad   QtPrivate::QMetaTypeInterfaceWrapper<void>::metaType
        .quad   QtPrivate::QMetaTypeInterfaceWrapper<void>::metaType

        .globl  QDeviceClosedNotifier::staticMetaObject
QDeviceClosedNotifier::staticMetaObject:
        .quad   QObject::staticMetaObject
        .quad   QDeviceClosedNotifier::qt_staticMetaObjectStaticContent<(anonymous namespace)::qt_meta_tag_ZN21QDeviceClosedNotifierE_t>+88
        .quad   QDeviceClosedNotifier::qt_staticMetaObjectStaticContent<(anonymous namespace)::qt_meta_tag_ZN21QDeviceClosedNotifierE_t>
        .quad   QDeviceClosedNotifier::qt_static_metacall(QObject*, QMetaObject::Call, int, void**)
        .quad   0
        .quad   QDeviceClosedNotifier::qt_staticMetaObjectRelocatingContent<(anonymous namespace)::qt_meta_tag_ZN21QDeviceClosedNotifierE_t>
        .quad   0

Change-Id: I484c9165989ae4eaeea1fffd196c08947c083cb5
Reviewed-by: Fabian Kosmale <[email protected]>

5 files changed, 153 insertions, 128 deletions

diff --git a/src/corelib/kernel/qtmetamacros.h b/src/corelib/kernel/qtmetamacros.h
index f2838c46c77..4edfbcf8378 100644
--- a/src/corelib/kernel/qtmetamacros.h
+++ b/src/corelib/kernel/qtmetamacros.h
@@ -122,9 +122,9 @@ QT_BEGIN_NAMESPACE
     template <typename MetaObjectTagType> static constexpr inline auto          \
     qt_staticMetaObjectContent = qt_create_metaobjectdata<MetaObjectTagType>(); \
     template <typename MetaObjectTagType> static constexpr inline auto          \
-    qt_staticMetaObjectStaticContent = qt_staticMetaObjectContent<MetaObjectTagType>.data;      \
+    qt_staticMetaObjectStaticContent = qt_staticMetaObjectContent<MetaObjectTagType>.staticData;\
     template <typename MetaObjectTagType> static constexpr inline auto          \
-    qt_staticMetaObjectRelocatingContent = qt_staticMetaObjectContent<MetaObjectTagType>.metaTypes;
+    qt_staticMetaObjectRelocatingContent = qt_staticMetaObjectContent<MetaObjectTagType>.relocatingData;
 
 #define QT_OBJECT_GADGET_COMMON  \
     QT_META_OBJECT_VARS \
diff --git a/src/corelib/kernel/qtmochelpers.h b/src/corelib/kernel/qtmochelpers.h
index 7620e0341f1..a253e7a1291 100644
--- a/src/corelib/kernel/qtmochelpers.h
+++ b/src/corelib/kernel/qtmochelpers.h
@@ -34,6 +34,18 @@ static constexpr size_t MaxStringSize =
         (std::min)(size_t((std::numeric_limits<uint>::max)()),
                    size_t((std::numeric_limits<qsizetype>::max)()));
 
+template <uint UCount, uint SCount, size_t SSize, uint MCount> struct MetaObjectContents
+{
+    struct StaticContent {
+        uint data[UCount];
+        uint stringdata[SCount];
+        char strings[SSize];
+    } staticData = {};
+    struct RelocatingContent {
+        const QtPrivate::QMetaTypeInterface *metaTypes[MCount];
+    } relocatingData = {};
+};
+
 template <int Count, size_t StringSize> struct StringData
 {
     static_assert(StringSize <= MaxStringSize, "Meta Object data is too big");
@@ -192,7 +204,7 @@ template <typename... T> struct MetaTypeList
                 TryMetaTypeInterfaceForType<Unique, T>::type()...
             };
             for (const QMetaTypeInterface *mt : metaTypes)
-                result.metaTypes[metatypeoffset++] = mt;
+                result.relocatingData.metaTypes[metatypeoffset++] = mt;
         }
     }
 };
@@ -272,7 +284,7 @@ template <typename... Block> struct UintData
     template <typename Unique, typename Result> constexpr void
     copyTo(Result &result, size_t dataoffset, uint &metatypeoffset) const
     {
-        uint *ptr = result.data.data();
+        uint *ptr = result.staticData.data;
         size_t payloadoffset = dataoffset + headerSize();
         data.forEach([&](const auto &input) {
             // copy the uint data
@@ -528,17 +540,11 @@ template <typename F> struct RevisionedConstructorData :
     {}
 };
 
-
-template <uint N, uint M> struct UintAndMetaTypeData
-{
-    std::array<uint, N> data;
-    std::array<const QtPrivate::QMetaTypeInterface *, M> metaTypes;
-};
-
-template <typename ObjectType, typename Unique,
+template <typename ObjectType, typename Unique, typename Strings,
           typename Methods, typename Properties, typename Enums,
           typename Constructors = UintData<>, typename ClassInfo = detail::UintDataBlock<0, 0>>
-constexpr auto metaObjectData(uint flags, const Methods &methods, const Properties &properties,
+constexpr auto metaObjectData(uint flags, const Strings &strings,
+                              const Methods &methods, const Properties &properties,
                               const Enums &enums, const Constructors &constructors = {},
                               const ClassInfo &classInfo = {})
 {
@@ -556,54 +562,59 @@ constexpr auto metaObjectData(uint flags, const Methods &methods, const Properti
             + Constructors::dataSize()
             + ClassInfo::headerSize() // + ClassInfo::payloadSize()
             + 1;    // empty EOD
-    UintAndMetaTypeData<TotalSize, MetaTypeCount> result = {};
+
+    MetaObjectContents<TotalSize, 2 * Strings::StringCount, Strings::StringSize,
+            MetaTypeCount> result = {};
+    strings.writeTo(result.staticData.stringdata, result.staticData.strings);
+
     uint dataoffset = HeaderSize;
     uint metatypeoffset = 0;
+    uint *data = result.staticData.data;
 
-    result.data[0] = QtMocConstants::OutputRevision;
-    result.data[1] = 0;     // class name index (it's always 0)
+    data[0] = QtMocConstants::OutputRevision;
+    data[1] = 0;     // class name index (it's always 0)
 
-    result.data[2] = ClassInfo::headerSize() / 2;
-    result.data[3] = ClassInfo::headerSize() ? dataoffset : 0;
-    q20::copy_n(classInfo.header, classInfo.headerSize(), result.data.data() + dataoffset);
+    data[2] = ClassInfo::headerSize() / 2;
+    data[3] = ClassInfo::headerSize() ? dataoffset : 0;
+    q20::copy_n(classInfo.header, classInfo.headerSize(), data + dataoffset);
     dataoffset += ClassInfo::headerSize();
 
-    result.data[6] = properties.count();
-    result.data[7] = properties.count() ? dataoffset : 0;
+    data[6] = properties.count();
+    data[7] = properties.count() ? dataoffset : 0;
     properties.template copyTo<Unique>(result, dataoffset, metatypeoffset);
     dataoffset += properties.dataSize();
 
-    result.data[8] = enums.count();
-    result.data[9] = enums.count() ? dataoffset : 0;
+    data[8] = enums.count();
+    data[9] = enums.count() ? dataoffset : 0;
     enums.template copyTo<Unique>(result, dataoffset, metatypeoffset);
     dataoffset += enums.dataSize();
 
     // the meta type referring to the object itself
-    result.metaTypes[metatypeoffset++] =
+    result.relocatingData.metaTypes[metatypeoffset++] =
             QtPrivate::qTryMetaTypeInterfaceForType<void,
                 QtPrivate::TypeAndForceComplete<ObjectType, std::true_type>>();
 
-    result.data[4] = methods.count();
-    result.data[5] = methods.count() ? dataoffset : 0;
+    data[4] = methods.count();
+    data[5] = methods.count() ? dataoffset : 0;
     methods.template copyTo<Unique>(result, dataoffset, metatypeoffset);
     dataoffset += methods.dataSize();
 
-    result.data[10] = constructors.count();
-    result.data[11] = constructors.count() ? dataoffset : 0;
+    data[10] = constructors.count();
+    data[11] = constructors.count() ? dataoffset : 0;
     constructors.template copyTo<Unique>(result, dataoffset, metatypeoffset);
     dataoffset += constructors.dataSize();
 
-    result.data[12] = flags;
+    data[12] = flags;
 
     // count the number of signals
     if constexpr (Methods::count()) {
         constexpr uint MethodHeaderSize = Methods::headerSize() / Methods::count();
-        const uint *ptr = &result.data[result.data[5]];
-        const uint *end = &result.data[result.data[5] + MethodHeaderSize * Methods::count()];
+        const uint *ptr = &data[data[5]];
+        const uint *end = &data[data[5] + MethodHeaderSize * Methods::count()];
         for ( ; ptr < end; ptr += MethodHeaderSize) {
             if ((ptr[4] & QtMocConstants::MethodSignal) == 0)
                 break;
-            ++result.data[13];
+            ++data[13];
         }
     }
 
diff --git a/src/tools/moc/generator.cpp b/src/tools/moc/generator.cpp
index 54972ade90e..43583b35528 100644
--- a/src/tools/moc/generator.cpp
+++ b/src/tools/moc/generator.cpp
@@ -115,7 +115,7 @@ static inline qsizetype lengthOfEscapeSequence(const QByteArray &s, qsizetype i)
 // opening and closing quotes are NOT included (it's up to the caller).
 static void printStringWithIndentation(FILE *out, const QByteArray &s)
 {
-    static constexpr int ColumnWidth = 72;
+    static constexpr int ColumnWidth = 68;
     const qsizetype len = s.size();
     qsizetype idx = 0;
 
@@ -127,7 +127,7 @@ static void printStringWithIndentation(FILE *out, const QByteArray &s)
             const qsizetype escapeLen = lengthOfEscapeSequence(s, backSlashPos);
             spanLen = qBound(spanLen, backSlashPos + escapeLen - idx, len - idx);
         }
-        fprintf(out, "\n    \"%.*s\"", int(spanLen), s.constData() + idx);
+        fprintf(out, "\n        \"%.*s\"", int(spanLen), s.constData() + idx);
         idx += spanLen;
     } while (idx < len);
 }
@@ -271,24 +271,7 @@ void Generator::generateCode()
             qualifiedClassNameIdentifier.constData());
 
 //
-// Build the strings using QtMocHelpers::stringData
-//
-
-    fprintf(out, "static constexpr auto qt_meta_stringdata_%s = QtMocHelpers::stringData(",
-            qualifiedClassNameIdentifier.constData());
-    {
-        char comma = 0;
-        for (const QByteArray &str : strings) {
-            if (comma)
-                fputc(comma, out);
-            printStringWithIndentation(out, str);
-            comma = ',';
-        }
-    }
-    fprintf(out, "\n);\n\n");
-
-//
-// build the data array
+// build the strings, data, and metatype arrays
 //
 
     // We define a method inside the context of the class or namespace we're
@@ -297,10 +280,15 @@ void Generator::generateCode()
     // types).
     fprintf(out, "template <> constexpr inline auto %s::qt_create_metaobjectdata<qt_meta_tag_%s_t>()\n"
                  "{\n"
-                 "    namespace QMC = QtMocConstants;\n"
-                 "    QtMocHelpers::UintData qt_methods {\n",
+                 "    namespace QMC = QtMocConstants;\n",
             cdef->qualified.constData(), qualifiedClassNameIdentifier.constData());
 
+    fprintf(out, "    QtMocHelpers::StringRefStorage qt_stringData {");
+    addStrings(strings);
+    fprintf(out, "\n    };\n\n");
+
+    fprintf(out, "    QtMocHelpers::UintData qt_methods {\n");
+
     // Build signals array first, otherwise the signal indices would be wrong
     addFunctions(cdef->signalList, "Signal");
     addFunctions(cdef->slotList, "Slot");
@@ -344,7 +332,7 @@ void Generator::generateCode()
         QByteArray tagType = "qt_meta_tag_" + qualifiedClassNameIdentifier +  "_t";
         if (requireCompleteness)
             tagType = "QtMocHelpers::ForceCompleteMetaTypes<" + tagType + '>';
-        fprintf(out, "    return QtMocHelpers::metaObjectData<%s, %s>(%s,\n"
+        fprintf(out, "    return QtMocHelpers::metaObjectData<%s, %s>(%s, qt_stringData,\n"
                      "            qt_methods, qt_properties, qt_enums%s);\n"
                      "}\n",
                 ownType, tagType.constData(), metaObjectFlags, uintDataParams);
@@ -360,9 +348,9 @@ void Generator::generateCode()
 static constexpr auto qt_staticMetaObjectContent%s =
     %s::qt_create_metaobjectdata<qt_meta_tag%s_t>();
 static constexpr auto qt_staticMetaObjectStaticContent%s =
-    qt_staticMetaObjectContent%s.data;
+    qt_staticMetaObjectContent%s.staticData;
 static constexpr auto qt_staticMetaObjectRelocatingContent%s =
-    qt_staticMetaObjectContent%s.metaTypes;
+    qt_staticMetaObjectContent%s.relocatingData;
 
 )",
                 n, cdef->qualified.constData(), n,
@@ -459,9 +447,9 @@ static constexpr auto qt_staticMetaObjectRelocatingContent%s =
         fprintf(out, "    QtPrivate::MetaObjectForType<%s>::value,\n", purestSuperClass.constData());
     else
         fprintf(out, "    nullptr,\n");
-    fprintf(out, "    qt_meta_stringdata_%s.offsetsAndSizes,\n"
-            "    qt_staticMetaObjectStaticContent%s.data(),\n",
-            qualifiedClassNameIdentifier.constData(),
+    fprintf(out, "    qt_staticMetaObjectStaticContent%s.stringdata,\n"
+            "    qt_staticMetaObjectStaticContent%s.data,\n",
+            metaVarNameSuffix.constData(),
             metaVarNameSuffix.constData());
     if (hasStaticMetaCall)
         fprintf(out, "    qt_static_metacall,\n");
@@ -473,7 +461,7 @@ static constexpr auto qt_staticMetaObjectRelocatingContent%s =
     else
         fprintf(out, "    qt_meta_extradata_%s,\n", qualifiedClassNameIdentifier.constData());
 
-    fprintf(out, "    qt_staticMetaObjectRelocatingContent%s.data(),\n",
+    fprintf(out, "    qt_staticMetaObjectRelocatingContent%s.metaTypes,\n",
             metaVarNameSuffix.constData());
 
     fprintf(out, "    nullptr\n} };\n\n");
@@ -497,7 +485,7 @@ static constexpr auto qt_staticMetaObjectRelocatingContent%s =
 //
     fprintf(out, "\nvoid *%s::qt_metacast(const char *_clname)\n{\n", cdef->qualified.constData());
     fprintf(out, "    if (!_clname) return nullptr;\n");
-    fprintf(out, "    if (!strcmp(_clname, qt_meta_stringdata_%s.stringdata0))\n"
+    fprintf(out, "    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_%s_t>.strings))\n"
                   "        return static_cast<void*>(this);\n",
             qualifiedClassNameIdentifier.constData());
 
@@ -617,6 +605,17 @@ void Generator::registerByteArrayVector(const QList<QByteArray> &list)
         strreg(ba);
 }
 
+void Generator::addStrings(const QByteArrayList &strings)
+{
+    char comma = 0;
+    for (const QByteArray &str : strings) {
+        if (comma)
+            fputc(comma, out);
+        printStringWithIndentation(out, str);
+        comma = ',';
+    }
+}
+
 void Generator::addFunctions(const QList<FunctionDef> &list, const char *functype)
 {
     for (const FunctionDef &f : list) {
diff --git a/src/tools/moc/generator.h b/src/tools/moc/generator.h
index f70c8746e81..281ea092cde 100644
--- a/src/tools/moc/generator.h
+++ b/src/tools/moc/generator.h
@@ -28,6 +28,7 @@ private:
     void registerClassInfoStrings();
     void registerFunctionStrings(const QList<FunctionDef> &list);
     void registerByteArrayVector(const QList<QByteArray> &list);
+    void addStrings(const QByteArrayList &strings);
     void addProperties();
     void addEnums();
     void addFunctions(const QList<FunctionDef> &list, const char *functype);
diff --git a/tests/auto/tools/mochelpers/tst_mochelpers.cpp b/tests/auto/tools/mochelpers/tst_mochelpers.cpp
index 1f4ee16a805..022263e7d81 100644
--- a/tests/auto/tools/mochelpers/tst_mochelpers.cpp
+++ b/tests/auto/tools/mochelpers/tst_mochelpers.cpp
@@ -86,12 +86,14 @@ void tst_MocHelpers::classinfoData()
     }
 }
 
-template <size_t N> static void checkClassInfos(const std::array<uint, N> &data)
+constexpr QtMocHelpers::StringRefStorage dummyStringData {"tst_QtMocHelpers"};
+
+template <size_t N> static void checkClassInfos(const uint (&data)[N])
 {
     QCOMPARE(data[2], 2U);
     QCOMPARE_GE(data[3], 14U);
 
-    const uint *classinfos = data.data() + data[3];
+    const uint *classinfos = data + data[3];
     QCOMPARE(classinfos[0], 1U);
     QCOMPARE(classinfos[1], 2U);
     QCOMPARE(classinfos[2], 3U);
@@ -100,22 +102,22 @@ template <size_t N> static void checkClassInfos(const std::array<uint, N> &data)
 
 void tst_MocHelpers::classinfoDataGroup()
 {
-    constexpr auto data = QtMocHelpers::metaObjectData<void, void>(0,
+    constexpr auto data = QtMocHelpers::metaObjectData<void, void>(0, dummyStringData,
             QtMocHelpers::UintData{}, QtMocHelpers::UintData{},
             QtMocHelpers::UintData{}, QtMocHelpers::UintData{},
             QtMocHelpers::ClassInfos({{1, 2}, {3, 4}}));
-    checkClassInfos(data.data);
+    checkClassInfos(data.staticData.data);
 }
 
 template <typename MetaTypeHolder> constexpr auto getMetaTypes(MetaTypeHolder)
 {
-    QtMocHelpers::UintAndMetaTypeData<0, MetaTypeHolder::count()> r = {};
+    QtMocHelpers::MetaObjectContents<1, 1, 1, MetaTypeHolder::count()> r = {};
     uint metatypeoffset = 0;
     MetaTypeHolder::template copyTo<void>(r, metatypeoffset);
 
     std::array<QMetaType, MetaTypeHolder::count()> result;
     for (uint i = 0; i < result.size(); ++i)
-        result[i] = QMetaType(r.metaTypes[i]);
+        result[i] = QMetaType(r.relocatingData.metaTypes[i]);
 
     return result;
 }
@@ -227,14 +229,14 @@ template <typename Data> void testUintData(const Data &data)
     QCOMPARE(data.payloadSize(), payloadSize);
 }
 
-template <size_t N> static void
-checkEnums(const std::array<uint, N> &data, const QtPrivate::QMetaTypeInterface *const *metaTypes)
+static void
+checkEnums(const uint *data, const QtPrivate::QMetaTypeInterface *const *metaTypes)
 {
     using namespace QtMocConstants;
     QCOMPARE(data[8], 4U);
     QCOMPARE_NE(data[9], 0U);
 
-    const uint *header = data.data() + data[9];
+    const uint *header = data + data[9];
     metaTypes += data[6];          // property count
 
     // E1:
@@ -243,7 +245,7 @@ checkEnums(const std::array<uint, N> &data, const QtPrivate::QMetaTypeInterface
     QCOMPARE(header[0 + 2], 0U);
     QCOMPARE(header[0 + 3], 1U);
     QCOMPARE_GE(header[0 + 4], 14U);
-    const uint *payload = data.data() + header[0 + 4];
+    const uint *payload = data + header[0 + 4];
     QCOMPARE(payload[0], 3U);
     QCOMPARE(payload[1], uint(E1::AnEnumValue));
     QCOMPARE(QMetaType(metaTypes[0]), QMetaType::fromType<E1>());
@@ -254,7 +256,7 @@ checkEnums(const std::array<uint, N> &data, const QtPrivate::QMetaTypeInterface
     QCOMPARE(header[5 + 2], EnumIsFlag | EnumIsScoped | EnumIs64Bit);
     QCOMPARE(header[5 + 3], 2U);
     QCOMPARE_GE(header[5 + 4], 14U);
-    payload = data.data() + header[5 + 4];
+    payload = data + header[5 + 4];
     QCOMPARE(payload[0], 6U);
     QCOMPARE(payload[1], uint(E3::V));
     QCOMPARE(payload[2], 8U);
@@ -269,7 +271,7 @@ checkEnums(const std::array<uint, N> &data, const QtPrivate::QMetaTypeInterface
     QCOMPARE(header[10 + 2], EnumIsFlag | EnumIsScoped);
     QCOMPARE(header[10 + 3], 2U);
     QCOMPARE_GE(header[10 + 4], 14U);
-    payload = data.data() + header[10 + 4];
+    payload = data + header[10 + 4];
     QCOMPARE(payload[0], 7U);
     QCOMPARE(payload[1], uint(E2::V0));
     QCOMPARE(payload[2], 10U);
@@ -282,7 +284,7 @@ checkEnums(const std::array<uint, N> &data, const QtPrivate::QMetaTypeInterface
     QCOMPARE(header[15 + 2], EnumIsFlag);
     QCOMPARE(header[15 + 3], 1U);
     QCOMPARE_GE(header[15 + 4], 14U);
-    payload = data.data() + header[15 + 4];
+    payload = data + header[15 + 4];
     QCOMPARE(payload[0], 3U);
     QCOMPARE(payload[1], uint(E1::AnEnumValue));
     QCOMPARE(QMetaType(metaTypes[3]), QMetaType::fromType<QFlags<E1>>());
@@ -302,9 +304,9 @@ void tst_MocHelpers::enumUintGroup()
     };
     testUintData(enums);
 
-    constexpr auto data = QtMocHelpers::metaObjectData<void, void>(0,
+    constexpr auto data = QtMocHelpers::metaObjectData<void, void>(0, dummyStringData,
             QtMocHelpers::UintData{}, QtMocHelpers::UintData{}, enums);
-    checkEnums(data.data, data.metaTypes.data());
+    checkEnums(data.staticData.data, data.relocatingData.metaTypes);
 }
 
 void tst_MocHelpers::propertyUintData()
@@ -333,13 +335,13 @@ void tst_MocHelpers::propertyUintData()
     }
 }
 
-template <size_t N> static void
-checkProperties(const std::array<uint, N> &data, const QtPrivate::QMetaTypeInterface *const *metaTypes)
+static void
+checkProperties(const uint *data, const QtPrivate::QMetaTypeInterface *const *metaTypes)
 {
     QCOMPARE(data[6], 3U);
     QCOMPARE_NE(data[7], 0U);
 
-    const uint *header = data.data() + data[7];
+    const uint *header = data + data[7];
 
     QCOMPARE(header[0 + 0], 3U);
     QCOMPARE(header[0 + 1], uint(QMetaType::Int));
@@ -373,8 +375,9 @@ void tst_MocHelpers::propertyUintGroup()
     };
     testUintData(properties);
 
-    constexpr auto data = QtMocHelpers::metaObjectData<void, void>(0, QtMocHelpers::UintData{}, properties, QtMocHelpers::UintData{});
-    checkProperties(data.data, data.metaTypes.data());
+    constexpr auto data = QtMocHelpers::metaObjectData<void, void>(0, dummyStringData,
+            QtMocHelpers::UintData{}, properties, QtMocHelpers::UintData{});
+    checkProperties(data.staticData.data, data.relocatingData.metaTypes);
 }
 
 void tst_MocHelpers::methodUintData()
@@ -431,14 +434,14 @@ void tst_MocHelpers::methodUintData()
     }
 }
 
-template <size_t N> static void
-checkMethods(const std::array<uint, N> &data, const QtPrivate::QMetaTypeInterface *const *metaTypes)
+static void
+checkMethods(const uint *data, const QtPrivate::QMetaTypeInterface *const *metaTypes)
 {
     using namespace QtMocConstants;
     QCOMPARE(data[4], 3U);
     QCOMPARE_NE(data[5], 0U);
 
-    const uint *header = data.data() + data[5];
+    const uint *header = data + data[5];
     uint initialMetaTypeOffset = data[6] + data[8] + 1; // propcount + enumcount + object
 
     // signals: void signal()
@@ -448,7 +451,7 @@ checkMethods(const std::array<uint, N> &data, const QtPrivate::QMetaTypeInterfac
     QCOMPARE(header[3], 2U);
     QCOMPARE(header[4], AccessPublic | MethodSignal | MethodRevisioned);
     QCOMPARE(header[5], initialMetaTypeOffset);
-    const uint *payload = data.data() + header[2];
+    const uint *payload = data + header[2];
     QCOMPARE(payload[-1], 0x0509U);
     QCOMPARE(payload[0], uint(QMetaType::Void));
     QCOMPARE(QMetaType(metaTypes[header[5]]), QMetaType::fromType<void>());
@@ -461,7 +464,7 @@ checkMethods(const std::array<uint, N> &data, const QtPrivate::QMetaTypeInterfac
     QCOMPARE(header[3], 2U);
     QCOMPARE(header[4], AccessPublic | MethodSignal);
     QCOMPARE(header[5], initialMetaTypeOffset + 1);
-    payload = data.data() + header[2];
+    payload = data + header[2];
     QCOMPARE(payload[0], uint(QMetaType::Void));
     QCOMPARE(payload[1], 0x80000000U | 4);  // not a builtin type
     QCOMPARE(payload[2], 0x80000000U | 5);
@@ -479,7 +482,7 @@ checkMethods(const std::array<uint, N> &data, const QtPrivate::QMetaTypeInterfac
     QCOMPARE(header[3], 2U);
     QCOMPARE(header[4], AccessPublic | MethodSlot | MethodIsConst);
     QCOMPARE(header[5], initialMetaTypeOffset + 4);
-    payload = data.data() + header[2];
+    payload = data + header[2];
     QCOMPARE(payload[0], uint(QMetaType::Bool));
     QCOMPARE(payload[1], 0x80000000U | 10); // not a builtin type
     QCOMPARE(payload[2], 11U);
@@ -505,9 +508,9 @@ void tst_MocHelpers::methodUintGroup()
     testUintData(methods);
 
     constexpr auto data =
-            QtMocHelpers::metaObjectData<tst_MocHelpers, tst_MocHelpers>(0, methods, QtMocHelpers::UintData{},
-                                                                         QtMocHelpers::UintData{});
-    checkMethods(data.data, data.metaTypes.data());
+            QtMocHelpers::metaObjectData<tst_MocHelpers, tst_MocHelpers>(0, dummyStringData,
+                    methods, QtMocHelpers::UintData{}, QtMocHelpers::UintData{});
+    checkMethods(data.staticData.data, data.relocatingData.metaTypes);
 }
 
 void tst_MocHelpers::constructorUintData()
@@ -543,14 +546,14 @@ void tst_MocHelpers::constructorUintData()
     }
 }
 
-template <size_t N> static void
-checkConstructors(const std::array<uint, N> &data, const QtPrivate::QMetaTypeInterface *const *metaTypes)
+static void
+checkConstructors(const uint *data, const QtPrivate::QMetaTypeInterface *const *metaTypes)
 {
     using namespace QtMocConstants;
     QCOMPARE(data[10], 3U);
     QCOMPARE_NE(data[11], 0U);
 
-    const uint *header = data.data() + data[11];
+    const uint *header = data + data[11];
 
     // Constructor(QObject *)
     QCOMPARE(header[0], 0U);
@@ -559,7 +562,7 @@ checkConstructors(const std::array<uint, N> &data, const QtPrivate::QMetaTypeInt
     QCOMPARE(header[3], 1U);
     QCOMPARE(header[4], AccessPublic | MethodConstructor);
     QCOMPARE_GT(header[5], 0U);
-    const uint *payload = data.data() + header[2];
+    const uint *payload = data + header[2];
     QCOMPARE(payload[0], uint(QMetaType::UnknownType));
     QCOMPARE(payload[1], uint(QMetaType::QObjectStar));
     QCOMPARE(QMetaType(metaTypes[header[5]]), QMetaType::fromType<QObject *>());
@@ -572,7 +575,7 @@ checkConstructors(const std::array<uint, N> &data, const QtPrivate::QMetaTypeInt
     QCOMPARE(header[3], 1U);
     QCOMPARE(header[4], AccessPublic | MethodConstructor | MethodCloned);
     QCOMPARE_GT(header[5], 0U);
-    payload = data.data() + header[2];
+    payload = data + header[2];
     QCOMPARE(payload[0], uint(QMetaType::UnknownType));
     // no metatype stored for this constructor
 
@@ -584,7 +587,7 @@ checkConstructors(const std::array<uint, N> &data, const QtPrivate::QMetaTypeInt
     QCOMPARE(header[3], 1U);
     QCOMPARE(header[4], AccessPublic | MethodConstructor);
     QCOMPARE_GT(header[5], 0U);
-    payload = data.data() + header[2];
+    payload = data + header[2];
     QCOMPARE(payload[0], uint(QMetaType::UnknownType));
     QCOMPARE(payload[1], uint(QMetaType::QString));
     QCOMPARE(QMetaType(metaTypes[header[5]]), QMetaType::fromType<QString>());
@@ -607,15 +610,15 @@ void tst_MocHelpers::constructorUintGroup()
     };
     testUintData(constructors);
 
-    constexpr auto data = QtMocHelpers::metaObjectData<void, void>(0,
+    constexpr auto data = QtMocHelpers::metaObjectData<void, void>(0, dummyStringData,
             QtMocHelpers::UintData{}, QtMocHelpers::UintData{},
             QtMocHelpers::UintData{}, constructors);
-    checkConstructors(data.data, data.metaTypes.data());
+    checkConstructors(data.staticData.data, data.relocatingData.metaTypes);
 }
 
 struct Gadget {};
 
-template <size_t N> static void checkUintArrayGeneric(const std::array<uint, N> &data, uint flags = 0)
+template <size_t N> static void checkUintArrayGeneric(const uint (&data)[N], uint flags = 0)
 {
     using namespace QtMocConstants;
     QCOMPARE(data[0], uint(OutputRevision));
@@ -634,29 +637,33 @@ template <size_t N> static void checkUintArrayGeneric(const std::array<uint, N>
 void tst_MocHelpers::emptyUintArray()
 {
     using namespace QtMocConstants;
-    constexpr auto data = QtMocHelpers::metaObjectData<Gadget, void>(MetaObjectFlag{},
+    constexpr auto mo = QtMocHelpers::metaObjectData<Gadget, void>(MetaObjectFlag{}, dummyStringData,
             QtMocHelpers::UintData{}, QtMocHelpers::UintData{}, QtMocHelpers::UintData{});
     QTest::setThrowOnFail(true);
-    checkUintArrayGeneric(data.data, MetaObjectFlag{});
+    checkUintArrayGeneric(mo.staticData.data, MetaObjectFlag{});
     QTest::setThrowOnFail(false);
 
+    const uint *data = mo.staticData.data;
+    auto &metaTypes = mo.relocatingData.metaTypes;
+
     // check it says nothing was added
-    QCOMPARE(data.data[2], 0U);     // classinfos
-    QCOMPARE(data.data[4], 0U);     // methods
-    QCOMPARE(data.data[6], 0U);     // properties
-    QCOMPARE(data.data[8], 0U);     // enums
-    QCOMPARE(data.data[10], 0U);    // constructors
-    QCOMPARE(data.data[13], 0U);    // signals
-
-    QCOMPARE(data.metaTypes.size(), 1U);
-    QMetaType self(data.metaTypes[data.data[6] + data.data[8]]);
+    QCOMPARE(data[2], 0U);      // classinfos
+    QCOMPARE(data[4], 0U);      // methods
+    QCOMPARE(data[6], 0U);      // properties
+    QCOMPARE(data[8], 0U);      // enums
+    QCOMPARE(data[10], 0U);     // constructors
+    QCOMPARE(data[13], 0U);     // signals
+
+    QCOMPARE(std::size(metaTypes), 1U);
+    QMetaType self(metaTypes[data[6] + data[8]]);
     QCOMPARE(self, QMetaType::fromType<Gadget>());
 }
 
 void tst_MocHelpers::uintArrayNoMethods()
 {
     using namespace QtMocConstants;
-    constexpr auto data = QtMocHelpers::metaObjectData<Gadget, void>(PropertyAccessInStaticMetaCall,
+    constexpr auto mo = QtMocHelpers::metaObjectData<Gadget, Gadget>(PropertyAccessInStaticMetaCall,
+            dummyStringData,
             QtMocHelpers::UintData{},
             QtMocHelpers::UintData{
                 QtMocHelpers::PropertyData<int>(3, QMetaType::Int, 0x3, 13, 0x101),
@@ -671,16 +678,19 @@ void tst_MocHelpers::uintArrayNoMethods()
                 QtMocHelpers::EnumData<QFlags<E1>>(11, 1, EnumIsFlag).add({ { 3, E1::AnEnumValue } }),
             }, QtMocHelpers::UintData{}, QtMocHelpers::ClassInfos({{1, 2}, {3, 4}}));
 
+    auto &data = mo.staticData.data;
+    auto &metaTypes = mo.relocatingData.metaTypes;
+
     QTest::setThrowOnFail(true);
-    checkUintArrayGeneric(data.data, PropertyAccessInStaticMetaCall);
-    checkClassInfos(data.data);
-    checkProperties(data.data, data.metaTypes.data());
-    checkEnums(data.data, data.metaTypes.data());
+    checkUintArrayGeneric(data, PropertyAccessInStaticMetaCall);
+    checkClassInfos(data);
+    checkProperties(data, metaTypes);
+    checkEnums(data, metaTypes);
     QTest::setThrowOnFail(false);
-    QCOMPARE(data.data[4], 0U);     // methods
-    QCOMPARE(data.data[10], 0U);    // constructors
-    QCOMPARE(data.data[13], 0U);    // signals
-    QMetaType self(data.metaTypes[data.data[6] + data.data[8]]);
+    QCOMPARE(data[4], 0U);      // methods
+    QCOMPARE(data[10], 0U);     // constructors
+    QCOMPARE(data[13], 0U);     // signals
+    QMetaType self(metaTypes[data[6] + data[8]]);
     QCOMPARE(self, QMetaType::fromType<Gadget>());
 }
 
@@ -689,7 +699,8 @@ void tst_MocHelpers::uintArray()
     using Dummy = QString;
     using QtMocHelpers::NoType;
     using namespace QtMocConstants;
-    constexpr auto data = QtMocHelpers::metaObjectData<void, tst_MocHelpers>(PropertyAccessInStaticMetaCall,
+    constexpr auto mo = QtMocHelpers::metaObjectData<void, void>(PropertyAccessInStaticMetaCall,
+            dummyStringData,
             QtMocHelpers::UintData{
                 QtMocHelpers::RevisionedSignalData<void()>(1, 2, QtMocConstants::AccessPublic, 0x509,
                     QMetaType::Void, {{ }}
@@ -725,14 +736,17 @@ void tst_MocHelpers::uintArray()
                 )
             }, QtMocHelpers::ClassInfos({{1, 2}, {3, 4}}));
 
+    auto &data = mo.staticData.data;
+    auto &metaTypes = mo.relocatingData.metaTypes;
+
     QTest::setThrowOnFail(true);
-    checkUintArrayGeneric(data.data, PropertyAccessInStaticMetaCall);
-    checkClassInfos(data.data);
-    checkProperties(data.data, data.metaTypes.data());
-    checkEnums(data.data, data.metaTypes.data());
-    checkMethods(data.data, data.metaTypes.data());
-    checkConstructors(data.data, data.metaTypes.data());
-    QMetaType self(data.metaTypes[data.data[6] + data.data[8]]);
+    checkUintArrayGeneric(data, PropertyAccessInStaticMetaCall);
+    checkClassInfos(data);
+    checkProperties(data, metaTypes);
+    checkEnums(data, metaTypes);
+    checkMethods(data, metaTypes);
+    checkConstructors(data, metaTypes);
+    QMetaType self(metaTypes[data[6] + data[8]]);
     QCOMPARE(self, QMetaType::fromType<void>());
 }