qt5base-lts/cmake
Alexey Edelev 7f5429f2f4 Add newline to the end of the config.summary
Amends 94b6bec01f

Pick-to: 6.0
Change-Id: I0d4be9c7f9aff071468a66d7940d6cd2488136ca
Reviewed-by: Cristian Adam <cristian.adam@qt.io>
2021-01-08 10:01:29 +01:00
..
3rdparty update KDE-ECM CMake modules to include fuzzer sanitizer 2020-11-14 10:05:20 +01:00
macos cmake: Add default Info.plist for macOS with some important keys 2020-03-13 15:23:56 +01:00
QtBuildInternals Fix autotest config in cross-compiled prefix build 2020-12-08 16:36:50 +01:00
tests CMake: Introduce Qt::GlobalConfig to hold the global features 2019-01-17 08:33:27 +00:00
configure-cmake-mapping.md CMake: Document some missing configure cmake mappings 2020-12-08 23:18:11 +08:00
FindATSPI2.cmake CMake: Mark all find_package(PkgConfig) to be quiet 2020-06-29 12:23:10 +02:00
FindCups.cmake CMake: Add FindCups.cmake from upstream cmake 2019-04-03 08:54:14 +00:00
FindDB2.cmake CMake: Display found information in some of the Find modules 2020-06-26 22:14:48 +02:00
FindDirectFB.cmake CMake: Mark all find_package(PkgConfig) to be quiet 2020-06-29 12:23:10 +02:00
Finddouble-conversion.cmake cmake: Only use the doubleconversion cmake config if "valid" 2019-02-01 12:26:43 +00:00
FindGLESv2.cmake CMake: Fix FindGLESv2 2020-09-16 14:48:46 +02:00
FindGSSAPI.cmake CMake: Mark all find_package(PkgConfig) to be quiet 2020-06-29 12:23:10 +02:00
FindGTK3.cmake CMake: pro2cmake: Specify library versions for 3rd party libs part 2 2020-08-10 11:56:54 +02:00
FindLibb2.cmake QtCore: Use system-wide libb2 if present 2020-07-31 15:05:24 +02:00
FindLibproxy.cmake CMake: Mark all find_package(PkgConfig) to be quiet 2020-06-29 12:23:10 +02:00
FindLibsystemd.cmake CMake: Mark all find_package(PkgConfig) to be quiet 2020-06-29 12:23:10 +02:00
FindLibudev.cmake CMake: Mark all find_package(PkgConfig) to be quiet 2020-06-29 12:23:10 +02:00
FindMtdev.cmake CMake: Mark all find_package(PkgConfig) to be quiet 2020-06-29 12:23:10 +02:00
FindMySQL.cmake CMake: Mark all find_package(PkgConfig) to be quiet 2020-06-29 12:23:10 +02:00
FindOracle.cmake Add 'oci' to possible Oracle Client library names 2021-01-06 16:17:47 +01:00
FindPPS.cmake CMake Build: Add include guards for FindPPS.cmake and FindSlog2.cmake 2020-08-19 12:46:10 +02:00
FindSlog2.cmake CMake Build: Add include guards for FindPPS.cmake and FindSlog2.cmake 2020-08-19 12:46:10 +02:00
FindTslib.cmake CMake: Mark all find_package(PkgConfig) to be quiet 2020-06-29 12:23:10 +02:00
FindWrapAtomic.cmake CMake: Display found information in some of the Find modules 2020-06-26 22:14:48 +02:00
FindWrapBrotli.cmake QDecompressHelper: Add brotli support 2020-08-06 20:56:42 +02:00
FindWrapDBus1.cmake CMake: pro2cmake: Specify library versions for 3rd party libraries 2020-08-10 11:56:54 +02:00
FindWrapDoubleConversion.cmake CMake: Display found information in some of the Find modules 2020-06-26 22:14:48 +02:00
FindWrapFreetype.cmake CMake: Handle conditions in third party find modules correctly 2020-03-05 16:08:14 +01:00
FindWrapHarfbuzz.cmake CMake: Handle conditions in third party find modules correctly 2020-03-05 16:08:14 +01:00
FindWrapOpenGL.cmake CMake: Use correct framework link flags in scripts and .pri files 2020-07-01 10:03:38 +02:00
FindWrapOpenSSL.cmake CMake: Handle finding of OpenSSL headers correctly 2020-04-08 22:03:24 +02:00
FindWrapOpenSSLHeaders.cmake CMake: Handle finding of OpenSSL headers correctly 2020-04-08 22:03:24 +02:00
FindWrapPCRE2.cmake CMake: Handle conditions in third party find modules correctly 2020-03-05 16:08:14 +01:00
FindWrapPNG.cmake CMake: Handle conditions in third party find modules correctly 2020-03-05 16:08:14 +01:00
FindWrapRt.cmake CMake: Fix FindWrapRt 2020-09-18 20:25:58 +02:00
FindWrapSystemFreetype.cmake CMake: pro2cmake: Specify library versions for 3rd party libraries 2020-08-10 11:56:54 +02:00
FindWrapSystemHarfbuzz.cmake CMake: pro2cmake: Specify library versions for 3rd party libraries 2020-08-10 11:56:54 +02:00
FindWrapSystemPCRE2.cmake CMake: Add PCRE2 library selection depend on debug version availability 2020-11-08 03:13:03 +01:00
FindWrapSystemPNG.cmake CMake: pro2cmake: Specify library versions for 3rd party libraries 2020-08-10 11:56:54 +02:00
FindXKB_COMMON_X11.cmake CMake: Mark all find_package(PkgConfig) to be quiet 2020-06-29 12:23:10 +02:00
FindXRender.cmake CMake: Mark all find_package(PkgConfig) to be quiet 2020-06-29 12:23:10 +02:00
FindZSTD.cmake CMake: Make zstd config-based lookup quiet 2020-11-09 17:47:57 +00:00
ModuleDescription.json.in Write out a module description file 2019-10-21 11:28:55 +00:00
Qt3rdPartyLibraryConfig.cmake.in CMake: Enable NEW policies by CMake version with a global default 2020-12-07 13:22:57 +11:00
Qt3rdPartyLibraryHelpers.cmake CMake: Disable static plugin imports for non-executable targets 2020-12-08 09:13:03 +01:00
qt.toolchain.cmake.in CMake: Fix usage of cache variables in qt.toolchain.cmake 2020-11-05 13:04:56 +01:00
QtAndroidHelpers.cmake CMake: Rename QtBuildInternalsAndroid.cmake to QtAndroidHelpers.cmake 2020-11-24 21:51:34 +01:00
QtAppHelpers.cmake CMake: Fix installation errors in multi-config build 2020-11-10 04:24:28 +01:00
QtAutoDetect.cmake CMake: Warn when building Qt with a generator other than Ninja 2020-11-10 16:53:31 +01:00
QtAutogenHelpers.cmake CMake: Split QtBuild.cmake into smaller files 2020-08-14 13:17:11 +02:00
QtBaseCMakeTesting.cmake CMake: Add option to run cmake build tests 2018-11-22 08:39:12 +00:00
QtBaseConfigureTests.cmake CMake: Fix arch parsing for oss-fuzz 2020-12-04 06:14:03 +01:00
QtBaseGlobalTargets.cmake CMake: Enable NEW policies by CMake version with a global default 2020-12-07 13:22:57 +11:00
QtBuild.cmake CMake: Use cmake_language(DEFER) when available for scope finalizers 2020-11-25 22:08:10 +01:00
QtBuildInformation.cmake Add newline to the end of the config.summary 2021-01-08 10:01:29 +01:00
QtBuildInternalsExtra.cmake.in CMake: Name QT_NO_MAKE_*/BUILD_* variables consistently 2020-11-20 20:38:03 +01:00
QtCMakeHelpers.cmake cmake: Add function to get a target property, with empty string as fallback 2020-11-08 13:14:30 +01:00
QtCMakeVersionHelpers.cmake CMake: Enable NEW policies by CMake version with a global default 2020-12-07 13:22:57 +11:00
QtCompatibilityHelpers.cmake CMake: Rename internal functions to contain qt_internal 2020-09-23 16:59:05 +02:00
QtCompilerFlags.cmake CMake: Allow disabling warnings similar to CONFIG += warn_off 2020-02-25 15:43:15 +01:00
QtCompilerOptimization.cmake QNX7.1 updates 2020-11-20 15:28:31 +02:00
QtConfig.cmake.in CMake: Use host variables instead of hardcoded directories 2020-12-21 13:41:13 +01:00
QtConfigDependencies.cmake.in Revert "Revert "CMake: Add facility to mark package dependencies as optional"" 2020-09-14 15:03:14 +02:00
QtDbusHelpers.cmake CMake: Split QtBuild.cmake into smaller files 2020-08-14 13:17:11 +02:00
QtDeferredDependenciesHelpers.cmake CMake: Let doc targets depend on doc tools in top-level build 2020-10-23 21:11:40 +02:00
QtDocsHelpers.cmake Fix qch install path 2021-01-07 14:13:41 +00:00
QtExecutableHelpers.cmake CMake: Install missing debug info for some executable files 2020-11-16 19:36:26 +08:00
QtFeature.cmake CMake: Print feature condition errors in configure report 2021-01-05 08:03:12 +00:00
QtFeatureCommon.cmake CMake: Introduce QtFeatureCommon.cmake 2020-08-13 19:31:59 +02:00
QtFileConfigure.txt.in CMake: Introduce qt_configure_file 2020-03-23 09:54:56 +01:00
QtFindPackageHelpers.cmake CMake: Fill QT.<module-name>.uses entries in module .pri files 2020-11-30 23:17:55 +01:00
QtFindWrapConfigExtra.cmake.in CMake: Handle conditions in third party find modules correctly 2020-03-05 16:08:14 +01:00
QtFindWrapHelper.cmake CMake: Display found information in some of the Find modules 2020-06-26 22:14:48 +02:00
QtFinishPrlFile.cmake CMake: Fix generation of prl files for non-qtbase modules 2020-10-29 12:11:53 +01:00
QtFlagHandlingHelpers.cmake Build Qt (and client apps using it) with /permissive- 2020-11-10 20:01:49 +01:00
QtFrameworkHelpers.cmake Use 'A' for Apple framework version instead of Qt major version 2020-09-23 16:59:06 +02:00
QtGenerateExtPri.cmake CMake: Generate information about 3rdparty libs in module .pri files 2020-05-19 13:26:53 +02:00
QtGenerateLibHelpers.cmake CMake: Fix generation of prl files for non-qtbase modules 2020-10-29 12:11:53 +01:00
QtGenerateLibPri.cmake CMake: Fix glitch in module pri generation for Ninja Multi-Config 2020-12-21 13:22:36 +01:00
QtGlobalStateHelpers.cmake CMake: Split QtBuild.cmake into smaller files 2020-08-14 13:17:11 +02:00
QtHeadersClean.cmake CMake: Fix headersclean interaction with header only modules 2020-11-25 22:08:10 +01:00
QtHostInfoConfig.cmake.in CMake: Expose public info about whether Qt is a shared lib build 2020-08-12 14:20:44 +02:00
QtInstallHelpers.cmake CMake: Split QtBuild.cmake into smaller files 2020-08-14 13:17:11 +02:00
QtInternalTargets.cmake CMake: Add --enable-new-dtags flag support 2020-12-22 10:28:34 +00:00
QtJavaHelpers.cmake CMake: build add flags for building QtAndroid.jar 2020-09-16 20:55:16 +03:00
QtLalrHelpers.cmake CMake: Split QtBuild.cmake into smaller files 2020-08-14 13:17:11 +02:00
QtModuleConfig.cmake.in CMake: Add detection of FEATURE_foo change by user 2020-12-17 13:03:37 +01:00
QtModuleDependencies.cmake.in CMake: Use host variables instead of hardcoded directories 2020-12-21 13:41:13 +01:00
QtModuleHelpers.cmake CMake: Disable static plugin imports for non-executable targets 2020-12-08 09:13:03 +01:00
QtModuleToolsConfig.cmake.in CMake: Enable NEW policies by CMake version with a global default 2020-12-07 13:22:57 +11:00
QtModuleToolsDependencies.cmake.in Revert "Revert "CMake: Fix usage of find_dependency()"" 2020-09-14 15:03:13 +02:00
QtModuleToolsVersionlessTargets.cmake.in CMake: Fix creation of versionless targets for tools 2019-12-06 11:11:16 +00:00
QtNoLinkTargetHelpers.cmake CMake: Split QtBuild.cmake into smaller files 2020-08-14 13:17:11 +02:00
QtPlatformAndroid.cmake CMake: Use host variables instead of hardcoded directories 2020-12-21 13:41:13 +01:00
QtPlatformSupport.cmake CMake: Add additional info which was missing in qconfig.pri 2020-06-17 15:13:43 +02:00
QtPluginConfig.cmake.in CMake: Enable NEW policies by CMake version with a global default 2020-12-07 13:22:57 +11:00
QtPluginDependencies.cmake.in CMake: Allow finding Qt CMake packages in additional locations 2020-09-28 15:48:17 +02:00
QtPluginHelpers.cmake CMake: Disable static plugin imports for non-executable targets 2020-12-08 09:13:03 +01:00
QtPlugins.cmake.in CMake: Fix prl files of static Qt builds 2020-08-06 19:19:46 +02:00
QtPostProcess.cmake CMake: Move QtPostProcess functions into QtPostProcessHelpers.cmake 2020-08-14 21:40:28 +02:00
QtPostProcessHelpers.cmake CMake: Enable NEW policies by CMake version with a global default 2020-12-07 13:22:57 +11:00
QtPrecompiledHeadersHelpers.cmake CMake: Split QtBuild.cmake into smaller files 2020-08-14 13:17:11 +02:00
QtPriHelpers.cmake CMake: Fix QMAKE_LIB_<NAME> variable names in module .pri files 2020-12-03 17:18:23 +01:00
QtPrlHelpers.cmake CMake: Fix resource object file paths in prl files for prefix builds 2020-11-30 16:16:21 +00:00
QtProcessConfigureArgs.cmake CMake: Add proactive check of generator multi-config capabilities 2021-01-05 09:03:24 +01:00
QtProperties.cmake Rename / prefix all our private API functions with qt_ 2019-11-14 09:05:33 +00:00
QtPublicTargetsHelpers.cmake Build Qt (and client apps using it) with /permissive- 2020-11-10 20:01:49 +01:00
QtQmakeHelpers.cmake CMake: Do not write Effective[Source]Paths to target_qt.conf 2020-12-08 15:15:58 +01:00
QtResourceHelpers.cmake CMake: Fix compile warnings when MSVC and -DFEATURE_static_runtime=ON 2020-12-15 22:54:46 +08:00
QtRpathHelpers.cmake CMake: Apply $ORIGIN style rpaths for non-prefix builds as well 2020-09-10 17:29:11 +02:00
QtSanitizerHelpers.cmake CMake: Split QtBuild.cmake into smaller files 2020-08-14 13:17:11 +02:00
QtScopeFinalizerHelpers.cmake CMake: Use cmake_language(DEFER) when available for scope finalizers 2020-11-25 22:08:10 +01:00
QtSeparateDebugInfo.cmake CMake Build: Enable separate debug info for all target types 2020-11-04 01:41:06 +01:00
QtSeparateDebugInfo.Info.plist.in CMake: Port the 'separate_debug_info' feature 2020-03-06 13:38:37 +01:00
QtSetup.cmake CMake: Use Release build type by default 2020-12-21 16:16:29 +00:00
QtSimdHelpers.cmake CMake: Rename internal functions to contain qt_internal 2020-09-23 16:59:05 +02:00
QtStandaloneTestsConfig.cmake.in Make standalone tests build via top level repo project 2019-11-08 15:42:32 +00:00
QtSyncQtHelpers.cmake CMake: Use host variables instead of hardcoded directories 2020-12-21 13:41:13 +01:00
QtTargetHelpers.cmake CMake: Use host variables instead of hardcoded directories 2020-12-21 13:41:13 +01:00
QtTestHelpers.cmake Fix the CMake feature for docker-testserver to use correct mkspecs path 2020-12-23 10:56:16 +01:00
QtToolchainHelpers.cmake CMake: Use host variables instead of hardcoded directories 2020-12-21 13:41:13 +01:00
QtToolHelpers.cmake CMake: Enable NEW policies by CMake version with a global default 2020-12-07 13:22:57 +11:00
QtWrapperScriptHelpers.cmake Android: install android test scripts to libexec to test on all modules 2020-12-11 20:28:50 +00:00
QtWriteArgsFile.cmake CMake: Fix Windows top-level configure.bat 2020-11-03 13:06:14 +01:00
README.md CMake: Name QT_NO_MAKE_*/BUILD_* variables consistently 2020-11-20 20:38:03 +01:00

