Remove uses of Q_ATOMIC_INT{8,16,32}_IS_SUPPORTED

It's always true these days, assert so in qatomic.cpp and
tst_QAtomicInteger.

Update the docs.

Change-Id: I3684cff96c1d2e05677314e29514cc279bd6b1a1
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
(cherry picked from commit 0587d4752d8fb814d47a599130d98724d78b1525)
Reviewed-by: Qt Cherry-pick Bot <cherrypick_bot@qt-project.org>

src/corelib/io/qloggingcategory.cpp

@@ -9,18 +9,6 @@ QT_BEGIN_NAMESPACE
 const char qtDefaultCategoryName[] = "default";
 Q_GLOBAL_STATIC(QLoggingCategory, qtDefaultCategory, qtDefaultCategoryName)
 
-#ifndef Q_ATOMIC_INT8_IS_SUPPORTED
-static void setBoolLane(QBasicAtomicInt *atomic, bool enable, int shift)
-{
-    const int bit = 1 << shift;
-
-    if (enable)
-        atomic->fetchAndOrRelaxed(bit);
-    else
-        atomic->fetchAndAndRelaxed(~bit);
-}
-#endif
-
 /*!
     \class QLoggingCategory
     \inmodule QtCore
@@ -288,17 +276,10 @@ bool QLoggingCategory::isEnabled(QtMsgType msgtype) const
 void QLoggingCategory::setEnabled(QtMsgType type, bool enable)
 {
     switch (type) {
-#ifdef Q_ATOMIC_INT8_IS_SUPPORTED
     case QtDebugMsg: bools.enabledDebug.storeRelaxed(enable); break;
     case QtInfoMsg: bools.enabledInfo.storeRelaxed(enable); break;
     case QtWarningMsg: bools.enabledWarning.storeRelaxed(enable); break;
     case QtCriticalMsg: bools.enabledCritical.storeRelaxed(enable); break;
-#else
-    case QtDebugMsg: setBoolLane(&enabled, enable, DebugShift); break;
-    case QtInfoMsg: setBoolLane(&enabled, enable, InfoShift); break;
-    case QtWarningMsg: setBoolLane(&enabled, enable, WarningShift); break;
-    case QtCriticalMsg: setBoolLane(&enabled, enable, CriticalShift); break;
-#endif
     case QtFatalMsg: break;
     }
 }

src/corelib/io/qloggingcategory.h

@@ -19,17 +19,11 @@ public:
     bool isEnabled(QtMsgType type) const;
     void setEnabled(QtMsgType type, bool enable);
 
-#ifdef Q_ATOMIC_INT8_IS_SUPPORTED
     bool isDebugEnabled() const { return bools.enabledDebug.loadRelaxed(); }
     bool isInfoEnabled() const { return bools.enabledInfo.loadRelaxed(); }
     bool isWarningEnabled() const { return bools.enabledWarning.loadRelaxed(); }
     bool isCriticalEnabled() const { return bools.enabledCritical.loadRelaxed(); }
-#else
+
-    bool isDebugEnabled() const { return enabled.loadRelaxed() >> DebugShift & 1; }
-    bool isInfoEnabled() const { return enabled.loadRelaxed() >> InfoShift & 1; }
-    bool isWarningEnabled() const { return enabled.loadRelaxed() >> WarningShift & 1; }
-    bool isCriticalEnabled() const { return enabled.loadRelaxed() >> CriticalShift & 1; }
-#endif
     const char *categoryName() const { return name; }
 
     // allows usage of both factory method and variable in qCX macros
@@ -49,19 +43,11 @@ private:
     Q_DECL_UNUSED_MEMBER void *d; // reserved for future use
     const char *name;
 
-#ifdef Q_BIG_ENDIAN
-    enum { DebugShift = 0, WarningShift = 8, CriticalShift = 16, InfoShift = 24 };
-#else
-    enum { DebugShift = 24, WarningShift = 16, CriticalShift = 8, InfoShift = 0};
-#endif
-
     struct AtomicBools {
-#ifdef Q_ATOMIC_INT8_IS_SUPPORTED
         QBasicAtomicInteger<bool> enabledDebug;
         QBasicAtomicInteger<bool> enabledWarning;
         QBasicAtomicInteger<bool> enabledCritical;
         QBasicAtomicInteger<bool> enabledInfo;
-#endif
     };
     union {
         AtomicBools bools;

src/corelib/thread/qatomic.cpp

@@ -39,11 +39,11 @@
        \li pointer size: qintptr, quintptr, qptrdiff
     \endlist
 
-    Of the list above, only the 32-bit- and pointer-sized instantiations are guaranteed to
+    Of the list above, only the 8-bit, 16-bit, 32-bit- and pointer-sized
-    work on all platforms. Support for other sizes depends on the compiler and
+    instantiations are guaranteed to work on all platforms. Support for other
-    processor architecture the code is being compiled for. To test whether the
+    sizes depends on the compiler and processor architecture the code is being
-    other types are supported, check the macro \c Q_ATOMIC_INT\e{nn}_IS_SUPPORTED,
+    compiled for. To test whether the 64-bit types are supported on 32-bit
-    where \c{\e{nn}} is the number of bits desired.
+    platforms, check the macro \c Q_ATOMIC_INT64_IS_SUPPORTED.
 
     \section1 The Atomic API
 
@@ -950,9 +950,16 @@
 
     This macro is defined if atomic integers of size \e{nn} (in bits) are
     supported in this compiler / architecture combination.
-    Q_ATOMIC_INT32_IS_SUPPORTED is always defined.
 
     \e{nn} is the size of the integer, in bits (8, 16, 32 or 64).
+
+    The following macros always defined:
+
+    \list
+    \li Q_ATOMIC_INT8_IS_SUPPORTED
+    \li Q_ATOMIC_INT16_IS_SUPPORTED
+    \li Q_ATOMIC_INT32_IS_SUPPORTED
+    \endlist
 */
 
 /*!
@@ -1653,6 +1660,12 @@
 */
 
 // static checks
