Update README.md

6.6.0

.cmake.conf

@@ -5,10 +5,9 @@
 # (directly by qtbase) we actually add the extra definitions
 if (NOT DEFINED QT_SUPERBUILD OR DEFINED QT_REPO_MODULE_VERSION)
     set(QT_EXTRA_INTERNAL_TARGET_DEFINES "QT_LEAN_HEADERS=1")
-    list(APPEND QT_EXTRA_INTERNAL_TARGET_DEFINES "QT_NO_AS_CONST=1")
 endif()
 
-set(QT_REPO_MODULE_VERSION "6.5.1")
+set(QT_REPO_MODULE_VERSION "6.6.0")
 set(QT_REPO_MODULE_PRERELEASE_VERSION_SEGMENT "alpha1")
 
 set(QT_COPYRIGHT_YEAR "2023")
@@ -17,12 +16,14 @@ set(QT_COPYRIGHT "Copyright (C) ${QT_COPYRIGHT_YEAR} The Qt Company Ltd and othe
 # Minimum requirement for building Qt
 set(QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT_SHARED "3.16")
 set(QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT_STATIC "3.21")
+set(QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT_APPLE "3.21")
 
 # Minimum requirement for consuming Qt in a user project.
 # This might be different in the future, e.g. be lower than the requirement for
 # building Qt.
 set(QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT_SHARED "3.16")
 set(QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT_STATIC "3.21")
+set(QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT_APPLE "3.21")
 
 # Policy settings for commands defined by qtbase. These will also be injected
 # into the top level policy scope of each Qt module when building Qt so that

.gitattributes

@@ -1,2 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto

.github/workflows/ninja-build.yml

@@ -1,154 +0,0 @@
-# Smoke builds
-#
-# The goal of this workflow is to finish as fast as possible. Therefore some
-# choices have been made:
-# - no optimizations
-# - link to system-provided libraries instead of building
-#   bundled 3rd party libraries
-# - ccache
-
-name: Smoke build
-
-on: push
-
-env:
-  BRANCH:     dev
-  BRANCH_REF: refs/heads/dev
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - name: ubuntu-20.04
-            os:   ubuntu-20.04
-            # NOTE: system libmd4c is not detected
-            deps:  libgl-dev libglu-dev 'libxcb*-dev' libx11-xcb-dev libxkbcommon-x11-dev libpcre2-dev libz-dev libfreetype6-dev libpng-dev libjpeg-dev libsqlite3-dev libharfbuzz-dev libb2-dev libdouble-conversion-dev libmd4c-dev
-            tools: ninja-build ccache
-            install_cmd: sudo apt-get -y install
-            configure_flags: -xcb -system-sqlite -system-pcre -system-zlib -system-freetype -system-libpng -system-libjpeg -system-harfbuzz -system-libb2 -system-doubleconversion -system-libmd4c
-          - name: ubuntu-18.04
-            os:   ubuntu-18.04
-            # NOTE: system libb2 is not detected because version < 0.98.1 lacks pkg-config module
-            # NOTE: system libharfbuzz is not detected because system has old version
-            deps:  libgl-dev libglu-dev 'libxcb*-dev' libx11-xcb-dev libxkbcommon-x11-dev libpcre2-dev libz-dev libfreetype6-dev libpng-dev libjpeg-dev libsqlite3-dev libharfbuzz-dev libb2-dev libdouble-conversion-dev
-            tools: ninja-build ccache gcc-10
-            install_cmd: sudo apt-get -y install
-            configure_flags: -xcb -system-sqlite -system-pcre -system-zlib -system-freetype -system-libpng -system-libjpeg -system-harfbuzz -system-libb2 -system-doubleconversion
-          - name: macos-10.15
-            os:   macos-10.15
-            deps:  jpeg sqlite libpng pcre2 harfbuzz freetype libb2 double-conversion
-            tools: ninja ccache pkg-config
-            install_cmd: HOMEBREW_NO_INSTALL_CLEANUP=1 brew install
-            # Specifically on macOS pkg_config has to be manually turned on otherwise libraries under /usr/local are not detected.
-            configure_flags: -pkg-config -system-sqlite -system-pcre -system-zlib -system-freetype -system-libpng -system-libjpeg -system-harfbuzz -system-libb2 -system-doubleconversion
-          - name: windows-2019
-            os:   windows-2019
-            install_cmd: choco install
-            install_cmd_postfix: --yes --no-progress
-            # Chocolatey sqlite package does not come with headers, so we build with bundled sqlite.
-            #deps: sqlite
-            # ccache installed separately later in order to force version
-            tools: ninja
-            # We don't want the system headers / libraries from Strawberry Perl while compiling with MinGW 8.1.0
-            configure_flags: -qt-sqlite -qt-pcre -qt-zlib -qt-freetype -qt-libpng -qt-libjpeg -qt-harfbuzz -no-feature-sql-psql -no-feature-sql-mysql -no-feature-sql-odbc
-    runs-on: ${{ matrix.os }}
-
-
-    steps:
-
-    - name: prepare Linux
-      if: runner.os == 'Linux'
-      run: |
-        sudo apt-get update
-        sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-10 100
-        sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-10 100
-    - name: prepare macOS
-      if: runner.os == 'macOS'
-      run: echo noop
-    - name: prepare Windows
-      if: runner.os == 'Windows'
-      # Header pthread.h from postgres is included and creates issues.
-      # Also library zlib.lib is linked instead of the system one.
-      run: |
-        rm -rf "C:/Program Files/PostgreSQL/"
-        choco install ccache --version 3.7.12 --yes --no-progress --not-silent --verbose --debug
-
-    - uses: actions/checkout@v2
-      with:
-        path: source
-
-    - name: restore ccache
-      id: ccache
-      uses: actions/cache@v2
-      with:
-        path: ${{ runner.temp }}/ccache
-        # "github.run_id" is unique, which causes the cache to always get
-        # saved at the end of a successful run.
-        key:  ccache-${{ matrix.os }}-${{ github.ref }}-${{ github.run_id }}
-        # As the unique "key" above will never be found in the cache when the
-        # job starts, we need these broader "restore-keys" in order to match
-        # and restore the most recent cache.
-        restore-keys: |
-          ccache-${{ matrix.os }}-${{ github.ref }}-
-          ccache-${{ matrix.os }}-${{ env.BRANCH_REF }}-
-          ccache-${{ matrix.os }}-refs/heads/dev-
-          ccache-${{ matrix.os }}-
-
-    - name: install build dependencies
-      run:  ${{ matrix.install_cmd }}  ${{ matrix.deps }}  ${{ matrix.install_cmd_postfix }}
-      if: matrix.deps != ''
-    - name: install compiler tools
-      run:  ${{ matrix.install_cmd }}  ${{ matrix.tools }}  ${{ matrix.install_cmd_postfix }}
-    - name: configure ccache
-      run: |
-        ccache --set-config sloppiness=file_macro,time_macros
-        ccache --set-config cache_dir='${{ runner.temp }}'/ccache
-        ccache --set-config compression=true
-        ccache --set-config max_size=1G
-    - name: print versions and environment
-      run: |
-        gcc --version    | head -1
-        cmake --version  | head -1
-        echo Ninja `ninja --version`
-        { ninja --help || true ; } 2>&1 | grep "run N jobs in parallel"
-        ccache --version | head -1
-        ccache --show-config  ||  echo 'Old ccache version does not support --show-config'
-        echo Environment:
-        printenv
-
-    - name: make build directory
-      run:  mkdir build
-    - name: configure
-      working-directory: build
-      run:  "../source/configure -opensource -confirm-license -ccache -no-pch
-        -debug -nomake tests -nomake examples
-        -prefix '${{ runner.temp }}'/install_dir
-        ${{ matrix.configure_flags }}"
-    - name: ninja
-      working-directory: build
-      run: ninja
-
-    - name: various stats
-      # Print ccache utilization statistics, then reset them.
-      run: |
-        ccache -s
-        ccache -x 2>/dev/null || true
-        ccache -z
-
-    - name: print logfiles and other info in case of failure
-      if: ${{ failure() }}
-      run: |
-        echo ==== CMakeOutput.log ====
-        cat build/CMakeFiles/CMakeOutput.log
-        echo
-        echo ==== CMakeError.log ====
-        cat build/CMakeFiles/CMakeError.log
-        echo ==== CMakeCache.txt ====
-        cat build/CMakeCache.txt

.release-timestamp

@@ -1 +1 @@
-QT_PACKAGEDATE_STR=2023-05-22
+QT_PACKAGEDATE_STR=2023-10-04

.tag

@@ -1 +1 @@
-55aee8697512af105dfefabc1e2ec41d4df1e45e
+33f5e985e480283bb0ca9dea5f82643e825ba87c

CMakeLists.txt

@@ -1,8 +1,6 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: BSD-3-Clause
 
-# special case skip regeneration
-
 # Need an explicit call at the top level. This is the absolute minimum version
 # needed to configure the project with any combination of enabled features.
 # The call to qt_build_repo_begin() will upgrade policies further.
@@ -40,11 +38,26 @@ function(qt_internal_check_if_path_has_symlinks path)
         endwhile()
     endif()
     if(is_symlink)
-        message(FATAL_ERROR "The path \"${path}\" contains symlinks. \
-            This is not supported. Possible solutions:
-            - map directories using a transparent mechanism such as mount --bind
-            - pass the real path of the build directory to CMake, e.g. using \
-            cd $(realpath <path>) before invoking cmake <source_dir>.")
+        set(possible_solutions_for_resolving_symlink [[
+    - Map directories using a transparent mechanism such as mount --bind
+    - Pass the real path of the build directory to CMake, e.g. using
+      cd $(realpath <path>) before invoking cmake <source_dir>.
+            ]])
+        if(QT_ALLOW_SYMLINK_IN_PATHS)
+            # In some cases, e.g., Homebrew, it is beneficial to skip this check.
+            # Before this, Homebrew had to patch this out to be able to get their build.
+            message(WARNING
+                "The path \"${path}\" contains symlinks. "
+                "This is not recommended, and it may lead to unexpected issues. If you do "
+                "not have a good reason for enabling 'QT_ALLOW_SYMLINK_IN_PATHS', disable "
+                "it, and follow one of the following solutions: \n"
+                "${possible_solutions_for_resolving_symlink} ")
+        else()
+            message(FATAL_ERROR
+                "The path \"${path}\" contains symlinks. "
+                "This is not supported. Possible solutions: \n"
+                "${possible_solutions_for_resolving_symlink} ")
+        endif()
     endif()
 endfunction()
 qt_internal_check_if_path_has_symlinks("${CMAKE_BINARY_DIR}")

README.md

@@ -0,0 +1,6 @@
+This is Qt 6.6.0 backport that runs on Windows 7 (what?). Here's qtbase with all source modifications already applied. 
+Approach is based on this [forum thread](https://forum.qt.io/topic/133002/qt-creator-6-0-1-and-qt-6-2-2-running-on-windows-7/60) but better: many improvements amongst important fallbacks to default Qt 6 behaviour when running on newer Windows.
+
+You basically need to compile Qt yourself (we use the [compile_win](https://github.com/crystalidea/qt-build-tools/tree/master/6.6.0) script).
+
+The only issue noticed is that scalled UI is somewhat too big for 125% scalling option set in Windows 7. Something should be tweaked with dpi settings probably.

bin/qt-cmake-create.bat.in

@@ -0,0 +1,18 @@
+@echo off
+:: The directory of this script is the expanded absolute path of the "$qt_prefix/bin" directory.
+set script_dir_path=%~dp0
+
+:: Try to use original cmake, otherwise to make it relocatable, use any cmake found in PATH.
+set cmake_path=@CMAKE_COMMAND@
+if not exist "%cmake_path%" set cmake_path=cmake
+
+if NOT "%~2" == "" goto :showhelp
+if NOT "%~1" == "" (set PROJECT_DIR=%~1) else (set PROJECT_DIR=%cd%)
+
+"%cmake_path%" -DPROJECT_DIR="%PROJECT_DIR%" -P "%script_dir_path%\@__GlobalConfig_relative_path_from_bin_dir_to_cmake_config_dir@\QtInitProject.cmake"
+exit /b %errorlevel%
+
+:showhelp
+echo Usage
+echo.    qt-cmake-create <path/to/project>
+exit /b 1

bin/qt-cmake-create.in

@@ -0,0 +1,29 @@
+#!/bin/sh
+
+HELP_MESSAGE="Usage
+    qt-cmake-create <path/to/project>"
+
+# The directory of this script is the expanded absolute path of the "$qt_prefix/bin" directory.
+script_dir_path=`dirname $0`
+script_dir_path=`(cd "$script_dir_path"; /bin/pwd)`
+
+# Try to use original cmake, otherwise to make it relocatable, use any cmake found in PATH.
+original_cmake_path="@CMAKE_COMMAND@"
+cmake_path=$original_cmake_path
+if ! test -f "$cmake_path"; then
+    cmake_path="cmake"
+fi
+
+if [ "$#" -gt 1 ]; then
+    echo "Invalid number of arguments"
+    echo "$HELP_MESSAGE"
+    exit 1
+fi
+
+if [ "$#" -gt 0 ]; then
+    PROJECT_DIR=$1
+else
+    PROJECT_DIR=$PWD
+fi
+exec "$cmake_path" -DPROJECT_DIR="$PROJECT_DIR" -P \
+    "$script_dir_path/@__GlobalConfig_relative_path_from_bin_dir_to_cmake_config_dir@/QtInitProject.cmake"

cmake/3rdparty/extra-cmake-modules/find-modules/FindEGL.cmake

@@ -128,7 +128,8 @@ check_cxx_source_compiles("
 #include <EGL/egl.h>
 
 int main(int, char **) {
-    EGLint x = 0; EGLDisplay dpy = 0; EGLContext ctx = 0;
+    [[maybe_unused]] EGLint x = 0;
+    EGLDisplay dpy = 0; EGLContext ctx = 0;
     eglDestroyContext(dpy, ctx);
 }" HAVE_EGL)
 

cmake/FindGSSAPI.cmake

@@ -12,12 +12,24 @@ find_path(GSSAPI_INCLUDE_DIRS
           HINTS ${PC_GSSAPI_INCLUDEDIR}
 )
 
-find_library(GSSAPI_LIBRARIES
-             NAMES
+# On macOS, vcpkg opts for finding frameworks LAST. This is generally fine;
+# however, in the case of GSSAPI, `usr/lib/libgssapi_krb5.tbd` which is a
+# symlink to `Kerberos.framework` misses a few symols, e.g.,
+# `___gss_c_nt_hostbased_service_oid_desc`, and it causes build failure.
+# So, we need to make sure that we find `GSS.framework`.
+set(gssapi_library_names
   GSS    # framework
   gss    # solaris
   gssapi # FreeBSD
   gssapi_krb5
+)
+if(APPLE)
+  list(REMOVE_ITEM gssapi_library_names "gssapi_krb5")
+endif()
+
+find_library(GSSAPI_LIBRARIES
+             NAMES
+             ${gssapi_library_names}
              HINTS ${PC_GSSAPI_LIBDIR}
 )
 
@@ -44,4 +56,3 @@ mark_as_advanced(GSSAPI_INCLUDE_DIRS GSSAPI_LIBRARIES)
 include(FeatureSummary)
 set_package_properties(GSSAPI PROPERTIES
   DESCRIPTION "Generic Security Services Application Program Interface")
-

cmake/FindMimer.cmake

@@ -0,0 +1,98 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# Copyright (C) 2022 Mimer Information Technology
+# SPDX-License-Identifier: BSD-3-Clause
+
+# FindMimer
+# ---------
+# Try to locate the Mimer SQL client library
+if(NOT DEFINED MimerSQL_ROOT)
+    if(DEFINED ENV{MIMERSQL_DEV_ROOT})
+        set(MimerSQL_ROOT "$ENV{MIMERSQL_DEV_ROOT}")
+    endif()
+endif()
+
+if(NOT DEFINED MimerSQL_ROOT)
+    find_package(PkgConfig QUIET)
+endif()
+if(PkgConfig_FOUND AND NOT DEFINED MimerSQL_ROOT)
+    pkg_check_modules(PC_Mimer QUIET mimcontrol)
+    set(MimerSQL_include_dir_hints "${PC_MimerSQL_INCLUDEDIR}")
+    set(MimerSQL_library_hints "${PC_MimerSQL_LIBDIR}")
+else()
+    if(DEFINED MimerSQL_ROOT)
+        if(WIN32)
+            set(MimerSQL_include_dir_hints "${MimerSQL_ROOT}\\include")
+            if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86|X86)$")
+                set(MimerSQL_library_hints "${MimerSQL_ROOT}\\lib\\x86")
+             elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(amd64|AMD64)$")
+                set(MimerSQL_library_hints "${MimerSQL_ROOT}\\lib\\amd64")
+            else()
+                set(MimerSQL_library_hints "")
+            endif()
+        else()
+            set(MimerSQL_include_dir_hints "${MimerSQL_ROOT}/include")
+            set(MimerSQL_library_hints "${MimerSQL_ROOT}/lib")
+        endif()
+    else()
+        if(WIN32)
+            set(MimerSQL_include_dir_hints "C:\\MimerSQLDev\\include")
+            if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86|X86)$")
+                set(MimerSQL_library_hints "C:\\MimerSQLDev\\lib\\x86")
+            elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(amd64|AMD64)$")
+                set(MimerSQL_library_hints "C:\\MimerSQLDev\\lib\\amd64")
+            else()
+                set(MimerSQL_library_hints "")
+            endif()
+        elseif(APPLE AND ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+            set(MimerSQL_library_hints "/usr/local/lib")
+            set(MimerSQL_include_dir_hints "/usr/local/include")
+        else()
+            set(MimerSQL_include_dir_hints "")
+            set(MimerSQL_library_hints "")
+        endif()
+    endif()
+endif()
+
+find_path(Mimer_INCLUDE_DIR
+    NAMES mimerapi.h
+    HINTS ${MimerSQL_include_dir_hints})
+
+if(WIN32)
+  if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86|X86)$")
+    set(MIMER_LIBS_NAMES mimapi32)
+  elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(amd64|AMD64)$")
+    set(MIMER_LIBS_NAMES mimapi64)
+  endif()
+else()
+  set(MIMER_LIBS_NAMES mimerapi)
+endif()
+
+find_library(Mimer_LIBRARIES
+    NAMES ${MIMER_LIBS_NAMES}
+    HINTS ${MimerSQL_library_hints})
+
+include(FindPackageHandleStandardArgs)
+
+find_package_handle_standard_args(Mimer
+    REQUIRED_VARS Mimer_LIBRARIES Mimer_INCLUDE_DIR)
+
+
+
+# Now try to get the include and library path.
+if(Mimer_FOUND)
+  set(Mimer_INCLUDE_DIRS ${Mimer_INCLUDE_DIR})
+  set(Mimer_LIBRARY_DIRS ${Mimer_LIBRARIES})
+  if (NOT TARGET MimerSQL::MimerSQL)
+    add_library(MimerSQL::MimerSQL UNKNOWN IMPORTED)
+    set_target_properties(MimerSQL::MimerSQL PROPERTIES
+      IMPORTED_LOCATION "${Mimer_LIBRARY_DIRS}"
+      INTERFACE_INCLUDE_DIRECTORIES "${Mimer_INCLUDE_DIRS}")
+  endif ()
+endif()
+
+mark_as_advanced(Mimer_INCLUDE_DIR Mimer_LIBRARIES)
+
+include(FeatureSummary)
+set_package_properties(MimerSQL PROPERTIES
+  URL "https://www.mimer.com"
+  DESCRIPTION "Mimer client library")

cmake/FindPPS.cmake

@@ -18,9 +18,7 @@ find_package_handle_standard_args(PPS DEFAULT_MSG PPS_INCLUDE_DIR PPS_LIBRARY)
 mark_as_advanced(PPS_INCLUDE_DIR PPS_LIBRARY)
 
 if(PPS_FOUND)
-    add_library(__PPS INTERFACE IMPORTED)
-    target_link_libraries(__PPS INTERFACE "${PPS_LIBRARY}")
-    target_include_directories(__PPS INTERFACE "${PPS_INCLUDE_DIR}")
-
-    add_library(PPS::PPS ALIAS __PPS)
+    add_library(PPS::PPS INTERFACE IMPORTED)
+    target_link_libraries(PPS::PPS INTERFACE "${PPS_LIBRARY}")
+    target_include_directories(PPS::PPS INTERFACE "${PPS_INCLUDE_DIR}")
 endif()

cmake/FindWrapOpenGL.cmake

@@ -17,14 +17,18 @@ if (OpenGL_FOUND)
 
     add_library(WrapOpenGL::WrapOpenGL INTERFACE IMPORTED)
     if(APPLE)
+        # CMake 3.27 and older:
         # On Darwin platforms FindOpenGL sets IMPORTED_LOCATION to the absolute path of the library
         # within the framework. This ends up as an absolute path link flag, which we don't want,
         # because that makes our .prl files un-relocatable.
         # Extract the framework path instead, and use that in INTERFACE_LINK_LIBRARIES,
-        # which CMake ends up transforming into a reloctable -framework flag.
+        # which CMake ends up transforming into a relocatable -framework flag.
         # See https://gitlab.kitware.com/cmake/cmake/-/issues/20871 for details.
+        #
+        # CMake 3.28 and above:
+        # IMPORTED_LOCATION is the absolute path the the OpenGL.framework folder.
         get_target_property(__opengl_fw_lib_path OpenGL::GL IMPORTED_LOCATION)
-        if(__opengl_fw_lib_path)
+        if(__opengl_fw_lib_path AND NOT __opengl_fw_lib_path MATCHES "/([^/]+)\\.framework$")
             get_filename_component(__opengl_fw_path "${__opengl_fw_lib_path}" DIRECTORY)
         endif()
 

cmake/FindWrapResolv.cmake

@@ -0,0 +1,53 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# Copyright (C) 2023 Intel Corpotation.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# We can't create the same interface imported target multiple times, CMake will complain if we do
+# that. This can happen if the find_package call is done in multiple different subdirectories.
+if(TARGET WrapResolv::WrapResolv)
+    set(WrapResolv_FOUND ON)
+    return()
+endif()
+
+set(WrapResolv_FOUND OFF)
+
+include(CheckCXXSourceCompiles)
+include(CMakePushCheckState)
+
+if(QNX)
+    find_library(LIBRESOLV socket)
+else()
+    find_library(LIBRESOLV resolv)
+endif()
+
+cmake_push_check_state()
+if(LIBRESOLV)
+    list(APPEND CMAKE_REQUIRED_LIBRARIES "${LIBRESOLV}")
+endif()
+
+check_cxx_source_compiles("
+#include <netinet/in.h>
+#include <resolv.h>
+
+int main(int, char **argv)
+{
+    res_state statep;
+    int n = res_nmkquery(statep, 0, argv[1], 0, 0, NULL, 0, NULL, NULL, 0);
+    n = res_nsend(statep, NULL, 0, NULL, 0);
+    n = dn_expand(NULL, NULL, NULL, NULL, 0);
+    return n;
+}
+" HAVE_LIBRESOLV_FUNCTIONS)
+
+cmake_pop_check_state()
+
+if(HAVE_LIBRESOLV_FUNCTIONS)
+    set(WrapResolv_FOUND ON)
+    add_library(WrapResolv::WrapResolv INTERFACE IMPORTED)
+    if(LIBRESOLV)
+        target_link_libraries(WrapResolv::WrapResolv INTERFACE "${LIBRESOLV}")
+    endif()
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WrapResolv DEFAULT_MSG WrapResolv_FOUND)

cmake/FindWrapRt.cmake

@@ -21,17 +21,31 @@ if(LIBRT)
 endif()
 
 check_cxx_source_compiles("
-#include <unistd.h>
 #include <time.h>
+#include <unistd.h>
 
 int main(int, char **) {
-    timespec ts; clock_gettime(CLOCK_REALTIME, &ts);
-}" HAVE_GETTIME)
+    struct timespec ts;
+    clock_gettime(CLOCK_REALTIME, &ts);
+    return 0;
+}
+" HAVE_GETTIME)
+
+check_cxx_source_compiles("
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+
+int main(int, char **) {
+    shm_open(\"test\", O_RDWR | O_CREAT | O_EXCL, 0666);
+    shm_unlink(\"test\");
+    return 0;
+}
+" HAVE_SHM_OPEN_SHM_UNLINK)
 
 cmake_pop_check_state()
 
-
-if(HAVE_GETTIME)
+if(HAVE_GETTIME OR HAVE_SHM_OPEN_SHM_UNLINK)
     set(WrapRt_FOUND ON)
     add_library(WrapRt::WrapRt INTERFACE IMPORTED)
     if (LIBRT)

cmake/FindWrapVulkanHeaders.cmake

@@ -48,6 +48,26 @@ if(Vulkan_INCLUDE_DIR)
             target_include_directories(WrapVulkanHeaders::WrapVulkanHeaders INTERFACE
                 ${__qt_molten_vk_homebrew_include_path})
         endif()
+
+        # Check for homebrew vulkan-headers folder structure
+        # If instead of molten-vk folder, CMAKE_PREFIX_PATH points to Homebrew's
+        # vulkan-headers installation, then we will not be able to find molten-vk
+        # headers. If we assume that user has installed the molten-vk formula as
+        # well, then we might have a chance to pick it up like this.
+        if(Vulkan_INCLUDE_DIR MATCHES "/homebrew/Cellar/")
+            set(__qt_standalone_molten_vk_homebrew_include_path
+                    "${Vulkan_INCLUDE_DIR}/../../../../opt/molten-vk/include")
+        else()
+            set(__qt_standalone_molten_vk_homebrew_include_path
+                    "${Vulkan_INCLUDE_DIR}/../../molten-vk/include")
+        endif()
+        get_filename_component(
+            __qt_standalone_molten_vk_homebrew_include_path
+            "${__qt_standalone_molten_vk_homebrew_include_path}" ABSOLUTE)
+        if(EXISTS "${__qt_standalone_molten_vk_homebrew_include_path}")
+            target_include_directories(WrapVulkanHeaders::WrapVulkanHeaders INTERFACE
+                ${__qt_standalone_molten_vk_homebrew_include_path})
+        endif()
     endif()
 endif()
 

cmake/FindWrapZSTD.cmake

@@ -28,10 +28,10 @@ include(FindPackageHandleStandardArgs)
 if(TARGET zstd::libzstd_static OR TARGET zstd::libzstd_shared)
     find_package_handle_standard_args(WrapZSTD
                                       REQUIRED_VARS zstd_VERSION VERSION_VAR zstd_VERSION)
-    if(TARGET zstd::libzstd_static)
-        set(zstdtargetsuffix "_static")
-    else()
+    if(TARGET zstd::libzstd_shared)
         set(zstdtargetsuffix "_shared")
+    else()
+        set(zstdtargetsuffix "_static")
     endif()
     if(NOT TARGET WrapZSTD::WrapZSTD)
         add_library(WrapZSTD::WrapZSTD INTERFACE IMPORTED)

cmake/ModuleDescription.json.in

@@ -7,6 +7,7 @@
         "compiler_target": "${CMAKE_CXX_COMPILER_TARGET}",
         "compiler_version": "${CMAKE_CXX_COMPILER_VERSION}",
         "cross_compiled": ${cross_compilation},
-        "target_system": "${CMAKE_SYSTEM_NAME}"
+        "target_system": "${CMAKE_SYSTEM_NAME}",
+        "architecture": "${TEST_architecture_arch}"
     }
 }

cmake/QtAppHelpers.cmake

@@ -53,6 +53,7 @@ function(qt_internal_add_app target)
         ${arg_NO_UNITY_BUILD}
         ${forward_install_dir}
         SOURCES ${arg_SOURCES}
+        NO_PCH_SOURCES ${arg_NO_PCH_SOURCES}
         NO_UNITY_BUILD_SOURCES ${arg_NO_UNITY_BUILD_SOURCES}
         INCLUDE_DIRECTORIES
             ${arg_INCLUDE_DIRECTORIES}

cmake/QtAutoDetect.cmake

@@ -8,6 +8,9 @@
 # Make sure to not run detection when building standalone tests, because the detection was already
 # done when initially configuring qtbase.
 
+# This needs to be here because QtAutoDetect loads before any other modules
+option(QT_USE_VCPKG "Enable the use of vcpkg" ON)
+
 function(qt_internal_ensure_static_qt_config)
     if(NOT DEFINED BUILD_SHARED_LIBS)
         set(BUILD_SHARED_LIBS OFF CACHE BOOL "Build Qt statically or dynamically" FORCE)
@@ -161,7 +164,7 @@ function(qt_auto_detect_android)
 endfunction()
 
 function(qt_auto_detect_vcpkg)
-    if(DEFINED ENV{VCPKG_ROOT})
+    if(QT_USE_VCPKG AND DEFINED ENV{VCPKG_ROOT})
         set(vcpkg_toolchain_file "$ENV{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake")
         get_filename_component(vcpkg_toolchain_file "${vcpkg_toolchain_file}" ABSOLUTE)
 
@@ -174,8 +177,8 @@ function(qt_auto_detect_vcpkg)
         endif()
         set(CMAKE_TOOLCHAIN_FILE "${vcpkg_toolchain_file}" CACHE STRING "" FORCE)
         message(STATUS "Using vcpkg from $ENV{VCPKG_ROOT}")
-        if(DEFINED ENV{VCPKG_DEFAULT_TRIPLET} AND NOT DEFINED VCPKG_TARGET_TRIPLET)
-            set(VCPKG_TARGET_TRIPLET "$ENV{VCPKG_DEFAULT_TRIPLET}" CACHE STRING "")
+        if(DEFINED ENV{QT_VCPKG_TARGET_TRIPLET} AND NOT DEFINED VCPKG_TARGET_TRIPLET)
+            set(VCPKG_TARGET_TRIPLET "$ENV{QT_VCPKG_TARGET_TRIPLET}" CACHE STRING "")
             message(STATUS "Using vcpkg triplet ${VCPKG_TARGET_TRIPLET}")
         endif()
         unset(vcpkg_toolchain_file)
@@ -229,7 +232,9 @@ function(qt_auto_detect_ios)
         endif()
         set(CMAKE_OSX_ARCHITECTURES "${osx_architectures}" CACHE STRING "")
 
+        if(NOT DEFINED BUILD_SHARED_LIBS)
             qt_internal_ensure_static_qt_config()
+        endif()
 
         # Disable qt rpaths for iOS, just like mkspecs/common/uikit.conf does, due to those
         # bundles not being able to use paths outside the app bundle. Not sure this is strictly
@@ -239,7 +244,15 @@ function(qt_auto_detect_ios)
 endfunction()
 
 function(qt_auto_detect_cmake_config)
-    if(CMAKE_CONFIGURATION_TYPES)
+    # If CMAKE_CONFIGURATION_TYPES are not set for the multi-config generator use Release and
+    # Debug configurations by default, instead of those are proposed by the CMake internal logic.
+    get_property(is_multi GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+    if(is_multi)
+        if(NOT CMAKE_CONFIGURATION_TYPES)
+            set(CMAKE_CONFIGURATION_TYPES Release Debug)
+            set(CMAKE_CONFIGURATION_TYPES "${CMAKE_CONFIGURATION_TYPES}" PARENT_SCOPE)
+        endif()
+
         # Allow users to specify this option.
         if(NOT QT_MULTI_CONFIG_FIRST_CONFIG)
             list(GET CMAKE_CONFIGURATION_TYPES 0 first_config_type)
@@ -476,6 +489,12 @@ function(qt_auto_detect_integrity)
     endif()
 endfunction()
 
+# Save the build type before project() might set one.
+# This allows us to determine if the user has set an explicit build type that we should use.
+function(qt_auto_detect_cmake_build_type)
+    set(__qt_auto_detect_cmake_build_type_before_project_call "${CMAKE_BUILD_TYPE}" PARENT_SCOPE)
+endfunction()
+
 # Let CMake load our custom platform modules.
 # CMake-provided platform modules take precedence.
 if(NOT QT_AVOID_CUSTOM_PLATFORM_MODULES)
@@ -495,3 +514,4 @@ qt_auto_detect_wasm()
 qt_auto_detect_win32_arm()
 qt_auto_detect_linux_x86()
 qt_auto_detect_integrity()
+qt_auto_detect_cmake_build_type()

cmake/QtBaseConfigureTests.cmake

@@ -115,43 +115,38 @@ endfunction()
 
 
 function(qt_run_linker_version_script_support)
-    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/version_flag.map" "VERS_1 { global: sym; };
-VERS_2 { global: sym; }
-VERS_1;
-")
-    if(DEFINED CMAKE_REQUIRED_FLAGS)
-        set(CMAKE_REQUIRED_FLAGS_SAVE ${CMAKE_REQUIRED_FLAGS})
-    else()
-        set(CMAKE_REQUIRED_FLAGS "")
-    endif()
-    set(CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS} "-Wl,--version-script=\"${CMAKE_CURRENT_BINARY_DIR}/version_flag.map\"")
-
-    # Pass the linker that the main project uses to the version script compile test.
-    qt_internal_get_active_linker_flags(linker_flags)
-    if(linker_flags)
-        set(CMAKE_REQUIRED_LINK_OPTIONS ${linker_flags})
-    endif()
-
-    check_cxx_source_compiles("int main(void){return 0;}" HAVE_LD_VERSION_SCRIPT)
-    if(DEFINED CMAKE_REQUIRED_FLAGS_SAVE)
-        set(CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS_SAVE})
-    endif()
-    file(REMOVE "${CMAKE_CURRENT_BINARY_DIR}/conftest.map")
-
     # For some reason the linker command line written by the XCode generator, which is
     # subsequently executed by xcodebuild, ignores the linker flag, and thus the test
     # seemingly succeeds. Explicitly disable the version script test on darwin platforms.
-    if(APPLE)
-        set(HAVE_LD_VERSION_SCRIPT OFF)
-    endif()
     # Also makes no sense with MSVC-style command-line
-    if(MSVC)
+    if(NOT APPLE AND NOT MSVC)
+        file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/version_flag.map" [=[
+            VERS_1 { global: sym1; };
+            VERS_2 { global: sym2; } VERS_1;
+        ]=])
+        set(CMAKE_REQUIRED_LINK_OPTIONS "")
+        list(APPEND CMAKE_REQUIRED_LINK_OPTIONS
+             "-Wl,--version-script=${CMAKE_CURRENT_BINARY_DIR}/version_flag.map")
+        # Pass the linker that the main project uses to the version script compile test.
+        qt_internal_get_active_linker_flags(linker_flags)
+        if(linker_flags)
+            list(APPEND CMAKE_REQUIRED_LINK_OPTIONS ${linker_flags})
+        endif()
+        check_cxx_source_compiles([=[
+            int sym1;
+            int sym2;
+            int main(void) { return 0; }
+        ]=] HAVE_LD_VERSION_SCRIPT)
+        file(REMOVE "${CMAKE_CURRENT_BINARY_DIR}/version_flag.map")
+    else()
         set(HAVE_LD_VERSION_SCRIPT OFF)
     endif()
 
-    set(TEST_ld_version_script "${HAVE_LD_VERSION_SCRIPT}" CACHE INTERNAL "linker version script support")
+    set(TEST_ld_version_script "${HAVE_LD_VERSION_SCRIPT}"
+        CACHE INTERNAL "linker version script support")
     list(APPEND QT_BASE_CONFIGURE_TESTS_VARS_TO_EXPORT TEST_ld_version_script)
-    set(QT_BASE_CONFIGURE_TESTS_VARS_TO_EXPORT ${QT_BASE_CONFIGURE_TESTS_VARS_TO_EXPORT} CACHE INTERNAL "Test variables that should be exported")
+    set(QT_BASE_CONFIGURE_TESTS_VARS_TO_EXPORT ${QT_BASE_CONFIGURE_TESTS_VARS_TO_EXPORT}
+        CACHE INTERNAL "Test variables that should be exported")
 endfunction()
 
 function(qt_internal_ensure_latest_win_nt_api)

cmake/QtBaseGlobalTargets.cmake

@@ -101,7 +101,8 @@ if(MACOS AND QT_IS_MACOS_UNIVERSAL
         QT_FEATURE_x86intrin)
 endif()
 
-if(MACOS AND QT_IS_MACOS_UNIVERSAL AND __qt_osx_first_arch STREQUAL "x86_64")
+if(MACOS AND QT_IS_MACOS_UNIVERSAL AND
+    (__qt_osx_first_arch STREQUAL "x86_64" OR __qt_osx_first_arch STREQUAL "x86_64h"))
     set(QT_FORCE_FEATURE_neon ON CACHE INTERNAL "Force enable neon due to platform requirements.")
     set(__QtFeature_custom_enabled_cache_variables
         TEST_subarch_neon
@@ -215,6 +216,7 @@ qt_copy_or_install(FILES
                    cmake/QtAndroidHelpers.cmake
                    cmake/QtAppHelpers.cmake
                    cmake/QtAutogenHelpers.cmake
+                   cmake/QtBaseTopLevelHelpers.cmake
                    cmake/QtBuild.cmake
                    cmake/QtBuildInformation.cmake
                    cmake/QtCMakeHelpers.cmake
@@ -331,6 +333,7 @@ set(__public_cmake_helpers
     cmake/QtCopyFileIfDifferent.cmake
     cmake/QtFeature.cmake
     cmake/QtFeatureCommon.cmake
+    cmake/QtInitProject.cmake
     cmake/QtPublicAppleHelpers.cmake
     cmake/QtPublicCMakeHelpers.cmake
     cmake/QtPublicCMakeVersionHelpers.cmake
@@ -373,6 +376,10 @@ qt_copy_or_install(DIRECTORY cmake/
     FILES_MATCHING PATTERN "Find*.cmake"
     PATTERN "tests" EXCLUDE
     PATTERN "3rdparty" EXCLUDE
+    PATTERN "macos" EXCLUDE
+    PATTERN "ios" EXCLUDE
+    PATTERN "platforms" EXCLUDE
+    PATTERN "QtBuildInternals" EXCLUDE
 )
 
 # In prefix builds we also need to copy the files into the build config directory, so that the
@@ -383,20 +390,37 @@ if(QT_WILL_INSTALL)
         FILES_MATCHING PATTERN "Find*.cmake"
         PATTERN "tests" EXCLUDE
         PATTERN "3rdparty" EXCLUDE
+        PATTERN "macos" EXCLUDE
+        PATTERN "ios" EXCLUDE
+        PATTERN "platforms" EXCLUDE
+        PATTERN "QtBuildInternals" EXCLUDE
     )
 endif()
 
+if(APPLE)
     if(MACOS)
-    qt_copy_or_install(FILES
-        cmake/macos/MacOSXBundleInfo.plist.in
-        DESTINATION "${__GlobalConfig_install_dir}/macos"
-    )
+        set(platform_shortname "macos")
     elseif(IOS)
-    qt_copy_or_install(FILES
-        cmake/ios/Info.plist.app.in
-        cmake/ios/LaunchScreen.storyboard
+        set(platform_shortname "ios")
+    endif()
+
+    qt_copy_or_install(FILES "cmake/${platform_shortname}/Info.plist.app.in"
+        DESTINATION "${__GlobalConfig_install_dir}/${platform_shortname}"
+    )
+    # For examples built as part of prefix build before install
+    file(COPY "cmake/${platform_shortname}/Info.plist.app.in"
+        DESTINATION "${__GlobalConfig_build_dir}/${platform_shortname}"
+    )
+
+    if(IOS)
+        qt_copy_or_install(FILES "cmake/ios/LaunchScreen.storyboard"
             DESTINATION "${__GlobalConfig_install_dir}/ios"
         )
+        # For examples built as part of prefix build before install
+        file(COPY "cmake/ios/LaunchScreen.storyboard"
+            DESTINATION "${__GlobalConfig_build_dir}/ios"
+        )
+    endif()
 elseif(WASM)
     configure_file("${CMAKE_CURRENT_SOURCE_DIR}/util/wasm/wasmtestrunner/qt-wasmtestrunner.py"
         "${QT_BUILD_DIR}/${INSTALL_LIBEXECDIR}/qt-wasmtestrunner.py" @ONLY)

cmake/QtBaseTopLevelHelpers.cmake

@@ -0,0 +1,85 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# Depends on __qt6_qtbase_src_path being set in the top-level dir.
+macro(qt_internal_top_level_setup_autodetect)
+    # Run platform auto-detection /before/ the first project() call and thus
+    # before the toolchain file is loaded.
+    # Don't run auto-detection when doing standalone tests. In that case, the detection
+    # results are taken from either QtBuildInternals or the qt.toolchain.cmake file.
+
+    if(NOT QT_BUILD_STANDALONE_TESTS)
+        set(__qt6_auto_detect_path "${__qt6_qtbase_src_path}/cmake/QtAutoDetect.cmake")
+        if(NOT EXISTS "${__qt6_auto_detect_path}")
+            message(FATAL_ERROR "Required file does not exist: '${__qt6_auto_detect_path}'")
+        endif()
+        include("${__qt6_auto_detect_path}")
+    endif()
+endmacro()
+
+macro(qt_internal_top_level_setup_after_project)
+    # TODO: Remove this variable once the top-level calls this function and
+    # qt_internal_qt_configure_end is not called in qt_print_build_instructions anymore.
+    set(__qt6_top_level_after_project_called TRUE)
+
+    qt_internal_top_level_setup_testing()
+endmacro()
+
+macro(qt_internal_top_level_setup_testing)
+    # Required so we can call ctest from the root build directory
+    enable_testing()
+endmacro()
+
+# Depends on __qt6_qtbase_src_path being set in the top-level dir.
+macro(qt_internal_top_level_setup_cmake_module_path)
+    if (NOT QT_BUILD_STANDALONE_TESTS)
+        set(__qt6_cmake_module_path "${__qt6_qtbase_src_path}/cmake")
+        if(NOT EXISTS "${__qt6_cmake_module_path}")
+            message(FATAL_ERROR "Required directory does not exist: '${__qt6_cmake_module_path}'")
+        endif()
+
+        list(APPEND CMAKE_MODULE_PATH "${__qt6_cmake_module_path}")
+
+        list(APPEND CMAKE_MODULE_PATH
+            "${__qt6_cmake_module_path}/3rdparty/extra-cmake-modules/find-modules")
+        list(APPEND CMAKE_MODULE_PATH "${__qt6_cmake_module_path}/3rdparty/kwin")
+    endif()
+endmacro()
+
+macro(qt_internal_top_level_before_build_submodules)
+    qt_internal_top_level_setup_no_create_targets()
+endmacro()
+
+macro(qt_internal_top_level_setup_no_create_targets)
+    # Also make sure the CMake config files do not recreate the already-existing targets
+    if (NOT QT_BUILD_STANDALONE_TESTS)
+        set(QT_NO_CREATE_TARGETS TRUE)
+    endif()
+endmacro()
+
+macro(qt_internal_top_level_end)
+    qt_internal_print_top_level_info()
+
+    # Depends on QtBuildInternalsConfig being included, which is the case whenver any repo is
+    # configured.
+    qt_internal_qt_configure_end()
+endmacro()
+
+function(qt_internal_print_top_level_info)
+    if(NOT QT_BUILD_STANDALONE_TESTS)
+        # Display a summary of everything
+        include(QtBuildInformation)
+        include(QtPlatformSupport)
+        qt_print_feature_summary()
+        qt_print_build_instructions()
+    endif()
+endfunction()
+
+macro(qt_internal_top_level_after_add_subdirectory)
+    if(module STREQUAL "qtbase")
+        if (NOT QT_BUILD_STANDALONE_TESTS)
+            list(APPEND CMAKE_PREFIX_PATH "${QtBase_BINARY_DIR}/${INSTALL_LIBDIR}/cmake")
+            list(APPEND CMAKE_FIND_ROOT_PATH "${QtBase_BINARY_DIR}")
+        endif()
+    endif()
+endmacro()

cmake/QtBuild.cmake

@@ -281,24 +281,24 @@ qt_setup_tool_path_command()
 # Platform define path, etc.
 if(WIN32)
     set(QT_DEFAULT_PLATFORM_DEFINITIONS WIN32 _ENABLE_EXTENDED_ALIGNED_STORAGE)
-    if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+    if(QT_64BIT)
         list(APPEND QT_DEFAULT_PLATFORM_DEFINITIONS WIN64 _WIN64)
     endif()
-    if(MSVC)
+
     if(CLANG)
+        if(CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC" OR MSVC)
             set(QT_DEFAULT_MKSPEC win32-clang-msvc)
-        elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64")
+        elseif(CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU" OR MINGW)
+            set(QT_DEFAULT_MKSPEC win32-clang-g++)
+        endif()
+    elseif(MSVC)
+        if(CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64")
             set(QT_DEFAULT_MKSPEC win32-arm64-msvc)
         else()
             set(QT_DEFAULT_MKSPEC win32-msvc)
         endif()
-    elseif(CLANG AND MINGW)
-        set(QT_DEFAULT_MKSPEC win32-clang-g++)
     elseif(MINGW)
         set(QT_DEFAULT_MKSPEC win32-g++)
-    endif()
-
-    if (MINGW)
         list(APPEND QT_DEFAULT_PLATFORM_DEFINITIONS MINGW_HAS_SECURE_API=1)
     endif()
 elseif(LINUX)
@@ -376,15 +376,23 @@ else()
     set(QT_QMAKE_HOST_MKSPEC "${QT_QMAKE_TARGET_MKSPEC}")
 endif()
 
-if(NOT EXISTS "${QT_MKSPECS_DIR}/${QT_QMAKE_TARGET_MKSPEC}")
+if(NOT QT_QMAKE_TARGET_MKSPEC OR NOT EXISTS "${QT_MKSPECS_DIR}/${QT_QMAKE_TARGET_MKSPEC}")
+    if(NOT QT_QMAKE_TARGET_MKSPEC)
+        set(reason "Platform is not detected. Please make sure your build environment is configured"
+            " properly or specify it manually using QT_QMAKE_TARGET_MKSPEC variable and one of the"
+            " known platforms.")
+    else()
+        set(reason "Unknown platform ${QT_QMAKE_TARGET_MKSPEC}")
+    endif()
+
     file(GLOB known_platforms
         LIST_DIRECTORIES true
         RELATIVE "${QT_MKSPECS_DIR}"
         "${QT_MKSPECS_DIR}/*"
     )
     list(JOIN known_platforms "\n    " known_platforms)
-    message(FATAL_ERROR "Unknown platform ${QT_QMAKE_TARGET_MKSPEC}\n\
-Known platforms:\n    ${known_platforms}")
+    message(FATAL_ERROR "${reason}\n"
+        "Known platforms:\n    ${known_platforms}")
 endif()
 
 if(NOT DEFINED QT_DEFAULT_PLATFORM_DEFINITIONS)
@@ -426,7 +434,7 @@ set(QT_TOP_LEVEL_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
 # Prevent warnings about object files without any symbols. This is a common
 # thing in Qt as we tend to build files unconditionally, and then use ifdefs
 # to compile out parts that are not relevant.
-if(CMAKE_HOST_APPLE AND APPLE)
+if(CMAKE_CXX_COMPILER_ID MATCHES "AppleClang")
     foreach(lang ASM C CXX)
         # We have to tell 'ar' to not run ranlib by itself, by passing the 'S' option
         set(CMAKE_${lang}_ARCHIVE_CREATE "<CMAKE_AR> qcS <TARGET> <LINK_FLAGS> <OBJECTS>")
@@ -459,6 +467,7 @@ set(__default_private_args
     DISABLE_AUTOGEN_TOOLS
     ENABLE_AUTOGEN_TOOLS
     PLUGIN_TYPES
+    NO_PCH_SOURCES
     NO_UNITY_BUILD_SOURCES
 )
 set(__default_public_args
@@ -568,11 +577,6 @@ endif()
 _qt_internal_determine_if_host_info_package_needed(__qt_build_requires_host_info_package)
 _qt_internal_find_host_info_package("${__qt_build_requires_host_info_package}")
 
-# Create tool script wrapper if necessary.
-# TODO: Remove once all direct usages of QT_TOOL_COMMAND_WRAPPER_PATH are replaced with function
-# calls.
-_qt_internal_generate_tool_command_wrapper()
-
 # This sets up the poor man's scope finalizer mechanism.
 # For newer CMake versions, we use cmake_language(DEFER CALL) instead.
 if(CMAKE_VERSION VERSION_LESS "3.19.0")

cmake/QtBuildInformation.cmake

@@ -109,7 +109,14 @@ from the build directory")
     set(QT_INTERNAL_BUILD_INSTRUCTIONS_SHOWN "TRUE" CACHE STRING "" FORCE)
 
     if(QT_SUPERBUILD)
-        qt_internal_save_previously_found_packages()
+        qt_internal_save_previously_visited_packages()
+    endif()
+
+    # TODO: Abuse qt_print_build_instructions being called as the last command in a top-level build.
+    # Instead we should call this explicitly at the end of the top-level project.
+    # TODO: Remove this once the top-level calls qt_internal_top_level_setup_after_project
+    if(QT_SUPERBUILD AND NOT __qt6_top_level_after_project_called)
+        qt_internal_qt_configure_end()
     endif()
 endfunction()
 

cmake/QtBuildInternals/QtBuildInternalsConfig.cmake

@@ -105,6 +105,30 @@ endif()
 # build.
 include(QtPlatformSupport)
 
+# Set FEATURE_${feature} if INPUT_${feature} is set in certain circumstances.
+#
+# Needs to be in QtBuildInternalsConfig.cmake instead of QtFeature.cmake because it's used in
+# qt_build_internals_disable_pkg_config_if_needed.
+function(qt_internal_compute_feature_value_from_possible_input feature)
+    # If FEATURE_ is not defined try to use the INPUT_ variable to enable/disable feature.
+    # If FEATURE_ is defined and the configure script is being used (so
+    # QT_INTERNAL_CALLED_FROM_CONFIGURE is TRUE), ignore the FEATURE_ variable, and take into
+    # account the INPUT_ variable instead, because a command line argument takes priority over
+    # a pre-cached FEATURE_ variable.
+    if((NOT DEFINED FEATURE_${feature} OR QT_INTERNAL_CALLED_FROM_CONFIGURE)
+        AND DEFINED INPUT_${feature}
+        AND NOT "${INPUT_${feature}}" STREQUAL "undefined"
+        AND NOT "${INPUT_${feature}}" STREQUAL "")
+        if(INPUT_${feature})
+            set(FEATURE_${feature} ON)
+        else()
+            set(FEATURE_${feature} OFF)
+        endif()
+
+        set(FEATURE_${feature} "${FEATURE_${feature}}" PARENT_SCOPE)
+    endif()
+endfunction()
+
 function(qt_build_internals_disable_pkg_config_if_needed)
     # pkg-config should not be used by default on Darwin and Windows platforms (and QNX), as defined
     # in the qtbase/configure.json. Unfortunately by the time the feature is evaluated there are
@@ -131,15 +155,7 @@ function(qt_build_internals_disable_pkg_config_if_needed)
     endif()
 
     # Features won't have been evaluated yet if this is the first run, have to evaluate this here
-    if ((NOT DEFINED "FEATURE_pkg_config") AND (DEFINED "INPUT_pkg_config")
-            AND (NOT "${INPUT_pkg_config}" STREQUAL "undefined")
-            AND (NOT "${INPUT_pkg_config}" STREQUAL ""))
-        if(INPUT_pkg_config)
-            set(FEATURE_pkg_config ON)
-        else()
-            set(FEATURE_pkg_config OFF)
-        endif()
-    endif()
+    qt_internal_compute_feature_value_from_possible_input(pkg_config)
 
     # If user explicitly specified a value for the feature, honor it, even if it might break
     # the build.
@@ -296,7 +312,27 @@ function(qt_build_internals_add_toplevel_targets)
                 COMMENT "Building everything in ${qt_repo_targets_name}/${qt_repo_target_basename}")
             add_dependencies("${qt_repo_target_name}" ${qt_repo_targets})
             list(APPEND qt_repo_target_all "${qt_repo_target_name}")
+
+            # Create special dependency target for External Project examples excluding targets
+            # marked as skipped.
+            set(qt_repo_target_name
+                "${qt_repo_targets_name}_${qt_repo_target_basename}_for_examples")
+            add_custom_target("${qt_repo_target_name}")
+
+            set(unskipped_targets "")
+            foreach(target IN LISTS qt_repo_targets)
+                if(TARGET "${target}")
+                    qt_internal_is_target_skipped_for_examples("${target}" is_skipped)
+                    if(NOT is_skipped)
+                        list(APPEND unskipped_targets "${target}")
                     endif()
+                endif()
+            endforeach()
+            if(unskipped_targets)
+                add_dependencies("${qt_repo_target_name}" ${unskipped_targets})
+            endif()
+        endif()
+
     endforeach()
     if (qt_repo_target_all)
         # Note qt_repo_targets_name is different from qt_repo_target_name that is used above.
@@ -308,24 +344,19 @@ function(qt_build_internals_add_toplevel_targets)
 endfunction()
 
 macro(qt_enable_cmake_languages)
-    include(CheckLanguage)
     set(__qt_required_language_list C CXX)
-    set(__qt_optional_language_list )
+    set(__qt_platform_required_language_list )
 
-    # https://gitlab.kitware.com/cmake/cmake/-/issues/20545
     if(APPLE)
-        list(APPEND __qt_optional_language_list OBJC OBJCXX)
+        list(APPEND __qt_platform_required_language_list OBJC OBJCXX)
     endif()
 
     foreach(__qt_lang ${__qt_required_language_list})
         enable_language(${__qt_lang})
     endforeach()
 
-    foreach(__qt_lang ${__qt_optional_language_list})
-        check_language(${__qt_lang})
-        if(CMAKE_${__qt_lang}_COMPILER)
+    foreach(__qt_lang ${__qt_platform_required_language_list})
         enable_language(${__qt_lang})
-        endif()
     endforeach()
 
     # The qtbase call is handled in qtbase/CMakeLists.txt.
@@ -434,6 +465,12 @@ macro(qt_build_repo_begin)
         add_custom_target(sync_headers)
     endif()
 
+    # The special target that we use to sync 3rd-party headers before the gn run when building
+    # qtwebengine in top-level builds.
+    if(NOT TARGET thirdparty_sync_headers)
+        add_custom_target(thirdparty_sync_headers)
+    endif()
+
     # Add global qt_plugins, qpa_plugins and qpa_default_plugins convenience custom targets.
     # Internal executables will add a dependency on the qpa_default_plugins target,
     # so that building and running a test ensures it won't fail at runtime due to a missing qpa
@@ -562,16 +599,34 @@ macro(qt_build_repo_end)
     endif()
 
     if(NOT QT_SUPERBUILD)
-        qt_internal_save_previously_found_packages()
+        qt_internal_save_previously_visited_packages()
     endif()
 
     if(QT_INTERNAL_FRESH_REQUESTED)
         set(QT_INTERNAL_FRESH_REQUESTED "FALSE" CACHE INTERNAL "")
     endif()
 
+    if(NOT QT_SUPERBUILD)
+        qt_internal_qt_configure_end()
+    endif()
+
     list(POP_BACK CMAKE_MESSAGE_CONTEXT)
 endmacro()
 
+# Function called either at the end of per-repo configuration, or at the end of configuration of
+# a super build.
+# At the moment it is called before examples are configured in a per-repo build. We might want
+# to change that at some point if needed.
+function(qt_internal_qt_configure_end)
+    # If Qt is configued via the configure script, remove the marker variable, so that any future
+    # reconfigurations that are done by calling cmake directly don't trigger configure specific
+    # logic.
+    unset(QT_INTERNAL_CALLED_FROM_CONFIGURE CACHE)
+
+    # Clean up stale feature input values.
+    qt_internal_clean_feature_inputs()
+endfunction()
+
 macro(qt_build_repo)
     qt_build_repo_begin(${ARGN})
 
@@ -855,7 +910,7 @@ macro(qt_examples_build_begin)
         set(QT_EXAMPLE_DEPENDENCIES ${qt_repo_plugins_recursive} ${arg_DEPENDS})
 
         if(TARGET ${qt_repo_targets_name}_src)
-            list(APPEND QT_EXAMPLE_DEPENDENCIES ${qt_repo_targets_name}_src)
+            list(APPEND QT_EXAMPLE_DEPENDENCIES ${qt_repo_targets_name}_src_for_examples)
         endif()
 
         if(TARGET ${qt_repo_targets_name}_tools)
@@ -979,19 +1034,118 @@ set(CMAKE_INSTALL_PREFIX \"\${_qt_internal_examples_cmake_install_prefix_backup}
     set(CMAKE_UNITY_BUILD ${QT_UNITY_BUILD})
 endmacro()
 
+# Allows building an example either as an ExternalProject or in-tree with the Qt build.
+# Also allows installing the example sources.
 function(qt_internal_add_example subdir)
+    # Pre-compute unique example name based on the subdir, in case of target name clashes.
+    qt_internal_get_example_unique_name(unique_example_name "${subdir}")
+
+    # QT_INTERNAL_NO_CONFIGURE_EXAMPLES is not meant to be used by Qt builders, it's here for faster
+    # testing of the source installation code path for build system engineers.
+    if(NOT QT_INTERNAL_NO_CONFIGURE_EXAMPLES)
         if(NOT QT_IS_EXTERNAL_EXAMPLES_BUILD)
-        qt_internal_add_example_in_tree(${ARGV})
+            qt_internal_add_example_in_tree("${subdir}")
         else()
-        qt_internal_add_example_external_project(${ARGV})
+            qt_internal_add_example_external_project("${subdir}"
+                NAME "${unique_example_name}")
         endif()
+    endif()
+
+    if(QT_INSTALL_EXAMPLES_SOURCES)
+        string(TOLOWER ${PROJECT_NAME} project_name_lower)
+
+        qt_internal_install_example_sources("${subdir}"
+            NAME "${unique_example_name}"
+            REPO_NAME "${project_name_lower}")
+    endif()
+endfunction()
+
+# Gets the install prefix where an example should be installed.
+# Used for computing the final installation path.
+function(qt_internal_get_example_install_prefix out_var)
+    # Allow customizing the installation path of the examples. Will be used in CI.
+    if(QT_INTERNAL_EXAMPLES_INSTALL_PREFIX)
+        set(qt_example_install_prefix "${QT_INTERNAL_EXAMPLES_INSTALL_PREFIX}")
+    else()
+        set(qt_example_install_prefix "${CMAKE_INSTALL_PREFIX}/${INSTALL_EXAMPLESDIR}")
+    endif()
+    file(TO_CMAKE_PATH "${qt_example_install_prefix}" qt_example_install_prefix)
+    set(${out_var} "${qt_example_install_prefix}" PARENT_SCOPE)
+endfunction()
+
+# Gets the install prefix where an example's sources should be installed.
+# Used for computing the final installation path.
+function(qt_internal_get_examples_sources_install_prefix out_var)
+    # Allow customizing the installation path of the examples source specifically.
+    if(QT_INTERNAL_EXAMPLES_SOURCES_INSTALL_PREFIX)
+        set(qt_example_install_prefix "${QT_INTERNAL_EXAMPLES_SOURCES_INSTALL_PREFIX}")
+    else()
+        qt_internal_get_example_install_prefix(qt_example_install_prefix)
+    endif()
+    file(TO_CMAKE_PATH "${qt_example_install_prefix}" qt_example_install_prefix)
+    set(${out_var} "${qt_example_install_prefix}" PARENT_SCOPE)
+endfunction()
+
+# Gets the relative path of an example, relative to the current repo's examples source dir.
+# QT_EXAMPLE_BASE_DIR is meant to be already set in a parent scope.
+function(qt_internal_get_example_rel_path out_var subdir)
+    file(RELATIVE_PATH example_rel_path
+         "${QT_EXAMPLE_BASE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/${subdir}")
+    set(${out_var} "${example_rel_path}" PARENT_SCOPE)
+endfunction()
+
+# Gets the install path where an example should be installed.
+function(qt_internal_get_example_install_path out_var subdir)
+    qt_internal_get_example_install_prefix(qt_example_install_prefix)
+    qt_internal_get_example_rel_path(example_rel_path "${subdir}")
+    set(example_install_path "${qt_example_install_prefix}/${example_rel_path}")
+
+    set(${out_var} "${example_install_path}" PARENT_SCOPE)
+endfunction()
+
+# Gets the install path where an example's sources should be installed.
+function(qt_internal_get_examples_sources_install_path out_var subdir)
+    qt_internal_get_examples_sources_install_prefix(qt_example_install_prefix)
+    qt_internal_get_example_rel_path(example_rel_path "${subdir}")
+    set(example_install_path "${qt_example_install_prefix}/${example_rel_path}")
+
+    set(${out_var} "${example_install_path}" PARENT_SCOPE)
+endfunction()
+
+# Get the unique name of an example project based on its subdir or explicitly given name.
+# Makes the name unique by appending a short sha1 hash of the relative path of the example
+# if a target of the same name already exist.
+function(qt_internal_get_example_unique_name out_var subdir)
+    qt_internal_get_example_rel_path(example_rel_path "${subdir}")
+
+    set(name "${subdir}")
+
+    # qtdeclarative has calls like qt_internal_add_example(imagine/automotive)
+    # so passing a nested subdirectory. Custom targets (and thus ExternalProjects) can't contain
+    # slashes, so extract the last part of the path to be used as a name.
+    if(name MATCHES "/")
+        string(REPLACE "/" ";" exploded_path "${name}")
+        list(POP_BACK exploded_path last_dir)
+        if(NOT last_dir)
+            message(FATAL_ERROR "Example subdirectory must have a name.")
+        else()
+            set(name "${last_dir}")
+        endif()
+    endif()
+
+    # Likely a clash with an example subdir ExternalProject custom target of the same name in a
+    # top-level build.
+    if(TARGET "${name}")
+        string(SHA1 rel_path_hash "${example_rel_path}")
+        string(SUBSTRING "${rel_path_hash}" 0 4 short_hash)
+        set(name "${name}-${short_hash}")
+    endif()
+
+    set(${out_var} "${name}" PARENT_SCOPE)
 endfunction()
 
 # Use old non-ExternalProject approach, aka build in-tree with the Qt build.
 function(qt_internal_add_example_in_tree subdir)
-    file(RELATIVE_PATH example_rel_path
-         "${QT_EXAMPLE_BASE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/${subdir}")
-
     # Unset the default CMAKE_INSTALL_PREFIX that's generated in
     #   ${CMAKE_CURRENT_BINARY_DIR}/cmake_install.cmake
     # so we can override it with a different value in
@@ -1005,15 +1159,8 @@ unset(CMAKE_INSTALL_PREFIX)
 
     # Override the install prefix in the subdir cmake_install.cmake, so that
     # relative install(TARGETS DESTINATION) calls in example projects install where we tell them to.
-    # Allow customizing the installation path of the examples. Will be used in CI.
-    if(QT_INTERNAL_EXAMPLES_INSTALL_PREFIX)
-        set(qt_example_install_prefix "${QT_INTERNAL_EXAMPLES_INSTALL_PREFIX}")
-    else()
-        set(qt_example_install_prefix "${CMAKE_INSTALL_PREFIX}/${INSTALL_EXAMPLESDIR}")
-    endif()
-    file(TO_CMAKE_PATH "${qt_example_install_prefix}" qt_example_install_prefix)
-
-    set(CMAKE_INSTALL_PREFIX "${qt_example_install_prefix}/${example_rel_path}")
+    qt_internal_get_example_install_path(example_install_path "${subdir}")
+    set(CMAKE_INSTALL_PREFIX "${example_install_path}")
 
     # Make sure unclean example projects have their INSTALL_EXAMPLEDIR set to "."
     # Won't have any effect on example projects that don't use INSTALL_EXAMPLEDIR.
@@ -1023,7 +1170,7 @@ unset(CMAKE_INSTALL_PREFIX)
     # TODO: Remove once all repositories use qt_internal_add_example instead of add_subdirectory.
     set(QT_INTERNAL_SET_EXAMPLE_INSTALL_DIR_TO_DOT ON)
 
-    add_subdirectory(${subdir} ${ARGN})
+    add_subdirectory(${subdir})
 endfunction()
 
 function(qt_internal_add_example_external_project subdir)
@@ -1033,33 +1180,6 @@ function(qt_internal_add_example_external_project subdir)
 
     cmake_parse_arguments(PARSE_ARGV 1 arg "${options}" "${singleOpts}" "${multiOpts}")
 
-    file(RELATIVE_PATH example_rel_path
-         "${QT_EXAMPLE_BASE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/${subdir}")
-
-    if(NOT arg_NAME)
-        set(arg_NAME "${subdir}")
-
-        # qtdeclarative has calls like qt_internal_add_example(imagine/automotive)
-        # so passing a nested subdirectory. Custom targets (and thus ExternalProjects) can't contain
-        # slashes, so extract the last part of the path to be used as a name.
-        if(arg_NAME MATCHES "/")
-            string(REPLACE "/" ";" exploded_path "${arg_NAME}")
-            list(POP_BACK exploded_path last_dir)
-            if(NOT last_dir)
-                message(FATAL_ERROR "Example subdirectory must have a name.")
-            else()
-                set(arg_NAME "${last_dir}")
-            endif()
-        endif()
-    endif()
-
-    # Likely a clash with an example subdir ExternalProject custom target of the same name.
-    if(TARGET "${arg_NAME}")
-        string(SHA1 rel_path_hash "${example_rel_path}")
-        string(SUBSTRING "${rel_path_hash}" 0 4 short_hash)
-        set(arg_NAME "${arg_NAME}-${short_hash}")
-    endif()
-
     # TODO: Fix example builds when using Conan / install prefixes are different for each repo.
     if(QT_SUPERBUILD OR QtBase_BINARY_DIR)
         # When doing a top-level build or when building qtbase,
@@ -1280,15 +1400,7 @@ function(qt_internal_add_example_external_project subdir)
     #    example_source_dir, use _qt_internal_override_example_install_dir_to_dot to ensure
     #    INSTALL_EXAMPLEDIR does not interfere.
 
-    # Allow customizing the installation path of the examples. Will be used in CI.
-    if(QT_INTERNAL_EXAMPLES_INSTALL_PREFIX)
-        set(qt_example_install_prefix "${QT_INTERNAL_EXAMPLES_INSTALL_PREFIX}")
-    else()
-        set(qt_example_install_prefix "${CMAKE_INSTALL_PREFIX}/${INSTALL_EXAMPLESDIR}")
-    endif()
-    file(TO_CMAKE_PATH "${qt_example_install_prefix}" qt_example_install_prefix)
-
-    set(example_install_prefix "${qt_example_install_prefix}/${example_rel_path}")
+    qt_internal_get_example_install_path(example_install_path "${subdir}")
 
     set(ep_binary_dir    "${CMAKE_CURRENT_BINARY_DIR}/${subdir}")
 
@@ -1303,7 +1415,7 @@ function(qt_internal_add_example_external_project subdir)
         PREFIX           "${CMAKE_CURRENT_BINARY_DIR}/${subdir}-ep"
         STAMP_DIR        "${CMAKE_CURRENT_BINARY_DIR}/${subdir}-ep/stamp"
         BINARY_DIR       "${ep_binary_dir}"
-        INSTALL_DIR      "${example_install_prefix}"
+        INSTALL_DIR      "${example_install_path}"
         INSTALL_COMMAND  ""
         ${build_command}
         TEST_COMMAND     ""
@@ -1357,6 +1469,54 @@ execute_process(
 
 endfunction()
 
+function(qt_internal_install_example_sources subdir)
+    set(options "")
+    set(single_args NAME REPO_NAME)
+    set(multi_args "")
+
+    cmake_parse_arguments(PARSE_ARGV 1 arg "${options}" "${single_args}" "${multi_args}")
+
+    qt_internal_get_examples_sources_install_path(example_install_path "${subdir}")
+
+    # The trailing slash is important to avoid duplicate nested directory names.
+    set(example_source_dir "${subdir}/")
+
+    # Allow controlling whether sources should be part of the default install target.
+    if(QT_INSTALL_EXAMPLES_SOURCES_BY_DEFAULT)
+        set(exclude_from_all "")
+    else()
+        set(exclude_from_all "EXCLUDE_FROM_ALL")
+    endif()
+
+    # Create an install component for all example sources. Can also be part of the default
+    # install target if EXCLUDE_FROM_ALL is not passed.
+    install(
+        DIRECTORY "${example_source_dir}"
+        DESTINATION "${example_install_path}"
+        COMPONENT "examples_sources"
+        USE_SOURCE_PERMISSIONS
+        ${exclude_from_all}
+    )
+
+    # Also create a specific install component just for this repo's examples.
+    install(
+        DIRECTORY "${example_source_dir}"
+        DESTINATION "${example_install_path}"
+        COMPONENT "examples_sources_${arg_REPO_NAME}"
+        USE_SOURCE_PERMISSIONS
+        EXCLUDE_FROM_ALL
+    )
+
+    # Also create a specific install component just for the current example's sources.
+    install(
+        DIRECTORY "${example_source_dir}"
+        DESTINATION "${example_install_path}"
+        COMPONENT "examples_sources_${arg_NAME}"
+        USE_SOURCE_PERMISSIONS
+        EXCLUDE_FROM_ALL
+    )
+endfunction()
+
 if ("STANDALONE_TEST" IN_LIST Qt6BuildInternals_FIND_COMPONENTS)
     include(${CMAKE_CURRENT_LIST_DIR}/QtStandaloneTestTemplateProject/Main.cmake)
     if (NOT PROJECT_VERSION_MAJOR)
@@ -1415,3 +1575,13 @@ function(qt_internal_run_common_config_tests)
     qt_internal_check_cmp0099_available()
     qt_configure_end_summary_section()
 endfunction()
+
+# It is used in QtWebEngine to replace the REALPATH with ABSOLUTE path, which is
+# useful for building Qt in Homebrew.
+function(qt_internal_get_filename_path_mode out_var)
+    set(mode REALPATH)
+    if(APPLE AND QT_ALLOW_SYMLINK_IN_PATHS)
+        set(mode ABSOLUTE)
+    endif()
+    set(${out_var} ${mode} PARENT_SCOPE)
+endfunction()

cmake/QtBuildInternalsExtra.cmake.in

@@ -103,6 +103,9 @@ set(QT_BUILD_EXAMPLES_AS_EXTERNAL "@QT_BUILD_EXAMPLES_AS_EXTERNAL@" CACHE BOOL
 # Propagate usage of ccache.
 set(QT_USE_CCACHE @QT_USE_CCACHE@ CACHE BOOL "Enable the use of ccache")
 
+# Propagate usage of vcpkg, ON by default.
+set(QT_USE_VCPKG @QT_USE_VCPKG@ CACHE BOOL "Enable the use of vcpkg")
+
 # Propagate usage of unity build.
 set(QT_UNITY_BUILD @QT_UNITY_BUILD@ CACHE BOOL "Enable unity (jumbo) build")
 set(QT_UNITY_BUILD_BATCH_SIZE "@QT_UNITY_BUILD_BATCH_SIZE@" CACHE STRING "Unity build batch size")
@@ -163,6 +166,7 @@ function(qt_internal_force_set_cmake_build_type_conditionally value)
         AND NOT QT_NO_FORCE_SET_CMAKE_BUILD_TYPE
         AND NOT __qt_internal_extras_is_multi_config)
         set(CMAKE_BUILD_TYPE "${value}" CACHE STRING "Choose the type of build." FORCE)
+        set(__qt_build_internals_cmake_build_type "${value}" PARENT_SCOPE)
     endif()
 endfunction()
 

cmake/QtCMakeVersionHelpers.cmake

@@ -14,6 +14,8 @@ function(qt_internal_get_supported_min_cmake_version_for_building_qt out_var)
         set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT}")
 
     # We're building qtbase so the values come from .cmake.conf.
+    elseif(APPLE)
+        set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT_APPLE}")
     elseif(BUILD_SHARED_LIBS)
         set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_BUILDING_QT_SHARED}")
     else()
@@ -30,7 +32,9 @@ function(qt_internal_get_supported_min_cmake_version_for_using_qt out_var)
             "It should have been set by this point.")
     endif()
 
-    if(BUILD_SHARED_LIBS)
+    if(APPLE)
+        set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT_APPLE}")
+    elseif(BUILD_SHARED_LIBS)
         set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT_SHARED}")
     else()
         set(supported_version "${QT_SUPPORTED_MIN_CMAKE_VERSION_FOR_USING_QT_STATIC}")

cmake/QtCompilerOptimization.cmake

@@ -92,10 +92,10 @@ endif()
 
 # Windows MSVC
 if(MSVC)
-    set(QT_CFLAGS_OPTIMIZE "-O2")
+    set(QT_CFLAGS_OPTIMIZE "-O2 -Ob3") # -Ob3 was introduced in Visual Studio 2019 version 16.0
     set(QT_CFLAGS_OPTIMIZE_DEBUG "-Od")
     set(QT_CFLAGS_OPTIMIZE_SIZE "-O1")
-    set(QT_CFLAGS_OPTIMIZE_VALID_VALUES "/O2" "/O1" "/Od" "/Ob0" "/Ob1" "/Ob2" "/O0" "-O0")
+    set(QT_CFLAGS_OPTIMIZE_VALID_VALUES "/O2" "/O1" "/Od" "/Ob0" "/Ob1" "/Ob2" "/Ob3" "/O0" "-O0")
 
     if(CLANG)
         set(QT_CFLAGS_OPTIMIZE_FULL "/clang:-O3")
@@ -124,5 +124,5 @@ endif()
 # Emscripten Clang
 if(WASM)
     set(QT_CFLAGS_OPTIMIZE_DEBUG "-O2 -g") # -Og is not supported
-    set(QT_CFLAGS_SSE2 -O2 -msimd128 -msse -msse2)
+    set(QT_CFLAGS_SSE2 "-O2 -msimd128 -msse -msse2")
 endif()

cmake/QtConfig.cmake.in

@@ -29,13 +29,12 @@ list(APPEND CMAKE_MODULE_PATH "${_qt_import_prefix}")
 list(APPEND CMAKE_MODULE_PATH "${_qt_import_prefix}/3rdparty/extra-cmake-modules/find-modules")
 list(APPEND CMAKE_MODULE_PATH "${_qt_import_prefix}/3rdparty/kwin")
 
-if(APPLE AND (NOT CMAKE_SYSTEM_NAME OR CMAKE_SYSTEM_NAME STREQUAL "Darwin"))
-    # Add module directory to pick up custom Info.plist template for macOS
-    list(APPEND CMAKE_MODULE_PATH "${_qt_import_prefix}/macos")
-elseif(APPLE AND CMAKE_SYSTEM_NAME STREQUAL "iOS")
-    # Add module directory to pick up custom Info.plist template for iOS
-    set(__qt_internal_cmake_ios_support_files_path "${_qt_import_prefix}/ios")
-    list(APPEND CMAKE_MODULE_PATH "${__qt_internal_cmake_ios_support_files_path}")
+if(APPLE)
+    if(NOT CMAKE_SYSTEM_NAME OR CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+        set(__qt_internal_cmake_apple_support_files_path "${_qt_import_prefix}/macos")
+    elseif(CMAKE_SYSTEM_NAME STREQUAL "iOS")
+        set(__qt_internal_cmake_apple_support_files_path "${_qt_import_prefix}/ios")
+    endif()
 endif()
 
 # Public helpers available to all Qt packages.

cmake/QtExecutableHelpers.cmake

@@ -30,6 +30,7 @@ function(qt_internal_add_executable name)
     endif()
 
     _qt_internal_create_executable(${name})
+    qt_internal_mark_as_internal_target(${name})
     if(ANDROID)
         _qt_internal_android_executable_finalizer(${name})
     endif()
@@ -119,6 +120,7 @@ function(qt_internal_add_executable name)
     qt_internal_extend_target("${name}"
         ${arg_NO_UNITY_BUILD}
         SOURCES ${arg_SOURCES}
+        NO_PCH_SOURCES ${arg_NO_PCH_SOURCES}
         NO_UNITY_BUILD_SOURCES ${arg_NO_UNITY_BUILD_SOURCES}
         INCLUDE_DIRECTORIES ${private_includes}
         DEFINES ${arg_DEFINES}
@@ -146,7 +148,7 @@ function(qt_internal_add_executable name)
 
     if(WASM)
         # WASM unconditionally sets DISABLE_EXCEPTION_CATCHING=1
-        qt_internal_set_exceptions_flags("${name}" NO_EXCEPTIONS)
+        qt_internal_set_exceptions_flags("${name}" FALSE)
     else()
         qt_internal_set_exceptions_flags("${name}" ${arg_EXCEPTIONS})
     endif()
@@ -369,6 +371,7 @@ function(qt_internal_add_configure_time_executable target)
     set(target_binary_dir "${CMAKE_CURRENT_BINARY_DIR}/configure_time_bins")
     if(arg_CONFIG)
         set(CMAKE_TRY_COMPILE_CONFIGURATION "${arg_CONFIG}")
+        string(TOUPPER "_${arg_CONFIG}" config_suffix)
     endif()
 
     get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG)
@@ -419,7 +422,7 @@ function(qt_internal_add_configure_time_executable target)
     )
 
     set(should_build_at_configure_time TRUE)
-    if(EXISTS "${target_binary_path}")
+    if(EXISTS "${target_binary_path}" AND EXISTS "${timestamp_file}")
         set(last_ts 0)
         foreach(source IN LISTS sources)
             file(TIMESTAMP "${source}" ts "%s")
@@ -462,6 +465,29 @@ function(qt_internal_add_configure_time_executable target)
             set(cmake_flags_arg CMAKE_FLAGS "${arg_CMAKE_FLAGS}")
         endif()
         configure_file("${template}" "${target_binary_dir}/CMakeLists.txt" @ONLY)
+
+        qt_internal_get_enabled_languages_for_flag_manipulation(enabled_languages)
+        foreach(lang IN LISTS enabled_languages)
+            set(compiler_flags_var "CMAKE_${lang}_FLAGS")
+            list(APPEND cmake_flags_arg "-D${compiler_flags_var}:STRING=${${compiler_flags_var}}")
+            if(arg_CONFIG)
+                set(compiler_flags_var_config "${compiler_flags_var}${config_suffix}")
+                list(APPEND cmake_flags_arg
+                    "-D${compiler_flags_var_config}:STRING=${${compiler_flags_var_config}}")
+            endif()
+        endforeach()
+
+        qt_internal_get_target_link_types_for_flag_manipulation(target_link_types)
+        foreach(linker_type IN LISTS target_link_types)
+            set(linker_flags_var "CMAKE_${linker_type}_LINKER_FLAGS")
+            list(APPEND cmake_flags_arg "-D${linker_flags_var}:STRING=${${linker_flags_var}}")
+            if(arg_CONFIG)
+                set(linker_flags_var_config "${linker_flags_var}${config_suffix}")
+                list(APPEND cmake_flags_arg
+                    "-D${linker_flags_var_config}:STRING=${${linker_flags_var_config}}")
+            endif()
+        endforeach()
+
         try_compile(result
             "${target_binary_dir}"
             "${target_binary_dir}"

cmake/QtFeature.cmake

@@ -177,15 +177,20 @@ function(qt_evaluate_config_expression resultVar)
     set(${resultVar} ${result} PARENT_SCOPE)
 endfunction()
 
+function(_qt_internal_get_feature_condition_keywords out_var)
+    set(keywords "EQUAL" "LESS" "LESS_EQUAL" "GREATER" "GREATER_EQUAL" "STREQUAL" "STRLESS"
+        "STRLESS_EQUAL" "STRGREATER" "STRGREATER_EQUAL" "VERSION_EQUAL" "VERSION_LESS"
+        "VERSION_LESS_EQUAL" "VERSION_GREATER" "VERSION_GREATER_EQUAL" "MATCHES"
+        "EXISTS" "COMMAND" "DEFINED" "NOT" "AND" "OR" "TARGET" "EXISTS" "IN_LIST" "(" ")")
+    set(${out_var} "${keywords}" PARENT_SCOPE)
+endfunction()
+
 function(_qt_internal_dump_expression_values expression_dump expression)
     set(dump "")
     set(skipNext FALSE)
     set(isTargetExpression FALSE)
 
-    set(keywords "EQUAL" "LESS" "LESS_EQUAL" "GREATER" "GREATER_EQUAL" "STREQUAL" "STRLESS"
-        "STRLESS_EQUAL" "STRGREATER" "STRGREATER_EQUAL" "VERSION_EQUAL" "VERSION_LESS"
-        "VERSION_LESS_EQUAL" "VERSION_GREATER" "VERSION_GREATER_EQUAL" "MATCHES"
-        "EXISTS" "COMMAND" "DEFINED" "NOT" "AND" "OR" "TARGET" "EXISTS" "IN_LIST" "(" ")")
+    _qt_internal_get_feature_condition_keywords(keywords)
 
     list(LENGTH expression length)
     math(EXPR length "${length}-1")
@@ -239,19 +244,44 @@ endfunction()
 # ${computed} is also stored when reconfiguring and the condition does not align with the user
 # provided value.
 #
-function(qt_feature_check_and_save_user_provided_value resultVar feature condition computed label)
+function(qt_feature_check_and_save_user_provided_value
+        resultVar feature condition condition_expression computed label)
     if (DEFINED "FEATURE_${feature}")
         # Revisit new user provided value
         set(user_value "${FEATURE_${feature}}")
-        string(TOUPPER "${user_value}" result)
+        string(TOUPPER "${user_value}" user_value_upper)
+        set(result "${user_value_upper}")
 
-        # If the build is marked as dirty and the user_value doesn't meet the new condition,
-        # reset it to the computed one.
+        # If ${feature} depends on another dirty feature, reset the ${feature} value to
+        # ${computed}.
         get_property(dirty_build GLOBAL PROPERTY _qt_dirty_build)
-        if(NOT condition AND result AND dirty_build)
+        if(dirty_build)
+            _qt_internal_feature_compute_feature_dependencies(deps "${feature}")
+            if(deps)
+                get_property(dirty_features GLOBAL PROPERTY _qt_dirty_features)
+                foreach(dirty_feature ${dirty_features})
+                    if(dirty_feature IN_LIST deps AND NOT "${result}" STREQUAL "${computed}")
                         set(result "${computed}")
-            message(WARNING "Reset FEATURE_${feature} value to ${result}, because it doesn't \
-meet its condition after reconfiguration.")
+                        message(WARNING
+                            "Auto-resetting 'FEATURE_${feature}' from '${user_value_upper}' to "
+                            "'${computed}', "
+                            "because the dependent feature '${dirty_feature}' was marked dirty.")
+
+                        # Append ${feature} as a new dirty feature.
+                        set_property(GLOBAL APPEND PROPERTY _qt_dirty_features "${feature}")
+                        break()
+                    endif()
+                endforeach()
+            endif()
+
+            # If the build is marked as dirty and the feature doesn't meet its condition,
+            # reset its value to the computed one, which is likely OFF.
+            if(NOT condition AND result)
+                set(result "${computed}")
+                message(WARNING "Resetting 'FEATURE_${feature}' from '${user_value_upper}' to "
+                    "'${computed}' because it doesn't meet its condition after reconfiguration. "
+                    "Condition expression is: '${condition_expression}'")
+            endif()
         endif()
 
         set(bool_values OFF NO FALSE N ON YES TRUE Y)
@@ -299,6 +329,14 @@ condition:\n    ${conditionString}\nCondition values dump:\n    ${conditionDump}
     set(QT_KNOWN_FEATURES "${QT_KNOWN_FEATURES}" CACHE INTERNAL "" FORCE)
 endmacro()
 
+macro(_qt_internal_parse_feature_definition feature)
+    cmake_parse_arguments(arg
+        "PRIVATE;PUBLIC"
+        "LABEL;PURPOSE;SECTION;"
+        "AUTODETECT;CONDITION;ENABLE;DISABLE;EMIT_IF"
+        ${_QT_FEATURE_DEFINITION_${feature}})
+endmacro()
+
 
 # The build system stores 2 CMake cache variables for each feature, to allow detecting value changes
 # during subsequent reconfigurations.
@@ -334,9 +372,7 @@ function(qt_evaluate_feature feature)
         message(FATAL_ERROR "Attempting to evaluate feature ${feature} but its definition is missing. Either the feature does not exist or a dependency to the module that defines it is missing")
     endif()
 
-    cmake_parse_arguments(arg
-        "PRIVATE;PUBLIC"
-        "LABEL;PURPOSE;SECTION;" "AUTODETECT;CONDITION;ENABLE;DISABLE;EMIT_IF" ${_QT_FEATURE_DEFINITION_${feature}})
+    _qt_internal_parse_feature_definition("${feature}")
 
     if("${arg_ENABLE}" STREQUAL "")
         set(arg_ENABLE OFF)
@@ -374,16 +410,7 @@ function(qt_evaluate_feature feature)
         qt_evaluate_config_expression(emit_if ${arg_EMIT_IF})
     endif()
 
-    # If FEATURE_ is not defined trying to use INPUT_ variable to enable/disable feature.
-    if ((NOT DEFINED "FEATURE_${feature}") AND (DEFINED "INPUT_${feature}")
-        AND (NOT "${INPUT_${feature}}" STREQUAL "undefined")
-        AND (NOT "${INPUT_${feature}}" STREQUAL ""))
-        if(INPUT_${feature})
-            set(FEATURE_${feature} ON)
-        else()
-            set(FEATURE_${feature} OFF)
-        endif()
-    endif()
+    qt_internal_compute_feature_value_from_possible_input("${feature}")
 
     # Warn about a feature which is not emitted, but the user explicitly provided a value for it.
     if(NOT emit_if AND DEFINED FEATURE_${feature})
@@ -401,7 +428,8 @@ function(qt_evaluate_feature feature)
     # Only save the user provided value if the feature was emitted.
     if(emit_if)
         qt_feature_check_and_save_user_provided_value(
-            saved_user_value "${feature}" "${condition}" "${computed}" "${arg_LABEL}")
+            saved_user_value
+            "${feature}" "${condition}" "${arg_CONDITION}" "${computed}" "${arg_LABEL}")
     else()
         # Make sure the feature internal value is OFF if not emitted.
         set(saved_user_value OFF)
@@ -414,6 +442,60 @@ function(qt_evaluate_feature feature)
     set(QT_FEATURE_LABEL_${feature} "${arg_LABEL}" CACHE INTERNAL "")
 endfunction()
 
+# Collect feature names that ${feature} depends on, by inspecting the given expression.
+function(_qt_internal_feature_extract_feature_dependencies_from_expression out_var expression)
+    list(LENGTH expression length)
+    math(EXPR length "${length}-1")
+
+    if(length LESS 0)
+        set(${out_var} "" PARENT_SCOPE)
+        return()
+    endif()
+
+    set(deps "")
+
+    foreach(memberIdx RANGE ${length})
+        list(GET expression ${memberIdx} member)
+        if(member MATCHES "^QT_FEATURE_(.+)")
+            list(APPEND deps "${CMAKE_MATCH_1}")
+        endif()
+    endforeach()
+    set(${out_var} "${deps}" PARENT_SCOPE)
+endfunction()
+
+# Collect feature names that ${feature} depends on, based on feature names that appear
+# in the ${feature}'s condition expressions.
+function(_qt_internal_feature_compute_feature_dependencies out_var feature)
+    # Only compute the deps once per feature.
+    get_property(deps_computed GLOBAL PROPERTY _qt_feature_deps_computed_${feature})
+    if(deps_computed)
+        get_property(deps GLOBAL PROPERTY _qt_feature_deps_${feature})
+        set(${out_var} "${deps}" PARENT_SCOPE)
+        return()
+    endif()
+
+    _qt_internal_parse_feature_definition("${feature}")
+
+    set(options_to_check AUTODETECT CONDITION ENABLE DISABLE EMIT_IF)
+    set(deps "")
+
+    # Go through each option that takes condition expressions and collect the feature names.
+    foreach(option ${options_to_check})
+        set(option_value "${arg_${option}}")
+        if(option_value)
+            _qt_internal_feature_extract_feature_dependencies_from_expression(
+                option_deps "${option_value}")
+            if(option_deps)
+                list(APPEND deps ${option_deps})
+            endif()
+        endif()
+    endforeach()
+
+    set_property(GLOBAL PROPERTY _qt_feature_deps_computed_${feature} TRUE)
+    set_property(GLOBAL PROPERTY _qt_feature_deps_${feature} "${deps}")
+    set(${out_var} "${deps}" PARENT_SCOPE)
+endfunction()
+
 function(qt_feature_config feature config_var_name)
     qt_feature_normalize_name("${feature}" feature)
     cmake_parse_arguments(PARSE_ARGV 2 arg
@@ -786,6 +868,49 @@ function(qt_feature_copy_global_config_features_to_core target)
     endif()
 endfunction()
 
+function(qt_internal_detect_dirty_features)
+    # We need to clean up QT_FEATURE_*, but only once per configuration cycle
+    get_property(qt_feature_clean GLOBAL PROPERTY _qt_feature_clean)
+    if(NOT qt_feature_clean AND NOT QT_NO_FEATURE_AUTO_RESET)
+        message(STATUS "Checking for feature set changes")
+        set_property(GLOBAL PROPERTY _qt_feature_clean TRUE)
+        foreach(feature ${QT_KNOWN_FEATURES})
+            qt_internal_compute_feature_value_from_possible_input("${feature}")
+
+            if(DEFINED "FEATURE_${feature}" AND
+                NOT "${QT_FEATURE_${feature}}" STREQUAL "${FEATURE_${feature}}")
+                message("    '${feature}' was changed from ${QT_FEATURE_${feature}} "
+                    "to ${FEATURE_${feature}}")
+                set(dirty_build TRUE)
+                set_property(GLOBAL APPEND PROPERTY _qt_dirty_features "${feature}")
+            endif()
+            unset("QT_FEATURE_${feature}" CACHE)
+        endforeach()
+
+        set(QT_KNOWN_FEATURES "" CACHE INTERNAL "" FORCE)
+
+        if(dirty_build)
+            set_property(GLOBAL PROPERTY _qt_dirty_build TRUE)
+            message(WARNING
+                "Due to detected feature set changes, dependent features "
+                "will be re-computed automatically. This might cause a lot of files to be rebuilt. "
+                "To disable this behavior, configure with -DQT_NO_FEATURE_AUTO_RESET=ON")
+        endif()
+    endif()
+endfunction()
+
+function(qt_internal_clean_feature_inputs)
+    foreach(feature IN LISTS QT_KNOWN_FEATURES)
+        # Unset the INPUT_foo cache variables after they were used in feature evaluation, to
+        # ensure stale values don't influence features upon reconfiguration when
+        # QT_INTERNAL_CALLED_FROM_CONFIGURE is TRUE and the INPUT_foo variable is not passed.
+        # e.g. first configure -no-gui, then manually toggle FEATURE_gui to ON in
+        # CMakeCache.txt, then reconfigure (with the configure script) without -no-gui.
+        # Without this unset(), we'd have switched FEATURE_gui to OFF again.
+        unset(INPUT_${feature} CACHE)
+    endforeach()
+endfunction()
+
 function(qt_config_compile_test name)
     if(DEFINED "TEST_${name}")
         return()
@@ -924,6 +1049,7 @@ function(qt_config_compile_test name)
                 # fail instead of cmake abort later via CMAKE_REQUIRED_LIBRARIES.
                 string(FIND "${library}" "::" cmake_target_namespace_separator)
                 if(NOT cmake_target_namespace_separator EQUAL -1)
+                    message(STATUS "Performing Test ${arg_LABEL} - Failed because ${library} not found")
                     set(HAVE_${name} FALSE)
                     break()
                 endif()

cmake/QtFindPackageHelpers.cmake

@@ -16,6 +16,15 @@ function(qt_find_package_promote_targets_to_global_scope target)
                             "qt_find_package_targets_dict" "promote_global")
 endfunction()
 
+# As an optimization when using -developer-build, qt_find_package records which
+# packages were found during the initial configuration. Then on subsequent
+# reconfigurations it skips looking for packages that were not found on the
+# initial run.
+# For the build system to pick up a newly added qt_find_package call, you need to:
+# - Start with a clean build dir
+# - Or remove the <builddir>/CMakeCache.txt file and configure from scratch
+# - Or remove the QT_INTERNAL_PREVIOUSLY_FOUND_PACKAGES cache variable (by
+#   editing CMakeCache.txt) and reconfigure.
 macro(qt_find_package)
     # Get the target names we expect to be provided by the package.
     set(find_package_options CONFIG NO_MODULE MODULE REQUIRED)
@@ -41,10 +50,13 @@ macro(qt_find_package)
     # Due to this behavior being different from what general CMake projects expect, it is only
     # done for -developer-builds.
     if(QT_INTERNAL_PREVIOUSLY_FOUND_PACKAGES AND
-            NOT "${ARGV0}" IN_LIST QT_INTERNAL_PREVIOUSLY_FOUND_PACKAGES)
+            NOT "${ARGV0}" IN_LIST QT_INTERNAL_PREVIOUSLY_FOUND_PACKAGES
+            AND "${ARGV0}" IN_LIST QT_INTERNAL_PREVIOUSLY_SEARCHED_PACKAGES)
         set(_qt_find_package_skip_find_package TRUE)
     endif()
 
+    set_property(GLOBAL APPEND PROPERTY _qt_previously_searched_packages "${ARGV0}")
+
     if(QT_DEBUG_QT_FIND_PACKAGE AND ${ARGV0}_FOUND AND arg_PROVIDED_TARGETS)
         set(_qt_find_package_skip_find_package TRUE)
         foreach(qt_find_package_target_name ${arg_PROVIDED_TARGETS})
@@ -221,7 +233,7 @@ endmacro()
 # Only applies to -developer-builds by default.
 # Can also be opted in or opted out via QT_INTERNAL_SAVE_PREVIOUSLY_FOUND_PACKAGES.
 # Opting out will need two reconfigurations to take effect.
-function(qt_internal_save_previously_found_packages)
+function(qt_internal_save_previously_visited_packages)
     if(DEFINED QT_INTERNAL_SAVE_PREVIOUSLY_FOUND_PACKAGES)
         set(should_save "${QT_INTERNAL_SAVE_PREVIOUSLY_FOUND_PACKAGES}")
     else()
@@ -235,6 +247,7 @@ function(qt_internal_save_previously_found_packages)
     if(NOT should_save)
         # When the value is flipped to OFF, remove any previously saved packages.
         unset(QT_INTERNAL_PREVIOUSLY_FOUND_PACKAGES CACHE)
+        unset(QT_INTERNAL_PREVIOUSLY_SEARCHED_PACKAGES CACHE)
         return()
     endif()
 
@@ -244,6 +257,15 @@ function(qt_internal_save_previously_found_packages)
         set(QT_INTERNAL_PREVIOUSLY_FOUND_PACKAGES "${_qt_previously_found_packages}" CACHE INTERNAL
             "List of CMake packages found during configuration using qt_find_package.")
     endif()
+
+    get_property(_qt_previously_searched_packages GLOBAL PROPERTY _qt_previously_searched_packages)
+    if(_qt_previously_searched_packages)
+        list(REMOVE_DUPLICATES _qt_previously_searched_packages)
+        set(QT_INTERNAL_PREVIOUSLY_SEARCHED_PACKAGES
+            "${_qt_previously_searched_packages}" CACHE INTERNAL
+            "List of CMake packages searched during configuration using qt_find_package."
+        )
+    endif()
 endfunction()
 
 # Return qmake library name for the given target, e.g. return "vulkan" for "Vulkan::Vulkan".

cmake/QtFlagHandlingHelpers.cmake

@@ -33,22 +33,15 @@ function(qt_internal_add_linker_version_script target)
         endif()
         string(APPEND contents "};\n")
         set(current "Qt_${PROJECT_VERSION_MAJOR}")
-        if (QT_NAMESPACE STREQUAL "")
-            set(tag_symbol "qt_version_tag")
-        else()
-            set(tag_symbol "qt_version_tag_${QT_NAMESPACE}")
-        endif()
         string(APPEND contents "${current} { *; };\n")
 
-        foreach(minor_version RANGE ${PROJECT_VERSION_MINOR})
-            set(previous "${current}")
-            set(current "Qt_${PROJECT_VERSION_MAJOR}.${minor_version}")
-            if (minor_version EQUAL ${PROJECT_VERSION_MINOR})
-                string(APPEND contents "${current} { ${tag_symbol}; } ${previous};\n")
-            else()
-                string(APPEND contents "${current} {} ${previous};\n")
+        get_target_property(type ${target} TYPE)
+        if(NOT target_type STREQUAL "INTERFACE_LIBRARY")
+            set(property_genex "$<TARGET_PROPERTY:${target},_qt_extra_linker_script_content>")
+            set(check_genex "$<BOOL:${property_genex}>")
+            string(APPEND contents
+                "$<${check_genex}:${property_genex}>")
         endif()
-        endforeach()
 
         set(infile "${CMAKE_CURRENT_BINARY_DIR}/${target}.version.in")
         set(outfile "${CMAKE_CURRENT_BINARY_DIR}/${target}.version")
@@ -87,6 +80,11 @@ function(qt_internal_add_link_flags_no_undefined target)
     if (NOT QT_BUILD_SHARED_LIBS OR WASM)
         return()
     endif()
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+        # ld64 defaults to -undefined,error, and in Xcode 15
+        # passing this option is deprecated, causing a warning.
+        return()
+    endif()
     if ((GCC OR CLANG) AND NOT MSVC)
         if(CLANG AND QT_FEATURE_sanitizer)
             return()
@@ -124,11 +122,20 @@ endfunction()
 
 function(qt_internal_apply_gc_binaries target visibility)
     set(possible_visibilities PRIVATE INTERFACE PUBLIC)
-    list(FIND possible_visibilities "${visibility}" known_visibility)
-    if (known_visibility EQUAL "-1")
+    if(NOT visibility IN_LIST possible_visibilities)
         message(FATAL_ERROR "Visibitily setting must be one of PRIVATE, INTERFACE or PUBLIC.")
     endif()
 
+    string(JOIN "" clang_or_gcc_begin
+        "$<$<OR:"
+            "$<CXX_COMPILER_ID:GNU>,"
+            "$<CXX_COMPILER_ID:Clang>,"
+            "$<CXX_COMPILER_ID:AppleClang>,"
+            "$<CXX_COMPILER_ID:IntelLLVM>"
+        ">:"
+    )
+    set(clang_or_gcc_end ">")
+
     if ((GCC OR CLANG) AND NOT WASM AND NOT UIKIT AND NOT MSVC)
         if(APPLE)
             set(gc_sections_flag "-Wl,-dead_strip")
@@ -137,16 +144,26 @@ function(qt_internal_apply_gc_binaries target visibility)
         elseif(LINUX OR BSD OR WIN32 OR ANDROID)
             set(gc_sections_flag "-Wl,--gc-sections")
         endif()
+
+        # Save the flag value with and without genex wrapping, so we can remove the wrapping
+        # when generating .pc pkgconfig files.
+        set_property(GLOBAL PROPERTY _qt_internal_gc_sections_without_genex "${gc_sections_flag}")
+
+        set(gc_sections_flag
+            "${clang_or_gcc_begin}${gc_sections_flag}${clang_or_gcc_end}")
+
+        set_property(GLOBAL PROPERTY _qt_internal_gc_sections_with_genex "${gc_sections_flag}")
     endif()
     if(gc_sections_flag)
         target_link_options("${target}" ${visibility} "${gc_sections_flag}")
     endif()
 
     if((GCC OR CLANG) AND NOT WASM AND NOT UIKIT AND NOT MSVC)
-        set(split_sections_flags "-ffunction-sections" "-fdata-sections")
+        set(split_sections_flags
+            "${clang_or_gcc_begin}-ffunction-sections;-fdata-sections${clang_or_gcc_end}")
     endif()
     if(split_sections_flags)
-        target_compile_options("${target}" ${visibility} ${split_sections_flags})
+        target_compile_options("${target}" ${visibility} "${split_sections_flags}")
     endif()
 endfunction()
 
@@ -156,13 +173,17 @@ function(qt_internal_apply_intel_cet target visibility)
     endif()
 
     set(possible_visibilities PRIVATE INTERFACE PUBLIC)
-    list(FIND possible_visibilities "${visibility}" known_visibility)
-    if (known_visibility EQUAL "-1")
+    if(NOT visibility IN_LIST possible_visibilities)
         message(FATAL_ERROR "Visibitily setting must be one of PRIVATE, INTERFACE or PUBLIC.")
     endif()
 
     if(GCC)
-        set(flags "-mshstk")
+        string(JOIN "" flags
+            "$<$<OR:"
+                "$<CXX_COMPILER_ID:GNU>,"
+                "$<CXX_COMPILER_ID:Clang>,"
+                "$<CXX_COMPILER_ID:AppleClang>"
+            ">:-mshstk>")
     endif()
     if(flags)
         target_compile_options("${target}" ${visibility} "${flags}")
@@ -287,14 +308,15 @@ function(qt_set_msvc_cplusplus_options target visibility)
     # Check qt_config_compile_test for more info.
     if(MSVC AND MSVC_VERSION GREATER_EQUAL 1913)
         set(flags "-Zc:__cplusplus" "-permissive-")
-        target_compile_options("${target}" ${visibility} "$<$<COMPILE_LANGUAGE:CXX>:${flags}>")
+        target_compile_options("${target}" ${visibility}
+            "$<$<AND:$<CXX_COMPILER_ID:MSVC>,$<COMPILE_LANGUAGE:CXX>>:${flags}>")
     endif()
 endfunction()
 
 function(qt_enable_utf8_sources target)
     set(utf8_flags "")
     if(MSVC)
-        list(APPEND utf8_flags "-utf-8")
+        list(APPEND utf8_flags "$<$<CXX_COMPILER_ID:MSVC>:-utf-8>")
     endif()
 
     if(utf8_flags)
@@ -557,12 +579,20 @@ endfunction()
 
 # Removes specified flags from CMAKE_<LANGUAGES>_FLAGS[_CONFIGS] variables
 #
-# IN_CACHE enables flags removal from CACHE
-# CONFIGS list of configurations that need to clear flags. Clears all configs by default if not
+# Option Arguments:
+#   IN_CACHE
+#       Enables flags removal from CACHE
+#   REGEX
+#       Enables the flag processing as a regular expression.
+#
+# Multi-value Arguments:
+#   CONFIGS
+#       List of configurations that need to clear flags. Clears all configs by default if not
 #       specified.
-# LANGUAGES list of LANGUAGES that need clear flags. Clears all languages by default if not
+#
+#   LANGUAGES
+#       List of LANGUAGES that need clear flags. Clears all languages by default if not
 #       specified.
-# REGEX enables the flag processing as a regular expression.
 function(qt_internal_remove_compiler_flags flags)
     cmake_parse_arguments(PARSE_ARGV 1 arg
         "IN_CACHE;REGEX"
@@ -585,8 +615,7 @@ function(qt_internal_remove_compiler_flags flags)
     if(arg_CONFIGS)
         set(configs "${arg_CONFIGS}")
     else()
-        message(FATAL_ERROR
-                "You must specify at least one configuration for which to remove the flags.")
+        qt_internal_get_configs_for_flag_manipulation(configs)
     endif()
 
     if(arg_REGEX)
@@ -992,14 +1021,42 @@ function(qt_internal_set_up_config_optimizations_like_in_qmake)
                 IN_CACHE)
     endif()
 
+    # Legacy Android toolchain file adds the `-g` flag to CMAKE_<LANG>_FLAGS, as a
+    # result, our release build ends up containing debug symbols. To avoid that, we
+    # remove the flag from CMAKE_<LANGL>_FLAGS and add
+    # it to CMAKE_<LANG>_FLAGS_DEBUG.
+    #
+    # Note:
+    #   The new `android.toolchain.cmake` file does not have this problem, but
+    #   it has other issues, eg., https://github.com/android/ndk/issues/1693, so we
+    #   cannot force it. While we do load the new toolchain, it automatically falls
+    #   back to the legacy toolchain, ie., `android-legacy.toolchain.cmake` which
+    #   has the problem described above.
+    #
+    # Todo:
+    #   When the new toolchain is fixed, and it doesn't fall back to the legacy
+    #   anymore by default, then we should be able to remove this workaround.
+    if(ANDROID AND ANDROID_COMPILER_FLAGS MATCHES "(^| )-g")
+        qt_internal_remove_compiler_flags("-g")
+        qt_internal_add_compiler_flags(FLAGS "-g" CONFIGS DEBUG RELWITHDEBINFO)
+    endif()
+
     # Update all relevant flags in the calling scope
-    foreach(config ${configs})
     foreach(lang ${enabled_languages})
+        set(flag_var_name "CMAKE_${lang}_FLAGS")
+        set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE)
+
+        foreach(config ${configs})
             set(flag_var_name "CMAKE_${lang}_FLAGS_${config}")
             set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE)
         endforeach()
+    endforeach()
 
     foreach(t ${target_link_types})
+        set(flag_var_name "CMAKE_${t}_LINKER_FLAGS")
+        set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE)
+
+        foreach(config ${configs})
             set(flag_var_name "CMAKE_${t}_LINKER_FLAGS_${config}")
             set(${flag_var_name} "${${flag_var_name}}" PARENT_SCOPE)
         endforeach()

cmake/QtFrameworkHelpers.cmake

@@ -4,6 +4,7 @@
 macro(qt_find_apple_system_frameworks)
     if(APPLE)
         qt_internal_find_apple_system_framework(FWAppKit AppKit)
+        qt_internal_find_apple_system_framework(FWCFNetwork CFNetwork)
         qt_internal_find_apple_system_framework(FWAssetsLibrary AssetsLibrary)
         qt_internal_find_apple_system_framework(FWPhotos Photos)
         qt_internal_find_apple_system_framework(FWAudioToolbox AudioToolbox)
@@ -58,7 +59,7 @@ function(qt_internal_find_apple_system_framework out_var framework_name)
     endif()
 endfunction()
 
-# Copy header files to QtXYZ.framework/Versions/A/Headers/
+# Copy header files to the framework's Headers directory
 # Use this function for header files that
 #   - are not added as source files to the target
 #   - are not marked as PUBLIC_HEADER
@@ -71,7 +72,7 @@ function(qt_copy_framework_headers target)
 
     set(options)
     set(oneValueArgs)
-    set(multiValueArgs PUBLIC PRIVATE QPA)
+    set(multiValueArgs PUBLIC PRIVATE QPA RHI)
     cmake_parse_arguments(arg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
     qt_internal_get_framework_info(fw ${target})
@@ -79,10 +80,11 @@ function(qt_copy_framework_headers target)
     set(output_dir_PUBLIC "${output_dir}/${fw_versioned_header_dir}")
     set(output_dir_PRIVATE "${output_dir}/${fw_private_module_header_dir}/private")
     set(output_dir_QPA "${output_dir}/${fw_private_module_header_dir}/qpa")
+    set(output_dir_RHI "${output_dir}/${fw_private_module_header_dir}/rhi")
 
 
     set(out_files)
-    foreach(type IN ITEMS PUBLIC PRIVATE QPA)
+    foreach(type IN ITEMS PUBLIC PRIVATE QPA RHI)
         set(fw_output_header_dir "${output_dir_${type}}")
         foreach(hdr IN LISTS arg_${type})
             get_filename_component(in_file_path ${hdr} ABSOLUTE)
@@ -164,8 +166,13 @@ function(qt_internal_get_framework_info out_var target)
     set(${out_var}_name "${module}")
     set(${out_var}_dir "${${out_var}_name}.framework")
     set(${out_var}_header_dir "${${out_var}_dir}/Headers")
+    if(UIKIT)
+        # iOS frameworks do not version their headers
+        set(${out_var}_versioned_header_dir "${${out_var}_header_dir}")
+    else()
         set(${out_var}_versioned_header_dir "${${out_var}_dir}/Versions/${${out_var}_version}/Headers")
-    set(${out_var}_private_header_dir "${${out_var}_header_dir}/${${out_var}_bundle_version}")
+    endif()
+    set(${out_var}_private_header_dir "${${out_var}_versioned_header_dir}/${${out_var}_bundle_version}")
     set(${out_var}_private_module_header_dir "${${out_var}_private_header_dir}/${module}")
 
     set(${out_var}_name "${${out_var}_name}" PARENT_SCOPE)

cmake/QtHeadersClean.cmake

@@ -104,6 +104,7 @@ function(qt_internal_add_headersclean_target module_target module_headers)
 
         set(hcleanFLAGS -Wall -Wextra -Werror -Woverloaded-virtual -Wshadow -Wundef -Wfloat-equal
             -Wnon-virtual-dtor -Wpointer-arith -Wformat-security -Wno-long-long -Wno-variadic-macros
+            -fno-operator-names
             -pedantic-errors)
 
         if(QT_FEATURE_reduce_relocations AND UNIX)
@@ -181,9 +182,10 @@ function(qt_internal_add_headersclean_target module_target module_headers)
         )
         set(input_header_path_type ABSOLUTE)
     elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-        # -Za would enable strict standards behavior, but we can't add it because
-        # <windows.h> and <GL.h> violate the standards.
-        set(hcleanFLAGS -std:c++latest -Zc:__cplusplus -WX -W3)
+        set(hcleanFLAGS -std:c++latest -Zc:__cplusplus -WX -W3 -EHsc)
+
+        # Because we now add `-DNOMINMAX` to `PlatformCommonInternal`.
+        set(hcleanUDEFS -UNOMINMAX)
 
         # cl.exe needs a source path
         get_filename_component(source_path "${QT_MKSPECS_DIR}/features/data/dummy.cpp" REALPATH)
@@ -195,6 +197,7 @@ function(qt_internal_add_headersclean_target module_target module_headers)
             "${hcleanFLAGS}"
             "${target_includes_joined_genex}"
             "${hcleanDEFS}"
+            "${hcleanUDEFS}"
         )
         string(JOIN " " compiler_command_line_variables
             "-FI"
@@ -227,7 +230,7 @@ function(qt_internal_add_headersclean_target module_target module_headers)
     file(GENERATE OUTPUT "${headers_check_parameters}"
         CONTENT "${headers_check_parameters_content}")
 
-    set(sync_headers_dep "sync_headers")
+    set(sync_headers_dep "${module_target}_sync_headers")
 
     foreach(header ${hclean_headers})
         # We need realpath here to make sure path starts with drive letter

cmake/QtInitProject.cmake

@@ -0,0 +1,214 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+cmake_minimum_required(VERSION 3.16)
+
+if(NOT PROJECT_DIR)
+    set(PROJECT_DIR "${CMAKE_SOURCE_DIR}")
+endif()
+
+get_filename_component(project_name "${PROJECT_DIR}" NAME)
+
+get_filename_component(project_abs_dir "${PROJECT_DIR}" ABSOLUTE)
+if(NOT IS_DIRECTORY "${project_abs_dir}")
+    message(FATAL_ERROR "Unable to scan ${project_abs_dir}. The directory doesn't exist.")
+endif()
+
+set(known_extensions "")
+set(types "")
+
+# The function allows extending the capabilities of this script and establishes simple relation
+# chains between the file types.
+# Option Arguments:
+#     EXPERIMENTAL
+#         Marks that the support of the following files is experimental and the required Qt modules
+#         are in Technical preview state.
+#     DEPRECATED
+#         Marks that the support of the following files will be discontinued soon and the required
+#         Qt modules are deprecated.
+# One-value Arguments:
+#     TEMPLATE
+#         The CMake code template. Use the '@files@' string for the files substitution.
+# Multi-value Arguments:
+#     EXTENSIONS
+#         List of the file extensions treated as this source 'type'.
+#     MODULES
+#         List of Qt modules required for these file types.
+#     DEPENDS
+#         The prerequisite source 'type' needed by this source 'type'
+macro(handle_type type)
+    cmake_parse_arguments(arg
+        "EXPERIMENTAL;DEPRECATED"
+        "TEMPLATE"
+        "EXTENSIONS;MODULES;DEPENDS"
+        ${ARGN}
+    )
+
+    if(NOT arg_EXTENSIONS)
+        message(FATAL_ERROR "Unexpected call handle_type of with no EXTENSIONS specified."
+            " This is the Qt issue, please report a bug at https://bugreports.qt.io.")
+    endif()
+    set(unique_extensions_subset "${known_extensions}")
+    list(REMOVE_ITEM unique_extensions_subset ${arg_EXTENSIONS})
+    if(NOT "${known_extensions}" STREQUAL "${unique_extensions_subset}")
+        message(FATAL_ERROR "${type} contains duplicated extensions, this is not supported."
+            " This is the Qt issue, please report a bug at https://bugreports.qt.io.")
+    endif()
+    set(${type}_file_extensions "${arg_EXTENSIONS}")
+
+    if(NOT arg_TEMPLATE)
+        message(FATAL_ERROR "Unexpected call handle_type of with no TEMPLATE specified."
+            " This is the Qt issue, please report a bug at https://bugreports.qt.io.")
+    endif()
+    set(${type}_template "${arg_TEMPLATE}")
+
+    if(arg_MODULES)
+        set(${type}_required_modules "${arg_MODULES}")
+    endif()
+
+    list(APPEND types ${type})
+
+    if(arg_EXPERIMENTAL)
+        set(${type}_is_experimental TRUE)
+    else()
+        set(${type}_is_experimental FALSE)
+    endif()
+
+    if(arg_DEPRECATED)
+        set(${type}_is_deprecated TRUE)
+    else()
+        set(${type}_is_deprecated FALSE)
+    endif()
+
+    if(arg_DEPENDS)
+        set(${type}_dependencies ${arg_DEPENDS})
+    endif()
+endmacro()
+
+handle_type(cpp EXTENSIONS .c .cc .cpp .cxx .h .hh .hxx .hpp MODULES Core TEMPLATE
+"\n\nqt_add_executable(${project_name}
+    @files@
+)"
+)
+
+handle_type(qml EXTENSIONS .qml .js .mjs MODULES Gui Qml Quick TEMPLATE
+"\n\nqt_add_qml_module(${project_name}
+    URI ${project_name}
+    OUTPUT_DIRECTORY qml
+    VERSION 1.0
+    RESOURCE_PREFIX /qt/qml
+    QML_FILES
+        @files@
+)"
+)
+
+handle_type(ui EXTENSIONS .ui MODULES Gui Widgets DEPENDS cpp TEMPLATE
+"\n\ntarget_sources(${project_name}
+    PRIVATE
+        @files@
+)"
+)
+
+handle_type(qrc EXTENSIONS .qrc DEPENDS cpp TEMPLATE
+"\n\nqt_add_resources(${project_name}_resources @files@)
+target_sources(${project_name}
+    PRIVATE
+        \\\${${project_name}_resources}
+)"
+)
+
+handle_type(protobuf EXPERIMENTAL EXTENSIONS .proto MODULES Protobuf Grpc TEMPLATE
+"\n\nqt_add_protobuf(${project_name}
+    GENERATE_PACKAGE_SUBFOLDERS
+    PROTO_FILES
+        @files@
+)"
+)
+
+set(extra_packages "")
+file(GLOB_RECURSE files RELATIVE "${project_abs_dir}" "${project_abs_dir}/*")
+foreach(f IN LISTS files)
+    get_filename_component(file_extension "${f}" LAST_EXT)
+    string(TOLOWER "${file_extension}" file_extension)
+
+    foreach(type IN LISTS types)
+        if(file_extension IN_LIST ${type}_file_extensions)
+            list(APPEND ${type}_sources "${f}")
+            list(APPEND packages ${${type}_required_modules})
+            if(${type}_is_experimental)
+                message("We found files with the following extensions in your directory:"
+                    " ${${type}_file_extensions}\n"
+                    "Note that the modules ${${type}_required_modules} are"
+                    " in the technical preview state.")
+            endif()
+            if(${type}_is_deprecated)
+                message("We found files with the following extensions in your directory:"
+                    " ${${type}_file_extensions}\n"
+                    "Note that the modules ${${type}_required_modules} are deprecated.")
+            endif()
+            break()
+        endif()
+    endforeach()
+endforeach()
+
+if(packages)
+    list(REMOVE_DUPLICATES packages)
+    list(JOIN packages " " packages_string)
+    list(JOIN packages "\n        Qt::" deps_string)
+    set(deps_string "Qt::${deps_string}")
+endif()
+
+set(content
+"cmake_minimum_required(VERSION 3.16)
+project(${project_name} LANGUAGES CXX)
+
+find_package(Qt6 REQUIRED COMPONENTS ${packages_string})
+qt_standard_project_setup()"
+)
+
+set(has_useful_sources FALSE)
+foreach(type IN LISTS types)
+    if(${type}_sources)
+        set(skip FALSE)
+        foreach(dep IN LISTS ${type}_dependencies)
+            if(NOT ${dep}_sources)
+                set(skip TRUE)
+                message("Sources of type ${${type}_file_extensions} cannot live in the project"
+                " without ${${dep}_file_extensions} files. Skipping.")
+                break()
+            endif()
+        endforeach()
+        if(skip)
+            continue()
+        endif()
+
+        set(has_useful_sources TRUE)
+        string(REGEX MATCH "( +)@files@" unused "${${type}_template}")
+        list(JOIN ${type}_sources "\n${CMAKE_MATCH_1}" ${type}_sources)
+        string(REPLACE "@files@" "${${type}_sources}" ${type}_content
+            "${${type}_template}")
+        string(APPEND content "${${type}_content}")
+    endif()
+endforeach()
+
+string(APPEND content "\n\ntarget_link_libraries(${project_name}
+    PRIVATE
+        ${deps_string}
+)\n"
+)
+
+if(EXISTS "${project_abs_dir}/CMakeLists.txt")
+    message(FATAL_ERROR "Project is already initialized in current directory."
+        " Please remove CMakeLists.txt if you want to regenerate the project.")
+endif()
+
+if(NOT has_useful_sources)
+    message(FATAL_ERROR "Could not find any files to generate the project.")
+endif()
+file(WRITE "${project_abs_dir}/CMakeLists.txt" "${content}")
+
+message("The project file is successfully generated. To build the project run:"
+    "\nmkdir build"
+    "\ncd build"
+    "\nqt-cmake ${project_abs_dir}"
+    "\ncmake --build ${project_abs_dir}"
+)

