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

Conflicts: mkspecs/linux-icc/qmake.conf mkspecs/macx-icc/qmake.conf mkspecs/win32-icc/qmake.conf src/gui/painting/qgrayraster.c Change-Id: Ib08c45ea3215be05f986ecb3e1f4b37d209aa775
2017-04-07 10:18:50 +02:00 · 2017-04-07 10:18:50 +02:00 · 5d6073be27
commit 5d6073be27
parent 97d7d80e73 bbb67ca32c
175 changed files with 1543 additions and 1950 deletions
--- a/config.tests/common/alloca/alloca.cpp
+++ b/config.tests/common/alloca/alloca.cpp
@ -39,6 +39,9 @@

 #include <alloca.h>

+// extra include needed in QNX7 to define NULL for the alloca() macro
+#include <stdlib.h>
+
 int main(int, char **)
 {
    alloca(1);
--- a/config.tests/common/c++98default/c++98default.pro
+++ b/config.tests/common/c++98default/c++98default.pro
@ -1,3 +0,0 @@
-TEMPLATE = app
-CONFIG -= c++11 c++14 c++1z
-SOURCES = c++98default.cpp
--- a/config.tests/common/f16c/f16c.cpp
+++ b/config.tests/common/f16c/f16c.cpp
@ -41,14 +41,11 @@

 int main(int, char**)
 {
-    float f = 1.f;
-    unsigned short s = _cvtss_sh(f, 0);
-    float g = _cvtsh_ss(s);
-    bool result = f == g;
-    (void)result;
    __m128i a = _mm_setzero_si128();
-    __m256 b = _mm256_cvtph_ps(a);
-    __m128i c = _mm256_cvtps_ph(b, 0);
+    __m128 b = _mm_cvtph_ps(a);
+    __m256 b256 = _mm256_cvtph_ps(a);
+    __m128i c = _mm_cvtps_ph(b, 0);
+    c = _mm256_cvtps_ph(b256, 0);
    (void)c;
    return 0;
 }
--- a/configure.json
+++ b/configure.json
@ -247,11 +247,6 @@
            "type": "compile",
            "test": "common/c++1z"
        },
-        "cxx11default": {
-            "label": "compiler defaulting to C++11 or higher",
-            "type": "compile",
-            "test": "common/c++98default"
-        },
        "precompile_header": {
            "label": "precompiled header support",
            "type": "compile",
@ -479,11 +474,6 @@
            "condition": "call.crossCompile",
            "output": [ "publicConfig", "privateConfig", "publicFeature", "crossCompile" ]
        },
-        "cxx11default": {
-            "label": "Compiler defaults to C++11 or higher",
-            "condition": "!tests.cxx11default",
-            "output": [ { "type": "publicConfig", "name": "c++11" } ]
-        },
        "compiler-flags": {
            "output": [ "compilerFlags" ]
        },
--- a/mkspecs/common/ghs-integrity-armv7.conf
+++ b/mkspecs/common/ghs-integrity-armv7.conf
@ -7,6 +7,8 @@ QMAKE_PLATFORM          = integrity

 include(unix.conf)

+QMAKE_CFLAGS           += -bigswitch
+
 include(ghs-base.conf)

 QMAKE_CC                = cxintarm -bsp $$(INTEGRITY_BSP) -os_dir $$(INTEGRITY_DIR) -non_shared
--- a/mkspecs/common/msvc-version.conf
+++ b/mkspecs/common/msvc-version.conf
@ -49,6 +49,8 @@ greaterThan(QMAKE_MSC_VER, 1799) {
    QMAKE_CFLAGS       += -FS
    QMAKE_CXXFLAGS     += -FS

+    QMAKE_CFLAGS_F16C   = -arch:AVX
+
    equals(QMAKE_MSC_VER, 1800) {
        QMAKE_CFLAGS_RELEASE += -Zc:strictStrings
        QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO += -Zc:strictStrings
--- a/mkspecs/features/data/macros.cpp
+++ b/mkspecs/features/data/macros.cpp
@ -1,4 +1,5 @@
 // Keep this file small. The pre-processed contents are eval'd by qmake.
+QT_COMPILER_STDCXX = __cplusplus
 #ifdef _MSC_VER
 QMAKE_MSC_VER = _MSC_VER
 QMAKE_MSC_FULL_VER = _MSC_FULL_VER
--- a/mkspecs/features/default_post.prf
+++ b/mkspecs/features/default_post.prf
@ -100,6 +100,11 @@ breakpad {
    !isEmpty(QMAKE_STRIP):QMAKE_POST_LINK = $$QMAKE_POST_LINK$$escape_expand(\\n\\t)$$quote($$QMAKE_STRIP $$DEBUGFILENAME)
 }

+!c++11:!c++14:!c++1z {
+    # Qt requires C++11 since 5.7, check if we need to force a compiler option
+    QT_COMPILER_STDCXX_no_L = $$replace(QT_COMPILER_STDCXX, "L$", "")
+    !greaterThan(QT_COMPILER_STDCXX_no_L, 199711): CONFIG += c++11
+}
 c++11|c++14|c++1z {
    # Disable special compiler flags for host builds
    !host_build|!cross_compile {
--- a/mkspecs/features/toolchain.prf
+++ b/mkspecs/features/toolchain.prf
@ -137,6 +137,7 @@ unset(target_prefix)

 # Populate QMAKE_COMPILER_DEFINES and some compatibility variables.
 # The $$format_number() calls strip leading zeros to avoid misinterpretation as octal.
+QMAKE_COMPILER_DEFINES += __cplusplus=$$QT_COMPILER_STDCXX
 !isEmpty(QMAKE_MSC_VER) {
    QMAKE_COMPILER_DEFINES += _MSC_VER=$$QMAKE_MSC_VER _MSC_FULL_VER=$$QMAKE_MSC_FULL_VER
    QT_MSVC_MAJOR_VERSION = $$replace(QMAKE_MSC_FULL_VER, "(..)(..)(.*)", "\\1")
--- a/mkspecs/linux-aarch64-gnu-g++/qmake.conf
+++ b/mkspecs/linux-aarch64-gnu-g++/qmake.conf
@ -0,0 +1,24 @@
+#
+# qmake configuration for building with aarch64-linux-gnu-g++
+#
+
+MAKEFILE_GENERATOR      = UNIX
+CONFIG                 += incremental
+QMAKE_INCREMENTAL_STYLE = sublib
+
+include(../common/linux.conf)
+include(../common/gcc-base-unix.conf)
+include(../common/g++-unix.conf)
+
+# modifications to g++.conf
+QMAKE_CC                = aarch64-linux-gnu-gcc
+QMAKE_CXX               = aarch64-linux-gnu-g++
+QMAKE_LINK              = aarch64-linux-gnu-g++
+QMAKE_LINK_SHLIB        = aarch64-linux-gnu-g++
+
+# modifications to linux.conf
+QMAKE_AR                = aarch64-linux-gnu-ar cqs
+QMAKE_OBJCOPY           = aarch64-linux-gnu-objcopy
+QMAKE_NM                = aarch64-linux-gnu-nm -P
+QMAKE_STRIP             = aarch64-linux-gnu-strip
+load(qt_config)
--- a/config.tests/common/c++98default/c++98default.cpp
+++ b/config.tests/common/c++98default/c++98default.cpp
@ -1,9 +1,9 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2017 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
-** This file is part of the configuration of the Qt Toolkit.
+** This file is part of the qmake spec of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** Commercial License Usage
@ -37,8 +37,4 @@
 **
 ****************************************************************************/

-#if __cplusplus < 201103L
-#error "compiler does not use c++11 or higher by default"
-#endif
-
-int main(int, char **) {}
+#include "../linux-g++/qplatformdefs.h"
--- a/mkspecs/linux-icc/qmake.conf
+++ b/mkspecs/linux-icc/qmake.conf
@ -42,6 +42,7 @@ QMAKE_CFLAGS_AVX512PF  += -xMIC-AVX512
 QMAKE_CFLAGS_AVX512DQ  += -xCORE-AVX512
 QMAKE_CFLAGS_AVX512BW  += -xCORE-AVX512
 QMAKE_CFLAGS_AVX512VL  += -xCORE-AVX512
+QMAKE_CFLAGS_F16C      += $$QMAKE_CFLAGS_AVX2
 QMAKE_CFLAGS_AESNI     += -maes
 QMAKE_CFLAGS_SHANI     += -msha

--- a/mkspecs/macx-icc/qmake.conf
+++ b/mkspecs/macx-icc/qmake.conf
@ -40,6 +40,7 @@ QMAKE_CFLAGS_AVX512PF  += -xMIC-AVX512
 QMAKE_CFLAGS_AVX512DQ  += -xCORE-AVX512
 QMAKE_CFLAGS_AVX512BW  += -xCORE-AVX512
 QMAKE_CFLAGS_AVX512VL  += -xCORE-AVX512
+QMAKE_CFLAGS_F16C      += $$QMAKE_CFLAGS_AVX2
 QMAKE_CFLAGS_AESNI     += -maes
 QMAKE_CFLAGS_SHANI     += -msha

--- a/mkspecs/win32-icc/qmake.conf
+++ b/mkspecs/win32-icc/qmake.conf
@ -33,6 +33,7 @@ QMAKE_CFLAGS_AVX512PF  += -QxMIC-AVX512
 QMAKE_CFLAGS_AVX512DQ  += -QxCORE-AVX512
 QMAKE_CFLAGS_AVX512BW  += -QxCORE-AVX512
 QMAKE_CFLAGS_AVX512VL  += -QxCORE-AVX512
+QMAKE_CFLAGS_F16C       = $$QMAKE_CFLAGS_AVX2
 QMAKE_CFLAGS_AESNI      = -QxSSE2
 QMAKE_CFLAGS_SHANI      = -QxSSE4.2

--- a/qmake/doc/src/qmake-manual.qdoc
+++ b/qmake/doc/src/qmake-manual.qdoc
@ -2883,6 +2883,11 @@
    MY_VAR2 will contain '-Lone -Ltwo -Lthree -Lfour -Lfive', and MY_VAR3 will
    contain 'three two three'.

+    \section2 files(pattern[, recursive=false])
+
+    Expands the specified wildcard pattern and returns a list of filenames.
+    If \c recursive is true, this function descends into subdirectories.
+
    \target fn_first
    \section2 first(variablename)

@ -3376,11 +3381,6 @@
    Exports the current value of \c variablename from the local context of a
    function to the global context.

-    \section2 files(pattern[, recursive=false])
-
-    Expands the specified wildcard pattern and returns a list of filenames.
-    If \c recursive is true, this function descends into subdirectories.
-
    \target forfunction
    \section2 for(iterate, list)

--- a/src/concurrent/qtconcurrentstoredfunctioncall.h
+++ b/src/concurrent/qtconcurrentstoredfunctioncall.h
@ -103,7 +103,7 @@ template <typename T, typename Class>
 class StoredMemberFunctionCall0 : public RunFunctionTask<T>
 {
 public:
-    StoredMemberFunctionCall0(T (Class::*_fn)() , const Class &_object)
+    StoredMemberFunctionCall0(T (Class::*_fn)(), const Class &_object)
    : fn(_fn), object(_object){ }

    void runFunctor() override
@ -119,7 +119,7 @@ template <typename T, typename Class>
 class VoidStoredMemberFunctionCall0 : public RunFunctionTask<T>
 {
 public:
-    VoidStoredMemberFunctionCall0(T (Class::*_fn)() , const Class &_object)
+    VoidStoredMemberFunctionCall0(T (Class::*_fn)(), const Class &_object)
    : fn(_fn), object(_object){ }

    void runFunctor() override
@ -150,7 +150,7 @@ public:
        this->result = (object.*fn)();
    }
 private:
-    T (Class::*fn)()const;
+    T (Class::*fn)() const;
    const Class object;

 };
@ -166,7 +166,7 @@ public:
        (object.*fn)();
    }
 private:
-    T (Class::*fn)()const;
+    T (Class::*fn)() const;
    const Class object;

 };
@ -181,7 +181,7 @@ template <typename T, typename Class>
 class StoredMemberFunctionPointerCall0 : public RunFunctionTask<T>
 {
 public:
-    StoredMemberFunctionPointerCall0(T (Class::*_fn)() , Class *_object)
+    StoredMemberFunctionPointerCall0(T (Class::*_fn)(), Class *_object)
    : fn(_fn), object(_object){ }

    void runFunctor() override
@ -197,7 +197,7 @@ template <typename T, typename Class>
 class VoidStoredMemberFunctionPointerCall0 : public RunFunctionTask<T>
 {
 public:
-    VoidStoredMemberFunctionPointerCall0(T (Class::*_fn)() , Class *_object)
+    VoidStoredMemberFunctionPointerCall0(T (Class::*_fn)(), Class *_object)
    : fn(_fn), object(_object){ }

    void runFunctor() override
@ -228,7 +228,7 @@ public:
        this->result = (object->*fn)();
    }
 private:
-    T (Class::*fn)()const;
+    T (Class::*fn)() const;
    Class const *object;

 };
@ -244,7 +244,7 @@ public:
        (object->*fn)();
    }
 private:
-    T (Class::*fn)()const;
+    T (Class::*fn)() const;
    Class const *object;

 };
@ -306,7 +306,7 @@ template <typename T, typename Class, typename Param1, typename Arg1>
 class StoredMemberFunctionCall1 : public RunFunctionTask<T>
 {
 public:
-    StoredMemberFunctionCall1(T (Class::*_fn)(Param1) , const Class &_object, const Arg1 &_arg1)
+    StoredMemberFunctionCall1(T (Class::*_fn)(Param1), const Class &_object, const Arg1 &_arg1)
    : fn(_fn), object(_object), arg1(_arg1){ }

    void runFunctor() override
@ -322,7 +322,7 @@ template <typename T, typename Class, typename Param1, typename Arg1>
 class VoidStoredMemberFunctionCall1 : public RunFunctionTask<T>
 {
 public:
-    VoidStoredMemberFunctionCall1(T (Class::*_fn)(Param1) , const Class &_object, const Arg1 &_arg1)
+    VoidStoredMemberFunctionCall1(T (Class::*_fn)(Param1), const Class &_object, const Arg1 &_arg1)
    : fn(_fn), object(_object), arg1(_arg1){ }

    void runFunctor() override
@ -353,7 +353,7 @@ public:
        this->result = (object.*fn)(arg1);
    }
 private:
-    T (Class::*fn)(Param1)const;
+    T (Class::*fn)(Param1) const;
    const Class object;
    Arg1 arg1;
 };
@ -369,7 +369,7 @@ public:
        (object.*fn)(arg1);
    }
 private:
-    T (Class::*fn)(Param1)const;
+    T (Class::*fn)(Param1) const;
    const Class object;
    Arg1 arg1;
 };
@ -384,7 +384,7 @@ template <typename T, typename Class, typename Param1, typename Arg1>
 class StoredMemberFunctionPointerCall1 : public RunFunctionTask<T>
 {
 public:
-    StoredMemberFunctionPointerCall1(T (Class::*_fn)(Param1) , Class *_object, const Arg1 &_arg1)
+    StoredMemberFunctionPointerCall1(T (Class::*_fn)(Param1), Class *_object, const Arg1 &_arg1)
    : fn(_fn), object(_object), arg1(_arg1){ }

    void runFunctor() override
@ -400,7 +400,7 @@ template <typename T, typename Class, typename Param1, typename Arg1>
 class VoidStoredMemberFunctionPointerCall1 : public RunFunctionTask<T>
 {
 public:
-    VoidStoredMemberFunctionPointerCall1(T (Class::*_fn)(Param1) , Class *_object, const Arg1 &_arg1)
+    VoidStoredMemberFunctionPointerCall1(T (Class::*_fn)(Param1), Class *_object, const Arg1 &_arg1)
    : fn(_fn), object(_object), arg1(_arg1){ }

    void runFunctor() override
@ -431,7 +431,7 @@ public:
        this->result = (object->*fn)(arg1);
    }
 private:
-    T (Class::*fn)(Param1)const;
+    T (Class::*fn)(Param1) const;
    Class const *object;
    Arg1 arg1;
 };
@ -447,7 +447,7 @@ public:
        (object->*fn)(arg1);
    }
 private:
-    T (Class::*fn)(Param1)const;
+    T (Class::*fn)(Param1) const;
    Class const *object;
    Arg1 arg1;
 };
@ -492,7 +492,7 @@ template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
 struct VoidStoredFunctorPointerCall2: public RunFunctionTask<T>
 {
    inline VoidStoredFunctorPointerCall2(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2)
-    : function(_function), arg1(_arg1), arg2(_arg2) {}
+      : function(_function), arg1(_arg1), arg2(_arg2) {}
    void runFunctor() override { (*function)(arg1, arg2); }
    FunctionPointer * function;
    Arg1 arg1; Arg2 arg2;
@ -509,7 +509,7 @@ template <typename T, typename Class, typename Param1, typename Arg1, typename P
 class StoredMemberFunctionCall2 : public RunFunctionTask<T>
 {
 public:
-    StoredMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
+    StoredMemberFunctionCall2(T (Class::*_fn)(Param1, Param2), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }

    void runFunctor() override
@ -525,7 +525,7 @@ template <typename T, typename Class, typename Param1, typename Arg1, typename P
 class VoidStoredMemberFunctionCall2 : public RunFunctionTask<T>
 {
 public:
-    VoidStoredMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
+    VoidStoredMemberFunctionCall2(T (Class::*_fn)(Param1, Param2), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }

    void runFunctor() override
@ -556,7 +556,7 @@ public:
        this->result = (object.*fn)(arg1, arg2);
    }
 private:
-    T (Class::*fn)(Param1, Param2)const;
+    T (Class::*fn)(Param1, Param2) const;
    const Class object;
    Arg1 arg1; Arg2 arg2;
 };
@ -572,7 +572,7 @@ public:
        (object.*fn)(arg1, arg2);
    }
 private:
-    T (Class::*fn)(Param1, Param2)const;
+    T (Class::*fn)(Param1, Param2) const;
    const Class object;
    Arg1 arg1; Arg2 arg2;
 };
@ -587,7 +587,7 @@ template <typename T, typename Class, typename Param1, typename Arg1, typename P
 class StoredMemberFunctionPointerCall2 : public RunFunctionTask<T>
 {
 public:
-    StoredMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
+    StoredMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }

    void runFunctor() override
@ -603,7 +603,7 @@ template <typename T, typename Class, typename Param1, typename Arg1, typename P
 class VoidStoredMemberFunctionPointerCall2 : public RunFunctionTask<T>
 {
 public:
-    VoidStoredMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
+    VoidStoredMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }

    void runFunctor() override
@ -634,7 +634,7 @@ public:
        this->result = (object->*fn)(arg1, arg2);
    }
 private:
-    T (Class::*fn)(Param1, Param2)const;
+    T (Class::*fn)(Param1, Param2) const;
    Class const *object;
    Arg1 arg1; Arg2 arg2;
 };
