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

CMAKE_ANDROID_STL_TYPE

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

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

CMAKE_<LANG>_ANDROID_TOOLCHAIN_PREFIX: Абсолютный префикс пути к binutils в NDK toolchain.
CMAKE_<LANG>_ANDROID_TOOLCHAIN_SUFFIX: Суффикс хостовой платформы binutils в NDK 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)

Альтернативно, значения можно указать без файла конфигурации:

$ 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 с использованием standalone toolchain.

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

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