cmake/QtInternalTargets.cmake

@@ -102,7 +102,7 @@ function(qt_internal_add_global_definition definition)
     set(optional_args)
     set(single_value_args VALUE)
     set(multi_value_args SCOPE)
-    cmake_parse_arguments(args
+    cmake_parse_arguments(arg
         "${optional_args}"
         "${single_value_args}"
         "${multi_value_args}"
@@ -156,6 +156,8 @@ qt_internal_add_target_aliases(PlatformToolInternal)
 target_link_libraries(PlatformToolInternal INTERFACE PlatformAppInternal)
 
 qt_internal_add_global_definition(QT_NO_JAVA_STYLE_ITERATORS)
+qt_internal_add_global_definition(QT_NO_AS_CONST)
+qt_internal_add_global_definition(QT_NO_QEXCHANGE)
 qt_internal_add_global_definition(QT_NO_NARROWING_CONVERSIONS_IN_CONNECT)
 qt_internal_add_global_definition(QT_EXPLICIT_QFILE_CONSTRUCTION_FROM_PATH)
 
@@ -168,6 +170,8 @@ if(WIN32)
     # Needed for M_PI define. Same as mkspecs/features/qt_module.prf.
     # It's set for every module being built, but it's not propagated to user apps.
     target_compile_definitions(PlatformModuleInternal INTERFACE _USE_MATH_DEFINES)
+    # Not disabling min/max macros may result in unintended substitutions of std::min/max
+    target_compile_definitions(PlatformCommonInternal INTERFACE NOMINMAX)
 endif()
 if(FEATURE_largefile AND UNIX)
     target_compile_definitions(PlatformCommonInternal
@@ -205,6 +209,14 @@ function(qt_internal_apply_bitcode_flags target)
     target_compile_options("${target}" INTERFACE ${bitcode_flags})
 endfunction()
 
+# Function guards linker options that are applicable for internal Qt targets only from propagating
+# them to user projects.
+function(qt_internal_platform_link_options target scope)
+    set(options ${ARGN})
+    set(is_internal_target_genex "$<BOOL:$<TARGET_PROPERTY:_qt_is_internal_target>>")
+    target_link_options(${target} ${scope} "$<${is_internal_target_genex}:${options}>")
+endfunction()
+
 # Apple deprecated the entire OpenGL API in favor of Metal, which
 # we are aware of, so silence the deprecation warnings in code.
 # This does not apply to user-code, which will need to silence
@@ -283,7 +295,7 @@ if (MSVC)
         $<$<NOT:$<CONFIG:Debug>>:-guard:cf -Gw>
     )
 
-    target_link_options(PlatformCommonInternal INTERFACE
+    qt_internal_platform_link_options(PlatformCommonInternal INTERFACE
         -DYNAMICBASE -NXCOMPAT -LARGEADDRESSAWARE
         $<$<NOT:$<CONFIG:Debug>>:-OPT:REF -OPT:ICF -GUARD:CF>
     )
@@ -299,7 +311,7 @@ endif()
 
 if(QT_FEATURE_intelcet)
     if(MSVC)
-        target_link_options(PlatformCommonInternal INTERFACE
+        qt_internal_platform_link_options(PlatformCommonInternal INTERFACE
             -CETCOMPAT
         )
     else()
@@ -328,30 +340,31 @@ endif()
 if(DEFINED QT_EXTRA_FRAMEWORKPATHS AND APPLE)
     list(TRANSFORM QT_EXTRA_FRAMEWORKPATHS PREPEND "-F" OUTPUT_VARIABLE __qt_fw_flags)
     target_compile_options(PlatformCommonInternal INTERFACE ${__qt_fw_flags})
-    target_link_options(PlatformCommonInternal INTERFACE ${__qt_fw_flags})
+    qt_internal_platform_link_options(PlatformCommonInternal INTERFACE ${__qt_fw_flags})
     unset(__qt_fw_flags)
 endif()
 
 qt_internal_get_active_linker_flags(__qt_internal_active_linker_flags)
 if(__qt_internal_active_linker_flags)
-    target_link_options(PlatformCommonInternal INTERFACE "${__qt_internal_active_linker_flags}")
+    qt_internal_platform_link_options(PlatformCommonInternal INTERFACE
+        "${__qt_internal_active_linker_flags}")
 endif()
 unset(__qt_internal_active_linker_flags)
 
 if(QT_FEATURE_enable_gdb_index)
-    target_link_options(PlatformCommonInternal INTERFACE "-Wl,--gdb-index")
+    qt_internal_platform_link_options(PlatformCommonInternal INTERFACE "-Wl,--gdb-index")
 endif()
 
 if(QT_FEATURE_enable_new_dtags)
-    target_link_options(PlatformCommonInternal INTERFACE "-Wl,--enable-new-dtags")
+    qt_internal_platform_link_options(PlatformCommonInternal INTERFACE "-Wl,--enable-new-dtags")
 endif()
 
 function(qt_get_implicit_sse2_genex_condition out_var)
     set(is_shared_lib "$<STREQUAL:$<TARGET_PROPERTY:TYPE>,SHARED_LIBRARY>")
     set(is_static_lib "$<STREQUAL:$<TARGET_PROPERTY:TYPE>,STATIC_LIBRARY>")
     set(is_static_qt_build "$<NOT:$<BOOL:${QT_BUILD_SHARED_LIBS}>>")
-    set(is_staitc_lib_during_static_qt_build "$<AND:${is_static_qt_build},${is_static_lib}>")
-    set(enable_sse2_condition "$<OR:${is_shared_lib},${is_staitc_lib_during_static_qt_build}>")
+    set(is_static_lib_during_static_qt_build "$<AND:${is_static_qt_build},${is_static_lib}>")
+    set(enable_sse2_condition "$<OR:${is_shared_lib},${is_static_lib_during_static_qt_build}>")
     set(${out_var} "${enable_sse2_condition}" PARENT_SCOPE)
 endfunction()
 

cmake/QtJavaHelpers.cmake

@@ -4,6 +4,10 @@
 # This function can be used to compile java sources into a jar package.
 
 function(qt_internal_add_jar target)
+    set(options)
+    set(oneValueArgs OUTPUT_DIR)
+    set(multiValueArgs INCLUDE_JARS SOURCES)
+    cmake_parse_arguments(arg "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
     set(javac_target_version "${QT_ANDROID_JAVAC_TARGET}")
     if (NOT javac_target_version)
@@ -18,4 +22,8 @@ function(qt_internal_add_jar target)
     set(CMAKE_JAVA_COMPILE_FLAGS -source "${javac_source_version}" -target "${javac_target_version}" -Xlint:unchecked -bootclasspath "${QT_ANDROID_JAR}")
     add_jar(${ARGV})
 
+    foreach(f IN LISTS arg_SOURCES)
+        _qt_internal_expose_source_file_to_ide(${target} "${f}")
+    endforeach()
+
 endfunction()

cmake/QtLalrHelpers.cmake

@@ -35,6 +35,15 @@ function(qt_process_qlalr consuming_target input_file_list flags)
         return()
     endif()
 
+    qt_internal_is_skipped_test(skipped ${consuming_target})
+    if(skipped)
+        return()
+    endif()
+    qt_internal_is_in_test_batch(in_batch ${consuming_target})
+    if(in_batch)
+        _qt_internal_test_batch_target_name(consuming_target)
+    endif()
+
     foreach(input_file ${input_file_list})
         file(STRINGS ${input_file} input_file_lines)
         qt_qlalr_find_option_in_list("${input_file_lines}" "^%parser(.+)" "parser")

cmake/QtModuleConfig.cmake.in

@@ -27,6 +27,8 @@ endif()
 if (NOT QT_NO_CREATE_TARGETS AND @INSTALL_CMAKE_NAMESPACE@@target@_FOUND)
     include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@Targets.cmake")
     include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@AdditionalTargetInfo.cmake")
+    include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@ExtraProperties.cmake"
+        OPTIONAL)
     if(NOT QT_NO_CREATE_VERSIONLESS_TARGETS)
         include("${CMAKE_CURRENT_LIST_DIR}/@INSTALL_CMAKE_NAMESPACE@@target@VersionlessTargets.cmake")
     endif()

cmake/QtModuleHelpers.cmake

@@ -30,6 +30,7 @@ macro(qt_internal_get_internal_add_module_keywords option_args single_args multi
         EXTERNAL_HEADERS_DIR
         PRIVATE_HEADER_FILTERS
         QPA_HEADER_FILTERS
+        RHI_HEADER_FILTERS
         HEADER_SYNC_SOURCE_DIRECTORY
         ${__default_target_info_args}
     )
@@ -37,7 +38,6 @@ macro(qt_internal_get_internal_add_module_keywords option_args single_args multi
         QMAKE_MODULE_CONFIG
         EXTRA_CMAKE_FILES
         EXTRA_CMAKE_INCLUDES
-        NO_PCH_SOURCES
         EXTERNAL_HEADERS
         POLICIES
         ${__default_private_args}
@@ -115,6 +115,10 @@ endfunction()
 #     The regular expressions that filter QPA header files out of target sources.
 #     The value must use the following format 'regex1|regex2|regex3'.
 #
+#   RHI_HEADER_FILTERS
+#     The regular expressions that filter RHI header files out of target sources.
+#     The value must use the following format 'regex1|regex2|regex3'.
+#
 #   HEADER_SYNC_SOURCE_DIRECTORY
 #     The source directory for header sync procedure. Header files outside this directory will be
 #     ignored by syncqt. The specifying this directory allows to skip the parsing of the whole
@@ -327,13 +331,23 @@ function(qt_internal_add_module target)
                      EXPORT_PROPERTIES "${export_properties}")
     endif()
 
+    # FIXME: This workaround is needed because the deployment logic
+    # for iOS and WASM just copies/embeds the directly linked library,
+    # which will just be a versioned symlink to the actual library.
+    if((UIKIT OR WASM) AND BUILD_SHARED_LIBS)
+        set(version_args "")
+    else()
+        set(version_args
+            VERSION ${PROJECT_VERSION}
+            SOVERSION ${PROJECT_VERSION_MAJOR})
+    endif()
+
     if(NOT arg_HEADER_MODULE)
         set_target_properties(${target} PROPERTIES
             LIBRARY_OUTPUT_DIRECTORY "${QT_BUILD_DIR}/${INSTALL_LIBDIR}"
             RUNTIME_OUTPUT_DIRECTORY "${QT_BUILD_DIR}/${INSTALL_BINDIR}"
             ARCHIVE_OUTPUT_DIRECTORY "${QT_BUILD_DIR}/${INSTALL_LIBDIR}"
-            VERSION ${PROJECT_VERSION}
-            SOVERSION ${PROJECT_VERSION_MAJOR}
+            ${version_args}
         )
         qt_set_target_info_properties(${target} ${ARGN})
         qt_handle_multi_config_output_dirs("${target}")
@@ -437,6 +451,13 @@ function(qt_internal_add_module target)
         set_target_properties(${target}
             PROPERTIES _qt_module_qpa_headers_filter_regex "${qpa_filter_regex}")
 
+        set(rhi_filter_regex "")
+        if(arg_RHI_HEADER_FILTERS)
+            set(rhi_filter_regex "${arg_RHI_HEADER_FILTERS}")
+        endif()
+        set_target_properties(${target}
+            PROPERTIES _qt_module_rhi_headers_filter_regex "${rhi_filter_regex}")
+
         set(private_filter_regex ".+_p(ch)?\\.h")
         if(arg_PRIVATE_HEADER_FILTERS)
             set(private_filter_regex "${private_filter_regex}|${arg_PRIVATE_HEADER_FILTERS}")
@@ -447,6 +468,8 @@ function(qt_internal_add_module target)
         # If EXTERNAL_HEADERS_DIR is set we install the specified directory and keep the structure
         # without taking into the account the CMake source tree and syncqt outputs.
         if(arg_EXTERNAL_HEADERS_DIR)
+            set_property(TARGET ${target}
+                PROPERTY _qt_external_headers_dir "${arg_EXTERNAL_HEADERS_DIR}")
             qt_install(DIRECTORY "${arg_EXTERNAL_HEADERS_DIR}/"
                 DESTINATION "${module_install_interface_include_dir}"
             )
@@ -792,6 +815,11 @@ set(QT_ALLOW_MISSING_TOOLS_PACKAGES TRUE)")
         EXPORT_NAME_PREFIX ${INSTALL_CMAKE_NAMESPACE}${target}
         CONFIG_INSTALL_DIR "${config_install_dir}")
 
+    qt_internal_export_genex_properties(TARGETS ${target}
+        EXPORT_NAME_PREFIX ${INSTALL_CMAKE_NAMESPACE}${target}
+        CONFIG_INSTALL_DIR "${config_install_dir}"
+    )
+
     ### fixme: cmake is missing a built-in variable for this. We want to apply it only to modules and plugins
     # that belong to Qt.
     if(NOT arg_HEADER_MODULE)
@@ -877,6 +905,7 @@ function(qt_finalize_module target)
         PUBLIC ${module_headers_public} "${module_depends_header}"
         PRIVATE ${module_headers_private}
         QPA ${module_headers_qpa}
+        RHI ${module_headers_rhi}
     )
 
     qt_finalize_framework_headers_copy(${target})
@@ -909,6 +938,7 @@ endfunction()
 #  * foo_versioned_inner_include_dir with the value "QtCore/6.2.0/QtCore"
 #  * foo_private_include_dir with the value "QtCore/6.2.0/QtCore/private"
 #  * foo_qpa_include_dir with the value "QtCore/6.2.0/QtCore/qpa"
+#  * foo_rhi_include_dir with the value "QtCore/6.2.0/QtCore/rhi"
 #  * foo_interface_name the interface name of the module stored in _qt_module_interface_name
 #    property, e.g. Core.
 #
@@ -931,6 +961,9 @@ endfunction()
 #  * foo_<build|install>_qpa_include_dir with
 #    qtbase_build_dir/include/QtCore/6.2.0/QtCore/qpa for build interface and
 #    include/QtCore/6.2.0/QtCore/qpa for install interface.
+#  * foo_<build|install>_rhi_include_dir with
+#    qtbase_build_dir/include/QtCore/6.2.0/QtCore/rhi for build interface and
+#    include/QtCore/6.2.0/QtCore/rhi for install interface.
 # The following values are set by the function and might be useful in caller's scope:
 #  * repo_install_interface_include_dir contains path to the top-level repository include directory,
 #    e.g. qtbase_build_dir/include
@@ -965,6 +998,8 @@ the different base name for the module info variables.")
         "${${result}_versioned_inner_include_dir}/private")
     set("${result}_qpa_include_dir"
         "${${result}_versioned_inner_include_dir}/qpa")
+    set("${result}_rhi_include_dir"
+        "${${result}_versioned_inner_include_dir}/rhi")
 
     # Module build interface directories
     set(repo_build_interface_include_dir "${QT_BUILD_DIR}/include")
@@ -978,6 +1013,8 @@ the different base name for the module info variables.")
         "${repo_build_interface_include_dir}/${${result}_private_include_dir}")
     set("${result}_build_interface_qpa_include_dir"
         "${repo_build_interface_include_dir}/${${result}_qpa_include_dir}")
