Merge remote-tracking branch 'origin/5.15' into dev

Change-Id: Ic1fd51143f903b7e9086fc19ca960dfd9654ee00

29 files changed, 707 insertions, 488 deletions

diff --git a/src/corelib/configure.json b/src/corelib/configure.json
index f7b6d41534..ae360239c6 100644
--- a/src/corelib/configure.json
+++ b/src/corelib/configure.json
@@ -158,21 +158,6 @@
                 "-latomic"
             ]
         },
-        "libdl": {
-            "label": "dlopen()",
-            "test": {
-                "main": [
-                    "dlclose(dlopen(0, 0));",
-                    "dlsym(RTLD_DEFAULT, 0);",
-                    "dlerror();"
-                ]
-            },
-            "headers": "dlfcn.h",
-            "sources": [
-                "",
-                "-ldl"
-            ]
-        },
         "librt": {
             "label": "clock_gettime()",
             "test": {
@@ -612,11 +597,6 @@
             "condition": "features.clock-gettime && tests.clock-monotonic",
             "output": [ "feature" ]
         },
-        "dlopen": {
-            "label": "dlopen()",
-            "condition": "config.unix && libs.libdl",
-            "output": [ "privateFeature" ]
-        },
         "doubleconversion": {
             "label": "DoubleConversion",
             "output": [ "privateFeature", "feature" ]
diff --git a/src/corelib/corelib.pro b/src/corelib/corelib.pro
index 121db51eb5..ba5f5adf8d 100644
--- a/src/corelib/corelib.pro
+++ b/src/corelib/corelib.pro
@@ -21,7 +21,7 @@ CONFIG += simd optimize_full
 QMAKE_DOCS = $$PWD/doc/qtcore.qdocconf
 
 ANDROID_LIB_DEPENDENCIES = \
-    plugins/platforms/android/libqtforandroid.so
+    plugins/platforms/libqtforandroid.so
 ANDROID_BUNDLED_JAR_DEPENDENCIES = \
     jar/QtAndroid.jar
 ANDROID_PERMISSIONS = \
diff --git a/src/corelib/doc/snippets/hellotrmain.cpp b/src/corelib/doc/snippets/hellotrmain.cpp
index 2fab919a47..721a83240b 100644
--- a/src/corelib/doc/snippets/hellotrmain.cpp
+++ b/src/corelib/doc/snippets/hellotrmain.cpp
@@ -56,13 +56,13 @@ int main(int argc, char *argv[])
     QTranslator translator;
     // look up e.g. :/translations/myapp_de.qm
     if (translator.load(QLocale(), QLatin1String("myapp"), QLatin1String("_"), QLatin1String(":/translations")))
-        app.installTranslator(&translator);
+        QCoreApplication::installTranslator(&translator);
 
     QPushButton hello(QCoreApplication::translate("main", "Hello world!"));
     hello.resize(100, 30);
 
     hello.show();
-    return app.exec();
+    return QCoreApplication::exec();
 }
 //! [0]
 
diff --git a/src/corelib/global/qlibraryinfo.cpp b/src/corelib/global/qlibraryinfo.cpp
index 4c1b04f05e..c7357f9d13 100644
--- a/src/corelib/global/qlibraryinfo.cpp
+++ b/src/corelib/global/qlibraryinfo.cpp
@@ -55,15 +55,24 @@ QT_END_NAMESPACE
 # include "qcoreapplication.h"
 #endif
 
+#ifndef QT_BUILD_QMAKE_BOOTSTRAP
+#  include "private/qglobal_p.h"
+#  include "qconfig.cpp"
+#endif
+
 #ifdef Q_OS_DARWIN
 #  include "private/qcore_mac_p.h"
-#endif
+#endif // Q_OS_DARWIN
 
-#ifndef QT_BUILD_QMAKE_BOOTSTRAP
-# include "qconfig.cpp"
+#include "archdetect.cpp"
+
+#if !defined(QT_BUILD_QMAKE) && QT_CONFIG(relocatable) && QT_CONFIG(dlopen) && !QT_CONFIG(framework)
+#  include <dlfcn.h>
 #endif
 
-#include "archdetect.cpp"
+#if !defined(QT_BUILD_QMAKE) && QT_CONFIG(relocatable) && defined(Q_OS_WIN)
+#  include <qt_windows.h>
+#endif
 
 QT_BEGIN_NAMESPACE
 
@@ -453,6 +462,160 @@ void QLibraryInfo::sysrootify(QString *path)
 }
 #endif // QT_BUILD_QMAKE
 
+#ifndef QT_BUILD_QMAKE
+static QString prefixFromAppDirHelper()
+{
+    QString appDir;
+
+    if (QCoreApplication::instance()) {
+#ifdef Q_OS_DARWIN
+        CFBundleRef bundleRef = CFBundleGetMainBundle();
+        if (bundleRef) {
+            QCFType<CFURLRef> urlRef = CFBundleCopyBundleURL(bundleRef);
+            if (urlRef) {
+                QCFString path = CFURLCopyFileSystemPath(urlRef, kCFURLPOSIXPathStyle);
+#ifdef Q_OS_MACOS
+                QString bundleContentsDir = QString(path) + QLatin1String("/Contents/");
+                if (QDir(bundleContentsDir).exists())
+                    return QDir::cleanPath(bundleContentsDir);
+#else
+                return QDir::cleanPath(QString(path)); // iOS
+#endif // Q_OS_MACOS
+            }
+        }
+#endif // Q_OS_DARWIN
+        // We make the prefix path absolute to the executable's directory.
+        appDir = QCoreApplication::applicationDirPath();
+    } else {
+        appDir = QDir::currentPath();
+    }
+
+    return appDir;
+}
+#endif
+
+#if !defined(QT_BUILD_QMAKE) && QT_CONFIG(relocatable)
+static QString prefixFromQtCoreLibraryHelper(const QString &qtCoreLibraryPath)
+{
+    const QString qtCoreLibrary = QDir::fromNativeSeparators(qtCoreLibraryPath);
+    const QString libDir = QFileInfo(qtCoreLibrary).absolutePath();
+    const QString prefixDir = libDir + QLatin1Char('/')
+            + QLatin1String(QT_CONFIGURE_LIBLOCATION_TO_PREFIX_PATH);
+    return QDir::cleanPath(prefixDir);
+}
+
+#if defined(Q_OS_WIN)
+#if defined(Q_OS_WINRT)
+EXTERN_C IMAGE_DOS_HEADER __ImageBase;
+static HMODULE getWindowsModuleHandle()
+{
+    return reinterpret_cast<HMODULE>(&__ImageBase);
+}
+#else  // Q_OS_WINRT
+static HMODULE getWindowsModuleHandle()
+{
+    HMODULE hModule = NULL;
+    GetModuleHandleEx(
+        GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+        (LPCTSTR)&QLibraryInfo::isDebugBuild, &hModule);
+    return hModule;
+}
+#endif // !Q_OS_WINRT
+#endif // Q_OS_WIN
+
+static QString getRelocatablePrefix()
+{
+    QString prefixPath;
+
+    // For static builds, the prefix will be the app directory.
+    // For regular builds, the prefix will be relative to the location of the QtCore shared library.
+#if defined(QT_STATIC)
+    prefixPath = prefixFromAppDirHelper();
+#elif defined(Q_OS_DARWIN) && QT_CONFIG(framework)
+    CFBundleRef qtCoreBundle = CFBundleGetBundleWithIdentifier(
+            CFSTR("org.qt-project.QtCore"));
+    Q_ASSERT(qtCoreBundle);
+
+    QCFType<CFURLRef> qtCorePath = CFBundleCopyBundleURL(qtCoreBundle);
+    Q_ASSERT(qtCorePath);
+
+    QCFType<CFURLRef> qtCorePathAbsolute = CFURLCopyAbsoluteURL(qtCorePath);
+    Q_ASSERT(qtCorePathAbsolute);
+
+    QCFType<CFURLRef> libDirCFPath = CFURLCreateCopyDeletingLastPathComponent(NULL, qtCorePathAbsolute);
+
+    const QCFString libDirCFString = CFURLCopyFileSystemPath(libDirCFPath, kCFURLPOSIXPathStyle);
+
+    const QString prefixDir = QString(libDirCFString) + QLatin1Char('/')
+        + QLatin1String(QT_CONFIGURE_LIBLOCATION_TO_PREFIX_PATH);
+
+    prefixPath = QDir::cleanPath(prefixDir);
+#elif QT_CONFIG(dlopen)
+    Dl_info info;
+    int result = dladdr(reinterpret_cast<void *>(&QLibraryInfo::isDebugBuild), &info);
+    if (result > 0 && info.dli_fname)
+        prefixPath = prefixFromQtCoreLibraryHelper(QString::fromLatin1(info.dli_fname));
+#elif defined(Q_OS_WIN)
+    HMODULE hModule = getWindowsModuleHandle();
+    const int kBufferSize = 4096;
+    wchar_t buffer[kBufferSize];
+    const int pathSize = GetModuleFileName(hModule, buffer, kBufferSize);
+    if (pathSize > 0)
+        prefixPath = prefixFromQtCoreLibraryHelper(QString::fromWCharArray(buffer, pathSize));
+#else
+#error "The chosen platform / config does not support querying for a dynamic prefix."
+#endif
+
+    Q_ASSERT_X(!prefixPath.isEmpty(), "getRelocatablePrefix",
+                                      "Failed to find the Qt prefix path.");
+    return prefixPath;
+}
+#endif
+
+#if defined(QT_BUILD_QMAKE) && !defined(QT_BUILD_QMAKE_BOOTSTRAP)
+QString qmake_abslocation();
+
+static QString getPrefixFromHostBinDir(const char *hostBinDirToPrefixPath)
+{
+    const QFileInfo qmfi = QFileInfo(qmake_abslocation()).canonicalFilePath();
+    return QDir::cleanPath(qmfi.absolutePath() + QLatin1Char('/')
+                           + QLatin1String(hostBinDirToPrefixPath));
+}
+
+static QString getExtPrefixFromHostBinDir()
+{
+    return getPrefixFromHostBinDir(QT_CONFIGURE_HOSTBINDIR_TO_EXTPREFIX_PATH);
+}
+
+static QString getHostPrefixFromHostBinDir()
+{
+    return getPrefixFromHostBinDir(QT_CONFIGURE_HOSTBINDIR_TO_HOSTPREFIX_PATH);
+}
+#endif
+
+#ifndef QT_BUILD_QMAKE_BOOTSTRAP
+static const char *getPrefix(
+#ifdef QT_BUILD_QMAKE
+        QLibraryInfo::PathGroup group
+#endif
+        )
+{
+#if defined(QT_BUILD_QMAKE)
+#  if QT_CONFIGURE_CROSSBUILD
+    if (group == QLibraryInfo::DevicePaths)
+        return QT_CONFIGURE_PREFIX_PATH;
+#  endif
+    static QByteArray extPrefixPath = getExtPrefixFromHostBinDir().toLatin1();
+    return extPrefixPath.constData();
+#elif QT_CONFIG(relocatable)
+    static QByteArray prefixPath = getRelocatablePrefix().toLatin1();
+    return prefixPath.constData();
+#else
+    return QT_CONFIGURE_PREFIX_PATH;
+#endif
+}
+#endif // QT_BUILD_QMAKE_BOOTSTRAP
+
 /*!
   Returns the location specified by \a loc.
 */
