Revision control

++ # Copyright (C) 2022 The Qt Company Ltd.
++ # SPDX-License-Identifier: BSD-3-Clause
++
++ #### Inputs
++
++
++
++ #### Libraries
++
++ qt_find_package(WrapSystemZLIB 1.0.8 MODULE
++ PROVIDED_TARGETS WrapSystemZLIB::WrapSystemZLIB MODULE_NAME global QMAKE_LIB zlib
++ VCPKG_PORT zlib
++ )
++ # Work around global target promotion failure when WrapZLIB is used on APPLE platforms.
++ # What ends up happening is that the ZLIB::ZLIB target is not promoted to global by qt_find_package,
++ # then qt_find_package(WrapSystemPNG) tries to find its dependency ZLIB::ZLIB, sees it's not global
++ # and tries to promote it to global, but fails because the directory scope of the PNG package is
++ # different (src/gui) from where ZLIB was originally found (qtbase root).
++ # To avoid that, just manually promote the target to global here.
++ if(TARGET ZLIB::ZLIB)
++ set_property(TARGET ZLIB::ZLIB PROPERTY IMPORTED_GLOBAL TRUE)
++ endif()
++
++ # Look for Threads in the same scope as OpenSSL package, because OpenSSL sometimes depends on
++ # Threads (for static OpenSSL builds) and we want to promote the target to global in the same
++ # directory scope.
++ qt_find_package(Threads MODULE PROVIDED_TARGETS Threads::Threads)
++ qt_find_package(WrapOpenSSLHeaders MODULE
++ PROVIDED_TARGETS WrapOpenSSLHeaders::WrapOpenSSLHeaders MODULE_NAME core
++ VCPKG_PORT openssl
++ VCPKG_ADD_TO_FEATURE openssl
++ )
++ # openssl_headers
++ # OPENSSL_VERSION_MAJOR is not defined for OpenSSL 1.1.1
++ qt_config_compile_test(opensslv11_headers
++ LABEL "opensslv11_headers"
++ LIBRARIES
++ WrapOpenSSLHeaders::WrapOpenSSLHeaders
++ CODE
++ "#include <openssl/ssl.h>
++ #include <openssl/opensslv.h>
++ #if !defined(OPENSSL_VERSION_NUMBER) || defined(OPENSSL_VERSION_MAJOR) || OPENSSL_VERSION_NUMBER-0 < 0x10101000L
++ # error OpenSSL >= 1.1.1 is required
++ #endif
++ #if !defined(OPENSSL_NO_EC) && !defined(SSL_CTRL_SET_CURVES)
++ # error OpenSSL was reported as >= 1.1.1 but is missing required features, possibly it is libressl which is unsupported
++ #endif
++
++ int main(void)
++ {
++ /* BEGIN TEST: */
++ /* END TEST: */
++ return 0;
++ }
++ ")
++
++ qt_find_package(WrapOpenSSL MODULE
++ PROVIDED_TARGETS WrapOpenSSL::WrapOpenSSL MODULE_NAME core QMAKE_LIB openssl)
++ # openssl
++ # OPENSSL_VERSION_MAJOR is not defined for OpenSSL 1.1.1
++ qt_config_compile_test(opensslv11
++ LABEL "opensslv11"
++ LIBRARIES
++ WrapOpenSSL::WrapOpenSSL
++ CODE
++ "#include <openssl/ssl.h>
++ #include <openssl/opensslv.h>
++ #if !defined(OPENSSL_VERSION_NUMBER) || defined(OPENSSL_VERSION_MAJOR) || OPENSSL_VERSION_NUMBER-0 < 0x10101000L
++ # error OpenSSL >= 1.1.1 is required
++ #endif
++ #if !defined(OPENSSL_NO_EC) && !defined(SSL_CTRL_SET_CURVES)
++ # error OpenSSL was reported as >= 1.1.1 but is missing required features, possibly it is libressl which is unsupported
++ #endif
++
++ int main(void)
++ {
++ /* BEGIN TEST: */
++ SSL_free(SSL_new(0));
++ /* END TEST: */
++ return 0;
++ }
++ ")
++
++ # opensslv30
++ # openssl_headers
++ qt_config_compile_test(opensslv30_headers
++ LABEL "opensslv30_headers"
++ LIBRARIES
++ WrapOpenSSLHeaders::WrapOpenSSLHeaders
++ CODE
++ "#include <openssl/ssl.h>
++ #include <openssl/opensslv.h>
++ #if !OPENSSL_VERSION_PREREQ(3,0)
++ # error OpenSSL >= 3.0 is required
++ #endif
++
++ int main(void)
++ {
++ /* BEGIN TEST: */
++ /* END TEST: */
++ return 0;
++ }
++ ")
++ qt_config_compile_test(opensslv30
++ LABEL "opensslv30"
++ LIBRARIES
++ WrapOpenSSL::WrapOpenSSL
++ CODE
++ "#include <openssl/ssl.h>
++ #include <openssl/opensslv.h>
++ #if !OPENSSL_VERSION_PREREQ(3,0)
++ # error OpenSSL >= 3.0 is required
++ #endif
++
++ int main(void)
++ {
++ /* BEGIN TEST: */
++ SSL_free(SSL_new(0));
++ /* END TEST: */
++ return 0;
++ }
++ ")
++
++ qt_find_package(WrapZSTD 1.3 MODULE
++ PROVIDED_TARGETS
++ WrapZSTD::WrapZSTD
++ zstd::libzstd
++ zstd::libzstd_static
++ zstd::libzstd_shared
++ MODULE_NAME global
++ QMAKE_LIB zstd
++ )
++ qt_find_package(WrapDBus1 1.2 MODULE PROVIDED_TARGETS dbus-1 MODULE_NAME global QMAKE_LIB dbus)
++ qt_find_package(Libudev MODULE
++ PROVIDED_TARGETS PkgConfig::Libudev MODULE_NAME global QMAKE_LIB libudev)
++ qt_find_package(LTTngUST MODULE PROVIDED_TARGETS LTTng::UST MODULE_NAME core QMAKE_LIB lttng-ust)
++ qt_add_qmake_lib_dependency(lttng-ust libdl)
++
++
++ #### Early-evaluated, Linker-related Tests and Features
++
++ qt_internal_check_if_linker_is_available(use_bfd_linker
++ LABEL "bfd linker"
++ FLAG "-fuse-ld=bfd"
++ )
++
++ qt_internal_check_if_linker_is_available(use_gold_linker
++ LABEL "gold linker"
++ FLAG "-fuse-ld=gold"
++ )
++
++ qt_internal_check_if_linker_is_available(use_lld_linker
++ LABEL "lld linker"
++ FLAG "-fuse-ld=lld"
++ )
++
++ # We set an invalid flag as a default flag so the compile test fails
++ # in case if no mold is found in PATH.
++ set(__qt_internal_mold_linker_flags "-Wl,-invalid-flag")
++ if(NOT QT_CONFIGURE_RUNNING)
++ qt_internal_get_mold_linker_flags(__qt_internal_mold_linker_flags)
++ endif()
++ qt_internal_check_if_linker_is_available(use_mold_linker
++ LABEL "mold linker"
++ FLAG "${__qt_internal_mold_linker_flags}"
++ )
++ unset(__qt_internal_mold_linker_flags)
++
++ qt_feature("use_bfd_linker"
++ PRIVATE
++ LABEL "bfd"
++ AUTODETECT false
++ CONDITION NOT MSVC AND NOT INTEGRITY AND NOT WASM AND TEST_use_bfd_linker
++ ENABLE INPUT_linker STREQUAL 'bfd'
++ EXCLUSIVE_GROUP linker
++ )
++ qt_feature_config("use_bfd_linker" QMAKE_PRIVATE_CONFIG)
++
++ qt_feature("use_gold_linker_alias"
++ AUTODETECT false
++ CONDITION NOT WIN32 AND NOT INTEGRITY AND NOT WASM AND TEST_use_gold_linker
++ )
++ qt_feature("use_gold_linker"
++ PRIVATE
++ LABEL "gold"
++ AUTODETECT false
++ CONDITION NOT WIN32 AND NOT INTEGRITY AND NOT WASM AND NOT rtems AND TEST_use_gold_linker
++ ENABLE INPUT_linker STREQUAL 'gold' OR QT_FEATURE_use_gold_linker_alias
++ EXCLUSIVE_GROUP linker
++ )
++ qt_feature_config("use_gold_linker" QMAKE_PRIVATE_CONFIG)
++
++ qt_feature("use_lld_linker"
++ PRIVATE
++ LABEL "lld"
++ AUTODETECT false
++ CONDITION NOT MSVC AND NOT INTEGRITY AND NOT WASM AND TEST_use_lld_linker
++ ENABLE INPUT_linker STREQUAL 'lld'
++ EXCLUSIVE_GROUP linker
++ )
++ qt_feature_config("use_lld_linker" QMAKE_PRIVATE_CONFIG)
++
++ qt_feature("use_mold_linker"
++ PRIVATE
++ LABEL "mold"
++ AUTODETECT FALSE
++ CONDITION NOT WIN32 AND NOT INTEGRITY AND NOT WASM AND TEST_use_mold_linker
++ ENABLE INPUT_linker STREQUAL 'mold'
++ EXCLUSIVE_GROUP linker
++ )
++ qt_feature_config("use_mold_linker" QMAKE_PRIVATE_CONFIG)
++
++ if(NOT QT_CONFIGURE_RUNNING)
++ qt_evaluate_feature(use_bfd_linker)
++ qt_evaluate_feature(use_gold_linker_alias)
++ qt_evaluate_feature(use_gold_linker)
++ qt_evaluate_feature(use_lld_linker)
++ qt_evaluate_feature(use_mold_linker)
++
++ qt_run_linker_version_script_support()
++ endif()
++
++ qt_feature("version_tagging"
++ PUBLIC
++ AUTODETECT TRUE
++ CONDITION TEST_ld_version_script OR APPLE OR WIN32
++ )
++ qt_feature_definition("version_tagging" "QT_NO_VERSION_TAGGING" NEGATE)
++
++ #### Tests
++
++ # machineTuple
++ qt_config_compile_test_machine_tuple("machine tuple")
++
++ # glibc
++ qt_config_compile_test(glibc
++ LABEL "Using Glibc"
++ CODE
++ "#include <features.h>
++ #ifndef __GLIBC__
++ #error
++ #endif
++ int main() {}"
++ )
++
++ # glibc 2.34 and gcc >= 12 or clang >= 9, for _FORTIFY_SOURCE=3
++ qt_config_compile_test(glibc_fortify_source_3
++ LABEL "_FORTIFY_SOURCE=3 support"
++ COMPILE_OPTIONS "-Werror=cpp -D_FORTIFY_SOURCE=3"
++ CODE
++ "#include <features.h>
++ int main() {}"
++ )
++
++ # cxx20
++ qt_config_compile_test(cxx20
++ LABEL "C++20 support"
++ CODE
++ "#if __cplusplus > 201703L
++ // Compiler claims to support C++20, trust it
++ #else
++ # error __cplusplus must be > 201703L (the value for C++17)
++ #endif
++
++ int main(void)
++ {
++ /* BEGIN TEST: */
++ /* END TEST: */
++ return 0;
++ }
++ "
++ CXX_STANDARD 20
++ )
++
++ qt_config_compile_test(cxx2b
++ LABEL "C++23 support"
++ CODE
++ "#if __cplusplus > 202002L
++ // Compiler claims to support C++23, trust it
++ #else
++ # error __cplusplus must be > 202002L (the value for C++20)
++ #endif
++
++ int main(void)
++ {
++ /* BEGIN TEST: */
++ /* END TEST: */
++ return 0;
++ }
++ "
++ CXX_STANDARD 23
++ )
++
++ qt_config_compile_test(cxx2c
++ LABEL "C++2c support"
++ CODE
++ "#if __cplusplus > 202302L
++ // Compiler claims to support C++2c, trust it
++ #else
++ # error __cplusplus must be > 202302L (the value for C++23)
++ #endif
++
++ int main(void)
++ {
++ /* BEGIN TEST: */
++ /* END TEST: */
++ return 0;
++ }
++ "
++ CXX_STANDARD 26
++ )
++
++ qt_config_compile_test(elf
++ LABEL "ELF system"
++ CODE
++ "#ifdef __ELF__
++ #include <elf.h>
++ #else
++ #error __ELF__ not defined
++ #endif
++ int main() { return 0; }
++ "
++ )
++
++ qt_config_linker_supports_flag_test(linker_dynamic_list
++ LABEL "--dynamic-list support"
++ # doesn't matter that it's an .in, it just has to be the right syntax
++ FLAG "--dynamic-list=${CMAKE_CURRENT_SOURCE_DIR}/src/corelib/QtCore.dynlist.in"
++ )
++
++ qt_config_linker_supports_flag_test(linker_symbolic_functions
++ # Note: we infer the linker also supports -Bsymbolic if it supports this
++ LABEL "-Bsymbolic-functions support"
++ FLAG "-Bsymbolic-functions"
++ )
++
++ qt_config_compiler_supports_flag_test(optimize_debug
++ LABEL "-Og support"
++ FLAG "-Og"
++ )
++
++ qt_config_compile_test(no_direct_extern_access
++ LABEL "-mno-direct-extern-access / -fno-direct-access-external-data support"
++ PROJECT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/config.tests/no_direct_extern_access"
++ )
++
++ qt_config_linker_supports_flag_test(enable_new_dtags
++ LABEL "new dtags support"
++ FLAG "--enable-new-dtags"
++ )
++
++ qt_config_linker_supports_flag_test(gdb_index
++ LABEL "gdb index support"
++ FLAG "--gdb-index"
++ )
++
++
++ if(MSVC OR APPLE)
++ # These platforms / toolchains support separate debug information. Skip the compile test.
++ set(TEST_separate_debug_info ON CACHE INTERNAL "separate debug information support")
++ else()
++ qt_config_compile_test("separate_debug_info"
++ LABEL "separate debug information support"
++ PROJECT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/config.tests/separate_debug_info"
++ )
++ endif()
++
++ # signaling_nan
++ qt_config_compile_test(signaling_nan
++ LABEL "Signaling NaN for doubles"
++ CODE
++ "#if defined(__ghs) && (__GHS_VERSION_NUMBER <= 202014)
++ # error Signal NaNs are not supported by GHS compiler, but has_signaling_NaN returns TRUE. Will be fixed in future compiler releases.
++ #endif
++
++ #include <limits>
++
++ int main(void)
++ {
++ /* BEGIN TEST: */
++ using B = std::numeric_limits<double>;
++ static_assert(B::has_signaling_NaN, \"System lacks signaling NaN\");
++ /* END TEST: */
++ return 0;
++ }
++ ")
++
++ # basic x86 intrinsics support
++ qt_config_compile_test(x86intrin
++ LABEL "Basic x86 intrinsics"
++ PROJECT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/config.tests/x86intrin"
++ )
++
++ # x86: avx512vbmi2
++ qt_config_compile_test_x86simd(avx512vbmi2 "AVX512VBMI2")
++
++ # x86: vaes
++ qt_config_compile_test_x86simd(vaes "VAES")
++
++ # arm: crypto
++ qt_config_compile_test_armintrin(crypto "CRYPTO")
++
++ # arm: sve
++ qt_config_compile_test_armintrin(sve "SVE")
++
++ # loongarch: lsx
++ qt_config_compile_test_loongarchsimd(lsx "LSX")
++
++ # loongarch: lasx
++ qt_config_compile_test_loongarchsimd(lasx "LASX")
++
++ # 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()"
++ CODE
++ "#include <fcntl.h>
++ #include <unistd.h>
++
++ int main(void)
++ {
++ /* BEGIN TEST: */
++ (void) posix_fallocate(0, 0, 0);
++ /* END TEST: */
++ return 0;
++ }
++ ")
++
++ # stack_protector
++ if(NOT WASM AND NOT VXWORKS)
++ # emcc doesn't support this, but the detection accidentally succeeds
++
++ # VXWORKS: We currently don't know the correct linker options. This is
++ # tracked at QTBUG-123715
++ qt_config_compiler_supports_flag_test(stack_protector
++ LABEL "stack protection"
++ FLAG "-fstack-protector-strong"
++ )
++ endif()
++
++ # stack_clash_protection
++ qt_config_compiler_supports_flag_test(stack_clash_protection
++ LABEL "-fstack-clash-protection support"
++ FLAG "-fstack-clash-protection"
++ )
++ endif()
++
++ # trivial_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)
++ qt_config_linker_supports_flag_test(intelcet
++ LABEL "Support for Intel Control-flow Enforcement Technology (CET)"
++ FLAG "-CETCOMPAT"
++ )
++ else()
++ qt_config_compile_test(intelcet
++ LABEL "Support for Intel Control-flow Enforcement Technology (CET)"
++ COMPILE_OPTIONS -fcf-protection=full
++ CODE
++ "int main(void)
++ {
++ /* BEGIN TEST: */
++ #if !defined(__CET__)
++ # error Intel CET not available
++ #endif
++ /* END TEST: */
++ return 0;
++ }
++ "
++ )
++ endif()
++
++ # -z relro -z now
++ if(NOT WIN32)
++ qt_config_linker_supports_flag_test(relro_now_linker
++ LABEL "Support for -z relro and -z now"
++ FLAG "-z,relro,-z,now"
++ )
++ endif()
++
++ # Is libc++ the default Standard Library?
++ qt_config_compile_test(using_stdlib_libcpp
++ LABEL "Compiler defaults to libc++"
++ CODE
++ "
++ #include <ciso646>
++
++ int main(void)
++ {
++ /* BEGIN TEST: */
++ #ifndef _LIBCPP_VERSION
++ # error
++ #endif
++ /* END TEST: */
++ }
++ "
++ )
++
++
++ #### Features
++
++ # This belongs into gui, but the license check needs it here already.
++ qt_feature("android-style-assets" PRIVATE
++ LABEL "Android Style Assets"
++ CONDITION ANDROID
++ )
++ qt_feature_alias("shared" PUBLIC
++ LABEL "Building shared libraries"
++ ALIAS_OF_CACHE BUILD_SHARED_LIBS
++ )
++ qt_feature_definition("shared" "QT_STATIC" NEGATE PREREQUISITE "!defined(QT_SHARED) && !defined(QT_STATIC)")
++ qt_feature_config("shared" QMAKE_PUBLIC_QT_CONFIG)
++ qt_feature_config("shared" QMAKE_PUBLIC_CONFIG)
++ qt_feature_alias("static"
++ ALIAS_OF_FEATURE "shared"
++ NEGATE
++ )
++ qt_feature_config("static" QMAKE_PUBLIC_QT_CONFIG)
++ qt_feature_config("static" QMAKE_PUBLIC_CONFIG)
++ qt_feature("cross_compile" PUBLIC
++ LABEL "Cross compiling"
++ CONDITION CMAKE_CROSSCOMPILING
++ )
++ qt_feature_config("cross_compile" QMAKE_PUBLIC_CONFIG)
++ qt_feature_config("cross_compile" QMAKE_PRIVATE_CONFIG)
++ qt_feature("gc_binaries" PRIVATE
++ CONDITION NOT QT_FEATURE_shared
++ )
++ qt_feature("optimize_debug"
++ LABEL "Optimize debug build"
++ AUTODETECT NOT QT_FEATURE_developer_build
++ CONDITION NOT MSVC AND NOT CLANG AND ( QT_FEATURE_debug OR QT_FEATURE_debug_and_release ) AND TEST_optimize_debug
++ )
++ qt_feature_config("optimize_debug" QMAKE_PRIVATE_CONFIG)
++ qt_feature("optimize_size"
++ LABEL "Optimize release build for size"
++ AUTODETECT OFF
++ CONDITION NOT QT_FEATURE_debug OR QT_FEATURE_debug_and_release
++ )
++ qt_feature_config("optimize_size" QMAKE_PRIVATE_CONFIG)
++ qt_feature("optimize_full"
++ LABEL "Fully optimize release builds (-O3)"
++ AUTODETECT OFF
++ )
++ qt_feature_config("optimize_full" QMAKE_PRIVATE_CONFIG)
++ qt_feature("optimized_tools" PRIVATE
++ LABEL "Build optimized tools for the Debug configuration"
++ AUTODETECT OFF
++ )
++ qt_feature("msvc_obj_debug_info"
++ LABEL "Embed debug info in object files (MSVC)"
++ ENABLE QT_USE_CCACHE OR CMAKE_CXX_COMPILER_LAUNCHER
++ AUTODETECT OFF
++ EMIT_IF MSVC
++ )
++ qt_feature_config("msvc_obj_debug_info" QMAKE_PRIVATE_CONFIG)
++ qt_feature("pkg-config" PUBLIC
++ LABEL "Using pkg-config"
++ AUTODETECT NOT APPLE AND NOT WIN32 AND NOT ANDROID AND NOT OHOS
++ CONDITION PKG_CONFIG_FOUND
++ )
++ qt_feature_config("pkg-config" QMAKE_PUBLIC_QT_CONFIG
++ NEGATE)
++ qt_feature("developer-build" PRIVATE
++ LABEL "Developer build"
++ AUTODETECT OFF
++ )
++ qt_feature("no-prefix"
++ LABEL "No prefix build"
++ AUTODETECT NOT QT_WILL_INSTALL
++ CONDITION NOT QT_WILL_INSTALL
++ )
++ qt_feature("lint_generated_code"
++ LABEL "Lint qt-generated code"
++ AUTODETECT QT_FEATURE_developer_build
++ )
++ qt_feature("private_tests" PRIVATE
++ LABEL "Developer build: private_tests"
++ CONDITION QT_FEATURE_developer_build
++ )
++ qt_feature("doc_snippets" PRIVATE
++ LABEL "Developer build: doc_snippets"
++ AUTODETECT QT_BUILD_DOC_SNIPPETS
++ CONDITION QT_FEATURE_shared
++ )
++ qt_feature_definition("developer-build" "QT_BUILD_INTERNAL")
++ qt_feature_config("developer-build" QMAKE_PUBLIC_QT_CONFIG
++ NAME "private_tests"
++ )
++ qt_feature("debug" PRIVATE
++ LABEL "Build for debugging"
++ AUTODETECT ON
++ CONDITION CMAKE_BUILD_TYPE STREQUAL Debug OR Debug IN_LIST CMAKE_CONFIGURATION_TYPES
++ )
++ qt_feature("debug_and_release" PUBLIC
++ LABEL "Compile libs in debug and release mode"
++ AUTODETECT 1
++ CONDITION QT_GENERATOR_IS_MULTI_CONFIG
++ )
++ qt_feature_config("debug_and_release" QMAKE_PUBLIC_QT_CONFIG)
++ qt_feature("force_debug_info"
++ LABEL "Add debug info in release mode"
++ AUTODETECT CMAKE_BUILD_TYPE STREQUAL RelWithDebInfo OR RelWithDebInfo IN_LIST CMAKE_CONFIGURATION_TYPES
++ )
++ qt_feature_config("force_debug_info" QMAKE_PRIVATE_CONFIG)
++ qt_feature("separate_debug_info" PUBLIC
++ LABEL "Split off debug information"
++ AUTODETECT OFF
++ CONDITION ( QT_FEATURE_shared ) AND ( QT_FEATURE_debug OR QT_FEATURE_debug_and_release OR QT_FEATURE_force_debug_info ) AND TEST_separate_debug_info
++ )
++ qt_feature_config("separate_debug_info" QMAKE_PUBLIC_QT_CONFIG)
++ qt_feature("appstore-compliant" PUBLIC
++ LABEL "App store compliance"
++ PURPOSE "Disables code that is not allowed in platform app stores"
++ AUTODETECT UIKIT OR ANDROID
++ )
++ if(APPLE)
++ qt_feature_definition("appstore-compliant" "QT_APPLE_NO_PRIVATE_APIS")
++ endif()
++ qt_feature("simulator_and_device" PUBLIC
++ LABEL "Build for both simulator and device"
++ CONDITION IOS AND NOT QT_APPLE_SDK
++ )
++ qt_feature_config("simulator_and_device" QMAKE_PUBLIC_QT_CONFIG)
++ qt_feature("rpath" PUBLIC
++ LABEL "Build with RPATH"
++ AUTODETECT 1
++ CONDITION BUILD_SHARED_LIBS AND UNIX AND NOT WIN32 AND NOT ANDROID
++ )
++ qt_feature_config("rpath" QMAKE_PUBLIC_QT_CONFIG)
++ qt_feature("elf"
++ LABEL "ELF system"
++ AUTODETECT UNIX AND NOT APPLE
++ CONDITION TEST_elf
++ )
++ qt_feature("elf_private_full_version" PRIVATE
++ LABEL "Use Qt's full version number in ELF version symbols"
++ AUTODETECT OFF
++ CONDITION BUILD_SHARED_LIBS AND QT_FEATURE_elf
++ )
++ qt_feature_config("elf_private_full_version" QMAKE_PRIVATE_QT_CONFIG)
++ qt_feature("force_asserts" PUBLIC
++ LABEL "Force assertions"
++ AUTODETECT OFF
++ )
++
++ qt_feature("exceptions"
++ LABEL "Enable exceptions"
++ AUTODETECT OFF
++ )
++
++ 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")
++ qt_feature_config("framework" QMAKE_PUBLIC_QT_CONFIG
++ NAME "qt_framework"
++ )
++ qt_feature_config("framework" QMAKE_PUBLIC_CONFIG
++ NAME "qt_framework"
++ )
++ qt_feature("largefile"
++ LABEL "Large file support"
++ CONDITION NOT INTEGRITY AND NOT rtems AND NOT OHOS
++ )
++ qt_feature_definition("largefile" "QT_LARGEFILE_SUPPORT" VALUE "64")
++ qt_feature_config("largefile" QMAKE_PRIVATE_CONFIG)
++ qt_feature("sanitize_address"
++ LABEL "Addresses"
++ AUTODETECT OFF
++ )
++ qt_feature_config("sanitize_address" QMAKE_PUBLIC_CONFIG)
++ qt_feature("sanitize_thread"
++ LABEL "Threads"
++ AUTODETECT OFF
++ )
++ qt_feature_config("sanitize_thread" QMAKE_PUBLIC_CONFIG)
++ qt_feature("sanitize_memory"
++ LABEL "Memory"
++ AUTODETECT OFF
++ )
++ qt_feature_config("sanitize_memory" QMAKE_PUBLIC_CONFIG)
++ qt_feature("sanitize_fuzzer_no_link"
++ LABEL "Fuzzer (instrumentation only)"
++ PURPOSE "Adds instrumentation for fuzzing to the binaries but links to the usual main function instead of a fuzzer's."
++ AUTODETECT OFF
++ )
++ qt_feature_config("sanitize_fuzzer_no_link" QMAKE_PUBLIC_CONFIG)
++ qt_feature("sanitize_undefined"
++ LABEL "Undefined"
++ AUTODETECT OFF
++ )
++ qt_feature_config("sanitize_undefined" QMAKE_PUBLIC_CONFIG)
++ qt_feature("sanitizer"
++ LABEL "Sanitizers"
++ CONDITION QT_FEATURE_sanitize_address OR QT_FEATURE_sanitize_thread OR QT_FEATURE_sanitize_memory OR QT_FEATURE_sanitize_fuzzer_no_link OR QT_FEATURE_sanitize_undefined
++ )
++ qt_feature_config("sanitizer" QMAKE_PUBLIC_CONFIG)
++ qt_feature("plugin-manifests"
++ LABEL "Embed manifests in plugins"
++ AUTODETECT OFF
++ EMIT_IF WIN32
++ )
++ qt_feature_config("plugin-manifests" QMAKE_PUBLIC_CONFIG
++ NEGATE
++ NAME "no_plugin_manifest"
++ )
++ qt_feature("c++20" PUBLIC
++ LABEL "C++20"
++ AUTODETECT OFF
++ CONDITION TEST_cxx20 AND NOT VXWORKS
++ )
++ qt_feature_config("c++20" QMAKE_PUBLIC_QT_CONFIG)
++ qt_feature("c++2a" PUBLIC
++ LABEL "C++20"
++ CONDITION QT_FEATURE_cxx20
++ )
++ qt_feature_config("c++2a" QMAKE_PUBLIC_QT_CONFIG)
++ qt_feature("c++2b" PUBLIC
++ LABEL "C++23"
++ AUTODETECT OFF
++ CONDITION QT_FEATURE_cxx20 AND (CMAKE_VERSION VERSION_GREATER_EQUAL "3.20") AND TEST_cxx2b
++ )
++ qt_feature_config("c++2b" QMAKE_PUBLIC_QT_CONFIG)
++ qt_feature("c++2c" PUBLIC
++ LABEL "C++2c"
++ AUTODETECT OFF
++ CONDITION QT_FEATURE_cxx2b AND (CMAKE_VERSION VERSION_GREATER_EQUAL "3.25") AND TEST_cxx2c
++ )
++ qt_feature_config("c++2c" QMAKE_PUBLIC_QT_CONFIG)
++ set(__qt_ltcg_detected FALSE)
++ if(CMAKE_INTERPROCEDURAL_OPTIMIZATION)
++ set(__qt_ltcg_detected TRUE)
++ else()
++ foreach(config ${CMAKE_BUILD_TYPE} ${CMAKE_CONFIGURATION_TYPES})
++ string(TOUPPER "${config}" __qt_uc_config)
++ if(CMAKE_INTERPROCEDURAL_OPTIMIZATION_${__qt_uc_config})
++ set(__qt_ltcg_detected TRUE)
++ break()
++ endif()
++ endforeach()
++ unset(__qt_uc_config)
++ endif()
++ qt_feature("ltcg"
++ LABEL "Using Link Time Optimization (LTCG)"
++ AUTODETECT ON
++ CONDITION __qt_ltcg_detected
++ )
++ qt_feature_config("ltcg" QMAKE_PRIVATE_CONFIG)
++
++ if(NOT QT_CONFIGURE_RUNNING)
++ # This feature is used early in QtCompilerOptimization.cmake.
++ qt_evaluate_feature(ltcg)
++ endif()
++
++ qt_feature("enable_new_dtags"
++ LABEL "Using new DTAGS"
++ CONDITION QT_FEATURE_elf AND TEST_enable_new_dtags
++ )
++ qt_feature_config("enable_new_dtags" QMAKE_PRIVATE_CONFIG)
++ qt_feature("enable_gdb_index"
++ LABEL "Generating GDB index"
++ AUTODETECT QT_FEATURE_developer_build
++ CONDITION GCC AND NOT CLANG AND ( QT_FEATURE_debug OR QT_FEATURE_force_debug_info OR QT_FEATURE_debug_and_release ) AND TEST_gdb_index
++ )
++ qt_feature_config("enable_gdb_index" QMAKE_PRIVATE_CONFIG)
++ qt_feature("reduce_exports" PRIVATE
++ LABEL "Reduce amount of exported symbols"
++ CONDITION NOT MSVC
++ )
++ qt_feature_definition("reduce_exports" "QT_VISIBILITY_AVAILABLE")
++ qt_feature_config("reduce_exports" QMAKE_PUBLIC_QT_CONFIG)
++ qt_feature("no_direct_extern_access" PRIVATE
++ LABEL "Use protected visibility and -mno-direct-extern-access"
++ CONDITION NOT WIN32 AND TEST_no_direct_extern_access
++ AUTODETECT OFF
++ )
++ qt_feature_definition("no_direct_extern_access" "QT_USE_PROTECTED_VISIBILITY")
++ qt_feature_config("no_direct_extern_access" QMAKE_PUBLIC_QT_CONFIG)
++ qt_feature("reduce_relocations" PUBLIC
++ LABEL "Reduce amount of relocations"
++ AUTODETECT NOT WIN32 AND
++ (TEST_architecture_arch STREQUAL i386) OR (TEST_architecture_arch STREQUAL x86_64) # See QTBUG-36129
++ CONDITION TEST_linker_symbolic_functions AND TEST_linker_dynamic_list
++ )
++ qt_feature_definition("reduce_relocations" "QT_REDUCE_RELOCATIONS")
++ qt_feature_config("reduce_relocations" QMAKE_PUBLIC_QT_CONFIG)
++ qt_feature("signaling_nan" PUBLIC
++ LABEL "Signaling NaN"
++ CONDITION TEST_signaling_nan
++ )
++ qt_feature("x86intrin" PRIVATE
++ LABEL "Basic"
++ CONDITION
++ ( (TEST_architecture_arch STREQUAL i386)
++ OR (TEST_architecture_arch STREQUAL x86_64)
++ OR (QT_IS_MACOS_UNIVERSAL AND x86_64 IN_LIST CMAKE_OSX_ARCHITECTURES))
++ AND (QT_FORCE_FEATURE_x86intrin OR TEST_x86intrin)
++ AUTODETECT NOT WASM
++ )
++ qt_feature("sse2" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("sse2" "QT_COMPILER_SUPPORTS_SSE2" VALUE "1")
++ qt_feature_config("sse2" QMAKE_PRIVATE_CONFIG)
++ qt_feature("sse3" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("sse3" "QT_COMPILER_SUPPORTS_SSE3" VALUE "1")
++ qt_feature_config("sse3" QMAKE_PRIVATE_CONFIG)
++ qt_feature("ssse3" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("ssse3" "QT_COMPILER_SUPPORTS_SSSE3" VALUE "1")
++ qt_feature_config("ssse3" QMAKE_PRIVATE_CONFIG)
++ qt_feature("sse4_1" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("sse4_1" "QT_COMPILER_SUPPORTS_SSE4_1" VALUE "1")
++ qt_feature_config("sse4_1" QMAKE_PRIVATE_CONFIG)
++ qt_feature("sse4_2" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("sse4_2" "QT_COMPILER_SUPPORTS_SSE4_2" VALUE "1")
++ qt_feature_config("sse4_2" QMAKE_PRIVATE_CONFIG)
++ qt_feature("avx" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("avx" "QT_COMPILER_SUPPORTS_AVX" VALUE "1")
++ qt_feature_config("avx" QMAKE_PRIVATE_CONFIG)
++ qt_feature("f16c" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("f16c" "QT_COMPILER_SUPPORTS_F16C" VALUE "1")
++ qt_feature_config("f16c" QMAKE_PRIVATE_CONFIG)
++ qt_feature("avx2" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("avx2" "QT_COMPILER_SUPPORTS_AVX2" VALUE "1")
++ qt_feature_config("avx2" QMAKE_PRIVATE_CONFIG)
++ qt_feature("avx512f" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("avx512f" "QT_COMPILER_SUPPORTS_AVX512F" VALUE "1")
++ qt_feature_config("avx512f" QMAKE_PRIVATE_CONFIG)
++ qt_feature("avx512er" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("avx512er" "QT_COMPILER_SUPPORTS_AVX512ER" VALUE "1")
++ qt_feature_config("avx512er" QMAKE_PRIVATE_CONFIG)
++ qt_feature("avx512cd" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("avx512cd" "QT_COMPILER_SUPPORTS_AVX512CD" VALUE "1")
++ qt_feature_config("avx512cd" QMAKE_PRIVATE_CONFIG)
++ qt_feature("avx512pf" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("avx512pf" "QT_COMPILER_SUPPORTS_AVX512PF" VALUE "1")
++ qt_feature_config("avx512pf" QMAKE_PRIVATE_CONFIG)
++ qt_feature("avx512dq" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("avx512dq" "QT_COMPILER_SUPPORTS_AVX512DQ" VALUE "1")
++ qt_feature_config("avx512dq" QMAKE_PRIVATE_CONFIG)
++ qt_feature("avx512bw" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("avx512bw" "QT_COMPILER_SUPPORTS_AVX512BW" VALUE "1")
++ qt_feature_config("avx512bw" QMAKE_PRIVATE_CONFIG)
++ qt_feature("avx512vl" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("avx512vl" "QT_COMPILER_SUPPORTS_AVX512VL" VALUE "1")
++ qt_feature_config("avx512vl" QMAKE_PRIVATE_CONFIG)
++ qt_feature("avx512ifma" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("avx512ifma" "QT_COMPILER_SUPPORTS_AVX512IFMA" VALUE "1")
++ qt_feature_config("avx512ifma" QMAKE_PRIVATE_CONFIG)
++ qt_feature("avx512vbmi" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("avx512vbmi" "QT_COMPILER_SUPPORTS_AVX512VBMI" VALUE "1")
++ qt_feature_config("avx512vbmi" QMAKE_PRIVATE_CONFIG)
++ qt_feature("avx512vbmi2" PRIVATE
++ LABEL "AVX512VBMI2"
++ CONDITION QT_FEATURE_x86intrin AND TEST_subarch_avx512vbmi2
++ )
++ qt_feature_definition("avx512vbmi2" "QT_COMPILER_SUPPORTS_AVX512VBMI2" VALUE "1")
++ qt_feature_config("avx512vbmi2" QMAKE_PRIVATE_CONFIG)
++ qt_feature("aesni" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("aesni" "QT_COMPILER_SUPPORTS_AES" VALUE "1")
++ qt_feature_config("aesni" QMAKE_PRIVATE_CONFIG)
++ qt_feature("vaes" PRIVATE
++ LABEL "VAES"
++ CONDITION QT_FEATURE_x86intrin AND TEST_subarch_vaes
++ )
++ qt_feature_definition("vaes" "QT_COMPILER_SUPPORTS_VAES" VALUE "1")
++ qt_feature_config("vaes" QMAKE_PRIVATE_CONFIG)
++ qt_feature("rdrnd" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("rdrnd" "QT_COMPILER_SUPPORTS_RDRND" VALUE "1")
++ qt_feature_config("rdrnd" QMAKE_PRIVATE_CONFIG)
++ qt_feature("rdseed" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("rdseed" "QT_COMPILER_SUPPORTS_RDSEED" VALUE "1")
++ qt_feature_config("rdseed" QMAKE_PRIVATE_CONFIG)
++ qt_feature("shani" PRIVATE
++ CONDITION QT_FEATURE_x86intrin
++ )
++ qt_feature_definition("shani" "QT_COMPILER_SUPPORTS_SHA" VALUE "1")
++ qt_feature_config("shani" QMAKE_PRIVATE_CONFIG)
++ qt_feature("lsx" PRIVATE
++ LABEL "LSX"
++ CONDITION ( TEST_architecture_arch STREQUAL loongarch64 ) AND TEST_subarch_lsx
++ )
++ qt_feature_definition("lsx" "QT_COMPILER_SUPPORTS_LSX" VALUE "1")
++ qt_feature_config("lsx" QMAKE_PRIVATE_CONFIG)
++ qt_feature("lasx" PRIVATE
++ LABEL "LASX"
++ CONDITION ( TEST_architecture_arch STREQUAL loongarch64 ) AND TEST_subarch_lasx
++ )
++ qt_feature_definition("lasx" "QT_COMPILER_SUPPORTS_LASX" VALUE "1")
++ qt_feature_config("lasx" QMAKE_PRIVATE_CONFIG)
++ qt_feature("mips_dsp" PRIVATE
++ LABEL "DSP"
++ CONDITION ( TEST_architecture_arch STREQUAL mips ) AND TEST_arch_${TEST_architecture_arch}_subarch_dsp
++ )
++ qt_feature_definition("mips_dsp" "QT_COMPILER_SUPPORTS_MIPS_DSP" VALUE "1")
++ qt_feature_config("mips_dsp" QMAKE_PRIVATE_CONFIG)
++ qt_feature("mips_dspr2" PRIVATE
++ LABEL "DSPr2"
++ CONDITION ( TEST_architecture_arch STREQUAL mips ) AND TEST_arch_${TEST_architecture_arch}_subarch_dspr2
++ )
++ qt_feature_definition("mips_dspr2" "QT_COMPILER_SUPPORTS_MIPS_DSPR2" VALUE "1")
++ qt_feature_config("mips_dspr2" QMAKE_PRIVATE_CONFIG)
++ qt_feature("neon" PRIVATE
++ LABEL "NEON"
++ CONDITION ( ( ( TEST_architecture_arch STREQUAL arm ) OR
++ ( TEST_architecture_arch STREQUAL arm64 ) ) AND
++ TEST_arch_${TEST_architecture_arch}_subarch_neon ) OR QT_FORCE_FEATURE_neon
++ )
++ qt_feature_definition("neon" "QT_COMPILER_SUPPORTS_NEON" VALUE "1")
++ qt_feature_config("neon" QMAKE_PRIVATE_CONFIG)
++ qt_feature("arm_crc32" PRIVATE
++ LABEL "CRC32"
++ CONDITION ( ( TEST_architecture_arch STREQUAL arm ) OR ( TEST_architecture_arch STREQUAL arm64 ) ) AND TEST_arch_${TEST_architecture_arch}_subarch_crc32
++ )
++ qt_feature_definition("arm_crc32" "QT_COMPILER_SUPPORTS_CRC32" VALUE "1")
++ qt_feature_config("arm_crc32" QMAKE_PRIVATE_CONFIG)
++ qt_feature("arm_crypto" PRIVATE
++ LABEL "AES"
++ CONDITION ( ( TEST_architecture_arch STREQUAL arm ) OR ( TEST_architecture_arch STREQUAL arm64 ) ) AND ( TEST_arch_${TEST_architecture_arch}_subarch_crypto OR TEST_subarch_crypto )
++ AUTODETECT NOT OHOS
++ )
++ qt_feature_definition("arm_crypto" "QT_COMPILER_SUPPORTS_CRYPTO" VALUE "1")
++ qt_feature_definition("arm_crypto" "QT_COMPILER_SUPPORTS_AES" VALUE "1")
++ qt_feature_config("arm_crypto" QMAKE_PRIVATE_CONFIG)
++
++ qt_feature("arm_sve" PRIVATE
++ LABEL "SVE"
++ CONDITION ( TEST_architecture_arch STREQUAL arm64 ) AND ( TEST_arch_${TEST_architecture_arch}_subarch_sve OR TEST_subarch_sve )
++ )
++ qt_feature_definition("arm_sve" "QT_COMPILER_SUPPORTS_SVE" VALUE "1")
++ qt_feature_config("arm_sve" QMAKE_PRIVATE_CONFIG)
++
++ qt_feature("wasm-simd128" PUBLIC
++ LABEL "WebAssembly SIMD128"
++ PURPOSE "Enables WebAssembly SIMD"
++ AUTODETECT OFF
++ )
++ qt_feature_definition("wasm-simd128" "QT_COMPILER_SUPPORTS_WASM_SIMD128" VALUE "1")
++ qt_feature_config("wasm-simd128" QMAKE_PRIVATE_CONFIG)
++
++ qt_feature("wasm-exceptions" PUBLIC
++ LABEL "WebAssembly Exceptions"
++ PURPOSE "Enables WebAssembly Exceptions"
++ AUTODETECT OFF
++ )
++ qt_feature_definition("wasm-exceptions" "QT_WASM_EXCEPTIONS" VALUE "1")
++ qt_feature_config("wasm-exceptions" QMAKE_PRIVATE_CONFIG)
++
++ qt_feature("wasm-jspi" PUBLIC
++ LABEL "WebAssembly JSPI"
++ PURPOSE "Enables WebAssembly JavaScript Promise Integration (JSPI)"
++ AUTODETECT OFF
++ CONDITION QT_FEATURE_wasm_exceptions # JSPI requires wasm-exceptions
++ )
++ qt_feature_definition("wasm-jspi" "QT_WASM_JSPI" VALUE "1")
++ qt_feature_config("wasm-jspi" 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
++ )
++ qt_feature("force-system-libs" PRIVATE
++ LABEL "Force the usage of system libraries"
++ AUTODETECT OFF
++ )
++ qt_feature("force-bundled-libs" PRIVATE
++ LABEL "Force the usage of bundled libraries"
++ AUTODETECT OFF
++ )
++ qt_feature("system-zlib" PRIVATE SYSTEM_LIBRARY
++ LABEL "Using system zlib"
++ CONDITION WrapSystemZLIB_FOUND
++ )
++ qt_feature("zstd" PUBLIC
++ LABEL "Zstandard support"
++ CONDITION WrapZSTD_FOUND
++ )
++ qt_feature("stdlib-libcpp" PRIVATE
++ LABEL "Using stdlib=libc++"
++ AUTODETECT OFF
++ CONDITION MINGW OR (LINUX AND NOT ANDROID)
++ )
++ # Check whether CMake was built with zstd support.
++ if(NOT DEFINED CACHE{QT_CMAKE_ZSTD_SUPPORT})
++ set(QT_CMAKE_ZSTD_SUPPORT FALSE CACHE INTERNAL "")
++ if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.18")
++ execute_process(COMMAND "${CMAKE_COMMAND}"
++ -P "${CMAKE_CURRENT_SOURCE_DIR}/config.tests/cmake_zstd/check_zstd.cmake"
++ WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/config.tests"
++ OUTPUT_QUIET ERROR_QUIET
++ RESULT_VARIABLE qt_check_zstd_exit_code)
++ if(qt_check_zstd_exit_code EQUAL 0)
++ set(QT_CMAKE_ZSTD_SUPPORT TRUE CACHE INTERNAL "")
++ endif()
++ unset(qt_check_zstd_exit_code)
++ endif()
++ endif()
++ qt_feature("thread" PUBLIC
++ SECTION "Kernel"
++ LABEL "Thread support"
++ PURPOSE "Provides QThread and related classes."
++ AUTODETECT NOT WASM
++ )
++ qt_feature("future" PUBLIC
++ SECTION "Kernel"
++ LABEL "QFuture"
++ PURPOSE "Provides QFuture and related classes."
++ )
++ qt_feature("concurrent" PUBLIC
++ SECTION "Kernel"
++ LABEL "Qt Concurrent"
++ PURPOSE "Provides a high-level multi-threading API."
++ CONDITION QT_FEATURE_future
++ )
++ qt_feature_definition("concurrent" "QT_NO_CONCURRENT" NEGATE VALUE "1")
++ qt_feature("dbus" PUBLIC PRIVATE
++ LABEL "Qt D-Bus"
++ AUTODETECT NOT UIKIT AND NOT ANDROID AND NOT VXWORKS
++ CONDITION QT_FEATURE_thread AND NOT WASM
++ )
++ qt_feature_definition("dbus" "QT_NO_DBUS" NEGATE VALUE "1")
++ qt_feature("dbus-linked" PRIVATE
++ LABEL "Qt D-Bus directly linked to libdbus"
++ CONDITION QT_FEATURE_dbus AND DBus1_FOUND
++ ENABLE INPUT_dbus STREQUAL 'linked'
++ DISABLE INPUT_dbus STREQUAL 'runtime'
++ )
++ qt_feature("qreal"
++ LABEL "Type for qreal"
++ CONDITION DEFINED QT_COORD_TYPE AND NOT QT_COORD_TYPE STREQUAL "double"
++ )
++ qt_feature_definition("qreal" "QT_COORD_TYPE" VALUE "${QT_COORD_TYPE}")
++ qt_feature_definition("qreal" "QT_COORD_TYPE_STRING" VALUE "\"${QT_COORD_TYPE}\"")
++ if(QT_COORD_TYPE STREQUAL "double")
++ qt_feature_definition("qreal" "QT_COORD_TYPE_IS_DOUBLE" VALUE "1")
++ elseif(QT_COORD_TYPE STREQUAL "float")
++ qt_feature_definition("qreal" "QT_COORD_TYPE_IS_FLOAT" VALUE "1")
++ endif()
++ qt_feature("gui" PRIVATE
++ LABEL "Qt Gui"
++ VCPKG_DEFAULT
++ )
++ qt_feature_config("gui" QMAKE_PUBLIC_QT_CONFIG
++ NEGATE)
++ qt_feature("network" PRIVATE
++ LABEL "Qt Network"
++ SECTION "Module"
++ PURPOSE "Provides the Qt Network module."
++ VCPKG_DEFAULT
++ )
++ qt_feature("printsupport" PRIVATE
++ LABEL "Qt PrintSupport"
++ CONDITION QT_FEATURE_widgets
++ SECTION "Module"
++ PURPOSE "Provides the Qt PrintSupport module."
++ )
++ qt_feature("sql" PRIVATE
++ LABEL "Qt Sql"
++ SECTION "Module"
++ PURPOSE "Provides the Sql module."
++ VCPKG_OPTIONAL
++ )
++ qt_feature("testlib" PRIVATE
++ LABEL "Qt Testlib"
++ SECTION "Module"
++ PURPOSE "Provides the Qt Testlib module."
++ )
++ qt_feature("widgets" PRIVATE
++ LABEL "Qt Widgets"
++ AUTODETECT NOT TVOS AND NOT WATCHOS
++ CONDITION QT_FEATURE_gui
++ )
++ qt_feature_definition("widgets" "QT_NO_WIDGETS" NEGATE)
++ qt_feature_config("widgets" QMAKE_PUBLIC_QT_CONFIG
++ NEGATE)
++ qt_feature("xml" PRIVATE
++ LABEL "Qt Xml"
++ SECTION "Module"
++ PURPOSE "Provides the Qt Xml module."
++ )
++ qt_feature("libudev" PRIVATE
++ LABEL "udev"
++ CONDITION Libudev_FOUND AND NOT INTEGRITY AND NOT OHOS
++ )
++ qt_feature("openssl" PRIVATE
++ LABEL "OpenSSL"
++ CONDITION QT_FEATURE_openssl_runtime OR QT_FEATURE_openssl_linked
++ ENABLE false
++ VCPKG_DEFAULT
++ )
++ qt_feature_definition("openssl" "QT_NO_OPENSSL" NEGATE)
++ qt_feature_config("openssl" QMAKE_PUBLIC_QT_CONFIG)
++ qt_feature("openssl-runtime"
++ AUTODETECT NOT WASM
++ CONDITION TEST_opensslv11_headers OR TEST_opensslv30_headers
++ ENABLE INPUT_openssl STREQUAL 'yes' OR INPUT_openssl STREQUAL 'runtime'
++ DISABLE INPUT_openssl STREQUAL 'no' OR INPUT_openssl STREQUAL 'linked' OR INPUT_ssl STREQUAL 'no'
++ )
++ qt_feature("openssl-linked" PUBLIC
++ LABEL " Qt directly linked to OpenSSL"
++ AUTODETECT OFF
++ CONDITION TEST_opensslv11 OR TEST_opensslv30
++ ENABLE INPUT_openssl STREQUAL 'linked'
++ )
++ qt_feature_definition("openssl-linked" "QT_LINKED_OPENSSL")
++ qt_feature("opensslv11" PUBLIC
++ LABEL "OpenSSL 1.1"
++ CONDITION TEST_opensslv11 OR TEST_opensslv11_headers
++ DISABLE INPUT_openssl STREQUAL 'no' OR INPUT_ssl STREQUAL 'no'
++ )
++ qt_feature("opensslv30" PUBLIC
++ LABEL "OpenSSL 3.0"
++ CONDITION TEST_opensslv30 OR TEST_opensslv30_headers
++ DISABLE INPUT_openssl STREQUAL 'no' OR INPUT_ssl STREQUAL 'no'
++ )
++ qt_feature("ccache"
++ LABEL "Using ccache"
++ AUTODETECT 1
++ CONDITION QT_USE_CCACHE
++ )
++ qt_feature_config("ccache" QMAKE_PRIVATE_CONFIG)
++ qt_feature("static_runtime"
++ LABEL "Statically link the C/C++ runtime library"
++ AUTODETECT OFF
++ CONDITION NOT QT_FEATURE_shared
++ EMIT_IF WIN32
++ )
++ qt_feature_config("static_runtime" QMAKE_PUBLIC_CONFIG)
++ qt_feature_config("static_runtime" QMAKE_PUBLIC_QT_CONFIG)
++ qt_feature("static_compiler_runtime" PUBLIC
++ LABEL "Statically link the C++ library and compiler runtime, but not the UCRT"
++ AUTODETECT OFF
++ CONDITION NOT QT_FEATURE_static_runtime AND WIN32 AND MSVC
++ )
++ qt_feature("dlopen" PRIVATE
++ LABEL "dlopen()"
++ CONDITION UNIX AND NOT INTEGRITY
++ )
++ qt_feature("relocatable" PRIVATE
++ LABEL "Relocatable"
++ PURPOSE "Enable the Qt installation to be relocated."
++ AUTODETECT QT_FEATURE_shared OR APPLE
++ CONDITION QT_FEATURE_dlopen OR WIN32 OR NOT QT_FEATURE_shared
++ )
++ # hardening features
++ qt_feature("intelcet" PRIVATE
++ LABEL "Using Intel Control-flow Enforcement Technology (CET)"
++ AUTODETECT ON
++ CONDITION TEST_intelcet
++ )
++ qt_feature_config("intelcet" QMAKE_PUBLIC_CONFIG)
++ qt_feature("glibc_fortify_source" PRIVATE
++ LABEL "Using Glibc function fortification level 3, if it's supported, otherwise level 2"
++ AUTODETECT ON
++ CONDITION TEST_glibc_fortify_source_3 OR TEST_glibc
++ )
++ qt_feature_config("glibc_fortify_source" QMAKE_PUBLIC_CONFIG)
++ qt_feature("trivial_auto_var_init_pattern" PRIVATE
++ LABEL "Using -ftrivial-auto-var-init=pattern"
++ AUTODETECT ON
++ CONDITION TEST_trivial_auto_var_init_pattern
++ )
++ qt_feature_config("trivial_auto_var_init_pattern" QMAKE_PUBLIC_CONFIG)
++ qt_feature("stack_protector" PRIVATE
++ LABEL "Using -fstack-protector-strong"
++ AUTODETECT ON
++ CONDITION TEST_stack_protector
++ )
++ qt_feature_config("stack_protector" QMAKE_PUBLIC_CONFIG)
++ qt_feature("stack_clash_protection" PRIVATE
++ LABEL "Using -fstack-clash-protection"
++ AUTODETECT ON
++ CONDITION TEST_stack_clash_protection
++ )
++ qt_feature_config("stack_clash_protection" QMAKE_PUBLIC_CONFIG)
++ qt_feature("libstdcpp_assertions" PRIVATE
++ LABEL "Using libstdc++ assertions"
++ AUTODETECT ON
++ CONDITION (GCC OR (CLANG AND NOT MSVC AND NOT QT_FEATURE_stdlib_libcpp AND NOT TEST_using_stdlib_libcpp))
++ )
++ qt_feature_config("libstdcpp_assertions" QMAKE_PUBLIC_CONFIG)
++ qt_feature("libcpp_hardening" PRIVATE
++ LABEL "Using libc++ hardening"
++ AUTODETECT ON
++ CONDITION (QT_FEATURE_stdlib_libcpp OR TEST_using_stdlib_libcpp)
++ )
++ qt_feature_config("libcpp_hardening" QMAKE_PUBLIC_CONFIG)
++ qt_feature("relro_now_linker" PRIVATE
++ LABEL "Using -z relro -z now when linking"
++ AUTODETECT ON
++ CONDITION TEST_relro_now_linker
++ )
++ qt_feature_config("relro_now_linker" QMAKE_PUBLIC_CONFIG)
++
++
++ qt_config_compile_test(gcov
++ LABEL "gcov compiler flags"
++ COMPILE_OPTIONS "--coverage"
++ CODE
++ "int main(void)
++ {
++ /* BEGIN TEST: */
++ /* END TEST: */
++ return 0;
++ }
++ ")
++
++ qt_config_compile_test(llvm_cov_flags
++ LABEL "LLVM source-based coverage flags"
++ COMPILE_OPTIONS "-fprofile-instr-generate" "-fcoverage-mapping"
++ CODE
++ "int main(void)
++ {
++ /* BEGIN TEST: */
++ /* END TEST: */
++ return 0;
++ }
++ ")
++
++ qt_feature("coverage-gcov"
++ LABEL "Gcov"
++ AUTODETECT OFF
++ ENABLE INPUT_coverage STREQUAL "gcov"
++ CONDITION TEST_gcov AND
++ ( QT_FEATURE_debug OR QT_FEATURE_debug_and_release )
++ )
++
++ qt_feature("coverage-llvm"
++ LABEL "LLVM source-based"
++ AUTODETECT OFF
++ ENABLE INPUT_coverage STREQUAL "llvm-cov"
++ CONDITION TEST_llvm_cov_flags
++ )
++
++ qt_feature("coverage"
++ LABEL "Coverage"
++ CONDITION QT_FEATURE_coverage_gcov OR QT_FEATURE_coverage_llvm
++ )
++
++ # Mark the feature as PRIVATE because we want it to be exported, but we don't want modifications
++ # in the public qconfig.h header in a patch release.
++ qt_feature("android_16kb_pages" PRIVATE
++ LABEL "16KB page size"
++ PURPOSE "Build Android binaries aligned to 16KB page size."
++ CONDITION ANDROID AND (((CMAKE_ANDROID_NDK_VERSION VERSION_GREATER_EQUAL "25.0.0"))
++ AND ((CMAKE_ANDROID_ARCH_ABI STREQUAL "arm64-v8a") OR
++ (CMAKE_ANDROID_ARCH_ABI STREQUAL "x86_64")))
++ )
++ # The feature is saved into the public QT_CONFIG var in the qt_lib_core.pri file, to ensure it's
++ # available automatically for testing with qtConfig() in all user projects.
++ qt_feature_config("android_16kb_pages" QMAKE_PUBLIC_QT_CONFIG)
++
++ qt_feature("clang_module_maps" PRIVATE
++ LABEL "Generate Clang header module maps"
++ AUTODETECT OFF
++ ENABLE QT_FEATURE_swift_interop
++ )
++ qt_feature("swift_interop" PRIVATE
++ LABEL "Swift/C++ interoperability"
++ PURPOSE "Enable Swift/C++ interoperability for Qt modules."
++ AUTODETECT OFF
++ )
++
++ qt_configure_add_summary_build_type_and_config()
++ qt_configure_add_summary_section(NAME "Build options")
++ qt_configure_add_summary_build_mode(Mode)
++ qt_configure_add_summary_entry(
++ ARGS "optimize_debug"
++ CONDITION NOT MSVC AND NOT CLANG AND ( QT_FEATURE_debug OR QT_FEATURE_debug_and_release )
++ )
++ qt_configure_add_summary_entry(
++ ARGS "optimize_size"
++ CONDITION NOT QT_FEATURE_debug OR QT_FEATURE_debug_and_release
++ )
++ qt_configure_add_summary_entry(
++ ARGS "optimize_full"
++ )
++ qt_configure_add_summary_entry(ARGS "force_asserts" CONDITION QT_FEATURE_force_asserts)
++ qt_configure_add_summary_entry(ARGS "shared")
++ qt_configure_add_summary_entry(
++ ARGS "ccache"
++ CONDITION UNIX
++ )
++ qt_configure_add_summary_entry(
++ TYPE "message" ARGS "Unity Build" MESSAGE "yes" CONDITION QT_UNITY_BUILD
++ )
++ qt_configure_add_summary_entry(
++ TYPE "message" ARGS "Unity Build" MESSAGE "no" CONDITION NOT QT_UNITY_BUILD
++ )
++ qt_configure_add_summary_entry(
++ TYPE "message"
++ ARGS "Unity Build Batch Size"
++ MESSAGE "${QT_UNITY_BUILD_BATCH_SIZE}"
++ CONDITION QT_UNITY_BUILD
++ )
++ qt_configure_add_summary_entry(
++ TYPE "firstAvailableFeature"
++ ARGS "use_bfd_linker use_gold_linker use_lld_linker use_mold_linker"
++ MESSAGE "Linker"
++ CONDITION QT_FEATURE_use_bfd_linker OR QT_FEATURE_use_gold_linker OR QT_FEATURE_use_lld_linker
++ OR QT_FEATURE_use_mold_linker
++ )
++ qt_configure_add_summary_entry(
++ ARGS "enable_new_dtags"
++ CONDITION QT_FEATURE_elf
++ )
++ qt_configure_add_summary_entry(
++ ARGS "enable_gdb_index"
++ CONDITION GCC AND NOT CLANG AND ( QT_FEATURE_debug OR QT_FEATURE_force_debug_info OR QT_FEATURE_debug_and_release )
++ )
++ qt_configure_add_summary_entry(ARGS "relocatable")
++ qt_configure_add_summary_entry(ARGS "ltcg")
++ qt_configure_add_summary_entry(ARGS "intelcet")
++ qt_configure_add_summary_entry(ARGS "glibc_fortify_source")
++ qt_configure_add_summary_entry(ARGS "trivial_auto_var_init_pattern")
++ qt_configure_add_summary_entry(ARGS "stack_protector")
++ qt_configure_add_summary_entry(ARGS "stack_clash_protection")
++ qt_configure_add_summary_entry(ARGS "libstdcpp_assertions")
++ qt_configure_add_summary_entry(ARGS "libcpp_hardening")
++ qt_configure_add_summary_entry(ARGS "relro_now_linker")
++ qt_configure_add_summary_entry(
++ ARGS "wasm-simd128"
++ CONDITION ( TEST_architecture_arch STREQUAL wasm )
++ )
++ qt_configure_add_summary_entry(
++ ARGS "wasm-exceptions"
++ CONDITION ( TEST_architecture_arch STREQUAL wasm )
++ )
++ qt_configure_add_summary_entry(
++ ARGS "wasm-jspi"
++ CONDITION ( TEST_architecture_arch STREQUAL wasm )
++ )
++ qt_configure_add_summary_section(NAME "Target compiler supports")
++ qt_configure_add_summary_entry(
++ TYPE "featureList"
++ ARGS "x86intrin vaes avx512vbmi2"
++ MESSAGE "x86 Intrinsics"
++ CONDITION ( ( TEST_architecture_arch STREQUAL i386 ) OR ( TEST_architecture_arch STREQUAL x86_64 ) )
++ )
++ qt_configure_add_summary_entry(
++ TYPE "featureList"
++ ARGS "neon arm_crc32 arm_crypto arm_sve"
++ MESSAGE "ARM Extensions"
++ CONDITION ( TEST_architecture_arch STREQUAL arm ) OR ( TEST_architecture_arch STREQUAL arm64 )
++ )
++ qt_configure_add_summary_entry(
++ TYPE "featureList"
++ ARGS "lsx lasx"
++ MESSAGE "LOONGARCH Extensions"
++ CONDITION ( TEST_architecture_arch STREQUAL loongarch64 )
++ )
++ qt_configure_add_summary_entry(
++ ARGS "mips_dsp"
++ CONDITION ( TEST_architecture_arch STREQUAL mips )
++ )
++ qt_configure_add_summary_entry(
++ ARGS "mips_dspr2"
++ CONDITION ( TEST_architecture_arch STREQUAL mips )
++ )
++ qt_configure_end_summary_section() # end of "Target compiler supports" section
++ qt_configure_add_summary_section(NAME "Sanitizers")
++ qt_configure_add_summary_entry(ARGS "sanitize_address")
++ qt_configure_add_summary_entry(ARGS "sanitize_thread")
++ qt_configure_add_summary_entry(ARGS "sanitize_memory")
++ qt_configure_add_summary_entry(ARGS "sanitize_fuzzer_no_link")
++ qt_configure_add_summary_entry(ARGS "sanitize_undefined")
++ qt_configure_end_summary_section() # end of "Sanitizers" section
++ qt_configure_add_summary_build_parts("Build parts")
++ if(QT_INSTALL_EXAMPLES_SOURCES)
++ set(_examples_sources_entry_message "yes")
++ else()
++ set(_examples_sources_entry_message "no")
++ endif()
++ qt_configure_add_summary_entry(ARGS "Install examples sources" TYPE "message"
++ MESSAGE "${_examples_sources_entry_message}")
++ qt_configure_add_summary_entry(
++ ARGS "appstore-compliant"
++ CONDITION APPLE OR ANDROID OR WIN32
++ )
++ qt_configure_add_summary_entry(
++ ARGS "clang_module_maps"
++ CONDITION QT_FEATURE_clang_module_maps
++ )
++ qt_configure_add_summary_entry(
++ ARGS "swift_interop"
++ CONDITION QT_FEATURE_swift_interop
++ )
++ qt_configure_end_summary_section() # end of "Build options" section
++ qt_configure_add_summary_section(NAME "Qt modules and options")
++ qt_configure_add_summary_entry(ARGS "concurrent")
++ qt_configure_add_summary_entry(ARGS "dbus")
++ qt_configure_add_summary_entry(ARGS "dbus-linked")
++ qt_configure_add_summary_entry(ARGS "gui")
++ qt_configure_add_summary_entry(ARGS "network")
++ qt_configure_add_summary_entry(ARGS "printsupport")
++ qt_configure_add_summary_entry(ARGS "sql")
++ qt_configure_add_summary_entry(ARGS "testlib")
++ qt_configure_add_summary_entry(ARGS "widgets")
++ qt_configure_add_summary_entry(ARGS "xml")
++ qt_configure_end_summary_section() # end of "Qt modules and options" section
++ qt_configure_add_summary_section(NAME "Support enabled for")
++ qt_configure_add_summary_entry(ARGS "pkg-config")
++
++ if(QT_USE_VCPKG
++ AND (
++ (DEFINED ENV{VCPKG_ROOT} AND EXISTS "$ENV{VCPKG_ROOT}")
++ OR VCPKG_TARGET_TRIPLET
++ )
++ )
++ set(_vcpkg_entry_message "yes")
++ else()
++ set(_vcpkg_entry_message "no")
++ endif()
++ qt_configure_add_summary_entry(ARGS "Using vcpkg" TYPE "message" MESSAGE "${_vcpkg_entry_message}")
++
++ qt_configure_add_summary_entry(ARGS "libudev")
++ qt_configure_add_summary_entry(ARGS "liburing")
++ qt_configure_add_summary_entry(ARGS "openssl")
++ qt_configure_add_summary_entry(ARGS "openssl-linked")
++ qt_configure_add_summary_entry(ARGS "opensslv11")
++ qt_configure_add_summary_entry(ARGS "opensslv30")
++ qt_configure_add_summary_entry(ARGS "system-zlib")
++ qt_configure_add_summary_entry(ARGS "zstd")
++ qt_configure_add_summary_entry(ARGS "thread")
++ qt_configure_add_summary_entry(ARGS "android_16kb_pages")
++
++ qt_configure_end_summary_section() # end of "Support enabled for" section
++ qt_configure_add_report_entry(
++ TYPE NOTE
++ MESSAGE "Using static linking will disable the use of dynamically loaded plugins. Make sure to import all needed static plugins, or compile needed modules into the library."
++ CONDITION NOT QT_FEATURE_shared
++ )
++ qt_configure_add_report_entry(
++ TYPE WARNING
++ MESSAGE "-debug-and-release is only supported on Darwin and Windows platforms. Qt can be built in release mode with separate debug information, so -debug-and-release is no longer necessary."
++ CONDITION INPUT_debug_and_release STREQUAL 'yes' AND NOT APPLE AND NOT WIN32
++ )
++ qt_configure_add_report_entry(
++ TYPE ERROR
++ MESSAGE "Static builds don't support RPATH"
++ CONDITION ( QT_FEATURE_rpath OR QT_EXTRA_RPATHS ) AND NOT QT_FEATURE_shared
++ )
++ qt_configure_add_report_entry(
++ TYPE ERROR
++ MESSAGE "Command line option -sanitize fuzzer-no-link is only supported with clang compilers."
++ CONDITION QT_FEATURE_sanitize_fuzzer_no_link AND NOT CLANG
++ )
++ if (TEST_architecture_arch STREQUAL x86_64 OR TEST_architecture_arch STREQUAL i386)
++ if ((TEST_architecture_arch STREQUAL i386) OR QNX OR WASM)
++ # Warn only
++ qt_configure_add_report_entry(
++ TYPE WARNING
++ CONDITION (NOT QT_FEATURE_x86intrin)
++ MESSAGE [=[
++ All x86 intrinsics and SIMD support were disabled. If this was in error, check
++ the result of the build in config.tests/x86intrin and report at https://bugreports.qt.io.
++ ]=]
++ )
++ elseif (MSVC AND CLANG)
++ # Warn only
++ qt_configure_add_report_entry(
++ TYPE WARNING
++ CONDITION (NOT QT_FEATURE_x86intrin)
++ MESSAGE [=[
++ x86 intrinsics support is disabled for clang-cl build. This might be necessary due to
++ ]=]
++ )
++ else()
++ string(CONCAT x86_intrin_error_message
++ "x86 intrinsics support missing. Check your compiler settings.\n"
++ "If this is a problem for you, report at https://bugreports.qt.io with your compiler ID and "
++ "version, and the TEST_x86intrin compile test output.\n"
++ )
++ qt_configure_add_report_entry(
++ TYPE ERROR
++ CONDITION (NOT QT_FEATURE_x86intrin)
++ COMPILE_TESTS_TO_SHOW_ON_ERROR TEST_x86intrin
++ MESSAGE "${x86_intrin_error_message}"
++ )
++ endif()
++ endif()
++ qt_configure_add_report_entry(
++ TYPE ERROR
++ MESSAGE "Setting a library infix is not supported for framework builds."
++ CONDITION QT_FEATURE_framework AND DEFINED QT_LIBINFIX
++ )
++ qt_configure_add_report_entry(
++ TYPE NOTE
++ MESSAGE "WASM Thread support enabled."
++ CONDITION QT_FEATURE_thread AND WASM
++ )
++ qt_configure_add_report_entry(
++ TYPE ERROR
++ MESSAGE "You should use the recommended Emscripten version ${QT_EMCC_RECOMMENDED_VERSION} with this Qt. You have ${EMCC_VERSION}."
++ CONDITION WASM AND ${EMCC_VERSION} VERSION_LESS ${QT_EMCC_RECOMMENDED_VERSION}
++ )
++ qt_configure_add_report_entry(
++ TYPE WARNING
++ MESSAGE "Using Emscripten version ${EMCC_VERSION} with this Qt
++ may have issues. The recommended version is ${QT_EMCC_RECOMMENDED_VERSION}."
++ CONDITION WASM AND ${EMCC_VERSION} VERSION_GREATER ${QT_EMCC_RECOMMENDED_VERSION}
++ )
++ qt_configure_add_report_entry(
++ TYPE WARNING
++ MESSAGE "Some tests might fail to build when targeting WASM without -feature-thread."
++ CONDITION WASM AND QT_BUILD_TESTS AND NOT QT_FEATURE_thread
++ )
++ qt_configure_add_report_entry(
++ TYPE ERROR
++ MESSAGE "Building Qt with C++20 is not supported with MSVC 2019."
++ CONDITION QT_FEATURE_cxx20 AND MSVC AND MSVC_VERSION LESS "1930"
++ )
++ qt_configure_add_report_entry(
++ TYPE ERROR
++ MESSAGE "You cannot force both system and bundled libraries."
++ CONDITION QT_FEATURE_force_bundled_libs AND QT_FEATURE_force_system_libs
++ )
++ qt_configure_add_report_entry(
++ TYPE NOTE
++ MESSAGE "Building Qt for Android and user projects with 16KB page sizes."
++ CONDITION QT_FEATURE_android_16kb_pages
++ )
++ if(WASM)
++ qt_extra_definition("QT_EMCC_VERSION" "\"${EMCC_VERSION}\"" PUBLIC)
++ endif()
++ qt_extra_definition("QT_VERSION_STR" "\"${PROJECT_VERSION}\"" PUBLIC)
++ qt_extra_definition("QT_VERSION_MAJOR" ${PROJECT_VERSION_MAJOR} PUBLIC)
++ qt_extra_definition("QT_VERSION_MINOR" ${PROJECT_VERSION_MINOR} PUBLIC)
++ qt_extra_definition("QT_VERSION_PATCH" ${PROJECT_VERSION_PATCH} PUBLIC)
++
++ qt_extra_definition("QT_COPYRIGHT" \"${QT_COPYRIGHT}\" PUBLIC)
++
++ qt_configure_add_report_entry(
++ TYPE WARNING
++ MESSAGE "QT_ALLOW_SYMLINK_IN_PATHS is enabled. This is not recommended, and it may lead to unexpected issues.
++ E.g., When building QtWebEngine, enabling this option may result in build issues in certain platforms.
++ CONDITION QT_ALLOW_SYMLINK_IN_PATHS
++ )
++
++ # QtGuiTest interface
++ qt_feature_definition("test_gui" "QT_GUI_TEST" VALUE "1")
++ qt_feature("test_gui" PUBLIC
++ LABEL "Build QtGuiTest namespace"
++ )
++
++ # Run squish based tests on Windows, macOS and Linux
++ qt_feature("test_squish" PUBLIC
++ LABEL "Run Squish based tests"
++ CONDITION WIN32 OR (APPLE AND NOT IOS) OR (CMAKE_SYSTEM_NAME STREQUAL "Linux" AND NOT ANDROID)
++ )
++
++ qt_configure_add_report_entry(
++ TYPE NOTE
++ MESSAGE "Building Squish Autotests"
++ CONDITION QT_FEATURE_test_squish AND QT_BUILD_TESTS
++ )
++
++ # Fuzz tests — generate and run fuzz targets with qt_fuzzgen
++ find_program(QT_FUZZGEN_EXECUTABLE qt_fuzzgen
++ HINTS "${QT_HOST_PATH}/libexec" "${QT_HOST_PATH}/bin"
++ )
++ qt_feature("test_fuzz" PUBLIC
++ LABEL "Generate and run fuzz tests"
++ AUTODETECT OFF
++ CONDITION QT_FUZZGEN_EXECUTABLE AND QT_BUILD_TESTS
++ )
++ qt_configure_add_report_entry(
++ TYPE NOTE
++ MESSAGE "Generating fuzz tests with qt_fuzzgen"
++ CONDITION QT_FEATURE_test_fuzz
++ )
++
++ # Compile autotests
++ qt_feature("test_auto" PUBLIC
++ LABEL "Compile auto tests"
++ )
++
++ # Compile baseline tests
++ qt_feature("test_baseline" PUBLIC
++ LABEL "Compile baseline tests"
++ AUTODETECT OFF
++ )
++
++ qt_configure_add_report_entry(
++ TYPE WARNING
++ MESSAGE "Starting with Qt 6.10, a -no-prefix or -developer-build
++ Qt build might not find all necessary Qt packages when using CMake < 3.26.
++ Please use a newer CMake version."
++ CONDITION QT_FEATURE_no_prefix AND CMAKE_VERSION VERSION_LESS "3.26"
++ )