Status

Port is still on-going.

Note: You need CMake 3.16.0 or later for most platforms (due to new AUTOMOC json feature). You need CMake 3.17.0 to build Qt for iOS with the simulator_and_device feature. You need CMake 3.17.0 + Ninja to build Qt in debug_and_release mode on Windows / Linux. You need CMake 3.18.0 + Ninja to build Qt on macOS in debug_and_release mode when using frameworks.

Intro

The CMake update offers an opportunity to revisit some topics that came up during the last few years.

  • The Qt build system does not support building host tools during a cross-compilation run. You need to build a Qt for your host machine first and then use the platform tools from that version. The decision to do this was reached independent of cmake: This does save resources on build machines as the host tools will only get built once.

  • For now Qt still ships and builds bundled 3rd party code, due to time constraints on getting all the necessary pieces together in order to remove the bundled code (changes are necessary not only in the build system but in other parts of the SDK like the Qt Installer).

  • There is less need for bootstrapping. Only moc and rcc (plus the lesser known tracegen and qfloat16-tables) are linking against the bootstrap Qt library. Everything else can link against the full QtCore. This will include qmake. Qmake is supported as a build system for applications using Qt going forward and will not go away anytime soon.

  • We keep the qmake-based Qt build system working so that we do not interfere too much with ongoing development.