@ -650,7 +650,7 @@ public:
        (object->*fn)(arg1, arg2);
    }
 private:
-    T (Class::*fn)(Param1, Param2)const;
+    T (Class::*fn)(Param1, Param2) const;
    Class const *object;
    Arg1 arg1; Arg2 arg2;
 };
@ -712,7 +712,7 @@ template <typename T, typename Class, typename Param1, typename Arg1, typename P
 class StoredMemberFunctionCall3 : public RunFunctionTask<T>
 {
 public:
-    StoredMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
+    StoredMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }

    void runFunctor() override
@ -728,7 +728,7 @@ template <typename T, typename Class, typename Param1, typename Arg1, typename P
 class VoidStoredMemberFunctionCall3 : public RunFunctionTask<T>
 {
 public:
-    VoidStoredMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
+    VoidStoredMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }

    void runFunctor() override
@ -759,7 +759,7 @@ public:
        this->result = (object.*fn)(arg1, arg2, arg3);
    }
 private:
-    T (Class::*fn)(Param1, Param2, Param3)const;
+    T (Class::*fn)(Param1, Param2, Param3) const;
    const Class object;
    Arg1 arg1; Arg2 arg2; Arg3 arg3;
 };
@ -775,7 +775,7 @@ public:
        (object.*fn)(arg1, arg2, arg3);
    }
 private:
-    T (Class::*fn)(Param1, Param2, Param3)const;
+    T (Class::*fn)(Param1, Param2, Param3) const;
    const Class object;
    Arg1 arg1; Arg2 arg2; Arg3 arg3;
 };
@ -790,7 +790,7 @@ template <typename T, typename Class, typename Param1, typename Arg1, typename P
 class StoredMemberFunctionPointerCall3 : public RunFunctionTask<T>
 {
 public:
-    StoredMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
+    StoredMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }

    void runFunctor() override
@ -806,7 +806,7 @@ template <typename T, typename Class, typename Param1, typename Arg1, typename P
 class VoidStoredMemberFunctionPointerCall3 : public RunFunctionTask<T>
 {
 public:
-    VoidStoredMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
+    VoidStoredMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }

    void runFunctor() override
@ -837,7 +837,7 @@ public:
        this->result = (object->*fn)(arg1, arg2, arg3);
    }
 private:
-    T (Class::*fn)(Param1, Param2, Param3)const;
+    T (Class::*fn)(Param1, Param2, Param3) const;
    Class const *object;
    Arg1 arg1; Arg2 arg2; Arg3 arg3;
 };
@ -853,7 +853,7 @@ public:
        (object->*fn)(arg1, arg2, arg3);
    }
 private:
-    T (Class::*fn)(Param1, Param2, Param3)const;
+    T (Class::*fn)(Param1, Param2, Param3) const;
    Class const *object;
    Arg1 arg1; Arg2 arg2; Arg3 arg3;
 };
@ -915,7 +915,7 @@ template <typename T, typename Class, typename Param1, typename Arg1, typename P
 class StoredMemberFunctionCall4 : public RunFunctionTask<T>
 {
 public:
-    StoredMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
+    StoredMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }

    void runFunctor() override
@ -931,7 +931,7 @@ template <typename T, typename Class, typename Param1, typename Arg1, typename P
 class VoidStoredMemberFunctionCall4 : public RunFunctionTask<T>
 {
 public:
-    VoidStoredMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
+    VoidStoredMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }

    void runFunctor() override
@ -962,7 +962,7 @@ public:
        this->result = (object.*fn)(arg1, arg2, arg3, arg4);
    }
 private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4)const;
+    T (Class::*fn)(Param1, Param2, Param3, Param4) const;
    const Class object;
    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
 };
@ -978,7 +978,7 @@ public:
        (object.*fn)(arg1, arg2, arg3, arg4);
    }
 private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4)const;
+    T (Class::*fn)(Param1, Param2, Param3, Param4) const;
    const Class object;
    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
 };
@ -993,7 +993,7 @@ template <typename T, typename Class, typename Param1, typename Arg1, typename P
 class StoredMemberFunctionPointerCall4 : public RunFunctionTask<T>
 {
 public:
-    StoredMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
+    StoredMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }

    void runFunctor() override
@ -1009,7 +1009,7 @@ template <typename T, typename Class, typename Param1, typename Arg1, typename P
 class VoidStoredMemberFunctionPointerCall4 : public RunFunctionTask<T>
 {
 public:
-    VoidStoredMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
+    VoidStoredMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }

    void runFunctor() override
@ -1040,7 +1040,7 @@ public:
        this->result = (object->*fn)(arg1, arg2, arg3, arg4);
    }
 private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4)const;
+    T (Class::*fn)(Param1, Param2, Param3, Param4) const;
    Class const *object;
    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
 };
@ -1056,7 +1056,7 @@ public:
        (object->*fn)(arg1, arg2, arg3, arg4);
    }
 private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4)const;
+    T (Class::*fn)(Param1, Param2, Param3, Param4) const;
    Class const *object;
    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
 };
@ -1102,7 +1102,7 @@ struct VoidStoredFunctorPointerCall5: public RunFunctionTask<T>
 {
    inline VoidStoredFunctorPointerCall5(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
      : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
-    void runFunctor() override {(*function)(arg1, arg2, arg3, arg4, arg5); }
+    void runFunctor() override { (*function)(arg1, arg2, arg3, arg4, arg5); }
    FunctionPointer * function;
    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
 };
@ -1118,7 +1118,7 @@ template <typename T, typename Class, typename Param1, typename Arg1, typename P
 class StoredMemberFunctionCall5 : public RunFunctionTask<T>
 {
 public:
-    StoredMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
+    StoredMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }

    void runFunctor() override
@ -1134,7 +1134,7 @@ template <typename T, typename Class, typename Param1, typename Arg1, typename P
 class VoidStoredMemberFunctionCall5 : public RunFunctionTask<T>
 {
 public:
-    VoidStoredMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
+    VoidStoredMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5), const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }

    void runFunctor() override
@ -1165,7 +1165,7 @@ public:
        this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5);
    }
 private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5)const;
+    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const;
    const Class object;
    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
 };
@ -1181,7 +1181,7 @@ public:
        (object.*fn)(arg1, arg2, arg3, arg4, arg5);
    }
 private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5)const;
+    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const;
    const Class object;
    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
 };
@ -1196,7 +1196,7 @@ template <typename T, typename Class, typename Param1, typename Arg1, typename P
 class StoredMemberFunctionPointerCall5 : public RunFunctionTask<T>
 {
 public:
-    StoredMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
+    StoredMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }

    void runFunctor() override
@ -1212,7 +1212,7 @@ template <typename T, typename Class, typename Param1, typename Arg1, typename P
 class VoidStoredMemberFunctionPointerCall5 : public RunFunctionTask<T>
 {
 public:
-    VoidStoredMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
+    VoidStoredMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5), Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
    : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }

    void runFunctor() override
@ -1243,7 +1243,7 @@ public:
        this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5);
    }
 private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5)const;
+    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const;
    Class const *object;
    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
 };
@ -1259,7 +1259,7 @@ public:
        (object->*fn)(arg1, arg2, arg3, arg4, arg5);
    }
 private:
-    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5)const;
+    T (Class::*fn)(Param1, Param2, Param3, Param4, Param5) const;
    Class const *object;
    Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
 };
--- a/src/corelib/global/qcompilerdetection.h
+++ b/src/corelib/global/qcompilerdetection.h
@ -1329,15 +1329,14 @@
        Q_ASSUME_IMPL(valueOfExpression);\
    } while (0)

+#if defined(__cplusplus)
 #if QT_HAS_CPP_ATTRIBUTE(fallthrough)
 #  define Q_FALLTHROUGH() [[fallthrough]]
-#elif defined(__cplusplus)
-/* Clang can not parse namespaced attributes in C mode, but defines __has_cpp_attribute */
-#  if QT_HAS_CPP_ATTRIBUTE(clang::fallthrough)
+#elif QT_HAS_CPP_ATTRIBUTE(clang::fallthrough)
 #    define Q_FALLTHROUGH() [[clang::fallthrough]]
-#  elif QT_HAS_CPP_ATTRIBUTE(gnu::fallthrough)
+#elif QT_HAS_CPP_ATTRIBUTE(gnu::fallthrough)
 #    define Q_FALLTHROUGH() [[gnu::fallthrough]]
-#  endif
+#endif
 #endif
 #ifndef Q_FALLTHROUGH
 #  if defined(Q_CC_GNU) && Q_CC_GNU >= 700
--- a/src/corelib/global/qfloat16.h
+++ b/src/corelib/global/qfloat16.h
@ -113,10 +113,14 @@ inline Q_REQUIRED_RESULT bool qIsNull(qfloat16 f) Q_DECL_NOTHROW
 inline int qIntCast(qfloat16 f) Q_DECL_NOTHROW
 { return int(static_cast<float>(f)); }

+QT_WARNING_PUSH
+QT_WARNING_DISABLE_CLANG("-Wc99-extensions")
 inline qfloat16::qfloat16(float f) Q_DECL_NOTHROW
 {
-#if defined(QT_COMPILER_SUPPORTS_F16C) && defined(__F16C__)
-    b16 = _cvtss_sh(f, 0);
+#if defined(QT_COMPILER_SUPPORTS_F16C) && (defined(__F16C__) || defined(__AVX2__))
+    __m128 packsingle = _mm_set_ss(f);
+    __m128i packhalf = _mm_cvtps_ph(packsingle, 0);
+    b16 = _mm_extract_epi16(packhalf, 0);
 #elif defined (__ARM_FP16_FORMAT_IEEE)
    __fp16 f16 = f;
    memcpy(&b16, &f16, sizeof(quint16));
@ -127,11 +131,14 @@ inline qfloat16::qfloat16(float f) Q_DECL_NOTHROW
          + ((u & 0x007fffff) >> shifttable[(u >> 23) & 0x1ff]);
 #endif
 }
+QT_WARNING_POP

 inline qfloat16::operator float() const Q_DECL_NOTHROW
 {
-#if defined(QT_COMPILER_SUPPORTS_F16C) && defined(__F16C__)
-    return _cvtsh_ss(b16);
+#if defined(QT_COMPILER_SUPPORTS_F16C) && (defined(__F16C__) || defined(__AVX2__))
+    __m128i packhalf = _mm_cvtsi32_si128(b16);
+    __m128 packsingle = _mm_cvtph_ps(packhalf);
+    return _mm_cvtss_f32(packsingle);
 #elif defined (__ARM_FP16_FORMAT_IEEE)
    __fp16 f16;
    memcpy(&f16, &b16, sizeof(quint16));
--- a/src/corelib/global/qlibraryinfo.cpp
+++ b/src/corelib/global/qlibraryinfo.cpp
@ -663,6 +663,8 @@ QStringList QLibraryInfo::platformPluginArguments(const QString &platformName)
                + QLatin1String("Arguments");
        return settings->value(key).toStringList();
    }
+#else
+    Q_UNUSED(platformName);
 #endif // !QT_BUILD_QMAKE && !QT_NO_SETTINGS
    return QStringList();
 }
--- a/src/corelib/global/qlogging.cpp
+++ b/src/corelib/global/qlogging.cpp
@ -217,7 +217,7 @@ static bool willLogToConsole()
 #  elif defined(Q_OS_UNIX)
    // if /dev/tty exists, we can only open it if we have a controlling TTY
    int devtty = qt_safe_open("/dev/tty", O_RDONLY);
-    if (devtty == -1 && (errno == ENOENT || errno == EPERM)) {
+    if (devtty == -1 && (errno == ENOENT || errno == EPERM || errno == ENXIO)) {
        // no /dev/tty, fall back to isatty on stderr
        return isatty(STDERR_FILENO);
    } else if (devtty != -1) {
--- a/src/corelib/global/qmalloc.cpp
+++ b/src/corelib/global/qmalloc.cpp
@ -40,6 +40,7 @@
 #include "qplatformdefs.h"

 #include <stdlib.h>
+#include <string.h>

 /*
    Define the container allocation functions in a separate file, so that our
@ -79,8 +80,6 @@ void *qMallocAligned(size_t size, size_t alignment)
 void *qReallocAligned(void *oldptr, size_t newsize, size_t oldsize, size_t alignment)
 {
    // fake an aligned allocation
-    Q_UNUSED(oldsize);
-
    void *actualptr = oldptr ? static_cast<void **>(oldptr)[-1] : 0;
    if (alignment <= sizeof(void*)) {
        // special, fast case
@ -110,9 +109,15 @@ void *qReallocAligned(void *oldptr, size_t newsize, size_t oldsize, size_t align

    quintptr faked = reinterpret_cast<quintptr>(real) + alignment;
    faked &= ~(alignment - 1);
-
    void **faked_ptr = reinterpret_cast<void **>(faked);

+    if (oldptr) {
+        qptrdiff oldoffset = static_cast<char *>(oldptr) - static_cast<char *>(actualptr);
+        qptrdiff newoffset = reinterpret_cast<char *>(faked_ptr) - static_cast<char *>(real);
+        if (oldoffset != newoffset)
+            memmove(faked_ptr, static_cast<char *>(real) + oldoffset, qMin(oldsize, newsize));
+    }
+
    // now save the value of the real pointer at faked-sizeof(void*)
    // by construction, alignment > sizeof(void*) and is a power of 2, so
    // faked-sizeof(void*) is properly aligned for a pointer
--- a/src/corelib/global/qsysinfo.h
+++ b/src/corelib/global/qsysinfo.h
@ -135,19 +135,6 @@ public:
        WV_CE_6     = 0x0400,
        WV_CE_based = 0x0f00
    };
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_GCC("-Wdeprecated-declarations")
-QT_WARNING_DISABLE_CLANG("-Wdeprecated-declarations")
-QT_WARNING_DISABLE_INTEL(1478)
-QT_WARNING_DISABLE_MSVC(4996)
-#if defined(Q_OS_WIN) || defined(Q_OS_CYGWIN)
-    QT_SYSINFO_DEPRECATED_X("Use QOperatingSystemVersion::current()") static const WinVersion WindowsVersion;
-    QT_SYSINFO_DEPRECATED_X("Use QOperatingSystemVersion::current()") static WinVersion windowsVersion();
-#else
-    QT_SYSINFO_DEPRECATED_X("Use QOperatingSystemVersion::current()") static const WinVersion WindowsVersion = WV_None;
-    QT_SYSINFO_DEPRECATED_X("Use QOperatingSystemVersion::current()") static WinVersion windowsVersion() { return WV_None; }
-#endif
-QT_WARNING_POP

 #define Q_MV_OSX(major, minor) (major == 10 ? minor + 2 : (major == 9 ? 1 : 0))
 #define Q_MV_IOS(major, minor) (QSysInfo::MV_IOS | major << 4 | minor)
@ -222,11 +209,19 @@ QT_WARNING_POP
        MV_WATCHOS_2_2 = Q_MV_WATCHOS(2, 2),
        MV_WATCHOS_3_0 = Q_MV_WATCHOS(3, 0)
    };
+
 QT_WARNING_PUSH
 QT_WARNING_DISABLE_GCC("-Wdeprecated-declarations")
 QT_WARNING_DISABLE_CLANG("-Wdeprecated-declarations")
-QT_WARNING_DISABLE_INTEL(1478)
+QT_WARNING_DISABLE_INTEL(1786)
 QT_WARNING_DISABLE_MSVC(4996)
+#if defined(Q_OS_WIN) || defined(Q_OS_CYGWIN)
+    QT_SYSINFO_DEPRECATED_X("Use QOperatingSystemVersion::current()") static const WinVersion WindowsVersion;
+    QT_SYSINFO_DEPRECATED_X("Use QOperatingSystemVersion::current()") static WinVersion windowsVersion();
+#else
+    QT_SYSINFO_DEPRECATED_X("Use QOperatingSystemVersion::current()") static const WinVersion WindowsVersion = WV_None;
+    QT_SYSINFO_DEPRECATED_X("Use QOperatingSystemVersion::current()") static WinVersion windowsVersion() { return WV_None; }
+#endif
 #if defined(Q_OS_MAC)
    QT_SYSINFO_DEPRECATED_X("Use QOperatingSystemVersion::current()") static const MacVersion MacintoshVersion;
    QT_SYSINFO_DEPRECATED_X("Use QOperatingSystemVersion::current()") static MacVersion macVersion();
--- a/src/corelib/io/qlockfile_unix.cpp
+++ b/src/corelib/io/qlockfile_unix.cpp
@ -115,6 +115,7 @@ int QLockFilePrivate::checkFcntlWorksAfterFlock(const QString &fn)
        return 0;
    return 1;
 #else
+    Q_UNUSED(fn);
    return 0;
 #endif
 }
--- a/src/corelib/kernel/qmetatype.h
+++ b/src/corelib/kernel/qmetatype.h
@ -527,7 +527,7 @@ public:
    static bool load(QDataStream &stream, int type, void *data);
 #endif

-    explicit QMetaType(const int type);
+    explicit QMetaType(const int type); // ### Qt6: drop const
    inline ~QMetaType();

    inline bool isValid() const;
--- a/src/corelib/kernel/qvariant.h
+++ b/src/corelib/kernel/qvariant.h
@ -464,7 +464,7 @@ public:
    void create(int type, const void *copy);
    bool cmp(const QVariant &other) const;
    int compare(const QVariant &other) const;
-    bool convert(const int t, void *ptr) const;
+    bool convert(const int t, void *ptr) const; // ### Qt6: drop const

 private:
    // force compile error, prevent QVariant(bool) to be called
--- a/src/corelib/statemachine/qstatemachine.cpp
+++ b/src/corelib/statemachine/qstatemachine.cpp
@ -2331,6 +2331,7 @@ void QStateMachinePrivate::unregisterAllTransitions()
                unregisterSignalTransition(t);
        }
    }
+#if QT_CONFIG(qeventtransition)
    {
        QList<QEventTransition*> transitions = rootState()->findChildren<QEventTransition*>();
        for (int i = 0; i < transitions.size(); ++i) {
@ -2339,6 +2340,7 @@ void QStateMachinePrivate::unregisterAllTransitions()
                unregisterEventTransition(t);
        }
    }
+#endif
 }

 #if QT_CONFIG(qeventtransition)
--- a/src/corelib/tools/qcryptographichash.cpp
+++ b/src/corelib/tools/qcryptographichash.cpp
@ -180,9 +180,45 @@ public:
        SHA3Context sha3Context;
 #endif
    };
+#ifndef QT_CRYPTOGRAPHICHASH_ONLY_SHA1
+    void sha3Finish(int bitCount);
+#endif
    QByteArray result;
 };

+#ifndef QT_CRYPTOGRAPHICHASH_ONLY_SHA1
+void QCryptographicHashPrivate::sha3Finish(int bitCount)
+{
+    /*
+        FIPS 202 §6.1 defines SHA-3 in terms of calculating the Keccak function
+        over the original message with the two-bit suffix "01" appended to it.
+        This variable stores that suffix (and it's fed into the calculations
+        when the hash is returned to users).
+
+        Only 2 bits of this variable are actually used (see the call to sha3Update
+        below). The Keccak implementation we're using will actually use the
+        *leftmost* 2 bits, and interpret them right-to-left. In other words, the
+        bits must appear in order of *increasing* significance; and as the two most
+        significant bits of the byte -- the rightmost 6 are ignored. (Yes, this
+        seems self-contradictory, but it's the way it is...)
+
+        Overall, this means:
+        * the leftmost two bits must be "10" (not "01"!);
+        * we don't care what the other six bits are set to (they can be set to
+        any value), but we arbitrarily set them to 0;
+
+        and for an unsigned char this gives us 0b10'00'00'00, or 0x80.
+    */
+    static const unsigned char sha3FinalSuffix = 0x80;
+
+    result.resize(bitCount / 8);
+
+    SHA3Context copy = sha3Context;
+    sha3Update(&copy, reinterpret_cast<const BitSequence *>(&sha3FinalSuffix), 2);
+    sha3Final(&copy, reinterpret_cast<BitSequence *>(result.data()));
+}
+#endif
+
 /*!
  \class QCryptographicHash
  \inmodule QtCore
@ -196,7 +232,8 @@ public:

  QCryptographicHash can be used to generate cryptographic hashes of binary or text data.

-  Currently MD4, MD5, SHA-1, SHA-224, SHA-256, SHA-384, and SHA-512 are supported.
+  Refer to the documentation of the \l QCryptographicHash::Algorithm enum for a
+  list of the supported algorithms.
 */

 /*!
@ -426,27 +463,19 @@ QByteArray QCryptographicHash::result() const
        break;
    }
    case Sha3_224: {
-        SHA3Context copy = d->sha3Context;
-        d->result.resize(224/8);
-        sha3Final(&copy, reinterpret_cast<BitSequence *>(d->result.data()));
+        d->sha3Finish(224);
        break;
    }
    case Sha3_256: {
-        SHA3Context copy = d->sha3Context;
-        d->result.resize(256/8);
-        sha3Final(&copy, reinterpret_cast<BitSequence *>(d->result.data()));
+        d->sha3Finish(256);
        break;
    }
    case Sha3_384: {
-        SHA3Context copy = d->sha3Context;
-        d->result.resize(384/8);
-        sha3Final(&copy, reinterpret_cast<BitSequence *>(d->result.data()));
+        d->sha3Finish(384);
        break;
    }
    case Sha3_512: {
-        SHA3Context copy = d->sha3Context;
-        d->result.resize(512/8);
-        sha3Final(&copy, reinterpret_cast<BitSequence *>(d->result.data()));
+        d->sha3Finish(512);
        break;
    }
 #endif
--- a/src/corelib/tools/qvector.h
+++ b/src/corelib/tools/qvector.h
@ -291,6 +291,7 @@ public:
 private:
    friend class QRegion; // Optimization for QRegion::rects()

+    // ### Qt6: remove const from int parameters
    void reallocData(const int size, const int alloc, QArrayData::AllocationOptions options = QArrayData::Default);
    void reallocData(const int sz) { reallocData(sz, d->alloc); }
    void freeData(Data *d);
--- a/src/corelib/xml/qxmlstream_p.h
+++ b/src/corelib/xml/qxmlstream_p.h
@ -1139,6 +1139,7 @@ bool QXmlStreamReaderPrivate::parse()
            case '\n':
                ++lineNumber;
                lastLineStart = characterOffset + readBufferPos;
+                Q_FALLTHROUGH();
            case ' ':
            case '\t':
                token = SPACE;
--- a/src/gui/gui.pro
+++ b/src/gui/gui.pro
@ -58,13 +58,13 @@ win32: CMAKE_WINDOWS_BUILD = True
 qtConfig(angle) {
    CMAKE_GL_INCDIRS = $$CMAKE_INCLUDE_DIR
    CMAKE_ANGLE_EGL_DLL_RELEASE = libEGL.dll
-    CMAKE_ANGLE_EGL_IMPLIB_RELEASE = libEGL.lib
+    CMAKE_ANGLE_EGL_IMPLIB_RELEASE = libEGL.$${QMAKE_EXTENSION_STATICLIB}
    CMAKE_ANGLE_GLES2_DLL_RELEASE = libGLESv2.dll
-    CMAKE_ANGLE_GLES2_IMPLIB_RELEASE = libGLESv2.lib
+    CMAKE_ANGLE_GLES2_IMPLIB_RELEASE = libGLESv2.$${QMAKE_EXTENSION_STATICLIB}
    CMAKE_ANGLE_EGL_DLL_DEBUG = libEGLd.dll
-    CMAKE_ANGLE_EGL_IMPLIB_DEBUG = libEGLd.lib
+    CMAKE_ANGLE_EGL_IMPLIB_DEBUG = libEGLd.$${QMAKE_EXTENSION_STATICLIB}
    CMAKE_ANGLE_GLES2_DLL_DEBUG = libGLESv2d.dll
-    CMAKE_ANGLE_GLES2_IMPLIB_DEBUG = libGLESv2d.lib
+    CMAKE_ANGLE_GLES2_IMPLIB_DEBUG = libGLESv2d.$${QMAKE_EXTENSION_STATICLIB}

    CMAKE_QT_OPENGL_IMPLEMENTATION = GLESv2
 } else {
--- a/src/gui/image/qbmphandler.cpp
+++ b/src/gui/image/qbmphandler.cpp
@ -183,14 +183,14 @@ static bool read_dib_infoheader(QDataStream &s, BMP_INFOHDR &bi)
    return true;
 }

-static bool read_dib_body(QDataStream &s, const BMP_INFOHDR &bi, int offset, int startpos, QImage &image)
+static bool read_dib_body(QDataStream &s, const BMP_INFOHDR &bi, qint64 offset, qint64 startpos, QImage &image)
 {
    QIODevice* d = s.device();
    if (d->atEnd())                                // end of stream/file
        return false;
 #if 0
-    qDebug("offset...........%d", offset);
-    qDebug("startpos.........%d", startpos);
+    qDebug("offset...........%lld", offset);
+    qDebug("startpos.........%lld", startpos);
    qDebug("biSize...........%d", bi.biSize);
    qDebug("biWidth..........%d", bi.biWidth);
    qDebug("biHeight.........%d", bi.biHeight);
--- a/src/gui/image/qbmphandler_p.h
+++ b/src/gui/image/qbmphandler_p.h
@ -121,7 +121,7 @@ private:
    State state;
    BMP_FILEHDR fileHeader;
    BMP_INFOHDR infoHeader;
-    int startpos;
+    qint64 startpos;
 };

 QT_END_NAMESPACE
--- a/src/gui/image/qimagereader.cpp
+++ b/src/gui/image/qimagereader.cpp
@ -471,7 +471,8 @@ static QImageIOHandler *createReadHandlerHelper(QIODevice *device,

            --numFormats;
            ++currentFormat;
-            currentFormat %= _qt_NumFormats;
+            if (currentFormat >= _qt_NumFormats)
+                currentFormat = 0;
        }
    }

--- a/src/gui/kernel/qguiapplication.cpp
+++ b/src/gui/kernel/qguiapplication.cpp
@ -2008,6 +2008,8 @@ void QGuiApplicationPrivate::processWheelEvent(QWindowSystemInterfacePrivate::Wh
                    buttons, e->modifiers, e->phase, e->source, e->inverted);
     ev.setTimestamp(e->timestamp);
     QGuiApplication::sendSpontaneousEvent(window, &ev);
+#else
+     Q_UNUSED(e);
 #endif /* ifndef QT_NO_WHEELEVENT */
 }

