cmake-toolchains(7)

Введение
Языки
Переменные и свойства
Функции инструментальной цепочки
Кросс-компиляция

Введение

CMake использует инструментальную цепочку утилит для компиляции, компоновки библиотек и создания архивов, а также для выполнения других задач по управлению сборкой. Доступные утилиты инструментальной цепочки определяются включенными языками. При обычных сборках CMake автоматически определяет инструментальную цепочку для сборки на хост-системе на основе интроспекции системы и значений по умолчанию. В сценариях кросс-компиляции может быть указан файл инструментальной цепочки с информацией о путях компилятора и утилит.

Добавлено в версии 3.19: Можно использовать cmake-presets(7) для указания файлов инструментальной цепочки.

Языки

Языки включаются командой project(). Языковые встроенные переменные, такие как CMAKE_CXX_COMPILER, CMAKE_CXX_COMPILER_ID и т. д., устанавливаются с помощью команды project(). Если команда project отсутствует в файле CMakeLists верхнего уровня, она будет сгенерирована неявно. По умолчанию включены языки C и CXX:

project(C_Only C)

Также можно использовать специальное значение NONE с командой project() для отключения всех языков:

project(MyProject NONE)

Команда enable_language() может быть использована для включения языков после команды project():

enable_language(CXX)

При включении языка CMake находит компилятор для этого языка и определяет некоторые сведения, такие как поставщик и версия компилятора, целевая архитектура и разрядность, расположение соответствующих утилит и т. д.

Глобальное свойство ENABLED_LANGUAGES содержит языки, которые в настоящее время включены.

Переменные и свойства

Несколько переменных относятся к языковым компонентам инструментальной цепочки, которые включены:

CMAKE_<LANG>_COMPILER: Полный путь к компилятору, используемому для <LANG>
CMAKE_<LANG>_COMPILER_ID: Идентификатор компилятора, используемый CMake
CMAKE_<LANG>_COMPILER_VERSION: Версия компилятора.
CMAKE_<LANG>_FLAGS: Переменные и аналогичные им свойства конфигурации содержат флаги, которые будут добавлены к команде компиляции при компиляции файла определенного языка.

CMake должен определить, какой компилятор использовать для вызова компоновщика. Это определяется свойством LANGUAGE файлов исходного кода из target, а в случае статических библиотек - LANGUAGE зависимых библиотек. Выбор, который делает CMake, можно переопределить с помощью свойства целевого объекта LINKER_LANGUAGE.

Функции инструментальной цепочки

CMake предоставляет команду try_compile() и макросы-обертки, такие как CheckSourceCompiles, CheckCXXSymbolExists и CheckIncludeFile для проверки возможностей и доступности различных функций инструментальной цепочки. Эти API проверяют инструментальную цепочку каким-либо образом и кэшируют результат, чтобы при следующем запуске CMake проверка не выполнялась повторно.

Некоторые функции инструментальной цепочки имеют встроенную обработку в CMake и не требуют проверки компиляции. Например, POSITION_INDEPENDENT_CODE позволяет указать, что целевой объект должен быть скомпилирован как позиционно-независимый код, если компилятор поддерживает эту функцию. Свойства целевых объектов <LANG>_VISIBILITY_PRESET и VISIBILITY_INLINES_HIDDEN добавляют флаги для скрытой видимости, если это поддерживается компилятором.

Кросс-компиляция

Если cmake(1) вызывается с параметром командной строки --toolchain path/to/file или -DCMAKE_TOOLCHAIN_FILE=path/to/file, файл будет загружен в самом начале для установки значений компиляторов. Переменная CMAKE_CROSSCOMPILING устанавливается в значение true, когда CMake выполняет кросс-компиляцию.

Обратите внимание, что использование переменных CMAKE_SOURCE_DIR или CMAKE_BINARY_DIR внутри файла инструментальной цепочки обычно нежелательно. Файл инструментальной цепочки используется в контекстах, где эти переменные имеют разные значения в разных местах (например, как часть вызова try_compile()). В большинстве случаев, когда необходимо оценить пути внутри файла инструментальной цепочки, более подходящей переменной будет CMAKE_CURRENT_LIST_DIR, так как она всегда имеет однозначное и предсказуемое значение.

Кросс-компиляция для Linux

Типичная инструментальная цепочка кросс-компиляции для Linux содержит содержимое, такое как:

set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR arm)