Building against homebrew on macOS

You may use brew to install dependencies needed to build QtBase.

  • Install homebrew: /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
  • Build Qt dependencies: brew install pcre2 harfbuzz freetype
  • Install cmake: brew install cmake
  • When running cmake in qtbase, pass -DCMAKE_PREFIX_PATH=/usr/local

Building

The basic way of building with cmake is as follows:

    cd {build directory}
    cmake -DCMAKE_INSTALL_PREFIX=/path/where/to/install {path to source directory}
    cmake --build .
    cmake --install .

The mapping of configure options to CMake arguments is described here.

You need one build directory per Qt module. The build directory can be a sub-directory inside the module qtbase/build or an independent directory qtbase_build. The installation prefix is chosen when running cmake by passing -DCMAKE_INSTALL_PREFIX. To build more than one Qt module, make sure to pass the same install prefix.

cmake --build and cmake --install are simple wrappers around the basic build tool that CMake generated a build system for. It works with any supported build backend supported by cmake, but you can also use the backend build tool directly, e.g. by running make.

CMake has a ninja backend that works quite well and is noticeably faster (and more featureful) than make, so you may want to use that:

    cd {build directory}
    cmake -GNinja -DCMAKE_INSTALL_PREFIX=/path/where/to/install {path to source directory}
    cmake --build .
    cmake --install .

