diff --git a/CMakeLists.txt b/CMakeLists.txt index d04f27e560097..dad1ecb5ad262 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -123,8 +123,11 @@ set(SWIFT_INSTALL_COMPONENTS "${_SWIFT_KNOWN_INSTALL_COMPONENTS}" CACHE STRING # * toolchain-dev-tools -- install development tools useful in a shared toolchain # * dev -- headers and libraries required to use Swift compiler as a library. -set(SWIFT_SDKS "" CACHE STRING - "If non-empty, limits building target binaries only to specified SDKs (despite other SDKs being available)") +set(SWIFT_CROSS_COMPILE_STDLIB_TARGETS "" CACHE STRING + "A list of deployment-targets to cross-compile the standard-library for (by default, the standard library is always compiled for the host)") + +set(SWIFT_SKIP_HOST_STDLIB "" CACHE STRING + "If True, will not build the standard library for the host") set(SWIFT_PRIMARY_VARIANT_SDK "" CACHE STRING "Primary SDK for target binaries") @@ -418,10 +421,97 @@ function(check_working_std_regex result_var_name) endfunction() check_working_std_regex(SWIFT_HAVE_WORKING_STD_REGEX) -# If SWIFT_HOST_VARIANT_SDK not given, try to detect from the CMAKE_SYSTEM_NAME. -if(SWIFT_HOST_VARIANT_SDK) - set(SWIFT_HOST_VARIANT_SDK_default "${SWIFT_HOST_VARIANT_SDK}") +# +# Enable additional warnings. +# +swift_common_cxx_warnings() + +# +# Configure SDKs. +# + +function(get_sdk_from_stdlib_target stdlib_target result_var_name) + string(REPLACE "-" ";" target_components "${stdlib_target}") + list(GET target_components 0 target_sdk) + + # Darwin SDK names don't match their stdlib-deployment-target names + if("${target_sdk}" STREQUAL "macosx") + set(target_sdk "OSX") + elseif("${target_sdk}" STREQUAL "iphoneos") + set(target_sdk "IOS") + elseif("${target_sdk}" STREQUAL "iphonesimulator") + set(target_sdk "IOS_SIMULATOR") + elseif("${target_sdk}" STREQUAL "appletvos") + set(target_sdk "TVOS") + elseif("${target_sdk}" STREQUAL "appletvsimulator") + set(target_sdk "TVOS_SIMULATOR") + elseif("${target_sdk}" STREQUAL "watchos") + set(target_sdk "WATCHOS") + elseif("${target_sdk}" STREQUAL "watchsimulator") + set(target_sdk "WATCHOS_SIMULATOR") + endif() + + string(TOUPPER "${target_sdk}" target_sdk) + set("${result_var_name}" "${target_sdk}" PARENT_SCOPE) +endfunction() + +function(get_arch_from_stdlib_target stdlib_target result_var_name) + string(REPLACE "-" ";" target_components "${stdlib_target}") + list(GET target_components 1 target_arch) + set("${result_var_name}" "${target_arch}" PARENT_SCOPE) +endfunction() + +# Calculate the triple for an sdk/architecture. +# Will only return a result for supported targets. +function(get_triple sdk arch result_var_name) + if("${sdk}" STREQUAL "LINUX") + if("${arch}" STREQUAL "x86_64") + set(triple "x86_64-unknown-linux-gnu") + elseif("${arch}" STREQUAL "aarch64") + set(triple "aarch64-unknown-linux-gnu") + elseif("${arch}" STREQUAL "s390x") + set(triple "s390x-unknown-linux-gnu") + elseif("${arch}" MATCHES "(powerpc64|powerpc64le)") + set(triple "${arch}-unknown-linux-gnu") + elseif("${arch}" MATCHES "(armv6|armv7)") + set(triple "${arch}-unknown-linux-gnueabihf") + endif() + elseif("${sdk}" STREQUAL "ANDROID") + if("${arch}" STREQUAL "armv7") + set(triple "armv7-none-linux-androideabi") + endif() + elseif("${sdk}" STREQUAL "FREEBSD") + if("${arch}" STREQUAL "x86_64") + # FIXME: Using the host OS version won't produce correct results for + # cross-compilation. + string(REPLACE "[-].*" "" FREEBSD_SYSTEM_VERSION ${CMAKE_SYSTEM_VERSION}) + message(STATUS "FreeBSD Version: ${FREEBSD_SYSTEM_VERSION}") + set(triple "x86_64-unknown-freebsd${FREEBSD_SYSTEM_VERSION}") + endif() + elseif("${sdk}" STREQUAL "CYGWIN") + if("${arch}" STREQUAL "x86_64") + set(triple "x86_64-unknown-windows-cygnus") + endif() + #FIXME: Add Darwin sdks + endif() + + set("${result_var_name}" "${triple}" PARENT_SCOPE) +endfunction() + +# Set SWIFT_HOST_VARIANT_SDK/ARCH +# - Parse from SWIFT_HOST, if given. +# - Derive from CMAKE_SYSTEM_NAME/PROCESSOR otherwise + +if(SWIFT_HOST) + get_sdk_from_stdlib_target("${SWIFT_HOST}" SWIFT_HOST_VARIANT_SDK_default) + get_arch_from_stdlib_target("${SWIFT_HOST}" SWIFT_HOST_VARIANT_ARCH_default) + if("${SWIFT_HOST_VARIANT_SDK_default}" STREQUAL "" OR + "${SWIFT_HOST_VARIANT_ARCH_default}" STREQUAL "") + message(FATAL_ERROR "Invalid SWIFT_HOST; cannot be parsed.") + endif() else() + + # Derive SDK if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux") set(SWIFT_HOST_VARIANT_SDK_default "LINUX") elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "FreeBSD") @@ -433,12 +523,8 @@ else() else() message(FATAL_ERROR "Unable to detect SDK for host system: ${CMAKE_SYSTEM_NAME}") endif() -endif() -# If SWIFT_HOST_VARIANT_ARCH not given, try to detect from the CMAKE_SYSTEM_PROCESSOR. -if(SWIFT_HOST_VARIANT_ARCH) - set(SWIFT_HOST_VARIANT_ARCH_default, "${SWIFT_HOST_VARIANT_ARCH}") -else() + # Derive ARCH if("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "x86_64") set(SWIFT_HOST_VARIANT_ARCH_default "x86_64") elseif("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "aarch64") @@ -464,47 +550,18 @@ set(SWIFT_HOST_VARIANT_SDK "${SWIFT_HOST_VARIANT_SDK_default}" CACHE STRING set(SWIFT_HOST_VARIANT_ARCH "${SWIFT_HOST_VARIANT_ARCH_default}" CACHE STRING "Deployment arch for Swift host tools (the compiler).") -# -# Enable additional warnings. -# -swift_common_cxx_warnings() - -# -# Configure SDKs. -# -function(is_sdk_requested name result_var_name) - if("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "${name}") - set("${result_var_name}" "TRUE" PARENT_SCOPE) - else() - list(FIND SWIFT_SDKS "${name}" sdk_index) - if(${sdk_index} EQUAL -1) - set("${result_var_name}" "FALSE" PARENT_SCOPE) - else() - set("${result_var_name}" "TRUE" PARENT_SCOPE) - endif() - endif() -endfunction() if(XCODE) # FIXME: Cannot cross-compile the standard library using Xcode. Xcode # insists on passing -mmacosx-version-min to the compiler, and we need # to pass -mios-version-min. Clang sees both options and complains. - set(SWIFT_SDKS "OSX") -endif() - -# FIXME: the parameters we specify in SWIFT_SDKS are lacking architecture specifics, -# so we need to hard-code it. For example, the SDK for Android is just 'ANDROID', -# which we assume below to be armv7. -# The iOS SDKs all have their architectures hardcoded because they are just specified by name (e.g. 'IOS' or 'WATCHOS'). -# We can't cross-compile the standard library for another linux architecture, -# because the SDK list would just be 'LINUX' and we couldn't disambiguate it from the host. -# -# To fix it, we would need to append the architecture to the SDKs, -# for example: 'OSX-x86_64;IOS-armv7;...etc'. -# We could easily do that - we have all of that information in build-script-impl. -# Also, we would need to be provided with the sysroot for each SDK (see SWIFT_ANDROID_SDK_PATH/SWIFT_SDK_ANDROID_PATH). -# Darwin targets cheat and use `xcrun`. + set(SWIFT_CROSS_COMPILE_STDLIB_TARGETS "") +endif() + + +# FIXME: Configure prefixes should include architecture, not just SDK name +# Otherwise, we can't configure two linux targets with different sysroots. if("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "LINUX") @@ -512,47 +569,45 @@ if("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "LINUX") set(SWIFT_HOST_VARIANT "linux" CACHE STRING "Deployment OS for Swift host tools (the compiler) [linux].") - # Calculate the host triple - if("${SWIFT_HOST_TRIPLE}" STREQUAL "") - if("${SWIFT_HOST_VARIANT_ARCH}" STREQUAL "x86_64") - set(SWIFT_HOST_TRIPLE "x86_64-unknown-linux-gnu") - elseif("${SWIFT_HOST_VARIANT_ARCH}" STREQUAL "aarch64") - set(SWIFT_HOST_TRIPLE "aarch64-unknown-linux-gnu") - elseif("${SWIFT_HOST_VARIANT_ARCH}" MATCHES "(powerpc64|powerpc64le)") - set(SWIFT_HOST_TRIPLE "${SWIFT_HOST_VARIANT_ARCH}-unknown-linux-gnu") - elseif("${SWIFT_HOST_VARIANT_ARCH}" MATCHES "s390x") - set(SWIFT_HOST_TRIPLE "s390x-unknown-linux-gnu") - elseif("${SWIFT_HOST_VARIANT_ARCH}" MATCHES "(armv6|armv7)") - set(SWIFT_HOST_TRIPLE "${SWIFT_HOST_VARIANT_ARCH}-unknown-linux-gnueabihf") - else() - message(FATAL_ERROR "Unable to calculate triple for linux host on ${SWIFT_HOST_VARIANT_ARCH}") + # Configure the host + if(NOT SWIFT_SKIP_HOST_STDLIB) + get_triple("${SWIFT_HOST_VARIANT_SDK}" "${SWIFT_HOST_VARIANT_ARCH}" SWIFT_HOST_TRIPLE) + if(NOT SWIFT_HOST_TRIPLE) + message(FATAL_ERROR "Unsupported Linux target: ${SWIFT_HOST_VARIANT_ARCH}") endif() - endif() - # Should we build the standard library for the host? - is_sdk_requested(LINUX swift_build_linux) - if(swift_build_linux) - configure_sdk_unix(LINUX "Linux" "linux" "${SWIFT_HOST_VARIANT}" "${SWIFT_HOST_VARIANT_ARCH}" "${SWIFT_HOST_TRIPLE}" "/") + configure_sdk_unix(LINUX "Linux" "linux" "${SWIFT_HOST_VARIANT}" "${SWIFT_HOST_VARIANT_ARCH}" "${SWIFT_HOST_TRIPLE}" "${CMAKE_SYSROOT}") set(SWIFT_PRIMARY_VARIANT_SDK_default "${SWIFT_HOST_VARIANT_SDK}") set(SWIFT_PRIMARY_VARIANT_ARCH_default "${SWIFT_HOST_VARIANT_ARCH}") endif() - # Compatible cross-compile SDKS for LINUX: ANDROID (arch always armv7) - is_sdk_requested(ANDROID swift_build_android) - if("${SWIFT_ANDROID_NDK_PATH}" STREQUAL "") - set(swift_can_crosscompile_stdlib_android FALSE) - else() - set(swift_can_crosscompile_stdlib_android TRUE) - endif() + # Configure additional (cross-compile) targets. + foreach(stdlib_target ${SWIFT_CROSS_COMPILE_STDLIB_TARGETS}) + get_sdk_from_stdlib_target("${stdlib_target}" target_sdk) + get_arch_from_stdlib_target("${stdlib_target}" target_arch) + get_triple("${target_sdk}" "${target_arch}" target_triple) + + if(NOT(target_sdk AND target_arch AND target_triple)) + message(FATAL_ERROR "Unsupported target: ${stdlib_target}") + endif() - if(swift_build_android AND ${swift_can_crosscompile_stdlib_android}) - configure_sdk_unix(ANDROID "Android" "android" "android" "armv7" "armv7-none-linux-androideabi" "${SWIFT_ANDROID_SDK_PATH}") - # If we're not building for the host, the cross-compiled target should be the 'primary variant'. - if("${swift_build_linux}" STREQUAL "FALSE") - set(SWIFT_PRIMARY_VARIANT_SDK_default "ANDROID") - set(SWIFT_PRIMARY_VARIANT_ARCH_default "armv7") + # Compatible cross-compile SDKS for LINUX: ANDROID (only armv7) + if("${target_sdk}" STREQUAL "ANDROID") + if(NOT SWIFT_ANDROID_NDK_PATH) + message(FATAL_ERROR "Android NDK Path is required") + endif() + configure_sdk_unix(ANDROID "Android" "android" "android" "${target_arch}" "${target_triple}" "${SWIFT_ANDROID_SDK_PATH}") + else() + message(FATAL_ERROR "We don't support cross-compiling for ${target_sdk} on Linux yet") endif() - endif() + + # If we're not building for the host, the first cross-compiled target should be the 'primary variant'. + if(SWIFT_SKIP_HOST_STDLIB AND NOT SWIFT_PRIMARY_VARIANT_SDK_default) + set(SWIFT_PRIMARY_VARIANT_SDK_default "${target_sdk}") + set(SWIFT_PRIMARY_VARIANT_ARCH_default "${target_arch}") + endif() + + endforeach() elseif("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "FREEBSD") @@ -560,14 +615,14 @@ elseif("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "FREEBSD") set(SWIFT_HOST_VARIANT "freebsd" CACHE STRING "Deployment OS for Swift host tools (the compiler) [freebsd].") - # FIXME: Using the host OS version won't produce correct results for - # cross-compilation. - string(REPLACE "[-].*" "" FREEBSD_SYSTEM_VERSION ${CMAKE_SYSTEM_VERSION}) - message(STATUS "FreeBSD Version: ${FREEBSD_SYSTEM_VERSION}") - configure_sdk_unix(FREEBSD "FreeBSD" "freebsd" "freebsd" "x86_64" - "x86_64-unknown-freebsd${FREEBSD_SYSTEM_VERSION}" "/") + get_triple("${SWIFT_HOST_VARIANT_SDK}" "${SWIFT_HOST_VARIANT_ARCH}" SWIFT_HOST_TRIPLE) + if(NOT SWIFT_HOST_TRIPLE) + message(FATAL_ERROR "Unsupported FreeBSD target: ${SWIFT_HOST_VARIANT_ARCH}") + endif() + + configure_sdk_unix(FREEBSD "FreeBSD" "freebsd" "${SWIFT_HOST_VARIANT}" "${SWIFT_HOST_VARIANT_ARCH}" "${SWIFT_HOST_TRIPLE}" "${CMAKE_SYSROOT}") set(SWIFT_PRIMARY_VARIANT_SDK_default "${SWIFT_HOST_VARIANT_SDK}") - set(SWIFT_PRIMARY_VARIANT_ARCH_default "x86_64") + set(SWIFT_PRIMARY_VARIANT_ARCH_default "${SWIFT_HOST_VARIANT_ARCH}") elseif("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "CYGWIN") @@ -575,9 +630,17 @@ elseif("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "CYGWIN") set(SWIFT_HOST_VARIANT "windows" CACHE STRING "Deployment OS for Swift host tools (the compiler) [windows].") - configure_sdk_unix(CYGWIN "Cygwin" "windows" "cygwin" "windows" "x86_64-unknown-windows-cygnus" "/") + get_triple("${SWIFT_HOST_VARIANT_SDK}" "${SWIFT_HOST_VARIANT_ARCH}" SWIFT_HOST_TRIPLE) + if(NOT SWIFT_HOST_TRIPLE) + message(FATAL_ERROR "Unsupported Cygwin target: ${SWIFT_HOST_VARIANT_ARCH}") + endif() + + # FIXME: The arguments here look incorrect + # - 'cygwin' should be 'windows' (the variant, as above) + # - 'windows' should be '${SWIFT_HOST_VARIANT_ARCH}' (the architecture) + configure_sdk_unix(CYGWIN "Cygwin" "windows" "cygwin" "windows" "${SWIFT_HOST_TRIPLE}" "${CMAKE_SYSROOT}") set(SWIFT_PRIMARY_VARIANT_SDK_default "${SWIFT_HOST_VARIANT_SDK}") - set(SWIFT_PRIMARY_VARIANT_ARCH_default "x86_64") + set(SWIFT_PRIMARY_VARIANT_ARCH_default "${SWIFT_HOST_VARIANT_ARCH}") elseif("${SWIFT_HOST_VARIANT_SDK}" MATCHES "(OSX|IOS*|TVOS*|WATCHOS*)") @@ -594,34 +657,61 @@ elseif("${SWIFT_HOST_VARIANT_SDK}" MATCHES "(OSX|IOS*|TVOS*|WATCHOS*)") message(STATUS "${xcode_version}") message(STATUS "") - is_sdk_requested(OSX swift_build_osx) - if(swift_build_osx) - configure_sdk_darwin( - OSX "OS X" "${SWIFT_DARWIN_DEPLOYMENT_VERSION_OSX}" - macosx macosx macosx "x86_64") + # Compatible host/cross-compile SDKS for Darwin OSes: + # OSX, IOS(_SIMULATOR), TVOS(_SIMULATOR), WATCHOS(_SIMULATOR) + + # - configure_sdk_darwin handles the architectures for each SDK, + # so we need to gather them up (including merging host/cross targets in one list) + # - configure_sdk_darwin calculates its own triple, so + # Darwin target validation happens here. + + set(OSX_VALID_ARCHITECTURES "x86_64") + set(IOS_VALID_ARCHITECTURES "armv7;armv7s;arm64") + set(TVOS_VALID_ARCHITECTURES "arm64") + set(WATCHOS_VALID_ARCHITECTURES "armv7k") + set(IOS_SIMULATOR_VALID_ARCHITECTURES "i386;x86_64") + set(TVOS_SIMULATOR_VALID_ARCHITECTURES "x86_64") + set(WATCHOS_SIMULATOR_VALID_ARCHITECTURES "i386") + + foreach(stdlib_target ${SWIFT_CROSS_COMPILE_STDLIB_TARGETS}) + get_sdk_from_stdlib_target("${stdlib_target}" target_sdk) + get_arch_from_stdlib_target("${stdlib_target}" target_arch) + + list_contains("${${target_sdk}_VALID_ARCHITECTURES}" "${target_arch}" is_valid_arch) + if(NOT is_valid_arch) + message(FATAL_ERROR "${target_arch} is not a recognised architecture for ${target_sdk}") + endif() + list(APPEND SWIFT_TARGET_${target_sdk}_ARCHS "${target_arch}") + endforeach() + + if(NOT SWIFT_SKIP_HOST_STDLIB) + list(APPEND SWIFT_TARGET_${SWIFT_HOST_VARIANT_SDK}_ARCHS "${SWIFT_HOST_VARIANT_ARCH}") + endif() + + # OSX + if(SWIFT_TARGET_OSX_ARCHS) + configure_sdk_darwin(OSX "OS X" "${SWIFT_DARWIN_DEPLOYMENT_VERSION_OSX}" + macosx macosx macosx "${SWIFT_TARGET_OSX_ARCHS}") configure_target_variant(OSX-DA "OS X Debug+Asserts" OSX DA "Debug+Asserts") configure_target_variant(OSX-RA "OS X Release+Asserts" OSX RA "Release+Asserts") configure_target_variant(OSX-R "OS X Release" OSX R "Release") endif() - # Compatible cross-compile SDKS for Darwin OSes: IOS, IOS_SIMULATOR, TVOS, - # TVOS_SIMULATOR, WATCHOS, WATCHOS_SIMULATOR (archs hardcoded below). - - is_sdk_requested(IOS swift_build_ios) - if(swift_build_ios) + # IOS + if(SWIFT_TARGET_IOS_ARCHS) configure_sdk_darwin( IOS "iOS" "${SWIFT_DARWIN_DEPLOYMENT_VERSION_IOS}" - iphoneos ios ios "armv7;armv7s;arm64") + iphoneos ios ios "${SWIFT_TARGET_IOS_ARCHS}") configure_target_variant(IOS-DA "iOS Debug+Asserts" IOS DA "Debug+Asserts") configure_target_variant(IOS-RA "iOS Release+Asserts" IOS RA "Release+Asserts") configure_target_variant(IOS-R "iOS Release" IOS R "Release") endif() - is_sdk_requested(IOS_SIMULATOR swift_build_ios_simulator) - if(swift_build_ios_simulator) + # IOS_SIMULATOR + if(SWIFT_TARGET_IOS_SIMULATOR_ARCHS) configure_sdk_darwin( IOS_SIMULATOR "iOS Simulator" "${SWIFT_DARWIN_DEPLOYMENT_VERSION_IOS}" - iphonesimulator ios-simulator ios "i386;x86_64") + iphonesimulator ios-simulator ios "${SWIFT_TARGET_IOS_SIMULATOR_ARCHS}") configure_target_variant( IOS_SIMULATOR-DA "iOS Debug+Asserts" IOS_SIMULATOR DA "Debug+Asserts") configure_target_variant( @@ -629,22 +719,22 @@ elseif("${SWIFT_HOST_VARIANT_SDK}" MATCHES "(OSX|IOS*|TVOS*|WATCHOS*)") configure_target_variant( IOS_SIMULATOR-R "iOS Release" IOS_SIMULATOR R "Release") endif() - - is_sdk_requested(TVOS swift_build_tvos) - if(swift_build_tvos) + + # TVOS + if(SWIFT_TARGET_TVOS_ARCHS) configure_sdk_darwin( TVOS "tvOS" "${SWIFT_DARWIN_DEPLOYMENT_VERSION_TVOS}" - appletvos tvos tvos "arm64") + appletvos tvos tvos "${SWIFT_TARGET_TVOS_ARCHS}") configure_target_variant(TVOS-DA "tvOS Debug+Asserts" TVOS DA "Debug+Asserts") configure_target_variant(TVOS-RA "tvOS Release+Asserts" TVOS RA "Release+Asserts") configure_target_variant(TVOS-R "tvOS Release" TVOS R "Release") endif() - - is_sdk_requested(TVOS_SIMULATOR swift_build_tvos_simulator) - if(swift_build_tvos_simulator) + + # TVOS_SIMULATOR + if(SWIFT_TARGET_TVOS_SIMULATOR_ARCHS) configure_sdk_darwin( TVOS_SIMULATOR "tvOS Simulator" "${SWIFT_DARWIN_DEPLOYMENT_VERSION_TVOS}" - appletvsimulator tvos-simulator tvos "x86_64") + appletvsimulator tvos-simulator tvos "${SWIFT_TARGET_TVOS_SIMULATOR_ARCHS}") configure_target_variant( TVOS_SIMULATOR-DA "tvOS Debug+Asserts" TVOS_SIMULATOR DA "Debug+Asserts") configure_target_variant( @@ -652,22 +742,22 @@ elseif("${SWIFT_HOST_VARIANT_SDK}" MATCHES "(OSX|IOS*|TVOS*|WATCHOS*)") configure_target_variant( TVOS_SIMULATOR-R "tvOS Release" TVOS_SIMULATOR R "Release") endif() - - is_sdk_requested(WATCHOS swift_build_watchos) - if(swift_build_watchos) + + # WATCHOS + if(SWIFT_TARGET_WATCHOS_ARCHS) configure_sdk_darwin( WATCHOS "watchOS" "${SWIFT_DARWIN_DEPLOYMENT_VERSION_WATCHOS}" - watchos watchos watchos "armv7k") + watchos watchos watchos "${SWIFT_TARGET_WATCHOS_ARCHS}") configure_target_variant(WATCHOS-DA "watchOS Debug+Asserts" WATCHOS DA "Debug+Asserts") configure_target_variant(WATCHOS-RA "watchOS Release+Asserts" WATCHOS RA "Release+Asserts") configure_target_variant(WATCHOS-R "watchOS Release" WATCHOS R "Release") endif() - - is_sdk_requested(WATCHOS_SIMULATOR swift_build_watchos_simulator) - if(swift_build_watchos_simulator) + + # WATCHOS_SIMULATOR + if(SWIFT_TARGET_WATCHOS_SIMULATOR_ARCHS) configure_sdk_darwin( WATCHOS_SIMULATOR "watchOS Simulator" "${SWIFT_DARWIN_DEPLOYMENT_VERSION_WATCHOS}" - watchsimulator watchos-simulator watchos "i386") + watchsimulator watchos-simulator watchos "${SWIFT_TARGET_WATCHOS_SIMULATOR_ARCHS}") configure_target_variant(WATCHOS_SIMULATOR-DA "watchOS Debug+Asserts" WATCHOS_SIMULATOR DA "Debug+Asserts") configure_target_variant(WATCHOS_SIMULATOR-RA "watchOS Release+Asserts" WATCHOS_SIMULATOR RA "Release+Asserts") configure_target_variant(WATCHOS_SIMULATOR-R "watchOS Release" WATCHOS_SIMULATOR R "Release") @@ -688,30 +778,39 @@ elseif("${SWIFT_HOST_VARIANT_SDK}" MATCHES "(OSX|IOS*|TVOS*|WATCHOS*)") # Primary variant is always OSX; even on iOS hosts. set(SWIFT_PRIMARY_VARIANT_SDK_default "OSX") set(SWIFT_PRIMARY_VARIANT_ARCH_default "x86_64") - +else() + message(FATAL_ERROR "Unknown Host SDK") endif() -if("${SWIFT_PRIMARY_VARIANT_SDK}" STREQUAL "") - set(SWIFT_PRIMARY_VARIANT_SDK "${SWIFT_PRIMARY_VARIANT_SDK_default}") -endif() -if("${SWIFT_PRIMARY_VARIANT_ARCH}" STREQUAL "") - set(SWIFT_PRIMARY_VARIANT_ARCH "${SWIFT_PRIMARY_VARIANT_ARCH_default}") -endif() +# Confirm that all requested SDKs were configured. -if("${SWIFT_SDKS}" STREQUAL "") - set(SWIFT_SDKS "${SWIFT_CONFIGURED_SDKS}") +if((NOT SWIFT_SKIP_HOST_STDLIB) AND SWIFT_HOST_VARIANT_SDK) + list(APPEND requested_sdks "${SWIFT_HOST_VARIANT_SDK}") endif() - -list_subtract("${SWIFT_SDKS}" "${SWIFT_CONFIGURED_SDKS}" unknown_sdks) +foreach(stdlib_target ${SWIFT_CROSS_COMPILE_STDLIB_TARGETS}) + get_sdk_from_stdlib_target("${stdlib_target}" target_sdk) + list(APPEND requested_sdks "${target_sdk}") +endforeach() +list(REMOVE_DUPLICATES requested_sdks) +list_subtract("${requested_sdks}" "${SWIFT_CONFIGURED_SDKS}" unknown_sdks) if(NOT "${unknown_sdks}" STREQUAL "") - message(FATAL_ERROR "Unknown SDKs: ${unknown_sdks}") + message(FATAL_ERROR "${unknown_sdks} was requested but not configured.") endif() if("${SWIFT_CONFIGURED_SDKS}" STREQUAL "") message(FATAL_ERROR "No SDKs selected.") endif() +# Set sdk/arch flags. + +if("${SWIFT_PRIMARY_VARIANT_SDK}" STREQUAL "") + set(SWIFT_PRIMARY_VARIANT_SDK "${SWIFT_PRIMARY_VARIANT_SDK_default}") +endif() +if("${SWIFT_PRIMARY_VARIANT_ARCH}" STREQUAL "") + set(SWIFT_PRIMARY_VARIANT_ARCH "${SWIFT_PRIMARY_VARIANT_ARCH_default}") +endif() + if("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "") message(FATAL_ERROR "No SDK for host tools.") endif() @@ -724,8 +823,10 @@ set(SWIFT_PRIMARY_VARIANT_SUFFIX "-${SWIFT_SDK_${SWIFT_PRIMARY_VARIANT_SDK}_LIB_SUBDIR}-${SWIFT_PRIMARY_VARIANT_ARCH}") # Clear universal library names to prevent adding duplicates -foreach(sdk ${SWIFT_SDKS}) - unset(UNIVERSAL_LIBRARY_NAMES_${SWIFT_SDK_${sdk}_LIB_SUBDIR} CACHE) +unset(UNIVERSAL_LIBRARY_NAMES_${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR} CACHE) +foreach(stdlib_target ${SWIFT_CROSS_COMPILE_STDLIB_TARGETS}) + get_sdk_from_stdlib_target("${stdlib_target}" target_sdk) + unset(UNIVERSAL_LIBRARY_NAMES_${SWIFT_SDK_${target_sdk}_LIB_SUBDIR} CACHE) endforeach() if(SWIFT_PARALLEL_LINK_JOBS) @@ -744,13 +845,15 @@ if("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin") set(CMAKE_OSX_DEPLOYMENT_TARGET "") endif() -message(STATUS "Building host Swift tools for ${SWIFT_HOST_VARIANT_SDK} ${SWIFT_HOST_VARIANT_ARCH}") +message(STATUS "Configuration Summary:") +message(STATUS "") +message(STATUS "Host for Swift tools: ${SWIFT_HOST_VARIANT_SDK} ${SWIFT_HOST_VARIANT_ARCH}") message(STATUS " Build type: ${CMAKE_BUILD_TYPE}") message(STATUS " Assertions: ${LLVM_ENABLE_ASSERTIONS}") message(STATUS " LTO: ${SWIFT_TOOLS_ENABLE_LTO}") message(STATUS "") -message(STATUS "Building Swift standard library and SDK overlays for SDKs: ${SWIFT_SDKS}") +message(STATUS "Swift standard library and SDK overlay targets: ${SWIFT_CONFIGURED_SDKS}") message(STATUS " Build type: ${SWIFT_STDLIB_BUILD_TYPE}") message(STATUS " Assertions: ${SWIFT_STDLIB_ASSERTIONS}") message(STATUS "") @@ -790,8 +893,7 @@ if(SWIFT_BUILD_TOOLS) add_subdirectory(tools) endif() -is_sdk_requested("${SWIFT_HOST_VARIANT_SDK}" SWIFT_HOST_SDK_REQUESTED) -if(SWIFT_BUILD_TOOLS AND SWIFT_BUILD_STDLIB AND SWIFT_HOST_SDK_REQUESTED) +if(SWIFT_BUILD_TOOLS AND SWIFT_BUILD_STDLIB AND NOT SWIFT_SKIP_HOST_STDLIB) add_subdirectory(tools/swift-reflection-dump) endif() diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt index 8c614a182a902..c54fe68a51980 100644 --- a/benchmark/CMakeLists.txt +++ b/benchmark/CMakeLists.txt @@ -199,7 +199,7 @@ endforeach() set(executable_targets) -if(SWIFT_SDKS) +if(SWIFT_CONFIGURED_SDKS) set(IS_SWIFT_BUILD true) endif() diff --git a/benchmark/scripts/generate_harness/CMakeLists.txt_template b/benchmark/scripts/generate_harness/CMakeLists.txt_template index 528e61c7e6a6c..cde3ff771d0b1 100644 --- a/benchmark/scripts/generate_harness/CMakeLists.txt_template +++ b/benchmark/scripts/generate_harness/CMakeLists.txt_template @@ -137,7 +137,7 @@ endforeach() set(executable_targets) -if(SWIFT_SDKS) +if(SWIFT_CONFIGURED_SDKS) set(IS_SWIFT_BUILD true) endif() diff --git a/cmake/modules/AddSwift.cmake b/cmake/modules/AddSwift.cmake index e205e18f40b73..b0df023c392a9 100644 --- a/cmake/modules/AddSwift.cmake +++ b/cmake/modules/AddSwift.cmake @@ -1106,9 +1106,9 @@ function(add_swift_library name) set(SWIFTLIB_INSTALL_IN_COMPONENT dev) endif() - # If target SDKs are not specified, build for all known SDKs. + # If target SDKs are not specified, build for all configured SDKs. if("${SWIFTLIB_TARGET_SDKS}" STREQUAL "") - set(SWIFTLIB_TARGET_SDKS ${SWIFT_SDKS}) + set(SWIFTLIB_TARGET_SDKS ${SWIFT_CONFIGURED_SDKS}) endif() # All Swift code depends on the standard library, except for the standard @@ -1162,12 +1162,14 @@ function(add_swift_library name) # 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) - if(SWIFTLIB_FORCE_BUILD_FOR_HOST_SDK) + "${SWIFTLIB_TARGET_SDKS}" "${SWIFT_CONFIGURED_SDKS}" SWIFTLIB_TARGET_SDKS) + list_contains("${SWIFT_CONFIGURED_SDKS}" "${SWIFT_HOST_VARIANT_SDK}" IS_BUILDING_HOST) + if(SWIFTLIB_FORCE_BUILD_FOR_HOST_SDK AND IS_BUILDING_HOST) list_union( "${SWIFTLIB_TARGET_SDKS}" "${SWIFT_HOST_VARIANT_SDK}" SWIFTLIB_TARGET_SDKS) endif() + foreach(sdk ${SWIFTLIB_TARGET_SDKS}) set(THIN_INPUT_TARGETS) @@ -1325,7 +1327,6 @@ function(add_swift_library name) # Determine the subdirectory where this library will be installed. set(resource_dir_sdk_subdir "${SWIFT_SDK_${sdk}_LIB_SUBDIR}") - if("${resource_dir_sdk_subdir}" STREQUAL "") message(FATAL_ERROR "internal error: the variable should be non-empty") endif() @@ -1621,7 +1622,7 @@ function(add_swift_target_executable name) swiftCore) endif() - foreach(sdk ${SWIFT_SDKS}) + foreach(sdk ${SWIFT_CONFIGURED_SDKS}) foreach(arch ${SWIFT_SDK_${sdk}_ARCHITECTURES}) set(VARIANT_SUFFIX "-${SWIFT_SDK_${sdk}_LIB_SUBDIR}-${arch}") set(VARIANT_NAME "${name}${VARIANT_SUFFIX}") diff --git a/cmake/modules/SwiftConfigureSDK.cmake b/cmake/modules/SwiftConfigureSDK.cmake index 219330c7d21b6..0ac7ef71e0a9b 100644 --- a/cmake/modules/SwiftConfigureSDK.cmake +++ b/cmake/modules/SwiftConfigureSDK.cmake @@ -3,7 +3,7 @@ # Each element in this list is an SDK for which the various # SWIFT_SDK_${name}_* variables are defined. Swift libraries will be # built for each variant. -set(SWIFT_CONFIGURED_SDKS) +set(SWIFT_CONFIGURED_SDKS "") # Report the given SDK to the user. function(_report_sdk prefix) @@ -106,6 +106,8 @@ macro(configure_sdk_darwin # Add this to the list of known SDKs. list(APPEND SWIFT_CONFIGURED_SDKS "${prefix}") + set(SWIFT_CONFIGURED_SDKS "${SWIFT_CONFIGURED_SDKS}" CACHE STRING + "The SDKs which have been configured to build") _report_sdk("${prefix}") endmacro() @@ -134,6 +136,8 @@ macro(configure_sdk_unix # Add this to the list of known SDKs. list(APPEND SWIFT_CONFIGURED_SDKS "${prefix}") + set(SWIFT_CONFIGURED_SDKS "${SWIFT_CONFIGURED_SDKS}" CACHE STRING + "The SDKs which have been configured to build") _report_sdk("${prefix}") endmacro() diff --git a/cmake/modules/SwiftList.cmake b/cmake/modules/SwiftList.cmake index 2e555e14234c9..06f64d66c28d7 100644 --- a/cmake/modules/SwiftList.cmake +++ b/cmake/modules/SwiftList.cmake @@ -30,3 +30,12 @@ function(list_union lhs rhs result_var_name) endforeach() set("${result_var_name}" "${result}" PARENT_SCOPE) endfunction() + +function(list_contains list item result_var_name) + list(FIND list "${item}" index) + if(${index} EQUAL -1) + set("${result_var_name}" 0 PARENT_SCOPE) + else() + set("${result_var_name}" 1 PARENT_SCOPE) + endif() +endfunction() \ No newline at end of file diff --git a/stdlib/CMakeLists.txt b/stdlib/CMakeLists.txt index d46e8f369fe45..91e112cd3843c 100644 --- a/stdlib/CMakeLists.txt +++ b/stdlib/CMakeLists.txt @@ -17,7 +17,7 @@ if(SWIFT_BUILD_STATIC_STDLIB) endif() add_custom_target(swift-stdlib-all) -foreach(SDK ${SWIFT_SDKS}) +foreach(SDK ${SWIFT_CONFIGURED_SDKS}) add_custom_target("swift-stdlib-${SWIFT_SDK_${SDK}_LIB_SUBDIR}") add_custom_target("swift-test-stdlib-${SWIFT_SDK_${SDK}_LIB_SUBDIR}") foreach(ARCH ${SWIFT_SDK_${SDK}_ARCHITECTURES}) diff --git a/stdlib/private/SwiftReflectionTest/CMakeLists.txt b/stdlib/private/SwiftReflectionTest/CMakeLists.txt index e03f724c9830b..99e183cf53a77 100644 --- a/stdlib/private/SwiftReflectionTest/CMakeLists.txt +++ b/stdlib/private/SwiftReflectionTest/CMakeLists.txt @@ -3,7 +3,7 @@ add_swift_library(swiftSwiftReflectionTest ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I SWIFT_MODULE_DEPENDS Darwin INSTALL_IN_COMPONENT stdlib-experimental) -foreach(SDK ${SWIFT_SDKS}) +foreach(SDK ${SWIFT_CONFIGURED_SDKS}) foreach(ARCH ${SWIFT_SDK_${SDK}_ARCHITECTURES}) set(VARIANT_SUFFIX "-${SWIFT_SDK_${SDK}_LIB_SUBDIR}-${ARCH}") add_dependencies( diff --git a/stdlib/public/Platform/CMakeLists.txt b/stdlib/public/Platform/CMakeLists.txt index 1878a2fb8134a..2c96a3abd3505 100644 --- a/stdlib/public/Platform/CMakeLists.txt +++ b/stdlib/public/Platform/CMakeLists.txt @@ -29,7 +29,7 @@ add_swift_library(${swift_platform_name} ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_ ${swift_platform_flags}) set(glibc_modulemap_target_list) -foreach(sdk ${SWIFT_SDKS}) +foreach(sdk ${SWIFT_CONFIGURED_SDKS}) if("${sdk}" STREQUAL "LINUX" OR "${sdk}" STREQUAL "FREEBSD" OR "${sdk}" STREQUAL "ANDROID" OR diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index ff0732014c3cf..724fac735ebaf 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -139,7 +139,7 @@ if(PYTHONINTERP_FOUND) only_long ) - foreach(SDK ${SWIFT_SDKS}) + foreach(SDK ${SWIFT_CONFIGURED_SDKS}) foreach(ARCH ${SWIFT_SDK_${SDK}_ARCHITECTURES}) # Configure variables for this subdirectory. set(VARIANT_SUFFIX "-${SWIFT_SDK_${SDK}_LIB_SUBDIR}-${ARCH}") diff --git a/utils/SwiftBuildSupport.py b/utils/SwiftBuildSupport.py index bf5a117108389..9fc0ba4615771 100644 --- a/utils/SwiftBuildSupport.py +++ b/utils/SwiftBuildSupport.py @@ -142,7 +142,8 @@ def get_preset_options(substitutions, preset_file_names, preset_name): diagnostics.fatal("missing option(s) for preset '" + preset_name + "': " + ", ".join(missing_opts)) - # Migrate 'swift-sdks' parameter to 'stdlib-deployment-targets' + # Migrate 'swift-sdks' parameter to + # 'cross-compile-stdlib-deployment-targets' for opt in build_script_impl_opts: if opt.startswith("--swift-sdks"): sdks_to_configure = opt.split("=")[1].split(";") @@ -164,8 +165,10 @@ def get_preset_options(substitutions, preset_file_names, preset_name): tgts += StdlibDeploymentTarget.AppleWatch.targets elif sdk == "WATCHOS_SIMULATOR": tgts += StdlibDeploymentTarget.AppleWatchSimulator.targets + tgts = [x for x in tgts + if x != StdlibDeploymentTarget.host_target()] - build_script_opts.append("--stdlib-deployment-targets=" + + build_script_opts.append("--cross-compile-stdlib-deployment-targets=" + " ".join([tgt.name for tgt in tgts])) # Filter the swift-sdks parameter build_script_impl_opts = [opt for opt in build_script_impl_opts diff --git a/utils/build-presets.ini b/utils/build-presets.ini index 8e23e8635a5a8..3a77951a48e2f 100644 --- a/utils/build-presets.ini +++ b/utils/build-presets.ini @@ -74,7 +74,7 @@ skip-build-tvos skip-test-tvos skip-build-watchos skip-test-watchos -stdlib-deployment-targets=macosx-x86_64 +cross-compile-stdlib-deployment-targets='' swift-primary-variant-sdk=OSX swift-primary-variant-arch=x86_64 diff --git a/utils/build-script b/utils/build-script index 7ca4356b0742e..1cd234b1ac723 100755 --- a/utils/build-script +++ b/utils/build-script @@ -74,47 +74,57 @@ class HostSpecificConfiguration(object): def __init__(self, host_target, invocation): """Initialize for the given `host_target`.""" - # Compute the set of deployment targets to configure/build. args = invocation.args + + # [*] Compute the list of deployment targets to configure. + # + # We only need to configure cross-compiled stdlib targets. + # The host_target is implicitly configured by CMake. + + self.host_target = StdlibDeploymentTarget\ + .get_target_for_name(host_target) + if self.host_target is None: + diagnostics.fatal("unknown host target: %r" % ( + host_target)) + + self.stdlib_targets_to_configure = [] + # FIXME: Cross-compiled hosts don't support cross-compiled targets + # or filtering build lists, only because we don't + # have an argument structure to define them for NxM hosts and targets. if host_target == args.host_target: - # This host is the user's desired product, so honor the requested - # set of targets to configure/build. - stdlib_targets_to_configure = args.stdlib_deployment_targets - if "all" in args.build_stdlib_deployment_targets: - stdlib_targets_to_build = set(stdlib_targets_to_configure) - else: - stdlib_targets_to_build = set( - args.build_stdlib_deployment_targets).intersection( - set(args.stdlib_deployment_targets)) - else: - # Otherwise, this is a host we are building as part of - # cross-compiling, so we only need the target itself. - stdlib_targets_to_configure = [host_target] - stdlib_targets_to_build = set(stdlib_targets_to_configure) - - # Compute the lists of **CMake** targets for each use case (configure - # vs. build vs. run) and the SDKs to configure with. - self.sdks_to_configure = set() + for name in args.cross_compile_stdlib_deployment_targets: + dpymt_target = StdlibDeploymentTarget.get_target_for_name(name) + if dpymt_target is None: + diagnostics.fatal("unknown stdlib target: %r" % ( + name)) + else: + self.stdlib_targets_to_configure.append(dpymt_target) + + # [*] Compute the list of deployment targets to build. + # + # Even though we don't need to configure host_target, we do need + # to explicitly build it. + # So by default, build all configured targets + the host + + self.stdlib_targets_to_build = [self.host_target] + self.stdlib_targets_to_build += self.stdlib_targets_to_configure + + if host_target == args.host_target and \ + "all" not in args.build_stdlib_deployment_targets: + self.stdlib_targets_to_build = \ + [t for t in self.stdlib_targets_to_build + if t.name in args.build_stdlib_deployment_targets] + + # [*] Compute the lists of **CMake** build/run targets + self.swift_stdlib_build_targets = [] self.swift_test_run_targets = [] self.swift_benchmark_build_targets = [] self.swift_benchmark_run_targets = [] - for deployment_target_name in stdlib_targets_to_configure: - # Get the target object. - deployment_target = StdlibDeploymentTarget.get_target_for_name( - deployment_target_name) - if deployment_target is None: - diagnostics.fatal("unknown target: %r" % ( - deployment_target_name,)) - - # Add the SDK to use. - deployment_platform = deployment_target.platform - self.sdks_to_configure.add(deployment_platform.sdk_name) + for deployment_target in self.stdlib_targets_to_build: - # If we aren't actually building this target (only configuring - # it), do nothing else. - if deployment_target_name not in stdlib_targets_to_build: - continue + deployment_platform = deployment_target.platform + name = deployment_target.name # Compute which actions are desired. build = ( @@ -139,7 +149,6 @@ class HostSpecificConfiguration(object): else: test = False - name = deployment_target.name if build: # Validation and long tests require building the full standard # library, whereas the other targets can build a slightly @@ -201,7 +210,7 @@ class BuildScriptInvocation(object): diagnostics.fatal( "can't find distcc-pump (please install distcc-pump)") - if args.host_target is None or args.stdlib_deployment_targets is None: + if args.host_target is None: diagnostics.fatal("unknown operating system") if args.symbols_package: @@ -397,17 +406,19 @@ class BuildScriptInvocation(object): args.build_subdir = \ swift_build_support.workspace.compute_build_subdir(args) - # Add optional stdlib-deployment-targets + # Add optional cross-compile-stdlib-deployment-targets if args.android: - args.stdlib_deployment_targets.append( + args.cross_compile_stdlib_deployment_targets.append( StdlibDeploymentTarget.Android.armv7.name) # Infer platform flags from manually-specified configure targets. # This doesn't apply to Darwin platforms, as they are # already configured. No building without the platform flag, though. - android_tgts = [tgt for tgt in args.stdlib_deployment_targets - if StdlibDeploymentTarget.Android.contains(tgt)] + android_tgts = \ + [tgt for tgt in args.cross_compile_stdlib_deployment_targets + if StdlibDeploymentTarget.Android.contains(tgt)] + if not args.android and len(android_tgts) > 0: args.android = True args.skip_build_android = True @@ -542,8 +553,6 @@ class BuildScriptInvocation(object): "--build-dir", self.workspace.build_root, "--install-prefix", args.install_prefix, "--host-target", args.host_target, - "--stdlib-deployment-targets", - " ".join(args.stdlib_deployment_targets), "--host-cc", toolchain.cc, "--host-cxx", toolchain.cxx, "--darwin-xcrun-toolchain", args.darwin_xcrun_toolchain, @@ -576,10 +585,24 @@ class BuildScriptInvocation(object): pipes.quote(arg) for arg in cmake.build_args()), ] + # Specify additional stdlib targets to configure. Remove zero-length + # names. + args.cross_compile_stdlib_deployment_targets = \ + [t for t in args.cross_compile_stdlib_deployment_targets + if len(t) > 0] + + if args.cross_compile_stdlib_deployment_targets is not None and \ + len(args.cross_compile_stdlib_deployment_targets) > 0 and \ + 'none' not in args.cross_compile_stdlib_deployment_targets: + impl_args += ["--cross-compile-stdlib-deployment-targets", + " ".join( + args.cross_compile_stdlib_deployment_targets)] + # Specify stdlib targets to build if args.build_stdlib_deployment_targets: impl_args += [ "--build-stdlib-deployment-targets", " ".join( args.build_stdlib_deployment_targets)] + # Specify additional hosts to configure + build if args.cross_compile_hosts: impl_args += [ "--cross-compile-hosts", " ".join(args.cross_compile_hosts)] @@ -783,16 +806,18 @@ class BuildScriptInvocation(object): config = HostSpecificConfiguration(host_target, self) # Convert into `build-script-impl` style variables. + stdlib_target_names = [t.name for t + in config.stdlib_targets_to_configure] options[host_target] = { - "SWIFT_SDKS": " ".join(sorted( - config.sdks_to_configure)), - "SWIFT_STDLIB_TARGETS": " ".join( + "SWIFT_CROSS_COMPILE_STDLIB_TARGETS": " ".join( + stdlib_target_names), + "SWIFT_STDLIB_BUILD_TARGETS": " ".join( config.swift_stdlib_build_targets), - "SWIFT_BENCHMARK_TARGETS": " ".join( + "SWIFT_BENCHMARK_BUILD_TARGETS": " ".join( config.swift_benchmark_build_targets), - "SWIFT_RUN_BENCHMARK_TARGETS": " ".join( + "SWIFT_BENCHMARK_RUN_TARGETS": " ".join( config.swift_benchmark_run_targets), - "SWIFT_TEST_TARGETS": " ".join( + "SWIFT_TEST_RUN_TARGETS": " ".join( config.swift_test_run_targets), } @@ -1088,15 +1113,14 @@ details of the setups of other systems or automated environments.""") "tools for. Can be used multiple times.", action=arguments.action.concat, type=arguments.type.shell_split, default=[]) - stdlib_targets = StdlibDeploymentTarget.default_stdlib_deployment_targets() + default_cross_stdlib_targets = StdlibDeploymentTarget\ + .default_cross_compile_stdlib_targets() targets_group.add_argument( - "--stdlib-deployment-targets", - help="list of targets to compile or cross-compile the Swift standard " + "--cross-compile-stdlib-deployment-targets", + help="list of targets to cross-compile the Swift standard " "library for. %(default)s by default.", nargs="*", - default=[ - target.name - for target in stdlib_targets]) + default=[t.name for t in default_cross_stdlib_targets]) targets_group.add_argument( "--build-stdlib-deployment-targets", help="A space-separated list that filters which of the configured " diff --git a/utils/build-script-impl b/utils/build-script-impl index 508b710eabc2c..2bf6c521063c8 100755 --- a/utils/build-script-impl +++ b/utils/build-script-impl @@ -184,7 +184,7 @@ KNOWN_SETTINGS=( install-libdispatch "" "whether to install libdispatch" darwin-install-extract-symbols "" "whether to extract symbols with dsymutil during installations" host-target "" "The host target. LLVM, Clang, and Swift will be built for this target. The built LLVM and Clang will be used to compile Swift for the cross-compilation targets. **This argument is required**" - stdlib-deployment-targets "" "space-separated list of targets to configure the Swift standard library to be compiled or cross-compiled for" + cross-compile-stdlib-deployment-targets "" "space-separated list of targets to configure the host target's Swift standard library to be cross-compiled for" build-stdlib-deployment-targets "all" "space-separated list that filters which of the configured targets to build the Swift standard library for, or 'all'" cross-compile-hosts "" "space-separated list of targets to cross-compile host Swift tools for" cross-compile-with-host-tools "" "set to use the clang we build for the host to then build the cross-compile hosts" @@ -359,59 +359,22 @@ function set_build_options_for_host() { swift_cmake_options=() cmark_cmake_options=() swiftpm_bootstrap_options=() - SWIFT_HOST_VARIANT= - SWIFT_HOST_VARIANT_SDK= - SWIFT_HOST_VARIANT_ARCH= - SWIFT_HOST_TRIPLE= + LLVM_HOST_TRIPLE= USE_GOLD_LINKER= local host="$1" # Hosts which can be cross-compiled must specify: - # SWIFT_HOST_TRIPLE and llvm_target_arch (as well as usual HOST_VARIANT flags) + # LLVM_HOST_TRIPLE and llvm_target_arch (as well as usual HOST_VARIANT flags) case ${host} in - freebsd-x86_64) - SWIFT_HOST_VARIANT="freebsd" - SWIFT_HOST_VARIANT_SDK="FREEBSD" - SWIFT_HOST_VARIANT_ARCH="x86_64" + linux-armv6) + LLVM_HOST_TRIPLE="armv6-linux-gnueabihf" + llvm_target_arch="ARM" ;; - cygwin-x86_64) - SWIFT_HOST_VARIANT="windows" - SWIFT_HOST_VARIANT_SDK="CYGWIN" - SWIFT_HOST_VARIANT_ARCH="x86_64" + linux-armv7) + LLVM_HOST_TRIPLE="armv7-linux-gnueabihf" + llvm_target_arch="ARM" ;; - linux-*) - SWIFT_HOST_VARIANT="linux" - SWIFT_HOST_VARIANT_SDK="LINUX" - USE_GOLD_LINKER=1 - case ${host} in - linux-x86_64) - SWIFT_HOST_VARIANT_ARCH="x86_64" - ;; - linux-armv6) - SWIFT_HOST_VARIANT_ARCH="armv6" - SWIFT_HOST_TRIPLE="armv6-linux-gnueabihf" - llvm_target_arch="ARM" - ;; - linux-armv7) - SWIFT_HOST_VARIANT_ARCH="armv7" - SWIFT_HOST_TRIPLE="armv7-linux-gnueabihf" - llvm_target_arch="ARM" - ;; - linux-aarch64) - SWIFT_HOST_VARIANT_ARCH="aarch64" - ;; - linux-powerpc64) - SWIFT_HOST_VARIANT_ARCH="powerpc64" - ;; - linux-powerpc64le) - SWIFT_HOST_VARIANT_ARCH="powerpc64le" - ;; - linux-s390x) - SWIFT_HOST_VARIANT_ARCH="s390x" - ;; - esac - ;; macosx-* | iphoneos-* | iphonesimulator-* | \ appletvos-* | appletvsimulator-* | \ watchos-* | watchsimulator-*) @@ -419,10 +382,7 @@ function set_build_options_for_host() { macosx-x86_64) xcrun_sdk_name="macosx" llvm_target_arch="" - SWIFT_HOST_TRIPLE="x86_64-apple-macosx${DARWIN_DEPLOYMENT_VERSION_OSX}" - SWIFT_HOST_VARIANT="macosx" - SWIFT_HOST_VARIANT_SDK="OSX" - SWIFT_HOST_VARIANT_ARCH="x86_64" + LLVM_HOST_TRIPLE="x86_64-apple-macosx${DARWIN_DEPLOYMENT_VERSION_OSX}" cmake_osx_deployment_target="${DARWIN_DEPLOYMENT_VERSION_OSX}" cmark_cmake_options=( @@ -438,10 +398,7 @@ function set_build_options_for_host() { iphonesimulator-i386) xcrun_sdk_name="iphonesimulator" llvm_target_arch="X86" - SWIFT_HOST_TRIPLE="i386-apple-ios${DARWIN_DEPLOYMENT_VERSION_IOS}" - SWIFT_HOST_VARIANT="iphonesimulator" - SWIFT_HOST_VARIANT_SDK="IOS_SIMULATOR" - SWIFT_HOST_VARIANT_ARCH="i386" + LLVM_HOST_TRIPLE="i386-apple-ios${DARWIN_DEPLOYMENT_VERSION_IOS}" cmake_osx_deployment_target="" cmark_cmake_options=( @@ -453,10 +410,7 @@ function set_build_options_for_host() { iphonesimulator-x86_64) xcrun_sdk_name="iphonesimulator" llvm_target_arch="X86" - SWIFT_HOST_TRIPLE="x86_64-apple-ios${DARWIN_DEPLOYMENT_VERSION_IOS}" - SWIFT_HOST_VARIANT="iphonesimulator" - SWIFT_HOST_VARIANT_SDK="IOS_SIMULATOR" - SWIFT_HOST_VARIANT_ARCH="x86_64" + LLVM_HOST_TRIPLE="x86_64-apple-ios${DARWIN_DEPLOYMENT_VERSION_IOS}" cmake_osx_deployment_target="" cmark_cmake_options=( @@ -468,10 +422,7 @@ function set_build_options_for_host() { iphoneos-armv7) xcrun_sdk_name="iphoneos" llvm_target_arch="ARM" - SWIFT_HOST_TRIPLE="armv7-apple-ios${DARWIN_DEPLOYMENT_VERSION_IOS}" - SWIFT_HOST_VARIANT="iphoneos" - SWIFT_HOST_VARIANT_SDK="IOS" - SWIFT_HOST_VARIANT_ARCH="armv7" + LLVM_HOST_TRIPLE="armv7-apple-ios${DARWIN_DEPLOYMENT_VERSION_IOS}" cmake_osx_deployment_target="" cmark_cmake_options=( @@ -483,10 +434,7 @@ function set_build_options_for_host() { iphoneos-armv7s) xcrun_sdk_name="iphoneos" llvm_target_arch="ARM" - SWIFT_HOST_TRIPLE="armv7s-apple-ios${DARWIN_DEPLOYMENT_VERSION_IOS}" - SWIFT_HOST_VARIANT="iphoneos" - SWIFT_HOST_VARIANT_SDK="IOS" - SWIFT_HOST_VARIANT_ARCH="armv7s" + LLVM_HOST_TRIPLE="armv7s-apple-ios${DARWIN_DEPLOYMENT_VERSION_IOS}" cmake_osx_deployment_target="" cmark_cmake_options=( @@ -498,10 +446,7 @@ function set_build_options_for_host() { iphoneos-arm64) xcrun_sdk_name="iphoneos" llvm_target_arch="AArch64" - SWIFT_HOST_TRIPLE="arm64-apple-ios${DARWIN_DEPLOYMENT_VERSION_IOS}" - SWIFT_HOST_VARIANT="iphoneos" - SWIFT_HOST_VARIANT_SDK="IOS" - SWIFT_HOST_VARIANT_ARCH="arm64" + LLVM_HOST_TRIPLE="arm64-apple-ios${DARWIN_DEPLOYMENT_VERSION_IOS}" cmake_osx_deployment_target="" cmark_cmake_options=( @@ -513,10 +458,7 @@ function set_build_options_for_host() { appletvsimulator-x86_64) xcrun_sdk_name="appletvsimulator" llvm_target_arch="X86" - SWIFT_HOST_TRIPLE="x86_64-apple-tvos${DARWIN_DEPLOYMENT_VERSION_TVOS}" - SWIFT_HOST_VARIANT="appletvsimulator" - SWIFT_HOST_VARIANT_SDK="TVOS_SIMULATOR" - SWIFT_HOST_VARIANT_ARCH="x86_64" + LLVM_HOST_TRIPLE="x86_64-apple-tvos${DARWIN_DEPLOYMENT_VERSION_TVOS}" cmake_osx_deployment_target="" cmark_cmake_options=( @@ -528,10 +470,7 @@ function set_build_options_for_host() { appletvos-arm64) xcrun_sdk_name="appletvos" llvm_target_arch="AArch64" - SWIFT_HOST_TRIPLE="arm64-apple-tvos${DARWIN_DEPLOYMENT_VERSION_TVOS}" - SWIFT_HOST_VARIANT="appletvos" - SWIFT_HOST_VARIANT_SDK="TVOS" - SWIFT_HOST_VARIANT_ARCH="arm64" + LLVM_HOST_TRIPLE="arm64-apple-tvos${DARWIN_DEPLOYMENT_VERSION_TVOS}" cmake_osx_deployment_target="" cmark_cmake_options=( @@ -543,10 +482,7 @@ function set_build_options_for_host() { watchsimulator-i386) xcrun_sdk_name="watchsimulator" llvm_target_arch="X86" - SWIFT_HOST_TRIPLE="i386-apple-watchos${DARWIN_DEPLOYMENT_VERSION_WATCHOS}" - SWIFT_HOST_VARIANT="watchsimulator" - SWIFT_HOST_VARIANT_SDK="WATCHOS_SIMULATOR" - SWIFT_HOST_VARIANT_ARCH="i386" + LLVM_HOST_TRIPLE="i386-apple-watchos${DARWIN_DEPLOYMENT_VERSION_WATCHOS}" cmake_osx_deployment_target="" cmark_cmake_options=( @@ -558,10 +494,7 @@ function set_build_options_for_host() { watchos-armv7k) xcrun_sdk_name="watchos" llvm_target_arch="ARM" - SWIFT_HOST_TRIPLE="armv7k-apple-watchos${DARWIN_DEPLOYMENT_VERSION_WATCHOS}" - SWIFT_HOST_VARIANT="watchos" - SWIFT_HOST_VARIANT_SDK="WATCHOS" - SWIFT_HOST_VARIANT_ARCH="armv7k" + LLVM_HOST_TRIPLE="armv7k-apple-watchos${DARWIN_DEPLOYMENT_VERSION_WATCHOS}" cmake_osx_deployment_target="" cmark_cmake_options=( @@ -571,7 +504,7 @@ function set_build_options_for_host() { ) ;; *) - echo "Unknown host for swift tools: ${host}" + echo "Unknown darwin host for swift tools: ${host}" exit 1 ;; esac @@ -627,28 +560,26 @@ function set_build_options_for_host() { ;; esac - if [[ "${llvm_target_arch}" ]] ; then - llvm_cmake_options+=( - -DLLVM_TARGET_ARCH="${llvm_target_arch}" - ) + swift_cmake_options+=( + -DSWIFT_HOST="${host}" + ) + + if [[ "${host}" == "linux-"* ]]; then + USE_GOLD_LINKER=1 fi # For cross-compilable hosts, we need to know the triple # and it must be the same for both LLVM and Swift - - if [[ "${SWIFT_HOST_TRIPLE}" ]] ; then + if [[ "${llvm_target_arch}" ]] ; then llvm_cmake_options+=( - -DLLVM_HOST_TRIPLE:STRING="${SWIFT_HOST_TRIPLE}" + -DLLVM_TARGET_ARCH="${llvm_target_arch}" ) - swift_cmake_options+=( - -DSWIFT_HOST_TRIPLE:STRING="${SWIFT_HOST_TRIPLE}" + fi + if [[ "${LLVM_HOST_TRIPLE}" ]] ; then + llvm_cmake_options+=( + -DLLVM_HOST_TRIPLE:STRING="${LLVM_HOST_TRIPLE}" ) fi - swift_cmake_options+=( - -DSWIFT_HOST_VARIANT="${SWIFT_HOST_VARIANT}" - -DSWIFT_HOST_VARIANT_SDK="${SWIFT_HOST_VARIANT_SDK}" - -DSWIFT_HOST_VARIANT_ARCH="${SWIFT_HOST_VARIANT_ARCH}" - ) } function configure_default_options() { @@ -912,7 +843,8 @@ function make_relative_symlink() { # In the Build/Host/Target paradigm: # - "LOCAL_HOST" is Build (local machine running this script) # - "CROSS_COMPILE_HOSTS" are the Hosts (implicitly includes LOCAL_HOST) -# - "STDLIB_DEPLOYMENT_TARGETS" are the Targets (for configuration) +# - "CROSS_COMPILE_STDLIB_DEPLOYMENT_TARGETS" are the Targets +# (for configuration, implicitly includes relevant Host) # - "BUILD_STDLIB_DEPLOYMENT_TARGETS" are the Targets to build in this invocation CROSS_COMPILE_HOSTS=($CROSS_COMPILE_HOSTS) @@ -1022,23 +954,6 @@ function host_has_darwin_symbols() { esac } -function get_stdlib_targets_for_host() { - -# FIXME: STDLIB_DEPLOYMENT_TARGETS argument assumed to apply when Host == Build -# Cross-compile Hosts are only built with their native standard libraries. -# To fix this, we would need to pass in a list of stdlib targets _per host_, -# and the SWIFT_SDKS parameters would need to be able to capture both the SDK -# and architecture of each stdlib target -- currently it only captures the SDK. -# -# We turn these targets in to SWIFT_SDKS in `calculate_targets_for_host()` - - if [[ $(is_cross_tools_host $1) ]] ; then - echo "$1" - else - echo "${STDLIB_DEPLOYMENT_TARGETS[@]}" - fi -} - function should_build_stdlib_target() { local stdlib_target=$1 local host=$2 @@ -1165,18 +1080,24 @@ function get_host_specific_variable() { function calculate_targets_for_host() { local host=$1 - - SWIFT_STDLIB_TARGETS=() - SWIFT_SDKS=() - SWIFT_BENCHMARK_TARGETS=() - SWIFT_RUN_BENCHMARK_TARGETS=() - SWIFT_TEST_TARGETS=() + + SWIFT_CROSS_COMPILE_STDLIB_TARGETS=() + SWIFT_STDLIB_BUILD_TARGETS=() + SWIFT_BENCHMARK_BUILD_TARGETS=() + SWIFT_BENCHMARK_RUN_TARGETS=() + SWIFT_TEST_RUN_TARGETS=() # Get the list of Target platforms for the Host - local stdlib_targets=($(get_stdlib_targets_for_host ${host})) + # Implicitly include the Host itself. + + if [[ $(is_cross_tools_host ${host}) ]] ; then + local stdlib_targets="${host}" + else + local stdlib_targets=($CROSS_COMPILE_STDLIB_DEPLOYMENT_TARGETS) + stdlib_targets=("${host}" "${stdlib_targets[@]}") + fi for stdlib_deployment_target in "${stdlib_targets[@]}"; do - local swift_sdk= local is_in_build_list=$(should_build_stdlib_target ${stdlib_deployment_target} ${host}) local build_for_this_target=1 local test_this_target=1 @@ -1186,29 +1107,24 @@ function calculate_targets_for_host() { case ${stdlib_deployment_target} in linux-*) - swift_sdk="LINUX" build_for_this_target=$(not ${SKIP_BUILD_LINUX}) test_this_target=$(not ${SKIP_TEST_LINUX}) ;; freebsd-*) - swift_sdk="FREEBSD" build_for_this_target=$(not ${SKIP_BUILD_FREEBSD}) test_this_target=$(not ${SKIP_TEST_FREEBSD}) ;; cygwin-*) - swift_sdk="CYGWIN" build_for_this_target=$(not ${SKIP_BUILD_CYGWIN}) test_this_target=$(not ${SKIP_TEST_CYGWIN}) ;; macosx-*) - swift_sdk="OSX" build_for_this_target=$(not ${SKIP_BUILD_OSX}) test_this_target=$(not ${SKIP_TEST_OSX}) build_benchmark_this_target=$(not ${SKIP_BUILD_OSX}) test_benchmark_this_target=$(not ${SKIP_BUILD_OSX}) ;; iphoneos-*) - swift_sdk="IOS" build_for_this_target=$(not ${SKIP_BUILD_IOS_DEVICE}) if [[ ! "${SKIP_TEST_IOS_HOST}" ]] ; then test_host_only=1 @@ -1223,12 +1139,10 @@ function calculate_targets_for_host() { fi ;; iphonesimulator-*) - swift_sdk="IOS_SIMULATOR" build_for_this_target=$(not ${SKIP_BUILD_IOS_SIMULATOR}) test_this_target=$(not ${SKIP_TEST_IOS_SIMULATOR}) ;; appletvos-*) - swift_sdk="TVOS" build_for_this_target=$(not ${SKIP_BUILD_TVOS_DEVICE}) if [[ ! "${SKIP_TEST_TVOS_HOST}" ]] ; then test_host_only=1 @@ -1238,12 +1152,10 @@ function calculate_targets_for_host() { build_benchmark_this_target=$(not ${SKIP_BUILD_TVOS_DEVICE}) ;; appletvsimulator-*) - swift_sdk="TVOS_SIMULATOR" build_for_this_target=$(not ${SKIP_BUILD_TVOS_SIMULATOR}) test_this_target=$(not ${SKIP_TEST_TVOS_SIMULATOR}) ;; watchos-*) - swift_sdk="WATCHOS" build_for_this_target=$(not ${SKIP_BUILD_WATCHOS_DEVICE}) if [[ ! "${SKIP_TEST_WATCHOS_HOST}" ]] ; then test_host_only=1 @@ -1253,12 +1165,10 @@ function calculate_targets_for_host() { build_benchmark_this_target=$(not ${SKIP_BUILD_WATCHOS_DEVICE}) ;; watchsimulator-*) - swift_sdk="WATCHOS_SIMULATOR" build_for_this_target=$(not ${SKIP_BUILD_WATCHOS_SIMULATOR}) test_this_target=$(not ${SKIP_TEST_WATCHOS_SIMULATOR}) ;; android-*) - swift_sdk="ANDROID" build_for_this_target=$(not ${SKIP_BUILD_ANDROID}) test_this_target=$(not ${SKIP_TEST_ANDROID_HOST}) ;; @@ -1268,24 +1178,27 @@ function calculate_targets_for_host() { ;; esac - SWIFT_SDKS+=("${swift_sdk}") + # The host is implicitly compliled. It's not a cross-compile target. + if [[ "${host}" != "${stdlib_deployment_target}" ]]; then + SWIFT_CROSS_COMPILE_STDLIB_TARGETS+=("${stdlib_deployment_target}") + fi if [[ "${build_for_this_target}" ]] && [[ "${is_in_build_list}" ]]; then if [[ "${BUILD_SWIFT_STDLIB_UNITTEST_EXTRA}" == "1" ]] ; then - SWIFT_STDLIB_TARGETS+=("swift-stdlib-${stdlib_deployment_target}") + SWIFT_STDLIB_BUILD_TARGETS+=("swift-stdlib-${stdlib_deployment_target}") else if [[ "${VALIDATION_TEST}" == "1" || "${LONG_TEST}" == "1" ]] ; then - SWIFT_STDLIB_TARGETS+=("swift-stdlib-${stdlib_deployment_target}") + SWIFT_STDLIB_BUILD_TARGETS+=("swift-stdlib-${stdlib_deployment_target}") else - SWIFT_STDLIB_TARGETS+=("swift-test-stdlib-${stdlib_deployment_target}") + SWIFT_STDLIB_BUILD_TARGETS+=("swift-test-stdlib-${stdlib_deployment_target}") fi fi fi if [[ "${build_benchmark_this_target}" ]] && [[ "${is_in_build_list}" ]]; then - SWIFT_BENCHMARK_TARGETS+=("swift-benchmark-${stdlib_deployment_target}") + SWIFT_BENCHMARK_BUILD_TARGETS+=("swift-benchmark-${stdlib_deployment_target}") if [[ $(not ${SKIP_TEST_BENCHMARK}) ]] ; then - SWIFT_RUN_BENCHMARK_TARGETS+=("check-swift-benchmark-${stdlib_deployment_target}") + SWIFT_BENCHMARK_RUN_TARGETS+=("check-swift-benchmark-${stdlib_deployment_target}") fi fi if [[ "${test_this_target}" ]] && [[ "${is_in_build_list}" ]]; then @@ -1306,48 +1219,44 @@ function calculate_targets_for_host() { test_subset_target_suffix="-only_long" fi fi - SWIFT_TEST_TARGETS+=("check-swift${test_subset_target_suffix}${test_target_suffix}-${stdlib_deployment_target}") + SWIFT_TEST_RUN_TARGETS+=("check-swift${test_subset_target_suffix}${test_target_suffix}-${stdlib_deployment_target}") if [[ $(not ${SKIP_TEST_OPTIMIZED}) && ! -n "${test_host_only}" ]] ; then - SWIFT_TEST_TARGETS+=("check-swift${test_subset_target_suffix}-optimize-${stdlib_deployment_target}") + SWIFT_TEST_RUN_TARGETS+=("check-swift${test_subset_target_suffix}-optimize-${stdlib_deployment_target}") fi fi done - # Filter duplicate SWIFT_SDKs - # We will get them if building for multiple architecture variants - SWIFT_SDKS=($(echo "${SWIFT_SDKS[@]}" | tr " " "\n" | sort -u | tr "\n" " ")) - # Get the values passed by `build-script`. - LEGACY_SWIFT_STDLIB_TARGETS=(${SWIFT_STDLIB_TARGETS[@]}) - LEGACY_SWIFT_SDKS=(${SWIFT_SDKS[@]}) - LEGACY_SWIFT_BENCHMARK_TARGETS=(${SWIFT_BENCHMARK_TARGETS[@]}) - LEGACY_SWIFT_RUN_BENCHMARK_TARGETS=(${SWIFT_RUN_BENCHMARK_TARGETS[@]}) - LEGACY_SWIFT_TEST_TARGETS=(${SWIFT_TEST_TARGETS[@]}) - SWIFT_STDLIB_TARGETS=($(get_host_specific_variable ${host} SWIFT_STDLIB_TARGETS)) - SWIFT_SDKS=($(get_host_specific_variable ${host} SWIFT_SDKS)) - SWIFT_BENCHMARK_TARGETS=($(get_host_specific_variable ${host} SWIFT_BENCHMARK_TARGETS)) - SWIFT_RUN_BENCHMARK_TARGETS=($(get_host_specific_variable ${host} SWIFT_RUN_BENCHMARK_TARGETS)) - SWIFT_TEST_TARGETS=($(get_host_specific_variable ${host} SWIFT_TEST_TARGETS)) + LEGACY_SWIFT_STDLIB_BUILD_TARGETS=(${SWIFT_STDLIB_BUILD_TARGETS[@]}) + LEGACY_SWIFT_CROSS_COMPILE_STDLIB_TARGETS=(${SWIFT_CROSS_COMPILE_STDLIB_TARGETS[@]}) + LEGACY_SWIFT_BENCHMARK_BUILD_TARGETS=(${SWIFT_BENCHMARK_BUILD_TARGETS[@]}) + LEGACY_SWIFT_BENCHMARK_RUN_TARGETS=(${SWIFT_BENCHMARK_RUN_TARGETS[@]}) + LEGACY_SWIFT_TEST_RUN_TARGETS=(${SWIFT_TEST_RUN_TARGETS[@]}) + SWIFT_STDLIB_BUILD_TARGETS=($(get_host_specific_variable ${host} SWIFT_STDLIB_BUILD_TARGETS)) + SWIFT_CROSS_COMPILE_STDLIB_TARGETS=($(get_host_specific_variable ${host} SWIFT_CROSS_COMPILE_STDLIB_TARGETS)) + SWIFT_BENCHMARK_BUILD_TARGETS=($(get_host_specific_variable ${host} SWIFT_BENCHMARK_BUILD_TARGETS)) + SWIFT_BENCHMARK_RUN_TARGETS=($(get_host_specific_variable ${host} SWIFT_BENCHMARK_RUN_TARGETS)) + SWIFT_TEST_RUN_TARGETS=($(get_host_specific_variable ${host} SWIFT_TEST_RUN_TARGETS)) # Validate the parameters match. - if [[ "${SWIFT_STDLIB_TARGETS[*]}" != "${LEGACY_SWIFT_STDLIB_TARGETS[*]}" ]]; then - printf "error: invalid build-script refactor for 'SWIFT_STDLIB_TARGETS': '%s' vs '%s'\n" "${SWIFT_STDLIB_TARGETS[*]}" "${LEGACY_SWIFT_STDLIB_TARGETS[*]}" + if [[ "${SWIFT_STDLIB_BUILD_TARGETS[*]}" != "${LEGACY_SWIFT_STDLIB_BUILD_TARGETS[*]}" ]]; then + printf "error: invalid build-script refactor for 'SWIFT_STDLIB_BUILD_TARGETS': '%s' vs '%s'\n" "${SWIFT_STDLIB_BUILD_TARGETS[*]}" "${LEGACY_SWIFT_STDLIB_BUILD_TARGETS[*]}" exit 1 fi - if [[ "${SWIFT_SDKS[*]}" != "${LEGACY_SWIFT_SDKS[*]}" ]]; then - printf "error: invalid build-script for 'SWIFT_SDKS' refactor: '%s' vs '%s'\n" "${SWIFT_SDKS[*]}" "${LEGACY_SWIFT_SDKS[*]}" + if [[ "${SWIFT_CROSS_COMPILE_STDLIB_TARGETS[*]}" != "${LEGACY_SWIFT_CROSS_COMPILE_STDLIB_TARGETS[*]}" ]]; then + printf "error: invalid build-script for 'SWIFT_CROSS_COMPILE_STDLIB_TARGETS' refactor: '%s' vs '%s'\n" "${SWIFT_CROSS_COMPILE_STDLIB_TARGETS[*]}" "${LEGACY_SWIFT_CROSS_COMPILE_STDLIB_TARGETS[*]}" exit 1 fi - if [[ "${SWIFT_BENCHMARK_TARGETS[*]}" != "${LEGACY_SWIFT_BENCHMARK_TARGETS[*]}" ]]; then - printf "error: invalid build-script refactor for 'SWIFT_BENCHMARK_TARGETS': '%s' vs '%s'\n" "${SWIFT_BENCHMARK_TARGETS[*]}" "${LEGACY_SWIFT_BENCHMARK_TARGETS[*]}" + if [[ "${SWIFT_BENCHMARK_BUILD_TARGETS[*]}" != "${LEGACY_SWIFT_BENCHMARK_BUILD_TARGETS[*]}" ]]; then + printf "error: invalid build-script refactor for 'SWIFT_BENCHMARK_BUILD_TARGETS': '%s' vs '%s'\n" "${SWIFT_BENCHMARK_BUILD_TARGETS[*]}" "${LEGACY_SWIFT_BENCHMARK_BUILD_TARGETS[*]}" exit 1 fi - if [[ "${SWIFT_RUN_BENCHMARK_TARGETS[*]}" != "${LEGACY_SWIFT_RUN_BENCHMARK_TARGETS[*]}" ]]; then - printf "error: invalid build-script refactor for 'SWIFT_RUN_BENCHMARK_TARGETS': '%s' vs '%s'\n" "${SWIFT_RUN_BENCHMARK_TARGETS[*]}" "${LEGACY_SWIFT_RUN_BENCHMARK_TARGETS[*]}" + if [[ "${SWIFT_BENCHMARK_RUN_TARGETS[*]}" != "${LEGACY_SWIFT_BENCHMARK_RUN_TARGETS[*]}" ]]; then + printf "error: invalid build-script refactor for 'SWIFT_BENCHMARK_RUN_TARGETS': '%s' vs '%s'\n" "${SWIFT_BENCHMARK_RUN_TARGETS[*]}" "${LEGACY_SWIFT_BENCHMARK_RUN_TARGETS[*]}" exit 1 fi - if [[ "${SWIFT_TEST_TARGETS[*]}" != "${LEGACY_SWIFT_TEST_TARGETS[*]}" ]]; then - printf "error: invalid build-script refactor for 'SWIFT_TEST_TARGETS': '%s' vs '%s'\n" "${SWIFT_TEST_TARGETS[*]}" "${LEGACY_SWIFT_TEST_TARGETS[*]}" + if [[ "${SWIFT_TEST_RUN_TARGETS[*]}" != "${LEGACY_SWIFT_TEST_RUN_TARGETS[*]}" ]]; then + printf "error: invalid build-script refactor for 'SWIFT_TEST_RUN_TARGETS': '%s' vs '%s'\n" "${SWIFT_TEST_RUN_TARGETS[*]}" "${LEGACY_SWIFT_TEST_RUN_TARGETS[*]}" exit 1 fi } @@ -1581,14 +1490,14 @@ for host in "${ALL_HOSTS[@]}"; do # Don't echo anything if only executing an individual action. if [[ "${ONLY_EXECUTE}" = "all" ]]; then - echo "Building the standard library for: ${SWIFT_STDLIB_TARGETS[@]}" - if [[ "${SWIFT_TEST_TARGETS[@]}" ]] && ! [[ "${SKIP_TEST_SWIFT}" ]]; then - echo "Running Swift tests for: ${SWIFT_TEST_TARGETS[@]}" + echo "Building the standard library for: ${SWIFT_STDLIB_BUILD_TARGETS[@]}" + if [[ "${SWIFT_TEST_RUN_TARGETS[@]}" ]] && ! [[ "${SKIP_TEST_SWIFT}" ]]; then + echo "Running Swift tests for: ${SWIFT_TEST_RUN_TARGETS[@]}" fi if ! [[ "${SKIP_TEST_BENCHMARKS}" ]] && - [[ "${SWIFT_RUN_BENCHMARK_TARGETS[@]}" ]] && + [[ "${SWIFT_BENCHMARK_RUN_TARGETS[@]}" ]] && ! [[ "${SKIP_TEST_BENCHMARK}" ]]; then - echo "Running Swift benchmarks for: ${SWIFT_RUN_BENCHMARK_TARGETS[@]}" + echo "Running Swift benchmarks for: ${SWIFT_BENCHMARK_RUN_TARGETS[@]}" fi fi @@ -1924,10 +1833,10 @@ for host in "${ALL_HOSTS[@]}"; do ) fi - if [[ "${SWIFT_SDKS}" ]] ; then + if [[ "${SWIFT_CROSS_COMPILE_STDLIB_TARGETS}" ]] ; then cmake_options=( "${cmake_options[@]}" - -DSWIFT_SDKS:STRING="$(join ";" ${SWIFT_SDKS[@]})" + -DSWIFT_CROSS_COMPILE_STDLIB_TARGETS:STRING="$(join ";" ${SWIFT_CROSS_COMPILE_STDLIB_TARGETS[@]})" ) fi if [[ "${SWIFT_PRIMARY_VARIANT_SDK}" ]] ; then @@ -1938,7 +1847,7 @@ for host in "${ALL_HOSTS[@]}"; do ) fi - build_targets=(all "${SWIFT_STDLIB_TARGETS[@]}") + build_targets=(all "${SWIFT_STDLIB_BUILD_TARGETS[@]}") if [[ $(true_false "${build_perf_testsuite_this_time}") == "TRUE" ]]; then native_swift_tools_path="$(build_directory_bin ${LOCAL_HOST} swift)" cmake_options=( @@ -1946,7 +1855,7 @@ for host in "${ALL_HOSTS[@]}"; do -DSWIFT_EXEC:STRING="${native_swift_tools_path}/swiftc" ) build_targets=("${build_targets[@]}" - "${SWIFT_BENCHMARK_TARGETS[@]}") + "${SWIFT_BENCHMARK_BUILD_TARGETS[@]}") fi skip_build=${SKIP_BUILD_SWIFT} @@ -2315,7 +2224,7 @@ for host in "${ALL_HOSTS[@]}"; do results_targets= if ! [[ "${SKIP_TEST_SWIFT}" ]]; then executable_target=SwiftUnitTests - results_targets=("${SWIFT_TEST_TARGETS[@]}") + results_targets=("${SWIFT_TEST_RUN_TARGETS[@]}") if [[ "${STRESS_TEST_SOURCEKIT}" ]]; then results_targets=( "${results_targets[@]}" @@ -2326,7 +2235,7 @@ for host in "${ALL_HOSTS[@]}"; do if ! [[ "${SKIP_TEST_BENCHMARKS}" ]]; then results_targets=( "${results_targets[@]}" - "${SWIFT_RUN_BENCHMARK_TARGETS[@]}" + "${SWIFT_BENCHMARK_RUN_TARGETS[@]}" ) fi if [[ -z "${results_targets[@]}" ]]; then diff --git a/utils/swift_build_support/swift_build_support/targets.py b/utils/swift_build_support/swift_build_support/targets.py index f7269945af61f..51b86d6e7dd23 100644 --- a/utils/swift_build_support/swift_build_support/targets.py +++ b/utils/swift_build_support/swift_build_support/targets.py @@ -184,7 +184,7 @@ def host_target(): return None @staticmethod - def default_stdlib_deployment_targets(): + def default_cross_compile_stdlib_targets(): """ Return targets for the Swift stdlib, based on the build machine. If the build machine is not one of the recognized ones, return None. @@ -198,8 +198,7 @@ def default_stdlib_deployment_targets(): # Put iOS native targets last so that we test them last # (it takes a long time). if host_target == StdlibDeploymentTarget.OSX.x86_64: - return [host_target] + \ - StdlibDeploymentTarget.iOSSimulator.targets + \ + return StdlibDeploymentTarget.iOSSimulator.targets + \ StdlibDeploymentTarget.AppleTVSimulator.targets + \ StdlibDeploymentTarget.AppleWatchSimulator.targets + \ StdlibDeploymentTarget.iOS.targets + \ @@ -207,7 +206,7 @@ def default_stdlib_deployment_targets(): StdlibDeploymentTarget.AppleWatch.targets else: # All other machines only configure their host stdlib by default. - return [host_target] + return [] @classmethod def get_target_for_name(cls, name):