@@ -564,12 +727,11 @@ QLibraryInfo::rawLocation(LibraryLocation loc, PathGroup group)
     if (!fromConf) {
         const char * volatile path = 0;
         if (loc == PrefixPath) {
-            path =
-# ifdef QT_BUILD_QMAKE
-                (group != DevicePaths) ?
-                    QT_CONFIGURE_EXT_PREFIX_PATH :
-# endif
-                    QT_CONFIGURE_PREFIX_PATH;
+            path = getPrefix(
+#ifdef QT_BUILD_QMAKE
+                        group
+#endif
+                   );
         } else if (unsigned(loc) <= sizeof(qt_configure_str_offsets)/sizeof(qt_configure_str_offsets[0])) {
             path = qt_configure_strs + qt_configure_str_offsets[loc - 1];
 #ifndef Q_OS_WIN // On Windows we use the registry
@@ -578,7 +740,8 @@ QLibraryInfo::rawLocation(LibraryLocation loc, PathGroup group)
 #endif
 # ifdef QT_BUILD_QMAKE
         } else if (loc == HostPrefixPath) {
-            path = QT_CONFIGURE_HOST_PREFIX_PATH;
+            static const QByteArray hostPrefixPath = getHostPrefixFromHostBinDir().toLatin1();
+            path = hostPrefixPath.constData();
 # endif
         }
 
@@ -612,28 +775,7 @@ QLibraryInfo::rawLocation(LibraryLocation loc, PathGroup group)
         }
 #else
         if (loc == PrefixPath) {
-            if (QCoreApplication::instance()) {
-#ifdef Q_OS_DARWIN
-                CFBundleRef bundleRef = CFBundleGetMainBundle();
-                if (bundleRef) {
-                    QCFType<CFURLRef> urlRef = CFBundleCopyBundleURL(bundleRef);
-                    if (urlRef) {
-                        QCFString path = CFURLCopyFileSystemPath(urlRef, kCFURLPOSIXPathStyle);
-#ifdef Q_OS_OSX
-                        QString bundleContentsDir = QString(path) + QLatin1String("/Contents/");
-                        if (QDir(bundleContentsDir).exists())
-                            return QDir::cleanPath(bundleContentsDir + ret);
-#else
-                        return QDir::cleanPath(QString(path) + QLatin1Char('/') + ret); // iOS
-#endif // Q_OS_OSX
-                    }
-                }
-#endif // Q_OS_DARWIN
-                // We make the prefix path absolute to the executable's directory.
-                baseDir = QCoreApplication::applicationDirPath();
-            } else {
-                baseDir = QDir::currentPath();
-            }
+            baseDir = prefixFromAppDirHelper();
         } else {
             // we make any other path absolute to the prefix directory
             baseDir = location(PrefixPath);
diff --git a/src/corelib/global/qlogging.cpp b/src/corelib/global/qlogging.cpp
index cebab1daef..17f2246082 100644
--- a/src/corelib/global/qlogging.cpp
+++ b/src/corelib/global/qlogging.cpp
@@ -1803,8 +1803,8 @@ static void qt_message_print(QtMsgType msgType, const QMessageLogContext &contex
 #ifndef QT_BOOTSTRAPPED
     Q_TRACE(qt_message_print, msgType, context.category, context.function, context.file, context.line, message);
 
-    // qDebug, qWarning, ... macros do not check whether category is enabled
-    if (isDefaultCategory(context.category)) {
+    // qDebug, qWarning, ... macros do not check whether category is enabledgc
+    if (msgType != QtFatalMsg && isDefaultCategory(context.category)) {
         if (QLoggingCategory *defaultCategory = QLoggingCategory::defaultCategory()) {
             if (!defaultCategory->isEnabled(msgType))
                 return;
diff --git a/src/corelib/global/qnamespace.qdoc b/src/corelib/global/qnamespace.qdoc
index 886aedb4f3..cce88782e9 100644
--- a/src/corelib/global/qnamespace.qdoc
+++ b/src/corelib/global/qnamespace.qdoc
@@ -3287,7 +3287,7 @@
   the application object is created, or by setting the QT_SCALE_FACTOR_ROUNDING_POLICY
   environment variable.
 
-  \sa QGuiApplication::setHighDdpiScaleFactorRoundingPolicy()
+  \sa QGuiApplication::setHighDpiScaleFactorRoundingPolicy()
   \sa AA_EnableHighDpiScaling.
 
   \omitvalue Unset
diff --git a/src/corelib/global/qoperatingsystemversion.cpp b/src/corelib/global/qoperatingsystemversion.cpp
index ded86cbc4e..33793ca168 100644
--- a/src/corelib/global/qoperatingsystemversion.cpp
+++ b/src/corelib/global/qoperatingsystemversion.cpp
@@ -356,14 +356,6 @@ bool QOperatingSystemVersion::isAnyOfType(std::initializer_list<OSType> types) c
 }
 
 /*!
-    \variable QOperatingSystemVersion::WindowsVista
-    \brief a version corresponding to Windows Vista (version 6.0).
-    \since 6.0
- */
-const QOperatingSystemVersion QOperatingSystemVersion::WindowsVista =
-        QOperatingSystemVersion(QOperatingSystemVersion::Windows, 6, 0);
-
-/*!
     \variable QOperatingSystemVersion::Windows7
     \brief a version corresponding to Windows 7 (version 6.1).
     \since 5.9
diff --git a/src/corelib/global/qoperatingsystemversion.h b/src/corelib/global/qoperatingsystemversion.h
index 879bd379b0..f22878de89 100644
--- a/src/corelib/global/qoperatingsystemversion.h
+++ b/src/corelib/global/qoperatingsystemversion.h
@@ -60,7 +60,6 @@ public:
         Android
     };
 
-    static const QOperatingSystemVersion WindowsVista;
     static const QOperatingSystemVersion Windows7;
     static const QOperatingSystemVersion Windows8;
     static const QOperatingSystemVersion Windows8_1;
diff --git a/src/corelib/global/qrandom.cpp b/src/corelib/global/qrandom.cpp
index 711eb8f4d5..e5b2399566 100644
--- a/src/corelib/global/qrandom.cpp
+++ b/src/corelib/global/qrandom.cpp
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2017 Intel Corporation.
+** Copyright (C) 2019 Intel Corporation.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
@@ -103,17 +103,22 @@ static QT_FUNCTION_TARGET(RDRND) qsizetype qt_random_cpu(void *buffer, qsizetype
 {
     unsigned *ptr = reinterpret_cast<unsigned *>(buffer);
     unsigned *end = ptr + count;
+    int retries = 10;
 
     while (ptr + sizeof(qregisteruint)/sizeof(*ptr) <= end) {
-        if (_rdrandXX_step(reinterpret_cast<qregisteruint *>(ptr)) == 0)
+        if (_rdrandXX_step(reinterpret_cast<qregisteruint *>(ptr)))
+            ptr += sizeof(qregisteruint)/sizeof(*ptr);
+        else if (--retries == 0)
             goto out;
-        ptr += sizeof(qregisteruint)/sizeof(*ptr);
     }
 
-    if (sizeof(*ptr) != sizeof(qregisteruint) && ptr != end) {
-        if (_rdrand32_step(ptr))
-            goto out;
-        ++ptr;
+    while (sizeof(*ptr) != sizeof(qregisteruint) && ptr != end) {
+        bool ok = _rdrand32_step(ptr);
+        if (!ok && --retries)
+            continue;
+        if (ok)
+            ++ptr;
+        break;
     }
 
 out:
diff --git a/src/corelib/io/qfilesystemwatcher.cpp b/src/corelib/io/qfilesystemwatcher.cpp
index 64c422c55a..a4705136a2 100644
--- a/src/corelib/io/qfilesystemwatcher.cpp
+++ b/src/corelib/io/qfilesystemwatcher.cpp
@@ -41,9 +41,9 @@
 #include "qfilesystemwatcher_p.h"
 
 #include <qdatetime.h>
-#include <qdebug.h>
 #include <qdir.h>
 #include <qfileinfo.h>
+#include <qloggingcategory.h>
 #include <qset.h>
 #include <qtimer.h>
 
@@ -67,6 +67,8 @@
 
 QT_BEGIN_NAMESPACE
 
+Q_LOGGING_CATEGORY(lcWatcher, "qt.core.filesystemwatcher")
+
 QFileSystemWatcherEngine *QFileSystemWatcherPrivate::createNativeEngine(QObject *parent)
 {
 #if defined(Q_OS_WIN)
@@ -137,6 +139,7 @@ void QFileSystemWatcherPrivate::initPollerEngine()
 void QFileSystemWatcherPrivate::_q_fileChanged(const QString &path, bool removed)
 {
     Q_Q(QFileSystemWatcher);
+    qCDebug(lcWatcher) << "file changed" << path << "removed?" << removed << "watching?" << files.contains(path);
     if (!files.contains(path)) {
         // the path was removed after a change was detected, but before we delivered the signal
         return;
@@ -149,6 +152,7 @@ void QFileSystemWatcherPrivate::_q_fileChanged(const QString &path, bool removed
 void QFileSystemWatcherPrivate::_q_directoryChanged(const QString &path, bool removed)
 {
     Q_Q(QFileSystemWatcher);
+    qCDebug(lcWatcher) << "directory changed" << path << "removed?" << removed << "watching?" << directories.contains(path);
     if (!directories.contains(path)) {
         // perhaps the path was removed after a change was detected, but before we delivered the signal
         return;
@@ -355,7 +359,7 @@ QStringList QFileSystemWatcher::addPaths(const QStringList &paths)
         qWarning("QFileSystemWatcher::addPaths: list is empty");
         return p;
     }
-
+    qCDebug(lcWatcher) << "adding" << paths;
     const auto selectEngine = [this, d]() -> QFileSystemWatcherEngine* {
 #ifdef QT_BUILD_INTERNAL
         const QString on = objectName();
@@ -364,11 +368,11 @@ QStringList QFileSystemWatcher::addPaths(const QStringList &paths)
             // Autotest override case - use the explicitly selected engine only
             const QStringRef forceName = on.midRef(26);
             if (forceName == QLatin1String("poller")) {
-                qDebug("QFileSystemWatcher: skipping native engine, using only polling engine");
+                qCDebug(lcWatcher, "QFileSystemWatcher: skipping native engine, using only polling engine");
                 d_func()->initPollerEngine();
                 return d->poller;
             } else if (forceName == QLatin1String("native")) {
-                qDebug("QFileSystemWatcher: skipping polling engine, using only native engine");
+                qCDebug(lcWatcher, "QFileSystemWatcher: skipping polling engine, using only native engine");
                 return d->native;
             }
             return nullptr;
@@ -431,6 +435,7 @@ QStringList QFileSystemWatcher::removePaths(const QStringList &paths)
         qWarning("QFileSystemWatcher::removePaths: list is empty");
         return p;
     }
+    qCDebug(lcWatcher) << "removing" << paths;
 
     if (d->native)
         p = d->native->removePaths(p, &d->files, &d->directories);
diff --git a/src/corelib/io/qtldurl.cpp b/src/corelib/io/qtldurl.cpp
index 912609ec91..fc3e16b241 100644
--- a/src/corelib/io/qtldurl.cpp
+++ b/src/corelib/io/qtldurl.cpp
@@ -125,10 +125,10 @@ Q_CORE_EXPORT bool qIsEffectiveTLD(const QStringRef &domain)
         return true;
 
     const int dot = domain.indexOf(QLatin1Char('.'));
-    if (dot >= 0) {
-        if (containsTLDEntry(domain.mid(dot), SuffixMatch))   // 2
-            return !containsTLDEntry(domain, ExceptionMatch); // 3
-    }
+    if (dot < 0) // Actual TLD: may be effective if the subject of a wildcard rule:
+        return containsTLDEntry(QString(QLatin1Char('.') + domain), SuffixMatch);
+    if (containsTLDEntry(domain.mid(dot), SuffixMatch))   // 2
+        return !containsTLDEntry(domain, ExceptionMatch); // 3
     return false;
 }
 
diff --git a/src/corelib/kernel/qcoreapplication.cpp b/src/corelib/kernel/qcoreapplication.cpp
index 6647ea99f5..c537e8f51b 100644
--- a/src/corelib/kernel/qcoreapplication.cpp
+++ b/src/corelib/kernel/qcoreapplication.cpp
@@ -2693,7 +2693,14 @@ Q_GLOBAL_STATIC(QRecursiveMutex, libraryPathMutex)
 QStringList QCoreApplication::libraryPaths()
 {
     QMutexLocker locker(libraryPathMutex());
+    return libraryPathsLocked();
+}
 
+/*!
+    \internal
+*/
+QStringList QCoreApplication::libraryPathsLocked()
+{
     if (coreappdata()->manual_libpaths)
         return *(coreappdata()->manual_libpaths);
 
@@ -2769,7 +2776,7 @@ void QCoreApplication::setLibraryPaths(const QStringList &paths)
     // When the application is constructed it should still amend the paths. So we keep the originals
     // around, and even create them if they don't exist, yet.
     if (!coreappdata()->app_libpaths)
-        libraryPaths();
+        libraryPathsLocked();
 
     if (coreappdata()->manual_libpaths)
         *(coreappdata()->manual_libpaths) = paths;
@@ -2812,7 +2819,7 @@ void QCoreApplication::addLibraryPath(const QString &path)
             return;
     } else {
         // make sure that library paths are initialized
-        libraryPaths();
+        libraryPathsLocked();
         QStringList *app_libpaths = coreappdata()->app_libpaths.data();
         if (app_libpaths->contains(canonicalPath))
             return;
@@ -2851,7 +2858,7 @@ void QCoreApplication::removeLibraryPath(const QString &path)
             return;
     } else {
         // make sure that library paths is initialized
-        libraryPaths();
+        libraryPathsLocked();
         QStringList *app_libpaths = coreappdata()->app_libpaths.data();
         if (!app_libpaths->contains(canonicalPath))
             return;
diff --git a/src/corelib/kernel/qcoreapplication.h b/src/corelib/kernel/qcoreapplication.h
index b7df004736..71ea124fbe 100644
--- a/src/corelib/kernel/qcoreapplication.h
+++ b/src/corelib/kernel/qcoreapplication.h
@@ -208,6 +208,9 @@ private:
     static bool notifyInternal2(QObject *receiver, QEvent *);
     static bool forwardEvent(QObject *receiver, QEvent *event, QEvent *originatingEvent = nullptr);
 #endif
+#if QT_CONFIG(library)
+    static QStringList libraryPathsLocked();
+#endif
 
     static QCoreApplication *self;
 
diff --git a/src/corelib/kernel/qeventdispatcher_winrt.cpp b/src/corelib/kernel/qeventdispatcher_winrt.cpp
index 600c6c38fd..f7a1f969a8 100644
--- a/src/corelib/kernel/qeventdispatcher_winrt.cpp
+++ b/src/corelib/kernel/qeventdispatcher_winrt.cpp
@@ -44,12 +44,13 @@
 #include <QtCore/QHash>
 #include <QtCore/QMutex>
 #include <QtCore/QSemaphore>
-#include <QtCore/QSharedPointer>
 #include <QtCore/qfunctions_winrt.h>
 #include <private/qabstracteventdispatcher_p.h>
 #include <private/qcoreapplication_p.h>
 
 #include <functional>
+#include <memory>
+
 #include <wrl.h>
 #include <windows.foundation.h>
 #include <windows.system.threading.h>
@@ -300,19 +301,19 @@ HRESULT QEventDispatcherWinRT::runOnMainThread(const std::function<HRESULT()> &d
     if (QThread::currentThread() == QCoreApplication::instance()->thread())
         return delegate();
 
-    auto semaphore = QSharedPointer<QSemaphore>(new QSemaphore);
-    auto ptrSemaphore = new QSharedPointer<QSemaphore>(semaphore);
-    auto result = QSharedPointer<HRESULT>(new HRESULT);
-    auto ptrResult = new QSharedPointer<HRESULT>(result);
+    struct State {
+        QSemaphore semaphore;
+        HRESULT result;
+    };
+
+    const auto state = std::make_shared<State>();
 
-    QMetaObject::invokeMethod(QCoreApplication::instance(), [delegate, ptrSemaphore, ptrResult]() {
-        **ptrResult = delegate();
-        delete ptrResult;
-        (*ptrSemaphore)->release();
-        delete ptrSemaphore;
+    QMetaObject::invokeMethod(QCoreApplication::instance(), [delegate, state]() {
+        const QSemaphoreReleaser releaser{state->semaphore};
+        state->result = delegate();
     }, nullptr);
 
-    return semaphore->tryAcquire(1, timeout) ? *result : E_FAIL;
+    return state->semaphore.tryAcquire(1, timeout) ? state->result : E_FAIL;
 }
 
 bool QEventDispatcherWinRT::processEvents(QEventLoop::ProcessEventsFlags flags)
diff --git a/src/corelib/kernel/qpointer.h b/src/corelib/kernel/qpointer.h
index 7052bcf0d4..5efdb0b395 100644
--- a/src/corelib/kernel/qpointer.h
+++ b/src/corelib/kernel/qpointer.h
@@ -54,20 +54,11 @@ class QPointer
 {
     Q_STATIC_ASSERT_X(!std::is_pointer<T>::value, "QPointer's template type must not be a pointer type");
 
-    template<typename U>
-    struct TypeSelector
-    {
-        typedef QObject Type;
-    };
-    template<typename U>
-    struct TypeSelector<const U>
-    {
-        typedef const QObject Type;
-    };
-    typedef typename TypeSelector<T>::Type QObjectType;
+    using QObjectType =
+        typename std::conditional<std::is_const<T>::value, const QObject, QObject>::type;
     QWeakPointer<QObjectType> wp;
 public:
-    inline QPointer() { }
+    QPointer() = default;
     inline QPointer(T *p) : wp(p, true) { }
     // compiler-generated copy/move ctor/assignment operators are fine!
     // compiler-generated dtor is fine!
diff --git a/src/corelib/plugin/qlibrary.cpp b/src/corelib/plugin/qlibrary.cpp
index 1ace28c93f..98a198df43 100644
--- a/src/corelib/plugin/qlibrary.cpp
+++ b/src/corelib/plugin/qlibrary.cpp
@@ -74,7 +74,7 @@ QT_BEGIN_NAMESPACE
 #  define QLIBRARY_AS_DEBUG true
 #endif
 
-#if defined(Q_OS_UNIX) || defined(Q_CC_MINGW)
+#if defined(Q_OS_UNIX)
 // We don't use separate debug and release libs on UNIX, so we want
 // to allow loading plugins, regardless of how they were built.
 #  define QT_NO_DEBUG_PLUGIN_CHECK
diff --git a/src/corelib/thread/qbasicatomic.h b/src/corelib/thread/qbasicatomic.h
index dc976819ef..9804e60119 100644
--- a/src/corelib/thread/qbasicatomic.h
+++ b/src/corelib/thread/qbasicatomic.h
@@ -99,8 +99,10 @@ public:
     typename Ops::Type _q_value;
 
     // Everything below is either implemented in ../arch/qatomic_XXX.h or (as fallback) in qgenericatomic.h
-    T load() const noexcept { return loadRelaxed(); }
-    void store(T newValue) noexcept { storeRelaxed(newValue); }
+#if QT_DEPRECATED_SINCE(5, 14)
+    QT_DEPRECATED_VERSION_X_5_14("Use loadRelaxed") T load() const noexcept { return loadRelaxed(); }
+    QT_DEPRECATED_VERSION_X_5_14("Use storeRelaxed") void store(T newValue) noexcept { storeRelaxed(newValue); }
+#endif
 
     T loadRelaxed() const noexcept { return Ops::loadRelaxed(_q_value); }
     void storeRelaxed(T newValue) noexcept { Ops::storeRelaxed(_q_value, newValue); }
@@ -238,8 +240,10 @@ public:
 
     AtomicType _q_value;
 
-    Type load() const noexcept { return loadRelaxed(); }
-    void store(Type newValue) noexcept { storeRelaxed(newValue); }
+#if QT_DEPRECATED_SINCE(5, 14)
+    QT_DEPRECATED_VERSION_X_5_14("Use loadRelaxed") Type load() const noexcept { return loadRelaxed(); }
+    QT_DEPRECATED_VERSION_X_5_14("Use storeRelaxed") void store(Type newValue) noexcept { storeRelaxed(newValue); }
+#endif
 
     Type loadRelaxed() const noexcept { return Ops::loadRelaxed(_q_value); }
     void storeRelaxed(Type newValue) noexcept { Ops::storeRelaxed(_q_value, newValue); }
diff --git a/src/corelib/thread/qreadwritelock.cpp b/src/corelib/thread/qreadwritelock.cpp
index 30e9b95a52..5aba05c1b9 100644
--- a/src/corelib/thread/qreadwritelock.cpp
+++ b/src/corelib/thread/qreadwritelock.cpp
@@ -48,6 +48,9 @@
 #include "qreadwritelock_p.h"
 #include "qelapsedtimer.h"
 #include "private/qfreelist_p.h"
+#include "private/qlocking_p.h"
+
+#include <chrono>
 
 QT_BEGIN_NAMESPACE
 
@@ -64,6 +67,9 @@ QT_BEGIN_NAMESPACE
  */
 
 namespace {
+
+using ms = std::chrono::milliseconds;
+
 enum {
     StateMask = 0x3,
     StateLockedForRead = 0x1,
@@ -262,7 +268,7 @@ bool QReadWriteLock::tryLockForRead(int timeout)
         if (d->recursive)
             return d->recursiveLockForRead(timeout);
 
-        QMutexLocker lock(&d->mutex);
+        auto lock = qt_unique_lock(d->mutex);
         if (d != d_ptr.loadRelaxed()) {
             // d_ptr has changed: this QReadWriteLock was unlocked before we had
             // time to lock d->mutex.
@@ -273,7 +279,7 @@ bool QReadWriteLock::tryLockForRead(int timeout)
             d = d_ptr.loadAcquire();
             continue;
         }
-        return d->lockForRead(timeout);
+        return d->lockForRead(lock, timeout);
     }
 }
 
@@ -369,7 +375,7 @@ bool QReadWriteLock::tryLockForWrite(int timeout)
         if (d->recursive)
             return d->recursiveLockForWrite(timeout);
 
-        QMutexLocker lock(&d->mutex);
+        auto lock = qt_unique_lock(d->mutex);
         if (d != d_ptr.loadRelaxed()) {
             // The mutex was unlocked before we had time to lock the mutex.
             // We are holding to a mutex within a QReadWriteLockPrivate that is already released
@@ -377,7 +383,7 @@ bool QReadWriteLock::tryLockForWrite(int timeout)
             d = d_ptr.loadAcquire();
             continue;
         }
-        return d->lockForWrite(timeout);
+        return d->lockForWrite(lock, timeout);
     }
 }
 
@@ -418,7 +424,7 @@ void QReadWriteLock::unlock()
             return;
         }
 
-        QMutexLocker locker(&d->mutex);
+        const auto lock = qt_scoped_lock(d->mutex);
         if (d->writerCount) {
             Q_ASSERT(d->writerCount == 1);
             Q_ASSERT(d->readerCount == 0);
@@ -460,9 +466,9 @@ QReadWriteLock::StateForWaitCondition QReadWriteLock::stateForWaitCondition() co
 
 }
 
-bool QReadWriteLockPrivate::lockForRead(int timeout)
+bool QReadWriteLockPrivate::lockForRead(std::unique_lock<std::mutex> &lock, int timeout)
 {
-    Q_ASSERT(!mutex.tryLock()); // mutex must be locked when entering this function
+    Q_ASSERT(!mutex.try_lock()); // mutex must be locked when entering this function
 
     QElapsedTimer t;
     if (timeout > 0)
@@ -476,10 +482,10 @@ bool QReadWriteLockPrivate::lockForRead(int timeout)
             if (elapsed > timeout)
                 return false;
             waitingReaders++;
-            readerCond.wait(&mutex, timeout - elapsed);
+            readerCond.wait_for(lock, ms{timeout - elapsed});
         } else {
             waitingReaders++;
-            readerCond.wait(&mutex);
+            readerCond.wait(lock);
         }
         waitingReaders--;
     }
@@ -488,9 +494,9 @@ bool QReadWriteLockPrivate::lockForRead(int timeout)
     return true;
 }
 
-bool QReadWriteLockPrivate::lockForWrite(int timeout)
+bool QReadWriteLockPrivate::lockForWrite(std::unique_lock<std::mutex> &lock, int timeout)
 {
-    Q_ASSERT(!mutex.tryLock()); // mutex must be locked when entering this function
+    Q_ASSERT(!mutex.try_lock()); // mutex must be locked when entering this function
 
     QElapsedTimer t;
     if (timeout > 0)
@@ -505,15 +511,15 @@ bool QReadWriteLockPrivate::lockForWrite(int timeout)
                 if (waitingReaders && !waitingWriters && !writerCount) {
                     // We timed out and now there is no more writers or waiting writers, but some
                     // readers were queueud (probably because of us). Wake the waiting readers.
-                    readerCond.wakeAll();
+                    readerCond.notify_all();
                 }
                 return false;
             }
             waitingWriters++;
-            writerCond.wait(&mutex, timeout - elapsed);
+            writerCond.wait_for(lock, ms{timeout - elapsed});
         } else {
             waitingWriters++;
-            writerCond.wait(&mutex);
+            writerCond.wait(lock);
         }
         waitingWriters--;
     }
@@ -526,17 +532,17 @@ bool QReadWriteLockPrivate::lockForWrite(int timeout)
 
 void QReadWriteLockPrivate::unlock()
 {
-    Q_ASSERT(!mutex.tryLock()); // mutex must be locked when entering this function
+    Q_ASSERT(!mutex.try_lock()); // mutex must be locked when entering this function
     if (waitingWriters)
-        writerCond.wakeOne();
+        writerCond.notify_one();
     else if (waitingReaders)
-        readerCond.wakeAll();
+        readerCond.notify_all();
 }
 
 bool QReadWriteLockPrivate::recursiveLockForRead(int timeout)
 {
     Q_ASSERT(recursive);
-    QMutexLocker lock(&mutex);
+    auto lock = qt_unique_lock(mutex);
 
     Qt::HANDLE self = QThread::currentThreadId();
 
@@ -546,7 +552,7 @@ bool QReadWriteLockPrivate::recursiveLockForRead(int timeout)
         return true;
     }
 
-    if (!lockForRead(timeout))
+    if (!lockForRead(lock, timeout))
         return false;
 
     currentReaders.insert(self, 1);
@@ -556,7 +562,7 @@ bool QReadWriteLockPrivate::recursiveLockForRead(int timeout)
 bool QReadWriteLockPrivate::recursiveLockForWrite(int timeout)
 {
     Q_ASSERT(recursive);
-    QMutexLocker lock(&mutex);
+    auto lock = qt_unique_lock(mutex);
 
     Qt::HANDLE self = QThread::currentThreadId();
     if (currentWriter == self) {
@@ -564,7 +570,7 @@ bool QReadWriteLockPrivate::recursiveLockForWrite(int timeout)
         return true;
     }
 
-    if (!lockForWrite(timeout))
+    if (!lockForWrite(lock, timeout))
         return false;
 
     currentWriter = self;
@@ -574,7 +580,7 @@ bool QReadWriteLockPrivate::recursiveLockForWrite(int timeout)
 void QReadWriteLockPrivate::recursiveUnlock()
 {
     Q_ASSERT(recursive);
-    QMutexLocker lock(&mutex);
+    auto lock = qt_unique_lock(mutex);
 
     Qt::HANDLE self = QThread::currentThreadId();
     if (self == currentWriter) {
diff --git a/src/corelib/thread/qreadwritelock_p.h b/src/corelib/thread/qreadwritelock_p.h
index 31da2401c0..b2e782f9ee 100644
--- a/src/corelib/thread/qreadwritelock_p.h
+++ b/src/corelib/thread/qreadwritelock_p.h
@@ -54,7 +54,9 @@
 
 #include <QtCore/private/qglobal_p.h>
 #include <QtCore/qhash.h>
-#include <QtCore/qwaitcondition.h>
+
+#include <mutex>
+#include <condition_variable>
 
 QT_REQUIRE_CONFIG(thread);
 
@@ -63,38 +65,36 @@ QT_BEGIN_NAMESPACE
 class QReadWriteLockPrivate
 {
 public:
-    QReadWriteLockPrivate(bool isRecursive = false)
-        : readerCount(0), writerCount(0), waitingReaders(0), waitingWriters(0),
-        recursive(isRecursive), id(0), currentWriter(nullptr) {}
+    explicit QReadWriteLockPrivate(bool isRecursive = false)
+        : recursive(isRecursive) {}
 
-    QMutex mutex;
-    QWaitCondition writerCond;
-    QWaitCondition readerCond;
-    int readerCount;
-    int writerCount;
-    int waitingReaders;
-    int waitingWriters;
+    std::mutex mutex;
+    std::condition_variable writerCond;
+    std::condition_variable readerCond;
+    int readerCount = 0;
+    int writerCount = 0;
+    int waitingReaders = 0;
+    int waitingWriters = 0;
     const bool recursive;
 
     //Called with the mutex locked
-    bool lockForWrite(int timeout);
-    bool lockForRead(int timeout);
+    bool lockForWrite(std::unique_lock<std::mutex> &lock, int timeout);
+    bool lockForRead(std::unique_lock<std::mutex> &lock, int timeout);
     void unlock();
 
     //memory management
-    int id;
+    int id = 0;
     void release();
     static QReadWriteLockPrivate *allocate();
 
     // Recusive mutex handling
-    Qt::HANDLE currentWriter;
+    Qt::HANDLE currentWriter = {};
     QHash<Qt::HANDLE, int> currentReaders;
 
     // called with the mutex unlocked
     bool recursiveLockForWrite(int timeout);
     bool recursiveLockForRead(int timeout);
     void recursiveUnlock();
-
 };
 
 QT_END_NAMESPACE
diff --git a/src/corelib/time/qcalendar.cpp b/src/corelib/time/qcalendar.cpp
index d31eee6632..d706f1d5ab 100644
--- a/src/corelib/time/qcalendar.cpp
+++ b/src/corelib/time/qcalendar.cpp
@@ -201,7 +201,7 @@ QCalendar::System QCalendarBackend::calendarSystem() const
 }
 
 /*!
-  The primary name of this calendar.
+    The primary name of this calendar.
  */
 QString QCalendar::name() const
 {
@@ -221,8 +221,8 @@ QString QCalendar::name() const
    Calendars with intercallary days may represent these as extra days of the
    preceding month, or as short months separate from the usual ones. In the
    former case, daysInMonth(month, year) should be the number of ordinary days
-   in the month, although \c{isDateValid(year, month, day)} might return \c true for
-   some larger values of \c day.
+   in the month, although \c{isDateValid(year, month, day)} might return \c true
+   for some larger values of \c day.
 
    \sa daysInYear(), monthsInYear(), minimumDaysInMonth(), maximumDaysInMonth()
 */
@@ -440,101 +440,104 @@ int QCalendarBackend::dayOfWeek(qint64 jd) const
 
 // Month and week-day name look-ups (implemented in qlocale.cpp):
 /*!
-  \fn QString QCalendarBackend::monthName(const QLocale &locale, int month, int year,
-                                          QLocale::FormatType format) const
+    \fn QString QCalendarBackend::monthName(const QLocale &locale, int month, int year,
+                                            QLocale::FormatType format) const
 
-  Returns the name of the specified \a month in the given \a year for the chosen
-  \a locale, using the given \a format to determine how complete the name is.
+    Returns the name of the specified \a month in the given \a year for the
+    chosen \a locale, using the given \a format to determine how complete the
+    name is.
 
-  If \a year is Unspecified, return the name for the month that usually has this
-  number within a typical year. Calendars with a leap month that isn't always
-  the last may need to take account of the year to map the month number to the
-  particular year's month with that number.
+    If \a year is Unspecified, return the name for the month that usually has
+    this number within a typical year. Calendars with a leap month that isn't
+    always the last may need to take account of the year to map the month number
+    to the particular year's month with that number.
 
-  \note Backends for which CLDR provides data can configure the default
-  implementation of the two month name look-up methods by arranging for
-  localeMonthIndexData() and localeMonthData() to provide access to the CLDR
-  data (see cldr2qlocalexml.py, qlocalexml2cpp.py and existing backends).
-  Conversely, backends that override both month name look-up methods need not
-  return anything meaningful from localeMonthIndexData() or localeMonthData().
+    \note Backends for which CLDR provides data can configure the default
+    implementation of the two month name look-up methods by arranging for
+    localeMonthIndexData() and localeMonthData() to provide access to the CLDR
+    data (see cldr2qlocalexml.py, qlocalexml2cpp.py and existing backends).
+    Conversely, backends that override both month name look-up methods need not
+    return anything meaningful from localeMonthIndexData() or localeMonthData().
 
-  \sa standaloneMonthName(), QLocale::monthName()
+    \sa standaloneMonthName(), QLocale::monthName()
 */
 
 /*!
-  \fn QString QCalendarBackend::standaloneMonthName(const QLocale &locale, int month, int year
-                                                    QLocale::FormatType format) const
+    \fn QString QCalendarBackend::standaloneMonthName(const QLocale &locale, int month, int year
+                                                      QLocale::FormatType format) const
 
-  Returns the standalone name of the specified \a month in the chosen \a locale,
-  using the specified \a format to determine how complete the name is.
+    Returns the standalone name of the specified \a month in the chosen \a
+    locale, using the specified \a format to determine how complete the name is.
 
-  If \a year is Unspecified, return the standalone name for the month that
-  usually has this number within a typical year. Calendars with a leap month
-  that isn't always the last may need to take account of the year to map the
-  month number to the particular year's month with that number.
+    If \a year is Unspecified, return the standalone name for the month that
+    usually has this number within a typical year. Calendars with a leap month
+    that isn't always the last may need to take account of the year to map the
+    month number to the particular year's month with that number.
 
-  \sa monthName(), QLocale::standaloneMonthName()
+    \sa monthName(), QLocale::standaloneMonthName()
 */
 
 /*!
-  \fn QString QCalendarBackend::weekDayName(const QLocale &locale, int day,
-                                            QLocale::FormatType format) const
+    \fn QString QCalendarBackend::weekDayName(const QLocale &locale, int day,
+                                              QLocale::FormatType format) const
 
-  Returns the name of the specified \a day of the week in the chosen \a locale,
-  using the specified \a format to determine how complete the name is.
+    Returns the name of the specified \a day of the week in the chosen \a
+    locale, using the specified \a format to determine how complete the name is.
 
-  The base implementation handles \a day values from 1 to 7 using the day names
-  CLDR provides, which are suitable for calendards that use the same
-  (Hebrew-derived) week as the Gregorian calendar.
+    The base implementation handles \a day values from 1 to 7 using the day
+    names CLDR provides, which are suitable for calendards that use the same
+    (Hebrew-derived) week as the Gregorian calendar.
 
-  Calendars whose dayOfWeek() returns a value outside the range from 1 to 7 need
-  to reimplement this method to handle such extra week-day values. They can
-  assume that \a day is a value returned by the same calendar's dayOfWeek().
+    Calendars whose dayOfWeek() returns a value outside the range from 1 to 7
+    need to reimplement this method to handle such extra week-day values. They
+    can assume that \a day is a value returned by the same calendar's
+    dayOfWeek().
 
-  \sa dayOfWeek(), standaloneWeekDayName(), QLocale::dayName()
+    \sa dayOfWeek(), standaloneWeekDayName(), QLocale::dayName()
 */
 
 /*!
-  \fn QString QCalendarBackend::standaloneWeekDayName(const QLocale &locale, int day,
-                                                      QLocale::FormatType format) const
+    \fn QString QCalendarBackend::standaloneWeekDayName(const QLocale &locale, int day,
+                                                        QLocale::FormatType format) const
 
-  Returns the standalone name of the specified \a day of the week in the chosen
-  \a locale, using the specified \a format to determine how complete the name
-  is.
+    Returns the standalone name of the specified \a day of the week in the
+    chosen \a locale, using the specified \a format to determine how complete
+    the name is.
 
-  The base implementation handles \a day values from 1 to 7 using the standalone
-  day names CLDR provides, which are suitable for calendards that use the same
-  (Hebrew-derived) week as the Gregorian calendar.
+    The base implementation handles \a day values from 1 to 7 using the
+    standalone day names CLDR provides, which are suitable for calendards that
+    use the same (Hebrew-derived) week as the Gregorian calendar.
 
-  Calendars whose dayOfWeek() returns a value outside the range from 1 to 7 need
-  to reimplement this method to handle such extra week-day values. They can
-  assume that \a day is a value returned by the same calendar's dayOfWeek().
+    Calendars whose dayOfWeek() returns a value outside the range from 1 to 7
+    need to reimplement this method to handle such extra week-day values. They
+    can assume that \a day is a value returned by the same calendar's
+    dayOfWeek().
 
-  \sa dayOfWeek(), weekDayName(), QLocale::standaloneDayName()
+    \sa dayOfWeek(), weekDayName(), QLocale::standaloneDayName()
 */
 
 /*!
-  \fn QString QCalendarBackend::dateTimeToString(QStringView format, const QDateTime &datetime,
-                                                 const QDate &dateOnly, const QTime &timeOnly,
-                                                 const QLocale &locale) const
-
-  Returns a string representing a given date, time or date-time.
-
-  If \a datetime is specified and valid, it is used and both date and time
-  format tokens are converted to appropriate representations of the parts of the
-  datetime. Otherwise, if \a dateOnly is valid, only date format tokens are
-  converted; else, if \a timeOnly is valid, only time format tokens are
-  converted. If none are valid, an empty string is returned.
-
-  The specified \a locale influences how some format tokens are converted; for
-  example, when substituting day and month names and their short-forms. For the
-  supported formatting tokens, see QDate::toString() and QTime::toString(). As
-  described above, the provided date, time and date-time determine which of
-  these tokens are recognized: where these appear in \a format they are replaced
-  by data. Any text in \a format not recognized as a format token is copied
-  verbatim into the result string.
-
-  \sa QDate::toString(), QTime::toString(), QDateTime::toString()
+    \fn QString QCalendarBackend::dateTimeToString(QStringView format, const QDateTime &datetime,
+                                                   const QDate &dateOnly, const QTime &timeOnly,
+                                                   const QLocale &locale) const
+
+    Returns a string representing a given date, time or date-time.
+
+    If \a datetime is specified and valid, it is used and both date and time
+    format tokens are converted to appropriate representations of the parts of
+    the datetime. Otherwise, if \a dateOnly is valid, only date format tokens
+    are converted; else, if \a timeOnly is valid, only time format tokens are
+    converted. If none are valid, an empty string is returned.
+
+    The specified \a locale influences how some format tokens are converted; for
+    example, when substituting day and month names and their short-forms. For
+    the supported formatting tokens, see QDate::toString() and
+    QTime::toString(). As described above, the provided date, time and date-time
+    determine which of these tokens are recognized: where these appear in \a
+    format they are replaced by data. Any text in \a format not recognized as a
+    format token is copied verbatim into the result string.
+
+    \sa QDate::toString(), QTime::toString(), QDateTime::toString()
 */
 // End of methods implemented in qlocale.cpp
 
@@ -571,16 +574,16 @@ bool QCalendarBackend::registerAlias(const QString &name)
 }
 
 /*!
-  Returns a pointer to a named calendar backend.
+    Returns a pointer to a named calendar backend.
 
-  If the given \a name is present in availableCalendars(), the backend matching
-  it is returned; otherwise, \c nullptr is returned. Matching of names ignores
-  case. Note that this won't provoke construction of a calendar backend, it will
-  only return ones that have been instantiated (and not yet destroyed) by some
-  other means. However, calendars available via the QCalendar::System enum are
-  always registered when this is called.
+    If the given \a name is present in availableCalendars(), the backend
+    matching it is returned; otherwise, \c nullptr is returned. Matching of
+    names ignores case. Note that this won't provoke construction of a calendar
+    backend, it will only return ones that have been instantiated (and not yet
+    destroyed) by some other means. However, calendars available via the
+    QCalendar::System enum are always registered when this is called.
 
-  \sa availableCalendars(), registerAlias(), fromEnum()
+    \sa availableCalendars(), registerAlias(), fromEnum()
 */
 const QCalendarBackend *QCalendarBackend::fromName(QStringView name)
 {
@@ -592,7 +595,7 @@ const QCalendarBackend *QCalendarBackend::fromName(QStringView name)
 }
 
 /*!
-  \overload
+    \overload
  */
 const QCalendarBackend *QCalendarBackend::fromName(QLatin1String name)
 {
@@ -604,11 +607,11 @@ const QCalendarBackend *QCalendarBackend::fromName(QLatin1String name)
 }
 
 /*!
-  Returns a pointer to a calendar backend, specified by enum.
+    Returns a pointer to a calendar backend, specified by enum.
 
-  This will instantiate the indicated calendar (which will enable fromName() to
-  return it subsequently), but only for the Qt-supported calendars for which
-  (where relevant) the appropriate feature has been enabled.
+    This will instantiate the indicated calendar (which will enable fromName()
+    to return it subsequently), but only for the Qt-supported calendars for
+    which (where relevant) the appropriate feature has been enabled.
 */
 const QCalendarBackend *QCalendarBackend::fromEnum(QCalendar::System system)
 {
@@ -643,28 +646,29 @@ const QCalendarBackend *QCalendarBackend::fromEnum(QCalendar::System system)
 }
 
 /*!
-  \since 5.14
-
-  \class QCalendar
-  \inmodule QtCore
-  \reentrant
-  \brief The QCalendar class describes calendar systems.
-
-  A QCalendar object maps a year, month, and day-number to a specific day
-  (ultimately identified by its Julian day number), using the rules of a
-  particular system.
+    \since 5.14
 
-  The default QCalendar() is a proleptic Gregorian calendar, which has no year
-  zero. Other calendars may be supported by enabling suitable features or
-  loading plugins. Calendars supported as features can be constructed by passing
-  the QCalendar::System enumeration to the constructor. All supported calendars
-  may be constructed by name, once they have been constructed. (Thus plugins
-  instantiate their calendar backend to register it.) Built-in backends,
-  accessible via QCalendar::System, are also always available by name.
+    \class QCalendar
+    \inmodule QtCore
+    \reentrant
+    \brief The QCalendar class describes calendar systems.
+
+    A QCalendar object maps a year, month, and day-number to a specific day
+    (ultimately identified by its Julian day number), using the rules of a
+    particular system.
+
+    The default QCalendar() is a proleptic Gregorian calendar, which has no year
+    zero. Other calendars may be supported by enabling suitable features or
+    loading plugins. Calendars supported as features can be constructed by
+    passing the QCalendar::System enumeration to the constructor. All supported
+    calendars may be constructed by name, once they have been constructed. (Thus
+    plugins instantiate their calendar backend to register it.) Built-in
+    backends, accessible via QCalendar::System, are also always available by
+    name.
 
-  A QCalendar value is immutable.
+    A QCalendar value is immutable.
 
-  \sa QDate, QDateTime
+    \sa QDate, QDateTime
 */
 
 /*!
@@ -684,20 +688,20 @@ const QCalendarBackend *QCalendarBackend::fromEnum(QCalendar::System system)
 */
 
 /*!
-  \fn QCalendar::QCalendar()
-  \fn QCalendar::QCalendar(QCalendar::System system)
-  \fn QCalendar::QCalendar(QLatin1String name)
-  \fn QCalendar::QCalendar(QStringView name)
+    \fn QCalendar::QCalendar()
+    \fn QCalendar::QCalendar(QCalendar::System system)
+    \fn QCalendar::QCalendar(QLatin1String name)
+    \fn QCalendar::QCalendar(QStringView name)
 
-  Constructs a calendar object.
+    Constructs a calendar object.
 
-  The choice of calendar to use may be indicated as \a system, using the
-  enumeration QCalendar::System, or by \a name, using a string (either Unicode
-  or Latin 1). Construction by name may depend on an instance of the given
-  calendar being constructed by other means first. With no argument, the default
-  constructor returns the Gregorian calendar.
+    The choice of calendar to use may be indicated as \a system, using the
+    enumeration QCalendar::System, or by \a name, using a string (either Unicode
+    or Latin 1). Construction by name may depend on an instance of the given
+    calendar being constructed by other means first. With no argument, the
+    default constructor returns the Gregorian calendar.
 
-  \sa QCalendar, System
+    \sa QCalendar, System
 */
 
 QCalendar::QCalendar()
@@ -722,12 +726,13 @@ QCalendar::QCalendar(QStringView name)
 // Date queries:
 
 /*!
-  Returns the number of days in the given \a month of the given \a year.
+    Returns the number of days in the given \a month of the given \a year.
 
-  Months are numbered consecutively, starting with 1 for the first month of each
-  year.
+    Months are numbered consecutively, starting with 1 for the first month of
+    each year. If \a year is \c Unspecified (its default, if not passed), the
+    month's length in a normal year is returned.
 
-  \sa maximumDaysInMonth(), minimumDaysInMonth()
+    \sa maximumDaysInMonth(), minimumDaysInMonth()
 */
 int QCalendar::daysInMonth(int month, int year) const
 {
@@ -735,7 +740,7 @@ int QCalendar::daysInMonth(int month, int year) const
 }
 
 /*!
-  Returns the number of days in the given \a year.
+    Returns the number of days in the given \a year.
 */
 int QCalendar::daysInYear(int year) const
 {
@@ -751,12 +756,12 @@ int QCalendar::monthsInYear(int year) const
 }
 
 /*!
-  Returns \c true precisely if the given \a year, \a month, and \a day specify a
-  valid date in this calendar.
+    Returns \c true precisely if the given \a year, \a month, and \a day specify
+    a valid date in this calendar.
 
-  Usually this means 1 <= month <= monthsInYear(year) and 1 <= day <=
-  daysInMonth(month, year). However, calendars with intercallary days or months
-  may complicate that.
+    Usually this means 1 <= month <= monthsInYear(year) and 1 <= day <=
+    daysInMonth(month, year). However, calendars with intercallary days or
+    months may complicate that.
 */
 bool QCalendar::isDateValid(int year, int month, int day) const
 {
@@ -776,13 +781,13 @@ bool QCalendar::isGregorian() const
 }
 
 /*!
-  Returns \c true if the given \a year is a leap year.
+    Returns \c true if the given \a year is a leap year.
 
-  Since the year is not a whole number of days long, some years are longer than
-  others. The difference may be a whole month or just a single day; the details
-  vary between calendars.
+    Since the year is not a whole number of days long, some years are longer
+    than others. The difference may be a whole month or just a single day; the
+    details vary between calendars.
 
-  \sa isDateValid()
+    \sa isDateValid()
 */
 bool QCalendar::isLeapYear(int year) const
 {
@@ -790,9 +795,9 @@ bool QCalendar::isLeapYear(int year) const
 }
 
 /*!
-  Returns \c true if this calendar is a lunar calendar.
+    Returns \c true if this calendar is a lunar calendar.
 
-  A lunar calendar is one based primarily on the phases of the moon.
+    A lunar calendar is one based primarily on the phases of the moon.
 */
 bool QCalendar::isLunar() const
 {
@@ -800,11 +805,11 @@ bool QCalendar::isLunar() const
 }
 
 /*!
-  Returns \c true if this calendar is luni-solar.
+    Returns \c true if this calendar is luni-solar.
 
-  A luni-solar calendar expresses the phases of the moon but adapts itself to
-  also keep track of the Sun's varying position in the sky, relative to the
-  fixed stars.
+    A luni-solar calendar expresses the phases of the moon but adapts itself to
+    also keep track of the Sun's varying position in the sky, relative to the
+    fixed stars.
 */
 bool QCalendar::isLuniSolar() const
 {
@@ -812,10 +817,10 @@ bool QCalendar::isLuniSolar() const
 }
 
 /*!
-  Returns \c true if this calendar is solar.
+    Returns \c true if this calendar is solar.
 
-  A solar calendar is based primarily on the Sun's varying position in the sky,
-  relative to the fixed stars.
+    A solar calendar is based primarily on the Sun's varying position in the
+    sky, relative to the fixed stars.
 */
 bool QCalendar::isSolar() const
 {
@@ -823,13 +828,13 @@ bool QCalendar::isSolar() const
 }
 
 /*!
-  Returns \c true if this calendar is proleptic.
+    Returns \c true if this calendar is proleptic.
 
-  A proleptic calendar is able to describe years arbitrarily long before its
-  first. These are represented by negative year numbers and possibly by a year
-  zero.
+    A proleptic calendar is able to describe years arbitrarily long before its
+    first. These are represented by negative year numbers and possibly by a year
+    zero.
 
-  \sa hasYearZero()
+    \sa hasYearZero()
 */
 bool QCalendar::isProleptic() const
 {
@@ -837,29 +842,29 @@ bool QCalendar::isProleptic() const
 }
 
 /*!
-  Returns \c true if this calendar has a year zero.
-
-  A non-proleptic calendar with no year zero represents years from its first
-  year onwards but provides no way to describe years before its first; such a
-  calendar has no year zero and is not proleptic.
-
-  A calendar which represents years before its first may number these years
-  simply by following the usual integer counting, so that the year before the
-  first is year zero, with negative-numbered years preceding this; such a
-  calendar is proleptic and has a year zero. A calendar might also have a year
-  zero (for example, the year of some great event, with subsequent years being
-  the first year after that event, the second year after, and so on) without
-  describing years before its year zero. Such a calendar would have a year zero
-  without being proleptic.
-
-  Some calendars, however, represent years before their first by an alternate
-  numbering; for example, the proleptic Gregorian calendar's first year is 1 CE
-  and the year before it is 1 BCE, preceded by 2 BCE and so on. In this case,
-  we use negative year numbers, with year -1 as the year before year 1, year -2
-  as the year before year -1 and so on. Such a calendar is proleptic but has no
-  year zero.
-
-  \sa isProleptic()
+    Returns \c true if this calendar has a year zero.
+
+    A calendar may represent years from its first year onwards but provide no
+    way to describe years before its first; such a calendar has no year zero and
+    is not proleptic.
+
+    A calendar which represents years before its first may number these years
+    simply by following the usual integer counting, so that the year before the
+    first is year zero, with negative-numbered years preceding this; such a
+    calendar is proleptic and has a year zero. A calendar might also have a year
+    zero (for example, the year of some great event, with subsequent years being
+    the first year after that event, the second year after, and so on) without
+    describing years before its year zero. Such a calendar would have a year
+    zero without being proleptic.
+
+    Some calendars, however, represent years before their first by an alternate
+    numbering; for example, the proleptic Gregorian calendar's first year is 1
+    CE and the year before it is 1 BCE, preceded by 2 BCE and so on. In this
+    case, we use negative year numbers for this alternate numbering, with year
+    -1 as the year before year 1, year -2 as the year before year -1 and so
+    on. Such a calendar is proleptic but has no year zero.
+
+    \sa isProleptic()
 */
 bool QCalendar::hasYearZero() const
 {
@@ -867,9 +872,9 @@ bool QCalendar::hasYearZero() const
 }
 
 /*!
-  Returns the number of days in the longest month in the calendar, in any year.
+    Returns the number of days in the longest month in the calendar, in any year.
 
-  \sa daysInMonth(), minimumDaysInMonth()
+    \sa daysInMonth(), minimumDaysInMonth()
 */
 int QCalendar::maximumDaysInMonth() const
 {
@@ -877,9 +882,9 @@ int QCalendar::maximumDaysInMonth() const
 }
 
 /*!
-  Returns the number of days in the shortest month in the calendar, in any year.
+    Returns the number of days in the shortest month in the calendar, in any year.
 
-  \sa daysInMonth(), maximumDaysInMonth()
+    \sa daysInMonth(), maximumDaysInMonth()
 */
 int QCalendar::minimumDaysInMonth() const
 {
@@ -887,9 +892,9 @@ int QCalendar::minimumDaysInMonth() const
 }
 
 /*!
-  Returns the largest number of months that any year may contain.
+    Returns the largest number of months that any year may contain.
 
-  \sa monthName(), standaloneMonthName(), monthsInYear()
+    \sa monthName(), standaloneMonthName(), monthsInYear()
 */
 int QCalendar::maximumMonthsInYear() const
 {
@@ -939,13 +944,13 @@ QCalendar::YearMonthDay QCalendar::partsFromDate(QDate date) const
 }
 
 /*!
-  Returns the day of the week number for the given \a date.
+    Returns the day of the week number for the given \a date.
 
-  Returns zero if the calendar is unable to represent the indicated date.
-  Returns 1 for Monday through 7 for Sunday. Calendars with intercallary days
-  may use other numbers to represent these.
+    Returns zero if the calendar is unable to represent the indicated date.
+    Returns 1 for Monday through 7 for Sunday. Calendars with intercallary days
+    may use other numbers to represent these.
 
-  \sa partsFromDate(), Qt::DayOfWeek
+    \sa partsFromDate(), Qt::DayOfWeek
 */
 int QCalendar::dayOfWeek(QDate date) const
 {
@@ -955,23 +960,23 @@ int QCalendar::dayOfWeek(QDate date) const
 // Locale data access
 
 /*!
-  Returns a suitably localised name for a month.
+    Returns a suitably localised name for a month.
 
-  The month is indicated by a number, with \a month = 1 meaning the first month
-  of the year and subsequent months numbered accordingly. Returns an empty
-  string if the \a month number is unrecognized.
+    The month is indicated by a number, with \a month = 1 meaning the first
+    month of the year and subsequent months numbered accordingly. Returns an
+    empty string if the \a month number is unrecognized.
 
-  The \a year may be Unspecified, in which case the mapping from numbers to
-  names for a typical year's months should be used. Some calendars have leap
-  months that aren't always at the end of the year; their mapping of month
-  numbers to names may then depend on the placement of a leap month. Thus the
-  year should normally be specified, if known.
+    The \a year may be Unspecified, in which case the mapping from numbers to
+    names for a typical year's months should be used. Some calendars have leap
+    months that aren't always at the end of the year; their mapping of month
+    numbers to names may then depend on the placement of a leap month. Thus the
+    year should normally be specified, if known.
 
-  The name is returned in the form that would normally be used in a full date,
-  in the specified \a locale; the \a format determines how fully it shall be
-  expressed (i.e. to what extent it is abbreviated).
+    The name is returned in the form that would normally be used in a full date,
+    in the specified \a locale; the \a format determines how fully it shall be
+    expressed (i.e. to what extent it is abbreviated).
 
-  \sa standaloneMonthName(), maximumMonthsInYear(), dateTimeToString()
+    \sa standaloneMonthName(), maximumMonthsInYear(), dateTimeToString()
 */
 QString QCalendar::monthName(const QLocale &locale, int month, int year,
                              QLocale::FormatType format) const
@@ -984,23 +989,23 @@ QString QCalendar::monthName(const QLocale &locale, int month, int year,
 }
 
 /*!
-  Returns a suitably localised standalone name for a month.
+    Returns a suitably localised standalone name for a month.
 
-  The month is indicated by a number, with \a month = 1 meaning the first month
-  of the year and subsequent months numbered accordingly. Returns an empty
-  string if the \a month number is unrecognized.
+    The month is indicated by a number, with \a month = 1 meaning the first
+    month of the year and subsequent months numbered accordingly. Returns an
+    empty string if the \a month number is unrecognized.
 
-  The \a year may be Unspecified, in which case the mapping from numbers to
-  names for a typical year's months should be used. Some calendars have leap
-  months that aren't always at the end of the year; their mapping of month
-  numbers to names may then depend on the placement of a leap month. Thus the
-  year should normally be specified, if known.
+    The \a year may be Unspecified, in which case the mapping from numbers to
+    names for a typical year's months should be used. Some calendars have leap
+    months that aren't always at the end of the year; their mapping of month
+    numbers to names may then depend on the placement of a leap month. Thus the
+    year should normally be specified, if known.
 
-  The name is returned in the form that would be used in isolation in the
-  specified \a locale; the \a format determines how fully it shall be expressed
-  (i.e. to what extent it is abbreviated).
+    The name is returned in the form that would be used in isolation in the
+    specified \a locale; the \a format determines how fully it shall be
+    expressed (i.e. to what extent it is abbreviated).
 
-  \sa monthName(), maximumMonthsInYear(), dateTimeToString()
+    \sa monthName(), maximumMonthsInYear(), dateTimeToString()
 */
 QString QCalendar::standaloneMonthName(const QLocale &locale, int month, int year,
                                        QLocale::FormatType format) const
@@ -1013,18 +1018,18 @@ QString QCalendar::standaloneMonthName(const QLocale &locale, int month, int yea
 }
 
 /*!
-  Returns a suitably localised name for a day of the week.
+    Returns a suitably localised name for a day of the week.
 
-  The days of the week are numbered from 1 for Monday through 7 for Sunday. Some
-  calendars may support higher numbers for other days (e.g. intercallary days,
-  that are not part of any week). Returns an empty string if the \a day number
-  is unrecognized.
+    The days of the week are numbered from 1 for Monday through 7 for
+    Sunday. Some calendars may support higher numbers for other days
+    (e.g. intercallary days, that are not part of any week). Returns an empty
+    string if the \a day number is unrecognized.
 
-  The name is returned in the form that would normally be used in a full date,
-  in the specified \a locale; the \a format determines how fully it shall be
-  expressed (i.e. to what extent it is abbreviated).
+    The name is returned in the form that would normally be used in a full date,
+    in the specified \a locale; the \a format determines how fully it shall be
+    expressed (i.e. to what extent it is abbreviated).
 
-  \sa standaloneWeekDayName(), dayOfWeek()
+    \sa standaloneWeekDayName(), dayOfWeek()
 */
 QString QCalendar::weekDayName(const QLocale &locale, int day,
                                QLocale::FormatType format) const
@@ -1033,19 +1038,20 @@ QString QCalendar::weekDayName(const QLocale &locale, int day,
 }
 
 /*!
-  Returns a suitably localised standalone name for a day of the week.
+    Returns a suitably localised standalone name for a day of the week.
 
-  The days of the week are numbered from 1 for Monday through 7 for Sunday. Some
-  calendars may support higher numbers for other days (e.g. intercallary days,
-  that are not part of any week). Returns an empty string if the \a day number
-  is unrecognized.
+    The days of the week are numbered from 1 for Monday through 7 for
+    Sunday. Some calendars may support higher numbers for other days
+    (e.g. intercallary days, that are not part of any week). Returns an empty
+    string if the \a day number is unrecognized.
 
-  The name is returned in the form that would be used in isolation (for example
-  as a column heading in a calendar's tabular display of a month with successive
-  weeks as rows) in the specified \a locale; the \a format determines how fully
-  it shall be expressed (i.e. to what extent it is abbreviated).
+    The name is returned in the form that would be used in isolation (for
+    example as a column heading in a calendar's tabular display of a month with
+    successive weeks as rows) in the specified \a locale; the \a format
+    determines how fully it shall be expressed (i.e. to what extent it is
+    abbreviated).
 
-  \sa weekDayName(), dayOfWeek()
+    \sa weekDayName(), dayOfWeek()
 */
 QString QCalendar::standaloneWeekDayName(const QLocale &locale, int day,
                                          QLocale::FormatType format) const
@@ -1054,23 +1060,23 @@ QString QCalendar::standaloneWeekDayName(const QLocale &locale, int day,
 }
 
 /*!
-  Returns a string representing a given date, time or date-time.
-
-  If \a datetime is valid, it is represented and format specifiers for both date
-  and time fields are recognized; otherwise, if \a dateOnly is valid, it is
-  represented and only format specifiers for date fields are recognized;
-  finally, if \a timeOnly is valid, it is represented and only format specifiers
-  for time fields are recognized. If none of these is valid, an empty string is
-  returned.
-
-  See QDate::toString and QTime::toString() for the supported field specifiers.
-  Characters in \a format that are recognized as field specifiers are replaced
-  by text representing appropriate data from the date and/or time being
-  represented. The texts to represent them may depend on the \a locale
-  specified. Other charagers in \a format are copied verbatim into the returned
-  string.
-
-  \sa monthName(), weekDayName(), QDate::toString(), QTime::toString()
+    Returns a string representing a given date, time or date-time.
+
+    If \a datetime is valid, it is represented and format specifiers for both
+    date and time fields are recognized; otherwise, if \a dateOnly is valid, it
+    is represented and only format specifiers for date fields are recognized;
+    finally, if \a timeOnly is valid, it is represented and only format
+    specifiers for time fields are recognized. If none of these is valid, an
+    empty string is returned.
+
+    See QDate::toString and QTime::toString() for the supported field
+    specifiers.  Characters in \a format that are recognized as field specifiers
+    are replaced by text representing appropriate data from the date and/or time
+    being represented. The texts to represent them may depend on the \a locale
+    specified. Other charagers in \a format are copied verbatim into the
+    returned string.
+
+    \sa monthName(), weekDayName(), QDate::toString(), QTime::toString()
 */
 QString QCalendar::dateTimeToString(QStringView format, const QDateTime &datetime,
                                     const QDate &dateOnly, const QTime &timeOnly,
diff --git a/src/corelib/time/qdatetime.cpp b/src/corelib/time/qdatetime.cpp
index 8b1665e7dd..13a54c1210 100644
--- a/src/corelib/time/qdatetime.cpp
+++ b/src/corelib/time/qdatetime.cpp
@@ -3432,15 +3432,15 @@ inline qint64 QDateTimePrivate::zoneMSecsToEpochMSecs(qint64 zoneMSecs, const QT
     datetime by adding a number of seconds, days, months, or years.
 
     QDateTime can describe datetimes with respect to \l{Qt::LocalTime}{local
-    time}, to \l{Qt::UTC}{UTC}, to a specified \l{Qt::OffsetFromUTC}{offset
-    from UTC} or to a specified \l{Qt::TimeZone}{time zone}, in conjunction
-    with the QTimeZone class. For example, a time zone of "Europe/Berlin" will
-    apply the daylight-saving rules as used in Germany since 1970. In contrast,
-    an offset from UTC of +3600 seconds is one hour ahead of UTC (usually
-    written in ISO standard notation as "UTC+01:00"), with no daylight-saving
-    offset or changes. When using either local time or a specified time zone,
-    time-zone transitions such as the starts and ends of daylight-saving time
-    (DST) are taken into account. The choice of system used to represent a
+    time}, to \l{Qt::UTC}{UTC}, to a specified \l{Qt::OffsetFromUTC}{offset from
+    UTC} or to a specified \l{Qt::TimeZone}{time zone}, in conjunction with the
+    QTimeZone class. For example, a time zone of "Europe/Berlin" will apply the
+    daylight-saving rules as used in Germany since 1970. In contrast, an offset
+    from UTC of +3600 seconds is one hour ahead of UTC (usually written in ISO
+    standard notation as "UTC+01:00"), with no daylight-saving offset or
+    changes. When using either local time or a specified time zone, time-zone
+    transitions such as the starts and ends of daylight-saving time (DST; but
+    see below) are taken into account. The choice of system used to represent a
     datetime is described as its "timespec".
 
     A QDateTime object is typically created either by giving a date and time
@@ -3528,11 +3528,13 @@ inline qint64 QDateTimePrivate::zoneMSecsToEpochMSecs(qint64 zoneMSecs, const QT
 
     The range of valid dates taking DST into account is 1970-01-01 to the
     present, and rules are in place for handling DST correctly until 2037-12-31,
-    but these could change. For dates falling outside that range, QDateTime
-    makes a \e{best guess} using the rules for year 1970 or 2037, but we can't
-    guarantee accuracy. This means QDateTime doesn't take into account changes
-    in a time zone before 1970, even if the system's time zone database provides
-    that information.
+    but these could change. For dates after 2037, QDateTime makes a \e{best
+    guess} using the rules for year 2037, but we can't guarantee accuracy;
+    indeed, for \e{any} future date, the time-zone may change its rules before
+    that date comes around. For dates before 1970, QDateTime doesn't take DST
+    changes into account, even if the system's time zone database provides that
+    information, although it does take into account changes to the time-zone's
+    standard offset, where this information is available.
 
     \section2 Offsets From UTC
 
@@ -3797,17 +3799,22 @@ QTimeZone QDateTime::timeZone() const
 /*!
     \since 5.2
 
-    Returns the current Offset From UTC in seconds.
+    Returns this date-time's Offset From UTC in seconds.
 
-    If the timeSpec() is Qt::OffsetFromUTC this will be the value originally set.
-
-    If the timeSpec() is Qt::TimeZone this will be the offset effective in the
-    Time Zone including any Daylight-Saving Offset.
-
-    If the timeSpec() is Qt::LocalTime this will be the difference between the
-    Local Time and UTC including any Daylight-Saving Offset.
+    The result depends on timeSpec():
+    \list
+    \li \c Qt::UTC The offset is 0.
+    \li \c Qt::OffsetFromUTC The offset is the value originally set.
+    \li \c Qt::LocalTime The local time's offset from UTC is returned.
+    \li \c Qt::TimeZone The offset used by the time-zone is returned.
+    \endlist
 
-    If the timeSpec() is Qt::UTC this will be 0.
+    For the last two, the offset at this date and time will be returned, taking
+    account of Daylight-Saving Offset unless the date precedes the start of
+    1970. The offset is the difference between the local time or time in the
+    given time-zone and UTC time; it is positive in time-zones ahead of UTC
+    (East of The Prime Meridian), negative for those behind UTC (West of The
+    Prime Meridian).
 
     \sa setOffsetFromUtc()
 */
diff --git a/src/corelib/time/qhijricalendar.cpp b/src/corelib/time/qhijricalendar.cpp
index 9aabe46570..b5d89fbc5c 100644
--- a/src/corelib/time/qhijricalendar.cpp
+++ b/src/corelib/time/qhijricalendar.cpp
@@ -44,36 +44,37 @@
 QT_BEGIN_NAMESPACE
 
 /*!
-  \since 5.14
+    \since 5.14
+    \internal
 
-  \class QHijriCalendar
-  \inmodule QtCore
-  \brief The QHijriCalendar class supports Islamic (Hijri) calendar implementations.
+    \class QHijriCalendar
+    \inmodule QtCore
+    \brief The QHijriCalendar class supports Islamic (Hijri) calendar implementations.
 
-  \section1 Islamic Calendar System
+    \section1 Islamic Calendar System
 
-  The Islamic, Muslim, or Hijri calendar is a lunar calendar consisting of 12
-  months in a year of 354 or 355 days. It is used (often alongside the
-  Gregorian calendar) to date events in many Muslim countries. It is also used
-  by Muslims to determine the proper days of Islamic holidays and rituals,
-  such as the annual period of fasting and the proper time for the pilgrimage
-  to Mecca.
+    The Islamic, Muslim, or Hijri calendar is a lunar calendar consisting of 12
+    months in a year of 354 or 355 days. It is used (often alongside the
+    Gregorian calendar) to date events in many Muslim countries. It is also used
+    by Muslims to determine the proper days of Islamic holidays and rituals,
+    such as the annual period of fasting and the proper time for the pilgrimage
+    to Mecca.
 
-  Source: \l {https://en.wikipedia.org/wiki/Islamic_calendar}{Wikipedia page on
-  Hijri Calendar}
+    Source: \l {https://en.wikipedia.org/wiki/Islamic_calendar}{Wikipedia page
+    on Hijri Calendar}
 
-  \section1 Support for variants
+    \section1 Support for variants
 
-  This base class provides the common details shared by all variants on the
-  Islamic calendar. Each year comprises 12 months of 29 or 30 days each; most
-  years have as many of 29 as of 30, but leap years extend one 29-day month to
-  30 days. In tabular versions of the calendar (where mathematical rules are
-  used to determine the details), odd-numbered months have 30 days, as does the
-  last (twelfth) month of a leap year; all other months have 29 days. Other
-  versions are based on actual astronomical observations of the moon's phase at
-  sunset, which vary from place to place.
+    This base class provides the common details shared by all variants on the
+    Islamic calendar. Each year comprises 12 months of 29 or 30 days each; most
+    years have as many of 29 as of 30, but leap years extend one 29-day month to
+    30 days. In tabular versions of the calendar (where mathematical rules are
+    used to determine the details), odd-numbered months have 30 days, as does
+    the last (twelfth) month of a leap year; all other months have 29
+    days. Other versions are based on actual astronomical observations of the
+    moon's phase at sunset, which vary from place to place.
 
-  \sa QIslamicCivilCalendar, QCalendar
+    \sa QIslamicCivilCalendar, QCalendar
 */
 
 bool QHijriCalendar::isLunar() const
diff --git a/src/corelib/time/qislamiccivilcalendar.cpp b/src/corelib/time/qislamiccivilcalendar.cpp
index 27c93f5c00..a6a2afd207 100644
--- a/src/corelib/time/qislamiccivilcalendar.cpp
+++ b/src/corelib/time/qislamiccivilcalendar.cpp
@@ -47,27 +47,29 @@ QT_BEGIN_NAMESPACE
 using namespace QRoundingDown;
 
 /*!
-  \since 5.14
+    \since 5.14
+    \internal
 
-  \class QIslamicCivilCalendar
-  \inmodule QtCore
-  \brief Implements a commonly-used computed version of the Islamic calendar.
+    \class QIslamicCivilCalendar
+    \inmodule QtCore
+    \brief Implements a commonly-used computed version of the Islamic calendar.
 
-  \section1 Civil Islamic Calendar
+    \section1 Civil Islamic Calendar
 
-  QIslamicCivilCalendar implements a tabular version of the Hijri calendar which
-  is known as the Islamic Civil Calendar. It has the same numbering of years and
-  months, but the months are determined by arithmetical rules rather than by
-  observation or astronomical calculations.
+    QIslamicCivilCalendar implements a tabular version of the Hijri calendar
+    which is known as the Islamic Civil Calendar. It has the same numbering of
+    years and months, but the months are determined by arithmetical rules rather
+    than by observation or astronomical calculations.
 
-  \section2 Calendar Organization
+    \section2 Calendar Organization
 
-  The civil calendar follows the usual tabular scheme of odd-numbered months and
-  the last month of each leap year being 30 days long, the rest being 29 days
-  long. Its determination of leap years follows a 30-year cycle, in each of
-  which the years 2, 5, 7, 10, 13, 16, 18, 21, 24, 26 and 29 are leap years.
+    The civil calendar follows the usual tabular scheme of odd-numbered months
+    and the last month of each leap year being 30 days long, the rest being 29
+    days long. Its determination of leap years follows a 30-year cycle, in each
+    of which the years 2, 5, 7, 10, 13, 16, 18, 21, 24, 26 and 29 are leap
+    years.
 
-  \sa QJijriCalendar, QCalendar
+    \sa QHijriCalendar, QCalendar
 */
 
 QIslamicCivilCalendar::QIslamicCivilCalendar()
diff --git a/src/corelib/time/qromancalendar.cpp b/src/corelib/time/qromancalendar.cpp
index 36cad01b81..c3cd134490 100644
--- a/src/corelib/time/qromancalendar.cpp
+++ b/src/corelib/time/qromancalendar.cpp
@@ -44,20 +44,20 @@
 QT_BEGIN_NAMESPACE
 
 /*!
-  \since 5.14
+    \since 5.14
 
-  \class QRomanCalendar
-  \inmodule QtCore
-  \brief The QRomanCalendar class is a shared base for calendars based on the
-  ancient Roman calendar.
+    \class QRomanCalendar
+    \inmodule QtCore
+    \brief The QRomanCalendar class is a shared base for calendars based on the
+    ancient Roman calendar.
 
-  \section1
+    \section1
 
-  Calendars based on the ancient Roman calendar share the names of months, whose
-  lengths depend in a common way on whether the year is a leap year. They differ
-  in how they determine which years are leap years.
+    Calendars based on the ancient Roman calendar share the names of months,
+    whose lengths depend in a common way on whether the year is a leap
+    year. They differ in how they determine which years are leap years.
 
-  \sa QGregorianCalendar, QJulianCalendar, QMilankovicCalendar
+    \sa QGregorianCalendar, QJulianCalendar, QMilankovicCalendar
 */
 
 int QRomanCalendar::daysInMonth(int month, int year) const
diff --git a/src/corelib/time/qtimezone.cpp b/src/corelib/time/qtimezone.cpp
index ef323de14a..410a16e3c5 100644
--- a/src/corelib/time/qtimezone.cpp
+++ b/src/corelib/time/qtimezone.cpp
@@ -325,20 +325,33 @@ QTimeZone::QTimeZone() noexcept
 /*!
     Creates an instance of the requested time zone \a ianaId.
 
-    The ID must be one of the available system IDs otherwise an invalid
-    time zone will be returned.
+    The ID must be one of the available system IDs or a valid UTC-with-offset
+    ID, otherwise an invalid time zone will be returned.
 
     \sa availableTimeZoneIds()
 */
 
 QTimeZone::QTimeZone(const QByteArray &ianaId)
 {
-    // Try and see if it's a valid UTC offset ID, just as quick to try create as look-up
+    // Try and see if it's a CLDR UTC offset ID - just as quick by creating as
+    // by looking up.
     d = new QUtcTimeZonePrivate(ianaId);
-    // If not a valid UTC offset ID then try create it with the system backend
-    // Relies on backend not creating valid tz with invalid name
+    // If not a CLDR UTC offset ID then try creating it with the system backend.
+    // Relies on backend not creating valid TZ with invalid name.
     if (!d->isValid())
         d = newBackendTimeZone(ianaId);
+    // Can also handle UTC with arbitrary (valid) offset, but only do so as
+    // fall-back, since either of the above may handle it more informatively.
+    if (!d->isValid()) {
+        qint64 offset = QUtcTimeZonePrivate::offsetFromUtcString(ianaId);
+        if (offset != QTimeZonePrivate::invalidSeconds()) {
+            // Should have abs(offset) < 24 * 60 * 60 = 86400.
+            qint32 seconds = qint32(offset);
+            Q_ASSERT(qint64(seconds) == offset);
+            // NB: this canonicalises the name, so it might not match ianaId
+            d = new QUtcTimeZonePrivate(seconds);
+        }
+    }
 }
 
 /*!
diff --git a/src/corelib/time/qtimezoneprivate.cpp b/src/corelib/time/qtimezoneprivate.cpp
index 569b343187..72a0e3c24e 100644
--- a/src/corelib/time/qtimezoneprivate.cpp
+++ b/src/corelib/time/qtimezoneprivate.cpp
@@ -1,5 +1,6 @@
 /****************************************************************************
 **
+** Copyright (C) 2019 The Qt Company Ltd.
 ** Copyright (C) 2013 John Layt <jlayt@kde.org>
 ** Contact: https://www.qt.io/licensing/
 **
@@ -761,6 +762,39 @@ QUtcTimeZonePrivate::QUtcTimeZonePrivate(const QByteArray &id)
     }
 }
 
+qint64 QUtcTimeZonePrivate::offsetFromUtcString(const QByteArray &id)
+{
+    // Convert reasonable UTC[+-]\d+(:\d+){,2} to offset in seconds.
+    // Assumption: id has already been tried as a CLDR UTC offset ID (notably
+    // including plain "UTC" itself) and a system offset ID; it's neither.
+    if (!id.startsWith("UTC") || id.size() < 5)
+        return invalidSeconds(); // Doesn't match
+    const char signChar = id.at(3);
+    if (signChar != '-' && signChar != '+')
+        return invalidSeconds(); // No sign
+    const int sign = signChar == '-' ? -1 : 1;
+
+    const auto offsets = id.mid(4).split(':');
+    if (offsets.isEmpty() || offsets.size() > 3)
+        return invalidSeconds(); // No numbers, or too many.
+
+    qint32 seconds = 0;
+    int prior = 0; // Number of fields parsed thus far
+    for (const auto &offset : offsets) {
+        bool ok = false;
+        unsigned short field = offset.toUShort(&ok);
+        // Bound hour above at 24, minutes and seconds at 60:
+        if (!ok || field >= (prior ? 60 : 24))
+            return invalidSeconds();
+        seconds = seconds * 60 + field;
+        ++prior;
+    }
+    while (prior++ < 3)
+        seconds *= 60;
+
+    return seconds * sign;
+}
+
 // Create offset from UTC
 QUtcTimeZonePrivate::QUtcTimeZonePrivate(qint32 offsetSeconds)
 {
@@ -874,22 +908,25 @@ QByteArray QUtcTimeZonePrivate::systemTimeZoneId() const
 
 bool QUtcTimeZonePrivate::isTimeZoneIdAvailable(const QByteArray &ianaId) const
 {
+    // Only the zone IDs supplied by CLDR and recognized by constructor.
     for (int i = 0; i < utcDataTableSize; ++i) {
         const QUtcData *data = utcData(i);
-        if (utcId(data) == ianaId) {
+        if (utcId(data) == ianaId)
             return true;
-        }
     }
+    // But see offsetFromUtcString(), which lets us accept some "unavailable" IDs.
     return false;
 }
 
 QList<QByteArray> QUtcTimeZonePrivate::availableTimeZoneIds() const
 {
+    // Only the zone IDs supplied by CLDR and recognized by constructor.
     QList<QByteArray> result;
     result.reserve(utcDataTableSize);
     for (int i = 0; i < utcDataTableSize; ++i)
         result << utcId(utcData(i));
-    std::sort(result.begin(), result.end()); // ### or already sorted??
+    // Not guaranteed to be sorted, so sort:
+    std::sort(result.begin(), result.end());
     // ### assuming no duplicates
     return result;
 }
@@ -904,13 +941,16 @@ QList<QByteArray> QUtcTimeZonePrivate::availableTimeZoneIds(QLocale::Country cou
 
 QList<QByteArray> QUtcTimeZonePrivate::availableTimeZoneIds(qint32 offsetSeconds) const
 {
+    // Only if it's present in CLDR. (May get more than one ID: UTC, UTC+00:00
+    // and UTC-00:00 all have the same offset.)
     QList<QByteArray> result;
     for (int i = 0; i < utcDataTableSize; ++i) {
         const QUtcData *data = utcData(i);
         if (data->offsetFromUtc == offsetSeconds)
             result << utcId(data);
     }
-    std::sort(result.begin(), result.end()); // ### or already sorted??
+    // Not guaranteed to be sorted, so sort:
+    std::sort(result.begin(), result.end());
     // ### assuming no duplicates
     return result;
 }
diff --git a/src/corelib/time/qtimezoneprivate_p.h b/src/corelib/time/qtimezoneprivate_p.h
index 5f6491ef81..a57f61f381 100644
--- a/src/corelib/time/qtimezoneprivate_p.h
+++ b/src/corelib/time/qtimezoneprivate_p.h
@@ -188,6 +188,9 @@ public:
     QUtcTimeZonePrivate(const QUtcTimeZonePrivate &other);
     virtual ~QUtcTimeZonePrivate();
 
+    // Fall-back for UTC[+-]\d+(:\d+){,2} IDs.
+    static qint64 offsetFromUtcString(const QByteArray &id);
+
     QUtcTimeZonePrivate *clone() const override;
 
     Data data(qint64 forMSecsSinceEpoch) const override;
diff --git a/src/corelib/time/qtimezoneprivate_win.cpp b/src/corelib/time/qtimezoneprivate_win.cpp
index 1bf2366748..5a480222e0 100644
--- a/src/corelib/time/qtimezoneprivate_win.cpp
+++ b/src/corelib/time/qtimezoneprivate_win.cpp
@@ -371,6 +371,7 @@ QDate calculateTransitionLocalDate(const SYSTEMTIME &rule, int year)
     // Otherwise, the rule date is annual and relative:
     const int dayOfWeek = rule.wDayOfWeek == 0 ? 7 : rule.wDayOfWeek;
     QDate date(year, rule.wMonth, 1);
+    Q_ASSERT(date.isValid());
     // How many days before was last dayOfWeek before target month ?
     int adjust = dayOfWeek - date.dayOfWeek(); // -6 <= adjust < 7
     if (adjust >= 0) // Ensure -7 <= adjust < 0:
@@ -401,6 +402,7 @@ qint64 calculateTransitionForYear(const SYSTEMTIME &rule, int year, int bias)
 {
     // TODO Consider caching the calculated values - i.e. replace SYSTEMTIME in
     // WinTransitionRule; do this in init() once and store the results.
+    Q_ASSERT(year);
     const QDate date = calculateTransitionLocalDate(rule, year);
     const QTime time = QTime(rule.wHour, rule.wMinute, rule.wSecond);
     if (date.isValid() && time.isValid())
@@ -479,6 +481,7 @@ struct TransitionTimePair
 
 int yearEndOffset(const QWinTimeZonePrivate::QWinTransitionRule &rule, int year)
 {
+    Q_ASSERT(year);
     int offset = rule.standardTimeBias;
     // Only needed to help another TransitionTimePair work out year + 1's start
     // offset; and the oldYearOffset we use only affects an alleged transition
@@ -743,11 +746,12 @@ QTimeZonePrivate::Data QWinTimeZonePrivate::data(qint64 forMSecsSinceEpoch) cons
         const QWinTransitionRule &rule = m_tranRules.at(ruleIndex);
         // Does this rule's period include any transition at all ?
         if (rule.standardTimeRule.wMonth > 0 || rule.daylightTimeRule.wMonth > 0) {
-            const int endYear = qMax(rule.startYear, year - 1);
+            int prior = year == 1 ? -1 : year - 1; // No year 0.
+            const int endYear = qMax(rule.startYear, prior);
             while (year >= endYear) {
                 const int newYearOffset = (year <= rule.startYear && ruleIndex > 0)
-                    ? yearEndOffset(m_tranRules.at(ruleIndex - 1), year - 1)
-                    : yearEndOffset(rule, year - 1);
+                    ? yearEndOffset(m_tranRules.at(ruleIndex - 1), prior)
+                    : yearEndOffset(rule, prior);
                 const TransitionTimePair pair(rule, year, newYearOffset);
                 bool isDst = false;
                 if (pair.std != invalidMSecs() && pair.std <= forMSecsSinceEpoch) {
@@ -755,7 +759,8 @@ QTimeZonePrivate::Data QWinTimeZonePrivate::data(qint64 forMSecsSinceEpoch) cons
                 } else if (pair.dst != invalidMSecs() && pair.dst <= forMSecsSinceEpoch) {
                     isDst = true;
                 } else {
-                    --year; // Try an earlier year for this rule (once).
+                    year = prior; // Try an earlier year for this rule (once).
+                    prior = year == 1 ? -1 : year - 1; // No year 0.
                     continue;
                 }
                 return ruleToData(rule, forMSecsSinceEpoch,
@@ -767,8 +772,11 @@ QTimeZonePrivate::Data QWinTimeZonePrivate::data(qint64 forMSecsSinceEpoch) cons
             // No transition, no DST, use the year's standard time.
             return ruleToData(rule, forMSecsSinceEpoch, QTimeZone::StandardTime);
         }
-        if (year >= rule.startYear)
+        if (year >= rule.startYear) {
             year = rule.startYear - 1; // Seek last transition in new rule.
+            if (!year)
+                --year;
+        }
     }
     // We don't have relevant data :-(
     return invalidData();
@@ -795,9 +803,10 @@ QTimeZonePrivate::Data QWinTimeZonePrivate::nextTransition(qint64 afterMSecsSinc
                 year = rule.startYear; // Seek first transition in this rule.
             const int endYear = ruleIndex + 1 < m_tranRules.count()
                 ? qMin(m_tranRules.at(ruleIndex + 1).startYear, year + 2) : (year + 2);
+            int prior = year == 1 ? -1 : year - 1; // No year 0.
             int newYearOffset = (year <= rule.startYear && ruleIndex > 0)
-                ? yearEndOffset(m_tranRules.at(ruleIndex - 1), year - 1)
-                : yearEndOffset(rule, year - 1);
+                ? yearEndOffset(m_tranRules.at(ruleIndex - 1), prior)
+                : yearEndOffset(rule, prior);
             while (year < endYear) {
                 const TransitionTimePair pair(rule, year, newYearOffset);
                 bool isDst = false;
@@ -810,7 +819,9 @@ QTimeZonePrivate::Data QWinTimeZonePrivate::nextTransition(qint64 afterMSecsSinc
                     newYearOffset = rule.standardTimeBias;
                     if (pair.dst > pair.std)
                         newYearOffset += rule.daylightTimeBias;
-                    ++year; // Try a later year for this rule (once).
+                    // Try a later year for this rule (once).
+                    prior = year;
+                    year = year == -1 ? 1 : year + 1; // No year 0
                     continue;
                 }
 
@@ -837,11 +848,12 @@ QTimeZonePrivate::Data QWinTimeZonePrivate::previousTransition(qint64 beforeMSec
         const QWinTransitionRule &rule = m_tranRules.at(ruleIndex);
         // Does this rule's period include any transition at all ?
         if (rule.standardTimeRule.wMonth > 0 || rule.daylightTimeRule.wMonth > 0) {
-            const int endYear = qMax(rule.startYear, year - 1);
+            int prior = year == 1 ? -1 : year - 1; // No year 0.
+            const int endYear = qMax(rule.startYear, prior);
             while (year >= endYear) {
                 const int newYearOffset = (year <= rule.startYear && ruleIndex > 0)
-                    ? yearEndOffset(m_tranRules.at(ruleIndex - 1), year - 1)
-                    : yearEndOffset(rule, year - 1);
+                    ? yearEndOffset(m_tranRules.at(ruleIndex - 1), prior)
+                    : yearEndOffset(rule, prior);
                 const TransitionTimePair pair(rule, year, newYearOffset);
                 bool isDst = false;
                 if (pair.std != invalidMSecs() && pair.std < beforeMSecsSinceEpoch) {
@@ -849,7 +861,8 @@ QTimeZonePrivate::Data QWinTimeZonePrivate::previousTransition(qint64 beforeMSec
                 } else if (pair.dst != invalidMSecs() && pair.dst < beforeMSecsSinceEpoch) {
                     isDst = true;
                 } else {
-                    --year; // Try an earlier year for this rule (once).
+                    year = prior; // Try an earlier year for this rule (once).
+                    prior = year == 1 ? -1 : year - 1; // No year 0.
                     continue;
                 }
                 if (isDst)
@@ -863,8 +876,11 @@ QTimeZonePrivate::Data QWinTimeZonePrivate::previousTransition(qint64 beforeMSec
             // rule:
             return ruleToData(rule, startOfTime, QTimeZone::StandardTime, false);
         } // else: no transition during rule's period
-        if (year >= rule.startYear)
+        if (year >= rule.startYear) {
             year = rule.startYear - 1; // Seek last transition in new rule
+            if (!year)
+                --year;
+        }
     }
     // Apparently no transition before the given time:
     return invalidData();
diff --git a/src/corelib/tools/qcontainertools_impl.h b/src/corelib/tools/qcontainertools_impl.h
index 86a16eb32b..3a0c4381f1 100644
--- a/src/corelib/tools/qcontainertools_impl.h
+++ b/src/corelib/tools/qcontainertools_impl.h
@@ -49,8 +49,6 @@
 #include <QtCore/qglobal.h>
 #include <iterator>
 
-#ifndef Q_QDOC
-
 QT_BEGIN_NAMESPACE
 
 namespace QtPrivate
@@ -131,6 +129,4 @@ using IfAssociativeIteratorHasFirstAndSecond =
 
 QT_END_NAMESPACE
 
-#endif // Q_QDOC
-
 #endif // QCONTAINERTOOLS_IMPL_H