set(CMAKE_SYSROOT /home/devel/rasp-pi-rootfs)
set(CMAKE_STAGING_PREFIX /home/devel/stage)

set(tools /home/devel/gcc-4.7-linaro-rpi-gnueabihf)
set(CMAKE_C_COMPILER ${tools}/bin/arm-linux-gnueabihf-gcc)
set(CMAKE_CXX_COMPILER ${tools}/bin/arm-linux-gnueabihf-g++)

set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

Где:

CMAKE_SYSTEM_NAME: является идентификатором CMake целевой платформы для сборки.
CMAKE_SYSTEM_PROCESSOR: является идентификатором CMake целевой архитектуры.
CMAKE_SYSROOT: необязательный, и может быть указан, если доступен sysroot.
CMAKE_STAGING_PREFIX: также необязательный. Он может быть использован для указания пути на хосте для установки. CMAKE_INSTALL_PREFIX всегда является местоположением установки времени выполнения, даже при кросс-компиляции.
CMAKE_<LANG>_COMPILER: переменная может быть установлена в полные пути или в имена компиляторов для поиска в стандартных местоположениях. Для системных инструментов, которые не поддерживают связывание бинарных файлов без пользовательских флагов или скриптов, можно установить CMAKE_TRY_COMPILE_TARGET_TYPE переменную в STATIC_LIBRARY , чтобы сообщить CMake не пытаться связывать исполняемые файлы во время проверки.

Команды CMake find_* по умолчанию будут искать в sysroot и CMAKE_FIND_ROOT_PATH записи во всех случаях, а также в корневом префиксе хост-системы. Хотя это можно контролировать в каждом отдельном случае, при кросс-компиляции может быть полезно исключить поиск в хосте или целевой системе для определённых артефактов. Как правило, заголовки, библиотеки и пакеты должны быть найдены в префиксах целевой системы, в то время как исполняемые файлы, которые должны быть запущены в рамках сборки, должны быть найдены только на хосте, а не на целевой системе. Для этого предназначены переменные CMAKE_FIND_ROOT_PATH_MODE_*.

Кросс-компиляция для среды Cray Linux

Кросс-компиляция для вычислительных узлов в среде Cray Linux может быть выполнена без необходимости отдельного файла конфигурации инструментария. Указание -DCMAKE_SYSTEM_NAME=CrayLinuxEnvironment в командной строке CMake обеспечит настройку соответствующих параметров сборки и путей поиска. Платформа будет получать конфигурацию из текущих переменных среды и настроить проект на использование оболочек компиляторов из модулей PrgEnv-* среды Cray Programming Environment, если они присутствуют и загружены.

По умолчанию среда Cray Programming Environment поддерживает только статические библиотеки. Это можно изменить и включить динамические библиотеки, установив переменную среды CRAYPE_LINK_TYPE в значение dynamic.

Запуск CMake без указания CMAKE_SYSTEM_NAME запустит этап конфигурации в режиме хоста, предполагая стандартную среду Linux. Если не переопределено, будут использоваться оболочки компиляторов PrgEnv-*, что при нацеливании на узел входа или вычислительный узел, скорее всего, не является желаемым поведением. Исключением является случай, когда вы собираетесь непосредственно на NID, а не кросс-компилируете с узла входа. Если вы пытаетесь собрать программное обеспечение для узла входа, вам нужно будет либо сначала разгрузить текущий загруженный модуль PrgEnv-*, либо явно указать CMake использовать системные компиляторы в /usr/bin вместо оболочек Cray. Если вместо этого нужно нацелится на вычислительный узел, просто укажите CMAKE_SYSTEM_NAME, как указано выше.

Кросс-компиляция с использованием Clang

Некоторые компиляторы, такие как Clang, изначально являются кросс-компиляторами. CMAKE_<LANG>_COMPILER_TARGET может быть установлен для передачи значения этим поддерживаемым компиляторам при компиляции:

set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR arm)

set(triple arm-linux-gnueabihf)

set(CMAKE_C_COMPILER clang)
set(CMAKE_C_COMPILER_TARGET ${triple})
set(CMAKE_CXX_COMPILER clang++)
set(CMAKE_CXX_COMPILER_TARGET ${triple})

Аналогично, некоторые компиляторы не поставляют собственные вспомогательные утилиты, такие как компоновщики, но предоставляют способ указать расположение внешнего инструментария, который будет использоваться драйвером компилятора. Переменная CMAKE_<LANG>_COMPILER_EXTERNAL_TOOLCHAIN может быть установлена в файле конфигурации инструментария для передачи пути к драйверу компилятора.