You can look into the generated build.ninja file if you're curious and you can also build targets directly, such as ninja lib/libQt6Core.so.

Make sure to remove CMakeCache.txt if you forgot to set the CMAKE_INSTALL_PREFIX on the first configuration, otherwise a second re-configuration will not pick up the new install prefix.

You can use cmake-gui {path to build directory} or ccmake {path to build directory} to configure the values of individual cmake variables or Qt features. After changing a value, you need to choose the configure step (usually several times:-/), followed by the generate step (to generate makefiles/ninja files).

Developer Build

When working on Qt itself, it can be tedious to wait for the install step. In that case you want to use the developer build option, to get as many auto tests enabled and no longer be required to make install:

    cd {build directory}
    cmake -GNinja -DFEATURE_developer_build=ON {path to source directory}
    cmake --build .
    # do NOT make install

Specifying configure.json features on the command line

QMake defines most features in configure.json files, like -developer-build or -no-opengl.

In CMake land, we currently generate configure.cmake files from the configure.json files into the source directory next to them using the helper script path_to_qtbase_source/util/cmake/configurejson2cmake.py. They are checked into the repository. If the feature in configure.json has the name "dlopen", you can specify whether to enable or disable that feature in CMake with a -D flag on the CMake command line. So for example -DFEATURE_dlopen=ON or -DFEATURE_sql_mysql=OFF. Remember to convert all '-' to '_' in the feature name. At the moment, if you change a FEATURE flag's value, you have to remove the CMakeCache.txt file and reconfigure with CMake. And even then you might stumble on some issues when reusing an existing build, because of an automoc bug in upstream CMake.

