diff options
Diffstat (limited to 'src/corelib/global')
| -rw-r--r-- | src/corelib/global/global.pri | 20 | ||||
| -rw-r--r-- | src/corelib/global/minimum-linux.S | 106 | ||||
| -rw-r--r-- | src/corelib/global/qconfig-bootstrapped.h | 7 | ||||
| -rw-r--r-- | src/corelib/global/qendian.h | 235 | ||||
| -rw-r--r-- | src/corelib/global/qendian.qdoc | 369 | ||||
| -rw-r--r-- | src/corelib/global/qendian_p.h | 142 | ||||
| -rw-r--r-- | src/corelib/global/qfloat16.cpp | 24 | ||||
| -rw-r--r-- | src/corelib/global/qglobal.cpp | 307 | ||||
| -rw-r--r-- | src/corelib/global/qglobal.h | 48 | ||||
| -rw-r--r-- | src/corelib/global/qlogging.cpp | 28 | ||||
| -rw-r--r-- | src/corelib/global/qnamespace.h | 10 | ||||
| -rw-r--r-- | src/corelib/global/qnamespace.qdoc | 25 | ||||
| -rw-r--r-- | src/corelib/global/qnumeric.h | 18 | ||||
| -rw-r--r-- | src/corelib/global/qnumeric_p.h | 54 | ||||
| -rw-r--r-- | src/corelib/global/qrandom.cpp | 1050 | ||||
| -rw-r--r-- | src/corelib/global/qrandom.h | 154 | ||||
| -rw-r--r-- | src/corelib/global/qrandom_p.h | 78 | ||||
| -rw-r--r-- | src/corelib/global/qtypeinfo.h | 10 |
18 files changed, 2370 insertions, 315 deletions
diff --git a/src/corelib/global/global.pri b/src/corelib/global/global.pri index b76d1ef43c..78b37755a4 100644 --- a/src/corelib/global/global.pri +++ b/src/corelib/global/global.pri @@ -9,6 +9,7 @@ HEADERS += \ global/qprocessordetection.h \ global/qnamespace.h \ global/qendian.h \ + global/qendian_p.h \ global/qnumeric_p.h \ global/qnumeric.h \ global/qfloat16_p.h \ @@ -21,6 +22,8 @@ HEADERS += \ global/qisenum.h \ global/qtypetraits.h \ global/qflags.h \ + global/qrandom.h \ + global/qrandom_p.h \ global/qhooks_p.h \ global/qversiontagging.h @@ -33,6 +36,7 @@ SOURCES += \ global/qfloat16.cpp \ global/qoperatingsystemversion.cpp \ global/qlogging.cpp \ + global/qrandom.cpp \ global/qhooks.cpp VERSIONTAGGING_SOURCES = global/qversiontagging.cpp @@ -55,6 +59,22 @@ if(linux*|hurd*):!cross_compile:!static:!*-armcc* { DEFINES += ELF_INTERPRETER=\\\"$$system(LC_ALL=C readelf -l /bin/ls | perl -n -e \'$$prog\')\\\" } +linux:!static { + precompile_header { + # we'll get an error if we just use SOURCES += + no_pch_assembler.commands = $$QMAKE_CC -c $(CFLAGS) $(INCPATH) ${QMAKE_FILE_IN} -o ${QMAKE_FILE_OUT} + no_pch_assembler.dependency_type = TYPE_C + no_pch_assembler.output = ${QMAKE_VAR_OBJECTS_DIR}${QMAKE_FILE_BASE}$${first(QMAKE_EXT_OBJ)} + no_pch_assembler.input = NO_PCH_ASM + no_pch_assembler.name = compiling[no_pch] ${QMAKE_FILE_IN} + silent: no_pch_assembler.commands = @echo compiling[no_pch] ${QMAKE_FILE_IN} && $$no_pch_assembler.commands + QMAKE_EXTRA_COMPILERS += no_pch_assembler + NO_PCH_ASM += global/minimum-linux.S + } else { + SOURCES += global/minimum-linux.S + } +} + qtConfig(slog2): \ LIBS_PRIVATE += -lslog2 diff --git a/src/corelib/global/minimum-linux.S b/src/corelib/global/minimum-linux.S new file mode 100644 index 0000000000..6b7fb4f63b --- /dev/null +++ b/src/corelib/global/minimum-linux.S @@ -0,0 +1,106 @@ +/**************************************************************************** +** +** Copyright (C) 2017 Intel Corporation. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "private/qglobal_p.h" + +/* Copied from #include <elf.h>: + */ +#define ELF_NOTE_GNU "GNU" +#define NT_GNU_ABI_TAG 1 +#define ELF_NOTE_OS_LINUX 0 + +#ifdef __arm__ +# define progbits %progbits +# define note %note +#else +# define progbits @progbits +# define note @note +#endif + +/* Add information for the ELF dynamic linker what the minimum Linux version + * required for Qt is. + * + * The .note.ABI-tag note section is defined at + * https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/noteabitag.html + */ + + .section ".note.GNU-stack", "", progbits + .section ".note.ABI-tag", "a", note + .align 4 /* we have 32-bit data */ + +/* * For the format of the note section's contents, see Elf32_Nhdr / Elf64_Nhdr */ + .long .Lnameend-.Lname /* n_namesz */ + .long 16 /* n_descsz(16 bytes, normative) */ + .long NT_GNU_ABI_TAG /* n_type */ + +.Lname: + .asciz ELF_NOTE_GNU +.Lnameend: + +/* Operating systems: */ + .long ELF_NOTE_OS_LINUX + +/* Minimum Linux kernel version: + * We require the following features in Qt (unconditional, no fallback): + * Feature Added in version Macro + * - inotify_init1 before 2.6.12-rc12 + * - futex(2) before 2.6.12-rc12 + * - linkat(2) 2.6.17 O_TMPFILE + * - FUTEX_PRIVATE_FLAG 2.6.22 + * - O_CLOEXEC 2.6.23 + * - eventfd 2.6.23 + * - pipe2 & dup3 2.6.27 + * - accept4 2.6.28 + * - renameat2 3.16 QT_CONFIG(renameat2) + * - getrandom 3.17 QT_CONFIG(getentropy) + */ + +#if QT_CONFIG(getentropy) + .long 3 + .long 17 + .long 0 +#elif QT_CONFIG(renameat2) + .long 3 + .long 16 + .long 0 +#else + .long 2 + .long 6 + .long 28 +#endif diff --git a/src/corelib/global/qconfig-bootstrapped.h b/src/corelib/global/qconfig-bootstrapped.h index 0b02ecc8ec..95095f4b76 100644 --- a/src/corelib/global/qconfig-bootstrapped.h +++ b/src/corelib/global/qconfig-bootstrapped.h @@ -75,14 +75,21 @@ #else # define QT_FEATURE_alloca_malloc_h -1 #endif +#define QT_FEATURE_cxx11_random (QT_HAS_INCLUDE(<random>) ? 1 : -1) +#define QT_FEATURE_getauxval (QT_HAS_INCLUDE(<sys/auxv.h>) ? 1 : -1) +#define QT_FEATURE_getentropy -1 #define QT_FEATURE_iconv -1 #define QT_FEATURE_icu -1 #define QT_FEATURE_journald -1 +#define QT_FEATURE_futimens -1 +#define QT_FEATURE_futimes -1 #define QT_FEATURE_library -1 #define QT_NO_QOBJECT #define QT_FEATURE_process -1 #define QT_NO_SYSTEMLOCALE +#define QT_FEATURE_renameat2 -1 #define QT_FEATURE_slog2 -1 +#define QT_FEATURE_statx -1 #define QT_FEATURE_syslog -1 #define QT_FEATURE_temporaryfile 1 #define QT_NO_THREAD diff --git a/src/corelib/global/qendian.h b/src/corelib/global/qendian.h index 4e9cd2e6e3..3337829de0 100644 --- a/src/corelib/global/qendian.h +++ b/src/corelib/global/qendian.h @@ -52,22 +52,6 @@ QT_BEGIN_NAMESPACE /* * ENDIAN FUNCTIONS */ -inline void qbswap_helper(const void *src, void *dest, int size) -{ - for (int i = 0; i < size ; ++i) - static_cast<uchar *>(dest)[i] = static_cast<const uchar *>(src)[size - 1 - i]; -} - -/* - * qbswap(const T src, const void *dest); - * Changes the byte order of \a src from big endian to little endian or vice versa - * and stores the result in \a dest. - * There is no alignment requirements for \a dest. -*/ -template <typename T> inline void qbswap(const T src, void *dest) -{ - qbswap_helper(&src, dest, sizeof(T)); -} // Used to implement a type-safe and alignment-safe copy operation // If you want to avoid the memcpy, you must write specializations for these functions @@ -103,30 +87,11 @@ template <typename T> Q_ALWAYS_INLINE T qFromUnaligned(const void *src) * This function can be used if you are not concerned about alignment issues, * and it is therefore a bit more convenient and in most cases more efficient. */ -template <typename T> T qbswap(T source); - -// GCC 4.3 implemented all the intrinsics, but the 16-bit one only got implemented in 4.8; -// Clang 2.6 implemented the 32- and 64-bit but waited until 3.2 to implement the 16-bit one -#if (defined(Q_CC_GNU) && Q_CC_GNU >= 403) || QT_HAS_BUILTIN(__builtin_bswap32) -template <> inline quint64 qbswap<quint64>(quint64 source) -{ - return __builtin_bswap64(source); -} -template <> inline quint32 qbswap<quint32>(quint32 source) -{ - return __builtin_bswap32(source); -} +template <typename T> Q_DECL_CONSTEXPR T qbswap(T source); -template <> inline void qbswap<quint64>(quint64 source, void *dest) -{ - qToUnaligned<quint64>(__builtin_bswap64(source), dest); -} -template <> inline void qbswap<quint32>(quint32 source, void *dest) -{ - qToUnaligned<quint32>(__builtin_bswap32(source), dest); -} -#else -template <> inline quint64 qbswap<quint64>(quint64 source) +// These definitions are written so that they are recognized by most compilers +// as bswap and replaced with single instruction builtins if available. +template <> inline Q_DECL_CONSTEXPR quint64 qbswap<quint64>(quint64 source) { return 0 | ((source & Q_UINT64_C(0x00000000000000ff)) << 56) @@ -139,7 +104,7 @@ template <> inline quint64 qbswap<quint64>(quint64 source) | ((source & Q_UINT64_C(0xff00000000000000)) >> 56); } -template <> inline quint32 qbswap<quint32>(quint32 source) +template <> inline Q_DECL_CONSTEXPR quint32 qbswap<quint32>(quint32 source) { return 0 | ((source & 0x000000ff) << 24) @@ -147,65 +112,61 @@ template <> inline quint32 qbswap<quint32>(quint32 source) | ((source & 0x00ff0000) >> 8) | ((source & 0xff000000) >> 24); } -#endif // GCC & Clang intrinsics -#if (defined(Q_CC_GNU) && Q_CC_GNU >= 408) || QT_HAS_BUILTIN(__builtin_bswap16) -template <> inline quint16 qbswap<quint16>(quint16 source) -{ - return __builtin_bswap16(source); -} -template <> inline void qbswap<quint16>(quint16 source, void *dest) -{ - qToUnaligned<quint16>(__builtin_bswap16(source), dest); -} -#else -template <> inline quint16 qbswap<quint16>(quint16 source) + +template <> inline Q_DECL_CONSTEXPR quint16 qbswap<quint16>(quint16 source) { return quint16( 0 | ((source & 0x00ff) << 8) | ((source & 0xff00) >> 8) ); } -#endif // GCC & Clang intrinsics + +template <> inline Q_DECL_CONSTEXPR quint8 qbswap<quint8>(quint8 source) +{ + return source; +} // signed specializations -template <> inline qint64 qbswap<qint64>(qint64 source) +template <> inline Q_DECL_CONSTEXPR qint64 qbswap<qint64>(qint64 source) { return qbswap<quint64>(quint64(source)); } -template <> inline qint32 qbswap<qint32>(qint32 source) +template <> inline Q_DECL_CONSTEXPR qint32 qbswap<qint32>(qint32 source) { return qbswap<quint32>(quint32(source)); } -template <> inline qint16 qbswap<qint16>(qint16 source) +template <> inline Q_DECL_CONSTEXPR qint16 qbswap<qint16>(qint16 source) { return qbswap<quint16>(quint16(source)); } -template <> inline void qbswap<qint64>(qint64 source, void *dest) +template <> inline Q_DECL_CONSTEXPR qint8 qbswap<qint8>(qint8 source) { - qbswap<quint64>(quint64(source), dest); + return source; } -template <> inline void qbswap<qint32>(qint32 source, void *dest) +/* + * qbswap(const T src, const void *dest); + * Changes the byte order of \a src from big endian to little endian or vice versa + * and stores the result in \a dest. + * There is no alignment requirements for \a dest. +*/ +template <typename T> inline void qbswap(const T src, void *dest) { - qbswap<quint32>(quint32(source), dest); + qToUnaligned<T>(qbswap<T>(src), dest); } -template <> inline void qbswap<qint16>(qint16 source, void *dest) -{ - qbswap<quint16>(quint16(source), dest); -} #if Q_BYTE_ORDER == Q_BIG_ENDIAN -template <typename T> inline T qToBigEndian(T source) +template <typename T> inline Q_DECL_CONSTEXPR T qToBigEndian(T source) { return source; } -template <typename T> inline T qFromBigEndian(T source) +template <typename T> inline Q_DECL_CONSTEXPR T qFromBigEndian(T source) { return source; } -template <typename T> inline T qToLittleEndian(T source) +template <typename T> inline Q_DECL_CONSTEXPR T qToLittleEndian(T source) { return qbswap<T>(source); } -template <typename T> inline T qFromLittleEndian(T source) +template <typename T> inline Q_DECL_CONSTEXPR T qFromLittleEndian(T source) { return qbswap<T>(source); } template <typename T> inline void qToBigEndian(T src, void *dest) { qToUnaligned<T>(src, dest); } @@ -213,13 +174,13 @@ template <typename T> inline void qToLittleEndian(T src, void *dest) { qbswap<T>(src, dest); } #else // Q_LITTLE_ENDIAN -template <typename T> inline T qToBigEndian(T source) +template <typename T> inline Q_DECL_CONSTEXPR T qToBigEndian(T source) { return qbswap<T>(source); } -template <typename T> inline T qFromBigEndian(T source) +template <typename T> inline Q_DECL_CONSTEXPR T qFromBigEndian(T source) { return qbswap<T>(source); } -template <typename T> inline T qToLittleEndian(T source) +template <typename T> inline Q_DECL_CONSTEXPR T qToLittleEndian(T source) { return source; } -template <typename T> inline T qFromLittleEndian(T source) +template <typename T> inline Q_DECL_CONSTEXPR T qFromLittleEndian(T source) { return source; } template <typename T> inline void qToBigEndian(T src, void *dest) { qbswap<T>(src, dest); } @@ -228,15 +189,6 @@ template <typename T> inline void qToLittleEndian(T src, void *dest) #endif // Q_BYTE_ORDER == Q_BIG_ENDIAN -template <> inline quint8 qbswap<quint8>(quint8 source) -{ - return source; -} - -template <> inline qint8 qbswap<qint8>(qint8 source) -{ - return source; -} /* T qFromLittleEndian(const void *src) * This function will read a little-endian encoded value from \a src @@ -267,6 +219,127 @@ template <> inline quint8 qFromBigEndian<quint8>(const void *src) template <> inline qint8 qFromBigEndian<qint8>(const void *src) { return static_cast<const qint8 *>(src)[0]; } +template<class S> +class QSpecialInteger +{ + typedef typename S::StorageType T; + T val; +public: + QSpecialInteger() = default; + explicit Q_DECL_CONSTEXPR QSpecialInteger(T i) : val(S::toSpecial(i)) {} + + QSpecialInteger &operator =(T i) { val = S::toSpecial(i); return *this; } + operator T() const { return S::fromSpecial(val); } + + bool operator ==(QSpecialInteger<S> i) const { return val == i.val; } + bool operator !=(QSpecialInteger<S> i) const { return val != i.val; } + + QSpecialInteger &operator +=(T i) + { return (*this = S::fromSpecial(val) + i); } + QSpecialInteger &operator -=(T i) + { return (*this = S::fromSpecial(val) - i); } + QSpecialInteger &operator *=(T i) + { return (*this = S::fromSpecial(val) * i); } + QSpecialInteger &operator >>=(T i) + { return (*this = S::fromSpecial(val) >> i); } + QSpecialInteger &operator <<=(T i) + { return (*this = S::fromSpecial(val) << i); } + QSpecialInteger &operator /=(T i) + { return (*this = S::fromSpecial(val) / i); } + QSpecialInteger &operator %=(T i) + { return (*this = S::fromSpecial(val) % i); } + QSpecialInteger &operator |=(T i) + { return (*this = S::fromSpecial(val) | i); } + QSpecialInteger &operator &=(T i) + { return (*this = S::fromSpecial(val) & i); } + QSpecialInteger &operator ^=(T i) + { return (*this = S::fromSpecial(val) ^ i); } +}; + +template<typename T> +class QLittleEndianStorageType { +public: + typedef T StorageType; + static Q_DECL_CONSTEXPR T toSpecial(T source) { return qToLittleEndian(source); } + static Q_DECL_CONSTEXPR T fromSpecial(T source) { return qFromLittleEndian(source); } +}; + +template<typename T> +class QBigEndianStorageType { +public: + typedef T StorageType; + static Q_DECL_CONSTEXPR T toSpecial(T source) { return qToBigEndian(source); } + static Q_DECL_CONSTEXPR T fromSpecial(T source) { return qFromBigEndian(source); } +}; + +#ifdef Q_QDOC +class QLEInteger { +public: + explicit Q_DECL_CONSTEXPR QLEInteger(T i); + QLEInteger &operator =(T i); + operator T() const; + bool operator ==(QLEInteger i) const; + bool operator !=(QLEInteger i) const; + QLEInteger &operator +=(T i); + QLEInteger &operator -=(T i); + QLEInteger &operator *=(T i); + QLEInteger &operator >>=(T i); + QLEInteger &operator <<=(T i); + QLEInteger &operator /=(T i); + QLEInteger &operator %=(T i); + QLEInteger &operator |=(T i); + QLEInteger &operator &=(T i); + QLEInteger &operator ^=(T i); +}; + +class QBEInteger { +public: + explicit Q_DECL_CONSTEXPR QBEInteger(T i); + QBEInteger &operator =(T i); + operator T() const; + bool operator ==(QBEInteger i) const; + bool operator !=(QBEInteger i) const; + QBEInteger &operator +=(T i); + QBEInteger &operator -=(T i); + QBEInteger &operator *=(T i); + QBEInteger &operator >>=(T i); + QBEInteger &operator <<=(T i); + QBEInteger &operator /=(T i); + QBEInteger &operator %=(T i); + QBEInteger &operator |=(T i); + QBEInteger &operator &=(T i); + QBEInteger &operator ^=(T i); +}; +#else + +template<typename T> +using QLEInteger = QSpecialInteger<QLittleEndianStorageType<T>>; + +template<typename T> +using QBEInteger = QSpecialInteger<QBigEndianStorageType<T>>; +#endif +template <typename T> +class QTypeInfo<QLEInteger<T> > + : public QTypeInfoMerger<QLEInteger<T>, T> {}; + +template <typename T> +class QTypeInfo<QBEInteger<T> > + : public QTypeInfoMerger<QBEInteger<T>, T> {}; + +typedef QLEInteger<qint16> qint16_le; +typedef QLEInteger<qint32> qint32_le; +typedef QLEInteger<qint64> qint64_le; +typedef QLEInteger<quint16> quint16_le; +typedef QLEInteger<quint32> quint32_le; +typedef QLEInteger<quint64> quint64_le; + +typedef QBEInteger<qint16> qint16_be; +typedef QBEInteger<qint32> qint32_be; +typedef QBEInteger<qint64> qint64_be; +typedef QBEInteger<quint16> quint16_be; +typedef QBEInteger<quint32> quint32_be; +typedef QBEInteger<quint64> quint64_be; + QT_END_NAMESPACE #endif // QENDIAN_H diff --git a/src/corelib/global/qendian.qdoc b/src/corelib/global/qendian.qdoc index 9ce9dbdb0e..2ccdea5979 100644 --- a/src/corelib/global/qendian.qdoc +++ b/src/corelib/global/qendian.qdoc @@ -183,3 +183,372 @@ unmodified. */ +/*! + \class QLEInteger + \inmodule QtCore + \brief The QLEInteger class provides platform-independent little-endian integers. + \since 5.10 + + The template parameter \c T must be a C++ integer type: + \list + \li 8-bit: char, signed char, unsigned char, qint8, quint8 + \li 16-bit: short, unsigned short, qint16, quint16, char16_t + \li 32-bit: int, unsigned int, qint32, quint32, char32_t + \li 64-bit: long long, unsigned long long, qint64, quint64 + \li platform-specific size: long, unsigned long + \li pointer size: qintptr, quintptr, qptrdiff + \endlist + + \note Using this class may be slower than using native integers, so only use it when + an exact endian is needed. +*/ + +/*! \fn QLEInteger::QLEInteger(T value) + + Constructs a QLEInteger with the given \a value. +*/ + +/*! \fn QLEInteger &QLEInteger::operator=(T value) + + Assigns \a value to this QLEInteger and returns a reference to + this QLEInteger. +*/ + +/*! + \fn QLEInteger::operator T() const + + Returns the value of this QLEInteger as a native integer. +*/ + +/*! + \fn bool QLEInteger::operator==(QLEInteger other) const + + Returns \c true if the value of this QLEInteger is equal to the value of \a other. +*/ + +/*! + \fn bool QLEInteger::operator!=(QLEInteger other) const + + Returns \c true if the value of this QLEInteger is not equal to the value of \a other. +*/ + +/*! + \fn QLEInteger &QLEInteger::operator+=(T i) + + Adds \a i to this QLEInteger and returns a reference to + this object. +*/ + +/*! + \fn QLEInteger &QLEInteger::operator-=(T i) + + Subtracts \a i from this QLEInteger and returns a reference to + this object. +*/ + +/*! + \fn QLEInteger &QLEInteger::operator*=(T i) + + Multiplies \a i with this QLEInteger and returns a reference to + this object. +*/ + +/*! + \fn QLEInteger &QLEInteger::operator/=(T i) + + Divides this QLEInteger with \a i and returns a reference to + this object. +*/ + +/*! + \fn QLEInteger &QLEInteger::operator%=(T i) + + Sets this QLEInteger to the remainder of a division by \a i and + returns a reference to this object. +*/ + +/*! + \fn QLEInteger &QLEInteger::operator>>=(T i) + + Performs a left-shift by \a i on this QLEInteger and returns a + reference to this object. +*/ + +/*! + \fn QLEInteger &QLEInteger::operator<<=(T i) + + Performs a right-shift by \a i on this QLEInteger and returns a + reference to this object. +*/ + +/*! + \fn QLEInteger &QLEInteger::operator|=(T i) + + Performs a bitwise OR with \a i onto this QLEInteger and returns a reference to + this object. +*/ + +/*! + \fn QLEInteger &QLEInteger::operator&=(T i) + + Performs a bitwise AND with \a i onto this QLEInteger and returns a reference to + this object. +*/ + +/*! + \fn QLEInteger &QLEInteger::operator^=(T i) + + Performs a bitwise XOR with \a i onto this QLEInteger and returns a reference to + this object. +*/ + +/*! + \class QBEInteger + \inmodule QtCore + \brief The QBEInteger class provides platform-independent big-endian integers. + \since 5.10 + + The template parameter \c T must be a C++ integer type: + \list + \li 8-bit: char, signed char, unsigned char, qint8, quint8 + \li 16-bit: short, unsigned short, qint16, quint16, char16_t (C++11) + \li 32-bit: int, unsigned int, qint32, quint32, char32_t (C++11) + \li 64-bit: long long, unsigned long long, qint64, quint64 + \li platform-specific size: long, unsigned long + \li pointer size: qintptr, quintptr, qptrdiff + \endlist + + \note Using this class may be slower than using native integers, so only use it when + an exact endian is needed. +*/ + +/*! \fn QBEInteger::QBEInteger(T value) + + Constructs a QBEInteger with the given \a value. +*/ + +/*! \fn QBEInteger &QBEInteger::operator=(T value) + + Assigns \a value to this QBEInteger and returns a reference to + this QBEInteger. +*/ + +/*! + \fn QBEInteger::operator T() const + + Returns the value of this QBEInteger as a native integer. +*/ + +/*! + \fn bool QBEInteger::operator==(QBEInteger other) const + + Returns \c true if the value of this QBEInteger is equal to the value of \a other. +*/ + +/*! + \fn bool QBEInteger::operator!=(QBEInteger other) const + + Returns \c true if the value of this QBEInteger is not equal to the value of \a other. +*/ + +/*! + \fn QBEInteger &QBEInteger::operator+=(T i) + + Adds \a i to this QBEInteger and returns a reference to + this object. +*/ + +/*! + \fn QBEInteger &QBEInteger::operator-=(T i) + + Subtracts \a i from this QBEInteger and returns a reference to + this object. +*/ + +/*! + \fn QBEInteger &QBEInteger::operator*=(T i) + + Multiplies \a i with this QBEInteger and returns a reference to + this object. +*/ + +/*! + \fn QBEInteger &QBEInteger::operator/=(T i) + + Divides this QBEInteger with \a i and returns a reference to + this object. +*/ + +/*! + \fn QBEInteger &QBEInteger::operator%=(T i) + + Sets this QBEInteger to the remainder of a division by \a i and + returns a reference to this object. +*/ + +/*! + \fn QBEInteger &QBEInteger::operator>>=(T i) + + Performs a left-shift by \a i on this QBEInteger and returns a + reference to this object. +*/ + +/*! + \fn QBEInteger &QBEInteger::operator<<=(T i) + + Performs a right-shift by \a i on this QBEInteger and returns a + reference to this object. +*/ + +/*! + \fn QBEInteger &QBEInteger::operator|=(T i) + + Performs a bitwise OR with \a i onto this QBEInteger and returns a reference to + this object. +*/ + +/*! + \fn QBEInteger &QBEInteger::operator&=(T i) + + Performs a bitwise AND with \a i onto this QBEInteger and returns a reference to + this object. +*/ + +/*! + \fn QBEInteger &QBEInteger::operator^=(T i) + + Performs a bitwise XOR with \a i onto this QBEInteger and returns a reference to + this object. +*/ + +/*! + \typedef quint16_le + \relates <QtEndian> + \since 5.10 + + Typedef for QLEInteger<quint16>. This type is guaranteed to be stored in memory as + a 16-bit little-endian unsigned integer on all platforms supported by Qt. + + \sa quint16 +*/ + +/*! + \typedef quint32_le + \relates <QtEndian> + \since 5.10 + + Typedef for QLEInteger<quint32>. This type is guaranteed to be stored in memory as + a 32-bit little-endian unsigned integer on all platforms supported by Qt. + + \sa quint32 +*/ + +/*! + \typedef quint64_le + \relates <QtEndian> + \since 5.10 + + Typedef for QLEInteger<quint64>. This type is guaranteed to be stored in memory as + a 64-bit little-endian unsigned integer on all platforms supported by Qt. + + \sa quint64 +*/ + +/*! + \typedef quint16_be + \relates <QtEndian> + \since 5.10 + + Typedef for QBEInteger<quint16>. This type is guaranteed to be stored in memory as + a 16-bit big-endian unsigned integer on all platforms supported by Qt. + + \sa quint16 +*/ + +/*! + \typedef quint32_be + \relates <QtEndian> + \since 5.10 + + Typedef for QBEInteger<quint32>. This type is guaranteed to be stored in memory as + a 32-bit big-endian unsigned integer on all platforms supported by Qt. + + \sa quint32 +*/ + +/*! + \typedef quint64_be + \relates <QtEndian> + \since 5.10 + + Typedef for QBEInteger<quint64>. This type is guaranteed to be stored in memory as + a 64-bit big-endian unsigned integer on all platforms supported by Qt. + + \sa quint64 +*/ + +/*! + \typedef qint16_le + \relates <QtEndian> + \since 5.10 + + Typedef for QLEInteger<qint16>. This type is guaranteed to be stored in memory as + a 16-bit little-endian signed integer on all platforms supported by Qt. + + \sa qint16 +*/ + +/*! + \typedef qint32_le + \relates <QtEndian> + \since 5.10 + + Typedef for QLEInteger<qint32>. This type is guaranteed to be stored in memory as + a 32-bit little-endian signed integer on all platforms supported by Qt. + + \sa qint32 +*/ + +/*! + \typedef qint64_le + \relates <QtEndian> + \since 5.10 + + Typedef for QLEInteger<qint64>. This type is guaranteed to be stored in memory as + a 64-bit little-endian signed integer on all platforms supported by Qt. + + \sa qint64 +*/ + +/*! + \typedef qint16_be + \relates <QtEndian> + \since 5.10 + + Typedef for QBEInteger<qint16>. This type is guaranteed to be stored in memory as + a 16-bit big-endian signed integer on all platforms supported by Qt. + + \sa qint16 +*/ + +/*! + \typedef qint32_be + \relates <QtEndian> + \since 5.10 + + Typedef for QBEInteger<qint32>. This type is guaranteed to be stored in memory as + a 32-bit big-endian signed integer on all platforms supported by Qt. + + \sa qint32 +*/ + +/*! + \typedef qint64_be + \relates <QtEndian> + \since 5.10 + + Typedef for QBEInteger<qint64>. This type is guaranteed to be stored in memory as + a 64-bit big-endian signed integer on all platforms supported by Qt. + + \sa qint64 +*/ diff --git a/src/corelib/global/qendian_p.h b/src/corelib/global/qendian_p.h new file mode 100644 index 0000000000..c830e65b54 --- /dev/null +++ b/src/corelib/global/qendian_p.h @@ -0,0 +1,142 @@ +/**************************************************************************** +** +** Copyright (C) 2017 The Qt Company Ltd. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QENDIAN_P_H +#define QENDIAN_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include <QtCore/qendian.h> + +QT_BEGIN_NAMESPACE + +// Note if using multiple of these bitfields in a union; the underlying storage type must +// match. Since we always use an unsigned storage type, unsigned and signed versions may +// be used together, but different bit-widths may not. +template<class S, int pos, int width> +class QSpecialIntegerBitfield +{ +protected: + typedef typename S::StorageType T; + typedef typename std::make_unsigned<T>::type UT; + + static Q_DECL_CONSTEXPR UT mask() + { + return ((UT(1) << width) - 1) << pos; + } +public: + // FIXME: val is public until qtdeclarative is fixed to not access it directly. + UT val; + + QSpecialIntegerBitfield &operator =(T t) + { + UT i = S::fromSpecial(val); + i &= ~mask(); + i |= (UT(t) << pos) & mask(); + val = S::toSpecial(i); + return *this; + } + operator T() const + { + if (std::is_signed<T>::value) { + UT i = S::fromSpecial(val); + i <<= (sizeof(T) * 8) - width - pos; + T t = T(i); + t >>= (sizeof(T) * 8) - width; + return t; + } + return (S::fromSpecial(val) & mask()) >> pos; + } + + bool operator !() const { return !(val & S::toSpecial(mask())); } + bool operator ==(QSpecialIntegerBitfield<S, pos, width> i) const + { return ((val ^ i.val) & S::toSpecial(mask())) == 0; } + bool operator !=(QSpecialIntegerBitfield<S, pos, width> i) const + { return ((val ^ i.val) & S::toSpecial(mask())) != 0; } + + QSpecialIntegerBitfield &operator +=(T i) + { return (*this = (T(*this) + i)); } + QSpecialIntegerBitfield &operator -=(T i) + { return (*this = (T(*this) - i)); } + QSpecialIntegerBitfield &operator *=(T i) + { return (*this = (T(*this) * i)); } + QSpecialIntegerBitfield &operator /=(T i) + { return (*this = (T(*this) / i)); } + QSpecialIntegerBitfield &operator %=(T i) + { return (*this = (T(*this) % i)); } + QSpecialIntegerBitfield &operator |=(T i) + { return (*this = (T(*this) | i)); } + QSpecialIntegerBitfield &operator &=(T i) + { return (*this = (T(*this) & i)); } + QSpecialIntegerBitfield &operator ^=(T i) + { return (*this = (T(*this) ^ i)); } + QSpecialIntegerBitfield &operator >>=(T i) + { return (*this = (T(*this) >> i)); } + QSpecialIntegerBitfield &operator <<=(T i) + { return (*this = (T(*this) << i)); } +}; + +template<typename T, int pos, int width> +using QLEIntegerBitfield = QSpecialIntegerBitfield<QLittleEndianStorageType<T>, pos, width>; + +template<typename T, int pos, int width> +using QBEIntegerBitfield = QSpecialIntegerBitfield<QBigEndianStorageType<T>, pos, width>; + +template<int pos, int width> +using qint32_le_bitfield = QLEIntegerBitfield<int, pos, width>; +template<int pos, int width> +using quint32_le_bitfield = QLEIntegerBitfield<uint, pos, width>; +template<int pos, int width> +using qint32_be_bitfield = QBEIntegerBitfield<int, pos, width>; +template<int pos, int width> +using quint32_be_bitfield = QBEIntegerBitfield<uint, pos, width>; + + +QT_END_NAMESPACE + +#endif // QENDIAN_P_H diff --git a/src/corelib/global/qfloat16.cpp b/src/corelib/global/qfloat16.cpp index 1de1ae65fb..89edfc8787 100644 --- a/src/corelib/global/qfloat16.cpp +++ b/src/corelib/global/qfloat16.cpp @@ -41,7 +41,11 @@ QT_BEGIN_NAMESPACE -/*! \headerfile <QFloat16> +/*! + \headerfile <QFloat16> + \title 16-bit Floating Point Support + \ingroup funclists + \brief The <QFloat16> header file provides 16-bit floating point support. This header file provides support for half-precision (16-bit) floating point data with the class \c qfloat16. It is fully compliant with IEEE @@ -59,24 +63,6 @@ QT_BEGIN_NAMESPACE \since 5.9 */ -Q_STATIC_ASSERT_X(sizeof(float) == sizeof(quint32), - "qfloat16 assumes that floats are 32 bits wide"); - -// There are a few corner cases regarding denormals where GHS compiler is relying -// hardware behavior that is not IEC 559 compliant. Therefore the compiler -// reports std::numeric_limits<float>::is_iec559 as false. This is all right -// according to our needs. - -#if !defined(Q_CC_GHS) -Q_STATIC_ASSERT_X(std::numeric_limits<float>::is_iec559, - "Only works with IEEE 754 floating point"); -#endif - -Q_STATIC_ASSERT_X(std::numeric_limits<float>::has_infinity && - std::numeric_limits<float>::has_quiet_NaN && - std::numeric_limits<float>::has_signaling_NaN, - "Only works with IEEE 754 floating point"); - /*! Returns true if the \c qfloat16 \a {f} is equivalent to infinity. \relates <QFloat16> diff --git a/src/corelib/global/qglobal.cpp b/src/corelib/global/qglobal.cpp index b5cc88534e..f2f807e1d9 100644 --- a/src/corelib/global/qglobal.cpp +++ b/src/corelib/global/qglobal.cpp @@ -42,7 +42,6 @@ #include "qstring.h" #include "qvector.h" #include "qlist.h" -#include "qthreadstorage.h" #include "qdir.h" #include "qdatetime.h" #include "qoperatingsystemversion.h" @@ -131,6 +130,38 @@ Q_CORE_EXPORT void *qMemSet(void *dest, int c, size_t n); Q_STATIC_ASSERT_X(sizeof(int) == 4, "Qt assumes that int is 32 bits"); Q_STATIC_ASSERT_X(UCHAR_MAX == 255, "Qt assumes that char is 8 bits"); Q_STATIC_ASSERT_X(QT_POINTER_SIZE == sizeof(void *), "QT_POINTER_SIZE defined incorrectly"); +Q_STATIC_ASSERT_X(sizeof(float) == 4, "Qt assumes that float is 32 bits"); + +// 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 GHC the compiler reports std::numeric_limits<float>::is_iec559 as false. +// This is all right according to our needs. +#if !defined(Q_CC_GHS) +Q_STATIC_ASSERT_X(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... +Q_STATIC_ASSERT_X(std::numeric_limits<float>::has_infinity && + std::numeric_limits<float>::has_quiet_NaN && + std::numeric_limits<float>::has_signaling_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. +Q_STATIC_ASSERT_X(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 +Q_STATIC_ASSERT_X(sizeof(size_t) == sizeof(void *), "size_t and a pointer don't have the same size"); +Q_STATIC_ASSERT(sizeof(size_t) == sizeof(qssize_t)); // implied by the definition +Q_STATIC_ASSERT((std::is_same<qssize_t, qptrdiff>::value)); /*! \class QFlag @@ -793,6 +824,21 @@ Q_STATIC_ASSERT_X(QT_POINTER_SIZE == sizeof(void *), "QT_POINTER_SIZE defined in */ /*! + \typedef qssize_t + \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 qssize_t is signed. Use \c size_t for unsigned values. + + \sa qptrdiff +*/ + +/*! \enum QtMsgType \relates <QtGlobal> @@ -3091,7 +3137,7 @@ void qt_assert_x(const char *where, const char *what, const char *file, int line Deliberately not exported as part of the Qt API, but used in both qsimplerichtext.cpp and qgfxraster_qws.cpp */ -Q_CORE_EXPORT unsigned int qt_int_sqrt(unsigned int n) +Q_CORE_EXPORT Q_DECL_CONST_FUNCTION unsigned int qt_int_sqrt(unsigned int n) { // n must be in the range 0...UINT_MAX/2-1 if (n >= (UINT_MAX>>2)) { @@ -3121,24 +3167,27 @@ void *qMemSet(void *dest, int c, size_t n) { return memset(dest, c, n); } // add thread-safety for the Qt wrappers. static QBasicMutex environmentMutex; -// getenv is declared as deprecated in VS2005. This function -// makes use of the new secure getenv function. /*! \relates <QtGlobal> + \threadsafe - Returns the value of the environment variable with name \a - varName. To get the variable string, use QByteArray::constData(). - To convert the data to a QString use QString::fromLocal8Bit(). + Returns the value of the environment variable with name \a varName as a + QByteArray. If no variable by that name is found in the environment, this + function returns a default-constructed QByteArray. - \note qgetenv() was introduced because getenv() from the standard - C library was deprecated in VC2005 (and later versions). qgetenv() - uses the new replacement function in VC, and calls the standard C - library's implementation on all other platforms. + The Qt environment manipulation functions are thread-safe, but this + requires that the C library equivalent functions like getenv and putenv are + not directly called. - \warning Don't use qgetenv on Windows if the content may contain - non-US-ASCII characters, like file paths. + To convert the data to a QString use QString::fromLocal8Bit(). + + \note on desktop Windows, qgetenv() may produce data loss if the + original string contains Unicode characters not representable in the + ANSI encoding. Use qEnvironmentVariable() instead. + On Unix systems, this function is lossless. - \sa qputenv(), qEnvironmentVariableIsSet(), qEnvironmentVariableIsEmpty() + \sa qputenv(), qEnvironmentVariable(), qEnvironmentVariableIsSet(), + qEnvironmentVariableIsEmpty() */ QByteArray qgetenv(const char *varName) { @@ -3160,6 +3209,87 @@ QByteArray qgetenv(const char *varName) #endif } + +/*! + \relates <QtGlobal> + \since 5.10 + + Returns the value of the environment variable with name \a varName as a + QString. If no variable by that name is found in the environment, this + function returns \a defaultValue. + + The Qt environment manipulation functions are thread-safe, but this + requires that the C library equivalent functions like getenv and putenv are + not directly called. + + The following table describes how to choose between qgetenv() and + qEnvironmentVariable(): + \table + \header \li Condition \li Recommendation + \row + \li Variable contains file paths or user text + \li qEnvironmentVariable() + \row + \li Windows-specific code + \li qEnvironmentVariable() + \row + \li Unix-specific code, destination variable is not QString and/or is + used to interface with non-Qt APIs + \li qgetenv() + \row + \li Destination variable is a QString + \li qEnvironmentVariable() + \row + \li Destination variable is a QByteArray or std::string + \li qgetenv() + \endtable + + \note on Unix systems, this function may produce data loss if the original + string contains arbitrary binary data that cannot be decoded by the locale + codec. Use qgetenv() instead for that case. On Windows, this function is + lossless. + + \note the variable name \a varName must contain only US-ASCII characters. + + \sa qputenv(), qgetenv(), qEnvironmentVariableIsSet(), qEnvironmentVariableIsEmpty() +*/ +QString qEnvironmentVariable(const char *varName, const QString &defaultValue) +{ +#if defined(Q_OS_WIN) && !defined(Q_OS_WINRT) + QMutexLocker locker(&environmentMutex); + QVarLengthArray<wchar_t, 32> wname(int(strlen(varName)) + 1); + for (int i = 0; i < wname.size(); ++i) // wname.size() is correct: will copy terminating null + wname[i] = uchar(varName[i]); + size_t requiredSize = 0; + QString buffer; + _wgetenv_s(&requiredSize, 0, 0, wname.data()); + if (requiredSize == 0) + return defaultValue; + buffer.resize(int(requiredSize)); + _wgetenv_s(&requiredSize, reinterpret_cast<wchar_t *>(buffer.data()), requiredSize, + wname.data()); + // requiredSize includes the terminating null, which we don't want. + Q_ASSERT(buffer.endsWith(QLatin1Char('\0'))); + buffer.chop(1); + return buffer; +#else + QByteArray value = qgetenv(varName); + if (value.isNull()) + return defaultValue; +// duplicated in qfile.h (QFile::decodeName) +#if defined(Q_OS_DARWIN) + return QString::fromUtf8(value).normalized(QString::NormalizationForm_C); +#else // other Unix + return QString::fromLocal8Bit(value); +#endif +#endif +} + +QString qEnvironmentVariable(const char *varName) +{ + return qEnvironmentVariable(varName, QString()); +} + /*! \relates <QtGlobal> \since 5.1 @@ -3172,7 +3302,7 @@ QByteArray qgetenv(const char *varName) \endcode except that it's potentially much faster, and can't throw exceptions. - \sa qgetenv(), qEnvironmentVariableIsSet() + \sa qgetenv(), qEnvironmentVariable(), qEnvironmentVariableIsSet() */ bool qEnvironmentVariableIsEmpty(const char *varName) Q_DECL_NOEXCEPT { @@ -3209,7 +3339,7 @@ bool qEnvironmentVariableIsEmpty(const char *varName) Q_DECL_NOEXCEPT are too long will either be truncated or this function will set \a ok to \c false. - \sa qgetenv(), qEnvironmentVariableIsSet() + \sa qgetenv(), qEnvironmentVariable(), qEnvironmentVariableIsSet() */ int qEnvironmentVariableIntValue(const char *varName, bool *ok) Q_DECL_NOEXCEPT { @@ -3260,7 +3390,7 @@ int qEnvironmentVariableIntValue(const char *varName, bool *ok) Q_DECL_NOEXCEPT \endcode except that it's potentially much faster, and can't throw exceptions. - \sa qgetenv(), qEnvironmentVariableIsEmpty() + \sa qgetenv(), qEnvironmentVariable(), qEnvironmentVariableIsEmpty() */ bool qEnvironmentVariableIsSet(const char *varName) Q_DECL_NOEXCEPT { @@ -3290,7 +3420,7 @@ bool qEnvironmentVariableIsSet(const char *varName) Q_DECL_NOEXCEPT uses the replacement function in VC, and calls the standard C library's implementation on all other platforms. - \sa qgetenv() + \sa qgetenv(), qEnvironmentVariable() */ bool qputenv(const char *varName, const QByteArray& value) { @@ -3321,7 +3451,7 @@ bool qputenv(const char *varName, const QByteArray& value) \since 5.1 - \sa qputenv(), qgetenv() + \sa qputenv(), qgetenv(), qEnvironmentVariable() */ bool qunsetenv(const char *varName) { @@ -3346,138 +3476,6 @@ bool qunsetenv(const char *varName) #endif } -#if defined(Q_OS_ANDROID) && (__ANDROID_API__ < 21) -typedef QThreadStorage<QJNIObjectPrivate> AndroidRandomStorage; -Q_GLOBAL_STATIC(AndroidRandomStorage, randomTLS) - -#elif defined(Q_OS_UNIX) && !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && (_POSIX_THREAD_SAFE_FUNCTIONS - 0 > 0) - -# if defined(Q_OS_INTEGRITY) && defined(__GHS_VERSION_NUMBER) && (__GHS_VERSION_NUMBER < 500) -// older versions of INTEGRITY used a long instead of a uint for the seed. -typedef long SeedStorageType; -# else -typedef uint SeedStorageType; -# endif - -typedef QThreadStorage<SeedStorageType *> SeedStorage; -Q_GLOBAL_STATIC(SeedStorage, randTLS) // Thread Local Storage for seed value -#endif - -/*! - \relates <QtGlobal> - \since 4.2 - - Thread-safe version of the standard C++ \c srand() function. - - Sets the argument \a seed to be used to generate a new random number sequence of - pseudo random integers to be returned by qrand(). - - The sequence of random numbers generated is deterministic per thread. For example, - if two threads call qsrand(1) and subsequently call qrand(), the threads will get - the same random number sequence. - - \sa qrand() -*/ -void qsrand(uint seed) -{ -#if defined(Q_OS_ANDROID) && (__ANDROID_API__ < 21) - if (randomTLS->hasLocalData()) { - randomTLS->localData().callMethod<void>("setSeed", "(J)V", jlong(seed)); - return; - } - - QJNIObjectPrivate random("java/util/Random", - "(J)V", - jlong(seed)); - if (!random.isValid()) { - srand(seed); - return; - } - - randomTLS->setLocalData(random); -#elif defined(Q_OS_UNIX) && !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && (_POSIX_THREAD_SAFE_FUNCTIONS - 0 > 0) - SeedStorage *seedStorage = randTLS(); - if (seedStorage) { - SeedStorageType *pseed = seedStorage->localData(); - if (!pseed) - seedStorage->setLocalData(pseed = new SeedStorageType); - *pseed = seed; - } else { - //global static seed storage should always exist, - //except after being deleted by QGlobalStaticDeleter. - //But since it still can be called from destructor of another - //global static object, fallback to srand(seed) - srand(seed); - } -#else - // On Windows srand() and rand() already use Thread-Local-Storage - // to store the seed between calls - // this is also valid for QT_NO_THREAD - srand(seed); -#endif -} - -/*! - \relates <QtGlobal> - \since 4.2 - - Thread-safe version of the standard C++ \c rand() function. - - Returns a value between 0 and \c RAND_MAX (defined in \c <cstdlib> and - \c <stdlib.h>), the next number in the current sequence of pseudo-random - integers. - - Use \c qsrand() to initialize the pseudo-random number generator with - a seed value. - - \sa qsrand() -*/ -int qrand() -{ -#if defined(Q_OS_ANDROID) && (__ANDROID_API__ < 21) - AndroidRandomStorage *randomStorage = randomTLS(); - if (!randomStorage) - return rand(); - - if (randomStorage->hasLocalData()) { - return randomStorage->localData().callMethod<jint>("nextInt", - "(I)I", - RAND_MAX); - } - - QJNIObjectPrivate random("java/util/Random", - "(J)V", - jlong(1)); - - if (!random.isValid()) - return rand(); - - randomStorage->setLocalData(random); - return random.callMethod<jint>("nextInt", "(I)I", RAND_MAX); -#elif defined(Q_OS_UNIX) && !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && (_POSIX_THREAD_SAFE_FUNCTIONS - 0 > 0) - SeedStorage *seedStorage = randTLS(); - if (seedStorage) { - SeedStorageType *pseed = seedStorage->localData(); - if (!pseed) { - seedStorage->setLocalData(pseed = new SeedStorageType); - *pseed = 1; - } - return rand_r(pseed); - } else { - //global static seed storage should always exist, - //except after being deleted by QGlobalStaticDeleter. - //But since it still can be called from destructor of another - //global static object, fallback to rand() - return rand(); - } -#else - // On Windows srand() and rand() already use Thread-Local-Storage - // to store the seed between calls - // this is also valid for QT_NO_THREAD - return rand(); -#endif -} - /*! \macro forever \relates <QtGlobal> @@ -4377,8 +4375,11 @@ bool QInternal::activateCallbacks(Callback cb, void **parameters) stderr. Under Windows, the message is sent to the debugger. On QNX the message is sent to slogger2. This function does nothing if \c QT_NO_WARNING_OUTPUT was defined - during compilation; it exits if the environment variable \c - QT_FATAL_WARNINGS is not empty. + during compilation; it exits if at the nth warning corresponding to the + counter in environment variable \c QT_FATAL_WARNINGS. That is, if the + environment variable contains the value 1, it will exit on the 1st message; + if it contains the value 10, it will exit on the 10th message. Any + non-numeric value is equivalent to 1. This function takes a format string and a list of arguments, similar to the C printf() function. The format should be a Latin-1 diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h index 6023cc8564..ff388770f5 100644 --- a/src/corelib/global/qglobal.h +++ b/src/corelib/global/qglobal.h @@ -46,8 +46,9 @@ # include <cstddef> # include <utility> #endif - -#include <stddef.h> +#ifndef __ASSEMBLER__ +# include <stddef.h> +#endif /* QT_VERSION is (major << 16) + (minor << 8) + patch. @@ -188,6 +189,7 @@ namespace QT_NAMESPACE {} # define QT_LARGEFILE_SUPPORT 64 #endif +#ifndef __ASSEMBLER__ QT_BEGIN_NAMESPACE /* @@ -355,7 +357,7 @@ typedef double qreal; #if !defined(QT_NAMESPACE) && defined(__cplusplus) && !defined(Q_QDOC) extern "C" #endif -Q_CORE_EXPORT const char *qVersion() Q_DECL_NOTHROW; +Q_CORE_EXPORT Q_DECL_CONST_FUNCTION const char *qVersion() Q_DECL_NOTHROW; #if defined(__cplusplus) @@ -436,6 +438,9 @@ namespace QtPrivate { sizeof(void *) == sizeof(quintptr) && sizeof(void *) == sizeof(qptrdiff) + + size_t and qssize_t are not guaranteed to be the same size as a pointer, but + they usually are. */ template <int> struct QIntegerForSize; template <> struct QIntegerForSize<1> { typedef quint8 Unsigned; typedef qint8 Signed; }; @@ -451,6 +456,7 @@ typedef QIntegerForSize<Q_PROCESSOR_WORDSIZE>::Unsigned qregisteruint; typedef QIntegerForSizeof<void*>::Unsigned quintptr; typedef QIntegerForSizeof<void*>::Signed qptrdiff; typedef qptrdiff qintptr; +using qssize_t = QIntegerForSizeof<std::size_t>::Signed; /* moc compats (signals/slots) */ #ifndef QT_MOC_COMPAT @@ -612,6 +618,18 @@ private: void *pool; }; +#else + +#define QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(macos, ios, tvos, watchos) (0) +#define QT_MACOS_IOS_PLATFORM_SDK_EQUAL_OR_ABOVE(macos, ios) (0) +#define QT_MACOS_PLATFORM_SDK_EQUAL_OR_ABOVE(macos) (0) +#define QT_IOS_PLATFORM_SDK_EQUAL_OR_ABOVE(ios) (0) +#define QT_TVOS_PLATFORM_SDK_EQUAL_OR_ABOVE(tvos) (0) +#define QT_WATCHOS_PLATFORM_SDK_EQUAL_OR_ABOVE(watchos) (0) + +#define QT_MAC_PLATFORM_SDK_EQUAL_OR_ABOVE(osx, ios) (0) +#define QT_OSX_PLATFORM_SDK_EQUAL_OR_ABOVE(osx) (0) + #endif // Q_OS_DARWIN /* @@ -660,7 +678,7 @@ Q_NORETURN Q_CORE_EXPORT void qTerminate() Q_DECL_NOTHROW; # endif #endif -Q_CORE_EXPORT bool qSharedBuild() Q_DECL_NOTHROW; +Q_CORE_EXPORT Q_DECL_CONST_FUNCTION bool qSharedBuild() Q_DECL_NOTHROW; #ifndef Q_OUTOFLINE_TEMPLATE # define Q_OUTOFLINE_TEMPLATE @@ -709,9 +727,9 @@ Q_CORE_EXPORT void qt_assert(const char *assertion, const char *file, int line) #if !defined(Q_ASSERT) # if defined(QT_NO_DEBUG) && !defined(QT_FORCE_ASSERTS) -# define Q_ASSERT(cond) do { } while ((false) && (cond)) +# define Q_ASSERT(cond) static_cast<void>(false && (cond)) # else -# define Q_ASSERT(cond) ((!(cond)) ? qt_assert(#cond,__FILE__,__LINE__) : qt_noop()) +# define Q_ASSERT(cond) ((cond) ? static_cast<void>(0) : qt_assert(#cond, __FILE__, __LINE__)) # endif #endif @@ -726,9 +744,9 @@ Q_CORE_EXPORT void qt_assert_x(const char *where, const char *what, const char * #if !defined(Q_ASSERT_X) # if defined(QT_NO_DEBUG) && !defined(QT_FORCE_ASSERTS) -# define Q_ASSERT_X(cond, where, what) do { } while ((false) && (cond)) +# define Q_ASSERT_X(cond, where, what) static_cast<void>(false && (cond)) # else -# define Q_ASSERT_X(cond, where, what) ((!(cond)) ? qt_assert_x(where, what,__FILE__,__LINE__) : qt_noop()) +# define Q_ASSERT_X(cond, where, what) ((cond) ? static_cast<void>(0) : qt_assert_x(where, what, __FILE__, __LINE__)) # endif #endif @@ -915,13 +933,9 @@ QT_WARNING_DISABLE_MSVC(4530) /* C++ exception handler used, but unwind semantic # endif #endif -namespace QtPrivate { -template <typename T> struct QAddConst { typedef const T Type; }; -} - // this adds const to non-const objects (like std::as_const) template <typename T> -Q_DECL_CONSTEXPR typename QtPrivate::QAddConst<T>::Type &qAsConst(T &t) Q_DECL_NOTHROW { return t; } +Q_DECL_CONSTEXPR typename std::add_const<T>::type &qAsConst(T &t) Q_DECL_NOTHROW { return t; } // prevent rvalue arguments: template <typename T> void qAsConst(const T &&) Q_DECL_EQ_DELETE; @@ -1112,6 +1126,13 @@ template <typename... Args> Q_CONSTEXPR Q_DECL_UNUSED QNonConstOverload<Args...> class QByteArray; Q_CORE_EXPORT QByteArray qgetenv(const char *varName); +#ifdef Q_QDOC +Q_CORE_EXPORT QString qEnvironmentVariable(const char *varName, + const QString &defaultValue = QString()); +#else // need it as two functions because QString is only forward-declared here +Q_CORE_EXPORT QString qEnvironmentVariable(const char *varName); +Q_CORE_EXPORT QString qEnvironmentVariable(const char *varName, const QString &defaultValue); +#endif Q_CORE_EXPORT bool qputenv(const char *varName, const QByteArray& value); Q_CORE_EXPORT bool qunsetenv(const char *varName); @@ -1161,5 +1182,6 @@ QT_END_NAMESPACE #include <QtCore/qversiontagging.h> #endif /* __cplusplus */ +#endif /* !__ASSEMBLER__ */ #endif /* QGLOBAL_H */ diff --git a/src/corelib/global/qlogging.cpp b/src/corelib/global/qlogging.cpp index b5ba935194..6602d53b08 100644 --- a/src/corelib/global/qlogging.cpp +++ b/src/corelib/global/qlogging.cpp @@ -153,19 +153,39 @@ Q_NORETURN static void qt_message_fatal(QtMsgType, const QMessageLogContext &context, const QString &message); static void qt_message_print(QtMsgType, const QMessageLogContext &context, const QString &message); +static int checked_var_value(const char *varname) +{ + // qEnvironmentVariableIntValue returns 0 on both parsing failure and on + // empty, but we need to distinguish between the two for backwards + // compatibility reasons. + QByteArray str = qgetenv(varname); + if (str.isEmpty()) + return 0; + + bool ok; + int value = str.toInt(&ok, 0); + return ok ? value : 1; +} + static bool isFatal(QtMsgType msgType) { if (msgType == QtFatalMsg) return true; if (msgType == QtCriticalMsg) { - static bool fatalCriticals = !qEnvironmentVariableIsEmpty("QT_FATAL_CRITICALS"); - return fatalCriticals; + static QAtomicInt fatalCriticals = checked_var_value("QT_FATAL_CRITICALS"); + + // it's fatal if the current value is exactly 1, + // otherwise decrement if it's non-zero + return fatalCriticals.load() && fatalCriticals.fetchAndAddRelaxed(-1) == 1; } if (msgType == QtWarningMsg || msgType == QtCriticalMsg) { - static bool fatalWarnings = !qEnvironmentVariableIsEmpty("QT_FATAL_WARNINGS"); - return fatalWarnings; + static QAtomicInt fatalWarnings = checked_var_value("QT_FATAL_WARNINGS"); + + // it's fatal if the current value is exactly 1, + // otherwise decrement if it's non-zero + return fatalWarnings.load() && fatalWarnings.fetchAndAddRelaxed(-1) == 1; } return false; diff --git a/src/corelib/global/qnamespace.h b/src/corelib/global/qnamespace.h index da44c01594..ab83730caa 100644 --- a/src/corelib/global/qnamespace.h +++ b/src/corelib/global/qnamespace.h @@ -241,8 +241,11 @@ public: TextForceRightToLeft = 0x40000, // Ensures that the longest variant is always used when computing the // size of a multi-variant string. - TextLongestVariant = 0x80000, - TextBypassShaping = 0x100000 + TextLongestVariant = 0x80000 + +#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) + , TextBypassShaping = 0x100000 +#endif }; enum TextElideMode { @@ -508,6 +511,9 @@ public: AA_CompressHighFrequencyEvents = 25, AA_DontCheckOpenGLContextThreadAffinity = 26, AA_DisableShaderDiskCache = 27, + AA_DontShowShortcutsInContextMenus = 28, + AA_CompressTabletEvents = 29, + AA_DisableWindowContextHelpButton = 30, // ### Qt 6: remove me // Add new attributes before this line AA_AttributeCount diff --git a/src/corelib/global/qnamespace.qdoc b/src/corelib/global/qnamespace.qdoc index efa8e26938..e74ba4026a 100644 --- a/src/corelib/global/qnamespace.qdoc +++ b/src/corelib/global/qnamespace.qdoc @@ -114,6 +114,11 @@ \macos menubar \e{may not} pick up a change in this attribute. Changes in the QAction::iconVisibleInMenu property will always be picked up. + \value AA_DontShowShortcutsInContextMenus Actions with the Shortcut property + won't be shown in any shortcut menus unless specifically set by the + QAction::shortcutVisibleInContextMenu property. This value has + been added in Qt 5.10. + \value AA_NativeWindows Ensures that widgets have native windows. \value AA_DontCreateNativeWidgetSiblings Ensures that siblings of native @@ -244,7 +249,14 @@ (In the future, the compression feature may be implemented across platforms.) You can test the attribute to see whether compression is enabled. If your application needs to handle all events with no compression, - you can unset this attribute. This value has been added in Qt 5.7. + you can unset this attribute. Notice that input events from tablet devices + will not be compressed. See AA_CompressTabletEvents if you want these to be + compressed as well. This value has been added in Qt 5.7. + + \value AA_CompressTabletEvents Enables compression of input events from tablet devices. + Notice that AA_CompressHighFrequencyEvents must be true for events compression + to be enabled, and that this flag extends the former to tablet events. Its default + value is false. This value has been added in Qt 5.10. \value AA_DontCheckOpenGLContextThreadAffinity When making a context current using QOpenGLContext, do not check that the @@ -262,6 +274,12 @@ \e glProgramBinary(). In the unlikely event of this being problematic, set this attribute to disable all disk-based caching of shaders. + \value AA_DisableWindowContextHelpButton Disables the WindowContextHelpButtonHint + by default on Qt::Sheet and Qt::Dialog widgets. This hides the \gui ? button + on Windows, which only makes sense if you use \l QWhatsThis functionality. + This value has been added in Qt 5.10. For Qt 6, WindowContextHelpButtonHint + will not be set by default. + The following values are deprecated or obsolete: \value AA_ImmediateWidgetCreation This attribute is no longer fully @@ -664,8 +682,9 @@ be short, localized names. This is basically equivalent to using the date format string, "ddd MMM d yyyy". See QDate::toString() for more information. - \value ISODate \l{ISO 8601} extended format: either \c{YYYY-MM-DD} for dates or - \c{YYYY-MM-DDTHH:mm:ss}, \c{YYYY-MM-DDTHH:mm:ssTZD} (e.g., 1997-07-16T19:20:30+01:00) + \value ISODate \l{ISO 8601} extended format: either \c{yyyy-MM-dd} for dates or + \c{yyyy-MM-ddTHH:mm:ss} (e.g. 2017-07-24T15:46:29), or with a time-zone + suffix (Z for UTC otherwise an offset as [+|-]HH:mm) where appropriate for combined dates and times. \value ISODateWithMs \l{ISO 8601} extended format, including milliseconds if applicable. diff --git a/src/corelib/global/qnumeric.h b/src/corelib/global/qnumeric.h index 80be984bef..535a96aaec 100644 --- a/src/corelib/global/qnumeric.h +++ b/src/corelib/global/qnumeric.h @@ -45,15 +45,15 @@ QT_BEGIN_NAMESPACE -Q_CORE_EXPORT bool qIsInf(double d); -Q_CORE_EXPORT bool qIsNaN(double d); -Q_CORE_EXPORT bool qIsFinite(double d); -Q_CORE_EXPORT bool qIsInf(float f); -Q_CORE_EXPORT bool qIsNaN(float f); -Q_CORE_EXPORT bool qIsFinite(float f); -Q_CORE_EXPORT double qSNaN(); -Q_CORE_EXPORT double qQNaN(); -Q_CORE_EXPORT double qInf(); +Q_CORE_EXPORT Q_DECL_CONST_FUNCTION bool qIsInf(double d); +Q_CORE_EXPORT Q_DECL_CONST_FUNCTION bool qIsNaN(double d); +Q_CORE_EXPORT Q_DECL_CONST_FUNCTION bool qIsFinite(double d); +Q_CORE_EXPORT Q_DECL_CONST_FUNCTION bool qIsInf(float f); +Q_CORE_EXPORT Q_DECL_CONST_FUNCTION bool qIsNaN(float f); +Q_CORE_EXPORT Q_DECL_CONST_FUNCTION bool qIsFinite(float f); +Q_CORE_EXPORT Q_DECL_CONST_FUNCTION double qSNaN(); +Q_CORE_EXPORT Q_DECL_CONST_FUNCTION double qQNaN(); +Q_CORE_EXPORT Q_DECL_CONST_FUNCTION double qInf(); Q_CORE_EXPORT quint32 qFloatDistance(float a, float b); Q_CORE_EXPORT quint64 qFloatDistance(double a, double b); diff --git a/src/corelib/global/qnumeric_p.h b/src/corelib/global/qnumeric_p.h index 2291675501..37eddfa9b5 100644 --- a/src/corelib/global/qnumeric_p.h +++ b/src/corelib/global/qnumeric_p.h @@ -73,12 +73,12 @@ QT_BEGIN_NAMESPACE namespace qnumeric_std_wrapper { // the 'using namespace std' below is cases where the stdlib already put the math.h functions in the std namespace and undefined the macros. -static inline bool math_h_isnan(double d) { using namespace std; return isnan(d); } -static inline bool math_h_isinf(double d) { using namespace std; return isinf(d); } -static inline bool math_h_isfinite(double d) { using namespace std; return isfinite(d); } -static inline bool math_h_isnan(float f) { using namespace std; return isnan(f); } -static inline bool math_h_isinf(float f) { using namespace std; return isinf(f); } -static inline bool math_h_isfinite(float f) { using namespace std; return isfinite(f); } +Q_DECL_CONST_FUNCTION static inline bool math_h_isnan(double d) { using namespace std; return isnan(d); } +Q_DECL_CONST_FUNCTION static inline bool math_h_isinf(double d) { using namespace std; return isinf(d); } +Q_DECL_CONST_FUNCTION static inline bool math_h_isfinite(double d) { using namespace std; return isfinite(d); } +Q_DECL_CONST_FUNCTION static inline bool math_h_isnan(float f) { using namespace std; return isnan(f); } +Q_DECL_CONST_FUNCTION static inline bool math_h_isinf(float f) { using namespace std; return isinf(f); } +Q_DECL_CONST_FUNCTION static inline bool math_h_isfinite(float f) { using namespace std; return isfinite(f); } } QT_END_NAMESPACE // These macros from math.h conflict with the real functions in the std namespace. @@ -94,23 +94,23 @@ QT_BEGIN_NAMESPACE namespace qnumeric_std_wrapper { #if defined(QT_MATH_H_DEFINES_MACROS) # undef QT_MATH_H_DEFINES_MACROS -static inline bool isnan(double d) { return math_h_isnan(d); } -static inline bool isinf(double d) { return math_h_isinf(d); } -static inline bool isfinite(double d) { return math_h_isfinite(d); } -static inline bool isnan(float f) { return math_h_isnan(f); } -static inline bool isinf(float f) { return math_h_isinf(f); } -static inline bool isfinite(float f) { return math_h_isfinite(f); } +Q_DECL_CONST_FUNCTION static inline bool isnan(double d) { return math_h_isnan(d); } +Q_DECL_CONST_FUNCTION static inline bool isinf(double d) { return math_h_isinf(d); } +Q_DECL_CONST_FUNCTION static inline bool isfinite(double d) { return math_h_isfinite(d); } +Q_DECL_CONST_FUNCTION static inline bool isnan(float f) { return math_h_isnan(f); } +Q_DECL_CONST_FUNCTION static inline bool isinf(float f) { return math_h_isinf(f); } +Q_DECL_CONST_FUNCTION static inline bool isfinite(float f) { return math_h_isfinite(f); } #else -static inline bool isnan(double d) { return std::isnan(d); } -static inline bool isinf(double d) { return std::isinf(d); } -static inline bool isfinite(double d) { return std::isfinite(d); } -static inline bool isnan(float f) { return std::isnan(f); } -static inline bool isinf(float f) { return std::isinf(f); } -static inline bool isfinite(float f) { return std::isfinite(f); } +Q_DECL_CONST_FUNCTION static inline bool isnan(double d) { return std::isnan(d); } +Q_DECL_CONST_FUNCTION static inline bool isinf(double d) { return std::isinf(d); } +Q_DECL_CONST_FUNCTION static inline bool isfinite(double d) { return std::isfinite(d); } +Q_DECL_CONST_FUNCTION static inline bool isnan(float f) { return std::isnan(f); } +Q_DECL_CONST_FUNCTION static inline bool isinf(float f) { return std::isinf(f); } +Q_DECL_CONST_FUNCTION static inline bool isfinite(float f) { return std::isfinite(f); } #endif } -Q_DECL_CONSTEXPR static inline double qt_inf() Q_DECL_NOEXCEPT +Q_DECL_CONSTEXPR Q_DECL_CONST_FUNCTION static inline double qt_inf() Q_DECL_NOEXCEPT { Q_STATIC_ASSERT_X(std::numeric_limits<double>::has_infinity, "platform has no definition for infinity for type double"); @@ -118,7 +118,7 @@ Q_DECL_CONSTEXPR static inline double qt_inf() Q_DECL_NOEXCEPT } // Signaling NaN -Q_DECL_CONSTEXPR static inline double qt_snan() Q_DECL_NOEXCEPT +Q_DECL_CONSTEXPR Q_DECL_CONST_FUNCTION static inline double qt_snan() Q_DECL_NOEXCEPT { Q_STATIC_ASSERT_X(std::numeric_limits<double>::has_signaling_NaN, "platform has no definition for signaling NaN for type double"); @@ -126,39 +126,39 @@ Q_DECL_CONSTEXPR static inline double qt_snan() Q_DECL_NOEXCEPT } // Quiet NaN -Q_DECL_CONSTEXPR static inline double qt_qnan() Q_DECL_NOEXCEPT +Q_DECL_CONSTEXPR Q_DECL_CONST_FUNCTION static inline double qt_qnan() Q_DECL_NOEXCEPT { Q_STATIC_ASSERT_X(std::numeric_limits<double>::has_quiet_NaN, "platform has no definition for quiet NaN for type double"); return std::numeric_limits<double>::quiet_NaN(); } -static inline bool qt_is_inf(double d) +Q_DECL_CONST_FUNCTION static inline bool qt_is_inf(double d) { return qnumeric_std_wrapper::isinf(d); } -static inline bool qt_is_nan(double d) +Q_DECL_CONST_FUNCTION static inline bool qt_is_nan(double d) { return qnumeric_std_wrapper::isnan(d); } -static inline bool qt_is_finite(double d) +Q_DECL_CONST_FUNCTION static inline bool qt_is_finite(double d) { return qnumeric_std_wrapper::isfinite(d); } -static inline bool qt_is_inf(float f) +Q_DECL_CONST_FUNCTION static inline bool qt_is_inf(float f) { return qnumeric_std_wrapper::isinf(f); } -static inline bool qt_is_nan(float f) +Q_DECL_CONST_FUNCTION static inline bool qt_is_nan(float f) { return qnumeric_std_wrapper::isnan(f); } -static inline bool qt_is_finite(float f) +Q_DECL_CONST_FUNCTION static inline bool qt_is_finite(float f) { return qnumeric_std_wrapper::isfinite(f); } diff --git a/src/corelib/global/qrandom.cpp b/src/corelib/global/qrandom.cpp new file mode 100644 index 0000000000..395bf0b0cb --- /dev/null +++ b/src/corelib/global/qrandom.cpp @@ -0,0 +1,1050 @@ +/**************************************************************************** +** +** Copyright (C) 2017 Intel Corporation. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// for rand_s +#define _CRT_RAND_S + +#include "qrandom.h" +#include "qrandom_p.h" +#include <qobjectdefs.h> +#include <qthreadstorage.h> +#include <private/qsimd_p.h> + +#include <errno.h> + +#if QT_CONFIG(getentropy) +# include <sys/random.h> +#else +# if QT_CONFIG(cxx11_random) +# include <random> +# include "qdeadlinetimer.h" +# include "qhashfunctions.h" +# endif + +# if QT_CONFIG(getauxval) +# include <sys/auxv.h> +# endif +#endif // !QT_CONFIG(getentropy) + +#ifdef Q_OS_UNIX +# include <fcntl.h> +# include <private/qcore_unix_p.h> +#else +# include <qt_windows.h> + +// RtlGenRandom is not exported by its name in advapi32.dll, but as SystemFunction036 +// See https://msdn.microsoft.com/en-us/library/windows/desktop/aa387694(v=vs.85).aspx +// Implementation inspired on https://hg.mozilla.org/mozilla-central/file/722fdbff1efc/security/nss/lib/freebl/win_rand.c#l146 +// Argument why this is safe to use: https://bugzilla.mozilla.org/show_bug.cgi?id=504270 +extern "C" { +DECLSPEC_IMPORT BOOLEAN WINAPI SystemFunction036(PVOID RandomBuffer, ULONG RandomBufferLength); +} +#endif + +#if defined(Q_OS_ANDROID) +# include <private/qjni_p.h> +#endif + +// This file is too low-level for regular Q_ASSERT (the logging framework may +// recurse back), so use regular assert() +#undef NDEBUG +#undef Q_ASSERT_X +#undef Q_ASSERT +#define Q_ASSERT(cond) assert(cond) +#if defined(QT_NO_DEBUG) && !defined(QT_FORCE_ASSERTS) +# define NDEBUG 1 +#endif +#include <assert.h> + +QT_BEGIN_NAMESPACE + +#if defined(Q_PROCESSOR_X86) && QT_COMPILER_SUPPORTS_HERE(RDRND) +static qssize_t qt_random_cpu(void *buffer, qssize_t count); + +# ifdef Q_PROCESSOR_X86_64 +# define _rdrandXX_step _rdrand64_step +# else +# define _rdrandXX_step _rdrand32_step +# endif + +static QT_FUNCTION_TARGET(RDRND) qssize_t qt_random_cpu(void *buffer, qssize_t count) +{ + unsigned *ptr = reinterpret_cast<unsigned *>(buffer); + unsigned *end = ptr + count; + + while (ptr + sizeof(qregisteruint)/sizeof(*ptr) <= end) { + if (_rdrandXX_step(reinterpret_cast<qregisteruint *>(ptr)) == 0) + goto out; + ptr += sizeof(qregisteruint)/sizeof(*ptr); + } + + if (sizeof(*ptr) != sizeof(qregisteruint) && ptr != end) { + if (_rdrand32_step(ptr)) + goto out; + ++ptr; + } + +out: + return ptr - reinterpret_cast<unsigned *>(buffer); +} +#endif + +namespace { +#if QT_CONFIG(getentropy) +class SystemRandom +{ +public: + enum { EfficientBufferFill = true }; + static qssize_t fillBuffer(void *buffer, qssize_t count) Q_DECL_NOTHROW + { + // getentropy can read at most 256 bytes, so break the reading + qssize_t read = 0; + while (count - read > 256) { + // getentropy can't fail under normal circumstances + int ret = getentropy(reinterpret_cast<uchar *>(buffer) + read, 256); + Q_ASSERT(ret == 0); + read += 256; + } + + int ret = getentropy(reinterpret_cast<uchar *>(buffer) + read, count - read); + Q_ASSERT(ret == 0); + return count; + } +}; + +#elif defined(Q_OS_UNIX) +class SystemRandom +{ + static QBasicAtomicInt s_fdp1; // "file descriptor plus 1" + static int openDevice(); + SystemRandom() {} + ~SystemRandom(); +public: + enum { EfficientBufferFill = true }; + static qssize_t fillBuffer(void *buffer, qssize_t count); +}; +QBasicAtomicInt SystemRandom::s_fdp1 = Q_BASIC_ATOMIC_INITIALIZER(0); + +SystemRandom::~SystemRandom() +{ + int fd = s_fdp1.loadAcquire() - 1; + if (fd >= 0) + qt_safe_close(fd); +} + +int SystemRandom::openDevice() +{ + int fd = s_fdp1.loadAcquire() - 1; + if (fd != -1) + return fd; + + fd = qt_safe_open("/dev/urandom", O_RDONLY); + if (fd == -1) + fd = qt_safe_open("/dev/random", O_RDONLY | O_NONBLOCK); + if (fd == -1) { + // failed on both, set to -2 so we won't try again + fd = -2; + } + + int opened_fdp1; + if (s_fdp1.testAndSetOrdered(0, fd + 1, opened_fdp1)) { + if (fd >= 0) { + static const SystemRandom closer; + Q_UNUSED(closer); + } + return fd; + } + + // failed, another thread has opened the file descriptor + if (fd >= 0) + qt_safe_close(fd); + return opened_fdp1 - 1; +} + +qssize_t SystemRandom::fillBuffer(void *buffer, qssize_t count) +{ + int fd = openDevice(); + if (Q_UNLIKELY(fd < 0)) + return 0; + + qint64 n = qt_safe_read(fd, buffer, count); + return qMax<qssize_t>(n, 0); // ignore any errors +} +#endif // Q_OS_UNIX + +#if defined(Q_OS_WIN) && !defined(Q_OS_WINRT) +class SystemRandom +{ +public: + enum { EfficientBufferFill = true }; + static qssize_t fillBuffer(void *buffer, qssize_t count) + { + auto RtlGenRandom = SystemFunction036; + return RtlGenRandom(buffer, ULONG(count)) ? count: 0; + } +}; +#elif defined(Q_OS_WINRT) +class SystemRandom +{ +public: + enum { EfficientBufferFill = false }; + static qssize_t fillBuffer(void *, qssize_t) + { + // always use the fallback + return 0; + } +}; +#endif // Q_OS_WINRT +} // unnamed namespace + +#if defined(Q_OS_WIN) +static void fallback_update_seed(unsigned) {} +static void fallback_fill(quint32 *ptr, qssize_t left) Q_DECL_NOTHROW +{ + // on Windows, rand_s is a high-quality random number generator + // and it requires no seeding + std::generate(ptr, ptr + left, []() { + unsigned value; + rand_s(&value); + return value; + }); +} +#elif QT_CONFIG(getentropy) +static void fallback_update_seed(unsigned) {} +static void fallback_fill(quint32 *, qssize_t) Q_DECL_NOTHROW +{ + // no fallback necessary, getentropy cannot fail under normal circumstances +} +#elif defined(Q_OS_BSD4) +static void fallback_update_seed(unsigned) {} +static void fallback_fill(quint32 *ptr, qssize_t left) Q_DECL_NOTHROW +{ + // BSDs have arc4random(4) and these work even in chroot(2) + arc4random_buf(ptr, left * sizeof(*ptr)); +} +#elif QT_CONFIG(cxx11_random) +static QBasicAtomicInteger<unsigned> seed = Q_BASIC_ATOMIC_INITIALIZER(0U); +static void fallback_update_seed(unsigned value) +{ + // Update the seed to be used for the fallback mechansim, if we need to. + // We can't use QtPrivate::QHashCombine here because that is not an atomic + // operation. A simple XOR will have to do then. + seed.fetchAndXorRelaxed(value); +} + +Q_NEVER_INLINE +#ifdef Q_CC_GNU +__attribute__((cold)) // this function is pretty big, so optimize for size +#endif +static void fallback_fill(quint32 *ptr, qssize_t left) Q_DECL_NOTHROW +{ + quint32 scratch[12]; // see element count below + quint32 *end = scratch; + + auto foldPointer = [](quintptr v) { + if (sizeof(quintptr) == sizeof(quint32)) { + // For 32-bit systems, we simply return the pointer. + return quint32(v); + } else { + // For 64-bit systems, we try to return the variable part of the + // pointer. On current x86-64 and AArch64, the top 17 bits are + // architecturally required to be the same, but in reality the top + // 24 bits on Linux are likely to be the same for all processes. + return quint32(v >> (32 - 24)); + } + }; + + Q_ASSERT(left); + + *end++ = foldPointer(quintptr(&seed)); // 1: variable in this library/executable's .data + *end++ = foldPointer(quintptr(&scratch)); // 2: variable in the stack + *end++ = foldPointer(quintptr(&errno)); // 3: veriable either in libc or thread-specific + *end++ = foldPointer(quintptr(reinterpret_cast<void*>(strerror))); // 4: function in libc (and unlikely to be a macro) + +#ifndef QT_BOOTSTRAPPED + quint64 nsecs = QDeadlineTimer::current(Qt::PreciseTimer).deadline(); + *end++ = quint32(nsecs); // 5 +#endif + + if (quint32 v = seed.load()) + *end++ = v; // 6 + +#if QT_CONFIG(getauxval) + // works on Linux -- all modern libc have getauxval +# ifdef AT_RANDOM + // ELF's auxv AT_RANDOM has 16 random bytes + // (other ELF-based systems don't seem to have AT_RANDOM) + ulong auxvSeed = getauxval(AT_RANDOM); + if (auxvSeed) { + memcpy(scratch, reinterpret_cast<void *>(auxvSeed), 16); + end += 4; // 7 to 10 + } +# endif + + // Both AT_BASE and AT_SYSINFO_EHDR have some randomness in them due to the + // system's ASLR, even if many bits are the same. They also have randomness + // between them. +# ifdef AT_BASE + // present at least on the BSDs too, indicates the address of the loader + ulong base = getauxval(AT_BASE); + if (base) + *end++ = foldPointer(base); // 11 +# endif +# ifdef AT_SYSINFO_EHDR + // seems to be Linux-only, indicates the global page of the sysinfo + ulong sysinfo_ehdr = getauxval(AT_SYSINFO_EHDR); + if (sysinfo_ehdr) + *end++ = foldPointer(sysinfo_ehdr); // 12 +# endif +#endif + + Q_ASSERT(end <= std::end(scratch)); + + // this is highly inefficient, we should save the generator across calls... + std::seed_seq sseq(scratch, end); + std::mt19937 generator(sseq); + std::generate(ptr, ptr + left, generator); + + fallback_update_seed(*ptr); +} +#else +static void fallback_update_seed(unsigned) {} +static Q_NORETURN void fallback_fill(quint32 *, qssize_t) +{ + qFatal("Random number generator failed and no high-quality backup available"); +} +#endif + +static qssize_t fill_cpu(quint32 *buffer, qssize_t count) +{ +#if defined(Q_PROCESSOR_X86) && QT_COMPILER_SUPPORTS_HERE(RDRND) + if (qCpuHasFeature(RDRND) && (uint(qt_randomdevice_control) & SkipHWRNG) == 0) + return qt_random_cpu(buffer, count); +#else + Q_UNUSED(buffer); + Q_UNUSED(count); +#endif + return 0; +} + +static void fill_internal(quint32 *buffer, qssize_t count) +{ + if (Q_UNLIKELY(uint(qt_randomdevice_control) & SetRandomData)) { + uint value = uint(qt_randomdevice_control) & RandomDataMask; + std::fill_n(buffer, count, value); + return; + } + + qssize_t filled = fill_cpu(buffer, count); + if (filled != count && (uint(qt_randomdevice_control) & SkipSystemRNG) == 0) { + qssize_t bytesFilled = + SystemRandom::fillBuffer(buffer + filled, (count - filled) * qssize_t(sizeof(*buffer))); + filled += bytesFilled / qssize_t(sizeof(*buffer)); + } + if (filled) + fallback_update_seed(*buffer); + + if (Q_UNLIKELY(filled != count)) { + // failed to fill the entire buffer, try the faillback mechanism + fallback_fill(buffer + filled, count - filled); + } +} + +static Q_NEVER_INLINE void fill(void *buffer, void *bufferEnd) +{ + struct ThreadState { + enum { + DesiredBufferByteSize = 32, + BufferCount = DesiredBufferByteSize / sizeof(quint32) + }; + quint32 buffer[BufferCount]; + int idx = BufferCount; + }; + + // Verify that the pointers are properly aligned for 32-bit + Q_ASSERT(quintptr(buffer) % sizeof(quint32) == 0); + Q_ASSERT(quintptr(bufferEnd) % sizeof(quint32) == 0); + + quint32 *ptr = reinterpret_cast<quint32 *>(buffer); + quint32 * const end = reinterpret_cast<quint32 *>(bufferEnd); + +#if defined(Q_COMPILER_THREAD_LOCAL) && !defined(QT_BOOTSTRAPPED) + if (SystemRandom::EfficientBufferFill && (end - ptr) < ThreadState::BufferCount + && uint(qt_randomdevice_control) == 0) { + thread_local ThreadState state; + qssize_t itemsAvailable = ThreadState::BufferCount - state.idx; + + // copy as much as we already have + qssize_t itemsToCopy = qMin(qssize_t(end - ptr), itemsAvailable); + memcpy(ptr, state.buffer + state.idx, size_t(itemsToCopy) * sizeof(*ptr)); + ptr += itemsToCopy; + + if (ptr != end) { + // refill the buffer and try again + fill_internal(state.buffer, ThreadState::BufferCount); + state.idx = 0; + + itemsToCopy = end - ptr; + memcpy(ptr, state.buffer + state.idx, size_t(itemsToCopy) * sizeof(*ptr)); + ptr = end; + } + + // erase what we copied and advance +# ifdef Q_OS_WIN + // Microsoft recommends this + SecureZeroMemory(state.buffer + state.idx, size_t(itemsToCopy) * sizeof(*ptr)); +# else + // We're quite confident the compiler will not optimize this out because + // we're writing to a thread-local buffer + memset(state.buffer + state.idx, 0, size_t(itemsToCopy) * sizeof(*ptr)); +# endif + state.idx += itemsToCopy; + } +#endif // Q_COMPILER_THREAD_LOCAL && !QT_BOOTSTRAPPED + + if (ptr != end) { + // fill directly in the user buffer + fill_internal(ptr, end - ptr); + } +} + +/*! + \class QRandomGenerator + \inmodule QtCore + \since 5.10 + + \brief The QRandomGenerator class allows one to obtain random values from a + high-quality, seed-less Random Number Generator. + + QRandomGenerator may be used to generate random values from a high-quality + random number generator. Unlike qrand(), QRandomGenerator does not need to be + seeded. That also means it is not possible to force it to produce a + reliable sequence, which may be needed for debugging. + + The class can generate 32-bit or 64-bit quantities, or fill an array of + those. The most common way of generating new values is to call the get32(), + get64() or fillRange() functions. One would use it as: + + \code + quint32 value = QRandomGenerator::get32(); + \endcode + + Additionally, it provides a floating-point function getReal() that returns + a number in the range [0, 1) (that is, inclusive of zero and exclusive of + 1). There's also a set of convenience functions that facilitate obtaining a + random number in a bounded, integral range. + + \warning This class is not suitable for bulk data creation. See below for the + technical reasons. + + \section1 Frequency and entropy exhaustion + + QRandomGenerator does not need to be seeded and instead uses operating system + or hardware facilities to generate random numbers. On some systems and with + certain hardware, those facilities are true Random Number Generators. + However, if they are true RNGs, those facilities have finite entropy source + and thus may fail to produce any results if the entropy pool is exhausted. + + If that happens, first the operating system then QRandomGenerator will fall + back to Pseudo Random Number Generators of decreasing qualities (Qt's + fallback generator being the simplest). Therefore, QRandomGenerator should + not be used for high-frequency random number generation, lest the entropy + pool become empty. As a rule of thumb, this class should not be called upon + to generate more than a kilobyte per second of random data (note: this may + vary from system to system). + + If an application needs true RNG data in bulk, it should use the operating + system facilities (such as \c{/dev/random} on Unix systems) directly and + wait for entropy to become available. If true RNG is not required, + applications should instead use a PRNG engines and can use QRandomGenerator to + seed those. + + \section1 Standard C++ Library compatibility + + QRandomGenerator is modeled after + \c{\l{http://en.cppreference.com/w/cpp/numeric/random/random_device}{std::random_device}} + and may be used in almost all contexts that the Standard Library can. + QRandomGenerator attempts to use either the same engine that backs + \c{std::random_device} or a better one. Note that \c{std::random_device} is + also allowed to fail if the source entropy pool becomes exhausted, in which + case it will throw an exception. QRandomGenerator never throws, but may abort + program execution instead. + + Like the Standard Library class, QRandomGenerator can be used to seed Standard + Library deterministic random engines from \c{<random>}, such as the + Mersenne Twister. Unlike \c{std::random_device}, QRandomGenerator also + implements the API of + \c{\l{http://en.cppreference.com/w/cpp/numeric/random/seed_seq}{std::seed_seq}}, + allowing it to seed the deterministic engines directly. + + The following code can be used to create and seed the + implementation-defined default deterministic PRNG, then use it to fill a + block range: + + \code + QRandomGenerator rd; + std::default_random_engine rng(rd); + std::generate(block.begin(), block.end(), rng); + + // equivalent to: + for (auto &v : block) + v = rng(); + \endcode + + QRandomGenerator is also compatible with the uniform distribution classes + \c{std::uniform_int_distribution} and \c{std:uniform_real_distribution}, as + well as the free function \c{std::generate_canonical}. For example, the + following code may be used to generate a floating-point number in the range + [1, 2.5): + + \code + QRandomGenerator64 rd; + std::uniform_real_distribution dist(1, 2.5); + return dist(rd); + \endcode + + Note the use of the QRandomGenerator64 class instead of QRandomGenerator to + obtain 64 bits of random data in a single call, though it is not required + to make the algorithm work (the Standard Library functions will make as + many calls as required to obtain enough bits of random data for the desired + range). + + \sa QRandomGenerator64, qrand() + */ + +/*! + \fn QRandomGenerator::QRandomGenerator() + \internal + Defaulted constructor, does nothing. + */ + +/*! + \typedef QRandomGenerator::result_type + + A typedef to the type that operator()() returns. That is, quint32. + + \sa operator()() + */ + +/*! + \fn result_type QRandomGenerator::operator()() + + Generates a 32-bit random quantity and returns it. + + \sa QRandomGenerator::get32(), QRandomGenerator::get64() + */ + +/*! + \fn double QRandomGenerator::entropy() const + + Returns the estimate of the entropy in the random generator source. + + This function exists to comply with the Standard Library requirements for + \c{\l{http://en.cppreference.com/w/cpp/numeric/random/random_device}{std::random_device}} + but it does not and cannot ever work. It is not possible to obtain a + reliable entropy value in a shared entropy pool in a multi-tasking system, + as other processes or threads may use that entropy. Any value non-zero + value that this function could return would be obsolete by the time the + user code reached it. + + Since QRandomGenerator attempts to use a hardware Random Number Generator, + this function always returns 0.0. + */ + +/*! + \fn result_type QRandomGenerator::min() + + Returns the minimum value that QRandomGenerator may ever generate. That is, 0. + + \sa max(), QRandomGenerator64::max() + */ + +/*! + \fn result_type QRandomGenerator::max() + + Returns the maximum value that QRandomGenerator may ever generate. That is, + \c {std::numeric_limits<result_type>::max()}. + + \sa min(), QRandomGenerator64::max() + */ + +/*! + \fn void QRandomGenerator::generate(ForwardIterator begin, ForwardIterator end) + + Generates 32-bit quantities and stores them in the range between \a begin + and \a end. This function is equivalent to (and is implemented as): + + \code + std::generate(begin, end, []() { return get32(); }); + \endcode + + This function complies with the requirements for the function + \c{\l{http://en.cppreference.com/w/cpp/numeric/random/seed_seq/generate}{std::seed_seq::generate}}, + which requires unsigned 32-bit integer values. + + Note that if the [begin, end) range refers to an area that can store more + than 32 bits per element, the elements will still be initialized with only + 32 bits of data. Any other bits will be zero. To fill the range with 64 bit + quantities, one can write: + + \code + std::generate(begin, end, []() { return get64(); }); + \endcode + + If the range refers to contiguous memory (such as an array or the data from + a QVector), the fillRange() function may be used too. + + \sa fillRange() + */ + +/*! + \fn void QRandomGenerator::generate(quint32 *begin, quint32 *end) + \overload + \internal + + Same as the other overload, but more efficiently fills \a begin to \a end. + */ + +/*! + \fn void QRandomGenerator::fillRange(UInt *buffer, qssize_t count) + + Generates \a count 32- or 64-bit quantities (depending on the type \c UInt) + and stores them in the buffer pointed by \a buffer. This is the most + efficient way to obtain more than one quantity at a time, as it reduces the + number of calls into the Random Number Generator source. + + For example, to fill a vector of 16 entries with random values, one may + write: + + \code + QVector<quint32> vector; + vector.resize(16); + QRandomGenerator::fillRange(vector.data(), vector.size()); + \endcode + + \sa generate() + */ + +/*! + \fn void QRandomGenerator::fillRange(UInt (&buffer)[N}) + + Generates \c N 32- or 64-bit quantities (depending on the type \c UInt) and + stores them in the \a buffer array. This is the most efficient way to + obtain more than one quantity at a time, as it reduces the number of calls + into the Random Number Generator source. + + For example, to fill generate two 32-bit quantities, one may write: + + \code + quint32 array[2]; + QRandomGenerator::fillRange(array); + \endcode + + It would have also been possible to make one call to get64() and then split + the two halves of the 64-bit value. + + \sa generate() + */ + +/*! + \fn qreal QRandomGenerator::getReal() + + Generates one random qreal in the canonical range [0, 1) (that is, + inclusive of zero and exclusive of 1). + + This function is equivalent to: + \code + QRandomGenerator64 rd; + return std::generate_canonical<qreal, std::numeric_limits<qreal>::digits>(rd); + \endcode + + The same may also be obtained by using + \c{\l{http://en.cppreference.com/w/cpp/numeric/random/uniform_real_distribution}{std::uniform_real_distribution}} + with parameters 0 and 1. + + \sa get32(), get64(), bounded() + */ + +/*! + \fn qreal QRandomGenerator::bounded(qreal sup) + + Generates one random qreal in the range between 0 (inclusive) and \a + sup (exclusive). This function is equivalent to and is implemented as: + + \code + return getReal() * sup; + \endcode + + \sa getReal(), bounded() + */ + +/*! + \fn quint32 QRandomGenerator::bounded(quint32 sup) + \overload + + Generates one random 32-bit quantity in the range between 0 (inclusive) and + \a sup (exclusive). The same result may also be obtained by using + \c{\l{http://en.cppreference.com/w/cpp/numeric/random/uniform_int_distribution}{std::uniform_int_distribution}} + with parameters 0 and \c{sup - 1}. That class can also be used to obtain + quantities larger than 32 bits. + + For example, to obtain a value between 0 and 255 (inclusive), one would write: + + \code + quint32 v = QRandomGenerator::bounded(256); + \endcode + + Naturally, the same could also be obtained by masking the result of get32() + to only the lower 8 bits. Either solution is as efficient. + + Note that this function cannot be used to obtain values in the full 32-bit + range of quint32. Instead, use get32(). + + \sa get32(), get64(), getReal() + */ + +/*! + \fn quint32 QRandomGenerator::bounded(int sup) + \overload + + Generates one random 32-bit quantity in the range between 0 (inclusive) and + \a sup (exclusive). \a sup must not be negative. + + Note that this function cannot be used to obtain values in the full 32-bit + range of int. Instead, use get32() and cast to int. + + \sa get32(), get64(), getReal() + */ + +/*! + \fn quint32 QRandomGenerator::bounded(quint32 min, quint32 sup) + \overload + + Generates one random 32-bit quantity in the range between \a min (inclusive) + and \a sup (exclusive). The same result may also be obtained by using + \c{\l{http://en.cppreference.com/w/cpp/numeric/random/uniform_int_distribution}{std::uniform_int_distribution}} + with parameters \a min and \c{\a sup - 1}. That class can also be used to + obtain quantities larger than 32 bits. + + For example, to obtain a value between 1000 (incl.) and 2000 (excl.), one + would write: + + \code + quint32 v = QRandomGenerator::bounded(1000, 2000); + \endcode + + + Note that this function cannot be used to obtain values in the full 32-bit + range of quint32. Instead, use get32(). + + \sa get32(), get64(), getReal() + */ + +/*! + \fn quint32 QRandomGenerator::bounded(int min, int sup) + \overload + + Generates one random 32-bit quantity in the range between \a min + (inclusive) and \a sup (exclusive), both of which may be negative. + + Note that this function cannot be used to obtain values in the full 32-bit + range of int. Instead, use get32() and cast to int. + + \sa get32(), get64(), getReal() + */ + +/*! + \class QRandomGenerator64 + \inmodule QtCore + \since 5.10 + + \brief The QRandomGenerator64 class allows one to obtain 64-bit random values + from a high-quality, seed-less Random Number Generator. + + QRandomGenerator64 is a simple adaptor class around QRandomGenerator, making the + QRandomGenerator::get64() function the default for operator()(), instead of the + function that returns 32-bit quantities. This class is intended to be used + in conjunction with Standard Library algorithms that need 64-bit quantities + instead of 32-bit ones. + + In all other aspects, the class is the same. Please refer to + QRandomGenerator's documentation for more information. + + \sa QRandomGenerator +*/ + +/*! + \fn QRandomGenerator64::QRandomGenerator64() + \internal + Defaulted constructor, does nothing. + */ + +/*! + \typedef QRandomGenerator64::result_type + + A typedef to the type that operator()() returns. That is, quint64. + + \sa operator()() + */ + +/*! + \fn result_type QRandomGenerator64::operator()() + + Generates a 64-bit random quantity and returns it. + + \sa QRandomGenerator::get32(), QRandomGenerator::get64() + */ + +/*! + \fn double QRandomGenerator64::entropy() const + + Returns the estimate of the entropy in the random generator source. + + This function exists to comply with the Standard Library requirements for + \c{\l{http://en.cppreference.com/w/cpp/numeric/random/random_device}{std::random_device}} + but it does not and cannot ever work. It is not possible to obtain a + reliable entropy value in a shared entropy pool in a multi-tasking system, + as other processes or threads may use that entropy. Any value non-zero + value that this function could return would be obsolete by the time the + user code reached it. + + Since QRandomGenerator64 attempts to use a hardware Random Number Generator, + this function always returns 0.0. + */ + +/*! + \fn result_type QRandomGenerator64::min() + + Returns the minimum value that QRandomGenerator64 may ever generate. That is, 0. + + \sa max(), QRandomGenerator::max() + */ + +/*! + \fn result_type QRandomGenerator64::max() + + Returns the maximum value that QRandomGenerator64 may ever generate. That is, + \c {std::numeric_limits<result_type>::max()}. + + \sa min(), QRandomGenerator::max() + */ + +/*! + Generates one 32-bit random value and returns it. + + Note about casting to a signed integer: all bits returned by this function + are random, so there's a 50% chance that the most significant bit will be + set. If you wish to cast the returned value to int and keep it positive, + you should mask the sign bit off: + + \code + int value = QRandomGenerator::get32() & std::numeric_limits<int>::max(); + \endcode + + \sa get64(), getReal() + */ +quint32 QRandomGenerator::get32() +{ + quint32 ret; + fill(&ret, &ret + 1); + return ret; +} + +/*! + Generates one 64-bit random value and returns it. + + Note about casting to a signed integer: all bits returned by this function + are random, so there's a 50% chance that the most significant bit will be + set. If you wish to cast the returned value to qint64 and keep it positive, + you should mask the sign bit off: + + \code + qint64 value = QRandomGenerator::get64() & std::numeric_limits<qint64>::max(); + \endcode + + \sa get32(), getReal(), QRandomGenerator64 + */ +quint64 QRandomGenerator::get64() +{ + quint64 ret; + fill(&ret, &ret + 1); + return ret; +} + +/*! + \internal + + Fills the range pointed by \a buffer and \a bufferEnd with 32-bit random + values. The buffer must be correctly aligned. + */ +void QRandomGenerator::fillRange_helper(void *buffer, void *bufferEnd) +{ + fill(buffer, bufferEnd); +} + +#if defined(Q_OS_ANDROID) && (__ANDROID_API__ < 21) +typedef QThreadStorage<QJNIObjectPrivate> AndroidRandomStorage; +Q_GLOBAL_STATIC(AndroidRandomStorage, randomTLS) + +#elif defined(Q_OS_UNIX) && !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && (_POSIX_THREAD_SAFE_FUNCTIONS - 0 > 0) +using SeedStorageType = QtPrivate::FunctionPointer<decltype(&srand)>::Arguments::Car; + +typedef QThreadStorage<SeedStorageType *> SeedStorage; +Q_GLOBAL_STATIC(SeedStorage, randTLS) // Thread Local Storage for seed value + +#endif + +/*! + \relates <QtGlobal> + \since 4.2 + + Thread-safe version of the standard C++ \c srand() function. + + Sets the argument \a seed to be used to generate a new random number sequence of + pseudo random integers to be returned by qrand(). + + The sequence of random numbers generated is deterministic per thread. For example, + if two threads call qsrand(1) and subsequently call qrand(), the threads will get + the same random number sequence. + + \sa qrand(), QRandomGenerator +*/ +void qsrand(uint seed) +{ +#if defined(Q_OS_ANDROID) && (__ANDROID_API__ < 21) + if (randomTLS->hasLocalData()) { + randomTLS->localData().callMethod<void>("setSeed", "(J)V", jlong(seed)); + return; + } + + QJNIObjectPrivate random("java/util/Random", + "(J)V", + jlong(seed)); + if (!random.isValid()) { + srand(seed); + return; + } + + randomTLS->setLocalData(random); +#elif defined(Q_OS_UNIX) && !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && (_POSIX_THREAD_SAFE_FUNCTIONS - 0 > 0) + SeedStorage *seedStorage = randTLS(); + if (seedStorage) { + SeedStorageType *pseed = seedStorage->localData(); + if (!pseed) + seedStorage->setLocalData(pseed = new SeedStorageType); + *pseed = seed; + } else { + //global static seed storage should always exist, + //except after being deleted by QGlobalStaticDeleter. + //But since it still can be called from destructor of another + //global static object, fallback to srand(seed) + srand(seed); + } +#else + // On Windows srand() and rand() already use Thread-Local-Storage + // to store the seed between calls + // this is also valid for QT_NO_THREAD + srand(seed); +#endif +} + +/*! + \relates <QtGlobal> + \since 4.2 + + Thread-safe version of the standard C++ \c rand() function. + + Returns a value between 0 and \c RAND_MAX (defined in \c <cstdlib> and + \c <stdlib.h>), the next number in the current sequence of pseudo-random + integers. + + Use \c qsrand() to initialize the pseudo-random number generator with a + seed value. Seeding must be performed at least once on each thread. If that + step is skipped, then the sequence will be pre-seeded with a constant + value. + + \sa qsrand(), QRandomGenerator +*/ +int qrand() +{ +#if defined(Q_OS_ANDROID) && (__ANDROID_API__ < 21) + AndroidRandomStorage *randomStorage = randomTLS(); + if (!randomStorage) + return rand(); + + if (randomStorage->hasLocalData()) { + return randomStorage->localData().callMethod<jint>("nextInt", + "(I)I", + RAND_MAX); + } + + QJNIObjectPrivate random("java/util/Random", + "(J)V", + jlong(1)); + + if (!random.isValid()) + return rand(); + + randomStorage->setLocalData(random); + return random.callMethod<jint>("nextInt", "(I)I", RAND_MAX); +#elif defined(Q_OS_UNIX) && !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && (_POSIX_THREAD_SAFE_FUNCTIONS - 0 > 0) + SeedStorage *seedStorage = randTLS(); + if (seedStorage) { + SeedStorageType *pseed = seedStorage->localData(); + if (!pseed) { + seedStorage->setLocalData(pseed = new SeedStorageType); + *pseed = 1; + } + return rand_r(pseed); + } else { + //global static seed storage should always exist, + //except after being deleted by QGlobalStaticDeleter. + //But since it still can be called from destructor of another + //global static object, fallback to rand() + return rand(); + } +#else + // On Windows srand() and rand() already use Thread-Local-Storage + // to store the seed between calls + // this is also valid for QT_NO_THREAD + return rand(); +#endif +} + +QT_END_NAMESPACE diff --git a/src/corelib/global/qrandom.h b/src/corelib/global/qrandom.h new file mode 100644 index 0000000000..3bede87fa6 --- /dev/null +++ b/src/corelib/global/qrandom.h @@ -0,0 +1,154 @@ +/**************************************************************************** +** +** Copyright (C) 2017 Intel Corporation. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QRANDOM_H +#define QRANDOM_H + +#include <QtCore/qglobal.h> +#include <algorithm> // for std::generate + +QT_BEGIN_NAMESPACE + +class QRandomGenerator +{ + // restrict the template parameters to unsigned integers 32 bits wide or larger + template <typename UInt> using IfValidUInt = + typename std::enable_if<std::is_unsigned<UInt>::value && sizeof(UInt) >= sizeof(uint), bool>::type; +public: + QRandomGenerator() = default; + + static Q_CORE_EXPORT quint32 get32(); + static Q_CORE_EXPORT quint64 get64(); + static qreal getReal() + { + const int digits = std::numeric_limits<qreal>::digits; + if (digits < std::numeric_limits<quint32>::digits) { + // use get32() + return qreal(get32()) / ((max)() + qreal(1.0)); + } else { + // use get64() + // we won't have enough bits for a __float128 though + return qreal(get64()) / ((std::numeric_limits<quint64>::max)() + qreal(1.0)); + } + } + + static qreal bounded(qreal sup) + { + return getReal() * sup; + } + + static quint32 bounded(quint32 sup) + { + quint64 value = get32(); + value *= sup; + value /= (max)() + quint64(1); + return quint32(value); + } + + static int bounded(int sup) + { + return int(bounded(quint32(sup))); + } + + static quint32 bounded(quint32 min, quint32 sup) + { + return bounded(sup - min) + min; + } + + static int bounded(int min, int sup) + { + return bounded(sup - min) + min; + } + + template <typename UInt, IfValidUInt<UInt> = true> + static void fillRange(UInt *buffer, qssize_t count) + { + fillRange_helper(buffer, buffer + count); + } + + template <typename UInt, size_t N, IfValidUInt<UInt> = true> + static void fillRange(UInt (&buffer)[N]) + { + fillRange_helper(buffer, buffer + N); + } + + // API like std::seed_seq + template <typename ForwardIterator> + void generate(ForwardIterator begin, ForwardIterator end) + { + std::generate(begin, end, &QRandomGenerator::get32); + } + + void generate(quint32 *begin, quint32 *end) + { + fillRange_helper(begin, end); + } + + // API like std::random_device + typedef quint32 result_type; + result_type operator()() { return get32(); } + double entropy() const Q_DECL_NOTHROW { return 0.0; } + static Q_DECL_CONSTEXPR result_type min() { return (std::numeric_limits<result_type>::min)(); } + static Q_DECL_CONSTEXPR result_type max() { return (std::numeric_limits<result_type>::max)(); } + +private: + Q_DISABLE_COPY(QRandomGenerator) + static Q_CORE_EXPORT void fillRange_helper(void *buffer, void *bufferEnd); +}; + +class QRandomGenerator64 +{ +public: + QRandomGenerator64() = default; + + // API like std::random_device + typedef quint64 result_type; + result_type operator()() { return QRandomGenerator::get64(); } + double entropy() const Q_DECL_NOTHROW { return 0.0; } + static Q_DECL_CONSTEXPR result_type min() { return (std::numeric_limits<result_type>::min)(); } + static Q_DECL_CONSTEXPR result_type max() { return (std::numeric_limits<result_type>::max)(); } + +private: + Q_DISABLE_COPY(QRandomGenerator64) +}; + + +QT_END_NAMESPACE + +#endif // QRANDOM_H diff --git a/src/corelib/global/qrandom_p.h b/src/corelib/global/qrandom_p.h new file mode 100644 index 0000000000..6ac2904e1b --- /dev/null +++ b/src/corelib/global/qrandom_p.h @@ -0,0 +1,78 @@ +/**************************************************************************** +** +** Copyright (C) 2017 Intel Corporation. +** Contact: https://www.qt.io/licensing/ +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see https://www.qt.io/terms-conditions. For further +** information use the contact form at https://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or (at your option) the GNU General +** Public license version 3 or any later version approved by the KDE Free +** Qt Foundation. The licenses are as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +** included in the packaging of this file. Please review the following +** information to ensure the GNU General Public License requirements will +** be met: https://www.gnu.org/licenses/gpl-2.0.html and +** https://www.gnu.org/licenses/gpl-3.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QRANDOM_P_H +#define QRANDOM_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists purely as an +// implementation detail. This header file may change from version to +// version without notice, or even be removed. +// +// We mean it. +// + +#include "qglobal_p.h" + +QT_BEGIN_NAMESPACE + +enum QRandomGeneratorControl { + SkipMemfill = 1, + SkipSystemRNG = 2, + SkipHWRNG = 4, + SetRandomData = 8, + + // 28 bits + RandomDataMask = 0xfffffff0 +}; + +#if defined(QT_BUILD_INTERNAL) && defined(QT_BUILD_CORE_LIB) +Q_CORE_EXPORT QBasicAtomicInteger<uint> qt_randomdevice_control = Q_BASIC_ATOMIC_INITIALIZER(0U); +#elif defined(QT_BUILD_INTERNAL) +extern Q_CORE_EXPORT QBasicAtomicInteger<uint> qt_randomdevice_control; +#else +enum { qt_randomdevice_control = 0 }; +#endif + +QT_END_NAMESPACE + +#endif // QRANDOM_P_H diff --git a/src/corelib/global/qtypeinfo.h b/src/corelib/global/qtypeinfo.h index 7031021e16..4f79c48c51 100644 --- a/src/corelib/global/qtypeinfo.h +++ b/src/corelib/global/qtypeinfo.h @@ -311,14 +311,11 @@ Q_DECLARE_TYPEINFO(qint64, Q_PRIMITIVE_TYPE); Q_DECLARE_TYPEINFO(quint64, Q_PRIMITIVE_TYPE); Q_DECLARE_TYPEINFO(float, Q_PRIMITIVE_TYPE); Q_DECLARE_TYPEINFO(double, Q_PRIMITIVE_TYPE); -#ifndef Q_OS_DARWIN -Q_DECLARE_TYPEINFO(long double, Q_PRIMITIVE_TYPE); -#endif - #if QT_VERSION >= QT_VERSION_CHECK(6,0,0) // ### Qt 6: remove the other branch // This was required so that QList<T> for these types allocates out of the array storage +Q_DECLARE_TYPEINFO(long double, Q_PRIMITIVE_TYPE); # ifdef Q_COMPILER_UNICODE_STRINGS Q_DECLARE_TYPEINFO(char16_t, Q_PRIMITIVE_TYPE); Q_DECLARE_TYPEINFO(char32_t, Q_PRIMITIVE_TYPE); @@ -327,6 +324,11 @@ Q_DECLARE_TYPEINFO(char32_t, Q_PRIMITIVE_TYPE); Q_DECLARE_TYPEINFO(wchar_t, Q_PRIMITIVE_TYPE); # endif #else +# ifndef Q_OS_DARWIN +Q_DECLARE_TYPEINFO(long double, Q_PRIMITIVE_TYPE); +# else +Q_DECLARE_TYPEINFO(long double, Q_RELOCATABLE_TYPE); +# endif # ifdef Q_COMPILER_UNICODE_STRINGS Q_DECLARE_TYPEINFO(char16_t, Q_RELOCATABLE_TYPE); Q_DECLARE_TYPEINFO(char32_t, Q_RELOCATABLE_TYPE); |