--- a/src/gui/kernel/qopenglcontext.cpp
+++ b/src/gui/kernel/qopenglcontext.cpp
@ -982,6 +982,40 @@ bool QOpenGLContext::makeCurrent(QSurface *surface)
    QOpenGLContext *previous = QOpenGLContextPrivate::setCurrentContext(this);

    if (d->platformGLContext->makeCurrent(surface->surfaceHandle())) {
+        static bool needsWorkaroundSet = false;
+        static bool needsWorkaround = false;
+
+        if (!needsWorkaroundSet) {
+            QByteArray env;
+#ifdef Q_OS_ANDROID
+            env = qgetenv(QByteArrayLiteral("QT_ANDROID_DISABLE_GLYPH_CACHE_WORKAROUND"));
+            needsWorkaround = env.isEmpty() || env == QByteArrayLiteral("0") || env == QByteArrayLiteral("false");
+#endif
+            env = qgetenv(QByteArrayLiteral("QT_ENABLE_GLYPH_CACHE_WORKAROUND"));
+            if (env == QByteArrayLiteral("1") || env == QByteArrayLiteral("true"))
+                needsWorkaround = true;
+
+            if (!needsWorkaround) {
+                const char *rendererString = reinterpret_cast<const char *>(functions()->glGetString(GL_RENDERER));
+                if (rendererString)
+                    needsWorkaround =
+                            qstrncmp(rendererString, "Mali-4xx", 6) == 0 // Mali-400, Mali-450
+                            || qstrncmp(rendererString, "Adreno (TM) 2xx", 13) == 0 // Adreno 200, 203, 205
+                            || qstrncmp(rendererString, "Adreno 2xx", 8) == 0 // Same as above but without the '(TM)'
+                            || qstrncmp(rendererString, "Adreno (TM) 30x", 14) == 0 // Adreno 302, 305
+                            || qstrncmp(rendererString, "Adreno 30x", 9) == 0 // Same as above but without the '(TM)'
+                            || qstrncmp(rendererString, "Adreno (TM) 4xx", 13) == 0 // Adreno 405, 418, 420, 430
+                            || qstrncmp(rendererString, "Adreno 4xx", 8) == 0 // Same as above but without the '(TM)'
+                            || qstrcmp(rendererString, "GC800 core") == 0
+                            || qstrcmp(rendererString, "GC1000 core") == 0
+                            || qstrcmp(rendererString, "Immersion.16") == 0;
+            }
+            needsWorkaroundSet = true;
+        }
+
+        if (needsWorkaround)
+            d->workaround_brokenFBOReadBack = true;
+
        d->surface = surface;

        d->shareGroup->d_func()->deletePendingResources(this);
--- a/src/gui/kernel/qplatforminputcontextfactory.cpp
+++ b/src/gui/kernel/qplatforminputcontextfactory.cpp
@ -82,6 +82,8 @@ QPlatformInputContext *QPlatformInputContextFactory::create(const QString& key)

        delete ic;
    }
+#else
+    Q_UNUSED(key);
 #endif
    return 0;
 }
--- a/src/gui/kernel/qrasterwindow.cpp
+++ b/src/gui/kernel/qrasterwindow.cpp
@ -105,6 +105,14 @@ QRasterWindow::QRasterWindow(QWindow *parent)
    d_func()->backingstore.reset(new QBackingStore(this));
 }

+QRasterWindow::~QRasterWindow()
+{
+  Q_D(QRasterWindow);
+  // Delete backingstore while window is still alive, as it
+  // might need to reference the window in the process
+  d->backingstore.reset(nullptr);
+}
+
 /*!
  \internal
 */
--- a/src/gui/kernel/qrasterwindow.h
+++ b/src/gui/kernel/qrasterwindow.h
@ -54,6 +54,7 @@ class Q_GUI_EXPORT QRasterWindow : public QPaintDeviceWindow

 public:
    explicit QRasterWindow(QWindow *parent = Q_NULLPTR);
+    ~QRasterWindow();

 protected:
    int metric(PaintDeviceMetric metric) const Q_DECL_OVERRIDE;
--- a/src/gui/painting/qblendfunctions_p.h
+++ b/src/gui/painting/qblendfunctions_p.h
@ -375,12 +375,12 @@ void qt_transform_image_rasterize(DestT *destPixels, int dbpl,
                --ii;
            }
            switch (i & 7) {
-                case 7: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
-                case 6: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
-                case 5: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
-                case 4: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
-                case 3: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
-                case 2: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
+                case 7: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line; Q_FALLTHROUGH();
+                case 6: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line; Q_FALLTHROUGH();
+                case 5: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line; Q_FALLTHROUGH();
+                case 4: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line; Q_FALLTHROUGH();
+                case 3: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line; Q_FALLTHROUGH();
+                case 2: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line; Q_FALLTHROUGH();
                case 1: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
            }

