Revert "xcb: handle XI2 input button and motion events from slave devices"

This reverts commit b71be292780b858f2c55ce92601452e2ea946de2, which causes a regression when using mouse wheel and moving cursor together
on scroll bar for some qt applications, like qutebrowser and
qbittorrent.

Fixes: QTBUG-129509
Fixes: QTBUG-129514
Task-number: QTBUG-110841
Change-Id: I703158874413a1306ea99217bced4ba38382f543
Reviewed-by: Liang Qi <liang.qi@qt.io>
Reviewed-by: Axel Spoerl <axel.spoerl@qt.io>
(cherry picked from commit 5875da6d70303468eab85030a80f54c268f80b79)

.cmake.conf

@@ -38,15 +38,15 @@ set(QT_MAX_NEW_POLICY_CMAKE_VERSION "3.21")
 
 # These should be updated together with the documentation in
 # qtdoc/doc/src/platforms/supported-platforms.qdocinc
-set(QT_SUPPORTED_MIN_MACOS_SDK_VERSION "13")
-set(QT_SUPPORTED_MAX_MACOS_SDK_VERSION "14")
-set(QT_SUPPORTED_MIN_MACOS_XCODE_VERSION "14")
+set(QT_SUPPORTED_MIN_MACOS_SDK_VERSION "14")
+set(QT_SUPPORTED_MAX_MACOS_SDK_VERSION "15")
+set(QT_SUPPORTED_MIN_MACOS_XCODE_VERSION "15")
 
-set(QT_SUPPORTED_MIN_IOS_SDK_VERSION "16")
-set(QT_SUPPORTED_MAX_IOS_SDK_VERSION "17")
-set(QT_SUPPORTED_MIN_IOS_XCODE_VERSION "14")
+set(QT_SUPPORTED_MIN_IOS_SDK_VERSION "17")
+set(QT_SUPPORTED_MAX_IOS_SDK_VERSION "18")
+set(QT_SUPPORTED_MIN_IOS_XCODE_VERSION "15")
 
 set(QT_SUPPORTED_MIN_VISIONOS_SDK_VERSION "1")
-set(QT_SUPPORTED_MAX_VISIONOS_SDK_VERSION "1")
+set(QT_SUPPORTED_MAX_VISIONOS_SDK_VERSION "2")
 set(QT_SUPPORTED_MIN_VISIONOS_XCODE_VERSION "15")
 

bin/qt-configure-module.in

@@ -34,5 +34,5 @@ echo "$arg" >> "$optfile"
 done
 
 cmake_script_path="$script_dir_path/@__relative_path_to_cmake_scripts_dir@/QtProcessConfigureArgs.cmake"
-qt_cmake_private_path="$script_dir_path/../libexec"
+qt_cmake_private_path="$script_dir_path/../@INSTALL_LIBEXECDIR@"
 "$qt_cmake_private_path/qt-cmake-private" -DOPTFILE=$optfile -DMODULE_ROOT="$module_root" -DCMAKE_COMMAND="$qt_cmake_private_path/qt-cmake-private" -P "$cmake_script_path"

cmake/FindGLESv2.cmake

@@ -80,7 +80,9 @@ if(GLESv2_FOUND AND NOT TARGET GLESv2::GLESv2)
             IMPORTED_LOCATION "${GLESv2_LIBRARY}"
             INTERFACE_INCLUDE_DIRECTORIES "${GLESv2_INCLUDE_DIR}")
 
-        if(EGL_LIBRARY)
+        if(TARGET EGL::EGL)
+            target_link_libraries(GLESv2::GLESv2 INTERFACE "EGL::EGL")
+        elseif(EGL_LIBRARY)
             target_link_libraries(GLESv2::GLESv2 INTERFACE "${EGL_LIBRARY}")
         endif()
     endif()

cmake/FindInterbase.cmake

@@ -23,13 +23,13 @@
 
 find_path(Interbase_INCLUDE_DIR
           NAMES ibase.h
-          HINTS ${Interbase_INCLUDEDIR}
+          HINTS "${Interbase_INCLUDEDIR}" "${Interbase_ROOT}/include"
           PATH_SUFFIXES firebird
 )
 
 find_library(Interbase_LIBRARY
-             NAMES firebase_ms fbclient gds
-             HINTS ${Interbase_LIBDIR}
+             NAMES firebase_ms fbclient_ms fbclient gds
+             HINTS "${Interbase_LIBDIR}" "${Interbase_ROOT}/lib"
 )
 
 include(FindPackageHandleStandardArgs)

cmake/FindMySQL.cmake

@@ -48,7 +48,7 @@ if(PkgConfig_FOUND AND NOT DEFINED MySQL_ROOT)
     set(MySQL_library_hints ${PC_MySQL_LIBDIR})
     set(MySQL_library_hints_debug "")
 else()
-    set(MySQL_include_dir_hints "")
+    set(MySQL_include_dir_hints "${MySQL_ROOT}" "${MySQL_ROOT}/include")
     if(NOT DEFINED MySQL_LIBRARY_DIR)
         set(MySQL_LIBRARY_DIR "${MySQL_ROOT}/lib")
     endif()

cmake/FindOracle.cmake

@@ -23,13 +23,16 @@
 
 find_path(Oracle_INCLUDE_DIR
   NAMES oci.h
-  HINTS ${Oracle_INCLUDE_DIR})
+  HINTS ${Oracle_INCLUDE_DIR} "${Oracle_ROOT}" "${Oracle_ROOT}/include" "${Oracle_ROOT}/sdk/include"
+)
 
 set(ORACLE_OCI_NAMES clntsh ociei oraociei12 oci)
 
 find_library(Oracle_LIBRARY
   NAMES ${ORACLE_OCI_NAMES}
-  HINTS ${Oracle_LIBRARY_DIR})
+  HINTS ${Oracle_LIBRARY_DIR} "${Oracle_ROOT}" "${Oracle_ROOT}/lib" "${Oracle_ROOT}/sdk/lib"
+  PATH_SUFFIXES msvc
+)
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(Oracle DEFAULT_MSG Oracle_LIBRARY Oracle_INCLUDE_DIR)

cmake/Qt3rdPartyLibraryHelpers.cmake

@@ -135,18 +135,22 @@ endfunction()
 #
 function(qt_internal_add_3rdparty_library target)
     qt_internal_get_add_library_option_args(library_option_args)
+
     set(option_args
         EXCEPTIONS
         INSTALL
         SKIP_AUTOMOC
-        )
+        ${__qt_internal_sbom_optional_args}
+    )
     set(single_args
         OUTPUT_DIRECTORY
         QMAKE_LIB_NAME
+        ${__qt_internal_sbom_single_args}
     )
     set(multi_args
         ${__default_private_args}
         ${__default_public_args}
+        ${__qt_internal_sbom_multi_args}
     )
 
     cmake_parse_arguments(PARSE_ARGV 1 arg
@@ -193,7 +197,6 @@ function(qt_internal_add_3rdparty_library target)
 
     qt_internal_add_qt_repo_known_module(${target})
     qt_internal_add_target_aliases(${target})
-    _qt_internal_apply_strict_cpp(${target})
 
     qt_skip_warnings_are_errors_when_repo_unclean("${target}")
 
@@ -253,6 +256,12 @@ function(qt_internal_add_3rdparty_library target)
     )
 
     if(NOT BUILD_SHARED_LIBS OR arg_INSTALL)
+        set(will_install TRUE)
+    else()
+        set(will_install FALSE)
+    endif()
+
+    if(will_install)
         qt_generate_3rdparty_lib_pri_file("${target}" "${arg_QMAKE_LIB_NAME}" pri_file)
         if(pri_file)
             qt_install(FILES "${pri_file}" DESTINATION "${INSTALL_MKSPECSDIR}/modules")
@@ -327,6 +336,57 @@ function(qt_internal_add_3rdparty_library target)
             INTERPROCEDURAL_OPTIMIZATION OFF
         )
     endif()
+
+    if(QT_GENERATE_SBOM)
+        set(sbom_args "")
+        list(APPEND sbom_args TYPE QT_THIRD_PARTY_MODULE)
+
+        if(NOT will_install)
+            list(APPEND sbom_args NO_INSTALL)
+        endif()
+
+        qt_get_cmake_configurations(configs)
+        foreach(config IN LISTS configs)
+            _qt_internal_sbom_append_multi_config_aware_single_arg_option(
+                RUNTIME_PATH
+                "${INSTALL_BINDIR}"
+                "${config}"
+                sbom_args
+            )
+            _qt_internal_sbom_append_multi_config_aware_single_arg_option(
+                LIBRARY_PATH
+                "${INSTALL_LIBDIR}"
+                "${config}"
+                sbom_args
+            )
+            _qt_internal_sbom_append_multi_config_aware_single_arg_option(
+                ARCHIVE_PATH
+                "${INSTALL_LIBDIR}"
+                "${config}"
+                sbom_args
+            )
+        endforeach()
+
+        _qt_internal_forward_function_args(
+            FORWARD_APPEND
+            FORWARD_PREFIX arg
+            FORWARD_OUT_VAR sbom_args
+            FORWARD_OPTIONS
+                ${__qt_internal_sbom_optional_args}
+            FORWARD_SINGLE
+                ${__qt_internal_sbom_single_args}
+            FORWARD_MULTI
+                ${__qt_internal_sbom_multi_args}
+        )
+
+        _qt_internal_extend_sbom(${target} ${sbom_args})
+    endif()
+
+    qt_add_list_file_finalizer(qt_internal_finalize_3rdparty_library ${target})
+endfunction()
+
+function(qt_internal_finalize_3rdparty_library target)
+    _qt_internal_finalize_sbom(${target})
 endfunction()
 
 function(qt_install_3rdparty_library_wrap_config_extra_file target)
@@ -368,9 +428,11 @@ function(qt_internal_add_3rdparty_header_module target)
     _qt_internal_validate_all_args_are_parsed(arg)
 
     qt_internal_add_module(${target}
+        IS_QT_3RD_PARTY_HEADER_MODULE
         INTERNAL_MODULE
         HEADER_MODULE
         NO_CONFIG_HEADER_FILE
+        NO_GENERATE_CPP_EXPORTS
         EXTERNAL_HEADERS ${arg_EXTERNAL_HEADERS}
         EXTERNAL_HEADERS_DIR ${arg_EXTERNAL_HEADERS_DIR}
     )

cmake/QtAppHelpers.cmake

@@ -4,10 +4,28 @@
 # This function creates a CMake target for a Qt internal app.
 # Such projects had a load(qt_app) command.
 function(qt_internal_add_app target)
+    set(option_args
+        NO_INSTALL
+        INSTALL_VERSIONED_LINK
+        EXCEPTIONS
+        NO_UNITY_BUILD
+        ${__qt_internal_sbom_optional_args}
+    )
+    set(single_args
+        ${__default_target_info_args}
+        ${__qt_internal_sbom_single_args}
+        INSTALL_DIR
+    )
+    set(multi_args
+        ${__default_private_args}
+        ${__qt_internal_sbom_multi_args}
+        PUBLIC_LIBRARIES
+    )
+
     cmake_parse_arguments(PARSE_ARGV 1 arg
-        "NO_INSTALL;INSTALL_VERSIONED_LINK;EXCEPTIONS;NO_UNITY_BUILD"
-        "${__default_target_info_args};INSTALL_DIR"
-        "${__default_private_args};PUBLIC_LIBRARIES"
+        "${option_args}"
+        "${single_args}"
+        "${multi_args}"
     )
     _qt_internal_validate_all_args_are_parsed(arg)
 
@@ -76,7 +94,6 @@ function(qt_internal_add_app target)
         # qt_set_target_info_properties knows how to process them
     )
     qt_internal_add_target_aliases("${target}")
-    _qt_internal_apply_strict_cpp("${target}")
     qt_internal_adjust_main_config_runtime_output_dir("${target}" "${output_directory}")
 
     # To mimic the default behaviors of qt_app.prf, we by default enable GUI Windows applications,
@@ -96,6 +113,43 @@ function(qt_internal_add_app target)
         TARGETS ${target})
     endif()
 
+    if(QT_GENERATE_SBOM)
+        set(sbom_args "")
+        list(APPEND sbom_args TYPE QT_APP)
+
+        qt_get_cmake_configurations(cmake_configs)
+        foreach(cmake_config IN LISTS cmake_configs)
+            qt_get_install_target_default_args(
+                OUT_VAR unused_install_targets_default_args
+                OUT_VAR_RUNTIME runtime_install_destination
+                RUNTIME "${arg_INSTALL_DIR}"
+                CMAKE_CONFIG "${cmake_config}"
+                ALL_CMAKE_CONFIGS ${cmake_configs})
+
+            _qt_internal_sbom_append_multi_config_aware_single_arg_option(
+                RUNTIME_PATH
+                "${runtime_install_destination}"
+                "${cmake_config}"
+                sbom_args
+            )
+        endforeach()
+
+        _qt_internal_forward_function_args(
+            FORWARD_APPEND
+            FORWARD_PREFIX arg
+            FORWARD_OUT_VAR sbom_args
+            FORWARD_OPTIONS
+                NO_INSTALL
+                ${__qt_internal_sbom_optional_args}
+            FORWARD_SINGLE
+                ${__qt_internal_sbom_single_args}
+            FORWARD_MULTI
+                ${__qt_internal_sbom_multi_args}
+        )
+
+        _qt_internal_extend_sbom(${target} ${sbom_args})
+    endif()
+
     qt_add_list_file_finalizer(qt_internal_finalize_app ${target})
 endfunction()
 
@@ -143,4 +197,5 @@ function(qt_internal_finalize_app target)
     # set after a qt_internal_add_app call.
     qt_apply_rpaths(TARGET "${target}" INSTALL_PATH "${INSTALL_BINDIR}" RELATIVE_RPATH)
     qt_internal_apply_staging_prefix_build_rpath_workaround()
+    _qt_internal_finalize_sbom(${target})
 endfunction()

cmake/QtAutoDetectHelpers.cmake

@@ -333,6 +333,137 @@ function(qt_auto_detect_cyclic_toolchain)
     endif()
 endfunction()
 
+# Gets output of running 'uname -m', finding uname in path, and caching its location in QT_UNAME.
+# Usually returns an architecture string like 'arch64' or 'x86_64'.
+# Returns an empty string in case of an error.
+# Does not pierce Rosetta, so will not always return the actual physical architecture.
+# Usually that is based on the architecture of the parent process that invokes cmake.
+function(qt_internal_get_uname_m_output out_var)
+    # This caches by default.
+    find_program(QT_UNAME NAMES uname PATHS /bin /usr/bin /usr/local/bin)
+
+    execute_process(COMMAND ${QT_UNAME} -m
+        OUTPUT_VARIABLE output
+        RESULT_VARIABLE result
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        ERROR_QUIET)
+    if(result EQUAL 0)
+        set(value "${output}")
+    else()
+        set(value "")
+    endif()
+
+    set(${out_var} "${value}" PARENT_SCOPE)
+endfunction()
+
+# Sets out_var to TRUE if running on a host machine with an Apple silicon arm64 CPU.
+# This is TRUE even when running under Rosetta, aka it pierces Rosetta, unlike the result of
+# 'uname -m'.
+# Same as the logic in Modules/Platform/Darwin-Initialize.cmake
+# Or https://github.com/Homebrew/brew/pull/7995/files
+function(qt_internal_is_apple_physical_cpu_arm64 out_var)
+    execute_process(
+        COMMAND sysctl -q hw.optional.arm64
+        OUTPUT_VARIABLE sysctl_stdout
+        ERROR_VARIABLE sysctl_stderr
+        RESULT_VARIABLE sysctl_result)
+
+    if(sysctl_result EQUAL 0 AND sysctl_stdout MATCHES "hw.optional.arm64: 1")
+        set(value TRUE)
+    else()
+        set(value FALSE)
+    endif()
+
+    set(${out_var} "${value}" PARENT_SCOPE)
+endfunction()
+
+# Mirror CMake's logic of detecting the CMAKE_HOST_SYSTEM_PROCESSOR, including handling of Apple
+# silicon, before project() is actually called.
+# Honors whatever architecture Rosetta reports.
+# Similar to the code in Modules/CMakeDetermineSystem.cmake
+# and thus allows override via CMAKE_APPLE_SILICON_PROCESSOR.
+function(qt_internal_get_early_apple_host_system_arch out_var_processor)
+    # If we are running on Apple Silicon, honor CMAKE_APPLE_SILICON_PROCESSOR.
+    if(DEFINED CMAKE_APPLE_SILICON_PROCESSOR)
+        set(processor "${CMAKE_APPLE_SILICON_PROCESSOR}")
+    elseif(DEFINED ENV{CMAKE_APPLE_SILICON_PROCESSOR})
+        set(processor "$ENV{CMAKE_APPLE_SILICON_PROCESSOR}")
+    else()
+        set(processor "")
+    endif()
+
+    if(processor)
+        # Handle case when CMAKE_APPLE_SILICON_PROCESSOR is passed on an Intel x86_64 machine, in
+        # that case we unset the given value, instead relying on the output of 'uname -m'.
+        if(";${processor};" MATCHES "^;(arm64|x86_64);$")
+            qt_internal_is_apple_physical_cpu_arm64(is_arm64)
+            if(NOT is_arm64)
+                set(processor "")
+            endif()
+        endif()
+    endif()
+
+    if(processor)
+        set(output "${processor}")
+    else()
+        qt_internal_get_uname_m_output(output)
+    endif()
+
+    set(${out_var_processor} "${output}" PARENT_SCOPE)
+endfunction()
+
+# Detect whether the user intends to cross-compile to arm64 on an x86_64 macOS host, or vice versa,
+# based on the passed-in CMAKE_OSX_ARCHITECTURES and the real physical host architecture.
+#
+# CMake doesn't handle this properly by default, unless one explicitly passes
+# -DCMAKE_SYSTEM_NAME=Darwin, which people don't really know about and is somewhat unintuitive.
+#
+# If a cross-compilation is detected, a host Qt will be required for tools.
+function(qt_auto_detect_macos_single_arch_cross_compilation)
+    # Skip on non-Apple platforms.
+    if(NOT APPLE
+
+        # If CMAKE_SYSTEM_NAME is explicitly specified, it means CMake will implicitly
+        # do `set(CMAKE_CROSSCOMPILING TRUE)`, so we don't need to do anything extra.
+        OR CMAKE_SYSTEM_NAME OR CMAKE_CROSSCOMPILING
+
+        # Opt out just in case this breaks something
+        OR QT_NO_HANDLE_APPLE_SINGLE_ARCH_CROSS_COMPILING
+
+        # Exit early if check was previously done, so we don't need to do extra process calls.
+        OR QT_INTERNAL_MACOS_SINGLE_ARCH_CROSS_COMPILING_DETECTION_DONE)
+        return()
+    endif()
+
+    list(LENGTH CMAKE_OSX_ARCHITECTURES arch_count)
+
+    # We only consider cross-compilation the case where arch count is exactly 1.
+    if(NOT arch_count EQUAL 1)
+        return()
+    else()
+        set(target_arch "${CMAKE_OSX_ARCHITECTURES}")
+    endif()
+
+    qt_internal_get_early_apple_host_system_arch(host_arch)
+    if(NOT "${host_arch}" STREQUAL "${target_arch}" AND
+            NOT ("${host_arch}" STREQUAL "x86_64" AND "${target_arch}" STREQUAL "x86_64h"))
+        message(
+            STATUS "Detected implicit macOS cross-compilation. "
+            "Host arch: ${host_arch} Target arch: ${target_arch}. "
+            "Setting CMAKE_CROSSCOMPILING to TRUE."
+        )
+
+        # Setting these tells CMake we are cross-compiling. This gets set in the correct scope
+        # for top-level builds as well, because it is included via
+        # qt_internal_top_level_setup_autodetect -> include() -> qt_internal_setup_autodetect()
+        # all of which are macros that don't create a new scope.
+        set(CMAKE_SYSTEM_NAME "Darwin" PARENT_SCOPE)
+        set(CMAKE_CROSSCOMPILING "TRUE" PARENT_SCOPE)
+    endif()
+
+    set(QT_INTERNAL_MACOS_SINGLE_ARCH_CROSS_COMPILING_DETECTION_DONE TRUE CACHE BOOL "")
+endfunction()
+
 function(qt_auto_detect_pch)
     set(default_value "ON")
 
@@ -476,6 +607,7 @@ macro(qt_internal_setup_autodetect)
     qt_auto_detect_cyclic_toolchain()
     qt_auto_detect_cmake_config()
     qt_auto_detect_apple()
+    qt_auto_detect_macos_single_arch_cross_compilation()
     qt_auto_detect_android()
     qt_auto_detect_pch()
     qt_auto_detect_wasm()

cmake/QtBaseGlobalTargets.cmake

@@ -68,7 +68,7 @@ qt_internal_create_toolchain_file()
 ## Library to hold global features:
 ## These features are stored and accessed via Qt::GlobalConfig, but the
 ## files always lived in Qt::Core, so we keep it that way
