Extract header qtypes.h from qglobal.h

And move the related checks from qglobal.cpp to qtypes.cpp.

This requires removing the unnecessary include statement for qglobal.h
from qprocessordetection.h, that now needs to be included in qtypes.h.

Task-number: QTBUG-99313
Change-Id: Ifd72b956326909be82c162f37854cad0878010e2
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>

6 files changed, 497 insertions, 453 deletions

diff --git a/src/corelib/CMakeLists.txt b/src/corelib/CMakeLists.txt
index 6b18d0e506..575bb1b0f4 100644
--- a/src/corelib/CMakeLists.txt
+++ b/src/corelib/CMakeLists.txt
@@ -79,6 +79,7 @@ qt_internal_add_module(Core
         global/qtranslation.h
         global/qtversionchecks.h
         global/qtypeinfo.h
+        global/qtypes.cpp global/qtypes.h
         global/qvolatile_p.h
         global/q20algorithm.h
         global/q20functional.h
diff --git a/src/corelib/global/qglobal.cpp b/src/corelib/global/qglobal.cpp
index 2852beaaab..d8d618e92b 100644
--- a/src/corelib/global/qglobal.cpp
+++ b/src/corelib/global/qglobal.cpp
@@ -19,7 +19,6 @@
 #include "qnativeinterface_p.h"
 
 #include <stdlib.h>
-#include <limits.h>
 #include <stdarg.h>
 #include <string.h>
 
@@ -88,62 +87,6 @@ QT_BEGIN_NAMESPACE
 
 using namespace Qt::StringLiterals;
 
-// Statically check assumptions about the environment we're running
-// in. The idea here is to error or warn if otherwise implicit Qt
-// assumptions are not fulfilled on new hardware or compilers
-// (if this list becomes too long, consider factoring into a separate file)
-static_assert(UCHAR_MAX == 255, "Qt assumes that char is 8 bits");
-static_assert(sizeof(int) == 4, "Qt assumes that int is 32 bits");
-static_assert(QT_POINTER_SIZE == sizeof(void *), "QT_POINTER_SIZE defined incorrectly");
-static_assert(sizeof(float) == 4, "Qt assumes that float is 32 bits");
-static_assert(sizeof(char16_t) == 2, "Qt assumes that char16_t is 16 bits");
-static_assert(sizeof(char32_t) == 4, "Qt assumes that char32_t is 32 bits");
-#if defined(Q_OS_WIN)
-static_assert(sizeof(wchar_t) == sizeof(char16_t));
-#endif
-static_assert(std::numeric_limits<int>::radix == 2,
-                  "Qt assumes binary integers");
-static_assert((std::numeric_limits<int>::max() + std::numeric_limits<int>::lowest()) == -1,
-                  "Qt assumes two's complement integers");
-static_assert(sizeof(wchar_t) == sizeof(char32_t) || sizeof(wchar_t) == sizeof(char16_t),
-              "Qt assumes wchar_t is compatible with either char32_t or char16_t");
-
-// While we'd like to check for __STDC_IEC_559__, as per ISO/IEC 9899:2011
-// Annex F (C11, normative for C++11), there are a few corner cases regarding
-// denormals where GHS compiler is relying hardware behavior that is not IEC
-// 559 compliant. So split the check in several subchecks.
-
-// On GHS the compiler reports std::numeric_limits<float>::is_iec559 as false.
-// This is all right according to our needs.
-#if !defined(Q_CC_GHS)
-static_assert(std::numeric_limits<float>::is_iec559,
-                  "Qt assumes IEEE 754 floating point");
-#endif
-
-// Technically, presence of NaN and infinities are implied from the above check,
-// but double checking our environment doesn't hurt...
-static_assert(std::numeric_limits<float>::has_infinity &&
-                  std::numeric_limits<float>::has_quiet_NaN,
-                  "Qt assumes IEEE 754 floating point");
-
-// is_iec559 checks for ISO/IEC/IEEE 60559:2011 (aka IEEE 754-2008) compliance,
-// but that allows for a non-binary radix. We need to recheck that.
-// Note how __STDC_IEC_559__ would instead check for IEC 60559:1989, aka
-// ANSI/IEEE 754−1985, which specifically implies binary floating point numbers.
-static_assert(std::numeric_limits<float>::radix == 2,
-                  "Qt assumes binary IEEE 754 floating point");
-
-// not required by the definition of size_t, but we depend on this
-static_assert(sizeof(size_t) == sizeof(void *), "size_t and a pointer don't have the same size");
-static_assert(sizeof(size_t) == sizeof(qsizetype)); // implied by the definition
-static_assert((std::is_same<qsizetype, qptrdiff>::value));
-
-// Check that our own typedefs are not broken.
-static_assert(sizeof(qint8) == 1, "Internal error, qint8 is misdefined");
-static_assert(sizeof(qint16)== 2, "Internal error, qint16 is misdefined");
-static_assert(sizeof(qint32) == 4, "Internal error, qint32 is misdefined");
-static_assert(sizeof(qint64) == 8, "Internal error, qint64 is misdefined");
-
 /*!
     \class QFlag
     \inmodule QtCore
@@ -773,265 +716,6 @@ static_assert(sizeof(qint64) == 8, "Internal error, qint64 is misdefined");
 */
 
 /*!
-    \typedef qreal
-    \relates <QtGlobal>
-
-    Typedef for \c double unless Qt is configured with the
-    \c{-qreal float} option.
-*/
-
-/*! \typedef uchar
-    \relates <QtGlobal>
-
-    Convenience typedef for \c{unsigned char}.
-*/
-
-/*! \typedef ushort
-    \relates <QtGlobal>
-
-    Convenience typedef for \c{unsigned short}.
-*/
-
-/*! \typedef uint
-    \relates <QtGlobal>
-
-    Convenience typedef for \c{unsigned int}.
-*/
-
-/*! \typedef ulong
-    \relates <QtGlobal>
-
-    Convenience typedef for \c{unsigned long}.
-*/
-
-/*! \typedef qint8
-    \relates <QtGlobal>
-
-    Typedef for \c{signed char}. This type is guaranteed to be 8-bit
-    on all platforms supported by Qt.
-*/
-
-/*!
-    \typedef quint8
-    \relates <QtGlobal>
-
-    Typedef for \c{unsigned char}. This type is guaranteed to
-    be 8-bit on all platforms supported by Qt.
-*/
-
-/*! \typedef qint16
-    \relates <QtGlobal>
-
-    Typedef for \c{signed short}. This type is guaranteed to be
-    16-bit on all platforms supported by Qt.
-*/
-
-/*!
-    \typedef quint16
-    \relates <QtGlobal>
-
-    Typedef for \c{unsigned short}. This type is guaranteed to
-    be 16-bit on all platforms supported by Qt.
-*/
-
-/*! \typedef qint32
-    \relates <QtGlobal>
-
-    Typedef for \c{signed int}. This type is guaranteed to be 32-bit
-    on all platforms supported by Qt.
-*/
-
-/*!
-    \typedef quint32
-    \relates <QtGlobal>
-
-    Typedef for \c{unsigned int}. This type is guaranteed to
-    be 32-bit on all platforms supported by Qt.
-*/
-
-/*! \typedef qint64
-    \relates <QtGlobal>
-
-    Typedef for \c{long long int}. This type is guaranteed to be 64-bit
-    on all platforms supported by Qt.
-
-    Literals of this type can be created using the Q_INT64_C() macro:
-
-    \snippet code/src_corelib_global_qglobal.cpp 5
-
-    \sa Q_INT64_C(), quint64, qlonglong
-*/
-
-/*!
-    \typedef quint64
-    \relates <QtGlobal>
-
-    Typedef for \c{unsigned long long int}. This type is guaranteed to
-    be 64-bit on all platforms supported by Qt.
-
-    Literals of this type can be created using the Q_UINT64_C()
-    macro:
-
-    \snippet code/src_corelib_global_qglobal.cpp 6
-
-    \sa Q_UINT64_C(), qint64, qulonglong
-*/
-
-/*!
-    \typedef qintptr
-    \relates <QtGlobal>
-
-    Integral type for representing pointers in a signed integer (useful for
-    hashing, etc.).
-
-    Typedef for either qint32 or qint64. This type is guaranteed to
-    be the same size as a pointer on all platforms supported by Qt. On
-    a system with 32-bit pointers, qintptr is a typedef for qint32;
-    on a system with 64-bit pointers, qintptr is a typedef for
-    qint64.
-
-    Note that qintptr is signed. Use quintptr for unsigned values.
-
-    In order to print values of this type by using formatted-output
-    facilities such as \c{printf()}, qDebug(), QString::asprintf() and
-    so on, you can use the \c{PRIdQINTPTR} and \c{PRIiQINTPTR}
-    macros as format specifiers. They will both print the value as a
-    base 10 number.
-
-    \code
-    qintptr p = 123;
-    printf("The pointer is %" PRIdQINTPTR "\n", p);
-    \endcode
-
-    \sa qptrdiff, qint32, qint64
-*/
-
-/*!
-    \macro PRIdQINTPTR
-    \macro PRIiQINTPTR
-    \since 6.2
-    \relates <QtGlobal>
-
-    See qintptr.
-*/
-
-/*!
-    \typedef quintptr
-    \relates <QtGlobal>
-
-    Integral type for representing pointers in an unsigned integer (useful for
-    hashing, etc.).
-
-    Typedef for either quint32 or quint64. This type is guaranteed to
-    be the same size as a pointer on all platforms supported by Qt. On
-    a system with 32-bit pointers, quintptr is a typedef for quint32;
-    on a system with 64-bit pointers, quintptr is a typedef for
-    quint64.
-
-    Note that quintptr is unsigned. Use qptrdiff for signed values.
-
-    In order to print values of this type by using formatted-output
-    facilities such as \c{printf()}, qDebug(), QString::asprintf() and
-    so on, you can use the following macros as format specifiers:
-
-    \list
-    \li \c{PRIuQUINTPTR}: prints the value as a base 10 number.
-    \li \c{PRIoQUINTPTR}: prints the value as a base 8 number.
-    \li \c{PRIxQUINTPTR}: prints the value as a base 16 number, using lowercase \c{a-f} letters.
-    \li \c{PRIXQUINTPTR}: prints the value as a base 16 number, using uppercase \c{A-F} letters.
-    \endlist
-
-    \code
-    quintptr p = 123u;
-    printf("The pointer value is 0x%" PRIXQUINTPTR "\n", p);
-    \endcode
-
-    \sa qptrdiff, quint32, quint64
-*/
-
-/*!
-    \macro PRIoQUINTPTR
-    \macro PRIuQUINTPTR
-    \macro PRIxQUINTPTR
-    \macro PRIXQUINTPTR
-    \since 6.2
-    \relates <QtGlobal>
-
-    See quintptr.
-*/
-
-/*!
-    \typedef qptrdiff
-    \relates <QtGlobal>
-
-    Integral type for representing pointer differences.
-
-    Typedef for either qint32 or qint64. This type is guaranteed to be
-    the same size as a pointer on all platforms supported by Qt. On a
-    system with 32-bit pointers, quintptr is a typedef for quint32; on
-    a system with 64-bit pointers, quintptr is a typedef for quint64.
-
-    Note that qptrdiff is signed. Use quintptr for unsigned values.
-
-    In order to print values of this type by using formatted-output
-    facilities such as \c{printf()}, qDebug(), QString::asprintf() and
-    so on, you can use the \c{PRIdQPTRDIFF} and \c{PRIiQPTRDIFF}
-    macros as format specifiers. They will both print the value as a
-    base 10 number.
-
-    \code
-    qptrdiff d = 123;
-    printf("The difference is %" PRIdQPTRDIFF "\n", d);
-    \endcode
-
-    \sa quintptr, qint32, qint64
-*/
-
-/*!
-    \macro PRIdQPTRDIFF
-    \macro PRIiQPTRDIFF
-    \since 6.2
-    \relates <QtGlobal>
-
-    See qptrdiff.
-*/
-
-/*!
-    \typedef qsizetype
-    \relates <QtGlobal>
-    \since 5.10
-
-    Integral type providing Posix' \c ssize_t for all platforms.
-
-    This type is guaranteed to be the same size as a \c size_t on all
-    platforms supported by Qt.
-
-    Note that qsizetype is signed. Use \c size_t for unsigned values.
-
-    In order to print values of this type by using formatted-output
-    facilities such as \c{printf()}, qDebug(), QString::asprintf() and
-    so on, you can use the \c{PRIdQSIZETYPE} and \c{PRIiQSIZETYPE}
-    macros as format specifiers. They will both print the value as a
-    base 10 number.
-
-    \code
-    qsizetype s = 123;
-    printf("The size is %" PRIdQSIZETYPE "\n", s);
-    \endcode
-
-    \sa qptrdiff
-*/
-
-/*!
-    \macro PRIdQSIZETYPE
-    \macro PRIiQSIZETYPE
-    \since 6.2
-    \relates <QtGlobal>
-
-    See qsizetype.
-*/
-
-/*!
     \enum QtMsgType
     \relates <QtGlobal>
 
diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h
index b475c9cc64..82c6e5e037 100644
--- a/src/corelib/global/qglobal.h
+++ b/src/corelib/global/qglobal.h
@@ -7,7 +7,6 @@
 
 #if 0
 #pragma qt_class(QtGlobal)
-#pragma qt_class(QIntegerForSize)
 #endif
 
 #ifdef __cplusplus
@@ -98,6 +97,7 @@ inline void qt_noop(void) {}
 #include <QtCore/qcompilerdetection.h>
 
 #include <QtCore/qassert.h>
+#include <QtCore/qtypes.h>
 
 #if defined (__ELF__)
 #  define Q_OF_ELF
@@ -115,73 +115,6 @@ inline void qt_noop(void) {}
 QT_BEGIN_NAMESPACE
 
 /*
-   Size-dependent types (architechture-dependent byte order)
-
-   Make sure to update QMetaType when changing these typedefs
-*/
-
-typedef signed char qint8;         /* 8 bit signed */
-typedef unsigned char quint8;      /* 8 bit unsigned */
-typedef short qint16;              /* 16 bit signed */
-typedef unsigned short quint16;    /* 16 bit unsigned */
-typedef int qint32;                /* 32 bit signed */
-typedef unsigned int quint32;      /* 32 bit unsigned */
-// Unlike LL / ULL in C++, for historical reasons, we force the
-// result to be of the requested type.
-#ifdef __cplusplus
-#  define Q_INT64_C(c) static_cast<long long>(c ## LL)     /* signed 64 bit constant */
-#  define Q_UINT64_C(c) static_cast<unsigned long long>(c ## ULL) /* unsigned 64 bit constant */
-#else
-#  define Q_INT64_C(c) ((long long)(c ## LL))               /* signed 64 bit constant */
-#  define Q_UINT64_C(c) ((unsigned long long)(c ## ULL))    /* unsigned 64 bit constant */
-#endif
-typedef long long qint64;           /* 64 bit signed */
-typedef unsigned long long quint64; /* 64 bit unsigned */
-
-typedef qint64 qlonglong;
-typedef quint64 qulonglong;
-
-#ifndef __cplusplus
-// In C++ mode, we define below using QIntegerForSize template
-Q_STATIC_ASSERT_X(sizeof(ptrdiff_t) == sizeof(size_t), "Weird ptrdiff_t and size_t definitions");
-typedef ptrdiff_t qptrdiff;
-typedef ptrdiff_t qsizetype;
-typedef ptrdiff_t qintptr;
-typedef size_t quintptr;
-
-#define PRIdQPTRDIFF "td"
-#define PRIiQPTRDIFF "ti"
-
-#define PRIdQSIZETYPE "td"
-#define PRIiQSIZETYPE "ti"
-
-#define PRIdQINTPTR "td"
-#define PRIiQINTPTR "ti"
-
-#define PRIuQUINTPTR "zu"
-#define PRIoQUINTPTR "zo"
-#define PRIxQUINTPTR "zx"
-#define PRIXQUINTPTR "zX"
-#endif
-
-/*
-   Useful type definitions for Qt
-*/
-
-QT_BEGIN_INCLUDE_NAMESPACE
-typedef unsigned char uchar;
-typedef unsigned short ushort;
-typedef unsigned int uint;
-typedef unsigned long ulong;
-QT_END_INCLUDE_NAMESPACE
-
-#if defined(QT_COORD_TYPE)
-typedef QT_COORD_TYPE qreal;
-#else
-typedef double qreal;
-#endif
-
-/*
    Some classes do not permit copies to be made of an object. These
    classes contains a private copy constructor and assignment
    operator to disable copying (the compiler gives an error message).
@@ -297,72 +230,6 @@ Q_CORE_EXPORT Q_DECL_CONST_FUNCTION const char *qVersion(void) Q_DECL_NOEXCEPT;
 # define Q_DESTRUCTOR_FUNCTION(AFUNC) Q_DESTRUCTOR_FUNCTION0(AFUNC)
 #endif
 
-/*
-  quintptr and qptrdiff is guaranteed to be the same size as a pointer, i.e.
-
-      sizeof(void *) == sizeof(quintptr)
-      && sizeof(void *) == sizeof(qptrdiff)
-
-  size_t and qsizetype are not guaranteed to be the same size as a pointer, but
-  they usually are. We actually check for that in qglobal.cpp.
-*/
-template <int> struct QIntegerForSize;
-template <>    struct QIntegerForSize<1> { typedef quint8  Unsigned; typedef qint8  Signed; };
-template <>    struct QIntegerForSize<2> { typedef quint16 Unsigned; typedef qint16 Signed; };
-template <>    struct QIntegerForSize<4> { typedef quint32 Unsigned; typedef qint32 Signed; };
-template <>    struct QIntegerForSize<8> { typedef quint64 Unsigned; typedef qint64 Signed; };
-#if defined(Q_CC_GNU) && defined(__SIZEOF_INT128__)
-template <>    struct QIntegerForSize<16> { __extension__ typedef unsigned __int128 Unsigned; __extension__ typedef __int128 Signed; };
-#endif
-template <class T> struct QIntegerForSizeof: QIntegerForSize<sizeof(T)> { };
-typedef QIntegerForSize<Q_PROCESSOR_WORDSIZE>::Signed qregisterint;
-typedef QIntegerForSize<Q_PROCESSOR_WORDSIZE>::Unsigned qregisteruint;
-typedef QIntegerForSizeof<void *>::Unsigned quintptr;
-typedef QIntegerForSizeof<void *>::Signed qptrdiff;
-typedef qptrdiff qintptr;
-using qsizetype = QIntegerForSizeof<std::size_t>::Signed;
-
-// These custom definitions are necessary as we're not defining our
-// datatypes in terms of the language ones, but in terms of integer
-// types that have the sime size. For instance, on a 32-bit platform,
-// qptrdiff is int, while ptrdiff_t may be aliased to long; therefore
-// using %td to print a qptrdiff would be wrong (and raise -Wformat
-// warnings), although both int and long have same bit size on that
-// platform.
-//
-// We know that sizeof(size_t) == sizeof(void *) == sizeof(qptrdiff).
-#if SIZE_MAX == 4294967295ULL
-#define PRIuQUINTPTR "u"
-#define PRIoQUINTPTR "o"
-#define PRIxQUINTPTR "x"
-#define PRIXQUINTPTR "X"
-
-#define PRIdQPTRDIFF "d"
-#define PRIiQPTRDIFF "i"
-
-#define PRIdQINTPTR "d"
-#define PRIiQINTPTR "i"
-
-#define PRIdQSIZETYPE "d"
-#define PRIiQSIZETYPE "i"
-#elif SIZE_MAX == 18446744073709551615ULL
-#define PRIuQUINTPTR "llu"
-#define PRIoQUINTPTR "llo"
-#define PRIxQUINTPTR "llx"
-#define PRIXQUINTPTR "llX"
-
-#define PRIdQPTRDIFF "lld"
-#define PRIiQPTRDIFF "lli"
-
-#define PRIdQINTPTR "lld"
-#define PRIiQINTPTR "lli"
-
-#define PRIdQSIZETYPE "lld"
-#define PRIiQSIZETYPE "lli"
-#else
-#error Unsupported platform (unknown value for SIZE_MAX)
-#endif
-
 /* moc compats (signals/slots) */
 #ifndef QT_MOC_COMPAT
 #  define QT_MOC_COMPAT
diff --git a/src/corelib/global/qprocessordetection.h b/src/corelib/global/qprocessordetection.h
index 417b6cb508..e643192d53 100644
--- a/src/corelib/global/qprocessordetection.h
+++ b/src/corelib/global/qprocessordetection.h
@@ -2,9 +2,6 @@
 // Copyright (C) 2016 Intel Corporation.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
-#ifndef QGLOBAL_H
-# include <QtCore/qglobal.h>
-#endif
 
 #if 0
 #pragma qt_sync_skip_header_check
diff --git a/src/corelib/global/qtypes.cpp b/src/corelib/global/qtypes.cpp
new file mode 100644
index 0000000000..8441b9806b
--- /dev/null
+++ b/src/corelib/global/qtypes.cpp
@@ -0,0 +1,332 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// Copyright (C) 2022 Intel Corporation.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include "qtypes.h"
+
+#include <QtCore/qcompilerdetection.h>
+#include <QtCore/qsystemdetection.h>
+#include <QtCore/qprocessordetection.h>
+
+#include <climits>
+#include <limits>
+#include <type_traits>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+    \typedef qreal
+    \relates <QtTypes>
+
+    Typedef for \c double unless Qt is configured with the
+    \c{-qreal float} option.
+*/
+
+/*! \typedef uchar
+    \relates <QtTypes>
+
+    Convenience typedef for \c{unsigned char}.
+*/
+
+/*! \typedef ushort
+    \relates <QtTypes>
+
+    Convenience typedef for \c{unsigned short}.
+*/
+
+/*! \typedef uint
+    \relates <QtTypes>
+
+    Convenience typedef for \c{unsigned int}.
+*/
+
+/*! \typedef ulong
+    \relates <QtTypes>
+
+    Convenience typedef for \c{unsigned long}.
+*/
+
+/*! \typedef qint8
+    \relates <QtTypes>
+
+    Typedef for \c{signed char}. This type is guaranteed to be 8-bit
+    on all platforms supported by Qt.
+*/
+
+/*!
+    \typedef quint8
+    \relates <QtTypes>
+
+    Typedef for \c{unsigned char}. This type is guaranteed to
+    be 8-bit on all platforms supported by Qt.
+*/
+
+/*! \typedef qint16
+    \relates <QtTypes>
+
+    Typedef for \c{signed short}. This type is guaranteed to be
+    16-bit on all platforms supported by Qt.
+*/
+
+/*!
+    \typedef quint16
+    \relates <QtTypes>
+
+    Typedef for \c{unsigned short}. This type is guaranteed to
+    be 16-bit on all platforms supported by Qt.
+*/
+
+/*! \typedef qint32
+    \relates <QtTypes>
+
+    Typedef for \c{signed int}. This type is guaranteed to be 32-bit
+    on all platforms supported by Qt.
+*/
+
+/*!
+    \typedef quint32
+    \relates <QtTypes>
+
+    Typedef for \c{unsigned int}. This type is guaranteed to
+    be 32-bit on all platforms supported by Qt.
+*/
+
+/*! \typedef qint64
+    \relates <QtTypes>
+
+    Typedef for \c{long long int}. This type is guaranteed to be 64-bit
+    on all platforms supported by Qt.
+
+    Literals of this type can be created using the Q_INT64_C() macro:
+
+    \snippet code/src_corelib_global_qglobal.cpp 5
+
+    \sa Q_INT64_C(), quint64, qlonglong
+*/
+
+/*!
+    \typedef quint64
+    \relates <QtTypes>
+
+    Typedef for \c{unsigned long long int}. This type is guaranteed to
+    be 64-bit on all platforms supported by Qt.
+
+    Literals of this type can be created using the Q_UINT64_C()
+    macro:
+
+    \snippet code/src_corelib_global_qglobal.cpp 6
+
+    \sa Q_UINT64_C(), qint64, qulonglong
+*/
+
+/*!
+    \typedef qintptr
+    \relates <QtTypes>
+
+    Integral type for representing pointers in a signed integer (useful for
+    hashing, etc.).
+
+    Typedef for either qint32 or qint64. This type is guaranteed to
+    be the same size as a pointer on all platforms supported by Qt. On
+    a system with 32-bit pointers, qintptr is a typedef for qint32;
+    on a system with 64-bit pointers, qintptr is a typedef for
+    qint64.
+
+    Note that qintptr is signed. Use quintptr for unsigned values.
+
+    In order to print values of this type by using formatted-output
+    facilities such as \c{printf()}, qDebug(), QString::asprintf() and
+    so on, you can use the \c{PRIdQINTPTR} and \c{PRIiQINTPTR}
+    macros as format specifiers. They will both print the value as a
+    base 10 number.
+
+    \code
+    qintptr p = 123;
+    printf("The pointer is %" PRIdQINTPTR "\n", p);
+    \endcode
+
+    \sa qptrdiff, qint32, qint64
+*/
+
+/*!
+    \macro PRIdQINTPTR
+    \macro PRIiQINTPTR
+    \since 6.2
+    \relates <QtTypes>
+
+    See \l qintptr.
+*/
+
+/*!
+    \typedef quintptr
+    \relates <QtTypes>
+
+    Integral type for representing pointers in an unsigned integer (useful for
+    hashing, etc.).
+
+    Typedef for either quint32 or quint64. This type is guaranteed to
+    be the same size as a pointer on all platforms supported by Qt. On
+    a system with 32-bit pointers, quintptr is a typedef for quint32;
+    on a system with 64-bit pointers, quintptr is a typedef for
+    quint64.
+
+    Note that quintptr is unsigned. Use qptrdiff for signed values.
+
+    In order to print values of this type by using formatted-output
+    facilities such as \c{printf()}, qDebug(), QString::asprintf() and
+    so on, you can use the following macros as format specifiers:
+
+    \list
+    \li \c{PRIuQUINTPTR}: prints the value as a base 10 number.
+    \li \c{PRIoQUINTPTR}: prints the value as a base 8 number.
+    \li \c{PRIxQUINTPTR}: prints the value as a base 16 number, using lowercase \c{a-f} letters.
+    \li \c{PRIXQUINTPTR}: prints the value as a base 16 number, using uppercase \c{A-F} letters.
+    \endlist
+
+    \code
+    quintptr p = 123u;
+    printf("The pointer value is 0x%" PRIXQUINTPTR "\n", p);
+    \endcode
+
+    \sa qptrdiff, quint32, quint64
+*/
+
+/*!
+    \macro PRIoQUINTPTR
+    \macro PRIuQUINTPTR
+    \macro PRIxQUINTPTR
+    \macro PRIXQUINTPTR
+    \since 6.2
+    \relates <QtTypes>
+
+    See quintptr.
+*/
+
+/*!
+    \typedef qptrdiff
+    \relates <QtTypes>
+
+    Integral type for representing pointer differences.
+
+    Typedef for either qint32 or qint64. This type is guaranteed to be
+    the same size as a pointer on all platforms supported by Qt. On a
+    system with 32-bit pointers, quintptr is a typedef for quint32; on
+    a system with 64-bit pointers, quintptr is a typedef for quint64.
+
+    Note that qptrdiff is signed. Use quintptr for unsigned values.
+
+    In order to print values of this type by using formatted-output
+    facilities such as \c{printf()}, qDebug(), QString::asprintf() and
+    so on, you can use the \c{PRIdQPTRDIFF} and \c{PRIiQPTRDIFF}
+    macros as format specifiers. They will both print the value as a
+    base 10 number.
+
+    \code
+    qptrdiff d = 123;
+    printf("The difference is %" PRIdQPTRDIFF "\n", d);
+    \endcode
+
+    \sa quintptr, qint32, qint64
+*/
+
+/*!
+    \macro PRIdQPTRDIFF
+    \macro PRIiQPTRDIFF
+    \since 6.2
+    \relates <QtTypes>
+
+    See qptrdiff.
+*/
+
+/*!
+    \typedef qsizetype
+    \relates <QtTypes>
+    \since 5.10
+
+    Integral type providing Posix' \c ssize_t for all platforms.
+
+    This type is guaranteed to be the same size as a \c size_t on all
+    platforms supported by Qt.
+
+    Note that qsizetype is signed. Use \c size_t for unsigned values.
+
+    In order to print values of this type by using formatted-output
+    facilities such as \c{printf()}, qDebug(), QString::asprintf() and
+    so on, you can use the \c{PRIdQSIZETYPE} and \c{PRIiQSIZETYPE}
+    macros as format specifiers. They will both print the value as a
+    base 10 number.
+
+    \code
+    qsizetype s = 123;
+    printf("The size is %" PRIdQSIZETYPE "\n", s);
+    \endcode
+
+    \sa qptrdiff
+*/
+
+/*!
+    \macro PRIdQSIZETYPE
+    \macro PRIiQSIZETYPE
+    \since 6.2
+    \relates <QtTypes>
+
+    See qsizetype.
+*/
+
+// Statically check assumptions about the environment we're running
+// in. The idea here is to error or warn if otherwise implicit Qt
+// assumptions are not fulfilled on new hardware or compilers
+// (if this list becomes too long, consider factoring into a separate file)
+static_assert(UCHAR_MAX == 255, "Qt assumes that char is 8 bits");
+static_assert(sizeof(int) == 4, "Qt assumes that int is 32 bits");
+static_assert(QT_POINTER_SIZE == sizeof(void *), "QT_POINTER_SIZE defined incorrectly");
+static_assert(sizeof(float) == 4, "Qt assumes that float is 32 bits");
+static_assert(sizeof(char16_t) == 2, "Qt assumes that char16_t is 16 bits");
+static_assert(sizeof(char32_t) == 4, "Qt assumes that char32_t is 32 bits");
+#if defined(Q_OS_WIN)
+static_assert(sizeof(wchar_t) == sizeof(char16_t));
+#endif
+static_assert(std::numeric_limits<int>::radix == 2,
+                  "Qt assumes binary integers");
+static_assert((std::numeric_limits<int>::max() + std::numeric_limits<int>::lowest()) == -1,
+                  "Qt assumes two's complement integers");
+static_assert(sizeof(wchar_t) == sizeof(char32_t) || sizeof(wchar_t) == sizeof(char16_t),
+              "Qt assumes wchar_t is compatible with either char32_t or char16_t");
+
+// While we'd like to check for __STDC_IEC_559__, as per ISO/IEC 9899:2011
+// Annex F (C11, normative for C++11), there are a few corner cases regarding
+// denormals where GHS compiler is relying hardware behavior that is not IEC
+// 559 compliant. So split the check in several subchecks.
+
+// On GHS the compiler reports std::numeric_limits<float>::is_iec559 as false.
+// This is all right according to our needs.
+#if !defined(Q_CC_GHS)
+static_assert(std::numeric_limits<float>::is_iec559,
+                  "Qt assumes IEEE 754 floating point");
+#endif
+
+// Technically, presence of NaN and infinities are implied from the above check,
+// but double checking our environment doesn't hurt...
+static_assert(std::numeric_limits<float>::has_infinity &&
+                  std::numeric_limits<float>::has_quiet_NaN,
+                  "Qt assumes IEEE 754 floating point");
+
+// is_iec559 checks for ISO/IEC/IEEE 60559:2011 (aka IEEE 754-2008) compliance,
+// but that allows for a non-binary radix. We need to recheck that.
+// Note how __STDC_IEC_559__ would instead check for IEC 60559:1989, aka
+// ANSI/IEEE 754−1985, which specifically implies binary floating point numbers.
+static_assert(std::numeric_limits<float>::radix == 2,
+                  "Qt assumes binary IEEE 754 floating point");
+
+// not required by the definition of size_t, but we depend on this
+static_assert(sizeof(size_t) == sizeof(void *), "size_t and a pointer don't have the same size");
+static_assert(sizeof(size_t) == sizeof(qsizetype)); // implied by the definition
+static_assert((std::is_same<qsizetype, qptrdiff>::value));
+
+// Check that our own typedefs are not broken.
+static_assert(sizeof(qint8) == 1, "Internal error, qint8 is misdefined");
+static_assert(sizeof(qint16)== 2, "Internal error, qint16 is misdefined");
+static_assert(sizeof(qint32) == 4, "Internal error, qint32 is misdefined");
+static_assert(sizeof(qint64) == 8, "Internal error, qint64 is misdefined");
+
+QT_END_NAMESPACE
diff --git a/src/corelib/global/qtypes.h b/src/corelib/global/qtypes.h
new file mode 100644
index 0000000000..f7757b4311
--- /dev/null
+++ b/src/corelib/global/qtypes.h
@@ -0,0 +1,163 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// Copyright (C) 2022 Intel Corporation.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#ifndef QTYPES_H
+#define QTYPES_H
+
+#include <QtCore/qprocessordetection.h>
+#include <QtCore/qtconfigmacros.h>
+
+#ifdef __cplusplus
+#  include <cstddef>
+#  include <cstdint>
+#endif
+
+#if 0
+#pragma qt_class(QtTypes)
+#pragma qt_class(QIntegerForSize)
+#pragma qt_sync_stop_processing
+#endif
+
+#ifndef __ASSEMBLER__
+
+/*
+   Useful type definitions for Qt
+*/
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef unsigned int uint;
+typedef unsigned long ulong;
+
+QT_BEGIN_NAMESPACE
+
+/*
+   Size-dependent types (architecture-dependent byte order)
+
+   Make sure to update QMetaType when changing these typedefs
+*/
+
+typedef signed char qint8;         /* 8 bit signed */
+typedef unsigned char quint8;      /* 8 bit unsigned */
+typedef short qint16;              /* 16 bit signed */
+typedef unsigned short quint16;    /* 16 bit unsigned */
+typedef int qint32;                /* 32 bit signed */
+typedef unsigned int quint32;      /* 32 bit unsigned */
+// Unlike LL / ULL in C++, for historical reasons, we force the
+// result to be of the requested type.
+#ifdef __cplusplus
+#  define Q_INT64_C(c) static_cast<long long>(c ## LL)     /* signed 64 bit constant */
+#  define Q_UINT64_C(c) static_cast<unsigned long long>(c ## ULL) /* unsigned 64 bit constant */
+#else
+#  define Q_INT64_C(c) ((long long)(c ## LL))               /* signed 64 bit constant */
+#  define Q_UINT64_C(c) ((unsigned long long)(c ## ULL))    /* unsigned 64 bit constant */
+#endif
+typedef long long qint64;           /* 64 bit signed */
+typedef unsigned long long quint64; /* 64 bit unsigned */
+
+typedef qint64 qlonglong;
+typedef quint64 qulonglong;
+
+#ifndef __cplusplus
+// In C++ mode, we define below using QIntegerForSize template
+Q_STATIC_ASSERT_X(sizeof(ptrdiff_t) == sizeof(size_t), "Weird ptrdiff_t and size_t definitions");
+typedef ptrdiff_t qptrdiff;
+typedef ptrdiff_t qsizetype;
+typedef ptrdiff_t qintptr;
+typedef size_t quintptr;
+
+#define PRIdQPTRDIFF "td"
+#define PRIiQPTRDIFF "ti"
+
+#define PRIdQSIZETYPE "td"
+#define PRIiQSIZETYPE "ti"
+
+#define PRIdQINTPTR "td"
+#define PRIiQINTPTR "ti"
+
+#define PRIuQUINTPTR "zu"
+#define PRIoQUINTPTR "zo"
+#define PRIxQUINTPTR "zx"
+#define PRIXQUINTPTR "zX"
+#endif
+
+#if defined(QT_COORD_TYPE)
+typedef QT_COORD_TYPE qreal;
+#else
+typedef double qreal;
+#endif
+
+#if defined(__cplusplus)
+/*
+  quintptr are qptrdiff is guaranteed to be the same size as a pointer, i.e.
+
+      sizeof(void *) == sizeof(quintptr)
+      && sizeof(void *) == sizeof(qptrdiff)
+
+  While size_t and qsizetype are not guaranteed to be the same size as a pointer,
+  they usually are and we do check for that in qtypes.cpp, just to be sure.
+*/
+template <int> struct QIntegerForSize;
+template <>    struct QIntegerForSize<1> { typedef quint8  Unsigned; typedef qint8  Signed; };
+template <>    struct QIntegerForSize<2> { typedef quint16 Unsigned; typedef qint16 Signed; };
+template <>    struct QIntegerForSize<4> { typedef quint32 Unsigned; typedef qint32 Signed; };
+template <>    struct QIntegerForSize<8> { typedef quint64 Unsigned; typedef qint64 Signed; };
+#if defined(Q_CC_GNU) && defined(__SIZEOF_INT128__)
+template <>    struct QIntegerForSize<16> { __extension__ typedef unsigned __int128 Unsigned; __extension__ typedef __int128 Signed; };
+#endif
+template <class T> struct QIntegerForSizeof: QIntegerForSize<sizeof(T)> { };
+typedef QIntegerForSize<Q_PROCESSOR_WORDSIZE>::Signed qregisterint;
+typedef QIntegerForSize<Q_PROCESSOR_WORDSIZE>::Unsigned qregisteruint;
+typedef QIntegerForSizeof<void *>::Unsigned quintptr;
+typedef QIntegerForSizeof<void *>::Signed qptrdiff;
+typedef qptrdiff qintptr;
+using qsizetype = QIntegerForSizeof<std::size_t>::Signed;
+
+// These custom definitions are necessary as we're not defining our
+// datatypes in terms of the language ones, but in terms of integer
+// types that have the sime size. For instance, on a 32-bit platform,
+// qptrdiff is int, while ptrdiff_t may be aliased to long; therefore
+// using %td to print a qptrdiff would be wrong (and raise -Wformat
+// warnings), although both int and long have same bit size on that
+// platform.
+//
+// We know that sizeof(size_t) == sizeof(void *) == sizeof(qptrdiff).
+#if SIZE_MAX == 0xffffffffULL
+#define PRIuQUINTPTR "u"
+#define PRIoQUINTPTR "o"
+#define PRIxQUINTPTR "x"
+#define PRIXQUINTPTR "X"
+
+#define PRIdQPTRDIFF "d"
+#define PRIiQPTRDIFF "i"
+
+#define PRIdQINTPTR "d"
+#define PRIiQINTPTR "i"
+
+#define PRIdQSIZETYPE "d"
+#define PRIiQSIZETYPE "i"
+#elif SIZE_MAX == 0xffffffffffffffffULL
+#define PRIuQUINTPTR "llu"
+#define PRIoQUINTPTR "llo"
+#define PRIxQUINTPTR "llx"
+#define PRIXQUINTPTR "llX"
+
+#define PRIdQPTRDIFF "lld"
+#define PRIiQPTRDIFF "lli"
+
+#define PRIdQINTPTR "lld"
+#define PRIiQINTPTR "lli"
+
+#define PRIdQSIZETYPE "lld"
+#define PRIiQSIZETYPE "lli"
+#else
+#error Unsupported platform (unknown value for SIZE_MAX)
+#endif
+
+#endif // __cplusplus
+
+QT_END_NAMESPACE
+
+#endif // __ASSEMBLER__
+
+#endif // QTYPES_H