--- a/src/gui/painting/qdrawhelper_p.h
+++ b/src/gui/painting/qdrawhelper_p.h
@ -833,13 +833,13 @@ inline void qt_memfill(T *dest, T value, int count)
    int n = (count + 7) / 8;
    switch (count & 0x07)
    {
-    case 0: do { *dest++ = value;
-    case 7:      *dest++ = value;
-    case 6:      *dest++ = value;
-    case 5:      *dest++ = value;
-    case 4:      *dest++ = value;
-    case 3:      *dest++ = value;
-    case 2:      *dest++ = value;
+    case 0: do { *dest++ = value; Q_FALLTHROUGH();
+    case 7:      *dest++ = value; Q_FALLTHROUGH();
+    case 6:      *dest++ = value; Q_FALLTHROUGH();
+    case 5:      *dest++ = value; Q_FALLTHROUGH();
+    case 4:      *dest++ = value; Q_FALLTHROUGH();
+    case 3:      *dest++ = value; Q_FALLTHROUGH();
+    case 2:      *dest++ = value; Q_FALLTHROUGH();
    case 1:      *dest++ = value;
    } while (--n > 0);
    }
@ -875,13 +875,13 @@ do {                                          \
    int n = ((length) + 7) / 8;               \
    switch ((length) & 0x07)                  \
    {                                         \
-    case 0: do { *--_d = *--_s;                 \
-    case 7:      *--_d = *--_s;                 \
-    case 6:      *--_d = *--_s;                 \
-    case 5:      *--_d = *--_s;                 \
-    case 4:      *--_d = *--_s;                 \
-    case 3:      *--_d = *--_s;                 \
-    case 2:      *--_d = *--_s;                 \
+    case 0: do { *--_d = *--_s; Q_FALLTHROUGH(); \
+    case 7:      *--_d = *--_s; Q_FALLTHROUGH(); \
+    case 6:      *--_d = *--_s; Q_FALLTHROUGH(); \
+    case 5:      *--_d = *--_s; Q_FALLTHROUGH(); \
+    case 4:      *--_d = *--_s; Q_FALLTHROUGH(); \
+    case 3:      *--_d = *--_s; Q_FALLTHROUGH(); \
+    case 2:      *--_d = *--_s; Q_FALLTHROUGH(); \
    case 1:      *--_d = *--_s;                 \
    } while (--n > 0);                        \
    }                                         \
@ -895,13 +895,13 @@ do {                                          \
    int n = ((length) + 7) / 8;               \
    switch ((length) & 0x07)                  \
    {                                         \
-    case 0: do { *_d++ = *_s++;                 \
-    case 7:      *_d++ = *_s++;                 \
-    case 6:      *_d++ = *_s++;                 \
-    case 5:      *_d++ = *_s++;                 \
-    case 4:      *_d++ = *_s++;                 \
-    case 3:      *_d++ = *_s++;                 \
-    case 2:      *_d++ = *_s++;                 \
+    case 0: do { *_d++ = *_s++; Q_FALLTHROUGH(); \
+    case 7:      *_d++ = *_s++; Q_FALLTHROUGH(); \
+    case 6:      *_d++ = *_s++; Q_FALLTHROUGH(); \
+    case 5:      *_d++ = *_s++; Q_FALLTHROUGH(); \
+    case 4:      *_d++ = *_s++; Q_FALLTHROUGH(); \
+    case 3:      *_d++ = *_s++; Q_FALLTHROUGH(); \
+    case 2:      *_d++ = *_s++; Q_FALLTHROUGH(); \
    case 1:      *_d++ = *_s++;                 \
    } while (--n > 0);                        \
    }                                         \
--- a/src/gui/painting/qgrayraster.c
+++ b/src/gui/painting/qgrayraster.c
@ -183,6 +183,8 @@ typedef ptrdiff_t  QT_FT_PtrDist;
 #include <private/qrasterdefs_p.h>
 #include <private/qgrayraster_p.h>

+#include <qcompilerdetection.h>
+
 #include <stdlib.h>
 #include <stdio.h>

@ -1201,13 +1203,13 @@ QT_FT_END_STMNT
         */
        switch ( spans->len )
        {
-        case 7: *q++ = coverage;
-        case 6: *q++ = coverage;
-        case 5: *q++ = coverage;
-        case 4: *q++ = coverage;
-        case 3: *q++ = coverage;
-        case 2: *q++ = coverage;
-        case 1: *q   = coverage;
+        case 7: *q++ = coverage; Q_FALLTHROUGH();
+        case 6: *q++ = coverage; Q_FALLTHROUGH();
+        case 5: *q++ = coverage; Q_FALLTHROUGH();
+        case 4: *q++ = coverage; Q_FALLTHROUGH();
+        case 3: *q++ = coverage; Q_FALLTHROUGH();
+        case 2: *q++ = coverage; Q_FALLTHROUGH();
+        case 1: *q   = coverage; Q_FALLTHROUGH();
        case 0: break;
        default:
          QT_FT_MEM_SET( q, coverage, spans->len );
--- a/src/gui/painting/qpdf.cpp
+++ b/src/gui/painting/qpdf.cpp
@ -2808,6 +2808,7 @@ void QPdfEnginePrivate::drawTextItem(const QPointF &p, const QTextItemInt &ti)
        qreal size = ti.fontEngine->fontDef.pixelSize;
        int synthesized = ti.fontEngine->synthesized();
        qreal stretch = synthesized & QFontEngine::SynthesizedStretch ? ti.fontEngine->fontDef.stretch/100. : 1.;
+        Q_ASSERT(stretch > qreal(0));

        QTransform trans;
        // Build text rendering matrix (Trm). We need it to map the text area to user
@ -2884,6 +2885,7 @@ void QPdfEnginePrivate::drawTextItem(const QPointF &p, const QTextItemInt &ti)
        return;
    int synthesized = ti.fontEngine->synthesized();
    qreal stretch = synthesized & QFontEngine::SynthesizedStretch ? ti.fontEngine->fontDef.stretch/100. : 1.;
+    Q_ASSERT(stretch > qreal(0));

    *currentPage << "BT\n"
                 << "/F" << font->object_id << size << "Tf "
--- a/src/gui/painting/qtransform.cpp
+++ b/src/gui/painting/qtransform.cpp
@ -2094,7 +2094,8 @@ QTransform::TransformationType QTransform::type() const
        if (!qFuzzyIsNull(m_13) || !qFuzzyIsNull(m_23) || !qFuzzyIsNull(m_33 - 1)) {
             m_type = TxProject;
             break;
-         }
+        }
+        Q_FALLTHROUGH();
    case TxShear:
    case TxRotate:
        if (!qFuzzyIsNull(affine._m12) || !qFuzzyIsNull(affine._m21)) {
@ -2105,16 +2106,19 @@ QTransform::TransformationType QTransform::type() const
                m_type = TxShear;
            break;
        }
+        Q_FALLTHROUGH();
    case TxScale:
        if (!qFuzzyIsNull(affine._m11 - 1) || !qFuzzyIsNull(affine._m22 - 1)) {
            m_type = TxScale;
            break;
        }
+        Q_FALLTHROUGH();
    case TxTranslate:
        if (!qFuzzyIsNull(affine._dx) || !qFuzzyIsNull(affine._dy)) {
            m_type = TxTranslate;
            break;
        }
+        Q_FALLTHROUGH();
    case TxNone:
        m_type = TxNone;
        break;
--- a/src/gui/text/qplatformfontdatabase.cpp
+++ b/src/gui/text/qplatformfontdatabase.cpp
@ -465,16 +465,6 @@ bool QPlatformFontDatabase::fontsAlwaysScalable() const
    return ret;
 }

-QFontEngine::SubpixelAntialiasingType QPlatformFontDatabase::subpixelAntialiasingTypeHint() const
-{
-    static int type = -1;
-    if (type == -1) {
-        if (QScreen *screen = QGuiApplication::primaryScreen())
-            type = screen->handle()->subpixelAntialiasingTypeHint();
-    }
-    return static_cast<QFontEngine::SubpixelAntialiasingType>(type);
-}
-
 // ### copied to tools/makeqpf/qpf2.cpp

 // see the Unicode subset bitfields in the MSDN docs
--- a/src/gui/text/qplatformfontdatabase.h
+++ b/src/gui/text/qplatformfontdatabase.h
@ -116,7 +116,6 @@ public:
    virtual QString resolveFontFamilyAlias(const QString &family) const;
    virtual bool fontsAlwaysScalable() const;
    virtual QList<int> standardSizes() const;
-    QFontEngine::SubpixelAntialiasingType subpixelAntialiasingTypeHint() const;

    // helper
    static QSupportedWritingSystems writingSystemsFromTrueTypeBits(quint32 unicodeRange[4], quint32 codePageRange[2]);
--- a/src/gui/text/qtextdocumentfragment.cpp
+++ b/src/gui/text/qtextdocumentfragment.cpp
@ -408,6 +408,8 @@ QTextDocumentFragment QTextDocumentFragment::fromPlainText(const QString &plainT
    return res;
 }

+#ifndef QT_NO_TEXTHTMLPARSER
+
 static QTextListFormat::Style nextListStyle(QTextListFormat::Style style)
 {
    if (style == QTextListFormat::ListDisc)
@ -417,8 +419,6 @@ static QTextListFormat::Style nextListStyle(QTextListFormat::Style style)
    return style;
 }

-#ifndef QT_NO_TEXTHTMLPARSER
-
 QTextHtmlImporter::QTextHtmlImporter(QTextDocument *_doc, const QString &_html, ImportMode mode, const QTextDocument *resourceProvider)
    : indent(0), compressNextWhitespace(PreserveWhiteSpace), doc(_doc), importMode(mode)
 {
--- a/src/gui/text/qtextengine.cpp
+++ b/src/gui/text/qtextengine.cpp
@ -579,12 +579,14 @@ static bool bidiItemize(QTextEngine *engine, QScriptAnalysis *analysis, QBidiCon
                        else
                            eor = current;
                        status.eor = QChar::DirEN;
-                        dir = QChar::DirAN; break;
+                        dir = QChar::DirAN;
+                        break;
                    case QChar::DirES:
                    case QChar::DirCS:
                        if(status.eor == QChar::DirEN || dir == QChar::DirAN) {
                            eor = current; break;
                        }
+                        Q_FALLTHROUGH();
                    case QChar::DirBN:
                    case QChar::DirB:
                    case QChar::DirS:
@ -614,11 +616,13 @@ static bool bidiItemize(QTextEngine *engine, QScriptAnalysis *analysis, QBidiCon
                                eor = current; status.eor = dirCurrent;
                            }
                        }
+                        break;
                    default:
                        break;
                    }
                break;
            }
+            Q_FALLTHROUGH();
        case QChar::DirAN:
            hasBidi = true;
            dirCurrent = QChar::DirAN;
@ -642,6 +646,7 @@ static bool bidiItemize(QTextEngine *engine, QScriptAnalysis *analysis, QBidiCon
                    if(status.eor == QChar::DirAN) {
                        eor = current; break;
                    }
+                    Q_FALLTHROUGH();
                case QChar::DirES:
                case QChar::DirET:
                case QChar::DirBN:
--- a/src/network/access/qnetworkaccessmanager.cpp
+++ b/src/network/access/qnetworkaccessmanager.cpp
@ -1280,11 +1280,9 @@ QNetworkReply *QNetworkAccessManager::createRequest(QNetworkAccessManager::Opera
    Q_D(QNetworkAccessManager);

    QNetworkRequest req(originalReq);
-    if (req.attribute(QNetworkRequest::RedirectPolicyAttribute).isNull()
+    if (redirectPolicy() != QNetworkRequest::ManualRedirectPolicy
+        && req.attribute(QNetworkRequest::RedirectPolicyAttribute).isNull()
        && req.attribute(QNetworkRequest::FollowRedirectsAttribute).isNull()) {
-        // We only apply the general manager's policy if:
-        // - RedirectPolicyAttribute is not set already on request and
-        // - no FollowRedirectsAttribute is set.
        req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, redirectPolicy());
    }

--- a/src/network/socket/qnativesocketengine.cpp
+++ b/src/network/socket/qnativesocketengine.cpp
@ -129,6 +129,10 @@
 # include "qtcpserver.h"
 #endif

+#if !defined(QT_NO_SCTP)
+# include "qsctpserver.h"
+#endif
+
 QT_BEGIN_NAMESPACE

 //#define QNATIVESOCKETENGINE_DEBUG
--- a/src/network/socket/qnativesocketengine_p.h
+++ b/src/network/socket/qnativesocketengine_p.h
@ -286,8 +286,10 @@ public:
    bool checkProxy(const QHostAddress &address);
    bool fetchConnectionParameters();

+#if QT_CONFIG(networkinterface)
    static uint scopeIdFromString(const QString &scopeid)
    { return QNetworkInterface::interfaceIndexFromName(scopeid); }
+#endif

    /*! \internal
        Sets \a address and \a port in the \a aa sockaddr structure and the size in \a sockAddrSize.
@ -301,7 +303,9 @@ public:
            || socketProtocol == QAbstractSocket::AnyIPProtocol) {
            memset(&aa->a6, 0, sizeof(sockaddr_in6));
            aa->a6.sin6_family = AF_INET6;
+#if QT_CONFIG(networkinterface)
            aa->a6.sin6_scope_id = scopeIdFromString(address.scopeId());
+#endif
            aa->a6.sin6_port = htons(port);
            Q_IPV6ADDR tmp = address.toIPv6Address();
            memcpy(&aa->a6.sin6_addr, &tmp, sizeof(tmp));
--- a/src/network/socket/qnativesocketengine_unix.cpp
+++ b/src/network/socket/qnativesocketengine_unix.cpp
@ -121,8 +121,10 @@ static inline void qt_socket_getPortAndAddress(const qt_sockaddr *s, quint16 *po
            QHostAddress tmpAddress;
            tmpAddress.setAddress(tmp);
            *addr = tmpAddress;
+#if QT_CONFIG(networkinterface)
            if (s->a6.sin6_scope_id)
                addr->setScopeId(QNetworkInterface::interfaceNameFromIndex(s->a6.sin6_scope_id));
+#endif
        }
        if (port)
            *port = ntohs(s->a6.sin6_port);
@ -984,7 +986,8 @@ qint64 QNativeSocketEnginePrivate::nativeReceiveDatagram(char *data, qint64 maxS
            if (cmsgptr->cmsg_len == CMSG_LEN(sizeof(int))
                    && ((cmsgptr->cmsg_level == IPPROTO_IPV6 && cmsgptr->cmsg_type == IPV6_HOPLIMIT)
                        || (cmsgptr->cmsg_level == IPPROTO_IP && cmsgptr->cmsg_type == IP_TTL))) {
-                header->hopLimit = *reinterpret_cast<int *>(CMSG_DATA(cmsgptr));
+                Q_STATIC_ASSERT(sizeof(header->hopLimit) == sizeof(int));
+                memcpy(&header->hopLimit, CMSG_DATA(cmsgptr), sizeof(header->hopLimit));
            }

 #ifndef QT_NO_SCTP
--- a/src/platformsupport/fontdatabases/fontconfig/qfontconfigdatabase.cpp
+++ b/src/platformsupport/fontdatabases/fontconfig/qfontconfigdatabase.cpp
@ -677,6 +677,7 @@ QFontEngine *QFontconfigDatabase::fontEngine(const QFontDef &f, void *usrPtr)
    fid.filename = QFile::encodeName(fontfile->fileName);
    fid.index = fontfile->indexValue;

+    // FIXME: Unify with logic in QFontEngineFT::create()
    QFontEngineFT *engine = new QFontEngineFT(f);
    engine->face_id = fid;

@ -692,7 +693,7 @@ QFontEngine *QFontconfigDatabase::fontEngine(const QFontDef &f, void *usrPtr)

 QFontEngine *QFontconfigDatabase::fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference)
 {
-    QFontEngineFT *engine = static_cast<QFontEngineFT*>(QBasicFontDatabase::fontEngine(fontData, pixelSize, hintingPreference));
+    QFontEngineFT *engine = static_cast<QFontEngineFT*>(QFreeTypeFontDatabase::fontEngine(fontData, pixelSize, hintingPreference));
    if (engine == 0)
        return 0;

@ -844,7 +845,7 @@ QStringList QFontconfigDatabase::addApplicationFont(const QByteArray &fontData,

 QString QFontconfigDatabase::resolveFontFamilyAlias(const QString &family) const
 {
-    QString resolved = QBasicFontDatabase::resolveFontFamilyAlias(family);
+    QString resolved = QFreeTypeFontDatabase::resolveFontFamilyAlias(family);
    if (!resolved.isEmpty() && resolved != family)
        return resolved;
    FcPattern *pattern = FcPatternCreate();
--- a/src/platformsupport/fontdatabases/fontconfig/qfontconfigdatabase_p.h
+++ b/src/platformsupport/fontdatabases/fontconfig/qfontconfigdatabase_p.h
@ -52,13 +52,13 @@
 //

 #include <qpa/qplatformfontdatabase.h>
-#include <QtFontDatabaseSupport/private/qbasicfontdatabase_p.h>
+#include <QtFontDatabaseSupport/private/qfreetypefontdatabase_p.h>

 QT_BEGIN_NAMESPACE

 class QFontEngineFT;

-class QFontconfigDatabase : public QBasicFontDatabase
+class QFontconfigDatabase : public QFreeTypeFontDatabase
 {
 public:
    void populateFontDatabase() Q_DECL_OVERRIDE;
--- a/src/platformsupport/fontdatabases/fontdatabases.pro
+++ b/src/platformsupport/fontdatabases/fontdatabases.pro
@ -11,7 +11,7 @@ darwin {
    include($$PWD/mac/coretext.pri)
 } else {
    qtConfig(freetype) {
-        include($$PWD/basic/basic.pri)
+        include($$PWD/freetype/freetype.pri)
    }

    unix {
--- a/src/platformsupport/fontdatabases/freetype/freetype.pri
+++ b/src/platformsupport/fontdatabases/freetype/freetype.pri
@ -1,9 +1,9 @@
 HEADERS += \
-        $$PWD/qbasicfontdatabase_p.h \
+        $$PWD/qfreetypefontdatabase_p.h \
        $$PWD/qfontengine_ft_p.h

 SOURCES += \
-        $$PWD/qbasicfontdatabase.cpp \
+        $$PWD/qfreetypefontdatabase.cpp \
        $$PWD/qfontengine_ft.cpp

 QMAKE_USE_PRIVATE += freetype
--- a/src/platformsupport/fontdatabases/freetype/qfontengine_ft.cpp
+++ b/src/platformsupport/fontdatabases/freetype/qfontengine_ft.cpp
@ -44,6 +44,10 @@
 #include "qfontengine_ft_p.h"
 #include "private/qimage_p.h"
 #include <private/qstringiterator_p.h>
+#include <qguiapplication.h>
+#include <qscreen.h>
+#include <qpa/qplatformscreen.h>
+#include <QtCore/QUuid>

 #ifndef QT_NO_FREETYPE

@ -666,6 +670,93 @@ static void convoluteBitmap(const uchar *src, uchar *dst, int width, int height,
    }
 }

+static QFontEngine::SubpixelAntialiasingType subpixelAntialiasingTypeHint()
+{
+    static int type = -1;
+    if (type == -1) {
+        if (QScreen *screen = QGuiApplication::primaryScreen())
+            type = screen->handle()->subpixelAntialiasingTypeHint();
+    }
+    return static_cast<QFontEngine::SubpixelAntialiasingType>(type);
+}
+
+QFontEngineFT *QFontEngineFT::create(const QFontDef &fontDef, FaceId faceId, const QByteArray &fontData)
+{
+    QScopedPointer<QFontEngineFT> engine(new QFontEngineFT(fontDef));
+
+    QFontEngineFT::GlyphFormat format = QFontEngineFT::Format_Mono;
+    const bool antialias = !(fontDef.styleStrategy & QFont::NoAntialias);
+
+    if (antialias) {
+        QFontEngine::SubpixelAntialiasingType subpixelType = subpixelAntialiasingTypeHint();
+        if (subpixelType == QFontEngine::Subpixel_None || (fontDef.styleStrategy & QFont::NoSubpixelAntialias)) {
+            format = QFontEngineFT::Format_A8;
+            engine->subpixelType = QFontEngine::Subpixel_None;
+        } else {
+            format = QFontEngineFT::Format_A32;
+            engine->subpixelType = subpixelType;
+        }
+    }
+
+    if (!engine->init(faceId, antialias, format, fontData) || engine->invalid()) {
+        qWarning("QFontEngineFT: Failed to create FreeType font engine");
+        return nullptr;
+    }
+
+    engine->setQtDefaultHintStyle(static_cast<QFont::HintingPreference>(fontDef.hintingPreference));
+    return engine.take();
+}
+
+namespace {
+    class QFontEngineFTRawData: public QFontEngineFT
+    {
+    public:
+        QFontEngineFTRawData(const QFontDef &fontDef) : QFontEngineFT(fontDef)
+        {
+        }
+
+        void updateFamilyNameAndStyle()
+        {
+            fontDef.family = QString::fromLatin1(freetype->face->family_name);
+
+            if (freetype->face->style_flags & FT_STYLE_FLAG_ITALIC)
+                fontDef.style = QFont::StyleItalic;
+
+            if (freetype->face->style_flags & FT_STYLE_FLAG_BOLD)
+                fontDef.weight = QFont::Bold;
+        }
+
+        bool initFromData(const QByteArray &fontData)
+        {
+            FaceId faceId;
+            faceId.filename = "";
+            faceId.index = 0;
+            faceId.uuid = QUuid::createUuid().toByteArray();
+
+            return init(faceId, true, Format_None, fontData);
+        }
+    };
+}
+
+QFontEngineFT *QFontEngineFT::create(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference)
+{
+    QFontDef fontDef;
+    fontDef.pixelSize = pixelSize;
+    fontDef.stretch = QFont::Unstretched;
+    fontDef.hintingPreference = hintingPreference;
+
+    QFontEngineFTRawData *fe = new QFontEngineFTRawData(fontDef);
+    if (!fe->initFromData(fontData)) {
+        delete fe;
+        return 0;
+    }
+
+    fe->updateFamilyNameAndStyle();
+    fe->setQtDefaultHintStyle(static_cast<QFont::HintingPreference>(fontDef.hintingPreference));
+
+    return fe;
+}
+
 QFontEngineFT::QFontEngineFT(const QFontDef &fd)
    : QFontEngine(Freetype)
 {
--- a/src/platformsupport/fontdatabases/freetype/qfontengine_ft_p.h
+++ b/src/platformsupport/fontdatabases/freetype/qfontengine_ft_p.h
@ -292,6 +292,10 @@ private:
    bool initFromFontEngine(const QFontEngineFT *fontEngine);

    HintStyle defaultHintStyle() const { return default_hint_style; }
+
+    static QFontEngineFT *create(const QFontDef &fontDef, FaceId faceId, const QByteArray &fontData = QByteArray());
+    static QFontEngineFT *create(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference);
+
 protected:

    QFreetypeFace *freetype;
@ -311,8 +315,7 @@ protected:
 private:
    friend class QFontEngineFTRawFont;
    friend class QFontconfigDatabase;
-    friend class QBasicFontDatabase;
-    friend class QCoreTextFontDatabase;
+    friend class QFreeTypeFontDatabase;
    friend class QFontEngineMultiFontConfig;

    int loadFlags(QGlyphSet *set, GlyphFormat format, int flags, bool &hsubpixel, int &vfactor) const;
--- a/src/platformsupport/fontdatabases/freetype/qfreetypefontdatabase.cpp
+++ b/src/platformsupport/fontdatabases/freetype/qfreetypefontdatabase.cpp
@ -37,7 +37,7 @@
 **
 ****************************************************************************/

-#include "qbasicfontdatabase_p.h"
+#include "qfreetypefontdatabase_p.h"

 #include <QtGui/private/qguiapplication_p.h>
 #include <qpa/qplatformscreen.h>
@ -45,7 +45,6 @@
 #include <QtCore/QFile>
 #include <QtCore/QLibraryInfo>
 #include <QtCore/QDir>
-#include <QtCore/QUuid>
 #include <QtCore/QtEndian>

 #undef QT_NO_FREETYPE
@ -57,7 +56,7 @@

 QT_BEGIN_NAMESPACE

-void QBasicFontDatabase::populateFontDatabase()
+void QFreeTypeFontDatabase::populateFontDatabase()
 {
    QString fontpath = fontDir();
    QDir dir(fontpath);
@ -79,99 +78,32 @@ void QBasicFontDatabase::populateFontDatabase()
    const auto fis = dir.entryInfoList(nameFilters, QDir::Files);
    for (const QFileInfo &fi : fis) {
        const QByteArray file = QFile::encodeName(fi.absoluteFilePath());
-        QBasicFontDatabase::addTTFile(QByteArray(), file);
+        QFreeTypeFontDatabase::addTTFile(QByteArray(), file);
    }
 }

-QFontEngine *QBasicFontDatabase::fontEngine(const QFontDef &fontDef, void *usrPtr)
+QFontEngine *QFreeTypeFontDatabase::fontEngine(const QFontDef &fontDef, void *usrPtr)
 {
-    FontFile *fontfile = static_cast<FontFile *> (usrPtr);
-    QFontEngine::FaceId fid;
-    fid.filename = QFile::encodeName(fontfile->fileName);
-    fid.index = fontfile->indexValue;
+    FontFile *fontfile = static_cast<FontFile *>(usrPtr);
+    QFontEngine::FaceId faceId;
+    faceId.filename = QFile::encodeName(fontfile->fileName);
+    faceId.index = fontfile->indexValue;

-    bool antialias = !(fontDef.styleStrategy & QFont::NoAntialias);
-    QFontEngineFT *engine = new QFontEngineFT(fontDef);
-    QFontEngineFT::GlyphFormat format = QFontEngineFT::Format_Mono;
-    if (antialias) {
-        QFontEngine::SubpixelAntialiasingType subpixelType = subpixelAntialiasingTypeHint();
-        if (subpixelType == QFontEngine::Subpixel_None || (fontDef.styleStrategy & QFont::NoSubpixelAntialias)) {
-            format = QFontEngineFT::Format_A8;
-            engine->subpixelType = QFontEngine::Subpixel_None;
-        } else {
-            format = QFontEngineFT::Format_A32;
-            engine->subpixelType = subpixelType;
-        }
-    }
-
-    if (!engine->init(fid, antialias, format) || engine->invalid()) {
-        delete engine;
-        engine = 0;
-    } else {
-        engine->setQtDefaultHintStyle(static_cast<QFont::HintingPreference>(fontDef.hintingPreference));
-    }
-
-    return engine;
+    return QFontEngineFT::create(fontDef, faceId);
 }

-namespace {
-
-    class QFontEngineFTRawData: public QFontEngineFT
-    {
-    public:
-        QFontEngineFTRawData(const QFontDef &fontDef) : QFontEngineFT(fontDef)
-        {
-        }
-
-        void updateFamilyNameAndStyle()
-        {
-            fontDef.family = QString::fromLatin1(freetype->face->family_name);
-
-            if (freetype->face->style_flags & FT_STYLE_FLAG_ITALIC)
-                fontDef.style = QFont::StyleItalic;
-
-            if (freetype->face->style_flags & FT_STYLE_FLAG_BOLD)
-                fontDef.weight = QFont::Bold;
-        }
-
-        bool initFromData(const QByteArray &fontData)
-        {
-            FaceId faceId;
-            faceId.filename = "";
-            faceId.index = 0;
-            faceId.uuid = QUuid::createUuid().toByteArray();
-
-            return init(faceId, true, Format_None, fontData);
-        }
-    };
-
-}
-
-QFontEngine *QBasicFontDatabase::fontEngine(const QByteArray &fontData, qreal pixelSize,
+QFontEngine *QFreeTypeFontDatabase::fontEngine(const QByteArray &fontData, qreal pixelSize,
                                                QFont::HintingPreference hintingPreference)
 {
-    QFontDef fontDef;
-    fontDef.pixelSize = pixelSize;
-    fontDef.hintingPreference = hintingPreference;
-
-    QFontEngineFTRawData *fe = new QFontEngineFTRawData(fontDef);
-    if (!fe->initFromData(fontData)) {
-        delete fe;
-        return 0;
-    }
-
-    fe->updateFamilyNameAndStyle();
-    fe->setQtDefaultHintStyle(static_cast<QFont::HintingPreference>(fontDef.hintingPreference));
-
-    return fe;
+    return QFontEngineFT::create(fontData, pixelSize, hintingPreference);
 }

-QStringList QBasicFontDatabase::addApplicationFont(const QByteArray &fontData, const QString &fileName)
+QStringList QFreeTypeFontDatabase::addApplicationFont(const QByteArray &fontData, const QString &fileName)
 {
-    return QBasicFontDatabase::addTTFile(fontData, fileName.toLocal8Bit());
+    return QFreeTypeFontDatabase::addTTFile(fontData, fileName.toLocal8Bit());
 }

-void QBasicFontDatabase::releaseHandle(void *handle)
+void QFreeTypeFontDatabase::releaseHandle(void *handle)
 {
    FontFile *file = static_cast<FontFile *>(handle);
    delete file;
@ -179,7 +111,7 @@ void QBasicFontDatabase::releaseHandle(void *handle)

 extern FT_Library qt_getFreetype();

-QStringList QBasicFontDatabase::addTTFile(const QByteArray &fontData, const QByteArray &file)
+QStringList QFreeTypeFontDatabase::addTTFile(const QByteArray &fontData, const QByteArray &file)
 {
    FT_Library library = qt_getFreetype();

--- a/src/platformsupport/fontdatabases/freetype/qfreetypefontdatabase_p.h
+++ b/src/platformsupport/fontdatabases/freetype/qfreetypefontdatabase_p.h
@ -37,8 +37,8 @@
 **
 ****************************************************************************/

-#ifndef QBASICFONTDATABASE_H
-#define QBASICFONTDATABASE_H
+#ifndef QFREETYPEFONTDATABASE_H
+#define QFREETYPEFONTDATABASE_H

 //
 //  W A R N I N G
@ -63,7 +63,7 @@ struct FontFile
    int indexValue;
 };

-class QBasicFontDatabase : public QPlatformFontDatabase
+class QFreeTypeFontDatabase : public QPlatformFontDatabase
 {
 public:
    void populateFontDatabase() Q_DECL_OVERRIDE;
@ -77,4 +77,4 @@ public:

 QT_END_NAMESPACE

-#endif // QBASICFONTDATABASE_H
+#endif // QFREETYPEFONTDATABASE_H
--- a/src/platformsupport/fontdatabases/genericunix/qgenericunixfontdatabase_p.h
+++ b/src/platformsupport/fontdatabases/genericunix/qgenericunixfontdatabase_p.h
@ -57,8 +57,8 @@
 #include <QtFontDatabaseSupport/private/qfontconfigdatabase_p.h>
 typedef QFontconfigDatabase QGenericUnixFontDatabase;
 #else
-#include <QtFontDatabaseSupport/private/qbasicfontdatabase_p.h>
-typedef QBasicFontDatabase QGenericUnixFontDatabase;
+#include <QtFontDatabaseSupport/private/qfreetypefontdatabase_p.h>
+typedef QFreeTypeFontDatabase QGenericUnixFontDatabase;
 #endif //Q_FONTCONFIGDATABASE

 #endif // QGENERICUNIXFONTDATABASE_H
--- a/src/platformsupport/fontdatabases/mac/coretext.pri
+++ b/src/platformsupport/fontdatabases/mac/coretext.pri
@ -3,8 +3,8 @@ OBJECTIVE_SOURCES += $$PWD/qfontengine_coretext.mm $$PWD/qcoretextfontdatabase.m

 qtConfig(freetype) {
    QMAKE_USE_PRIVATE += freetype
-    HEADERS += basic/qfontengine_ft_p.h
-    SOURCES += basic/qfontengine_ft.cpp
+    HEADERS += freetype/qfontengine_ft_p.h
+    SOURCES += freetype/qfontengine_ft.cpp
 }

 uikit: \
--- a/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase.mm
+++ b/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase.mm
@ -112,12 +112,8 @@ static NSInteger languageMapSort(id obj1, id obj2, void *context)
 }
 #endif

-QCoreTextFontDatabase::QCoreTextFontDatabase(bool useFreeType)
-#ifndef QT_NO_FREETYPE
-    : m_useFreeType(useFreeType)
-#endif
+QCoreTextFontDatabase::QCoreTextFontDatabase()
 {
-    Q_UNUSED(useFreeType)
 #ifdef Q_OS_MACX
    QSettings appleSettings(QLatin1String("apple.com"));
    QVariant appleValue = appleSettings.value(QLatin1String("AppleAntiAliasingThreshold"));
@ -367,61 +363,25 @@ void QCoreTextFontDatabase::releaseHandle(void *handle)
    CFRelease(CTFontDescriptorRef(handle));
 }

-#ifndef QT_NO_FREETYPE
-static QByteArray filenameForCFUrl(CFURLRef url)
-{
-    // The on-stack buffer prevents that a QByteArray allocated for the worst case (MAXPATHLEN)
-    // stays around for the lifetime of the font. Additionally, it helps to move the char
-    // signedness cast to an acceptable place.
-    uchar buffer[MAXPATHLEN];
-    QByteArray filename;
-
-    if (!CFURLGetFileSystemRepresentation(url, true, buffer, sizeof(buffer))) {
-        qWarning("QCoreTextFontDatabase::filenameForCFUrl: could not resolve file for URL %s",
-                 url ? qPrintable(QString::fromCFString(CFURLGetString(url))) : "(null)");
-    } else {
-        QCFType<CFStringRef> scheme = CFURLCopyScheme(url);
-        if (QString::fromCFString(scheme) == QLatin1String("qrc"))
-            filename = ":";
-
-        filename += reinterpret_cast<char *>(buffer);
-    }
-
-    return filename;
-}
-#endif
-
 extern CGAffineTransform qt_transform_from_fontdef(const QFontDef &fontDef);

-QFontEngine *QCoreTextFontDatabase::fontEngine(const QFontDef &f, void *usrPtr)
+template <>
+QFontEngine *QCoreTextFontDatabaseEngineFactory<QCoreTextFontEngine>::fontEngine(const QFontDef &fontDef, void *usrPtr)
 {
    CTFontDescriptorRef descriptor = static_cast<CTFontDescriptorRef>(usrPtr);

-#ifndef QT_NO_FREETYPE
-    if (m_useFreeType) {
-        QCFType<CFURLRef> url(static_cast<CFURLRef>(CTFontDescriptorCopyAttribute(descriptor, kCTFontURLAttribute)));
-
-        QByteArray filename;
-        if (url)
-            filename = filenameForCFUrl(url);
-
-        return freeTypeFontEngine(f, filename);
-    }
-#endif
-
    // Since we do not pass in the destination DPI to CoreText when making
    // the font, we need to pass in a point size which is scaled to include
    // the DPI. The default DPI for the screen is 72, thus the scale factor
    // is destinationDpi / 72, but since pixelSize = pointSize / 72 * dpi,
    // the pixelSize is actually the scaled point size for the destination
    // DPI, and we can use that directly.
-    qreal scaledPointSize = f.pixelSize;
+    qreal scaledPointSize = fontDef.pixelSize;

-    CGAffineTransform matrix = qt_transform_from_fontdef(f);
+    CGAffineTransform matrix = qt_transform_from_fontdef(fontDef);
    CTFontRef font = CTFontCreateWithFontDescriptor(descriptor, scaledPointSize, &matrix);
    if (font) {
-        QFontEngine *engine = new QCoreTextFontEngine(font, f);
-        engine->fontDef = f;
+        QFontEngine *engine = new QCoreTextFontEngine(font, fontDef);
        CFRelease(font);
        return engine;
    }
@ -429,6 +389,29 @@ QFontEngine *QCoreTextFontDatabase::fontEngine(const QFontDef &f, void *usrPtr)
    return NULL;
 }

+#ifndef QT_NO_FREETYPE
+template <>
+QFontEngine *QCoreTextFontDatabaseEngineFactory<QFontEngineFT>::fontEngine(const QFontDef &fontDef, void *usrPtr)
+{
+    CTFontDescriptorRef descriptor = static_cast<CTFontDescriptorRef>(usrPtr);
+
+    QByteArray filename;
+    if (NSURL *url = [static_cast<NSURL *>(CTFontDescriptorCopyAttribute(descriptor, kCTFontURLAttribute)) autorelease]) {
+        if ([url.scheme isEqual:@"qrc"])
+            filename = ":";
+        else if (!url.fileURL)
+            qWarning() << "QFontDatabase: Unknown scheme" << url.scheme << "in font descriptor URL";
+
+        filename += QString::fromNSString(url.path).toUtf8();
+    }
+    Q_ASSERT(!filename.isEmpty());
+
+    QFontEngine::FaceId faceId;
+    faceId.filename = filename;
+    return QFontEngineFT::create(fontDef, faceId);
+}
+#endif
+
 static void releaseFontData(void* info, const void* data, size_t size)
 {
    Q_UNUSED(data);
@ -436,31 +419,9 @@ static void releaseFontData(void* info, const void* data, size_t size)
    delete (QByteArray*)info;
 }

-QFontEngine *QCoreTextFontDatabase::fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference)
+template <>
+QFontEngine *QCoreTextFontDatabaseEngineFactory<QCoreTextFontEngine>::fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference)
 {
-#ifndef QT_NO_FREETYPE
-    if (m_useFreeType) {
-        QByteArray *fontDataCopy = new QByteArray(fontData);
-        QCFType<CGDataProviderRef> dataProvider = CGDataProviderCreateWithData(fontDataCopy,
-                fontDataCopy->constData(), fontDataCopy->size(), releaseFontData);
-        QCFType<CGFontRef> cgFont(CGFontCreateWithDataProvider(dataProvider));
-
-        if (!cgFont) {
-            qWarning("QCoreTextFontDatabase::fontEngine: CGFontCreateWithDataProvider failed");
-            return Q_NULLPTR;
-        }
-
-        QFontDef fontDef;
-        fontDef.pixelSize = pixelSize;
-        fontDef.pointSize = pixelSize * 72.0 / qt_defaultDpi();
-        fontDef.hintingPreference = hintingPreference;
-        CGAffineTransform transform = qt_transform_from_fontdef(fontDef);
-        QCFType<CTFontRef> ctFont(CTFontCreateWithGraphicsFont(cgFont, fontDef.pixelSize, &transform, Q_NULLPTR));
-        QCFType<CFURLRef> url(static_cast<CFURLRef>(CTFontCopyAttribute(ctFont, kCTFontURLAttribute)));
-        return freeTypeFontEngine(fontDef, filenameForCFUrl(url), fontData);
-    }
-#endif
-
    Q_UNUSED(hintingPreference);

    QByteArray* fontDataCopy = new QByteArray(fontData);
@ -483,6 +444,14 @@ QFontEngine *QCoreTextFontDatabase::fontEngine(const QByteArray &fontData, qreal
    return fontEngine;
 }

+#ifndef QT_NO_FREETYPE
+template <>
+QFontEngine *QCoreTextFontDatabaseEngineFactory<QFontEngineFT>::fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference)
+{
+    return QFontEngineFT::create(fontData, pixelSize, hintingPreference);
+}
+#endif
+
 QFont::StyleHint styleHintFromNSString(NSString *style)
 {
    if ([style isEqual: @"sans-serif"])
@ -615,17 +584,27 @@ QStringList QCoreTextFontDatabase::fallbacksForFamily(const QString &family, QFo
    return fallbackLists[styleLookupKey.arg(styleHint)];
 }

-CFArrayRef QCoreTextFontDatabase::createDescriptorArrayForFont(CTFontRef font, const QString &fileName)
+template <>
+CFArrayRef QCoreTextFontDatabaseEngineFactory<QCoreTextFontEngine>::createDescriptorArrayForFont(CTFontRef font, const QString &fileName)
+{
+    Q_UNUSED(fileName)
+    CFMutableArrayRef array = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
+    QCFType<CTFontDescriptorRef> descriptor = CTFontCopyFontDescriptor(font);
+    CFArrayAppendValue(array, descriptor);
+    return array;
+}
+
+#ifndef QT_NO_FREETYPE
+template <>
+CFArrayRef QCoreTextFontDatabaseEngineFactory<QFontEngineFT>::createDescriptorArrayForFont(CTFontRef font, const QString &fileName)
 {
    CFMutableArrayRef array = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
    QCFType<CTFontDescriptorRef> descriptor = CTFontCopyFontDescriptor(font);

-    Q_UNUSED(fileName)
-#ifndef QT_NO_FREETYPE
    // The physical font source URL (usually a local file or Qt resource) is only required for
    // FreeType, when using non-system fonts, and needs some hackery to attach in a format
    // agreeable to OSX.
-    if (m_useFreeType && !fileName.isEmpty()) {
+    if (!fileName.isEmpty()) {
        QCFType<CFURLRef> fontURL;

        if (fileName.startsWith(QLatin1String(":/"))) {
@ -642,11 +621,11 @@ CFArrayRef QCoreTextFontDatabase::createDescriptorArrayForFont(CTFontRef font, c
        CFDictionaryAddValue(attributes, kCTFontURLAttribute, fontURL);
        descriptor = CTFontDescriptorCreateCopyWithAttributes(descriptor, attributes);
    }
-#endif

    CFArrayAppendValue(array, descriptor);
    return array;
 }
+#endif

 QStringList QCoreTextFontDatabase::addApplicationFont(const QByteArray &fontData, const QString &fileName)
 {
@ -884,36 +863,5 @@ void QCoreTextFontDatabase::removeApplicationFonts()
    m_applicationFonts.clear();
 }

-#ifndef QT_NO_FREETYPE
-QFontEngine *QCoreTextFontDatabase::freeTypeFontEngine(const QFontDef &fontDef, const QByteArray &filename,
-                                                       const QByteArray &fontData)
-{
-    QFontEngine::FaceId faceId;
-    faceId.filename = filename;
-    const bool antialias = !(fontDef.styleStrategy & QFont::NoAntialias);
-
-    QScopedPointer<QFontEngineFT> engine(new QFontEngineFT(fontDef));
-    QFontEngineFT::GlyphFormat format = QFontEngineFT::Format_Mono;
-    if (antialias) {
-        QFontEngine::SubpixelAntialiasingType subpixelType = subpixelAntialiasingTypeHint();
-        if (subpixelType == QFontEngine::Subpixel_None || (fontDef.styleStrategy & QFont::NoSubpixelAntialias)) {
-            format = QFontEngineFT::Format_A8;
-            engine->subpixelType = QFontEngine::Subpixel_None;
-        } else {
-            format = QFontEngineFT::Format_A32;
-            engine->subpixelType = subpixelType;
-        }
-    }
-
-    if (!engine->init(faceId, antialias, format, fontData) || engine->invalid()) {
-        qWarning("QCoreTextFontDatabase::freeTypefontEngine Failed to create engine");
-        return Q_NULLPTR;
-    }
-    engine->setQtDefaultHintStyle(static_cast<QFont::HintingPreference>(fontDef.hintingPreference));
-
-    return engine.take();
-}
-#endif
-
 QT_END_NAMESPACE

--- a/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase_p.h
+++ b/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase_p.h
@ -68,13 +68,11 @@ QT_BEGIN_NAMESPACE
 class QCoreTextFontDatabase : public QPlatformFontDatabase
 {
 public:
-    QCoreTextFontDatabase(bool useFreeType = false);
+    QCoreTextFontDatabase();
    ~QCoreTextFontDatabase();
    void populateFontDatabase() Q_DECL_OVERRIDE;
    void populateFamily(const QString &familyName) Q_DECL_OVERRIDE;

-    QFontEngine *fontEngine(const QFontDef &fontDef, void *handle) Q_DECL_OVERRIDE;
-    QFontEngine *fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference) Q_DECL_OVERRIDE;
    QStringList fallbacksForFamily(const QString &family, QFont::Style style, QFont::StyleHint styleHint, QChar::Script script) const Q_DECL_OVERRIDE;
    QStringList addApplicationFont(const QByteArray &fontData, const QString &fileName) Q_DECL_OVERRIDE;
    void releaseHandle(void *handle) Q_DECL_OVERRIDE;
@ -89,13 +87,8 @@ public:

 private:
    void populateFromDescriptor(CTFontDescriptorRef font, const QString &familyName = QString());
-    CFArrayRef createDescriptorArrayForFont(CTFontRef font, const QString &fileName);
+    virtual CFArrayRef createDescriptorArrayForFont(CTFontRef font, const QString &fileName) = 0;

-#ifndef QT_NO_FREETYPE
-    bool m_useFreeType;
-    QFontEngine *freeTypeFontEngine(const QFontDef &fontDef, const QByteArray &filename,
-                                    const QByteArray &fontData = QByteArray());
-#endif
    mutable QString defaultFontName;

    void removeApplicationFonts();
@ -105,6 +98,19 @@ private:
    mutable QHash<QPlatformTheme::Font, QFont *> m_themeFonts;
 };

+// Split out into separate template class so that the compiler doesn't have
+// to generate code for each override in QCoreTextFontDatabase for each T.
+
+template <class T>
+class QCoreTextFontDatabaseEngineFactory : public QCoreTextFontDatabase
+{
+public:
+    QFontEngine *fontEngine(const QFontDef &fontDef, void *handle) override;
+    QFontEngine *fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference) override;
+protected:
+    CFArrayRef createDescriptorArrayForFont(CTFontRef font, const QString &fileName) override;
+};
+
 QT_END_NAMESPACE

 #endif // QCORETEXTFONTDATABASE_H
--- a/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase_ft.cpp
+++ b/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase_ft.cpp
@ -393,14 +393,14 @@ void QWindowsFontDatabaseFT::populateFontDatabase()

 QFontEngine * QWindowsFontDatabaseFT::fontEngine(const QFontDef &fontDef, void *handle)
 {
-    QFontEngine *fe = QBasicFontDatabase::fontEngine(fontDef, handle);
+    QFontEngine *fe = QFreeTypeFontDatabase::fontEngine(fontDef, handle);
    qCDebug(lcQpaFonts) << __FUNCTION__ << "FONTDEF" << fontDef.family << fe << handle;
    return fe;
 }

 QFontEngine *QWindowsFontDatabaseFT::fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference)
 {
-    QFontEngine *fe = QBasicFontDatabase::fontEngine(fontData, pixelSize, hintingPreference);
+    QFontEngine *fe = QFreeTypeFontDatabase::fontEngine(fontData, pixelSize, hintingPreference);
    qCDebug(lcQpaFonts) << __FUNCTION__ << "FONTDATA" << fontData << pixelSize << hintingPreference << fe;
    return fe;
 }
@ -410,7 +410,7 @@ QStringList QWindowsFontDatabaseFT::fallbacksForFamily(const QString &family, QF
    QStringList result;
    result.append(QWindowsFontDatabase::familyForStyleHint(styleHint));
    result.append(QWindowsFontDatabase::extraTryFontsForFamily(family));
-    result.append(QBasicFontDatabase::fallbacksForFamily(family, style, styleHint, script));
+    result.append(QFreeTypeFontDatabase::fallbacksForFamily(family, style, styleHint, script));

    qCDebug(lcQpaFonts) << __FUNCTION__ << family << style << styleHint
        << script << result;
--- a/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase_ft_p.h
+++ b/src/platformsupport/fontdatabases/windows/qwindowsfontdatabase_ft_p.h
@ -51,13 +51,13 @@
 // We mean it.
 //

-#include <QtFontDatabaseSupport/private/qbasicfontdatabase_p.h>
+#include <QtFontDatabaseSupport/private/qfreetypefontdatabase_p.h>
 #include <QtCore/QSharedPointer>
 #include <QtCore/qt_windows.h>

 QT_BEGIN_NAMESPACE

-class QWindowsFontDatabaseFT : public QBasicFontDatabase
+class QWindowsFontDatabaseFT : public QFreeTypeFontDatabase
 {
 public:
    void populateFontDatabase() Q_DECL_OVERRIDE;
--- a/src/platformsupport/fontdatabases/windows/qwindowsfontengine.cpp
+++ b/src/platformsupport/fontdatabases/windows/qwindowsfontengine.cpp
@ -1281,6 +1281,7 @@ QFontEngine *QWindowsMultiFontEngine::loadEngine(int at)
                    fedw->fontDef.style = fontEngine->fontDef.style;
                fedw->fontDef.family = fam;
                fedw->fontDef.hintingPreference = fontEngine->fontDef.hintingPreference;
+                fedw->fontDef.stretch = fontEngine->fontDef.stretch;
                return fedw;
            } else {
                qErrnoWarning("%s: CreateFontFace failed", __FUNCTION__);
@ -1298,6 +1299,7 @@ QFontEngine *QWindowsMultiFontEngine::loadEngine(int at)
        fe->fontDef.style = fontEngine->fontDef.style;
    fe->fontDef.family = fam;
    fe->fontDef.hintingPreference = fontEngine->fontDef.hintingPreference;
+    fe->fontDef.stretch = fontEngine->fontDef.stretch;
    return fe;
 }

--- a/src/platformsupport/fontdatabases/winrt/qwinrtfontdatabase.cpp
+++ b/src/platformsupport/fontdatabases/winrt/qwinrtfontdatabase.cpp
@ -144,7 +144,7 @@ QWinRTFontDatabase::~QWinRTFontDatabase()
 QString QWinRTFontDatabase::fontDir() const
 {
    qCDebug(lcQpaFonts) << __FUNCTION__;
-    QString fontDirectory = QBasicFontDatabase::fontDir();
+    QString fontDirectory = QFreeTypeFontDatabase::fontDir();
    if (!QFile::exists(fontDirectory)) {
        // Fall back to app directory + fonts, and just app directory after that
        const QString applicationDirPath = QCoreApplication::applicationDirPath();
@ -176,7 +176,7 @@ void QWinRTFontDatabase::populateFontDatabase()
    HRESULT hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_ISOLATED, __uuidof(IDWriteFactory1), &factory);
    if (FAILED(hr)) {
        qWarning("Failed to create DirectWrite factory: %s", qPrintable(qt_error_string(hr)));
-        QBasicFontDatabase::populateFontDatabase();
+        QFreeTypeFontDatabase::populateFontDatabase();
        return;
    }

@ -184,7 +184,7 @@ void QWinRTFontDatabase::populateFontDatabase()
    hr = factory->GetSystemFontCollection(&fontCollection);
    if (FAILED(hr)) {
        qWarning("Failed to open system font collection: %s", qPrintable(qt_error_string(hr)));
-        QBasicFontDatabase::populateFontDatabase();
+        QFreeTypeFontDatabase::populateFontDatabase();
        return;
    }

@ -222,7 +222,7 @@ void QWinRTFontDatabase::populateFontDatabase()
        registerFontFamily(familyName);
    }

-    QBasicFontDatabase::populateFontDatabase();
+    QFreeTypeFontDatabase::populateFontDatabase();
 }

 void QWinRTFontDatabase::populateFamily(const QString &familyName)
@ -399,7 +399,7 @@ QFontEngine *QWinRTFontDatabase::fontEngine(const QFontDef &fontDef, void *handl

    IDWriteFontFile *fontFile = reinterpret_cast<IDWriteFontFile *>(handle);
    if (!m_fonts.contains(fontFile))
-        return QBasicFontDatabase::fontEngine(fontDef, handle);
+        return QFreeTypeFontDatabase::fontEngine(fontDef, handle);

    const void *referenceKey;
    quint32 referenceKeySize;
@ -444,15 +444,8 @@ QFontEngine *QWinRTFontDatabase::fontEngine(const QFontDef &fontDef, void *handl
    const FontDescription description = m_fonts.value(fontFile);
    faceId.uuid = description.uuid;
    faceId.index = description.index;
-    const bool antialias = !(fontDef.styleStrategy & QFont::NoAntialias);
-    QFontEngineFT::GlyphFormat format = antialias ? QFontEngineFT::Format_A8 : QFontEngineFT::Format_Mono;
-    QFontEngineFT *engine = new QFontEngineFT(fontDef);
-    if (!engine->init(faceId, antialias, format, fontData) || engine->invalid()) {
-        delete engine;
-        return 0;
-    }

-    return engine;
+    return QFontEngineFT::create(fontDef, faceId, fontData);
 }

 QStringList QWinRTFontDatabase::fallbacksForFamily(const QString &family, QFont::Style style,
@ -468,7 +461,7 @@ QStringList QWinRTFontDatabase::fallbacksForFamily(const QString &family, QFont:
    QStringList result;
    if (family == QLatin1String("Helvetica"))
        result.append(QStringLiteral("Arial"));
-    result.append(QBasicFontDatabase::fallbacksForFamily(family, style, styleHint, script));
+    result.append(QFreeTypeFontDatabase::fallbacksForFamily(family, style, styleHint, script));
    return result;
 }

@ -486,7 +479,7 @@ void QWinRTFontDatabase::releaseHandle(void *handle)
        return;
    }

-    QBasicFontDatabase::releaseHandle(handle);
+    QFreeTypeFontDatabase::releaseHandle(handle);
 }

 QT_END_NAMESPACE
--- a/src/platformsupport/fontdatabases/winrt/qwinrtfontdatabase_p.h
+++ b/src/platformsupport/fontdatabases/winrt/qwinrtfontdatabase_p.h
@ -51,7 +51,7 @@
 // We mean it.
 //

-#include <QtFontDatabaseSupport/private/qbasicfontdatabase_p.h>
+#include <QtFontDatabaseSupport/private/qfreetypefontdatabase_p.h>
 #include <QtCore/QLoggingCategory>

 struct IDWriteFontFile;
@ -67,7 +67,7 @@ struct FontDescription
    QByteArray uuid;
 };

-class QWinRTFontDatabase : public QBasicFontDatabase
+class QWinRTFontDatabase : public QFreeTypeFontDatabase
 {
 public:
    ~QWinRTFontDatabase();
--- a/src/platformsupport/graphics/qrasterbackingstore.cpp
+++ b/src/platformsupport/graphics/qrasterbackingstore.cpp
@ -42,6 +42,9 @@
 #include <QtGui/qbackingstore.h>
 #include <QtGui/qpainter.h>

+#include <private/qhighdpiscaling_p.h>
+#include <qpa/qplatformwindow.h>
+
 QT_BEGIN_NAMESPACE

 QRasterBackingStore::QRasterBackingStore(QWindow *window)
@ -57,14 +60,14 @@ void QRasterBackingStore::resize(const QSize &size, const QRegion &staticContent
 {
    Q_UNUSED(staticContents);

-    int windowDevicePixelRatio = window()->devicePixelRatio();
-    QSize effectiveBufferSize = size * windowDevicePixelRatio;
+    qreal nativeWindowDevicePixelRatio = window()->handle()->devicePixelRatio();
+    QSize effectiveBufferSize = size * nativeWindowDevicePixelRatio;

    if (m_image.size() == effectiveBufferSize)
        return;

    m_image = QImage(effectiveBufferSize, format());
-    m_image.setDevicePixelRatio(windowDevicePixelRatio);
+    m_image.setDevicePixelRatio(nativeWindowDevicePixelRatio);
    if (m_image.format() == QImage::Format_ARGB32_Premultiplied)
        m_image.fill(Qt::transparent);
 }
@ -106,8 +109,11 @@ bool QRasterBackingStore::scroll(const QRegion &region, int dx, int dy)
 void QRasterBackingStore::beginPaint(const QRegion &region)
 {
    // Keep backing store device pixel ratio in sync with window
-    if (m_image.devicePixelRatio() != window()->devicePixelRatio())
-        resize(backingStore()->size(), backingStore()->staticContents());
+    qreal nativeWindowDevicePixelRatio = window()->handle()->devicePixelRatio();
+    if (m_image.devicePixelRatio() != nativeWindowDevicePixelRatio) {
+        const QSize nativeSize = QHighDpi::toNativePixels(backingStore()->size(), window());
+        resize(nativeSize, backingStore()->staticContents());
+    }

    if (!m_image.hasAlphaChannel())
        return;
--- a/src/plugins/platforms/android/extract.cpp
+++ b/src/plugins/platforms/android/extract.cpp
@ -1,26 +1,37 @@
 /****************************************************************************
 **
 ** Copyright (C) 2014 BogDan Vatra <bogdan@kde.org>
-** Contact: http://www.qt.io/licensing/
+** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the plugins of the Qt Toolkit.
 **
-** $QT_BEGIN_LICENSE:LGPL3-COMM$
+** $QT_BEGIN_LICENSE:LGPL$
 ** Commercial License Usage
 ** Licensees holding valid commercial Qt licenses may use this file in
 ** accordance with the commercial license agreement provided with the
 ** Software or, alternatively, in accordance with the terms contained in
 ** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see http://www.qt.io/terms-conditions. For further
-** information use the contact form at http://www.qt.io/contact-us.
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
 **
 ** GNU Lesser General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU Lesser
 ** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
 ** packaging of this file. Please review the following information to
 ** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl.html.
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
 **
 ** $QT_END_LICENSE$
 **
--- a/src/plugins/platforms/android/qandroidplatformfontdatabase.cpp
+++ b/src/plugins/platforms/android/qandroidplatformfontdatabase.cpp
@ -66,7 +66,7 @@ void QAndroidPlatformFontDatabase::populateFontDatabase()
    const auto entries = dir.entryInfoList(nameFilters, QDir::Files);
    for (const QFileInfo &fi : entries) {
        const QByteArray file = QFile::encodeName(fi.absoluteFilePath());
-        QBasicFontDatabase::addTTFile(QByteArray(), file);
+        QFreeTypeFontDatabase::addTTFile(QByteArray(), file);
    }
 }

@ -82,7 +82,7 @@ QStringList QAndroidPlatformFontDatabase::fallbacksForFamily(const QString &fami
        result.append(QString(qgetenv("QT_ANDROID_FONTS_SERIF")).split(QLatin1Char(';')));
    else
        result.append(QString(qgetenv("QT_ANDROID_FONTS")).split(QLatin1Char(';')));
-    result.append(QBasicFontDatabase::fallbacksForFamily(family, style, styleHint, script));
+    result.append(QFreeTypeFontDatabase::fallbacksForFamily(family, style, styleHint, script));

    return result;
 }
--- a/src/plugins/platforms/android/qandroidplatformfontdatabase.h
+++ b/src/plugins/platforms/android/qandroidplatformfontdatabase.h
@ -40,11 +40,11 @@
 #ifndef QANDROIDPLATFORMFONTDATABASE_H
 #define QANDROIDPLATFORMFONTDATABASE_H

-#include <QtFontDatabaseSupport/private/qbasicfontdatabase_p.h>
+#include <QtFontDatabaseSupport/private/qfreetypefontdatabase_p.h>

 QT_BEGIN_NAMESPACE

-class QAndroidPlatformFontDatabase: public QBasicFontDatabase
+class QAndroidPlatformFontDatabase: public QFreeTypeFontDatabase
 {
 public:
    QString fontDir() const override;
--- a/src/plugins/platforms/android/qandroidplatformopenglcontext.cpp
+++ b/src/plugins/platforms/android/qandroidplatformopenglcontext.cpp
@ -67,42 +67,11 @@ void QAndroidPlatformOpenGLContext::swapBuffers(QPlatformSurface *surface)
    QEGLPlatformContext::swapBuffers(surface);
 }

-bool QAndroidPlatformOpenGLContext::needsFBOReadBackWorkaround()
-{
-    static bool set = false;
-    static bool needsWorkaround = false;
-
-    if (!set) {
-        QByteArray env = qgetenv("QT_ANDROID_DISABLE_GLYPH_CACHE_WORKAROUND");
-        needsWorkaround = env.isEmpty() || env == "0" || env == "false";
-
-        if (!needsWorkaround) {
-            const char *rendererString = reinterpret_cast<const char *>(glGetString(GL_RENDERER));
-            needsWorkaround =
-                    qstrncmp(rendererString, "Mali-4xx", 6) == 0 // Mali-400, Mali-450
-                    || qstrncmp(rendererString, "Adreno (TM) 2xx", 13) == 0 // Adreno 200, 203, 205
-                    || qstrncmp(rendererString, "Adreno 2xx", 8) == 0 // Same as above but without the '(TM)'
-                    || qstrncmp(rendererString, "Adreno (TM) 30x", 14) == 0 // Adreno 302, 305
-                    || qstrncmp(rendererString, "Adreno 30x", 9) == 0 // Same as above but without the '(TM)'
-                    || qstrcmp(rendererString, "GC800 core") == 0
-                    || qstrcmp(rendererString, "GC1000 core") == 0
-                    || qstrcmp(rendererString, "Immersion.16") == 0;
-        }
-
-        set = true;
-    }
-
-    return needsWorkaround;
-}
-
 bool QAndroidPlatformOpenGLContext::makeCurrent(QPlatformSurface *surface)
 {
    bool ret = QEGLPlatformContext::makeCurrent(surface);
    QOpenGLContextPrivate *ctx_d = QOpenGLContextPrivate::get(context());

-    if (!ctx_d->workaround_brokenFBOReadBack && needsFBOReadBackWorkaround())
-        ctx_d->workaround_brokenFBOReadBack = true;
-
    return ret;
 }

--- a/src/plugins/platforms/android/qandroidplatformopenglcontext.h
+++ b/src/plugins/platforms/android/qandroidplatformopenglcontext.h
@ -55,7 +55,6 @@ public:
 private:
    EGLSurface eglSurfaceForPlatformSurface(QPlatformSurface *surface) override;

-    static bool needsFBOReadBackWorkaround();
 };

 QT_END_NAMESPACE
--- a/src/plugins/platforms/cocoa/qcocoafiledialoghelper.mm
+++ b/src/plugins/platforms/cocoa/qcocoafiledialoghelper.mm
@ -101,7 +101,7 @@ typedef QSharedPointer<QFileDialogOptions> SharedPointerFileDialogOptions;
 }

 - (NSString *)strip:(const QString &)label;
- (BOOL)panel:(id)sender shouldShowFilename:(NSString *)filename;
+- (BOOL)panel:(id)sender shouldEnableURL:(NSURL *)url;
 - (void)filterChanged:(id)sender;
 - (void)showModelessPanel;
 - (BOOL)runApplicationModalPanel;
@ -222,12 +222,12 @@ static QString strippedText(QString s)
    if (mOpenPanel){
        QFileInfo info(*mCurrentSelection);
        NSString *filepath = info.filePath().toNSString();
+        NSURL *url = [NSURL fileURLWithPath:filepath isDirectory:info.isDir()];
        bool selectable = (mOptions->acceptMode() == QFileDialogOptions::AcceptSave)
-            || [self panel:nil shouldShowFilename:filepath];
+            || [self panel:nil shouldEnableURL:url];

        [self updateProperties];
        QCocoaMenuBar::redirectKnownMenuItemsToFirstResponder();
-        [mOpenPanel setAllowedFileTypes:nil];
        [mSavePanel setNameFieldStringValue:selectable ? info.fileName().toNSString() : @""];

        [mOpenPanel beginWithCompletionHandler:^(NSInteger result){
@ -242,8 +242,9 @@ static QString strippedText(QString s)
 {
    QFileInfo info(*mCurrentSelection);
    NSString *filepath = info.filePath().toNSString();
+    NSURL *url = [NSURL fileURLWithPath:filepath isDirectory:info.isDir()];
    bool selectable = (mOptions->acceptMode() == QFileDialogOptions::AcceptSave)
-        || [self panel:nil shouldShowFilename:filepath];
+        || [self panel:nil shouldEnableURL:url];

    [mSavePanel setDirectoryURL: [NSURL fileURLWithPath:mCurrentDir]];
    [mSavePanel setNameFieldStringValue:selectable ? info.fileName().toNSString() : @""];
@ -273,8 +274,9 @@ static QString strippedText(QString s)
 {
    QFileInfo info(*mCurrentSelection);
    NSString *filepath = info.filePath().toNSString();
+    NSURL *url = [NSURL fileURLWithPath:filepath isDirectory:info.isDir()];
    bool selectable = (mOptions->acceptMode() == QFileDialogOptions::AcceptSave)
-        || [self panel:nil shouldShowFilename:filepath];
+        || [self panel:nil shouldEnableURL:url];

    [self updateProperties];
    QCocoaMenuBar::redirectKnownMenuItemsToFirstResponder();
@ -290,26 +292,24 @@ static QString strippedText(QString s)
    }];
 }

- (BOOL)isHiddenFile:(NSString *)filename isDir:(BOOL)isDir
+- (BOOL)isHiddenFileAtURL:(NSURL *)url
 {
-    CFURLRef url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, (CFStringRef)filename, kCFURLPOSIXPathStyle, isDir);
-    CFBooleanRef isHidden;
-    Boolean errorOrHidden = false;
-    if (!CFURLCopyResourcePropertyForKey(url, kCFURLIsHiddenKey, &isHidden, NULL)) {
-        errorOrHidden = true;
-    } else {
-        if (CFBooleanGetValue(isHidden))
-            errorOrHidden = true;
-        CFRelease(isHidden);
+    BOOL hidden = NO;
+    if (url) {
+        CFBooleanRef isHiddenProperty;
+        if (CFURLCopyResourcePropertyForKey((__bridge CFURLRef)url, kCFURLIsHiddenKey, &isHiddenProperty, NULL)) {
+            hidden = CFBooleanGetValue(isHiddenProperty);
+            CFRelease(isHiddenProperty);
+        }
    }
-    CFRelease(url);
-    return errorOrHidden;
+    return hidden;
 }

- (BOOL)panel:(id)sender shouldShowFilename:(NSString *)filename
+- (BOOL)panel:(id)sender shouldEnableURL:(NSURL *)url
 {
    Q_UNUSED(sender);

+    NSString *filename = [url path];
    if ([filename length] == 0)
        return NO;

@ -353,7 +353,7 @@ static QString strippedText(QString s)
            return NO;
    }
    if (!(filter & QDir::Hidden)
-        && (qtFileName.startsWith(QLatin1Char('.')) || [self isHiddenFile:filename isDir:isDir]))
+        && (qtFileName.startsWith(QLatin1Char('.')) || [self isHiddenFileAtURL:url]))
            return NO;

    return YES;
@ -446,11 +446,15 @@ static QString strippedText(QString s)
    [mSavePanel setTitle:mOptions->windowTitle().toNSString()];
    [mPopUpButton setHidden:chooseDirsOnly];    // TODO hide the whole sunken pane instead?

-    QStringList ext = [self acceptableExtensionsForSave];
-    const QString defaultSuffix = mOptions->defaultSuffix();
-    if (!ext.isEmpty() && !defaultSuffix.isEmpty())
-        ext.prepend(defaultSuffix);
-    [mSavePanel setAllowedFileTypes:ext.isEmpty() ? nil : qt_mac_QStringListToNSMutableArray(ext)];
+    if (mOptions->acceptMode() == QFileDialogOptions::AcceptSave) {
+        QStringList ext = [self acceptableExtensionsForSave];
+        const QString defaultSuffix = mOptions->defaultSuffix();
+        if (!ext.isEmpty() && !defaultSuffix.isEmpty())
+            ext.prepend(defaultSuffix);
+        [mSavePanel setAllowedFileTypes:ext.isEmpty() ? nil : qt_mac_QStringListToNSMutableArray(ext)];
+    } else {
+        [mOpenPanel setAllowedFileTypes:nil]; // delegate panel:shouldEnableURL: does the file filtering for NSOpenPanel
+    }

    if ([mSavePanel respondsToSelector:@selector(isVisible)] && [mSavePanel isVisible]) {
        if ([mSavePanel respondsToSelector:@selector(validateVisibleColumns)])
--- a/src/plugins/platforms/cocoa/qcocoaintegration.mm
+++ b/src/plugins/platforms/cocoa/qcocoaintegration.mm
@ -69,6 +69,9 @@ static void initResources()

 QT_BEGIN_NAMESPACE

+class QCoreTextFontEngine;
+class QFontEngineFT;
+
 QCocoaScreen::QCocoaScreen(int screenIndex)
    : QPlatformScreen(), m_screenIndex(screenIndex), m_refreshRate(60.0)
 {
@ -302,7 +305,7 @@ QCocoaIntegration *QCocoaIntegration::mInstance = 0;

 QCocoaIntegration::QCocoaIntegration(const QStringList &paramList)
    : mOptions(parseOptions(paramList))
-    , mFontDb(new QCoreTextFontDatabase(mOptions.testFlag(UseFreeTypeFontEngine)))
+    , mFontDb(0)
 #ifndef QT_NO_ACCESSIBILITY
    , mAccessibility(new QCocoaAccessibility)
 #endif
@ -318,6 +321,13 @@ QCocoaIntegration::QCocoaIntegration(const QStringList &paramList)
        qWarning("Creating multiple Cocoa platform integrations is not supported");
    mInstance = this;

+#ifndef QT_NO_FREETYPE
+    if (mOptions.testFlag(UseFreeTypeFontEngine))
+        mFontDb.reset(new QCoreTextFontDatabaseEngineFactory<QFontEngineFT>);
+    else
+#endif
+        mFontDb.reset(new QCoreTextFontDatabaseEngineFactory<QCoreTextFontEngine>);
+
    QString icStr = QPlatformInputContextFactory::requested();
    icStr.isNull() ? mInputContext.reset(new QCocoaInputContext)
                   : mInputContext.reset(QPlatformInputContextFactory::create(icStr));
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_emu/qeglfsemulatorintegration.cpp
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_emu/qeglfsemulatorintegration.cpp
@ -97,7 +97,9 @@ void QEglFSEmulatorIntegration::screenInit()
                }
            }
        } else {
-            qWarning() << "eglfs_emu: Failed to parse display info JSON with error: " << error.errorString();
+            qWarning() << "eglfs_emu: Failed to parse display info JSON with error: " << error.errorString()
+                       << " at offset " << error.offset << " : " << displaysInfo;
+
        }
    } else {
        qFatal("EGL library doesn't support Emulator extensions");
--- a/src/plugins/platforms/ios/qiosintegration.mm
+++ b/src/plugins/platforms/ios/qiosintegration.mm
@ -69,13 +69,15 @@

 QT_BEGIN_NAMESPACE

+class QCoreTextFontEngine;
+
 QIOSIntegration *QIOSIntegration::instance()
 {
    return static_cast<QIOSIntegration *>(QGuiApplicationPrivate::platformIntegration());
 }

 QIOSIntegration::QIOSIntegration()
-    : m_fontDatabase(new QCoreTextFontDatabase)
+    : m_fontDatabase(new QCoreTextFontDatabaseEngineFactory<QCoreTextFontEngine>)
 #if !defined(Q_OS_TVOS) && !defined(QT_NO_CLIPBOARD)
    , m_clipboard(new QIOSClipboard)
 #endif
--- a/src/plugins/platforms/minimal/qminimalintegration.cpp
+++ b/src/plugins/platforms/minimal/qminimalintegration.cpp
@ -44,7 +44,7 @@
 #include <QtGui/private/qguiapplication_p.h>
 #include <qpa/qplatformwindow.h>

-#include <QtFontDatabaseSupport/private/qbasicfontdatabase_p.h>
+#include <QtFontDatabaseSupport/private/qfreetypefontdatabase_p.h>
 #if defined(Q_OS_WINRT)
 #  include <QtFontDatabaseSupport/private/qwinrtfontdatabase_p.h>
 #elif defined(Q_OS_WIN)
@ -69,6 +69,8 @@

 QT_BEGIN_NAMESPACE

+class QCoreTextFontEngine;
+
 static const char debugBackingStoreEnvironmentVariable[] = "QT_DEBUG_BACKINGSTORE";

 static inline unsigned parseOptions(const QStringList &paramList)
@ -140,7 +142,7 @@ QPlatformFontDatabase *QMinimalIntegration::fontDatabase() const
            m_fontDatabase = new QWindowsFontDatabase;
        }
 #elif defined(Q_OS_DARWIN)
-        m_fontDatabase = new QCoreTextFontDatabase;
+        m_fontDatabase = new QCoreTextFontDatabaseEngineFactory<QCoreTextFontEngine>;
 #else
        m_fontDatabase = QPlatformIntegration::fontDatabase();
 #endif
--- a/src/plugins/platforms/offscreen/qoffscreenintegration.cpp
+++ b/src/plugins/platforms/offscreen/qoffscreenintegration.cpp
@ -49,7 +49,7 @@
 #include <QtFontDatabaseSupport/private/qgenericunixfontdatabase_p.h>
 #endif
 #elif defined(Q_OS_WIN)
-#include <QtFontDatabaseSupport/private/qbasicfontdatabase_p.h>
+#include <QtFontDatabaseSupport/private/qfreetypefontdatabase_p.h>
 #ifndef Q_OS_WINRT
 #include <QtCore/private/qeventdispatcher_win_p.h>
 #else
@ -103,7 +103,7 @@ QOffscreenIntegration::QOffscreenIntegration()
    m_fontDatabase.reset(new QGenericUnixFontDatabase());
 #endif
 #elif defined(Q_OS_WIN)
-    m_fontDatabase.reset(new QBasicFontDatabase());
+    m_fontDatabase.reset(new QFreeTypeFontDatabase());
 #endif

 #ifndef QT_NO_DRAGANDDROP
--- a/src/plugins/platforms/offscreen/qoffscreenwindow.cpp
+++ b/src/plugins/platforms/offscreen/qoffscreenwindow.cpp
@ -157,10 +157,13 @@ QMargins QOffscreenWindow::frameMargins() const

 void QOffscreenWindow::setFrameMarginsEnabled(bool enabled)
 {
-    if (enabled && !(window()->flags() & Qt::FramelessWindowHint))
+    if (enabled
+        && !(window()->flags() & Qt::FramelessWindowHint)
+        && (parent() == nullptr)) {
        m_margins = QMargins(2, 2, 2, 2);
-    else
+    } else {
        m_margins = QMargins(0, 0, 0, 0);
+    }
 }

 void QOffscreenWindow::setWindowState(Qt::WindowStates state)
--- a/src/plugins/platforms/vnc/qvncintegration.cpp
+++ b/src/plugins/platforms/vnc/qvncintegration.cpp
@ -1,34 +1,37 @@
 /****************************************************************************
 **
-** Copyright (C) 2015 The Qt Company Ltd.
-** Contact: http://www.qt.io/licensing/
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
 **
-** This file is part of the FOO module of the Qt Toolkit.
+** This file is part of the plugins of the Qt Toolkit.
 **
-** $QT_BEGIN_LICENSE:LGPL3$
+** $QT_BEGIN_LICENSE:LGPL$
 ** Commercial License Usage
 ** Licensees holding valid commercial Qt licenses may use this file in
 ** accordance with the commercial license agreement provided with the
 ** Software or, alternatively, in accordance with the terms contained in
 ** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see http://www.qt.io/terms-conditions. For further
-** information use the contact form at http://www.qt.io/contact-us.
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
 **
 ** GNU Lesser General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU Lesser
 ** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
 ** packaging of this file. Please review the following information to
 ** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl.html.
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
 **
 ** GNU General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or later as published by the Free
-** Software Foundation and appearing in the file LICENSE.GPL included in
-** the packaging of this file. Please review the following information to
-** ensure the GNU General Public License version 2.0 requirements will be
-** met: http://www.gnu.org/licenses/gpl-2.0.html.
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
 **
 ** $QT_END_LICENSE$
 **
--- a/src/plugins/platforms/winrt/qwinrtdrag.cpp
+++ b/src/plugins/platforms/winrt/qwinrtdrag.cpp
@ -1,34 +1,37 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: http://www.qt.io/licensing/
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the plugins of the Qt Toolkit.
 **
-** $QT_BEGIN_LICENSE:LGPL3$
+** $QT_BEGIN_LICENSE:LGPL$
 ** Commercial License Usage
 ** Licensees holding valid commercial Qt licenses may use this file in
 ** accordance with the commercial license agreement provided with the
 ** Software or, alternatively, in accordance with the terms contained in
 ** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see http://www.qt.io/terms-conditions. For further
-** information use the contact form at http://www.qt.io/contact-us.
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
 **
 ** GNU Lesser General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU Lesser
 ** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
 ** packaging of this file. Please review the following information to
 ** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl.html.
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
 **
 ** GNU General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or later as published by the Free
-** Software Foundation and appearing in the file LICENSE.GPL included in
-** the packaging of this file. Please review the following information to
-** ensure the GNU General Public License version 2.0 requirements will be
-** met: http://www.gnu.org/licenses/gpl-2.0.html.
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
 **
 ** $QT_END_LICENSE$
 **
--- a/src/plugins/platforms/winrt/qwinrtdrag.h
+++ b/src/plugins/platforms/winrt/qwinrtdrag.h
@ -1,34 +1,37 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: http://www.qt.io/licensing/
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the plugins of the Qt Toolkit.
 **
-** $QT_BEGIN_LICENSE:LGPL3$
+** $QT_BEGIN_LICENSE:LGPL$
 ** Commercial License Usage
 ** Licensees holding valid commercial Qt licenses may use this file in
 ** accordance with the commercial license agreement provided with the
 ** Software or, alternatively, in accordance with the terms contained in
 ** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see http://www.qt.io/terms-conditions. For further
-** information use the contact form at http://www.qt.io/contact-us.
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
 **
 ** GNU Lesser General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU Lesser
 ** General Public License version 3 as published by the Free Software
-** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
 ** packaging of this file. Please review the following information to
 ** ensure the GNU Lesser General Public License version 3 requirements
-** will be met: https://www.gnu.org/licenses/lgpl.html.
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
 **
 ** GNU General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 2.0 or later as published by the Free
-** Software Foundation and appearing in the file LICENSE.GPL included in
-** the packaging of this file. Please review the following information to
-** ensure the GNU General Public License version 2.0 requirements will be
-** met: http://www.gnu.org/licenses/gpl-2.0.html.
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
 **
 ** $QT_END_LICENSE$
 **
--- a/src/plugins/platforms/xcb/gl_integrations/xcb_glx/qglxintegration.cpp
+++ b/src/plugins/platforms/xcb/gl_integrations/xcb_glx/qglxintegration.cpp
@ -693,7 +693,7 @@ void QGLXContext::queryDummyContext()
    if (const char *renderer = (const char *) glGetString(GL_RENDERER)) {
        for (int i = 0; qglx_threadedgl_blacklist_renderer[i]; ++i) {
            if (strstr(renderer, qglx_threadedgl_blacklist_renderer[i]) != 0) {
-                qCInfo(lcQpaGl).nospace() << "Multithreaded OpenGL disabled: "
+                qCDebug(lcQpaGl).nospace() << "Multithreaded OpenGL disabled: "
                                             "blacklisted renderer \""
                                          << qglx_threadedgl_blacklist_renderer[i]
                                          << "\"";
@ -706,7 +706,7 @@ void QGLXContext::queryDummyContext()
    if (glxvendor) {
        for (int i = 0; qglx_threadedgl_blacklist_vendor[i]; ++i) {
            if (strstr(glxvendor, qglx_threadedgl_blacklist_vendor[i]) != 0) {
-                qCInfo(lcQpaGl).nospace() << "Multithreaded OpenGL disabled: "
+                qCDebug(lcQpaGl).nospace() << "Multithreaded OpenGL disabled: "
                                             "blacklisted vendor \""
                                          << qglx_threadedgl_blacklist_vendor[i]
                                          << "\"";
@ -722,7 +722,7 @@ void QGLXContext::queryDummyContext()
        oldContext->makeCurrent(oldSurface);

    if (!m_supportsThreading) {
-        qCInfo(lcQpaGl) << "Force-enable multithreaded OpenGL by setting "
+        qCDebug(lcQpaGl) << "Force-enable multithreaded OpenGL by setting "
                           "environment variable QT_OPENGL_NO_SANITY_CHECK";
    }
 }
--- a/src/plugins/platforms/xcb/qxcbconnection.cpp
+++ b/src/plugins/platforms/xcb/qxcbconnection.cpp
@ -1092,7 +1092,9 @@ void QXcbConnection::handleXcbEvent(xcb_generic_event_t *event)
            break;
        case XCB_SELECTION_REQUEST:
        {
+#if QT_CONFIG(draganddrop) || QT_CONFIG(clipboard)
            xcb_selection_request_event_t *sr = reinterpret_cast<xcb_selection_request_event_t *>(event);
+#endif
 #ifndef QT_NO_DRAGANDDROP
            if (sr->selection == atom(QXcbAtom::XdndSelection))
                m_drag->handleSelectionRequest(sr);
@ -1285,9 +1287,9 @@ void QXcbEventReader::unlock()
    m_mutex.unlock();
 }

-void QXcbConnection::setFocusWindow(QXcbWindow *w)
+void QXcbConnection::setFocusWindow(QWindow *w)
 {
-    m_focusWindow = w;
+    m_focusWindow = w ? static_cast<QXcbWindow *>(w->handle()) : nullptr;
 }
 void QXcbConnection::setMouseGrabber(QXcbWindow *w)
 {
--- a/src/plugins/platforms/xcb/qxcbconnection.h
+++ b/src/plugins/platforms/xcb/qxcbconnection.h
@ -480,7 +480,7 @@ public:
    Qt::MouseButton translateMouseButton(xcb_button_t s);

    QXcbWindow *focusWindow() const { return m_focusWindow; }
-    void setFocusWindow(QXcbWindow *);
+    void setFocusWindow(QWindow *);
    QXcbWindow *mouseGrabber() const { return m_mouseGrabber; }
    void setMouseGrabber(QXcbWindow *);
    QXcbWindow *mousePressWindow() const { return m_mousePressWindow; }
--- a/src/plugins/platforms/xcb/qxcbmime.cpp
+++ b/src/plugins/platforms/xcb/qxcbmime.cpp
@ -44,12 +44,6 @@
 #include <QtCore/QBuffer>
 #include <qdebug.h>

-#include <X11/Xutil.h>
-
-#undef XCB_ATOM_STRING
-#undef XCB_ATOM_PIXMAP
-#undef XCB_ATOM_BITMAP
-
 QT_BEGIN_NAMESPACE

 #if !(defined(QT_NO_DRAGANDDROP) && defined(QT_NO_CLIPBOARD))
--- a/src/plugins/platforms/xcb/qxcbwindow.cpp
+++ b/src/plugins/platforms/xcb/qxcbwindow.cpp
@ -284,6 +284,8 @@ static inline XTextProperty* qstringToXTP(Display *dpy, const QString& s)
        free_prop = false;
 #if QT_CONFIG(textcodec)
    }
+#else
+    Q_UNUSED(dpy);
 #endif
    return &tp;
 }
@ -916,7 +918,7 @@ void QXcbWindow::doFocusIn()
    if (relayFocusToModalWindow())
        return;
    QWindow *w = static_cast<QWindowPrivate *>(QObjectPrivate::get(window()))->eventReceiver();
-    connection()->setFocusWindow(static_cast<QXcbWindow *>(w->handle()));
+    connection()->setFocusWindow(w);
    QWindowSystemInterface::handleWindowActivated(w, Qt::ActiveWindowFocusReason);
 }

@ -924,7 +926,7 @@ static bool focusInPeeker(QXcbConnection *connection, xcb_generic_event_t *event
 {
    if (!event) {
        // FocusIn event is not in the queue, proceed with FocusOut normally.
-        QWindowSystemInterface::handleWindowActivated(0, Qt::ActiveWindowFocusReason);
+        QWindowSystemInterface::handleWindowActivated(nullptr, Qt::ActiveWindowFocusReason);
        return true;
    }
    uint response_type = event->response_type & ~0x80;
@ -949,12 +951,10 @@ static bool focusInPeeker(QXcbConnection *connection, xcb_generic_event_t *event

 void QXcbWindow::doFocusOut()
 {
-    if (relayFocusToModalWindow())
-        return;
-    connection()->setFocusWindow(0);
-    // Do not set the active window to 0 if there is a FocusIn coming.
-    // There is however no equivalent for XPutBackEvent so register a
-    // callback for QXcbConnection instead.
+    connection()->setFocusWindow(nullptr);
+    relayFocusToModalWindow();
+    // Do not set the active window to nullptr if there is a FocusIn coming.
+    // The FocusIn handler will update QXcbConnection::setFocusWindow() accordingly.
    connection()->addPeekFunc(focusInPeeker);
 }

@ -2746,14 +2746,14 @@ void QXcbWindow::handleXEmbedMessage(const xcb_client_message_event_t *event)
            reason = Qt::OtherFocusReason;
            break;
        }
-        connection()->setFocusWindow(static_cast<QXcbWindow*>(window()->handle()));
+        connection()->setFocusWindow(window());
        QWindowSystemInterface::handleWindowActivated(window(), reason);
        break;
    case XEMBED_FOCUS_OUT:
        if (window() == QGuiApplication::focusWindow()
            && !activeWindowChangeQueued(window())) {
-            connection()->setFocusWindow(0);
-            QWindowSystemInterface::handleWindowActivated(0);
+            connection()->setFocusWindow(nullptr);
+            QWindowSystemInterface::handleWindowActivated(nullptr);
        }
        break;
    }
--- a/src/sql/kernel/qsqldatabase.cpp
+++ b/src/sql/kernel/qsqldatabase.cpp
@ -695,6 +695,9 @@ void QSqlDatabasePrivate::init(const QString &type)
 /*!
    Destroys the object and frees any allocated resources.

+    \note When the last connection is destroyed, the destructor
+    implicitly calls close() to release the database connection.
+
    \sa close()
 */

--- a/src/widgets/kernel/qlayout.cpp
+++ b/src/widgets/kernel/qlayout.cpp
@ -581,7 +581,7 @@ void QLayoutPrivate::doResize(const QSize &r)
    QWidget *mw = q->parentWidget();
    QRect rect = mw->testAttribute(Qt::WA_LayoutOnEntireRect) ? mw->rect() : mw->contentsRect();
    const int mbTop = rect.top();
-    rect.setTop(rect.top() + mbh);
+    rect.setTop(mbTop + mbh);
    q->setGeometry(rect);
 #ifndef QT_NO_MENUBAR
    if (menubar)
--- a/src/widgets/kernel/qwidget.cpp
+++ b/src/widgets/kernel/qwidget.cpp
@ -6763,12 +6763,12 @@ void QWidget::clearFocus()

 bool QWidget::focusNextPrevChild(bool next)
 {
-    Q_D(QWidget);
    QWidget* p = parentWidget();
    bool isSubWindow = (windowType() == Qt::SubWindow);
    if (!isWindow() && !isSubWindow && p)
        return p->focusNextPrevChild(next);
 #ifndef QT_NO_GRAPHICSVIEW
+    Q_D(QWidget);
    if (d->extra && d->extra->proxyWidget)
        return d->extra->proxyWidget->focusNextPrevChild(next);
 #endif
--- a/src/widgets/styles/qcommonstyle.cpp
+++ b/src/widgets/styles/qcommonstyle.cpp
@ -416,6 +416,8 @@ void QCommonStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *opt, Q
        proxy()->drawItemPixmap(p, opt->rect, Qt::AlignCenter, pixmap);
        break;
    }
+#else
+    Q_UNUSED(d);
 #endif // QT_NO_TABBAR
    case PE_FrameTabWidget:
    case PE_FrameWindow:
@ -2315,6 +2317,9 @@ void QCommonStyle::drawControl(ControlElement element, const QStyleOption *opt,
    default:
        break;
    }
+#if !QT_CONFIG(tabbar) && !QT_CONFIG(itemviews)
+    Q_UNUSED(d);
+#endif
 }

 /*!
@ -3014,6 +3019,7 @@ QRect QCommonStyle::subElementRect(SubElement sr, const QStyleOption *opt,
            r = subElementRect(SE_CheckBoxIndicator, opt, widget);
            break;
        }
+        Q_FALLTHROUGH();
    case SE_ItemViewItemDecoration:
    case SE_ItemViewItemText:
    case SE_ItemViewItemFocusRect:
@ -3058,6 +3064,9 @@ QRect QCommonStyle::subElementRect(SubElement sr, const QStyleOption *opt,
        break;
    }
    return r;
+#if !QT_CONFIG(tabwidget) && !QT_CONFIG(itemviews)
+    Q_UNUSED(d);
+#endif
 }

 #ifndef QT_NO_DIAL
@ -4186,11 +4195,13 @@ QRect QCommonStyle::subControlRect(ComplexControl cc, const QStyleOptionComplex
            case SC_TitleBarContextHelpButton:
                if (tb->titleBarFlags & Qt::WindowContextHelpButtonHint)
                    offset += delta;
+                Q_FALLTHROUGH();
            case SC_TitleBarMinButton:
                if (!isMinimized && (tb->titleBarFlags & Qt::WindowMinimizeButtonHint))
                    offset += delta;
                else if (sc == SC_TitleBarMinButton)
                    break;
+                Q_FALLTHROUGH();
            case SC_TitleBarNormalButton:
                if (isMinimized && (tb->titleBarFlags & Qt::WindowMinimizeButtonHint))
                    offset += delta;
@ -4198,21 +4209,25 @@ QRect QCommonStyle::subControlRect(ComplexControl cc, const QStyleOptionComplex
                    offset += delta;
                else if (sc == SC_TitleBarNormalButton)
                    break;
+                Q_FALLTHROUGH();
            case SC_TitleBarMaxButton:
                if (!isMaximized && (tb->titleBarFlags & Qt::WindowMaximizeButtonHint))
                    offset += delta;
                else if (sc == SC_TitleBarMaxButton)
                    break;
+                Q_FALLTHROUGH();
            case SC_TitleBarShadeButton:
                if (!isMinimized && (tb->titleBarFlags & Qt::WindowShadeButtonHint))
                    offset += delta;
                else if (sc == SC_TitleBarShadeButton)
                    break;
+                Q_FALLTHROUGH();
            case SC_TitleBarUnshadeButton:
                if (isMinimized && (tb->titleBarFlags & Qt::WindowShadeButtonHint))
                    offset += delta;
                else if (sc == SC_TitleBarUnshadeButton)
                    break;
+                Q_FALLTHROUGH();
            case SC_TitleBarCloseButton:
                if (tb->titleBarFlags & Qt::WindowSystemMenuHint)
                    offset += delta;
@ -4357,6 +4372,9 @@ QRect QCommonStyle::subControlRect(ComplexControl cc, const QStyleOptionComplex
     default:
        qWarning("QCommonStyle::subControlRect: Case %d not handled", cc);
    }
+#if !QT_CONFIG(slider) && !QT_CONFIG(spinbox) && !QT_CONFIG(toolbutton) && !QT_CONFIG(groupbox)
+    Q_UNUSED(widget);
+#endif
    return ret;
 }

@ -5278,6 +5296,7 @@ static inline QString clearText16IconPath()
 }
 #endif // !QT_NO_IMAGEFORMAT_PNG

+#if defined(Q_OS_WIN) || QT_CONFIG(imageformat_png)
 static QIcon clearTextIcon(bool rtl)
 {
    const QString directionalThemeName = rtl
@ -5301,6 +5320,7 @@ static QIcon clearTextIcon(bool rtl)
 #endif // !QT_NO_IMAGEFORMAT_PNG
    return icon;
 }
+#endif

 /*! \reimp */
 QPixmap QCommonStyle::standardPixmap(StandardPixmap sp, const QStyleOption *option,
@ -5645,6 +5665,9 @@ QPixmap QCommonStyle::standardPixmap(StandardPixmap sp, const QStyleOption *opti
    }
 #endif //QT_NO_IMAGEFORMAT_XPM

+#if !QT_CONFIG(imageformat_png) && !QT_CONFIG(imageformat_xpm) && !QT_CONFIG(imageformat_png)
+    Q_UNUSED(rtl);
+#endif

    return QPixmap();
 }
--- a/src/widgets/styles/qfusionstyle.cpp
+++ b/src/widgets/styles/qfusionstyle.cpp
@ -908,8 +908,6 @@ void QFusionStyle::drawPrimitive(PrimitiveElement elem,
            return;
        }

-        BEGIN_STYLE_PIXMAPCACHE(QString::fromLatin1("pushbutton-%1").arg(isDefault))
-                r = rect.adjusted(0, 1, -1, 0);

        bool isEnabled = option->state & State_Enabled;
        bool hasFocus = (option->state & State_HasFocus && option->state & State_KeyboardFocusChange);
@ -923,6 +921,9 @@ void QFusionStyle::drawPrimitive(PrimitiveElement elem,
        if (isDefault)
            buttonColor = mergedColors(buttonColor, highlightedOutline.lighter(130), 90);

+        BEGIN_STYLE_PIXMAPCACHE(QStringLiteral("pushbutton-") + buttonColor.name(QColor::HexArgb))
+        r = rect.adjusted(0, 1, -1, 0);
+
        p->setRenderHint(QPainter::Antialiasing, true);
        p->translate(0.5, -0.5);

@ -1953,9 +1954,13 @@ void QFusionStyle::drawComplexControl(ComplexControl control, const QStyleOption

    Q_D (const QFusionStyle);

+#if QT_CONFIG(spinbox) || QT_CONFIG(slider)
    QColor buttonColor = d->buttonColor(option->palette);
+#endif
+#if QT_CONFIG(slider)
    QColor gradientStartColor = buttonColor.lighter(118);
    QColor gradientStopColor = buttonColor;
+#endif
    QColor outline = d->outline(option->palette);

    QColor alphaCornerColor;
@ -3575,11 +3580,13 @@ QRect QFusionStyle::subControlRect(ComplexControl control, const QStyleOptionCom
            case SC_TitleBarContextHelpButton:
                if (tb->titleBarFlags & Qt::WindowContextHelpButtonHint)
                    offset += delta;
+                Q_FALLTHROUGH();
            case SC_TitleBarMinButton:
                if (!isMinimized && (tb->titleBarFlags & Qt::WindowMinimizeButtonHint))
                    offset += delta;
                else if (sc == SC_TitleBarMinButton)
                    break;
+                Q_FALLTHROUGH();
            case SC_TitleBarNormalButton:
                if (isMinimized && (tb->titleBarFlags & Qt::WindowMinimizeButtonHint))
                    offset += delta;
@ -3587,21 +3594,25 @@ QRect QFusionStyle::subControlRect(ComplexControl control, const QStyleOptionCom
                    offset += delta;
                else if (sc == SC_TitleBarNormalButton)
                    break;
+                Q_FALLTHROUGH();
            case SC_TitleBarMaxButton:
                if (!isMaximized && (tb->titleBarFlags & Qt::WindowMaximizeButtonHint))
                    offset += delta;
                else if (sc == SC_TitleBarMaxButton)
                    break;
+                Q_FALLTHROUGH();
            case SC_TitleBarShadeButton:
                if (!isMinimized && (tb->titleBarFlags & Qt::WindowShadeButtonHint))
                    offset += delta;
                else if (sc == SC_TitleBarShadeButton)
                    break;
+                Q_FALLTHROUGH();
            case SC_TitleBarUnshadeButton:
                if (isMinimized && (tb->titleBarFlags & Qt::WindowShadeButtonHint))
                    offset += delta;
                else if (sc == SC_TitleBarUnshadeButton)
                    break;
+                Q_FALLTHROUGH();
            case SC_TitleBarCloseButton:
                if (tb->titleBarFlags & Qt::WindowSystemMenuHint)
                    offset += delta;
--- a/src/widgets/styles/qpixmapstyle.cpp
+++ b/src/widgets/styles/qpixmapstyle.cpp
@ -204,6 +204,9 @@ void QPixmapStyle::polish(QWidget *widget)
 #if QT_CONFIG(scrollbar)
    if (qobject_cast<QScrollBar*>(widget))
        widget->setAttribute(Qt::WA_OpaquePaintEvent, false);
+#endif
+#if !QT_CONFIG(progressbar) && !QT_CONFIG(combobox)
+    Q_UNUSED(d);
 #endif
    QCommonStyle::polish(widget);
 }
@ -929,6 +932,10 @@ void QPixmapStyle::drawSlider(const QStyleOptionComplex *option,
            painter->drawPixmap(handle, d->pixmaps.value(pix).pixmap);
        }
    }
+#else
+    Q_UNUSED(option);
+    Q_UNUSED(painter);
+    Q_UNUSED(widget);
 #endif // QT_CONFIG(slider)
 }

@ -968,6 +975,10 @@ void QPixmapStyle::drawScrollBar(const QStyleOptionComplex *option,
                ? SB_Horizontal : SB_Vertical;
        drawCachedPixmap(control, rect, painter);
    }
+#else
+    Q_UNUSED(option);
+    Q_UNUSED(painter);
+    Q_UNUSED(widget);
 #endif // QT_CONFIG(slider)
 }

@ -1044,6 +1055,9 @@ QSize QPixmapStyle::sliderSizeFromContents(const QStyleOption *option,
    else
        return QSize(desc.size.width(), result.height());
 #else // QT_CONFIG(slider)
+    Q_UNUSED(option);
+    Q_UNUSED(contentsSize);
+    Q_UNUSED(widget);
    return QSize();
 #endif // QT_CONFIG(slider)
 }
@ -1160,6 +1174,9 @@ QRect QPixmapStyle::scrollBarSubControlRect(const QStyleOptionComplex *option,
            }
        }
    }
+#else
+    Q_UNUSED(option);
+    Q_UNUSED(sc);
 #endif // QT_CONFIG(slider)
    return QRect();
 }
--- a/src/widgets/styles/qstylehelper.cpp
+++ b/src/widgets/styles/qstylehelper.cpp
@ -415,6 +415,8 @@ QColor backgroundColor(const QPalette &pal, const QWidget* widget)
    if (qobject_cast<const QScrollBar *>(widget) && widget->parent() &&
            qobject_cast<const QAbstractScrollArea *>(widget->parent()->parent()))
        return widget->parentWidget()->parentWidget()->palette().color(QPalette::Base);
+#else
+    Q_UNUSED(widget);
 #endif
    return pal.color(QPalette::Base);
 }
--- a/src/widgets/styles/qstylesheetstyle.cpp
+++ b/src/widgets/styles/qstylesheetstyle.cpp
@ -4376,7 +4376,7 @@ void QStyleSheetStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *op
            break;
        }
 #endif
-    //fall tghought
+        Q_FALLTHROUGH();
    case PE_PanelMenu:
    case PE_PanelStatusBar:
        if(rule.hasDrawable()) {
@ -4935,7 +4935,7 @@ QSize QStyleSheetStyle::sizeFromContents(ContentsType ct, const QStyleOption *op
    case CT_ToolButton:
        if (rule.hasBox() || !rule.hasNativeBorder() || !rule.baseStyleCanDraw())
            sz += QSize(3, 3); // ### broken QToolButton
-        //fall thought
+        Q_FALLTHROUGH();
    case CT_ComboBox:
    case CT_PushButton:
        if (rule.hasBox() || !rule.hasNativeBorder()) {
--- a/src/widgets/styles/qwindowsstyle.cpp
+++ b/src/widgets/styles/qwindowsstyle.cpp
@ -1734,6 +1734,8 @@ void QWindowsStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPai
                    step = (animation->animationStep() / 3) % chunkCount;
                else
                    d->startAnimation(new QProgressStyleAnimation(d->animationFps, opt->styleObject));
+#else
+                Q_UNUSED(d);
 #endif
                int chunksInRow = 5;
                int myY = pbBits.rect.y();
--- a/src/widgets/widgets/qabstractspinbox.cpp
+++ b/src/widgets/widgets/qabstractspinbox.cpp
@ -980,6 +980,7 @@ void QAbstractSpinBox::keyPressEvent(QKeyEvent *event)
    case Qt::Key_PageDown:
        steps *= 10;
        isPgUpOrDown = true;
+        Q_FALLTHROUGH();
    case Qt::Key_Up:
    case Qt::Key_Down: {
 #ifdef QT_KEYPAD_NAVIGATION
@ -2115,6 +2116,7 @@ int QAbstractSpinBoxPrivate::variantCompare(const QVariant &arg1, const QVariant
    case QVariant::Invalid:
        if (arg2.type() == QVariant::Invalid)
            return 0;
+        Q_FALLTHROUGH();
    default:
        Q_ASSERT_X(0, "QAbstractSpinBoxPrivate::variantCompare",
                   qPrintable(QString::fromLatin1("Internal error 3 (%1 %2)").
--- a/src/widgets/widgets/qdatetimeedit.cpp
+++ b/src/widgets/widgets/qdatetimeedit.cpp
@ -1113,6 +1113,7 @@ void QDateTimeEdit::keyPressEvent(QKeyEvent *event)
                       && !(event->modifiers() & ~(Qt::ShiftModifier|Qt::KeypadModifier));
            break;
        }
+        Q_FALLTHROUGH();
    case Qt::Key_Left:
    case Qt::Key_Right:
        if (event->key() == Qt::Key_Left || event->key() == Qt::Key_Right) {
--- a/Show More
+++ b/Show More