diff --git a/src/corelib/tools/qbytearray.cpp b/src/corelib/tools/qbytearray.cpp
index 09cc6d2f97a..e56e4fc8ff7 100644
--- a/src/corelib/tools/qbytearray.cpp
+++ b/src/corelib/tools/qbytearray.cpp
@@ -614,9 +614,9 @@ static inline char qToLower(char c)
         return c;
 }
 
-const QConstByteArrayData<1> QByteArray::shared_null = { { Q_REFCOUNT_INITIALIZE_STATIC,
+const QStaticByteArrayData<1> QByteArray::shared_null = { { Q_REFCOUNT_INITIALIZE_STATIC,
                                                            0, 0, 0, { 0 } }, { 0 } };
-const QConstByteArrayData<1> QByteArray::shared_empty = { { Q_REFCOUNT_INITIALIZE_STATIC,
+const QStaticByteArrayData<1> QByteArray::shared_empty = { { Q_REFCOUNT_INITIALIZE_STATIC,
                                                             0, 0, 0, { 0 } }, { 0 } };
 
 /*!
diff --git a/src/corelib/tools/qbytearray.h b/src/corelib/tools/qbytearray.h
index 932998cb4cb..dcaa6153f97 100644
--- a/src/corelib/tools/qbytearray.h
+++ b/src/corelib/tools/qbytearray.h
@@ -133,24 +133,24 @@ struct QByteArrayData
     inline const char *data() const { return d + sizeof(qptrdiff) + offset; }
 };
 
-template<int N> struct QConstByteArrayData
+template<int N> struct QStaticByteArrayData
 {
-    const QByteArrayData ba;
-    const char data[N + 1];
+    QByteArrayData ba;
+    char data[N + 1];
 };
 
-template<int N> struct QConstByteArrayDataPtr
+template<int N> struct QStaticByteArrayDataPtr
 {
-    const QConstByteArrayData<N> *ptr;
+    const QStaticByteArrayData<N> *ptr;
 };
 
 
 #if defined(Q_COMPILER_LAMBDA)
-#  define QByteArrayLiteral(str) ([]() -> QConstByteArrayDataPtr<sizeof(str) - 1> { \
+#  define QByteArrayLiteral(str) ([]() -> QStaticByteArrayDataPtr<sizeof(str) - 1> { \
         enum { Size = sizeof(str) - 1 }; \
-        static const QConstByteArrayData<Size> qbytearray_literal = \
+        static const QStaticByteArrayData<Size> qbytearray_literal = \
         { { Q_REFCOUNT_INITIALIZE_STATIC, Size, 0, 0, { 0 } }, str }; \
-        QConstByteArrayDataPtr<Size> holder = { &qbytearray_literal }; \
+        QStaticByteArrayDataPtr<Size> holder = { &qbytearray_literal }; \
     return holder; }())
 
 #elif defined(Q_CC_GNU)
@@ -161,9 +161,9 @@ template<int N> struct QConstByteArrayDataPtr
 #  define QByteArrayLiteral(str) \
     __extension__ ({ \
         enum { Size = sizeof(str) - 1 }; \
-        static const QConstByteArrayData<Size> qbytearray_literal = \
+        static const QStaticByteArrayData<Size> qbytearray_literal = \
         { { Q_REFCOUNT_INITIALIZE_STATIC, Size, 0, 0, { 0 } }, str }; \
-        QConstByteArrayDataPtr<Size> holder = { &qbytearray_literal }; \
+        QStaticByteArrayDataPtr<Size> holder = { &qbytearray_literal }; \
         holder; })
 #endif
 
@@ -378,16 +378,16 @@ public:
     bool isNull() const;
 
     template <int n>
-    inline QByteArray(const QConstByteArrayData<n> &dd)
+    inline QByteArray(const QStaticByteArrayData<n> &dd)
         : d(const_cast<QByteArrayData *>(&dd.str)) {}
     template <int N>
-    Q_DECL_CONSTEXPR inline QByteArray(QConstByteArrayDataPtr<N> dd)
+    Q_DECL_CONSTEXPR inline QByteArray(QStaticByteArrayDataPtr<N> dd)
         : d(const_cast<QByteArrayData *>(&dd.ptr->ba)) {}
 
 private:
     operator QNoImplicitBoolCast() const;
-    static const QConstByteArrayData<1> shared_null;
-    static const QConstByteArrayData<1> shared_empty;
+    static const QStaticByteArrayData<1> shared_null;
+    static const QStaticByteArrayData<1> shared_empty;
     Data *d;
     QByteArray(Data *dd, int /*dummy*/, int /*dummy*/) : d(dd) {}
     void realloc(int alloc);
diff --git a/src/corelib/tools/qstring.cpp b/src/corelib/tools/qstring.cpp
index 16bf26721ea..d57adbe7312 100644
--- a/src/corelib/tools/qstring.cpp
+++ b/src/corelib/tools/qstring.cpp
@@ -798,8 +798,8 @@ const QString::Null QString::null = { };
     \sa split()
 */
 
-const QConstStringData<1> QString::shared_null = { { Q_REFCOUNT_INITIALIZE_STATIC, 0, 0, false, { 0 } }, { 0 } };
-const QConstStringData<1> QString::shared_empty = { { Q_REFCOUNT_INITIALIZE_STATIC, 0, 0, false, { 0 } }, { 0 } };
+const QStaticStringData<1> QString::shared_null = { { Q_REFCOUNT_INITIALIZE_STATIC, 0, 0, false, { 0 } }, { 0 } };
+const QStaticStringData<1> QString::shared_empty = { { Q_REFCOUNT_INITIALIZE_STATIC, 0, 0, false, { 0 } }, { 0 } };
 
 int QString::grow(int size)
 {
diff --git a/src/corelib/tools/qstring.h b/src/corelib/tools/qstring.h
index ba3407e1cc3..898c80ce35f 100644
--- a/src/corelib/tools/qstring.h
+++ b/src/corelib/tools/qstring.h
@@ -90,27 +90,27 @@ struct QStringData {
     inline const ushort *data() const { return d + sizeof(qptrdiff)/sizeof(ushort) + offset; }
 };
 
-template<int N> struct QConstStringData;
-template<int N> struct QConstStringDataPtr
+template<int N> struct QStaticStringData;
+template<int N> struct QStaticStringDataPtr
 {
-    const QConstStringData<N> *ptr;
+    const QStaticStringData<N> *ptr;
 };
 
 #if defined(Q_COMPILER_UNICODE_STRINGS)
-template<int N> struct QConstStringData
+template<int N> struct QStaticStringData
 {
-    const QStringData str;
-    const char16_t data[N + 1];
+    QStringData str;
+    char16_t data[N + 1];
 };
 
 #define QT_UNICODE_LITERAL_II(str) u"" str
 
 #elif defined(Q_OS_WIN) || (defined(__SIZEOF_WCHAR_T__) && __SIZEOF_WCHAR_T__ == 2) || defined(WCHAR_MAX) && (WCHAR_MAX - 0 < 65536)
 // wchar_t is 2 bytes
-template<int N> struct QConstStringData
+template<int N> struct QStaticStringData
 {
-    const QStringData str;
-    const wchar_t data[N + 1];
+    QStringData str;
+    wchar_t data[N + 1];
 };
 
 #if defined(Q_CC_MSVC)
@@ -120,21 +120,21 @@ template<int N> struct QConstStringData
 #endif
 
 #else
-template<int N> struct QConstStringData
+template<int N> struct QStaticStringData
 {
-    const QStringData str;
-    const ushort data[N + 1];
+    QStringData str;
+    ushort data[N + 1];
 };
 #endif
 
 #if defined(QT_UNICODE_LITERAL_II)
 #  define QT_UNICODE_LITERAL(str) QT_UNICODE_LITERAL_II(str)
 # if defined(Q_COMPILER_LAMBDA)
-#  define QStringLiteral(str) ([]() -> QConstStringDataPtr<sizeof(QT_UNICODE_LITERAL(str))/2 - 1> { \
+#  define QStringLiteral(str) ([]() -> QStaticStringDataPtr<sizeof(QT_UNICODE_LITERAL(str))/2 - 1> { \
         enum { Size = sizeof(QT_UNICODE_LITERAL(str))/2 - 1 }; \
-        static const QConstStringData<Size> qstring_literal = \
+        static const QStaticStringData<Size> qstring_literal = \
         { { Q_REFCOUNT_INITIALIZE_STATIC, Size, 0, 0, { 0 } }, QT_UNICODE_LITERAL(str) }; \
-        QConstStringDataPtr<Size> holder = { &qstring_literal }; \
+        QStaticStringDataPtr<Size> holder = { &qstring_literal }; \
     return holder; }())
 
 # elif defined(Q_CC_GNU)
@@ -145,9 +145,9 @@ template<int N> struct QConstStringData
 #  define QStringLiteral(str) \
     __extension__ ({ \
         enum { Size = sizeof(QT_UNICODE_LITERAL(str))/2 - 1 }; \
-        static const QConstStringData<Size> qstring_literal = \
+        static const QStaticStringData<Size> qstring_literal = \
         { { Q_REFCOUNT_INITIALIZE_STATIC, Size, 0, 0, { 0 } }, QT_UNICODE_LITERAL(str) }; \
-        QConstStringDataPtr<Size> holder = { &qstring_literal }; \
+        QStaticStringDataPtr<Size> holder = { &qstring_literal }; \
         holder; })
 # endif
 #endif
@@ -586,9 +586,9 @@ public:
 
     QString(int size, Qt::Initialization);
     template <int n>
-    inline QString(const QConstStringData<n> &dd) : d(const_cast<QStringData *>(&dd.str)) {}
+    inline QString(const QStaticStringData<n> &dd) : d(const_cast<QStringData *>(&dd.str)) {}
     template <int N>
-    Q_DECL_CONSTEXPR inline QString(QConstStringDataPtr<N> dd) : d(const_cast<QStringData *>(&dd.ptr->str)) {}
+    Q_DECL_CONSTEXPR inline QString(QStaticStringDataPtr<N> dd) : d(const_cast<QStringData *>(&dd.ptr->str)) {}
 
 private:
 #if defined(QT_NO_CAST_FROM_ASCII) && !defined(Q_NO_DECLARED_NOT_DEFINED)
@@ -600,8 +600,8 @@ private:
     QString &operator=(const QByteArray &a);
 #endif
 
-    static const QConstStringData<1> shared_null;
-    static const QConstStringData<1> shared_empty;
+    static const QStaticStringData<1> shared_null;
+    static const QStaticStringData<1> shared_empty;
     Data *d;
     inline QString(Data *dd, int /*dummy*/) : d(dd) {}
 
diff --git a/src/corelib/tools/qstringbuilder.h b/src/corelib/tools/qstringbuilder.h
index 30b81c42f48..de6b655e95c 100644
--- a/src/corelib/tools/qstringbuilder.h
+++ b/src/corelib/tools/qstringbuilder.h
@@ -249,9 +249,9 @@ template <> struct QConcatenable<QString> : private QAbstractConcatenable
 #endif
 };
 
-template <int N> struct QConcatenable<QConstStringDataPtr<N> > : private QAbstractConcatenable
+template <int N> struct QConcatenable<QStaticStringDataPtr<N> > : private QAbstractConcatenable
 {
-    typedef QConstStringDataPtr<N> type;
+    typedef QStaticStringDataPtr<N> type;
     typedef QString ConvertTo;
     enum { ExactSize = true };
     static int size(const type &) { return N; }
@@ -363,9 +363,9 @@ template <> struct QConcatenable<QByteArray> : private QAbstractConcatenable
     }
 };
 