Building with CCache

You can pass -DQT_USE_CCACHE=ON to make the build system look for ccache in your PATH and prepend it to all C/C++/Objective-C compiler calls. At the moment this is only supported for the Ninja and the Makefile generators.

Cross Compiling

Compiling for a target architecture that's different than the host requires one build of Qt for the host. This "host build" is needed because the process of building Qt involves the compilation of intermediate code generator tools, that in turn are called to produce source code that needs to be compiled into the final libraries. These tools are built using Qt itself and they need to run on the machine you're building on, regardless of the architecure you are targeting.

Build Qt regularly for your host system and install it into a directory of your choice using the CMAKE_INSTALL_PREFIX variable. You are free to disable the build of tests and examples by passing -DQT_BUILD_EXAMPLES=OFF and -DQT_BUILD_TESTS=OFF.

With this installation of Qt in place, which contains all tools needed, we can proceed to create a new build of Qt that is cross-compiled to the target architecture of choice. You may proceed by setting up your environment. The CMake wiki has further information how to do that at

https://gitlab.kitware.com/cmake/community/wikis/doc/cmake/CrossCompiling

Yocto based device SDKs come with an environment setup script that needs to be sourced in your shell and takes care of setting up environment variables and a cmake alias with a toolchain file, so that you can call cmake as you always do.