+    set("${result}_build_interface_rhi_include_dir"
+        "${repo_build_interface_include_dir}/${${result}_rhi_include_dir}")
 
     # Module install interface directories
     set(repo_install_interface_include_dir "${INSTALL_INCLUDEDIR}")
@@ -991,6 +1028,8 @@ the different base name for the module info variables.")
         "${repo_install_interface_include_dir}/${${result}_private_include_dir}")
     set("${result}_install_interface_qpa_include_dir"
         "${repo_install_interface_include_dir}/${${result}_qpa_include_dir}")
+    set("${result}_install_interface_rhi_include_dir"
+        "${repo_install_interface_include_dir}/${${result}_rhi_include_dir}")
 
     set("${result}" "${module}" PARENT_SCOPE)
     set("${result}_versioned" "${module_versioned}" PARENT_SCOPE)
@@ -1004,6 +1043,7 @@ the different base name for the module info variables.")
         "${${result}_versioned_inner_include_dir}" PARENT_SCOPE)
     set("${result}_private_include_dir" "${${result}_private_include_dir}" PARENT_SCOPE)
     set("${result}_qpa_include_dir" "${${result}_qpa_include_dir}" PARENT_SCOPE)
+    set("${result}_rhi_include_dir" "${${result}_rhi_include_dir}" PARENT_SCOPE)
     set("${result}_interface_name" "${module_interface_name}" PARENT_SCOPE)
 
     # Setting module build interface directories in parent scope
