AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
574b625914
qt5base-lts/cmake/qt.toolchain.cmake.in

220 lines
9.9 KiB
CMake
Raw Normal View History

CMake: Fix usage of cache variables in qt.toolchain.cmake We have some cache variables that are used in our qt.toolchain.cmake toolchain file, for example QT_CHAINLOAD_TOOLCHAIN_FILE. When CMake runs a configure test with try_compile, our toolchain file is included again, but only a restricted set of variables is available. Add the variables that are used in our internal toolchain file to CMAKE_TRY_COMPILE_PLATFORM_VARIABLES. This makes them visible for try_compile calls operating on source files. Also pass the variables via the environment to support try_compile calls that operate on whole projects. Fixes: QTBUG-87873 Change-Id: Iebca9e23686bec5072194b15482e1782b9367a0e Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
2020-11-04 13:39:52 +00:00
set(__qt_toolchain_used_variables
QT_CHAINLOAD_TOOLCHAIN_FILE
QT_TOOLCHAIN_INCLUDE_FILE
QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR
CMake: Clean up and improve QT_HOST_PATH_CMAKE_DIR computation Previously when one wanted to use a cross-compiled Qt with a host Qt installed in a non-default location, they'd have to provide both QT_HOST_PATH and QT_HOST_PATH_CMAKE_DIR. This change will now try to first check if ${QT_HOST_PATH}/lib/cmake is a valid path on disk and use that. This is nicer to the user because they don't need to specify 2 paths anymore. Furthermore the path computation and sanity checks are now done after any extra toolchain cmake files are loaded, to give an opportunity to the files to set the paths first. Finally, both variables need to be added to __qt_toolchain_used_variables so they are passed along to try_compile calls if the variables are specified manually. Otherwise when the toolchain file is loaded by a try_compile project, it will error out saying no host path found (as long as the initial paths embedded in the toolchain are invalid). Amends 93fc3afe71467ca6aeffa41d7a6f4a170f82b62e and ec90f9013b4c6b63d7e03a964f66f97329be7885 Pick-to: 6.2 Change-Id: I433239b36b084f2d0a7a0dd043fdf87d77c138f3 Reviewed-by: Craig Scott <craig.scott@qt.io>
2021-10-20 13:46:50 +00:00
QT_TOOLCHAIN_RELOCATABLE_PREFIX
QT_HOST_PATH
QT_HOST_PATH_CMAKE_DIR
CMake: Allow enabling/disabling QT_HOST_PATH checks via variable One can now pass -DQT_REQUIRE_HOST_PATH_CHECK=OFF or -DQT_REQUIRE_HOST_PATH_CHECK=ON to force disable or enable the QT_HOST_PATH and QT_HOST_CMAKE_DIR_PATH validity checks. One potential use case is if a project wants to manually find QtFooTools packages by manipulating CMAKE_FIND_ROOT_PATH and such, in which case they might not want to pass a QT_HOST_PATH. Another potential use case is cross-building Qt with -DQT_BUILD_TOOLS_WHEN_CROSSCOMPILING=ON and allowing the same generated toolchain file to be used on the device image. By default the generated toolchain file would require a host path because it expects that it's still being used for cross-compiling. But once the toolchain file is deployed to the device there's no need to use the host tools anymore. Another use case is building a desktop Qt using the host tools of another desktop Qt. The new desktop Qt can use its newly built tools just fine and wouldn't need the original desktop Qt tools. QT_REQUIRE_HOST_PATH_CHECK needs to be added the list of vars to pass through to try_compile calls. Change-Id: I4b922b5d854828e6b9210dd8c07b4b1b8630aad1 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Craig Scott <craig.scott@qt.io>
2021-10-22 10:31:39 +00:00
QT_REQUIRE_HOST_PATH_CHECK
CMake: Clean up and improve QT_HOST_PATH_CMAKE_DIR computation Previously when one wanted to use a cross-compiled Qt with a host Qt installed in a non-default location, they'd have to provide both QT_HOST_PATH and QT_HOST_PATH_CMAKE_DIR. This change will now try to first check if ${QT_HOST_PATH}/lib/cmake is a valid path on disk and use that. This is nicer to the user because they don't need to specify 2 paths anymore. Furthermore the path computation and sanity checks are now done after any extra toolchain cmake files are loaded, to give an opportunity to the files to set the paths first. Finally, both variables need to be added to __qt_toolchain_used_variables so they are passed along to try_compile calls if the variables are specified manually. Otherwise when the toolchain file is loaded by a try_compile project, it will error out saying no host path found (as long as the initial paths embedded in the toolchain are invalid). Amends 93fc3afe71467ca6aeffa41d7a6f4a170f82b62e and ec90f9013b4c6b63d7e03a964f66f97329be7885 Pick-to: 6.2 Change-Id: I433239b36b084f2d0a7a0dd043fdf87d77c138f3 Reviewed-by: Craig Scott <craig.scott@qt.io>
2021-10-20 13:46:50 +00:00
)
CMake: Fix usage of cache variables in qt.toolchain.cmake We have some cache variables that are used in our qt.toolchain.cmake toolchain file, for example QT_CHAINLOAD_TOOLCHAIN_FILE. When CMake runs a configure test with try_compile, our toolchain file is included again, but only a restricted set of variables is available. Add the variables that are used in our internal toolchain file to CMAKE_TRY_COMPILE_PLATFORM_VARIABLES. This makes them visible for try_compile calls operating on source files. Also pass the variables via the environment to support try_compile calls that operate on whole projects. Fixes: QTBUG-87873 Change-Id: Iebca9e23686bec5072194b15482e1782b9367a0e Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
2020-11-04 13:39:52 +00:00
@init_additional_used_variables@
# Make cache variables used by this toolchain file available to the
# try_compile command that operates on sources files.
list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES ${__qt_toolchain_used_variables})
list(REMOVE_DUPLICATES CMAKE_TRY_COMPILE_PLATFORM_VARIABLES)
# Turn the environment variables that are created at the end of this
# file into proper variables. This is needed for try_compile calls
# that operate on whole projects.
if($ENV{_QT_TOOLCHAIN_VARS_INITIALIZED})
foreach(var ${__qt_toolchain_used_variables})
set(${var} "$ENV{_QT_TOOLCHAIN_${var}}")
endforeach()
endif()
Generate a toolchain and convenience cmake wrapper This gets us a step into the direction of convenience that qmake offered: * QtBase is configured with a long command line (especially when cross-compiling) * Afterwards application developers (or other module builds) can just use qmake && make By generating a toolchain file we can capture vcpkg and toolchain chain-loading and a shell script can take care of providing the prefix path. Change-Id: Ided81f5432cab862306f2bea86cfe8e56adf71b0 Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
2019-06-21 12:58:52 +00:00
@init_original_toolchain_file@
@init_vcpkg@
CMake: allow using ANDORID_NDK_ROOT for user projects Allow CMake for Android to use ANDROID_NDK_ROOT to deduce the path for QT_CHAINLOAD_TOOLCHAIN_FILE instead of the user providing it manually. Change-Id: Ida728011d5ca8d5a723d341ea77b173e8f105f8c Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
2020-10-26 19:50:36 +00:00
@init_platform@
CMake: Introduce QT_CHAINLOAD_TOOLCHAIN_FILE This variable can be set when using qt-cmake[-private] to override the CMake toolchain file that is chainloaded by Qt's toolchain file. Task-number: QTBUG-87068 Change-Id: Id529408381e4174becda1ba07a489535c8cf1314 Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
2020-10-06 13:23:05 +00:00
if(NOT "${QT_CHAINLOAD_TOOLCHAIN_FILE}" STREQUAL "")
set(__qt_chainload_toolchain_file "${QT_CHAINLOAD_TOOLCHAIN_FILE}")
endif()
CMake: Protect against Qt toolchain file recursive inclusion Three different people have encountered the issue that calling calling qt-cmake on a project prints 1000 inclusion lines of the same qt toolchain file, and then CMake bails out saying can't find the CMAKE_MAKE_PROGRAM Ninja. This happened because people accidentally called qt-cmake to configure qtbase (instead of just cmake), which created a toolchain file that chainloads itself recursively. Error out when configuring qtbase, and when using the generated toolchain file in the case when it would try to include itself. The solution is to remove the qtbase CMakeCache.txt file, and configure qtbase again, so it generates a proper qt.toolchain.cmake file. If somebody feels enthusiastic, they can move the check into the qt-cmake and qt-cmake-private shell scripts, and error out before the qtbase/CMakeCache.txt is polluted with the wrong toolchain file. That is left for people that feel more comfortable with bash and batch scripting. Change-Id: If518c94791fe7c30731e6e462e347f26a5213c64 Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>
2020-06-02 16:06:37 +00:00
if(__qt_chainload_toolchain_file)
get_filename_component(__qt_chainload_toolchain_file_real_path
"${__qt_chainload_toolchain_file}" REALPATH)
if(__qt_chainload_toolchain_file_real_path STREQUAL CMAKE_CURRENT_LIST_FILE)
message(FATAL_ERROR
"Woah, the Qt toolchain file tried to include itself recusively! '${__qt_chainload_toolchain_file}' "
"Make sure to remove qtbase/CMakeCache.txt and reconfigure qtbase with 'cmake' "
"rather than 'qt-cmake', and then you can reconfigure your own project."
)
CMake: Issue warning if chainloaded toolchain file does not exist Change-Id: Ib7e9b172c6e42feb074955786d49b071639ca86e Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
2020-10-07 08:31:40 +00:00
elseif(NOT EXISTS "${__qt_chainload_toolchain_file_real_path}")
message(WARNING "The toolchain file to be chainloaded "
"'${__qt_chainload_toolchain_file}' does not exist.")
CMake: Protect against Qt toolchain file recursive inclusion Three different people have encountered the issue that calling calling qt-cmake on a project prints 1000 inclusion lines of the same qt toolchain file, and then CMake bails out saying can't find the CMAKE_MAKE_PROGRAM Ninja. This happened because people accidentally called qt-cmake to configure qtbase (instead of just cmake), which created a toolchain file that chainloads itself recursively. Error out when configuring qtbase, and when using the generated toolchain file in the case when it would try to include itself. The solution is to remove the qtbase CMakeCache.txt file, and configure qtbase again, so it generates a proper qt.toolchain.cmake file. If somebody feels enthusiastic, they can move the check into the qt-cmake and qt-cmake-private shell scripts, and error out before the qtbase/CMakeCache.txt is polluted with the wrong toolchain file. That is left for people that feel more comfortable with bash and batch scripting. Change-Id: If518c94791fe7c30731e6e462e347f26a5213c64 Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>
2020-06-02 16:06:37 +00:00
else()
include("${__qt_chainload_toolchain_file}")
CMake: Show error in user projects if wasm toolchain file not found Rather than fail with obscure can't find Qt packages errors when the Webassembly CMake toolchain file can not be found, error out with a clear error on how to ensure it is found. Pick-to: 6.2 Task-number: QTBUG-96843 Change-Id: I0f34cdcde05efb25c93017f3fd365186335ed52c Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>
2021-09-27 10:27:23 +00:00
set(__qt_chainload_toolchain_file_included TRUE)
CMake: Protect against Qt toolchain file recursive inclusion Three different people have encountered the issue that calling calling qt-cmake on a project prints 1000 inclusion lines of the same qt toolchain file, and then CMake bails out saying can't find the CMAKE_MAKE_PROGRAM Ninja. This happened because people accidentally called qt-cmake to configure qtbase (instead of just cmake), which created a toolchain file that chainloads itself recursively. Error out when configuring qtbase, and when using the generated toolchain file in the case when it would try to include itself. The solution is to remove the qtbase CMakeCache.txt file, and configure qtbase again, so it generates a proper qt.toolchain.cmake file. If somebody feels enthusiastic, they can move the check into the qt-cmake and qt-cmake-private shell scripts, and error out before the qtbase/CMakeCache.txt is polluted with the wrong toolchain file. That is left for people that feel more comfortable with bash and batch scripting. Change-Id: If518c94791fe7c30731e6e462e347f26a5213c64 Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>
2020-06-02 16:06:37 +00:00
endif()
unset(__qt_chainload_toolchain_file)
Generate a toolchain and convenience cmake wrapper This gets us a step into the direction of convenience that qmake offered: * QtBase is configured with a long command line (especially when cross-compiling) * Afterwards application developers (or other module builds) can just use qmake && make By generating a toolchain file we can capture vcpkg and toolchain chain-loading and a shell script can take care of providing the prefix path. Change-Id: Ided81f5432cab862306f2bea86cfe8e56adf71b0 Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
2019-06-21 12:58:52 +00:00
endif()
CMake: Show error in user projects if wasm toolchain file not found Rather than fail with obscure can't find Qt packages errors when the Webassembly CMake toolchain file can not be found, error out with a clear error on how to ensure it is found. Pick-to: 6.2 Task-number: QTBUG-96843 Change-Id: I0f34cdcde05efb25c93017f3fd365186335ed52c Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>
2021-09-27 10:27:23 +00:00
@init_post_chainload_toolchain@
CMake: Make build system of installed Qt more relocatable Aka handle CMAKE_INSTALL_PREFIX in a more relocatable way. The following story inspired this change. If a user wants to build a Qt repo into a different install prefix than the usual Qt one, this will fail configuration because we look for various things like syncqt, qdoc, etc relative to CMAKE_INSTALL_PREFIX, which will now point to a different location where none of the above tools are located. The intent for such a use case is to support building Qt packages with Conan, which sets a random install prefix when configuring a repo. The idea is to derive the qt prefix dynamically from the QtBuildInternals package location. Essentially it's a reverse relative path from the QtBuildInternalsConfig.cmake file to the install prefix that was specified when initially configuring qtbase. Once the dynamic prefix is computed (so we know where the possibly relocated Qt is), we can find tools like syncqt and qdoc. This is an initial attempt to support a use case like that. More design work will probably needed in case if tools / libs need to be found in a location different than the Qt install prefix (so support for multiple install prefixes / search paths). An example of such a case would be when building qtdeclarative and qtquickcontrols2 as Conan packages in one go. Most likely the qmltyperegistrar tool will be located in the random install prefix set by Conan, so building qtquickcontrols2 might fail due to not finding the tool in the original Qt install prefix. As to the implementation details, the change does the following: - Dynamically computes and sets the QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX variable when find_package()'ing QtBuildInternals. It's an absolute path pointing to where the relocated Qt is. - When building qtbase this variable is not yet available (due to QtBuildInternalsExtra not existing), in that case we set the variable to the absolute path of CMAKE_INSTALL_PREFIX (but only for the initial qtbase configuration). - Remove QT_BUILD_INTERNALS_ORIGINAL_INSTALL_PREFIX which was used for standalone tests purposes. It's not needed now that we compute the location of the Qt prefix dynamically. - The Unixy qt-cmake and qt-cmake-private shell scripts now use a relative path to find the toolchain file we created. - The toolchain file also dynamically computes the location of the Qt packages, and adds them to CMAKE_PREFIX_PATH. - A lot of existing CMAKE_INSTALL_PREFIX uses are replaced with QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX. This includes finding tool locations, mkspecs dir, path environment setup for tools, etc. - Some places still use CMAKE_PREFIX_PATH in the following cases - When determining paths while configuring qtbase (valid cases) - When I wasn't sure what the behavior should be, so I left them as-is (an example is documentation generation, do we want to install it into the random Conan prefix, or into the main prefix? Currently it installs in the random prefix). Note that relocating a Qt installation does not work for non-prefix / non-installed builds, due to hardcoded paths to include directories and libraries in generated FooTargets.cmake files. Task-number: QTBUG-83999 Change-Id: I87d6558729db93121b1715771034b03ce3295923 Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>
2020-05-05 08:30:35 +00:00
# Compute dynamically the Qt installation prefix from the location of this file. This allows
# the usage of the toolchain file when the Qt installation is relocated.
get_filename_component(QT_TOOLCHAIN_RELOCATABLE_INSTALL_PREFIX
${CMAKE_CURRENT_LIST_DIR}/../@qt_path_from_cmake_config_dir_to_prefix@
ABSOLUTE)
CMake: Fix handling of CMAKE_FIND_ROOT_PATH and CMAKE_PREFIX_PATH While trying to implement the 'host artifact reuse' Coin instructions change, a bug surfaced where the qemu configurations didn't find the host tools and instead tried to use the cross-compiled tools while building qtbase, which failed due to not finding the runtime linker (another unsolved issue). Before the host artifact reuse change, the host tools were found successfully. The difference that caused the issue is that the target install prefix was a direct subfolder of the host prefix. host - /home/qt/work/qt/install target - /home/qt/work/qt/install/target Before the host reuse change the install prefixes were as follows host - /home/qt/work/qt/install/host target - /home/qt/work/qt/install/target While looking for the Qt6CoreTools package, we temporarily set CMAKE_FIND_ROOT_PATH and CMAKE_PREFIX_PATH to contain first '/home/qt/work/qt/install' and then '/home/qt/work/qt/install/target'. CMake then reroots the CMAKE_PREFIX_PATH values onto values in CMAKE_FIND_ROOT_PATH, making an MxN list of prefixes to search. Rerooting essentially means concatenating 2 paths, unless the considered prefix is a subfolder of the root path. What happened was that the first considered value was '/home/qt/work/qt/install/home/qt/work/qt/install', a non-existent location that gets discarded. The second considered value was '/home/qt/work/qt/install/target. The second value is the result of seeing that '/home/qt/work/qt/install/target' is a subfolder of '/home/qt/work/qt/install' and thus the root path is stripped. All of this is done in cmFindPackageCommand::FindConfig() -> cmFindCommon::RerootPaths. The behavior above caused the target tools be found instead of the host ones. Before the host reuse change, both of the initial constructed prefixes were discared due to them not existing, e.g. '/home/qt/work/qt/install/target/home/qt/work/qt/install/target' and '/home/qt/work/qt/install/host/home/qt/work/qt/install/host' One of the later prefixes combined CMAKE_FIND_ROOT_PATH == '/home/qt/work/qt/install/host' + CMAKE_PREFIX_PATH == '/' resulting in '/home/qt/work/qt/install/host/' and this accidentally found the host tools package. We actually stumbled upon this issue a while ago when implementing Qt 5.14 Android CMake support in 52c799ed4425076df4353c02950ea1444fe5f102 That commit message mentions the fix is to add a "lib/cmake" suffix to the PATHS option of find_package(). This would cause the subfolder => strip root behavior mentioned above. So finally the fix. First, make sure not to append QT_HOST_PATH in the toolchain file, there shouldn't be any need to do that, give that we temporarily set it when looking for Tools packages. Second, recreate the subdir scenario in the Qt toolchain file by setting CMAKE_FIND_ROOT_PATH to the current (relocated) install prefix as usual, but also setting CMAKE_PREFIX_PATH to a new value poining to the CMake directory. Aka '/home/alex/qt' and '/home/alex/qt/lib/cmake'. Third, when a QT_HOST_PATH is given, save 2 paths in the generated Qt toolchain: QT_HOST_PATH and QT_HOST_PATH_CMAKE_DIR. There are the host equivalents of the target ones above. Use these values when looking for host tools in Qt6CoreModuleDependencies.cmake, again facilitaing the subdir behavior. Note these are currently absolute paths and are not relocatable. We'll have to figure out if it's even possible to make the host path relocatable. Finally as a cleanup, look for the Qt6HostInfo package in QtSetup strictly in the given QT_HOST_PATH, so CMake doesn't accidentally find a system Qt package. Change-Id: Iefbcfbbcedd35f1c33417ab7e9f44eaf35ff6337 Reviewed-by: Cristian Adam <cristian.adam@qt.io>
2020-07-21 15:34:40 +00:00
# Compute the path to the installed Qt lib/cmake folder.
# We assume that the Qt toolchain location is inside the CMake Qt6 package, and thus the directory
# one level higher is what we're looking for.
get_filename_component(QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR "${CMAKE_CURRENT_LIST_DIR}/.." ABSOLUTE)
CMake: Fix QT_ADDITIONAL_PACKAGES_PREFIX_PATH for cross-builds The QT_ADDITIONAL_PACKAGES_PREFIX_PATH variable was introduced to allow specifying extra locations to find Qt packages. The reason it was introduced instead of just using CMAKE_PREFIX_PATH is because the Qt6 component find_package call uses NO_DEFAULT_PATH which means CMAKE_PREFIX_PATH is ignored. We use NO_DEFAULT_PATH to ensure we don't accidentally pick up system / distro Qt packages. The paths from QT_ADDITIONAL_PACKAGES_PREFIX_PATH are added to the find_package PATHS option in the Qt6 package, each ModuleDependencies.cmake file and some other places. Unfortunately that's not enough to make it work for cross-builds. Imagine the following scenario. host qtbase, qtdeclarative installed in /host_qt target qtbase installed in /target_qtbase target qtdeclarative installed in /target_qtdeclarative We want to cross-build qtlottie. We configure qtlottie as follows /target_qtbase/bin/qt-configure-module /qtlottie_src -- -DQT_ADDITIONAL_PACKAGES_PREFIX_PATH=/target_qtdeclarative We expect the target QtQuick package to be found, but it won't be. The reason is that QT_ADDITIONAL_PACKAGES_PREFIX_PATH is added to the PATHs option, but we don't adjust CMAKE_FIND_ROOT_PATH. Without adding the new paths in CMAKE_FIND_ROOT_PATH, CMake will re-root the passed PATHs under the existing CMAKE_FIND_ROOT_PATH, which is QT_TOOLCHAIN_RELOCATABLE_INSTALL_PREFIX, which evaluates to /target_qtbase. There is no QtQuick package there. To fix this, prepend the values of QT_ADDITIONAL_PACKAGES_PREFIX_PATH to CMAKE_FIND_ROOT_PATH. The location where we currently do CMAKE_FIND_ROOT_PATH manipulations is in the qt.toolchain.cmake file, so to be consistent, we prepend the new prefixes there as well. We need to adjust both CMAKE_FIND_ROOT_PATH and CMAKE_PREFIX_PATH, due the path re-rooting bug in CMake. See https://gitlab.kitware.com/cmake/cmake/-/issues/21937 as well as the existing comment in qt.toolchain.cmake marked with REROOT_PATH_ISSUE_MARKER. We also need to do a few more things to make the setup work Because Qt6Config uses NO_DEFAULT_PATH, the CMAKE_PREFIX_PATH adjustments we do in the toolchain file are not enough, so we still need to add the same prefixes to the Qt6Config find_package PATHS option. One would ask why do we need to adjust CMAKE_PREFIX_PATH at all then. It's for find_package(Qt6Foo) calls to work which don't go through the Qt6Config umbrella package. To make the CMake re-rooting behavior happy, we need to ensure the provided paths are absolute. So we iterate over the values of QT_ADDITIONAL_PACKAGES_PREFIX_PATH, to make them absolute. We do the same for the environment variable. We need to append lib/cmake to the prefixes which are added to CMAKE_PREFIX_PATH, otherwise the CMake re-rooting bug is hit. We need to specify the Qt6 package location (${_qt_cmake_dir}) to the PATHS option in the various Dependencies.cmake.in files, to ensure that dependency resolution can jump around between the Qt6 dir and the additional prefixes. Previously the dependency lookup code assumed that all dependencies would be within the same prefix. The same is needed for qt and qml plugin dependency lookup. Amends 7bb91398f25cb2016c0558fd397b376f413e3e96 Amends 60c87c68016c6f02b0eddd4002f75a49ab51d4a8 Amends 5bbd700124d13a292ff8bae6045316112500e230 Pick-to: 6.2 Fixes: QTBUG-95854 Change-Id: I35ae82330fec427d0d38fc9a0542ffafff52556a Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>
2021-08-17 15:03:02 +00:00
# REROOT_PATH_ISSUE_MARKER
CMake: Fix handling of CMAKE_FIND_ROOT_PATH and CMAKE_PREFIX_PATH While trying to implement the 'host artifact reuse' Coin instructions change, a bug surfaced where the qemu configurations didn't find the host tools and instead tried to use the cross-compiled tools while building qtbase, which failed due to not finding the runtime linker (another unsolved issue). Before the host artifact reuse change, the host tools were found successfully. The difference that caused the issue is that the target install prefix was a direct subfolder of the host prefix. host - /home/qt/work/qt/install target - /home/qt/work/qt/install/target Before the host reuse change the install prefixes were as follows host - /home/qt/work/qt/install/host target - /home/qt/work/qt/install/target While looking for the Qt6CoreTools package, we temporarily set CMAKE_FIND_ROOT_PATH and CMAKE_PREFIX_PATH to contain first '/home/qt/work/qt/install' and then '/home/qt/work/qt/install/target'. CMake then reroots the CMAKE_PREFIX_PATH values onto values in CMAKE_FIND_ROOT_PATH, making an MxN list of prefixes to search. Rerooting essentially means concatenating 2 paths, unless the considered prefix is a subfolder of the root path. What happened was that the first considered value was '/home/qt/work/qt/install/home/qt/work/qt/install', a non-existent location that gets discarded. The second considered value was '/home/qt/work/qt/install/target. The second value is the result of seeing that '/home/qt/work/qt/install/target' is a subfolder of '/home/qt/work/qt/install' and thus the root path is stripped. All of this is done in cmFindPackageCommand::FindConfig() -> cmFindCommon::RerootPaths. The behavior above caused the target tools be found instead of the host ones. Before the host reuse change, both of the initial constructed prefixes were discared due to them not existing, e.g. '/home/qt/work/qt/install/target/home/qt/work/qt/install/target' and '/home/qt/work/qt/install/host/home/qt/work/qt/install/host' One of the later prefixes combined CMAKE_FIND_ROOT_PATH == '/home/qt/work/qt/install/host' + CMAKE_PREFIX_PATH == '/' resulting in '/home/qt/work/qt/install/host/' and this accidentally found the host tools package. We actually stumbled upon this issue a while ago when implementing Qt 5.14 Android CMake support in 52c799ed4425076df4353c02950ea1444fe5f102 That commit message mentions the fix is to add a "lib/cmake" suffix to the PATHS option of find_package(). This would cause the subfolder => strip root behavior mentioned above. So finally the fix. First, make sure not to append QT_HOST_PATH in the toolchain file, there shouldn't be any need to do that, give that we temporarily set it when looking for Tools packages. Second, recreate the subdir scenario in the Qt toolchain file by setting CMAKE_FIND_ROOT_PATH to the current (relocated) install prefix as usual, but also setting CMAKE_PREFIX_PATH to a new value poining to the CMake directory. Aka '/home/alex/qt' and '/home/alex/qt/lib/cmake'. Third, when a QT_HOST_PATH is given, save 2 paths in the generated Qt toolchain: QT_HOST_PATH and QT_HOST_PATH_CMAKE_DIR. There are the host equivalents of the target ones above. Use these values when looking for host tools in Qt6CoreModuleDependencies.cmake, again facilitaing the subdir behavior. Note these are currently absolute paths and are not relocatable. We'll have to figure out if it's even possible to make the host path relocatable. Finally as a cleanup, look for the Qt6HostInfo package in QtSetup strictly in the given QT_HOST_PATH, so CMake doesn't accidentally find a system Qt package. Change-Id: Iefbcfbbcedd35f1c33417ab7e9f44eaf35ff6337 Reviewed-by: Cristian Adam <cristian.adam@qt.io>
2020-07-21 15:34:40 +00:00
# There's a subdirectory check in cmake's cmFindCommon::RerootPaths() function, that doesn't handle
# the case of CMAKE_PREFIX_PATH == CMAKE_FIND_ROOT_PATH for a particular pair of entries.
# Instead of collapsing the search prefix (which is the case when one is a subdir of the other),
# it concatenates them creating an invalid path. Workaround it by setting the root path to the
# Qt install prefix, and the prefix path to the lib/cmake subdir.
CMake: Fix QT_ADDITIONAL_PACKAGES_PREFIX_PATH for cross-builds The QT_ADDITIONAL_PACKAGES_PREFIX_PATH variable was introduced to allow specifying extra locations to find Qt packages. The reason it was introduced instead of just using CMAKE_PREFIX_PATH is because the Qt6 component find_package call uses NO_DEFAULT_PATH which means CMAKE_PREFIX_PATH is ignored. We use NO_DEFAULT_PATH to ensure we don't accidentally pick up system / distro Qt packages. The paths from QT_ADDITIONAL_PACKAGES_PREFIX_PATH are added to the find_package PATHS option in the Qt6 package, each ModuleDependencies.cmake file and some other places. Unfortunately that's not enough to make it work for cross-builds. Imagine the following scenario. host qtbase, qtdeclarative installed in /host_qt target qtbase installed in /target_qtbase target qtdeclarative installed in /target_qtdeclarative We want to cross-build qtlottie. We configure qtlottie as follows /target_qtbase/bin/qt-configure-module /qtlottie_src -- -DQT_ADDITIONAL_PACKAGES_PREFIX_PATH=/target_qtdeclarative We expect the target QtQuick package to be found, but it won't be. The reason is that QT_ADDITIONAL_PACKAGES_PREFIX_PATH is added to the PATHs option, but we don't adjust CMAKE_FIND_ROOT_PATH. Without adding the new paths in CMAKE_FIND_ROOT_PATH, CMake will re-root the passed PATHs under the existing CMAKE_FIND_ROOT_PATH, which is QT_TOOLCHAIN_RELOCATABLE_INSTALL_PREFIX, which evaluates to /target_qtbase. There is no QtQuick package there. To fix this, prepend the values of QT_ADDITIONAL_PACKAGES_PREFIX_PATH to CMAKE_FIND_ROOT_PATH. The location where we currently do CMAKE_FIND_ROOT_PATH manipulations is in the qt.toolchain.cmake file, so to be consistent, we prepend the new prefixes there as well. We need to adjust both CMAKE_FIND_ROOT_PATH and CMAKE_PREFIX_PATH, due the path re-rooting bug in CMake. See https://gitlab.kitware.com/cmake/cmake/-/issues/21937 as well as the existing comment in qt.toolchain.cmake marked with REROOT_PATH_ISSUE_MARKER. We also need to do a few more things to make the setup work Because Qt6Config uses NO_DEFAULT_PATH, the CMAKE_PREFIX_PATH adjustments we do in the toolchain file are not enough, so we still need to add the same prefixes to the Qt6Config find_package PATHS option. One would ask why do we need to adjust CMAKE_PREFIX_PATH at all then. It's for find_package(Qt6Foo) calls to work which don't go through the Qt6Config umbrella package. To make the CMake re-rooting behavior happy, we need to ensure the provided paths are absolute. So we iterate over the values of QT_ADDITIONAL_PACKAGES_PREFIX_PATH, to make them absolute. We do the same for the environment variable. We need to append lib/cmake to the prefixes which are added to CMAKE_PREFIX_PATH, otherwise the CMake re-rooting bug is hit. We need to specify the Qt6 package location (${_qt_cmake_dir}) to the PATHS option in the various Dependencies.cmake.in files, to ensure that dependency resolution can jump around between the Qt6 dir and the additional prefixes. Previously the dependency lookup code assumed that all dependencies would be within the same prefix. The same is needed for qt and qml plugin dependency lookup. Amends 7bb91398f25cb2016c0558fd397b376f413e3e96 Amends 60c87c68016c6f02b0eddd4002f75a49ab51d4a8 Amends 5bbd700124d13a292ff8bae6045316112500e230 Pick-to: 6.2 Fixes: QTBUG-95854 Change-Id: I35ae82330fec427d0d38fc9a0542ffafff52556a Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>
2021-08-17 15:03:02 +00:00
list(PREPEND CMAKE_PREFIX_PATH "${QT_TOOLCHAIN_RELOCATABLE_CMAKE_DIR}")
list(PREPEND CMAKE_FIND_ROOT_PATH "${QT_TOOLCHAIN_RELOCATABLE_INSTALL_PREFIX}")
CMake: Ensure that UNIX is set for INTEGRITY Certain platform-related variables, in this case UNIX, must be set in a platform module, because they get cleared after the toolchain file is loaded. Such platform modules live in upstream CMake, but there is none yet for INTEGRITY. This manifests in an undefined UNIX variable and "System is unknown to CMake" warnings for the project and every configure test. Add the CMake module "Platform/Integrity" in the cmake/platforms directory. Add this directory to CMAKE_MODULE_PATH to let CMake load Platform/Integrity when the toolchain file set CMAKE_SYSTEM_NAME to "Integrity". CMake's module directory takes precedence, when loading platform modules. This is special for platform modules and different from the documented behavior of CMAKE_MODULE_PATH and include(). In case the user wants to provide their own platform modules via CMAKE_MODULE_PATH, they can instruct Qt to not add its path by setting QT_AVOID_CUSTOM_PLATFORM_MODULES to ON. Make sure that configure tests with project files also load the custom platform module. Pick-to: 6.2 Fixes: QTBUG-96998 Change-Id: I9855d620d24dc66353cec5e847a2675b464ace26 Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
2021-09-30 13:05:52 +00:00
# Let CMake load our custom platform modules.
# CMake-provided platform modules take precedence.
if(NOT QT_AVOID_CUSTOM_PLATFORM_MODULES)
list(PREPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/platforms")
endif()
CMake: Fix QT_ADDITIONAL_PACKAGES_PREFIX_PATH for cross-builds The QT_ADDITIONAL_PACKAGES_PREFIX_PATH variable was introduced to allow specifying extra locations to find Qt packages. The reason it was introduced instead of just using CMAKE_PREFIX_PATH is because the Qt6 component find_package call uses NO_DEFAULT_PATH which means CMAKE_PREFIX_PATH is ignored. We use NO_DEFAULT_PATH to ensure we don't accidentally pick up system / distro Qt packages. The paths from QT_ADDITIONAL_PACKAGES_PREFIX_PATH are added to the find_package PATHS option in the Qt6 package, each ModuleDependencies.cmake file and some other places. Unfortunately that's not enough to make it work for cross-builds. Imagine the following scenario. host qtbase, qtdeclarative installed in /host_qt target qtbase installed in /target_qtbase target qtdeclarative installed in /target_qtdeclarative We want to cross-build qtlottie. We configure qtlottie as follows /target_qtbase/bin/qt-configure-module /qtlottie_src -- -DQT_ADDITIONAL_PACKAGES_PREFIX_PATH=/target_qtdeclarative We expect the target QtQuick package to be found, but it won't be. The reason is that QT_ADDITIONAL_PACKAGES_PREFIX_PATH is added to the PATHs option, but we don't adjust CMAKE_FIND_ROOT_PATH. Without adding the new paths in CMAKE_FIND_ROOT_PATH, CMake will re-root the passed PATHs under the existing CMAKE_FIND_ROOT_PATH, which is QT_TOOLCHAIN_RELOCATABLE_INSTALL_PREFIX, which evaluates to /target_qtbase. There is no QtQuick package there. To fix this, prepend the values of QT_ADDITIONAL_PACKAGES_PREFIX_PATH to CMAKE_FIND_ROOT_PATH. The location where we currently do CMAKE_FIND_ROOT_PATH manipulations is in the qt.toolchain.cmake file, so to be consistent, we prepend the new prefixes there as well. We need to adjust both CMAKE_FIND_ROOT_PATH and CMAKE_PREFIX_PATH, due the path re-rooting bug in CMake. See https://gitlab.kitware.com/cmake/cmake/-/issues/21937 as well as the existing comment in qt.toolchain.cmake marked with REROOT_PATH_ISSUE_MARKER. We also need to do a few more things to make the setup work Because Qt6Config uses NO_DEFAULT_PATH, the CMAKE_PREFIX_PATH adjustments we do in the toolchain file are not enough, so we still need to add the same prefixes to the Qt6Config find_package PATHS option. One would ask why do we need to adjust CMAKE_PREFIX_PATH at all then. It's for find_package(Qt6Foo) calls to work which don't go through the Qt6Config umbrella package. To make the CMake re-rooting behavior happy, we need to ensure the provided paths are absolute. So we iterate over the values of QT_ADDITIONAL_PACKAGES_PREFIX_PATH, to make them absolute. We do the same for the environment variable. We need to append lib/cmake to the prefixes which are added to CMAKE_PREFIX_PATH, otherwise the CMake re-rooting bug is hit. We need to specify the Qt6 package location (${_qt_cmake_dir}) to the PATHS option in the various Dependencies.cmake.in files, to ensure that dependency resolution can jump around between the Qt6 dir and the additional prefixes. Previously the dependency lookup code assumed that all dependencies would be within the same prefix. The same is needed for qt and qml plugin dependency lookup. Amends 7bb91398f25cb2016c0558fd397b376f413e3e96 Amends 60c87c68016c6f02b0eddd4002f75a49ab51d4a8 Amends 5bbd700124d13a292ff8bae6045316112500e230 Pick-to: 6.2 Fixes: QTBUG-95854 Change-Id: I35ae82330fec427d0d38fc9a0542ffafff52556a Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>
2021-08-17 15:03:02 +00:00
# Handle packages located in QT_ADDITIONAL_PACKAGES_PREFIX_PATH when cross-compiling. Needed for
# Conan.
# We prepend to CMAKE_PREFIX_PATH so that a find_package(Qt6Foo) call works, without having to go
# through the Qt6 umbrella package. The paths must end in lib/cmake to esnsure the package is found.
# See REROOT_PATH_ISSUE_MARKER.
# We prepend to CMAKE_FIND_ROOT_PATH, due to the bug mentioned at REROOT_PATH_ISSUE_MARKER.
set(__qt_toolchain_additional_packages_prefixes "")
if(QT_ADDITIONAL_PACKAGES_PREFIX_PATH)
list(APPEND __qt_toolchain_additional_packages_prefixes
${QT_ADDITIONAL_PACKAGES_PREFIX_PATH})
endif()
if(DEFINED ENV{QT_ADDITIONAL_PACKAGES_PREFIX_PATH}
AND NOT "$ENV{QT_ADDITIONAL_PACKAGES_PREFIX_PATH}" STREQUAL "")
list(APPEND __qt_toolchain_additional_packages_prefixes
$ENV{QT_ADDITIONAL_PACKAGES_PREFIX_PATH})
endif()
if(__qt_toolchain_additional_packages_prefixes)
set(__qt_toolchain_additional_packages_root_paths "")
set(__qt_toolchain_additional_packages_prefix_paths "")
foreach(__qt_additional_path IN LISTS __qt_toolchain_additional_packages_prefixes)
file(TO_CMAKE_PATH "${__qt_additional_path}" __qt_additional_path)
get_filename_component(__qt_additional_path "${__qt_additional_path}" ABSOLUTE)
set(__qt_additional_path_lib_cmake "${__qt_additional_path}")
if(NOT __qt_additional_path_lib_cmake MATCHES "/lib/cmake$")
string(APPEND __qt_additional_path_lib_cmake "/lib/cmake")
endif()
list(APPEND __qt_toolchain_additional_packages_root_paths
"${__qt_additional_path}")
list(APPEND __qt_toolchain_additional_packages_prefix_paths
"${__qt_additional_path_lib_cmake}")
endforeach()
list(PREPEND CMAKE_PREFIX_PATH ${__qt_toolchain_additional_packages_prefix_paths})
list(PREPEND CMAKE_FIND_ROOT_PATH ${__qt_toolchain_additional_packages_root_paths})
unset(__qt_additional_path)
unset(__qt_additional_path_lib_cmake)
unset(__qt_toolchain_additional_packages_root_paths)
unset(__qt_toolchain_additional_packages_prefix_paths)
endif()
unset(__qt_toolchain_additional_packages_prefixes)
CMake: Don't use list(PREPEND) in qt.toolchain.cmake list(PREPEND) command was added in CMake 3.15+, but so far we claim support for CMake 3.14 in user projects. Use set command instead. This is not the only place where we use list PREPEND in public API, but it's the first immediate issue that comes up when using CMake 3.14. Amends 963017f58884dfd929249c5546aadbb0f74501e8 Pick-to: 6.1 Change-Id: I7ba4507fc7da2dc550317848751502b8b46c298c Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>
2021-05-05 14:01:15 +00:00
CMake: Allow customization of the generated CMake toolchain file Provide two customization points: - optionally include a 'qt.toolchain.extra.cmake' file if it exists and is placed next to the main generated toolchain file. This use case is mostly for the Qt installer, so that it can create an extra file with correct installer-provided paths, instead of patching the toolchain file directly. - optionally include a file passed via the command line CMake argument 'QT_TOOLCHAIN_INCLUDE_FILE'. The use case is for application developers that might want to adjust the toolchain file after the modifications done by the Qt installer. These options do not replace the existing QT_CHAINLOAD_TOOLCHAIN_FILE option, which is meant to chainload a platform specific existing toolchain file (like Android or Emscripten). Task-number: QTBUG-87068 Change-Id: I956949840f55742cfbd3bc8fc0bd8c6b3f774d3d Reviewed-by: Cristian Adam <cristian.adam@qt.io>
2020-10-12 09:29:43 +00:00
# Allow customization of the toolchain file by placing an additional file next to it.
set(__qt_toolchain_extra_file "${CMAKE_CURRENT_LIST_DIR}/qt.toolchain.extra.cmake")
if(EXISTS "${__qt_toolchain_extra_file}")
include("${__qt_toolchain_extra_file}")
endif()
# Allow customization of the toolchain file by passing a path to an additional CMake file to be
# included.
if(QT_TOOLCHAIN_INCLUDE_FILE)
get_filename_component(__qt_toolchain_include_file_real_path
"${QT_TOOLCHAIN_INCLUDE_FILE}" REALPATH)
if(EXISTS "${__qt_toolchain_include_file_real_path}")
include("${__qt_toolchain_include_file_real_path}")
else()
message(WARNING "The passed extra toolchain file to be included does not exist: "
"${__qt_toolchain_include_file_real_path}")
endif()
endif()
CMake: Fix usage of cache variables in qt.toolchain.cmake We have some cache variables that are used in our qt.toolchain.cmake toolchain file, for example QT_CHAINLOAD_TOOLCHAIN_FILE. When CMake runs a configure test with try_compile, our toolchain file is included again, but only a restricted set of variables is available. Add the variables that are used in our internal toolchain file to CMAKE_TRY_COMPILE_PLATFORM_VARIABLES. This makes them visible for try_compile calls operating on source files. Also pass the variables via the environment to support try_compile calls that operate on whole projects. Fixes: QTBUG-87873 Change-Id: Iebca9e23686bec5072194b15482e1782b9367a0e Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
2020-11-04 13:39:52 +00:00
CMake: Clean up and improve QT_HOST_PATH_CMAKE_DIR computation Previously when one wanted to use a cross-compiled Qt with a host Qt installed in a non-default location, they'd have to provide both QT_HOST_PATH and QT_HOST_PATH_CMAKE_DIR. This change will now try to first check if ${QT_HOST_PATH}/lib/cmake is a valid path on disk and use that. This is nicer to the user because they don't need to specify 2 paths anymore. Furthermore the path computation and sanity checks are now done after any extra toolchain cmake files are loaded, to give an opportunity to the files to set the paths first. Finally, both variables need to be added to __qt_toolchain_used_variables so they are passed along to try_compile calls if the variables are specified manually. Otherwise when the toolchain file is loaded by a try_compile project, it will error out saying no host path found (as long as the initial paths embedded in the toolchain are invalid). Amends 93fc3afe71467ca6aeffa41d7a6f4a170f82b62e and ec90f9013b4c6b63d7e03a964f66f97329be7885 Pick-to: 6.2 Change-Id: I433239b36b084f2d0a7a0dd043fdf87d77c138f3 Reviewed-by: Craig Scott <craig.scott@qt.io>
2021-10-20 13:46:50 +00:00
# Set up QT_HOST_PATH and do sanity checks.
# A host path is required when cross-compiling but optional when doing a native build.
CMake: Allow enabling/disabling QT_HOST_PATH checks via variable One can now pass -DQT_REQUIRE_HOST_PATH_CHECK=OFF or -DQT_REQUIRE_HOST_PATH_CHECK=ON to force disable or enable the QT_HOST_PATH and QT_HOST_CMAKE_DIR_PATH validity checks. One potential use case is if a project wants to manually find QtFooTools packages by manipulating CMAKE_FIND_ROOT_PATH and such, in which case they might not want to pass a QT_HOST_PATH. Another potential use case is cross-building Qt with -DQT_BUILD_TOOLS_WHEN_CROSSCOMPILING=ON and allowing the same generated toolchain file to be used on the device image. By default the generated toolchain file would require a host path because it expects that it's still being used for cross-compiling. But once the toolchain file is deployed to the device there's no need to use the host tools anymore. Another use case is building a desktop Qt using the host tools of another desktop Qt. The new desktop Qt can use its newly built tools just fine and wouldn't need the original desktop Qt tools. QT_REQUIRE_HOST_PATH_CHECK needs to be added the list of vars to pass through to try_compile calls. Change-Id: I4b922b5d854828e6b9210dd8c07b4b1b8630aad1 Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Craig Scott <craig.scott@qt.io>
2021-10-22 10:31:39 +00:00
# Requiredness can be overridden via variable.
if(DEFINED QT_REQUIRE_HOST_PATH_CHECK)
set(__qt_toolchain_host_path_required "${QT_REQUIRE_HOST_PATH_CHECK}")
else()
set(__qt_toolchain_host_path_required "@qt_host_path_required@")
endif()
CMake: Clean up and improve QT_HOST_PATH_CMAKE_DIR computation Previously when one wanted to use a cross-compiled Qt with a host Qt installed in a non-default location, they'd have to provide both QT_HOST_PATH and QT_HOST_PATH_CMAKE_DIR. This change will now try to first check if ${QT_HOST_PATH}/lib/cmake is a valid path on disk and use that. This is nicer to the user because they don't need to specify 2 paths anymore. Furthermore the path computation and sanity checks are now done after any extra toolchain cmake files are loaded, to give an opportunity to the files to set the paths first. Finally, both variables need to be added to __qt_toolchain_used_variables so they are passed along to try_compile calls if the variables are specified manually. Otherwise when the toolchain file is loaded by a try_compile project, it will error out saying no host path found (as long as the initial paths embedded in the toolchain are invalid). Amends 93fc3afe71467ca6aeffa41d7a6f4a170f82b62e and ec90f9013b4c6b63d7e03a964f66f97329be7885 Pick-to: 6.2 Change-Id: I433239b36b084f2d0a7a0dd043fdf87d77c138f3 Reviewed-by: Craig Scott <craig.scott@qt.io>
2021-10-20 13:46:50 +00:00
set(__qt_toolchain_initial_qt_host_path
"@qt_host_path_absolute@")
set(__qt_toolchain_initial_qt_host_path_cmake_dir
"@qt_host_path_cmake_dir_absolute@")
# Prefer initially configured path if none was explicitly set.
if(NOT DEFINED QT_HOST_PATH AND __qt_toolchain_initial_qt_host_path
AND EXISTS "${__qt_toolchain_initial_qt_host_path}")
set(QT_HOST_PATH "${__qt_toolchain_initial_qt_host_path}" CACHE PATH "")
endif()
if(NOT QT_HOST_PATH STREQUAL "")
get_filename_component(__qt_toolchain_host_path_absolute "${QT_HOST_PATH}" ABSOLUTE)
endif()
if(__qt_toolchain_host_path_required AND
("${QT_HOST_PATH}" STREQUAL "" OR NOT EXISTS "${__qt_toolchain_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(__qt_toolchain_host_path_required AND NOT DEFINED QT_HOST_PATH_CMAKE_DIR)
if(__qt_toolchain_initial_qt_host_path_cmake_dir
AND EXISTS "${__qt_toolchain_initial_qt_host_path_cmake_dir}")
set(QT_HOST_PATH_CMAKE_DIR "${__qt_toolchain_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_toolchain_host_path_cmake_dir_absolute
"${QT_HOST_PATH_CMAKE_DIR}" ABSOLUTE)
endif()
if(__qt_toolchain_host_path_required AND
("${QT_HOST_PATH_CMAKE_DIR}" STREQUAL ""
OR NOT EXISTS "${__qt_toolchain_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()
CMake: Support overriding CMAKE_BUILD_TYPE per-repo or test One might want to build qtbase in Release, but qtsvg or some test in Debug mode. Before if qtbase was configured as Release, there was no way to override that. Now we try to detect whether a custom build type was specified to qt-cmake / qt-configure-module / qt-cmake-standalone-test / qt-internal-configure-tests Note mixing won't work on Windows due to different C/C++ runtimes. Also, now we don't force set a single build type when a multi config generator is used as well as one opts out via the QT_NO_FORCE_SET_CMAKE_BUILD_TYPE variable. Pick-to: 6.2 6.3 Change-Id: I6dc4325087ff7f905ad677d87b0267e2f3e4693f Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org> Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>
2022-01-19 12:13:12 +00:00
# Store initial build type (if any is specified) to be read by QtBuildInternals.cmake when building
# a Qt repo, standalone tests or a single test.
if(DEFINED CACHE{CMAKE_BUILD_TYPE})
set(__qt_toolchain_cmake_build_type_before_project_call "${CMAKE_BUILD_TYPE}")
endif()
CMake: Fix usage of cache variables in qt.toolchain.cmake We have some cache variables that are used in our qt.toolchain.cmake toolchain file, for example QT_CHAINLOAD_TOOLCHAIN_FILE. When CMake runs a configure test with try_compile, our toolchain file is included again, but only a restricted set of variables is available. Add the variables that are used in our internal toolchain file to CMAKE_TRY_COMPILE_PLATFORM_VARIABLES. This makes them visible for try_compile calls operating on source files. Also pass the variables via the environment to support try_compile calls that operate on whole projects. Fixes: QTBUG-87873 Change-Id: Iebca9e23686bec5072194b15482e1782b9367a0e Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
2020-11-04 13:39:52 +00:00
# Compile tests only see a restricted set of variables.
CMake: Fix _QT_TOOLCHAIN_VARS_INITIALIZED check in toolchain file The environment variable check to set extra env vars was using invalid syntax. The condition always resolved to TRUE which means the env vars were constantly re-assigned inside each try_compile project. To check for undefined-ness, one can use if(NOT DEFINED ENV{...}) To check for false-ness, one can use if(NOT "$ENV{...}") To check for string emptiness, one can use if(NOT "$ENV{...}" STREQUAL "") In this particular case checking for false-ness is good enough. The extra re-assigning had no visible effect, so this is just cleanup. As a drive-by, clarify one comment. Amends ca59c20939a09587662fa8fecd4e480b68244541 Pick-to: 6.2 Change-Id: I8fd400101efa9e610a81268c33cac8c0cb33cba3 Reviewed-by: Alexey Edelev <alexey.edelev@qt.io> Reviewed-by: Craig Scott <craig.scott@qt.io>
2021-10-22 10:20:19 +00:00
# All cache variables, this toolchain file uses, must be made available to project-based
# try_compile tests because this toolchain file will be included there too.
if(NOT "$ENV{_QT_TOOLCHAIN_VARS_INITIALIZED}")
CMake: Fix usage of cache variables in qt.toolchain.cmake We have some cache variables that are used in our qt.toolchain.cmake toolchain file, for example QT_CHAINLOAD_TOOLCHAIN_FILE. When CMake runs a configure test with try_compile, our toolchain file is included again, but only a restricted set of variables is available. Add the variables that are used in our internal toolchain file to CMAKE_TRY_COMPILE_PLATFORM_VARIABLES. This makes them visible for try_compile calls operating on source files. Also pass the variables via the environment to support try_compile calls that operate on whole projects. Fixes: QTBUG-87873 Change-Id: Iebca9e23686bec5072194b15482e1782b9367a0e Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>
2020-11-04 13:39:52 +00:00
set(ENV{_QT_TOOLCHAIN_VARS_INITIALIZED} ON)
foreach(var ${__qt_toolchain_used_variables})
set(ENV{_QT_TOOLCHAIN_${var}} "${${var}}")
endforeach()
endif()
Reference in New Issue Copy Permalink