1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
qtbase/cmake/QtPublicDependencyHelpers.cmake
Alexandru Croitor 5da0b7624f CMake: Prevent most global promotion errors when building Qt 
Backstory.

The main reason why we keep getting "unable to promote 3rd party 'X'
target to global scope" errors when building Qt repositories, is
because we try to promote 3rd party imported targets in a different
scope than where the imported targets were created.

What were the main motivations for promoting 3rd party targets to
global?

1) imported targets are by default local to the directory scope they
   were created in

2) we want 3rd party targets to be accessible across subdirectory
   scopes, but looked up once, e.g. qt_find_package(JPEG) looked up in
   src/gui/CMakeLists.txt, but the target should also be usable in the
   sibling scope
   src/plugins/imageformats/CMakeLists.txt
   Having the package lookup close to the consuming qt module is easier
   to maintain, because all the other 3rd party dependency lookups are
   in the same file. This goes against the conventional CMake advice
   where each subdirectory should look for its own dependencies, or the
   dependency should be available directly in the root project scope.

3) to make the 3rd party targets available in the root project scope
   as part of the following flow:
   QtPostProcess.cmake ->
   qt_internal_create_module_depends_file() ->
   qt_collect_third_party_deps() ->
   get_property(INTERFACE_QT_PACKAGE_NAME) ->
   write 3rd party Dependencies.cmake file for each qt module.
   Properties can only be queried from an imported target if it's in
   the same scope or was promoted to global, otherwise you get
   'non-existent target' errors.

4) for prl and pri file generation, where we need the targets to be
   available during generator expression evaluation within the
   relevant qt module directory scope

Here is a list of approaches I came up with on how to improve the
situation.

1) Make all imported targets global during the Qt build, by iterating
   over the directory property IMPORTED_TARGETS and making each one
   global.
   Requires CMake 3.21.
   Status: Already implemented for a long time, but is opt-in.
   Pros: Relatively robust
   Cons: Minimum CMake version for building Qt is 3.16.

2) Make all imported targets global during the Qt build using the
   CMAKE_FIND_PACKAGE_TARGETS_GLOBAL variable.
   Requires CMake 3.24.
   Status: Not implemented, but can be set by Qt builders directly on
   the command line.
   Pros: Should be robust
   Cons: Minimum CMake version for building Qt is 3.16.

3) Abandon the desire to have a single qt_find_package in a single
   directory scope, and embrace the CMake-way of repeating the
   dependency in each subdirectory that requires it.
   Status: Not implemented.
   Pros: Should be robust
   Cons: A lot of qt_find_package duplication, will require rewriting
   various code paths, QtPostProcess would have to be done at
   directory scope, unclear if dependency tracking will still work
   work reliably when there might be multiple same-named
   directory-scoped targets, other unknown unknowns

4) Move all qt_find_package calls into a $repo_name/dependencies.cmake
   file which would be read at project root scope. This would
   potentially avoid all scoping issues, because all dependencies will
   have to be specified at root scope.
   Status: Not implemented.
   Pros: No duplication
   Cons: Dependencies are not scoped anymore to module directories,
   won't be able to conditionally look for dependencies based on
   module feature evaluation, not clear yet how this will tie into
   standalone tests which are in tests/ subdir, other unknown unknowns

