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() # Compute the deployment version function(deployment_version result_var_name) set(arguments SDK DEPLOYMENT_VERSION_OSX DEPLOYMENT_VERSION_IOS DEPLOYMENT_VERSION_TVOS DEPLOYMENT_VERSION_WATCHOS DEPLOYMENT_VERSION_XROS ) cmake_parse_arguments(GETDEP "" "${arguments}" "" ${ARGN}) if("${GETDEP_SDK}" IN_LIST SWIFT_DARWIN_PLATFORMS) # Check if there's a specific OS deployment version needed for this invocation if("${GETDEP_SDK}" STREQUAL "OSX") set(DEPLOYMENT_VERSION ${GETDEP_DEPLOYMENT_VERSION_OSX}) elseif("${GETDEP_SDK}" STREQUAL "IOS" OR "${GETDEP_SDK}" STREQUAL "IOS_SIMULATOR") set(DEPLOYMENT_VERSION ${GETDEP_DEPLOYMENT_VERSION_IOS}) elseif("${GETDEP_SDK}" STREQUAL "TVOS" OR "${GETDEP_SDK}" STREQUAL "TVOS_SIMULATOR") set(DEPLOYMENT_VERSION ${GETDEP_DEPLOYMENT_VERSION_TVOS}) elseif("${GETDEP_SDK}" STREQUAL "WATCHOS" OR "${GETDEP_SDK}" STREQUAL "WATCHOS_SIMULATOR") set(DEPLOYMENT_VERSION ${GETDEP_DEPLOYMENT_VERSION_WATCHOS}) elseif("${GETDEP_SDK}" STREQUAL "XROS" OR "${GETDEP_SDK}" STREQUAL "XROS_SIMULATOR") set(DEPLOYMENT_VERSION ${GETDEP_DEPLOYMENT_VERSION_XROS}) endif() if("${DEPLOYMENT_VERSION}" STREQUAL "") set(DEPLOYMENT_VERSION "${SWIFT_SDK_${GETDEP_SDK}_DEPLOYMENT_VERSION}") endif() endif() if("${GETDEP_SDK}" STREQUAL "ANDROID") set(DEPLOYMENT_VERSION ${SWIFT_ANDROID_API_LEVEL}) endif() if("${GETDEP_SDK}" STREQUAL "FREESTANDING") set(DEPLOYMENT_VERSION "${SWIFT_SDK_${GETDEP_SDK}_DEPLOYMENT_VERSION}") endif() set("${result_var_name}" "${DEPLOYMENT_VERSION}" PARENT_SCOPE) 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(DEFINED maccatalyst_build_flavor AND DEFINED CFLAGS_DEPLOYMENT_VERSION_MACCATALYST) set(DEPLOYMENT_VERSION_OSX "${CFLAGS_DEPLOYMENT_VERSION_MACCATALYST}") else() set(DEPLOYMENT_VERSION_OSX "${CFLAGS_DEPLOYMENT_VERSION_OSX}") endif() deployment_version(DEPLOYMENT_VERSION SDK ${CFLAGS_SDK} DEPLOYMENT_VERSION_OSX "${DEPLOYMENT_VERSION_OSX}" 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}") # 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 $) 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. deployment_version(DEPLOYMENT_VERSION SDK "${SWIFTLIB_SINGLE_SDK}" 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}" DEPLOYMENT_VERSION_XROS "${SWIFTLIB_SINGLE_DEPLOYMENT_VERSION_XROS}") 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 StdlibDeploymentTarget 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" "StdlibDeploymentTarget" current "${def}") if(NOT SWIFT_STDLIB_ENABLE_STRICT_AVAILABILITY AND SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_AVAILABILITY_NAME) if(SWIFTLIB_SINGLE_SDK STREQUAL "OSX" AND SWIFTLIB_SINGLE_MACCATALYST_BUILD_FLAVOR STREQUAL "ios-like") string(REGEX MATCH "iOS ([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_DARWIN_DEPLOYMENT_VERSION_MACCATALYST}") string(REGEX REPLACE ":.*" ":iOS ${SWIFT_DARWIN_DEPLOYMENT_VERSION_MACCATALYST}" current "${current}") endif() elseif(SWIFTLIB_SINGLE_SDK STREQUAL "OSX" AND SWIFTLIB_SINGLE_MACCATALYST_BUILD_FLAVOR STREQUAL "zippered") string(REGEX MATCH "iOS ([0-9]+(\.[0-9]+)+)" ios_platform_version "${def}") string(REGEX MATCH "[0-9]+(\.[0-9]+)+" ios_version "${ios_platform_version}") string(REGEX MATCH "macOS ([0-9]+(\.[0-9]+)+)" macos_platform_version "${def}") string(REGEX MATCH "[0-9]+(\.[0-9]+)+" macos_version "${macos_platform_version}") if((NOT macos_version STREQUAL "9999" OR NOT ios_version STREQUAL "9999") AND (macos_version VERSION_GREATER "${DEPLOYMENT_VERSION}" OR ios_version VERSION_GREATER "${SWIFT_DARWIN_DEPLOYMENT_VERSION_MACCATALYST}")) string(REGEX REPLACE ":.*" ": macOS ${DEPLOYMENT_VERSION}, iOS ${SWIFT_DARWIN_DEPLOYMENT_VERSION_MACCATALYST}" current "${current}") endif() else() 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 "${DEPLOYMENT_VERSION}") string(REGEX REPLACE ":.*" ":${SWIFT_SDK_${SWIFTLIB_SINGLE_SDK}_AVAILABILITY_NAME} ${DEPLOYMENT_VERSION}" current "${current}") endif() 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 $) 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 $) 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 # $) 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-. 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 $ ${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 $) 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$<$: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") # Ensure compatibility with Android 15+ devices using 16KB memory pages. list(APPEND swiftlib_link_flags_all "-Wl,-z,max-page-size=16384") 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 $) 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$<$: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()