@@ -1018,6 +1058,8 @@ the different base name for the module info variables.")
         "${${result}_build_interface_private_include_dir}" PARENT_SCOPE)
     set("${result}_build_interface_qpa_include_dir"
         "${${result}_build_interface_qpa_include_dir}" PARENT_SCOPE)
+    set("${result}_build_interface_rhi_include_dir"
+        "${${result}_build_interface_rhi_include_dir}" PARENT_SCOPE)
 
     # Setting module install interface directories in parent scope
     set(repo_install_interface_include_dir "${repo_install_interface_include_dir}" PARENT_SCOPE)
@@ -1031,6 +1073,8 @@ the different base name for the module info variables.")
         "${${result}_install_interface_private_include_dir}" PARENT_SCOPE)
     set("${result}_install_interface_qpa_include_dir"
         "${${result}_install_interface_qpa_include_dir}" PARENT_SCOPE)
+    set("${result}_install_interface_rhi_include_dir"
+        "${${result}_install_interface_rhi_include_dir}" PARENT_SCOPE)
 endfunction()
 
 function(qt_internal_list_to_json_array out_var list_var)
@@ -1074,6 +1118,10 @@ function(qt_describe_module target)
     endif()
 
     set(extra_build_information "")
+    if(NOT QT_NAMESPACE STREQUAL "")
+        string(APPEND extra_build_information "
+        \"namespace\": \"${QT_NAMESPACE}\",")
+    endif()
     if(ANDROID)
         string(APPEND extra_build_information "
         \"android\": {
@@ -1134,7 +1182,7 @@ endfunction()
 function(qt_internal_install_module_headers target)
     set(options)
     set(one_value_args)
-    set(multi_value_args PUBLIC PRIVATE QPA)
+    set(multi_value_args PUBLIC PRIVATE QPA RHI)
     cmake_parse_arguments(arg "${options}" "${one_value_args}" "${multi_value_args}" ${ARGN})
 
     qt_internal_module_info(module ${target})
@@ -1159,6 +1207,7 @@ function(qt_internal_install_module_headers target)
             PUBLIC ${arg_PUBLIC}
             PRIVATE ${arg_PRIVATE}
             QPA ${arg_QPA}
+            RHI ${arg_RHI}
         )
     else()
         if(arg_PUBLIC)
@@ -1172,6 +1221,9 @@ function(qt_internal_install_module_headers target)
         if(arg_QPA)
             qt_install(FILES ${arg_QPA} DESTINATION "${module_install_interface_qpa_include_dir}")
         endif()
+        if(arg_RHI)
+            qt_install(FILES ${arg_RHI} DESTINATION "${module_install_interface_rhi_include_dir}")
+        endif()
     endif()
 endfunction()
 
@@ -1179,6 +1231,7 @@ function(qt_internal_collect_module_headers out_var target)
     set(${out_var}_public "")
     set(${out_var}_private "")
     set(${out_var}_qpa "")
+    set(${out_var}_rhi "")
     set(${out_var}_all "")
 
     qt_internal_get_target_sources(sources ${target})
@@ -1186,16 +1239,20 @@ function(qt_internal_collect_module_headers out_var target)
     get_target_property(target_type ${target} TYPE)
     if(target_type STREQUAL "INTERFACE_LIBRARY")
         set(source_dir "${CMAKE_CURRENT_SOURCE_DIR}")
+        set(binary_dir "${CMAKE_CURRENT_BINARY_DIR}")
     else()
         get_target_property(source_dir ${target} SOURCE_DIR)
+        get_target_property(binary_dir ${target} BINARY_DIR)
     endif()
     get_filename_component(source_dir "${source_dir}" ABSOLUTE)
+    get_filename_component(binary_dir "${binary_dir}" ABSOLUTE)
 
     get_target_property(is_3rdparty_library ${target} _qt_module_is_3rdparty_header_library)
 
     get_target_property(public_filter ${target} _qt_module_public_headers_filter_regex)
     get_target_property(private_filter ${target} _qt_module_private_headers_filter_regex)
     get_target_property(qpa_filter ${target} _qt_module_qpa_headers_filter_regex)
+    get_target_property(rhi_filter ${target} _qt_module_rhi_headers_filter_regex)
 
     set(condition_independent_headers_warning "")
     foreach(file_path IN LISTS sources)
@@ -1232,7 +1289,14 @@ function(qt_internal_collect_module_headers out_var target)
                 "\nCondition:\n    ${condition_string}")
         endif()
 
-        if(file_path MATCHES "3rdparty/.+" AND NOT is_3rdparty_library)
+        if(is_outside_module_source_dir)
+            set(base_dir "${binary_dir}")
+        else()
+            set(base_dir "${source_dir}")
+        endif()
+
+        file(RELATIVE_PATH file_path_rel "${base_dir}" "${file_path}")
+        if(file_path_rel MATCHES "3rdparty/.+" AND NOT is_3rdparty_library)
             set(is_3rdparty_header TRUE)
         else()
             set(is_3rdparty_header FALSE)
@@ -1240,6 +1304,8 @@ function(qt_internal_collect_module_headers out_var target)
         list(APPEND ${out_var}_all "${file_path}")
         if(qpa_filter AND file_name MATCHES "${qpa_filter}")
             list(APPEND ${out_var}_qpa "${file_path}")
+        elseif(rhi_filter AND file_name MATCHES "${rhi_filter}")
+            list(APPEND ${out_var}_rhi "${file_path}")
         elseif(private_filter AND file_name MATCHES "${private_filter}")
             list(APPEND ${out_var}_private "${file_path}")
         elseif((NOT public_filter OR file_name MATCHES "${public_filter}")
@@ -1263,7 +1329,7 @@ function(qt_internal_collect_module_headers out_var target)
     endif()
 
 
-    set(header_types public private qpa)
+    set(header_types public private qpa rhi)
     set(has_header_types_properties "")
     foreach(header_type IN LISTS header_types)
         get_target_property(current_propety_value ${target} _qt_module_has_${header_type}_headers)
@@ -1285,5 +1351,6 @@ function(qt_internal_collect_module_headers out_var target)
             _qt_module_has_public_headers
             _qt_module_has_private_headers
             _qt_module_has_qpa_headers
+            _qt_module_has_rhi_headers
     )
 endfunction()

cmake/QtPkgConfigHelpers.cmake

@@ -51,6 +51,17 @@ function(qt_internal_generate_pkg_config_file module)
     list(TRANSFORM loose_include_dirs REPLACE "${INSTALL_INCLUDEDIR}" "\${includedir}")
     list(TRANSFORM loose_include_dirs REPLACE "${INSTALL_MKSPECSDIR}" "\${mkspecsdir}")
 
+    # Remove genex wrapping around gc_sections flag because we can't evaluate genexes like
+    # $<CXX_COMPILER_ID> in file(GENERATE). And given that .pc files don't support dynamic
+    # evaluation like the $<CXX_COMPILER_ID> genex, distros will be expected to patch the .pc
+    # files according to which compiler they intend to be used with.
+    get_property(gc_sections_with_genex GLOBAL PROPERTY _qt_internal_gc_sections_with_genex)
+    get_property(gc_sections_without_genex GLOBAL PROPERTY _qt_internal_gc_sections_without_genex)
+    if(loose_link_options AND gc_sections_with_genex AND gc_sections_without_genex)
+        string(REPLACE "${gc_sections_with_genex}" "${gc_sections_without_genex}"
+            loose_link_options "${loose_link_options}")
+    endif()
+
     qt_internal_set_pkg_config_cpp_flags(link_options "${loose_link_options}" "")
     qt_internal_set_pkg_config_cpp_flags(compile_defs "${loose_compile_defs}" -D)
     qt_internal_set_pkg_config_cpp_flags(include_dirs "${loose_include_dirs}" -I)

cmake/QtPluginHelpers.cmake

@@ -336,6 +336,8 @@ function(qt_internal_add_plugin target)
     qt_internal_extend_target("${target}"
         ${arg_NO_UNITY_BUILD}
         SOURCES ${arg_SOURCES}
+        NO_PCH_SOURCES
+            ${arg_NO_PCH_SOURCES}
         NO_UNITY_BUILD_SOURCES
             ${arg_NO_UNITY_BUILD_SOURCES}
         INCLUDE_DIRECTORIES

cmake/QtPriHelpers.cmake

@@ -26,9 +26,14 @@ function(qt_generate_qmake_libraries_pri_content module_name output_root_dir out
         set(lib_incdir "")
         set(lib_libdir "")
         set(lib_libs "")
+        set(seen_targets "")
         while(lib_targets)
             list(POP_BACK lib_targets lib_target)
             if(TARGET ${lib_target})
+                if(${lib_target} IN_LIST seen_targets)
+                    continue()
+                endif()
+                list(APPEND seen_targets ${lib_target})
                 get_target_property(lib_target_type ${lib_target} TYPE)
                 if(lib_target_type STREQUAL "INTERFACE_LIBRARY")
                     get_target_property(iface_libs ${lib_target} INTERFACE_LINK_LIBRARIES)

cmake/QtProcessConfigureArgs.cmake

@@ -55,7 +55,10 @@ if("${MODULE_ROOT}" STREQUAL "")
     set(qtbase_or_top_level_build TRUE)
 else()
     # If MODULE_ROOT is passed without drive letter, we try to add it to the path.
+    # The check is necessary; otherwise, `get_filename_component` returns an empty string.
+    if(NOT MODULE_ROOT STREQUAL ".")
         get_filename_component(MODULE_ROOT "." REALPATH BASE_DIR "${MODULE_ROOT}")
+    endif()
     set(qtbase_or_top_level_build FALSE)
 endif()
 set(configure_filename "configure.cmake")
@@ -136,13 +139,6 @@ while(NOT "${configure_args}" STREQUAL "")
         list(POP_FRONT configure_args version)
         is_valid_qt_hex_version("${arg}" "${version}")
         push("-DQT_DISABLE_DEPRECATED_UP_TO=${version}")
-    elseif(arg STREQUAL "-unity-build")
-        push("-DQT_UNITY_BUILD=ON")
-        # QT_UNITY_BUILD_BATCH_SIZE will be set to 8, CMake's default.
-    elseif(arg STREQUAL "-unity-build-batch-size")
-        list(POP_FRONT configure_args unity_build_batch_size)
-        is_non_empty_valid_arg("${arg}" "${unity_build_batch_size}")
-        push("-DQT_UNITY_BUILD_BATCH_SIZE=${unity_build_batch_size}")
     elseif(arg STREQUAL "--")
         # Everything after this argument will be passed to CMake verbatim.
         list(APPEND cmake_args "${configure_args}")
@@ -152,6 +148,41 @@ while(NOT "${configure_args}" STREQUAL "")
     endif()
 endwhile()
 
+# Read the specified manually generator value from CMake command line.
+# The '-cmake-generator' argument has higher priority than CMake command line.
+if(NOT generator)
+    set(is_next_arg_generator_name FALSE)
+    foreach(arg IN LISTS cmake_args)
+        if(is_next_arg_generator_name)
+            set(is_next_arg_generator_name FALSE)
+            if(NOT arg MATCHES "^-.*")
+                set(generator "${arg}")
+                set(auto_detect_generator FALSE)
+            endif()
+        elseif(arg MATCHES "^-G(.*)")
+            set(generator "${CMAKE_MATCH_1}")
+            if(generator)
+                set(auto_detect_generator FALSE)
+            else()
+                set(is_next_arg_generator_name TRUE)
+            endif()
+        endif()
+    endforeach()
+endif()
+
+# Attempt to detect the generator type, either single or multi-config
+if("${generator}" STREQUAL "Xcode"
+    OR "${generator}" STREQUAL "Ninja Multi-Config"
+    OR "${generator}" MATCHES "^Visual Studio")
+    set(multi_config ON)
+else()
+    set(multi_config OFF)
+endif()
+
+# Tell the build system we are configuring via the configure script so we can act on that.
+# The cache variable is unset at the end of configuration.
+push("-DQT_INTERNAL_CALLED_FROM_CONFIGURE:BOOL=TRUE")
+
 if(FRESH_REQUESTED)
     push("-DQT_INTERNAL_FRESH_REQUESTED:BOOL=TRUE")
     if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.24")
@@ -827,7 +858,10 @@ endfunction()
 drop_input(commercial)
 drop_input(confirm-license)
 translate_boolean_input(precompile_header BUILD_WITH_PCH)
+translate_boolean_input(unity_build QT_UNITY_BUILD)
+translate_string_input(unity_build_batch_size QT_UNITY_BUILD_BATCH_SIZE)
 translate_boolean_input(ccache QT_USE_CCACHE)
+translate_boolean_input(vcpkg QT_USE_VCPKG)
 translate_boolean_input(shared BUILD_SHARED_LIBS)
 translate_boolean_input(warnings_are_errors WARNINGS_ARE_ERRORS)
 translate_string_input(qt_namespace QT_NAMESPACE)
@@ -877,6 +911,7 @@ endif()
 
 drop_input(make)
 drop_input(nomake)
+translate_boolean_input(install-examples-sources QT_INSTALL_EXAMPLES_SOURCES)
 
 check_qt_build_parts(nomake)
 check_qt_build_parts(make)
@@ -898,9 +933,9 @@ if(INPUT_force_debug_info)
 endif()
 
 list(LENGTH build_configs nr_of_build_configs)
-if(nr_of_build_configs EQUAL 1)
+if(nr_of_build_configs EQUAL 1 AND NOT multi_config)
     push("-DCMAKE_BUILD_TYPE=${build_configs}")
-elseif(nr_of_build_configs GREATER 1)
+elseif(nr_of_build_configs GREATER 1 OR multi_config)
     set(multi_config ON)
     string(REPLACE ";" "[[;]]" escaped_build_configs "${build_configs}")
     # We must not use the push macro here to avoid variable expansion.
@@ -985,6 +1020,14 @@ endforeach()
 
 push("${MODULE_ROOT}")
 
+if(INPUT_sysroot)
+    qtConfAddWarning("The -sysroot option is deprecated and no longer has any effect. "
+                     "It is recommended to use a toolchain file instead, i.e., "
+                     "-DCMAKE_TOOLCHAIN_FILE=<filename>. "
+                     "Alternatively, you may use -DCMAKE_SYSROOT option "
+                     "to pass the sysroot to CMake.\n")
+endif()
+
 # Restore the escaped semicolons in arguments that are lists
 list(TRANSFORM cmake_args REPLACE "\\[\\[;\\]\\]" "\\\\;")
 

cmake/QtPublicAppleHelpers.cmake

@@ -27,7 +27,7 @@ function(_qt_internal_handle_ios_launch_screen target)
     if(NOT launch_screen AND NOT QT_NO_SET_DEFAULT_IOS_LAUNCH_SCREEN)
         set(is_default_launch_screen TRUE)
         set(launch_screen
-            "${__qt_internal_cmake_ios_support_files_path}/LaunchScreen.storyboard")
+            "${__qt_internal_cmake_apple_support_files_path}/LaunchScreen.storyboard")
     endif()
 
     # Check that the launch screen exists.
@@ -221,7 +221,7 @@ function(_qt_internal_find_ios_development_team_id out_var)
     endif()
 endfunction()
 
-function(_qt_internal_get_ios_bundle_identifier_prefix out_var)
+function(_qt_internal_get_apple_bundle_identifier_prefix out_var)
     get_property(prefix GLOBAL PROPERTY _qt_internal_ios_bundle_identifier_prefix)
     get_property(prefix_computed GLOBAL PROPERTY
                  _qt_internal_ios_bundle_identifier_prefix_computed)
@@ -269,8 +269,8 @@ function(_qt_internal_escape_rfc_1034_identifier value out_var)
     set("${out_var}" "${value}" PARENT_SCOPE)
 endfunction()
 
-function(_qt_internal_get_default_ios_bundle_identifier out_var)
-    _qt_internal_get_ios_bundle_identifier_prefix(prefix)
+function(_qt_internal_get_default_apple_bundle_identifier target out_var)
+    _qt_internal_get_apple_bundle_identifier_prefix(prefix)
     if(NOT prefix)
         set(prefix "com.yourcompany")
 
@@ -281,13 +281,15 @@ function(_qt_internal_get_default_ios_bundle_identifier out_var)
             string(SHA1 hash "${team_id}")
             string(SUBSTRING "${hash}" 0 8 infix)
             string(APPEND prefix ".${infix}")
-        else()
+        endif()
+
+        if(CMAKE_GENERATOR STREQUAL "Xcode")
             message(WARNING
-                "No organization bundle identifier prefix could be retrieved from Xcode "
-                "preferences. This can lead to code signing issues due to a non-unique bundle "
-                "identifier. Please set up an organization prefix by creating a new project within "
-                "Xcode, or consider providing a custom bundle identifier by specifying the "
-                "XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER property."
+                "No organization bundle identifier prefix could be retrieved from Xcode preferences. \
+                This can lead to code signing issues due to a non-unique bundle \
+                identifier. Please set up an organization prefix by creating a new project within \
+                Xcode, or consider providing a custom bundle identifier by specifying the \
+                MACOSX_BUNDLE_GUI_IDENTIFIER or XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER property."
                 )
         endif()
     endif()
@@ -299,7 +301,12 @@ function(_qt_internal_get_default_ios_bundle_identifier out_var)
     # that the identifier is invalid.
     _qt_internal_escape_rfc_1034_identifier("${prefix}" prefix)
 
-    set(identifier "${prefix}.\${PRODUCT_NAME:rfc1034identifier}")
+    if(CMAKE_GENERATOR STREQUAL "Xcode")
+        set(identifier "${prefix}.$(PRODUCT_NAME:rfc1034identifier)")
+    else()
+        set(identifier "${prefix}.${target}")
+    endif()
+
     set("${out_var}" "${identifier}" PARENT_SCOPE)
 endfunction()
 
@@ -384,56 +391,72 @@ function(_qt_internal_set_xcode_development_team_id target)
     endif()
 endfunction()
 
-function(_qt_internal_set_xcode_bundle_identifier target)
+function(_qt_internal_set_apple_bundle_identifier target)
     # Skip all logic if requested.
     if(QT_NO_SET_XCODE_BUNDLE_IDENTIFIER)
         return()
     endif()
 
-    # There are two fields to consider: the CFBundleIdentifier key (CFBI) to be written to
-    # Info.plist
-    # and the PRODUCT_BUNDLE_IDENTIFIER (PBI) property to set in the Xcode project.
-    # The following logic enables the best out-of-the-box experience combined with maximum
-    # customization.
-    # 1) If values for both fields are not provided, assign ${PRODUCT_BUNDLE_IDENTIFIER} to CFBI
-    #    (which is expanded by xcodebuild at build time and will use the value of PBI) and
-    #    auto-compute a default PBI from Xcode's ${PRODUCT_NAME}.
-    # 2) If CFBI is set and PBI isn't, use given CFBI and keep PBI empty.
-    # 3) If PBI is set and CFBI isn't, assign ${PRODUCT_BUNDLE_IDENTIFIER} to CFBI and use
-    #    the given PBI.
-    # 4) If both are set, use both given values.
-    # TLDR:
-    # cfbi    pbi   -> result_cfbi result_pbi
-    # unset   unset    computed    computed
-    # set     unset    given_val   unset
-    # unset   set      computed    given_val
-    # set     set      given_val   given_val
+    # There are two fields to consider: the CFBundleIdentifier key (ie., cmake_bundle_identifier)
+    # to be written to Info.plist and the PRODUCT_BUNDLE_IDENTIFIER (ie., xcode_bundle_identifier)
+    # property to set in the Xcode project. The `cmake_bundle_identifier` set by
+    # MACOSX_BUNDLE_GUI_IDENTIFIER applies to both Xcode, and other generators, while
+    # `xcode_bundle_identifier` set by XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER is
+    # Xcode specific.
+    #
+    # If Ninja is the generator, we set the value of `MACOSX_BUNDLE_GUI_IDENTIFIER`
+    # and don't touch the `XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER`.
+    # If Xcode is the generator, we set the value of `XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER`,
+    # and additionally, to silence a Xcode's warning, we set the `MACOSX_BUNDLE_GUI_IDENTIFIER` to
+    # `${PRODUCT_BUNDLE_IDENTIFIER}` so that Xcode could sort it out.
 
-    get_target_property(existing_cfbi "${target}" MACOSX_BUNDLE_GUI_IDENTIFIER)
-    if(NOT MACOSX_BUNDLE_GUI_IDENTIFIER AND NOT existing_cfbi)
-        set(is_cfbi_given FALSE)
-    else()
-        set(is_cfbi_given TRUE)
+    get_target_property(existing_cmake_bundle_identifier "${target}"
+                        MACOSX_BUNDLE_GUI_IDENTIFIER)
+    get_target_property(existing_xcode_bundle_identifier "${target}"
+                        XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER)
+
+    set(is_cmake_bundle_identifier_given FALSE)
+    if(existing_cmake_bundle_identifier)
+        set(is_cmake_bundle_identifier_given TRUE)
+    elseif(MACOSX_BUNDLE_GUI_IDENTIFIER)
+        set(is_cmake_bundle_identifier_given TRUE)
+        set(existing_cmake_bundle_identifier ${MACOSX_BUNDLE_GUI_IDENTIFIER})
     endif()
 
-    if(NOT is_cfbi_given)
+    set(is_xcode_bundle_identifier_given FALSE)
+    if(existing_xcode_bundle_identifier)
+        set(is_xcode_bundle_identifier_given TRUE)
+    elseif(CMAKE_XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER)
+        set(is_xcode_bundle_identifier_given TRUE)
+        set(existing_xcode_bundle_identifier ${CMAKE_XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER})
+    endif()
+
+    if(is_cmake_bundle_identifier_given
+        AND is_xcode_bundle_identifier_given
+            AND NOT existing_cmake_bundle_identifier STREQUAL existing_xcode_bundle_identifier)
+        message(WARNING
+            "MACOSX_BUNDLE_GUI_IDENTIFIER and XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER "
+            "are set to different values. You only need to set one of them. ")
+    endif()
+
+    if(NOT is_xcode_bundle_identifier_given
+        AND NOT is_cmake_bundle_identifier_given)
+        _qt_internal_get_default_apple_bundle_identifier("${target}" bundle_id)
+    elseif(is_cmake_bundle_identifier_given)
+        set(bundle_id ${existing_cmake_bundle_identifier})
+    elseif(is_xcode_bundle_identifier_given)
+        set(bundle_id ${existing_xcode_bundle_identifier})
+    endif()
+
+    if(CMAKE_GENERATOR STREQUAL "Xcode")
         set_target_properties("${target}"
                               PROPERTIES
-                              MACOSX_BUNDLE_GUI_IDENTIFIER "\${PRODUCT_BUNDLE_IDENTIFIER}")
-    endif()
-
-    get_target_property(existing_pbi "${target}" XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER)
-    if(NOT CMAKE_XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER AND NOT existing_pbi)
-        set(is_pbi_given FALSE)
+                              XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER "${bundle_id}"
+                              MACOSX_BUNDLE_GUI_IDENTIFIER "$(PRODUCT_BUNDLE_IDENTIFIER)")
     else()
