averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
28f96e64ab8a78ca98e8c9615ec94780df5a4142
swift-mirror/stdlib/cmake/modules/AddSwiftStdlib.cmake
Alastair Houghton 28f96e64ab [Concurrency][Stdlib] Add SwiftStdlibCurrentOS availability, use it. 
If you use SwiftStdlibCurrentOS availability, you will be able to
use new types and functions from within the implementation. This
works by, when appropriate, building with the CurrentOS availability
set to the current deployment target.

rdar://150944675
2025-05-12 12:07:24 +01:00

3485 lines
137 KiB
CMake
Raw Blame History

include(AddSwift)
include(SwiftSource)
include(CompatibilityLibs)
function(add_dependencies_multiple_targets)
cmake_parse_arguments(
ADMT # prefix
"" # options
"" # single-value args
"TARGETS;DEPENDS" # multi-value args
${ARGN})
precondition(ADMT_UNPARSED_ARGUMENTS NEGATE MESSAGE "unrecognized arguments: ${ADMT_UNPARSED_ARGUMENTS}")
if(NOT "${ADMT_DEPENDS}" STREQUAL "")
foreach(target ${ADMT_TARGETS})
add_dependencies("${target}" ${ADMT_DEPENDS})
endforeach()
endif()
endfunction()
# Usage:
# _add_target_variant_c_compile_link_flags(
# SDK sdk
# ARCH arch
# BUILD_TYPE build_type
# ENABLE_LTO enable_lto
# ANALYZE_CODE_COVERAGE analyze_code_coverage
# RESULT_VAR_NAME result_var_name
# DEPLOYMENT_VERSION_OSX version # If provided, overrides the default value of the OSX deployment target set by the Swift project for this compilation only.
# DEPLOYMENT_VERSION_MACCATALYST version
# DEPLOYMENT_VERSION_IOS version
# DEPLOYMENT_VERSION_TVOS version
# DEPLOYMENT_VERSION_WATCHOS version
# DEPLOYMENT_VERSION_XROS version
#
# )
function(_add_target_variant_c_compile_link_flags)
set(oneValueArgs SDK ARCH BUILD_TYPE RESULT_VAR_NAME ENABLE_LTO ANALYZE_CODE_COVERAGE
DEPLOYMENT_VERSION_OSX DEPLOYMENT_VERSION_MACCATALYST DEPLOYMENT_VERSION_IOS DEPLOYMENT_VERSION_TVOS DEPLOYMENT_VERSION_WATCHOS
DEPLOYMENT_VERSION_XROS
MACCATALYST_BUILD_FLAVOR
)
cmake_parse_arguments(CFLAGS
""
"${oneValueArgs}"
""
${ARGN})
get_maccatalyst_build_flavor(maccatalyst_build_flavor
"${CFLAGS_SDK}" "${CFLAGS_MACCATALYST_BUILD_FLAVOR}")
set(result ${${CFLAGS_RESULT_VAR_NAME}})
if("${CFLAGS_SDK}" IN_LIST SWIFT_DARWIN_PLATFORMS)
# Check if there's a specific OS deployment version needed for this invocation
if("${CFLAGS_SDK}" STREQUAL "OSX")
if(DEFINED maccatalyst_build_flavor AND DEFINED CFLAGS_DEPLOYMENT_VERSION_MACCATALYST)
set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_MACCATALYST})
else()
set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_OSX})
endif()
elseif("${CFLAGS_SDK}" STREQUAL "IOS" OR "${CFLAGS_SDK}" STREQUAL "IOS_SIMULATOR")
set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_IOS})
elseif("${CFLAGS_SDK}" STREQUAL "TVOS" OR "${CFLAGS_SDK}" STREQUAL "TVOS_SIMULATOR")
set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_TVOS})
elseif("${CFLAGS_SDK}" STREQUAL "WATCHOS" OR "${CFLAGS_SDK}" STREQUAL "WATCHOS_SIMULATOR")
set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_WATCHOS})
elseif("${CFLAGS_SDK}" STREQUAL "XROS" OR "${CFLAGS_SDK}" STREQUAL "XROS_SIMULATOR")
set(DEPLOYMENT_VERSION ${CFLAGS_DEPLOYMENT_VERSION_XROS})
endif()
if("${DEPLOYMENT_VERSION}" STREQUAL "")
set(DEPLOYMENT_VERSION "${SWIFT_SDK_${CFLAGS_SDK}_DEPLOYMENT_VERSION}")
endif()
endif()
if("${CFLAGS_SDK}" STREQUAL "ANDROID")
set(DEPLOYMENT_VERSION ${SWIFT_ANDROID_API_LEVEL})
endif()
# MSVC, clang-cl, gcc don't understand -target.
if(CMAKE_C_COMPILER_ID MATCHES "^Clang|AppleClang$" AND
NOT SWIFT_COMPILER_IS_MSVC_LIKE)
get_target_triple(target target_variant "${CFLAGS_SDK}" "${CFLAGS_ARCH}"
MACCATALYST_BUILD_FLAVOR "${maccatalyst_build_flavor}"
DEPLOYMENT_VERSION "${DEPLOYMENT_VERSION}")
list(APPEND result "-target" "${target}")
if(target_variant)
# Check if the C compiler supports `-target-variant` flag
# TODO (etcwilde): This is a massive hack to deal with the fact that we
# are lying to cmake about what compiler is being used. Normally we could
# use `check_compiler_flag(C ...)` here. Unfortunately, that uses a
# different compiler since we swap out the C/CXX compiler part way through
# the build.
file(WRITE "${CMAKE_BINARY_DIR}/stdlib/empty" "")
execute_process(
COMMAND
"${CMAKE_C_COMPILER}"
-Wno-unused-command-line-argument
-target-variant x86_64-apple-ios14.5-macabi -x c -c - -o /dev/null
INPUT_FILE
"${CMAKE_BINARY_DIR}/stdlib/empty"
OUTPUT_QUIET ERROR_QUIET
RESULT_VARIABLE
SUPPORTS_TARGET_VARIANT)
if(NOT SUPPORTS_TARGET_VARIANT)
list(APPEND result "-target-variant" "${target_variant}")
else()
list(APPEND result "-darwin-target-variant" "${target_variant}")
endif()
endif()
endif()
set(_sysroot "${SWIFT_SDK_${CFLAGS_SDK}_ARCH_${CFLAGS_ARCH}_PATH}")
if(SWIFT_SDK_${CFLAGS_SDK}_USE_ISYSROOT)
list(APPEND result "-isysroot" "${_sysroot}")
elseif(NOT SWIFT_COMPILER_IS_MSVC_LIKE AND NOT "${_sysroot}" STREQUAL "/")
list(APPEND result "--sysroot=${_sysroot}")
endif()
if("${CFLAGS_SDK}" STREQUAL "LINUX_STATIC")
list(APPEND result "-isystem" "${SWIFT_MUSL_PATH}/${CFLAGS_ARCH}/usr/include/c++/v1")
list(APPEND result "-DSWIFT_LIBC_IS_MUSL")
endif()
if("${CFLAGS_SDK}" STREQUAL "ANDROID")
# Make sure the Android NDK lld is used.
swift_android_tools_path(${CFLAGS_ARCH} tools_path)
list(APPEND result "-B" "${tools_path}")
endif()
if("${CFLAGS_SDK}" IN_LIST SWIFT_DARWIN_PLATFORMS)
# We collate -F with the framework path to avoid unwanted deduplication
# of options by target_compile_options -- this way no undesired
# side effects are introduced should a new search path be added.
list(APPEND result
"-F${SWIFT_SDK_${CFLAGS_SDK}_PATH}/../../../Developer/Library/Frameworks")
endif()
if(CFLAGS_ANALYZE_CODE_COVERAGE)
list(APPEND result "-fprofile-instr-generate"
"-fcoverage-mapping")
endif()
# Use frame pointers on Linux
if("${CFLAGS_SDK}" STREQUAL "LINUX")
list(APPEND result "-fno-omit-frame-pointer")
endif()
_compute_lto_flag("${CFLAGS_ENABLE_LTO}" _lto_flag_out)
if (_lto_flag_out)
list(APPEND result "${_lto_flag_out}")
# Disable opaque pointers in lto mode.
#list(APPEND result "-Xclang")
#list(APPEND result "-no-opaque-pointers")
endif()
set("${CFLAGS_RESULT_VAR_NAME}" "${result}" PARENT_SCOPE)
endfunction()
function(_add_target_variant_c_compile_flags)
set(oneValueArgs SDK ARCH BUILD_TYPE ENABLE_ASSERTIONS ANALYZE_CODE_COVERAGE
DEPLOYMENT_VERSION_OSX DEPLOYMENT_VERSION_MACCATALYST DEPLOYMENT_VERSION_IOS DEPLOYMENT_VERSION_TVOS DEPLOYMENT_VERSION_WATCHOS
DEPLOYMENT_VERSION_XROS
RESULT_VAR_NAME ENABLE_LTO
MACCATALYST_BUILD_FLAVOR)
cmake_parse_arguments(CFLAGS
""
"${oneValueArgs}"
""
${ARGN})
set(result ${${CFLAGS_RESULT_VAR_NAME}})
list(APPEND result
"-DSWIFT_RUNTIME"
"-DSWIFT_LIB_SUBDIR=\"${SWIFT_SDK_${CFLAGS_SDK}_LIB_SUBDIR}\""
"-DSWIFT_ARCH=\"${CFLAGS_ARCH}\""
)
if ("${CFLAGS_ARCH}" STREQUAL "arm64" OR
"${CFLAGS_ARCH}" STREQUAL "arm64_32")
if (SWIFT_ENABLE_GLOBAL_ISEL_ARM64)
list(APPEND result "-fglobal-isel")
endif()
endif()
_add_target_variant_c_compile_link_flags(
SDK "${CFLAGS_SDK}"
ARCH "${CFLAGS_ARCH}"
BUILD_TYPE "${CFLAGS_BUILD_TYPE}"
ENABLE_ASSERTIONS "${CFLAGS_ENABLE_ASSERTIONS}"
ENABLE_LTO "${CFLAGS_ENABLE_LTO}"
ANALYZE_CODE_COVERAGE FALSE
DEPLOYMENT_VERSION_OSX "${CFLAGS_DEPLOYMENT_VERSION_OSX}"
DEPLOYMENT_VERSION_MACCATALYST "${CFLAGS_DEPLOYMENT_VERSION_MACCATALYST}"
DEPLOYMENT_VERSION_IOS "${CFLAGS_DEPLOYMENT_VERSION_IOS}"
DEPLOYMENT_VERSION_TVOS "${CFLAGS_DEPLOYMENT_VERSION_TVOS}"
DEPLOYMENT_VERSION_WATCHOS "${CFLAGS_DEPLOYMENT_VERSION_WATCHOS}"
DEPLOYMENT_VERSION_XROS "${CFLAGS_DEPLOYMENT_VERSION_XROS}"
RESULT_VAR_NAME result
MACCATALYST_BUILD_FLAVOR "${CFLAGS_MACCATALYST_BUILD_FLAVOR}")
is_build_type_optimized("${CFLAGS_BUILD_TYPE}" optimized)
if(optimized)
if("${CFLAGS_BUILD_TYPE}" STREQUAL "MinSizeRel")
list(APPEND result "-Os")
else()
list(APPEND result "-O2")
endif()
# Omit leaf frame pointers on x86 production builds (optimized, no debug
# info, and no asserts).
is_build_type_with_debuginfo("${CFLAGS_BUILD_TYPE}" debug)
if(NOT debug AND NOT CFLAGS_ENABLE_ASSERTIONS)
if("${CFLAGS_ARCH}" STREQUAL "i386" OR "${CFLAGS_ARCH}" STREQUAL "i686")
if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
list(APPEND result "-momit-leaf-frame-pointer")
else()
list(APPEND result "/Oy")
endif()
endif()
endif()
else()
if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
list(APPEND result "-O0")
else()
list(APPEND result "/Od")
endif()
endif()
# CMake automatically adds the flags for debug info if we use MSVC/clang-cl.
if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
is_build_type_with_debuginfo("${CFLAGS_BUILD_TYPE}" debuginfo)
if(debuginfo)
_compute_lto_flag("${CFLAGS_ENABLE_LTO}" _lto_flag_out)
if(_lto_flag_out)
list(APPEND result "-gline-tables-only")
else()
list(APPEND result "-g")
endif()
elseif("${CFLAGS_BUILD_TYPE}" STREQUAL "MinSizeRel")
# MinSizeRel builds of stdlib (but not the compiler) should get debug info
list(APPEND result "-g")
else()
list(APPEND result "-g0")
endif()
endif()
if("${CFLAGS_SDK}" STREQUAL "WINDOWS")
# MSVC/clang-cl don't support -fno-pic or -fms-compatibility-version.
if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
list(APPEND result -fno-pic)
list(APPEND result "-fms-compatibility-version=1900")
endif()
list(APPEND result "-DLLVM_ON_WIN32")
list(APPEND result "-D_CRT_SECURE_NO_WARNINGS")
list(APPEND result "-D_CRT_NONSTDC_NO_WARNINGS")
list(APPEND result "-D_CRT_USE_BUILTIN_OFFSETOF")
# TODO(compnerd) permit building for different families
list(APPEND result "-D_CRT_USE_WINAPI_FAMILY_DESKTOP_APP")
if("${CFLAGS_ARCH}" MATCHES arm)
list(APPEND result "-D_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE")
endif()
list(APPEND result "-D_MT")
# TODO(compnerd) handle /MT
list(APPEND result "-D_DLL")
# NOTE: We assume that we are using VS 2015 U2+
list(APPEND result "-D_ENABLE_ATOMIC_ALIGNMENT_FIX")
# NOTE: We use over-aligned values for the RefCount side-table
# (see revision d913eefcc93f8c80d6d1a6de4ea898a2838d8b6f)
# This is required to build with VS2017 15.8+
list(APPEND result "-D_ENABLE_EXTENDED_ALIGNED_STORAGE=1")
# msvcprt's std::function requires RTTI, but we do not want RTTI data.
# Emulate /GR-.
# TODO(compnerd) when moving up to VS 2017 15.3 and newer, we can disable
# RTTI again
if(SWIFT_COMPILER_IS_MSVC_LIKE)
list(APPEND result /GR-)
else()
list(APPEND result -frtti)
list(APPEND result -Xclang;-fno-rtti-data)
endif()
# NOTE: VS 2017 15.3 introduced this to disable the static components of
# RTTI as well. This requires a newer SDK though and we do not have
# guarantees on the SDK version currently.
list(APPEND result "-D_HAS_STATIC_RTTI=0")
# NOTE(compnerd) workaround LLVM invoking `add_definitions(-D_DEBUG)` which
# causes failures for the runtime library when cross-compiling due to
# undefined symbols from the standard library.
if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
list(APPEND result "-U_DEBUG")
endif()
endif()
# The concurrency library uses double-word atomics. MSVC's std::atomic
# uses a spin lock for this, so to get reasonable behavior we have to
# implement it ourselves using _InterlockedCompareExchange128.
# clang-cl requires us to enable the `cx16` feature to use this intrinsic.
if(CFLAGS_ARCH STREQUAL "x86_64")
if(SWIFT_COMPILER_IS_MSVC_LIKE)
list(APPEND result /clang:-mcx16)
else()
list(APPEND result -mcx16)
endif()
endif()
if(CFLAGS_ENABLE_ASSERTIONS)
list(APPEND result "-UNDEBUG")
else()
list(APPEND result "-DNDEBUG")
endif()
if(SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS)
list(APPEND result "-DSWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS")
endif()
if(CFLAGS_ANALYZE_CODE_COVERAGE)
list(APPEND result "-fprofile-instr-generate"
"-fcoverage-mapping")
endif()
# Use frame pointers on Linux
if("${CFLAGS_SDK}" STREQUAL "LINUX")
list(APPEND result "-fno-omit-frame-pointer")
endif()
if((CFLAGS_ARCH STREQUAL "armv7" OR CFLAGS_ARCH STREQUAL "aarch64") AND
(CFLAGS_SDK STREQUAL "LINUX" OR CFLAGS_SDK STREQUAL "ANDROID"))
list(APPEND result -funwind-tables)
endif()
if("${CFLAGS_SDK}" STREQUAL "LINUX")
if("${CFLAGS_ARCH}" STREQUAL "x86_64")
# this is the minimum architecture that supports 16 byte CAS, which is necessary to avoid a dependency to libatomic
list(APPEND result "-march=core2")
endif()
endif()
if("${CFLAGS_SDK}" STREQUAL "WASI")
list(APPEND result "-D_WASI_EMULATED_MMAN" "-D_WASI_EMULATED_PROCESS_CLOCKS" "-D_WASI_EMULATED_SIGNAL")
endif()
if(NOT SWIFT_STDLIB_ENABLE_OBJC_INTEROP)
list(APPEND result "-DSWIFT_OBJC_INTEROP=0")
endif()
if(SWIFT_STDLIB_COMPACT_ABSOLUTE_FUNCTION_POINTER)
list(APPEND result "-DSWIFT_COMPACT_ABSOLUTE_FUNCTION_POINTER=1")
endif()
if(SWIFT_STDLIB_STABLE_ABI)
list(APPEND result "-DSWIFT_LIBRARY_EVOLUTION=1")
else()
list(APPEND result "-DSWIFT_LIBRARY_EVOLUTION=0")
endif()
if(SWIFT_STDLIB_SUPPORT_BACK_DEPLOYMENT)
list(APPEND result "-DSWIFT_STDLIB_SUPPORT_BACK_DEPLOYMENT")
endif()
if(SWIFT_ENABLE_REFLECTION)
list(APPEND result "-DSWIFT_ENABLE_REFLECTION")
endif()
if(SWIFT_STDLIB_HAS_DLADDR)
list(APPEND result "-DSWIFT_STDLIB_HAS_DLADDR")
endif()
if(SWIFT_STDLIB_HAS_DLSYM)
list(APPEND result "-DSWIFT_STDLIB_HAS_DLSYM=1")
else()
list(APPEND result "-DSWIFT_STDLIB_HAS_DLSYM=0")
endif()
if(SWIFT_STDLIB_HAS_FILESYSTEM)
list(APPEND result "-DSWIFT_STDLIB_HAS_FILESYSTEM")
endif()
if(SWIFT_RUNTIME_STATIC_IMAGE_INSPECTION)
list(APPEND result "-DSWIFT_RUNTIME_STATIC_IMAGE_INSPECTION")
endif()
if(SWIFT_STDLIB_HAS_DARWIN_LIBMALLOC)
list(APPEND result "-DSWIFT_STDLIB_HAS_DARWIN_LIBMALLOC=1")
else()
list(APPEND result "-DSWIFT_STDLIB_HAS_DARWIN_LIBMALLOC=0")
endif()
if(SWIFT_STDLIB_HAS_ASL)
list(APPEND result "-DSWIFT_STDLIB_HAS_ASL")
endif()
if(SWIFT_STDLIB_HAS_STDIN)
list(APPEND result "-DSWIFT_STDLIB_HAS_STDIN")
endif()
if(SWIFT_STDLIB_HAS_ENVIRON)
list(APPEND result "-DSWIFT_STDLIB_HAS_ENVIRON")
endif()
if(SWIFT_STDLIB_HAS_LOCALE)
list(APPEND result "-DSWIFT_STDLIB_HAS_LOCALE")
endif()
if(SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY)
list(APPEND result "-DSWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY")
endif()
if(SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
list(APPEND result "-DSWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY")
endif()
if (SWIFT_CONCURRENCY_USES_DISPATCH)
list(APPEND result "-DSWIFT_CONCURRENCY_USES_DISPATCH")
endif()
string(TOUPPER "${SWIFT_SDK_${CFLAGS_SDK}_THREADING_PACKAGE}" _threading_package)
list(APPEND result "-DSWIFT_THREADING_${_threading_package}")
if(SWIFT_STDLIB_OS_VERSIONING)
list(APPEND result "-DSWIFT_RUNTIME_OS_VERSIONING")
endif()
if(SWIFT_STDLIB_PASSTHROUGH_METADATA_ALLOCATOR)
list(APPEND result "-DSWIFT_STDLIB_PASSTHROUGH_METADATA_ALLOCATOR")
endif()
if(SWIFT_STDLIB_SHORT_MANGLING_LOOKUPS)
list(APPEND result "-DSWIFT_STDLIB_SHORT_MANGLING_LOOKUPS")
endif()
if(SWIFT_STDLIB_ENABLE_VECTOR_TYPES)
list(APPEND result "-DSWIFT_STDLIB_ENABLE_VECTOR_TYPES")
endif()
if(SWIFT_STDLIB_HAS_TYPE_PRINTING)
list(APPEND result "-DSWIFT_STDLIB_HAS_TYPE_PRINTING")
endif()
if(SWIFT_STDLIB_SUPPORTS_BACKTRACE_REPORTING)
list(APPEND result "-DSWIFT_STDLIB_SUPPORTS_BACKTRACE_REPORTING")
endif()
if(SWIFT_STDLIB_ENABLE_UNICODE_DATA)
list(APPEND result "-DSWIFT_STDLIB_ENABLE_UNICODE_DATA")
endif()
if(SWIFT_STDLIB_TRACING)
list(APPEND result "-DSWIFT_STDLIB_TRACING")
endif()
if(SWIFT_STDLIB_CONCURRENCY_TRACING)
list(APPEND result "-DSWIFT_STDLIB_CONCURRENCY_TRACING")
endif()
if(SWIFT_STDLIB_USE_RELATIVE_PROTOCOL_WITNESS_TABLES)
list(APPEND result "-DSWIFT_STDLIB_USE_RELATIVE_PROTOCOL_WITNESS_TABLES")
endif()
if(SWIFT_STDLIB_USE_FRAGILE_RESILIENT_PROTOCOL_WITNESS_TABLES)
list(APPEND result "-DSWIFT_STDLIB_USE_FRAGILE_RESILIENT_PROTOCOL_WITNESS_TABLES")
endif()
if(SWIFT_STDLIB_OVERRIDABLE_RETAIN_RELEASE)
list(APPEND result "-DSWIFT_STDLIB_OVERRIDABLE_RETAIN_RELEASE")
endif()
if(SWIFT_USE_OS_TRACE_LAZY_INIT)
list(APPEND result "-DSWIFT_USE_OS_TRACE_LAZY_INIT")
endif()
list(APPEND result ${SWIFT_STDLIB_EXTRA_C_COMPILE_FLAGS})
set("${CFLAGS_RESULT_VAR_NAME}" "${result}" PARENT_SCOPE)
endfunction()
function(_add_target_variant_link_flags)
set(oneValueArgs SDK ARCH BUILD_TYPE ENABLE_ASSERTIONS ANALYZE_CODE_COVERAGE
DEPLOYMENT_VERSION_OSX DEPLOYMENT_VERSION_MACCATALYST DEPLOYMENT_VERSION_IOS DEPLOYMENT_VERSION_TVOS DEPLOYMENT_VERSION_WATCHOS
DEPLOYMENT_VERSION_XROS
RESULT_VAR_NAME ENABLE_LTO LTO_OBJECT_NAME LINK_LIBRARIES_VAR_NAME LIBRARY_SEARCH_DIRECTORIES_VAR_NAME
MACCATALYST_BUILD_FLAVOR
)
cmake_parse_arguments(LFLAGS
""
"${oneValueArgs}"
""
${ARGN})
precondition(LFLAGS_SDK MESSAGE "Should specify an SDK")
precondition(LFLAGS_ARCH MESSAGE "Should specify an architecture")
set(result ${${LFLAGS_RESULT_VAR_NAME}})
set(link_libraries ${${LFLAGS_LINK_LIBRARIES_VAR_NAME}})
set(library_search_directories ${${LFLAGS_LIBRARY_SEARCH_DIRECTORIES_VAR_NAME}})
_add_target_variant_c_compile_link_flags(
SDK "${LFLAGS_SDK}"
ARCH "${LFLAGS_ARCH}"
BUILD_TYPE "${LFLAGS_BUILD_TYPE}"
ENABLE_ASSERTIONS "${LFLAGS_ENABLE_ASSERTIONS}"
ENABLE_LTO "${LFLAGS_ENABLE_LTO}"
ANALYZE_CODE_COVERAGE "${LFLAGS_ANALYZE_CODE_COVERAGE}"
DEPLOYMENT_VERSION_OSX "${LFLAGS_DEPLOYMENT_VERSION_OSX}"
DEPLOYMENT_VERSION_MACCATALYST "${LFLAGS_DEPLOYMENT_VERSION_MACCATALYST}"
DEPLOYMENT_VERSION_IOS "${LFLAGS_DEPLOYMENT_VERSION_IOS}"
DEPLOYMENT_VERSION_TVOS "${LFLAGS_DEPLOYMENT_VERSION_TVOS}"
DEPLOYMENT_VERSION_WATCHOS "${LFLAGS_DEPLOYMENT_VERSION_WATCHOS}"
DEPLOYMENT_VERSION_XROS "${LFLAGS_DEPLOYMENT_VERSION_XROS}"
RESULT_VAR_NAME result
MACCATALYST_BUILD_FLAVOR "${LFLAGS_MACCATALYST_BUILD_FLAVOR}")
if("${LFLAGS_SDK}" STREQUAL "LINUX")
list(APPEND link_libraries "pthread" "dl")
if("${LFLAGS_ARCH}" MATCHES "armv5|armv6|armv7|i686")
list(APPEND link_libraries "atomic")
endif()
elseif("${LFLAGS_SDK}" STREQUAL "LINUX_STATIC")
list(APPEND link_libraries "pthread" "dl")
elseif("${LFLAGS_SDK}" STREQUAL "FREEBSD")
list(APPEND link_libraries "pthread")
elseif("${LFLAGS_SDK}" STREQUAL "OPENBSD")
list(APPEND link_libraries "pthread")
list(APPEND result "-Wl,-Bsymbolic")
elseif("${LFLAGS_SDK}" STREQUAL "CYGWIN")
# No extra libraries required.
elseif("${LFLAGS_SDK}" STREQUAL "WINDOWS")
# We don't need to add -nostdlib using MSVC or clang-cl, as MSVC and clang-cl rely on auto-linking entirely.
if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
# NOTE: we do not use "/MD" or "/MDd" and select the runtime via linker
# options. This causes conflicts.
list(APPEND result "-nostdlib")
endif()
if(NOT CMAKE_HOST_SYSTEM MATCHES Windows)
swift_windows_lib_for_arch(${LFLAGS_ARCH} ${LFLAGS_ARCH}_LIB)
list(APPEND library_search_directories ${${LFLAGS_ARCH}_LIB})
endif()
# NOTE(compnerd) workaround incorrectly extensioned import libraries from
# the Windows SDK on case sensitive file systems.
list(APPEND library_search_directories
${CMAKE_BINARY_DIR}/winsdk_lib_${LFLAGS_ARCH}_symlinks)
elseif("${LFLAGS_SDK}" STREQUAL "HAIKU")
list(APPEND link_libraries "bsd")
list(APPEND result "-Wl,-Bsymbolic")
elseif("${LFLAGS_SDK}" STREQUAL "ANDROID")
list(APPEND link_libraries "dl" "log")
# We need to add the math library, which is linked implicitly by libc++
list(APPEND result "-lm")
if(NOT CMAKE_HOST_SYSTEM MATCHES Windows AND NOT "${SWIFT_ANDROID_NDK_PATH}" STREQUAL "")
# The Android resource dir is specified from build.ps1 on windows.
if(EXISTS "${SWIFT_ANDROID_NDK_PATH}/source.properties")
file(READ "${SWIFT_ANDROID_NDK_PATH}/source.properties" NDK_VERSION)
if(NOT NDK_VERSION MATCHES "Pkg\\.Revision = ([0-9\\.]+)")
message(FATAL_ERROR "Could not find NDK version in source.properties: ${NDK_VERSION}")
endif()
if("${CMAKE_MATCH_1}" VERSION_GREATER_EQUAL "26")
file(GLOB RESOURCE_DIR ${SWIFT_SDK_ANDROID_ARCH_${LFLAGS_ARCH}_PATH}/../lib/clang/*)
else()
file(GLOB RESOURCE_DIR ${SWIFT_SDK_ANDROID_ARCH_${LFLAGS_ARCH}_PATH}/../lib64/clang/*)
endif()
list(APPEND result "-resource-dir=${RESOURCE_DIR}")
else()
message(FATAL_ERROR "Could not detect NDK version: ${SWIFT_ANDROID_NDK_PATH}/source.properties not found")
endif()
endif()
# link against the custom C++ library
swift_android_cxx_libraries_for_arch(${LFLAGS_ARCH} cxx_link_libraries)
list(APPEND link_libraries ${cxx_link_libraries})
else()
# If lto is enabled, we need to add the object path flag so that the LTO code
# generator leaves the intermediate object file in a place where it will not
# be touched. The reason why this must be done is that on OS X, debug info is
# left in object files. So if the object file is removed when we go to
# generate a dsym, the debug info is gone.
if (LFLAGS_ENABLE_LTO)
precondition(LFLAGS_LTO_OBJECT_NAME
MESSAGE "Should specify a unique name for the lto object")
set(lto_object_dir ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR})
set(lto_object ${lto_object_dir}/${LFLAGS_LTO_OBJECT_NAME}-lto.o)
list(APPEND result "-Wl,-object_path_lto,${lto_object}")
endif()
endif()
if(SWIFT_USE_LINKER AND NOT SWIFT_COMPILER_IS_MSVC_LIKE)
# The linker is normally chosen based on the host, but the Android NDK only
# uses lld now.
if("${LFLAGS_SDK}" STREQUAL "ANDROID")
set(linker "lld")
else()
set(linker "${SWIFT_USE_LINKER}")
endif()
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
list(APPEND result "-fuse-ld=${linker}.exe")
else()
list(APPEND result "-fuse-ld=${linker}")
endif()
endif()
# Enable build-ids on non-Windows non-Darwin platforms
if(SWIFT_SDK_${LFLAGS_SDK}_USE_BUILD_ID)
list(APPEND result "-Wl,--build-id=sha1")
endif()
# Enable dead stripping. Portions of this logic were copied from llvm's
# `add_link_opts` function (which, perhaps, should have been used here in the
# first place, but at this point it's hard to say whether that's feasible).
#
# TODO: Evaluate/enable -f{function,data}-sections --gc-sections for bfd,
# gold, and lld.
if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
# See rdar://48283130: This gives 6MB+ size reductions for swift and
# SourceKitService, and much larger size reductions for sil-opt etc.
list(APPEND result "-Wl,-dead_strip")
endif()
endif()
get_maccatalyst_build_flavor(maccatalyst_build_flavor
"${LFLAGS_SDK}" "${LFLAGS_MACCATALYST_BUILD_FLAVOR}")
set("${LFLAGS_RESULT_VAR_NAME}" "${result}" PARENT_SCOPE)
set("${LFLAGS_LINK_LIBRARIES_VAR_NAME}" "${link_libraries}" PARENT_SCOPE)
set("${LFLAGS_LIBRARY_SEARCH_DIRECTORIES_VAR_NAME}" "${library_search_directories}" PARENT_SCOPE)
endfunction()
# Add a universal binary target created from the output of the given
# set of targets by running 'lipo'.
#
# Usage:
# _add_swift_lipo_target(
# sdk # The name of the SDK the target was created for.
# # Examples include "OSX", "IOS", "ANDROID", etc.
# target # The name of the target to create
# output # The file to be created by this target
# source_targets... # The source targets whose outputs will be
# # lipo'd into the output.
# )
function(_add_swift_lipo_target)
cmake_parse_arguments(
LIPO # prefix
"CODESIGN" # options
"SDK;TARGET;OUTPUT" # single-value args
"" # multi-value args
${ARGN})
precondition(LIPO_SDK MESSAGE "sdk is required")
precondition(LIPO_TARGET MESSAGE "target is required")
precondition(LIPO_OUTPUT MESSAGE "output is required")
precondition(LIPO_UNPARSED_ARGUMENTS MESSAGE "one or more inputs are required")
set(source_targets ${LIPO_UNPARSED_ARGUMENTS})
# Gather the source binaries.
set(source_binaries)
foreach(source_target ${source_targets})
list(APPEND source_binaries $<TARGET_FILE:${source_target}>)
endforeach()
if("${SWIFT_SDK_${LIPO_SDK}_OBJECT_FORMAT}" STREQUAL "MACHO")
if(LIPO_CODESIGN)
set(codesign_command COMMAND "codesign" "-f" "-s" "-" "${LIPO_OUTPUT}")
endif()
set(lipo_lto_env)
# When lipo-ing LTO-based libraries with lipo on Darwin, the tool uses
# libLTO.dylib to inspect the bitcode files. However, by default the "host"
# libLTO.dylib is loaded, which might be too old and not understand the
# just-built bitcode format. Let's ask lipo to use the just-built
# libLTO.dylib from the toolchain that we're using to build.
if(APPLE AND SWIFT_NATIVE_CLANG_TOOLS_PATH)
set(lipo_lto_env "LIBLTO_PATH=${SWIFT_NATIVE_CLANG_TOOLS_PATH}/../lib/libLTO.dylib")
endif()
# Use lipo to create the final binary.
add_custom_command_target(unused_var
COMMAND "${CMAKE_COMMAND}" "-E" "env" ${lipo_lto_env} "${SWIFT_LIPO}" "-create" "-output" "${LIPO_OUTPUT}" ${source_binaries}
${codesign_command}
CUSTOM_TARGET_NAME "${LIPO_TARGET}"
OUTPUT "${LIPO_OUTPUT}"
DEPENDS ${source_targets})
else()
# We don't know how to create fat binaries for other platforms.
add_custom_command_target(unused_var
COMMAND "${CMAKE_COMMAND}" "-E" "copy" "${source_binaries}" "${LIPO_OUTPUT}"
CUSTOM_TARGET_NAME "${LIPO_TARGET}"
OUTPUT "${LIPO_OUTPUT}"
DEPENDS ${source_targets})
endif()
endfunction()
# Add a single variant of a new Swift library.
#
# Usage:
# add_swift_target_library_single(
# target
# name
# [MODULE_TARGETS]
# [SHARED]
# [STATIC]
# [SDK sdk]
# [ARCHITECTURE architecture]
# [DEPENDS dep1 ...]
# [LINK_LIBRARIES dep1 ...]
# [FRAMEWORK_DEPENDS dep1 ...]
# [FRAMEWORK_DEPENDS_WEAK dep1 ...]
# [C_COMPILE_FLAGS flag1...]
# [SWIFT_COMPILE_FLAGS flag1...]
# [LINK_FLAGS flag1...]
# [FILE_DEPENDS target1 ...]
# [DONT_EMBED_BITCODE]
# [IS_STDLIB]
# [IS_STDLIB_CORE]
# [ONLY_SWIFTMODULE]
# [NO_SWIFTMODULE]
# [IS_SDK_OVERLAY]
# [IS_FRAGILE]
# INSTALL_IN_COMPONENT comp
# MACCATALYST_BUILD_FLAVOR flavor
# source1 [source2 source3 ...])
#
# target
# Name of the target (e.g., swiftParse-IOS-armv7).
#
# name
# Name of the library (e.g., swiftParse).
#
# MODULE_TARGETS
# Names of the module target (e.g., swiftParse-swiftmodule-IOS-armv7).
#
# SHARED
# Build a shared library.
#
# STATIC
# Build a static library.
#
# SDK sdk
# SDK to build for.
#
# ARCHITECTURE
# Architecture to build for.
#
# DEPENDS
# Targets that this library depends on.
#
# LINK_LIBRARIES
# Libraries this library depends on.
#
# FRAMEWORK_DEPENDS
# System frameworks this library depends on.
#
# FRAMEWORK_DEPENDS_WEAK
# System frameworks this library depends on that should be weakly-linked.
#
# C_COMPILE_FLAGS
# Extra compile flags (C, C++, ObjC).
#
# SWIFT_COMPILE_FLAGS
# Extra compile flags (Swift).
#
# LINK_FLAGS
# Extra linker flags.
#
# FILE_DEPENDS
# Additional files this library depends on.
#
# DONT_EMBED_BITCODE
# Don't embed LLVM bitcode in this target, even if it is enabled globally.
#
# IS_STDLIB
# Install library dylib and swift module files to lib/swift.
#
# IS_STDLIB_CORE
# Compile as the standard library core.
#
# ONLY_SWIFTMODULE
# Do not build either static or shared, build just the .swiftmodule.
#
# NO_SWIFTMODULE
# Only build either static or shared, and skip the .swiftmodule.
#
# IS_SDK_OVERLAY
# Treat the library as a part of the Swift SDK overlay.
#
# INSTALL_IN_COMPONENT comp
# The Swift installation component that this library belongs to.
#
# MACCATALYST_BUILD_FLAVOR
# Possible values are 'ios-like', 'macos-like', 'zippered', 'unzippered-twin'
# IS_FRAGILE
# Disable library evolution even
# if this library is part of the SDK.
#
# source1 ...
# Sources to add into this library
function(add_swift_target_library_single target name)
set(SWIFTLIB_SINGLE_options
DONT_EMBED_BITCODE
IS_SDK_OVERLAY
IS_STDLIB
IS_STDLIB_CORE
NOSWIFTRT
OBJECT_LIBRARY
SHARED
STATIC
ONLY_SWIFTMODULE
NO_SWIFTMODULE
NO_LINK_NAME
INSTALL_WITH_SHARED
IS_FRAGILE)
set(SWIFTLIB_SINGLE_single_parameter_options
ARCHITECTURE
ARCHITECTURE_SUBDIR_NAME
DEPLOYMENT_VERSION_IOS
DEPLOYMENT_VERSION_OSX
DEPLOYMENT_VERSION_TVOS
DEPLOYMENT_VERSION_WATCHOS
DEPLOYMENT_VERSION_XROS
INSTALL_IN_COMPONENT
DARWIN_INSTALL_NAME_DIR
SDK
DEPLOYMENT_VERSION_MACCATALYST
MACCATALYST_BUILD_FLAVOR
BACK_DEPLOYMENT_LIBRARY
ENABLE_LTO
MODULE_DIR
BOOTSTRAPPING
INSTALL_BINARY_SWIFTMODULE)
set(SWIFTLIB_SINGLE_multiple_parameter_options
C_COMPILE_FLAGS
DEPENDS
FILE_DEPENDS
FRAMEWORK_DEPENDS
FRAMEWORK_DEPENDS_WEAK
GYB_SOURCES
INCORPORATE_OBJECT_LIBRARIES
INCORPORATE_OBJECT_LIBRARIES_SHARED_ONLY
LINK_FLAGS
LINK_LIBRARIES
PRIVATE_LINK_LIBRARIES
PREFIX_INCLUDE_DIRS
SWIFT_COMPILE_FLAGS
MODULE_TARGETS)
cmake_parse_arguments(SWIFTLIB_SINGLE
"${SWIFTLIB_SINGLE_options}"
"${SWIFTLIB_SINGLE_single_parameter_options}"
"${SWIFTLIB_SINGLE_multiple_parameter_options}"
${ARGN})
translate_flag(${SWIFTLIB_SINGLE_STATIC} "STATIC"
SWIFTLIB_SINGLE_STATIC_keyword)
translate_flag(${SWIFTLIB_SINGLE_NO_LINK_NAME} "NO_LINK_NAME"
SWIFTLIB_SINGLE_NO_LINK_NAME_keyword)
if(DEFINED SWIFTLIB_SINGLE_BOOTSTRAPPING)
set(BOOTSTRAPPING_arg "BOOTSTRAPPING" ${SWIFTLIB_SINGLE_BOOTSTRAPPING})
endif()
get_bootstrapping_path(out_bin_dir
${SWIFT_RUNTIME_OUTPUT_INTDIR} "${SWIFTLIB_SINGLE_BOOTSTRAPPING}")
get_bootstrapping_path(out_lib_dir
${SWIFT_LIBRARY_OUTPUT_INTDIR} "${SWIFTLIB_SINGLE_BOOTSTRAPPING}")
get_bootstrapping_path(lib_dir
${SWIFTLIB_DIR} "${SWIFTLIB_SINGLE_BOOTSTRAPPING}")
get_bootstrapping_path(static_lib_dir
${SWIFTSTATICLIB_DIR} "${SWIFTLIB_SINGLE_BOOTSTRAPPING}")
# Determine macCatalyst build flavor
get_maccatalyst_build_flavor(maccatalyst_build_flavor
"${SWIFTLIB_SINGLE_SDK}" "${SWIFTLIB_SINGLE_MACCATALYST_BUILD_FLAVOR}")
set(SWIFTLIB_SINGLE_SOURCES ${SWIFTLIB_SINGLE_UNPARSED_ARGUMENTS})
translate_flags(SWIFTLIB_SINGLE "${SWIFTLIB_SINGLE_options}")
# Check arguments.
precondition(SWIFTLIB_SINGLE_SDK MESSAGE "Should specify an SDK")
precondition(SWIFTLIB_SINGLE_ARCHITECTURE MESSAGE "Should specify an architecture")
precondition(SWIFTLIB_SINGLE_INSTALL_IN_COMPONENT MESSAGE "INSTALL_IN_COMPONENT is required")
if (NOT SWIFTLIB_SINGLE_ARCHITECTURE_SUBDIR_NAME)
set(SWIFTLIB_SINGLE_ARCHITECTURE_SUBDIR_NAME "${SWIFTLIB_SINGLE_ARCHITECTURE}")
endif()
if(NOT SWIFTLIB_SINGLE_SHARED AND
NOT SWIFTLIB_SINGLE_STATIC AND
NOT SWIFTLIB_SINGLE_OBJECT_LIBRARY AND
NOT SWIFTLIB_SINGLE_ONLY_SWIFTMODULE)
message(FATAL_ERROR
"Either SHARED, STATIC, or OBJECT_LIBRARY must be specified")
endif()
if(NOT DEFINED SWIFTLIB_INSTALL_BINARY_SWIFTMODULE)
set(SWIFTLIB_INSTALL_BINARY_SWIFTMODULE TRUE)
endif()
# Determine the subdirectory where this library will be installed.
set(SWIFTLIB_SINGLE_SUBDIR
"${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_LIB_SUBDIR}/${SWIFTLIB_SINGLE_ARCHITECTURE_SUBDIR_NAME}")
# macCatalyst ios-like builds are installed in the maccatalyst/x86_64 directory
if(maccatalyst_build_flavor STREQUAL "ios-like")
set(SWIFTLIB_SINGLE_SUBDIR
"${SWIFT_SDK_MACCATALYST_LIB_SUBDIR}/${SWIFTLIB_SINGLE_ARCHITECTURE_SUBDIR_NAME}")
endif()
if ("${SWIFTLIB_SINGLE_BOOTSTRAPPING}" STREQUAL "")
set(output_sub_dir ${SWIFTLIB_SINGLE_SUBDIR})
else()
# In the bootstrapping builds, we only have the single host architecture.
# So generated the library directly in the parent SDK specific directory
# (avoiding to lipo/copy the library).
set(output_sub_dir ${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_LIB_SUBDIR})
endif()
# Include LLVM Bitcode slices for iOS, Watch OS, and Apple TV OS device libraries.
set(embed_bitcode_arg)
if(SWIFT_EMBED_BITCODE_SECTION AND NOT SWIFTLIB_SINGLE_DONT_EMBED_BITCODE)
if("${SWIFTLIB_SINGLE_SDK}" STREQUAL "IOS" OR
"${SWIFTLIB_SINGLE_SDK}" STREQUAL "TVOS" OR
"${SWIFTLIB_SINGLE_SDK}" STREQUAL "XROS" OR
"${SWIFTLIB_SINGLE_SDK}" STREQUAL "WATCHOS")
list(APPEND SWIFTLIB_SINGLE_C_COMPILE_FLAGS "-fembed-bitcode")
set(embed_bitcode_arg EMBED_BITCODE)
endif()
endif()
# FIXME: swiftDarwin and swiftDifferentiationUnittest currently trip an assertion in SymbolGraphGen
if (SWIFTLIB_IS_STDLIB AND SWIFT_STDLIB_BUILD_SYMBOL_GRAPHS AND NOT ${name} STREQUAL "swiftDarwin"
AND NOT ${name} STREQUAL "swiftDifferentiationUnittest")
list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS "-Xfrontend;-emit-symbol-graph")
list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS
"-Xfrontend;-emit-symbol-graph-dir;-Xfrontend;${out_lib_dir}/symbol-graph/${VARIANT_NAME}")
list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS
"-Xfrontend;-symbol-graph-allow-availability-platforms;-Xfrontend;Swift")
endif()
if(MODULE)
set(libkind MODULE)
elseif(SWIFTLIB_SINGLE_OBJECT_LIBRARY)
set(libkind OBJECT)
# If both SHARED and STATIC are specified, we add the SHARED library first.
# The STATIC library is handled further below.
elseif(SWIFTLIB_SINGLE_SHARED)
set(libkind SHARED)
elseif(SWIFTLIB_SINGLE_STATIC)
set(libkind STATIC)
elseif(SWIFTLIB_SINGLE_ONLY_SWIFTMODULE)
set(libkind NONE)
else()
message(FATAL_ERROR
"Either SHARED, STATIC, or OBJECT_LIBRARY must be specified")
endif()
if(SWIFTLIB_SINGLE_GYB_SOURCES)
handle_gyb_sources(
gyb_dependency_targets
SWIFTLIB_SINGLE_GYB_SOURCES
ARCH "${SWIFTLIB_SINGLE_ARCHITECTURE}")
set(SWIFTLIB_SINGLE_SOURCES ${SWIFTLIB_SINGLE_SOURCES}
${SWIFTLIB_SINGLE_GYB_SOURCES})
endif()
# Remove the "swift" prefix from the name to determine the module name.
if(SWIFTLIB_SINGLE_IS_STDLIB_CORE)
set(module_name "Swift")
else()
string(REPLACE swift "" module_name "${name}")
endif()
if("${SWIFTLIB_SINGLE_SDK}" STREQUAL "WINDOWS")
if(NOT "${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
swift_windows_get_sdk_vfs_overlay(SWIFTLIB_SINGLE_VFS_OVERLAY)
list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS
-Xcc;-Xclang;-Xcc;-ivfsoverlay;-Xcc;-Xclang;-Xcc;${SWIFTLIB_SINGLE_VFS_OVERLAY})
endif()
list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS
-vfsoverlay;"${SWIFT_WINDOWS_VFS_OVERLAY}";-Xfrontend;-strict-implicit-module-context;-Xcc;-Xclang;-Xcc;-fbuiltin-headers-in-system-modules)
if(NOT CMAKE_HOST_SYSTEM MATCHES Windows)
swift_windows_include_for_arch(${SWIFTLIB_SINGLE_ARCHITECTURE} SWIFTLIB_INCLUDE)
foreach(directory ${SWIFTLIB_INCLUDE})
list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS -Xcc;-isystem;-Xcc;${directory})
endforeach()
endif()
if("${SWIFTLIB_SINGLE_ARCHITECTURE}" MATCHES arm)
list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS -Xcc;-D_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE)
endif()
list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS
-libc;${SWIFT_STDLIB_MSVC_RUNTIME_LIBRARY})
endif()
# Define availability macros.
foreach(def ${SWIFT_STDLIB_AVAILABILITY_DEFINITIONS})
list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS "-Xfrontend" "-define-availability" "-Xfrontend" "${def}")
if("${def}" MATCHES "SwiftStdlib .*")
# For each SwiftStdlib x.y, also define SwiftStdlibTargetOS x.y, which,
# will expand to the current `-target` platform if the macro defines a
# newer platform as its availability.
#
# There is a setting, SWIFT_STDLIB_ENABLE_STRICT_AVAILABILITY, which if set
# ON will cause us to use the "proper" availability instead.
string(REPLACE "SwiftStdlib" "SwiftStdlibCurrentOS" current "${def}")
if(NOT SWIFT_STDLIB_ENABLE_STRICT_AVAILABILITY AND SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_AVAILABILITY_NAME)
string(REGEX MATCH "${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_AVAILABILITY_NAME} ([0-9]+(\.[0-9]+)+)" platform_version "${def}")
string(REGEX MATCH "[0-9]+(\.[0-9]+)+" version "${platform_version}")
if(NOT version STREQUAL "9999" AND version VERSION_GREATER "${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_DEPLOYMENT_VERSION}")
string(REGEX REPLACE ":.*" ":${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_AVAILABILITY_NAME} ${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_DEPLOYMENT_VERSION}" current "${current}")
endif()
endif()
list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS "-Xfrontend" "-define-availability" "-Xfrontend" "${current}")
endif()
endforeach()
# Enable -target-min-inlining-version
list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS "-Xfrontend" "-target-min-inlining-version" "-Xfrontend" "min")
# Don't install the Swift module content for back-deployment libraries.
if (SWIFTLIB_SINGLE_BACK_DEPLOYMENT_LIBRARY)
set(install_in_component "never_install")
else()
set(install_in_component "${SWIFTLIB_SINGLE_INSTALL_IN_COMPONENT}")
endif()
# Use frame pointers on Linux
if ("${SWIFTLIB_SINGLE_SDK}" STREQUAL "LINUX")
list(APPEND SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS "-Xcc" "-fno-omit-frame-pointer")
endif()
# FIXME: don't actually depend on the libraries in SWIFTLIB_SINGLE_LINK_LIBRARIES,
# just any swiftmodule files that are associated with them.
handle_swift_sources(
swift_object_dependency_target
swift_module_dependency_target
swift_sib_dependency_target
swift_sibopt_dependency_target
swift_sibgen_dependency_target
SWIFTLIB_SINGLE_SOURCES
SWIFTLIB_SINGLE_EXTERNAL_SOURCES ${name}
DEPENDS
${gyb_dependency_targets}
${SWIFTLIB_SINGLE_DEPENDS}
${SWIFTLIB_SINGLE_FILE_DEPENDS}
${SWIFTLIB_SINGLE_LINK_LIBRARIES}
SDK ${SWIFTLIB_SINGLE_SDK}
ARCHITECTURE ${SWIFTLIB_SINGLE_ARCHITECTURE}
ARCHITECTURE_SUBDIR_NAME ${SWIFTLIB_SINGLE_ARCHITECTURE_SUBDIR_NAME}
MODULE_NAME ${module_name}
MODULE_DIR ${SWIFTLIB_SINGLE_MODULE_DIR}
COMPILE_FLAGS ${SWIFTLIB_SINGLE_SWIFT_COMPILE_FLAGS}
${SWIFTLIB_SINGLE_IS_STDLIB_keyword}
${SWIFTLIB_SINGLE_IS_STDLIB_CORE_keyword}
${SWIFTLIB_SINGLE_IS_SDK_OVERLAY_keyword}
${SWIFTLIB_SINGLE_IS_FRAGILE_keyword}
${SWIFTLIB_SINGLE_ONLY_SWIFTMODULE_keyword}
${SWIFTLIB_SINGLE_NO_SWIFTMODULE_keyword}
${embed_bitcode_arg}
${SWIFTLIB_SINGLE_STATIC_keyword}
${SWIFTLIB_SINGLE_NO_LINK_NAME_keyword}
ENABLE_LTO "${SWIFTLIB_SINGLE_ENABLE_LTO}"
INSTALL_IN_COMPONENT "${install_in_component}"
DEPLOYMENT_VERSION_OSX ${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_OSX}
DEPLOYMENT_VERSION_IOS ${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_IOS}
DEPLOYMENT_VERSION_TVOS ${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_TVOS}
DEPLOYMENT_VERSION_WATCHOS ${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_WATCHOS}
MACCATALYST_BUILD_FLAVOR "${SWIFTLIB_SINGLE_MACCATALYST_BUILD_FLAVOR}"
${BOOTSTRAPPING_arg}
INSTALL_BINARY_SWIFTMODULE ${SWIFTLIB_INSTALL_BINARY_SWIFTMODULE})
add_swift_source_group("${SWIFTLIB_SINGLE_EXTERNAL_SOURCES}")
# If there were any swift sources, then a .swiftmodule may have been created.
# If that is the case, then add a target which is an alias of the module files.
set(VARIANT_SUFFIX "-${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_LIB_SUBDIR}-${SWIFTLIB_SINGLE_ARCHITECTURE_SUBDIR_NAME}")
if(maccatalyst_build_flavor STREQUAL "ios-like")
set(VARIANT_SUFFIX "-${SWIFT_SDK_MACCATALYST_LIB_SUBDIR}-${SWIFTLIB_SINGLE_ARCHITECTURE_SUBDIR_NAME}")
endif()
if(NOT "${SWIFTLIB_SINGLE_MODULE_TARGETS}" STREQUAL "" AND NOT "${swift_module_dependency_target}" STREQUAL "")
foreach(module_target ${SWIFTLIB_SINGLE_MODULE_TARGETS})
add_custom_target("${module_target}"
DEPENDS ${swift_module_dependency_target})
set_target_properties("${module_target}" PROPERTIES
FOLDER "Swift libraries/Modules")
endforeach()
endif()
# For standalone overlay builds to work
if(NOT BUILD_STANDALONE AND "${SWIFTLIB_SINGLE_BOOTSTRAPPING}" STREQUAL "")
if (EXISTS swift_sib_dependency_target AND NOT "${swift_sib_dependency_target}" STREQUAL "")
add_dependencies(swift-stdlib${VARIANT_SUFFIX}-sib ${swift_sib_dependency_target})
endif()
if (EXISTS swift_sibopt_dependency_target AND NOT "${swift_sibopt_dependency_target}" STREQUAL "")
add_dependencies(swift-stdlib${VARIANT_SUFFIX}-sibopt ${swift_sibopt_dependency_target})
endif()
if (EXISTS swift_sibgen_dependency_target AND NOT "${swift_sibgen_dependency_target}" STREQUAL "")
add_dependencies(swift-stdlib${VARIANT_SUFFIX}-sibgen ${swift_sibgen_dependency_target})
endif()
endif()
# Only build the modules for any arch listed in the *_MODULE_ARCHITECTURES.
if(SWIFTLIB_SINGLE_SDK IN_LIST SWIFT_DARWIN_PLATFORMS
AND SWIFTLIB_SINGLE_ARCHITECTURE IN_LIST SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_MODULE_ARCHITECTURES)
# Create dummy target to hook up the module target dependency.
add_custom_target("${target}"
DEPENDS
"${swift_module_dependency_target}")
if(TARGET "${install_in_component}")
add_dependencies("${install_in_component}" "${target}")
endif()
return()
endif()
set(SWIFTLIB_INCORPORATED_OBJECT_LIBRARIES_EXPRESSIONS)
foreach(object_library ${SWIFTLIB_SINGLE_INCORPORATE_OBJECT_LIBRARIES})
list(APPEND SWIFTLIB_INCORPORATED_OBJECT_LIBRARIES_EXPRESSIONS
$<TARGET_OBJECTS:${object_library}${VARIANT_SUFFIX}>)
endforeach()
set(SWIFTLIB_INCORPORATED_OBJECT_LIBRARIES_EXPRESSIONS_SHARED_ONLY)
foreach(object_library ${SWIFTLIB_SINGLE_INCORPORATE_OBJECT_LIBRARIES_SHARED_ONLY})
list(APPEND SWIFTLIB_INCORPORATED_OBJECT_LIBRARIES_EXPRESSIONS_SHARED_ONLY
$<TARGET_OBJECTS:${object_library}${VARIANT_SUFFIX}>)
endforeach()
set(INCORPORATED_OBJECT_LIBRARIES_EXPRESSIONS ${SWIFTLIB_INCORPORATED_OBJECT_LIBRARIES_EXPRESSIONS})
if(libkind STREQUAL "SHARED")
list(APPEND INCORPORATED_OBJECT_LIBRARIES_EXPRESSIONS
${SWIFTLIB_INCORPORATED_OBJECT_LIBRARIES_EXPRESSIONS_SHARED_ONLY})
endif()
if (SWIFTLIB_SINGLE_ONLY_SWIFTMODULE)
add_custom_target("${target}"
DEPENDS "${swift_module_dependency_target}")
if(TARGET "${install_in_component}")
add_dependencies("${install_in_component}" "${target}")
endif()
return()
endif()
add_library("${target}" ${libkind}
${SWIFTLIB_SINGLE_SOURCES}
${SWIFTLIB_SINGLE_EXTERNAL_SOURCES}
${INCORPORATED_OBJECT_LIBRARIES_EXPRESSIONS})
if (NOT SWIFTLIB_SINGLE_OBJECT_LIBRARY AND TARGET "${install_in_component}")
add_dependencies("${install_in_component}" "${target}")
endif()
# NOTE: always inject the LLVMSupport directory before anything else. We want
# to ensure that the runtime is built with our local copy of LLVMSupport
target_include_directories(${target} BEFORE PRIVATE
${SWIFT_SOURCE_DIR}/stdlib/include)
target_include_directories(${target} BEFORE PRIVATE
${SWIFTLIB_SINGLE_PREFIX_INCLUDE_DIRS})
if(("${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_OBJECT_FORMAT}" STREQUAL "ELF" OR
"${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_OBJECT_FORMAT}" STREQUAL "COFF"))
if("${libkind}" STREQUAL "SHARED" AND NOT SWIFTLIB_SINGLE_NOSWIFTRT)
# TODO(compnerd) switch to the generator expression when cmake is upgraded
# to a version which supports it.
# target_sources(${target}
# PRIVATE
# $<TARGET_OBJECTS:swiftImageRegistrationObject${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_OBJECT_FORMAT}-${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_LIB_SUBDIR}-${SWIFTLIB_SINGLE_ARCHITECTURE}>)
if(SWIFTLIB_SINGLE_SDK STREQUAL "WINDOWS")
set(extension .obj)
else()
set(extension .o)
endif()
target_sources(${target}
PRIVATE
"${SWIFTLIB_DIR}/${SWIFTLIB_SINGLE_SUBDIR}/swiftrt${extension}")
set_source_files_properties("${SWIFTLIB_DIR}/${SWIFTLIB_SINGLE_SUBDIR}/swiftrt${extension}"
PROPERTIES
GENERATED 1)
endif()
endif()
_set_target_prefix_and_suffix("${target}" "${libkind}" "${SWIFTLIB_SINGLE_SDK}")
# Target libraries that include libDemangling must define the name to use for
# the inline namespace to distinguish symbols from those built for the
# compiler, in order to avoid possible ODR violations if both are statically
# linked into the same binary.
target_compile_definitions("${target}" PRIVATE
SWIFT_INLINE_NAMESPACE=__runtime)
if("${SWIFTLIB_SINGLE_SDK}" STREQUAL "WINDOWS")
if(NOT CMAKE_HOST_SYSTEM MATCHES Windows)
swift_windows_include_for_arch(${SWIFTLIB_SINGLE_ARCHITECTURE} SWIFTLIB_INCLUDE)
target_include_directories("${target}" SYSTEM PRIVATE
${SWIFTLIB_INCLUDE})
endif()
if(libkind STREQUAL STATIC)
set_property(TARGET "${target}" PROPERTY
PREFIX lib)
endif()
endif()
if("${SWIFTLIB_SINGLE_SDK}" STREQUAL "WINDOWS" AND NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "Windows")
if("${libkind}" STREQUAL "SHARED")
# Each dll has an associated .lib (import library); since we may be
# building on a non-DLL platform (not windows), create an imported target
# for the library which created implicitly by the dll.
add_custom_command_target(${target}_IMPORT_LIBRARY
OUTPUT "${SWIFTLIB_DIR}/${SWIFTLIB_SINGLE_SUBDIR}/${name}.lib"
DEPENDS "${target}")
add_library(${target}_IMPLIB SHARED IMPORTED GLOBAL)
set_property(TARGET "${target}_IMPLIB" PROPERTY
IMPORTED_LOCATION "${SWIFTLIB_DIR}/${SWIFTLIB_SINGLE_SUBDIR}/${name}.lib")
add_dependencies(${target}_IMPLIB ${${target}_IMPORT_LIBRARY})
endif()
set_property(TARGET "${target}" PROPERTY NO_SONAME ON)
endif()
llvm_update_compile_flags(${target})
set_output_directory(${target}
BINARY_DIR ${out_bin_dir} LIBRARY_DIR ${out_lib_dir})
if(MODULE)
set_target_properties("${target}" PROPERTIES
PREFIX ""
SUFFIX ${LLVM_PLUGIN_EXT})
endif()
# For back-deployed libraries, install into lib/swift-<version>.
if (SWIFTLIB_SINGLE_BACK_DEPLOYMENT_LIBRARY)
set(swiftlib_prefix "${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib/swift-${SWIFTLIB_SINGLE_BACK_DEPLOYMENT_LIBRARY}")
else()
set(swiftlib_prefix ${lib_dir})
endif()
# Install runtime libraries to lib/swift instead of lib. This works around
# the fact that -isysroot prevents linking to libraries in the system
# /usr/lib if Swift is installed in /usr.
set_target_properties("${target}" PROPERTIES
LIBRARY_OUTPUT_DIRECTORY ${swiftlib_prefix}/${output_sub_dir}
ARCHIVE_OUTPUT_DIRECTORY ${swiftlib_prefix}/${output_sub_dir})
if(SWIFTLIB_SINGLE_SDK STREQUAL "WINDOWS" AND SWIFTLIB_SINGLE_IS_STDLIB_CORE
AND libkind STREQUAL "SHARED")
add_custom_command(TARGET ${target} POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:${target}> ${swiftlib_prefix}/${output_sub_dir})
endif()
foreach(config ${CMAKE_CONFIGURATION_TYPES})
string(TOUPPER ${config} config_upper)
set_target_properties(${target} PROPERTIES
LIBRARY_OUTPUT_DIRECTORY_${config_upper} ${swiftlib_prefix}/${output_sub_dir}
ARCHIVE_OUTPUT_DIRECTORY_${config_upper} ${swiftlib_prefix}/${output_sub_dir})
endforeach()
if(SWIFTLIB_SINGLE_SDK IN_LIST SWIFT_DARWIN_PLATFORMS)
set(install_name_dir "@rpath")
if(SWIFTLIB_SINGLE_IS_STDLIB)
set(install_name_dir "${SWIFT_DARWIN_STDLIB_INSTALL_NAME_DIR}")
# iOS-like overlays are installed in a separate directory so that
# unzippered twins do not conflict.
if(maccatalyst_build_flavor STREQUAL "ios-like"
AND DEFINED SWIFT_DARWIN_MACCATALYST_STDLIB_INSTALL_NAME_DIR)
set(install_name_dir "${SWIFT_DARWIN_MACCATALYST_STDLIB_INSTALL_NAME_DIR}")
endif()
endif()
if(SWIFTLIB_SINGLE_DARWIN_INSTALL_NAME_DIR)
set(install_name_dir "${SWIFTLIB_SINGLE_DARWIN_INSTALL_NAME_DIR}")
endif()
set_target_properties("${target}"
PROPERTIES
INSTALL_NAME_DIR "${install_name_dir}")
elseif("${SWIFTLIB_SINGLE_SDK}" STREQUAL "LINUX")
set_target_properties("${target}"
PROPERTIES
INSTALL_RPATH "$ORIGIN")
elseif("${SWIFTLIB_SINGLE_SDK}" STREQUAL "CYGWIN")
set_target_properties("${target}"
PROPERTIES
INSTALL_RPATH "$ORIGIN:/usr/lib/swift/cygwin")
elseif("${SWIFTLIB_SINGLE_SDK}" STREQUAL "ANDROID")
# CMake generates an incorrect rule `$SONAME_FLAG $INSTALLNAME_DIR$SONAME`
# for an Android cross-build from a macOS host. Construct the proper linker
# flags manually in add_swift_target_library instead, see there with
# variable `swiftlib_link_flags_all`.
set_target_properties("${target}" PROPERTIES NO_SONAME TRUE)
# Only set the install RPATH if the toolchain and stdlib will be in Termux
# or some other native sysroot on Android.
if(NOT "${SWIFT_ANDROID_NATIVE_SYSROOT}" STREQUAL "")
set_target_properties("${target}"
PROPERTIES
INSTALL_RPATH "$ORIGIN")
endif()
set_target_properties(${target} PROPERTIES
POSITION_INDEPENDENT_CODE YES)
elseif("${SWIFTLIB_SINGLE_SDK}" STREQUAL "OPENBSD")
set_target_properties("${target}"
PROPERTIES
INSTALL_RPATH "$ORIGIN")
elseif("${SWIFTLIB_SINGLE_SDK}" STREQUAL "FREEBSD")
set_target_properties("${target}"
PROPERTIES
INSTALL_RPATH "$ORIGIN")
endif()
set_target_properties("${target}" PROPERTIES BUILD_WITH_INSTALL_RPATH YES)
set_target_properties("${target}" PROPERTIES FOLDER "Swift libraries")
# Configure the static library target.
# Set compile and link flags for the non-static target.
# Do these LAST.
set(target_static)
if(SWIFTLIB_SINGLE_IS_STDLIB AND SWIFTLIB_SINGLE_STATIC)
set(target_static "${target}-static")
if (SWIFTLIB_SINGLE_INSTALL_WITH_SHARED)
# Create an interface library for the static version, and explicitly
# add the output path for the non-static version to its libraries.
add_library(${target_static} INTERFACE)
add_dependencies(${target_static} ${target})
target_link_libraries(${target_static} INTERFACE $<TARGET_FILE:${target}>)
else()
# We have already compiled Swift sources. Link everything into a static
# library.
add_library(${target_static} STATIC
${SWIFTLIB_SINGLE_SOURCES}
${SWIFTLIB_INCORPORATED_OBJECT_LIBRARIES_EXPRESSIONS})
set_output_directory(${target_static}
BINARY_DIR ${out_bin_dir}
LIBRARY_DIR ${out_lib_dir})
if(SWIFTLIB_INSTALL_WITH_SHARED)
set(swift_lib_dir ${lib_dir})
else()
set(swift_lib_dir ${static_lib_dir})
endif()
foreach(config ${CMAKE_CONFIGURATION_TYPES})
string(TOUPPER ${config} config_upper)
set_target_properties(${target_static} PROPERTIES
LIBRARY_OUTPUT_DIRECTORY_${config_upper} ${swift_lib_dir}/${output_sub_dir}
ARCHIVE_OUTPUT_DIRECTORY_${config_upper} ${swift_lib_dir}/${output_sub_dir})
endforeach()
set_target_properties(${target_static} PROPERTIES
LIBRARY_OUTPUT_DIRECTORY ${swift_lib_dir}/${output_sub_dir}
ARCHIVE_OUTPUT_DIRECTORY ${swift_lib_dir}/${output_sub_dir})
endif()
endif()
set_target_properties(${target}
PROPERTIES
# Library name (without the variant information)
OUTPUT_NAME ${name})
if(target_static)
set_target_properties(${target_static}
PROPERTIES
OUTPUT_NAME ${name})
endif()
# Don't build standard libraries by default. We will enable building
# standard libraries that the user requested; the rest can be built on-demand.
foreach(t "${target}" ${target_static})
set_target_properties(${t} PROPERTIES EXCLUDE_FROM_ALL TRUE)
endforeach()
# Handle linking and dependencies.
add_dependencies_multiple_targets(
TARGETS "${target}" ${target_static}
DEPENDS
${SWIFTLIB_SINGLE_DEPENDS}
${gyb_dependency_targets}
"${swift_object_dependency_target}"
"${swift_module_dependency_target}"
${LLVM_COMMON_DEPENDS})
if("${libkind}" STREQUAL "SHARED")
target_link_libraries("${target}" PRIVATE ${SWIFTLIB_SINGLE_LINK_LIBRARIES})
elseif("${libkind}" STREQUAL "OBJECT")
precondition_list_empty(
"${SWIFTLIB_SINGLE_LINK_LIBRARIES}"
"OBJECT_LIBRARY may not link to anything")
else()
target_link_libraries("${target}" INTERFACE ${SWIFTLIB_SINGLE_LINK_LIBRARIES})
endif()
if(target_static)
set(target_static_depends)
foreach(dep ${SWIFTLIB_SINGLE_LINK_LIBRARIES})
if (NOT "${dep}" MATCHES "^(icucore|dispatch|BlocksRuntime)($|-.*)$")
list(APPEND target_static_depends "${dep}-static")
endif()
endforeach()
# FIXME: should this be target_link_libraries?
add_dependencies_multiple_targets(
TARGETS "${target_static}"
DEPENDS ${target_static_depends})
endif()
# Link against system frameworks.
foreach(FRAMEWORK ${SWIFTLIB_SINGLE_FRAMEWORK_DEPENDS})
foreach(t "${target}" ${target_static})
target_link_libraries("${t}" PUBLIC "-framework ${FRAMEWORK}")
endforeach()
endforeach()
foreach(FRAMEWORK ${SWIFTLIB_SINGLE_FRAMEWORK_DEPENDS_WEAK})
foreach(t "${target}" ${target_static})
target_link_libraries("${t}" PUBLIC "-weak_framework ${FRAMEWORK}")
endforeach()
endforeach()
# Collect compile and link flags for the static and non-static targets.
# Don't set PROPERTY COMPILE_FLAGS or LINK_FLAGS directly.
set(c_compile_flags
${SWIFTLIB_SINGLE_C_COMPILE_FLAGS} "-DSWIFT_TARGET_LIBRARY_NAME=${name}")
set(link_flags ${SWIFTLIB_SINGLE_LINK_FLAGS})
set(library_search_subdir "${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_LIB_SUBDIR}")
set(library_search_directories
"${lib_dir}/${output_sub_dir}"
"${SWIFT_NATIVE_SWIFT_TOOLS_PATH}/../lib/swift/${SWIFTLIB_SINGLE_SUBDIR}"
"${SWIFT_NATIVE_SWIFT_TOOLS_PATH}/../lib/swift/${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_LIB_SUBDIR}")
# In certain cases when building, the environment variable SDKROOT is set to override
# where the sdk root is located in the system. If that environment variable has been
# set by the user, respect it and add the specified SDKROOT directory to the
# library_search_directories so we are able to link against those libraries
if(DEFINED ENV{SDKROOT} AND EXISTS "$ENV{SDKROOT}/usr/lib/swift")
list(APPEND library_search_directories "$ENV{SDKROOT}/usr/lib/swift")
endif()
list(APPEND library_search_directories "${SWIFT_SDK_${sdk}_ARCH_${arch}_PATH}/usr/lib/swift")
# Add variant-specific flags.
set(build_type "${SWIFT_STDLIB_BUILD_TYPE}")
set(enable_assertions "${SWIFT_STDLIB_ASSERTIONS}")
set(lto_type "${SWIFT_STDLIB_ENABLE_LTO}")
_add_target_variant_c_compile_flags(
SDK "${SWIFTLIB_SINGLE_SDK}"
ARCH "${SWIFTLIB_SINGLE_ARCHITECTURE}"
BUILD_TYPE "${build_type}"
ENABLE_ASSERTIONS "${enable_assertions}"
ANALYZE_CODE_COVERAGE "${analyze_code_coverage}"
ENABLE_LTO "${lto_type}"
DEPLOYMENT_VERSION_OSX "${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_OSX}"
DEPLOYMENT_VERSION_MACCATALYST "${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_MACCATALYST}"
DEPLOYMENT_VERSION_IOS "${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_IOS}"
DEPLOYMENT_VERSION_TVOS "${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_TVOS}"
DEPLOYMENT_VERSION_WATCHOS "${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_WATCHOS}"
DEPLOYMENT_VERSION_XROS "${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_XROS}"
RESULT_VAR_NAME c_compile_flags
MACCATALYST_BUILD_FLAVOR "${SWIFTLIB_SINGLE_MACCATALYST_BUILD_FLAVOR}"
)
if(SWIFTLIB_SINGLE_SDK STREQUAL "WINDOWS")
if(libkind STREQUAL "SHARED")
list(APPEND c_compile_flags -D_WINDLL)
endif()
endif()
_add_target_variant_link_flags(
SDK "${SWIFTLIB_SINGLE_SDK}"
ARCH "${SWIFTLIB_SINGLE_ARCHITECTURE}"
BUILD_TYPE "${build_type}"
ENABLE_ASSERTIONS "${enable_assertions}"
ANALYZE_CODE_COVERAGE "${analyze_code_coverage}"
ENABLE_LTO "${lto_type}"
LTO_OBJECT_NAME "${target}-${SWIFTLIB_SINGLE_SDK}-${SWIFTLIB_SINGLE_ARCHITECTURE}"
DEPLOYMENT_VERSION_OSX "${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_OSX}"
DEPLOYMENT_VERSION_MACCATALYST "${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_MACCATALYST}"
DEPLOYMENT_VERSION_IOS "${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_IOS}"
DEPLOYMENT_VERSION_TVOS "${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_TVOS}"
DEPLOYMENT_VERSION_WATCHOS "${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_WATCHOS}"
DEPLOYMENT_VERSION_XROS "${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_XROS}"
RESULT_VAR_NAME link_flags
LINK_LIBRARIES_VAR_NAME link_libraries
LIBRARY_SEARCH_DIRECTORIES_VAR_NAME library_search_directories
MACCATALYST_BUILD_FLAVOR "${SWIFTLIB_SINGLE_MACCATALYST_BUILD_FLAVOR}"
)
# Configure plist creation for OS X.
set(PLIST_INFO_PLIST "Info.plist" CACHE STRING "Plist name")
if("${SWIFTLIB_SINGLE_SDK}" IN_LIST SWIFT_DARWIN_PLATFORMS AND SWIFTLIB_SINGLE_IS_STDLIB)
set(PLIST_INFO_NAME ${name})
# Underscores aren't permitted in the bundle identifier.
string(REPLACE "_" "" PLIST_INFO_UTI "com.apple.dt.runtime.${name}")
set(PLIST_INFO_VERSION "${SWIFT_VERSION}")
if (SWIFT_COMPILER_VERSION)
set(PLIST_INFO_BUILD_VERSION
"${SWIFT_COMPILER_VERSION}")
endif()
set(PLIST_INFO_PLIST_OUT "${PLIST_INFO_PLIST}")
list(APPEND link_flags
"-Wl,-sectcreate,__TEXT,__info_plist,${CMAKE_CURRENT_BINARY_DIR}/${PLIST_INFO_PLIST_OUT}")
configure_file(
"${SWIFT_SOURCE_DIR}/stdlib/${PLIST_INFO_PLIST}.in"
"${PLIST_INFO_PLIST_OUT}"
@ONLY
NEWLINE_STYLE UNIX)
set_property(TARGET ${target} APPEND PROPERTY LINK_DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${PLIST_INFO_PLIST_OUT}")
# If Application Extensions are enabled, pass the linker flag marking
# the dylib as safe.
if (CXX_SUPPORTS_FAPPLICATION_EXTENSION AND (NOT DISABLE_APPLICATION_EXTENSION))
list(APPEND link_flags "-Wl,-application_extension")
endif()
set(PLIST_INFO_UTI)
set(PLIST_INFO_NAME)
set(PLIST_INFO_VERSION)
set(PLIST_INFO_BUILD_VERSION)
endif()
# Set compilation and link flags.
if(SWIFTLIB_SINGLE_SDK STREQUAL "WINDOWS")
if(NOT CMAKE_HOST_SYSTEM MATCHES Windows)
swift_windows_include_for_arch(${SWIFTLIB_SINGLE_ARCHITECTURE}
${SWIFTLIB_SINGLE_ARCHITECTURE}_INCLUDE)
target_include_directories(${target} SYSTEM PRIVATE
${${SWIFTLIB_SINGLE_ARCHITECTURE}_INCLUDE})
endif()
if(NOT CMAKE_C_COMPILER_ID STREQUAL "MSVC")
swift_windows_get_sdk_vfs_overlay(SWIFTLIB_SINGLE_VFS_OVERLAY)
target_compile_options(${target} PRIVATE
"SHELL:-Xclang -ivfsoverlay -Xclang ${SWIFTLIB_SINGLE_VFS_OVERLAY}")
# MSVC doesn't support -Xclang. We don't need to manually specify
# the dependent libraries as `cl` does so.
target_compile_options(${target} PRIVATE
"SHELL:-Xclang --dependent-lib=oldnames"
# TODO(compnerd) handle /MT, /MTd
"SHELL:-Xclang --dependent-lib=msvcrt$<$<CONFIG:Debug>:d>")
endif()
endif()
target_compile_options(${target} PRIVATE
${c_compile_flags})
target_link_options(${target} PRIVATE
${link_flags})
if(SWIFTLIB_SINGLE_SDK IN_LIST SWIFT_DARWIN_PLATFORMS)
target_link_options(${target} PRIVATE
"LINKER:-compatibility_version,1")
if(SWIFT_COMPILER_VERSION)
target_link_options(${target} PRIVATE
"LINKER:-current_version,${SWIFT_COMPILER_VERSION}")
endif()
# Include LLVM Bitcode slices for iOS, Watch OS, and Apple TV OS device libraries.
if(SWIFT_EMBED_BITCODE_SECTION AND NOT SWIFTLIB_SINGLE_DONT_EMBED_BITCODE)
if("${SWIFTLIB_SINGLE_SDK}" STREQUAL "IOS" OR
"${SWIFTLIB_SINGLE_SDK}" STREQUAL "TVOS" OR
"${SWIFTLIB_SINGLE_SDK}" STREQUAL "XROS" OR
"${SWIFTLIB_SINGLE_SDK}" STREQUAL "WATCHOS")
# Please note that using a generator expression to fit
# this in a single target_link_options does not work
# (at least in CMake 3.15 and 3.16),
# since that seems not to allow the LINKER: prefix to be
# evaluated (i.e. it will be added as-is to the linker parameters)
target_link_options(${target} PRIVATE
"LINKER:-bitcode_bundle"
"LINKER:-lto_library,${LLVM_LIBRARY_DIR}/libLTO.dylib")
if(SWIFT_EMBED_BITCODE_SECTION_HIDE_SYMBOLS)
target_link_options(${target} PRIVATE
"LINKER:-bitcode_hide_symbols")
endif()
endif()
endif()
# Silence warnings about global initializers. We already have clang
# emitting warnings about global initializers when it compiles the code.
list(APPEND swiftlib_link_flags_all "-Xlinker -no_warn_inits")
endif()
if(SWIFTLIB_SINGLE_SDK IN_LIST SWIFT_APPLE_PLATFORMS)
# In the past, we relied on unsetting globally
# CMAKE_OSX_ARCHITECTURES to ensure that CMake
# would not add the -arch flag. This is no longer
# the case when running on Apple Silicon, when
# CMake will enforce a default (see
# https://gitlab.kitware.com/cmake/cmake/-/merge_requests/5291)
set_property(TARGET ${target} PROPERTY OSX_ARCHITECTURES "${SWIFTLIB_SINGLE_ARCHITECTURE}")
if(TARGET "${target_static}")
set_property(TARGET ${target_static} PROPERTY OSX_ARCHITECTURES "${SWIFTLIB_SINGLE_ARCHITECTURE}")
endif()
endif()
target_link_libraries(${target} PRIVATE
${link_libraries})
target_link_directories(${target} PRIVATE
${library_search_directories})
# Adjust the linked libraries for windows targets. On Windows, the link is
# performed against the import library, and the runtime uses the dll. Not
# doing so will result in incorrect symbol resolution and linkage. We created
# import library targets when the library was added. Use that to adjust the
# link libraries.
if(SWIFTLIB_SINGLE_SDK STREQUAL "WINDOWS" AND NOT CMAKE_SYSTEM_NAME STREQUAL "Windows")
foreach(library_list LINK_LIBRARIES PRIVATE_LINK_LIBRARIES)
set(import_libraries)
foreach(library ${SWIFTLIB_SINGLE_${library_list}})
# Ensure that the library is a target. If an absolute path was given,
# then we do not have an import library associated with it. This occurs
# primarily with ICU (which will be an import library). Import
# libraries are only associated with shared libraries, so add an
# additional check for that as well.
set(import_library ${library})
if(TARGET ${library})
get_target_property(type ${library} TYPE)
if(type STREQUAL "SHARED_LIBRARY")
set(import_library ${library}_IMPLIB)
endif()
endif()
list(APPEND import_libraries ${import_library})
endforeach()
set(SWIFTLIB_SINGLE_${library_list} ${import_libraries})
endforeach()
endif()
if("${libkind}" STREQUAL "OBJECT")
precondition_list_empty(
"${SWIFTLIB_SINGLE_PRIVATE_LINK_LIBRARIES}"
"OBJECT_LIBRARY may not link to anything")
else()
target_link_libraries("${target}" PRIVATE
${SWIFTLIB_SINGLE_PRIVATE_LINK_LIBRARIES})
endif()
# NOTE(compnerd) use the C linker language to invoke `clang` rather than
# `clang++` as we explicitly link against the C++ runtime. We were previously
# actually passing `-nostdlib++` to avoid the C++ runtime linkage.
if("${SWIFTLIB_SINGLE_SDK}" STREQUAL "ANDROID")
set_property(TARGET "${target}" PROPERTY
LINKER_LANGUAGE "C")
else()
set_property(TARGET "${target}" PROPERTY
LINKER_LANGUAGE "CXX")
endif()
if(target_static AND NOT SWIFTLIB_SINGLE_INSTALL_WITH_SHARED)
target_compile_options(${target_static} PRIVATE
${c_compile_flags})
# FIXME: The fallback paths here are going to be dynamic libraries.
if(SWIFTLIB_INSTALL_WITH_SHARED)
set(search_base_dir ${lib_dir})
else()
set(search_base_dir ${static_lib_dir})
endif()
set(library_search_directories
"${search_base_dir}/${SWIFTLIB_SINGLE_SUBDIR}"
"${SWIFT_NATIVE_SWIFT_TOOLS_PATH}/../lib/swift/${SWIFTLIB_SINGLE_SUBDIR}"
"${SWIFT_NATIVE_SWIFT_TOOLS_PATH}/../lib/swift/${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_LIB_SUBDIR}")
target_link_directories(${target_static} PRIVATE
${library_search_directories})
_list_add_string_suffix(
"${SWIFTLIB_SINGLE_PRIVATE_LINK_LIBRARIES}"
"-static"
target_private_libs)
target_link_libraries("${target_static}" PRIVATE
${target_private_libs})
# Force executables linker language to be CXX so that we do not link using the
# host toolchain swiftc.
if("${SWIFTLIB_SINGLE_SDK}" STREQUAL "ANDROID")
set_property(TARGET "${target_static}" PROPERTY
LINKER_LANGUAGE "C")
else()
set_property(TARGET "${target_static}" PROPERTY
LINKER_LANGUAGE "CXX")
endif()
endif()
# Do not add code here.
endfunction()
# Add a new Swift target library.
#
# NOTE: This has not had the swift host code debrided from it yet. That will be
# in a forthcoming commit.
#
# Usage:
# add_swift_target_library(name
# [SHARED]
# [STATIC]
# [DEPENDS dep1 ...]
# [LINK_LIBRARIES dep1 ...]
# [SWIFT_MODULE_DEPENDS dep1 ...]
# [FRAMEWORK_DEPENDS dep1 ...]
# [FRAMEWORK_DEPENDS_WEAK dep1 ...]
# [FILE_DEPENDS target1 ...]
# [TARGET_SDKS sdk1...]
# [C_COMPILE_FLAGS flag1...]
# [SWIFT_COMPILE_FLAGS flag1...]
# [LINK_FLAGS flag1...]
# [DONT_EMBED_BITCODE]
# [INSTALL]
# [IS_STDLIB]
# [IS_STDLIB_CORE]
# [ONLY_SWIFTMODULE]
# [NO_SWIFTMODULE]
# [INSTALL_WITH_SHARED]
# INSTALL_IN_COMPONENT comp
# DEPLOYMENT_VERSION_OSX version
# DEPLOYMENT_VERSION_MACCATALYST version
# DEPLOYMENT_VERSION_IOS version
# DEPLOYMENT_VERSION_TVOS version
# DEPLOYMENT_VERSION_WATCHOS version
# DEPLOYMENT_VERSION_XROS version
# MACCATALYST_BUILD_FLAVOR flavor
# BACK_DEPLOYMENT_LIBRARY version
# source1 [source2 source3 ...])
#
# name
# Name of the library (e.g., swiftParse).
#
# SHARED
# Build a shared library.
#
# STATIC
# Build a static library.
#
# DEPENDS
# Targets that this library depends on.
#
# LINK_LIBRARIES
# Libraries this library depends on.
#
# SWIFT_MODULE_DEPENDS
# Swift modules this library depends on.
#
# SWIFT_MODULE_DEPENDS_OSX
# Swift modules this library depends on when built for OS X.
#
# SWIFT_MODULE_DEPENDS_MACCATALYST
# Zippered Swift modules this library depends on when built for macCatalyst.
# For example, Foundation.
#
# SWIFT_MODULE_DEPENDS_MACCATALYST_UNZIPPERED
# Unzippered Swift modules this library depends on when built for macCatalyst.
# For example, UIKit
#
# SWIFT_MODULE_DEPENDS_IOS
# Swift modules this library depends on when built for iOS.
#
# SWIFT_MODULE_DEPENDS_TVOS
# Swift modules this library depends on when built for tvOS.
#
# SWIFT_MODULE_DEPENDS_WATCHOS
# Swift modules this library depends on when built for watchOS.
#
# SWIFT_MODULE_DEPENDS_XROS
# Swift modules this library depends on when built for xrOS.
#
# SWIFT_MODULE_DEPENDS_FREESTANDING
# Swift modules this library depends on when built for Freestanding.
#
# SWIFT_MODULE_DEPENDS_FREEBSD
# Swift modules this library depends on when built for FreeBSD.
#
# SWIFT_MODULE_DEPENDS_OPENBSD
# Swift modules this library depends on when built for OpenBSD.
#
# SWIFT_MODULE_DEPENDS_LINUX
# Swift modules this library depends on when built for Linux.
#
# SWIFT_MODULE_DEPENDS_CYGWIN
# Swift modules this library depends on when built for Cygwin.
#
# SWIFT_MODULE_DEPENDS_HAIKU
# Swift modules this library depends on when built for Haiku.
#
# SWIFT_MODULE_DEPENDS_WASI
# Swift modules this library depends on when built for WASI.
#
# SWIFT_MODULE_DEPENDS_ANDROID
# Swift modules this library depends on when built for Android.
#
# FRAMEWORK_DEPENDS
# System frameworks this library depends on.
#
# FRAMEWORK_DEPENDS_WEAK
# System frameworks this library depends on that should be weak-linked
#
# FILE_DEPENDS
# Additional files this library depends on.
#
# TARGET_SDKS
# The set of SDKs in which this library is included. If empty, the library
# is included in all SDKs.
#
# C_COMPILE_FLAGS
# Extra compiler flags (C, C++, ObjC).
#
# SWIFT_COMPILE_FLAGS
# Extra compiler flags (Swift).
#
# LINK_FLAGS
# Extra linker flags.
#
# DONT_EMBED_BITCODE
# Don't embed LLVM bitcode in this target, even if it is enabled globally.
#
# IS_STDLIB
# Treat the library as a part of the Swift standard library.
#
# IS_STDLIB_CORE
# Compile as the Swift standard library core.
#
# ONLY_SWIFTMODULE
# Do not build either static or shared, build just the .swiftmodule.
#
# NO_SWIFTMODULE
# Only build either static or shared, and skip the .swiftmodule.
#
# IS_SDK_OVERLAY
# Treat the library as a part of the Swift SDK overlay.
#
# BACK_DEPLOYMENT_LIBRARY
# Treat this as a back-deployment library to the given Swift version
#
# INSTALL_IN_COMPONENT comp
# The Swift installation component that this library belongs to.
#
# DEPLOYMENT_VERSION_OSX
# The minimum deployment version to build for if this is an OSX library.
#
# DEPLOYMENT_VERSION_MACCATALYST
# The minimum deployment version to build for if this is an macCatalyst library.
#
# DEPLOYMENT_VERSION_IOS
# The minimum deployment version to build for if this is an iOS library.
#
# DEPLOYMENT_VERSION_TVOS
# The minimum deployment version to build for if this is an TVOS library.
#
# DEPLOYMENT_VERSION_WATCHOS
# The minimum deployment version to build for if this is an WATCHOS library.
#
# DEPLOYMENT_VERSION_XROS
# The minimum deployment version to build for if this is an XROS library.
#
# INSTALL_WITH_SHARED
# Install a static library target alongside shared libraries
#
# IMPORTS_NON_OSSA
# Imports a non-ossa module
#
# MACCATALYST_BUILD_FLAVOR
# Possible values are 'ios-like', 'macos-like', 'zippered', 'unzippered-twin'
# Presence of a build flavor requires SWIFT_MODULE_DEPENDS_MACCATALYST to be
# defined and have values.
#
# SWIFT_SOURCES_DEPENDS_MACOS
# Sources that are built when this library is being built for macOS
#
# SWIFT_SOURCES_DEPENDS_IOS
# Sources that are built when this library is being built for iOS
#
# SWIFT_SOURCES_DEPENDS_TVOS
# Sources that are built when this library is being built for tvOS
#
# SWIFT_SOURCES_DEPENDS_WATCHOS
# Sources that are built when this library is being built for watchOS
#
# SWIFT_SOURCES_DEPENDS_VISIONOS
# Sources that are built when this library is being built for visionOS
#
# SWIFT_SOURCES_DEPENDS_FREESTANDING
# Sources that are built when this library is being built for freestanding
#
# SWIFT_SOURCES_DEPENDS_FREEBSD
# Sources that are built when this library is being built for FreeBSD
#
# SWIFT_SOURCES_DEPENDS_OPENBSD
# Sources that are built when this library is being built for OpenBSD
#
# SWIFT_SOURCES_DEPENDS_LINUX
# Sources that are built when this library is being built for Linux
#
# SWIFT_SOURCES_DEPENDS_CYGWIN
# Sources that are built when this library is being built for Cygwin
#
# SWIFT_SOURCES_DEPENDS_HAIKU
# Sources that are built when this library is being built for Haiku
#
# SWIFT_SOURCES_DEPENDS_WASI
# Sources that are built when this library is being built for WASI
#
# SWIFT_SOURCES_DEPENDS_WINDOWS
# Sources that are built when this library is being built for Windows
#
# source1 ...
# Sources to add into this library.
function(add_swift_target_library name)
set(SWIFTLIB_options
DONT_EMBED_BITCODE
HAS_SWIFT_CONTENT
IS_SDK_OVERLAY
IS_STDLIB
IS_STDLIB_CORE
IS_SWIFT_ONLY
NOSWIFTRT
ONLY_SWIFTMODULE
NO_SWIFTMODULE
OBJECT_LIBRARY
SHARED
STATIC
NO_LINK_NAME
INSTALL_WITH_SHARED
IMPORTS_NON_OSSA)
set(SWIFTLIB_single_parameter_options
DEPLOYMENT_VERSION_IOS
DEPLOYMENT_VERSION_OSX
DEPLOYMENT_VERSION_TVOS
DEPLOYMENT_VERSION_WATCHOS
DEPLOYMENT_VERSION_XROS
INSTALL_IN_COMPONENT
INSTALL_BINARY_SWIFTMODULE
DARWIN_INSTALL_NAME_DIR
DEPLOYMENT_VERSION_MACCATALYST
MACCATALYST_BUILD_FLAVOR
BACK_DEPLOYMENT_LIBRARY)
set(SWIFTLIB_multiple_parameter_options
C_COMPILE_FLAGS
C_COMPILE_FLAGS_IOS
C_COMPILE_FLAGS_OSX
C_COMPILE_FLAGS_TVOS
C_COMPILE_FLAGS_WATCHOS
C_COMPILE_FLAGS_LINUX
C_COMPILE_FLAGS_WINDOWS
DEPENDS
FILE_DEPENDS
FRAMEWORK_DEPENDS
FRAMEWORK_DEPENDS_IOS_TVOS
FRAMEWORK_DEPENDS_OSX
FRAMEWORK_DEPENDS_WEAK
GYB_SOURCES
INCORPORATE_OBJECT_LIBRARIES
INCORPORATE_OBJECT_LIBRARIES_SHARED_ONLY
LINK_FLAGS
LINK_LIBRARIES
PREFIX_INCLUDE_DIRS
PRIVATE_LINK_LIBRARIES
SWIFT_COMPILE_FLAGS
SWIFT_COMPILE_FLAGS_IOS
SWIFT_COMPILE_FLAGS_OSX
SWIFT_COMPILE_FLAGS_TVOS
SWIFT_COMPILE_FLAGS_WATCHOS
SWIFT_COMPILE_FLAGS_XROS
SWIFT_COMPILE_FLAGS_LINUX
SWIFT_COMPILE_FLAGS_LINUX_STATIC
SWIFT_MODULE_DEPENDS
SWIFT_MODULE_DEPENDS_ANDROID
SWIFT_MODULE_DEPENDS_CYGWIN
SWIFT_MODULE_DEPENDS_FREEBSD
SWIFT_MODULE_DEPENDS_FREESTANDING
SWIFT_MODULE_DEPENDS_OPENBSD
SWIFT_MODULE_DEPENDS_HAIKU
SWIFT_MODULE_DEPENDS_IOS
SWIFT_MODULE_DEPENDS_LINUX
SWIFT_MODULE_DEPENDS_LINUX_STATIC
SWIFT_MODULE_DEPENDS_OSX
SWIFT_MODULE_DEPENDS_TVOS
SWIFT_MODULE_DEPENDS_WASI
SWIFT_MODULE_DEPENDS_WATCHOS
SWIFT_MODULE_DEPENDS_XROS
SWIFT_MODULE_DEPENDS_WINDOWS
SWIFT_MODULE_DEPENDS_FROM_SDK
TARGET_SDKS
SWIFT_COMPILE_FLAGS_MACCATALYST
SWIFT_MODULE_DEPENDS_MACCATALYST
SWIFT_MODULE_DEPENDS_MACCATALYST_UNZIPPERED
SWIFT_SOURCES_DEPENDS_MACOS
SWIFT_SOURCES_DEPENDS_IOS
SWIFT_SOURCES_DEPENDS_TVOS
SWIFT_SOURCES_DEPENDS_WATCHOS
SWIFT_SOURCES_DEPENDS_VISIONOS
SWIFT_SOURCES_DEPENDS_FREESTANDING
SWIFT_SOURCES_DEPENDS_FREEBSD
SWIFT_SOURCES_DEPENDS_OPENBSD
SWIFT_SOURCES_DEPENDS_LINUX
SWIFT_SOURCES_DEPENDS_LINUX_STATIC
SWIFT_SOURCES_DEPENDS_CYGWIN
SWIFT_SOURCES_DEPENDS_HAIKU
SWIFT_SOURCES_DEPENDS_WASI
SWIFT_SOURCES_DEPENDS_WINDOWS)
cmake_parse_arguments(SWIFTLIB
"${SWIFTLIB_options}"
"${SWIFTLIB_single_parameter_options}"
"${SWIFTLIB_multiple_parameter_options}"
${ARGN})
set(SWIFTLIB_SOURCES ${SWIFTLIB_UNPARSED_ARGUMENTS})
# Ensure it's impossible to build for macCatalyst without module dependencies
if(SWIFT_ENABLE_MACCATALYST AND SWIFTLIB_MACCATALYST_BUILD_FLAVOR)
if((NOT SWIFTLIB_MACCATALYST_BUILD_FLAVOR STREQUAL "zippered") OR
SWIFTLIB_SWIFT_MODULE_DEPENDS_OSX)
precondition(SWIFTLIB_SWIFT_MODULE_DEPENDS_MACCATALYST
MESSAGE "SWIFT_MODULE_DEPENDS_MACCATALYST is required when building for macCatalyst")
endif()
endif()
# Infer arguments.
if(SWIFTLIB_IS_SDK_OVERLAY)
set(SWIFTLIB_HAS_SWIFT_CONTENT TRUE)
set(SWIFTLIB_IS_STDLIB TRUE)
endif()
# Standard library is always a target library.
if(SWIFTLIB_IS_STDLIB)
set(SWIFTLIB_HAS_SWIFT_CONTENT TRUE)
endif()
# If target SDKs are not specified, build for all known SDKs.
if("${SWIFTLIB_TARGET_SDKS}" STREQUAL "")
set(SWIFTLIB_TARGET_SDKS ${SWIFT_SDKS})
endif()
list_replace(SWIFTLIB_TARGET_SDKS ALL_APPLE_PLATFORMS "${SWIFT_DARWIN_PLATFORMS}")
# Support adding a "NOT" on the front to mean all SDKs except the following
list(LENGTH SWIFTLIB_TARGET_SDKS number_of_target_sdks)
if(number_of_target_sdks GREATER_EQUAL "1")
list(GET SWIFTLIB_TARGET_SDKS 0 first_sdk)
if("${first_sdk}" STREQUAL "NOT")
list(REMOVE_AT SWIFTLIB_TARGET_SDKS 0)
list_subtract("${SWIFT_SDKS}" "${SWIFTLIB_TARGET_SDKS}"
"SWIFTLIB_TARGET_SDKS")
endif()
endif()
list_intersect(
"${SWIFTLIB_TARGET_SDKS}" "${SWIFT_SDKS}" SWIFTLIB_TARGET_SDKS)
# All Swift code depends on the standard library, except for the standard
# library itself.
if(SWIFTLIB_HAS_SWIFT_CONTENT AND NOT SWIFTLIB_IS_STDLIB_CORE)
list(APPEND SWIFTLIB_SWIFT_MODULE_DEPENDS Core)
# swiftSwiftOnoneSupport does not depend on itself, obviously.
if(NOT name STREQUAL "swiftSwiftOnoneSupport")
# All Swift code depends on the SwiftOnoneSupport in non-optimized mode,
# except for the standard library itself.
is_build_type_optimized("${SWIFT_STDLIB_BUILD_TYPE}" optimized)
if(NOT optimized)
list(APPEND SWIFTLIB_SWIFT_MODULE_DEPENDS SwiftOnoneSupport)
endif()
endif()
endif()
if((NOT "${SWIFT_BUILD_STDLIB}") AND
(NOT "${SWIFTLIB_SWIFT_MODULE_DEPENDS}" STREQUAL ""))
list(REMOVE_ITEM SWIFTLIB_SWIFT_MODULE_DEPENDS Core SwiftOnoneSupport)
endif()
translate_flags(SWIFTLIB "${SWIFTLIB_options}")
precondition(SWIFTLIB_INSTALL_IN_COMPONENT MESSAGE "INSTALL_IN_COMPONENT is required")
if(NOT SWIFTLIB_SHARED AND
NOT SWIFTLIB_STATIC AND
NOT SWIFTLIB_OBJECT_LIBRARY)
message(FATAL_ERROR
"Either SHARED, STATIC, or OBJECT_LIBRARY must be specified")
endif()
# In the standard library and overlays, warn about implicit overrides
# as a reminder to consider when inherited protocols need different
# behavior for their requirements.
if (SWIFTLIB_IS_STDLIB)
list(APPEND SWIFTLIB_SWIFT_COMPILE_FLAGS "-warn-implicit-overrides")
list(APPEND SWIFTLIB_SWIFT_COMPILE_FLAGS "-Xfrontend;-enable-lexical-lifetimes=false")
endif()
if (NOT SWIFTLIB_IMPORTS_NON_OSSA)
list(APPEND SWIFTLIB_SWIFT_COMPILE_FLAGS "-Xfrontend;-enable-ossa-modules")
endif()
if(NOT DEFINED SWIFTLIB_INSTALL_BINARY_SWIFTMODULE)
set(SWIFTLIB_INSTALL_BINARY_SWIFTMODULE TRUE)
endif()
if(NOT SWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER AND NOT BUILD_STANDALONE AND
NOT SWIFT_PREBUILT_CLANG AND NOT SWIFTLIB_IS_SWIFT_ONLY)
list(APPEND SWIFTLIB_DEPENDS clang)
endif()
# Turn off implicit import of _Concurrency when building libraries
list(APPEND SWIFTLIB_SWIFT_COMPILE_FLAGS "-Xfrontend;-disable-implicit-concurrency-module-import")
# Turn off implicit import of _StringProcessing when building libraries
list(APPEND SWIFTLIB_SWIFT_COMPILE_FLAGS "-Xfrontend;-disable-implicit-string-processing-module-import")
if(SWIFTLIB_IS_STDLIB AND SWIFT_STDLIB_ENABLE_PRESPECIALIZATION)
list(APPEND SWIFTLIB_SWIFT_COMPILE_FLAGS "-Xfrontend;-prespecialize-generic-metadata")
endif()
if(SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY)
list(APPEND SWIFTLIB_SWIFT_COMPILE_FLAGS "-Xfrontend;-concurrency-model=task-to-thread")
endif()
# If we are building this library for targets, loop through the various
# SDKs building the variants of this library.
list_intersect(
"${SWIFTLIB_TARGET_SDKS}" "${SWIFT_SDKS}" SWIFTLIB_TARGET_SDKS)
foreach(sdk ${SWIFTLIB_TARGET_SDKS})
if(NOT SWIFT_SDK_${sdk}_ARCHITECTURES)
# SWIFT_SDK_${sdk}_ARCHITECTURES is empty, so just continue
continue()
endif()
# Skip building library for macOS if macCatalyst support is not enabled and the
# library only builds for macOS when macCatalyst is enabled.
if(NOT SWIFT_ENABLE_MACCATALYST AND
sdk STREQUAL "OSX" AND
SWIFTLIB_MACCATALYST_BUILD_FLAVOR STREQUAL "ios-like")
message(STATUS "Skipping OSX SDK for module ${name}")
continue()
endif()
# Determine if/what macCatalyst build flavor we are
get_maccatalyst_build_flavor(maccatalyst_build_flavor
"${sdk}" "${SWIFTLIB_MACCATALYST_BUILD_FLAVOR}")
set(maccatalyst_build_flavors)
if(NOT DEFINED maccatalyst_build_flavor)
list(APPEND maccatalyst_build_flavors "none")
elseif(maccatalyst_build_flavor STREQUAL "unzippered-twin")
list(APPEND maccatalyst_build_flavors "macos-like" "ios-like")
else()
list(APPEND maccatalyst_build_flavors "${maccatalyst_build_flavor}")
endif()
# Loop over the build flavors for the this library. If it is an unzippered
# twin we'll build it twice: once for "macos-like" and once for "ios-like"
# flavors.
foreach(maccatalyst_build_flavor ${maccatalyst_build_flavors})
if(maccatalyst_build_flavor STREQUAL "none")
unset(maccatalyst_build_flavor)
endif()
set(THIN_INPUT_TARGETS)
# Collect architecture agnostic SDK module dependencies
set(swiftlib_module_depends_flattened ${SWIFTLIB_SWIFT_MODULE_DEPENDS})
if(sdk STREQUAL "OSX")
if(DEFINED maccatalyst_build_flavor AND NOT maccatalyst_build_flavor STREQUAL "macos-like")
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_MACCATALYST})
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_MACCATALYST_UNZIPPERED})
else()
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_OSX})
endif()
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_OSX})
elseif(sdk STREQUAL "IOS" OR sdk STREQUAL "IOS_SIMULATOR")
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_IOS})
elseif(sdk STREQUAL "TVOS" OR sdk STREQUAL "TVOS_SIMULATOR")
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_TVOS})
elseif(sdk STREQUAL "WATCHOS" OR sdk STREQUAL "WATCHOS_SIMULATOR")
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_WATCHOS})
elseif("${sdk}" STREQUAL "XROS" OR "${sdk}" STREQUAL "XROS_SIMULATOR")
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_XROS})
elseif(sdk STREQUAL "FREESTANDING")
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_FREESTANDING})
elseif(sdk STREQUAL "FREEBSD")
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_FREEBSD})
elseif(sdk STREQUAL "OPENBSD")
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_OPENBSD})
elseif(sdk STREQUAL "LINUX")
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_LINUX})
elseif(sdk STREQUAL "LINUX_STATIC")
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_LINUX_STATIC})
elseif(sdk STREQUAL "ANDROID")
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_ANDROID})
elseif(sdk STREQUAL "CYGWIN")
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_CYGWIN})
elseif(sdk STREQUAL "HAIKU")
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_HAIKU})
elseif(sdk STREQUAL "WASI")
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_WASI})
elseif(sdk STREQUAL "WINDOWS")
list(APPEND swiftlib_module_depends_flattened
${SWIFTLIB_SWIFT_MODULE_DEPENDS_WINDOWS})
endif()
# Collect architecture agnostic SDK framework dependencies
set(swiftlib_framework_depends_flattened ${SWIFTLIB_FRAMEWORK_DEPENDS})
if(sdk STREQUAL "OSX")
list(APPEND swiftlib_framework_depends_flattened
${SWIFTLIB_FRAMEWORK_DEPENDS_OSX})
elseif(sdk STREQUAL "IOS" OR sdk STREQUAL "IOS_SIMULATOR" OR
sdk STREQUAL "TVOS" OR sdk STREQUAL "TVOS_SIMULATOR")
list(APPEND swiftlib_framework_depends_flattened
${SWIFTLIB_FRAMEWORK_DEPENDS_IOS_TVOS})
endif()
# Collect architecture agnostic swift compiler flags
set(swiftlib_swift_compile_flags_all ${SWIFTLIB_SWIFT_COMPILE_FLAGS})
if(sdk STREQUAL "OSX")
list(APPEND swiftlib_swift_compile_flags_all
${SWIFTLIB_SWIFT_COMPILE_FLAGS_OSX})
elseif(sdk STREQUAL "IOS" OR sdk STREQUAL "IOS_SIMULATOR")
list(APPEND swiftlib_swift_compile_flags_all
${SWIFTLIB_SWIFT_COMPILE_FLAGS_IOS})
elseif(sdk STREQUAL "TVOS" OR sdk STREQUAL "TVOS_SIMULATOR")
list(APPEND swiftlib_swift_compile_flags_all
${SWIFTLIB_SWIFT_COMPILE_FLAGS_TVOS})
elseif(sdk STREQUAL "WATCHOS" OR sdk STREQUAL "WATCHOS_SIMULATOR")
list(APPEND swiftlib_swift_compile_flags_all
${SWIFTLIB_SWIFT_COMPILE_FLAGS_WATCHOS})
elseif("${sdk}" STREQUAL "XROS" OR "${sdk}" STREQUAL "XROS_SIMULATOR")
list(APPEND swiftlib_swift_compile_flags_all
${SWIFTLIB_SWIFT_COMPILE_FLAGS_XROS})
elseif(sdk STREQUAL "LINUX")
list(APPEND swiftlib_swift_compile_flags_all
${SWIFTLIB_SWIFT_COMPILE_FLAGS_LINUX})
elseif(sdk STREQUAL "LINUX_STATIC")
list(APPEND swiftlib_swift_compile_flags_all
${SWIFTLIB_SWIFT_COMPILE_FLAGS_LINUX_STATIC})
elseif(sdk STREQUAL "WINDOWS")
# FIXME: https://github.com/apple/swift/issues/44614
# static and shared are not mutually exclusive; however since we do a
# single build of the sources, this doesn't work for building both
# simultaneously. Effectively, only shared builds are supported on
# windows currently.
if(SWIFTLIB_SHARED)
list(APPEND swiftlib_swift_compile_flags_all -D_WINDLL)
if(SWIFTLIB_IS_STDLIB_CORE)
list(APPEND swiftlib_swift_compile_flags_all -DswiftCore_EXPORTS)
endif()
elseif(SWIFTLIB_STATIC)
list(APPEND swiftlib_swift_compile_flags_all -D_LIB)
endif()
endif()
# Collect architecture agnostic SDK linker flags
set(swiftlib_link_flags_all ${SWIFTLIB_LINK_FLAGS})
if(sdk STREQUAL "IOS_SIMULATOR" AND name STREQUAL "swiftMediaPlayer")
# message("DISABLING AUTOLINK FOR swiftMediaPlayer")
list(APPEND swiftlib_link_flags_all "-Xlinker" "-ignore_auto_link")
endif()
# Append SDK specific sources to the full list of sources
set(sources ${SWIFTLIB_SOURCES})
if(sdk STREQUAL "OSX")
list(APPEND sources ${SWIFTLIB_SWIFT_SOURCES_DEPENDS_MACOS})
elseif(sdk STREQUAL "IOS" OR sdk STREQUAL "IOS_SIMULATOR")
list(APPEND sources ${SWIFTLIB_SWIFT_SOURCES_DEPENDS_IOS})
elseif(sdk STREQUAL "TVOS" OR sdk STREQUAL "TVOS_SIMULATOR")
list(APPEND sources ${SWIFTLIB_SWIFT_SOURCES_DEPENDS_TVOS})
elseif(sdk STREQUAL "WATCHOS" OR sdk STREQUAL "WATCHOS_SIMULATOR")
list(APPEND sources ${SWIFTLIB_SWIFT_SOURCES_DEPENDS_WATCHOS})
elseif(sdk STREQUAL "XROS" OR sdk STREQUAL "XROS_SIMULATOR")
list(APPEND sources ${SWIFTLIB_SWIFT_SOURCES_DEPENDS_VISIONOS})
elseif(sdk STREQUAL "FREESTANDING")
list(APPEND sources ${SWIFTLIB_SWIFT_SOURCES_DEPENDS_FREESTANDING})
elseif(sdk STREQUAL "FREEBSD")
list(APPEND sources ${SWIFTLIB_SWIFT_SOURCES_DEPENDS_FREEBSD})
elseif(sdk STREQUAL "OPENBSD")
list(APPEND sources ${SWIFTLIB_SWIFT_SOURCES_DEPENDS_OPENBSD})
elseif(sdk STREQUAL "LINUX" OR sdk STREQUAL "ANDROID")
list(APPEND sources ${SWIFTLIB_SWIFT_SOURCES_DEPENDS_LINUX})
elseif(sdk STREQUAL "LINUX_STATIC")
list(APPEND sources ${SWIFTLIB_SWIFT_SOURCES_DEPENDS_LINUX_STATIC})
elseif(sdk STREQUAL "CYGWIN")
list(APPEND sources ${SWIFTLIB_SWIFT_SOURCES_DEPENDS_CYGWIN})
elseif(sdk STREQUAL "HAIKU")
list(APPEND sources ${SWIFTLIB_SWIFT_SOURCES_DEPENDS_HAIKU})
elseif(sdk STREQUAL "WASI")
list(APPEND sources ${SWIFTLIB_SWIFT_SOURCES_DEPENDS_WASI})
elseif(sdk STREQUAL "WINDOWS")
list(APPEND sources ${SWIFTLIB_SWIFT_SOURCES_DEPENDS_WINDOWS})
endif()
# We unconditionally removed "-z,defs" from CMAKE_SHARED_LINKER_FLAGS in
# swift_common_standalone_build_config_llvm within
# SwiftSharedCMakeConfig.cmake, where it was added by a call to
# HandleLLVMOptions.
#
# Rather than applying it to all targets and libraries, we here add it
# back to supported targets and libraries only. This is needed for ELF
# targets only; however, RemoteMirror needs to build with undefined
# symbols.
if(SWIFT_SDK_${sdk}_OBJECT_FORMAT STREQUAL "ELF" AND
NOT name STREQUAL "swiftRemoteMirror")
list(APPEND swiftlib_link_flags_all "-Wl,-z,defs")
endif()
# Setting back linker flags which are not supported when making Android build on macOS cross-compile host.
if(SWIFTLIB_SHARED AND sdk IN_LIST SWIFT_DARWIN_PLATFORMS)
list(APPEND swiftlib_link_flags_all "-dynamiclib -Wl,-headerpad_max_install_names")
endif()
set(sdk_supported_archs
${SWIFT_SDK_${sdk}_ARCHITECTURES}
${SWIFT_SDK_${sdk}_MODULE_ARCHITECTURES})
list(REMOVE_DUPLICATES sdk_supported_archs)
# For each architecture supported by this SDK
foreach(arch ${sdk_supported_archs})
# Configure variables for this subdirectory.
set(VARIANT_SUFFIX "-${SWIFT_SDK_${sdk}_LIB_SUBDIR}-${arch}")
set(VARIANT_NAME "${name}${VARIANT_SUFFIX}")
set(MODULE_VARIANT_SUFFIX "-swiftmodule${VARIANT_SUFFIX}")
set(MODULE_VARIANT_NAME "${name}${MODULE_VARIANT_SUFFIX}")
# Configure macCatalyst flavor variables
if(DEFINED maccatalyst_build_flavor)
set(maccatalyst_variant_suffix "-${SWIFT_SDK_MACCATALYST_LIB_SUBDIR}-${arch}")
set(maccatalyst_variant_name "${name}${maccatalyst_variant_suffix}")
set(maccatalyst_module_variant_suffix "-swiftmodule${maccatalyst_variant_suffix}")
set(maccatalyst_module_variant_name "${name}${maccatalyst_module_variant_suffix}")
endif()
# Map dependencies over to the appropriate variants.
set(swiftlib_link_libraries)
foreach(lib ${SWIFTLIB_LINK_LIBRARIES})
if(TARGET "${lib}${VARIANT_SUFFIX}")
list(APPEND swiftlib_link_libraries "${lib}${VARIANT_SUFFIX}")
else()
list(APPEND swiftlib_link_libraries "${lib}")
endif()
endforeach()
# Swift compiles depend on swift modules, while links depend on
# linked libraries. Find targets for both of these here.
set(swiftlib_module_dependency_targets)
set(swiftlib_private_link_libraries_targets)
if(NOT BUILD_STANDALONE)
foreach(mod ${swiftlib_module_depends_flattened})
if(DEFINED maccatalyst_build_flavor)
if(maccatalyst_build_flavor STREQUAL "zippered")
# Zippered libraries are dependent on both the macCatalyst and normal macOS
# modules of their dependencies (which themselves must be zippered).
list(APPEND swiftlib_module_dependency_targets
"swift${mod}${maccatalyst_module_variant_suffix}")
list(APPEND swiftlib_module_dependency_targets
"swift${mod}${MODULE_VARIANT_SUFFIX}")
# Zippered libraries link against their zippered library targets, which
# live (and are built in) the same location as normal macOS libraries.
list(APPEND swiftlib_private_link_libraries_targets
"swift${mod}${VARIANT_SUFFIX}")
elseif(maccatalyst_build_flavor STREQUAL "ios-like")
# iOS-like libraries depend on the macCatalyst modules of their dependencies
# regardless of whether the target is zippered or macCatalyst only.
list(APPEND swiftlib_module_dependency_targets
"swift${mod}${maccatalyst_module_variant_suffix}")
# iOS-like libraries can link against either iOS-like library targets
# or zippered targets.
if(mod IN_LIST SWIFTLIB_SWIFT_MODULE_DEPENDS_MACCATALYST_UNZIPPERED)
list(APPEND swiftlib_private_link_libraries_targets
"swift${mod}${maccatalyst_variant_suffix}")
else()
list(APPEND swiftlib_private_link_libraries_targets
"swift${mod}${VARIANT_SUFFIX}")
endif()
else()
list(APPEND swiftlib_module_dependency_targets
"swift${mod}${MODULE_VARIANT_SUFFIX}")
list(APPEND swiftlib_private_link_libraries_targets
"swift${mod}${VARIANT_SUFFIX}")
endif()
continue()
endif()
list(APPEND swiftlib_module_dependency_targets
"swift${mod}${MODULE_VARIANT_SUFFIX}")
list(APPEND swiftlib_private_link_libraries_targets
"swift${mod}${VARIANT_SUFFIX}")
endforeach()
endif()
foreach(lib ${SWIFTLIB_PRIVATE_LINK_LIBRARIES})
if(TARGET "${lib}${VARIANT_SUFFIX}")
list(APPEND swiftlib_private_link_libraries_targets
"${lib}${VARIANT_SUFFIX}")
else()
list(APPEND swiftlib_private_link_libraries_targets "${lib}")
endif()
endforeach()
# Add PrivateFrameworks, rdar://28466433
set(swiftlib_c_compile_flags_all ${SWIFTLIB_C_COMPILE_FLAGS})
set(swiftlib_link_flags_all ${SWIFTLIB_LINK_FLAGS})
# Collect architecture agnostic c compiler flags
if(sdk STREQUAL "OSX")
list(APPEND swiftlib_c_compile_flags_all
${SWIFTLIB_C_COMPILE_FLAGS_OSX})
elseif(sdk STREQUAL "IOS" OR sdk STREQUAL "IOS_SIMULATOR")
list(APPEND swiftlib_c_compile_flags_all
${SWIFTLIB_C_COMPILE_FLAGS_IOS})
elseif(sdk STREQUAL "TVOS" OR sdk STREQUAL "TVOS_SIMULATOR")
list(APPEND swiftlib_c_compile_flags_all
${SWIFTLIB_C_COMPILE_FLAGS_TVOS})
elseif(sdk STREQUAL "WATCHOS" OR sdk STREQUAL "WATCHOS_SIMULATOR")
list(APPEND swiftlib_c_compile_flags_all
${SWIFTLIB_C_COMPILE_FLAGS_WATCHOS})
elseif(sdk STREQUAL "LINUX")
list(APPEND swiftlib_c_compile_flags_all
${SWIFTLIB_C_COMPILE_FLAGS_LINUX})
elseif(sdk STREQUAL "WINDOWS")
list(APPEND swiftlib_c_compile_flags_all
${SWIFTLIB_C_COMPILE_FLAGS_WINDOWS})
endif()
# Add flags to prepend framework search paths for the parallel framework
# hierarchy rooted at /System/iOSSupport/...
# These paths must come before their normal counterparts so that when compiling
# macCatalyst-only or unzippered-twin overlays the macCatalyst version
# of a framework is found and not the Mac version.
if(maccatalyst_build_flavor STREQUAL "ios-like")
# The path to find iOS-only frameworks (such as UIKit) under macCatalyst.
set(ios_support_frameworks_path "${SWIFT_SDK_${sdk}_PATH}/System/iOSSupport/System/Library/Frameworks/")
list(APPEND swiftlib_swift_compile_flags_all "-Fsystem" "${ios_support_frameworks_path}")
list(APPEND swiftlib_c_compile_flags_all "-iframework" "${ios_support_frameworks_path}")
# We collate -F with the framework path to avoid unwanted deduplication
# of options by target_compile_options -- this way no undesired
# side effects are introduced should a new search path be added.
list(APPEND swiftlib_link_flags_all "-F${ios_support_frameworks_path}")
endif()
if(sdk IN_LIST SWIFT_DARWIN_PLATFORMS AND SWIFTLIB_IS_SDK_OVERLAY)
set(swiftlib_swift_compile_private_frameworks_flag "-Fsystem" "${SWIFT_SDK_${sdk}_ARCH_${arch}_PATH}/System/Library/PrivateFrameworks/")
foreach(tbd_lib ${SWIFTLIB_SWIFT_MODULE_DEPENDS_FROM_SDK})
list(APPEND swiftlib_link_flags_all "${SWIFT_SDK_${sdk}_ARCH_${arch}_PATH}/usr/lib/swift/libswift${tbd_lib}.tbd")
endforeach()
endif()
set(variant_name "${VARIANT_NAME}")
set(module_variant_names "${MODULE_VARIANT_NAME}")
if(maccatalyst_build_flavor STREQUAL "ios-like")
set(variant_name "${maccatalyst_variant_name}")
set(module_variant_names "${maccatalyst_module_variant_name}")
elseif(maccatalyst_build_flavor STREQUAL "zippered")
# Zippered libraries produce two modules: one for macCatalyst and one for macOS
# and so need two module targets.
list(APPEND module_variant_names "${maccatalyst_module_variant_name}")
endif()
# Setting back linker flags which are not supported when making Android build on macOS cross-compile host.
if(SWIFTLIB_SHARED AND sdk STREQUAL "ANDROID")
list(APPEND swiftlib_link_flags_all "-shared")
# TODO: Instead of `lib${name}.so` find variable or target property which already have this value.
list(APPEND swiftlib_link_flags_all "-Wl,-soname,lib${name}.so")
endif()
if (SWIFTLIB_BACK_DEPLOYMENT_LIBRARY)
set(back_deployment_library_option BACK_DEPLOYMENT_LIBRARY ${SWIFTLIB_BACK_DEPLOYMENT_LIBRARY})
else()
set(back_deployment_library_option)
endif()
# If the SDK is static only, always build static instead of dynamic
if(SWIFT_SDK_${sdk}_STATIC_ONLY AND SWIFTLIB_SHARED)
set(shared_keyword)
set(static_keyword STATIC)
else()
set(shared_keyword ${SWIFTLIB_SHARED_keyword})
set(static_keyword ${SWIFTLIB_STATIC_keyword})
endif()
# Add this library variant.
add_swift_target_library_single(
${variant_name}
${name}
${shared_keyword}
${static_keyword}
${SWIFTLIB_NO_LINK_NAME_keyword}
${SWIFTLIB_OBJECT_LIBRARY_keyword}
${SWIFTLIB_INSTALL_WITH_SHARED_keyword}
${sources}
MODULE_TARGETS ${module_variant_names}
SDK ${sdk}
ARCHITECTURE ${arch}
DEPENDS ${SWIFTLIB_DEPENDS}
LINK_LIBRARIES ${swiftlib_link_libraries}
FRAMEWORK_DEPENDS ${swiftlib_framework_depends_flattened}
FRAMEWORK_DEPENDS_WEAK ${SWIFTLIB_FRAMEWORK_DEPENDS_WEAK}
FILE_DEPENDS ${SWIFTLIB_FILE_DEPENDS} ${swiftlib_module_dependency_targets}
C_COMPILE_FLAGS ${swiftlib_c_compile_flags_all}
SWIFT_COMPILE_FLAGS ${swiftlib_swift_compile_flags_all} ${swiftlib_swift_compile_flags_arch} ${swiftlib_swift_compile_private_frameworks_flag}
LINK_FLAGS ${swiftlib_link_flags_all}
PRIVATE_LINK_LIBRARIES ${swiftlib_private_link_libraries_targets}
INCORPORATE_OBJECT_LIBRARIES ${SWIFTLIB_INCORPORATE_OBJECT_LIBRARIES}
INCORPORATE_OBJECT_LIBRARIES_SHARED_ONLY ${SWIFTLIB_INCORPORATE_OBJECT_LIBRARIES_SHARED_ONLY}
${SWIFTLIB_DONT_EMBED_BITCODE_keyword}
${SWIFTLIB_IS_STDLIB_keyword}
${SWIFTLIB_IS_STDLIB_CORE_keyword}
${SWIFTLIB_IS_SDK_OVERLAY_keyword}
${SWIFTLIB_NOSWIFTRT_keyword}
${SWIFTLIB_ONLY_SWIFTMODULE_keyword}
${SWIFTLIB_NO_SWIFTMODULE_keyword}
DARWIN_INSTALL_NAME_DIR "${SWIFTLIB_DARWIN_INSTALL_NAME_DIR}"
INSTALL_IN_COMPONENT "${SWIFTLIB_INSTALL_IN_COMPONENT}"
DEPLOYMENT_VERSION_OSX "${SWIFTLIB_DEPLOYMENT_VERSION_OSX}"
DEPLOYMENT_VERSION_MACCATALYST "${SWIFTLIB_DEPLOYMENT_VERSION_MACCATALYST}"
DEPLOYMENT_VERSION_IOS "${SWIFTLIB_DEPLOYMENT_VERSION_IOS}"
DEPLOYMENT_VERSION_TVOS "${SWIFTLIB_DEPLOYMENT_VERSION_TVOS}"
DEPLOYMENT_VERSION_WATCHOS "${SWIFTLIB_DEPLOYMENT_VERSION_WATCHOS}"
DEPLOYMENT_VERSION_XROS "${SWIFTLIB_DEPLOYMENT_VERSION_XROS}"
MACCATALYST_BUILD_FLAVOR "${maccatalyst_build_flavor}"
${back_deployment_library_option}
ENABLE_LTO "${SWIFT_STDLIB_ENABLE_LTO}"
GYB_SOURCES ${SWIFTLIB_GYB_SOURCES}
PREFIX_INCLUDE_DIRS ${SWIFTLIB_PREFIX_INCLUDE_DIRS}
INSTALL_BINARY_SWIFTMODULE ${SWIFTLIB_INSTALL_BINARY_SWIFTMODULE}
)
if(NOT SWIFT_BUILT_STANDALONE AND NOT "${CMAKE_C_COMPILER_ID}" MATCHES "Clang")
add_dependencies(${VARIANT_NAME} clang)
endif()
if(sdk STREQUAL "WINDOWS")
if(SWIFT_COMPILER_IS_MSVC_LIKE)
if (SWIFT_STDLIB_MSVC_RUNTIME_LIBRARY MATCHES MultiThreadedDebugDLL)
target_compile_options(${VARIANT_NAME} PRIVATE /MDd /D_DLL /D_DEBUG)
elseif (SWIFT_STDLIB_MSVC_RUNTIME_LIBRARY MATCHES MultiThreadedDebug)
target_compile_options(${VARIANT_NAME} PRIVATE /MTd /U_DLL /D_DEBUG)
elseif (SWIFT_STDLIB_MSVC_RUNTIME_LIBRARY MATCHES MultiThreadedDLL)
target_compile_options(${VARIANT_NAME} PRIVATE /MD /D_DLL /U_DEBUG)
elseif (SWIFT_STDLIB_MSVC_RUNTIME_LIBRARY MATCHES MultiThreaded)
target_compile_options(${VARIANT_NAME} PRIVATE /MT /U_DLL /U_DEBUG)
endif()
endif()
endif()
if(NOT SWIFTLIB_OBJECT_LIBRARY)
# Add dependencies on the (not-yet-created) custom lipo target.
foreach(DEP ${SWIFTLIB_LINK_LIBRARIES})
if (NOT "${DEP}" MATCHES "^icucore($|-.*)$" AND
NOT "${DEP}" MATCHES "^dispatch($|-.*)$" AND
NOT "${DEP}" MATCHES "^BlocksRuntime($|-.*)$")
add_dependencies(${VARIANT_NAME}
"${DEP}-${SWIFT_SDK_${sdk}_LIB_SUBDIR}")
endif()
endforeach()
if (SWIFTLIB_IS_STDLIB AND SWIFTLIB_STATIC)
# Add dependencies on the (not-yet-created) custom lipo target.
foreach(DEP ${SWIFTLIB_LINK_LIBRARIES})
if (NOT "${DEP}" MATCHES "^icucore($|-.*)$" AND
NOT "${DEP}" MATCHES "^dispatch($|-.*)$" AND
NOT "${DEP}" MATCHES "^BlocksRuntime($|-.*)$")
add_dependencies("${VARIANT_NAME}-static"
"${DEP}-${SWIFT_SDK_${sdk}_LIB_SUBDIR}-static")
endif()
endforeach()
endif()
if(arch IN_LIST SWIFT_SDK_${sdk}_ARCHITECTURES)
# Note this thin library.
list(APPEND THIN_INPUT_TARGETS ${VARIANT_NAME})
endif()
endif()
endforeach()
# Configure module-only targets
if(NOT SWIFT_SDK_${sdk}_ARCHITECTURES
AND SWIFT_SDK_${sdk}_MODULE_ARCHITECTURES)
set(_target "${name}-${SWIFT_SDK_${sdk}_LIB_SUBDIR}")
# Create unified sdk target
add_custom_target("${_target}")
foreach(_arch ${SWIFT_SDK_${sdk}_MODULE_ARCHITECTURES})
set(_variant_suffix "-${SWIFT_SDK_${sdk}_LIB_SUBDIR}-${_arch}")
set(_module_variant_name "${name}-swiftmodule-${_variant_suffix}")
add_dependencies("${_target}" ${_module_variant_name})
# Add Swift standard library targets as dependencies to the top-level
# convenience target.
if(TARGET "swift-stdlib${_variant_suffix}")
add_dependencies("swift-stdlib${_variant_suffix}"
"${_target}")
endif()
endforeach()
return()
endif()
set(library_subdir "${SWIFT_SDK_${sdk}_LIB_SUBDIR}")
if(maccatalyst_build_flavor STREQUAL "ios-like")
set(library_subdir "${SWIFT_SDK_MACCATALYST_LIB_SUBDIR}")
endif()
if(NOT SWIFTLIB_OBJECT_LIBRARY)
# Determine the name of the universal library.
if(SWIFTLIB_SHARED AND NOT SWIFT_SDK_${sdk}_STATIC_ONLY)
if("${sdk}" STREQUAL "WINDOWS")
set(UNIVERSAL_LIBRARY_NAME
"${SWIFTLIB_DIR}/${library_subdir}/${name}.dll")
elseif(SWIFTLIB_BACK_DEPLOYMENT_LIBRARY)
set(UNIVERSAL_LIBRARY_NAME
"${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib/swift-${SWIFTLIB_BACK_DEPLOYMENT_LIBRARY}/${library_subdir}/${CMAKE_SHARED_LIBRARY_PREFIX}${name}${CMAKE_SHARED_LIBRARY_SUFFIX}")
else()
set(UNIVERSAL_LIBRARY_NAME
"${SWIFTLIB_DIR}/${library_subdir}/${CMAKE_SHARED_LIBRARY_PREFIX}${name}${CMAKE_SHARED_LIBRARY_SUFFIX}")
endif()
else()
if(SWIFT_SDK_${sdk}_STATIC_ONLY)
set(lib_dir "${SWIFTSTATICLIB_DIR}")
else()
set(lib_dir "${SWIFTLIB_DIR}")
endif()
if("${sdk}" STREQUAL "WINDOWS")
set(UNIVERSAL_LIBRARY_NAME
"${lib_dir}/${library_subdir}/${name}.lib")
else()
set(UNIVERSAL_LIBRARY_NAME
"${lib_dir}/${library_subdir}/${CMAKE_STATIC_LIBRARY_PREFIX}${name}${CMAKE_STATIC_LIBRARY_SUFFIX}")
endif()
endif()
set(lipo_target "${name}-${library_subdir}")
if("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin" AND SWIFTLIB_SHARED)
set(codesign_arg CODESIGN)
endif()
precondition(THIN_INPUT_TARGETS)
_add_swift_lipo_target(SDK
${sdk}
TARGET
${lipo_target}
OUTPUT
${UNIVERSAL_LIBRARY_NAME}
${codesign_arg}
${THIN_INPUT_TARGETS})
# Cache universal libraries for dependency purposes
set(UNIVERSAL_LIBRARY_NAMES_${library_subdir}
${UNIVERSAL_LIBRARY_NAMES_${library_subdir}}
${lipo_target}
CACHE INTERNAL "UNIVERSAL_LIBRARY_NAMES_${library_subdir}")
# Determine the subdirectory where this library will be installed.
set(resource_dir_sdk_subdir "${SWIFT_SDK_${sdk}_LIB_SUBDIR}")
if(maccatalyst_build_flavor STREQUAL "ios-like")
set(resource_dir_sdk_subdir "${SWIFT_SDK_MACCATALYST_LIB_SUBDIR}")
endif()
precondition(resource_dir_sdk_subdir)
if((SWIFTLIB_SHARED AND NOT SWIFT_SDK_${sdk}_STATIC_ONLY)
OR SWIFTLIB_INSTALL_WITH_SHARED)
set(resource_dir "swift")
set(file_permissions
OWNER_READ OWNER_WRITE OWNER_EXECUTE
GROUP_READ GROUP_EXECUTE
WORLD_READ WORLD_EXECUTE)
else()
set(resource_dir "swift_static")
set(file_permissions
OWNER_READ OWNER_WRITE
GROUP_READ
WORLD_READ)
endif()
set(optional_arg)
if(sdk IN_LIST SWIFT_DARWIN_PLATFORMS)
# Allow installation of stdlib without building all variants on Darwin.
set(optional_arg "OPTIONAL")
endif()
if(sdk STREQUAL "WINDOWS" AND CMAKE_SYSTEM_NAME STREQUAL "Windows")
add_dependencies(${SWIFTLIB_INSTALL_IN_COMPONENT} ${name}-windows-${SWIFT_PRIMARY_VARIANT_ARCH})
swift_install_in_component(TARGETS ${name}-windows-${SWIFT_PRIMARY_VARIANT_ARCH}
RUNTIME
DESTINATION "bin"
COMPONENT "${SWIFTLIB_INSTALL_IN_COMPONENT}"
LIBRARY
DESTINATION "lib${LLVM_LIBDIR_SUFFIX}/${resource_dir}/${resource_dir_sdk_subdir}/${SWIFT_PRIMARY_VARIANT_ARCH}"
COMPONENT "${SWIFTLIB_INSTALL_IN_COMPONENT}"
ARCHIVE
DESTINATION "lib${LLVM_LIBDIR_SUFFIX}/${resource_dir}/${resource_dir_sdk_subdir}/${SWIFT_PRIMARY_VARIANT_ARCH}"
COMPONENT "${SWIFTLIB_INSTALL_IN_COMPONENT}"
PERMISSIONS ${file_permissions})
else()
# NOTE: ${UNIVERSAL_LIBRARY_NAME} is the output associated with the target
# ${lipo_target}
add_dependencies(${SWIFTLIB_INSTALL_IN_COMPONENT} ${lipo_target})
if (SWIFTLIB_BACK_DEPLOYMENT_LIBRARY)
# Back-deployment libraries get installed into a versioned directory.
set(install_dest "lib${LLVM_LIBDIR_SUFFIX}/${resource_dir}-${SWIFTLIB_BACK_DEPLOYMENT_LIBRARY}/${resource_dir_sdk_subdir}")
else()
set(install_dest "lib${LLVM_LIBDIR_SUFFIX}/${resource_dir}/${resource_dir_sdk_subdir}")
endif()
swift_install_in_component(FILES "${UNIVERSAL_LIBRARY_NAME}"
DESTINATION ${install_dest}
COMPONENT "${SWIFTLIB_INSTALL_IN_COMPONENT}"
PERMISSIONS ${file_permissions}
"${optional_arg}")
endif()
if(sdk STREQUAL "WINDOWS")
foreach(arch ${SWIFT_SDK_WINDOWS_ARCHITECTURES})
if(TARGET ${name}-windows-${arch}_IMPLIB)
get_target_property(import_library ${name}-windows-${arch}_IMPLIB IMPORTED_LOCATION)
add_dependencies(${SWIFTLIB_INSTALL_IN_COMPONENT} ${name}-windows-${arch}_IMPLIB)
swift_install_in_component(FILES ${import_library}
DESTINATION "lib${LLVM_LIBDIR_SUFFIX}/${resource_dir}/${resource_dir_sdk_subdir}/${arch}"
COMPONENT ${SWIFTLIB_INSTALL_IN_COMPONENT}
PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ)
endif()
endforeach()
endif()
swift_is_installing_component(
"${SWIFTLIB_INSTALL_IN_COMPONENT}"
is_installing)
# Add the arch-specific library targets to the global exports.
foreach(arch ${SWIFT_SDK_${sdk}_ARCHITECTURES})
set(_variant_name "${name}-${SWIFT_SDK_${sdk}_LIB_SUBDIR}-${arch}")
if(maccatalyst_build_flavor STREQUAL "ios-like")
set(_variant_name "${name}-${SWIFT_SDK_MACCATALYST_LIB_SUBDIR}-${arch}")
endif()
if(NOT TARGET "${_variant_name}")
continue()
endif()
if(is_installing)
set_property(GLOBAL APPEND
PROPERTY SWIFT_EXPORTS ${_variant_name})
else()
set_property(GLOBAL APPEND
PROPERTY SWIFT_BUILDTREE_EXPORTS ${_variant_name})
endif()
endforeach()
# Add the swiftmodule-only targets to the lipo target dependencies.
foreach(arch ${SWIFT_SDK_${sdk}_MODULE_ARCHITECTURES})
set(_variant_name "${name}-${SWIFT_SDK_${sdk}_LIB_SUBDIR}-${arch}")
if(maccatalyst_build_flavor STREQUAL "ios-like")
set(_variant_name "${name}-${SWIFT_SDK_MACCATALYST_LIB_SUBDIR}-${arch}")
endif()
if(NOT TARGET "${_variant_name}")
continue()
endif()
add_dependencies("${lipo_target}" "${_variant_name}")
endforeach()
# If we built static variants of the library, create a lipo target for
# them.
set(lipo_target_static)
if (SWIFTLIB_IS_STDLIB AND SWIFTLIB_STATIC AND NOT SWIFTLIB_INSTALL_WITH_SHARED)
set(THIN_INPUT_TARGETS_STATIC)
foreach(TARGET ${THIN_INPUT_TARGETS})
list(APPEND THIN_INPUT_TARGETS_STATIC "${TARGET}-static")
endforeach()
set(install_subdir "swift_static")
set(universal_subdir ${SWIFTSTATICLIB_DIR})
set(lipo_target_static
"${name}-${library_subdir}-static")
set(UNIVERSAL_LIBRARY_NAME
"${universal_subdir}/${library_subdir}/${CMAKE_STATIC_LIBRARY_PREFIX}${name}${CMAKE_STATIC_LIBRARY_SUFFIX}")
_add_swift_lipo_target(SDK
${sdk}
TARGET
${lipo_target_static}
OUTPUT
"${UNIVERSAL_LIBRARY_NAME}"
${THIN_INPUT_TARGETS_STATIC})
add_dependencies(${SWIFTLIB_INSTALL_IN_COMPONENT} ${lipo_target_static})
swift_install_in_component(FILES "${UNIVERSAL_LIBRARY_NAME}"
DESTINATION "lib${LLVM_LIBDIR_SUFFIX}/${install_subdir}/${resource_dir_sdk_subdir}"
PERMISSIONS
OWNER_READ OWNER_WRITE
GROUP_READ
WORLD_READ
COMPONENT "${SWIFTLIB_INSTALL_IN_COMPONENT}"
"${optional_arg}")
endif()
# Add Swift standard library targets as dependencies to the top-level
# convenience target.
set(FILTERED_UNITTESTS
swiftStdlibCollectionUnittest
swiftStdlibUnicodeUnittest)
foreach(arch ${SWIFT_SDK_${sdk}_ARCHITECTURES})
set(VARIANT_SUFFIX "-${SWIFT_SDK_${sdk}_LIB_SUBDIR}-${arch}")
if(TARGET "swift-stdlib${VARIANT_SUFFIX}" AND
TARGET "swift-test-stdlib${VARIANT_SUFFIX}")
add_dependencies("swift-stdlib${VARIANT_SUFFIX}"
${lipo_target}
${lipo_target_static})
if(NOT "${name}" IN_LIST FILTERED_UNITTESTS)
add_dependencies("swift-test-stdlib${VARIANT_SUFFIX}"
${lipo_target}
${lipo_target_static})
endif()
endif()
endforeach()
endif()
endforeach() # maccatalyst_build_flavors
endforeach()
endfunction()
# Add an executable compiled for a given variant.
#
# Don't use directly, use add_swift_executable and add_swift_target_executable
# instead.
#
# See add_swift_executable for detailed documentation.
#
# Additional parameters:
# [SDK sdk]
# SDK to build for.
#
# [ARCHITECTURE architecture]
# Architecture to build for.
#
# [INSTALL_IN_COMPONENT component]
# The Swift installation component that this executable belongs to.
# Defaults to never_install.
function(_add_swift_target_executable_single name)
set(options
NOSWIFTRT)
set(single_parameter_options
ARCHITECTURE
SDK
INSTALL_IN_COMPONENT)
set(multiple_parameter_options
COMPILE_FLAGS
DEPENDS
DEPLOYMENT_VERSION_IOS
DEPLOYMENT_VERSION_OSX
DEPLOYMENT_VERSION_MACCATALYST
DEPLOYMENT_VERSION_TVOS
DEPLOYMENT_VERSION_WATCHOS
DEPLOYMENT_VERSION_XROS)
cmake_parse_arguments(SWIFTEXE_SINGLE
"${options}"
"${single_parameter_options}"
"${multiple_parameter_options}"
${ARGN})
set(SWIFTEXE_SINGLE_SOURCES ${SWIFTEXE_SINGLE_UNPARSED_ARGUMENTS})
# Check arguments.
precondition(SWIFTEXE_SINGLE_SDK MESSAGE "Should specify an SDK")
precondition(SWIFTEXE_SINGLE_ARCHITECTURE MESSAGE "Should specify an architecture")
# Determine compiler flags.
set(c_compile_flags)
set(link_flags)
# Prepare linker search directories.
set(library_search_directories
"${SWIFTLIB_DIR}/${SWIFT_SDK_${SWIFTEXE_SINGLE_SDK}_LIB_SUBDIR}")
# Add variant-specific flags.
_add_target_variant_c_compile_flags(
SDK "${SWIFTEXE_SINGLE_SDK}"
ARCH "${SWIFTEXE_SINGLE_ARCHITECTURE}"
BUILD_TYPE "${CMAKE_BUILD_TYPE}"
ENABLE_ASSERTIONS "${LLVM_ENABLE_ASSERTIONS}"
ENABLE_LTO "${SWIFT_STDLIB_ENABLE_LTO}"
ANALYZE_CODE_COVERAGE "${SWIFT_ANALYZE_CODE_COVERAGE}"
DEPLOYMENT_VERSION_OSX "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_OSX}"
DEPLOYMENT_VERSION_MACCATALYST "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_MACCATALYST}"
DEPLOYMENT_VERSION_IOS "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_IOS}"
DEPLOYMENT_VERSION_TVOS "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_TVOS}"
DEPLOYMENT_VERSION_WATCHOS "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_WATCHOS}"
DEPLOYMENT_VERSION_XROS "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_XROS}"
RESULT_VAR_NAME c_compile_flags)
_add_target_variant_link_flags(
SDK "${SWIFTEXE_SINGLE_SDK}"
ARCH "${SWIFTEXE_SINGLE_ARCHITECTURE}"
BUILD_TYPE "${CMAKE_BUILD_TYPE}"
ENABLE_ASSERTIONS "${LLVM_ENABLE_ASSERTIONS}"
ENABLE_LTO "${SWIFT_STDLIB_ENABLE_LTO}"
LTO_OBJECT_NAME "${name}-${SWIFTEXE_SINGLE_SDK}-${SWIFTEXE_SINGLE_ARCHITECTURE}"
ANALYZE_CODE_COVERAGE "${SWIFT_ANALYZE_CODE_COVERAGE}"
DEPLOYMENT_VERSION_OSX "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_OSX}"
DEPLOYMENT_VERSION_MACCATALYST "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_MACCATALYST}"
DEPLOYMENT_VERSION_IOS "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_IOS}"
DEPLOYMENT_VERSION_TVOS "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_TVOS}"
DEPLOYMENT_VERSION_WATCHOS "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_WATCHOS}"
DEPLOYMENT_VERSION_XROS "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_XROS}"
RESULT_VAR_NAME link_flags
LINK_LIBRARIES_VAR_NAME link_libraries
LIBRARY_SEARCH_DIRECTORIES_VAR_NAME library_search_directories)
string(MAKE_C_IDENTIFIER "${name}" module_name)
if(SWIFTEXE_SINGLE_SDK STREQUAL "WINDOWS")
list(APPEND SWIFTEXE_SINGLE_COMPILE_FLAGS
-vfsoverlay;"${SWIFT_WINDOWS_VFS_OVERLAY}";-Xfrontend;-strict-implicit-module-context;-Xcc;-Xclang;-Xcc;-fbuiltin-headers-in-system-modules)
endif()
if ("${SWIFTEXE_SINGLE_SDK}" STREQUAL "LINUX")
list(APPEND SWIFTEXE_SINGLE_COMPILE_FLAGS "-Xcc" "-fno-omit-frame-pointer")
endif()
handle_swift_sources(
dependency_target
unused_module_dependency_target
unused_sib_dependency_target
unused_sibopt_dependency_target
unused_sibgen_dependency_target
SWIFTEXE_SINGLE_SOURCES SWIFTEXE_SINGLE_EXTERNAL_SOURCES ${name}
DEPENDS
${SWIFTEXE_SINGLE_DEPENDS}
MODULE_NAME ${module_name}
SDK ${SWIFTEXE_SINGLE_SDK}
ARCHITECTURE ${SWIFTEXE_SINGLE_ARCHITECTURE}
COMPILE_FLAGS ${SWIFTEXE_SINGLE_COMPILE_FLAGS}
ENABLE_LTO "${SWIFT_STDLIB_ENABLE_LTO}"
INSTALL_IN_COMPONENT "${install_in_component}"
DEPLOYMENT_VERSION_OSX "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_OSX}"
DEPLOYMENT_VERSION_MACCATALYST "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_MACCATALYST}"
DEPLOYMENT_VERSION_IOS "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_IOS}"
DEPLOYMENT_VERSION_TVOS "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_TVOS}"
DEPLOYMENT_VERSION_WATCHOS "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_WATCHOS}"
DEPLOYMENT_VERSION_XROS "${SWIFTEXE_SINGLE_DEPLOYMENT_VERSION_XROS}"
IS_MAIN)
add_swift_source_group("${SWIFTEXE_SINGLE_EXTERNAL_SOURCES}")
add_executable(${name}
${SWIFTEXE_SINGLE_SOURCES}
${SWIFTEXE_SINGLE_EXTERNAL_SOURCES})
# Darwin may need the compatibility libraries
set(compatibility_libs)
if(SWIFTEXE_SINGLE_SDK IN_LIST SWIFT_DARWIN_PLATFORMS)
get_compatibility_libs(
"${SWIFTEXE_SINGLE_SDK}"
"${SWIFTEXE_SINGLE_ARCHITECTURE}"
compatibility_libs)
endif()
# ELF and COFF need swiftrt
if(("${SWIFT_SDK_${SWIFTEXE_SINGLE_SDK}_OBJECT_FORMAT}" STREQUAL "ELF" OR
"${SWIFT_SDK_${SWIFTEXE_SINGLE_SDK}_OBJECT_FORMAT}" STREQUAL "COFF")
AND NOT SWIFTEXE_SINGLE_NOSWIFTRT)
target_sources(${name}
PRIVATE
$<TARGET_OBJECTS:swiftImageRegistrationObject${SWIFT_SDK_${SWIFTEXE_SINGLE_SDK}_OBJECT_FORMAT}-${SWIFT_SDK_${SWIFTEXE_SINGLE_SDK}_LIB_SUBDIR}-${SWIFTEXE_SINGLE_ARCHITECTURE}>)
endif()
add_dependencies_multiple_targets(
TARGETS "${name}"
DEPENDS
${dependency_target}
${compatibility_libs}
${LLVM_COMMON_DEPENDS}
${SWIFTEXE_SINGLE_DEPENDS})
llvm_update_compile_flags("${name}")
if(SWIFTEXE_SINGLE_SDK STREQUAL "WINDOWS")
if(NOT CMAKE_HOST_SYSTEM MATCHES Windows)
swift_windows_include_for_arch(${SWIFTEXE_SINGLE_ARCHITECTURE}
${SWIFTEXE_SINGLE_ARCHITECTURE}_INCLUDE)
target_include_directories(${name} SYSTEM PRIVATE
${${SWIFTEXE_SINGLE_ARCHITECTURE}_INCLUDE})
endif()
if(NOT CMAKE_C_COMPILER_ID STREQUAL "MSVC")
# MSVC doesn't support -Xclang. We don't need to manually specify
# the dependent libraries as `cl` does so.
target_compile_options(${name} PRIVATE
"SHELL:-Xclang --dependent-lib=oldnames"
# TODO(compnerd) handle /MT, /MTd
"SHELL:-Xclang --dependent-lib=msvcrt$<$<CONFIG:Debug>:d>")
endif()
endif()
target_compile_options(${name} PRIVATE
${c_compile_flags})
target_link_directories(${name} PRIVATE
${library_search_directories})
target_link_options(${name} PRIVATE
${link_flags})
target_link_libraries(${name} PRIVATE
${link_libraries})
if (SWIFT_PARALLEL_LINK_JOBS)
set_property(TARGET ${name} PROPERTY JOB_POOL_LINK swift_link_job_pool)
endif()
if(SWIFTEXE_SINGLE_SDK IN_LIST SWIFT_DARWIN_PLATFORMS)
set_target_properties(${name} PROPERTIES
BUILD_WITH_INSTALL_RPATH YES
INSTALL_RPATH "@executable_path/../lib/swift/${SWIFT_SDK_${SWIFTEXE_SINGLE_SDK}_LIB_SUBDIR};@executable_path/../../../lib/swift/${SWIFT_SDK_${SWIFTEXE_SINGLE_SDK}_LIB_SUBDIR}")
elseif(SWIFT_HOST_VARIANT_SDK STREQUAL "LINUX")
set_target_properties(${name} PROPERTIES
BUILD_WITH_INSTALL_RPATH YES
INSTALL_RPATH "$ORIGIN/../../../lib/swift/${SWIFT_SDK_${SWIFTEXE_SINGLE_SDK}_LIB_SUBDIR}")
endif()
set_output_directory(${name}
BINARY_DIR ${SWIFT_RUNTIME_OUTPUT_INTDIR}
LIBRARY_DIR ${SWIFT_LIBRARY_OUTPUT_INTDIR})
# NOTE(compnerd) use the C linker language to invoke `clang` rather than
# `clang++` as we explicitly link against the C++ runtime. We were previously
# actually passing `-nostdlib++` to avoid the C++ runtime linkage.
if(SWIFTEXE_SINGLE_SDK STREQUAL "ANDROID")
set_property(TARGET "${name}" PROPERTY
LINKER_LANGUAGE "C")
else()
set_property(TARGET "${name}" PROPERTY
LINKER_LANGUAGE "CXX")
endif()
set_target_properties(${name} PROPERTIES FOLDER "Swift executables")
endfunction()
# Conditionally append -static to a name, if that variant is a valid target
function(append_static name result_var_name)
cmake_parse_arguments(APPEND_TARGET
"STATIC_SWIFT_STDLIB"
""
""
${ARGN})
if(STATIC_SWIFT_STDLIB)
if(TARGET "${name}-static")
set("${result_var_name}" "${name}-static" PARENT_SCOPE)
else()
set("${result_var_name}" "${name}" PARENT_SCOPE)
endif()
else()
set("${result_var_name}" "${name}" PARENT_SCOPE)
endif()
endfunction()
# Add an executable for each target variant. Executables are given suffixes
# with the variant SDK and ARCH.
#
# See add_swift_executable for detailed documentation.
function(add_swift_target_executable name)
set(SWIFTEXE_options
EXCLUDE_FROM_ALL
BUILD_WITH_STDLIB
BUILD_WITH_LIBEXEC
PREFER_STATIC
NOSWIFTRT)
set(SWIFTEXE_single_parameter_options
DEPLOYMENT_VERSION_IOS
DEPLOYMENT_VERSION_OSX
DEPLOYMENT_VERSION_MACCATALYST
DEPLOYMENT_VERSION_TVOS
DEPLOYMENT_VERSION_WATCHOS
DEPLOYMENT_VERSION_XROS
INSTALL_IN_COMPONENT)
set(SWIFTEXE_multiple_parameter_options
DEPENDS
LINK_LIBRARIES
SWIFT_MODULE_DEPENDS
SWIFT_MODULE_DEPENDS_ANDROID
SWIFT_MODULE_DEPENDS_CYGWIN
SWIFT_MODULE_DEPENDS_FREEBSD
SWIFT_MODULE_DEPENDS_FREESTANDING
SWIFT_MODULE_DEPENDS_OPENBSD
SWIFT_MODULE_DEPENDS_HAIKU
SWIFT_MODULE_DEPENDS_IOS
SWIFT_MODULE_DEPENDS_LINUX
SWIFT_MODULE_DEPENDS_LINUX_STATIC
SWIFT_MODULE_DEPENDS_OSX
SWIFT_MODULE_DEPENDS_TVOS
SWIFT_MODULE_DEPENDS_WASI
SWIFT_MODULE_DEPENDS_WATCHOS
SWIFT_MODULE_DEPENDS_WINDOWS
SWIFT_MODULE_DEPENDS_FROM_SDK
SWIFT_MODULE_DEPENDS_MACCATALYST
SWIFT_MODULE_DEPENDS_MACCATALYST_UNZIPPERED
TARGET_SDKS
COMPILE_FLAGS
)
# Parse the arguments we were given.
cmake_parse_arguments(SWIFTEXE_TARGET
"${SWIFTEXE_options}"
"${SWIFTEXE_single_parameter_options}"
"${SWIFTEXE_multiple_parameter_options}"
${ARGN})
set(SWIFTEXE_TARGET_SOURCES ${SWIFTEXE_TARGET_UNPARSED_ARGUMENTS})
if(SWIFTEXE_TARGET_EXCLUDE_FROM_ALL)
message(SEND_ERROR "${name} is using EXCLUDE_FROM_ALL which is deprecated.")
endif()
if("${SWIFTEXE_TARGET_INSTALL_IN_COMPONENT}" STREQUAL "")
set(install_in_component "never_install")
else()
set(install_in_component "${SWIFTEXE_TARGET_INSTALL_IN_COMPONENT}")
endif()
# Turn off implicit imports
list(APPEND SWIFTEXE_TARGET_COMPILE_FLAGS "-Xfrontend;-disable-implicit-concurrency-module-import")
if(SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING)
list(APPEND SWIFTEXE_TARGET_COMPILE_FLAGS
"-Xfrontend;-disable-implicit-string-processing-module-import")
endif()
if(SWIFT_BUILD_STDLIB)
# All Swift executables depend on the standard library.
list(APPEND SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS Core)
# All Swift executables depend on the swiftSwiftOnoneSupport library.
list(APPEND SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS SwiftOnoneSupport)
endif()
# If target SDKs are not specified, build for all known SDKs.
if("${SWIFTEXE_TARGET_TARGET_SDKS}" STREQUAL "")
set(SWIFTEXE_TARGET_TARGET_SDKS ${SWIFT_SDKS})
endif()
list_replace(SWIFTEXE_TARGET_TARGET_SDKS ALL_APPLE_PLATFORMS "${SWIFT_DARWIN_PLATFORMS}")
# Support adding a "NOT" on the front to mean all SDKs except the following
list(LENGTH SWIFTEXE_TARGET_TARGET_SDKS number_of_target_sdks)
if(number_of_target_sdks GREATER_EQUAL "1")
list(GET SWIFTEXE_TARGET_TARGET_SDKS 0 first_sdk)
if("${first_sdk}" STREQUAL "NOT")
list(REMOVE_AT SWIFTEXE_TARGET_TARGET_SDKS 0)
list_subtract("${SWIFT_SDKS}" "${SWIFTEXE_TARGET_TARGET_SDKS}"
"SWIFTEXE_TARGET_TARGET_SDKS")
endif()
endif()
list_intersect(
"${SWIFTEXE_TARGET_TARGET_SDKS}" "${SWIFT_SDKS}" SWIFTEXE_TARGET_TARGET_SDKS)
foreach(sdk ${SWIFTEXE_TARGET_TARGET_SDKS})
set(THIN_INPUT_TARGETS)
# Collect architecture agnostic SDK module dependencies
set(swiftexe_module_depends_flattened ${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS})
if(sdk STREQUAL "OSX")
if(DEFINED maccatalyst_build_flavor AND NOT maccatalyst_build_flavor STREQUAL "macos-like")
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_MACCATALYST})
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_MACCATALYST_UNZIPPERED})
else()
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_OSX})
endif()
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_OSX})
elseif(sdk STREQUAL "IOS" OR sdk STREQUAL "IOS_SIMULATOR")
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_IOS})
elseif(sdk STREQUAL "TVOS" OR sdk STREQUAL "TVOS_SIMULATOR")
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_TVOS})
elseif(sdk STREQUAL "WATCHOS" OR sdk STREQUAL "WATCHOS_SIMULATOR")
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_WATCHOS})
elseif(sdk STREQUAL "FREESTANDING")
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_FREESTANDING})
elseif(sdk STREQUAL "FREEBSD")
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_FREEBSD})
elseif(sdk STREQUAL "OPENBSD")
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_OPENBSD})
elseif(sdk STREQUAL "LINUX")
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_LINUX})
elseif(sdk STREQUAL "LINUX_STATIC")
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_LINUX_STATIC})
elseif(sdk STREQUAL "ANDROID")
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_ANDROID})
elseif(sdk STREQUAL "CYGWIN")
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_CYGWIN})
elseif(sdk STREQUAL "HAIKU")
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_HAIKU})
elseif(sdk STREQUAL "WASI")
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_WASI})
elseif(sdk STREQUAL "WINDOWS")
list(APPEND swiftexe_module_depends_flattened
${SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_WINDOWS})
endif()
foreach(arch ${SWIFT_SDK_${sdk}_ARCHITECTURES})
set(VARIANT_SUFFIX "-${SWIFT_SDK_${sdk}_LIB_SUBDIR}-${arch}")
set(VARIANT_NAME "${name}${VARIANT_SUFFIX}")
set(MODULE_VARIANT_SUFFIX "-swiftmodule${VARIANT_SUFFIX}")
set(MODULE_VARIANT_NAME "${name}${MODULE_VARIANT_SUFFIX}")
# Configure macCatalyst flavor variables
if(DEFINED maccatalyst_build_flavor)
set(maccatalyst_variant_suffix "-${SWIFT_SDK_MACCATALYST_LIB_SUBDIR}-${arch}")
set(maccatalyst_variant_name "${name}${maccatalyst_variant_suffix}")
set(maccatalyst_module_variant_suffix "-swiftmodule${maccatalyst_variant_suffix}")
set(maccatalyst_module_variant_name "${name}${maccatalyst_module_variant_suffix}")
endif()
# Swift compiles depend on swift modules, while links depend on
# linked libraries. Find targets for both of these here.
set(swiftexe_module_dependency_targets)
set(swiftexe_link_libraries_targets)
foreach(mod ${swiftexe_module_depends_flattened})
if(DEFINED maccatalyst_build_flavor)
if(maccatalyst_build_flavor STREQUAL "zippered")
# Zippered libraries are dependent on both the macCatalyst and normal macOS
# modules of their dependencies (which themselves must be zippered).
list(APPEND swiftexe_module_dependency_targets
"swift${mod}${maccatalyst_module_variant_suffix}")
list(APPEND swiftexe_module_dependency_targets
"swift${mod}${MODULE_VARIANT_SUFFIX}")
# Zippered libraries link against their zippered library targets, which
# live (and are built in) the same location as normal macOS libraries.
list(APPEND swiftexe_link_libraries_targets
"swift${mod}${VARIANT_SUFFIX}")
elseif(maccatalyst_build_flavor STREQUAL "ios-like")
# iOS-like libraries depend on the macCatalyst modules of their dependencies
# regardless of whether the target is zippered or macCatalyst only.
list(APPEND swiftexe_module_dependency_targets
"swift${mod}${maccatalyst_module_variant_suffix}")
# iOS-like libraries can link against either iOS-like library targets
# or zippered targets.
if(mod IN_LIST SWIFTEXE_TARGET_SWIFT_MODULE_DEPENDS_MACCATALYST_UNZIPPERED)
list(APPEND swiftexe_link_libraries_targets
"swift${mod}${maccatalyst_variant_suffix}")
else()
list(APPEND swiftexe_link_libraries_targets
"swift${mod}${VARIANT_SUFFIX}")
endif()
else()
list(APPEND swiftexe_module_dependency_targets
"swift${mod}${MODULE_VARIANT_SUFFIX}")
list(APPEND swiftexe_link_libraries_targets
"swift${mod}${VARIANT_SUFFIX}")
endif()
continue()
endif()
list(APPEND swiftexe_module_dependency_targets
"swift${mod}${MODULE_VARIANT_SUFFIX}")
set(library_target "swift${mod}${VARIANT_SUFFIX}")
if(SWIFTEXE_TARGET_PREFER_STATIC AND TARGET "${library_target}-static")
set(library_target "${library_target}-static")
endif()
list(APPEND swiftexe_link_libraries_targets "${library_target}")
endforeach()
# Don't add the ${arch} to the suffix. We want to link against fat
# libraries.
_list_add_string_suffix(
"${SWIFTEXE_TARGET_DEPENDS}"
"-${SWIFT_SDK_${sdk}_LIB_SUBDIR}"
SWIFTEXE_TARGET_DEPENDS_with_suffix)
# Note: we add ${swiftexe_link_libraries_targets} to the DEPENDS
# below because when --bootstrapping=bootstrapping with
# skip-early-swiftsyntax, the build system builds the Swift compiler
# but not the standard library during the bootstrap, and then when
# it tries to build swift-backtrace it fails because *the compiler*
# refers to a libswiftCore.so that can't be found.
if(SWIFTEXE_TARGET_NOSWIFTRT)
set(NOSWIFTRT_KEYWORD "NOSWIFTRT")
else()
set(NOSWIFTRT_KEYWORD "")
endif()
_add_swift_target_executable_single(
${VARIANT_NAME}
${NOSWIFTRT_KEYWORD}
${SWIFTEXE_TARGET_SOURCES}
DEPENDS
${SWIFTEXE_TARGET_DEPENDS_with_suffix}
${swiftexe_module_dependency_targets}
${swiftexe_link_libraries_targets}
DEPLOYMENT_VERSION_OSX "${SWIFTEXE_TARGET_DEPLOYMENT_VERSION_OSX}"
DEPLOYMENT_VERSION_MACCATALYST
"${SWIFTEXE_TARGET_DEPLOYMENT_VERSION_MACCATALYST}"
DEPLOYMENT_VERSION_IOS "${SWIFTEXE_TARGET_DEPLOYMENT_VERSION_IOS}"
DEPLOYMENT_VERSION_TVOS "${SWIFTEXE_TARGET_DEPLOYMENT_VERSION_TVOS}"
DEPLOYMENT_VERSION_WATCHOS "${SWIFTEXE_TARGET_DEPLOYMENT_VERSION_WATCHOS}"
DEPLOYMENT_VERSION_XROS "${SWIFTEXE_TARGET_DEPLOYMENT_VERSION_XROS}"
SDK "${sdk}"
ARCHITECTURE "${arch}"
COMPILE_FLAGS
${SWIFTEXE_TARGET_COMPILE_FLAGS}
INSTALL_IN_COMPONENT ${install_in_component})
_list_add_string_suffix(
"${SWIFTEXE_TARGET_LINK_LIBRARIES}"
"-${SWIFT_SDK_${sdk}_LIB_SUBDIR}-${arch}"
SWIFTEXE_TARGET_LINK_LIBRARIES_TARGETS)
target_link_libraries(${VARIANT_NAME} PRIVATE
${SWIFTEXE_TARGET_LINK_LIBRARIES_TARGETS}
${swiftexe_link_libraries_targets})
if(NOT "${VARIANT_SUFFIX}" STREQUAL "${SWIFT_PRIMARY_VARIANT_SUFFIX}")
# By default, don't build executables for target SDKs to avoid building
# target stdlibs.
set_target_properties(${VARIANT_NAME} PROPERTIES
EXCLUDE_FROM_ALL TRUE)
endif()
if(sdk IN_LIST SWIFT_APPLE_PLATFORMS)
# In the past, we relied on unsetting globally
# CMAKE_OSX_ARCHITECTURES to ensure that CMake would
# not add the -arch flag
# This is no longer the case when running on Apple Silicon,
# when CMake will enforce a default (see
# https://gitlab.kitware.com/cmake/cmake/-/merge_requests/5291)
set_property(TARGET ${VARIANT_NAME} PROPERTY OSX_ARCHITECTURES "${arch}")
add_custom_command(TARGET ${VARIANT_NAME}
POST_BUILD
COMMAND "codesign" "-f" "-s" "-" "${SWIFT_RUNTIME_OUTPUT_INTDIR}/${VARIANT_NAME}")
endif()
list(APPEND THIN_INPUT_TARGETS ${VARIANT_NAME})
endforeach()
if(SWIFTEXE_TARGET_BUILD_WITH_LIBEXEC)
set(library_subdir "${SWIFT_SDK_${sdk}_LIB_SUBDIR}")
if(maccatalyst_build_flavor STREQUAL "ios-like")
set(library_subdir "${SWIFT_SDK_MACCATALYST_LIB_SUBDIR}")
endif()
set(lipo_target_dir "${SWIFTLIBEXEC_DIR}/${library_subdir}")
set(lipo_suffix "")
else()
set(lipo_target_dir "${SWIFT_RUNTIME_OUTPUT_INTDIR}")
set(lipo_suffix "-${sdk}")
endif()
if("${sdk}" STREQUAL "WINDOWS")
set(UNIVERSAL_NAME "${lipo_target_dir}/${name}${lipo_suffix}.exe")
else()
set(UNIVERSAL_NAME "${lipo_target_dir}/${name}${lipo_suffix}")
endif()
set(lipo_target "${name}-${sdk}")
if("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
set(codesign_arg CODESIGN)
endif()
precondition(THIN_INPUT_TARGETS)
_add_swift_lipo_target(SDK
${sdk}
TARGET
${lipo_target}
OUTPUT
${UNIVERSAL_NAME}
${codesign_arg}
${THIN_INPUT_TARGETS})
# Determine the subdirectory where this executable will be installed
set(resource_dir_sdk_subdir "${SWIFT_SDK_${sdk}_LIB_SUBDIR}")
if(maccatalyst_build_flavor STREQUAL "ios-like")
set(resource_dir_sdk_subdir "${SWIFT_SDK_MACCATALYST_LIB_SUBDIR}")
endif()
precondition(resource_dir_sdk_subdir)
if(sdk STREQUAL "WINDOWS" AND CMAKE_SYSTEM_NAME STREQUAL "Windows")
add_dependencies(${install_in_component} ${name}-windows-${SWIFT_PRIMARY_VARIANT_ARCH})
swift_install_in_component(TARGETS ${name}-windows-${SWIFT_PRIMARY_VARIANT_ARCH}
RUNTIME
DESTINATION "bin"
COMPONENT "${install_in_component}"
LIBRARY
DESTINATION "libexec${LLVM_LIBDIR_SUFFIX}/swift/${resource_dir_sdk_subdir}/${SWIFT_PRIMARY_VARIANT_ARCH}"
COMPONENT "${install_in_component}"
ARCHIVE
DESTINATION "libexec${LLVM_LIBDIR_SUFFIX}/swift/${resource_dir_sdk_subdir}/${SWIFT_PRIMARY_VARIANT_ARCH}"
COMPONENT "${install_in_component}"
PERMISSIONS
OWNER_READ OWNER_WRITE OWNER_EXECUTE
GROUP_READ GROUP_EXECUTE
WORLD_READ WORLD_EXECUTE)
else()
add_dependencies(${install_in_component} ${lipo_target})
set(install_dest "libexec${LLVM_LIBDIR_SUFFIX}/swift/${resource_dir_sdk_subdir}")
swift_install_in_component(FILES "${UNIVERSAL_NAME}"
DESTINATION ${install_dest}
COMPONENT "${install_in_component}"
PERMISSIONS
OWNER_READ OWNER_WRITE OWNER_EXECUTE
GROUP_READ GROUP_EXECUTE
WORLD_READ WORLD_EXECUTE
"${optional_arg}")
endif()
swift_is_installing_component(
"${install_in_component}"
is_installing)
# Add the arch-specific executable targets to the global exports
foreach(arch ${SWIFT_SDK_${sdk}_ARCHITECTURES})
set(VARIANT_SUFFIX "-${SWIFT_SDK_${sdk}_LIB_SUBDIR}-${arch}")
set(VARIANT_NAME "${name}${VARIANT_SUFFIX}")
if(is_installing)
set_property(GLOBAL APPEND
PROPERTY SWIFT_EXPORTS ${VARIANT_NAME})
else()
set_property(GLOBAL APPEND
PROPERTY SWIFT_BUILDTREE_EXPORTS ${VARIANT_NAME})
endif()
endforeach()
# Add the lipo target to the top-level convenience targets
if(SWIFTEXE_TARGET_BUILD_WITH_STDLIB)
foreach(arch ${SWIFT_SDK_${sdk}_ARCHITECTURES})
set(variant "-${SWIFT_SDK_${sdk}_LIB_SUBDIR}-${arch}")
if(TARGET "swift-stdlib${VARIANT_SUFFIX}" AND
TARGET "swift-test-stdlib${VARIANT_SUFFIX}")
add_dependencies("swift-stdlib${variant}" ${lipo_target})
add_dependencies("swift-test-stdlib${variant}" ${lipo_target})
endif()
endforeach()
endif()
if(SWIFTEXE_TARGET_BUILD_WITH_LIBEXEC)
foreach(arch ${SWIFT_SDK_${sdk}_ARCHITECTURES})
set(variant "-${SWIFT_SDK_${sdk}_LIB_SUBDIR}-${arch}")
if(TARGET "swift-libexec${variant}")
add_dependencies("swift-libexec${variant}" ${lipo_target})
endif()
endforeach()
endif()
endforeach()
endfunction()
Reference in New Issue View Git Blame Copy Permalink