In order to make sure that Qt picks up the code generator tools from the host build, you need to pass an extra parameter to cmake:

    -DQT_HOST_PATH=/path/to/your/host_build

The specified path needs to point to a directory that contains an installed host build of Qt.

Cross Compiling for Android

In order to cross-compile Qt to Android, you need a host build (see instructions above) and an Android build. In addition, it is necessary to install the Android NDK.

The following CMake variables are required for an Android build:

  • ANDROID_SDK_ROOT must point to where the Android SDK is installed
  • CMAKE_TOOLCHAIN_FILE must point to the toolchain file that comes with the NDK
  • QT_HOST_PATH must point to a host installation of Qt

Call CMake with the following arguments: -DCMAKE_TOOLCHAIN_FILE=<path/to/ndk>/build/cmake/android.toolchain.cmake -DQT_HOST_PATH=/path/to/your/host/build -DANDROID_SDK_ROOT=<path/to/sdk> -DCMAKE_INSTALL_PREFIX=$INSTALL_PATH

The toolchain file is usually located below the NDK's root at "build/cmake/android.toolchain.cmake". Instead of specifying the toolchain file you may specify ANDROID_NDK_ROOT instead. This variable is exclusively used for auto-detecting the toolchain file.

In a recent SDK installation, the NDK is located in a subdirectory "ndk_bundle" below the SDK's root directory. In that situation you may omit ANDROID_NDK_ROOT and CMAKE_TOOLCHAIN_FILE.

If you don't supply the configuration argument -DANDROID_ABI=..., it will default to armeabi-v7a. To target other architectures, use one of the following values:

  • arm64: -DANDROID_ABI=arm64-v8a
  • x86: -DANDROID_ABI=x86
  • x86_64: -DANDROID_ABI=x86_64

By default we set the android API level to 23. Should you need to change this supply the following configuration argument to the above CMake call: -DANDROID_NATIVE_API_LEVEL=${API_LEVEL}

Cross compiling for iOS

