2020-11-30 07:46:49 +00:00
|
|
|
# These values should be kept in sync with those in qtbase/.cmake.conf
|
|
|
|
cmake_minimum_required(VERSION 3.14...3.19)
|
2019-05-15 11:57:15 +00:00
|
|
|
|
|
|
|
######################################
|
|
|
|
#
|
|
|
|
# Macros for building Qt modules
|
|
|
|
#
|
|
|
|
######################################
|
|
|
|
|
2020-04-16 18:30:03 +00:00
|
|
|
set(QT_BACKUP_CMAKE_INSTALL_PREFIX_BEFORE_EXTRA_INCLUDE "${CMAKE_INSTALL_PREFIX}")
|
|
|
|
|
2019-05-15 11:57:15 +00:00
|
|
|
if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/QtBuildInternalsExtra.cmake")
|
|
|
|
include(${CMAKE_CURRENT_LIST_DIR}/QtBuildInternalsExtra.cmake)
|
|
|
|
endif()
|
|
|
|
|
2021-01-25 18:29:52 +00:00
|
|
|
# The variables might have already been set in QtBuildInternalsExtra.cmake if the file is included
|
|
|
|
# while building a new module and not QtBase. In that case, stop overriding the value.
|
|
|
|
if(NOT INSTALL_CMAKE_NAMESPACE)
|
|
|
|
set(INSTALL_CMAKE_NAMESPACE "Qt${PROJECT_VERSION_MAJOR}"
|
|
|
|
CACHE STRING "CMake namespace [Qt${PROJECT_VERSION_MAJOR}]")
|
|
|
|
endif()
|
|
|
|
if(NOT QT_CMAKE_EXPORT_NAMESPACE)
|
|
|
|
set(QT_CMAKE_EXPORT_NAMESPACE "Qt${PROJECT_VERSION_MAJOR}"
|
|
|
|
CACHE STRING "CMake namespace used when exporting targets [Qt${PROJECT_VERSION_MAJOR}]")
|
|
|
|
endif()
|
|
|
|
|
Allow building the tests directory as a standalone CMake project
At the moment, Coin builds tests as a separate qmake invocation
against an installed Qt. We need to support the same with CMake.
Change the tests subdirectory to be a standalone CMake project when
CMake does not detect an existing QtTest target while processing the
subdirectory. If the target exists, it means we are building the whole
repo, if the target does not exist, we need to call find_package
to find the installed Qt.
Refactor and move around a few things to make standalone tests build
successfully:
- add a new macro to set up paths to find QtSetup
- add a new macro to find all macOS frameworks
- add a new macro to set up building tests
- add a new macro that actually builds the tests
- export the INSTALL_CMAKE_NAMESPACE value into the BuildInternals
Config file
- export the CMAKE_BUILD_TYPE value, because a test project doesn't
have a .git subdir and thus defaults to be built in Release
mode, even though qtbase might have been built in Debug, so to
avoid the mixing, the propagate the build type
- stop overriding INSTALL_CMAKE_NAMESPACE and
QT_CMAKE_EXPORT_NAMESPACE inside QtSetup if they are set, because
the tests project doesn't specify a major version, and if we
override the values, the moc / uic targets don't get the correct
major version prefix and configuration fails
Change-Id: Ibdb03687302567fe325a15f6d1cb922c76240675
Fixes: QTBUG-75090
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2019-05-22 08:22:08 +00:00
|
|
|
macro(qt_set_up_build_internals_paths)
|
2019-09-26 15:58:53 +00:00
|
|
|
# Set up the paths for the cmake modules located in the prefix dir. Prepend, so the paths are
|
2019-09-05 16:17:00 +00:00
|
|
|
# least important compared to the source dir ones, but more important than command line
|
|
|
|
# provided ones.
|
Allow building the tests directory as a standalone CMake project
At the moment, Coin builds tests as a separate qmake invocation
against an installed Qt. We need to support the same with CMake.
Change the tests subdirectory to be a standalone CMake project when
CMake does not detect an existing QtTest target while processing the
subdirectory. If the target exists, it means we are building the whole
repo, if the target does not exist, we need to call find_package
to find the installed Qt.
Refactor and move around a few things to make standalone tests build
successfully:
- add a new macro to set up paths to find QtSetup
- add a new macro to find all macOS frameworks
- add a new macro to set up building tests
- add a new macro that actually builds the tests
- export the INSTALL_CMAKE_NAMESPACE value into the BuildInternals
Config file
- export the CMAKE_BUILD_TYPE value, because a test project doesn't
have a .git subdir and thus defaults to be built in Release
mode, even though qtbase might have been built in Debug, so to
avoid the mixing, the propagate the build type
- stop overriding INSTALL_CMAKE_NAMESPACE and
QT_CMAKE_EXPORT_NAMESPACE inside QtSetup if they are set, because
the tests project doesn't specify a major version, and if we
override the values, the moc / uic targets don't get the correct
major version prefix and configuration fails
Change-Id: Ibdb03687302567fe325a15f6d1cb922c76240675
Fixes: QTBUG-75090
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2019-05-22 08:22:08 +00:00
|
|
|
set(QT_CMAKE_MODULE_PATH "${QT_BUILD_INTERNALS_PATH}/../${QT_CMAKE_EXPORT_NAMESPACE}")
|
2019-09-05 16:17:00 +00:00
|
|
|
list(PREPEND CMAKE_MODULE_PATH "${QT_CMAKE_MODULE_PATH}")
|
|
|
|
|
2019-11-21 12:33:28 +00:00
|
|
|
# Prepend the qtbase source cmake directory to CMAKE_MODULE_PATH,
|
2019-09-05 16:17:00 +00:00
|
|
|
# so that if a change is done in cmake/QtBuild.cmake, it gets automatically picked up when
|
|
|
|
# building qtdeclarative, rather than having to build qtbase first (which will copy
|
|
|
|
# QtBuild.cmake to the build dir). This is similar to qmake non-prefix builds, where the
|
|
|
|
# source qtbase/mkspecs directory is used.
|
2019-11-21 12:33:28 +00:00
|
|
|
if(EXISTS "${QT_SOURCE_TREE}/cmake")
|
2019-09-05 16:17:00 +00:00
|
|
|
list(PREPEND CMAKE_MODULE_PATH "${QT_SOURCE_TREE}/cmake")
|
|
|
|
endif()
|
Allow building the tests directory as a standalone CMake project
At the moment, Coin builds tests as a separate qmake invocation
against an installed Qt. We need to support the same with CMake.
Change the tests subdirectory to be a standalone CMake project when
CMake does not detect an existing QtTest target while processing the
subdirectory. If the target exists, it means we are building the whole
repo, if the target does not exist, we need to call find_package
to find the installed Qt.
Refactor and move around a few things to make standalone tests build
successfully:
- add a new macro to set up paths to find QtSetup
- add a new macro to find all macOS frameworks
- add a new macro to set up building tests
- add a new macro that actually builds the tests
- export the INSTALL_CMAKE_NAMESPACE value into the BuildInternals
Config file
- export the CMAKE_BUILD_TYPE value, because a test project doesn't
have a .git subdir and thus defaults to be built in Release
mode, even though qtbase might have been built in Debug, so to
avoid the mixing, the propagate the build type
- stop overriding INSTALL_CMAKE_NAMESPACE and
QT_CMAKE_EXPORT_NAMESPACE inside QtSetup if they are set, because
the tests project doesn't specify a major version, and if we
override the values, the moc / uic targets don't get the correct
major version prefix and configuration fails
Change-Id: Ibdb03687302567fe325a15f6d1cb922c76240675
Fixes: QTBUG-75090
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2019-05-22 08:22:08 +00:00
|
|
|
|
|
|
|
# If the repo has its own cmake modules, include those in the module path.
|
|
|
|
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
|
2019-09-05 16:17:00 +00:00
|
|
|
list(PREPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
|
Allow building the tests directory as a standalone CMake project
At the moment, Coin builds tests as a separate qmake invocation
against an installed Qt. We need to support the same with CMake.
Change the tests subdirectory to be a standalone CMake project when
CMake does not detect an existing QtTest target while processing the
subdirectory. If the target exists, it means we are building the whole
repo, if the target does not exist, we need to call find_package
to find the installed Qt.
Refactor and move around a few things to make standalone tests build
successfully:
- add a new macro to set up paths to find QtSetup
- add a new macro to find all macOS frameworks
- add a new macro to set up building tests
- add a new macro that actually builds the tests
- export the INSTALL_CMAKE_NAMESPACE value into the BuildInternals
Config file
- export the CMAKE_BUILD_TYPE value, because a test project doesn't
have a .git subdir and thus defaults to be built in Release
mode, even though qtbase might have been built in Debug, so to
avoid the mixing, the propagate the build type
- stop overriding INSTALL_CMAKE_NAMESPACE and
QT_CMAKE_EXPORT_NAMESPACE inside QtSetup if they are set, because
the tests project doesn't specify a major version, and if we
override the values, the moc / uic targets don't get the correct
major version prefix and configuration fails
Change-Id: Ibdb03687302567fe325a15f6d1cb922c76240675
Fixes: QTBUG-75090
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2019-05-22 08:22:08 +00:00
|
|
|
endif()
|
2019-09-20 13:20:57 +00:00
|
|
|
|
|
|
|
# Find the cmake files when doing a standalone tests build.
|
|
|
|
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/../cmake")
|
|
|
|
list(PREPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../cmake")
|
|
|
|
endif()
|
Allow building the tests directory as a standalone CMake project
At the moment, Coin builds tests as a separate qmake invocation
against an installed Qt. We need to support the same with CMake.
Change the tests subdirectory to be a standalone CMake project when
CMake does not detect an existing QtTest target while processing the
subdirectory. If the target exists, it means we are building the whole
repo, if the target does not exist, we need to call find_package
to find the installed Qt.
Refactor and move around a few things to make standalone tests build
successfully:
- add a new macro to set up paths to find QtSetup
- add a new macro to find all macOS frameworks
- add a new macro to set up building tests
- add a new macro that actually builds the tests
- export the INSTALL_CMAKE_NAMESPACE value into the BuildInternals
Config file
- export the CMAKE_BUILD_TYPE value, because a test project doesn't
have a .git subdir and thus defaults to be built in Release
mode, even though qtbase might have been built in Debug, so to
avoid the mixing, the propagate the build type
- stop overriding INSTALL_CMAKE_NAMESPACE and
QT_CMAKE_EXPORT_NAMESPACE inside QtSetup if they are set, because
the tests project doesn't specify a major version, and if we
override the values, the moc / uic targets don't get the correct
major version prefix and configuration fails
Change-Id: Ibdb03687302567fe325a15f6d1cb922c76240675
Fixes: QTBUG-75090
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2019-05-22 08:22:08 +00:00
|
|
|
endmacro()
|
|
|
|
|
2019-09-26 15:58:53 +00:00
|
|
|
# Set up the build internal paths unless explicitly requested not to.
|
|
|
|
if(NOT QT_BUILD_INTERNALS_SKIP_CMAKE_MODULE_PATH_ADDITION)
|
|
|
|
qt_set_up_build_internals_paths()
|
|
|
|
endif()
|
2019-05-15 11:57:15 +00:00
|
|
|
|
2019-09-26 15:58:53 +00:00
|
|
|
# Define some constants to check for certain platforms, etc.
|
|
|
|
# Needs to be loaded before qt_repo_build() to handle require() clauses before even starting a repo
|
|
|
|
# build.
|
|
|
|
include(QtPlatformSupport)
|
|
|
|
|
CMake: Don't use libraries in /usr/local by default on macOS
qmake builds of Qt don't use libraries in /usr/local because the
path is not considered a system path. Only the SDK path should be
used as a source of system libraries.
We should do the same for the CMake builds, which involves a couple of
things.
Tell CMake not to consider /usr/local (and a bunch of other
paths) as system prefix paths.
Disable pkg-config usage which by default is not used in qmake
Windows and macOS builds.
If a user wishes to use libraries located in /usr/local on macOS, they
can explicitly enable the behavior via -DFEATURE_pkg_config=ON.
In addition to enabling pkg-config, that will also disable the system
prefix modification described above.
Implementation notes
To disable pkg-config usage, we set an empty path for
PKG_CONFIG_EXECUTABLE, because there is no other good way. The
downside to this is that a lot of warning messages will be printed
that the pkg-config package can not be found.
The pkg-config feature needs to be computed in QtBuildInternals before
qtbase/src/configure.cmake, because it's too late to do it in that
file where a few qt_find_package calls already exist.
The feature value is also saved to QtBuildInternalsExtra, to make sure
that pkg-config is disabled whenever building another repo.
System prefix adjustment is done by removing paths from
CMAKE_SYSTEM_PREFIX_PATH.
Ideally we would remove also /usr as a path, to match what qmake does,
but that breaks find_program() calls for perl, python, etc.
We have to make sure that qt_find_package does not look in
PATH when looking for packages, which is the default behavior, because
PATH on macOS most likely contains /usr/local.
One last curiosity for future generations is that CMake 3.18+ has
merged a change to prioritise SDK locations over regular /usr/lib.
Fixes: QTBUG-85261
Change-Id: I28fe5bae7997507a83b37b4eb1e0188e64062c57
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
2020-06-25 16:02:52 +00:00
|
|
|
function(qt_build_internals_disable_pkg_config_if_needed)
|
2020-08-26 16:48:01 +00:00
|
|
|
# pkg-config should not be used by default on Darwin and Windows platforms (and QNX), as defined
|
|
|
|
# in the qtbase/configure.json. Unfortunately by the time the feature is evaluated there are
|
|
|
|
# already a few find_package() calls that try to use the FindPkgConfig module.
|
|
|
|
# Thus, we have to duplicate the condition logic here and disable pkg-config for those platforms
|
|
|
|
# by default.
|
|
|
|
# We also need to check if the pkg-config executable exists, to mirror the condition test in
|
|
|
|
# configure.json. We do that by trying to find the executable ourselves, and not delegating to
|
|
|
|
# the FindPkgConfig module because that has more unwanted side-effects.
|
CMake: Don't use libraries in /usr/local by default on macOS
qmake builds of Qt don't use libraries in /usr/local because the
path is not considered a system path. Only the SDK path should be
used as a source of system libraries.
We should do the same for the CMake builds, which involves a couple of
things.
Tell CMake not to consider /usr/local (and a bunch of other
paths) as system prefix paths.
Disable pkg-config usage which by default is not used in qmake
Windows and macOS builds.
If a user wishes to use libraries located in /usr/local on macOS, they
can explicitly enable the behavior via -DFEATURE_pkg_config=ON.
In addition to enabling pkg-config, that will also disable the system
prefix modification described above.
Implementation notes
To disable pkg-config usage, we set an empty path for
PKG_CONFIG_EXECUTABLE, because there is no other good way. The
downside to this is that a lot of warning messages will be printed
that the pkg-config package can not be found.
The pkg-config feature needs to be computed in QtBuildInternals before
qtbase/src/configure.cmake, because it's too late to do it in that
file where a few qt_find_package calls already exist.
The feature value is also saved to QtBuildInternalsExtra, to make sure
that pkg-config is disabled whenever building another repo.
System prefix adjustment is done by removing paths from
CMAKE_SYSTEM_PREFIX_PATH.
Ideally we would remove also /usr as a path, to match what qmake does,
but that breaks find_program() calls for perl, python, etc.
We have to make sure that qt_find_package does not look in
PATH when looking for packages, which is the default behavior, because
PATH on macOS most likely contains /usr/local.
One last curiosity for future generations is that CMake 3.18+ has
merged a change to prioritise SDK locations over regular /usr/lib.
Fixes: QTBUG-85261
Change-Id: I28fe5bae7997507a83b37b4eb1e0188e64062c57
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
2020-06-25 16:02:52 +00:00
|
|
|
#
|
|
|
|
# Note that on macOS, if the pkg-config feature is enabled by the user explicitly, we will also
|
|
|
|
# tell CMake to consider paths like /usr/local (Homebrew) as system paths when looking for
|
|
|
|
# packages.
|
|
|
|
# We have to do that because disabling these paths but keeping pkg-config
|
|
|
|
# enabled won't enable finding all system libraries via pkg-config alone, many libraries can
|
|
|
|
# only be found via FooConfig.cmake files which means /usr/local should be in the system prefix
|
|
|
|
# path.
|
2020-08-26 16:48:01 +00:00
|
|
|
|
CMake: Don't use libraries in /usr/local by default on macOS
qmake builds of Qt don't use libraries in /usr/local because the
path is not considered a system path. Only the SDK path should be
used as a source of system libraries.
We should do the same for the CMake builds, which involves a couple of
things.
Tell CMake not to consider /usr/local (and a bunch of other
paths) as system prefix paths.
Disable pkg-config usage which by default is not used in qmake
Windows and macOS builds.
If a user wishes to use libraries located in /usr/local on macOS, they
can explicitly enable the behavior via -DFEATURE_pkg_config=ON.
In addition to enabling pkg-config, that will also disable the system
prefix modification described above.
Implementation notes
To disable pkg-config usage, we set an empty path for
PKG_CONFIG_EXECUTABLE, because there is no other good way. The
downside to this is that a lot of warning messages will be printed
that the pkg-config package can not be found.
The pkg-config feature needs to be computed in QtBuildInternals before
qtbase/src/configure.cmake, because it's too late to do it in that
file where a few qt_find_package calls already exist.
The feature value is also saved to QtBuildInternalsExtra, to make sure
that pkg-config is disabled whenever building another repo.
System prefix adjustment is done by removing paths from
CMAKE_SYSTEM_PREFIX_PATH.
Ideally we would remove also /usr as a path, to match what qmake does,
but that breaks find_program() calls for perl, python, etc.
We have to make sure that qt_find_package does not look in
PATH when looking for packages, which is the default behavior, because
PATH on macOS most likely contains /usr/local.
One last curiosity for future generations is that CMake 3.18+ has
merged a change to prioritise SDK locations over regular /usr/lib.
Fixes: QTBUG-85261
Change-Id: I28fe5bae7997507a83b37b4eb1e0188e64062c57
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
2020-06-25 16:02:52 +00:00
|
|
|
set(pkg_config_enabled ON)
|
2020-08-26 16:48:01 +00:00
|
|
|
qt_build_internals_find_pkg_config_executable()
|
|
|
|
|
2020-09-28 08:40:47 +00:00
|
|
|
if(APPLE OR WIN32 OR QNX OR ANDROID OR (NOT PKG_CONFIG_EXECUTABLE))
|
CMake: Don't use libraries in /usr/local by default on macOS
qmake builds of Qt don't use libraries in /usr/local because the
path is not considered a system path. Only the SDK path should be
used as a source of system libraries.
We should do the same for the CMake builds, which involves a couple of
things.
Tell CMake not to consider /usr/local (and a bunch of other
paths) as system prefix paths.
Disable pkg-config usage which by default is not used in qmake
Windows and macOS builds.
If a user wishes to use libraries located in /usr/local on macOS, they
can explicitly enable the behavior via -DFEATURE_pkg_config=ON.
In addition to enabling pkg-config, that will also disable the system
prefix modification described above.
Implementation notes
To disable pkg-config usage, we set an empty path for
PKG_CONFIG_EXECUTABLE, because there is no other good way. The
downside to this is that a lot of warning messages will be printed
that the pkg-config package can not be found.
The pkg-config feature needs to be computed in QtBuildInternals before
qtbase/src/configure.cmake, because it's too late to do it in that
file where a few qt_find_package calls already exist.
The feature value is also saved to QtBuildInternalsExtra, to make sure
that pkg-config is disabled whenever building another repo.
System prefix adjustment is done by removing paths from
CMAKE_SYSTEM_PREFIX_PATH.
Ideally we would remove also /usr as a path, to match what qmake does,
but that breaks find_program() calls for perl, python, etc.
We have to make sure that qt_find_package does not look in
PATH when looking for packages, which is the default behavior, because
PATH on macOS most likely contains /usr/local.
One last curiosity for future generations is that CMake 3.18+ has
merged a change to prioritise SDK locations over regular /usr/lib.
Fixes: QTBUG-85261
Change-Id: I28fe5bae7997507a83b37b4eb1e0188e64062c57
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
2020-06-25 16:02:52 +00:00
|
|
|
set(pkg_config_enabled OFF)
|
|
|
|
endif()
|
2020-08-26 16:48:01 +00:00
|
|
|
|
2021-01-14 04:12:06 +00:00
|
|
|
# Features won't have been evaluated yet if this is the first run, have to evaluate this here
|
|
|
|
if(NOT "${FEATURE_pkg_config}" AND "${INPUT_pkg_config}"
|
|
|
|
AND NOT "${INPUT_pkg_config}" STREQUAL "undefined")
|
|
|
|
set(FEATURE_pkg_config ON)
|
|
|
|
endif()
|
|
|
|
|
2020-08-26 16:48:01 +00:00
|
|
|
# If user explicitly specified a value for the feature, honor it, even if it might break
|
|
|
|
# the build.
|
CMake: Don't use libraries in /usr/local by default on macOS
qmake builds of Qt don't use libraries in /usr/local because the
path is not considered a system path. Only the SDK path should be
used as a source of system libraries.
We should do the same for the CMake builds, which involves a couple of
things.
Tell CMake not to consider /usr/local (and a bunch of other
paths) as system prefix paths.
Disable pkg-config usage which by default is not used in qmake
Windows and macOS builds.
If a user wishes to use libraries located in /usr/local on macOS, they
can explicitly enable the behavior via -DFEATURE_pkg_config=ON.
In addition to enabling pkg-config, that will also disable the system
prefix modification described above.
Implementation notes
To disable pkg-config usage, we set an empty path for
PKG_CONFIG_EXECUTABLE, because there is no other good way. The
downside to this is that a lot of warning messages will be printed
that the pkg-config package can not be found.
The pkg-config feature needs to be computed in QtBuildInternals before
qtbase/src/configure.cmake, because it's too late to do it in that
file where a few qt_find_package calls already exist.
The feature value is also saved to QtBuildInternalsExtra, to make sure
that pkg-config is disabled whenever building another repo.
System prefix adjustment is done by removing paths from
CMAKE_SYSTEM_PREFIX_PATH.
Ideally we would remove also /usr as a path, to match what qmake does,
but that breaks find_program() calls for perl, python, etc.
We have to make sure that qt_find_package does not look in
PATH when looking for packages, which is the default behavior, because
PATH on macOS most likely contains /usr/local.
One last curiosity for future generations is that CMake 3.18+ has
merged a change to prioritise SDK locations over regular /usr/lib.
Fixes: QTBUG-85261
Change-Id: I28fe5bae7997507a83b37b4eb1e0188e64062c57
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
2020-06-25 16:02:52 +00:00
|
|
|
if(DEFINED FEATURE_pkg_config)
|
|
|
|
if(FEATURE_pkg_config)
|
|
|
|
set(pkg_config_enabled ON)
|
|
|
|
else()
|
|
|
|
set(pkg_config_enabled OFF)
|
|
|
|
endif()
|
|
|
|
endif()
|
2020-08-26 16:48:01 +00:00
|
|
|
|
CMake: Don't use libraries in /usr/local by default on macOS
qmake builds of Qt don't use libraries in /usr/local because the
path is not considered a system path. Only the SDK path should be
used as a source of system libraries.
We should do the same for the CMake builds, which involves a couple of
things.
Tell CMake not to consider /usr/local (and a bunch of other
paths) as system prefix paths.
Disable pkg-config usage which by default is not used in qmake
Windows and macOS builds.
If a user wishes to use libraries located in /usr/local on macOS, they
can explicitly enable the behavior via -DFEATURE_pkg_config=ON.
In addition to enabling pkg-config, that will also disable the system
prefix modification described above.
Implementation notes
To disable pkg-config usage, we set an empty path for
PKG_CONFIG_EXECUTABLE, because there is no other good way. The
downside to this is that a lot of warning messages will be printed
that the pkg-config package can not be found.
The pkg-config feature needs to be computed in QtBuildInternals before
qtbase/src/configure.cmake, because it's too late to do it in that
file where a few qt_find_package calls already exist.
The feature value is also saved to QtBuildInternalsExtra, to make sure
that pkg-config is disabled whenever building another repo.
System prefix adjustment is done by removing paths from
CMAKE_SYSTEM_PREFIX_PATH.
Ideally we would remove also /usr as a path, to match what qmake does,
but that breaks find_program() calls for perl, python, etc.
We have to make sure that qt_find_package does not look in
PATH when looking for packages, which is the default behavior, because
PATH on macOS most likely contains /usr/local.
One last curiosity for future generations is that CMake 3.18+ has
merged a change to prioritise SDK locations over regular /usr/lib.
Fixes: QTBUG-85261
Change-Id: I28fe5bae7997507a83b37b4eb1e0188e64062c57
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
2020-06-25 16:02:52 +00:00
|
|
|
set(FEATURE_pkg_config "${pkg_config_enabled}" CACHE STRING "Using pkg-config")
|
|
|
|
if(NOT pkg_config_enabled)
|
|
|
|
qt_build_internals_disable_pkg_config()
|
|
|
|
else()
|
|
|
|
unset(PKG_CONFIG_EXECUTABLE CACHE)
|
|
|
|
endif()
|
|
|
|
endfunction()
|
|
|
|
|
2020-08-26 16:48:01 +00:00
|
|
|
# This is a copy of the first few lines in FindPkgConfig.cmake.
|
|
|
|
function(qt_build_internals_find_pkg_config_executable)
|
|
|
|
# find pkg-config, use PKG_CONFIG if set
|
|
|
|
if((NOT PKG_CONFIG_EXECUTABLE) AND (NOT "$ENV{PKG_CONFIG}" STREQUAL ""))
|
|
|
|
set(PKG_CONFIG_EXECUTABLE "$ENV{PKG_CONFIG}" CACHE FILEPATH "pkg-config executable")
|
|
|
|
endif()
|
|
|
|
find_program(PKG_CONFIG_EXECUTABLE NAMES pkg-config DOC "pkg-config executable")
|
|
|
|
mark_as_advanced(PKG_CONFIG_EXECUTABLE)
|
|
|
|
endfunction()
|
|
|
|
|
CMake: Don't use libraries in /usr/local by default on macOS
qmake builds of Qt don't use libraries in /usr/local because the
path is not considered a system path. Only the SDK path should be
used as a source of system libraries.
We should do the same for the CMake builds, which involves a couple of
things.
Tell CMake not to consider /usr/local (and a bunch of other
paths) as system prefix paths.
Disable pkg-config usage which by default is not used in qmake
Windows and macOS builds.
If a user wishes to use libraries located in /usr/local on macOS, they
can explicitly enable the behavior via -DFEATURE_pkg_config=ON.
In addition to enabling pkg-config, that will also disable the system
prefix modification described above.
Implementation notes
To disable pkg-config usage, we set an empty path for
PKG_CONFIG_EXECUTABLE, because there is no other good way. The
downside to this is that a lot of warning messages will be printed
that the pkg-config package can not be found.
The pkg-config feature needs to be computed in QtBuildInternals before
qtbase/src/configure.cmake, because it's too late to do it in that
file where a few qt_find_package calls already exist.
The feature value is also saved to QtBuildInternalsExtra, to make sure
that pkg-config is disabled whenever building another repo.
System prefix adjustment is done by removing paths from
CMAKE_SYSTEM_PREFIX_PATH.
Ideally we would remove also /usr as a path, to match what qmake does,
but that breaks find_program() calls for perl, python, etc.
We have to make sure that qt_find_package does not look in
PATH when looking for packages, which is the default behavior, because
PATH on macOS most likely contains /usr/local.
One last curiosity for future generations is that CMake 3.18+ has
merged a change to prioritise SDK locations over regular /usr/lib.
Fixes: QTBUG-85261
Change-Id: I28fe5bae7997507a83b37b4eb1e0188e64062c57
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
2020-06-25 16:02:52 +00:00
|
|
|
function(qt_build_internals_disable_pkg_config)
|
|
|
|
# Disable pkg-config by setting an empty executable path. There's no documented way to
|
2020-08-26 16:48:01 +00:00
|
|
|
# mark the package as not found, but we can force all pkg_check_modules calls to do nothing
|
|
|
|
# by setting the variable to an empty value.
|
CMake: Don't use libraries in /usr/local by default on macOS
qmake builds of Qt don't use libraries in /usr/local because the
path is not considered a system path. Only the SDK path should be
used as a source of system libraries.
We should do the same for the CMake builds, which involves a couple of
things.
Tell CMake not to consider /usr/local (and a bunch of other
paths) as system prefix paths.
Disable pkg-config usage which by default is not used in qmake
Windows and macOS builds.
If a user wishes to use libraries located in /usr/local on macOS, they
can explicitly enable the behavior via -DFEATURE_pkg_config=ON.
In addition to enabling pkg-config, that will also disable the system
prefix modification described above.
Implementation notes
To disable pkg-config usage, we set an empty path for
PKG_CONFIG_EXECUTABLE, because there is no other good way. The
downside to this is that a lot of warning messages will be printed
that the pkg-config package can not be found.
The pkg-config feature needs to be computed in QtBuildInternals before
qtbase/src/configure.cmake, because it's too late to do it in that
file where a few qt_find_package calls already exist.
The feature value is also saved to QtBuildInternalsExtra, to make sure
that pkg-config is disabled whenever building another repo.
System prefix adjustment is done by removing paths from
CMAKE_SYSTEM_PREFIX_PATH.
Ideally we would remove also /usr as a path, to match what qmake does,
but that breaks find_program() calls for perl, python, etc.
We have to make sure that qt_find_package does not look in
PATH when looking for packages, which is the default behavior, because
PATH on macOS most likely contains /usr/local.
One last curiosity for future generations is that CMake 3.18+ has
merged a change to prioritise SDK locations over regular /usr/lib.
Fixes: QTBUG-85261
Change-Id: I28fe5bae7997507a83b37b4eb1e0188e64062c57
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
2020-06-25 16:02:52 +00:00
|
|
|
set(PKG_CONFIG_EXECUTABLE "" CACHE STRING "Disabled pkg-config usage." FORCE)
|
|
|
|
endfunction()
|
|
|
|
|
|
|
|
if(NOT QT_BUILD_INTERNALS_SKIP_PKG_CONFIG_ADJUSTMENT)
|
|
|
|
qt_build_internals_disable_pkg_config_if_needed()
|
|
|
|
endif()
|
|
|
|
|
|
|
|
macro(qt_build_internals_find_pkg_config)
|
|
|
|
# Find package config once before any system prefix modifications.
|
|
|
|
find_package(PkgConfig QUIET)
|
|
|
|
endmacro()
|
|
|
|
|
|
|
|
if(NOT QT_BUILD_INTERNALS_SKIP_FIND_PKG_CONFIG)
|
|
|
|
qt_build_internals_find_pkg_config()
|
|
|
|
endif()
|
|
|
|
|
|
|
|
function(qt_build_internals_set_up_system_prefixes)
|
|
|
|
if(APPLE AND NOT FEATURE_pkg_config)
|
|
|
|
# Remove /usr/local and other paths like that which CMake considers as system prefixes on
|
|
|
|
# darwin platforms. CMake considers them as system prefixes, but in qmake / Qt land we only
|
|
|
|
# consider the SDK path as a system prefix.
|
|
|
|
# 3rd party libraries in these locations should not be picked up when building Qt,
|
|
|
|
# unless opted-in via the pkg-config feature, which in turn will disable this behavior.
|
|
|
|
#
|
|
|
|
# Note that we can't remove /usr as a system prefix path, because many programs won't be
|
|
|
|
# found then (e.g. perl).
|
|
|
|
set(QT_CMAKE_SYSTEM_PREFIX_PATH_BACKUP "${CMAKE_SYSTEM_PREFIX_PATH}" PARENT_SCOPE)
|
|
|
|
set(QT_CMAKE_SYSTEM_FRAMEWORK_PATH_BACKUP "${CMAKE_SYSTEM_FRAMEWORK_PATH}" PARENT_SCOPE)
|
|
|
|
|
|
|
|
list(REMOVE_ITEM CMAKE_SYSTEM_PREFIX_PATH
|
|
|
|
"/usr/local" # Homebrew
|
|
|
|
"/usr/X11R6"
|
|
|
|
"/usr/pkg"
|
|
|
|
"/opt"
|
|
|
|
"/sw" # Fink
|
|
|
|
"/opt/local" # MacPorts
|
|
|
|
)
|
|
|
|
if(_CMAKE_INSTALL_DIR)
|
|
|
|
list(REMOVE_ITEM CMAKE_SYSTEM_PREFIX_PATH "${_CMAKE_INSTALL_DIR}")
|
|
|
|
endif()
|
|
|
|
list(REMOVE_ITEM CMAKE_SYSTEM_FRAMEWORK_PATH "~/Library/Frameworks")
|
|
|
|
set(CMAKE_SYSTEM_PREFIX_PATH "${CMAKE_SYSTEM_PREFIX_PATH}" PARENT_SCOPE)
|
|
|
|
set(CMAKE_SYSTEM_FRAMEWORK_PATH "${CMAKE_SYSTEM_FRAMEWORK_PATH}" PARENT_SCOPE)
|
|
|
|
|
|
|
|
# Also tell qt_find_package() not to use PATH when looking for packages.
|
|
|
|
# We can't simply set CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH to OFF because that will break
|
|
|
|
# find_program(), and for instance ccache won't be found.
|
|
|
|
# That's why we set a different variable which is used by qt_find_package.
|
|
|
|
set(QT_NO_USE_FIND_PACKAGE_SYSTEM_ENVIRONMENT_PATH "ON" PARENT_SCOPE)
|
|
|
|
endif()
|
|
|
|
endfunction()
|
|
|
|
|
|
|
|
if(NOT QT_BUILD_INTERNALS_SKIP_SYSTEM_PREFIX_ADJUSTMENT)
|
|
|
|
qt_build_internals_set_up_system_prefixes()
|
|
|
|
endif()
|
|
|
|
|
2020-03-18 18:09:00 +00:00
|
|
|
macro(qt_build_internals_set_up_private_api)
|
2020-10-30 16:42:34 +00:00
|
|
|
# Check for the minimum CMake version.
|
|
|
|
include(QtCMakeVersionHelpers)
|
|
|
|
qt_internal_require_suitable_cmake_version()
|
2020-11-30 07:46:49 +00:00
|
|
|
qt_internal_upgrade_cmake_policies()
|
2020-10-30 16:42:34 +00:00
|
|
|
|
2019-05-15 11:57:15 +00:00
|
|
|
# Qt specific setup common for all modules:
|
|
|
|
include(QtSetup)
|
|
|
|
include(FeatureSummary)
|
2019-05-28 11:33:42 +00:00
|
|
|
|
|
|
|
# Optionally include a repo specific Setup module.
|
|
|
|
include(${PROJECT_NAME}Setup OPTIONAL)
|
2019-09-20 13:20:57 +00:00
|
|
|
include(QtRepoSetup OPTIONAL)
|
2019-06-13 13:55:38 +00:00
|
|
|
|
|
|
|
# Find Apple frameworks if needed.
|
|
|
|
qt_find_apple_system_frameworks()
|
2019-11-01 10:48:23 +00:00
|
|
|
|
|
|
|
# Decide whether tools will be built.
|
|
|
|
qt_check_if_tools_will_be_built()
|
2020-03-18 18:09:00 +00:00
|
|
|
endmacro()
|
|
|
|
|
2020-11-17 23:36:44 +00:00
|
|
|
# find all targets defined in $subdir by recursing through all added subdirectories
|
|
|
|
# populates $qt_repo_targets with a ;-list of non-UTILITY targets
|
|
|
|
macro(qt_build_internals_get_repo_targets subdir)
|
|
|
|
get_directory_property(_directories DIRECTORY "${subdir}" SUBDIRECTORIES)
|
|
|
|
if (_directories)
|
|
|
|
foreach(_directory IN LISTS _directories)
|
|
|
|
get_directory_property(_targets DIRECTORY "${_directory}" BUILDSYSTEM_TARGETS)
|
|
|
|
if (_targets)
|
|
|
|
foreach(_target IN LISTS _targets)
|
|
|
|
get_target_property(_type ${_target} TYPE)
|
|
|
|
if (NOT (${_type} STREQUAL "UTILITY" OR ${_type} STREQUAL "INTERFACE"))
|
|
|
|
list(APPEND qt_repo_targets "${_target}")
|
|
|
|
endif()
|
|
|
|
endforeach()
|
|
|
|
endif()
|
|
|
|
qt_build_internals_get_repo_targets("${_directory}")
|
|
|
|
endforeach()
|
|
|
|
endif()
|
|
|
|
endmacro()
|
|
|
|
|
|
|
|
# add toplevel targets for each subdirectory, e.g. qtbase_src
|
|
|
|
function(qt_build_internals_add_toplevel_targets)
|
|
|
|
set(qt_repo_target_all "")
|
|
|
|
get_directory_property(directories DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" SUBDIRECTORIES)
|
|
|
|
foreach(directory IN LISTS directories)
|
|
|
|
set(qt_repo_targets "")
|
|
|
|
get_filename_component(qt_repo_target_basename ${directory} NAME)
|
|
|
|
qt_build_internals_get_repo_targets("${directory}")
|
|
|
|
if (qt_repo_targets)
|
|
|
|
set(qt_repo_target_name "${qt_repo_targets_name}_${qt_repo_target_basename}")
|
|
|
|
message(DEBUG "${qt_repo_target_name} depends on ${qt_repo_targets}")
|
|
|
|
add_custom_target("${qt_repo_target_name}"
|
|
|
|
DEPENDS ${qt_repo_targets}
|
|
|
|
COMMENT "Building everything in ${qt_repo_targets_name}/${qt_repo_target_basename}")
|
|
|
|
list(APPEND qt_repo_target_all "${qt_repo_target_name}")
|
|
|
|
endif()
|
|
|
|
endforeach()
|
|
|
|
if (qt_repo_target_all)
|
|
|
|
add_custom_target("${qt_repo_targets_name}"
|
|
|
|
DEPENDS ${qt_repo_target_all}
|
|
|
|
COMMENT "Building everything in ${qt_repo_targets_name}")
|
|
|
|
endif()
|
|
|
|
endfunction()
|
|
|
|
|
2020-04-03 12:23:18 +00:00
|
|
|
macro(qt_enable_cmake_languages)
|
|
|
|
include(CheckLanguage)
|
|
|
|
set(__qt_required_language_list C CXX)
|
2020-04-06 13:52:48 +00:00
|
|
|
set(__qt_optional_language_list )
|
|
|
|
|
|
|
|
# https://gitlab.kitware.com/cmake/cmake/-/issues/20545
|
|
|
|
if(APPLE)
|
|
|
|
list(APPEND __qt_optional_language_list OBJC OBJCXX)
|
|
|
|
endif()
|
2020-04-03 12:23:18 +00:00
|
|
|
|
|
|
|
foreach(__qt_lang ${__qt_required_language_list})
|
|
|
|
enable_language(${__qt_lang})
|
|
|
|
endforeach()
|
|
|
|
|
|
|
|
foreach(__qt_lang ${__qt_optional_language_list})
|
|
|
|
check_language(${__qt_lang})
|
|
|
|
if(CMAKE_${__qt_lang}_COMPILER)
|
|
|
|
enable_language(${__qt_lang})
|
|
|
|
endif()
|
|
|
|
endforeach()
|
CMake: Adjust compiler flag optimizations to qmake mkspec ones
There are inconsistencies in the default optimization flags added by
CMake across configurations like Release and RelWithDebInfo.
In particular Release uses -O3, whereas RelWithDebInfo uses -O2,
as well as usage of /INCREMENTAL in release configs with MSVC, etc.
To make sure that the Qt 6 binaries built with CMake are consistent
across configs, as well as consistent with the flags we used when
building Qt 5 with qmake, add a horrible search and replace mechanism
to replaces the CMake flags with what our mkspecs indicate to use.
Ideally this would be done by providing custom CMake toolchain files
for each platform we support, and we might revisit that later if the
need really arises.
To implement the replacing, we first need the flags that should be
added. Port the QMAKE_CFLAGS_OPTIMIZE variables to CMake, which is
done in QtCompilerOptimization.cmake.
Then a new function called
qt_internal_set_up_config_optimizations_like_in_qmake will look for
any kind of optimization flags set in the
CMAKE_<LANG>_FLAGS_<CONFIG> style variables, remove them, and add
the appropriate flags that qmake mkspecs provide.
On some platforms (like Windows MSVC) the function also alters the
linker CMAKE_${TYPE}_LINKER_FLAGS_<CONFIG> style variables.
The mechanism allows opting out of this replacing by
setting the QT_USE_DEFAULT_CMAKE_OPTIMIZATION_FLAGS value.
It also allows opting into removal of flags for custom configs by
providing QT_ADDITIONAL_OPTIMIZATION_FLAG_CONFIGS. It's only removal,
because we wouldn't know what kind of config it is, and thus what
flags to add.
The currently modified configs are: Release, RelWithDebInfo,
MinSizeRel, Debug aka the usual default CMake provided ones.
The mechanism is only applied to C-like languages.
ASM is not handled to be on the safe side due to not knowing what kind
of compiler flags the platform assembler might take.
It's also important to skip RC on MSVC platforms.
Task-number: QTBUG-85992
Change-Id: I3712d5cd5a34fceab54f56a6fa46b4e678952362
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Cristian Adam <cristian.adam@qt.io>
2020-08-17 15:32:28 +00:00
|
|
|
|
2020-10-02 13:38:47 +00:00
|
|
|
# The qtbase call is handled in qtbase/CMakeLists.txt.
|
|
|
|
# This call is used for projects other than qtbase, including for other project's standalone
|
|
|
|
# tests.
|
|
|
|
# Because the function uses QT_FEATURE_foo values, it's important that find_package(Qt6Core) is
|
|
|
|
# called before this function. but that's usually the case for Qt repos.
|
2020-08-20 08:19:32 +00:00
|
|
|
if(NOT PROJECT_NAME STREQUAL "QtBase")
|
|
|
|
qt_internal_set_up_config_optimizations_like_in_qmake()
|
|
|
|
endif()
|
2020-04-03 12:23:18 +00:00
|
|
|
endmacro()
|
|
|
|
|
2020-04-23 09:24:48 +00:00
|
|
|
# Minimum setup required to have any CMakeList.txt build as as a standalone
|
|
|
|
# project after importing BuildInternals
|
|
|
|
macro(qt_prepare_standalone_project)
|
|
|
|
qt_set_up_build_internals_paths()
|
|
|
|
qt_build_internals_set_up_private_api()
|
|
|
|
qt_enable_cmake_languages()
|
|
|
|
endmacro()
|
|
|
|
|
2020-03-18 18:09:00 +00:00
|
|
|
macro(qt_build_repo_begin)
|
|
|
|
qt_build_internals_set_up_private_api()
|
2020-04-03 12:23:18 +00:00
|
|
|
qt_enable_cmake_languages()
|
2019-09-19 07:38:09 +00:00
|
|
|
|
2020-03-18 15:07:44 +00:00
|
|
|
# Add global docs targets that will work both for per-repo builds, and super builds.
|
|
|
|
if(NOT TARGET docs)
|
|
|
|
add_custom_target(docs)
|
|
|
|
add_custom_target(prepare_docs)
|
|
|
|
add_custom_target(generate_docs)
|
|
|
|
add_custom_target(html_docs)
|
|
|
|
add_custom_target(qch_docs)
|
2020-10-27 09:35:07 +00:00
|
|
|
add_custom_target(install_html_docs)
|
|
|
|
add_custom_target(install_qch_docs)
|
|
|
|
add_custom_target(install_docs)
|
|
|
|
add_dependencies(html_docs generate_docs)
|
|
|
|
add_dependencies(docs html_docs qch_docs)
|
|
|
|
add_dependencies(install_docs install_html_docs install_qch_docs)
|
2020-03-18 15:07:44 +00:00
|
|
|
endif()
|
2019-09-19 07:38:09 +00:00
|
|
|
|
2020-10-19 17:34:53 +00:00
|
|
|
# Add global qt_plugins, qpa_plugins and qpa_default_plugins convenience custom targets.
|
|
|
|
# Internal executables will add a dependency on the qpa_default_plugins target,
|
|
|
|
# so that building and running a test ensures it won't fail at runtime due to a missing qpa
|
|
|
|
# plugin.
|
|
|
|
if(NOT TARGET qt_plugins)
|
|
|
|
add_custom_target(qt_plugins)
|
|
|
|
add_custom_target(qpa_plugins)
|
|
|
|
add_custom_target(qpa_default_plugins)
|
|
|
|
endif()
|
|
|
|
|
2019-09-19 07:38:09 +00:00
|
|
|
string(TOLOWER ${PROJECT_NAME} project_name_lower)
|
|
|
|
|
2020-11-17 23:36:44 +00:00
|
|
|
set(qt_repo_targets_name ${project_name_lower})
|
2019-09-19 07:38:09 +00:00
|
|
|
set(qt_docs_target_name docs_${project_name_lower})
|
|
|
|
set(qt_docs_prepare_target_name prepare_docs_${project_name_lower})
|
|
|
|
set(qt_docs_generate_target_name generate_docs_${project_name_lower})
|
|
|
|
set(qt_docs_html_target_name html_docs_${project_name_lower})
|
|
|
|
set(qt_docs_qch_target_name qch_docs_${project_name_lower})
|
|
|
|
set(qt_docs_install_html_target_name install_html_docs_${project_name_lower})
|
|
|
|
set(qt_docs_install_qch_target_name install_qch_docs_${project_name_lower})
|
|
|
|
set(qt_docs_install_target_name install_docs_${project_name_lower})
|
|
|
|
|
|
|
|
add_custom_target(${qt_docs_target_name})
|
|
|
|
add_custom_target(${qt_docs_prepare_target_name})
|
|
|
|
add_custom_target(${qt_docs_generate_target_name})
|
|
|
|
add_custom_target(${qt_docs_qch_target_name})
|
|
|
|
add_custom_target(${qt_docs_html_target_name})
|
|
|
|
add_custom_target(${qt_docs_install_html_target_name})
|
|
|
|
add_custom_target(${qt_docs_install_qch_target_name})
|
|
|
|
add_custom_target(${qt_docs_install_target_name})
|
|
|
|
|
|
|
|
add_dependencies(${qt_docs_generate_target_name} ${qt_docs_prepare_target_name})
|
|
|
|
add_dependencies(${qt_docs_html_target_name} ${qt_docs_generate_target_name})
|
2020-10-27 09:35:07 +00:00
|
|
|
add_dependencies(${qt_docs_target_name} ${qt_docs_html_target_name} ${qt_docs_qch_target_name})
|
2019-09-19 07:38:09 +00:00
|
|
|
add_dependencies(${qt_docs_install_target_name} ${qt_docs_install_html_target_name} ${qt_docs_install_qch_target_name})
|
2020-03-18 15:07:44 +00:00
|
|
|
|
2020-10-27 09:35:07 +00:00
|
|
|
# Make top-level prepare_docs target depend on the repository-level prepare_docs_<repo> target.
|
2020-03-18 15:07:44 +00:00
|
|
|
add_dependencies(prepare_docs ${qt_docs_prepare_target_name})
|
2020-06-26 13:06:00 +00:00
|
|
|
|
2020-11-05 09:32:30 +00:00
|
|
|
# Make top-level install_*_docs targets depend on the repository-level install_*_docs targets.
|
|
|
|
add_dependencies(install_html_docs ${qt_docs_install_html_target_name})
|
|
|
|
add_dependencies(install_qch_docs ${qt_docs_install_qch_target_name})
|
|
|
|
|
2020-06-26 13:06:00 +00:00
|
|
|
# Add host_tools meta target, so that developrs can easily build only tools and their
|
|
|
|
# dependencies when working in qtbase.
|
|
|
|
if(NOT TARGET host_tools)
|
|
|
|
add_custom_target(host_tools)
|
|
|
|
add_custom_target(bootstrap_tools)
|
|
|
|
endif()
|
2020-12-03 18:13:08 +00:00
|
|
|
|
|
|
|
# Add benchmark meta target. It's collection of all benchmarks added/registered by
|
|
|
|
# 'qt_internal_add_benchmark' helper.
|
|
|
|
if(NOT TARGET benchmark)
|
|
|
|
add_custom_target(benchmark)
|
|
|
|
endif()
|
2019-05-15 11:57:15 +00:00
|
|
|
endmacro()
|
|
|
|
|
|
|
|
macro(qt_build_repo_end)
|
2019-11-01 10:48:23 +00:00
|
|
|
if(NOT QT_BUILD_STANDALONE_TESTS)
|
|
|
|
# Delayed actions on some of the Qt targets:
|
|
|
|
include(QtPostProcess)
|
|
|
|
|
|
|
|
# Install the repo-specific cmake find modules.
|
|
|
|
qt_path_join(__qt_repo_install_dir ${QT_CONFIG_INSTALL_DIR} ${INSTALL_CMAKE_NAMESPACE})
|
|
|
|
|
|
|
|
if(NOT PROJECT_NAME STREQUAL "QtBase")
|
|
|
|
if (EXISTS cmake)
|
|
|
|
qt_copy_or_install(DIRECTORY cmake/
|
|
|
|
DESTINATION "${__qt_repo_install_dir}"
|
|
|
|
FILES_MATCHING PATTERN "Find*.cmake"
|
|
|
|
)
|
|
|
|
endif()
|
2019-06-05 14:26:42 +00:00
|
|
|
endif()
|
2019-05-20 07:46:38 +00:00
|
|
|
|
2019-11-21 12:33:28 +00:00
|
|
|
if(NOT QT_SUPERBUILD)
|
|
|
|
qt_print_feature_summary()
|
|
|
|
endif()
|
2019-09-17 14:05:50 +00:00
|
|
|
endif()
|
|
|
|
|
2019-11-21 12:33:28 +00:00
|
|
|
if(NOT QT_SUPERBUILD)
|
|
|
|
qt_print_build_instructions()
|
2020-11-17 23:36:44 +00:00
|
|
|
else()
|
|
|
|
qt_build_internals_add_toplevel_targets()
|
2019-09-17 14:05:50 +00:00
|
|
|
endif()
|
2019-11-21 12:33:28 +00:00
|
|
|
endmacro()
|
2019-09-17 14:05:50 +00:00
|
|
|
|
2019-05-21 07:04:27 +00:00
|
|
|
macro(qt_build_repo)
|
|
|
|
qt_build_repo_begin(${ARGN})
|
|
|
|
|
2019-06-13 13:35:26 +00:00
|
|
|
# If testing is enabled, try to find the qtbase Test package.
|
|
|
|
# Do this before adding src, because there might be test related conditions
|
|
|
|
# in source.
|
2020-10-19 11:35:15 +00:00
|
|
|
if (QT_BUILD_TESTS AND NOT QT_BUILD_STANDALONE_TESTS)
|
2019-06-14 10:59:07 +00:00
|
|
|
find_package(Qt6 ${PROJECT_VERSION} CONFIG REQUIRED COMPONENTS Test)
|
2019-06-13 13:35:26 +00:00
|
|
|
endif()
|
|
|
|
|
2019-11-01 10:48:23 +00:00
|
|
|
if(NOT QT_BUILD_STANDALONE_TESTS)
|
|
|
|
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/CMakeLists.txt")
|
|
|
|
add_subdirectory(src)
|
|
|
|
endif()
|
2019-05-21 07:04:27 +00:00
|
|
|
|
2019-11-01 10:48:23 +00:00
|
|
|
if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/tools/CMakeLists.txt")
|
|
|
|
add_subdirectory(tools)
|
|
|
|
endif()
|
2019-06-05 14:10:59 +00:00
|
|
|
endif()
|
|
|
|
|
2020-10-19 11:35:15 +00:00
|
|
|
if (QT_BUILD_TESTS AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/tests/CMakeLists.txt")
|
2019-05-21 07:04:27 +00:00
|
|
|
add_subdirectory(tests)
|
2020-10-19 11:35:15 +00:00
|
|
|
if(NOT QT_BUILD_TESTS_BY_DEFAULT)
|
2019-11-04 13:43:39 +00:00
|
|
|
set_property(DIRECTORY tests PROPERTY EXCLUDE_FROM_ALL TRUE)
|
|
|
|
endif()
|
2019-05-21 07:04:27 +00:00
|
|
|
endif()
|
|
|
|
|
2019-06-11 13:46:31 +00:00
|
|
|
qt_build_repo_end()
|
|
|
|
|
2020-10-19 11:35:15 +00:00
|
|
|
if(QT_BUILD_EXAMPLES AND BUILD_SHARED_LIBS
|
2019-11-01 10:48:23 +00:00
|
|
|
AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/examples/CMakeLists.txt"
|
|
|
|
AND NOT QT_BUILD_STANDALONE_TESTS)
|
2019-05-24 17:18:21 +00:00
|
|
|
add_subdirectory(examples)
|
2020-10-19 11:35:15 +00:00
|
|
|
if(NOT QT_BUILD_EXAMPLES_BY_DEFAULT)
|
2019-11-04 13:43:39 +00:00
|
|
|
set_property(DIRECTORY examples PROPERTY EXCLUDE_FROM_ALL TRUE)
|
|
|
|
endif()
|
2019-05-21 07:04:27 +00:00
|
|
|
endif()
|
|
|
|
endmacro()
|
Allow building the tests directory as a standalone CMake project
At the moment, Coin builds tests as a separate qmake invocation
against an installed Qt. We need to support the same with CMake.
Change the tests subdirectory to be a standalone CMake project when
CMake does not detect an existing QtTest target while processing the
subdirectory. If the target exists, it means we are building the whole
repo, if the target does not exist, we need to call find_package
to find the installed Qt.
Refactor and move around a few things to make standalone tests build
successfully:
- add a new macro to set up paths to find QtSetup
- add a new macro to find all macOS frameworks
- add a new macro to set up building tests
- add a new macro that actually builds the tests
- export the INSTALL_CMAKE_NAMESPACE value into the BuildInternals
Config file
- export the CMAKE_BUILD_TYPE value, because a test project doesn't
have a .git subdir and thus defaults to be built in Release
mode, even though qtbase might have been built in Debug, so to
avoid the mixing, the propagate the build type
- stop overriding INSTALL_CMAKE_NAMESPACE and
QT_CMAKE_EXPORT_NAMESPACE inside QtSetup if they are set, because
the tests project doesn't specify a major version, and if we
override the values, the moc / uic targets don't get the correct
major version prefix and configuration fails
Change-Id: Ibdb03687302567fe325a15f6d1cb922c76240675
Fixes: QTBUG-75090
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2019-05-22 08:22:08 +00:00
|
|
|
|
|
|
|
macro(qt_set_up_standalone_tests_build)
|
2019-11-01 10:48:23 +00:00
|
|
|
# Remove this macro once all usages of it have been removed.
|
|
|
|
# Standalone tests are not handled via the main repo project and qt_build_tests.
|
Allow building the tests directory as a standalone CMake project
At the moment, Coin builds tests as a separate qmake invocation
against an installed Qt. We need to support the same with CMake.
Change the tests subdirectory to be a standalone CMake project when
CMake does not detect an existing QtTest target while processing the
subdirectory. If the target exists, it means we are building the whole
repo, if the target does not exist, we need to call find_package
to find the installed Qt.
Refactor and move around a few things to make standalone tests build
successfully:
- add a new macro to set up paths to find QtSetup
- add a new macro to find all macOS frameworks
- add a new macro to set up building tests
- add a new macro that actually builds the tests
- export the INSTALL_CMAKE_NAMESPACE value into the BuildInternals
Config file
- export the CMAKE_BUILD_TYPE value, because a test project doesn't
have a .git subdir and thus defaults to be built in Release
mode, even though qtbase might have been built in Debug, so to
avoid the mixing, the propagate the build type
- stop overriding INSTALL_CMAKE_NAMESPACE and
QT_CMAKE_EXPORT_NAMESPACE inside QtSetup if they are set, because
the tests project doesn't specify a major version, and if we
override the values, the moc / uic targets don't get the correct
major version prefix and configuration fails
Change-Id: Ibdb03687302567fe325a15f6d1cb922c76240675
Fixes: QTBUG-75090
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2019-05-22 08:22:08 +00:00
|
|
|
endmacro()
|
|
|
|
|
2020-03-18 18:09:00 +00:00
|
|
|
function(qt_get_standalone_tests_confg_files_path out_var)
|
|
|
|
set(path "${QT_CONFIG_INSTALL_DIR}/${INSTALL_CMAKE_NAMESPACE}BuildInternals/StandaloneTests")
|
2020-06-04 16:21:13 +00:00
|
|
|
|
|
|
|
# QT_CONFIG_INSTALL_DIR is relative in prefix builds.
|
|
|
|
if(QT_WILL_INSTALL)
|
2020-12-08 15:24:15 +00:00
|
|
|
if(DEFINED CMAKE_STAGING_PREFIX)
|
|
|
|
qt_path_join(path "${CMAKE_STAGING_PREFIX}" "${path}")
|
|
|
|
else()
|
|
|
|
qt_path_join(path "${CMAKE_INSTALL_PREFIX}" "${path}")
|
|
|
|
endif()
|
2020-06-04 16:21:13 +00:00
|
|
|
endif()
|
|
|
|
|
2020-03-18 18:09:00 +00:00
|
|
|
set("${out_var}" "${path}" PARENT_SCOPE)
|
|
|
|
endfunction()
|
|
|
|
|
Allow building the tests directory as a standalone CMake project
At the moment, Coin builds tests as a separate qmake invocation
against an installed Qt. We need to support the same with CMake.
Change the tests subdirectory to be a standalone CMake project when
CMake does not detect an existing QtTest target while processing the
subdirectory. If the target exists, it means we are building the whole
repo, if the target does not exist, we need to call find_package
to find the installed Qt.
Refactor and move around a few things to make standalone tests build
successfully:
- add a new macro to set up paths to find QtSetup
- add a new macro to find all macOS frameworks
- add a new macro to set up building tests
- add a new macro that actually builds the tests
- export the INSTALL_CMAKE_NAMESPACE value into the BuildInternals
Config file
- export the CMAKE_BUILD_TYPE value, because a test project doesn't
have a .git subdir and thus defaults to be built in Release
mode, even though qtbase might have been built in Debug, so to
avoid the mixing, the propagate the build type
- stop overriding INSTALL_CMAKE_NAMESPACE and
QT_CMAKE_EXPORT_NAMESPACE inside QtSetup if they are set, because
the tests project doesn't specify a major version, and if we
override the values, the moc / uic targets don't get the correct
major version prefix and configuration fails
Change-Id: Ibdb03687302567fe325a15f6d1cb922c76240675
Fixes: QTBUG-75090
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2019-05-22 08:22:08 +00:00
|
|
|
macro(qt_build_tests)
|
2019-11-01 10:48:23 +00:00
|
|
|
if(QT_BUILD_STANDALONE_TESTS)
|
|
|
|
# Find location of TestsConfig.cmake. These contain the modules that need to be
|
|
|
|
# find_package'd when testing.
|
2020-03-18 18:09:00 +00:00
|
|
|
qt_get_standalone_tests_confg_files_path(_qt_build_tests_install_prefix)
|
2019-11-21 12:33:28 +00:00
|
|
|
include("${_qt_build_tests_install_prefix}/${PROJECT_NAME}TestsConfig.cmake" OPTIONAL)
|
2019-11-01 10:48:23 +00:00
|
|
|
|
|
|
|
# Of course we always need the test module as well.
|
|
|
|
find_package(Qt6 ${PROJECT_VERSION} CONFIG REQUIRED COMPONENTS Test)
|
2020-02-18 09:59:11 +00:00
|
|
|
|
|
|
|
# Set language standards after finding Core, because that's when the relevant
|
|
|
|
# feature variables are available, and the call in QtSetup is too early when building
|
|
|
|
# standalone tests, because Core was not find_package()'d yet.
|
|
|
|
qt_set_language_standards()
|
2020-04-16 18:30:03 +00:00
|
|
|
|
|
|
|
if(NOT QT_SUPERBUILD)
|
2020-06-04 16:21:13 +00:00
|
|
|
# Set up fake standalone tests install prefix, so we don't pollute the Qt install
|
|
|
|
# prefix. For super builds it needs to be done in qt5/CMakeLists.txt.
|
|
|
|
qt_set_up_fake_standalone_tests_install_prefix()
|
2020-04-16 18:30:03 +00:00
|
|
|
endif()
|
2019-11-01 10:48:23 +00:00
|
|
|
endif()
|
|
|
|
|
Allow building the tests directory as a standalone CMake project
At the moment, Coin builds tests as a separate qmake invocation
against an installed Qt. We need to support the same with CMake.
Change the tests subdirectory to be a standalone CMake project when
CMake does not detect an existing QtTest target while processing the
subdirectory. If the target exists, it means we are building the whole
repo, if the target does not exist, we need to call find_package
to find the installed Qt.
Refactor and move around a few things to make standalone tests build
successfully:
- add a new macro to set up paths to find QtSetup
- add a new macro to find all macOS frameworks
- add a new macro to set up building tests
- add a new macro that actually builds the tests
- export the INSTALL_CMAKE_NAMESPACE value into the BuildInternals
Config file
- export the CMAKE_BUILD_TYPE value, because a test project doesn't
have a .git subdir and thus defaults to be built in Release
mode, even though qtbase might have been built in Debug, so to
avoid the mixing, the propagate the build type
- stop overriding INSTALL_CMAKE_NAMESPACE and
QT_CMAKE_EXPORT_NAMESPACE inside QtSetup if they are set, because
the tests project doesn't specify a major version, and if we
override the values, the moc / uic targets don't get the correct
major version prefix and configuration fails
Change-Id: Ibdb03687302567fe325a15f6d1cb922c76240675
Fixes: QTBUG-75090
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2019-05-22 08:22:08 +00:00
|
|
|
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/auto/CMakeLists.txt")
|
|
|
|
add_subdirectory(auto)
|
|
|
|
endif()
|
2019-10-28 14:35:47 +00:00
|
|
|
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/benchmarks/CMakeLists.txt" AND QT_BUILD_BENCHMARKS)
|
Allow building the tests directory as a standalone CMake project
At the moment, Coin builds tests as a separate qmake invocation
against an installed Qt. We need to support the same with CMake.
Change the tests subdirectory to be a standalone CMake project when
CMake does not detect an existing QtTest target while processing the
subdirectory. If the target exists, it means we are building the whole
repo, if the target does not exist, we need to call find_package
to find the installed Qt.
Refactor and move around a few things to make standalone tests build
successfully:
- add a new macro to set up paths to find QtSetup
- add a new macro to find all macOS frameworks
- add a new macro to set up building tests
- add a new macro that actually builds the tests
- export the INSTALL_CMAKE_NAMESPACE value into the BuildInternals
Config file
- export the CMAKE_BUILD_TYPE value, because a test project doesn't
have a .git subdir and thus defaults to be built in Release
mode, even though qtbase might have been built in Debug, so to
avoid the mixing, the propagate the build type
- stop overriding INSTALL_CMAKE_NAMESPACE and
QT_CMAKE_EXPORT_NAMESPACE inside QtSetup if they are set, because
the tests project doesn't specify a major version, and if we
override the values, the moc / uic targets don't get the correct
major version prefix and configuration fails
Change-Id: Ibdb03687302567fe325a15f6d1cb922c76240675
Fixes: QTBUG-75090
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2019-05-22 08:22:08 +00:00
|
|
|
add_subdirectory(benchmarks)
|
|
|
|
endif()
|
2020-11-16 17:31:56 +00:00
|
|
|
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/manual/CMakeLists.txt" AND QT_BUILD_MANUAL_TESTS)
|
|
|
|
add_subdirectory(manual)
|
2019-11-08 10:23:04 +00:00
|
|
|
endif()
|
Allow building the tests directory as a standalone CMake project
At the moment, Coin builds tests as a separate qmake invocation
against an installed Qt. We need to support the same with CMake.
Change the tests subdirectory to be a standalone CMake project when
CMake does not detect an existing QtTest target while processing the
subdirectory. If the target exists, it means we are building the whole
repo, if the target does not exist, we need to call find_package
to find the installed Qt.
Refactor and move around a few things to make standalone tests build
successfully:
- add a new macro to set up paths to find QtSetup
- add a new macro to find all macOS frameworks
- add a new macro to set up building tests
- add a new macro that actually builds the tests
- export the INSTALL_CMAKE_NAMESPACE value into the BuildInternals
Config file
- export the CMAKE_BUILD_TYPE value, because a test project doesn't
have a .git subdir and thus defaults to be built in Release
mode, even though qtbase might have been built in Debug, so to
avoid the mixing, the propagate the build type
- stop overriding INSTALL_CMAKE_NAMESPACE and
QT_CMAKE_EXPORT_NAMESPACE inside QtSetup if they are set, because
the tests project doesn't specify a major version, and if we
override the values, the moc / uic targets don't get the correct
major version prefix and configuration fails
Change-Id: Ibdb03687302567fe325a15f6d1cb922c76240675
Fixes: QTBUG-75090
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>
2019-05-22 08:22:08 +00:00
|
|
|
endmacro()
|
2019-06-06 11:08:41 +00:00
|
|
|
|
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
|
|
|
function(qt_compute_relative_path_from_cmake_config_dir_to_prefix)
|
|
|
|
# Compute the reverse relative path from the CMake config dir to the install prefix.
|
|
|
|
# This is used in QtBuildInternalsExtras to create a relocatable relative install prefix path.
|
|
|
|
# This path is used for finding syncqt and other things, regardless of initial install prefix
|
|
|
|
# (e.g installed Qt was archived and unpacked to a different path on a different machine).
|
|
|
|
#
|
|
|
|
# This is meant to be called only once when configuring qtbase.
|
|
|
|
#
|
|
|
|
# Similar code exists in Qt6CoreConfigExtras.cmake.in and src/corelib/CMakeLists.txt which
|
|
|
|
# might not be needed anymore.
|
|
|
|
if(QT_WILL_INSTALL)
|
|
|
|
get_filename_component(clean_config_prefix
|
|
|
|
"${CMAKE_INSTALL_PREFIX}/${QT_CONFIG_INSTALL_DIR}" ABSOLUTE)
|
|
|
|
else()
|
|
|
|
get_filename_component(clean_config_prefix "${QT_CONFIG_BUILD_DIR}" ABSOLUTE)
|
|
|
|
endif()
|
|
|
|
file(RELATIVE_PATH
|
|
|
|
qt_path_from_cmake_config_dir_to_prefix
|
2020-06-05 09:05:05 +00:00
|
|
|
"${clean_config_prefix}" "${CMAKE_INSTALL_PREFIX}")
|
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
|
|
|
set(qt_path_from_cmake_config_dir_to_prefix "${qt_path_from_cmake_config_dir_to_prefix}"
|
|
|
|
PARENT_SCOPE)
|
|
|
|
endfunction()
|
|
|
|
|
|
|
|
function(qt_get_relocatable_install_prefix out_var)
|
|
|
|
# We need to compute it only once while building qtbase. Afterwards it's loaded from
|
|
|
|
# QtBuildInternalsExtras.cmake.
|
|
|
|
if(QT_BUILD_INTERNALS_RELOCATABLE_INSTALL_PREFIX)
|
|
|
|
return()
|
|
|
|
endif()
|
|
|
|
# The QtBuildInternalsExtras value is dynamically computed, whereas the initial qtbase
|
|
|
|
# configuration uses an absolute path.
|
|
|
|
set(${out_var} "${CMAKE_INSTALL_PREFIX}" PARENT_SCOPE)
|
|
|
|
endfunction()
|
|
|
|
|
2020-06-04 16:21:13 +00:00
|
|
|
function(qt_set_up_fake_standalone_tests_install_prefix)
|
|
|
|
# Set a fake local (non-cache) CMAKE_INSTALL_PREFIX.
|
|
|
|
# Needed for standalone tests, we don't want to accidentally install a test into the Qt prefix.
|
2020-06-05 11:46:48 +00:00
|
|
|
# Allow opt-out, if a user knows what they're doing.
|
|
|
|
if(QT_NO_FAKE_STANDALONE_TESTS_INSTALL_PREFIX)
|
|
|
|
return()
|
2020-04-28 09:45:44 +00:00
|
|
|
endif()
|
2020-06-05 11:46:48 +00:00
|
|
|
set(new_install_prefix "${CMAKE_BINARY_DIR}/fake_prefix")
|
2020-04-28 09:45:44 +00:00
|
|
|
|
2020-06-04 16:21:13 +00:00
|
|
|
# It's IMPORTANT that this is not a cache variable. Otherwise
|
|
|
|
# qt_get_standalone_tests_confg_files_path() will not work on re-configuration.
|
|
|
|
message(STATUS
|
|
|
|
"Setting local standalone test install prefix (non-cached) to '${new_install_prefix}'.")
|
|
|
|
set(CMAKE_INSTALL_PREFIX "${new_install_prefix}" PARENT_SCOPE)
|
2020-10-23 10:45:10 +00:00
|
|
|
|
|
|
|
# We also need to clear the staging prefix if it's set, otherwise CMake will modify any computed
|
|
|
|
# rpaths containing the staging prefix to point to the new fake prefix, which is not what we
|
|
|
|
# want. This replacement is done in cmComputeLinkInformation::GetRPath().
|
|
|
|
#
|
|
|
|
# By clearing the staging prefix for the standalone tests, any detected link time
|
|
|
|
# rpaths will be embedded as-is, which will point to the place where Qt was installed (aka
|
|
|
|
# the staging prefix).
|
|
|
|
if(DEFINED CMAKE_STAGING_PREFIX)
|
|
|
|
message(STATUS "Clearing local standalone test staging prefix (non-cached).")
|
|
|
|
set(CMAKE_STAGING_PREFIX "" PARENT_SCOPE)
|
|
|
|
endif()
|
2020-04-16 18:30:03 +00:00
|
|
|
endfunction()
|
|
|
|
|
2020-07-20 15:12:45 +00:00
|
|
|
# Mean to be called when configuring examples as part of the main build tree, as well as for CMake
|
|
|
|
# tests (tests that call CMake to try and build CMake applications).
|
|
|
|
macro(qt_internal_set_up_build_dir_package_paths)
|
|
|
|
list(APPEND CMAKE_PREFIX_PATH "${QT_BUILD_DIR}")
|
|
|
|
# Make sure the CMake config files do not recreate the already-existing targets
|
|
|
|
set(QT_NO_CREATE_TARGETS TRUE)
|
|
|
|
set(BACKUP_CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ${CMAKE_FIND_ROOT_PATH_MODE_PACKAGE})
|
|
|
|
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE "BOTH")
|
|
|
|
endmacro()
|
|
|
|
|
2019-06-06 11:08:41 +00:00
|
|
|
macro(qt_examples_build_begin)
|
2019-09-19 11:46:37 +00:00
|
|
|
# Examples that are built as part of the Qt build need to use the CMake config files from the
|
|
|
|
# build dir, because they are not installed yet in a prefix build.
|
|
|
|
# Appending to CMAKE_PREFIX_PATH helps find the initial Qt6Config.cmake.
|
|
|
|
# Appending to QT_EXAMPLES_CMAKE_PREFIX_PATH helps find components of Qt6, because those
|
|
|
|
# find_package calls use NO_DEFAULT_PATH, and thus CMAKE_PREFIX_PATH is ignored.
|
2020-07-20 15:12:45 +00:00
|
|
|
qt_internal_set_up_build_dir_package_paths()
|
2019-11-21 12:33:28 +00:00
|
|
|
list(APPEND QT_EXAMPLES_CMAKE_PREFIX_PATH "${QT_BUILD_DIR}")
|
CMake: Handle automatic rpath embedding correctly
Instead of using CMAKE_INSTALL_RPATH to embed an absolute path
to prefix/libdir into all targets, use the more sophisticated aproach
that qmake does.
For certain targets (modules, plugins, tools) use relative rpaths.
Otherwise embed absolute paths (examples, regular binaries).
Installed tests currently have no rpaths.
On certain platforms rpaths are not used (Windows, Android,
iOS / uikit).
Frameworks, app bundles and shallow bundles should also be handled
correctly.
Additional rpaths can be provided via QT_EXTRA_RPATHS variable
(similar to the -R option that configure takes).
Automatic embedding can be disabled either via QT_FEATURE_rpath=OFF
or QT_DISABLE_RPATH=ON.
Note that installed examples are not relocatable at the moment (due
to always having an absolute path rpath), so this is a missing feature
compared to qmake. This is due to missing information on where
examples will be installed, so a relative rpath can not be computed.
By default a Qt installation is relocatable, so there is no need to
pass -DQT_EXTRA_RPATHS=. like Coin used to do with qmake e.g. -R .
Relative rpaths will have the appropriate 'relative base' prefixed
to them (e.g $ORIGIN on linux and @loader_path on darwin platforms).
There is currently no support for other platforms that might have a
different 'relative base' than the ones mentioned above.
Any extra rpaths are saved to BuildInternalsExtra which are re-used
when building other repositories.
configurejson2cmake modified to include correct conditions for the
rpath feature.
It's very likely that we will need a new qt_add_internal_app()
function for gui apps that are to be installed to prefix/bin.
For example for Assistant from qttools. Currently such apps
use qt_add_executable().
The distinction is necessary to make sure that relative rpaths are
embedded into apps, but not executables (which tests are part of).
Amends e835a6853b9c0fb7af32798ed8965de3adf0e15b
Task-number: QTBUG-83497
Change-Id: I3510f63c0a59489741116cc8ec3ef6a0a7704f25
Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>
2020-04-15 16:48:26 +00:00
|
|
|
|
|
|
|
# Because CMAKE_INSTALL_RPATH is empty by default in the repo project, examples need to have
|
|
|
|
# it set here, so they can run when installed.
|
|
|
|
# This means that installed examples are not relocatable at the moment. We would need to
|
|
|
|
# annotate where each example is installed to, to be able to derive a relative rpath, and it
|
|
|
|
# seems there's no way to query such information from CMake itself.
|
|
|
|
set(CMAKE_INSTALL_RPATH "${_default_install_rpath}")
|
2020-04-21 11:28:57 +00:00
|
|
|
set(QT_DISABLE_QT_ADD_PLUGIN_COMPATIBILITY TRUE)
|
2019-06-06 11:08:41 +00:00
|
|
|
endmacro()
|
|
|
|
|
|
|
|
macro(qt_examples_build_end)
|
|
|
|
# We use AUTOMOC/UIC/RCC in the examples. Make sure to not fail on a fresh Qt build, that e.g. the moc binary does not exist yet.
|
|
|
|
|
|
|
|
# This function gets all targets below this directory
|
|
|
|
function(get_all_targets _result _dir)
|
|
|
|
get_property(_subdirs DIRECTORY "${_dir}" PROPERTY SUBDIRECTORIES)
|
|
|
|
foreach(_subdir IN LISTS _subdirs)
|
|
|
|
get_all_targets(${_result} "${_subdir}")
|
|
|
|
endforeach()
|
|
|
|
get_property(_sub_targets DIRECTORY "${_dir}" PROPERTY BUILDSYSTEM_TARGETS)
|
|
|
|
set(${_result} ${${_result}} ${_sub_targets} PARENT_SCOPE)
|
|
|
|
endfunction()
|
|
|
|
|
|
|
|
get_all_targets(targets "${CMAKE_CURRENT_SOURCE_DIR}")
|
|
|
|
|
|
|
|
foreach(target ${targets})
|
2019-09-20 12:18:17 +00:00
|
|
|
qt_autogen_tools(${target} ENABLE_AUTOGEN_TOOLS "moc" "rcc")
|
|
|
|
if(TARGET Qt::Widgets)
|
|
|
|
qt_autogen_tools(${target} ENABLE_AUTOGEN_TOOLS "uic")
|
|
|
|
endif()
|
2019-06-06 11:08:41 +00:00
|
|
|
endforeach()
|
|
|
|
|
|
|
|
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ${BACKUP_CMAKE_FIND_ROOT_PATH_MODE_PACKAGE})
|
|
|
|
endmacro()
|