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, если они присутствуют и загружены.

По умолчанию среда программирования Cray поддерживает только статические библиотеки. Это можно изменить и включить динамические библиотеки, установив переменную среды 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, так и на 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 vs. 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

Файл toolchain может настроить Генераторы 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 вместо унифицированных заголовков. Если не указано, по умолчанию будет false, если не используется NDK, который не предоставляет унифицированные заголовки.

CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION

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

CMAKE_ANDROID_STL_TYPE

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

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

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

Например, файл toolchain может содержать:

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)

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

$ 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 с автономной Toolchain

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

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

CMAKE_SYSTEM_NAME: Устанавливается в Android. Необходимо указать для включения кросс-компиляции для Android.
CMAKE_ANDROID_STANDALONE_TOOLCHAIN: Устанавливается на абсолютный путь к корневому каталогу автономной toolchain. Должен существовать каталог ${CMAKE_ANDROID_STANDALONE_TOOLCHAIN}/sysroot. Если не указано, по умолчанию будет выбрано значение, указанное выше.
CMAKE_ANDROID_ARM_MODE: При использовании автономной toolchain для ARM, опционально установите это значение в ON, чтобы указать 32-битный ARM вместо 16-битного Thumb. Смотрите документацию по переменной для подробностей.
CMAKE_ANDROID_ARM_NEON: При использовании автономной toolchain для 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, visionOS или watchOS

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

Любая из платформ Apple устройств может быть целевой, установив переменную 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
visionOS	visionOS	xros	xrsimulator
watchOS	watchOS	watchos	watchsimulator

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

cmake .. -GXcode -DCMAKE_SYSTEM_NAME=iOS

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

Следующий пример устанавливает пять архитектур в универсальную библиотеку для iOS-библиотеки. Он добавляет соответствующий -miphoneos-version-min=9.3 или -mios-simulator-version-min=9.3 флаг компилятора, где это необходимо. Обратите внимание, что переменная -miphoneos-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.29/manual/cmake-toolchains.7.html