5) Try to promote as many 3rd party libraries at project root scope
   as possible.
   Currently we have 2 general locations where we look up
   dependencies.
   One is each qt_find_package call. The other is
   Qt6FooDependencies.cmake ->
   _qt_internal_find_third_party_dependencies().

   Many 3rd party targets are created by
   _qt_internal_find_third_party_dependencies() in the root scope, but
   not promoted, and then we try to promote them in child scopes using
   qt_find_package, which causes the promotion errors.

   Starting with 58eefbd0b6169d0749b312268c1ae1e594e04362 and
   37a5e001277db9e1392a242171ab2b88cb6c3049 we now record the provided
   targets of previous qt_find_package calls.

   So instead of waiting to try and promote targets later during the
   configuration process, we can make sure we promote the targets at
   _qt_internal_find_third_party_dependencies() call time, right
   when we lookup the Qt dependencies of the qt repo, in the root
   scope.

   Status: Implemented in this change

   Notably, we only promote 3rd party targets to global for qt builds,
   and not user projects, to not accidentally break user project
   behaviors.

   Also, we only promote 3rd party targets, and not Qt internal
   targets like Qt6::Core, Qt6::Platform, Qt6::PlatformCommonInternal,
   Qt6::GlobalConfig, etc, for a few reasons:
   - the code that requires targets to be global only cares about
     3rd party targets
   - promoting the internal targets is more prone to breaking, because
     there is more than one place where find_package(Qt6Foo) might be
     called, and if that ends up being in a different directory scope,
     we encounter the same global promotion errors.
     Some notable cases where this happens:
      - tests/CMakeLists.txt brings in extra Qt packages via
        StandaloneTestsConfig.cmake files
      - qtbase standalone tests qt_internal_qtbase_pre_project_setup()
        calls find_package(Qt6 COMPONENTS BuildInternals) which ends
        up creating the Platform target in the root scope instead of
	the tests/ scope
      - Qt6::BundledLibpng links against Core, which ends up trying to
        promote Core's internal dependencies Platform and GlobalConfig

   To only promote 3rd party targets, we walk the dependencies of
   an initial target recursively, and skip promoting targets that have
   the _qt_is_internal_target or
   _qt_should_skip_global_promotion_always properties set.

   Pros: Improves the situation compared to the status quo
   Cons: Still not ideal due to the various filtering of internal
   targets and having to mark them as such.

6) Avoid promoting targets to global if we can detect that the target
   was created in a different scope than where we are trying to
   promote it.
   We can do that by comparing the target's BINARY_DIR to the
   CMAKE_CURRENT_BINARY_DIR and skip promotion if they are not equal.
   Status: Not implemented, but we can consider it because it's
   quick to do.
   Pros: More robust than newly implemented approach (5)
   Cons: Requires CMake 3.18, because trying to read the BINARY_DIR
   property on an INTERFACE_LIBRARY would error out.
   Also, if we implement it and make it the default when using 3.18+,
   we might 'collect' a lot more hidden promotion errors that will
   only be revealed later once someone uses CMake 3.16 or 3.17,
   because most will probably use newer CMake versions.
   Perhaps the trade-off is worth it?

Fixes: QTBUG-89204
Fixes: QTBUG-94356
Fixes: QTBUG-95052
Fixes: QTBUG-98807
Fixes: QTBUG-125371
Change-Id: I088a17a98ef35aa69537a3ad208c61de40def581
Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>
Reviewed-by:  Alexey Edelev <alexey.edelev@qt.io>
(cherry picked from commit d2e85cede01c0898ca73cbc3fb9f53aa9612cab5)
Reviewed-by: Qt Cherry-pick Bot <cherrypick_bot@qt-project.org>
2024-07-11 22:22:45 +00:00

327 lines
15 KiB
CMake
Raw Blame History