-        set(is_pbi_given TRUE)
-    endif()
-
-    if(NOT is_pbi_given AND NOT is_cfbi_given)
-        _qt_internal_get_default_ios_bundle_identifier(bundle_id)
         set_target_properties("${target}"
                               PROPERTIES
-                              XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER "${bundle_id}")
+                              MACOSX_BUNDLE_GUI_IDENTIFIER "${bundle_id}")
     endif()
 endfunction()
 
@@ -503,7 +526,7 @@ function(_qt_internal_set_xcode_bundle_name target)
         if(CMAKE_GENERATOR STREQUAL Xcode)
             set_target_properties("${target}"
                                   PROPERTIES
-                                  MACOSX_BUNDLE_BUNDLE_NAME "\${PRODUCT_NAME}")
+                                  MACOSX_BUNDLE_BUNDLE_NAME "$(PRODUCT_NAME)")
         else()
             set_target_properties("${target}"
                                   PROPERTIES
@@ -531,15 +554,13 @@ function(_qt_internal_set_xcode_bitcode_enablement target)
         "NO")
 endfunction()
 
-function(_qt_internal_generate_ios_info_plist target)
+function(_qt_internal_copy_info_plist target)
     # If the project already specifies a custom file, we don't override it.
-    get_target_property(existing_plist "${target}" MACOSX_BUNDLE_INFO_PLIST)
-    if(existing_plist)
-        return()
+    get_target_property(info_plist_in "${target}" MACOSX_BUNDLE_INFO_PLIST)
+    if(NOT info_plist_in)
+        set(info_plist_in "${__qt_internal_cmake_apple_support_files_path}/Info.plist.app.in")
     endif()
 
-    set(info_plist_in "${__qt_internal_cmake_ios_support_files_path}/Info.plist.app.in")
-
     string(MAKE_C_IDENTIFIER "${target}" target_identifier)
     set(info_plist_out_dir
         "${CMAKE_CURRENT_BINARY_DIR}/.qt/info_plist/${target_identifier}")
@@ -569,6 +590,62 @@ function(_qt_internal_generate_ios_info_plist target)
     set_target_properties("${target}" PROPERTIES MACOSX_BUNDLE_INFO_PLIST "${info_plist_out}")
 endfunction()
 
+function(_qt_internal_plist_buddy plist_file)
+    cmake_parse_arguments(PARSE_ARGV 1 arg
+        "" "OUTPUT_VARIABLE;ERROR_VARIABLE" "COMMANDS")
+    foreach(command ${arg_COMMANDS})
+        execute_process(COMMAND "/usr/libexec/PlistBuddy"
+                                -c "${command}" "${plist_file}"
+                    OUTPUT_VARIABLE plist_buddy_output
+                    ERROR_VARIABLE plist_buddy_error)
+        string(STRIP "${plist_buddy_output}" plist_buddy_output)
+        if(arg_OUTPUT_VARIABLE)
+            list(APPEND ${arg_OUTPUT_VARIABLE} ${plist_buddy_output})
+            set(${arg_OUTPUT_VARIABLE} ${${arg_OUTPUT_VARIABLE}} PARENT_SCOPE)
+        endif()
+        if(arg_ERROR_VARIABLE)
+            list(APPEND ${arg_ERROR_VARIABLE} ${plist_buddy_error})
+            set(${arg_ERROR_VARIABLE} ${${arg_ERROR_VARIABLE}} PARENT_SCOPE)
+        endif()
+        if(plist_buddy_error)
+            return()
+        endif()
+    endforeach()
+endfunction()
+
+function(_qt_internal_set_apple_localizations target)
+    if(QT_NO_SET_PLIST_LOCALIZATIONS)
+        return()
+    endif()
+
+    get_target_property(supported_languages "${target}" _qt_apple_supported_languages)
+    if("${supported_languages}" STREQUAL "supported_languages-NOTFOUND")
+        return()
+    endif()
+    get_target_property(plist_file "${target}" MACOSX_BUNDLE_INFO_PLIST)
+    if (NOT plist_file)
+        return()
+    endif()
+
+    _qt_internal_plist_buddy("${plist_file}"
+        COMMANDS "print CFBundleLocalizations"
+        OUTPUT_VARIABLE existing_localizations
+    )
+    if(existing_localizations)
+        return()
+    endif()
+
+    list(TRANSFORM supported_languages PREPEND
+        "Add CFBundleLocalizations: string ")
+
+    _qt_internal_plist_buddy("${plist_file}"
+        COMMANDS
+            "Add CFBundleLocalizations array"
+            ${supported_languages}
+            "Delete CFBundleAllowMixedLocalizations"
+    )
+endfunction()
+
 function(_qt_internal_set_ios_simulator_arch target)
     if(CMAKE_XCODE_ATTRIBUTE_ARCHS
         OR QT_NO_SET_XCODE_ARCHS)
@@ -598,27 +675,31 @@ endfunction()
 function(_qt_internal_finalize_apple_app target)
     # Shared between macOS and iOS apps
 
+    _qt_internal_copy_info_plist("${target}")
+    _qt_internal_set_apple_localizations("${target}")
+
     # Only set the various properties if targeting the Xcode generator, otherwise the various
     # Xcode tokens are embedded as-is instead of being dynamically evaluated.
     # This affects things like the version number or application name as reported by Qt API.
     if(CMAKE_GENERATOR STREQUAL "Xcode")
         _qt_internal_set_xcode_development_team_id("${target}")
-        _qt_internal_set_xcode_bundle_identifier("${target}")
         _qt_internal_set_xcode_code_sign_style("${target}")
         _qt_internal_set_xcode_bundle_display_name("${target}")
         _qt_internal_set_xcode_install_path("${target}")
     endif()
+
     _qt_internal_set_xcode_bundle_name("${target}")
+    _qt_internal_set_apple_bundle_identifier("${target}")
     _qt_internal_set_placeholder_apple_bundle_version("${target}")
 endfunction()
 
 function(_qt_internal_finalize_ios_app target)
-    _qt_internal_finalize_apple_app("${target}")
+    # Must be called before we generate the Info.plist
+    _qt_internal_handle_ios_launch_screen("${target}")
 
+    _qt_internal_finalize_apple_app("${target}")
     _qt_internal_set_xcode_targeted_device_family("${target}")
     _qt_internal_set_xcode_bitcode_enablement("${target}")
-    _qt_internal_handle_ios_launch_screen("${target}")
-    _qt_internal_generate_ios_info_plist("${target}")
     _qt_internal_set_ios_simulator_arch("${target}")
 endfunction()
 

cmake/QtPublicTargetHelpers.cmake

