1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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>
This commit is contained in:
Marc Mutz 2022-06-24 09:23:47 +02:00 committed by Qt Cherry-pick Bot
parent d39c01b830
commit 9e092ec83b
5 changed files with 39 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
src/corelib/io/qloggingcategory.cpp
View File

@ -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;
}
}

16
src/corelib/io/qloggingcategory.h
View File

@ -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;

38
src/corelib/thread/qatomic.cpp
View File

@ -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
work on all platforms. Support for other sizes depends on the compiler and
processor architecture the code is being compiled for. To test whether the
other types are supported, check the macro \c Q_ATOMIC_INT\e{nn}_IS_SUPPORTED,
where \c{\e{nn}} is the number of bits desired.
Of the list above, only the 8-bit, 16-bit, 32-bit- and pointer-sized
instantiations are guaranteed to work on all platforms. Support for other
sizes depends on the compiler and processor architecture the code is being
compiled for. To test whether the 64-bit types are supported on 32-bit
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

14
tests/auto/corelib/thread/qatomicint/tst_qatomicint.cpp
View File

@ -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()

32
tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp
View File

@ -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) \
|| (defined(WCHAR_MAX) && (WCHAR_MAX-0 > 0x10000))
# define TYPE_SUPPORTED_wchar_t 1
#endif
#define TYPE_SUPPORTED_char32_t 1
#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