+#ifndef Q_ATOMIC_INT8_IS_SUPPORTED
+#  error "Q_ATOMIC_INT8_IS_SUPPORTED must be defined"
+#endif
+#ifndef Q_ATOMIC_INT16_IS_SUPPORTED
+#  error "Q_ATOMIC_INT16_IS_SUPPORTED must be defined"
+#endif
 #ifndef Q_ATOMIC_INT32_IS_SUPPORTED
 #  error "Q_ATOMIC_INT32_IS_SUPPORTED must be defined"
 #endif
@@ -1671,22 +1684,19 @@ static_assert(sizeof(QAtomicInteger<quintptr>));
 static_assert(sizeof(QAtomicInteger<qptrdiff>));
 static_assert(sizeof(QAtomicInteger<char32_t>));
 
-#ifdef Q_ATOMIC_INT16_IS_SUPPORTED
 static_assert(sizeof(QAtomicInteger<short>));
 static_assert(sizeof(QAtomicInteger<unsigned short>));
-#  if WCHAR_MAX < 0x10000
 static_assert(sizeof(QAtomicInteger<wchar_t>));
-#  endif
 static_assert(sizeof(QAtomicInteger<char16_t>));
-#endif
+
+static_assert(sizeof(QAtomicInteger<char>));
+static_assert(sizeof(QAtomicInteger<unsigned char>));
+static_assert(sizeof(QAtomicInteger<signed char>));
+static_assert(sizeof(QAtomicInteger<bool>));
 
 #ifdef Q_ATOMIC_INT64_IS_SUPPORTED
 static_assert(sizeof(QAtomicInteger<qint64>));
 static_assert(sizeof(QAtomicInteger<quint64>));
 #endif
 
-#if WCHAR_MAX == INT_MAX
-static_assert(sizeof(QAtomicInteger<wchar_t>));
-#endif
-
 QT_END_NAMESPACE

tests/auto/corelib/thread/qatomicint/tst_qatomicint.cpp

@@ -161,23 +161,19 @@ void tst_QAtomicInt::warningFreeHelper()
     constexprFunctionsHelperTemplate<QBasicAtomicInteger<long int> >();
     constexprFunctionsHelperTemplate<QBasicAtomicInteger<unsigned long int> >();
 
-#ifdef Q_ATOMIC_INT16_IS_SUPPORTED
     warningFreeHelperTemplate<qint16, QBasicAtomicInteger<qint16> >();
     warningFreeHelperTemplate<quint16, QBasicAtomicInteger<quint16> >();
     constexprFunctionsHelperTemplate<QBasicAtomicInteger<qint16> >();
     constexprFunctionsHelperTemplate<QBasicAtomicInteger<quint16> >();
     warningFreeHelperTemplate<qint16, QBasicAtomicInteger<char16_t> >();
     constexprFunctionsHelperTemplate<QBasicAtomicInteger<char16_t> >();
-#endif
 
-#ifdef Q_ATOMIC_INT8_IS_SUPPORTED
     warningFreeHelperTemplate<char, QBasicAtomicInteger<char> >();
     warningFreeHelperTemplate<signed char, QBasicAtomicInteger<signed char> >();
     warningFreeHelperTemplate<unsigned char, QBasicAtomicInteger<unsigned char> >();
     constexprFunctionsHelperTemplate<QBasicAtomicInteger<char> >();
     constexprFunctionsHelperTemplate<QBasicAtomicInteger<signed char> >();
     constexprFunctionsHelperTemplate<QBasicAtomicInteger<unsigned char> >();