In order to cross-compile Qt to iOS, you need a host macOS build.

When running cmake in qtbase, pass -DCMAKE_SYSTEM_NAME=iOS -DQT_HOST_PATH=/path/to/your/host/build -DCMAKE_INSTALL_PREFIX=$INSTALL_PATH

If you don't supply the configuration argument -DQT_UIKIT_SDK=..., CMake will build a multi-arch simulator_and_device iOS build. To target another SDK / device type, use one of the following values:

  • iphonesimulator: -DQT_UIKIT_SDK=iphonesimulator
  • iphoneos: -DQT_UIKIT_SDK=iphoneos

Depending on what value you pass to -DQT_UIKIT_SDK= a list of target architectures is chosen by default:

  • iphonesimulator: x86_64
  • iphoneos: arm64
  • simulator_and_device: arm64;x86_64

You can try choosing a different list of architectures by passing -DCMAKE_OSX_ARCHITECTURES=x86_64;i386. Note that if you choose different architectures compared to the default ones, the build might fail. Only do it if you know what you are doing.

Debugging CMake files

CMake allows specifying the --trace and --trace-expand options, which work like qmake -d -d: As the cmake code is evaluated, the values of parameters and variables is shown. This can be a lot of output, so you may want to redirect it to a file using the --trace-redirect=log.txt option.

Porting Help

We have some python scripts to help with the conversion from qmake to cmake. These scripts can be found in utils/cmake.

configurejson2cmake.py

This script converts all configure.json in the Qt repository to configure.cmake files for use with CMake. We want to generate configure.cmake files for the foreseeable future, so if you need to tweak the generated configure.cmake files, please tweak the generation script instead.

configurejson2cmake.py is run like this: util/cmake/configurejson2cmake.py . in the top-level source directory of a Qt repository.

pro2cmake.py

pro2cmake.py generates a skeleton CMakeLists.txt file from a .pro-file. You will need to polish the resulting CMakeLists.txt file, but e.g. the list of files, etc. should be extracted for you.

pro2cmake.py is run like this: path_to_qtbase_source/util/cmake/pro2cmake.py some.pro.

run_pro2cmake.py

`` A small helper script to run pro2cmake.py on all .pro-files in a directory. Very useful to e.g. convert all the unit tests for a Qt module over to cmake;-)

run_pro2cmake.py is run like this: path_to_qtbase_source/util/cmake/run_pro2cmake.py some_dir.

vcpkg support

The initial port used vcpkg to provide 3rd party packages that Qt requires.

At the moment the Qt CI does not use vcpkg anymore, and instead builds bundled 3rd party sources if no relevant system package is found.

While the supporting code for building with vcpkg is still there, it is not tested at this time.

How to convert certain constructs

qmake CMake
qtHaveModule(foo) if(TARGET Qt::foo)
qtConfig(foo) if (QT_FEATURE_foo)

Convenience Scripts

A Qt installation's bin directory contains a number of convenience scripts.

qt-cmake

This is a wrapper around the CMake executable which passes a Qt-internal CMAKE_TOOLCHAIN_FILE. Use this to build projects against the installed Qt.

To use a custom toolchain file, use -DQT_CHAINLOAD_TOOLCHAIN_FILE=<file path>.

qt-cmake-private

The same as qt-cmake, but in addition, sets the CMake generator to Ninja.

Example:

$ cd some/empty/directory
$ ~/Qt/6.0.0/bin/qt-cmake-private ~/source/of/qtdeclarative -DFEATURE_qml_network=OFF
$ cmake --build . && cmake --install .

qt-configure-module

Call the configure script for a single Qt module, doing a CMake build.

Example:

$ cd some/empty/directory
$ ~/Qt/6.0.0/bin/qt-configure-module ~/source/of/qtdeclarative -no-feature-qml-network
$ cmake --build . && cmake --install .

qt-cmake-standalone-test

Build a single standalone test outside the Qt build.

Example:

$ cd some/empty/directory
$ ~/Qt/6.0.0/bin/qt-cmake-standalone-test ~/source/of/qtbase/test/auto/corelib/io/qprocess
$ cmake --build .