Кросс-компиляция для QNX

Так же как и компилятор Clang, компилятор QNX QCC является встроенным кросс-компилятором. И CMAKE_<LANG>_COMPILER_TARGET может быть установлен для передачи значения этим поддерживаемым компиляторам при компиляции:

set(CMAKE_SYSTEM_NAME QNX)

set(arch gcc_ntoarmv7le)

set(CMAKE_C_COMPILER qcc)
set(CMAKE_C_COMPILER_TARGET ${arch})
set(CMAKE_CXX_COMPILER QCC)
set(CMAKE_CXX_COMPILER_TARGET ${arch})

set(CMAKE_SYSROOT $ENV{QNX_TARGET})

Кросс-компиляция для Windows CE

Кросс-компиляция для Windows CE требует установки соответствующего SDK на вашей системе. Эти SDK обычно устанавливаются в C:/Program Files (x86)/Windows CE Tools/SDKs.

Файл конфигурации инструментария для настройки генератора Visual Studio для Windows CE может выглядеть так:

set(CMAKE_SYSTEM_NAME WindowsCE)

set(CMAKE_SYSTEM_VERSION 8.0)
set(CMAKE_SYSTEM_PROCESSOR arm)

set(CMAKE_GENERATOR_TOOLSET CE800) # Can be omitted for 8.0
set(CMAKE_GENERATOR_PLATFORM SDK_AM335X_SK_WEC2013_V310)

CMAKE_GENERATOR_PLATFORM сообщает генератору, какой SDK использовать. CMAKE_SYSTEM_VERSION сообщает генератору, какую версию Windows CE использовать. В настоящее время поддерживается версия 8.0 (Windows Embedded Compact 2013). Другие версии могут потребовать установки CMAKE_GENERATOR_TOOLSET в нужное значение.

Кросс-компиляция для универсальных приложений Windows 10

Файл конфигурации инструментария для настройки генераторов Visual Studio для универсального приложения Windows 10 может выглядеть так:

set(CMAKE_SYSTEM_NAME WindowsStore)
set(CMAKE_SYSTEM_VERSION 10.0)

Универсальное приложение Windows 10 нацелено как на Windows Store, так и на Windows Phone. Укажите переменную CMAKE_SYSTEM_VERSION в значении 10.0 или выше.

CMake выбирает Windows SDK, как описано в документации к переменной CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION.

Кросс-компиляция для Windows Phone

Файл конфигурации инструментария для настройки генератора Visual Studio для Windows Phone может выглядеть так:

set(CMAKE_SYSTEM_NAME WindowsPhone)
set(CMAKE_SYSTEM_VERSION 8.1)

Кросс-компиляция для Windows Store

Файл конфигурации инструментария для настройки генератора Visual Studio для Windows Store может выглядеть так:

set(CMAKE_SYSTEM_NAME WindowsStore)
set(CMAKE_SYSTEM_VERSION 8.1)

Кросс-компиляция для ADSP SHARC/Blackfin

Кросс-компиляция для ADSP SHARC или Blackfin может быть настроена путем установки переменной CMAKE_SYSTEM_NAME в значение ADSP и CMAKE_SYSTEM_PROCESSOR переменной в «номер детали», исключая префикс ADSP-, например, 21594, SC589, и т. д. Это значение нечувствительно к регистру.

CMake автоматически будет искать установленные CCES или VDSP++ в их стандартных местоположениях и выбирать последнюю найденную версию. CCES будет выбран вместо VDSP++, если оба установлены. Пользовательские пути установки могут быть заданы через переменную CMAKE_ADSP_ROOT или переменную среды ADSP_ROOT.

Компилятор (cc21k против ccblkfn) выбирается автоматически на основе значения CMAKE_SYSTEM_PROCESSOR.

Кросс-компиляция для Android

Файл конфигурации инструментария может настроить кросс-компиляцию для Android, установив переменную CMAKE_SYSTEM_NAME в Android. Дальнейшая настройка зависит от используемой среды разработки Android.

Для генераторов Visual Studio, CMake ожидает установки NVIDIA Nsight Tegra Visual Studio Edition или Visual Studio tools for Android. Подробные сведения о настройке см. в этих разделах.

Для генераторов Makefile и генератора Ninja, CMake ожидает наличия одной из этих сред:

NDK
Самостоятельный инструментарий

CMake использует следующие шаги для выбора одной из сред:

Если переменная CMAKE_ANDROID_NDK установлена, будет использоваться NDK по указанному пути.
В противном случае, если установлена переменная CMAKE_ANDROID_STANDALONE_TOOLCHAIN, будет использоваться Standalone Toolchain по указанному пути.
В противном случае, если переменная CMAKE_SYSROOT установлена на каталог вида <ndk>/platforms/android-<api>/arch-<arch>, часть <ndk> будет использована в качестве значения для CMAKE_ANDROID_NDK, и будет использован NDK.
В противном случае, если переменная CMAKE_SYSROOT установлена на каталог вида <standalone-toolchain>/sysroot, часть <standalone-toolchain> будет использована в качестве значения для CMAKE_ANDROID_STANDALONE_TOOLCHAIN, и будет использован Standalone Toolchain.
В противном случае, если переменная cmake ANDROID_NDK установлена, она будет использована в качестве значения для CMAKE_ANDROID_NDK, и будет использован NDK.
В противном случае, если переменная cmake ANDROID_STANDALONE_TOOLCHAIN установлена, она будет использована в качестве значения для CMAKE_ANDROID_STANDALONE_TOOLCHAIN, и будет использован Standalone Toolchain.
В противном случае, если переменная среды ANDROID_NDK_ROOT или ANDROID_NDK установлена, она будет использована в качестве значения для CMAKE_ANDROID_NDK, и будет использован NDK.
В противном случае, если переменная среды ANDROID_STANDALONE_TOOLCHAIN установлена, она будет использована в качестве значения для CMAKE_ANDROID_STANDALONE_TOOLCHAIN, и будет использован Standalone Toolchain.
В противном случае будет выведено сообщение об ошибке, что ни NDK, ни Standalone Toolchain не найдены.

Новое в версии 3.20: Если выбран Android NDK, его номер версии будет отображаться в переменной CMAKE_ANDROID_NDK_VERSION.

Компиляция для Android с помощью NDK

Файл цепочки инструментов может настроить Генераторы Makefile, Генераторы Ninja или Генераторы Visual Studio для настройки компиляции для Android.

Настройка использования Android NDK с помощью следующих переменных:

CMAKE_SYSTEM_NAME

Установите значение Android. Необходимо для включения кросс-компиляции для Android.

CMAKE_SYSTEM_VERSION

Установите уровень API Android. Если не указано, значение определяется следующим образом:

Если установлена переменная CMAKE_ANDROID_API, её значение используется в качестве уровня API.
Если установлена переменная CMAKE_SYSROOT, уровень API определяется из структуры каталога NDK, содержащей sysroot.
В противном случае используется последний доступный уровень API в NDK.

CMAKE_ANDROID_ARCH_ABI

Установите ABI Android (архитектуру). Если не указано, эта переменная по умолчанию будет установлена на первую поддерживаемую ABI из списка armeabi, armeabi-v7a и arm64-v8a. Переменная CMAKE_ANDROID_ARCH будет вычислена из CMAKE_ANDROID_ARCH_ABI автоматически. Также см. переменные CMAKE_ANDROID_ARM_MODE и CMAKE_ANDROID_ARM_NEON.

CMAKE_ANDROID_NDK

Установите абсолютный путь к корневому каталогу Android NDK. Если не указано, значение по умолчанию будет выбрано, как указано выше.

CMAKE_ANDROID_NDK_DEPRECATED_HEADERS

Установите в истинное значение, чтобы использовать устаревшие заголовки по уровням API вместо унифицированных заголовков. Если не указано, значение по умолчанию будет ложным, если не используется NDK, который не предоставляет унифицированные заголовки.

CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION

В NDK r19 или выше эта переменная должна быть не задана или установлена в clang. В NDK r18 или ниже, установите эту переменную на версию NDK компилятора, которую нужно выбрать. Если не указано, по умолчанию будет использоваться последняя доступная цепочка GCC.

CMAKE_ANDROID_STL_TYPE

Установите, чтобы указать, какую стандартную библиотеку C++ использовать. Если не указано, значение по умолчанию будет выбрано, как описано в документации переменной.

Следующие переменные будут вычислены и автоматически предоставлены:

CMAKE_<LANG>_ANDROID_TOOLCHAIN_PREFIX: Абсолютный префикс пути к binutils в цепочке инструментов NDK.
CMAKE_<LANG>_ANDROID_TOOLCHAIN_SUFFIX: Суффикс платформы-хозяина для binutils в цепочке инструментов NDK.

Например, файл цепочки инструментов может содержать:

set(CMAKE_SYSTEM_NAME Android)
set(CMAKE_SYSTEM_VERSION 21) # API level
set(CMAKE_ANDROID_ARCH_ABI arm64-v8a)
set(CMAKE_ANDROID_NDK /path/to/android-ndk)
set(CMAKE_ANDROID_STL_TYPE gnustl_static)

Вместо файла цепочки инструментов можно указать значения напрямую:

$ cmake ../src \
  -DCMAKE_SYSTEM_NAME=Android \
  -DCMAKE_SYSTEM_VERSION=21 \
  -DCMAKE_ANDROID_ARCH_ABI=arm64-v8a \
  -DCMAKE_ANDROID_NDK=/path/to/android-ndk \
  -DCMAKE_ANDROID_STL_TYPE=gnustl_static

Компиляция для Android с помощью Standalone Toolchain

Файл цепочки инструментов может настроить Генераторы Makefile или Ninja генератор для настройки компиляции для Android с помощью автономной цепочки инструментов.

Настройка использования автономной цепочки инструментов Android с помощью следующих переменных:

CMAKE_SYSTEM_NAME: Установите значение Android. Необходимо для включения кросс-компиляции для Android.
CMAKE_ANDROID_STANDALONE_TOOLCHAIN: Установите абсолютный путь к корневому каталогу автономной цепочки инструментов. Должен существовать каталог ${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/sysroot. Если не указано, значение по умолчанию будет выбрано, как указано выше.
CMAKE_ANDROID_ARM_MODE: Когда автономная цепочка инструментов направлена на ARM, необязательно установите значение ON, чтобы использовать 32-битный ARM вместо 16-битного Thumb. См. документацию переменной для получения подробностей.
CMAKE_ANDROID_ARM_NEON: Когда автономная цепочка инструментов направлена на ARM v7, необязательно установите значение ON, чтобы использовать устройства ARM NEON. См. документацию переменной для получения подробностей.

CMAKE_SYSTEM_VERSION: Уровень API Android, обнаруженный автономной цепочкой инструментов.
CMAKE_ANDROID_ARCH_ABI: ABI Android, обнаруженный автономной цепочкой инструментов.
CMAKE_<LANG>_ANDROID_TOOLCHAIN_PREFIX: Префикс абсолютного пути к binutils в автономной цепочке инструментов.
CMAKE_<LANG>_ANDROID_TOOLCHAIN_SUFFIX: Суффикс платформы-хоста binutils в автономной цепочке инструментов.

Например, файл цепочки инструментов может содержать:

set(CMAKE_SYSTEM_NAME Android)
set(CMAKE_ANDROID_STANDALONE_TOOLCHAIN /path/to/android-toolchain)

В качестве альтернативы, значения можно указать без файла цепочки инструментов:

$ cmake ../src \
  -DCMAKE_SYSTEM_NAME=Android \
  -DCMAKE_ANDROID_STANDALONE_TOOLCHAIN=/path/to/android-toolchain

Компиляция для Android с NVIDIA Nsight Tegra Visual Studio Edition

Файл цепочки инструментов для настройки одного из генераторов Visual Studio для сборки с использованием NVIDIA Nsight Tegra с нацеливанием на Android может выглядеть следующим образом:

set(CMAKE_SYSTEM_NAME Android)

Переменная CMAKE_GENERATOR_TOOLSET может быть установлена для выбора значения "Toolchain Version" Nsight Tegra.

См. также свойства целевых объектов:

Компиляция для iOS, tvOS или watchOS

Для кросс-компиляции для iOS, tvOS или watchOS рекомендуется генератор Xcode. Генераторы Unix Makefiles или Ninja также могут быть использованы, но они требуют, чтобы проект обрабатывал больше областей, таких как выбор целевого процессора и подписание кода.

Любая из трёх систем может быть целью, установив переменную CMAKE_SYSTEM_NAME на значение из таблицы ниже. По умолчанию выбирается последняя версия SDK устройства. Как и для всех платформ Apple, другой SDK (например, симулятора) можно выбрать, установив переменную CMAKE_OSX_SYSROOT, хотя это редко необходимо (см. Переключение между устройством и симулятором ниже). Список доступных SDK можно получить, выполнив xcodebuild -showsdks.

ОС	CMAKE_SYSTEM_NAME	SDK устройства (по умолчанию)	SDK симулятора
iOS	iOS	iphoneos	iphonesimulator
tvOS	tvOS	appletvos	appletvsimulator
watchOS	watchOS	watchos	watchsimulator

Например, для создания конфигурации CMake для iOS достаточно следующей команды:

cmake .. -GXcode -DCMAKE_SYSTEM_NAME=iOS

Переменная CMAKE_OSX_ARCHITECTURES может использоваться для установки архитектур как для устройства, так и для симулятора. Переменная CMAKE_OSX_DEPLOYMENT_TARGET может использоваться для установки целевой версии iOS/tvOS/watchOS.

Следующая конфигурация установит библиотеку iOS с 5 архитектурами и добавит флаги -miphoneos-version-min=9.3/-mios-simulator-version-min=9.3 к компилятору:

$ cmake -S. -B_builds -GXcode \
    -DCMAKE_SYSTEM_NAME=iOS \
    "-DCMAKE_OSX_ARCHITECTURES=armv7;armv7s;arm64;i386;x86_64" \
    -DCMAKE_OSX_DEPLOYMENT_TARGET=9.3 \
    -DCMAKE_INSTALL_PREFIX=`pwd`/_install \
    -DCMAKE_XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH=NO \
    -DCMAKE_IOS_INSTALL_COMBINED=YES

Пример:

# CMakeLists.txt
cmake_minimum_required(VERSION 3.14)
project(foo)
add_library(foo foo.cpp)
install(TARGETS foo DESTINATION lib)

Установка:

$ cmake --build _builds --config Release --target install

Проверка библиотеки:

$ lipo -info _install/lib/libfoo.a
Architectures in the fat file: _install/lib/libfoo.a are: i386 armv7 armv7s x86_64 arm64

$ otool -l _install/lib/libfoo.a | grep -A2 LC_VERSION_MIN_IPHONEOS
      cmd LC_VERSION_MIN_IPHONEOS
  cmdsize 16
  version 9.3

Подписание кода

Некоторые скомпилированные артефакты для встроенных платформ Apple требуют обязательного подписи кода. Если используется генератор Xcode и требуется или желательно подписание кода, идентификатор разработчика можно указать через переменную CMake CMAKE_XCODE_ATTRIBUTE_DEVELOPMENT_TEAM. Этот идентификатор команды затем будет включен в сгенерированный проект Xcode. По умолчанию CMake избегает необходимости подписи кода во время внутренней фазы конфигурации (т. е. идентификатор компилятора и обнаружение функций).

Переключение между устройством и симулятором

При настройке для любой из встроенных платформ можно нацеливаться либо на реальные устройства, либо на симулятор. У них есть свои отдельные SDK, но CMake поддерживает только указание одного SDK для фазы конфигурации. Это означает, что разработчик должен выбрать один или другой во время конфигурации. При использовании генератора Xcode это ограничение менее существенно, потому что Xcode всё ещё позволяет вам создавать как для устройства, так и для симулятора, даже если конфигурация была выполнена только для одного из двух. Внутри IDE Xcode сборка выполняется для выбранной платформы "назначения". При сборке из командной строки нужный SDK можно указать непосредственно, передав опцию -sdk базовому инструменту сборки (xcodebuild). Например:

$ cmake --build ... -- -sdk iphonesimulator

Обратите внимание, что проверки, выполненные во время конфигурации, проводились по отношению к SDK на момент конфигурации и могут не соответствовать другим SDK. Команды, такие как find_package(), find_library() и т. д., хранят и используют детали только для настроенного SDK/платформы, поэтому они могут быть проблематичными при переключении между сборками устройства и симулятора. Для того чтобы устройство + симуляторы работали, следует придерживаться следующих правил:

Используйте явное -l флаг линковщика, например target_link_libraries(foo PUBLIC "-lz")
Используйте явное -framework флаг линковщика, например target_link_libraries(foo PUBLIC "-framework CoreFoundation")
Используйте find_package() только для библиотек, установленных с помощью функции CMAKE_IOS_INSTALL_COMBINED

© 2000–2024 Kitware, Inc. and Contributors
Licensed under the BSD 3-clause License.
https://cmake.org/cmake/help/v3.27/manual/cmake-toolchains.7.html