@@ -307,7 +307,17 @@ function(_qt_internal_set_up_static_runtime_library target)
             set_property(TARGET ${target} PROPERTY
                 MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
         elseif(MINGW)
-            target_link_options(${target} INTERFACE "LINKER:-Bstatic")
+            get_target_property(target_type ${target} TYPE)
+            if(target_type STREQUAL "EXECUTABLE")
+                set(link_option PRIVATE)
+            else()
+                set(link_option INTERFACE)
+            endif()
+            if(CLANG)
+                target_link_options(${target} ${link_option} "LINKER:-Bstatic")
+            else()
+                target_link_options(${target} ${link_option} "-static")
+            endif()
         endif()
     endif()
 endfunction()

cmake/QtPublicWasmToolchainHelpers.cmake

@@ -53,7 +53,7 @@ endfunction()
 
 function(__qt_internal_get_emcc_recommended_version out_var)
     # This version of Qt needs this version of emscripten.
-    set(QT_EMCC_RECOMMENDED_VERSION "3.1.25")
+    set(QT_EMCC_RECOMMENDED_VERSION "3.1.37")
     set(${out_var} "${QT_EMCC_RECOMMENDED_VERSION}" PARENT_SCOPE)
 endfunction()
 
@@ -81,12 +81,16 @@ function(__qt_internal_get_qt_build_emsdk_version out_var)
     endif()
     if(EXISTS "${WASM_BUILD_DIR}/src/corelib/global/qconfig.h")
         file(READ "${WASM_BUILD_DIR}/src/corelib/global/qconfig.h" ver)
-    else()
+    elseif(EXISTS "${WASM_BUILD_DIR}/include/QtCore/qconfig.h")
         file(READ "${WASM_BUILD_DIR}/include/QtCore/qconfig.h" ver)
+    else()
+        message("qconfig.h not found, unable to determine Qt build Emscripten version")
     endif()
+    if (ver)
         string(REGEX MATCH "#define QT_EMCC_VERSION.\"[0-9]+\\.[0-9]+\\.[0-9]+\"" emOutput ${ver})
         string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" build_emcc_version "${emOutput}")
         set(${out_var} "${build_emcc_version}" PARENT_SCOPE)
+    endif()
 endfunction()
 
 function(_qt_test_emscripten_version)

cmake/QtQmakeHelpers.cmake

@@ -37,8 +37,6 @@ function(qt_generate_qconfig_cpp in_file out_file)
     set(QT_SYS_CONF_DIR "${INSTALL_SYSCONFDIR}")
 
     # Compute and set relocation prefixes.
-    # TODO: Clean this up, there's a bunch of unrealistic assumptions here.
-    # See qtConfOutput_preparePaths in qtbase/configure.pri.
     if(WIN32)
         set(lib_location_absolute_path
             "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_BINDIR}")
@@ -213,6 +211,7 @@ function(qt_get_qmake_module_name result module)
     string(REGEX REPLACE "^Qt6" "" module "${module}")
     string(REGEX REPLACE "Private$" "_private" module "${module}")
     string(REGEX REPLACE "Qpa$" "_qpa_lib_private" module "${module}")
+    string(REGEX REPLACE "Rhi$" "_rhi_lib_private" module "${module}")
     string(TOLOWER "${module}" module)
     set(${result} ${module} PARENT_SCOPE)
 endfunction()

cmake/QtResourceHelpers.cmake

@@ -3,10 +3,14 @@
 
 function(qt_internal_add_resource target resourceName)
     if(NOT TARGET "${target}")
-        qt_internal_is_in_test_batch(in_batch ${target})
-        if(NOT in_batch)
-            message(FATAL_ERROR "Trying to add resource to a non-existing target \"${target}\".")
+        message(FATAL_ERROR "${target} is not a target.")
     endif()
+    qt_internal_is_skipped_test(skipped ${target})
+    if(skipped)
+        return()
+    endif()
+    qt_internal_is_in_test_batch(in_batch ${target})
+    if(in_batch)
         _qt_internal_test_batch_target_name(target)
     endif()
 

cmake/QtRpathHelpers.cmake

@@ -6,7 +6,7 @@
 function(qt_internal_get_relative_rpath_base_token out_var)
     if(APPLE)
         set(rpath_rel_base "@loader_path")
-    elseif(LINUX OR SOLARIS OR FREEBSD OR HURD)
+    elseif(LINUX OR SOLARIS OR FREEBSD OR HURD OR OPENBSD)
         set(rpath_rel_base "$ORIGIN")
     else()
         set(rpath_rel_base "NO_KNOWN_RPATH_REL_BASE")

cmake/QtSeparateDebugInfo.cmake

@@ -201,7 +201,11 @@ endfunction()
 # Enable separate debug information for the given target
 function(qt_enable_separate_debug_info target installDestination)
     set(flags QT_EXECUTABLE)
+    if(APPLE)
+      set(options DSYM_OUTPUT_DIR)
+    else()
       set(options)
+    endif()
     set(multiopts ADDITIONAL_INSTALL_ARGS)
     cmake_parse_arguments(arg "${flags}" "${options}" "${multiopts}" ${ARGN})
 
@@ -248,12 +252,20 @@ function(qt_enable_separate_debug_info target installDestination)
         get_target_property(is_framework ${target} FRAMEWORK)
         if(is_framework)
             qt_internal_get_framework_info(fw ${target})
-            set(debug_info_bundle_dir "$<TARGET_BUNDLE_DIR:${target}>.${debug_info_suffix}")
             set(BUNDLE_ID ${fw_name})
         else()
-            set(debug_info_bundle_dir "$<TARGET_FILE:${target}>.${debug_info_suffix}")
             set(BUNDLE_ID ${target})
         endif()
+
+        if (NOT "x${arg_DSYM_OUTPUT_DIR}" STREQUAL "x")
+            set(debug_info_bundle_dir "${arg_DSYM_OUTPUT_DIR}/${target}")
+        elseif(is_framework)
+            set(debug_info_bundle_dir "$<TARGET_BUNDLE_DIR:${target}>")
+        else()
+            set(debug_info_bundle_dir "$<TARGET_FILE:${target}>")
+        endif()
+        set(debug_info_bundle_dir "${debug_info_bundle_dir}.${debug_info_suffix}")
+
         set(debug_info_contents_dir "${debug_info_bundle_dir}/Contents")
         set(debug_info_target_dir "${debug_info_contents_dir}/Resources/DWARF")
         configure_file(

cmake/QtSetup.cmake

@@ -5,21 +5,17 @@
 
 # Set the QT_IS_BUILDING_QT variable so we can verify whether we are building
 # Qt from source
-set(QT_BUILDING_QT TRUE CACHE
-    TYPE STRING "When this is present and set to true, it signals that we are building Qt from source.")
+set(QT_BUILDING_QT TRUE CACHE BOOL
+        "When this is present and set to true, it signals that we are building Qt from source.")
 
-# Pre-calculate the developer_build feature if it's set by the user via INPUT_developer_build
-if(NOT FEATURE_developer_build AND INPUT_developer_build
-        AND NOT "${INPUT_developer_build}" STREQUAL "undefined")
-    set(FEATURE_developer_build ON)
-endif()
+# Pre-calculate the developer_build feature if it's set by the user via the INPUT_developer_build
+# variable when using the configure script. When not using configure, don't take the INPUT variable
+# into account, so that users can toggle the feature directly in the cache or via IDE.
+qt_internal_compute_feature_value_from_possible_input(developer_build)
 
 # Pre-calculate the no_prefix feature if it's set by configure via INPUT_no_prefix.
 # This needs to be done before qtbase/configure.cmake is processed.
-if(NOT FEATURE_no_prefix AND INPUT_no_prefix
-        AND NOT "${INPUT_no_prefix}" STREQUAL "undefined")
-    set(FEATURE_no_prefix ON)
-endif()
+qt_internal_compute_feature_value_from_possible_input(no_prefix)
 
 set(_default_build_type "Release")
 if(FEATURE_developer_build)
@@ -49,7 +45,20 @@ unset(QT_EXTRA_BUILD_INTERNALS_VARS)
 # Save the global property in a variable to make it available to feature conditions.
 get_property(QT_GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 
-if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+# Try to detect if an explicit CMAKE_BUILD_TYPE was set by the user.
+# CMake sets CMAKE_BUILD_TYPE_INIT to Debug on most Windows platforms and doesn't set
+# anything for UNIXes. CMake assigns CMAKE_BUILD_TYPE_INIT to CMAKE_BUILD_TYPE during
+# first project() if CMAKE_BUILD_TYPE has no previous value.
+# We use extra information about the state of CMAKE_BUILD_TYPE before the first
+# project() call that's set in QtAutodetect.
+# STREQUAL check needs to have expanded variables because an undefined var is not equal
+# to an empty defined var.
+# See also qt_internal_force_set_cmake_build_type_conditionally which is used
+# to set the build type when building other repos or tests.
+if("${CMAKE_BUILD_TYPE}" STREQUAL "${CMAKE_BUILD_TYPE_INIT}"
+    AND NOT __qt_auto_detect_cmake_build_type_before_project_call
+    AND NOT __qt_build_internals_cmake_build_type
+    AND NOT CMAKE_CONFIGURATION_TYPES)
   message(STATUS "Setting build type to '${_default_build_type}' as none was specified.")
   set(CMAKE_BUILD_TYPE "${_default_build_type}" CACHE STRING "Choose the type of build." FORCE)
   set_property(CACHE CMAKE_BUILD_TYPE
@@ -193,6 +202,8 @@ else()
     set(QT_INTERNAL_CONFIGURE_FROM_IDE FALSE CACHE INTERNAL "Configuring Qt Project from IDE")
 endif()
 
+set(_qt_sync_headers_at_configure_time_default ${QT_INTERNAL_CONFIGURE_FROM_IDE})
+
 if(FEATURE_developer_build)
     if(DEFINED QT_CMAKE_EXPORT_COMPILE_COMMANDS)
         set(CMAKE_EXPORT_COMPILE_COMMANDS ${QT_CMAKE_EXPORT_COMPILE_COMMANDS})
@@ -213,11 +224,26 @@ if(FEATURE_developer_build)
     if (CMAKE_BUILD_TYPE AND CMAKE_BUILD_TYPE STREQUAL Debug)
         set(__build_benchmarks OFF)
     endif()
+
+    # Sync headers during the initial configuration of a -developer-build to facilitate code
+    # navigation for code editors that use an LSP-based code model.
+    set(_qt_sync_headers_at_configure_time_default TRUE)
 else()
     set(_qt_build_tests_default OFF)
     set(__build_benchmarks OFF)
 endif()
 
+# Sync Qt header files at configure time
+option(QT_SYNC_HEADERS_AT_CONFIGURE_TIME "Run syncqt at configure time already"
+    ${_qt_sync_headers_at_configure_time_default})
+unset(_qt_sync_headers_at_configure_time_default)
+
+# In static Ninja Multi-Config builds the sync_headers dependencies(and other autogen dependencies
+# are not added to '_autogen/timestamp' targets. See QTBUG-113974.
+if(CMAKE_GENERATOR STREQUAL "Ninja Multi-Config" AND NOT QT_BUILD_SHARED_LIBS)
+    set(QT_SYNC_HEADERS_AT_CONFIGURE_TIME TRUE CACHE BOOL "" FORCE)
+endif()
+
 # Build Benchmarks
 option(QT_BUILD_BENCHMARKS "Build Qt Benchmarks" ${__build_benchmarks})
 if(QT_BUILD_BENCHMARKS)
@@ -255,10 +281,10 @@ endif()
 
 option(QT_BUILD_TESTS_BATCHED "Link all tests into a single binary." ${_qt_batch_tests})
 
-if(QT_BUILD_TESTS AND QT_BUILD_TESTS_BATCHED AND CMAKE_VERSION VERSION_LESS "3.18")
+if(QT_BUILD_TESTS AND QT_BUILD_TESTS_BATCHED AND CMAKE_VERSION VERSION_LESS "3.19")
     message(FATAL_ERROR
-        "Test batching requires at least CMake 3.18, due to requiring per-source "
-        "TARGET_DIRECTORY assignments.")
+        "Test batching requires at least CMake 3.19, due to requiring per-source "
+        "TARGET_DIRECTORY assignments and DEFER calls.")
 endif()
 
 # QT_BUILD_TOOLS_WHEN_CROSSCOMPILING -> QT_FORCE_BUILD_TOOLS
@@ -285,6 +311,9 @@ enable_testing()
 
 option(QT_BUILD_EXAMPLES "Build Qt examples" OFF)
 option(QT_BUILD_EXAMPLES_BY_DEFAULT "Should examples be built as part of the default 'all' target." ON)
+option(QT_INSTALL_EXAMPLES_SOURCES "Install example sources" OFF)
+option(QT_INSTALL_EXAMPLES_SOURCES_BY_DEFAULT
+    "Install example sources as part of the default 'install' target" ON)
 
 # FIXME: Support prefix builds as well QTBUG-96232
 if(QT_WILL_INSTALL)
@@ -352,31 +381,13 @@ if(QT_UNITY_BUILD)
     set(CMAKE_UNITY_BUILD_BATCH_SIZE "${QT_UNITY_BUILD_BATCH_SIZE}")
 endif()
 
-# We need to clean up QT_FEATURE_*, but only once per configuration cycle
-get_property(qt_feature_clean GLOBAL PROPERTY _qt_feature_clean)
-if(NOT qt_feature_clean)
-    message(STATUS "Check for feature set changes")
-    set_property(GLOBAL PROPERTY _qt_feature_clean TRUE)
-    foreach(feature ${QT_KNOWN_FEATURES})
-        if(DEFINED "FEATURE_${feature}" AND
-            NOT "${QT_FEATURE_${feature}}" STREQUAL "${FEATURE_${feature}}")
-            message("    '${feature}' is changed from ${QT_FEATURE_${feature}} \
-to ${FEATURE_${feature}}")
-            set(dirty_build TRUE)
-        endif()
-        unset("QT_FEATURE_${feature}" CACHE)
-    endforeach()
+option(QT_ALLOW_SYMLINK_IN_PATHS "Allows symlinks in paths." OFF)
 
-    set(QT_KNOWN_FEATURES "" CACHE INTERNAL "" FORCE)
-
-    if(dirty_build)
-        set_property(GLOBAL PROPERTY _qt_dirty_build TRUE)
-        message(WARNING "Re-configuring in existing build folder. \
-Some features will be re-evaluated automatically.")
-    endif()
-endif()
+qt_internal_detect_dirty_features()
 
 if(NOT QT_BUILD_EXAMPLES)
     # Disable deployment setup to avoid warnings about missing patchelf with CMake < 3.21.
     set(QT_SKIP_SETUP_DEPLOYMENT ON)
 endif()
+
+option(QT_ALLOW_DOWNLOAD "Allows files to be downloaded when building Qt." OFF)

cmake/QtSyncQtHelpers.cmake

@@ -79,6 +79,7 @@ function(qt_internal_target_sync_headers target module_headers module_headers_ge
     endif()
 
     get_target_property(qpa_filter_regex ${target} _qt_module_qpa_headers_filter_regex)
+    get_target_property(rhi_filter_regex ${target} _qt_module_rhi_headers_filter_regex)
     get_target_property(private_filter_regex ${target} _qt_module_private_headers_filter_regex)
 
     # We need to use the real paths since otherwise it may lead to the invalid work of the
@@ -96,6 +97,12 @@ function(qt_internal_target_sync_headers target module_headers module_headers_ge
         )
     endif()
 
+    if(rhi_filter_regex)
+        set(rhi_filter_argument
+            -rhiHeadersFilter "${rhi_filter_regex}"
+        )
+    endif()
+
     set(common_syncqt_arguments
         -module "${module}"
         -sourceDir "${source_dir_real}"
@@ -104,8 +111,10 @@ function(qt_internal_target_sync_headers target module_headers module_headers_ge
         -includeDir "${module_build_interface_include_dir}"
         -privateIncludeDir "${module_build_interface_private_include_dir}"
         -qpaIncludeDir "${module_build_interface_qpa_include_dir}"
+        -rhiIncludeDir "${module_build_interface_rhi_include_dir}"
         -generatedHeaders ${module_headers_generated}
         ${qpa_filter_argument}
+        ${rhi_filter_argument}
         ${public_namespaces_filter}
         ${non_qt_module_argument}
         ${internal_module_argument}
@@ -139,7 +148,6 @@ function(qt_internal_target_sync_headers target module_headers module_headers_ge
 
     set(syncqt_args "${common_syncqt_arguments}")
     list(APPEND syncqt_args
-        ${common_syncqt_arguments}
         -headers ${module_headers}
         -stagingDir "${syncqt_staging_dir}"
         -knownModules ${known_modules}
@@ -150,6 +158,21 @@ function(qt_internal_target_sync_headers target module_headers module_headers_ge
     set(syncqt_args_rsp "${binary_dir_real}/${target}_syncqt_args")
     qt_configure_file(OUTPUT "${syncqt_args_rsp}" CONTENT "${syncqt_args_string}")
 
+    get_target_property(external_headers_dir ${target} _qt_external_headers_dir)
+    if(external_headers_dir)
+        if(NOT IS_ABSOLUTE "${external_headers_dir}")
+            get_filename_component(external_headers_dir "${external_headers_dir}" ABSOLUTE)
+        endif()
+        if(EXISTS "${external_headers_dir}")
+            set(external_headers_dir_copy_cmd
+                COMMAND
+                    ${CMAKE_COMMAND}
+                    -E copy_directory
+                    "${external_headers_dir}"
+                    "${module_build_interface_include_dir}"
+            )
+        endif()
+    endif()
     add_custom_command(
         OUTPUT
             ${syncqt_outputs}
@@ -157,22 +180,36 @@ function(qt_internal_target_sync_headers target module_headers module_headers_ge
             ${QT_CMAKE_EXPORT_NAMESPACE}::syncqt
             "@${syncqt_args_rsp}"
             ${build_time_syncqt_arguments}
+        ${external_headers_dir_copy_cmd}
         COMMAND
             ${CMAKE_COMMAND} -E touch "${syncqt_timestamp}"
         DEPENDS
             ${syncqt_args_rsp}
             ${module_headers}
             ${QT_CMAKE_EXPORT_NAMESPACE}::syncqt
+            "$<GENEX_EVAL:$<TARGET_PROPERTY:${target},_qt_internal_sync_headers_deps>>"
         COMMENT
             "Running syncqt.cpp for module: ${module}"
         VERBATIM
     )
+
+    set(add_sync_headers_to_all "")
+    if(is_interface_lib)
+        set(add_sync_headers_to_all ALL)
+    endif()
+
     add_custom_target(${target}_sync_headers
+        ${add_sync_headers_to_all}
         DEPENDS
             ${syncqt_outputs}
     )
     add_dependencies(sync_headers ${target}_sync_headers)
+    set_target_properties(${target}
+        PROPERTIES _qt_internal_sync_headers_target ${target}_sync_headers)
 
+    if(is_3rd_party_library)
+        add_dependencies(thirdparty_sync_headers ${target}_sync_headers)
+    endif()
     # This target is required when building docs, to make all header files and their aliases
     # available for qdoc.
     # ${target}_sync_headers is added as dependency to make sure that
@@ -185,6 +222,7 @@ function(qt_internal_target_sync_headers target module_headers module_headers_ge
         COMMAND
             ${QT_CMAKE_EXPORT_NAMESPACE}::syncqt
             "@${syncqt_all_args_rsp}"
+        ${external_headers_dir_copy_cmd}
         DEPENDS
             ${module_headers}
             ${syncqt_all_args_rsp}
@@ -198,7 +236,7 @@ function(qt_internal_target_sync_headers target module_headers module_headers_ge
     endif()
     add_dependencies(sync_all_public_headers ${target}_sync_all_public_headers)
 
-    if(NOT is_3rd_party_library AND NOT is_framework)
+    if(NOT is_3rd_party_library AND NOT is_framework AND module_headers)
         # Install all the CaMeL style aliases of header files from the staging directory in one rule
         qt_install(DIRECTORY "${syncqt_staging_dir}/"
             DESTINATION "${module_install_interface_include_dir}"
@@ -220,7 +258,7 @@ function(qt_internal_target_sync_headers target module_headers module_headers_ge
     # Run sync Qt first time at configure step to make all header files available for the code model
     # of IDEs.
     get_property(synced_modules GLOBAL PROPERTY _qt_synced_modules)
-    if(NOT "${module}" IN_LIST synced_modules)
+    if(NOT "${module}" IN_LIST synced_modules AND QT_SYNC_HEADERS_AT_CONFIGURE_TIME)
         message(STATUS "Running syncqt.cpp for module: ${module}")
         get_target_property(syncqt_location ${QT_CMAKE_EXPORT_NAMESPACE}::syncqt LOCATION)
         execute_process(

cmake/QtTargetHelpers.cmake

@@ -14,14 +14,20 @@
 #     module, these files will raise a warning at configure time if the condition is not met.
 #   COMPILE_FLAGS
 #     Custom compilation flags.
+#   EXTRA_LINKER_SCRIPT_CONTENT
+#     Extra content that should be appended to a target linker script. Applicable for ld only.
 #   NO_PCH_SOURCES
 #     Skip the specified source files by PRECOMPILE_HEADERS feature.
 function(qt_internal_extend_target target)
     if(NOT TARGET "${target}")
-        qt_internal_is_in_test_batch(in_batch ${target})
-        if(NOT in_batch)
-            message(FATAL_ERROR "Trying to extend a non-existing target \"${target}\".")
+        message(FATAL_ERROR "${target} is not a target.")
     endif()
+    qt_internal_is_skipped_test(skipped ${target})
+    if(skipped)
+        return()
+    endif()
+    qt_internal_is_in_test_batch(in_batch ${target})
+    if(in_batch)
         _qt_internal_test_batch_target_name(target)
     endif()
 
@@ -36,6 +42,7 @@ function(qt_internal_extend_target target)
     )
     set(single_args
         PRECOMPILED_HEADER
+        EXTRA_LINKER_SCRIPT_CONTENT
     )
     set(multi_args
         ${__default_public_args}
@@ -44,7 +51,6 @@ function(qt_internal_extend_target target)
         CONDITION
         CONDITION_INDEPENDENT_SOURCES
         COMPILE_FLAGS
-        NO_PCH_SOURCES
     )
 
     cmake_parse_arguments(PARSE_ARGV 1 arg
@@ -107,6 +113,19 @@ function(qt_internal_extend_target target)
             if(NOT base_lib STREQUAL lib)
                 qt_create_nolink_target("${base_lib}" ${target})
             endif()
+
+            # Collect _sync_headers targets from libraries that the target depends on. This is
+            # heuristic way of building the dependency tree between the _sync_headers targets of
+            # different Qt modules.
+            if(TARGET "${lib}")
+                get_target_property(is_private ${lib} _qt_is_private_module)
+                if(is_private)
+                    get_target_property(lib ${lib} _qt_public_module_target_name)
+                endif()
+                set(out_genex "$<TARGET_PROPERTY:${lib},_qt_internal_sync_headers_target>")
+                set_property(TARGET ${target}
+                    APPEND PROPERTY _qt_internal_sync_headers_deps "${out_genex}")
+            endif()
         endforeach()
 
         # Set-up the target
@@ -237,6 +256,10 @@ function(qt_internal_extend_target target)
             ${sources_property} "${arg_CONDITION_INDEPENDENT_SOURCES}")
     endif()
 
+    if(arg_EXTRA_LINKER_SCRIPT_CONTENT)
+        set_target_properties(${target} PROPERTIES
+            _qt_extra_linker_script_content "${arg_EXTRA_LINKER_SCRIPT_CONTENT}")
+    endif()
 endfunction()
 
 function(qt_is_imported_target target out_var)
@@ -1001,6 +1024,33 @@ endfunction()
 # Needed to allow selectively applying certain flags via PlatformXInternal targets.
 function(qt_internal_mark_as_internal_library target)
     set_target_properties(${target} PROPERTIES _qt_is_internal_library TRUE)
+    qt_internal_mark_as_internal_target(${target})
+endfunction()
+
+# Marks a target with a property that it was built using the internal Qt API (qt_internal_*) as
+# opposed to it being a user project library or executable(qt_add_*, etc).
+#
+# Needed to allow selectively applying certain flags via PlatformXInternal targets.
+function(qt_internal_mark_as_internal_target target)
+    set_target_properties(${target} PROPERTIES _qt_is_internal_target TRUE)
+endfunction()
+
+# Marks a target with a property to skip it adding it as a dependency when building examples as
+# ExternalProjects.
+# Needed to create a ${repo}_src global target that examples can depend on in multi-config builds
+# due to a bug in AUTOUIC.
+#
+# See QTBUG-110369.
+function(qt_internal_skip_dependency_for_examples target)
+    set_target_properties(${target} PROPERTIES _qt_skip_dependency_for_examples TRUE)
+endfunction()
+
+function(qt_internal_is_target_skipped_for_examples target out_var)
+    get_property(is_skipped TARGET ${target} PROPERTY _qt_skip_dependency_for_examples)
+    if(NOT is_skipped)
+        set(is_skipped FALSE)
+    endif()
+    set(${out_var} "${is_skipped}" PARENT_SCOPE)
 endfunction()
 
 function(qt_internal_link_internal_platform_for_object_library target)
@@ -1065,11 +1115,15 @@ endfunction()
 # The function disables one or multiple internal global definitions that are defined by the
 # qt_internal_add_global_definition function for a specific 'target'.
 function(qt_internal_undefine_global_definition target)
-    if(NOT TARGET ${target})
-        qt_internal_is_in_test_batch(in_batch ${target})
-        if(NOT ${in_batch})
+    if(NOT TARGET "${target}")
         message(FATAL_ERROR "${target} is not a target.")
     endif()
+    qt_internal_is_skipped_test(skipped ${target})
+    if(skipped)
+        return()
+    endif()
+    qt_internal_is_in_test_batch(in_batch ${target})
+    if(in_batch)
         _qt_internal_test_batch_target_name(target)
     endif()
 
@@ -1120,3 +1174,157 @@ function(qt_internal_get_target_sources_property out_var)
     endif()
     set(${out_var} "${${out_var}}" PARENT_SCOPE)
 endfunction()
+
+# This function collects target properties that contain generator expressions and needs to be
+# exported. This function is needed since the CMake EXPORT_PROPERTIES property doesn't support
+# properties that contain generator expressions.
+# Usage: qt_internal_add_genex_properties_export(target properties...)
+function(qt_internal_add_genex_properties_export target)
+    get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG)
+
+    set(config_check_begin "")
+    set(config_check_end "")
+    if(is_multi_config)
+        list(GET CMAKE_CONFIGURATION_TYPES 0 first_config_type)
+
+        # The genex snippet is evaluated to '$<NOT:$<BOOL:$<CONFIG>>>' in the generated cmake file.
+        # The check is only applicable to the 'main' configuration. If user project doesn't use
+        # multi-config generator, then the check supposed to return true and the value from the
+        # 'main' configuration supposed to be used.
+        string(JOIN "" check_if_config_empty
+            "$<1:$><NOT:"
+                "$<1:$><BOOL:"
+                    "$<1:$><CONFIG$<ANGLE-R>"
+                "$<ANGLE-R>"
+            "$<ANGLE-R>"
+        )
+
+        # The genex snippet is evaluated to '$<CONFIG:'Qt config type'>' in the generated cmake
+        # file and checks if the config that user uses matches the generated cmake file config.
+        string(JOIN "" check_user_config
+            "$<1:$><CONFIG:$<CONFIG>$<ANGLE-R>"
+        )
+
+        # The genex snippet is evaluated to '$<$<OR:$<CONFIG:'Qt config type'>>:'Property content'>
+        # for non-main Qt configs and to
+        # $<$<OR:$<CONFIG:'Qt config type'>,$<NOT:$<BOOL:$<CONFIG>>>>:'Property content'> for the
+        # main Qt config. This guard is required to choose the correct value of the property for the
+        # user project according to the user config type.
+        # All genexes need to be escaped properly to protect them from evaluation by the
+        # file(GENERATE call in the qt_internal_export_genex_properties function.
+        string(JOIN "" config_check_begin
+            "$<1:$><"
+                "$<1:$><OR:"
+                    "${check_user_config}"
+                    "$<$<CONFIG:${first_config_type}>:$<COMMA>${check_if_config_empty}>"
+                "$<ANGLE-R>:"
+        )
+        set(config_check_end "$<ANGLE-R>")
+    endif()
+    set(target_name "${QT_CMAKE_EXPORT_NAMESPACE}::${target}")
+    foreach(property IN LISTS ARGN)
+        set(target_property_genex "$<TARGET_PROPERTY:${target_name},${property}>")
+        # All properties that contain lists need to be protected of processing by JOIN genex calls.
+        # So this escapes the semicolons for these list.
+        set(target_property_list_escape
+            "$<JOIN:$<GENEX_EVAL:${target_property_genex}>,\;>")
+        set(property_value
+            "\"${config_check_begin}${target_property_list_escape}${config_check_end}\"")
+        set_property(TARGET ${target} APPEND PROPERTY _qt_export_genex_properties_content
+            "${property} ${property_value}")
+    endforeach()
+endfunction()
+
+# This function executes generator expressions for the properties that are added by the
+# qt_internal_add_genex_properties_export function and sets the calculated values to the
+# corresponding properties in the generated ExtraProperties.cmake file. The file then needs to be
+# included after the target creation routines in Config.cmake files. It also supports Multi-Config
+# builds.
+# Arguments:
+# EXPORT_NAME_PREFIX:
+#    The portion of the file name before ExtraProperties.cmake
+# CONFIG_INSTALL_DIR:
+#    Installation location for the file.
+# TARGETS:
+#    The internal target names.
+function(qt_internal_export_genex_properties)
+    set(option_args "")
+    set(single_args
+        EXPORT_NAME_PREFIX
+        CONFIG_INSTALL_DIR
+    )
+    set(multi_args TARGETS)
+    cmake_parse_arguments(arg "${option_args}" "${single_args}" "${multi_args}" ${ARGN})
+
+    if(NOT arg_EXPORT_NAME_PREFIX)
+        message(FATAL_ERROR "qt_internal_export_genex_properties: "
+            "Missing EXPORT_NAME_PREFIX argument.")
+    endif()
+
+    if(NOT arg_TARGETS)
+        message(FATAL_ERROR "qt_internal_export_genex_properties: "
+            "TARGETS argument must contain at least one target")
+    endif()
+
+    foreach(target IN LISTS arg_TARGETS)
+        get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG)
+
+        set(output_file_base_name "${arg_EXPORT_NAME_PREFIX}ExtraProperties")
+        set(should_append "")
+        set(config_suffix "")
+        if(is_multi_config)
+            list(GET CMAKE_CONFIGURATION_TYPES 0 first_config_type)
+            set(config_suffix "$<$<NOT:$<CONFIG:${first_config_type}>>:-$<CONFIG>>")
+            # If the generated file belongs to the 'main' config type, we should set property
+            # but not append it.
+            string(JOIN "" should_append
+                "$<$<NOT:$<CONFIG:${first_config_type}>>: APPEND>")
+        endif()
+        set(file_name "${output_file_base_name}${config_suffix}.cmake")
+
+        qt_path_join(output_file "${arg_CONFIG_INSTALL_DIR}"
+            "${file_name}")
+
+        if(NOT IS_ABSOLUTE "${output_file}")
+            qt_path_join(output_file "${QT_BUILD_DIR}" "${output_file}")
+        endif()
+
+        set(target_name "${QT_CMAKE_EXPORT_NAMESPACE}::${target}")
+
+        string(JOIN "" set_property_begin "set_property(TARGET "
+            "${target_name}${should_append} PROPERTY "
+        )
+        set(set_property_end ")")
+        set(set_property_glue "${set_property_end}\n${set_property_begin}")
+        set(property_list
+            "$<GENEX_EVAL:$<TARGET_PROPERTY:${target},_qt_export_genex_properties_content>>")
+        string(JOIN "" set_property_content "${set_property_begin}"
+            "$<JOIN:${property_list},${set_property_glue}>"
+            "${set_property_end}")
+
+        if(is_multi_config)
+            set(config_includes "")
+            foreach(config IN LISTS CMAKE_CONFIGURATION_TYPES)
+                if(NOT first_config_type STREQUAL config)
+                    set(include_file_name
+                        "${output_file_base_name}-${config}.cmake")
+                    list(APPEND config_includes
+                        "include(\"\${CMAKE_CURRENT_LIST_DIR}/${include_file_name}\")")
+                endif()
+            endforeach()
+            list(JOIN config_includes "\n" config_includes_string)
+            set(config_includes_string
+                "\n$<$<CONFIG:${first_config_type}>:${config_includes_string}>")
+        endif()
+
+        file(GENERATE OUTPUT "${output_file}"
+            CONTENT "$<$<BOOL:${property_list}>:${set_property_content}${config_includes_string}>"
+            CONDITION "$<BOOL:${property_list}>"
+        )
+    endforeach()
+
+    qt_install(FILES "$<$<BOOL:${property_list}>:${output_file}>"
+        DESTINATION "${arg_CONFIG_INSTALL_DIR}"
+        COMPONENT Devel
+    )
+endfunction()

cmake/QtTestHelpers.cmake

@@ -214,6 +214,7 @@ function(qt_internal_get_test_arg_definitions optional_args single_value_args mu
         MANUAL
         NO_BATCH
         NO_INSTALL
+        BUNDLE_ANDROID_OPENSSL_LIBS
         PARENT_SCOPE
     )
     set(${single_value_args}
@@ -246,6 +247,7 @@ function(qt_internal_add_test_to_batch batch_name name)
 
     # Lazy-init the test batch
     if(NOT TARGET ${target})
+        qt_internal_library_deprecation_level(deprecation_define)
         qt_internal_add_executable(${target}
             ${exceptions_text}
             ${gui_text}
@@ -253,11 +255,16 @@ function(qt_internal_add_test_to_batch batch_name name)
             NO_INSTALL
             OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/build_dir"
             SOURCES "${QT_CMAKE_DIR}/qbatchedtestrunner.in.cpp"
-            DEFINES QTEST_BATCH_TESTS
+            DEFINES QTEST_BATCH_TESTS ${deprecation_define}
             INCLUDE_DIRECTORIES ${private_includes}
             LIBRARIES ${QT_CMAKE_EXPORT_NAMESPACE}::Core
                     ${QT_CMAKE_EXPORT_NAMESPACE}::Test
                     ${QT_CMAKE_EXPORT_NAMESPACE}::TestPrivate
+                    # Add GUI by default so that the plugins link properly with non-standalone
+                    # build of tests. Plugin handling is currently only done in
+                    # qt_internal_add_executable if Gui is present. This should be reevaluated with
+                    # multiple batches.
+                    ${QT_CMAKE_EXPORT_NAMESPACE}::Gui
         )
 
         set_property(TARGET ${target} PROPERTY _qt_has_exceptions ${arg_EXCEPTIONS})
@@ -308,17 +315,12 @@ function(qt_internal_add_test_to_batch batch_name name)
     list(PREPEND batched_test_list ${name})
     set_property(GLOBAL PROPERTY _qt_batched_test_list_property ${batched_test_list})
 
-    qt_internal_library_deprecation_level(deprecation_define)
-
     # Merge the current test with the rest of the batch
     qt_internal_extend_target(${target}
         INCLUDE_DIRECTORIES ${arg_INCLUDE_DIRECTORIES}
         PUBLIC_LIBRARIES ${arg_PUBLIC_LIBRARIES}
         LIBRARIES ${arg_LIBRARIES}
         SOURCES ${arg_SOURCES}
-        DEFINES
-            ${arg_DEFINES}
-            ${deprecation_define}
         COMPILE_OPTIONS ${arg_COMPILE_OPTIONS}
         COMPILE_FLAGS ${arg_COMPILE_FLAGS}
         LINK_OPTIONS ${arg_LINK_OPTIONS}
@@ -335,7 +337,7 @@ function(qt_internal_add_test_to_batch batch_name name)
         set_source_files_properties(${source}
                                     TARGET_DIRECTORY ${target}
                                     PROPERTIES COMPILE_DEFINITIONS
-                                        "BATCHED_TEST_NAME=\"${name}\"")
+                                        "BATCHED_TEST_NAME=\"${name}\";${arg_DEFINES}" )
     endforeach()
     set(${batch_name} ${target} PARENT_SCOPE)
 
@@ -362,6 +364,34 @@ function(qt_internal_is_in_test_batch out name)
     endif()
 endfunction()
 
+function(qt_internal_is_skipped_test out name)
+    get_target_property(is_skipped_test ${name} _qt_is_skipped_test)
+    set(${out} ${is_skipped_test} PARENT_SCOPE)
+endfunction()
+
+function(qt_internal_set_skipped_test name)
+    set_target_properties(${name} PROPERTIES _qt_is_skipped_test TRUE)
+endfunction()
+
+function(qt_internal_is_qtbase_test out)
+    get_filename_component(dir "${CMAKE_CURRENT_BINARY_DIR}" ABSOLUTE)
+    set(${out} FALSE PARENT_SCOPE)
+
+    while(TRUE)
+        get_filename_component(filename "${dir}" NAME)
+        if("${filename}" STREQUAL "qtbase")
+            set(${out} TRUE PARENT_SCOPE)
+            break()
+        endif()
+
+        set(prev_dir "${dir}")
+        get_filename_component(dir "${dir}" DIRECTORY)
+        if("${dir}" STREQUAL "${prev_dir}")
+            break()
+        endif()
+    endwhile()
+endfunction()
+
 function(qt_internal_get_batched_test_arguments out testname)
     if(WASM)
         # Add a query string to the runner document, so that the script therein
@@ -402,6 +432,32 @@ function(qt_internal_add_test name)
     _qt_internal_validate_all_args_are_parsed(arg)
     _qt_internal_validate_no_unity_build(arg)
 
+    set(batch_current_test FALSE)
+    if(QT_BUILD_TESTS_BATCHED AND NOT arg_NO_BATCH AND NOT arg_QMLTEST AND NOT arg_MANUAL
+            AND ("${QT_STANDALONE_TEST_PATH}" STREQUAL ""
+                 OR DEFINED ENV{QT_BATCH_STANDALONE_TESTS}))
+        set(batch_current_test TRUE)
+    endif()
+
+    if(batch_current_test OR (QT_BUILD_TESTS_BATCHED AND arg_QMLTEST))
+        if (QT_SUPERBUILD OR DEFINED ENV{TESTED_MODULE_COIN})
+            set(is_qtbase_test FALSE)
+            if(QT_SUPERBUILD)
+                qt_internal_is_qtbase_test(is_qtbase_test)
+            elseif($ENV{TESTED_MODULE_COIN} STREQUAL "qtbase")
+                set(is_qtbase_test TRUE)
+            endif()
+            if(NOT is_qtbase_test)
+                file(GENERATE OUTPUT "dummy${name}.cpp" CONTENT "int main() { return 0; }")
+                # Add a dummy target to tackle some potential problems
+                qt_internal_add_executable(${name} SOURCES "dummy${name}.cpp")
+                # Batched tests outside of qtbase are unsupported and skipped
+                qt_internal_set_skipped_test(${name})
+                return()
+            endif()
+        endif()
+    endif()
+
     if (NOT arg_OUTPUT_DIRECTORY)
         set(arg_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
     endif()
@@ -420,9 +476,8 @@ function(qt_internal_add_test name)
             "removed in a future Qt version. Use the LIBRARIES option instead.")
     endif()
 
-    if(NOT arg_NO_BATCH AND QT_BUILD_TESTS_BATCHED AND NOT arg_QMLTEST AND NOT arg_MANUAL)
+    if(batch_current_test)
         qt_internal_add_test_to_batch(name ${name} ${ARGN})
-        set(setting_up_batched_test TRUE)
     elseif(arg_SOURCES)
         if(QT_BUILD_TESTS_BATCHED AND arg_QMLTEST)
             message(WARNING "QML tests won't be batched - unsupported (yet)")
@@ -498,7 +553,6 @@ function(qt_internal_add_test name)
         qt_internal_extend_target("${name}" CONDITION ANDROID
             LIBRARIES ${QT_CMAKE_EXPORT_NAMESPACE}::Gui
         )
-        set(setting_up_batched_test FALSE)
         set_target_properties(${name} PROPERTIES _qt_is_test_executable TRUE)
         set_target_properties(${name} PROPERTIES _qt_is_manual_test ${arg_MANUAL})
     endif()
@@ -526,6 +580,21 @@ function(qt_internal_add_test name)
     endif()
 
     if (ANDROID)
+        if(arg_BUNDLE_ANDROID_OPENSSL_LIBS)
+            if(NOT OPENSSL_ROOT_DIR)
+                message(WARNING "The argument BUNDLE_ANDROID_OPENSSL_LIBS is set "
+                "but OPENSSL_ROOT_DIR parameter is not set.")
+            else()
+                if(EXISTS "${OPENSSL_ROOT_DIR}/${CMAKE_ANDROID_ARCH_ABI}/libcrypto_3.so")
+                    set_property(TARGET ${name} APPEND PROPERTY QT_ANDROID_EXTRA_LIBS
+                        "${OPENSSL_ROOT_DIR}/${CMAKE_ANDROID_ARCH_ABI}/libcrypto_3.so"
+                        "${OPENSSL_ROOT_DIR}/${CMAKE_ANDROID_ARCH_ABI}/libssl_3.so")
+                else()
+                    message(STATUS "Test should bundle OpenSSL libraries but they are not found."
+                                    " This is fine if OpenSSL was built statically.")
+                endif()
+            endif()
+        endif()
         qt_internal_android_test_arguments("${name}" test_executable extra_test_args)
         set(test_working_dir "${CMAKE_CURRENT_BINARY_DIR}")
     elseif(QNX)
@@ -534,7 +603,7 @@ function(qt_internal_add_test name)
     elseif(WASM)
         # The test script expects an html file. In case of batched tests, the
         # version specialized for running batches has to be supplied.
-        if(setting_up_batched_test)
+        if(batch_current_test)
             get_target_property(batch_output_dir ${name} RUNTIME_OUTPUT_DIRECTORY)
             set(test_executable "${batch_output_dir}/${name}.html")
         else()
@@ -546,11 +615,16 @@ function(qt_internal_add_test name)
         list(APPEND extra_test_args "--silence_timeout=60")
         # TODO: Add functionality to specify browser
         list(APPEND extra_test_args "--browser=chrome")
+        list(APPEND extra_test_args "--browser_args=\"--password-store=basic\"")
+        list(APPEND extra_test_args "--kill_exit")
 
-        # We always want to enable asyncify for tests, as some of them use exec
+        # Tests may require asyncify if they use exec(). Enable asyncify for
+        # batched tests since this is the configuration used on the CI system.
         # Optimize for size (-Os), since asyncify tends to make the resulting
         # binary very large
+        if(batch_current_test)
             target_link_options("${name}" PRIVATE "SHELL:-s ASYNCIFY" "-Os")
+        endif()
 
         # This tells cmake to run the tests with this script, since wasm files can't be
         # executed directly
@@ -572,9 +646,11 @@ function(qt_internal_add_test name)
     endif()
 
     if(NOT arg_MANUAL)
-        if(setting_up_batched_test)
+        if(batch_current_test)
             qt_internal_get_batched_test_arguments(batched_test_args ${testname})
             list(PREPEND extra_test_args ${batched_test_args})
+        elseif(WASM AND CMAKE_BUILD_TYPE STREQUAL "Debug")
+            list(PREPEND extra_test_args "qvisualoutput")
         endif()
 
         qt_internal_collect_command_environment(test_env_path test_env_plugin_path)
@@ -645,11 +721,30 @@ function(qt_internal_add_test name)
             foreach(testdata IN LISTS arg_TESTDATA)
                 list(APPEND builtin_files ${testdata})
             endforeach()
+            foreach(file IN LISTS builtin_files)
+                set_source_files_properties(${file}
+                    PROPERTIES QT_SKIP_QUICKCOMPILER TRUE
+                )
+            endforeach()
 
+            if(batch_current_test)
+                set(blacklist_path "BLACKLIST")
+                if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${blacklist_path}")
+                    get_target_property(blacklist_files ${name} _qt_blacklist_files)
+                    if(NOT blacklist_files)
+                        set_target_properties(${name} PROPERTIES _qt_blacklist_files "")
+                        set(blacklist_files "")
+                        cmake_language(EVAL CODE "cmake_language(DEFER DIRECTORY \"${CMAKE_SOURCE_DIR}\" CALL \"_qt_internal_finalize_batch\" \"${name}\") ")
+                    endif()
+                    list(PREPEND blacklist_files "${CMAKE_CURRENT_SOURCE_DIR}/${blacklist_path}")
+                    set_target_properties(${name} PROPERTIES _qt_blacklist_files "${blacklist_files}")
+                endif()
+            else()
                 set(blacklist_path "BLACKLIST")
                 if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${blacklist_path}")
                     list(APPEND builtin_files ${blacklist_path})
                 endif()
+            endif()
 
             list(REMOVE_DUPLICATES builtin_files)
 
@@ -746,7 +841,8 @@ for this function. Will be ignored")
     endif()
 
     set(executable_name ${arg_NAME})
-    if(QT_BUILD_TESTS_BATCHED)
+    qt_internal_is_in_test_batch(is_in_batch ${executable_name})
+    if(is_in_batch)
         _qt_internal_test_batch_target_name(executable_name)
     endif()
     add_test(NAME "${arg_NAME}" COMMAND "${CMAKE_COMMAND}" "-P" "${arg_OUTPUT_FILE}"
@@ -812,8 +908,8 @@ function(qt_internal_add_test_helper name)
 
     set(extra_args_to_pass)
     if(NOT arg_OVERRIDE_OUTPUT_DIRECTORY)
-        if(QT_BUILD_TESTS_BATCHED)
         _qt_internal_test_batch_target_name(test_batch_target_name)
+        if(QT_BUILD_TESTS_BATCHED AND TARGET ${test_batch_target_name})
             get_target_property(
                 test_batch_output_dir ${test_batch_target_name} RUNTIME_OUTPUT_DIRECTORY)
             set(extra_args_to_pass OUTPUT_DIRECTORY "${test_batch_output_dir}")

cmake/QtToolHelpers.cmake

@@ -15,6 +15,13 @@
 #     INSTALL_VERSIONED_LINK
 #         Prefix build only. On installation, create a versioned hard-link of the installed file.
 #         E.g. create a link of "bin/qmake6" to "bin/qmake".
+#     TRY_RUN
+#         On Windows, it creates a helper batch script that tests whether the tool can be executed
+#         successfully or not. If not, build halts and an error will be show, with tips on what
+#         might be cause, and how to fix it. TRY_RUN is disabled when cross-compiling.
+#     TRY_RUN_FLAGS
+#         Command line flags that are going to be passed to the tool for testing its correctness.
+#         If no flags were given, we default to `-v`.
 #
 # One-value Arguments:
 #     EXTRA_CMAKE_FILES
@@ -42,11 +49,13 @@ function(qt_internal_add_tool target_name)
         USER_FACING
         INSTALL_VERSIONED_LINK
         EXCEPTIONS
-        NO_UNITY_BUILD)
+        NO_UNITY_BUILD
+        TRY_RUN)
     set(one_value_keywords
         TOOLS_TARGET
         INSTALL_DIR
         CORE_LIBRARY
+        TRY_RUN_FLAGS
         ${__default_target_info_args})
     set(multi_value_keywords
         EXTRA_CMAKE_FILES
@@ -105,6 +114,7 @@ function(qt_internal_add_tool target_name)
         NO_INSTALL
         ${arg_NO_UNITY_BUILD}
         SOURCES ${arg_SOURCES}
+        NO_PCH_SOURCES ${arg_NO_PCH_SOURCES}
         NO_UNITY_BUILD_SOURCES ${arg_NO_UNITY_BUILD_SOURCES}
         INCLUDE_DIRECTORIES
             ${arg_INCLUDE_DIRECTORIES}
@@ -224,10 +234,62 @@ function(qt_internal_add_tool target_name)
         qt_internal_apply_staging_prefix_build_rpath_workaround()
     endif()
 
+    if(arg_TRY_RUN AND WIN32 AND NOT CMAKE_CROSSCOMPILING)
+        if(NOT arg_TRY_RUN_FLAGS)
+            set(arg_TRY_RUN_FLAGS "-v")
+        endif()
+        _qt_internal_add_try_run_post_build("${target_name}" "${arg_TRY_RUN_FLAGS}")
+    endif()
+
     qt_enable_separate_debug_info(${target_name} "${install_dir}" QT_EXECUTABLE)
     qt_internal_install_pdb_files(${target_name} "${install_dir}")
 endfunction()
 
+function(_qt_internal_add_try_run_post_build target try_run_flags)
+    qt_internal_get_upper_case_main_cmake_configuration(main_cmake_configuration)
+    get_target_property(target_out_dir ${target}
+                        RUNTIME_OUTPUT_DIRECTORY_${main_cmake_configuration})
+    get_target_property(target_bin_dir ${target}
+                        BINARY_DIR)
+
+    set(try_run_scripts_path "${target_bin_dir}/${target}_try_run.bat")
+    # The only reason -h is passed is because some of the tools, e.g., moc
+    # wait for an input without any arguments.
+
+    qt_configure_file(OUTPUT "${try_run_scripts_path}"
+        CONTENT "@echo off
+
+${target_out_dir}/${target}.exe ${try_run_flags} > nul 2>&1
+
+if \"%errorlevel%\" == \"-1073741515\" (
+echo
+echo     '${target}' is built successfully, but some of the libraries
+echo     necessary for running it are missing. If you are building Qt with
+echo     3rdparty libraries, make sure that you add their directory to the
+echo     PATH environment variable.
+echo
+exit /b %errorlevel%
+)
+echo. > ${target_bin_dir}/${target}_try_run_passed"
+        )
+
+    add_custom_command(
+        OUTPUT
+            ${target_bin_dir}/${target}_try_run_passed
+        DEPENDS
+            ${target}
+        COMMAND
+            ${CMAKE_COMMAND} -E env QT_COMMAND_LINE_PARSER_NO_GUI_MESSAGE_BOXES=1
+            ${try_run_scripts_path}
+        COMMENT
+            "Testing ${target} by trying to run it."
+        VERBATIM
+    )
+
+    add_custom_target(${target}_try_run ALL
+                      DEPENDS ${target_bin_dir}/${target}_try_run_passed)
+endfunction()
+
 function(qt_export_tools module_name)
     # Bail out when not building tools.
     if(NOT QT_WILL_BUILD_TOOLS)
@@ -287,7 +349,7 @@ function(qt_export_tools module_name)
             string(REGEX REPLACE "_native$" "" tool_name ${tool_name})
         endif()
         set(extra_cmake_statements "${extra_cmake_statements}
-if (NOT QT_NO_CREATE_TARGETS)
+if(NOT QT_NO_CREATE_TARGETS AND ${INSTALL_CMAKE_NAMESPACE}${target}_FOUND)
     __qt_internal_promote_target_to_global(${INSTALL_CMAKE_NAMESPACE}::${tool_name})
 endif()
 ")

cmake/QtToolchainHelpers.cmake

@@ -31,6 +31,14 @@ set(__qt_chainload_toolchain_file \"\${__qt_initially_configured_toolchain_file}
         list(APPEND init_platform "set(CMAKE_SYSTEM_PROCESSOR arm64 CACHE STRING \"\")")
     endif()
 
+    if(QT_QMAKE_TARGET_MKSPEC)
+        list(APPEND init_platform
+            "if(NOT QT_QMAKE_TARGET_MKSPEC)"
+            "    set(QT_QMAKE_TARGET_MKSPEC ${QT_QMAKE_TARGET_MKSPEC} CACHE STRING \"\")"
+            "endif()"
+        )
+    endif()
+
     if("${QT_QMAKE_TARGET_MKSPEC}" STREQUAL "linux-g++-32" AND NOT QT_NO_AUTO_DETECT_LINUX_X86)
         set(__qt_toolchain_common_flags_init "-m32")
 

cmake/QtWasmHelpers.cmake

@@ -8,7 +8,8 @@ function (qt_internal_setup_wasm_target_properties wasmTarget)
     target_link_options("${wasmTarget}" INTERFACE
     "SHELL:-s MAX_WEBGL_VERSION=2"
     "SHELL:-s FETCH=1"
-    "SHELL:-s WASM_BIGINT=1")
+    "SHELL:-s WASM_BIGINT=1"
+    "SHELL:-s STACK_SIZE=5MB")
 
     target_link_libraries("${wasmTarget}" INTERFACE embind)
 
@@ -93,17 +94,25 @@ function (qt_internal_setup_wasm_target_properties wasmTarget)
 
         set_property(GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS TRUE)
 
-        # plugins are SIDE_MODULE
-        target_compile_options("${wasmTarget}" INTERFACE
-        "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,MODULE_LIBRARY>:" -s SIDE_MODULE=1>)
-        target_link_options("${wasmTarget}" INTERFACE
-        "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,MODULE_LIBRARY>:" -s SIDE_MODULE=1>)
+        set(side_modules
+            MODULE_LIBRARY SHARED_LIBRARY)
+        set(enable_side_module_if_needed
+            "$<$<IN_LIST:$<TARGET_PROPERTY:TYPE>,${side_modules}>:SHELL:-s SIDE_MODULE=1>")
+        set(enable_main_module_if_needed
+            "$<$<IN_LIST:$<TARGET_PROPERTY:TYPE>,EXECUTABLE>:SHELL:-s MAIN_MODULE=1>")
+        set(set_shared_module_type_if_needed
+            "${enable_side_module_if_needed}"
+            "${enable_main_module_if_needed}"
+        )
 
-        # shared libs are SIDE_MODULE
-        target_compile_options("${wasmTarget}" INTERFACE
-        "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,SHARED_LIBRARY>:" -s SIDE_MODULE=1>)
+        # Add Qt libdir to linker library paths
+        set(qt_lib_location
+            "${QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX}/${INSTALL_LIBDIR}")
         target_link_options("${wasmTarget}" INTERFACE
-        "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,SHARED_LIBRARY>:" -s SIDE_MODULE=1>)
+            "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,EXECUTABLE>:SHELL:" -L${qt_lib_location}/>)
+
+        target_compile_options("${wasmTarget}" INTERFACE "${set_shared_module_type_if_needed}")
+        target_link_options("${wasmTarget}" INTERFACE "${set_shared_module_type_if_needed}")
 
     else()
         target_link_options("${wasmTarget}" INTERFACE "SHELL:-s ERROR_ON_UNDEFINED_SYMBOLS=1")

cmake/QtWrapperScriptHelpers.cmake

@@ -39,6 +39,20 @@ function(qt_internal_create_wrapper_scripts)
                    DESTINATION "${INSTALL_BINDIR}")
     endif()
 
+    if(generate_unix)
+        configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake-create.in"
+                    "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake-create" @ONLY
+                    NEWLINE_STYLE LF)
+        qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake-create"
+                DESTINATION "${INSTALL_BINDIR}")
+    endif()
+    if(generate_non_unix)
+        configure_file("${CMAKE_CURRENT_SOURCE_DIR}/bin/qt-cmake-create.bat.in"
+                    "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake-create.bat" @ONLY
+                    NEWLINE_STYLE CRLF)
+        qt_install(PROGRAMS "${QT_BUILD_DIR}/${INSTALL_BINDIR}/qt-cmake-create.bat"
+                DESTINATION "${INSTALL_BINDIR}")
+    endif()
     # Provide a private convenience wrapper with options which should not be propagated via the
     # public qt-cmake wrapper e.g. CMAKE_GENERATOR.
     # These options can not be set in a toolchain file, but only on the command line.

cmake/QtWriteArgsFile.cmake

@@ -6,17 +6,74 @@
 # This is used for writing the config.opt file.
 #
 # This script takes the following arguments:
-# IN_FILE: The input file. The whole command line as one string.
+# IN_FILE: The input file. The whole command line as one string, or one argument per line.
+# REDO_FILE: A file containing extra commands to be joined with IN_FILE.
 # OUT_FILE: The output file. One argument per line.
 # SKIP_ARGS: Number of arguments to skip from the front of the arguments list.
 # IGNORE_ARGS: List of arguments to be ignored, i.e. that are not written.
+#
+# If the REDO_FILE is given, its parameters will be merged with IN_FILE parameters
+# and be written into the OUT_FILE.
 
 cmake_minimum_required(VERSION 3.16)
 
 # Read arguments from IN_FILE and separate them.
 file(READ "${IN_FILE}" raw_args)
+# To catch cases where the path ends with an `\`, e.g., `-prefix "C:\Path\"`
+string(REPLACE "\\\"" "\"" raw_args "${raw_args}")
+string(REPLACE ";" "[[;]]" raw_args "${raw_args}")
+
 separate_arguments(args NATIVE_COMMAND "${raw_args}")
 
+string(REPLACE "\;" ";" args "${args}")
+string(REPLACE "[[;]]" "\;" args "${args}")
+
+if(DEFINED REDO_FILE)
+    file(READ "${REDO_FILE}" raw_redo_args)
+    separate_arguments(redo_args NATIVE_COMMAND "${raw_redo_args}")
+
+    if(args)
+        list(FIND args "--" args_ddash_loc)
+        list(FIND redo_args "--" redo_ddash_loc)
+        if("${redo_ddash_loc}" STREQUAL "-1")
+            if("${args_ddash_loc}" STREQUAL "-1")
+                list(LENGTH args args_ddash_loc)
+            endif()
+            # Avoid adding an empty line for an empty -redo
+            if(NOT "${redo_args}" STREQUAL "")
+                list(INSERT args ${args_ddash_loc} "${redo_args}")
+            endif()
+        else()
+            # Handling redo's configure options
+            list(SUBLIST redo_args 0 ${redo_ddash_loc} redo_config_args)
+            if(redo_config_args)
+                if("${args_ddash_loc}" STREQUAL "-1")
+                    list(APPEND args "${redo_config_args}")
+                else()
+                    list(INSERT args ${args_ddash_loc} "${redo_config_args}")
+                endif()
+            endif()
+
+            # Handling redo's CMake options
+            list(LENGTH redo_args redo_args_len)
+            math(EXPR redo_ddash_loc "${redo_ddash_loc} + 1")
+            # Catch an unlikely case of -redo being called with an empty --, ie., `-redo --`
+            if(NOT ${redo_ddash_loc} STREQUAL ${redo_args_len})
+                list(SUBLIST redo_args ${redo_ddash_loc} -1 redo_cmake_args)
+            endif()
+
+            if(DEFINED redo_cmake_args)
+                if("${args_ddash_loc}" STREQUAL "-1")
+                    list(APPEND args "--")
+                endif()
+                list(APPEND args "${redo_cmake_args}")
+            endif()
+        endif()
+    else()
+        list(APPEND args "${redo_args}")
+    endif()
+endif()
+
 # Skip arguments if requested
 if(DEFINED SKIP_ARGS)
     foreach(i RANGE 1 ${SKIP_ARGS})

cmake/README.md

@@ -313,3 +313,16 @@ $ cd some/empty/directory
 $ ~/Qt/6.0.0/bin/qt-cmake-standalone-test ~/source/of/qtbase/test/auto/corelib/io/qprocess
 $ cmake --build .
 ```
+
+## qt-cmake-create
+
+Generates a simple CMakeLists.txt based on source files in specified project directory.
+
+Example:
+
+```
+$ cd some/source/directory/
+$ qt-cmake-create
+$ qt-cmake -S . -B /build/directory
+$ cmake --build /build/directory
+```

cmake/configure-cmake-mapping.md

@@ -17,7 +17,6 @@ The following table describes the mapping of configure options to CMake argument
 | -no-feature-foo                       | -DFEATURE_foo=OFF                                 |                                                                 |
 | -list-features                        |                                                   | At the moment: configure with cmake once,                       |
 |                                       |                                                   | then use ccmake or cmake-gui to inspect the features.           |
-| -list-libraries                       |                                                   |                                                                 |
 | -opensource                           | n/a                                               |                                                                 |
 | -commercial                           | n/a                                               |                                                                 |
 | -confirm-license                      | n/a                                               |                                                                 |
@@ -60,6 +59,7 @@ The following table describes the mapping of configure options to CMake argument
 | -R <string>                           | -DQT_EXTRA_RPATHS=path1;path2                     |                                                                 |
 | -rpath                                | negative CMAKE_SKIP_BUILD_RPATH                   |                                                                 |
 |                                       | negative CMAKE_SKIP_INSTALL_RPATH                 |                                                                 |
+|                                       | negative CMAKE_MACOSX_RPATH                       |                                                                 |
 | -reduce-exports                       | -DFEATURE_reduce_exports=ON                       |                                                                 |
 | -reduce-relocations                   | -DFEATURE_reduce_relocations=ON                   |                                                                 |
 | -plugin-manifests                     |                                                   |                                                                 |
@@ -75,16 +75,9 @@ The following table describes the mapping of configure options to CMake argument
 | -ccache                               | -DQT_USE_CCACHE=ON                                |                                                                 |
 | -unity-build                          | -DQT_UNITY_BUILD=ON                               |                                                                 |
 | -unity-build-batch-size <int>         | -DQT_UNITY_BUILD_BATCH_SIZE=<int>                 |                                                                 |
-| -make-tool <tool>                     | n/a                                               |                                                                 |
-| -mp                                   | n/a                                               |                                                                 |
 | -warnings-are-errors                  | -DWARNINGS_ARE_ERRORS=ON                          |                                                                 |
-| -silent                               | n/a                                               |                                                                 |
-| -sysroot <dir>                        | -DCMAKE_SYSROOT=<dir>                             | Should be provided by a toolchain file that's                   |
-|                                       |                                                   | passed via -DCMAKE_TOOLCHAIN_FILE=<filename>                    |
-| -no-gcc-sysroot                       | n/a                                               | The corresponding CMake variables are CMAKE_SYSROOT_LINK        |
-|                                       |                                                   | and CMAKE_SYSROOT_COMPILE.                                      |
-|                                       |                                                   | They are usually set in a toolchain file.                       |
 | -no-pkg-config                        | -DFEATURE_pkg_config=OFF                          |                                                                 |
+| -no-vcpkg                             | -DQT_USE_VCPKG=OFF                                |                                                                 |
 | -D <string>                           | -DQT_EXTRA_DEFINES=<string1>;<string2>            |                                                                 |
 | -I <string>                           | -DQT_EXTRA_INCLUDEPATHS=<string1>;<string2>       |                                                                 |
 | -L <string>                           | -DQT_EXTRA_LIBDIRS=<string1>;<string2>            |                                                                 |
@@ -110,6 +103,7 @@ The following table describes the mapping of configure options to CMake argument
 |                                       |                                                   | build them separately, after configuration.                     |
 | -nomake <part>                        | -DQT_BUILD_TESTS=OFF                              | A way to turn off tools explicitly is missing.                  |
 |                                       | -DQT_BUILD_EXAMPLES=OFF                           |                                                                 |
+| -install-examples-sources             | -DQT_INSTALL_EXAMPLES_SOURCES=ON                  |                                                                 |
 | -no-gui                               | -DFEATURE_gui=OFF                                 |                                                                 |
 | -no-widgets                           | -DFEATURE_widgets=OFF                             |                                                                 |
 | -no-dbus                              | -DFEATURE_dbus=OFF                                |                                                                 |

cmake/modulecppexports.h.in

@@ -1,11 +1,13 @@
 // Copyright (C) 2022 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
-#include <QtCore/qglobal.h>
-
 #ifndef @header_base_name_upper@_H
 #define @header_base_name_upper@_H
 
+#include <QtCore/qcompilerdetection.h>
+#include <QtCore/qtconfigmacros.h> // Q_@module_define_infix@_EXPORT
+#include <QtCore/qtdeprecationmarkers.h> // QT_IF_DEPRECATED_SINCE
+
 #if defined(QT_SHARED) || !defined(QT_STATIC)
 #  if defined(QT_BUILD_@module_define_infix@_LIB)
 #    define Q_@module_define_infix@_EXPORT Q_DECL_EXPORT
@@ -17,22 +19,22 @@
 #endif
 
 #if !defined(QT_BUILD_@module_define_infix@_LIB) && !defined(QT_STATIC)
-/* outside library → inline decl + defi */
+/* outside library -> inline decl + defi */
 /* static builds treat everything as part of the library, so they never inline */
 #  define QT_@module_define_infix@_INLINE_SINCE(major, minor) inline
 #  define QT_@module_define_infix@_INLINE_IMPL_SINCE(major, minor) 1
 #elif defined(QT_@module_define_infix@_BUILD_REMOVED_API)
 /* inside library, inside removed_api.cpp:
- * keep deprecated API → non-inline decl;
- * remove deprecated API → inline decl;
+ * keep deprecated API -> non-inline decl;
+ * remove deprecated API -> inline decl;
  * definition is always available */
 #  define QT_@module_define_infix@_INLINE_SINCE(major, minor) \
     QT_IF_DEPRECATED_SINCE(major, minor, inline, /* not inline */)
 #  define QT_@module_define_infix@_INLINE_IMPL_SINCE(major, minor) 1
 #else
 /* inside library, outside removed_api.cpp:
- * keep deprecated API → non-inline decl, no defi;
- * remove deprecated API → inline decl, defi */
+ * keep deprecated API -> non-inline decl, no defi;
+ * remove deprecated API -> inline decl, defi */
 #  define QT_@module_define_infix@_INLINE_SINCE(major, minor) \
     QT_IF_DEPRECATED_SINCE(major, minor, inline, /* not inline */)
 #  define QT_@module_define_infix@_INLINE_IMPL_SINCE(major, minor) \

cmake/modulecppexports_p.h.in

@@ -4,6 +4,8 @@
 #ifndef @header_base_name_upper@_P_H
 #define @header_base_name_upper@_P_H
 
+// This file is autogenerated. Changes will be overwritten.
+
 //
 //  W A R N I N G
 //  -------------

coin/axivion/ci_config_linux.json

@@ -0,0 +1,65 @@
+{
+    "Project": {
+        "Git": {
+            "_active": true,
+            "sourceserver_gitdir": "/data/axivion/databases/$(env:TESTED_MODULE_COIN).git"
+        },
+        "BuildSystemIntegration": {
+            "child_order": [
+                "GCCSetup",
+                "CMake",
+                "LinkLibraries"
+            ]
+        },
+        "CMake": {
+            "_active": true,
+            "_copy_from": "CMakeIntegration",
+            "build_environment": {},
+            "build_options": "-j4",
+            "generate_options": "--fresh",
+            "generator": "Ninja"
+        },
+        "GCCSetup": {
+            "_active": true,
+            "_copy_from": "Command",
+            "build_command": "gccsetup --cc gcc --cxx g++ --config ../../../axivion/"
+        },
+        "LinkLibraries": {
+            "_active": true,
+            "_copy_from": "AxivionLinker",
+            "input_files": [
+                "build/lib/lib*.so*.ir"
+            ],
+            "ir": "build/$(env:TESTED_MODULE_COIN).ir",
+            "plugin_files": [
+                "build/plugins/*/lib*.so*.ir"
+            ]
+        },
+        "Project-GlobalOptions": {
+            "ci_mode": {
+                "clean_before": false
+            },
+            "directory": "../work/qt/$(env:TESTED_MODULE_COIN)",
+            "ir": "build/$(env:TESTED_MODULE_COIN).ir",
+            "name": "qt_$(env:TESTED_MODULE_COIN)_dev_$(env:TARGET_OS_COIN)"
+        }
+    },
+    "Results": {
+        "Dashboard": {
+            "dashboard_url": "https://axivion-srv.ci.qt.io/axivion/"
+        },
+        "Database": {
+            "ci_mode": {
+                "directory": "/data/axivion/databases"
+            }
+        }
+    },
+    "_Format": "1.0",
+    "_Version": "trunk-9e0ef9c5818",
+    "_VersionNum": [
+        7,
+        6,
+        9999,
+        11489
+    ]
+}

coin/instructions/cmake_build_and_upload_test_artifacts_host.yaml

@@ -13,6 +13,11 @@ instructions:
         variableValue: "{{.Env.COMMON_TEST_CMAKE_ARGS}}"
       - !include "{{qt/qtbase}}/cmake_build_and_upload_test_artifacts.yaml"
     disable_if:
-      condition: property
+      condition: or
+      conditions:
+        - condition: property
           property: features
           contains_value: DisableTests
+        - condition: property
+          property: features
+          contains_value: DoNotBuildTests

coin/instructions/cmake_build_and_upload_test_artifacts_target.yaml

@@ -34,6 +34,11 @@ instructions:
         variableValue: "{{.Env.COMMON_TARGET_TEST_CMAKE_ARGS}}"
       - !include "{{qt/qtbase}}/cmake_build_and_upload_test_artifacts.yaml"
     disable_if:
-      condition: property
+      condition: or
+      conditions:
+        - condition: property
           property: features
           contains_value: DisableTests
+        - condition: property
+          property: features
+          contains_value: DoNotBuildTests

coin/instructions/cmake_cross_compilation_module_build_instructions.yaml

@@ -61,6 +61,11 @@ instructions:
             - condition: property
               property: host.os
               equals_value: Windows
+            - condition: and
+              conditions:
+                - condition: property
+                  property: target.os
+                  not_equals_value: QNX
                 - condition: property
                   property: target.osVersion
                   not_in_values: [WebAssembly, Android_ANY]
@@ -73,6 +78,11 @@ instructions:
             - condition: property
               property: host.os
               equals_value: Windows
+            - condition: and
+              conditions:
+                - condition: property
+                  property: target.os
+                  not_equals_value: QNX
                 - condition: property
                   property: target.osVersion
                   not_in_values: [WebAssembly, Android_ANY]
@@ -123,6 +133,11 @@ instructions:
         - condition: property
           property: host.os
           equals_value: Windows
+        - condition: and
+          conditions:
+            - condition: property
+              property: target.os
+              not_equals_value: QNX
             - condition: property
               property: target.osVersion
               not_in_values: [WebAssembly, Android_ANY]
@@ -135,6 +150,11 @@ instructions:
         - condition: property
           property: host.os
           equals_value: Windows
+        - condition: and
+          conditions:
+            - condition: property
+              property: target.os
+              not_equals_value: QNX
             - condition: property
               property: target.osVersion
               not_in_values: [WebAssembly, Android_ANY]

coin/instructions/cmake_cross_compilation_qtbase_build_instructions.yaml

@@ -47,6 +47,11 @@ instructions:
             - condition: property
               property: host.os
               equals_value: Windows
+            - condition: and
+              conditions:
+                - condition: property
+                  property: target.os
+                  not_equals_value: QNX
                 - condition: property
                   property: target.osVersion
                   not_in_values: [WebAssembly, Android_ANY]
@@ -59,6 +64,11 @@ instructions:
             - condition: property
               property: host.os
               equals_value: Windows
+            - condition: and
+              conditions:
+                - condition: property
+                  property: target.os
+                  not_equals_value: QNX
                 - condition: property
                   property: target.osVersion
                   not_in_values: [WebAssembly, Android_ANY]
@@ -124,6 +134,11 @@ instructions:
         - condition: property
           property: host.os
           equals_value: Windows
+        - condition: and
+          conditions:
+            - condition: property
+              property: target.os
+              not_equals_value: QNX
             - condition: property
               property: target.osVersion
               not_in_values: [WebAssembly, Android_ANY]
@@ -136,6 +151,11 @@ instructions:
         - condition: property
           property: host.os
           equals_value: Windows
+        - condition: and
+          conditions:
+            - condition: property
+              property: target.os
+              not_equals_value: QNX
             - condition: property
               property: target.osVersion
               not_in_values: [WebAssembly, Android_ANY]

coin/instructions/cmake_module_build_instructions.yaml

@@ -76,9 +76,14 @@ instructions:
   - !include "{{qt/qtbase}}/call_host_install.yaml"
   - type: SignPackage
     enable_if:
-      condition: property
+      condition: and
+      conditions:
+        - condition: property
           property: host.os
           equals_value: Windows
+        - condition: property
+          property: features
+          contains_value: Packaging
     directory: "{{.InstallRoot}}/{{.AgentWorkingDir}}"
     maxTimeInSeconds: 1200
     maxTimeBetweenOutput: 1200

coin/instructions/cmake_qtbase_build_instructions.yaml

@@ -41,6 +41,11 @@ instructions:
         - condition: property
           property: host.os
           equals_value: Windows
+        - condition: and
+          conditions:
+            - condition: property
+              property: target.os
+              not_equals_value: QNX
             - condition: property
               property: target.osVersion
               not_in_values: [WebAssembly, Android_ANY]
@@ -53,6 +58,11 @@ instructions:
         - condition: property
           property: host.os
           equals_value: Windows
+        - condition: and
+          conditions:
+            - condition: property
+              property: target.os
+              not_equals_value: QNX
             - condition: property
               property: target.osVersion
               not_in_values: [WebAssembly, Android_ANY]
@@ -63,9 +73,14 @@ instructions:
   - !include "{{qt/qtbase}}/call_host_install.yaml"
   - type: SignPackage
     enable_if:
-      condition: property
+      condition: and
+      conditions:
+        - condition: property
           property: host.os
           equals_value: Windows
+        - condition: property
+          property: features
+          contains_value: Packaging
     directory: "{{.InstallRoot}}/{{.AgentWorkingDir}}"
     maxTimeInSeconds: 1200
     maxTimeBetweenOutput: 1200

coin/instructions/coin_module_axivion_template_v2.yaml

@@ -0,0 +1,98 @@
+analysis_instructions_axivion: &analysis_instructions_axivion
+  type: Group
+  instructions:
+    - type: Group
+      instructions:
+      - type: EnvironmentVariable
+        variableName: AXIVION_CHAINLOAD_TOOLCHAIN_FILE
+        variableValue: "{{.AgentWorkingDir}}/install/lib/cmake/Qt6/qt.toolchain.cmake"
+      - type: EnvironmentVariable
+        variableName: CMAKE_PREFIX_PATH
+        variableValue: "{{.AgentWorkingDir}}/install/lib/cmake"
+        enable_if:
+          condition: runtime
+          env_var: TESTED_MODULE_COIN
+          not_equals_value: "qtbase"
+    - type: Group
+      instructions:
+      - type: Rename
+        sourcePath: "{{.SourceDir}}/coin/axivion/ci_config_{{.Env.TARGET_OS_COIN}}.json"
+        targetPath: "{{.Env.HOME}}/axivion/ci_config.json"
+        userMessageOnFailure: "Moving ci_config.json failed. Make sure you have included the file in coin/axivion/ -folder"
+      - type: SetBuildDirectory
+        directory: "{{.SourceDir}}"
+      - type: ChangeDirectory
+        directory: "{{.BuildDir}}"
+      - type: ExecuteCommand
+        command: ["../../../axivion/start_analysis.sh"]
+        maxTimeInSeconds: 28800
+        maxTimeBetweenOutput: 28800
+        userMessageOnFailure: "Failed to run analysis"
+
+build_environment_axivion: &build_environment_axivion
+  type: Group
+  instructions:
+    - type: ExecuteCommand
+      command: ["sudo", "mkdir", "-p","/data/axivion"]
+      maxTimeInSeconds: 100
+      maxTimeBetweenOutput: 100
+      userMessageOnFailure: "Create mount point for results failed"
+    - type: ExecuteCommand
+      command: ["sudo", "mount", "-o", "rw", "10.212.0.93:/data/axivion", "/data/axivion"]
+      maxTimeInSeconds: 100
+      maxTimeBetweenOutput: 100
+      userMessageOnFailure: "Mount failed"
+    - type: ExecuteCommand
+      command: ["rm","-rf","{{.SourceDir}}"]
+      maxTimeInSeconds: 100
+      maxTimeBetweenOutput: 100
+      userMessageOnFailure: "Failed to remove source directory"
+    - type: MakeDirectory
+      directory: "{{.SourceDir}}"
+    - type: ChangeDirectory
+      directory: "{{.SourceDir}}"
+    - type: ExecuteCommand
+      command: ["git", "clone", "--jobs={{.NumCPU}}", "-n","--depth=50", "git://{{.Env.QT_COIN_GIT_DAEMON}}/qt-project/qt/{{.Env.TESTED_MODULE_COIN}}","."]
+      maxTimeInSeconds: 900
+      maxTimeBetweenOutput: 900
+      userMessageOnFailure: "Failed to clone repository"
+    - type: ExecuteCommand
+      command: ["git", "fetch", "--recurse-submodules", "origin", "{{.Env.TESTED_MODULE_REVISION_COIN}}"]
+      maxTimeInSeconds: 900
+      maxTimeBetweenOutput: 900
+      userMessageOnFailure: "Failed to fetch sources"
+    - type: ExecuteCommand
+      command: ["git", "checkout", "--force", "{{.Env.TESTED_MODULE_REVISION_COIN}}"]
+      maxTimeInSeconds: 900
+      maxTimeBetweenOutput: 900
+      userMessageOnFailure: "Failed to checkout sources"
+    - type: ExecuteCommand
+      command: ["git", "submodule", "update", "--init", "--recursive"]
+      maxTimeInSeconds: 1800
+      maxTimeBetweenOutput: 900
+      userMessageOnFailure: "Failed to initialize git submodules"
+    - type: Group
+      instructions:
+      - !include "{{qt/qtbase}}/cmake_module_build_instructions.yaml"
+      enable_if:
+        condition: runtime
+        env_var: TESTED_MODULE_COIN
+        not_equals_value: "qtbase"
+    - type: Group
+      instructions:
+      - !include "{{qt/qtbase}}/cmake_qtbase_build_instructions.yaml"
+      enable_if:
+        condition: runtime
+        env_var: TESTED_MODULE_COIN
+        equals_value: "qtbase"
+
+type: Group
+instructions:
+  - !include "{{qt/qtbase}}/prepare_building_env.yaml"
+  - *build_environment_axivion
+  - *analysis_instructions_axivion
+enable_if:
+  condition: property
+  property: features
+  contains_value: Axivion
+

coin/instructions/coin_module_build_template_v2.yaml

@@ -24,6 +24,33 @@ instructions:
         - condition: property
           property: features
           not_contains_value: "TargetBuildOnly"
+        - condition: property
+          property: features
+          not_contains_value: "DebianPackaging"
+        - condition: property
+          property: features
+          not_contains_value: Axivion
+  - type: Group
+    instructions:
+       - !include "{{qt/qtbase}}/coin_module_axivion_template_v2.yaml"
+    enable_if:
+      condition: and
+      conditions:
+        - condition: property
+          property: features
+          contains_value: Axivion
+        - condition: runtime
+          env_var: TESTED_MODULE_COIN
+          not_equals_value: "qtdoc"
+        - condition: runtime
+          env_var: TESTED_MODULE_COIN
+          not_equals_value: "qtquickeffectmaker"
+        - condition: runtime
+          env_var: TESTED_MODULE_COIN
+          not_equals_value: "qttranslations"
+        - condition: runtime
+          env_var: TESTED_MODULE_COIN
+          not_equals_value: "qtwebengine"
   - type: Group
     instructions:
       - !include "{{qt/qtbase}}/cmake_cross_compilation_module_build_instructions.yaml"
@@ -48,3 +75,15 @@ instructions:
             - condition: property
               property: target.arch
               equals_value: ARM64
+            - condition: property
+              property: features
+              not_contains_value: "DebianPackaging"
+  - type: Group
+    instructions:
+      - type: Group
+        instructions:
+          - !include "{{qt/qtbase}}/debian/debian_build_module.yaml"
+        enable_if:
+          condition: property
+          property: features
+          contains_value: "DebianPackaging"

coin/instructions/coin_qtbase_build_template_v2.yaml

@@ -17,6 +17,19 @@ instructions:
         - condition: property
           property: features
           not_contains_value: "TargetBuildOnly"
+        - condition: property
+          property: features
+          not_contains_value: "DebianPackaging"
+        - condition: property
+          property: features
+          not_contains_value: Axivion
+  - type: Group
+    instructions:
+       - !include "{{qt/qtbase}}/coin_module_axivion_template_v2.yaml"
+    enable_if:
+      condition: property
+      property: features
+      contains_value: Axivion
   - type: Group
     instructions:
       - type: Group
@@ -53,3 +66,15 @@ instructions:
             - condition: property
               property: target.arch
               equals_value: ARM64
+            - condition: property
+              property: features
+              not_contains_value: "DebianPackaging"
+  - type: Group
+    instructions:
+      - type: Group
+        instructions:
+          - !include "{{qt/qtbase}}/debian/debian_build_module.yaml"
+        enable_if:
+          condition: property
+          property: features
+          contains_value: "DebianPackaging"

coin/instructions/debian/debian_build_module.yaml

@@ -0,0 +1,125 @@
+type: Group
+enable_if:
+  condition: property
+  property: features
+  contains_value: DebianPackaging
+instructions:
+  - !include "{{qt/qtbase}}/debian/prepare_debian_env.yaml"
+  - type: EnvironmentVariable
+    variableName: GIT_SSH_COMMAND
+    variableValue: "ssh -o StrictHostKeyChecking=no"
+  - type: ChangeDirectory
+    directory: "{{.AgentWorkingDir}}"
+  - type: MakeDirectory
+    directory: output/debian_packages
+  - type: MakeDirectory
+    directory: debian_packages
+  - type: ExecuteCommand
+    command: "git clone git@git.qt.io:tqtc-debian/package_generator.git"
+    maxTimeInSeconds: 900
+    maxTimeBetweenOutput: 900
+    userMessageOnFailure: "Failed to clone package generator repo"
+    disable_if:
+      condition: runtime
+      env_var:  COIN_SKIP_DEBIAN
+      contains_value: "MISSING_DEBIAN_INST"
+  - type: ExecuteCommand
+    command: "git clone -b 6.6 git@git.qt.io:tqtc-debian/qt6-{{.Env.TESTED_MODULE_PLAIN_COIN}}.git"
+    maxTimeInSeconds: 900
+    maxTimeBetweenOutput: 900
+    userMessageOnFailure: "Failed to clone debian packaging repo"
+    disable_if:
+      condition: runtime
+      env_var:  COIN_SKIP_DEBIAN
+      contains_value: "MISSING_DEBIAN_INST"
+  - type: ChangeDirectory
+    directory: "qt6-{{.Env.TESTED_MODULE_PLAIN_COIN}}"
+    disable_if:
+      condition: runtime
+      env_var:  COIN_SKIP_DEBIAN
+      contains_value: "MISSING_DEBIAN_INST"
+  - type: ExecuteCommand
+    command: "git checkout {{.Env.DEBIAN_RULES_REF}}"
+    maxTimeInSeconds: 900
+    maxTimeBetweenOutput: 900
+    userMessageOnFailure: "Failed to checkout debian rules branch"
+    disable_if:
+      condition: or
+      conditions:
+      - condition: runtime
+        env_var:  DEBIAN_RULES_REF
+        equals_value: null
+      - condition: runtime
+        env_var:  COIN_SKIP_DEBIAN
+        contains_value: "MISSING_DEBIAN_INST"
+  - type: ChangeDirectory
+    directory: "{{.AgentWorkingDir}}"
+  - type: ExecuteCommand
+    command: "wget -q {{.CoinDownloadURL}}/{{.Env.MODULE_SOURCES_RELATIVE_STORAGE_PATH}}"
+    maxTimeInSeconds: 900
+    maxTimeBetweenOutput: 900
+    userMessageOnFailure: "Failed get sources"
+    disable_if:
+      condition: runtime
+      env_var:  COIN_SKIP_DEBIAN
+      contains_value: "MISSING_DEBIAN_INST"
+  - type: ExecuteCommand
+    command: "mv sources_unix.tar.gz qt-{{.Env.QT_REPO_MODULE_VERSION}}-{{.Env.TESTED_MODULE_PLAIN_COIN}}-src_{{.Env.QT_REPO_MODULE_VERSION}}.orig.tar.gz"
+    maxTimeInSeconds: 900
+    maxTimeBetweenOutput: 900
+    userMessageOnFailure: "Failed rename src pkg"
+    disable_if:
+      condition: runtime
+      env_var:  COIN_SKIP_DEBIAN
+      contains_value: "MISSING_DEBIAN_INST"
+  - type: ChangeDirectory
+    directory: "{{.AgentWorkingDir}}/qt6-{{.Env.TESTED_MODULE_PLAIN_COIN}}"
+    disable_if:
+      condition: runtime
+      env_var:  COIN_SKIP_DEBIAN
+      contains_value: "MISSING_DEBIAN_INST"
+
+
+  # rc is required currently by the script
+  - type: ExecuteCommand
+    command: "../package_generator/generate_packaging.sh --qt-version {{.Env.QT_REPO_MODULE_VERSION}} --deb-rev 1 --release tqtc-focal"
+    maxTimeInSeconds: 900
+    maxTimeBetweenOutput: 900
+    userMessageOnFailure: "Failed to generate pkg"
+    disable_if:
+      condition: runtime
+      env_var:  COIN_SKIP_DEBIAN
+      contains_value: "MISSING_DEBIAN_INST"
+  - type: ChangeDirectory
+    directory: "{{.AgentWorkingDir}}"
+  - type: ExecuteCommand
+    command: "dpkg-source -b qt6-{{.Env.TESTED_MODULE_PLAIN_COIN}}"
+    maxTimeInSeconds: 900
+    maxTimeBetweenOutput: 900
+    userMessageOnFailure: "Failed dpkg-source"
+    disable_if:
+      condition: runtime
+      env_var:  COIN_SKIP_DEBIAN
+      contains_value: "MISSING_DEBIAN_INST"
+  - type: ExecuteCommand
+    command: ["sbuild",
+      "--build-dep-resolver=apt",
+      "-sAd", "tqtc-focal",
+      "-c", "{{.Env.COIN_SBUILD_CHROOT}}",
+      "--build-dir", "output/debian_packages",
+      "--extra-repository={{.Env.COIN_EXTRA_DEBIAN_REPO}}",
+      "--extra-package={{.Env.COIN_EXTRA_DEBIAN_PACKAGES}}",
+      "--extra-package={{.AgentWorkingDir}}/debian_packages/",
+      "qt-{{.Env.QT_REPO_MODULE_VERSION}}-{{.Env.TESTED_MODULE_PLAIN_COIN}}-src_{{.Env.QT_REPO_MODULE_VERSION}}-1.dsc"]
+    maxTimeInSeconds: 18000
+    maxTimeBetweenOutput: 18000
+    userMessageOnFailure: "Failed build debian packages"
+    disable_if:
+      condition: runtime
+      env_var:  COIN_SKIP_DEBIAN
+      contains_value: "MISSING_DEBIAN_INST"
+  - type: UploadArtifact
+    archiveDirectory: "{{.AgentWorkingDir}}/output"
+    transferType: UploadModuleBuildArtifact
+    maxTimeInSeconds: 1200
+    maxTimeBetweenOutput: 1200

coin/instructions/debian/prepare_debian_env.yaml

@@ -0,0 +1,85 @@
+type: Group
+enable_if:
+  condition: property
+  property: features
+  contains_value: DebianPackaging
+instructions:
+  - type: EnvironmentVariable
+    variableName: COIN_SBUILD_CHROOT
+    variableValue: "stable-arm64-sbuild"
+    enable_if:
+      condition: and
+      conditions:
+        - condition: runtime
+          env_var:  COIN_SBUILD_CHROOT
+          equals_value: null
+        - condition: property
+          property: target.arch
+          equals_value: AARCH64
+  - type: EnvironmentVariable
+    variableName: COIN_SBUILD_CHROOT
+    variableValue: "stable-amd64-sbuild"
+    enable_if:
+      condition: and
+      conditions:
+        - condition: runtime
+          env_var:  COIN_SBUILD_CHROOT
+          equals_value: null
+        - condition: property
+          property: target.arch
+          equals_value: X86_64
+  - type: EnvironmentVariable
+    variableName: COIN_SBUILD_DISTRO
+    variableValue: "arm64-focal"
+    enable_if:
+      condition: property
+      property: target.arch
+      equals_value: AARCH64
+  - type: EnvironmentVariable
+    variableName: COIN_SBUILD_DISTRO
+    variableValue: "amd64-focal"
+    disable_if:
+      condition: property
+      property: target.arch
+      equals_value: AARCH64
+
+  - type: EnvironmentVariable
+    variableName: COIN_SKIP_DEBIAN
+    variableValue: "MISSING_DEBIAN_INST"
+    enable_if:
+      condition: or
+      conditions:
+        - condition: runtime
+          env_var: TESTED_MODULE_COIN
+          equals_value: "qtactiveqt"
+        - condition: runtime
+          env_var: TESTED_MODULE_COIN
+          equals_value: "qtqa"
+        - condition: runtime
+          env_var: TESTED_MODULE_COIN
+          equals_value: "qtdoc"
+        - condition: runtime
+          env_var: TESTED_MODULE_COIN
+          equals_value: "qt5"
+  # Set version info to environment
+  - type: ParseEnvironmentVariableFromFile
+    regex: "QT_REPO_MODULE_VERSION \"(?P<QT_REPO_MODULE_VERSION>.*)\""
+    filename: "{{.SourceDir}}/.cmake.conf"
+    maxTimeInSeconds: 300
+    maxTimeBetweenOutput: 300
+    userMessageOnFailure: "Failed to parse version information from .cmake.conf"
+    disable_if:
+      condition: runtime
+      env_var: TESTED_MODULE_COIN
+      equals_value: "qt5"
+  - type: ParseEnvironmentVariableFromFile
+    regex: "QT_REPO_MODULE_PRERELEASE_VERSION_SEGMENT \"(?P<QT_REPO_MODULE_PRERELEASE_VERSION_SEGMENT>.*)\""
+    filename: "{{.SourceDir}}/.cmake.conf"
+    maxTimeInSeconds: 300
+    maxTimeBetweenOutput: 300
+    userMessageOnFailure: "Failed to parse status information from .cmake.conf"
+    disable_if:
+      condition: runtime
+      env_var: TESTED_MODULE_COIN
+      equals_value: "qt5"
+

coin/instructions/prepare_building_env.yaml

@@ -305,6 +305,14 @@ instructions:
         condition: property
         property: target.osVersion
         in_values: [QEMU]
+    # This fixes an issue where binfmts is sometimes disabled on the test VMs
+    - type: ExecuteCommand
+      command: sudo update-binfmts --enable
+      userMessageOnFailure: "Failed to enable binfmts"
+      enable_if:
+        condition: property
+        property: target.osVersion
+        equals_value: QEMU
 
   # Windows on Arm, cross-compilation with MSVC
   - type: Group

coin/module_config.yaml

@@ -4,9 +4,17 @@ accept_configuration:
   property: features
   not_contains_value: Disable
 
+downstream_check:
+  mode: build
+  modules:
+    ../qtdeclarative:
+      ref: dev
+  configurations:
+    - rhel-8.4
+
 machine_type:
   Build:
-    cores: 4
+    cores: 8
   Test:
     cores: 4
 

conanfile.py

@@ -1,300 +0,0 @@
-# Copyright (C) 2021 The Qt Company Ltd.
-# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
-
-from conans import ConanFile, tools
-from conans.errors import ConanInvalidConfiguration
-import os
-import re
-import shutil
-from functools import lru_cache
-from pathlib import Path
-from typing import Dict, Union
-
-
-class QtConanError(Exception):
-    pass
-
-
-def add_cmake_prefix_path(conan_file: ConanFile, dep: str) -> None:
-    if dep not in conan_file.deps_cpp_info.deps:
-        raise QtConanError("Unable to find dependency: {0}".format(dep))
-    dep_cpp_info = conan_file.deps_cpp_info[dep]
-    cmake_args_str = str(conan_file.options.get_safe("cmake_args_qtbase", default=""))
-    formatted_cmake_args_str = conan_file._shared.append_cmake_arg(
-        cmake_args_str, "CMAKE_PREFIX_PATH", dep_cpp_info.rootpath
-    )
-    print("Adjusted cmake args for qtbase build: {0}".format(formatted_cmake_args_str))
-    setattr(conan_file.options, "cmake_args_qtbase", formatted_cmake_args_str)
-
-
-def _build_qtbase(conan_file: ConanFile):
-    # we call the Qt's configure(.bat) directly
-    script = Path("configure.bat") if tools.os_info.is_windows else Path("configure")
-    configure = Path(conan_file.build_folder).joinpath(script).resolve(strict=True)
-
-    if conan_file.options.get_safe("icu", default=False):
-        # we need to tell Qt build system where to find the ICU
-        add_cmake_prefix_path(conan_file, dep="icu")
-
-    # convert the Conan options to Qt configure(.bat) arguments
-    parser = conan_file._qt_option_parser
-    qt_configure_options = parser.convert_conan_options_to_qt_options(conan_file.options)
-    cmd = " ".join(
-        [str(configure), " ".join(qt_configure_options), "-prefix", conan_file.package_folder]
-    )
-    cmake_args = parser.get_cmake_args_for_configure(conan_file.options)
-    if cmake_args:
-        cmd += " -- {0}".format(" ".join(cmake_args))
-    conan_file.output.info("Calling: {0}".format(cmd))
-    conan_file.run(cmd)
-
-    cmd = " ".join(["cmake", "--build", ".", "--parallel"])
-    conan_file.output.info("Calling: {0}".format(cmd))
-    conan_file.run(cmd)
-
-
-@lru_cache(maxsize=8)
-def _parse_qt_version_by_key(key: str) -> str:
-    with open(Path(__file__).parent.resolve() / ".cmake.conf") as f:
-        m = re.search(fr'{key} .*"(.*)"', f.read())
-    return m.group(1) if m else ""
-
-
-def _get_qt_minor_version() -> str:
-    return ".".join(_parse_qt_version_by_key("QT_REPO_MODULE_VERSION").split(".")[:2])
-
-
-class QtBase(ConanFile):
-    name = "qtbase"
-    license = "LGPL-3.0, GPL-2.0+, Commercial Qt License Agreement"
-    author = "The Qt Company <https://www.qt.io/contact-us>"
-    url = "https://code.qt.io/cgit/qt/qtbase.git"
-    description = "Qt6 core framework libraries and tools."
-    topics = ("qt", "qt6")
-    settings = "os", "compiler", "arch", "build_type"
-    _qt_option_parser = None
-    options = None
-    default_options = None
-    exports_sources = "*", "!conan*.*"
-    # use commit ID as the RREV (recipe revision)
-    revision_mode = "scm"
-    python_requires = "qt-conan-common/{0}@qt/everywhere".format(_get_qt_minor_version())
-    short_paths = True
-    _shared = None
-
-    def init(self):
-        self._shared = self.python_requires["qt-conan-common"].module
-        self._qt_option_parser = self._shared.QtOptionParser(Path(__file__).parent.resolve())
-        self.options = self._qt_option_parser.get_qt_conan_options()
-        self.default_options = self._qt_option_parser.get_default_qt_conan_options()
-
-    def set_version(self):
-        # Executed during "conan export" i.e. in source tree
-        _ver = _parse_qt_version_by_key("QT_REPO_MODULE_VERSION")
-        _prerelease = _parse_qt_version_by_key("QT_REPO_MODULE_PRERELEASE_VERSION_SEGMENT")
-        self.version = _ver + "-" + _prerelease if _prerelease else _ver
-
-    def export(self):
-        self.copy("configure_options.json")
-        self.copy("configure_features.txt")
-        self.copy(".cmake.conf")
-        conf = self._shared.qt_sw_versions_config_folder() / self._shared.qt_sw_versions_config_name()
-        if not conf.exists():
-            # If using "conan export" outside Qt CI provisioned machines
-            print("Warning: Couldn't find '{0}'. 3rd party dependencies skipped.".format(conf))
-        else:
-            shutil.copy2(conf, self.export_folder)
-
-    def requirements(self):
-        # list of tuples, (package_name, fallback version)
-        optional_requirements = [("icu", "56.1")]
-        for req_name, req_ver_fallback in optional_requirements:
-            if self.options.get_safe(req_name, default=False) == True:
-                # Note! If this conan package is being "conan export"ed outside Qt CI and the
-                # sw versions .ini file is not present then it will fall-back to default version
-                ver = self._shared.parse_qt_sw_pkg_dependency(
-                    config_folder=Path(self.recipe_folder),
-                    package_name=req_name,
-                    target_os=str(self.settings.os),
-                )
-                if not ver:
-                    print(
-                        "Warning: Using fallback version '{0}' for: {1}".format(
-                            req_name, req_ver_fallback
-                        )
-                    )
-                    ver = req_ver_fallback
-                requirement = "{0}/{1}@qt/everywhere".format(req_name, ver)
-                print("Setting 3rd party package requirement: {0}".format(requirement))
-                self.requires(requirement)
-
-    def _resolve_qt_host_path(self) -> Union[str, None]:
-        """
-        Attempt to resolve QT_HOST_PATH.
-
-        When cross-building the user needs to pass 'qt_host_path' which is transformed to
-        QT_HOST_PATH later on. Resolve the exact path if possible.
-
-        Returns:
-            string: The resolved QT_HOST_PATH or None if unable to determine it.
-        """
-        _host_p = self.options.get_safe("qt_host_path")
-        if _host_p:
-            return str(Path(os.path.expandvars(str(_host_p))).expanduser().resolve(strict=True))
-        else:
-            print("Warning: 'qt_host_path' option was not given in cross-build context")
-            return None
-
-    def configure(self):
-        if self.settings.compiler == "gcc" and tools.Version(self.settings.compiler.version) < "8":
-            raise ConanInvalidConfiguration("Qt6 does not support GCC before 8")
-
-        def _set_default_if_not_set(option_name: str, option_value: bool) -> None:
-            # let it fail if option name does not exist, it means the recipe is not up to date
-            if self.options.get_safe(option_name) in [None, "None"]:
-                setattr(self.options, option_name, option_value)
-
-        def _set_build_type(build_type: str) -> None:
-            if self.settings.build_type != build_type:
-                msg = (
-                    "The build_type '{0}' changed to '{1}'. Please check your Settings and "
-                    "Options. The used Qt options enforce '{2}' as a build_type. ".format(
-                        self.settings.build_type, build_type, build_type
-                    )
-                )
-                raise QtConanError(msg)
-            self.settings.build_type = build_type
-
-        def _check_mutually_exclusive_options(options: Dict[str, bool]) -> None:
-            if list(options.values()).count(True) > 1:
-                raise QtConanError(
-                    "These Qt options are mutually exclusive: {0}"
-                    ". Choose only one of them and try again.".format(list(options.keys()))
-                )
-
-        default_options = ["shared", "gui", "widgets", "accessibility", "system_proxies", "ico"]
-
-        if self.settings.os == "Macos":
-            default_options.append("framework")
-
-        for item in default_options:
-            _set_default_if_not_set(item, True)
-
-        release = self.options.get_safe("release", default=False)
-        debug = self.options.get_safe("debug", default=False)
-        debug_and_release = self.options.get_safe("debug_and_release", default=False)
-        force_debug_info = self.options.get_safe("force_debug_info", default=False)
-        optimize_size = self.options.get_safe("optimize_size", default=False)
-
-        # these options are mutually exclusive options so do a sanity check
-        _check_mutually_exclusive_options(
-            {"release": release, "debug": debug, "debug_and_release": debug_and_release}
-        )
-
-        # Prioritize Qt's configure options over Settings.build_type
-        if debug_and_release == True:
-            # Qt build system will build both debug and release binaries
-            if force_debug_info == True:
-                _set_build_type("RelWithDebInfo")
-            else:
-                _set_build_type("Release")
-        elif release == True:
-            _check_mutually_exclusive_options(
-                {"force_debug_info": force_debug_info, "optimize_size": optimize_size}
-            )
-            if force_debug_info == True:
-                _set_build_type("RelWithDebInfo")
-            elif optimize_size == True:
-                _set_build_type("MinSizeRel")
-            else:
-                _set_build_type("Release")
-        elif debug == True:
-            _set_build_type("Debug")
-        else:
-            # As a fallback set the build type for Qt configure based on the 'build_type'
-            # defined in the conan build settings
-            build_type = self.settings.get_safe("build_type")
-            if build_type in [None, "None"]:
-                # set default that mirror the configure(.bat) default values
-                self.options.release = True
-                self.settings.build_type = "Release"
-            elif build_type == "Release":
-                self.options.release = True
-            elif build_type == "Debug":
-                self.options.debug = True
-            elif build_type == "RelWithDebInfo":
-                self.options.release = True
-                self.options.force_debug_info = True
-            elif build_type == "MinSizeRel":
-                self.options.release = True
-                self.options.optimize_size = True
-            else:
-                raise QtConanError("Unknown build_type: {0}".format(self.settings.build_type))
-
-        if self.settings.os == "Android":
-            if self.options.get_safe("android_sdk_version") == None:
-                cmake_args_qtbase = str(self.options.get_safe("cmake_args_qtbase"))
-                sdk_ver = self._shared.parse_android_sdk_version(cmake_args_qtbase)
-                if sdk_ver:
-                    print("'android_sdk_version' not given. Deduced version: {0}".format(sdk_ver))
-                    self.options.android_sdk_version = sdk_ver
-                else:
-                    # TODO, for now we have no clean means to query the Android SDK version from
-                    # Qt build system so we just exclude the "android_sdk" from the package_id.
-                    print("Can't deduce 'android_sdk_version'. Excluding it from 'package_id'")
-                    delattr(self.info.options, "android_sdk_version")
-            if self.options.get_safe("android_ndk_version") == None:
-                ndk_ver = str(self.options.get_safe("android_ndk"))
-                ndk_ver = self._shared.parse_android_ndk_version(Path(ndk_ver, strict=True))
-                print("'android_ndk_version' not given. Deduced version: {0}".format(ndk_ver))
-                self.options.android_ndk_version = ndk_ver
-
-    def build(self):
-        self._shared.build_env_wrap(self, _build_qtbase)
-
-    def package(self):
-        self._shared.call_install(self)
-
-    def package_info(self):
-        self._shared.package_info(self)
-        if tools.cross_building(conanfile=self):
-            qt_host_path = self._resolve_qt_host_path()
-            if qt_host_path:
-                self.env_info.QT_HOST_PATH.append(qt_host_path)
-
-    def package_id(self):
-        # https://docs.conan.io/en/latest/creating_packages/define_abi_compatibility.html
-
-        # The package_revision_mode() is too strict for Qt CI. This mode includes artifacts
-        # checksum in package_id which is problematic in Qt CI re-runs (re-run flaky
-        # build) which contain different build timestamps (cmake) which end up in library
-        # files -> different package_id.
-        self.info.requires.recipe_revision_mode()
-
-        # Enable 'qt-conan-common' updates on client side with $conan install .. --update
-        self.info.python_requires.recipe_revision_mode()
-
-        # Remove those configure(.bat) options which should not affect package_id.
-        # These point to local file system paths and in order to re-use pre-built
-        # binaries (by Qt CI) by others these should not affect the 'package_id'
-        # as those probably differ on each machine
-        rm_list = [
-            "sdk",
-            "qpa",
-            "translationsdir",
-            "headersclean",
-            "qt_host_path",
-            "android_sdk",
-            "android_ndk",
-        ]
-        for item in rm_list:
-            if item in self.info.options:
-                delattr(self.info.options, item)
-        # filter also those cmake options that should not end up in the package_id
-        if hasattr(self.info.options, "cmake_args_qtbase"):
-            _filter = self._shared.filter_cmake_args_for_package_id
-            self.info.options.cmake_args_qtbase = _filter(self.info.options.cmake_args_qtbase)
-
-    def deploy(self):
-        self.copy("*")  # copy from current package
-        self.copy_deps("*")  # copy from dependencies

config.tests/arch/arch.cpp

@@ -141,7 +141,7 @@ const char msg2[] = "==Qt=magic=Qt== Sub-architecture:"
 // Leading-Zero bit count, Intel Core 4th Generation ("Haswell")
 " lzcnt"
 #endif
-#ifdef __MMX__
+#if defined(__MMX__) && defined(__i386__)
 // Multimedia Extensions, Pentium MMX, AMD K6-2
 " mmx"
 #endif
@@ -198,11 +198,11 @@ const char msg2[] = "==Qt=magic=Qt== Sub-architecture:"
 // Shadow stack, Intel processor TBA
 " shstk"
 #endif
-#if defined(__SSE__) || (defined(_M_IX86_FP) && _M_IX86_FP >= 1) || defined(_M_X64)
+#if (defined(__SSE__) && defined(__i386__)) || (defined(_M_IX86_FP) && _M_IX86_FP >= 1 && defined(_M_IX86))
 // Streaming SIMD Extensions, Intel Pentium III, AMD Athlon
 " sse"
 #endif
-#if defined(__SSE2__) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2) || defined(_M_X64)
+#if (defined(__SSE2__) && defined(__i386__)) || (defined(_M_IX86_FP) && _M_IX86_FP >= 2 && defined(_M_IX86))
 // SSE2, Intel Pentium-M, Intel Pentium 4, AMD Opteron and Athlon 64
 " sse2"
 #endif

config.tests/separate_debug_info/CMakeLists.txt

@@ -1,7 +1,6 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: BSD-3-Clause
 
-# special case skip regeneration
 cmake_minimum_required(VERSION 3.16)
 project(objcopytest LANGUAGES CXX)
 add_executable(objcopytest main.cpp)

config_help.txt

@@ -64,10 +64,13 @@ Build options:
   -cmake-file-api ...... Let CMake store build metadata for loading the build
                          into an IDE. [no; yes if -developer-build]
   -no-guess-compiler ... Do not guess the compiler from the target mkspec.
-  -release ............. Build Qt with debugging turned off [yes]
-  -debug ............... Build Qt with debugging turned on [no]
-  -debug-and-release ... Build two versions of Qt, with and without
-                         debugging turned on [yes] (Apple and Windows only)
+  -release ............. Build Qt with optimizations and without debug
+                         symbols [yes]
+                         Note that -developer-build implies -debug unless
+                         -release is also explicitly specified
+  -debug ............... Build Qt without optimizations and with debug symbols
+                         [no]
+  -debug-and-release ... Build two versions of Qt in one build tree [no]
   -optimize-debug ...... Enable debug-friendly optimizations in debug builds
                          [auto] (Not supported with MSVC or Clang toolchains)
   -optimize-size ....... Optimize release builds for size instead of speed [no]
@@ -80,7 +83,8 @@ Build options:
                          sections. [auto for static builds, otherwise no]
   -force-asserts ....... Enable Q_ASSERT even in release builds [no]
   -developer-build ..... Compile and link Qt for developing Qt itself
-                         (exports for auto-tests, extra checks, etc.) [no]
+                         (exports for auto-tests, extra checks, implies
+                         -no-prefix, etc.) [no]
 
   -shared .............. Build shared Qt libraries [yes] (no for UIKit)
   -static .............. Build static Qt libraries [no] (yes for UIKit)
@@ -157,10 +161,10 @@ Build options:
 
 Build environment:
 
-  -sysroot <dir> ....... Set <dir> as the target sysroot
-
   -pkg-config .......... Use pkg-config [auto] (Unix only)
 
+  -vcpkg ............... Use vcpkg [yes]
+
   -D <string> .......... Pass additional preprocessor define
   -I <string> .......... Pass additional include path
   -L <string> .......... Pass additional library path
@@ -198,6 +202,9 @@ Component selection:
                          [default: libs and examples, also tools if not
                          cross-building, also tests if -developer-build]
   -nomake <part> ....... Exclude <part> from the list of parts to be built.
+  -install-examples-sources Installs examples source code into the Qt prefix
+                         Only possible when -make examples is also passed
+                         [no]
   -gui ................. Build the Qt GUI module and dependencies [yes]
   -widgets ............. Build the Qt Widgets module and dependencies [yes]
   -no-dbus ............. Do not build the Qt D-Bus module
@@ -289,6 +296,6 @@ Gui, printing, widget options:
 Database options:
 
   -sql-<driver> ........ Enable SQL <driver> plugin. Supported drivers:
-                         db2 ibase mysql oci odbc psql sqlite
+                         db2 ibase mysql oci odbc psql sqlite mimer
                          [all auto]
   -sqlite .............. Select used sqlite [system/qt]

configure

@@ -8,14 +8,18 @@
 #-------------------------------------------------------------------------------
 
 # the directory of this script is the "source tree"
-relpath=`dirname $0`
+relpath=`dirname "$0"`
 relpath=`(cd "$relpath"; /bin/pwd)`
 # the current directory is the "build tree" or "object tree"
 outpath=`/bin/pwd`
+outpathPrefix=$outpath
 
 # do this early so we don't store it in config.status
 CFG_TOPLEVEL=
-outpathPrefix=
+
+SAVED_IFS=$IFS
+IFS='
+'
 
 checkTopLevelBuild()
 {
@@ -23,7 +27,7 @@ checkTopLevelBuild()
     if [ x"$1" = x"-top-level" ]; then
         CFG_TOPLEVEL=yes
         relpathMangled=`dirname "$relpath"`
-        outpathPrefix=../
+        outpathPrefix="$outpathPrefix/.."
     else
         if [ -f ../.qmake.super ]; then
             echo >&2 "ERROR: You cannot configure qtbase separately within a top-level build."
@@ -35,41 +39,26 @@ checkTopLevelBuild()
 OPT_CMDLINE=  # expanded version for the script
 determineOptFilePath()
 {
+> "${outpathPrefix}/config.redo.in"
 set -f  # suppress globbing in for loop
-SAVED_IFS=$IFS
-IFS='
-'
 for i in "$@"; do
     if [ x"$i" = x"-top-level" ]; then
         continue
     fi
     case $i in
         -redo|--redo)
-            optfile=${outpathPrefix}config.opt
-            if test -n "$CFG_TOPLEVEL" && ! test -f $optfile; then
-                optfile=config.opt
-            fi
-            if ! test -f $optfile; then
+            optfile=${outpathPrefix}/config.opt
+            if ! test -f "$optfile"; then
                 echo >&2 "No config.opt present - cannot redo configuration."
                 exit 1
             fi
-            for a in `cat $optfile`; do
-                OPT_CMDLINE="$OPT_CMDLINE
-$a"
-            done
             ;;
         *)
-            OPT_CMDLINE="$OPT_CMDLINE
-$i"
+            # If redo-ing, write the rest of parameters into the config.redo.in file
+            echo \"$i\" >> "${outpathPrefix}/config.redo.in"
             ;;
     esac
 done
-set --
-for i in $OPT_CMDLINE; do
-    set -- "$@" "$i"
-done
-set +f
-IFS=$SAVED_IFS
 }
 
 #-------------------------------------------------------------------------------
@@ -88,80 +77,10 @@ while [ "$#" -gt 0 ]; do
     CURRENT_OPT="$1"
     case "$1" in
     #Autoconf style options
-    --enable-*)
-        VAR=`echo $1 | sed 's,^--enable-\(.*\),\1,'`
-        VAL=yes
-        ;;
-    --disable-*)
-        VAR=`echo $1 | sed 's,^--disable-\(.*\),\1,'`
-        VAL=no
-        ;;
-    --*=*)
-        VAR=`echo $1 | sed 's,^--\(.*\)=.*,\1,'`
-        VAL=`echo $1 | sed 's,^--.*=\(.*\),\1,'`
-        ;;
-    --no-*)
-        VAR=`echo $1 | sed 's,^--no-\(.*\),\1,'`
-        VAL=no
-        ;;
     --*)
         VAR=`echo $1 | sed 's,^--\(.*\),\1,'`
         VAL=yes
         ;;
-    #Qt plugin options
-    -no-*-*|-plugin-*-*|-qt-*-*)
-        VAR=`echo $1 | sed 's,^-[^-]*-\(.*\),\1,'`
-        VAL=`echo $1 | sed 's,^-\([^-]*\).*,\1,'`
-        ;;
-    #Qt style no options
-    -no-*)
-        VAR=`echo $1 | sed 's,^-no-\(.*\),\1,'`
-        VAL=no
-        ;;
-    #Qt style options that pass an argument
-    -prefix| \
-    -docdir| \
-    -headerdir| \
-    -plugindir| \
-    -qmldir| \
-    -archdatadir| \
-    -datadir| \
-    -libdir| \
-    -bindir| \
-    -libexecdir| \
-    -translationdir| \
-    -sysconfdir| \
-    -examplesdir| \
-    -testsdir| \
-    -hostdatadir| \
-    -extprefix| \
-    -sysroot| \
-    -make| \
-    -nomake| \
-    -skip| \
-    -platform| \
-    -xplatform| \
-    -device| \
-    -device-option| \
-    -sdk| \
-    -android-sdk| \
-    -android-ndk| \
-    -android-ndk-platform| \
-    -android-arch)
-        VAR=`echo $1 | sed 's,^-\(.*\),\1,'`
-        shift
-        VAL="$1"
-        ;;
-    #Qt style complex options in one command
-    -enable-*|-disable-*)
-        VAR=`echo $1 | sed 's,^-\([^-]*\)-.*,\1,'`
-        VAL=`echo $1 | sed 's,^-[^-]*-\(.*\),\1,'`
-        ;;
-    #Qt Builtin/System style options
-    -no-*|-system-*|-qt-*)
-        VAR=`echo $1 | sed 's,^-[^-]*-\(.*\),\1,'`
-        VAL=`echo $1 | sed 's,^-\([^-]*\)-.*,\1,'`
-        ;;
     #General options, including Qt style yes options
     -*)
         VAR=`echo $1 | sed 's,^-\(.*\),\1,'`
@@ -176,24 +95,16 @@ while [ "$#" -gt 0 ]; do
 
     shift
 
-    UNKNOWN_OPT=no
     case "$VAR" in
     h|help)
         if [ "$VAL" = "yes" ]; then
             OPT_HELP="$VAL"
-        else
-            UNKNOWN_OPT=yes
         fi
         ;;
     *)
         ;;
     esac
-    if [ "$UNKNOWN_OPT" = "yes" ]; then
-        echo "${CURRENT_OPT}: invalid command-line switch"
-        ERROR=yes
-    fi
 done
-[ "x$ERROR" = "xyes" ] && exit 1
 }
 
 #-------------------------------------------------------------------------------
@@ -222,18 +133,27 @@ parseCommandline "$@"
 handleHelp
 determineOptFilePath "$@"
 
+optfilepath=${outpathPrefix}/config.opt
+opttmpfilepath=${outpathPrefix}/config.opt.in
+
+redofilepath=${outpathPrefix}/config.redo
+redotmpfilepath=${outpathPrefix}/config.redo.in
+
 fresh_requested_arg=
-optfilename=config.opt
 if [ -z "$optfile" ]; then   # only write optfile if not currently redoing
-    optfilepath=${outpathPrefix}${optfilename}
-    > "$optfilepath"
-    for arg in "$@"; do
-        if [ "$arg" = "-top-level" ]; then
-           continue
-        fi
-        echo $arg >> "$optfilepath"
-    done
+    > "$opttmpfilepath"
+    > "$redotmpfilepath"
+
+    for arg in "$@"; do echo \"$arg\" >> "$opttmpfilepath"; done
+
+    cmake -DIN_FILE="${opttmpfilepath}" -DOUT_FILE="${optfilepath}" -DIGNORE_ARGS=-top-level -P "${relpath}/cmake/QtWriteArgsFile.cmake"
 else
+    # Rewriting config.opt into config.opt.in anyway. Allows for direct manipulation of config.opt
+    > "$opttmpfilepath"
+    for arg in `cat $optfile`; do echo \"$arg\" >> "$opttmpfilepath"; done
+
+    cmake -DIN_FILE="${opttmpfilepath}" -DREDO_FILE="${redotmpfilepath}" -DOUT_FILE="${redofilepath}" -DIGNORE_ARGS=-top-level -P "${relpath}/cmake/QtWriteArgsFile.cmake"
+    optfilepath=${redofilepath}
     fresh_requested_arg=-DFRESH_REQUESTED=TRUE
 fi
 
@@ -243,4 +163,6 @@ if [ -n "$CFG_TOPLEVEL" ]; then
     cd ..
 fi
 
-cmake "-DOPTFILE=$optfilename" $top_level_arg $fresh_requested_arg -P "$relpath/cmake/QtProcessConfigureArgs.cmake"
+cmake "-DOPTFILE=${optfilepath}" ${top_level_arg} ${fresh_requested_arg} -P "${relpath}/cmake/QtProcessConfigureArgs.cmake"
+
+IFS=$SAVED_IFS

configure.bat

@@ -65,9 +65,8 @@ goto doneargs
 
 :redo
     if not exist "%TOPQTDIR%\config.opt" goto redoerr
-    set rargs=
-    for /f "usebackq delims=" %%i in ("%TOPQTDIR%\config.opt") do set rargs=!rargs! "%%i"
-    call :doargs %rargs%
+    echo %ARGS% > %TOPQTDIR%\config.redo.in
+    set redoing=""
     goto nextarg
 :redoerr
     echo No config.opt present - cannot redo configuration. >&2
@@ -78,15 +77,26 @@ goto doneargs
 cd "%TOPQTDIR%"
 
 rem Write config.opt if we're not currently -redo'ing
+set OPT_FILE_PATH=%TOPQTDIR%\config.opt
+set OPT_TMP_FILE_PATH=%TOPQTDIR%\config.opt.in
+set REDO_FILE_PATH=%TOPQTDIR%\config.redo
+set REDO_TMP_FILE_PATH=%TOPQTDIR%\config.redo.in
 set FRESH_REQUESTED_ARG=
-if "!rargs!" == "" (
-    echo.%*>config.opt.in
-    cmake -DIN_FILE=config.opt.in -DOUT_FILE=config.opt -DIGNORE_ARGS=-top-level -P "%QTSRC%\cmake\QtWriteArgsFile.cmake"
-) else if NOT "!rargs!" == "" (
+if not defined redoing (
+    echo.%*>"%OPT_TMP_FILE_PATH%"
+
+    cmake -DIN_FILE="%OPT_TMP_FILE_PATH%" -DOUT_FILE="%OPT_FILE_PATH%" -DIGNORE_ARGS=-top-level -P "%QTSRC%\cmake\QtWriteArgsFile.cmake"
+) else (
+    echo. 2> "%OPT_TMP_FILE_PATH%"
+    for /F "usebackq tokens=*" %%A in ("%OPT_FILE_PATH%") do echo "%%A" >> "%OPT_TMP_FILE_PATH%"
+
+    cmake -DIN_FILE="%OPT_TMP_FILE_PATH%" -DREDO_FILE="%REDO_TMP_FILE_PATH%" -DOUT_FILE="%REDO_FILE_PATH%" -DIGNORE_ARGS="-top-level;-redo;--redo" -P "%QTSRC%\cmake\QtWriteArgsFile.cmake"
+
+    set OPT_FILE_PATH=%REDO_FILE_PATH%
     set FRESH_REQUESTED_ARG=-DFRESH_REQUESTED=TRUE
 )
 
 rem Launch CMake-based configure
 set TOP_LEVEL_ARG=
 if %TOPLEVEL% == true set TOP_LEVEL_ARG=-DTOP_LEVEL=TRUE
-cmake -DOPTFILE=config.opt %TOP_LEVEL_ARG% %FRESH_REQUESTED_ARG% -P "%QTSRC%\cmake\QtProcessConfigureArgs.cmake"
+cmake -DOPTFILE="%OPT_FILE_PATH%" %TOP_LEVEL_ARG% %FRESH_REQUESTED_ARG% -P "%QTSRC%\cmake\QtProcessConfigureArgs.cmake"

configure.cmake

@@ -22,6 +22,7 @@ qt_find_package(WrapOpenSSLHeaders PROVIDED_TARGETS WrapOpenSSLHeaders::WrapOpen
 # openssl_headers
 # OPENSSL_VERSION_MAJOR is not defined for OpenSSL 1.1.1
 qt_config_compile_test(opensslv11_headers
+    LABEL "opensslv11_headers"
     LIBRARIES
         WrapOpenSSLHeaders::WrapOpenSSLHeaders
     CODE
@@ -46,6 +47,7 @@ qt_find_package(WrapOpenSSL PROVIDED_TARGETS WrapOpenSSL::WrapOpenSSL MODULE_NAM
 # openssl
 # OPENSSL_VERSION_MAJOR is not defined for OpenSSL 1.1.1
 qt_config_compile_test(opensslv11
+    LABEL "opensslv11"
     LIBRARIES
         WrapOpenSSL::WrapOpenSSL
     CODE
@@ -70,6 +72,7 @@ SSL_free(SSL_new(0));
 # opensslv30
 # openssl_headers
 qt_config_compile_test(opensslv30_headers
+    LABEL "opensslv30_headers"
     LIBRARIES
         WrapOpenSSLHeaders::WrapOpenSSLHeaders
     CODE
@@ -87,6 +90,7 @@ int main(void)
 }
 ")
 qt_config_compile_test(opensslv30
+    LABEL "opensslv30"
     LIBRARIES
         WrapOpenSSL::WrapOpenSSL
     CODE
@@ -105,7 +109,6 @@ SSL_free(SSL_new(0));
 }
 ")
 
-# special case end
 qt_find_package(WrapZSTD 1.3 PROVIDED_TARGETS WrapZSTD::WrapZSTD MODULE_NAME global QMAKE_LIB zstd)
 qt_find_package(WrapDBus1 1.2 PROVIDED_TARGETS dbus-1 MODULE_NAME global QMAKE_LIB dbus)
 qt_find_package(Libudev PROVIDED_TARGETS PkgConfig::Libudev MODULE_NAME global QMAKE_LIB libudev)
@@ -204,51 +207,6 @@ endif()
 # machineTuple
 qt_config_compile_test_machine_tuple("machine tuple")
 
-# cxx14
-qt_config_compile_test(cxx14
-    LABEL "C++14 support"
-    CODE
-"#if __cplusplus > 201103L
-// Compiler claims to support C++14, trust it
-#else
-#  error __cplusplus must be > 201103L (the value of C++11)
-#endif
-
-int main(void)
-{
-    /* BEGIN TEST: */
-    /* END TEST: */
-    return 0;
-}
-"
-    CXX_STANDARD 14
-)
-
-# cxx17
-qt_config_compile_test(cxx17
-    LABEL "C++17 support"
-    CODE
-"#if __cplusplus > 201402L
-// Compiler claims to support C++17, trust it
-#else
-#  error __cplusplus must be > 201402L (the value for C++14)
-#endif
-#include <map>  // https://bugs.llvm.org//show_bug.cgi?id=33117
-#include <variant>
-
-int main(void)
-{
-    /* BEGIN TEST: */
-std::variant<int> v(42);
-int i = std::get<int>(v);
-std::visit([](const auto &) { return 1; }, v);
-    /* END TEST: */
-    return 0;
-}
-"
-    CXX_STANDARD 17
-)
-
 # cxx20
 qt_config_compile_test(cxx20
     LABEL "C++20 support"
@@ -331,11 +289,13 @@ int main(void)
 "# FIXME: qmake: ['TEMPLATE = lib', 'CONFIG += dll bsymbolic_functions', 'isEmpty(QMAKE_LFLAGS_BSYMBOLIC_FUNC): error("Nope")']
 )
 
-
+if(NOT MSVC AND NOT APPLE)
     qt_config_compile_test("separate_debug_info"
                        LABEL "separate debug information support"
                        PROJECT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/config.tests/separate_debug_info"
     )
+endif()
+
 # signaling_nan
 qt_config_compile_test(signaling_nan
     LABEL "Signaling NaN for doubles"
@@ -479,7 +439,6 @@ qt_feature("android-style-assets" PRIVATE
 )
 qt_feature("shared" PUBLIC
     LABEL "Building shared libraries"
-    AUTODETECT NOT UIKIT
     CONDITION BUILD_SHARED_LIBS
 )
 qt_feature_definition("shared" "QT_STATIC" NEGATE PREREQUISITE "!defined(QT_SHARED) && !defined(QT_STATIC)")
@@ -511,7 +470,6 @@ qt_feature("optimize_size"
     CONDITION NOT QT_FEATURE_debug OR QT_FEATURE_debug_and_release
 )
 qt_feature_config("optimize_size" QMAKE_PRIVATE_CONFIG)
-# special case begin
 qt_feature("optimize_full"
     LABEL "Fully optimize release builds (-O3)"
     AUTODETECT OFF
@@ -520,10 +478,10 @@ qt_feature_config("optimize_full" QMAKE_PRIVATE_CONFIG)
 qt_feature("msvc_obj_debug_info"
     LABEL "Embed debug info in object files (MSVC)"
     CONDITION MSVC
+    ENABLE QT_USE_CCACHE
     AUTODETECT OFF
 )
 qt_feature_config("msvc_obj_debug_info" QMAKE_PRIVATE_CONFIG)
-# special case end
 qt_feature("pkg-config" PUBLIC
     LABEL "Using pkg-config"
     AUTODETECT NOT APPLE AND NOT WIN32 AND NOT ANDROID
@@ -535,7 +493,7 @@ qt_feature("developer-build" PRIVATE
     LABEL "Developer build"
     AUTODETECT OFF
 )
-qt_feature("no-prefix" PRIVATE
+qt_feature("no-prefix"
     LABEL "No prefix build"
     AUTODETECT NOT QT_WILL_INSTALL
     CONDITION NOT QT_WILL_INSTALL
@@ -567,7 +525,7 @@ qt_feature_config("force_debug_info" QMAKE_PRIVATE_CONFIG)
 qt_feature("separate_debug_info" PUBLIC
     LABEL "Split off debug information"
     AUTODETECT OFF
-    CONDITION ( QT_FEATURE_shared ) AND ( QT_FEATURE_debug OR QT_FEATURE_debug_and_release OR QT_FEATURE_force_debug_info ) AND ( APPLE OR TEST_separate_debug_info )
+    CONDITION ( QT_FEATURE_shared ) AND ( QT_FEATURE_debug OR QT_FEATURE_debug_and_release OR QT_FEATURE_force_debug_info ) AND ( MSVC OR APPLE OR TEST_separate_debug_info )
 )
 qt_feature_config("separate_debug_info" QMAKE_PUBLIC_QT_CONFIG)
 qt_feature("appstore-compliant" PUBLIC
@@ -661,29 +619,10 @@ qt_feature_config("plugin-manifests" QMAKE_PUBLIC_CONFIG
     NEGATE
     NAME "no_plugin_manifest"
 )
-qt_feature("c++11" PUBLIC
-    LABEL "C++11"
-)
-qt_feature_config("c++11" QMAKE_PUBLIC_QT_CONFIG)
-qt_feature("c++14" PUBLIC
-    LABEL "C++14"
-    CONDITION QT_FEATURE_cxx11 AND TEST_cxx14
-)
-qt_feature_config("c++14" QMAKE_PUBLIC_QT_CONFIG)
-qt_feature("c++17" PUBLIC
-    LABEL "C++17"
-    CONDITION QT_FEATURE_cxx14 AND TEST_cxx17
-)
-qt_feature_config("c++17" QMAKE_PUBLIC_QT_CONFIG)
-qt_feature("c++1z" PUBLIC
-    LABEL "C++17"
-    CONDITION QT_FEATURE_cxx17
-)
-qt_feature_config("c++1z" QMAKE_PUBLIC_QT_CONFIG)
 qt_feature("c++20" PUBLIC
     LABEL "C++20"
     AUTODETECT OFF
-    CONDITION QT_FEATURE_cxx17 AND TEST_cxx20
+    CONDITION TEST_cxx20
 )
 qt_feature_config("c++20" QMAKE_PUBLIC_QT_CONFIG)
 qt_feature("c++2a" PUBLIC
@@ -701,17 +640,6 @@ qt_feature("c++2b" PUBLIC
     AUTODETECT FALSE
     CONDITION QT_FEATURE_cxx20 AND (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20") AND TEST_cxx2b
 )
-qt_feature("c89"
-    LABEL "C89"
-)
-qt_feature("c99" PUBLIC
-    LABEL "C99"
-    CONDITION c_std_99 IN_LIST CMAKE_C_COMPILE_FEATURES
-)
-qt_feature("c11" PUBLIC
-    LABEL "C11"
-    CONDITION QT_FEATURE_c99 AND c_std_11 IN_LIST CMAKE_C_COMPILE_FEATURES
-)
 qt_feature("precompile_header"
     LABEL "Using precompiled headers"
     CONDITION BUILD_WITH_PCH AND TEST_precompile_header
@@ -914,7 +842,9 @@ qt_feature_definition("mips_dspr2" "QT_COMPILER_SUPPORTS_MIPS_DSPR2" VALUE "1")
 qt_feature_config("mips_dspr2" QMAKE_PRIVATE_CONFIG)
 qt_feature("neon" PRIVATE
     LABEL "NEON"
-    CONDITION ( ( ( TEST_architecture_arch STREQUAL arm ) OR ( TEST_architecture_arch STREQUAL arm64 ) ) AND TEST_arch_${TEST_architecture_arch}_subarch_neon ) OR QT_FORCE_FEATURE_neon  # special case
+    CONDITION ( ( ( TEST_architecture_arch STREQUAL arm ) OR
+        ( TEST_architecture_arch STREQUAL arm64 ) ) AND
+        TEST_arch_${TEST_architecture_arch}_subarch_neon ) OR QT_FORCE_FEATURE_neon
 )
 qt_feature_definition("neon" "QT_COMPILER_SUPPORTS_NEON" VALUE "1")
 qt_feature_config("neon" QMAKE_PRIVATE_CONFIG)
@@ -980,7 +910,6 @@ qt_feature("stdlib-libcpp" PRIVATE
     AUTODETECT OFF
     CONDITION LINUX AND NOT ANDROID
 )
-# special case begin
 # Check whether CMake was built with zstd support.
 # See https://gitlab.kitware.com/cmake/cmake/-/issues/21552
 if(NOT DEFINED CACHE{QT_CMAKE_ZSTD_SUPPORT})
@@ -997,7 +926,6 @@ if(NOT DEFINED CACHE{QT_CMAKE_ZSTD_SUPPORT})
         unset(qt_check_zstd_exit_code)
     endif()
 endif()
-# special case end
 qt_feature("thread" PUBLIC
     SECTION "Kernel"
     LABEL "Thread support"
@@ -1137,26 +1065,26 @@ qt_configure_add_summary_entry(
     ARGS "optimize_size"
     CONDITION NOT QT_FEATURE_debug OR QT_FEATURE_debug_and_release
 )
-# special case begin
 qt_configure_add_summary_entry(
     ARGS "optimize_full"
 )
-# special case end
 qt_configure_add_summary_entry(ARGS "shared")
-qt_configure_add_summary_entry(
-    TYPE "firstAvailableFeature"
-    ARGS "c11 c99 c89"
-    MESSAGE "Using C standard"
-)
-qt_configure_add_summary_entry(
-    TYPE "firstAvailableFeature"
-    ARGS "c++2b c++20 c++17 c++14 c++11"
-    MESSAGE "Using C++ standard"
-)
 qt_configure_add_summary_entry(
     ARGS "ccache"
     CONDITION UNIX
 )
+qt_configure_add_summary_entry(
+    TYPE "message" ARGS "Unity Build" MESSAGE "yes" CONDITION QT_UNITY_BUILD
+)
+qt_configure_add_summary_entry(
+    TYPE "message" ARGS "Unity Build" MESSAGE "no" CONDITION NOT QT_UNITY_BUILD
+)
+qt_configure_add_summary_entry(
+    TYPE "message"
+    ARGS "Unity Build Batch Size"
+    MESSAGE "${QT_UNITY_BUILD_BATCH_SIZE}"
+    CONDITION QT_UNITY_BUILD
+)
 qt_configure_add_summary_entry(
     TYPE "firstAvailableFeature"
     ARGS "use_bfd_linker use_gold_linker use_lld_linker use_mold_linker"
@@ -1214,6 +1142,13 @@ qt_configure_add_summary_entry(ARGS "sanitize_fuzzer_no_link")
 qt_configure_add_summary_entry(ARGS "sanitize_undefined")
 qt_configure_end_summary_section() # end of "Sanitizers" section
 qt_configure_add_summary_build_parts("Build parts")
+if(QT_INSTALL_EXAMPLES_SOURCES)
+    set(_examples_sources_entry_message "yes")
+else()
+    set(_examples_sources_entry_message "no")
+endif()
+qt_configure_add_summary_entry(ARGS "Install examples sources" TYPE "message"
+    MESSAGE "${_examples_sources_entry_message}")
 qt_configure_add_summary_entry(
     ARGS "appstore-compliant"
     CONDITION APPLE OR ANDROID OR WIN32
@@ -1233,6 +1168,14 @@ qt_configure_add_summary_entry(ARGS "xml")
 qt_configure_end_summary_section() # end of "Qt modules and options" section
 qt_configure_add_summary_section(NAME "Support enabled for")
 qt_configure_add_summary_entry(ARGS "pkg-config")
+
+if(QT_USE_VCPKG AND (DEFINED ENV{VCPKG_ROOT} OR VCPKG_TARGET_TRIPLET))
+    set(_vcpkg_entry_message "yes")
+else()
+    set(_vcpkg_entry_message "no")
+endif()
+qt_configure_add_summary_entry(ARGS "Using vcpkg" TYPE "message" MESSAGE "${_vcpkg_entry_message}")
+
 qt_configure_add_summary_entry(ARGS "libudev")
 qt_configure_add_summary_entry(ARGS "openssl")
 qt_configure_add_summary_entry(ARGS "openssl-linked")
@@ -1247,13 +1190,6 @@ qt_configure_add_report_entry(
     MESSAGE "Using static linking will disable the use of dynamically loaded plugins. Make sure to import all needed static plugins, or compile needed modules into the library."
     CONDITION NOT QT_FEATURE_shared
 )
-# special case begin
-# qt_configure_add_report_entry(
-#     TYPE ERROR
-#     MESSAGE "Debug build without Release build is not currently supported on ios see QTBUG-71990. Use -debug-and-release."
-#     CONDITION IOS AND QT_FEATURE_debug AND NOT QT_FEATURE_debug_and_release
-# )
-# special case end
 qt_configure_add_report_entry(
     TYPE WARNING
     MESSAGE "-debug-and-release is only supported on Darwin and Windows platforms.  Qt can be built in release mode with separate debug information, so -debug-and-release is no longer necessary."
@@ -1283,6 +1219,16 @@ if (TEST_architecture_arch STREQUAL x86_64 OR TEST_architecture_arch STREQUAL i3
             MESSAGE [=[
 All x86 intrinsics and SIMD support were disabled. If this was in error, check
 the result of the build in config.tests/x86intrin and report at https://bugreports.qt.io.
+]=]
+        )
+    elseif (MSVC AND CLANG)
+        # Warn only
+        qt_configure_add_report_entry(
+            TYPE WARNING
+            CONDITION (NOT QT_FEATURE_x86intrin)
+            MESSAGE [=[
+x86 intrinsics support is disabled for clang-cl build. This might be necessary due to
+https://github.com/llvm/llvm-project/issues/53520
 ]=]
         )
     else()
@@ -1299,7 +1245,6 @@ ${TEST_x86intrin_OUTPUT}
         )
     endif()
 endif()
-# special case begin
 qt_configure_add_report_entry(
     TYPE ERROR
     MESSAGE "Setting a library infix is not supported for framework builds."
@@ -1318,7 +1263,6 @@ qt_configure_add_report_entry(
 if(WASM)
     qt_extra_definition("QT_EMCC_VERSION" "\"${EMCC_VERSION}\"" PUBLIC)
 endif()
-# special case end
 qt_extra_definition("QT_VERSION_STR" "\"${PROJECT_VERSION}\"" PUBLIC)
 qt_extra_definition("QT_VERSION_MAJOR" ${PROJECT_VERSION_MAJOR} PUBLIC)
 qt_extra_definition("QT_VERSION_MINOR" ${PROJECT_VERSION_MINOR} PUBLIC)
@@ -1326,3 +1270,11 @@ qt_extra_definition("QT_VERSION_PATCH" ${PROJECT_VERSION_PATCH} PUBLIC)
 
 qt_extra_definition("QT_COPYRIGHT" \"${QT_COPYRIGHT}\" PRIVATE)
 qt_extra_definition("QT_COPYRIGHT_YEAR" \"${QT_COPYRIGHT_YEAR}\" PRIVATE)
+
+qt_configure_add_report_entry(
+    TYPE WARNING
+    MESSAGE "QT_ALLOW_SYMLINK_IN_PATHS is enabled. This is not recommended, and it may lead to unexpected issues.
+E.g., When building QtWebEngine, enabling this option may result in build issues in certain platforms.
+See https://bugreports.qt.io/browse/QTBUG-59769."
+    CONDITION QT_ALLOW_SYMLINK_IN_PATHS
+)

doc/CMakeLists.txt

@@ -1,7 +1,6 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: BSD-3-Clause
 
-# special case skip regeneration
 #
 # Copy/Install doc configuration files to the build/install directory
 #

doc/config/exampleurl-qtpositioning.qdocconf

@@ -0,0 +1 @@
+url.examples = "https://code.qt.io/cgit/qt/qtpositioning.git/tree/examples/\1?h=$QT_VER"

doc/global/config.qdocconf

@@ -29,6 +29,5 @@ url = https://doc.qt.io/qt
 
 defines += qt6
 
-# Uncomment the following two lines to generate documentation marked as \internal
-# alias.internal = disable
-# macro.internal.HTML = "<span style="color:red">[internal]</span>"
+# Require Qt modules to define qhp.projects
+qhp = true

doc/global/html-header-offline.qdocconf

@@ -2,11 +2,13 @@
 
 #specify the CSS file used by this template
 HTML.stylesheets = template/style/offline.css \
-                   template/style/offline-dark.css
+                   template/style/offline-dark.css \
+                   template/style/tech_preview.svg
 
 #for including files into the qch file
 qhp.extraFiles += style/offline.css \
-                  style/offline-dark.css
+                  style/offline-dark.css \
+                  style/tech_preview.svg
 
 HTML.headerstyles = \
     "  <link rel=\"stylesheet\" type=\"text/css\" href=\"style/offline.css\" />\n"

doc/global/html-header-online.qdocconf

@@ -11,8 +11,10 @@ HTML.stylesheets = template/style/online.css \
                    template/style/icomoon.woff \
                    template/style/cookiebar-x.png \
                    template/style/doc_search.png \
+                   template/style/tech_preview.svg \
                    template/style/theqtcompany.png
 
+
 #for including files into the qch file. Relative to the outputdir of a QDoc build.
 qhp.extraFiles += style/online.css \
                   style/cookie-confirm.css \
@@ -25,6 +27,7 @@ qhp.extraFiles += style/online.css \
                   style/icomoon.woff \
                   style/cookiebar-x.png \
                   style/doc_search.png \
+                  style/tech_preview.svg \
                   style/theqtcompany.png
 
 HTML.headerstyles = \

doc/global/macros.qdocconf

@@ -56,6 +56,19 @@ macro.endqdoc.HTML        = "*/"
 macro.borderedimage       = "\\div {class=\"border\"} \\image \1\n\\enddiv"
 macro.examplecategory     = "\\meta category {\1}\n\\ingroup category \1"
 
+macro.QDS                 = "Qt Design Studio"
+macro.QDV                 = "Qt Design Viewer"
+macro.QB                  = "Qt Bridge"
+macro.QBPS                = "Qt Bridge for Adobe Photoshop"
+macro.QBXD                = "Qt Bridge for Adobe XD"
+macro.QBSK                = "Qt Bridge for Sketch"
+macro.QBF                 = "Qt Bridge for Figma"
+macro.QMCU                = "Qt for MCUs"
+macro.QUL                 = "Qt Quick Ultralite"
+macro.QtAA                = "Qt for Android Automotive"
+macro.QOI                 = "Qt Online Installer"
+macro.QMT                 = "Qt Maintenance Tool"
+
 macro.beginfloatleft.HTML   = "<div style=\"float: left; margin-right: 2em\">"
 macro.beginfloatright.HTML  = "<div style=\"float: right; margin-left: 2em\">"
 macro.endfloat.HTML         = "</div>"
@@ -111,3 +124,9 @@ macro.cmakepropertywebassemblyonly = "\\note This property is used only if targe
 
 macro.cmakepropertyiosonly = "\\note This property is used only if targeting iOS."
 macro.cmakevariableiosonly = "\\note This variable is used only if targeting iOS."
+
+macro.qtpolicydeprecatedbehavior = "\\note The \\c{OLD} behavior of a policy is deprecated, and may be removed in the future."
+#Appends the tech preview link to the brief sentence and adds to tech_preview
+#group.
+#Must be placed directly under a \brief command
+macro.techpreview = "(Technical preview)\n\n\\meta status {Technical preview}\n\\ingroup tech_preview\n"

doc/global/manifest-meta.qdocconf

@@ -35,7 +35,7 @@ manifestmeta.highlighted.attributes =   isHighlighted:true
 manifestmeta.android.names          =   "Qt3D/Qt 3D: Basic Shapes C++ Example" \
                                         "Qt3D/Qt 3D: Planets QML Example" \
                                         "Qt3D/Qt 3D: Simple Custom Material QML Example" \
-                                        "QtAndroidExtras/Qt Notifier" \
+                                        "QtCore/Qt Android Notifier" \
                                         "QtBluetooth/Bluetooth Low Energy Scanner Example" \
                                         "QtBluetooth/Bluetooth Scanner Example" \
                                         "QtBluetooth/QML Bluetooth Scanner Example" \
@@ -51,15 +51,12 @@ manifestmeta.android.names          =   "Qt3D/Qt 3D: Basic Shapes C++ Example" \
                                         "QtLocation/Places Map (QML)" \
                                         "QtLocation/Plane Spotter (QML)" \
                                         "QtMultimedia/AudioEngine Example" \
-                                        "QtMultimedia/Camera Example" \
                                         "QtMultimedia/QML Camera Example" \
                                         "QtMultimedia/QML Video Example" \
                                         "QtMultimedia/QML Video Shader Effects Example" \
                                         "QtNFC/Annotated URL Example" \
                                         "QtNFC/QML Poster Example" \
-                                        "QtOpenGL/2D Painting Example" \
                                         "QtOpenGL/Hello GLES3 Example" \
-                                        "QtOpenGL/Textures Example" \
                                         "QtPositioning/SatelliteInfo (C++/QML)" \
                                         "QtPositioning/Weather Info (C++/QML)" \
                                         "QtPurchasing/Qt Purchasing Examples - QtHangman" \
@@ -94,9 +91,6 @@ manifestmeta.android.names          =   "Qt3D/Qt 3D: Basic Shapes C++ Example" \
                                         "QtQuickControls/Qt Quick Controls - Flat Style" \
                                         "QtQuickControls/Qt Quick Controls - Gallery" \
                                         "QtQuickControls/Qt Quick Controls - Imagine Style Example: Automotive" \
-                                        "QtQuickControls/Qt Quick Controls - Imagine Style Example: Music Player" \
-                                        "QtQuickControls/Qt Quick Controls - Side Panel" \
-                                        "QtQuickControls/Qt Quick Controls - Swipe to Remove" \
                                         "QtQuickControls/Qt Quick Controls - Text Editor" \
                                         "QtQuickControls/Qt Quick Controls - Wearable Demo" \
                                         "QtQuickDialogs/*" \
@@ -108,47 +102,7 @@ manifestmeta.android.names          =   "Qt3D/Qt 3D: Basic Shapes C++ Example" \
                                         "QtSQL/Master Detail Example" \
                                         "QtSVG/Text Object Example" \
                                         "QtUiTools/Text Finder Example" \
-                                        "QtWebView/Qt WebView Examples - Minibrowser" \
-                                        "QtWidgets/Address Book Example" \
-                                        "QtWidgets/Affine Transformations" \
-                                        "QtWidgets/Analog Clock Example" \
-                                        "QtWidgets/Animated Tiles Example" \
-                                        "QtWidgets/Application Chooser Example" \
-                                        "QtWidgets/Basic Layouts Example" \
-                                        "QtWidgets/Border Layout Example" \
-                                        "QtWidgets/Code Editor Example" \
-                                        "QtWidgets/Colliding Mice Example" \
-                                        "QtWidgets/Concentric Circles Example" \
-                                        "QtWidgets/Digital Clock Example" \
-                                        "QtWidgets/Dynamic Layouts Example" \
-                                        "QtWidgets/Easing Curves Example" \
-                                        "QtWidgets/Editable Tree Model Example" \
-                                        "QtWidgets/Elided Label Example" \
-                                        "QtWidgets/Fade Message Effect Example" \
-                                        "QtWidgets/Flow Layout Example" \
-                                        "QtWidgets/Font Sampler Example" \
-                                        "QtWidgets/Frozen Column Example" \
-                                        "QtWidgets/Gradients" \
-                                        "QtWidgets/Group Box Example" \
-                                        "QtWidgets/Image Composition Example" \
-                                        "QtWidgets/Line Edits Example" \
-                                        "QtWidgets/Mouse Button Tester" \
-                                        "QtWidgets/Move Blocks Example" \
-                                        "QtWidgets/Painter Paths Example" \
-                                        "QtWidgets/Painter Paths Example" \
-                                        "QtWidgets/Path Stroking" \
-                                        "QtWidgets/Pixelator Example" \
-                                        "QtWidgets/Recent Files Example" \
-                                        "QtWidgets/SDI Example" \
-                                        "QtWidgets/Scribble Example" \
-                                        "QtWidgets/Simple Tree Model Example" \
-                                        "QtWidgets/Sliders Example" \
-                                        "QtWidgets/Spreadsheet" \
-                                        "QtWidgets/Touch Dials Example" \
-                                        "QtWidgets/Transformations Example" \
-                                        "QtWidgets/Undo Framework" \
-                                        "QtWidgets/Vector Deformation" \
-                                        "QtWidgets/Wiggly Example"
+                                        "QtWebView/Qt WebView Examples - Minibrowser"
 
 manifestmeta.android.tags              =   android
 
@@ -166,7 +120,6 @@ manifestmeta.ios.names              =  "QtCore/Contiguous Cache Example" \
                                        "QtWidgets/Easing Curves Example" \
                                        "QtWidgets/Move Blocks Example" \
                                        "QtWidgets/States Example" \
-                                       "QtWidgets/Class Wizard Example" \
                                        "QtWidgets/Find Files Example" \
                                        "QtWidgets/License Wizard Example" \
                                        "QtWidgets/Standard Dialogs Example" \

doc/global/template/style/offline.css

@@ -574,6 +574,20 @@ ol.I > li {
     padding: 3px 15px 3px 0
 }
 
+span.status.technical-preview {
+    display: inline-block;
+    position: relative;
+    background: center/contain no-repeat url(tech_preview.svg);
+    width: 26px;
+    height: 23px;
+}
+
+td.memItemRight span.status {
+    margin-top: -10px;
+    right: -10px;
+    top: 6px;
+}
+
 .qml {
     display: block;
     margin: 10px;

doc/global/template/style/online.css

@@ -505,6 +505,18 @@ h1,h2,h3,h4,h5,h6 {
   font-size:150%;
   margin-bottom: 1em
 }
+span.status.technical-preview {
+  display:inline-block;
+  position:relative;
+  background:center/contain no-repeat url(tech_preview.svg);
+  width:26px;
+  height:23px
+}
+td.memItemRight span.status {
+  margin-top:-10px;
+  right:-10px;
+  top:6px
+}
 article,aside,details,figcaption,figure,footer,header,hgroup,menu,nav,section {
   display:block
 }

doc/global/template/style/tech_preview.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="49" height="43" viewBox="0 0 13 11" stroke="#09102b"><path d="M12.82 11.125L.155 11.121 6.491.155z" opacity=".999" fill="#ffe353" stroke-linejoin="round" stroke-width=".31"/><path d="M4.914 7.071L3.521 8.302l1.287 1.084m1.144.027l1.394-1.231-1.287-1.084m-.283-.539l-.788 2.974" fill="none" stroke-linecap="round" stroke-width=".151"/><path d="M7.287 9.358l-.013.259 1.695.025-.021-.297-1.662.013zm.706.017L7.989 5.7l.367-.004.017 3.658m.33-3.512l-.238.008.004.255.238.033-.004-.297zm-.221.05l-3.199.008.004.238 3.165-.021.029-.226zm-2.965.255l.025.447.28-.15.23.163-.267.313m-.23-.322l-.242-.046-.084.163.288.226" fill="#41cd52" stroke-width=".151"/></svg>