-#endif
 
 #ifdef Q_ATOMIC_INT64_IS_SUPPORTED
 #if !defined(__i386__) || (defined(Q_CC_GNU) && defined(__OPTIMIZE__))
@@ -205,17 +201,9 @@ void tst_QAtomicInt::alignment()
     static_assert(alignof(QBasicAtomicInt) == alignof(TypeInStruct<int>));
     static_assert(alignof(QBasicAtomicInt) == alignof(TypeInStruct<int>));
 
-#ifdef Q_ATOMIC_INT32_IS_SUPPORTED
     QCOMPARE(alignof(QBasicAtomicInteger<int>), alignof(TypeInStruct<int>));
-#endif
-
-#ifdef Q_ATOMIC_INT16_IS_SUPPORTED
     QCOMPARE(alignof(QBasicAtomicInteger<short>), alignof(TypeInStruct<short>));
-#endif
-
-#ifdef Q_ATOMIC_INT8_IS_SUPPORTED
     QCOMPARE(alignof(QBasicAtomicInteger<char>), alignof(TypeInStruct<char>));
-#endif
 
 #if !defined(Q_PROCESSOR_X86_32) && defined(Q_ATOMIC_INT64_IS_SUPPORTED)
     // The alignment is different on x86_32
@@ -493,7 +481,6 @@ void tst_QAtomicInt::testAndSet()
         QTEST(atomic.testAndSetOrdered(expected, newval), "result");
     }
 
-#ifdef Q_ATOMIC_INT32_IS_SUPPORTED
     QFETCH(bool, result);
     // the new implementation has the version that loads the current value
 
@@ -528,7 +515,6 @@ void tst_QAtomicInt::testAndSet()
         if (!result)
             QCOMPARE(currentval, value);
     }
-#endif
 }
 
 void tst_QAtomicInt::isFetchAndStoreNative()

tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp

@@ -32,6 +32,12 @@
 #include <limits.h>
 #include <wchar.h>
 
+#if !defined(Q_ATOMIC_INT8_IS_SUPPORTED)
+#  error "QAtomicInteger for 8-bit types must be supported!"
+#endif
+#if !defined(Q_ATOMIC_INT16_IS_SUPPORTED)
+#  error "QAtomicInteger for 16-bit types must be supported!"
+#endif
 #if !defined(Q_ATOMIC_INT32_IS_SUPPORTED)
 #  error "QAtomicInteger for 32-bit types must be supported!"
 #endif
@@ -40,31 +46,21 @@
 #endif
 
 // always supported types:
+#define TYPE_SUPPORTED_char         1
+#define TYPE_SUPPORTED_uchar        1
+#define TYPE_SUPPORTED_schar        1
+#define TYPE_SUPPORTED_short        1
+#define TYPE_SUPPORTED_ushort       1
+#define TYPE_SUPPORTED_char16_t     1
+#define TYPE_SUPPORTED_wchar_t      1
 #define TYPE_SUPPORTED_int          1
 #define TYPE_SUPPORTED_uint         1
 #define TYPE_SUPPORTED_long         1
 #define TYPE_SUPPORTED_ulong        1
 #define TYPE_SUPPORTED_qptrdiff     1
 #define TYPE_SUPPORTED_quintptr     1
-#if (defined(__SIZEOF_WCHAR_T__) && (__SIZEOF_WCHAR_T__-0) > 2) \
+#define TYPE_SUPPORTED_char32_t     1
-    || (defined(WCHAR_MAX) && (WCHAR_MAX-0 > 0x10000))
-#  define TYPE_SUPPORTED_wchar_t    1
-#endif
-#define TYPE_SUPPORTED_char32_t   1
 
-#ifdef Q_ATOMIC_INT8_IS_SUPPORTED
-#  define TYPE_SUPPORTED_char       1
-#  define TYPE_SUPPORTED_uchar      1
-#  define TYPE_SUPPORTED_schar      1
-#endif
-#ifdef Q_ATOMIC_INT16_IS_SUPPORTED
-#  define TYPE_SUPPORTED_short      1
-#  define TYPE_SUPPORTED_ushort     1
-#  define TYPE_SUPPORTED_char16_t 1
-#  ifndef TYPE_SUPPORTED_wchar_t
-#    define TYPE_SUPPORTED_wchar_t  1
-#  endif
-#endif
 #ifdef Q_ATOMIC_INT64_IS_SUPPORTED
 #  define TYPE_SUPPORTED_qlonglong  1
 #  define TYPE_SUPPORTED_qulonglong 1