cmake-toolchains(7)

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

Введение

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

Языки

Языки включаются командой project(). Языковые встроенные переменные, такие как CMAKE_CXX_COMPILER, CMAKE_CXX_COMPILER_ID и т.д., устанавливаются с помощью команды project(). Если в файле CMakeLists верхнего уровня нет команды project, она будет неявно сгенерирована. По умолчанию включенные языки — 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 исходных файлов в целевом объекте, а в случае статических библиотек — по языку зависимых библиотек. Выбор, сделанный CMake, может быть переопределен свойством целевого объекта LINKER_LANGUAGE.

Функции цепочки инструментов

CMake предоставляет команду try_compile() и макросы-оболочки, такие как CheckCXXSourceCompiles, 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, компиляция QCC QNX изначально является кросс-компиляцией. И 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, так и на Windows Phone. Установите переменную CMAKE_SYSTEM_VERSION в значение 10.0, чтобы выполнить сборку с последней доступной версией SDK Windows 10. Укажите более конкретную версию (например, 10.0.10240.0 для RTM), чтобы выполнить сборку с соответствующим SDK.

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

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

set(CMAKE_SYSTEM_NAME WindowsPhone)
set(CMAKE_SYSTEM_VERSION 8.1)

Кросс-компиляция для Магазина Windows

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

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 для 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

Установите Android ABI (архитектура). Если не указано, эта переменная будет по умолчанию установлена на первую поддерживаемую 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

Установите значение в true, чтобы использовать устаревшие заголовки для каждого уровня API вместо унифицированных заголовков. Если не указано, значение по умолчанию будет false, за исключением случаев использования 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 с помощью автономного инструментария

Файл конфигурации инструментария может настроить Генераторы 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 может быть установлена для выбора значения «Версия цепочки инструментов» 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 по-прежнему позволяет создавать сборки для устройства или симулятора, даже если конфигурация была выполнена только для одного из них. Внутри среды Xcode IDE сборки выполняются для выбранной платформы «назначения». При создании сборки из командной строки желаемый 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–2022 Kitware, Inc. and Contributors
Licensed under the BSD 3-clause License.
https://cmake.org/cmake/help/v3.24/manual/cmake-toolchains.7.html