-template <int N> struct QConcatenable<QConstByteArrayDataPtr<N> > : private QAbstractConcatenable
+template <int N> struct QConcatenable<QStaticByteArrayDataPtr<N> > : private QAbstractConcatenable
 {
-    typedef QConstByteArrayDataPtr<N> type;
+    typedef QStaticByteArrayDataPtr<N> type;
     typedef QByteArray ConvertTo;
     enum { ExactSize = false };
     static int size(const type &) { return N; }
diff --git a/tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp b/tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp
index 89a1f8bc75d..63a26ed926a 100644
--- a/tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp
+++ b/tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp
@@ -46,6 +46,23 @@
 
 #include "simplevector.h"
 
+struct SharedNullVerifier
+{
+    SharedNullVerifier()
+    {
+        Q_ASSERT(QArrayData::shared_null.ref.isStatic());
+        Q_ASSERT(QArrayData::shared_null.ref.isShared());
+        Q_ASSERT(QArrayData::shared_null.ref.isSharable());
+    }
+};
+
+// This is meant to verify/ensure that shared_null is not being dynamically
+// initialized and stays away from the order-of-static-initialization fiasco.
+//
+// Of course, if this was to fail, qmake and the build should have crashed and
+// burned before we ever got to this point :-)
+SharedNullVerifier globalInit;
+
 class tst_QArrayData : public QObject
 {
     Q_OBJECT