-add_library(GlobalConfig INTERFACE)
+qt_internal_add_platform_internal_target(GlobalConfig)
 target_include_directories(GlobalConfig INTERFACE
     $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include>
     $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include/QtCore>
@@ -121,9 +121,8 @@ qt_generate_qmake_and_qtpaths_wrapper_for_target()
 # Depends on the global features being evaluated.
 qt_internal_create_wrapper_scripts()
 
-add_library(Qt::GlobalConfig ALIAS GlobalConfig)
 
-add_library(GlobalConfigPrivate INTERFACE)
+qt_internal_add_platform_internal_target(GlobalConfigPrivate)
 target_link_libraries(GlobalConfigPrivate INTERFACE GlobalConfig)
 target_include_directories(GlobalConfigPrivate INTERFACE
     $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include/QtCore/${PROJECT_VERSION}>
@@ -131,8 +130,6 @@ target_include_directories(GlobalConfigPrivate INTERFACE
     $<INSTALL_INTERFACE:${INSTALL_INCLUDEDIR}/QtCore/${PROJECT_VERSION}>
     $<INSTALL_INTERFACE:${INSTALL_INCLUDEDIR}/QtCore/${PROJECT_VERSION}/QtCore>
 )
-add_library(Qt::GlobalConfigPrivate ALIAS GlobalConfigPrivate)
-add_library(${QT_CMAKE_EXPORT_NAMESPACE}::GlobalConfigPrivate ALIAS GlobalConfigPrivate)
 
 qt_internal_setup_public_platform_target()
 

cmake/QtBaseHelpers.cmake

@@ -166,6 +166,22 @@ macro(qt_internal_qtbase_build_repo)
         ## Build System tests:
         include(QtBaseCMakeTesting)
 
+        ## Include CoreMacros() for qt6_generate_meta_types()
+        ## Also needed for the QtBaseGlobalTargets creation.
+        set(QT_DEFAULT_MAJOR_VERSION 6)
+        include(src/corelib/Qt6CoreMacros.cmake)
+
+        # Needed when building qtbase for android.
+        if(ANDROID)
+            include(src/corelib/Qt6AndroidMacros.cmake)
+        endif()
+
+        # Needed when building for WebAssembly.
+        if(WASM)
+            include(cmake/QtWasmHelpers.cmake)
+            include(src/corelib/Qt6WasmMacros.cmake)
+        endif()
+
         ## Targets for global features, etc.:
         include(QtBaseGlobalTargets)
 
@@ -173,20 +189,11 @@ macro(qt_internal_qtbase_build_repo)
         ## feature variables are available.
         qt_set_language_standards()
 
-        #include CoreMacros() for qt6_generate_meta_types()
-        set(QT_DEFAULT_MAJOR_VERSION 6)
-        include(src/corelib/Qt6CoreMacros.cmake)
-
-        # Needed when building qtbase for android.
         if(ANDROID)
-            include(src/corelib/Qt6AndroidMacros.cmake)
             _qt_internal_create_global_android_targets()
         endif()
 
         if(WASM)
-            # Needed when building for WebAssembly.
-            include(cmake/QtWasmHelpers.cmake)
-            include(src/corelib/Qt6WasmMacros.cmake)
             qt_internal_setup_wasm_target_properties(Platform)
         endif()
 
@@ -205,7 +212,7 @@ macro(qt_internal_qtbase_build_repo)
     endif()
 
     if(NOT QT_INTERNAL_BUILD_STANDALONE_PARTS)
-        if(QT_WILL_BUILD_TOOLS AND QT_FEATURE_settings)
+        if(QT_FEATURE_settings)
             add_subdirectory(qmake)
         endif()
 

cmake/QtBuildHelpers.cmake

@@ -71,6 +71,10 @@ macro(qt_internal_include_qt_platform_android)
     endif()
 endmacro()
 
+macro(qt_internal_include_qt_properties)
+    include(QtProperties)
+endmacro()
+
 macro(qt_internal_set_compiler_optimization_flags)
     include(QtCompilerOptimization)
 endmacro()
@@ -192,10 +196,12 @@ function(qt_internal_get_qt_build_private_helpers out_var)
         QtPrecompiledHeadersHelpers
         QtPriHelpers
         QtPrlHelpers
+        QtProperties
         QtQmakeHelpers
         QtResourceHelpers
         QtRpathHelpers
         QtSanitizerHelpers
+        QtSbomHelpers
         QtScopeFinalizerHelpers
         QtSeparateDebugInfo
         QtSimdHelpers
@@ -278,7 +284,10 @@ function(qt_internal_get_qt_build_public_helpers out_var)
         QtPublicExternalProjectHelpers
         QtPublicFinalizerHelpers
         QtPublicFindPackageHelpers
+        QtPublicGitHelpers
         QtPublicPluginHelpers
+        QtPublicSbomGenerationHelpers
+        QtPublicSbomHelpers
         QtPublicTargetHelpers
         QtPublicTestHelpers
         QtPublicToolHelpers
@@ -417,6 +426,8 @@ macro(qt_internal_setup_build_and_global_variables)
 
     qt_internal_include_qt_platform_android()
 
+    qt_internal_include_qt_properties()
+
     # Depends on qt_internal_setup_default_install_prefix
     qt_internal_setup_paths_and_prefixes()
 

cmake/QtBuildInternals/QtStandaloneTestTemplateProject/Main.cmake

@@ -3,7 +3,16 @@
 
 # Includes QtSetup and friends for private CMake API.
 set(QT_INTERNAL_IS_STANDALONE_TEST TRUE)
+
+# Checks minimum CMake version and upgrades policies.
 qt_internal_project_setup()
+
+# Look for the Qt6 package before trying to call qt_build_internals_set_up_private_api,
+# otherwise it will fail when using a cross-compiled Qt, because QT_HOST_PATH will not be set.
+# QT_HOST_PATH is set by Qt6Dependencies.cmake.
+find_package(Qt6 REQUIRED)
+
+# Includes QtSetup.cmake.
 qt_build_internals_set_up_private_api()
 
 # Find all StandaloneTestsConfig.cmake files, and include them

cmake/QtBuildPathsHelpers.cmake

@@ -116,35 +116,42 @@ function(qt_configure_process_path name default docstring)
     endif()
 
     # No value provided, set the default.
+    # Make sure to process the paths even for the defaults to ensure we have canonicalized paths
+    # on the first configure run and thus don't regenerate qconfig.cpp on a subsequent
+    # configure run when the paths might become different if we didn't do it on first run.
+    # e.g. './plugins' would get turned to 'plugins'.
     if(NOT DEFINED "${name}")
-        set("${name}" "${default}" CACHE STRING "${docstring}")
-    else()
-        get_filename_component(given_path_as_abs "${${name}}" ABSOLUTE BASE_DIR
-                               "${CMAKE_INSTALL_PREFIX}")
-        file(RELATIVE_PATH rel_path "${CMAKE_INSTALL_PREFIX}"
-                                    "${given_path_as_abs}")
-
-        # If absolute path given, check that it's inside the prefix (error out if not).
-        # TODO: Figure out if we need to support paths that are outside the prefix.
-        #
-        # If relative path given, it's relative to the install prefix (rather than the binary dir,
-        # which is what qmake does for some reason).
-        # In both cases, store the value as a relative path.
-        if("${rel_path}" STREQUAL "")
-            # file(RELATIVE_PATH) returns an empty string if the given absolute paths are equal
-            set(rel_path ".")
-        elseif(rel_path MATCHES "^\.\./")
-            # INSTALL_SYSCONFDIR is allowed to be outside the prefix.
-            if(NOT name STREQUAL "INSTALL_SYSCONFDIR")
-                message(FATAL_ERROR
-                    "Path component '${name}' is outside computed install prefix: ${rel_path} ")
-                return()
-            endif()
-            set("${name}" "${${name}}" CACHE STRING "${docstring}" FORCE)
-        else()
-            set("${name}" "${rel_path}" CACHE STRING "${docstring}" FORCE)
-        endif()
+        set("${name}" "${default}")
     endif()
+
+    get_filename_component(given_path_as_abs "${${name}}" ABSOLUTE BASE_DIR
+                           "${CMAKE_INSTALL_PREFIX}")
+    file(RELATIVE_PATH rel_path "${CMAKE_INSTALL_PREFIX}"
+                                "${given_path_as_abs}")
+
+    # If absolute path given, check that it's inside the prefix (error out if not).
+    # If relative path given, it's relative to the install prefix (rather than the binary dir,
+    # which is what qmake does for some reason).
+    # In both cases, store the value as a relative path, unless we're processing INSTALL_SYSCONFDIR
+    # which should stay abslute.
+    if("${rel_path}" STREQUAL "")
+        # file(RELATIVE_PATH) returns an empty string if the given absolute paths are equal,
+        # so manually set it to '.'
+        set(new_value ".")
+    elseif(rel_path MATCHES "^\.\./")
+        # INSTALL_SYSCONFDIR is allowed to be outside the prefix.
+        if(NOT name STREQUAL "INSTALL_SYSCONFDIR")
+            message(FATAL_ERROR
+                "Path component '${name}' is outside computed install prefix: ${rel_path} ")
+        endif()
+        # Keep the absolute path.
+        set(new_value "${${name}}")
+    else()
+        # Use the canonicalized path.
+        set(new_value "${rel_path}")
+    endif()
+
+    set("${name}" "${new_value}" CACHE STRING "${docstring}" FORCE)
 endfunction()
 
 macro(qt_internal_setup_configure_install_paths)
@@ -193,6 +200,8 @@ macro(qt_internal_setup_configure_install_paths)
     qt_configure_process_path(INSTALL_DESCRIPTIONSDIR
                              "${INSTALL_ARCHDATADIR}/modules"
                               "Module description files directory")
+    qt_configure_process_path(INSTALL_SBOMDIR "${INSTALL_ARCHDATADIR}/sbom"
+        "SBOM [PREFIX/sbom]")
 endmacro()
 
 macro(qt_internal_set_cmake_install_libdir)

cmake/QtBuildRepoExamplesHelpers.cmake

@@ -28,6 +28,8 @@ macro(qt_examples_build_begin)
         qt_internal_find_standalone_parts_config_files()
     endif()
 
+    string(TOLOWER ${PROJECT_NAME} project_name_lower)
+
     if(arg_EXTERNAL_BUILD AND QT_BUILD_EXAMPLES_AS_EXTERNAL)
         # Examples will be built using ExternalProject.
         # We depend on all plugins built as part of the current repo as well as current repo's
@@ -50,7 +52,6 @@ macro(qt_examples_build_begin)
 
         set(QT_IS_EXTERNAL_EXAMPLES_BUILD TRUE)
 
-        string(TOLOWER ${PROJECT_NAME} project_name_lower)
         if(NOT TARGET examples)
             if(QT_BUILD_EXAMPLES_BY_DEFAULT)
                 add_custom_target(examples ALL)
@@ -120,6 +121,28 @@ macro(qt_examples_build_begin)
 # files are installed into the original install prefix.
 set(_qt_internal_examples_cmake_install_prefix_backup \"\${CMAKE_INSTALL_PREFIX}\")
 ")
+
+    # Backup the DESTDIR and unset it, so that example installation is not affected by DESTDIR.
+    # This is activated by our CI when QT_INTERNAL_EXAMPLES_INSTALL_PREFIX is set.
+    if(QT_INTERNAL_EXAMPLES_INSTALL_PREFIX)
+        set(_qt_examples_should_unset_destdir TRUE)
+    else()
+        set(_qt_examples_should_unset_destdir FALSE)
+    endif()
+
+    set_property(GLOBAL PROPERTY
+        _qt_examples_should_unset_destdir_${project_name_lower}
+        "${_qt_examples_should_unset_destdir}")
+    if(_qt_examples_should_unset_destdir)
+        install(CODE "
+    # Temporarily unset DESTDIR while examples are being installed.
+    set(_qt_internal_examples_destdir_backup \"\$ENV{DESTDIR}\")
+    unset(ENV{DESTDIR})
+")
+    endif()
+
+    unset(_qt_examples_should_unset_destdir)
+    unset(project_name_lower)
 endmacro()
 
 macro(qt_examples_build_end)
@@ -145,6 +168,21 @@ set(CMAKE_INSTALL_PREFIX \"\${_qt_internal_examples_cmake_install_prefix_backup}
 ")
 
     set(CMAKE_UNITY_BUILD ${QT_UNITY_BUILD})
+
+    string(TOLOWER ${PROJECT_NAME} project_name_lower)
+    get_property(_qt_examples_should_unset_destdir
+        GLOBAL PROPERTY _qt_examples_should_unset_destdir_${project_name_lower})
+
+    if(_qt_examples_should_unset_destdir)
+        install(CODE "
+    # Restore the DESTDIR env var after examples have been installed.
+    set(ENV{DESTDIR} \"\${_qt_internal_examples_destdir_backup}\")
+    unset(_qt_internal_examples_destdir_backup)
+")
+    endif()
+
+    unset(_qt_examples_should_unset_destdir)
+    unset(project_name_lower)
 endmacro()
 
 # Allows building an example either as an ExternalProject or in-tree with the Qt build.
@@ -345,7 +383,7 @@ function(qt_internal_add_example_external_project subdir)
     list(TRANSFORM glob_prefixes APPEND "/${INSTALL_LIBDIR}/cmake/${QT_CMAKE_EXPORT_NAMESPACE}Qml")
 
     set(qml_plugin_cmake_config_file_glob_prefixes "")
-    foreach(glob_prefix IN LISTS glob_prefix)
+    foreach(glob_prefix IN LISTS glob_prefixes)
         if(EXISTS "${glob_prefix}")
             list(APPEND qml_plugin_cmake_config_file_glob_prefixes "${glob_prefix}")
         endif()

cmake/QtBuildRepoHelpers.cmake

@@ -11,7 +11,6 @@ macro(qt_internal_project_setup)
     # Check for the minimum CMake version.
     qt_internal_require_suitable_cmake_version()
     qt_internal_upgrade_cmake_policies()
-    qt_internal_promote_platform_targets_to_global()
 endmacro()
 
 macro(qt_build_internals_set_up_private_api)
@@ -252,6 +251,7 @@ macro(qt_build_repo_begin)
 
     qt_internal_read_repo_dependencies(qt_repo_deps "${PROJECT_SOURCE_DIR}")
     if(qt_repo_deps)
+        set_property(GLOBAL PROPERTY _qt_repo_deps_${project_name_lower} ${qt_repo_deps})
         foreach(qt_repo_dep IN LISTS qt_repo_deps)
             if(TARGET qt_plugins_${qt_repo_dep})
                 message(DEBUG
@@ -308,6 +308,12 @@ macro(qt_build_repo_begin)
     if(QT_INTERNAL_SYNCED_MODULES)
         set_property(GLOBAL PROPERTY _qt_synced_modules ${QT_INTERNAL_SYNCED_MODULES})
     endif()
+
+    _qt_internal_sbom_begin_project(
+        INSTALL_PREFIX "${QT_STAGING_PREFIX}"
+        INSTALL_SBOM_DIR "${INSTALL_SBOMDIR}"
+        QT_CPE
+    )
 endmacro()
 
 # Runs delayed actions on some of the Qt targets.
@@ -371,6 +377,8 @@ macro(qt_build_repo_end)
         set(QT_INTERNAL_FRESH_REQUESTED "FALSE" CACHE INTERNAL "")
     endif()
 
+    _qt_internal_sbom_end_project()
+
     if(NOT QT_SUPERBUILD)
         qt_internal_qt_configure_end()
     endif()
@@ -556,14 +564,17 @@ macro(qt_build_repo_impl_tests)
             message(FATAL_ERROR
                 "Can't build both standalone tests and standalone examples at once.")
         endif()
-        option(QT_BUILD_TESTS_PROJECT_${PROJECT_NAME} "Configure tests for project ${PROJECT_NAME}" TRUE)
+        string(TOLOWER "${PROJECT_NAME}" __qt_repo_project_name_lowercase)
+        option(QT_BUILD_TESTS_PROJECT_${__qt_repo_project_name_lowercase}
+            "Configure tests for project ${__qt_repo_project_name_lowercase}" TRUE)
 
-        if (QT_BUILD_TESTS_PROJECT_${PROJECT_NAME})
+        if (QT_BUILD_TESTS_PROJECT_${__qt_repo_project_name_lowercase})
             add_subdirectory(tests)
             if(NOT QT_BUILD_TESTS_BY_DEFAULT)
                 set_property(DIRECTORY tests PROPERTY EXCLUDE_FROM_ALL TRUE)
             endif()
         endif()
+        unset(__qt_repo_project_name_lowercase)
     endif()
 endmacro()
 
@@ -577,8 +588,10 @@ macro(qt_build_repo_impl_examples)
 
         message(STATUS "Configuring examples.")
 
-        option(QT_BUILD_EXAMPLES_PROJECT_${PROJECT_NAME} "Configure examples for project ${PROJECT_NAME}" TRUE)
-        if(QT_BUILD_EXAMPLES_PROJECT_${PROJECT_NAME})
+        string(TOLOWER "${PROJECT_NAME}" __qt_repo_project_name_lowercase)
+        option(QT_BUILD_EXAMPLES_PROJECT_${__qt_repo_project_name_lowercase}
+            "Configure examples for project ${__qt_repo_project_name_lowercase}" TRUE)
+        if(QT_BUILD_EXAMPLES_PROJECT_${__qt_repo_project_name_lowercase})
 
             # Set this before any examples subdirectories are added, to warn about examples that are
             # added via add_subdirectory() calls instead of qt_internal_add_example().
@@ -589,6 +602,7 @@ macro(qt_build_repo_impl_examples)
 
             add_subdirectory(examples)
         endif()
+        unset(__qt_repo_project_name_lowercase)
     endif()
 endmacro()
 

cmake/QtConfigDependencies.cmake.in

@@ -3,7 +3,13 @@
 
 set(@INSTALL_CMAKE_NAMESPACE@_FOUND FALSE)
 
-set(__qt_platform_requires_host_info_package "@platform_requires_host_info_package@")
+if(DEFINED QT_REQUIRE_HOST_PATH_CHECK)
+    set(__qt_platform_requires_host_info_package "${QT_REQUIRE_HOST_PATH_CHECK}")
+elseif(DEFINED ENV{QT_REQUIRE_HOST_PATH_CHECK})
+    set(__qt_platform_requires_host_info_package "$ENV{QT_REQUIRE_HOST_PATH_CHECK}")
+else()
+    set(__qt_platform_requires_host_info_package "@platform_requires_host_info_package@")
+endif()
 set(__qt_platform_initial_qt_host_path "@qt_host_path_absolute@")
 set(__qt_platform_initial_qt_host_path_cmake_dir "@qt_host_path_cmake_dir_absolute@")
 
@@ -15,7 +21,7 @@ _qt_internal_find_host_info_package(${__qt_platform_requires_host_info_package})
 
 # note: _third_party_deps example: "ICU\\;FALSE\\;1.0\\;i18n uc data;ZLIB\\;FALSE\\;\\;"
 set(__qt_third_party_deps "@third_party_deps@")
-
+@third_party_deps_extra_info@
 @third_party_extra@
 
 # Don't propagate REQUIRED so we don't immediately FATAL_ERROR, rather let the find_dependency calls

cmake/QtExecutableHelpers.cmake

@@ -34,6 +34,9 @@ function(qt_internal_add_executable name)
     if(ANDROID)
         _qt_internal_android_executable_finalizer(${name})
     endif()
+    if(WASM)
+        qt_internal_wasm_add_finalizers(${name})
+    endif()
 
     if(arg_QT_APP AND QT_FEATURE_debug_and_release AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.19.0")
         set_property(TARGET "${name}"
@@ -148,10 +151,6 @@ function(qt_internal_add_executable name)
 
     qt_internal_set_exceptions_flags("${name}" ${arg_EXCEPTIONS})
 
-    if(WASM)
-        qt_internal_wasm_add_finalizers("${name}")
-    endif()
-
     # Check if target needs to be excluded from all target. Also affects qt_install.
     # Set by qt_exclude_tool_directories_from_default_target.
     set(exclude_from_all FALSE)
@@ -160,7 +159,10 @@ function(qt_internal_add_executable name)
             string(FIND "${CMAKE_CURRENT_SOURCE_DIR}" "${absolute_dir}" dir_starting_pos)
             if(dir_starting_pos EQUAL 0)
                 set(exclude_from_all TRUE)
-                set_target_properties("${name}" PROPERTIES EXCLUDE_FROM_ALL TRUE)
+                set_target_properties("${name}" PROPERTIES
+                    EXCLUDE_FROM_ALL TRUE
+                    _qt_internal_excluded_from_default_target TRUE
+                )
                 break()
             endif()
         endforeach()
@@ -207,6 +209,23 @@ function(qt_internal_add_executable name)
                                       ADDITIONAL_INSTALL_ARGS ${additional_install_args})
         qt_internal_install_pdb_files(${name} "${arg_INSTALL_DIRECTORY}")
     endif()
+
+    if(QT_GENERATE_SBOM)
+        set(sbom_args "")
+        _qt_internal_forward_function_args(
+            FORWARD_APPEND
+            FORWARD_PREFIX arg
+            FORWARD_OUT_VAR sbom_args
+            FORWARD_OPTIONS
+                ${__qt_internal_sbom_optional_args}
+            FORWARD_SINGLE
+                ${__qt_internal_sbom_single_args}
+            FORWARD_MULTI
+                ${__qt_internal_sbom_multi_args}
+        )
+
+        _qt_internal_extend_sbom(${name} ${sbom_args})
+    endif()
 endfunction()
 
 # This function compiles the target at configure time the very first time and creates the custom

cmake/QtFeature.cmake

@@ -401,7 +401,9 @@ function(qt_evaluate_feature feature)
     qt_evaluate_config_expression(auto_detect ${arg_AUTODETECT})
     if(${disable_result})
         set(computed OFF)
-    elseif((${enable_result}) OR (${auto_detect}))
+    elseif(${enable_result})
+        set(computed ON)
+    elseif(${auto_detect})
         set(computed ${condition})
     else()
         # feature not auto-detected and not explicitly enabled

cmake/QtFindPackageHelpers.cmake

@@ -1,21 +1,6 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: BSD-3-Clause
 
-# This function recursively walks transitive link libraries of the given target
-# and promotes those targets to be IMPORTED_GLOBAL if they are not.
-#
-# This is required for .prl file generation in top-level builds, to make sure that imported 3rd
-# party library targets in any repo are made global, so there are no scoping issues.
-#
-# Only works if called from qt_find_package(), because the promotion needs to happen in the same
-# directory scope where the imported target is first created.
-#
-# Uses __qt_internal_walk_libs.
-function(qt_find_package_promote_targets_to_global_scope target)
-    __qt_internal_walk_libs("${target}" _discarded_out_var _discarded_out_var_2
-                            "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
@@ -182,6 +167,19 @@ macro(qt_find_package)
                     set(qt_find_package_target_name ${aliased_target})
                 endif()
 
+                if("${qt_find_package_target_name}" MATCHES "${QT_CMAKE_EXPORT_NAMESPACE}::"
+                    AND QT_FEATURE_developer_build
+                )
+                    message(AUTHOR_WARNING
+                        "qt_find_package() should NOT be used to look up Qt packages. "
+                        "It should only be used to look up 3rd party packages. "
+                        "Please remove the "
+                        "qt_find_package(${ARGV0} PROVIDED_TARGETS "
+                        "${qt_find_package_target_name}) call and contact the build tools team "
+                        "in case the removal is causing issues."
+                    )
+                endif()
+
                 set_target_properties(${qt_find_package_target_name} PROPERTIES
                     INTERFACE_QT_PACKAGE_NAME ${ARGV0}
                     INTERFACE_QT_PACKAGE_IS_OPTIONAL ${arg_MARK_OPTIONAL})
@@ -224,27 +222,43 @@ macro(qt_find_package)
                     )
                 endif()
 
-                get_property(is_global TARGET ${qt_find_package_target_name} PROPERTY
-                                                                             IMPORTED_GLOBAL)
-                qt_internal_should_not_promote_package_target_to_global(
-                    "${qt_find_package_target_name}" should_not_promote)
-                if(NOT is_global AND NOT should_not_promote)
-                    __qt_internal_promote_target_to_global(${qt_find_package_target_name})
-                    qt_find_package_promote_targets_to_global_scope(
-                        "${qt_find_package_target_name}")
+                _qt_internal_promote_3rd_party_provided_target_and_3rd_party_deps_to_global(
+                    "${qt_find_package_target_name}")
+
+                set(_qt_find_package_sbom_args "")
+
+                if(_qt_find_package_found_version)
+                    list(APPEND _qt_find_package_sbom_args
+                        PACKAGE_VERSION "${_qt_find_package_found_version}"
+                    )
+                endif()
+
+                # Work around: QTBUG-125371
+                if(NOT "${ARGV0}" STREQUAL "Qt6")
+                    _qt_internal_sbom_record_system_library_usage(
+                        "${qt_find_package_target_name}"
+                        TYPE SYSTEM_LIBRARY
+                        FRIENDLY_PACKAGE_NAME "${ARGV0}"
+                        ${_qt_find_package_sbom_args}
+                    )
                 endif()
             endif()
-
         endforeach()
 
         if(arg_MODULE_NAME AND arg_QMAKE_LIB
            AND (NOT arg_QMAKE_LIB IN_LIST QT_QMAKE_LIBS_FOR_${arg_MODULE_NAME}))
             set(QT_QMAKE_LIBS_FOR_${arg_MODULE_NAME}
                 ${QT_QMAKE_LIBS_FOR_${arg_MODULE_NAME}};${arg_QMAKE_LIB} CACHE INTERNAL "")
-            set(QT_TARGETS_OF_QMAKE_LIB_${arg_QMAKE_LIB} ${arg_PROVIDED_TARGETS} CACHE INTERNAL "")
+            set(${arg_QMAKE_LIB}_existing_targets "")
             foreach(provided_target ${arg_PROVIDED_TARGETS})
-                set(QT_QMAKE_LIB_OF_TARGET_${provided_target} ${arg_QMAKE_LIB} CACHE INTERNAL "")
+                if(TARGET ${provided_target})
+                    list(APPEND ${arg_QMAKE_LIB}_existing_targets "${provided_target}")
+                    set(QT_QMAKE_LIB_OF_TARGET_${provided_target}
+                        ${arg_QMAKE_LIB} CACHE INTERNAL "")
+                endif()
             endforeach()
+            set(QT_TARGETS_OF_QMAKE_LIB_${arg_QMAKE_LIB}
+                "${${arg_QMAKE_LIB}_existing_targets}" CACHE INTERNAL "")
         endif()
     endif()
 endmacro()
@@ -635,9 +649,3 @@ function(qt_register_target_dependencies target public_libs private_libs)
 
     set_target_properties("${target}" PROPERTIES _qt_target_deps "${target_deps}")
 endfunction()
-
-# Sets out_var to to TRUE if the target was marked to not be promoted to global scope.
-function(qt_internal_should_not_promote_package_target_to_global target out_var)
-    get_property(should_not_promote TARGET "${target}" PROPERTY _qt_no_promote_global)
-    set("${out_var}" "${should_not_promote}" PARENT_SCOPE)
-endfunction()

cmake/QtFindWrapHelper.cmake

@@ -102,8 +102,11 @@ macro(qt_find_package_system_or_bundled _unique_prefix)
         endif()
 
         if(_qfwrap_${_unique_prefix}_package_version)
+            set(Wrap${_qfwrap_${_unique_prefix}_FRIENDLY_PACKAGE_NAME}_VERSION
+                "${_qfwrap_${_unique_prefix}_package_version}"
+            )
             set(_qfwrap_${_unique_prefix}_package_version_option
-                VERSION_VAR "_qfwrap_${_unique_prefix}_package_version"
+                VERSION_VAR "Wrap${_qfwrap_${_unique_prefix}_FRIENDLY_PACKAGE_NAME}_VERSION"
             )
         endif()
 

cmake/QtFinishPrlFile.cmake

@@ -27,6 +27,7 @@
 # IMPLICIT_LINK_DIRECTORIES: list of implicit linker search paths
 
 cmake_policy(SET CMP0007 NEW)
+cmake_policy(SET CMP0057 NEW)
 include("${CMAKE_CURRENT_LIST_DIR}/QtGenerateLibHelpers.cmake")
 
 file(STRINGS "${IN_FILE}" lines)
@@ -50,10 +51,14 @@ foreach(line ${lines})
                 qt_internal_path_is_relative_to_qt_lib_path(
                     "${lib}" "${QT_LIB_DIRS}" lib_is_a_qt_module relative_lib)
                 if(NOT lib_is_a_qt_module)
-                    # It's not a Qt module, extract the library name and prepend an -l to make
-                    # it relocatable.
+                    # It's not a Qt module, extract linker flags from the library path.
                     qt_transform_absolute_library_paths_to_link_flags(lib_with_link_flag "${lib}")
-                    list(APPEND adjusted_libs "${lib_with_link_flag}")
+                    foreach(flag ${lib_with_link_flag})
+                        # Linker flags started with "-L" shouldn't be added duplicately.
+                        if(NOT flag MATCHES "^-L" OR NOT flag IN_LIST adjusted_libs)
+                            list(APPEND adjusted_libs "${flag}")
+                        endif()
+                    endforeach()
                 else()
                     # Is a Qt module.
                     # Transform Qt framework paths into -framework flags.

cmake/QtFlagHandlingHelpers.cmake

@@ -87,6 +87,12 @@ function(qt_internal_add_linker_version_script target)
 
         get_target_property(target_type ${target} TYPE)
         if(NOT target_type STREQUAL "INTERFACE_LIBRARY")
+            # Export all specializations of the QExplicitlySharedDataPointer
+            # and QSharedDataPointer destructors; due to use of the
+            # QT_DECLARE_Q{,E}SDP_SPECIALIZATION_DTOR_WITH_EXPORT macros
+            string(APPEND contents "\n    _ZN*18QSharedDataPointerI*D?Ev;")
+            string(APPEND contents "\n    _ZN*28QExplicitlySharedDataPointerI*D?Ev;")
+
             set(genex_prefix "\n    ")
             set(genex_glue "$<SEMICOLON>\n    ")
             set(genex_suffix "$<SEMICOLON>")
@@ -235,6 +241,7 @@ function(qt_internal_apply_gc_binaries target visibility)
     endif()
 endfunction()
 
+# Only applied to Bootstrap and BundledPCRE2.
 function(qt_internal_apply_intel_cet target visibility)
     if(NOT QT_FEATURE_intelcet)
         return()
@@ -254,10 +261,36 @@ function(qt_internal_apply_intel_cet target visibility)
             ">:-mshstk>")
     endif()
     if(flags)
+        set(opt_out_condition "$<NOT:$<BOOL:$<TARGET_PROPERTY:_qt_no_intel_cet_harderning>>>")
+        set(flags "$<${opt_out_condition}:${flags}>")
         target_compile_options("${target}" ${visibility} "${flags}")
     endif()
 endfunction()
 
+# Meant to be applied to PlatformCommonInternal.
+function(qt_internal_apply_intel_cet_harderning target)
+    if(NOT QT_FEATURE_intelcet)
+        return()
+    endif()
+
+    set(opt_out_condition "$<NOT:$<BOOL:$<TARGET_PROPERTY:_qt_no_intel_cet_harderning>>>")
+
+    if(MSVC)
+        set(intel_cet_flag "-CETCOMPAT")
+        set(condition "$<${opt_out_condition}:${intel_cet_flag}>")
+        qt_internal_platform_link_options("${target}" INTERFACE "${condition}")
+    else()
+        set(intel_cet_flag "-fcf-protection=full")
+        set(condition "$<${opt_out_condition}:${intel_cet_flag}>")
+        target_compile_options("${target}" INTERFACE "${condition}")
+    endif()
+endfunction()
+
+# Allow opting out of the Intel CET hardening on a per-target basis.
+function(qt_internal_skip_intel_cet_hardening target)
+    set_target_properties("${target}" PROPERTIES _qt_no_intel_cet_harderning TRUE)
+endfunction()
+
 # Sets the exceptions flags for the given target according to exceptions_on
 function(qt_internal_set_exceptions_flags target exceptions_on)
     set(_defs "")

cmake/QtFrameworkHelpers.cmake

@@ -117,18 +117,32 @@ function(qt_copy_framework_headers target)
         "${output_dir}/${fw_versioned_header_dir}"
     )
 
+    set(copy_fw_sync_headers_marker_file
+        "${CMAKE_CURRENT_BINARY_DIR}/${target}_fw_sync_headers_marker_file"
+    )
+
+    set(copy_fw_sync_headers_marker_file_command
+        "${CMAKE_COMMAND}" -E touch "${copy_fw_sync_headers_marker_file}"
+    )
+
     if(CMAKE_GENERATOR MATCHES "^Ninja")
         add_custom_command(
-            OUTPUT "${output_dir}/${fw_versioned_header_dir}"
+            OUTPUT
+                "${output_dir}/${fw_versioned_header_dir}"
+                "${copy_fw_sync_headers_marker_file}"
             DEPENDS ${target}_sync_headers
             COMMAND ${copy_fw_sync_headers_command}
+            COMMAND ${copy_fw_sync_headers_marker_file_command}
             VERBATIM
         )
         add_custom_target(${target}_copy_fw_sync_headers
             DEPENDS "${output_dir}/${fw_versioned_header_dir}")
     else()
         add_custom_target(${target}_copy_fw_sync_headers
-            COMMAND ${copy_fw_sync_headers_command})
+            COMMAND ${copy_fw_sync_headers_command}
+            COMMAND ${copy_fw_sync_headers_marker_file_command}
+            DEPENDS ${target}_sync_headers
+        )
     endif()
 
     if(out_files)

cmake/QtGenerateLibHelpers.cmake

@@ -1,14 +1,19 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: BSD-3-Clause
 
-# Given "/usr/lib/x86_64-linux-gnu/libcups.so"
-# Returns "cups" or an empty string if the file is not an absolute library path.
-# Aka it strips the "lib" prefix, the .so extension and the base path.
+# Given "/usr/lib/x86_64-linux-gnu/libcups.so", returns "cups".
+# Given "libavcodec.a", returns "avcodec".
+# Given "ws2_32", returns "ws2_32".
+# Returns an empty string if not given a linkable library (most likely a linker flag).
 function(qt_get_library_name_without_prefix_and_suffix out_var file_path)
     set(out_value "")
-    if(IS_ABSOLUTE "${file_path}")
+    if(NOT file_path MATCHES "^-") # not a linker flag
         get_filename_component(basename "${file_path}" NAME_WE)
         get_filename_component(ext "${file_path}" EXT)
+        if(NOT ext) # seems like a library name without prefix and suffix
+            set(${out_var} "${file_path}" PARENT_SCOPE)
+            return()
+        endif()
         string(TOLOWER "${ext}" ext_lower)
         foreach(libsuffix ${LIBRARY_SUFFIXES})
             # Handle weird prefix extensions like in the case of
@@ -45,8 +50,10 @@ function(qt_get_library_name_without_prefix_and_suffix out_var file_path)
     set(${out_var} "${out_value}" PARENT_SCOPE)
 endfunction()
 
-# Given "/usr/lib/x86_64-linux-gnu/libcups.so"
-# Returns "-lcups" or an empty string if the file is not an absolute library path.
+# Given "/usr/lib/x86_64-linux-gnu/libcups.so", returns "-lcups".
+# Given "libavcodec.a", returns "-lavcodec".
+# Given "ws2_32", returns "-lws2_32".
+# Returns an empty string if not given a linkable library (most likely a linker flag).
 function(qt_get_library_with_link_flag out_var file_path)
     qt_get_library_name_without_prefix_and_suffix(lib_name "${file_path}")
 
@@ -70,11 +77,14 @@ function(qt_transform_absolute_library_paths_to_link_flags out_var library_path_
         if(lib_name_with_link_flag)
             string(TOLOWER "${IMPLICIT_LINK_DIRECTORIES}" IMPLICIT_LINK_DIRECTORIES_LOWER)
             get_filename_component(dir "${library_path}" DIRECTORY)
-            string(TOLOWER "${dir}" dir_lower)
-            # If library_path isn't in default link directories, we should add it to link flags.
-            list(FIND IMPLICIT_LINK_DIRECTORIES_LOWER "${dir_lower}" index)
-            if(${index} EQUAL -1)
-                list(APPEND out_list "-L\"${dir}\"")
+            if(dir)
+                string(TOLOWER "${dir}" dir_lower)
+                # If library_path isn't in default link directories, we should add it to link flags.
+                # But we shouldn't add it duplicately.
+                list(FIND IMPLICIT_LINK_DIRECTORIES_LOWER "${dir_lower}" index)
+                if(index EQUAL -1 AND NOT "-L\"${dir}\"" IN_LIST out_list)
+                    list(APPEND out_list "-L\"${dir}\"")
+                endif()
             endif()
             list(APPEND out_list "${lib_name_with_link_flag}")
         else()

cmake/QtInternalTargets.cmake

@@ -46,13 +46,11 @@ function(qt_internal_set_warnings_are_errors_flags target target_scope)
         endif()
 
         if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "11.0.0")
+            # Ditto
+            list(APPEND flags -Wno-error=stringop-overread)
+
             # We do mixed enum arithmetic all over the place:
             list(APPEND flags -Wno-error=deprecated-enum-enum-conversion -Wno-error=deprecated-enum-float-conversion)
-
-            # GCC has some false positive, and it specifically comes through in MINGW
-            if (MINGW)
-                list(APPEND flags -Wno-error=stringop-overread)
-            endif()
         endif()
 
         if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "11.0.0" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS "11.2.0")
@@ -135,29 +133,25 @@ function(qt_internal_add_global_definition definition)
     endif()
 endfunction()
 
-add_library(PlatformCommonInternal INTERFACE)
-qt_internal_add_target_aliases(PlatformCommonInternal)
+qt_internal_add_platform_internal_target(PlatformCommonInternal)
 target_link_libraries(PlatformCommonInternal INTERFACE Platform)
 
-add_library(PlatformModuleInternal INTERFACE)
-qt_internal_add_target_aliases(PlatformModuleInternal)
+qt_internal_add_platform_internal_target(PlatformModuleInternal)
 target_link_libraries(PlatformModuleInternal INTERFACE PlatformCommonInternal)
 
-add_library(PlatformPluginInternal INTERFACE)
-qt_internal_add_target_aliases(PlatformPluginInternal)
+qt_internal_add_platform_internal_target(PlatformPluginInternal)
 target_link_libraries(PlatformPluginInternal INTERFACE PlatformCommonInternal)
 
-add_library(PlatformAppInternal INTERFACE)
-qt_internal_add_target_aliases(PlatformAppInternal)
+qt_internal_add_platform_internal_target(PlatformAppInternal)
 target_link_libraries(PlatformAppInternal INTERFACE PlatformCommonInternal)
 
-add_library(PlatformToolInternal INTERFACE)
-qt_internal_add_target_aliases(PlatformToolInternal)
+qt_internal_add_platform_internal_target(PlatformToolInternal)
 target_link_libraries(PlatformToolInternal INTERFACE PlatformAppInternal)
 
 qt_internal_add_global_definition(QT_NO_JAVA_STYLE_ITERATORS)
 qt_internal_add_global_definition(QT_NO_QASCONST)
 qt_internal_add_global_definition(QT_NO_QEXCHANGE)
+qt_internal_add_global_definition(QT_NO_QSNPRINTF)
 qt_internal_add_global_definition(QT_NO_NARROWING_CONVERSIONS_IN_CONNECT)
 qt_internal_add_global_definition(QT_EXPLICIT_QFILE_CONSTRUCTION_FROM_PATH)
 qt_internal_add_global_definition(QT_USE_QSTRINGBUILDER SCOPE PLUGIN TOOL MODULE)
@@ -318,13 +312,8 @@ if (GCC AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "9.2")
 endif()
 
 # Hardening options
-if(QT_FEATURE_intelcet)
-    if(MSVC)
-        qt_internal_platform_link_options(PlatformCommonInternal INTERFACE -CETCOMPAT)
-    else()
-        target_compile_options(PlatformCommonInternal INTERFACE -fcf-protection=full)
-    endif()
-endif()
+
+qt_internal_apply_intel_cet_harderning(PlatformCommonInternal)
 
 if(QT_FEATURE_glibc_fortify_source)
     set(is_optimized_build "$<OR:$<NOT:$<CONFIG:Debug>>,$<BOOL:${QT_FEATURE_optimize_debug}>>")

cmake/QtMkspecHelpers.cmake

@@ -33,11 +33,13 @@ macro(qt_internal_setup_platform_definitions_and_mkspec)
                 set(QT_DEFAULT_MKSPEC win32-clang-g++)
             endif()
         elseif(MSVC)
-            if(CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64")
+            string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" cmake_system_processor_case_independent)
+            if(cmake_system_processor_case_independent STREQUAL "arm64")
                 set(QT_DEFAULT_MKSPEC win32-arm64-msvc)
             else()
                 set(QT_DEFAULT_MKSPEC win32-msvc)
             endif()
+            unset(cmake_system_processor_case_independent)
         elseif(MINGW)
             set(QT_DEFAULT_MKSPEC win32-g++)
             list(APPEND QT_DEFAULT_PLATFORM_DEFINITIONS MINGW_HAS_SECURE_API=1)

cmake/QtModuleConfig.cmake.in

@@ -58,7 +58,16 @@ if (NOT QT_NO_CREATE_TARGETS AND @INSTALL_CMAKE_NAMESPACE@@target@_FOUND)
     if(NOT @QT_CMAKE_EXPORT_NAMESPACE@@target@_DEFINITIONS)
         set(@QT_CMAKE_EXPORT_NAMESPACE@@target@_DEFINITIONS "")
     else()
-        list(TRANSFORM @QT_CMAKE_EXPORT_NAMESPACE@@target@_DEFINITIONS PREPEND "-D")
+        set(updated_defs "")
+        foreach(def IN LISTS  @QT_CMAKE_EXPORT_NAMESPACE@@target@_DEFINITIONS)
+             if(def MATCHES "^[A-Za-z_]")
+                 list(APPEND updated_defs "-D${def}")
+             else()
+                 list(APPEND updated_defs "${def}")
+             endif()
+        endforeach()
+        set(@QT_CMAKE_EXPORT_NAMESPACE@@target@_DEFINITIONS "${updated_defs}")
+        unset(updated_defs)
     endif()
 
     get_target_property(@QT_CMAKE_EXPORT_NAMESPACE@@target@_COMPILE_DEFINITIONS

cmake/QtModuleHelpers.cmake

@@ -16,9 +16,9 @@ macro(qt_internal_get_internal_add_module_keywords option_args single_args multi
         NO_ADDITIONAL_TARGET_INFO
         NO_GENERATE_METATYPES
         NO_HEADERSCLEAN_CHECK
-        GENERATE_CPP_EXPORTS # deprecated
         NO_GENERATE_CPP_EXPORTS
         NO_UNITY_BUILD
+        ${__qt_internal_sbom_optional_args}
     )
     set(${single_args}
         MODULE_INCLUDE_NAME
@@ -34,6 +34,7 @@ macro(qt_internal_get_internal_add_module_keywords option_args single_args multi
         SSG_HEADER_FILTERS
         HEADER_SYNC_SOURCE_DIRECTORY
         ${__default_target_info_args}
+        ${__qt_internal_sbom_single_args}
     )
     set(${multi_args}
         QMAKE_MODULE_CONFIG
@@ -44,6 +45,7 @@ macro(qt_internal_get_internal_add_module_keywords option_args single_args multi
         ${__default_private_args}
         ${__default_public_args}
         ${__default_private_module_args}
+        ${__qt_internal_sbom_multi_args}
     )
 endmacro()
 
@@ -236,6 +238,10 @@ function(qt_internal_add_module target)
         set_target_properties(${target} PROPERTIES _qt_is_internal_module TRUE)
         set_property(TARGET ${target} APPEND PROPERTY EXPORT_PROPERTIES _qt_is_internal_module)
     endif()
+    if(arg_HEADER_MODULE)
+        set_target_properties(${target} PROPERTIES _qt_is_header_module TRUE)
+        set_property(TARGET ${target} APPEND PROPERTY EXPORT_PROPERTIES _qt_is_header_module)
+    endif()
 
     if(NOT arg_CONFIG_MODULE_NAME)
         set(arg_CONFIG_MODULE_NAME "${module_lower}")
@@ -306,7 +312,6 @@ function(qt_internal_add_module target)
 
     qt_internal_add_target_aliases("${target}")
     qt_skip_warnings_are_errors_when_repo_unclean("${target}")
-    _qt_internal_apply_strict_cpp("${target}")
 
     # No need to compile Q_IMPORT_PLUGIN-containing files for non-executables.
     if(is_static_lib)
@@ -423,8 +428,7 @@ function(qt_internal_add_module target)
         # We should not generate export headers if module is defined as pure STATIC.
         # Static libraries don't need to export their symbols, and corner cases when sources are
         # also used in shared libraries, should be handled manually.
-        if((NOT arg_NO_GENERATE_CPP_EXPORTS OR arg_GENERATE_CPP_EXPORTS) AND NOT arg_STATIC
-            AND NOT arg_HEADER_MODULE)
+        if(NOT arg_NO_GENERATE_CPP_EXPORTS AND NOT arg_STATIC AND NOT arg_HEADER_MODULE)
             if(arg_CPP_EXPORT_HEADER_BASE_NAME)
                 set(cpp_export_header_base_name
                     "CPP_EXPORT_HEADER_BASE_NAME;${arg_CPP_EXPORT_HEADER_BASE_NAME}"
@@ -440,7 +444,7 @@ function(qt_internal_add_module target)
         set_source_files_properties("${module_depends_header}" PROPERTIES GENERATED TRUE)
         set_target_properties(${target} PROPERTIES _qt_module_depends_header
             "${module_depends_header}")
-        if(NOT ${arg_HEADER_MODULE})
+        if(NOT arg_HEADER_MODULE)
             set(module_header "${module_build_interface_include_dir}/${module_include_name}")
             set_property(TARGET "${target}" PROPERTY MODULE_HEADER
                     "${module_header}")
@@ -911,6 +915,60 @@ set(QT_ALLOW_MISSING_TOOLS_PACKAGES TRUE)")
     endif()
 
     qt_describe_module(${target})
+
+    if(QT_GENERATE_SBOM)
+        set(sbom_args "")
+
+        # 3rd party header modules should not be treated as Qt modules.
+        if(arg_IS_QT_3RD_PARTY_HEADER_MODULE)
+            list(APPEND sbom_args TYPE QT_THIRD_PARTY_MODULE)
+        else()
+            list(APPEND sbom_args TYPE QT_MODULE)
+        endif()
+
+        qt_get_cmake_configurations(configs)
+        foreach(config IN LISTS configs)
+            _qt_internal_sbom_append_multi_config_aware_single_arg_option(
+                RUNTIME_PATH
+                "${INSTALL_BINDIR}"
+                "${config}"
+                sbom_args
+            )
+            _qt_internal_sbom_append_multi_config_aware_single_arg_option(
+                LIBRARY_PATH
+                "${INSTALL_LIBDIR}"
+                "${config}"
+                sbom_args
+            )
+            _qt_internal_sbom_append_multi_config_aware_single_arg_option(
+                ARCHIVE_PATH
+                "${INSTALL_LIBDIR}"
+                "${config}"
+                sbom_args
+            )
+            _qt_internal_sbom_append_multi_config_aware_single_arg_option(
+                FRAMEWORK_PATH
+                "${INSTALL_LIBDIR}/${fw_versioned_binary_dir}"
+                "${config}"
+                sbom_args
+            )
+        endforeach()
+
+        _qt_internal_forward_function_args(
+            FORWARD_APPEND
+            FORWARD_PREFIX arg
+            FORWARD_OUT_VAR sbom_args
+            FORWARD_OPTIONS
+                ${__qt_internal_sbom_optional_args}
+            FORWARD_SINGLE
+                ${__qt_internal_sbom_single_args}
+            FORWARD_MULTI
+                ${__qt_internal_sbom_multi_args}
+        )
+
+        _qt_internal_extend_sbom(${target} ${sbom_args})
+    endif()
+
     qt_add_list_file_finalizer(qt_finalize_module ${target} ${arg_INTERNAL_MODULE} ${arg_NO_PRIVATE_MODULE})
 endfunction()
 
@@ -960,6 +1018,7 @@ function(qt_finalize_module target)
     qt_generate_module_pri_file("${target}" ${ARGN})
     qt_internal_generate_pkg_config_file(${target})
     qt_internal_apply_apple_privacy_manifest(${target})
+    _qt_internal_finalize_sbom(${target})
 endfunction()
 
 # Get a set of Qt module related values based on the target.

cmake/QtPlatformTargetHelpers.cmake

@@ -10,9 +10,7 @@ function(qt_internal_setup_public_platform_target)
     )
 
     ## QtPlatform Target:
-    add_library(Platform INTERFACE)
-    add_library(Qt::Platform ALIAS Platform)
-    add_library(${INSTALL_CMAKE_NAMESPACE}::Platform ALIAS Platform)
+    qt_internal_add_platform_target(Platform)
     target_include_directories(Platform
         INTERFACE
         $<BUILD_INTERFACE:${build_interface_definition_dir}>
@@ -49,15 +47,6 @@ function(qt_internal_setup_public_platform_target)
         target_compile_options(Platform INTERFACE "$<$<CXX_COMPILER_ID:Clang>:-fno-direct-access-external-data>")
     endif()
 
-    # Qt checks if a given platform supports 128 bit integers
-    # by checking if __SIZEOF_128__ is defined
-    # VXWORKS doesn't support 128 bit integers
-    # but it uses clang which defines __SIZEOF_128__
-    # which breaks the detection mechanism
-    if(VXWORKS)
-        target_compile_definitions(Platform INTERFACE "-DQT_NO_INT128")
-    endif()
-
     qt_set_msvc_cplusplus_options(Platform INTERFACE)
 
     # Propagate minimum C++ 17 via Platform to Qt consumers (apps), after the global features
@@ -72,6 +61,11 @@ function(qt_internal_setup_public_platform_target)
 
     # Generate a pkgconfig for Qt::Platform.
     qt_internal_generate_pkg_config_file(Platform)
+
+    qt_internal_add_sbom(Platform
+        TYPE QT_MODULE
+        IMMEDIATE_FINALIZATION
+    )
 endfunction()
 
 function(qt_internal_get_platform_definition_include_dir install_interface build_interface)

cmake/QtPluginHelpers.cmake

@@ -9,16 +9,19 @@ macro(qt_internal_get_internal_add_plugin_keywords option_args single_args multi
         ALLOW_UNDEFINED_SYMBOLS
         SKIP_INSTALL
         NO_UNITY_BUILD
+        ${__qt_internal_sbom_optional_args}
     )
     set(${single_args}
         OUTPUT_DIRECTORY
         INSTALL_DIRECTORY
         ARCHIVE_INSTALL_DIRECTORY
         ${__default_target_info_args}
+        ${__qt_internal_sbom_single_args}
     )
     set(${multi_args}
         ${__default_private_args}
         ${__default_public_args}
+        ${__qt_internal_sbom_multi_args}
         DEFAULT_IF
     )
 endmacro()
@@ -157,7 +160,6 @@ function(qt_internal_add_plugin target)
     qt_set_common_target_properties("${target}")
     qt_internal_add_target_aliases("${target}")
     qt_skip_warnings_are_errors_when_repo_unclean("${target}")
-    _qt_internal_apply_strict_cpp("${target}")
 
     set_target_properties("${target}" PROPERTIES
         LIBRARY_OUTPUT_DIRECTORY "${output_directory}"
@@ -414,6 +416,36 @@ function(qt_internal_add_plugin target)
     if(NOT arg_SKIP_INSTALL)
         list(APPEND finalizer_extra_args INSTALL_PATH "${install_directory}")
     endif()
+
+    if(QT_GENERATE_SBOM)
+        set(sbom_args "")
+        list(APPEND sbom_args TYPE QT_PLUGIN)
+
+        qt_get_cmake_configurations(configs)
+        foreach(config IN LISTS configs)
+            _qt_internal_sbom_append_multi_config_aware_single_arg_option(
+                INSTALL_PATH
+                "${install_directory}"
+                "${config}"
+                sbom_args
+            )
+        endforeach()
+
+        _qt_internal_forward_function_args(
+            FORWARD_APPEND
+            FORWARD_PREFIX arg
+            FORWARD_OUT_VAR sbom_args
+            FORWARD_OPTIONS
+                ${__qt_internal_sbom_optional_args}
+            FORWARD_SINGLE
+                ${__qt_internal_sbom_single_args}
+            FORWARD_MULTI
+                ${__qt_internal_sbom_multi_args}
+        )
+
+        _qt_internal_extend_sbom(${target} ${sbom_args})
+    endif()
+
     qt_add_list_file_finalizer(qt_finalize_plugin ${target} ${finalizer_extra_args})
 
     if(NOT arg_SKIP_INSTALL)
@@ -442,6 +474,8 @@ function(qt_finalize_plugin target)
             qt_generate_plugin_pri_file("${target}")
         endif()
     endif()
+
+    _qt_internal_finalize_sbom(${target})
 endfunction()
 
 function(qt_get_sanitized_plugin_type plugin_type out_var)

cmake/QtPostProcessHelpers.cmake

@@ -105,9 +105,6 @@ function(qt_internal_collect_third_party_dep_packages_info
         get_cmake_property(provided_targets _qt_find_package_${package_key}_provided_targets)
         if(provided_targets)
             set(key "__qt_${target}_third_party_package_${package_key}_provided_targets")
-
-            # Escape the semicolon, so it is preserved in the list(JOIN) below
-            string(REPLACE ";" "\;" provided_targets "${provided_targets}")
             string(APPEND packages_info "set(${key} \"${provided_targets}\")\n")
         endif()
     endforeach()
@@ -403,10 +400,22 @@ function(qt_internal_create_qt6_dependencies_file)
     unset(depends)
     unset(optional_public_depends)
 
+    set(third_party_deps "")
+    set(third_party_deps_seen "")
+    set(third_party_deps_package_components_ids "")
+
     # We need to collect third party deps that are set on the public Platform target,
     # like Threads::Threads.
     # This mimics find_package part of the CONFIG += thread assignment in mkspecs/features/qt.prf.
     qt_collect_third_party_deps(${actual_target})
+    qt_internal_collect_third_party_dep_packages_info("${INSTALL_CMAKE_NAMESPACE}"
+        "${third_party_deps_package_components_ids}"
+        packages_info)
+
+    set(third_party_deps_extra_info "")
+    if(packages_info)
+        string(APPEND third_party_deps_extra_info "${packages_info}")
+    endif()
 
     # For Threads we also need to write an extra variable assignment.
     set(third_party_extra "")
@@ -574,7 +583,7 @@ function(qt_generate_install_prefixes out_var)
     set(vars INSTALL_BINDIR INSTALL_INCLUDEDIR INSTALL_LIBDIR INSTALL_MKSPECSDIR INSTALL_ARCHDATADIR
         INSTALL_PLUGINSDIR INSTALL_LIBEXECDIR INSTALL_QMLDIR INSTALL_DATADIR INSTALL_DOCDIR
         INSTALL_TRANSLATIONSDIR INSTALL_SYSCONFDIR INSTALL_EXAMPLESDIR INSTALL_TESTSDIR
-        INSTALL_DESCRIPTIONSDIR)
+        INSTALL_DESCRIPTIONSDIR INSTALL_SBOMDIR)
 
     foreach(var ${vars})
         get_property(docstring CACHE "${var}" PROPERTY HELPSTRING)

cmake/QtPriHelpers.cmake

@@ -35,12 +35,13 @@ function(qt_generate_qmake_libraries_pri_content module_name output_root_dir out
                 endif()
                 list(APPEND seen_targets ${lib_target})
                 get_target_property(lib_target_type ${lib_target} TYPE)
-                if(lib_target_type STREQUAL "INTERFACE_LIBRARY")
+                if(lib_target_type MATCHES "^(INTERFACE|UNKNOWN)_LIBRARY")
                     get_target_property(iface_libs ${lib_target} INTERFACE_LINK_LIBRARIES)
                     if(iface_libs)
                         list(PREPEND lib_targets ${iface_libs})
                     endif()
-                else()
+                endif()
+                if(NOT lib_target_type STREQUAL "INTERFACE_LIBRARY")
                     list(APPEND lib_libs "$<TARGET_LINKER_FILE:${lib_target}>")
                 endif()
                 list(APPEND lib_libdir  "$<TARGET_PROPERTY:${lib_target},INTERFACE_LINK_DIRECTORIES>")
@@ -57,7 +58,7 @@ function(qt_generate_qmake_libraries_pri_content module_name output_root_dir out
                 list(APPEND lib_defines "$<TARGET_PROPERTY:${lib_target},INTERFACE_COMPILE_DEFINITIONS>")
             else()
                 if(lib_target MATCHES "/([^/]+).framework$")
-                    list(APPEND lib_libs "-framework" "${CMAKE_MATCH_1}")
+                    list(APPEND lib_libs "-framework ${CMAKE_MATCH_1}")
                 else()
                     list(APPEND lib_libs "${lib_target}")
                 endif()

cmake/QtProcessConfigureArgs.cmake

@@ -150,6 +150,8 @@ while(NOT "${configure_args}" STREQUAL "")
     elseif(arg STREQUAL "-no-prefix")
         set(no_prefix_option TRUE)
         push("-DFEATURE_no_prefix=ON")
+    elseif(arg STREQUAL "-sbom")
+        push("-DQT_GENERATE_SBOM=ON")
     elseif(arg STREQUAL "-cmake-file-api")
         set(cmake_file_api TRUE)
     elseif(arg STREQUAL "-no-cmake-file-api")
@@ -165,7 +167,7 @@ while(NOT "${configure_args}" STREQUAL "")
         list(APPEND cmake_args "${configure_args}")
         break()
     else()
-        set_property(GLOBAL APPEND PROPERTY UNHANDLED_ARGS "${arg}")
+        set_property(GLOBAL APPEND PROPERTY UNHANDLED_ARGS "${raw_arg}")
     endif()
 endwhile()
 
@@ -261,6 +263,11 @@ defstub(set_package_properties)
 defstub(qt_qml_find_python)
 defstub(qt_set01)
 defstub(qt_internal_check_if_linker_is_available)
+defstub(qt_internal_add_sbom)
+defstub(qt_internal_extend_sbom)
+defstub(qt_internal_sbom_add_license)
+defstub(qt_internal_extend_sbom_dependencies)
+defstub(qt_find_package_extend_sbom)
 
 ####################################################################################################
 # Define functions/macros that are called in qt_cmdline.cmake files
@@ -934,6 +941,7 @@ endforeach()
 translate_path_input(headerdir INSTALL_INCLUDEDIR)
 translate_path_input(plugindir INSTALL_PLUGINSDIR)
 translate_path_input(translationdir INSTALL_TRANSLATIONSDIR)
+translate_path_input(sbomdir INSTALL_SBOMDIR)
 
 if(NOT "${INPUT_device}" STREQUAL "")
     push("-DQT_QMAKE_TARGET_MKSPEC=devices/${INPUT_device}")

cmake/QtProperties.cmake

@@ -63,15 +63,6 @@ define_property(TARGET
         for instance, which QPA should be linked."
 )
 
-define_property(GLOBAL
-    PROPERTY
-        QT_KNOWN_PLUGINS
-    BRIEF_DOCS
-        ""
-    FULL_DOCS
-        ""
-)
-
 define_property(TARGET
     PROPERTY
         QT_QML_MODULE_TARGET_PATH

cmake/QtPublicAppleHelpers.cmake

@@ -499,6 +499,55 @@ function(_qt_internal_set_xcode_install_path target)
     endif()
 endfunction()
 
+# Explicitly set the debug information format for each build configuration to match the values
+# of a new project created via Xcode directly. This ensures debug information is included during
+# archiving.
+function(_qt_internal_set_xcode_debug_information_format target)
+    if(NOT DEFINED CMAKE_XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT
+            AND NOT QT_NO_SET_XCODE_DEBUG_INFORMATION_FORMAT)
+        get_target_property(existing "${target}" XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT)
+        if(NOT existing)
+            # The CMake Xcode generator searches for [variant=${config}], removes that substring,
+            # and generates the attribute only for the config that is specified as the "variant".
+            set_target_properties("${target}" PROPERTIES
+                "XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT[variant=Debug]" "dwarf")
+            set_target_properties("${target}" PROPERTIES
+                "XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT[variant=Release]" "dwarf-with-dsym")
+            set_target_properties("${target}" PROPERTIES
+                "XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT[variant=MinSizeRel]" "dwarf-with-dsym")
+            set_target_properties("${target}" PROPERTIES
+                "XCODE_ATTRIBUTE_DEBUG_INFORMATION_FORMAT[variant=RelWithDebInfo]"
+                "dwarf-with-dsym")
+        endif()
+    endif()
+endfunction()
+
+# Make sure to always generate debug symbols, to match the values of a new project created via
+# Xcode directly.
+function(_qt_internal_set_xcode_generate_debugging_symbols target)
+    if(NOT DEFINED CMAKE_XCODE_ATTRIBUTE_GCC_GENERATE_DEBUGGING_SYMBOLS
+            AND NOT QT_NO_SET_XCODE_GCC_GENERATE_DEBUGGING_SYMBOLS)
+        get_target_property(existing "${target}" XCODE_ATTRIBUTE_GCC_GENERATE_DEBUGGING_SYMBOLS)
+        if(NOT existing)
+            set_target_properties("${target}" PROPERTIES
+                "XCODE_ATTRIBUTE_GCC_GENERATE_DEBUGGING_SYMBOLS" "YES")
+        endif()
+    endif()
+endfunction()
+
+# CMake generates a project where this setting is set to an absolute path build dir.
+# Provide an opt-in to work around an Xcode issue where archiving does not find the project dSYMs
+# unless the configuration build dir starts with $(BUILD_DIR) or is set to $(inherited).
+# It is an opt-in, because it breaks certain CMake behavior like $<TARGET_FILE:${target}> genex
+# evaluation as well as ignoring the value of CMAKE_RUNTIME_OUTPUT_DIRECTORY.
+# So projects have to do it at their own risk.
+function(_qt_internal_set_xcode_configuration_build_dir target)
+    if(QT_USE_RISKY_DSYM_ARCHIVING_WORKAROUND)
+        set_target_properties("${target}" PROPERTIES
+            XCODE_ATTRIBUTE_CONFIGURATION_BUILD_DIR "$(inherited)")
+    endif()
+endfunction()
+
 function(_qt_internal_set_xcode_bundle_display_name target)
     # We want the value of CFBundleDisplayName to be ${PRODUCT_NAME}, but we can't put that
     # into the Info.plist.in template file directly, because the implicit configure_file(Info.plist)
@@ -628,19 +677,31 @@ function(_qt_internal_set_apple_localizations target)
         COMMANDS "print CFBundleLocalizations"
         OUTPUT_VARIABLE existing_localizations
     )
-    if(existing_localizations)
-        return()
+    if(NOT existing_localizations)
+        list(TRANSFORM supported_languages PREPEND
+            "Add CFBundleLocalizations: string ")
+
+        _qt_internal_plist_buddy("${plist_file}"
+            COMMANDS
+                "Add CFBundleLocalizations array"
+                ${supported_languages}
+                "Delete CFBundleAllowMixedLocalizations"
+        )
     endif()
 
-    list(TRANSFORM supported_languages PREPEND
-        "Add CFBundleLocalizations: string ")
-
-    _qt_internal_plist_buddy("${plist_file}"
-        COMMANDS
-            "Add CFBundleLocalizations array"
-            ${supported_languages}
-            "Delete CFBundleAllowMixedLocalizations"
-    )
+    if(NOT "${QT_I18N_SOURCE_LANGUAGE}" STREQUAL "")
+        _qt_internal_plist_buddy("${plist_file}"
+            COMMANDS "print CFBundleDevelopmentRegion"
+            OUTPUT_VARIABLE existing_dev_region
+        )
+        if(NOT existing_dev_region)
+            _qt_internal_plist_buddy("${plist_file}"
+                COMMANDS
+                    "Add CFBundleDevelopmentRegion string"
+                    "Set CFBundleDevelopmentRegion ${QT_I18N_SOURCE_LANGUAGE}"
+            )
+        endif()
+    endif()
 endfunction()
 
 function(_qt_internal_set_ios_simulator_arch target)
@@ -910,6 +971,9 @@ function(_qt_internal_finalize_apple_app target)
         _qt_internal_set_xcode_code_sign_style("${target}")
         _qt_internal_set_xcode_bundle_display_name("${target}")
         _qt_internal_set_xcode_install_path("${target}")
+        _qt_internal_set_xcode_configuration_build_dir("${target}")
+        _qt_internal_set_xcode_debug_information_format("${target}")
+        _qt_internal_set_xcode_generate_debugging_symbols("${target}")
     endif()
 
     _qt_internal_set_xcode_bundle_name("${target}")

cmake/QtPublicCMakeHelpers.cmake

@@ -387,6 +387,10 @@ endfunction()
 # It assigns the known properties from the versioned targets to the versionless created in this
 # function. This allows versionless targets mimic the versioned.
 function(_qt_internal_create_versionless_targets targets install_namespace)
+    set(known_imported_properties
+        IMPORTED_LINK_DEPENDENT_LIBRARIES
+    )
+
     set(known_interface_properties
         QT_MAJOR_VERSION
         AUTOMOC_MACRO_NAMES
@@ -434,6 +438,10 @@ function(_qt_internal_create_versionless_targets targets install_namespace)
         _qt_package_name
         _qt_package_version
         _qt_private_module_target_name
+        _qt_sbom_spdx_id
+        _qt_sbom_spdx_repo_document_namespace
+        _qt_sbom_spdx_relative_installed_repo_document_path
+        _qt_sbom_spdx_repo_project_name_lowercase
     )
 
     set(supported_target_types STATIC_LIBRARY MODULE_LIBRARY SHARED_LIBRARY OBJECT_LIBRARY
@@ -475,6 +483,15 @@ function(_qt_internal_create_versionless_targets targets install_namespace)
                 endif()
                 set_property(TARGET Qt::${target} PROPERTY
                     IMPORTED_LOCATION${config} "${target_imported_location}")
+
+                foreach(property IN LISTS known_imported_properties)
+                    get_target_property(exported_property_value
+                        ${install_namespace}::${target} ${property}${config})
+                    if(exported_property_value)
+                        set_property(TARGET Qt::${target} APPEND PROPERTY
+                            ${property} "${exported_property_value}")
+                    endif()
+                endforeach()
             endforeach()
 
             foreach(property IN LISTS known_qt_exported_properties)
@@ -641,13 +658,13 @@ function(_qt_internal_forward_function_args)
     endforeach()
 
     foreach(option_name IN LISTS arg_FORWARD_SINGLE)
-        if(${arg_FORWARD_PREFIX}_${option_name})
+        if(NOT "${${arg_FORWARD_PREFIX}_${option_name}}" STREQUAL "")
             list(APPEND forward_args "${option_name}" "${${arg_FORWARD_PREFIX}_${option_name}}")
         endif()
     endforeach()
 
     foreach(option_name IN LISTS arg_FORWARD_MULTI)
-        if(${arg_FORWARD_PREFIX}_${option_name})
+        if(NOT "${${arg_FORWARD_PREFIX}_${option_name}}" STREQUAL "")
             list(APPEND forward_args "${option_name}" ${${arg_FORWARD_PREFIX}_${option_name}})
         endif()
     endforeach()

cmake/QtPublicCMakeVersionHelpers.cmake

@@ -70,3 +70,22 @@ function(__qt_internal_require_suitable_cmake_version_for_using_qt)
             "Use at your own risk.")
     endif()
 endfunction()
+
+function(__qt_internal_set_cmp0156)
+    if(POLICY CMP0156)
+        if(QT_FORCE_CMP0156_TO_NEW)
+            cmake_policy(SET CMP0156 "NEW")
+        else()
+            cmake_policy(GET CMP0156 policy_value)
+            if(NOT "${policy_value}" STREQUAL "OLD")
+                if("${policy_value}" STREQUAL "NEW" AND NOT QT_BUILDING_QT)
+                    message(WARNING "CMP0156 is set to '${policy_value}'. Qt forces the 'OLD'"
+                        " behavior of this policy by default. Set QT_FORCE_CMP0156_TO_NEW=ON to"
+                        " force the 'NEW' behavior for the Qt commands that create either"
+                        " library or executable targets.")
+                endif()
+                cmake_policy(SET CMP0156 "OLD")
+            endif()
+        endif()
+    endif()
+endfunction()

cmake/QtPublicDependencyHelpers.cmake

@@ -35,6 +35,38 @@ macro(_qt_internal_find_third_party_dependencies target target_dep_list)
         else()
             find_dependency(${__qt_${target}_find_package_args})
         endif()
+
+        _qt_internal_get_package_components_id(
+            PACKAGE_NAME "${__qt_${target}_pkg}"
+            COMPONENTS ${__qt_${target}_components}
+            OPTIONAL_COMPONENTS ${__qt_${target}_optional_components}
+            OUT_VAR_KEY __qt_${target}_package_components_id
+        )
+        if(${__qt_${target}_pkg}_FOUND
+                AND __qt_${target}_third_party_package_${__qt_${target}_package_components_id}_provided_targets)
+            set(__qt_${target}_sbom_args "")
+
+            if(${__qt_${target}_pkg}_VERSION)
+                list(APPEND __qt_${target}_sbom_args
+                    PACKAGE_VERSION "${${__qt_${target}_pkg}_VERSION}"
+                )
+            endif()
+
+            foreach(__qt_${target}_provided_target
+                    IN LISTS
+                    __qt_${target}_third_party_package_${__qt_${target}_package_components_id}_provided_targets)
+
+                _qt_internal_promote_3rd_party_provided_target_and_3rd_party_deps_to_global(
+                    "${__qt_${target}_provided_target}")
+
+                _qt_internal_sbom_record_system_library_usage(
+                    "${__qt_${target}_provided_target}"
+                    TYPE SYSTEM_LIBRARY
+                    FRIENDLY_PACKAGE_NAME "${__qt_${target}_pkg}"
+                    ${__qt_${target}_sbom_args}
+                )
+            endforeach()
+        endif()
     endforeach()
 endmacro()
 
@@ -233,6 +265,8 @@ macro(_qt_internal_setup_qt_host_path
     # Requiredness can be overridden via variable.
     if(DEFINED QT_REQUIRE_HOST_PATH_CHECK)
         set(_qt_platform_host_path_required "${QT_REQUIRE_HOST_PATH_CHECK}")
+    elseif(DEFINED ENV{QT_REQUIRE_HOST_PATH_CHECK})
+        set(_qt_platform_host_path_required "$ENV{QT_REQUIRE_HOST_PATH_CHECK}")
     else()
         set(_qt_platform_host_path_required "${host_path_required}")
     endif()

cmake/QtPublicGitHelpers.cmake

@@ -0,0 +1,153 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# Copyright (C) 2023-2024 Jochem Rutgers
+# SPDX-License-Identifier: BSD-3-Clause AND MIT
+
+macro(_qt_internal_find_git_package)
+    find_package(Git)
+endmacro()
+
+# Helper to set the various git version variables in the parent scope across multiple return points.
+macro(_qt_internal_set_git_query_variables)
+    set("${arg_OUT_VAR_PREFIX}git_hash" "${version_git_hash}" PARENT_SCOPE)
+    set("${arg_OUT_VAR_PREFIX}git_hash_short" "${version_git_head}" PARENT_SCOPE)
+    set("${arg_OUT_VAR_PREFIX}git_version" "${git_version}" PARENT_SCOPE)
+
+    # git version sanitized for file paths.
+    string(REGEX REPLACE "[^-a-zA-Z0-9_.]+" "+" git_version_path "${git_version}")
+    set("${arg_OUT_VAR_PREFIX}git_version_path" "${git_version_path}" PARENT_SCOPE)
+endmacro()
+
+# Caches the results per working-directory in global cmake properties.
+# Sets the following variables in the outer scope:
+# - git_hash: Full git hash.
+# - git_hash_short: Short git hash.
+# - git_version: Git version string.
+# - git_version_path: Git version string sanitized for file paths.
+function(_qt_internal_query_git_version)
+    set(opt_args
+        EMPTY_VALUE_WHEN_NOT_GIT_REPO
+    )
+    set(single_args
+        WORKING_DIRECTORY
+        OUT_VAR_PREFIX
+    )
+    set(multi_args "")
+    cmake_parse_arguments(PARSE_ARGV 0 arg "${opt_args}" "${single_args}" "${multi_args}")
+    _qt_internal_validate_all_args_are_parsed(arg)
+
+    if(arg_EMPTY_VALUE_WHEN_NOT_GIT_REPO)
+        set(version_git_head "")
+        set(version_git_hash "")
+        set(version_git_branch "")
+        set(version_git_tag "")
+        set(git_version "")
+    else()
+        set(version_git_head "unknown")
+        set(version_git_hash "")
+        set(version_git_branch "dev")
+        set(version_git_tag "")
+        set(git_version "${version_git_head}+${version_git_branch}")
+    endif()
+
+    if(NOT Git_FOUND)
+        message(STATUS "Git not found, skipping querying git version.")
+        _qt_internal_set_git_query_variables()
+        return()
+    endif()
+
+    if(arg_WORKING_DIRECTORY)
+        set(working_directory "${arg_WORKING_DIRECTORY}")
+    else()
+        set(working_directory "${PROJECT_SOURCE_DIR}")
+    endif()
+
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} rev-parse --is-inside-work-tree
+        WORKING_DIRECTORY "${working_directory}"
+        OUTPUT_VARIABLE is_inside_work_tree_output
+        RESULT_VARIABLE is_inside_work_tree_result
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+
+    if((NOT is_inside_work_tree_result EQUAL 0) OR (NOT is_inside_work_tree_output STREQUAL "true"))
+        message(STATUS "Git repo not found, skipping querying git version.")
+        _qt_internal_set_git_query_variables()
+        return()
+    endif()
+
+    get_cmake_property(git_hash_cache _qt_git_hash_cache_${working_directory})
+    get_cmake_property(git_hash_short_cache _qt_git_hash_short_cache_${working_directory})
+    get_cmake_property(git_version_cache _qt_git_version_cache_${working_directory})
+    get_cmake_property(git_version_path_cache _qt_git_version_path_cache_${working_directory})
+    if(git_hash_cache)
+        set(git_hash "${git_hash_cache}")
+        set(git_hash_short "${git_hash_short_cache}")
+        set(git_version "${git_version_cache}")
+        set(git_version_path "${git_version_path_cache}")
+        _qt_internal_set_git_query_variables()
+        return()
+    endif()
+
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD
+        WORKING_DIRECTORY "${working_directory}"
+        OUTPUT_VARIABLE version_git_head
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} rev-parse HEAD
+        WORKING_DIRECTORY "${working_directory}"
+        OUTPUT_VARIABLE version_git_hash
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} rev-parse --abbrev-ref HEAD
+        WORKING_DIRECTORY "${working_directory}"
+        OUTPUT_VARIABLE version_git_branch
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} tag --points-at HEAD
+        WORKING_DIRECTORY "${working_directory}"
+        OUTPUT_VARIABLE version_git_tag
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+
+    string(REGEX REPLACE "[ \t\r\n].*$" "" version_git_tag "${version_git_tag}")
+
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} status -s
+        WORKING_DIRECTORY "${working_directory}"
+        OUTPUT_VARIABLE version_git_dirty
+        ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+
+    if(NOT "${version_git_dirty}" STREQUAL "")
+        set(version_git_dirty "+dirty")
+    endif()
+
+    if(NOT "${version_git_tag}" STREQUAL "")
+        set(git_version "${version_git_tag}")
+
+        if("${git_version}" MATCHES "^v[0-9]+\.")
+            string(REGEX REPLACE "^v" "" git_version "${git_version}")
+        endif()
+
+        set(git_version "${git_version}${version_git_dirty}")
+    else()
+        set(git_version
+            "${version_git_head}+${version_git_branch}${version_git_dirty}"
+        )
+    endif()
+
+    set_property(GLOBAL PROPERTY _qt_git_hash_cache_${working_directory} "${git_hash}")
+    set_property(GLOBAL PROPERTY _qt_git_hash_short_cache_${working_directory} "${git_hash_short}")
+    set_property(GLOBAL PROPERTY _qt_git_version_cache_${working_directory} "${git_version}")
+    set_property(GLOBAL PROPERTY _qt_git_version_path_cache_${working_directory}
+        "${git_version_path}")
+
+    _qt_internal_set_git_query_variables()
+endfunction()

cmake/QtPublicTargetHelpers.cmake

@@ -253,6 +253,53 @@ function(__qt_internal_collect_object_libraries_recursively out_var target initi
     set(${out_var} "${object_libraries}" PARENT_SCOPE)
 endfunction()
 
+# Sets out_var to to TRUE if the target was marked to not be promoted to global scope.
+function(_qt_internal_should_not_promote_package_target_to_global target out_var)
+    get_property(should_not_promote TARGET "${target}" PROPERTY _qt_no_promote_global)
+    set("${out_var}" "${should_not_promote}" PARENT_SCOPE)
+endfunction()
+
+# This function recursively walks transitive link libraries of the given target
+# and promotes encountered 3rd party targets to be IMPORTED_GLOBAL if they are not.
+#
+# This is required for .prl file generation in top-level builds, to make sure that imported 3rd
+# party library targets in any repo are made global, so there are no scoping issues.
+#
+# The promotion needs to happen in the same directory scope where the imported target is
+# first created.
+#
+# Uses __qt_internal_walk_libs.
+function(_qt_internal_promote_3rd_party_link_targets_to_global target)
+    __qt_internal_walk_libs("${target}" _discarded_out_var _discarded_out_var_2
+                            "qt_find_package_targets_dict" "promote_3rd_party_global")
+endfunction()
+
+# Check if a target is an internal target (one added by qt_internal_* API, executables, libraries,
+# etc).
+function(_qt_internal_is_internal_target target out_var)
+    get_target_property(is_internal ${target} _qt_is_internal_target)
+    if(is_internal)
+        set(value TRUE)
+    else()
+        set(value FALSE)
+    endif()
+    set(${out_var} "${value}" PARENT_SCOPE)
+endfunction()
+
+# Check if a target should never be promoted to global.
+# Some targets like the Platform target is public, and can't have _qt_is_internal_target set.
+# But we still want to avoid promoting it to global. Setting this property achieves that.
+function(_qt_internal_should_skip_3rd_party_global_promotion target out_var)
+    get_target_property(should_skip ${target} _qt_should_skip_3rd_party_global_promotion)
+    if(should_skip)
+        set(value TRUE)
+    else()
+        set(value FALSE)
+    endif()
+    set(${out_var} "${value}" PARENT_SCOPE)
+endfunction()
+
+# Tries to promote any non-global imported target to global scope.
 function(__qt_internal_promote_target_to_global target)
     get_property(is_global TARGET ${target} PROPERTY IMPORTED_GLOBAL)
     if(NOT is_global)
@@ -261,6 +308,48 @@ function(__qt_internal_promote_target_to_global target)
     endif()
 endfunction()
 
+# Promotes a 3rd party provided target to global, which was found by qt_find_package or
+# _qt_internal_find_third_party_dependencies.
+# Only does it when building Qt, but not when building user projects.
+function(_qt_internal_promote_3rd_party_provided_target_and_3rd_party_deps_to_global target)
+    # Return early if building a user project, and not Qt.
+    # QT_BUILDING_QT is set when building a qt repo, but we also check for QT_REPO_MODULE_VERSION,
+    # which is set in .cmake.conf, because _qt_internal_find_third_party_dependencies is called
+    # before QT_BUILDING_QT is set.
+    if(NOT (QT_BUILDING_QT OR QT_REPO_MODULE_VERSION))
+        return()
+    endif()
+
+    # Return early if the provided target does not exist, which can happen in the case of zstd,
+    # where we list multiple possible target names, but only some will be available.
+    if(NOT TARGET "${target}")
+        return()
+    endif()
+
+    get_property(is_global TARGET "${target}" PROPERTY IMPORTED_GLOBAL)
+    _qt_internal_should_not_promote_package_target_to_global("${target}" should_not_promote)
+    if(NOT is_global AND NOT should_not_promote)
+        _qt_internal_promote_3rd_party_target_to_global(${target})
+        _qt_internal_promote_3rd_party_link_targets_to_global("${target}")
+    endif()
+endfunction()
+
+# Tries to promote a non-global imported 3rd party target to global scope.
+# 3rd party targets are usually system library targets.
+# - targets that were not created by qt_internal_add_foo commands
+# - targets that don't have the should_skip_global_promotion property
+function(_qt_internal_promote_3rd_party_target_to_global target)
+    get_property(is_global TARGET ${target} PROPERTY IMPORTED_GLOBAL)
+
+    if(NOT is_global)
+        _qt_internal_is_internal_target("${target}" is_internal)
+        _qt_internal_should_skip_3rd_party_global_promotion("${target}" should_skip)
+        if(NOT is_internal AND NOT should_skip)
+            __qt_internal_promote_target_to_global("${target}")
+        endif()
+    endif()
+endfunction()
+
 function(__qt_internal_promote_target_to_global_checked target)
     # With CMake version 3.21 we use a different mechanism that allows us to promote all targets
     # within a scope.

cmake/QtPublicWalkLibsHelpers.cmake

@@ -74,7 +74,7 @@ endfunction()
 # operation: a string to tell the function what additional behaviors to execute.
 #            'collect_libs' (default) operation is to collect linker file paths and flags.
 #                           Used for prl file generation.
-#            'promote_global' promotes walked imported targets to global scope.
+#            'promote_3rd_party_global' promotes walked 3rd party imported targets to global scope.
 #            'collect_targets' collects all target names (discards framework or link flags)
 #            'direct_targets' collects only the direct target names (discards framework or link
 #                             flags)
@@ -238,7 +238,7 @@ function(__qt_internal_walk_libs
                         __qt_internal_merge_libs(rcc_objects ${lib_rcc_objects_${target}})
                     endif()
                 endif()
-                if(operation STREQUAL "promote_global")
+                if(operation STREQUAL "promote_3rd_party_global")
                     set(lib_target_unaliased "${lib_target}")
                     get_target_property(aliased_target ${lib_target} ALIASED_TARGET)
                     if(aliased_target)
@@ -249,15 +249,23 @@ function(__qt_internal_walk_libs
 
                     # Allow opting out of promotion. This is useful in certain corner cases
                     # like with WrapLibClang and Threads in qttools.
-                    qt_internal_should_not_promote_package_target_to_global(
+                    _qt_internal_should_not_promote_package_target_to_global(
                         "${lib_target_unaliased}" should_not_promote)
                     if(is_imported AND NOT should_not_promote)
-                        __qt_internal_promote_target_to_global(${lib_target_unaliased})
+                        _qt_internal_promote_3rd_party_target_to_global(
+                            ${lib_target_unaliased})
                     endif()
                 endif()
             elseif("${lib_target}" MATCHES "^(Qt|${QT_CMAKE_EXPORT_NAMESPACE})::(.*)")
-                message(FATAL_ERROR "The ${CMAKE_MATCH_2} target is mentioned as a dependency for \
-${target}, but not declared.")
+                if(QT_BUILDING_QT OR QT_BUILD_STANDALONE_TESTS)
+                    set(message_type FATAL_ERROR)
+                    set(message_addition "")
+                else()
+                    set(message_type WARNING)
+                    set(message_addition " The linking might be incomplete.")
+                endif()
+                message(${message_type} "The ${CMAKE_MATCH_2} target is mentioned as a dependency"
+                        " for ${target}, but not declared.${message_addition}")
             else()
                 if(NOT operation MATCHES "^(collect|direct)_targets$")
                     set(final_lib_name_to_merge "${lib_target}")

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.50")
+    set(QT_EMCC_RECOMMENDED_VERSION "3.1.56")
     set(${out_var} "${QT_EMCC_RECOMMENDED_VERSION}" PARENT_SCOPE)
 endfunction()
 

cmake/QtSbomHelpers.cmake

@@ -0,0 +1,24 @@
+# Copyright (C) 2024 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+# For now these are simple internal forwarding wrappers for the public counterparts, which are
+# meant to be used in qt repo CMakeLists.txt files.
+function(qt_internal_add_sbom)
+    _qt_internal_add_sbom(${ARGN})
+endfunction()
+
+function(qt_internal_extend_sbom)
+    _qt_internal_extend_sbom(${ARGN})
+endfunction()
+
+function(qt_internal_sbom_add_license)
+    _qt_internal_sbom_add_license(${ARGN})
+endfunction()
+
+function(qt_internal_extend_sbom_dependencies)
+    _qt_internal_extend_sbom_dependencies(${ARGN})
+endfunction()
+
+function(qt_find_package_extend_sbom)
+    _qt_find_package_extend_sbom(${ARGN})
+endfunction()

cmake/QtScopeFinalizerHelpers.cmake

@@ -77,9 +77,17 @@ function(qt_watch_current_list_dir variable access value current_list_file stack
                     qt_finalize_plugin(${a1} ${a2} ${a3} ${a4} ${a5} ${a6} ${a7} ${a8} ${a9})
                 elseif(func STREQUAL "qt_internal_finalize_app")
                     qt_internal_finalize_app(${a1} ${a2} ${a3} ${a4} ${a5} ${a6} ${a7} ${a8} ${a9})
+                elseif(func STREQUAL "qt_internal_finalize_tool")
+                    qt_internal_finalize_tool(${a1} ${a2} ${a3} ${a4} ${a5} ${a6} ${a7} ${a8} ${a9})
+                elseif(func STREQUAL "qt_internal_finalize_3rdparty_library")
+                    qt_internal_finalize_3rdparty_library(
+                        ${a1} ${a2} ${a3} ${a4} ${a5} ${a6} ${a7} ${a8} ${a9})
                 elseif(func STREQUAL "qt_internal_export_additional_targets_file_finalizer")
                     qt_internal_export_additional_targets_file_finalizer(
                         ${a1} ${a2} ${a3} ${a4} ${a5} ${a6} ${a7} ${a8} ${a9})
+                elseif(func STREQUAL "_qt_internal_finalize_sbom")
+                    _qt_internal_finalize_sbom(
+                        ${a1} ${a2} ${a3} ${a4} ${a5} ${a6} ${a7} ${a8} ${a9})
                 else()
                     message(FATAL_ERROR "qt_watch_current_list_dir doesn't know about ${func}. Consider adding it.")
                 endif()

cmake/QtTargetHelpers.cmake

@@ -41,10 +41,12 @@ function(qt_internal_extend_target target)
 
     set(option_args
         NO_UNITY_BUILD
+        ${__qt_internal_sbom_optional_args}
     )
     set(single_args
         PRECOMPILED_HEADER
         EXTRA_LINKER_SCRIPT_CONTENT
+        ${__qt_internal_sbom_single_args}
     )
     set(multi_args
         ${__default_public_args}
@@ -54,6 +56,7 @@ function(qt_internal_extend_target target)
         CONDITION_INDEPENDENT_SOURCES
         COMPILE_FLAGS
         EXTRA_LINKER_SCRIPT_EXPORTS
+        ${__qt_internal_sbom_multi_args}
     )
 
     cmake_parse_arguments(PARSE_ARGV 1 arg
@@ -210,6 +213,34 @@ function(qt_internal_extend_target target)
             endif()
         endforeach()
 
+        if(arg_LIBRARIES)
+            _qt_internal_append_to_target_property_without_duplicates(${target}
+                _qt_extend_target_libraries "${arg_LIBRARIES}"
+            )
+        endif()
+
+        if(arg_PUBLIC_LIBRARIES)
+            _qt_internal_append_to_target_property_without_duplicates(${target}
+                _qt_extend_target_public_libraries "${arg_PUBLIC_LIBRARIES}"
+            )
+        endif()
+
+        if(QT_GENERATE_SBOM)
+            set(sbom_args "")
+            _qt_internal_forward_function_args(
+                FORWARD_APPEND
+                FORWARD_PREFIX arg
+                FORWARD_OUT_VAR sbom_args
+                FORWARD_OPTIONS
+                    ${__qt_internal_sbom_optional_args}
+                FORWARD_SINGLE
+                    ${__qt_internal_sbom_single_args}
+                FORWARD_MULTI
+                    ${__qt_internal_sbom_multi_args}
+            )
+            _qt_internal_extend_sbom(${target} ${sbom_args})
+        endif()
+
         set(target_private "${target}Private")
         get_target_property(is_internal_module ${target} _qt_is_internal_module)
         # Internal modules don't have Private targets but we still need to
@@ -298,7 +329,7 @@ endfunction()
 function(qt_get_install_target_default_args)
     cmake_parse_arguments(PARSE_ARGV 0 arg
        ""
-       "OUT_VAR;CMAKE_CONFIG;RUNTIME;LIBRARY;ARCHIVE;INCLUDES;BUNDLE"
+       "OUT_VAR;OUT_VAR_RUNTIME;CMAKE_CONFIG;RUNTIME;LIBRARY;ARCHIVE;INCLUDES;BUNDLE"
        "ALL_CMAKE_CONFIGS")
     _qt_internal_validate_all_args_are_parsed(arg)
 
@@ -348,6 +379,13 @@ function(qt_get_install_target_default_args)
         BUNDLE DESTINATION   "${bundle}${suffix}"
         INCLUDES DESTINATION "${includes}${suffix}")
     set(${arg_OUT_VAR} "${args}" PARENT_SCOPE)
+
+    if(arg_OUT_VAR_RUNTIME)
+        set(args
+            "${runtime}${suffix}"
+        )
+        set(${arg_OUT_VAR_RUNTIME} "${args}" PARENT_SCOPE)
+    endif()
 endfunction()
 
 macro(qt_internal_setup_default_target_function_options)
@@ -391,6 +429,12 @@ macro(qt_internal_setup_default_target_function_options)
         TARGET_COPYRIGHT
     )
 
+    _qt_internal_get_sbom_add_target_common_options(
+        __qt_internal_sbom_optional_args
+        __qt_internal_sbom_single_args
+        __qt_internal_sbom_multi_args
+    )
+
     # Collection of arguments so they can be shared across qt_internal_add_executable
     # and qt_internal_add_test_helper.
     set(__qt_internal_add_executable_optional_args
@@ -401,6 +445,7 @@ macro(qt_internal_setup_default_target_function_options)
         DELAY_TARGET_INFO
         QT_APP
         NO_UNITY_BUILD
+        ${__qt_internal_sbom_optional_args}
     )
     set(__qt_internal_add_executable_single_args
         CORE_LIBRARY
@@ -408,10 +453,12 @@ macro(qt_internal_setup_default_target_function_options)
         INSTALL_DIRECTORY
         VERSION
         ${__default_target_info_args}
+        ${__qt_internal_sbom_single_args}
     )
     set(__qt_internal_add_executable_multi_args
         ${__default_private_args}
         ${__default_public_args}
+        ${__qt_internal_sbom_multi_args}
     )
 endmacro()
 
@@ -447,7 +494,15 @@ function(qt_internal_setup_cmake_config_postfix)
             set(default_cmake_debug_postfix "d")
         endif()
     elseif(APPLE)
-        set(default_cmake_debug_postfix "_debug")
+        # Only add a suffix for explicit no-framework builds.
+        # For framework builds the library inside the framework
+        # is always unsuffixed, and we want to match that for
+        # plugins and other non-framework (static) libraries.
+        if(NOT (QT_FEATURE_framework OR FEATURE_framework
+           # Account for default in configure.json being ON
+           OR (NOT DEFINED QT_FEATURE_framework AND NOT DEFINED FEATURE_framework)))
+            set(default_cmake_debug_postfix "_debug")
+        endif()
     endif()
 
     set(custom_postfix_vars "")
@@ -921,6 +976,7 @@ endif()\n")
         set(write_implib FALSE)
         set(write_soname FALSE)
         set(write_objects FALSE)
+        set(write_link_dependencies FALSE)
         set(write_location TRUE)
 
         if(target_type STREQUAL "SHARED_LIBRARY")
@@ -931,6 +987,7 @@ endif()\n")
             else()
                 set(write_soname TRUE)
             endif()
+            set(write_link_dependencies TRUE)
         elseif(target_type STREQUAL "OBJECT_LIBRARY")
             set(write_objects TRUE)
             set(write_location FALSE)
@@ -946,6 +1003,9 @@ endif()\n")
             if(write_soname)
                 string(APPEND content "get_target_property(_qt_imported_soname ${full_target} IMPORTED_SONAME_${uc_release_cfg})\n")
             endif()
+            if(write_link_dependencies)
+                string(APPEND content "get_target_property(_qt_imported_link_dependencies ${full_target} IMPORTED_LINK_DEPENDENT_LIBRARIES_${uc_release_cfg})\n")
+            endif()
             if(write_objects)
                 string(APPEND content "get_target_property(_qt_imported_objects ${full_target} IMPORTED_OBJECTS_${uc_release_cfg})\n")
                 # We generate CLR props as well, because that's what CMake generates for object
@@ -962,6 +1022,9 @@ endif()\n")
         if(write_soname)
             string(APPEND content "get_target_property(_qt_imported_soname_default ${full_target} IMPORTED_SONAME_$\{QT_DEFAULT_IMPORT_CONFIGURATION})\n")
         endif()
+        if(write_link_dependencies)
+            string(APPEND content "get_target_property(_qt_imported_link_dependencies_default ${full_target} IMPORTED_LINK_DEPENDENT_LIBRARIES_$\{QT_DEFAULT_IMPORT_CONFIGURATION})\n")
+        endif()
         if(write_objects)
             string(APPEND content "get_target_property(_qt_imported_objects_default ${full_target} IMPORTED_OBJECTS_$\{QT_DEFAULT_IMPORT_CONFIGURATION})\n")
             string(APPEND content "get_target_property(_qt_imported_clr_default ${full_target} IMPORTED_COMMON_LANGUAGE_RUNTIME_$\{QT_DEFAULT_IMPORT_CONFIGURATION})\n")
@@ -996,6 +1059,12 @@ endif()")
                 string(APPEND content "
 if(_qt_imported_soname${var_suffix})
     set_property(TARGET ${full_target} PROPERTY IMPORTED_SONAME${property_suffix} \"$\{_qt_imported_soname${var_suffix}}\")
+endif()")
+            endif()
+            if(write_link_dependencies)
+                string(APPEND content "
+if(_qt_imported_link_dependencies${var_suffix})
+    set_property(TARGET ${full_target} PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES${property_suffix} \"$\{_qt_imported_link_dependencies${var_suffix}}\")
 endif()")
             endif()
             if(write_objects)
@@ -1018,6 +1087,8 @@ unset(_qt_imported_location)
 unset(_qt_imported_location_default)
 unset(_qt_imported_soname)
 unset(_qt_imported_soname_default)
+unset(_qt_imported_link_dependencies)
+unset(_qt_imported_link_dependencies_default)
 unset(_qt_imported_objects)
 unset(_qt_imported_objects_default)
 unset(_qt_imported_clr)
@@ -1354,6 +1425,7 @@ 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)
+    set_property(TARGET "${target}" APPEND PROPERTY EXPORT_PROPERTIES "_qt_is_internal_library")
     qt_internal_mark_as_internal_target(${target})
 endfunction()
 
@@ -1363,6 +1435,7 @@ endfunction()
 # 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)
+    set_property(TARGET "${target}" APPEND PROPERTY EXPORT_PROPERTIES "_qt_is_internal_target")
 endfunction()
 
 # Marks a target with a property to skip it adding it as a dependency when building examples as
@@ -1659,31 +1732,29 @@ function(qt_internal_export_genex_properties)
     )
 endfunction()
 
-# The macro promotes the Qt platform targets and their dependencies to global. The macro shouldn't
-# be called explicitly in regular cases. It's called right after the first find_package(Qt ...)
-# call in the qt_internal_project_setup macro.
-# This allows using the qt_find_package(Wrap<3rdparty> PROVIDED_TARGETS ...) function,
-# without the risk of having duplicated global promotion of Qt internals. This is especially
-# sensitive for the bundled 3rdparty libraries.
-macro(qt_internal_promote_platform_targets_to_global)
-    if(TARGET Qt6::Platform)
-        get_target_property(is_imported Qt6::Platform IMPORTED)
-        if(is_imported)
-            set(known_platform_targets
-                Platform
-                PlatformCommonInternal
-                PlatformModuleInternal
-                PlatformPluginInternal
-                PlatformAppInternal
-                PlatformToolInternal
-            )
-            set(versionless_platform_targets ${known_platform_targets})
+# A small wrapper for adding the Platform target, and a building block for the PlatformXInternal
+# and GlobalConfig INTERFACE targets to apply common options.
+function(qt_internal_add_platform_target target)
+    _qt_internal_add_library("${target}" INTERFACE)
+    qt_internal_add_target_aliases("${target}")
 
-            list(TRANSFORM known_platform_targets PREPEND Qt6::)
-            list(TRANSFORM versionless_platform_targets PREPEND Qt::)
-            qt_find_package(Qt6 PROVIDED_TARGETS
-                ${known_platform_targets}
-                ${versionless_platform_targets})
-        endif()
-    endif()
-endmacro()
+    # The platform targets should never be promoted to global via the
+    # _qt_internal_promote_3rd_party_target_to_global command.
+    set_property(TARGET "${target}" PROPERTY _qt_should_skip_3rd_party_global_promotion TRUE)
+    set_property(TARGET "${target}" APPEND PROPERTY EXPORT_PROPERTIES
+        "_qt_should_skip_3rd_party_global_promotion")
+endfunction()
+
+# A small wrapper for adding the PlatformXInternal and GlobalConfig INTERFACE targets to apply
+# common options.
+# They can't be added via qt_internal_add_module, because it automatically links to the
+# PlatformInternal targets creating a cyclic dependency.
+function(qt_internal_add_platform_internal_target target)
+    qt_internal_add_platform_target("${target}")
+    qt_internal_mark_as_internal_library("${target}")
+
+    qt_internal_add_sbom("${target}"
+        TYPE QT_MODULE
+        IMMEDIATE_FINALIZATION
+    )
+endfunction()

cmake/QtToolHelpers.cmake

@@ -50,18 +50,24 @@ function(qt_internal_add_tool target_name)
         INSTALL_VERSIONED_LINK
         EXCEPTIONS
         NO_UNITY_BUILD
-        TRY_RUN)
+        TRY_RUN
+        ${__qt_internal_sbom_optional_args}
+    )
     set(one_value_keywords
         TOOLS_TARGET
         INSTALL_DIR
         CORE_LIBRARY
         TRY_RUN_FLAGS
-        ${__default_target_info_args})
+        ${__default_target_info_args}
+        ${__qt_internal_sbom_single_args}
+    )
     set(multi_value_keywords
         EXTRA_CMAKE_FILES
         EXTRA_CMAKE_INCLUDES
         PUBLIC_LIBRARIES
-        ${__default_private_args})
+        ${__default_private_args}
+        ${__qt_internal_sbom_multi_args}
+    )
 
     cmake_parse_arguments(PARSE_ARGV 1 arg
         "${option_keywords}"
@@ -137,7 +143,6 @@ function(qt_internal_add_tool target_name)
         # qt_set_target_info_properties knows how to process them
     )
     qt_internal_add_target_aliases("${target_name}")
-    _qt_internal_apply_strict_cpp("${target_name}")
     qt_internal_adjust_main_config_runtime_output_dir("${target_name}" "${output_dir}")
 
     if (WIN32)
@@ -186,8 +191,21 @@ function(qt_internal_add_tool target_name)
         set_property(GLOBAL APPEND PROPERTY QT_USER_FACING_TOOL_TARGETS ${target_name})
     endif()
 
+    if(QT_GENERATE_SBOM)
+        set(sbom_args "")
+        list(APPEND sbom_args TYPE QT_TOOL)
+    endif()
 
     if(NOT arg_NO_INSTALL AND arg_TOOLS_TARGET)
+        set(will_install TRUE)
+    else()
+        set(will_install FALSE)
+        if(QT_GENERATE_SBOM)
+            list(APPEND sbom_args NO_INSTALL)
+        endif()
+    endif()
+
+    if(will_install)
         # Assign a tool to an export set, and mark the module to which the tool belongs.
         qt_internal_append_known_modules_with_tools("${arg_TOOLS_TARGET}")
 
@@ -202,6 +220,7 @@ function(qt_internal_add_tool target_name)
         foreach(cmake_config ${cmake_configs})
             qt_get_install_target_default_args(
                 OUT_VAR install_targets_default_args
+                OUT_VAR_RUNTIME runtime_install_destination
                 RUNTIME "${install_dir}"
                 CMAKE_CONFIG "${cmake_config}"
                 ALL_CMAKE_CONFIGS ${cmake_configs})
@@ -214,6 +233,15 @@ function(qt_internal_add_tool target_name)
                 unset(install_optional_arg)
             endif()
 
+            if(QT_GENERATE_SBOM)
+                _qt_internal_sbom_append_multi_config_aware_single_arg_option(
+                    RUNTIME_PATH
+                    "${runtime_install_destination}"
+                    "${cmake_config}"
+                    sbom_args
+                )
+            endif()
+
             qt_install(TARGETS "${target_name}"
                        ${install_initial_call_args}
                        ${install_optional_arg}
@@ -240,6 +268,28 @@ function(qt_internal_add_tool target_name)
 
     qt_enable_separate_debug_info(${target_name} "${install_dir}" QT_EXECUTABLE)
     qt_internal_install_pdb_files(${target_name} "${install_dir}")
+
+    if(QT_GENERATE_SBOM)
+        _qt_internal_forward_function_args(
+            FORWARD_APPEND
+            FORWARD_PREFIX arg
+            FORWARD_OUT_VAR sbom_args
+            FORWARD_OPTIONS
+                ${__qt_internal_sbom_optional_args}
+            FORWARD_SINGLE
+                ${__qt_internal_sbom_single_args}
+            FORWARD_MULTI
+                ${__qt_internal_sbom_multi_args}
+        )
+
+        _qt_internal_extend_sbom(${target_name} ${sbom_args})
+    endif()
+
+    qt_add_list_file_finalizer(qt_internal_finalize_tool ${target_name})
+endfunction()
+
+function(qt_internal_finalize_tool target)
+    _qt_internal_finalize_sbom(${target})
 endfunction()
 
 function(_qt_internal_add_try_run_post_build target try_run_flags)

cmake/QtToolchainHelpers.cmake

@@ -195,13 +195,27 @@ endif()")
         list(APPEND init_platform "endif()")
         list(APPEND init_platform "")
 
-        # For macOS user projects, default to not specifying any architecture. This means CMake will
-        # not pass an -arch flag to the compiler and the compiler will choose the default
-        # architecture to build for.
+        # For macOS user projects, the common case is to default to not specifying any architecture.
+        # This means CMake will not pass an -arch flag to the compiler and the compiler will
+        # choose the default architecture to build for.
         # On Apple Silicon, CMake will introspect whether it's running under Rosetta and will
         # pass the detected architecture (x86_64 under Rosetta or arm64 natively) to the compiler.
         # This is line with default CMake behavior for user projects.
-        #
+        # If Qt was cross-compiled to arm64 from an x86_64 host machine, or vice versa, we need
+        # to continue using the same architecture for the user project, otherwise the CMake default
+        # might be incorrect depending on which host arch the user project is built on.
+        if(NOT UIKIT)
+            list(LENGTH CMAKE_OSX_ARCHITECTURES arch_count)
+            if(arch_count EQUAL 1 AND CMAKE_CROSSCOMPILING AND CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+                list(APPEND init_platform
+"if(NOT __qt_toolchain_building_qt_repo AND NOT QT_NO_SET_OSX_ARCHITECTURES)"
+"    set(CMAKE_OSX_ARCHITECTURES \"${CMAKE_OSX_ARCHITECTURES}\" CACHE STRING \"\")"
+"    set(CMAKE_SYSTEM_NAME \"${CMAKE_SYSTEM_NAME}\" CACHE STRING \"\")"
+"endif()"
+                )
+            endif()
+        endif()
+
         # For iOS, we provide a bit more convenience.
         # When the user project is built using the Xcode generator, we only specify the architecture
         # if this is a single architecture Qt for iOS build. If we wouldn't, invoking just

cmake/QtWasmHelpers.cmake

@@ -11,16 +11,11 @@ function (qt_internal_setup_wasm_target_properties wasmTarget)
     "SHELL:-s WASM_BIGINT=1"
     "SHELL:-s STACK_SIZE=5MB")
 
-    target_link_libraries("${wasmTarget}" INTERFACE embind)
-
     ## wasm64
     if (WASM64)
         target_compile_options("${wasmTarget}" INTERFACE "SHELL:-s MEMORY64=1" )
         target_link_options("${wasmTarget}" INTERFACE   "SHELL:-s MEMORY64=1" -mwasm64)
     endif()
-    # Enable MODULARIZE so that we are able to set EXPORT_NAME later and instantiate on demand (with
-    # MODULARIZE=0, emscripten creates a global app instance object at Javascript eval time)
-    target_link_options("${wasmTarget}" INTERFACE "SHELL:-s MODULARIZE=1")
 
     #simd
     if (QT_FEATURE_wasm_simd128)
@@ -60,7 +55,6 @@ function (qt_internal_setup_wasm_target_properties wasmTarget)
 
     # a few good defaults to make console more verbose while debugging
     target_link_options("${wasmTarget}" INTERFACE $<$<CONFIG:Debug>:
-        "SHELL:-s DEMANGLE_SUPPORT=1"
         --profiling-funcs>)
 
     # target_link_options("${wasmTarget}" INTERFACE "SHELL:-s LIBRARY_DEBUG=1") # print out library calls, verbose
@@ -119,9 +113,5 @@ function (qt_internal_setup_wasm_target_properties wasmTarget)
 endfunction()
 
 function(qt_internal_wasm_add_finalizers target)
-    qt_add_list_file_finalizer(_qt_internal_set_wasm_export_name ${target})
-    qt_add_list_file_finalizer(_qt_internal_add_wasm_extra_exported_methods ${target})
-    qt_add_list_file_finalizer(_qt_internal_wasm_add_target_helpers ${target})
+    qt_add_list_file_finalizer(_qt_internal_finalize_wasm_app ${target})
 endfunction()
-
-

cmake/configure-cmake-mapping.md

@@ -45,6 +45,7 @@ The following table describes the mapping of configure options to CMake argument
 | -device-option <key=value>            | -DQT_QMAKE_DEVICE_OPTIONS=key1=value1;key2=value2 | Only used for generation qmake-compatibility files.             |
 |                                       |                                                   | The device options are written into mkspecs/qdevice.pri.        |
 | -appstore-compliant                   | -DFEATURE_appstore_compliant=ON                   |                                                                 |
+| -sbom                                 | -DQT_GENERATE_SBOM=ON                             | Enables generation and installation of an SBOM                  |
 | -qtinlinenamespace                    | -DQT_INLINE_NAMESPACE=ON                          | Make the namespace specified by -qtnamespace an inline one.     |
 | -qtnamespace <name>                   | -DQT_NAMESPACE=<name>                             |                                                                 |
 | -qtlibinfix <infix>                   | -DQT_LIBINFIX=<infix>                             |                                                                 |

coin/instructions/cmake_build_and_upload_test_artifacts.yaml

@@ -71,6 +71,11 @@ instructions:
     maxTimeBetweenOutput: 1200
     # INTEGRITY artifacts aren't used.
     disable_if:
-      condition: property
-      property: target.osVersion
-      equals_value: INTEGRITY
+      condition: or
+      conditions:
+        - condition: property
+          property: target.osVersion
+          equals_value: INTEGRITY
+        - condition: property
+          property: features
+          contains_value: DoNotUploadTests

coin/instructions/cmake_module_build_instructions.yaml

@@ -74,6 +74,9 @@ instructions:
     variableName: DESTDIR
     variableValue: "{{.InstallRoot}}"
   - !include "{{qt/qtbase}}/call_host_install.yaml"
+  - type: EnvironmentVariable
+    variableName: DESTDIR
+    variableValue: ""
   - type: SignPackage
     enable_if:
       condition: and

coin/instructions/cmake_qtbase_build_instructions.yaml

@@ -71,6 +71,9 @@ instructions:
     variableName: DESTDIR
     variableValue: "{{.InstallRoot}}"
   - !include "{{qt/qtbase}}/call_host_install.yaml"
+  - type: EnvironmentVariable
+    variableName: DESTDIR
+    variableValue: ""
   - type: SignPackage
     enable_if:
       condition: and

coin/instructions/cmake_regular_test_instructions.yaml

@@ -12,21 +12,4 @@ instructions:
   - type: ChangeDirectory
     directory: "{{.SourceDir}}_standalone_tests"
 
-  # Ignore CTest exit code for Tart configs, unless
-  # the module declares that it should be significant.
-  - type: Group
-    enable_if:
-      condition: and
-      conditions:
-        - condition: property
-          property: id
-          contains_value: tart
-        - condition: runtime
-          env_var: TART_SIGNIFICANT_TARGET_OSVERSIONS
-          not_contains_value: "{{.Env.TARGET_OSVERSION_COIN}}"
-    instructions:
-      - type: EnvironmentVariable
-        variableName: COIN_CTEST_IGNORE_EXIT_CODE
-        variableValue: "1"
-
   - !include "{{qt/qtbase}}/cmake_run_ctest.yaml"

coin/instructions/coin_module_build_template_v2.yaml

@@ -70,11 +70,11 @@ instructions:
         - condition: and
           conditions:
             - condition: property
-              property: host.compiler
-              equals_value: MSVC2019
+              property: target.os
+              equals_value: Windows
             - condition: property
               property: target.arch
-              equals_value: ARM64
+              not_equals_property: host.arch
             - condition: property
               property: features
               not_contains_value: "DebianPackaging"

coin/instructions/coin_module_test_docs.yaml

@@ -17,7 +17,7 @@ instructions:
 
   - type: EnvironmentVariable
     variableName: COIN_CMAKE_ARGS
-    variableValue: "-DQT_BUILD_TESTS=OFF"
+    variableValue: "-DQT_BUILD_TESTS=OFF {{.Env.COIN_DOC_CMAKE_ARGS}}"
   - type: EnvironmentVariable
     variableName: CONFIGURE_ENV_PREFIX
     variableValue: "{{.Env.ENV_PREFIX}}"

coin/instructions/coin_module_test_qnx_start_emulator.yaml

@@ -32,7 +32,7 @@ instructions:
 
             while :; do
                 echo "Waiting QEMU SSH coming up"
-                status=$(ssh -o BatchMode=yes -o ConnectTimeout=1 ${QEMUIPADDR} echo ok 2>&1)
+                status=$(ssh -o PreferredAuthentications=publickey -o BatchMode=yes -o ConnectTimeout=1 ${QEMUIPADDR} echo ok 2>&1)
                 RESULT=$?
                 if [ $RESULT -eq 0 ]; then
                     echo "QEMU SSH Connected ok"

coin/instructions/coin_module_test_template_v2.yaml

@@ -1,5 +1,12 @@
 type: Group
 instructions:
+  - type: Group
+    instructions:
+    - !include "{{qt/qtbase}}/run_license_check.yaml"
+    enable_if:
+      condition: property
+      property: features
+      contains_value: LicenseCheckV2
   - type: Group
     instructions:
       - !include "{{qt/qtbase}}/coin_module_test_template_common.yaml"
@@ -19,6 +26,11 @@ instructions:
               property: target.osVersion
               in_values: [QEMU, QNX_710]
     disable_if:
-      condition: property
-      property: features
-      contains_value: DisableTests
+      condition: or
+      conditions:
+        - condition: property
+          property: features
+          contains_value: DisableTests
+        - condition: property
+          property: features
+          contains_value: LicenseCheckV2

coin/instructions/coin_module_test_template_v3.yaml

@@ -1,5 +1,12 @@
 type: Group
 instructions:
+  - type: Group
+    instructions:
+    - !include "{{qt/qtbase}}/run_license_check.yaml"
+    enable_if:
+      condition: property
+      property: features
+      contains_value: LicenseCheckV2
   - type: Group
     instructions:
       - !include "{{qt/qtbase}}/coin_module_test_template_common.yaml"
@@ -19,6 +26,11 @@ instructions:
               property: features
               contains_value: AndroidTestRun
     disable_if:
-      condition: property
-      property: features
-      contains_value: DisableTests
+      condition: or
+      conditions:
+        - condition: property
+          property: features
+          contains_value: DisableTests
+        - condition: property
+          property: features
+          contains_value: LicenseCheckV2

coin/instructions/coin_qtbase_build_template_v2.yaml

@@ -61,11 +61,11 @@ instructions:
         - condition: and
           conditions:
             - condition: property
-              property: host.compiler
-              equals_value: MSVC2019
+              property: target.os
+              equals_value: Windows
             - condition: property
               property: target.arch
-              equals_value: ARM64
+              not_equals_property: host.arch
             - condition: property
               property: features
               not_contains_value: "DebianPackaging"

coin/instructions/prepare_building_env.yaml

@@ -347,11 +347,11 @@ instructions:
       condition: and
       conditions:
         - condition: property
-          property: host.compiler
-          equals_value: MSVC2019
+          property: target.os
+          equals_value: Windows
         - condition: property
           property: target.arch
-          equals_value: ARM64
+          not_equals_property: host.arch
     instructions:
       - type: EnvironmentVariable
         variableName: TARGET_ENV_PREFIX
@@ -473,6 +473,74 @@ instructions:
         property: features
         contains_value: UseConfigure
 
+  # SBOM
+  - type: Group
+    enable_if:
+      condition: property
+      property: features
+      contains_value: GenerateSBOM
+    instructions:
+    - type: AppendToEnvironmentVariable
+      variableName: COMMON_CMAKE_ARGS
+      variableValue: " -DQT_GENERATE_SBOM=ON -DQT_GENERATE_SOURCE_SBOM=ON"
+    - type: AppendToEnvironmentVariable
+      variableName: COMMON_NON_QTBASE_CMAKE_ARGS
+      variableValue: " -DQT_GENERATE_SBOM=ON -DQT_GENERATE_SOURCE_SBOM=ON"
+    - type: AppendToEnvironmentVariable
+      variableName: COMMON_TARGET_CMAKE_ARGS
+      variableValue: " -DQT_GENERATE_SBOM=ON -DQT_GENERATE_SOURCE_SBOM=ON"
+    - type: AppendToEnvironmentVariable
+      variableName: COMMON_NON_QTBASE_TARGET_CMAKE_ARGS
+      variableValue: " -DQT_GENERATE_SBOM=ON -DQT_GENERATE_SOURCE_SBOM=ON"
+
+  # SBOM Python apps path. On Windows python-installed apps are
+  # in the same directory where pip is, aka Scripts sub-directory.
+  - type: EnvironmentVariable
+    variableName: SBOM_PYTHON_APPS_PATH
+    variableValue: "{{.Env.PIP3_PATH}}"
+    enable_if:
+      condition: property
+      property: host.os
+      equals_value: Windows
+  - type: EnvironmentVariable
+    variableName: SBOM_PYTHON_APPS_PATH
+    variableValue: "{{.Env.PYTHON3_PATH}}"
+    disable_if:
+      condition: property
+      property: host.os
+      equals_value: Windows
+
+
+  # SBOM verification and auditing
+  - type: Group
+    enable_if:
+      condition: property
+      property: features
+      contains_value: VerifySBOM
+    instructions:
+    - type: EnvironmentVariable
+      variableName: SBOM_COMMON_ARGS
+      variableValue: >-
+        -DQT_LINT_SOURCE_SBOM=ON
+        -DQT_INTERNAL_NO_SBOM_FIND_PYTHON_FRAMEWORK=ON
+        -DQT_INTERNAL_SBOM_DEFAULT_CHECKS=ON
+        -DQT_INTERNAL_SBOM_AUDIT=ON
+        -DQT_INTERNAL_SBOM_AUDIT_NO_ERROR=ON
+        -DQT_SBOM_PYTHON_INTERP={{.Env.PYTHON3_PATH}}
+        -DQT_SBOM_PYTHON_APPS_PATH={{.Env.SBOM_PYTHON_APPS_PATH}}
+    - type: AppendToEnvironmentVariable
+      variableName: COMMON_CMAKE_ARGS
+      variableValue: " {{.Env.SBOM_COMMON_ARGS}} "
+    - type: AppendToEnvironmentVariable
+      variableName: COMMON_NON_QTBASE_CMAKE_ARGS
+      variableValue: " {{.Env.SBOM_COMMON_ARGS}} "
+    - type: AppendToEnvironmentVariable
+      variableName: COMMON_TARGET_CMAKE_ARGS
+      variableValue: " {{.Env.SBOM_COMMON_ARGS}} "
+    - type: AppendToEnvironmentVariable
+      variableName: COMMON_NON_QTBASE_TARGET_CMAKE_ARGS
+      variableValue: " {{.Env.SBOM_COMMON_ARGS}} "
+
   - type: Group
     instructions:
       - type: AppendToEnvironmentVariable

coin/instructions/run_license_check.yaml

@@ -0,0 +1,23 @@
+type: Group
+instructions:
+    - type: ChangeDirectory
+      directory: "{{.AgentWorkingDir}}"
+    - type: InstallSourceArchive
+      maxTimeInSeconds: 600
+      maxTimeBetweenOutput: 600
+      project: qt/qtqa
+      ref: dev
+      directory: qt/qtqa-latest
+      userMessageOnFailure: >
+              Could not install qtqa source archive. Please investigate why.
+    - type: EnvironmentVariable
+      variableName: QT_MODULE_TO_TEST
+      variableValue: "{{.SourceDir}}"
+      userMessageOnFailure: >
+              Failed to set QT_MODULE_TO_TEST environment variable. This should not happen.
+    - type: ExecuteCommand
+      command: perl qt/qtqa-latest/tests/prebuild/license/tst_licenses.pl
+      maxTimeInSeconds: 7200
+      maxTimeBetweenOutput: 120
+      userMessageOnFailure: >
+           Failed to run license check script.

config.tests/arch/arch.cpp

@@ -239,7 +239,7 @@ const char msg2[] = "==Qt=magic=Qt== Sub-architecture:"
 #endif
 
 // -- ARM --
-#if defined(__ARM_NEON) || defined(__ARM_NEON__)
+#if defined(__ARM_NEON) || defined(__ARM_NEON__) || defined(_M_ARM64)
 " neon"
 #endif
 #ifdef __IWMMXT__

config_help.txt

@@ -2,6 +2,10 @@ Usage:  configure [options] [-- cmake-options]
 
 This is a convenience script for configuring Qt with CMake.
 Options after the double dash are directly passed to CMake.
+You can pass CMake variables as configure arguments:
+    configure VAR=value
+which is equivalent to
+    configure -- -DVAR=value
 
 Top-level installation directories:
   -prefix <dir> ...... The deployment directory, as seen on the target device.
@@ -25,6 +29,8 @@ except -sysconfdir should be located under -prefix:
   -libexecdir <dir> ..... Helper programs [ARCHDATADIR/bin on Windows,
                           ARCHDATADIR/libexec otherwise]
   -qmldir <dir> ......... QML imports [ARCHDATADIR/qml]
+  -sbomdir <dir> .......  Software Bill of Materials (SBOM)
+                          installation directory [ARCHDATADIR/sbom]
   -datadir <dir> ........ Arch-independent data [PREFIX]
   -docdir <dir> ......... Documentation [DATADIR/doc]
   -translationdir <dir> . Translations [DATADIR/translations]
@@ -99,6 +105,9 @@ Build options:
                          through an app store by default, in particular Android,
                          iOS, tvOS, and watchOS. [auto]
 
+  -sbom ................ Enable Software Bill of Materials (SBOM) generation
+                         [no]
+
   -qt-host-path <path> . Specify path to a Qt host build for cross-compiling.
   -qtnamespace <name> .. Wrap all Qt library code in 'namespace <name> {...}'.
   -qtinlinenamespace ... Make -qtnamespace an inline namespace

configure.cmake

@@ -370,6 +370,36 @@ qt_config_compile_test_x86simd(avx512vbmi2 "AVX512VBMI2")
 # x86: vaes
 qt_config_compile_test_x86simd(vaes "VAES")
 
+# localtime_r
+qt_config_compile_test(localtime_r
+    LABEL "localtime_r()"
+    CODE
+"#include <time.h>
+
+int main(void)
+{
+    /* BEGIN TEST: */
+(void) localtime_r(nullptr, nullptr);
+    /* END TEST: */
+    return 0;
+}
+")
+
+# localtime_s
+qt_config_compile_test(localtime_s
+    LABEL "localtime_s()"
+    CODE
+"#include <time.h>
+
+int main(void)
+{
+    /* BEGIN TEST: */
+(void) localtime_s(nullptr, nullptr);
+    /* END TEST: */
+    return 0;
+}
+")
+
 # posix_fallocate
 qt_config_compile_test(posix_fallocate
     LABEL "POSIX fallocate()"
@@ -457,10 +487,13 @@ if(NOT CLANG) # https://gitlab.kitware.com/cmake/cmake/-/issues/21998
 endif()
 
 # trivial_auto_var_init_pattern
-qt_config_compiler_supports_flag_test(trivial_auto_var_init_pattern
-    LABEL "-ftrivial-auto-var-init=pattern support"
-    FLAG "-ftrivial-auto-var-init=pattern"
-)
+if(NOT GCC OR CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "14.2.0")
+    # Causes broken codegen on GCC https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115527
+    qt_config_compiler_supports_flag_test(trivial_auto_var_init_pattern
+        LABEL "-ftrivial-auto-var-init=pattern support"
+        FLAG "-ftrivial-auto-var-init=pattern"
+    )
+endif()
 
 # intelcet
 if(MSVC)
@@ -560,9 +593,9 @@ qt_feature("optimize_full"
 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
+    EMIT_IF MSVC
 )
 qt_feature_config("msvc_obj_debug_info" QMAKE_PRIVATE_CONFIG)
 qt_feature("pkg-config" PUBLIC
@@ -643,6 +676,8 @@ qt_feature("force_asserts" PUBLIC
 qt_feature("framework" PUBLIC
     LABEL "Build Apple Frameworks"
     AUTODETECT ON
+    # If changing this, please align with logic in
+    # qt_internal_setup_cmake_config_postfix.
     CONDITION APPLE
 )
 qt_feature_definition("framework" "QT_MAC_FRAMEWORK_BUILD")
@@ -701,7 +736,7 @@ qt_feature_config("plugin-manifests" QMAKE_PUBLIC_CONFIG
 qt_feature("c++20" PUBLIC
     LABEL "C++20"
     AUTODETECT OFF
-    CONDITION TEST_cxx20
+    CONDITION TEST_cxx20 AND NOT VXWORKS
 )
 qt_feature_config("c++20" QMAKE_PUBLIC_QT_CONFIG)
 qt_feature("c++2a" PUBLIC
@@ -952,6 +987,14 @@ qt_feature("wasm-exceptions" PUBLIC
 qt_feature_definition("wasm-exceptions" "QT_WASM_EXCEPTIONS" VALUE "1")
 qt_feature_config("wasm-exceptions" QMAKE_PRIVATE_CONFIG)
 
+qt_feature("localtime_r" PRIVATE
+    LABEL "localtime_r()"
+    CONDITION TEST_localtime_r
+)
+qt_feature("localtime_s" PRIVATE
+    LABEL "localtime_s()"
+    CONDITION TEST_localtime_s
+)
 qt_feature("posix_fallocate" PRIVATE
     LABEL "POSIX fallocate()"
     CONDITION TEST_posix_fallocate

doc/global/externalsites/qtcreator.qdoc

@@ -39,6 +39,11 @@
     \externalpage https://doc.qt.io/qtcreator/creator-how-tos.html
     \title Qt Creator: How-tos
 */
+/*!
+    \externalpage https://doc.qt.io/qtcreator/creator-how-to-build-and-run-tests.html
+    \title Qt Creator: Build and Run Tests
+*/
+
 /*!
     \externalpage https://doc.qt.io/qtcreator/creator-help.html
     \title Qt Creator: Using the Help Mode
@@ -600,7 +605,7 @@
     \title Qt Creator: Visualizing Chrome Trace Events
 */
 /*!
-    \externalpage https://doc.qt.io/qtcreator/creator-autotest.html
+    \externalpage https://doc.qt.io/qtcreator/creator-how-to-build-and-run-tests.html
     \title Qt Creator: Running Autotests
 */
 /*!

doc/global/grid.qdocconf

@@ -0,0 +1,59 @@
+# Macros for laying out a three-column grid structure of
+# items in online documentation. Takes three arguments,
+# wrapped in braces:
+#   a link, a title, and a description.
+
+# Usage:
+#   \grid
+#       \griditem {qtqml-index.html} {Qt Qml} {Classes for QML and JavaScript languages.}
+#       \griditem {qtquick-index.html} {Qt Quick} {
+#           Declarative framework for dynamic apps with custom UIs.
+#       }
+#       \griditem {qtquickcontrols-index.html} {Qt Quick Controls} {
+#           Lightweight QML types for creating performant user
+#           interfaces.
+#       }
+#   \endgrid
+
+# Note: For offline documentation, these macros
+# generate a \table structure instead.
+
+
+macro.grid = \
+"\\if defined(onlinedocs)\n" \
+"  \\raw HTML\n" \
+"  <div class=\"grid\">\n" \
+"  <ul class=\"l-tile\" data-column=\"3\">\n" \
+"  \\endraw\n" \
+"\\else\n" \
+"  \\table\n" \
+"\\endif\n"
+
+macro.griditem = \
+"\\detailedgriditem {\1} {\2} {\3} {#} {}"
+
+macro.detailedgriditem = \
+"\\if defined(onlinedocs)\n" \
+"  \\raw HTML\n" \
+"  <li class=\"l-tile__item\">\n" \
+"    <div class=\"c-feature c-feature--external-link\" data-scheme=\"\">\n" \
+"      <h3>\2</h3>\n" \
+"      <p>\3</p>\n" \
+"      <a class=\"c-feature__overlay-link\" href=\"\1\"></a>\n" \
+"      <a data-tag=\"\5\" href=\"\4\"></a>\n" \
+"    </div>\n" \
+"  </li>\n" \
+"  \\endraw\n" \
+"\\else\n" \
+"  \\row \\li \\l {\1}{\2} \\li \3\n" \
+"\\endif\n"
+
+macro.endgrid = \
+"\\if defined(onlinedocs)\n" \
+"  \\raw HTML\n" \
+"  </ul></div>\n" \
+"  \\endraw\n" \
+"\\else\n" \
+"  \\endtable\n" \
+"\\endif\n"
+

doc/global/macros.qdocconf

@@ -96,8 +96,8 @@ macro.AndroidMinVer       = "9"
 macro.AndroidMaxVer       = "14"
 macro.AndroidPlatformVer  = "34"
 macro.AndroidBuildToolsVer = "34.0.0"
-macro.GradleVer           = "8.7"
-macro.AGPVer              = "8.4.0"
+macro.GradleVer           = "8.10"
+macro.AGPVer              = "8.6.0"
 macro.AAOSVer             = "10 to 13"
 
 macro.beginfloatleft.HTML   = "<div style=\"float: left; margin-right: 2em\">"
@@ -171,3 +171,5 @@ macro.qtpolicydeprecatedbehavior = "\\note The \\c{OLD} behavior of a policy is
 #group.
 #Must be placed directly under a \brief command
 macro.techpreview = "(Technical preview)\n\n\\meta status {Technical preview}\n\\ingroup tech_preview\n"
+
+include(grid.qdocconf)

doc/global/template/style/offline.css

@@ -642,14 +642,7 @@ Content table
 
 @media print {
     .toc {
-        float: right;
-        clear: right;
-        padding-bottom: 10px;
-        padding-top: 50px;
-        width: 100%;
-        background-image: url(../images/bgrContent.png);
-        background-position: top;
-        background-repeat: no-repeat;
+        display: none;
     }
 }
 
@@ -731,6 +724,9 @@ Landing page
     vertical-align: top;
 }
 
+.landing {
+    display: flex;
+}
 
 .landing h2 {
     background-color: transparent;
@@ -745,19 +741,14 @@ Landing page
 }
 
 .col-1 {
-    display: inline-block;
     white-space: normal;
     width: 70%;
-    height: 100%;
-    float: left;
 }
 
 .col-2 {
-    display: inline-block;
     white-space: normal;
     width: 20%;
     margin-left: 5%;
-    position: relative;
     top: -20px;
 }
 

examples/corelib/threads/doc/src/queuedcustomtype.qdoc

@@ -12,10 +12,6 @@
 
     \image queuedcustomtype-example.png
 
-    Contents:
-
-    \tableofcontents
-
     \section1 Overview
 
     In this example, we create a value class, \c Block, and register it with

examples/opengl/doc/src/cube.qdoc

@@ -34,8 +34,6 @@
 
     We'll start by initializing OpenGL ES 2.0 in \c MainWidget.
 
-    \tableofcontents
-
     \section1 Initializing OpenGL ES 2.0
 
     Since OpenGL ES 2.0 doesn't support fixed graphics pipeline anymore it has to

examples/sql/masterdetail/CMakeLists.txt

@@ -32,6 +32,7 @@ target_link_libraries(masterdetail PRIVATE
 set(masterdetail_resource_files
     "images/icon.png"
     "images/image.png"
+    "albumdetails.xml"
 )
 
 qt_add_resources(masterdetail "masterdetail"

examples/sql/masterdetail/dialog.cpp

@@ -173,6 +173,7 @@ void Dialog::increaseAlbumCount(const QModelIndex &artistIndex)
 
     int albumCount = albumCountIndex.data().toInt();
     artistModel->setData(albumCountIndex, QVariant(albumCount + 1));
+    artistModel->submitAll();
 }
 
 

examples/sql/masterdetail/main.cpp

@@ -14,7 +14,7 @@ int main(int argc, char *argv[])
     if (!createConnection())
         return EXIT_FAILURE;
 
-    QFile albumDetails("albumdetails.xml");
+    QFile albumDetails(":/albumdetails.xml");
     MainWindow window("artists", "albums", &albumDetails);
     window.show();
     return app.exec();

examples/sql/masterdetail/mainwindow.cpp

@@ -202,6 +202,8 @@ void MainWindow::removeAlbumFromFile(int id)
 void MainWindow::removeAlbumFromDatabase(const QModelIndex &index)
 {
     model->removeRow(index.row());
+    // to avoid a blank row, see QSqlTableModel::removeRows()
+    model->select();
 }
 
 void MainWindow::decreaseAlbumCount(const QModelIndex &artistIndex)
@@ -217,6 +219,7 @@ void MainWindow::decreaseAlbumCount(const QModelIndex &artistIndex)
         showImageLabel();
     } else {
         artists->setData(albumCountIndex, QVariant(albumCount - 1));
+        artists->submitAll();
     }
 }
 

examples/sql/masterdetail/masterdetail.qrc

@@ -2,5 +2,6 @@
  <qresource>
     <file>images/icon.png</file>
     <file>images/image.png</file>
+    <file>albumdetails.xml</file>
  </qresource>
 </RCC>

examples/widgets/desktop/systray/main.cpp

@@ -13,10 +13,12 @@ int main(int argc, char *argv[])
     QApplication app(argc, argv);
 
     if (!QSystemTrayIcon::isSystemTrayAvailable()) {
-        QMessageBox::critical(nullptr, QObject::tr("Systray"),
-                              QObject::tr("I couldn't detect any system tray "
-                                          "on this system."));
-        return 1;
+        auto choice = QMessageBox::critical(nullptr, QObject::tr("Systray"),
+            QObject::tr("I couldn't detect any system tray on this system."),
+            QMessageBox::Close | QMessageBox::Ignore);
+        if (choice == QMessageBox::Close)
+            return 1;
+        // Otherwise "lurk": if a system tray is started later, the icon will appear.
     }
     QApplication::setQuitOnLastWindowClosed(false);
 

examples/widgets/gallery/main.cpp

@@ -9,6 +9,7 @@
 int main(int argc, char *argv[])
 {
     QApplication app(argc, argv);
+    app.styleHints()->setColorScheme(Qt::ColorScheme::Dark);
     WidgetGallery gallery;
     gallery.show();
     return QCoreApplication::exec();

examples/widgets/gallery/widgetgallery.cpp

@@ -140,9 +140,7 @@ WidgetGallery::WidgetGallery(QWidget *parent)
     colorSchemeComboBox->addItem(tr("Auto"));
     colorSchemeComboBox->addItem(tr("Light"));
     colorSchemeComboBox->addItem(tr("Dark"));
-    // override the color scheme to dark
-    qApp->styleHints()->setColorScheme(Qt::ColorScheme::Dark);
-    colorSchemeComboBox->setCurrentIndex(2);
+    colorSchemeComboBox->setCurrentIndex(static_cast<int>(qApp->styleHints()->colorScheme()));
 
     auto colorSchemeLabel = createWidget1<QLabel>(tr("&Color Scheme:"), "colorSchemeLabel");
     colorSchemeLabel->setBuddy(colorSchemeComboBox);

licenseRule.json

@@ -22,6 +22,16 @@
                 "file type" : "examples and snippets",
                 "spdx" : ["LicenseRef-Qt-Commercial OR BSD-3-Clause"]
             },
+            "cmake/QtPublicGitHelpers.cmake" : {
+                "comment" : "MIT licensed copied parts",
+                "file type" : "build system",
+                "spdx" : ["BSD-3-Clause AND MIT"]
+            },
+            "cmake/QtPublicSbomGenerationHelpers.cmake" : {
+                "comment" : "MIT licensed copied parts",
+                "file type" : "build system",
+                "spdx" : ["MIT AND BSD-3-Clause"]
+            },
             "tests/auto/cmake/test_plugin_shared_static_flavor\\.cmake" : {
                 "comment" : "Exception. This is a test file.",
                 "file type" : "test",
@@ -169,6 +179,11 @@
                 "file type" : "util",
                 "spdx" : ["LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0"]
             },
+            "util/locale_database/testlocales/localemodel.cpp" : {
+                "comment" : "Exception: this contains CLDR-generated code",
+                "file type" : "util",
+                "spdx" : ["Unicode-3.0"]
+            },
             "util/wasm/batchedtestrunner/" : {
                 "comment" : "Exception: this is a helper tool",
                 "file type" : "util",

mkspecs/common/wasm/wasm.conf

@@ -42,7 +42,6 @@ EMCC_COMMON_LFLAGS += \
 # but are here in debug for clarity.
 EMCC_COMMON_LFLAGS_DEBUG = \
     $$EMCC_COMMON_LFLAGS \
-    -s DEMANGLE_SUPPORT=1 \
     # -s LIBRARY_DEBUG=1 \ #print out library calls, verbose
     # -s SYSCALL_DEBUG=1 \ #print out sys calls, verbose
     # -s FS_LOG=1 \ #print out filesystem ops, verbose

mkspecs/features/qt_functions.prf

@@ -19,8 +19,13 @@ defineReplace(qtPlatformTargetSuffix) {
     }
     darwin {
         contains($$config_variable, debug, debug|release) {
-            !debug_and_release|build_pass: \
-                return($${suffix}_debug)
+            debug_and_release {
+                build_pass: \
+                    return($${suffix}_debug)
+            } else {
+                !qtConfig(framework): \
+                    return($${suffix}_debug)
+            }
         }
     }
     return($$suffix)

mkspecs/features/resolve_config.prf

@@ -45,7 +45,7 @@ CONFIG(debug, debug|release) {
             equals(build, debug): \
                 suffix = _debug
         } else {
-            contains(QT_CONFIG, debug): \
+            !qtConfig(framework):contains(QT_CONFIG, debug): \
                 suffix = _debug
         }
 

mkspecs/features/wasm/emcc_ver.prf

@@ -1,5 +1,5 @@
 defineReplace(qtEmccRecommendedVersion) {
-    return (3.1.50)
+    return (3.1.56)
 }
 
 defineReplace(qtSystemEmccVersion) {

qmake/CMakeLists.txt

@@ -8,44 +8,57 @@
 #####################################################################
 
 # The common object library, that should be available regardless of the presence of qmake.
-qt_add_library(QtLibraryInfo OBJECT
-    library/proitems.cpp library/proitems.h
-    library/qmake_global.h
-    property.cpp property.h
-    propertyprinter.cpp propertyprinter.h
-    qmakelibraryinfo.cpp qmakelibraryinfo.h
-)
+if(QT_WILL_BUILD_TOOLS)
+    qt_add_library(QtLibraryInfo OBJECT
+        library/proitems.cpp library/proitems.h
+        library/qmake_global.h
+        property.cpp property.h
+        propertyprinter.cpp propertyprinter.h
+        qmakelibraryinfo.cpp qmakelibraryinfo.h
+    )
+    qt_internal_add_sbom(QtLibraryInfo
+        TYPE QT_MODULE
+        NO_INSTALL
+    )
 
-# Make sure we use same parameters when building QtLibraryInfo and other Qt libraries,
-# otherwise some compilers may have compilation errors, such as clang-cl.
-target_link_libraries(QtLibraryInfo PUBLIC PlatformCommonInternal)
+    # Make sure we use same parameters when building QtLibraryInfo and other Qt libraries,
+    # otherwise some compilers may have compilation errors, such as clang-cl.
+    target_link_libraries(QtLibraryInfo PUBLIC PlatformCommonInternal)
 
-target_link_libraries(QtLibraryInfo PUBLIC Qt::CorePrivate)
+    target_link_libraries(QtLibraryInfo PUBLIC Qt::CorePrivate)
 
-qt_internal_add_sync_header_dependencies(QtLibraryInfo Core)
+    qt_internal_add_sync_header_dependencies(QtLibraryInfo Core)
 
-target_include_directories(QtLibraryInfo PUBLIC
-    "${CMAKE_CURRENT_SOURCE_DIR}"
-    "${CMAKE_CURRENT_SOURCE_DIR}/library"
-)
+    target_include_directories(QtLibraryInfo PUBLIC
+        "${CMAKE_CURRENT_SOURCE_DIR}"
+        "${CMAKE_CURRENT_SOURCE_DIR}/library"
+    )
 
-# Chop off the "/mkspecs" part of INSTALL_MKSPECSDIR
-get_filename_component(hostdatadir "${INSTALL_MKSPECSDIR}" DIRECTORY)
-if("${hostdatadir}" STREQUAL "")
-    set(hostdatadir ".")
+    # Chop off the "/mkspecs" part of INSTALL_MKSPECSDIR
+    get_filename_component(hostdatadir "${INSTALL_MKSPECSDIR}" DIRECTORY)
+    if("${hostdatadir}" STREQUAL "")
+        set(hostdatadir ".")
+    endif()
+
+    target_compile_definitions(QtLibraryInfo PUBLIC
+        PROEVALUATOR_FULL
+        QT_BUILD_QMAKE
+        QT_USE_QSTRINGBUILDER
+        QT_HOST_MKSPEC="${QT_QMAKE_HOST_MKSPEC}"
+        QT_TARGET_MKSPEC="${QT_QMAKE_TARGET_MKSPEC}"
+        QT_HOST_DATADIR="${hostdatadir}"
+    )
+
+    qt_internal_set_exceptions_flags(QtLibraryInfo OFF)
+
+    # Add QMAKE_VERSION_STR only if qmake is part of the build.
+    if(QT_FEATURE_qmake)
+        target_compile_definitions(QtLibraryInfo PUBLIC
+                QMAKE_VERSION_STR="3.1"
+        )
+    endif()
 endif()
 
-target_compile_definitions(QtLibraryInfo PUBLIC
-    PROEVALUATOR_FULL
-    QT_BUILD_QMAKE
-    QT_USE_QSTRINGBUILDER
-    QT_HOST_MKSPEC="${QT_QMAKE_HOST_MKSPEC}"
-    QT_TARGET_MKSPEC="${QT_QMAKE_TARGET_MKSPEC}"
-    QT_HOST_DATADIR="${hostdatadir}"
-)
-
-qt_internal_set_exceptions_flags(QtLibraryInfo OFF)
-
 if(NOT QT_FEATURE_qmake)
     return()
 endif()
@@ -99,13 +112,21 @@ qt_internal_add_tool(${target_name}
         generators/win32/msvc_objectmodel.cpp # xml symbols clash with generators/win32/msbuild_objectmodel.cpp
         library/qmakeparser.cpp               # struct statics clashes with qmakeevaluator_p.h
 )
-qt_internal_return_unless_building_tools()
 
-# Add QMAKE_VERSION_STR only if qmake is part of the build.
-target_compile_definitions(QtLibraryInfo PUBLIC
-        QMAKE_VERSION_STR="3.1"
+# When we don't build tools, we still want to be able to build the documentation.
+# Add a fake interface library to make sure the documentation target is created.
+# We use the direct name rather than ${target_name} to ensure the doc target keeps
+# the original name even when cross-building.
+if(NOT TARGET qmake)
+    add_library(qmake INTERFACE)
+endif()
+
+qt_internal_add_docs(qmake
+    doc/qmake.qdocconf
 )
 
+qt_internal_return_unless_building_tools()
+
 #### Keys ignored in scope 1:.:.:qmake.pro:<TRUE>:
 # _OPTION = "host_build"
 
@@ -133,6 +154,3 @@ set_target_properties(${target_name} PROPERTIES
 qt_internal_apply_gc_binaries(${target_name} PRIVATE)
 qt_skip_warnings_are_errors(${target_name})
 
-qt_internal_add_docs(${target_name}
-    doc/qmake.qdocconf
-)

qmake/generators/win32/msvc_nmake.cpp

@@ -314,9 +314,9 @@ void NmakeMakefileGenerator::writeImplicitRulesPart(QTextStream &t)
         const QStringList sourceFilesFilter = sourceFilesForImplicitRulesFilter();
         QStringList fixifiedSourceDirs = fileFixify(QList<QString>(source_directories.constBegin(), source_directories.constEnd()), FileFixifyAbsolute);
         fixifiedSourceDirs.removeDuplicates();
-        constexpr auto filters = QDir::Files | QDir::NoDotAndDotDot;
+        using F = QDirListing::IteratorFlag;
         for (const QString &sourceDir : std::as_const(fixifiedSourceDirs)) {
-            for (const auto &dirEntry : QDirListing(sourceDir, sourceFilesFilter, filters)) {
+            for (const auto &dirEntry : QDirListing(sourceDir, sourceFilesFilter, F::FilesOnly)) {
                 QString &duplicate = fileNames[dirEntry.completeBaseName()];
                 if (duplicate.isNull()) {
                     duplicate = dirEntry.filePath();

qmake/generators/win32/msvc_vcproj.cpp

@@ -1293,9 +1293,8 @@ void VcprojGenerator::initDeploymentTool()
             }
 
             int pathSize = searchPath.size();
-            constexpr auto filters = QDir::Files | QDir::NoDotAndDotDot | QDir::NoSymLinks;
             using F = QDirListing::IteratorFlag;
-            QDirListing dirList(searchPath, QStringList{nameFilter}, filters, F::Recursive);
+            QDirListing dirList(searchPath, QStringList{nameFilter}, F::FilesOnly | F::Recursive);
             // foreach dirIterator-entry in d
             for (const auto &dirEntry : dirList) {
                 const QString absoluteItemPath = Option::fixPathToTargetOS(dirEntry.absolutePath());

qmake/library/ioutils.cpp

@@ -221,15 +221,21 @@ bool IoUtils::touchFile(const QString &targetFileName, const QString &referenceF
         *errorString = fL1S("Cannot stat() reference file %1: %2.").arg(referenceFileName, fL1S(strerror(errno)));
         return false;
     }
-#    if defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L
-    const struct timespec times[2] = { { 0, UTIME_NOW }, st.st_mtim };
+#    if (defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L) || defined(Q_OS_DARWIN)
+    const struct timespec times[2] = { { 0, UTIME_NOW },
+#      if defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L
+        st.st_mtim // POSIX.1-2008
+#      else
+        st.st_mtimespec // Darwin
+#      endif
+    };
     const bool utimeError = utimensat(AT_FDCWD, targetFileName.toLocal8Bit().constData(), times, 0) < 0;
 #    else
     struct utimbuf utb;
     utb.actime = time(0);
     utb.modtime = st.st_mtime;
     const bool utimeError= utime(targetFileName.toLocal8Bit().constData(), &utb) < 0;
-#    endif
+#    endif // (defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L) || defined(Q_OS_DARWIN)
     if (utimeError) {
         *errorString = fL1S("Cannot touch %1: %2.").arg(targetFileName, fL1S(strerror(errno)));
         return false;
@@ -256,7 +262,7 @@ bool IoUtils::touchFile(const QString &targetFileName, const QString &referenceF
     }
     SetFileTime(wHand, NULL, NULL, &ft);
     CloseHandle(wHand);
-#  endif
+#  endif // Q_OS_UNIX
     return true;
 }
 

qmake/library/qmakeevaluator.cpp

@@ -1046,6 +1046,11 @@ void QMakeEvaluator::loadDefaults()
     case PROCESSOR_ARCHITECTURE_AMD64:
         archStr = ProString("x86_64");
         break;
+# endif
+# ifdef PROCESSOR_ARCHITECTURE_ARM64
+    case PROCESSOR_ARCHITECTURE_ARM64:
+        archStr = ProString("arm64");
+        break;
 # endif
     case PROCESSOR_ARCHITECTURE_INTEL:
         archStr = ProString("x86");

qt_cmdline.cmake

@@ -141,7 +141,10 @@ function(qt_commandline_cxxstd arg val nextok)
         qtConfAddError("Missing argument to command line parameter '${arg}'.")
         return()
     endif()
-    if(val MATCHES "(c\\+\\+)?(20|2a)")
+    if(val MATCHES "(c\\+\\+)?(17|1z)")
+        qtConfCommandlineDisableFeature(c++20)
+        qtConfCommandlineDisableFeature(c++2b)
+    elseif(val MATCHES "(c\\+\\+)?(20|2a)")
         qtConfCommandlineEnableFeature(c++20)
         qtConfCommandlineDisableFeature(c++2b)
     elseif(val MATCHES "(c\\+\\+)?(2b)")

src/3rdparty/CMakeLists.txt

@@ -8,6 +8,8 @@ if(QT_FEATURE_gui AND QT_FEATURE_jpeg AND NOT QT_FEATURE_system_jpeg)
 endif()
 qt_install_3rdparty_library_wrap_config_extra_file(BundledLibjpeg)
 
+# Needed for freetype, because it links against WrapPNG
+qt_find_package(WrapPNG PROVIDED_TARGETS WrapPNG::WrapPNG)
 if(QT_FEATURE_gui AND QT_FEATURE_freetype AND NOT QT_FEATURE_system_freetype)
     add_subdirectory(freetype)
 endif()

src/3rdparty/freetype/README

@@ -1,4 +1,4 @@
-FreeType 2.13.2
+FreeType 2.13.3
 ===============
 
 Homepage: https://www.freetype.org
@@ -32,9 +32,9 @@ sites.  Go to
 
 and download one of the following files.
 
-  freetype-doc-2.13.2.tar.xz
-  freetype-doc-2.13.2.tar.gz
-  ftdoc2132.zip
+  freetype-doc-2.13.3.tar.xz
+  freetype-doc-2.13.3.tar.gz
+  ftdoc2133.zip
 
 To view the documentation online, go to
 
@@ -94,7 +94,7 @@ Enjoy!
 
 ----------------------------------------------------------------------
 
-Copyright (C) 2006-2023 by
+Copyright (C) 2006-2024 by
 David Turner, Robert Wilhelm, and Werner Lemberg.
 
 This  file is  part of  the FreeType  project, and  may only  be used,

src/3rdparty/freetype/builds/unix/ftsystem.c

@@ -4,7 +4,7 @@
  *
  *   Unix-specific FreeType low-level system interface (body).
  *
- * Copyright (C) 1996-2023 by
+ * Copyright (C) 1996-2024 by
  * David Turner, Robert Wilhelm, and Werner Lemberg.
  *
  * This file is part of the FreeType project, and may only be used,

src/3rdparty/freetype/builds/windows/ftdebug.c

@@ -4,7 +4,7 @@
  *
  *   Debugging and logging component for Win32 (body).
  *
- * Copyright (C) 1996-2023 by
+ * Copyright (C) 1996-2024 by
  * David Turner, Robert Wilhelm, and Werner Lemberg.
  *
  * This file is part of the FreeType project, and may only be used,

src/3rdparty/freetype/docs/CHANGES

@@ -1,3 +1,43 @@
+CHANGES BETWEEN 2.13.2 and 2.13.3 (2024-Aug-11)
+
+  I. IMPORTANT CHANGES
+
+  - Some  fields  in  the  `FT_Outline` structure  have been   changed
+    from signed  to unsigned type,  which  better reflects  the actual
+    usage.   It  is  also  an  additional  means  to  protect  against
+    malformed input.
+
+
+  II. IMPORTANT BUG FIXES
+
+  - Rare double-free crashes in the cache subsystem have been fixed.
+
+  - Excessive stack allocation in the autohinter has been fixed.
+
+
+  III. MISCELLANEOUS
+
+  - The B/W  rasterizer has  received a major  upkeep that  results in
+    large performance improvements.  The rendering speed has increased
+    and even doubled for very complex glyphs.
+
+  - If the new configuration option `TT_CONFIG_OPTION_GPOS_KERNING` is
+    defined,  `FT_Get_Kerning`  understands rudimentary  GPOS  kerning
+    (for TrueType fonts  only).  This is not enabled  by default since
+    its usage  is very  limited, mainly  for legacy  applications that
+    have to support TrueType fonts automatically converted from 'kern'
+    tables to GPOS kerning.  If you need proper (GPOS) kerning support
+    please use a higher-level library like HarfBuzz.
+
+    Code contributed by David Saltzman <davidbsaltzman@gmail.com>.
+
+  - The internal structures  `PS_DesignMap` and `PS_Blend` related  to
+    parsing of old Multiple Masters fonts  have been removed  from the
+    public header file `t1tables.h`.
+
+
+======================================================================
+
 CHANGES BETWEEN 2.13.1 and 2.13.2 (2023-Aug-25)
 
   I. MISCELLANEOUS
@@ -5668,7 +5708,7 @@ Extensions support:
 
 ------------------------------------------------------------------------
 
-Copyright (C) 2000-2023 by
+Copyright (C) 2000-2024 by
 David Turner, Robert Wilhelm, and Werner Lemberg.
 
 This  file  is  part  of the  FreeType  project, and may  only be  used,

src/3rdparty/freetype/docs/CUSTOMIZE

@@ -139,7 +139,7 @@ IV. Overriding default configuration and module headers
 
 ----------------------------------------------------------------------
 
-Copyright (C) 2003-2023 by
+Copyright (C) 2003-2024 by
 David Turner, Robert Wilhelm, and Werner Lemberg.
 
 This  file is  part of  the FreeType  project, and  may only  be used,

src/3rdparty/freetype/docs/DEBUG

@@ -297,7 +297,7 @@ to access them.
 
 ------------------------------------------------------------------------
 
-Copyright (C) 2002-2023 by
+Copyright (C) 2002-2024 by
 David Turner, Robert Wilhelm, and Werner Lemberg.
 
 This  file is  part  of the  FreeType  project, and  may  only be  used,