This seems possible via -target x86_64-apple-ios-macabi -miphoneos-version-min=13.0. Adding it to CFLAGS and LDFLAGS should be sufficient, although untested.

Hi, I tried to get your iOS CMake Toolchain running but I always get the same error:

clang: error: invalid iOS deployment version '-mios-simulator-version-min=12.1',
iOS 10 is the maximum deployment target for 32-bit targets
[-Winvalid-ios-deployment-target]

I know 32-bit targets are no longer supported, but I don't understand why the CMake build always sets this target (i.e. i386). No matter if I set IOS_PLATFORM macro to OS or SIMULATOR64.

I also tried different deployment targets: 8.0, 10.0, 12.0, and 12.1. But since SDK 12.1 is my only installed SDK, the CMake build can only use this one.

Can anyone tell me what I'm doing wrong?

there is an error occur when i build the google test and avs-device-sdk

I enter the command on the command line: cmake ../googletest -DIOS_DEPLOYMENT_TARGET=10.0 -DCMAKE_TOOLCHAIN_FILE=../ios-cmake/ios.toolchain.cmake -DIOS_PLATFORM=OS or cmake ../avs-device-sdk -DIOS_DEPLOYMENT_TARGET=10.0 -DCMAKE_TOOLCHAIN_FILE=../ios-cmake/ios.toolchain.cmake -DIOS_PLATFORM=OS -DGSTREAMER_MEDIA_PLAYER=OFF -DCURL_LIBRARY=../Build-OpenSSL-cURL/archive/libcurl-7.54.1-openssl-1.0.2l-nghttp2-1.24.0/libcurl_iOS.a -DCURL_INCLUDE_DIR=../Build-OpenSSL-cURL/curl/curl-7.55.1/include -DGTEST_LIBRARY=../googletest_build/googlemock/libgmock.a -DGTEST_MAIN_LIBRARY=../googletest_build/googlemock/libgmock_main.a -DGTEST_INCLUDE_DIR=../googletest/googletest/include/ -DPKG_CONFIG_EXECUTABLE=/usr/local/bin/pkg-config

error is:

-- Building with Xcode version: -- Configuring iOS build for platform: SIMULATOR64, architecture(s): x86_64 -- Using SDK: for platform: SIMULATOR64 CMake Error at ../ios-cmake/ios.toolchain.cmake:172 (message): Invalid CMAKE_OSX_SYSROOT: does not exist. Call Stack (most recent call first): /usr/local/Cellar/cmake/3.11.3/share/cmake/Modules/CMakeDetermineSystem.cmake:94 (include) CMakeLists.txt:4 (project)

CMake Error: CMake was unable to find a build program corresponding to "Unix Makefiles". CMAKE_MAKE_PROGRAM is not set. You probably need to select a different build tool. CMake Error: CMAKE_CXX_COMPILER not set, after EnableLanguage -- Configuring incomplete, errors occurred!

How can I build it successfully？

Hello,

I tried the recent 3.0.1 update, and encountered an issue I can't fix.

For some part of my code, I use CMake to create XCTest targets with your toolchain using XCode generator. For this, I add find_package(XCTest REQUIRED) in my CMakeLists, and use the functions xctest_add_bundle and xctest_add_test to generator my XCTest targets.

Everything worked fine, but when I updated the toolchain from 2.2.0 to the 3.0.1 and changed IOS_PLATFORM to PLATFORM in my Cmake build scrits, I obtained the following error :

CMake Error at /usr/local/Cellar/cmake/3.14.1/share/cmake/Modules/FindPackageHandleStandardArgs.cmake:137 (message):
  Could NOT find XCTest (missing: XCTest_LIBRARY XCTest_INCLUDE_DIR)
Call Stack (most recent call first):
  /usr/local/Cellar/cmake/3.14.1/share/cmake/Modules/FindPackageHandleStandardArgs.cmake:378 (_FPHSA_FAILURE_MESSAGE)
  /usr/local/Cellar/cmake/3.14.1/share/cmake/Modules/FindXCTest.cmake:84 (find_package_handle_standard_args)
  MWMAudioKit/MWMAudioKit_Core/CoreMathVector-Tests/CMakeLists.txt:30 (find_package)

I'm running CMake 3.14.1 and I have XCode 10.2 with iOS SDK 12.2 installed.

I looked at the diff of your release and tried a few things but couldn't find any solution. Any idea of something I or you did wrong ?

Thanks again for your work :)

Tom