# Copyright (C) 2022 The Qt Company Ltd.
# SPDX-License-Identifier: BSD-3-Clause
# Note that target_dep_list does not accept a list of values, but a var name that contains the
# list of dependencies. See foreach block for reference.
macro(_qt_internal_find_third_party_dependencies target target_dep_list)
foreach(__qt_${target}_target_dep IN LISTS ${target_dep_list})
list(GET __qt_${target}_target_dep 0 __qt_${target}_pkg)
list(GET __qt_${target}_target_dep 1 __qt_${target}_is_optional)
list(GET __qt_${target}_target_dep 2 __qt_${target}_version)
list(GET __qt_${target}_target_dep 3 __qt_${target}_components)
list(GET __qt_${target}_target_dep 4 __qt_${target}_optional_components)
set(__qt_${target}_find_package_args "${__qt_${target}_pkg}")
if(__qt_${target}_version)
list(APPEND __qt_${target}_find_package_args "${__qt_${target}_version}")
endif()
if(__qt_${target}_components)
string(REPLACE " " ";" __qt_${target}_components "${__qt_${target}_components}")
list(APPEND __qt_${target}_find_package_args COMPONENTS ${__qt_${target}_components})
endif()
if(__qt_${target}_optional_components)
string(REPLACE " " ";"
__qt_${target}_optional_components "${__qt_${target}_optional_components}")
list(APPEND __qt_${target}_find_package_args
OPTIONAL_COMPONENTS ${__qt_${target}_optional_components})
endif()
_qt_internal_save_find_package_context_for_debugging(${target})
if(__qt_${target}_is_optional)
if(${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
list(APPEND __qt_${target}_find_package_args QUIET)
endif()
find_package(${__qt_${target}_find_package_args})
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()
# Note that target_dep_list does not accept a list of values, but a var name that contains the
# list of dependencies. See foreach block for reference.
macro(_qt_internal_find_tool_dependencies target target_dep_list)
if(NOT "${${target_dep_list}}" STREQUAL "" AND NOT "${QT_HOST_PATH}" STREQUAL "")
# Make sure that the tools find the host tools first
set(BACKUP_${target}_CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH})
set(BACKUP_${target}_CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH})
list(PREPEND CMAKE_PREFIX_PATH "${QT_HOST_PATH_CMAKE_DIR}"
"${_qt_additional_host_packages_prefix_paths}")
list(PREPEND CMAKE_FIND_ROOT_PATH "${QT_HOST_PATH}"
"${_qt_additional_host_packages_root_paths}")
endif()
foreach(__qt_${target}_target_dep IN LISTS ${target_dep_list})
list(GET __qt_${target}_target_dep 0 __qt_${target}_pkg)
list(GET __qt_${target}_target_dep 1 __qt_${target}_version)
unset(__qt_${target}_find_package_args)
if(${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
list(APPEND __qt_${target}_find_package_args QUIET)
endif()
_qt_internal_save_find_package_context_for_debugging(${target})
find_package(${__qt_${target}_pkg}
${__qt_${target}_version}
${__qt_${target}_find_package_args}
PATHS
"${CMAKE_CURRENT_LIST_DIR}/.."
"${_qt_cmake_dir}"
${_qt_additional_packages_prefix_paths}
)
if (NOT ${__qt_${target}_pkg}_FOUND AND NOT QT_ALLOW_MISSING_TOOLS_PACKAGES)
set(${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE)
set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE
"${CMAKE_FIND_PACKAGE_NAME} could not be found because dependency \
${__qt_${target}_pkg} could not be found.")
if(NOT "${QT_HOST_PATH}" STREQUAL "")
set(CMAKE_PREFIX_PATH ${BACKUP_${target}_CMAKE_PREFIX_PATH})
set(CMAKE_FIND_ROOT_PATH ${BACKUP_${target}_CMAKE_FIND_ROOT_PATH})
endif()
return()
endif()
endforeach()
if(NOT "${${target_dep_list}}" STREQUAL "" AND NOT "${QT_HOST_PATH}" STREQUAL "")
set(CMAKE_PREFIX_PATH ${BACKUP_${target}_CMAKE_PREFIX_PATH})
set(CMAKE_FIND_ROOT_PATH ${BACKUP_${target}_CMAKE_FIND_ROOT_PATH})
endif()
endmacro()
# Please note the target_dep_list accepts not the actual list values but the list names that
# contain preformed dependencies. See foreach block for reference.
# The same applies for find_dependency_path_list.
macro(_qt_internal_find_qt_dependencies target target_dep_list find_dependency_path_list)
foreach(__qt_${target}_target_dep IN LISTS ${target_dep_list})
list(GET __qt_${target}_target_dep 0 __qt_${target}_pkg)
list(GET __qt_${target}_target_dep 1 __qt_${target}_version)
if (NOT ${__qt_${target}_pkg}_FOUND)
# TODO: Remove Private handling once sufficient time has passed, aka all developers
# updated their builds not to contain stale FooDependencies.cmake files without the
# _qt_package_name property.
set(__qt_${target}_pkg_names ${__qt_${target}_pkg})
if(__qt_${target}_pkg MATCHES "(.*)Private$")
set(__qt_${target}_pkg_names "${CMAKE_MATCH_1};${__qt_${target}_pkg}")
endif()
_qt_internal_save_find_package_context_for_debugging(${target})
find_dependency(${__qt_${target}_pkg} ${__qt_${target}_version}
NAMES
${__qt_${target}_pkg_names}
PATHS
${QT_BUILD_CMAKE_PREFIX_PATH}
${${find_dependency_path_list}}
${_qt_additional_packages_prefix_paths}
${__qt_use_no_default_path_for_qt_packages}
)
endif()
endforeach()
endmacro()
# TODO: Remove once a dependency update completes and most developers have the Dependencies.cmake
# files updated in their builds.
# The name is too generic, it doesn't look for any kind of dependencies but only Qt package
# dependencies.
macro(_qt_internal_find_dependencies target_dep_list find_dependency_path_list)
_qt_internal_find_qt_dependencies("none" "${target_dep_list}" "${find_dependency_path_list}")
endmacro()
# If a dependency package was not found, provide some hints in the error message on how to debug
# the issue.
#
# pkg_name_var should be the variable name that contains the package that was not found.
# e.g. __qt_Core_pkg
#
# message_out_var should contain the variable name of the original "not found" message, and it
# will have the hints appended to it as a string. e.g. ${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE
#
# infix is used as a unique prefix to retrieve the find_package paths context for the last package
# that was not found, for debugging purposes.
#
# The function should not be called in Dependencies.cmake files directly, because find_dependency
# returns out of the included file.
macro(_qt_internal_suggest_dependency_debugging infix pkg_name_var message_out_var)
if(${pkg_name_var}
AND NOT ${CMAKE_FIND_PACKAGE_NAME}_FOUND
AND ${message_out_var})
if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.23")
string(APPEND ${message_out_var}
"\nConfiguring with --debug-find-pkg=${${pkg_name_var}} might reveal \
details why the package was not found.")
elseif(CMAKE_VERSION VERSION_GREATER_EQUAL "3.17")
string(APPEND ${message_out_var}
"\nConfiguring with -DCMAKE_FIND_DEBUG_MODE=TRUE might reveal \
details why the package was not found.")
endif()
if(NOT QT_DEBUG_FIND_PACKAGE)
string(APPEND ${message_out_var}
"\nConfiguring with -DQT_DEBUG_FIND_PACKAGE=ON will print the values of some of \
the path variables that find_package uses to try and find the package.")
else()
string(APPEND ${message_out_var}
"\n find_package search path values and other context for the last package that was not found:"
"\n CMAKE_MODULE_PATH: ${_qt_${infix}_CMAKE_MODULE_PATH}"
"\n CMAKE_PREFIX_PATH: ${_qt_${infix}_CMAKE_PREFIX_PATH}"
"\n \$ENV{CMAKE_PREFIX_PATH}: $ENV{CMAKE_PREFIX_PATH}"
"\n CMAKE_FIND_ROOT_PATH: ${_qt_${infix}_CMAKE_FIND_ROOT_PATH}"
"\n _qt_additional_packages_prefix_paths: ${_qt_${infix}_qt_additional_packages_prefix_paths}"
"\n _qt_additional_host_packages_prefix_paths: ${_qt_${infix}_qt_additional_host_packages_prefix_paths}"
"\n _qt_cmake_dir: ${_qt_${infix}_qt_cmake_dir}"
"\n QT_HOST_PATH: ${QT_HOST_PATH}"
"\n Qt6HostInfo_DIR: ${Qt6HostInfo_DIR}"
"\n Qt6_DIR: ${Qt6_DIR}"
"\n CMAKE_TOOLCHAIN_FILE: ${CMAKE_TOOLCHAIN_FILE}"
"\n CMAKE_FIND_ROOT_PATH_MODE_PACKAGE: ${CMAKE_FIND_ROOT_PATH_MODE_PACKAGE}"
"\n CMAKE_SYSROOT: ${CMAKE_SYSROOT}"
"\n \$ENV{PATH}: $ENV{PATH}"
)
endif()
endif()
endmacro()
# Save find_package search paths context just before a find_package call, to be shown with a
# package not found message.
macro(_qt_internal_save_find_package_context_for_debugging infix)
if(QT_DEBUG_FIND_PACKAGE)
set(_qt_${infix}_CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH}")
set(_qt_${infix}_CMAKE_PREFIX_PATH "${CMAKE_PREFIX_PATH}")
set(_qt_${infix}_CMAKE_FIND_ROOT_PATH "${CMAKE_FIND_ROOT_PATH}")
set(_qt_${infix}_qt_additional_packages_prefix_paths
"${_qt_additional_packages_prefix_paths}")
set(_qt_${infix}_qt_additional_host_packages_prefix_paths
"${_qt_additional_host_packages_prefix_paths}")
set(_qt_${infix}_qt_cmake_dir "${_qt_cmake_dir}")
endif()
endmacro()
function(_qt_internal_determine_if_host_info_package_needed out_var)
set(needed FALSE)
# If a QT_HOST_PATH is provided when configuring qtbase, we assume it's a cross build
# and thus we require the QT_HOST_PATH to be provided also when using the cross-built Qt.
# This tells the QtConfigDependencies file to do appropriate requirement checks.
if(NOT "${QT_HOST_PATH}" STREQUAL "" AND NOT QT_NO_REQUIRE_HOST_PATH_CHECK)
set(needed TRUE)
endif()
set(${out_var} "${needed}" PARENT_SCOPE)
endfunction()
macro(_qt_internal_find_host_info_package platform_requires_host_info)
if(${platform_requires_host_info})
find_package(Qt6HostInfo
CONFIG
REQUIRED
PATHS "${QT_HOST_PATH}"
"${QT_HOST_PATH_CMAKE_DIR}"
NO_CMAKE_FIND_ROOT_PATH
NO_DEFAULT_PATH)
endif()
endmacro()
macro(_qt_internal_setup_qt_host_path
host_path_required
initial_qt_host_path
initial_qt_host_path_cmake_dir
)
# Set up QT_HOST_PATH and do sanity checks.
# A host path is required when cross-compiling but optional when doing a native build.
# Requiredness can be overridden via variable.
if(DEFINED QT_REQUIRE_HOST_PATH_CHECK)
set(_qt_platform_host_path_required "${QT_REQUIRE_HOST_PATH_CHECK}")
else()
set(_qt_platform_host_path_required "${host_path_required}")
endif()
if(_qt_platform_host_path_required)
# QT_HOST_PATH precedence:
# - cache variable / command line option
# - environment variable
# - initial QT_HOST_PATH when qtbase was configured (and the directory exists)
if(NOT DEFINED QT_HOST_PATH)
if(DEFINED ENV{QT_HOST_PATH})
set(QT_HOST_PATH "$ENV{QT_HOST_PATH}" CACHE PATH "")
elseif(NOT "${initial_qt_host_path}" STREQUAL "" AND EXISTS "${initial_qt_host_path}")
set(QT_HOST_PATH "${initial_qt_host_path}" CACHE PATH "")
endif()
endif()
if(NOT QT_HOST_PATH STREQUAL "")
get_filename_component(_qt_platform_host_path_absolute "${QT_HOST_PATH}" ABSOLUTE)
endif()
if("${QT_HOST_PATH}" STREQUAL "" OR NOT EXISTS "${_qt_platform_host_path_absolute}")
message(FATAL_ERROR
"To use a cross-compiled Qt, please set the QT_HOST_PATH cache variable to the "
"location of your host Qt installation.")
endif()
# QT_HOST_PATH_CMAKE_DIR is needed to work around the rerooting issue when looking for host
# tools. See REROOT_PATH_ISSUE_MARKER.
# Prefer initially configured path if none was explicitly set.
if(NOT DEFINED QT_HOST_PATH_CMAKE_DIR)
if(NOT "${initial_qt_host_path_cmake_dir}" STREQUAL ""
AND EXISTS "${initial_qt_host_path_cmake_dir}")
set(QT_HOST_PATH_CMAKE_DIR "${initial_qt_host_path_cmake_dir}" CACHE PATH "")
else()
# First try to auto-compute the location instead of requiring to set
# QT_HOST_PATH_CMAKE_DIR explicitly.
set(__qt_candidate_host_path_cmake_dir "${QT_HOST_PATH}/lib/cmake")
if(__qt_candidate_host_path_cmake_dir
AND EXISTS "${__qt_candidate_host_path_cmake_dir}")
set(QT_HOST_PATH_CMAKE_DIR
"${__qt_candidate_host_path_cmake_dir}" CACHE PATH "")
endif()
endif()
endif()
if(NOT QT_HOST_PATH_CMAKE_DIR STREQUAL "")
get_filename_component(_qt_platform_host_path_cmake_dir_absolute
"${QT_HOST_PATH_CMAKE_DIR}" ABSOLUTE)
endif()
if("${QT_HOST_PATH_CMAKE_DIR}" STREQUAL ""
OR NOT EXISTS "${_qt_platform_host_path_cmake_dir_absolute}")
message(FATAL_ERROR
"To use a cross-compiled Qt, please set the QT_HOST_PATH_CMAKE_DIR cache variable "
"to the location of your host Qt installation lib/cmake directory.")
endif()
endif()
endmacro()
Reference in New Issue View Git Blame Copy Permalink