Since CMake 3.5.2, it seems CMake has support for Universal fat libraries out-of-the-box. This can be set with CMAKE_IOS_INSTALL_COMBINED.

From the official documentation for the target property IOS_INSTALL_COMBINED:

When this property is set to set to false (which is the default) then it will either be built with the device SDK or the simulator SDK depending on the SDK set. But if this property is set to true then the target will at install time also be built for the corresponding SDK and combined into one library.

This feature requires at least Xcode version 6.

Internally, it seems to create an install task on the target to build for all the supplied Apple Device SDKs then combine all the binaries into 1 fat binary using lipo.

I haven't actually started using this variable yet, and I'm not exactly sure how it would even fit with the current toolchain, but if I can figure it out before someone else investigates it, I'm willing to create a pull request.

It seems to me that the recent addition (solving #40) of CMAKE_SYSTEM_PROCESSOR breaks some build.

I am not sure why, so here is a reproducible example:

1. Use the latest ios.toolchain.cmake file
2. Use the following CMakeLists.txt, which will basically download and build libressl
3. Run cmake -DCMAKE_TOOLCHAIN_FILE=/path/to/ios.toolchain.cmake ..

CMakeLists.txt

cmake_minimum_required(VERSION 3.1)
  
project(external-libressl)
include(ExternalProject)

set(LIBRESSL_VERSION 2.9.0)

list(APPEND CMAKE_ARGS
    "-DCMAKE_TOOLCHAIN_FILE:PATH=${CMAKE_TOOLCHAIN_FILE}"
    "-DBUILD_SHARED_LIBS=OFF"
    "-DLIBRESSL_APPS=OFF"
    "-DLIBRESSL_TESTS=OFF"
    )

if(IOS)
    list(APPEND CMAKE_ARGS
        "-DPLATFORM=${PLATFORM}"
        "-DCMAKE_C_FLAGS=-Wno-implicit-function-declaration"
        )
endif()

message(STATUS "Preparing external project \"libressl\" with args:")
foreach(CMAKE_ARG ${CMAKE_ARGS})
    message(STATUS "-- ${CMAKE_ARG}")
endforeach()

ExternalProject_add(
    libressl
    URL https://ftp.openbsd.org/pub/OpenBSD/LibreSSL/libressl-${LIBRESSL_VERSION}.tar.gz
    PREFIX libressl
    CMAKE_ARGS "${CMAKE_ARGS}"
    )

The error I get:

[ 75%] Performing build step for 'libressl'
Scanning dependencies of target crypto
[  0%] Building C object crypto/CMakeFiles/crypto.dir/aes/aes-elf-armv4.S.o
/tmp/demo_libressl/build/libressl/src/libressl/crypto/aes/aes-elf-armv4.S:1:10: fatal error: 'arm_arch.h' file not found
#include "arm_arch.h"
         ^~~~~~~~~~~~

Removing this addition of CMAKE_SYSTEM_PROCESSOR fixes it, I have no idea why.

Describe the bug If you are trying to build OS64 or any platform which is not a simulator, you will be forced to code sign the output. When building from a Mac without code signing certificate (no Apple developer account), the CMAKE_XCODE_ATTRIBUTE_DEVELOPMENT_TEAM will be set as "123456789A" and the build will fail with error message,

Code Signing Error: No signing certificate "iOS Development" found: No "iOS Development" signing certificate matching team ID "123456789A" with a private key was found.

To Reproduce Steps to reproduce the behavior:

1. Build any project for device (not simulator) such as OS64 without providing CMAKE_XCODE_ATTRIBUTE_DEVELOPMENT_TEAM

Expected behavior Be able build without code signing. Not every libraries are required to be code signed, for example,

• Static linked libraries do not require code signing
• App developers may choose to code sign the dynamic library manually late
• For CIs verifying building, adding code signing will be extra work without obvious benefits

Environment

• What version of CMake did you run?
• Your faulty CMakeLists.txt here:

--- Paste here ---

Proposal Add an extra option to disable code signing, if CMAKE_XCODE_ATTRIBUTE_DEVELOPMENT_TEAM is not set. Can send PR

I'm using CMake with ios-cmake (3.1.0) inside an Xcode Run Script build phase, to build a 3rd party static library my target links with. However, Clang immediately fails with:

clang: error: invalid argument '-mmacosx-version-min=9.0' not allowed with '-mios-simulator-version-min=9.0'

The problem appears to be caused by this statement in ios.toolchain.cmake:

https://github.com/leetal/ios-cmake/blob/8f7c16a462d17eba7124aba921153382605df288/ios.toolchain.cmake#L545-L546

If I comment out those two lines, everything builds fine. It seems wrong for the script to be forcing a macOS deployment target when it's not building for macOS, but somehow I'm the only one having trouble as a result...

Here's the full CMake output:

CMake options:                  -DCMAKE_TOOLCHAIN_FILE=vendor/ios-cmake/ios.toolchain.cmake                 -DPLATFORM=SIMULATOR64             -DENABLE_PROGRAMS=0             -DENABLE_TESTING=0 -DCMAKE_BUILD_TYPE=Debug -DLWS_WITH_ASAN=1
-- Building with Xcode version: 11.2.1
-- Configuring iphonesimulator build for platform: SIMULATOR64, architecture(s): x86_64
-- Using SDK: /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator13.2.sdk for platform: SIMULATOR64
-- Using the default min-version since DEPLOYMENT_TARGET not provided!
-- Disabling bitcode support by default on simulators. ENABLE_BITCODE not provided for override!
-- Enabling ARC support by default. ENABLE_ARC not provided!
-- Hiding symbols visibility by default. ENABLE_VISIBILITY not provided!
-- Using NON-strict compiler checks by default. ENABLE_STRICT_TRY_COMPILE not provided!
-- Using C compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-- Using CXX compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang++
-- Using libtool: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/libtool
-- Using install_name_tool: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/install_name_tool
-- Using a data_ptr size of 8
-- Building for minimum iphonesimulator version: 9.0 (SDK version: 13.2)
-- Version flags set to: -mios-simulator-version-min=9.0
-- Disabling bitcode support.
-- Enabling ARC support.
-- Hiding symbols (-fvisibility=hidden).
-- Building with Xcode version: 11.2.1
-- Configuring iphonesimulator build for platform: SIMULATOR64, architecture(s): x86_64
-- Using SDK: /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator13.2.sdk for platform: SIMULATOR64 when checking compatibility
-- Using libtool: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/libtool
-- Using a data_ptr size of 8
-- Building for minimum iphonesimulator version: 9.0 (SDK version: 13.2)
-- Version flags set to: -mios-simulator-version-min=9.0
-- Disabling bitcode support.
-- Enabling ARC support.
-- Hiding symbols (-fvisibility=hidden).
-- The C compiler identification is AppleClang 11.0.0.11000033
-- Check for working C compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-- Check for working C compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang -- broken
CMake Error at /usr/local/Cellar/cmake/3.9.1/share/cmake/Modules/CMakeTestCCompiler.cmake:51 (message):
  The C compiler
  "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang"
  is not able to compile a simple test program.

  It fails with the following output:

   Change Dir: /Users/snej/Couchbase/CBL/couchbase-lite-ios/build/CouchbaseLite/Build/Intermediates.noindex/LiteCore.build/Debug-iphonesimulator/mbedTLS.build/Objects/mbedtls/CMakeFiles/CMakeTmp

  

  Run Build Command:"/Applications/Xcode.app/Contents/Developer/usr/bin/make"
  "cmTC_823d2/fast"

  /Applications/Xcode.app/Contents/Developer/usr/bin/make -f
  CMakeFiles/cmTC_823d2.dir/build.make CMakeFiles/cmTC_823d2.dir/build

  Building C object CMakeFiles/cmTC_823d2.dir/testCCompiler.c.o

  
  /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
  -mios-simulator-version-min=9.0 -fobjc-abi-version=2 -fobjc-arc
  -mios-simulator-version-min=9.0 -fobjc-abi-version=2 -fobjc-arc -arch
  x86_64 -isysroot
  /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator13.2.sdk
  -mmacosx-version-min=9.0 -o CMakeFiles/cmTC_823d2.dir/testCCompiler.c.o -c
  /Users/snej/Couchbase/CBL/couchbase-lite-ios/build/CouchbaseLite/Build/Intermediates.noindex/LiteCore.build/Debug-iphonesimulator/mbedTLS.build/Objects/mbedtls/CMakeFiles/CMakeTmp/testCCompiler.c


  clang: error: invalid argument '-mmacosx-version-min=9.0' not allowed with
  '-mios-simulator-version-min=9.0'

Here in the commit CMAKE_OSX_SYSROOT becomes like

/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator12.2.sdk

All is OK.

But here in the commit CMAKE_OSX_SYSROOT becomes like

iphonesimulator

For what purpose?

And further work is done with CMAKE_OSX_SYSROOT as a path to a file, rather than as the name of the SDK.

Hi,

First, you make a great toolkit, good job!

Second, im trying use your toolkit to build a simple FAT/COMBINED library and use on xcode.

The problem is that generated library is only with one "arch".

There is a test on my sample repository, and the problem can be checked there: https://travis-ci.com/prsolucoes/ios-lib-test/builds/138626985#L873

Im calling your toolkit with the params: https://github.com/prsolucoes/ios-lib-test/blob/master/Makefile#L24

It is strange, because if i run install it generate the library into system folder with all archs inside: /usr/local/lib/libcpp_lib_test.a

The command to install is here: https://github.com/prsolucoes/ios-lib-test/blob/master/Makefile#L40

Can you help me understand the problem?

Thanks.

Building example-lib get an error:

CMake Error at /usr/local/Cellar/cmake/3.14.5/share/cmake/Modules/Platform/iOS-Initialize.cmake:4 (message):
  iphoneos is not an iOS SDK
Call Stack (most recent call first):
  /usr/local/Cellar/cmake/3.14.5/share/cmake/Modules/CMakeSystemSpecificInitialize.cmake:21 (include)
  CMakeLists.txt:2 (project)

use cmake 3.15.rc not working. can some one help me?

I'm new to cross-compiling so I may be doing something wrong. I've tried using this toolchain together with cmake-conan script. I'm having problem with auto-detecting of compiler here: https://github.com/conan-io/cmake-conan/blob/835529148ac0def63bbd1d07ceb4e4c130d233af/conan.cmake#L370 In my case: cmake -E echo "#include <string>" | /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang++ --target=aarch64-apple-ios11.0 -fvisibility=hidden -fvisibility-inlines-hidden -x c++ --sysroot=/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS14.0.sdk -E -dM - This leads to error: unknown target triple 'unknown-apple-ios11.0.0', please use -triple or -arch

I've tried googling and found this issue https://groups.google.com/g/llvm-dev/c/PIBNR1EE9R0 Running the same command with arm64-apple-ios11.0 instead of aarch64-apple-ios11.0 seems to be working. cmake -E echo "#include <string>" | /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang++ --target=arm64-apple-ios11.0 -fvisibility=hidden -fvisibility-inlines-hidden -x c++ --sysroot=/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS14.0.sdk -E -dM -

So should something be changed in cmake-conan or in this toolchain (maybe CMAKE_CXX_COMPILER_TARGET should be different in this case)?

-- Using Xcode version: 12.0.1 -- CMake version: 3.23.1

Describe the bug

When i use -DPLATFORM=OS64COMBINED and generate Xcode project, it only create the project with BASE SDK equal iOS.

To Reproduce Steps to reproduce the behavior:

cmake -B build -GXcode -DCMAKE_TOOLCHAIN_FILE=cmake/ios.toolchain.cmake -DPLATFORM=OS64COMBINED

Expected behavior

Use BASE SDK iOS for arm64 and iOS Simulator for x86_64.

Environment

• What version of CMake did you run? 3.23.2

LOG:

-- Not setting any manual command-line buildflags, since Xcode is selected as generator. Modifying the Xcode build-settings directly instead.
-- Configuring iphoneos build for platform: OS64COMBINED, architecture(s): arm64;x86_64
-- Using SDK: /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS16.0.sdk
-- Using C compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-- Using CXX compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang++
-- Using libtool: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/libtool
-- Using install name tool: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/install_name_tool
-- Autoconf target triple: aarch64-x86_64-apple-ios9.0
-- Using minimum deployment version: 9.0 (SDK version: 16.0)
-- Merging integrated CMake 3.14+ iOS,tvOS,watchOS,macOS toolchain(s) with this toolchain!
-- Will combine built (static) artifacts into FAT lib...
-- Using Xcode version: 14.0
-- CMake version: 3.23.2
-- Using a data_ptr size of: 8
-- Bitcode: Disabled
-- ARC: Disabled
-- Hiding symbols: Enabled
-- The C compiler identification is AppleClang 14.0.0.14000029
-- The CXX compiler identification is AppleClang 14.0.0.14000029

Describe the bug Sets ENABLE_STRICT_TRY_COMPILE OFF default, will lead cmake generate incorrect native project for dynamic libraries.

To Reproduce Steps to reproduce the behavior:

1. https://github.com/axys1/axys/runs/8269974724?check_suite_focus=true

Expected behavior Generate native project correct when build dynamic library on iOS.

Environment

• What version of CMake did you run?
• Your faulty CMakeLists.txt here:

git clone https://github.com/kcat/openal-soft
cd openal-soft
cmake -B build -GXcode -DCMAKE_TOOLCHAIN_FILE=ios.cmake.toolchain -DPLATFORM=OS64
cmake --build build --target OpenAL
# will error with: ld: library not found for -latomic, because the openal-soft find non-exists library `libatomic` with this toolchain file

I have tweaked the CMakeLists.txt from the example in order to link to OpenCV. This seems to work for ios and mac. I can run the toy code on the simulator.

An issue though is that if I build with -DCMAKE_INSTALL_PREFIX=../mac-lib and -DPLATFORM=MAC_ARM64, then I cannot run the executable under ./mac-lib/Test.App/Contents/MacOS/TestApp. But I can run ./build/Release/Contents/MacOS/TestApp.

When I run from mac-lib I get:

Translated Report (Full Report Below)
-------------------------------------

Incident Identifier: 7BC035B9-D9BF-463A-821F-F89B8C4DFFEB
CrashReporter Key:   21F36FD2-7188-AE2F-1B85-FE079442FAD3
Hardware Model:      MacBookAir10,1
Process:             TestApp [49666]
Path:                /Users/USER/*/TestApp.app/Contents/MacOS/TestApp
Identifier:          leetal.com.helloworld
Version:             0.1 (0.1)
Code Type:           ARM-64 (Native)
Role:                Default
Parent Process:      launchd [1]
Coalition:           leetal.com.helloworld [32208]

Date/Time:           2022-08-21 22:11:01.1997 +0200
Launch Time:         2022-08-21 22:11:01.1853 +0200
OS Version:          macOS 12.5 (21G72)
Release Type:        User
Report Version:      104

Exception Type:  EXC_BAD_ACCESS (SIGKILL (Code Signature Invalid))
Exception Subtype: UNKNOWN_0x32 at 0x00000001049bc000
Exception Codes: 0x0000000000000032, 0x00000001049bc000
VM Region Info: 0x1049bc000 is in 0x1049bc000-0x1049c0000;  bytes after start: 0  bytes before end: 16383
      REGION TYPE                    START - END         [ VSIZE] PRT/MAX SHRMOD  REGION DETAIL
      UNUSED SPACE AT START
--->  mapped file                 1049bc000-1049c0000    [   16K] r-x/r-x SM=COW  ...t_id=ad270cb7
      mapped file                 1049c0000-1049c4000    [   16K] rw-/rw- SM=COW  ...t_id=ad270cb7
Exception Note:  EXC_CORPSE_NOTIFY
Termination Reason: CODESIGNING 2 

Highlighted by Thread:  0

Backtrace not available

The CMakeLists.txt is looking like this (I have added OpenCV on different places and the project name):

cmake_minimum_required (VERSION 3.2)
project (videoprocessing-ios)
enable_testing()

enable_language(CXX)
enable_language(OBJC)

MESSAGE( STATUS "CMAKE_CXX_FLAGS: " ${CMAKE_CXX_FLAGS} )
MESSAGE( STATUS "CMAKE_OBJC_FLAGS: " ${CMAKE_OBJC_FLAGS} )

# Add some sanitary checks that the toolchain is actually working!
include(CheckCXXSymbolExists)
check_cxx_symbol_exists(kqueue sys/event.h HAVE_KQUEUE)
if(NOT HAVE_KQUEUE)
  message(STATUS "kqueue NOT found!")
else()
  message(STATUS "kqueue found!")
endif()

find_library(APPKIT_LIBRARY AppKit)
if (NOT APPKIT_LIBRARY)
  message(STATUS "AppKit.framework NOT found!")
else()
  message(STATUS "AppKit.framework found! ${APPKIT_LIBRARY}")
endif()

find_library(FOUNDATION_LIBRARY Foundation)
if (NOT FOUNDATION_LIBRARY)
  message(STATUS "Foundation.framework NOT found!")
else()
  message(STATUS "Foundation.framework found! ${FOUNDATION_LIBRARY}")
endif()

find_library(UIKIT_LIBRARY UIKit)
if (NOT UIKIT_LIBRARY)
  message(STATUS "UIKit.framework NOT found!")
else()
  message(STATUS "UIKit.framework found! ${UIKIT_LIBRARY}")
endif()

# Hook up XCTest for the supported plaforms (all but WatchOS)
if(NOT PLATFORM MATCHES ".*WATCHOS.*")
  # Use the standard find_package, broken between 3.14.0 and 3.14.4 at least for XCtest...
  find_package(XCTest)
  # Fallback: Try to find XCtest as host package via toochain macro (should always work)
  find_host_package(XCTest REQUIRED)
endif()

# Includes
include_directories(${CMAKE_SOURCE_DIR}/include)

# Make sure try_compile() works
include(CheckTypeSize)
check_type_size(time_t SIZEOF_TIME_T)

#OpenCV
find_package( OpenCV REQUIRED PATHS "thirdparty/installdir/opencv_mac/lib/cmake/opencv4/" NO_DEFAULT_PATH)
include_directories( ${OpenCV_INCLUDE_DIRS} )

# Source files
set(SOURCES
  src/VideoProcessing.cpp
  src/VideoProcessingWrapperObjC.mm
)

# Headers
set(HEADERS
  include/VideoProcessing.hpp
  include/VideoProcessingWrapperObjC.h
)

# Library
if(BUILD_SHARED)
  add_library (videoprocessing SHARED ${SOURCES} ${HEADERS})
  target_link_libraries(videoprocessing ${FOUNDATION_LIBRARY} ${OpenCV_LIBS})
  target_compile_definitions(videoprocessing PUBLIC IS_BUILDING_SHARED)
  message(STATUS "Building shared version...")
else()
  add_library (videoprocessing STATIC ${SOURCES} ${HEADERS})
  target_link_libraries(videoprocessing ${FOUNDATION_LIBRARY} ${OpenCV_LIBS})
  message(STATUS "Building static version...")
endif()

if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
  set(CMAKE_INSTALL_PREFIX ${videoprocessing-ios_SOURCE_DIR}/../videoprocessing-app/videoprocessing-lib CACHE PATH "Install path" FORCE)
endif(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)

# Executable
if(PLATFORM MATCHES "MAC.*")
  set(APP_NAME TestApp)
  add_executable (${APP_NAME} MACOSX_BUNDLE src/main.cpp)
  set_target_properties(${APP_NAME} PROPERTIES
          BUNDLE True
          MACOSX_BUNDLE_GUI_IDENTIFIER leetal.com.helloworld
          MACOSX_BUNDLE_BUNDLE_NAME helloworld
          MACOSX_BUNDLE_BUNDLE_VERSION "0.1"
          MACOSX_BUNDLE_SHORT_VERSION_STRING "0.1"
          )
  # Link the library with the executable
  target_link_libraries(${APP_NAME} videoprocessing ${OpenCV_LIBS})
endif()

# Debug symbols set in XCode project
set_xcode_property(videoprocessing GCC_GENERATE_DEBUGGING_SYMBOLS YES "All")

# Installation
if(PLATFORM MATCHES "MAC.*")
  install(TARGETS ${APP_NAME}
          BUNDLE DESTINATION . COMPONENT Runtime
          RUNTIME DESTINATION bin COMPONENT Runtime
          LIBRARY DESTINATION lib
          ARCHIVE DESTINATION lib/static)

  # Note Mac specific extension .app
  set(APPS "\${CMAKE_INSTALL_PREFIX}/${APP_NAME}.app")

  # Directories to look for dependencies
  set(DIRS ${CMAKE_BINARY_DIR} ${OpenCV_INSTALL_PATH}/lib)

  install(CODE "include(BundleUtilities)
    fixup_bundle(\"${APPS}\" \"\" \"${DIRS}\")")

  set(CPACK_GENERATOR "DRAGNDROP")
  include(CPack)
else()
  install(TARGETS videoprocessing
          LIBRARY DESTINATION lib
          ARCHIVE DESTINATION lib/static)
endif()
install (FILES ${HEADERS} DESTINATION include)

The error says it is related to code signing, but why would that not apply to the executable in the build library?

Describe the bug The README file states the OS64COMBINED flag builds a fat lib including iphoneOS and iphoneOS Simulator, but in the toolchain file the statement is completely different.

To Reproduce

Expected behavior The documentation is correct

Environment

#    OS64COMBINED = Build for arm64 x86_64 iphoneOS. Combined into FAT STATIC lib (supported on 3.14+ of CMakewith "-G Xcode" argument ONLY)