#!/usr/bin/env bash #===--- build-script-impl - Implementation details of build-script ---------===# # ## This source file is part of the Swift.org open source project ## ## Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors ## Licensed under Apache License v2.0 with Runtime Library Exception ## ## See https://swift.org/LICENSE.txt for license information ## See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors # #===------------------------------------------------------------------------===# # # This script is an implementation detail of other build scripts and should not # be called directly. # # Note: This script will NOT auto-clean before building. # set -o pipefail set -e umask 0022 # Declare the set of known settings along with each one's description # # If you add a user-settable variable, add it to this list. # # A default value of "" indicates that the corresponding variable # will remain unset unless set explicitly. # # skip-* parameters do not affect the configuration (CMake parameters). # You can turn them on and off in different invocations of the script for the # same build directory. # # build-* parameters affect the CMake configuration (enable/disable those # components). # # Each variable name is re-exported into this script in uppercase, where dashes # are substituted by underscores. For example, `swift-install-components` is # referred to as `SWIFT_INSTALL_COMPONENTS` in the remainder of this script. KNOWN_SETTINGS=( # name default description dry-run "" "print the commands that would be executed, but do not execute them" build-args "" "arguments to the build tool; defaults to -j8 when CMake generator is \"Unix Makefiles\"" build-dir "" "out-of-tree build directory; default is in-tree. **This argument is required**" host-cc "" "the path to CC, the 'clang' compiler for the host platform. **This argument is required**" host-cxx "" "the path to CXX, the 'clang++' compiler for the host platform. **This argument is required**" host-lipo "" "the path to lipo for creating universal binaries on Darwin" host-libtool "" "the path to libtool" darwin-xcrun-toolchain "default" "the name of the toolchain to use on Darwin" ninja-bin "" "the path to Ninja tool" cmark-build-type "Debug" "the CMake build variant for CommonMark (Debug, RelWithDebInfo, Release, MinSizeRel). Defaults to Debug." lldb-extra-cmake-args "" "extra command line args to pass to lldb cmake" lldb-extra-xcodebuild-args "" "extra command line args to pass to lldb xcodebuild" lldb-test-cc "" "CC to use for building LLDB testsuite test inferiors. Defaults to just-built, in-tree clang. If set to 'host-toolchain', sets it to same as host-cc." lldb-test-with-curses "" "run test lldb test runner using curses terminal control" lldb-test-swift-only "0" "when running lldb tests, only include Swift-specific tests" lldb-no-debugserver "" "delete debugserver after building it, and don't try to codesign it" lldb-use-system-debugserver "" "don't try to codesign debugserver, and use the system's debugserver instead" lldb-assertions "1" "build lldb with assertions enabled" llvm-build-type "Debug" "the CMake build variant for LLVM and Clang (Debug, RelWithDebInfo, Release, MinSizeRel). Defaults to Debug." swift-build-type "Debug" "the CMake build variant for Swift" swift-enable-assertions "1" "enable assertions in Swift" swift-analyze-code-coverage "not-merged" "Code coverage analysis mode for Swift (false, not-merged, merged). Defaults to false if the argument is not present, and not-merged if the argument is present without a modifier." swift-tools-enable-lto "" "enable LTO compilation of Swift tools. *NOTE* This does not include the swift standard library and runtime. Must be set to one of 'thin' or 'full'" llvm-enable-lto "" "Must be set to one of 'thin' or 'full'" llvm-enable-modules "0" "enable building llvm using modules" swift-tools-num-parallel-lto-link-jobs "" "The number of parallel link jobs to use when compiling swift tools" llvm-num-parallel-lto-link-jobs "" "The number of parallel link jobs to use when compiling llvm" swift-stdlib-build-type "Debug" "the CMake build variant for Swift" swift-stdlib-enable-assertions "1" "enable assertions in Swift" swift-stdlib-use-nonatomic-rc "0" "build the Swift stdlib and overlays with nonatomic reference count operations enabled" lldb-build-type "Debug" "the CMake build variant for LLDB" lldb-build-with-xcode "1" "Use xcodebuild to build LLDB, instead of CMake" llbuild-build-type "Debug" "the CMake build variant for llbuild" foundation-build-type "Debug" "the build variant for Foundation" libdispatch-build-type "Debug" "the build variant for libdispatch" libicu-build-type "Debug" "the build variant for libicu" playgroundsupport-build-type "Debug" "the build variant for PlaygroundSupport" xctest-build-type "Debug" "the build variant for xctest" swiftpm-build-type "Debug" "the build variant for swiftpm" llbuild-enable-assertions "1" "enable assertions in llbuild" enable-asan "" "enable Address Sanitizer" enable-ubsan "" "enable Undefined Behavior Sanitizer" cmake "" "path to the cmake binary" distcc "" "use distcc in pump mode" distcc-pump "" "the path to distcc pump executable. This argument is required if distcc is set." build-runtime-with-host-compiler "" "use the host c++ compiler to build everything" cmake-generator "Unix Makefiles" "kind of build system to generate; see output of 'cmake --help' for choices" verbose-build "" "print the commands executed during the build" install-prefix "" "installation prefix" toolchain-prefix "" "the path to the .xctoolchain directory that houses the install prefix path" install-destdir "" "the path to use as the filesystem root for the installation" install-symroot "" "the path to install debug symbols into" swift-install-components "" "a semicolon-separated list of Swift components to install" llvm-install-components "" "a semicolon-separated list of LLVM components to install" installable-package "" "the path to the archive of the installation directory" test-installable-package "" "whether to run post-packaging tests on the produced package" reconfigure "" "force a CMake configuration run even if CMakeCache.txt already exists" skip-reconfigure "" "set to skip reconfigure" swift-primary-variant-sdk "" "default SDK for target binaries" swift-primary-variant-arch "" "default arch for target binaries" skip-build-cmark "" "set to skip building CommonMark" skip-build-llvm "" "set to skip building LLVM/Clang" skip-build-compiler-rt "" "set to skip building Compiler-RT" skip-build-swift "" "set to skip building Swift" skip-build-linux "" "set to skip building Swift stdlibs for Linux" skip-build-freebsd "" "set to skip building Swift stdlibs for FreeBSD" skip-build-cygwin "" "set to skip building Swift stdlibs for Cygwin" skip-build-haiku "" "set to skip building Swift stdlibs for Haiku" skip-build-osx "" "set to skip building Swift stdlibs for OS X" skip-build-ios-device "" "set to skip building Swift stdlibs for iOS devices (i.e. build simulators only)" skip-build-ios-simulator "" "set to skip building Swift stdlibs for iOS simulators (i.e. build devices only)" skip-build-tvos-device "" "set to skip building Swift stdlibs for tvOS devices (i.e. build simulators only)" skip-build-tvos-simulator "" "set to skip building Swift stdlibs for tvOS simulators (i.e. build devices only)" skip-build-watchos-device "" "set to skip building Swift stdlibs for Apple watchOS devices (i.e. build simulators only)" skip-build-watchos-simulator "" "set to skip building Swift stdlibs for Apple watchOS simulators (i.e. build devices only)" skip-build-android "" "set to skip building Swift stdlibs for Android" skip-build-lldb "" "set to skip building LLDB" skip-build-llbuild "" "set to skip building llbuild" skip-build-swiftpm "" "set to skip building swiftpm" skip-build-xctest "" "set to skip building xctest" skip-build-foundation "" "set to skip building foundation" skip-build-libdispatch "" "set to skip building libdispatch" skip-build-libicu "" "set to skip building libicu" skip-build-benchmarks "" "set to skip building Swift Benchmark Suite" skip-build-external-benchmarks "1" "set to skip building the external Swift Benchmark Suite. (skipped by default)" skip-build-playgroundsupport "" "set to skip building PlaygroundSupport" skip-test-cmark "" "set to skip testing CommonMark" skip-test-lldb "" "set to skip testing lldb" skip-test-swift "" "set to skip testing Swift" skip-test-llbuild "" "set to skip testing llbuild" skip-test-swiftpm "" "set to skip testing swiftpm" skip-test-xctest "" "set to skip testing xctest" skip-test-foundation "" "set to skip testing foundation" skip-test-libdispatch "" "set to skip testing libdispatch" skip-test-libicu "" "set to skip testing libicu" skip-test-playgroundsupport "" "set to skip testing PlaygroundSupport" skip-test-linux "" "set to skip testing Swift stdlibs for Linux" skip-test-freebsd "" "set to skip testing Swift stdlibs for FreeBSD" skip-test-cygwin "" "set to skip testing Swift stdlibs for Cygwin" skip-test-haiku "" "set to skip testing Swift stdlibs for Haiku" skip-test-osx "" "set to skip testing Swift stdlibs for OS X" skip-test-ios-32bit-simulator "" "set to skip testing Swift stdlibs for iOS 32bit simulators" skip-test-ios-simulator "" "set to skip testing Swift stdlibs for iOS simulators (i.e. test devices only)" skip-test-ios-host "" "set to skip testing the host parts of the iOS toolchain" skip-test-tvos-simulator "" "set to skip testing Swift stdlibs for tvOS simulators (i.e. test devices only)" skip-test-tvos-host "" "set to skip testing the host parts of the tvOS toolchain" skip-test-watchos-simulator "" "set to skip testing Swift stdlibs for Apple watchOS simulators (i.e. test devices only)" skip-test-watchos-host "" "set to skip testing the host parts of the watchOS toolchain" skip-test-android-host "" "set to skip testing the host parts of the Android toolchain" validation-test "0" "set to run the validation test suite" long-test "0" "set to run the long test suite" stress-test "0" "set to run the stress test suite" test-paths "" "run tests located in specific directories and/or files" skip-test-benchmarks "" "set to skip running Swift Benchmark Suite" skip-test-optimized "" "set to skip testing the test suite in optimized mode" skip-test-optimize-for-size "" "set to skip testing the test suite in optimize for size mode" skip-test-sourcekit "" "set to skip testing SourceKit" stress-test-sourcekit "" "set to run the stress-SourceKit target" workspace "${HOME}/src" "source directory containing llvm, clang, swift" enable-llvm-assertions "1" "set to enable llvm assertions" build-llvm "1" "set to 1 to build LLVM and Clang" build-swift-tools "1" "set to 1 to build Swift host tools" build-swift-dynamic-stdlib "" "set to 1 to build dynamic variants of the Swift standard library" build-swift-static-stdlib "" "set to 1 to build static variants of the Swift standard library" build-swift-stdlib-unittest-extra "0" "set to 1 to build optional StdlibUnittest components" build-swift-dynamic-sdk-overlay "" "set to 1 to build dynamic variants of the Swift SDK overlay" build-swift-static-sdk-overlay "" "set to 1 to build static variants of the Swift SDK overlay" build-swift-examples "1" "set to 1 to build examples" build-swift-remote-mirror "1" "set to 1 to build the Swift Remote Mirror library" build-sil-debugging-stdlib "0" "set to 1 to build the Swift standard library with -gsil to enable debugging and profiling on SIL level" check-incremental-compilation "0" "set to 1 to compile swift libraries multiple times to check if incremental compilation works" report-statistics "0" "set to 1 to generate compilation statistics files for swift libraries" llvm-include-tests "1" "Set to true to generate testing targets for LLVM. Set to true by default." swift-include-tests "1" "Set to true to generate testing targets for Swift. This allows the build to proceed when 'test' directory is missing (required for B&I builds)" native-llvm-tools-path "" "directory that contains LLVM tools that are executable on the build machine" native-clang-tools-path "" "directory that contains Clang tools that are executable on the build machine" native-swift-tools-path "" "directory that contains Swift tools that are executable on the build machine" embed-bitcode-section "0" "embed an LLVM bitcode section in stdlib/overlay binaries for supported platforms" darwin-crash-reporter-client "" "whether to enable CrashReporter integration" darwin-stdlib-install-name-dir "" "the directory of the install_name for standard library dylibs" install-cmark "" "whether to install cmark" install-swift "" "whether to install Swift" install-lldb "" "whether to install LLDB" install-llbuild "" "whether to install llbuild" install-swiftpm "" "whether to install swiftpm" install-xctest "" "whether to install xctest" install-foundation "" "whether to install foundation" install-libdispatch "" "whether to install libdispatch" install-libicu "" "whether to install libicu" install-playgroundsupport "" "whether to install PlaygroundSupport" 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" 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" cross-compile-install-prefixes "" "semicolon-separated list of install prefixes to use for the cross-compiled hosts. The list expands, so if there are more cross-compile hosts than prefixes, unmatched hosts use the last prefix in the list" skip-merge-lipo-cross-compile-tools "" "set to skip running merge-lipo after installing cross-compiled host Swift tools" darwin-deployment-version-osx "10.9" "minimum deployment target version for OS X" darwin-deployment-version-ios "7.0" "minimum deployment target version for iOS" darwin-deployment-version-tvos "9.0" "minimum deployment target version for tvOS" darwin-deployment-version-watchos "2.0" "minimum deployment target version for watchOS" extra-cmake-options "" "Extra options to pass to CMake for all targets" extra-swift-args "" "Extra arguments to pass to swift modules which match regex. Assumed to be a flattened cmake list consisting of [module_regexp, args, module_regexp, args, ...]" sil-verify-all "0" "If enabled, run the SIL verifier after each transform when building Swift files during this build process" swift-enable-ast-verifier "1" "If enabled, and the assertions are enabled, the built Swift compiler will run the AST verifier every time it is invoked" swift-runtime-enable-leak-checker "0" "Enable leaks checking routines in the runtime" use-gold-linker "" "Enable using the gold linker" darwin-toolchain-bundle-identifier "" "CFBundleIdentifier for xctoolchain info plist" darwin-toolchain-display-name "" "Display Name for xctoolcain info plist" darwin-toolchain-display-name-short "" "Display Name with out date for xctoolchain info plist" darwin-toolchain-name "" "Directory name for xctoolchain" darwin-toolchain-version "" "Version for xctoolchain info plist and installer pkg" darwin-toolchain-application-cert "" "Application Cert name to codesign xctoolchain" darwin-toolchain-installer-cert "" "Installer Cert name to create installer pkg" darwin-toolchain-installer-package "" "The path to installer pkg" darwin-sdk-deployment-targets "xctest-ios-8.0" "semicolon-separated list of triples like 'fookit-ios-9.0;barkit-watchos-9.0'" darwin-overlay-target "" "single overlay target to build, dependencies are computed later" build-jobs "" "The number of parallel build jobs to use" darwin-toolchain-alias "" "Swift alias for toolchain" android-ndk "" "An absolute path to the NDK that will be used as a libc implementation for Android builds" android-api-level "" "The Android API level to target when building for Android. Currently only 21 or above is supported" android-ndk-gcc-version "" "The GCC version to use when building for Android. Currently only 4.9 is supported" android-icu-uc "" "Path to a directory containing libicuuc.so" android-icu-uc-include "" "Path to a directory containing headers for libicuuc" android-icu-i18n "" "Path to a directory containing libicui18n.so" android-icu-i18n-include "" "Path to a directory containing headers libicui18n" android-deploy-device-path "" "Path on an Android device to which built Swift stdlib products will be deployed" check-args-only "" "set to check all arguments are known. Exit with status 0 if success, non zero otherwise" common-cmake-options "" "CMake options used for all targets, including LLVM/Clang" cmark-cmake-options "" "CMake options used for all cmark targets" ninja-cmake-options "" "CMake options used for all ninja targets" foundation-cmake-options "" "CMake options used for all foundation targets" libdispatch-cmake-options "" "CMake options used for all libdispatch targets" libicu-cmake-options "" "CMake options used for all libicu targets" llbuild-cmake-options "" "CMake options used for all llbuild targets" lldb-cmake-options "" "CMake options used for all lldb targets" llvm-cmake-options "" "CMake options used for all llvm targets" ninja-cmake-options "" "CMake options used for all ninja targets" swift-cmake-options "" "CMake options used for all swift targets" swiftpm-cmake-options "" "CMake options used for all swiftpm targets" xctest-cmake-options "" "CMake options used for all xctest targets" playgroundsupport-cmake-options "" "CMake options used for all playgroundsupport targets" # TODO: Remove this some time later. user-config-args "" "**Renamed to --extra-cmake-options**: User-supplied arguments to cmake when used to do configuration." only-execute "all" "Only execute the named action (see implementation)" llvm-lit-args "" "If set, override the lit args passed to LLVM" clang-profile-instr-use "" "If set, profile file to use for clang PGO" coverage-db "" "If set, coverage database to use when prioritizing testing" build-toolchain-only "" "If set, only build the necessary tools to build an external toolchain" skip-local-host-install "" "If we are cross-compiling multiple targets, skip an install pass locally if the hosts match" ) # Centralized access point for traced command invocation. # Every operation that might mutates file system should be called via # these functions. function call() { if [[ ${DRY_RUN} ]]; then echo "${PS4}"$(quoted_print "$@") else { set -x; } 2>/dev/null "$@" { set +x; } 2>/dev/null fi } function with_pushd() { local dir=$1 shift if [[ "$1" == "call" ]]; then shift fi if [[ ${DRY_RUN} ]]; then echo ${PS4}pushd "${dir}" echo "${PS4}"$(quoted_print "$@") echo ${PS4}popd else set -x pushd "${dir}" "$@" { set -x; } 2>/dev/null # because $@ might includes { set +x; } popd { set +x; } 2>/dev/null fi } function quoted_print() { python -c 'import pipes; import sys; print(" ".join(pipes.quote(arg) for arg in sys.argv[1:]))' "$@" } function toupper() { echo "$@" | tr '[:lower:]' '[:upper:]' } function tolower() { echo "$@" | tr '[:upper:]' '[:lower:]' } function true_false() { case "$1" in false | FALSE | 0 | "") echo "FALSE" ;; true | TRUE | 1) echo "TRUE" ;; *) echo "true_false: unknown value: $1" >&2 exit 1 ;; esac } function to_varname() { toupper "${1//-/_}" } function set_lldb_build_mode() { if [[ "${LLDB_BUILD_TYPE}" == "RelWithDebInfo" ]]; then LLDB_BUILD_MODE="CustomSwift-Release" else LLDB_BUILD_MODE="CustomSwift-${LLDB_BUILD_TYPE}" fi } function is_llvm_lto_enabled() { if [[ "${LLVM_ENABLE_LTO}" == "thin" ]] || [[ "${LLVM_ENABLE_LTO}" == "full" ]]; then echo "TRUE" else echo "FALSE" fi } function is_swift_lto_enabled() { if [[ "${SWIFT_TOOLS_ENABLE_LTO}" == "thin" ]] || [[ "${SWIFT_TOOLS_ENABLE_LTO}" == "full" ]]; then echo "TRUE" else echo "FALSE" fi } # Support for performing isolated actions. # # This is part of refactoring more work to be done or controllable via # `build-script` itself. For additional information, see: # https://bugs.swift.org/browse/SR-237 # # To use this functionality, the script is invoked with: # ONLY_EXECUTE= # where is one of: # all -- execute all actions # ${host}-${product}-build -- the build of the product # ${host}-${product}-test -- the test of the product # ${host}-${product}-install -- the install of the product # ${host}-package -- the package construction and test # merged-hosts-lipo -- the lipo step, if used # and if used, only the one individual action will be performed. # # If not set, the default is `all`. # should_execute_action(name) -> 1 or nil # # Check if the named action should be run in the given script invocation. function should_execute_action() { local name="$1" if [[ "${ONLY_EXECUTE}" = "all" ]] || [[ "${ONLY_EXECUTE}" = "${name}" ]]; then echo 1 fi } # should_execute_host_actions_for_phase(host, phase-name) -> 1 or nil # # Check if the there are any actions to execute for this host and phase (i.e., # "build", "test", or "install") function should_execute_host_actions_for_phase() { local host="$1" local phase_name="$2" if [[ "${ONLY_EXECUTE}" = "all" ]] || [[ "${ONLY_EXECUTE}" == ${host}-*-${phase_name} ]]; then echo 1 fi } function set_build_options_for_host() { llvm_cmake_options=() swift_cmake_options=() cmark_cmake_options=() lldb_cmake_options=() swiftpm_bootstrap_options=() SWIFT_HOST_VARIANT= SWIFT_HOST_VARIANT_SDK= SWIFT_HOST_VARIANT_ARCH= SWIFT_HOST_TRIPLE= 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) case ${host} in freebsd-x86_64) SWIFT_HOST_VARIANT="freebsd" SWIFT_HOST_VARIANT_SDK="FREEBSD" SWIFT_HOST_VARIANT_ARCH="x86_64" ;; cygwin-x86_64) SWIFT_HOST_VARIANT="cygwin" SWIFT_HOST_VARIANT_SDK="CYGWIN" SWIFT_HOST_VARIANT_ARCH="x86_64" ;; haiku-x86_64) SWIFT_HOST_VARIANT="haiku" SWIFT_HOST_VARIANT_SDK="HAIKU" SWIFT_HOST_VARIANT_ARCH="x86_64" ;; linux-*) SWIFT_HOST_VARIANT="linux" SWIFT_HOST_VARIANT_SDK="LINUX" case ${host} in linux-x86_64) SWIFT_HOST_VARIANT_ARCH="x86_64" ;; linux-armv6) SWIFT_HOST_VARIANT_ARCH="armv6" SWIFT_HOST_TRIPLE="armv6-unknown-linux-gnueabihf" llvm_target_arch="ARM" ;; linux-armv7) SWIFT_HOST_VARIANT_ARCH="armv7" SWIFT_HOST_TRIPLE="armv7-unknown-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-*) case ${host} in 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" cmake_osx_deployment_target="${DARWIN_DEPLOYMENT_VERSION_OSX}" cmark_cmake_options=( -DCMAKE_C_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_CXX_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk ${xcrun_sdk_name} --show-sdk-path)" -DCMAKE_OSX_DEPLOYMENT_TARGET="${cmake_osx_deployment_target}" ) swiftpm_bootstrap_options=( --sysroot="$(xcrun --sdk ${xcrun_sdk_name} --show-sdk-path)" ) ;; 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" cmake_osx_deployment_target="" cmark_cmake_options=( -DCMAKE_C_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_CXX_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk ${xcrun_sdk_name} --show-sdk-path)" ) ;; 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" cmake_osx_deployment_target="" cmark_cmake_options=( -DCMAKE_C_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_CXX_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk ${xcrun_sdk_name} --show-sdk-path)" ) ;; 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" cmake_osx_deployment_target="" cmark_cmake_options=( -DCMAKE_C_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_CXX_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk ${xcrun_sdk_name} --show-sdk-path)" ) ;; 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" cmake_osx_deployment_target="" cmark_cmake_options=( -DCMAKE_C_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_CXX_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk ${xcrun_sdk_name} --show-sdk-path)" ) ;; 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" cmake_osx_deployment_target="" cmark_cmake_options=( -DCMAKE_C_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_CXX_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk ${xcrun_sdk_name} --show-sdk-path)" ) ;; 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" cmake_osx_deployment_target="" cmark_cmake_options=( -DCMAKE_C_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_CXX_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk ${xcrun_sdk_name} --show-sdk-path)" ) ;; 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" cmake_osx_deployment_target="" cmark_cmake_options=( -DCMAKE_C_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_CXX_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk ${xcrun_sdk_name} --show-sdk-path)" ) ;; 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" cmake_osx_deployment_target="" cmark_cmake_options=( -DCMAKE_C_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_CXX_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk ${xcrun_sdk_name} --show-sdk-path)" ) ;; 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" cmake_osx_deployment_target="" cmark_cmake_options=( -DCMAKE_C_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_CXX_FLAGS="$(cmark_c_flags ${host})" -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk ${xcrun_sdk_name} --show-sdk-path)" ) ;; *) echo "Unknown host for swift tools: ${host}" exit 1 ;; esac if [[ "${DARWIN_SDK_DEPLOYMENT_TARGETS}" != "" ]]; then local IFS=";"; DARWIN_SDK_DEPLOYMENT_TARGETS=($DARWIN_SDK_DEPLOYMENT_TARGETS) for target in "${DARWIN_SDK_DEPLOYMENT_TARGETS[@]}"; do local IFS="-"; triple=($target) sdk_target=$(toupper ${triple[0]}_${triple[1]}) swift_cmake_options+=( "-DSWIFTLIB_DEPLOYMENT_VERSION_${sdk_target}=${triple[2]}" ) done fi llvm_cmake_options=( -DCMAKE_OSX_DEPLOYMENT_TARGET:STRING="${cmake_osx_deployment_target}" -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk ${xcrun_sdk_name} --show-sdk-path)" -DCOMPILER_RT_ENABLE_IOS:BOOL=FALSE -DCOMPILER_RT_ENABLE_WATCHOS:BOOL=FALSE -DCOMPILER_RT_ENABLE_TVOS:BOOL=FALSE -DSANITIZER_MIN_OSX_VERSION="${cmake_osx_deployment_target}" -DLLVM_ENABLE_MODULES:BOOL="$(true_false ${LLVM_ENABLE_MODULES})" ) if [[ $(is_llvm_lto_enabled) == "TRUE" ]]; then if [[ $(cmake_needs_to_specify_standard_computed_defaults) == "TRUE" ]]; then llvm_cmake_options+=( "-DCMAKE_C_STANDARD_COMPUTED_DEFAULT=AppleClang" "-DCMAKE_CXX_STANDARD_COMPUTED_DEFAULT=AppleClang" ) fi llvm_cmake_options+=( "-DLLVM_PARALLEL_LINK_JOBS=${LLVM_NUM_PARALLEL_LTO_LINK_JOBS}" ) fi if [[ $(is_swift_lto_enabled) == "TRUE" ]]; then if [[ $(cmake_needs_to_specify_standard_computed_defaults) = "TRUE" ]]; then swift_cmake_options+=( "-DCMAKE_C_STANDARD_COMPUTED_DEFAULT=AppleClang" "-DCMAKE_CXX_STANDARD_COMPUTED_DEFAULT=AppleClang" ) fi llvm_cmake_options+=( -DLLVM_ENABLE_MODULE_DEBUGGING:BOOL=NO ) swift_cmake_options+=( -DLLVM_ENABLE_MODULE_DEBUGGING:BOOL=NO "-DSWIFT_PARALLEL_LINK_JOBS=${SWIFT_TOOLS_NUM_PARALLEL_LTO_LINK_JOBS}" ) fi swift_cmake_options+=( -DSWIFT_DARWIN_DEPLOYMENT_VERSION_OSX="${DARWIN_DEPLOYMENT_VERSION_OSX}" -DSWIFT_DARWIN_DEPLOYMENT_VERSION_IOS="${DARWIN_DEPLOYMENT_VERSION_IOS}" -DSWIFT_DARWIN_DEPLOYMENT_VERSION_TVOS="${DARWIN_DEPLOYMENT_VERSION_TVOS}" -DSWIFT_DARWIN_DEPLOYMENT_VERSION_WATCHOS="${DARWIN_DEPLOYMENT_VERSION_WATCHOS}" ) ;; *) echo "Unknown host tools target: ${host}" exit 1 ;; esac llvm_cmake_options+=( -DLLVM_TOOL_COMPILER_RT_BUILD:BOOL="$(false_true ${SKIP_BUILD_COMPILER_RT})" -DLLVM_BUILD_EXTERNAL_COMPILER_RT:BOOL="$(false_true ${SKIP_BUILD_COMPILER_RT})" ) # If we are asked to not generate test targets for LLVM and or Swift, # disable as many LLVM tools as we can. This improves compile time when # compiling with LTO. # # *NOTE* Currently we do not support testing LLVM via build-script. But in a # future commit we will. #for arg in "$(compute_cmake_llvm_tool_disable_flags)"; do # llvm_cmake_options+=( ${arg} ) #done if [[ "${llvm_target_arch}" ]] ; then llvm_cmake_options+=( -DLLVM_TARGET_ARCH="${llvm_target_arch}" ) 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 llvm_cmake_options+=( -DLLVM_HOST_TRIPLE:STRING="${SWIFT_HOST_TRIPLE}" ) swift_cmake_options+=( -DSWIFT_HOST_TRIPLE:STRING="${SWIFT_HOST_TRIPLE}" ) lldb_cmake_options+=( -DLLVM_HOST_TRIPLE:STRING="${SWIFT_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}" ) if [[ "${LLVM_LIT_ARGS}" ]]; then llvm_cmake_options+=( -DLLVM_LIT_ARGS="${LLVM_LIT_ARGS}" ) swift_cmake_options+=( -DLLVM_LIT_ARGS="${LLVM_LIT_ARGS}" ) fi if [[ "${CLANG_PROFILE_INSTR_USE}" ]]; then llvm_cmake_options+=( -DLLVM_PROFDATA_FILE="${CLANG_PROFILE_INSTR_USE}" ) fi swift_cmake_options+=( -DCOVERAGE_DB="${COVERAGE_DB}" ) } function configure_default_options() { # Build a table of all of the known setting variables names. # # This is an optimization to do the argument to variable conversion (which is # slow) in a single pass. local all_settings=() for ((i = 0; i < ${#KNOWN_SETTINGS[@]}; i += 3)); do all_settings+=("${KNOWN_SETTINGS[i]}") done local known_setting_varnames=($(to_varname "${all_settings[*]}")) # Build up an "associative array" mapping setting names to variable names # (we use this for error checking to identify "known options", and as a fast # way to map the setting name to a variable name). See the code for scanning # command line arguments. # # This loop also sets (or unsets) each corresponding variable to its default # value. # # NOTE: If the Mac's bash were not stuck in the past, we could "declare -A" # an associative array, but instead we have to hack it by defining variables. for ((i = 0; i < ${#KNOWN_SETTINGS[@]}; i += 3)); do local setting="${KNOWN_SETTINGS[i]}" local default_value="${KNOWN_SETTINGS[$((i+1))]}" # Find the variable name in our lookup table. local varname="${known_setting_varnames[$((i/3))]}" # Establish the associative array mapping. eval "${setting//-/_}_VARNAME=${varname}" if [[ "${default_value}" ]] ; then # For an explanation of the backslash see http://stackoverflow.com/a/9715377 eval ${varname}=$\default_value else unset ${varname} fi done } configure_default_options COMMAND_NAME="$(basename "$0")" # Print instructions for using this script to stdout usage() { echo "Usage: ${COMMAND_NAME} [--help|-h] [ --SETTING=VALUE | --SETTING VALUE | --SETTING ]*" echo echo " Available settings. Each setting corresponds to a variable," echo " obtained by upcasing its name, in this script. A variable" echo " with no default listed here will be unset in the script if" echo " not explicitly specified. A setting passed in the 3rd form" echo " will set its corresponding variable to \"1\"." echo setting_list=" | |Setting| Default|Description | |-------| -------|----------- " for ((i = 0; i < ${#KNOWN_SETTINGS[@]}; i += 3)); do setting_list+="\ | |--${KNOWN_SETTINGS[i]}| ${KNOWN_SETTINGS[$((i+1))]}|${KNOWN_SETTINGS[$((i+2))]} " done echo "${setting_list}" | column -x -s'|' -t echo echo "Note: when using the form --SETTING VALUE, VALUE must not begin " echo " with a hyphen." echo "Note: the \"--release\" option creates a pre-packaged combination" echo " of settings used by the buildbot." echo echo "Cross-compiling Swift host tools" echo " When building cross-compiled tools, it first builds for the native" echo " build host machine. Then it proceeds to build the specified cross-compile" echo " targets. It currently builds the requested variants of stdlib each" echo " time around, so once for the native build, then again each time for" echo " the cross-compile tool targets." echo echo " When installing cross-compiled tools, it first installs each target" echo " arch into a separate subdirectory under install-destdir, since you" echo " can cross-compile for multiple targets at the same time. It then runs" echo " recursive-lipo to produce fat binaries by merging the cross-compiled" echo " targets, installing the merged result into the expected location of" echo " install-destdir. After that, any remaining steps to extract dsyms and" echo " create an installable package operates on install-destdir as normal." } # Scan all command-line arguments while [[ "$1" ]] ; do case "$1" in -h | --help ) usage exit ;; --* ) dashless="${1:2}" # drop suffix beginning with the first "=" setting="${dashless%%=*}" # compute the variable to set, using the cached map set up by # configure_default_options(). varname_var="${setting//-/_}_VARNAME" varname=${!varname_var} # check to see if this is a known option if [[ "${varname}" = "" ]] ; then echo "error: unknown setting: ${setting}" 1>&2 usage 1>&2 exit 1 fi # find the intended value if [[ "${dashless}" == *=* ]] ; then # if there's an '=', the value value="${dashless#*=}" # is everything after the first '=' elif [[ "$2" ]] && [[ "${2:0:1}" != "-" ]] ; then # else if the next parameter exists value="$2" # but isn't an option, use that shift else # otherwise, the value is 1 value=1 fi # For explanation of backslash see http://stackoverflow.com/a/9715377 eval ${varname}=$\value ;; *) echo "Error: Invalid argument: $1" 1>&2 usage 1>&2 exit 1 esac shift done # TODO: Rename this argument LOCAL_HOST=$HOST_TARGET # TODO: Remove this some time later. if [[ "${USER_CONFIG_ARGS}" ]]; then echo "Error: --user-config-args is renamed to --extra-cmake-options." 1>&2 exit 1 fi if [[ "${CHECK_ARGS_ONLY}" ]]; then exit 0 fi # FIXME: We currently do not support building compiler-rt with the # Xcode generator. if [[ "${CMAKE_GENERATOR}" == "Xcode" ]]; then SKIP_BUILD_COMPILER_RT=1 fi # FIXME: We currently do not support cross-compiling swift with compiler-rt. if [[ "${CROSS_COMPILE_HOSTS}" ]]; then SKIP_BUILD_COMPILER_RT=1 fi if [[ "${SKIP_RECONFIGURE}" ]]; then RECONFIGURE="" fi # WORKSPACE, BUILD_DIR and INSTALLABLE_PACKAGE must be absolute paths case "${WORKSPACE}" in /*) ;; *) echo "workspace must be an absolute path (was '${WORKSPACE}')" exit 1 ;; esac case "${BUILD_DIR}" in /*) ;; "") echo "the --build-dir option is required" usage exit 1 ;; *) echo "build-dir must be an absolute path (was '${BUILD_DIR}')" exit 1 ;; esac case "${INSTALLABLE_PACKAGE}" in /*) ;; "") ;; *) echo "installable-package must be an absolute path (was '${INSTALLABLE_PACKAGE}')" exit 1 ;; esac # WORKSPACE must exist if [ ! -e "${WORKSPACE}" ] ; then echo "Workspace does not exist (tried ${WORKSPACE})" exit 1 fi # FIXME: HOST_CC and CMAKE are set, and their presence is validated by, # utils/build-script. These checks are redundant, but must remain until # build-script-impl is merged completely with utils/build-script. # For additional information, see: https://bugs.swift.org/browse/SR-237 if [ -z "${HOST_CC}" ] ; then echo "Can't find clang. Please install clang-3.5 or a later version." exit 1 fi if [ -z "${CMAKE}" ] ; then echo "Environment variable CMAKE must be specified." exit 1 fi function xcrun_find_tool() { xcrun --sdk macosx --toolchain "${DARWIN_XCRUN_TOOLCHAIN}" --find "$@" } function not() { if [[ ! "$1" ]] ; then echo 1 fi } function join { local IFS="$1"; shift; echo "$*"; } function false_true() { if [[ $(true_false "$1") = "TRUE" ]]; then echo "FALSE" else echo "TRUE" fi } function cmake_version() { "${CMAKE}" --version | grep "cmake version" | cut -f 3 -d " " } function cmake_needs_to_specify_standard_computed_defaults() { if [[ $(cmake_version) = "3.4.0" ]]; then echo "TRUE" else echo "FALSE" fi } function make_relative_symlink() { local SOURCE=$1 local TARGET=$2 local TARGET_DIR=$(dirname "$2") local RELATIVE_SOURCE=$(python -c "import os.path; print(os.path.relpath(\"${SOURCE}\", \"${TARGET_DIR}\"))") call ln -sf "${RELATIVE_SOURCE}" "${TARGET}" } # Sanitize the list of cross-compilation targets. # # 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) # - "BUILD_STDLIB_DEPLOYMENT_TARGETS" are the Targets to build in this invocation CROSS_COMPILE_HOSTS=($CROSS_COMPILE_HOSTS) for t in "${CROSS_COMPILE_HOSTS[@]}"; do case ${t} in iphone* | appletv* | watch* | linux-armv6 | linux-armv7 ) ;; *) echo "Unknown host to cross-compile for: ${t}" exit 1 ;; esac done ALL_HOSTS=("${LOCAL_HOST}" "${CROSS_COMPILE_HOSTS[@]}") function has_cross_compile_hosts() { if [[ ${#ALL_HOSTS[@]} -gt 1 ]]; then echo "1" fi } # We install in to host-specific directories when building more than one host. # Other users will expect their products at INSTALL_DESTDIR. function get_host_install_destdir() { local host="$1" if [[ $(has_cross_compile_hosts) ]]; then # If cross compiling tools, install into a host-specific subdirectory. if [[ $(should_include_host_in_lipo ${host}) ]]; then # If this is one of the hosts we should lipo, install in to a temporary subdirectory. local host_install_destdir="${BUILD_DIR}/intermediate-install/${host}" else local host_install_destdir="${INSTALL_DESTDIR}/${host}" fi else local host_install_destdir="${INSTALL_DESTDIR}" fi echo "${host_install_destdir}/" # Should always end in a '/'; it's a directory. } function splitSemicolonDelimitedInstallPrefixes() { local IFS=";"; CROSS_COMPILE_INSTALL_PREFIXES=($CROSS_COMPILE_INSTALL_PREFIXES) } splitSemicolonDelimitedInstallPrefixes function get_host_install_prefix() { local host="$1" if [[ $(is_cross_tools_host ${host}) ]] && [[ ${#CROSS_COMPILE_INSTALL_PREFIXES[@]} -gt 0 ]]; then # Find the host's index in CROSS_COMPILE_HOSTS. for i in "${!CROSS_COMPILE_HOSTS[@]}"; do if [[ "${CROSS_COMPILE_HOSTS[$i]}" == "${host}" ]]; then local host_index=i fi done if [[ ${host_index} -lt ${#CROSS_COMPILE_INSTALL_PREFIXES[@]} ]]; then local host_install_prefix="${CROSS_COMPILE_INSTALL_PREFIXES[${host_index}]}" else # If there is no explicit install prefix for this host, use the last one # in the list. local host_install_prefix="${CROSS_COMPILE_INSTALL_PREFIXES[${#CROSS_COMPILE_INSTALL_PREFIXES[@]}-1]}" fi else local host_install_prefix="${INSTALL_PREFIX}" fi # Should always begin with a '/'; otherwise CMake will expand it as a relative path from the build folder. if [[ "${host_install_prefix:0:1}" != "/" ]]; then host_install_prefix="/${host_install_prefix}" fi echo "${host_install_prefix}/" # Should always end in a '/'; it's a directory. } function is_cross_tools_host() { local host="$1" for t in "${CROSS_COMPILE_HOSTS[@]}" ; do if [ "${host}" == "${t}" ] ; then echo 1 fi done } # When building cross-compilers for these hosts, # merge all of their contents together with lipo function should_include_host_in_lipo() { local host="$1" if [[ $(has_cross_compile_hosts) ]] && [[ -z "${SKIP_MERGE_LIPO_CROSS_COMPILE_TOOLS}" ]]; then case ${host} in iphone* | appletv* | watch* ) echo 1 ;; esac fi } function host_has_darwin_symbols() { local host="$1" case ${host} in macosx* | iphone* | appletv* | watch* ) echo 1 ;; 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 if [[ "${BUILD_STDLIB_DEPLOYMENT_TARGETS}" == "all" ]]; then echo 1 else # Only build the stdlib targets in 'build-stdlib-deployment-targets' local build_list=($BUILD_STDLIB_DEPLOYMENT_TARGETS) for t in "${build_list[@]}"; do if [[ "${t}" == "${stdlib_target}" ]]; then echo 1 fi done # As with 'stdlib-deployment-targets', 'build-stdlib-deployment-targets' # only applies to the LOCAL_HOST. For cross-tools hosts, always allow # their one-and-only stdlib-target to build. if [[ $(is_cross_tools_host ${host}) ]] && [[ "${stdlib_target}" == "${host}" ]]; then echo 1 fi fi } # # Calculate source directories for each product. # NINJA_SOURCE_DIR="${WORKSPACE}/ninja" SWIFT_SOURCE_DIR="${WORKSPACE}/swift" LLVM_SOURCE_DIR="${WORKSPACE}/llvm" CMARK_SOURCE_DIR="${WORKSPACE}/cmark" LLDB_SOURCE_DIR="${WORKSPACE}/lldb" LLBUILD_SOURCE_DIR="${WORKSPACE}/llbuild" SWIFTPM_SOURCE_DIR="${WORKSPACE}/swiftpm" XCTEST_SOURCE_DIR="${WORKSPACE}/swift-corelibs-xctest" FOUNDATION_SOURCE_DIR="${WORKSPACE}/swift-corelibs-foundation" LIBDISPATCH_SOURCE_DIR="${WORKSPACE}/swift-corelibs-libdispatch" LIBICU_SOURCE_DIR="${WORKSPACE}/icu" PLAYGROUNDSUPPORT_SOURCE_DIR="${WORKSPACE}/swift-xcode-playground-support" if [[ ! "${SKIP_BUILD_PLAYGROUNDSUPPORT}" && ! -d ${PLAYGROUNDSUPPORT_SOURCE_DIR} ]]; then echo "Couldn't find PlaygroundSupport source directory." exit 1 fi # Symlink clang into the llvm tree. CLANG_SOURCE_DIR="${LLVM_SOURCE_DIR}/tools/clang" if [ ! -e "${WORKSPACE}/clang" ] ; then # If llvm/tools/clang is already a directory, use that and skip the symlink. if [ ! -d "${CLANG_SOURCE_DIR}" ] ; then echo "Can't find source directory for clang (tried ${WORKSPACE}/clang and ${CLANG_SOURCE_DIR})" exit 1 fi fi if [ ! -d "${CLANG_SOURCE_DIR}" ] ; then make_relative_symlink "${WORKSPACE}/clang" "${CLANG_SOURCE_DIR}" fi # Symlink compiler-rt into the llvm tree, if it exists. COMPILER_RT_SOURCE_DIR="${LLVM_SOURCE_DIR}/projects/compiler-rt" if [ -e "${WORKSPACE}/compiler-rt" ] ; then if [ ! -d "${COMPILER_RT_SOURCE_DIR}" ] ; then make_relative_symlink "${WORKSPACE}/compiler-rt" "${COMPILER_RT_SOURCE_DIR}" fi fi PRODUCTS=(cmark llvm) if [[ ! "${SKIP_BUILD_LIBICU}" ]] ; then PRODUCTS=("${PRODUCTS[@]}" libicu) fi PRODUCTS=("${PRODUCTS[@]}" swift) if [[ ! "${SKIP_BUILD_LLDB}" ]] ; then PRODUCTS=("${PRODUCTS[@]}" lldb) fi # LLBuild, SwiftPM and XCTest are dependent on Foundation, so Foundation must be # added to the list of build products first. if [[ ! "${SKIP_BUILD_LIBDISPATCH}" ]] ; then PRODUCTS=("${PRODUCTS[@]}" libdispatch) fi if [[ ! "${SKIP_BUILD_FOUNDATION}" ]] ; then PRODUCTS=("${PRODUCTS[@]}" foundation) fi if [[ ! "${SKIP_BUILD_LLBUILD}" ]] ; then PRODUCTS=("${PRODUCTS[@]}" llbuild) fi if [[ ! "${SKIP_BUILD_PLAYGROUNDSUPPORT}" ]] ; then PRODUCTS=("${PRODUCTS[@]}" playgroundsupport) fi # SwiftPM is dependent on XCTest, so XCTest must be added to the list of # build products first. if [[ ! "${SKIP_BUILD_XCTEST}" ]] ; then PRODUCTS=("${PRODUCTS[@]}" xctest) fi if [[ ! "${SKIP_BUILD_SWIFTPM}" ]] ; then PRODUCTS=("${PRODUCTS[@]}" swiftpm) fi # Checks if a given product is enabled (i.e. part of $PRODUCTS array) function contains_product() { local current_product for current_product in "${PRODUCTS[@]}"; do if [[ "$current_product" == "$1" ]]; then return 0 fi done return 1 } # get_host_specific_variable(host, name) # # Get the value of a host-specific variable expected to have been passed by the # `build-script`. # # This is a total hack, and is part of the SR-237 migration. function get_host_specific_variable() { local host="$1" local name="$2" local envvar_name="HOST_VARIABLE_${host//-/_}__${name}" echo "${!envvar_name}" } function calculate_targets_for_host() { local host=$1 SWIFT_STDLIB_TARGETS=() SWIFT_SDKS=() SWIFT_BENCHMARK_TARGETS=() SWIFT_RUN_BENCHMARK_TARGETS=() SWIFT_TEST_TARGETS=() # Get the list of Target platforms for the Host local stdlib_targets=($(get_stdlib_targets_for_host ${host})) 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 local test_host_only= local build_benchmark_this_target= local build_external_benchmark_this_target= local test_benchmark_this_target= 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}) ;; haiku-*) swift_sdk="HAIKU" build_for_this_target=$(not ${SKIP_BUILD_HAIKU}) test_this_target=$(not ${SKIP_TEST_HAIKU}) ;; 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}) build_external_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 else test_this_target= fi build_benchmark_this_target=$(not ${SKIP_BUILD_IOS_DEVICE}) build_external_benchmark_this_target=$(not ${SKIP_BUILD_IOS_DEVICE}) # Never build iOS armv7s benchmarks. if [[ "${stdlib_deployment_target}" == "iphoneos-armv7s" ]]; then build_benchmark_this_target= build_external_benchmark_this_target= fi ;; iphonesimulator-x86_64) swift_sdk="IOS_SIMULATOR" build_for_this_target=$(not ${SKIP_BUILD_IOS_SIMULATOR}) test_this_target=$(not ${SKIP_TEST_IOS_SIMULATOR}) ;; iphonesimulator-i386) swift_sdk="IOS_SIMULATOR" build_for_this_target=$(not ${SKIP_BUILD_IOS_SIMULATOR}) if [[ "${SKIP_TEST_IOS_SIMULATOR}" == "1" ]] ; then SKIP_TEST_IOS_32BIT_SIMULATOR="${SKIP_TEST_IOS_SIMULATOR}" fi test_this_target=$(not ${SKIP_TEST_IOS_32BIT_SIMULATOR}) ;; appletvos-*) swift_sdk="TVOS" build_for_this_target=$(not ${SKIP_BUILD_TVOS_DEVICE}) if [[ ! "${SKIP_TEST_TVOS_HOST}" ]] ; then test_host_only=1 else test_this_target= fi build_benchmark_this_target=$(not ${SKIP_BUILD_TVOS_DEVICE}) build_external_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 else test_this_target= fi build_benchmark_this_target=$(not ${SKIP_BUILD_WATCHOS_DEVICE}) build_external_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}) ;; *) echo "Unknown compiler deployment target: ${stdlib_deployment_target}" exit 1 ;; esac SWIFT_SDKS+=("${swift_sdk}") 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}") else if [[ "${VALIDATION_TEST}" == "1" || "${LONG_TEST}" == "1" ]] ; then SWIFT_STDLIB_TARGETS+=("swift-stdlib-${stdlib_deployment_target}") else SWIFT_STDLIB_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}") if [[ $(not ${SKIP_TEST_BENCHMARKS}) ]] ; then SWIFT_RUN_BENCHMARK_TARGETS+=("check-swift-benchmark-${stdlib_deployment_target}") fi fi if [[ "$(true_false ${SKIP_BUILD_EXTERNAL_BENCHMARKS})" == "FALSE" ]] && [[ "${build_external_benchmark_this_target}" ]] && [[ "${is_in_build_list}" ]] ; then SWIFT_BENCHMARK_TARGETS+=("swift-benchmark-${stdlib_deployment_target}-external") if [[ $(not ${SKIP_TEST_BENCHMARKS}) ]] ; then SWIFT_RUN_BENCHMARK_TARGETS+=("check-swift-benchmark-${stdlib_deployment_target}-external") fi fi if [[ "${test_this_target}" ]] && [[ "${is_in_build_list}" ]]; then test_target_suffix="" if [[ -n "${test_host_only}" ]] ; then test_target_suffix="-non-executable" fi test_subset_target_suffix="" if [[ "${VALIDATION_TEST}" == "1" ]] ; then if [[ "${LONG_TEST}" == "1" ]] ; then test_subset_target_suffix="-all" else test_subset_target_suffix="-validation" fi else if [[ "${LONG_TEST}" == "1" ]] ; then test_subset_target_suffix="-only_long" fi fi SWIFT_TEST_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}") fi if [[ $(not ${SKIP_TEST_OPTIMIZE_FOR_SIZE}) && ! -n "${test_host_only}" ]] ; then SWIFT_TEST_TARGETS+=("check-swift${test_subset_target_suffix}-optimize_size-${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)) # 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[*]}" 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[*]}" 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[*]}" 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[*]}" 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[*]}" exit 1 fi } COMMON_C_FLAGS=" -Wno-unknown-warning-option -Werror=unguarded-availability-new" # Convert to an array. eval COMMON_CMAKE_OPTIONS=(${COMMON_CMAKE_OPTIONS}) eval EXTRA_CMAKE_OPTIONS=(${EXTRA_CMAKE_OPTIONS}) eval BUILD_ARGS=(${BUILD_ARGS}) if [[ -n "${DISTCC}" ]]; then if [[ "$(uname -s)" == "Darwin" ]] ; then # These are normally deduced by CMake, but when the compiler is set to # distcc which is installed elsewhere, we need to set them explicitly. COMMON_CMAKE_OPTIONS=( "${COMMON_CMAKE_OPTIONS[@]}" "-DCMAKE_AR=$(xcrun_find_tool ar)" "-DCMAKE_LINKER=$(xcrun_find_tool ld)" "-DCMAKE_NM=$(xcrun_find_tool nm)" "-DCMAKE_OBJDUMP=$(xcrun_find_tool objdump)" "-DCMAKE_RANLIB=$(xcrun_find_tool ranlib)" "-DCMAKE_STRIP=$(xcrun_find_tool strip)" ) fi fi eval CMAKE_BUILD=("${DISTCC_PUMP}" "${CMAKE}" "--build") if [[ "${CMAKE_GENERATOR}" == "Xcode" ]]; then BUILD_TARGET_FLAG="-target" fi function build_directory() { host=$1 product=$2 echo "${BUILD_DIR}/${product}-${host}" } function build_directory_bin() { host=$1 product=$2 root="$(build_directory ${host} ${product})" if [[ "${CMAKE_GENERATOR}" == "Xcode" ]] ; then case ${product} in cmark) echo "${root}/${CMARK_BUILD_TYPE}/bin" ;; llvm) echo "${root}/${LLVM_BUILD_TYPE}/bin" ;; swift) echo "${root}/${SWIFT_BUILD_TYPE}/bin" ;; lldb) ;; llbuild) echo "${root}/${LLBUILD_BUILD_TYPE}/bin" ;; swiftpm) echo "${root}/${SWIFTPM_BUILD_TYPE}/bin" ;; xctest) echo "${root}/${XCTEST_BUILD_TYPE}/bin" ;; foundation) echo "${root}/${FOUNDATION_BUILD_TYPE}/bin" ;; libdispatch) echo "${root}/${LIBDISPATCH_BUILD_TYPE}/bin" ;; libicu) ;; playgroundsupport) echo "${root}/${PLAYGROUNDSUPPORT_BUILD_TYPE}/bin" ;; *) echo "error: unknown product: ${product}" exit 1 ;; esac else echo "${root}/bin" fi } function is_cmake_release_build_type() { if [[ "$1" == "Release" || "$1" == "RelWithDebInfo" ]] ; then echo 1 fi } function is_cmake_debuginfo_build_type() { if [[ "$1" == "Debug" || "$1" == "RelWithDebInfo" ]] ; then echo 1 fi } function common_cross_c_flags() { echo -n "${COMMON_C_FLAGS}" case $1 in iphonesimulator-i386) echo -n " -arch i386 -mios-simulator-version-min=${DARWIN_DEPLOYMENT_VERSION_IOS}" ;; iphonesimulator-x86_64) echo -n " -arch x86_64 -mios-simulator-version-min=${DARWIN_DEPLOYMENT_VERSION_IOS}" ;; iphoneos-armv7) echo -n " -arch armv7 -miphoneos-version-min=${DARWIN_DEPLOYMENT_VERSION_IOS}" ;; iphoneos-armv7s) echo -n " -arch armv7s -miphoneos-version-min=${DARWIN_DEPLOYMENT_VERSION_IOS}" ;; iphoneos-arm64) echo -n " -arch arm64 -miphoneos-version-min=${DARWIN_DEPLOYMENT_VERSION_IOS}" ;; appletvsimulator-x86_64) echo -n " -arch x86_64 -mtvos-simulator-version-min=${DARWIN_DEPLOYMENT_VERSION_TVOS}" ;; appletvos-arm64) echo -n " -arch arm64 -mtvos-version-min=${DARWIN_DEPLOYMENT_VERSION_TVOS}" ;; watchsimulator-i386) echo -n " -arch i386 -mwatchos-simulator-version-min=${DARWIN_DEPLOYMENT_VERSION_WATCHOS}" ;; watchos-armv7k) echo -n " -arch armv7k -mwatchos-version-min=${DARWIN_DEPLOYMENT_VERSION_WATCHOS}" ;; android-armv7) echo -n " -arch armv7" ;; esac } function llvm_c_flags() { echo -n " $(common_cross_c_flags $1)" if [[ $(is_cmake_release_build_type "${LLVM_BUILD_TYPE}") ]] ; then echo -n " -fno-stack-protector" fi if [[ $(is_cmake_debuginfo_build_type "${LLVM_BUILD_TYPE}") ]] ; then if [[ $(is_llvm_lto_enabled) == "TRUE" ]] ; then echo -n " -gline-tables-only" else echo -n " -g" fi fi } function cmark_c_flags() { echo -n " $(common_cross_c_flags $1)" if [[ $(is_cmake_release_build_type "${CMARK_BUILD_TYPE}") ]] ; then echo -n " -fno-stack-protector" fi } function swift_c_flags() { # Don't pass common_cross_c_flags to Swift because CMake code in the Swift # project is itself aware of cross-compilation for the host tools and # standard library. echo -n "${COMMON_C_FLAGS}" if [[ $(is_cmake_release_build_type "${SWIFT_BUILD_TYPE}") ]] ; then echo -n " -fno-stack-protector" fi if [[ "$(true_false "${SWIFT_STDLIB_USE_NONATOMIC_RC}")" == "TRUE" ]]; then echo -n " -DSWIFT_STDLIB_USE_NONATOMIC_RC" fi } function cmake_config_opt() { product=$1 if [[ "${CMAKE_GENERATOR}" == "Xcode" ]] ; then # CMake automatically adds --target ALL_BUILD if we don't pass this. echo "--target ZERO_CHECK " case ${product} in cmark) echo "--config ${CMARK_BUILD_TYPE}" ;; llvm) echo "--config ${LLVM_BUILD_TYPE}" ;; swift) echo "--config ${SWIFT_BUILD_TYPE}" ;; lldb) ;; llbuild) echo "--config ${LLBUILD_BUILD_TYPE}" ;; swiftpm) echo "--config ${SWIFTPM_BUILD_TYPE}" ;; xctest) echo "--config ${XCTEST_BUILD_TYPE}" ;; foundation) echo "--config ${FOUNDATION_BUILD_TYPE}" ;; libdispatch) echo "--config ${LIBDISPATCH_BUILD_TYPE}" ;; libicu) ;; playgroundsupport) echo "--config ${PLAYGROUNDSUPPORT_BUILD_TYPE}" ;; *) echo "error: unknown product: ${product}" exit 1 ;; esac fi } function set_swiftpm_bootstrap_command() { SWIFTC_BIN="$(build_directory_bin ${LOCAL_HOST} swift)/swiftc" LLBUILD_BIN="$(build_directory_bin ${LOCAL_HOST} llbuild)/swift-build-tool" if [[ ! "${SKIP_BUILD_FOUNDATION}" ]] ; then FOUNDATION_BUILD_DIR=$(build_directory ${host} foundation) if [[ ! "${SKIP_BUILD_LIBDISPATCH}" ]] ; then LIBDISPATCH_BUILD_DIR="$(build_directory ${host} libdispatch)" LIBDISPATCH_BUILD_ARGS="--libdispatch-source-dir=${LIBDISPATCH_SOURCE_DIR} --libdispatch-build-dir=${LIBDISPATCH_BUILD_DIR}" fi if [[ ! "${SKIP_BUILD_LIBICU}" ]] ; then LIBICU_BUILD_DIR="$(build_directory ${host} libicu)" fi if [[ ! "${SKIP_BUILD_XCTEST}" ]] ; then XCTEST_BUILD_DIR=$(build_directory ${host} xctest) fi fi if [ "${SKIP_BUILD_LLBUILD}" ]; then echo "Error: Cannot build swiftpm without llbuild (swift-build-tool)." exit 1 fi swiftpm_bootstrap_command=("${SWIFTPM_SOURCE_DIR}/Utilities/bootstrap" "${swiftpm_bootstrap_options[@]}") # Add --release if we have to build in release mode. if [[ "${SWIFTPM_BUILD_TYPE}" == "Release" ]] ; then swiftpm_bootstrap_command+=(--release) fi if [[ "${VERBOSE_BUILD}" ]] ; then swiftpm_bootstrap_command+=(-v) fi # FIXME CROSSCOMPILING: # SwiftPM needs to be told about the target, sysroot and linker to use # when cross-compiling swiftpm_bootstrap_command+=( --swiftc="${SWIFTC_BIN}" --sbt="${LLBUILD_BIN}" --build="${build_dir}") # Add flags to link llbuild. LLBUILD_BUILD_DIR="$(build_directory ${host} llbuild)" swiftpm_bootstrap_command+=( --link-llbuild --llbuild-source-dir="${LLBUILD_SOURCE_DIR}" --llbuild-build-dir="${LLBUILD_BUILD_DIR}" ) if [[ ! "${SKIP_BUILD_FOUNDATION}" ]] ; then swiftpm_bootstrap_command+=( --foundation="${FOUNDATION_BUILD_DIR}/Foundation") if [[ ! "${SKIP_BUILD_LIBDISPATCH}" ]] ; then swiftpm_bootstrap_command+=( $LIBDISPATCH_BUILD_ARGS) fi if [[ ! "${SKIP_BUILD_XCTEST}" ]] ; then swiftpm_bootstrap_command+=( --xctest="${XCTEST_BUILD_DIR}") fi fi } # Construct the appropriate options to pass to an Xcode # build of any LLDB target. function set_lldb_xcodebuild_options() { llvm_build_dir=$(build_directory ${host} llvm) cmark_build_dir=$(build_directory ${host} cmark) lldb_build_dir=$(build_directory ${host} lldb) swift_build_dir=$(build_directory ${host} swift) lldb_xcodebuild_options=( LLDB_PATH_TO_LLVM_SOURCE="${LLVM_SOURCE_DIR}" LLDB_PATH_TO_CLANG_SOURCE="${CLANG_SOURCE_DIR}" LLDB_PATH_TO_SWIFT_SOURCE="${SWIFT_SOURCE_DIR}" LLDB_PATH_TO_LLVM_BUILD="${llvm_build_dir}" LLDB_PATH_TO_CLANG_BUILD="${llvm_build_dir}" LLDB_PATH_TO_SWIFT_BUILD="${swift_build_dir}" LLDB_PATH_TO_CMARK_BUILD="${cmark_build_dir}" LLDB_IS_BUILDBOT_BUILD="${LLDB_IS_BUILDBOT_BUILD}" LLDB_BUILD_DATE="\"${LLDB_BUILD_DATE}\"" SYMROOT="${lldb_build_dir}" OBJROOT="${lldb_build_dir}" -UseNewBuildSystem=NO ${LLDB_EXTRA_XCODEBUILD_ARGS} ) if [[ "${LLDB_NO_DEBUGSERVER}" ]] ; then lldb_xcodebuild_options=( "${lldb_xcodebuild_options[@]}" DEBUGSERVER_DISABLE_CODESIGN="1" DEBUGSERVER_DELETE_AFTER_BUILD="1" ) fi if [[ "${LLDB_USE_SYSTEM_DEBUGSERVER}" ]] ; then lldb_xcodebuild_options=( "${lldb_xcodebuild_options[@]}" DEBUGSERVER_USE_FROM_SYSTEM="1" ) fi if [[ "${ENABLE_ASAN}" ]] ; then lldb_xcodebuild_options=( "${lldb_xcodebuild_options[@]}" ENABLE_ADDRESS_SANITIZER="YES" -enableAddressSanitizer=YES ) fi if [[ "${ENABLE_UBSAN}" ]] ; then lldb_xcodebuild_options=( "${lldb_xcodebuild_options[@]}" ENABLE_UNDEFINED_BEHAVIOR_SANITIZER="YES" -enableUndefinedBehaviorSanitizer=YES ) fi if [[ "$(true_false ${LLDB_ASSERTIONS})" == "FALSE" ]]; then lldb_xcodebuild_options=( "${lldb_xcodebuild_options[@]}" OTHER_CFLAGS="-DNDEBUG" ) fi } # # Configure and build each product # # Start with native deployment targets because the resulting tools are used during cross-compilation. for host in "${ALL_HOSTS[@]}"; do # Skip this pass when the only action to execute can't match. if ! [[ $(should_execute_host_actions_for_phase ${host} build) ]]; then continue fi calculate_targets_for_host $host set_build_options_for_host $host # 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[@]}" fi if ! [[ "${SKIP_TEST_BENCHMARKS}" ]] && [[ "${SWIFT_RUN_BENCHMARK_TARGETS[@]}" ]]; then echo "Running Swift benchmarks for: ${SWIFT_RUN_BENCHMARK_TARGETS[@]}" fi fi common_cmake_options_host=("${COMMON_CMAKE_OPTIONS[@]}") if [[ $(is_cross_tools_host ${host}) ]] ; then if [[ "${CROSS_COMPILE_WITH_HOST_TOOLS}" ]]; then # Optionally use the freshly-built host copy of clang to build # for foreign hosts. common_cmake_options_host+=( -DCMAKE_C_COMPILER="$(build_directory ${LOCAL_HOST} llvm)/bin/clang" -DCMAKE_CXX_COMPILER="$(build_directory ${LOCAL_HOST} llvm)/bin/clang++" ) fi # CMake can't relink when using Ninja, but that's okay - # we don't need a build-local rpath because we can't run cross-compiled products if [[ "${CMAKE_GENERATOR}" == "Ninja" ]]; then common_cmake_options_host+=( -DCMAKE_BUILD_WITH_INSTALL_RPATH="1" ) fi fi llvm_cmake_options=( "${llvm_cmake_options[@]}" -DCMAKE_INSTALL_PREFIX:PATH="$(get_host_install_prefix ${host})" -DINTERNAL_INSTALL_PREFIX="local" ) if [[ "${DARWIN_TOOLCHAIN_VERSION}" ]] ; then swift_cmake_options=( "${swift_cmake_options[@]}" -DDARWIN_TOOLCHAIN_VERSION="${DARWIN_TOOLCHAIN_VERSION}" ) fi if [[ "${ENABLE_ASAN}" || "$(uname -s)" == "Linux" ]] ; then swift_cmake_options=( "${swift_cmake_options[@]}" -DSWIFT_SOURCEKIT_USE_INPROC_LIBRARY:BOOL=TRUE ) fi if [[ "${DARWIN_CRASH_REPORTER_CLIENT}" ]] ; then swift_cmake_options=( "${swift_cmake_options[@]}" -DSWIFT_RUNTIME_CRASH_REPORTER_CLIENT:BOOL=TRUE ) fi swift_cmake_options=( "${swift_cmake_options[@]}" -DSWIFT_DARWIN_XCRUN_TOOLCHAIN:STRING="${DARWIN_XCRUN_TOOLCHAIN}" ) if [[ "${DARWIN_STDLIB_INSTALL_NAME_DIR}" ]] ; then swift_cmake_options=( "${swift_cmake_options[@]}" -DSWIFT_DARWIN_STDLIB_INSTALL_NAME_DIR:STRING="${DARWIN_STDLIB_INSTALL_NAME_DIR}" ) fi if [[ "${EXTRA_SWIFT_ARGS}" ]] ; then swift_cmake_options=( "${swift_cmake_options[@]}" -DSWIFT_EXPERIMENTAL_EXTRA_REGEXP_FLAGS="${EXTRA_SWIFT_ARGS}" ) fi swift_cmake_options=( "${swift_cmake_options[@]}" -DSWIFT_AST_VERIFIER:BOOL=$(true_false "${SWIFT_ENABLE_AST_VERIFIER}") -DSWIFT_SIL_VERIFY_ALL:BOOL=$(true_false "${SIL_VERIFY_ALL}") -DSWIFT_RUNTIME_ENABLE_LEAK_CHECKER:BOOL=$(true_false "${SWIFT_RUNTIME_ENABLE_LEAK_CHECKER}") ) if [[ "${SKIP_TEST_SOURCEKIT}" ]] ; then swift_cmake_options=( "${swift_cmake_options[@]}" -DSWIFT_ENABLE_SOURCEKIT_TESTS:BOOL=FALSE ) fi for product in "${PRODUCTS[@]}"; do # Check if we should perform this action. if ! [[ $(should_execute_action "${host}-${product}-build") ]]; then continue fi unset skip_build source_dir_var="$(toupper ${product})_SOURCE_DIR" source_dir=${!source_dir_var} build_dir=$(build_directory ${host} ${product}) build_targets=(all) cmake_options=("${common_cmake_options_host[@]}") llvm_build_dir=$(build_directory ${host} llvm) module_cache="${build_dir}/module-cache" # Add any specific cmake options specified by build-script product_cmake_options_name=$(to_varname "${product}")_CMAKE_OPTIONS product_cmake_options=(${!product_cmake_options_name}) # convert to array cmake_options+=("${product_cmake_options[@]}") case ${product} in cmark) cmake_options=( "${cmake_options[@]}" -DCMAKE_BUILD_TYPE:STRING="${CMARK_BUILD_TYPE}" "${cmark_cmake_options[@]}" ) skip_build=${SKIP_BUILD_CMARK} build_targets=(all) ;; llvm) if [ "${BUILD_LLVM}" == "0" ] ; then build_targets=(clean) fi if [ "${SKIP_BUILD_LLVM}" ] ; then # We can't skip the build completely because the standalone # build of Swift depend on these. build_targets=(llvm-tblgen clang-headers intrinsics_gen clang-tablegen-targets) fi if [ "${HOST_LIBTOOL}" ] ; then cmake_options=( "${cmake_options[@]}" -DCMAKE_LIBTOOL:PATH="${HOST_LIBTOOL}" ) fi # Note: we set the variable: # # LLVM_TOOL_SWIFT_BUILD # # below because this script builds swift separately, and people # often have reasons to symlink the swift directory into # llvm/tools, e.g. to build LLDB. cmake_options=( "${cmake_options[@]}" -DCMAKE_C_FLAGS="$(llvm_c_flags ${host})" -DCMAKE_CXX_FLAGS="$(llvm_c_flags ${host})" -DCMAKE_C_FLAGS_RELWITHDEBINFO="-O2 -DNDEBUG" -DCMAKE_CXX_FLAGS_RELWITHDEBINFO="-O2 -DNDEBUG" -DCMAKE_BUILD_TYPE:STRING="${LLVM_BUILD_TYPE}" -DLLVM_TOOL_SWIFT_BUILD:BOOL=NO -DLLVM_INCLUDE_DOCS:BOOL=TRUE -DLLVM_ENABLE_LTO:STRING="${LLVM_ENABLE_LTO}" "${llvm_cmake_options[@]}" ) if [[ "${BUILD_TOOLCHAIN_ONLY}" ]]; then cmake_options+=( -DLLVM_BUILD_TOOLS=NO -DLLVM_INSTALL_TOOLCHAIN_ONLY=YES -DLLVM_INCLUDE_TESTS=NO -DCLANG_INCLUDE_TESTS=NO -DLLVM_INCLUDE_UTILS=NO -DLLVM_TOOL_LLI_BUILD=NO -DLLVM_TOOL_LLVM_AR_BUILD=NO -DCLANG_TOOL_CLANG_CHECK_BUILD=NO -DCLANG_TOOL_ARCMT_TEST_BUILD=NO -DCLANG_TOOL_C_ARCMT_TEST_BUILD=NO -DCLANG_TOOL_C_INDEX_TEST_BUILD=NO -DCLANG_TOOL_DRIVER_BUILD=$(false_true "${BUILD_RUNTIME_WITH_HOST_COMPILER}") -DCLANG_TOOL_DIAGTOOL_BUILD=NO -DCLANG_TOOL_SCAN_BUILD_BUILD=NO -DCLANG_TOOL_SCAN_VIEW_BUILD=NO -DCLANG_TOOL_CLANG_FORMAT_BUILD=NO ) fi if [[ $(true_false "${LLVM_INCLUDE_TESTS}") == "FALSE" ]]; then cmake_options+=( -DLLVM_INCLUDE_TESTS=NO -DCLANG_INCLUDE_TESTS=NO ) fi if [[ $(is_cross_tools_host ${host}) ]] ; then cmake_options=( "${cmake_options[@]}" -DLLVM_TABLEGEN=$(build_directory "${LOCAL_HOST}" llvm)/bin/llvm-tblgen -DCLANG_TABLEGEN=$(build_directory "${LOCAL_HOST}" llvm)/bin/clang-tblgen -DLLVM_NATIVE_BUILD=$(build_directory "${LOCAL_HOST}" llvm) ) fi ;; swift) if [[ ! "${SKIP_BUILD_ANDROID}" ]]; then cmake_options=( "${cmake_options[@]}" -DSWIFT_ANDROID_NDK_PATH:STRING="${ANDROID_NDK}" -DSWIFT_ANDROID_NDK_GCC_VERSION:STRING="${ANDROID_NDK_GCC_VERSION}" -DSWIFT_ANDROID_SDK_PATH:STRING="${ANDROID_NDK}/platforms/android-${ANDROID_API_LEVEL}/arch-arm" -DSWIFT_ANDROID_API_LEVEL:STRING="${ANDROID_API_LEVEL}" -DSWIFT_ANDROID_armv7_ICU_UC:STRING="${ANDROID_ICU_UC}" -DSWIFT_ANDROID_armv7_ICU_UC_INCLUDE:STRING="${ANDROID_ICU_UC_INCLUDE}" -DSWIFT_ANDROID_armv7_ICU_I18N:STRING="${ANDROID_ICU_I18N}" -DSWIFT_ANDROID_armv7_ICU_I18N_INCLUDE:STRING="${ANDROID_ICU_I18N_INCLUDE}" -DSWIFT_ANDROID_DEPLOY_DEVICE_PATH:STRING="${ANDROID_DEPLOY_DEVICE_PATH}" ) fi if [[ "${DARWIN_OVERLAY_TARGET}" != "" ]]; then # Split LOCAL_HOST into a pair ``arch-sdk`` # Example LOCAL_HOST: macosx-x86_64 [[ ${LOCAL_HOST} =~ (.*)-(.*) ]] overlay_target_closure_cmd="${SWIFT_SOURCE_DIR}/utils/find-overlay-deps-closure.sh ${DARWIN_OVERLAY_TARGET} ${BASH_REMATCH[1]} ${BASH_REMATCH[2]}" overlay_target_closure=$($overlay_target_closure_cmd) swift_cmake_options=( "${swift_cmake_options[@]}" "-DSWIFT_OVERLAY_TARGETS:STRING=${overlay_target_closure}" ) fi native_llvm_tools_path="" native_clang_tools_path="" native_swift_tools_path="" if [[ $(is_cross_tools_host ${host}) ]] ; then # Don't build benchmarks and tests when building cross compiler. build_perf_testsuite_this_time=false build_external_perf_testsuite_this_time=false build_tests_this_time=false native_llvm_tools_path="$(build_directory "${LOCAL_HOST}" llvm)/bin" native_clang_tools_path="$(build_directory "${LOCAL_HOST}" llvm)/bin" native_swift_tools_path="$(build_directory "${LOCAL_HOST}" swift)/bin" else # FIXME: Why is the next line not using false_true? build_perf_testsuite_this_time=$(true_false "$(not ${SKIP_BUILD_BENCHMARKS})") build_external_perf_testsuite_this_time=$(false_true "${SKIP_BUILD_EXTERNAL_BENCHMARKS}") build_tests_this_time=${SWIFT_INCLUDE_TESTS} fi # Command-line parameters override any autodetection that we # might have done. if [[ "${NATIVE_LLVM_TOOLS_PATH}" ]] ; then native_llvm_tools_path="${NATIVE_LLVM_TOOLS_PATH}" fi if [[ "${NATIVE_CLANG_TOOLS_PATH}" ]] ; then native_clang_tools_path="${NATIVE_CLANG_TOOLS_PATH}" fi if [[ "${NATIVE_SWIFT_TOOLS_PATH}" ]] ; then native_swift_tools_path="${NATIVE_SWIFT_TOOLS_PATH}" fi if [ "${BUILD_LLVM}" == "0" ] ; then cmake_options=( "${cmake_options[@]}" -DLLVM_TOOLS_BINARY_DIR:PATH=/tmp/dummy ) fi if [ "${HOST_LIPO}" ] ; then cmake_options=( "${cmake_options[@]}" -DSWIFT_LIPO:PATH="${HOST_LIPO}" ) fi if [ "${SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS}" == "" ] ; then SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS="${SWIFT_STDLIB_ENABLE_ASSERTIONS}" fi cmake_options=( "${cmake_options[@]}" -DCMAKE_C_FLAGS="$(swift_c_flags ${host})" -DCMAKE_CXX_FLAGS="$(swift_c_flags ${host})" -DCMAKE_C_FLAGS_RELWITHDEBINFO="-O2 -DNDEBUG" -DCMAKE_CXX_FLAGS_RELWITHDEBINFO="-O2 -DNDEBUG" -DCMAKE_BUILD_TYPE:STRING="${SWIFT_BUILD_TYPE}" -DLLVM_ENABLE_ASSERTIONS:BOOL=$(true_false "${SWIFT_ENABLE_ASSERTIONS}") -DSWIFT_ANALYZE_CODE_COVERAGE:STRING=$(toupper "${SWIFT_ANALYZE_CODE_COVERAGE}") -DSWIFT_STDLIB_BUILD_TYPE:STRING="${SWIFT_STDLIB_BUILD_TYPE}" -DSWIFT_STDLIB_ASSERTIONS:BOOL=$(true_false "${SWIFT_STDLIB_ENABLE_ASSERTIONS}") -DSWIFT_STDLIB_USE_NONATOMIC_RC:BOOL=$(true_false "${SWIFT_STDLIB_USE_NONATOMIC_RC}") -DSWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS:BOOL=$(true_false "${SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS}") -DSWIFT_NATIVE_LLVM_TOOLS_PATH:STRING="${native_llvm_tools_path}" -DSWIFT_NATIVE_CLANG_TOOLS_PATH:STRING="${native_clang_tools_path}" -DSWIFT_NATIVE_SWIFT_TOOLS_PATH:STRING="${native_swift_tools_path}" -DSWIFT_INCLUDE_TOOLS:BOOL=$(true_false "${BUILD_SWIFT_TOOLS}") -DSWIFT_BUILD_REMOTE_MIRROR:BOOL=$(true_false "${BUILD_SWIFT_REMOTE_MIRROR}") -DSWIFT_STDLIB_SIL_DEBUGGING:BOOL=$(true_false "${BUILD_SIL_DEBUGGING_STDLIB}") -DSWIFT_CHECK_INCREMENTAL_COMPILATION:BOOL=$(true_false "${CHECK_INCREMENTAL_COMPILATION}") -DSWIFT_REPORT_STATISTICS:BOOL=$(true_false "${REPORT_STATISTICS}") -DSWIFT_BUILD_DYNAMIC_STDLIB:BOOL=$(true_false "${BUILD_SWIFT_DYNAMIC_STDLIB}") -DSWIFT_BUILD_STATIC_STDLIB:BOOL=$(true_false "${BUILD_SWIFT_STATIC_STDLIB}") -DSWIFT_BUILD_DYNAMIC_SDK_OVERLAY:BOOL=$(true_false "${BUILD_SWIFT_DYNAMIC_SDK_OVERLAY}") -DSWIFT_BUILD_STATIC_SDK_OVERLAY:BOOL=$(true_false "${BUILD_SWIFT_STATIC_SDK_OVERLAY}") -DSWIFT_BUILD_PERF_TESTSUITE:BOOL=$(true_false "${build_perf_testsuite_this_time}") -DSWIFT_BUILD_EXTERNAL_PERF_TESTSUITE:BOOL=$(true_false "${build_external_perf_testsuite_this_time}") -DSWIFT_BUILD_EXAMPLES:BOOL=$(true_false "${BUILD_SWIFT_EXAMPLES}") -DSWIFT_INCLUDE_TESTS:BOOL=$(true_false "${build_tests_this_time}") -DSWIFT_INSTALL_COMPONENTS:STRING="${SWIFT_INSTALL_COMPONENTS}" -DSWIFT_EMBED_BITCODE_SECTION:BOOL=$(true_false "${EMBED_BITCODE_SECTION}") -DSWIFT_TOOLS_ENABLE_LTO:STRING="${SWIFT_TOOLS_ENABLE_LTO}" -DSWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER:BOOL=$(true_false "${BUILD_RUNTIME_WITH_HOST_COMPILER}") "${swift_cmake_options[@]}" ) if [[ "${BUILD_TOOLCHAIN_ONLY}" ]]; then cmake_options+=( -DSWIFT_TOOL_SIL_OPT_BUILD=FALSE -DSWIFT_TOOL_SWIFT_IDE_TEST_BUILD=FALSE -DSWIFT_TOOL_SWIFT_REMOTEAST_TEST_BUILD=FALSE -DSWIFT_TOOL_LLDB_MODULEIMPORT_TEST_BUILD=FALSE -DSWIFT_TOOL_SIL_EXTRACT_BUILD=FALSE -DSWIFT_TOOL_SWIFT_LLVM_OPT_BUILD=FALSE -DSWIFT_TOOL_SWIFT_SDK_ANALYZER_BUILD=FALSE -DSWIFT_TOOL_SWIFT_SDK_DIGESTER_BUILD=FALSE -DSWIFT_TOOL_SOURCEKITD_TEST_BUILD=FALSE -DSWIFT_TOOL_SOURCEKITD_REPL_BUILD=FALSE -DSWIFT_TOOL_COMPLETE_TEST_BUILD=FALSE -DSWIFT_TOOL_SWIFT_REFLECTION_DUMP_BUILD=FALSE ) fi cmake_options=( "${cmake_options[@]}" -DCMAKE_INSTALL_PREFIX:PATH="$(get_host_install_prefix ${host})" -DSWIFT_PATH_TO_CLANG_SOURCE:PATH="${CLANG_SOURCE_DIR}" -DSWIFT_PATH_TO_CLANG_BUILD:PATH="${llvm_build_dir}" -DSWIFT_PATH_TO_LLVM_SOURCE:PATH="${LLVM_SOURCE_DIR}" -DSWIFT_PATH_TO_LLVM_BUILD:PATH="${llvm_build_dir}" -DSWIFT_PATH_TO_CMARK_SOURCE:PATH="${CMARK_SOURCE_DIR}" -DSWIFT_PATH_TO_CMARK_BUILD:PATH="$(build_directory ${host} cmark)" -DSWIFT_PATH_TO_LIBDISPATCH_SOURCE:PATH="${LIBDISPATCH_SOURCE_DIR}" -DSWIFT_PATH_TO_LIBDISPATCH_BUILD:PATH="$(build_directory ${host} libdispatch)" ) if [[ ! "${SKIP_BUILD_LIBICU}" ]] ; then cmake_options=( "${cmake_options[@]}" -DSWIFT_PATH_TO_LIBICU_SOURCE:PATH="${LIBICU_SOURCE_DIR}" -DSWIFT_PATH_TO_LIBICU_BUILD:PATH="$(build_directory ${host} libicu)" ) fi if [[ "${CMAKE_GENERATOR}" == "Xcode" ]] ; then cmake_options=( "${cmake_options[@]}" -DSWIFT_CMARK_LIBRARY_DIR:PATH=$(build_directory ${host} cmark)/src/${CMARK_BUILD_TYPE} ) else cmake_options=( "${cmake_options[@]}" -DSWIFT_CMARK_LIBRARY_DIR:PATH=$(build_directory ${host} cmark)/src ) fi if [[ "${SWIFT_SDKS}" ]] ; then cmake_options=( "${cmake_options[@]}" -DSWIFT_SDKS:STRING="$(join ";" ${SWIFT_SDKS[@]})" ) fi if [[ "${SWIFT_PRIMARY_VARIANT_SDK}" ]] ; then cmake_options=( "${cmake_options[@]}" -DSWIFT_PRIMARY_VARIANT_SDK:STRING="${SWIFT_PRIMARY_VARIANT_SDK}" -DSWIFT_PRIMARY_VARIANT_ARCH:STRING="${SWIFT_PRIMARY_VARIANT_ARCH}" ) fi if contains_product "lldb" ; then lldb_build_dir=$(build_directory ${host} lldb) cmake_options=( "${cmake_options[@]}" -DLLDB_ENABLE:BOOL=TRUE -DLLDB_BUILD_DIR:STRING="${lldb_build_dir}" ) fi build_targets=(all "${SWIFT_STDLIB_TARGETS[@]}") if [[ $(true_false "${build_perf_testsuite_this_time}") == "TRUE" ]]; then native_swift_tools_path="$(build_directory_bin ${LOCAL_HOST} swift)" cmake_options=( "${cmake_options[@]}" -DSWIFT_EXEC:STRING="${native_swift_tools_path}/swiftc" ) build_targets=("${build_targets[@]}" "${SWIFT_BENCHMARK_TARGETS[@]}") fi skip_build=${SKIP_BUILD_SWIFT} ;; lldb) if [ ! -d "${LLDB_SOURCE_DIR}" ]; then echo "error: lldb not found in ${LLDB_SOURCE_DIR}" exit 1 fi if [[ "${CMAKE_GENERATOR}" != "Ninja" ]] ; then echo "error: lldb can only build with ninja" exit 1 fi cmark_build_dir=$(build_directory ${host} cmark) lldb_build_dir=$(build_directory ${host} lldb) swift_build_dir=$(build_directory ${host} swift) # Add any lldb extra cmake arguments here. cmake_options=( "${cmake_options[@]}" "${lldb_cmake_options[@]}" ) if [ ! -z "${LLDB_EXTRA_CMAKE_ARGS}" ]; then cmake_options=( "${cmake_options[@]}" ${LLDB_EXTRA_CMAKE_ARGS} ) fi # Figure out if we think this is a buildbot build. # This will influence the lldb version line. if [ ! -z "${JENKINS_HOME}" -a ! -z "${JOB_NAME}" -a ! -z "${BUILD_NUMBER}" ]; then LLDB_IS_BUILDBOT_BUILD=1 else LLDB_IS_BUILDBOT_BUILD=0 fi # Get the build date LLDB_BUILD_DATE=$(date +%Y-%m-%d) case "${host}" in linux-*) cmake_options=( "${cmake_options[@]}" -DCMAKE_BUILD_TYPE:STRING="${LLDB_BUILD_TYPE}" -DLLDB_SWIFTC:PATH="$(build_directory ${LOCAL_HOST} swift)/bin/swiftc" -DLLDB_SWIFT_LIBS:PATH="$(build_directory ${LOCAL_HOST} swift)/lib/swift" -DCMAKE_INSTALL_PREFIX:PATH="$(get_host_install_prefix ${host})" -DLLDB_PATH_TO_LLVM_SOURCE:PATH="${LLVM_SOURCE_DIR}" -DLLDB_PATH_TO_CLANG_SOURCE:PATH="${CLANG_SOURCE_DIR}" -DLLDB_PATH_TO_SWIFT_SOURCE:PATH="${SWIFT_SOURCE_DIR}" -DLLDB_PATH_TO_LLVM_BUILD:PATH="${llvm_build_dir}" -DLLDB_PATH_TO_CLANG_BUILD:PATH="${llvm_build_dir}" -DLLDB_PATH_TO_SWIFT_BUILD:PATH="${swift_build_dir}" -DLLDB_PATH_TO_CMARK_BUILD:PATH="${cmark_build_dir}" -DLLDB_IS_BUILDBOT_BUILD="${LLDB_IS_BUILDBOT_BUILD}" -DLLDB_BUILD_DATE:STRING="\"${LLDB_BUILD_DATE}\"" -DLLDB_ALLOW_STATIC_BINDINGS=1 ) ;; freebsd-*) cmake_options=( "${cmake_options[@]}" -DCMAKE_BUILD_TYPE:STRING="${LLDB_BUILD_TYPE}" -DLLDB_SWIFTC:PATH="$(build_directory ${LOCAL_HOST} swift)/bin/swiftc" -DLLDB_SWIFT_LIBS:PATH="$(build_directory ${LOCAL_HOST} swift)/lib/swift" -DCMAKE_INSTALL_PREFIX:PATH="$(get_host_install_prefix ${host})" -DLLDB_PATH_TO_LLVM_SOURCE:PATH="${LLVM_SOURCE_DIR}" -DLLDB_PATH_TO_CLANG_SOURCE:PATH="${CLANG_SOURCE_DIR}" -DLLDB_PATH_TO_SWIFT_SOURCE:PATH="${SWIFT_SOURCE_DIR}" -DLLDB_PATH_TO_LLVM_BUILD:PATH="${llvm_build_dir}" -DLLDB_PATH_TO_CLANG_BUILD:PATH="${llvm_build_dir}" -DLLDB_PATH_TO_SWIFT_BUILD:PATH="${swift_build_dir}" -DLLDB_PATH_TO_CMARK_BUILD:PATH="${cmark_build_dir}" -DLLDB_IS_BUILDBOT_BUILD="${LLDB_IS_BUILDBOT_BUILD}" -DLLDB_BUILD_DATE:STRING="\"${LLDB_BUILD_DATE}\"" -DLLDB_ALLOW_STATIC_BINDINGS=1 ) ;; cygwin-*) cmake_options=( "${cmake_options[@]}" -DCMAKE_BUILD_TYPE:STRING="${LLDB_BUILD_TYPE}" -DLLDB_SWIFTC:PATH="$(build_directory ${LOCAL_HOST} swift)/bin/swiftc" -DLLDB_SWIFT_LIBS:PATH="$(build_directory ${LOCAL_HOST} swift)/lib/swift" -DCMAKE_INSTALL_PREFIX:PATH="$(get_host_install_prefix ${host})" -DLLDB_PATH_TO_LLVM_SOURCE:PATH="${LLVM_SOURCE_DIR}" -DLLDB_PATH_TO_CLANG_SOURCE:PATH="${CLANG_SOURCE_DIR}" -DLLDB_PATH_TO_SWIFT_SOURCE:PATH="${SWIFT_SOURCE_DIR}" -DLLDB_PATH_TO_LLVM_BUILD:PATH="${llvm_build_dir}" -DLLDB_PATH_TO_CLANG_BUILD:PATH="${llvm_build_dir}" -DLLDB_PATH_TO_SWIFT_BUILD:PATH="${swift_build_dir}" -DLLDB_PATH_TO_CMARK_BUILD:PATH="${cmark_build_dir}" -DLLDB_IS_BUILDBOT_BUILD="${LLDB_IS_BUILDBOT_BUILD}" -DLLDB_BUILD_DATE:STRING="\"${LLDB_BUILD_DATE}\"" -DLLDB_ALLOW_STATIC_BINDINGS=1 ) ;; haiku-*) cmake_options=( "${cmake_options[@]}" -DCMAKE_BUILD_TYPE:STRING="${LLDB_BUILD_TYPE}" -DLLDB_SWIFTC:PATH="$(build_directory ${LOCAL_HOST} swift)/bin/swiftc" -DLLDB_SWIFT_LIBS:PATH="$(build_directory ${LOCAL_HOST} swift)/lib/swift" -DCMAKE_INSTALL_PREFIX:PATH="$(get_host_install_prefix ${host})" -DLLDB_PATH_TO_LLVM_SOURCE:PATH="${LLVM_SOURCE_DIR}" -DLLDB_PATH_TO_CLANG_SOURCE:PATH="${CLANG_SOURCE_DIR}" -DLLDB_PATH_TO_SWIFT_SOURCE:PATH="${SWIFT_SOURCE_DIR}" -DLLDB_PATH_TO_LLVM_BUILD:PATH="${llvm_build_dir}" -DLLDB_PATH_TO_CLANG_BUILD:PATH="${llvm_build_dir}" -DLLDB_PATH_TO_SWIFT_BUILD:PATH="${swift_build_dir}" -DLLDB_PATH_TO_CMARK_BUILD:PATH="${cmark_build_dir}" -DLLDB_IS_BUILDBOT_BUILD="${LLDB_IS_BUILDBOT_BUILD}" -DLLDB_BUILD_DATE:STRING="\"${LLDB_BUILD_DATE}\"" -DLLDB_ALLOW_STATIC_BINDINGS=1 ) ;; macosx-*) if [[ "$(true_false ${LLDB_BUILD_WITH_XCODE})" == "TRUE" ]] ; then # Set up flags to pass to xcodebuild set_lldb_xcodebuild_options set_lldb_build_mode with_pushd ${source_dir} \ call xcodebuild -target desktop -configuration ${LLDB_BUILD_MODE} ${lldb_xcodebuild_options[@]} continue else cmake_options=( "${cmake_options[@]}" -DCMAKE_BUILD_TYPE:STRING="${LLDB_BUILD_TYPE}" -DLLDB_SWIFTC:PATH="$(build_directory ${LOCAL_HOST} swift)/bin/swiftc" -DLLDB_SWIFT_LIBS:PATH="$(build_directory ${LOCAL_HOST} swift)/lib/swift" -DCMAKE_INSTALL_PREFIX:PATH="$(get_host_install_prefix ${host})" -DLLDB_PATH_TO_LLVM_SOURCE:PATH="${LLVM_SOURCE_DIR}" -DLLDB_PATH_TO_CLANG_SOURCE:PATH="${CLANG_SOURCE_DIR}" -DLLDB_PATH_TO_SWIFT_SOURCE:PATH="${SWIFT_SOURCE_DIR}" -DLLDB_PATH_TO_LLVM_BUILD:PATH="${llvm_build_dir}" -DLLDB_PATH_TO_CLANG_BUILD:PATH="${llvm_build_dir}" -DLLDB_PATH_TO_SWIFT_BUILD:PATH="${swift_build_dir}" -DLLDB_PATH_TO_CMARK_BUILD:PATH="${cmark_build_dir}" -DLLDB_BUILD_FRAMEWORK:BOOL=TRUE -DLLDB_IS_BUILDBOT_BUILD="${LLDB_IS_BUILDBOT_BUILD}" -DLLDB_BUILD_DATE:STRING="\"${LLDB_BUILD_DATE}\"" -DLLDB_ALLOW_STATIC_BINDINGS=1 -DLLDB_CODESIGN_IDENTITY="" ) fi ;; esac if [[ "${BUILD_TOOLCHAIN_ONLY}" ]]; then cmake_options+=( -DLLDB_INCLUDE_TESTS=NO ) else cmake_options+=( -DLLDB_INCLUDE_TESTS=YES ) fi ;; llbuild) cmake_options=( "${cmake_options[@]}" -DCMAKE_INSTALL_PREFIX:PATH="$(get_host_install_prefix ${host})" -DLIT_EXECUTABLE:PATH="${LLVM_SOURCE_DIR}/utils/lit/lit.py" -DFILECHECK_EXECUTABLE:PATH="$(build_directory_bin ${LOCAL_HOST} llvm)/FileCheck" -DCMAKE_BUILD_TYPE:STRING="${LLBUILD_BUILD_TYPE}" -DLLBUILD_ENABLE_ASSERTIONS:BOOL=$(true_false "${LLBUILD_ENABLE_ASSERTIONS}") -DSWIFTC_EXECUTABLE:PATH="$(build_directory_bin ${LOCAL_HOST} swift)/swiftc" -DFOUNDATION_BUILD_DIR:PATH="$(build_directory ${host} foundation)" -DLIBDISPATCH_BUILD_DIR:PATH="$(build_directory ${host} libdispatch)" -DLIBDISPATCH_SOURCE_DIR:PATH="${LIBDISPATCH_SOURCE_DIR}" -DLLBUILD_SUPPORT_BINDINGS:=Swift ) ;; swiftpm) set_swiftpm_bootstrap_command call "${swiftpm_bootstrap_command[@]}" # swiftpm installs itself with a bootstrap method. No further cmake building is performed. continue ;; xctest) SWIFTC_BIN="$(build_directory_bin ${LOCAL_HOST} swift)/swiftc" XCTEST_BUILD_DIR=$(build_directory ${host} xctest) FOUNDATION_BUILD_DIR=$(build_directory ${host} foundation) SWIFT_BUILD_DIR=$(build_directory ${host} swift) # Staging: require opt-in for building with dispatch if [[ ! "${SKIP_BUILD_LIBDISPATCH}" ]] ; then LIBDISPATCH_BUILD_DIR="$(build_directory ${host} libdispatch)" LIBDISPATCH_BUILD_ARGS="--libdispatch-src-dir=${LIBDISPATCH_SOURCE_DIR} --libdispatch-build-dir=${LIBDISPATCH_BUILD_DIR}" fi # Use XCTEST_BUILD_TYPE to build either --debug or --release. if [[ "${XCTEST_BUILD_TYPE}" == "Debug" ]] ; then XCTEST_BUILD_ARGS="--debug" else XCTEST_BUILD_ARGS="--release" fi call "${XCTEST_SOURCE_DIR}"/build_script.py \ --swiftc="${SWIFTC_BIN}" \ --build-dir="${XCTEST_BUILD_DIR}" \ --foundation-build-dir="${FOUNDATION_BUILD_DIR}/Foundation" \ --swift-build-dir="${SWIFT_BUILD_DIR}" \ $LIBDISPATCH_BUILD_ARGS \ $XCTEST_BUILD_ARGS # XCTest builds itself and doesn't rely on cmake continue ;; foundation) # The configuration script requires knowing about XCTest's # location for building and running the tests. Note that XCTest # is not yet built at this point. XCTEST_BUILD_DIR=$(build_directory ${host} xctest) SWIFTC_BIN="$(build_directory_bin ${LOCAL_HOST} swift)/swiftc" SWIFT_BIN="$(build_directory_bin ${LOCAL_HOST} swift)/swift" SWIFT_BUILD_PATH="$(build_directory ${host} swift)" LLVM_BIN="$(build_directory_bin ${LOCAL_HOST} llvm)" # Staging: require opt-in for building with dispatch if [[ ! "${SKIP_BUILD_LIBDISPATCH}" ]] ; then LIBDISPATCH_BUILD_DIR="$(build_directory ${host} libdispatch)" LIBDISPATCH_BUILD_ARGS="-DLIBDISPATCH_SOURCE_DIR=${LIBDISPATCH_SOURCE_DIR} -DLIBDISPATCH_BUILD_DIR=${LIBDISPATCH_BUILD_DIR}" fi # FIXME CROSSCOMPILING: # Foundation is a target library (like the Swift standard library), # so technically we should build it for all stdlib_targets, not just for the host. # However, we only have the triple and sysroot for the host. # Also, we will need to tell it which linker to use. FOUNDATION_BUILD_ARGS=() if [[ $(is_cross_tools_host ${host}) ]]; then FOUNDATION_BUILD_ARGS+=( "--target=${SWIFT_HOST_TRIPLE}" ) fi # FIXME: Foundation doesn't build from the script on OS X if [[ ${host} == "macosx"* ]]; then echo "Skipping Foundation on OS X -- use the Xcode project instead" continue fi # FIXME: Always re-build foundation on non-darwin platforms. # Remove this when products build in the CMake system. echo "Cleaning the Foundation build directory" call rm -rf "${build_dir}" with_pushd "${FOUNDATION_SOURCE_DIR}" \ call env SWIFTC="${SWIFTC_BIN}" CLANG="${LLVM_BIN}"/clang SWIFT="${SWIFT_BIN}" \ SDKROOT="${SWIFT_BUILD_PATH}" BUILD_DIR="${build_dir}" DSTROOT="$(get_host_install_destdir ${host})" PREFIX="$(get_host_install_prefix ${host})" ./configure "${FOUNDATION_BUILD_TYPE}" ${FOUNDATION_BUILD_ARGS[@]} -DXCTEST_BUILD_DIR=${XCTEST_BUILD_DIR} $LIBDISPATCH_BUILD_ARGS with_pushd "${FOUNDATION_SOURCE_DIR}" \ call ${NINJA_BIN} # Foundation builds itself and doesn't use cmake continue ;; libdispatch) LIBDISPATCH_BUILD_DIR=$(build_directory ${host} ${product}) SWIFT_BUILD_PATH="$(build_directory ${host} swift)" SWIFTC_BIN="$(build_directory_bin ${LOCAL_HOST} swift)/swiftc" LLVM_BIN="$(build_directory_bin ${LOCAL_HOST} llvm)" case "${host}" in macosx-*) if [[ "${RECONFIGURE}" || ! -f "${LIBDISPATCH_BUILD_DIR}"/config.status ]]; then echo "Reconfiguring libdispatch" # First time building; need to run autotools and configure if [[ "$LIBDISPATCH_BUILD_TYPE" == "Release" ]] ; then dispatch_build_variant_arg="release" elif [[ "$LIBDISPATCH_BUILD_TYPE" == "RelWithDebInfo" ]]; then dispatch_build_variant_arg="releasedebuginfo" else dispatch_build_variant_arg="debug" fi if [ $(true_false "${BUILD_SWIFT_STATIC_STDLIB}") == "TRUE" ]; then libdispatch_enable_static="--enable-static=yes" else libdispatch_enable_static="" fi call mkdir -p "${LIBDISPATCH_BUILD_DIR}" with_pushd "${LIBDISPATCH_SOURCE_DIR}" \ call autoreconf -fvi with_pushd "${LIBDISPATCH_BUILD_DIR}" \ call env CC="${LLVM_BIN}/clang" CXX="${LLVM_BIN}/clang++" SWIFTC="${SWIFTC_BIN}" \ "${LIBDISPATCH_SOURCE_DIR}"/configure --with-swift-toolchain="${SWIFT_BUILD_PATH}" \ --with-build-variant=$dispatch_build_variant_arg \ --prefix="$(get_host_install_destdir ${host})$(get_host_install_prefix ${host})" ${libdispatch_enable_static} else echo "Skipping reconfiguration of libdispatch" fi with_pushd "${LIBDISPATCH_BUILD_DIR}" \ call make with_pushd "${LIBDISPATCH_BUILD_DIR}/tests" \ call make build-tests # libdispatch builds itself and doesn't use cmake continue ;; *) # FIXME: Always re-build libdispatch on non-darwin platforms. # Remove this when products build in the CMake system. echo "Cleaning the libdispatch build directory" call rm -rf "${LIBDISPATCH_BUILD_DIR}" cmake_options=( ${cmake_options[@]} -DCMAKE_BUILD_TYPE:STRING="${LIBDISPATCH_BUILD_TYPE}" -DCMAKE_C_COMPILER:PATH="${LLVM_BIN}/clang" -DCMAKE_CXX_COMPILER:PATH="${LLVM_BIN}/clang++" -DCMAKE_SWIFT_COMPILER:PATH="${SWIFTC_BIN}" -DCMAKE_INSTALL_PREFIX:PATH="$(get_host_install_prefix ${host})" -DCMAKE_INSTALL_LIBDIR:PATH="lib" -DENABLE_SWIFT=YES -DSWIFT_RUNTIME_LIBDIR:PATH="${SWIFT_BUILD_PATH}/lib/swift/${SWIFT_HOST_VARIANT}/${SWIFT_HOST_VARIANT_ARCH}" -DENABLE_TESTING=YES ) ;; esac ;; libicu) SWIFT_BUILD_PATH=$(build_directory ${host} swift) LIBICU_BUILD_DIR=$(build_directory ${host} ${product}) ICU_TMPINSTALL=$LIBICU_BUILD_DIR/tmp_install ICU_TMPLIBDIR="${SWIFT_BUILD_PATH}/lib/swift/${SWIFT_HOST_VARIANT}/${SWIFT_HOST_VARIANT_ARCH}" if [[ "${RECONFIGURE}" || ! -f "${LIBICU_BUILD_DIR}"/config.status ]]; then echo "Reconfiguring libicu" if [[ "$LIBICU_BUILD_TYPE" == "Release" ]] ; then icu_build_variant_arg="--enable-release" elif [[ "$LIBICU_BUILD_TYPE" == "RelWithDebInfo" ]]; then icu_build_variant_arg="--enable-release" else icu_build_variant_arg="--enable-debug" fi call mkdir -p "${LIBICU_BUILD_DIR}" with_pushd "${LIBICU_BUILD_DIR}" \ call "${LIBICU_SOURCE_DIR}"/source/configure \ ${icu_build_variant_arg} --prefix=${ICU_TMPINSTALL} \ --libdir=${ICU_TMPLIBDIR} \ --enable-shared --enable-static \ --enable-strict --disable-icuio \ --disable-plugins --disable-dyload --disable-extras \ --disable-samples --with-data-packaging=auto else echo "Skipping reconfiguration of libicu" fi with_pushd "${LIBICU_BUILD_DIR}" \ call make install ICU_LIBDIR="$(build_directory ${host} swift)/lib/swift/${SWIFT_HOST_VARIANT}/${SWIFT_HOST_VARIANT_ARCH}" ICU_LIBDIR_STATIC="$(build_directory ${host} swift)/lib/swift_static/${SWIFT_HOST_VARIANT}" ICU_LIBDIR_STATIC_ARCH="$(build_directory ${host} swift)/lib/swift_static/${SWIFT_HOST_VARIANT}/${SWIFT_HOST_VARIANT_ARCH}" mkdir -p "${ICU_LIBDIR_STATIC_ARCH}" # Copy the static libs into the swift_static directory for l in uc i18n data do lib="${ICU_LIBDIR}/libicu${l}.a" cp "${lib}" "${ICU_LIBDIR_STATIC}" cp "${lib}" "${ICU_LIBDIR_STATIC_ARCH}" done # Set the PKG_CONFIG_PATH so that core-foundation can find the libraries and # header files export PKG_CONFIG_PATH="${ICU_TMPLIBDIR}/pkgconfig" swift_cmake_options=( "${swift_cmake_options[@]}" -DSWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_UC_INCLUDE:STRING="${ICU_TMPINSTALL}/include" -DSWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_I18N_INCLUDE:STRING="${ICU_TMPINSTALL}/include" -DSWIFT_${SWIFT_HOST_VARIANT_SDK}_${SWIFT_HOST_VARIANT_ARCH}_ICU_STATICLIB:BOOL=TRUE ) # libicu builds itself and doesn't use cmake continue ;; playgroundsupport) if [[ "$(uname -s)" != "Darwin" ]]; then echo "error: unable to build PlaygroundLogger and PlaygroundSupport on this platform" exit 1 fi SWIFTC_BIN="$(build_directory_bin ${host} swift)/swiftc" SWIFT_LIB_DIR="$(build_directory ${host} swift)"/lib/swift/ set -x pushd "${PLAYGROUNDSUPPORT_SOURCE_DIR}" if [[ $(not ${SKIP_BUILD_OSX}) ]]; then "xcodebuild" -configuration "${PLAYGROUNDSUPPORT_BUILD_TYPE}" -workspace swift-xcode-playground-support.xcworkspace -scheme BuildScript-macOS -sdk macosx -arch x86_64 -derivedDataPath "${build_dir}"/DerivedData SWIFT_EXEC="${SWIFTC_BIN}" SWIFT_LIBRARY_PATH="${SWIFT_LIB_DIR}/\$(PLATFORM_NAME)" ONLY_ACTIVE_ARCH=NO if [[ $(not ${SKIP_TEST_PLAYGROUNDSUPPORT}) ]]; then # If we're going to end up testing PlaygroundLogger/PlaygroundSupport, then we need to build the tests too. # Note that this *always* needs to run in Debug configuration. "xcodebuild" build-for-testing -configuration Debug -workspace swift-xcode-playground-support.xcworkspace -scheme BuildScript-Test-PlaygroundLogger-macOS -sdk macosx -arch x86_64 -derivedDataPath "${build_dir}"/DerivedData SWIFT_EXEC="${SWIFTC_BIN}" SWIFT_LIBRARY_PATH="${SWIFT_LIB_DIR}/\$(PLATFORM_NAME)" ONLY_ACTIVE_ARCH=NO fi fi if [[ $(not ${SKIP_BUILD_IOS_SIMULATOR}) ]]; then "xcodebuild" -configuration "${PLAYGROUNDSUPPORT_BUILD_TYPE}" -workspace swift-xcode-playground-support.xcworkspace -scheme BuildScript-iOS -sdk iphonesimulator -arch x86_64 -derivedDataPath "${build_dir}"/DerivedData SWIFT_EXEC="${SWIFTC_BIN}" SWIFT_LIBRARY_PATH="${SWIFT_LIB_DIR}/\$(PLATFORM_NAME)" ONLY_ACTIVE_ARCH=NO fi if [[ $(not ${SKIP_BUILD_TVOS_SIMULATOR}) ]]; then "xcodebuild" -configuration "${PLAYGROUNDSUPPORT_BUILD_TYPE}" -workspace swift-xcode-playground-support.xcworkspace -scheme BuildScript-tvOS -sdk appletvsimulator -arch x86_64 -derivedDataPath "${build_dir}"/DerivedData SWIFT_EXEC="${SWIFTC_BIN}" SWIFT_LIBRARY_PATH="${SWIFT_LIB_DIR}/\$(PLATFORM_NAME)" ONLY_ACTIVE_ARCH=NO fi popd { set +x; } 2>/dev/null continue ;; *) echo "error: unknown product: ${product}" exit 1 ;; esac # Compute the generator output file to check for, to determine if we # must reconfigure. We only handle Ninja for now. # # This is important for ensuring that if a CMake configuration fails in # CI, that we will still be willing to rerun the configuration process. generator_output_path="" if [[ "${CMAKE_GENERATOR}" == "Ninja" ]] ; then generator_output_path="${build_dir}/build.ninja" fi # Configure if necessary. cmake_cache_path="${build_dir}/CMakeCache.txt" if [[ "${RECONFIGURE}" || ! -f "${cmake_cache_path}" || \ ( ! -z "${generator_output_path}" && ! -f "${generator_output_path}" ) ]] ; then call mkdir -p "${build_dir}" if [[ -n "${DISTCC}" ]]; then EXTRA_DISTCC_OPTIONS=("DISTCC_HOSTS=localhost,lzo,cpp") fi with_pushd "${build_dir}" \ call env "${EXTRA_DISTCC_OPTIONS[@]}" "${CMAKE}" "${cmake_options[@]}" "${EXTRA_CMAKE_OPTIONS[@]}" "${source_dir}" fi # When we are building LLVM create symlinks to the c++ headers. We need # to do this before building LLVM since compiler-rt depends on being # built with the just built clang compiler. These are normally put into # place during the cmake step of LLVM's build when libcxx is in # tree... but we are not building llvm with libcxx in tree when we build # swift. So we need to do configure's work here. if [[ "${product}" == "llvm" ]]; then # Find the location of the c++ header dir. if [[ "$(uname -s)" == "Darwin" ]] ; then HOST_CXX_DIR=$(dirname "${HOST_CXX}") HOST_CXX_HEADERS_DIR="$HOST_CXX_DIR/../../usr/include/c++" elif [[ "$(uname -s)" == "Haiku" ]] ; then HOST_CXX_HEADERS_DIR="/boot/system/develop/headers/c++" else # Linux HOST_CXX_HEADERS_DIR="/usr/include/c++" fi # Find the path in which the local clang build is expecting to find # the c++ header files. BUILT_CXX_INCLUDE_DIR="$llvm_build_dir/include" echo "symlinking the system headers ($HOST_CXX_HEADERS_DIR) into the local clang build directory ($BUILT_CXX_INCLUDE_DIR)." call ln -s -f "$HOST_CXX_HEADERS_DIR" "$BUILT_CXX_INCLUDE_DIR" fi # Build. if [[ ! "${skip_build}" ]]; then if [[ "${CMAKE_GENERATOR}" == "Xcode" ]] ; then # Xcode generator uses "ALL_BUILD" instead of "all". # Also, xcodebuild uses -target instead of bare names. build_targets=("${build_targets[@]/all/ALL_BUILD}") build_targets=("${build_targets[@]/#/${BUILD_TARGET_FLAG} }") # Xcode can't restart itself if it turns out we need to reconfigure. # Do an advance build to handle that. call "${CMAKE_BUILD[@]}" "${build_dir}" $(cmake_config_opt ${product}) fi call "${CMAKE_BUILD[@]}" "${build_dir}" $(cmake_config_opt ${product}) -- "${BUILD_ARGS[@]}" ${build_targets[@]} fi done done # END OF BUILD PHASE # Trap function to print the current test configuration when tests fail. # This is a function so the text is not unnecessarily displayed when running -x. tests_busted () { echo "*** Failed while running tests for $1 $2" } for host in "${ALL_HOSTS[@]}"; do # Skip this pass when the only action to execute can't match. if ! [[ $(should_execute_host_actions_for_phase ${host} test) ]]; then continue fi # Calculate test targets calculate_targets_for_host $host # Run the tests for each product for product in "${PRODUCTS[@]}"; do # Check if we should perform this action. if ! [[ $(should_execute_action "${host}-${product}-test") ]]; then continue fi case ${product} in cmark) if [[ "${SKIP_TEST_CMARK}" ]]; then continue fi executable_target=api_test results_targets=(test) if [[ "${CMAKE_GENERATOR}" == "Xcode" ]]; then # Xcode generator uses "RUN_TESTS" instead of "test". results_targets=(RUN_TESTS) fi ;; llvm) continue # We don't test LLVM ;; swift) executable_target= results_targets= if ! [[ "${SKIP_TEST_SWIFT}" ]]; then executable_target=SwiftUnitTests results_targets=("${SWIFT_TEST_TARGETS[@]}") if [[ "${STRESS_TEST_SOURCEKIT}" ]]; then results_targets=( "${results_targets[@]}" stress-SourceKit ) fi fi if ! [[ "${SKIP_TEST_BENCHMARKS}" ]]; then results_targets=( "${results_targets[@]}" "${SWIFT_RUN_BENCHMARK_TARGETS[@]}" ) fi if [[ -z "${results_targets[@]}" ]]; then continue fi ;; lldb) if [[ "${SKIP_TEST_LLDB}" ]]; then continue fi lldb_build_dir=$(build_directory ${host} lldb) using_xcodebuild="FALSE" if [[ "$(uname -s)" == "Darwin" && "$(true_false ${LLDB_BUILD_WITH_XCODE})" == "TRUE" ]] ; then using_xcodebuild="TRUE" fi # Run the unittests. # FIXME: The xcode build project currently doesn't know how to run the lit style tests. if [[ "$using_xcodebuild" == "TRUE" ]] ; then set_lldb_xcodebuild_options # Run the LLDB unittests (gtests). with_pushd ${LLDB_SOURCE_DIR} \ call xcodebuild -scheme lldb-gtest -configuration ${LLDB_BUILD_MODE} ${lldb_xcodebuild_options[@]} rc=$? if [[ "$rc" -ne 0 ]] ; then >&2 echo "error: LLDB gtests failed" exit 1 fi else with_pushd ${lldb_build_dir} \ ${NINJA_BIN} check-lldb-lit fi swift_build_dir=$(build_directory ${host} swift) # Setup lldb executable path if [[ "$using_xcodebuild" == "TRUE" ]] ; then lldb_executable="${lldb_build_dir}"/${LLDB_BUILD_MODE}/lldb else lldb_executable="${lldb_build_dir}"/bin/lldb fi results_dir="${lldb_build_dir}/test-results" # Handle test results formatter if [[ "${LLDB_TEST_WITH_CURSES}" ]]; then # Setup the curses results formatter. LLDB_FORMATTER_OPTS="\ --results-formatter lldbsuite.test_event.formatter.curses.Curses \ --results-file /dev/stdout" else LLDB_FORMATTER_OPTS="\ --results-formatter lldbsuite.test_event.formatter.xunit.XunitFormatter \ --results-file ${results_dir}/results.xml \ -O--xpass=success \ -O--xfail=success" # Setup the xUnit results formatter. if [[ "$(uname -s)" != "Darwin" ]] ; then # On non-Darwin, we ignore skipped tests entirely # so that they don't pollute our xUnit results with # non-actionable content. LLDB_FORMATTER_OPTS="${LLDB_FORMATTER_OPTS} -O-ndsym -O-rdebugserver -O-rlibc\\\\+\\\\+ -O-rlong.running -O-rbenchmarks -O-rrequires.one?.of.darwin" fi fi # Optionally specify a test subdirectory and category filters. # Watchpoint testing is currently disabled: see rdar://38566150. if [[ "$(true_false ${LLDB_TEST_SWIFT_ONLY})" == "TRUE" ]]; then LLDB_TEST_SUBDIR_CLAUSE="--test-subdir lang/swift" LLDB_TEST_CATEGORIES="--skip-category=watchpoint --skip-category=dwo --skip-category=dsym --skip-category=gmodules -G swiftpr" else LLDB_TEST_SUBDIR_CLAUSE="" LLDB_TEST_CATEGORIES="--skip-category=watchpoint" fi # figure out which C/C++ compiler we should use for building test inferiors. if [[ "${LLDB_TEST_CC}" == "host-toolchain" ]]; then # Use the host toolchain: i.e. the toolchain specified by HOST_CC LLDB_DOTEST_CC_OPTS="-C ${HOST_CC}" elif [[ -n "${LLDB_TEST_CC}" ]]; then # Use exactly the compiler path specified by the user. LLDB_DOTEST_CC_OPTS="-C ${LLDB_TEST_CC}" else # Use the clang that was just built in the tree. LLDB_DOTEST_CC_OPTS="-C $(build_directory $LOCAL_HOST llvm)"/bin/clang fi # If we need to use the system debugserver, do so explicitly. if [[ "$(uname -s)" == "Darwin" && "${LLDB_USE_SYSTEM_DEBUGSERVER}" ]] ; then LLDB_TEST_DEBUG_SERVER="--server $(xcode-select -p)/../SharedFrameworks/LLDB.framework/Resources/debugserver --out-of-tree-debugserver" else LLDB_TEST_DEBUG_SERVER="" fi # Options to find the just-built libddispatch and Foundation. if [[ "$(uname -s)" == "Darwin" || "${SKIP_BUILD_FOUNDATION}" ]] ; then DOTEST_EXTRA="" else # This assumes that there are no spaces in any on these paths. FOUNDATION_BUILD_DIR=$(build_directory ${host} foundation) DOTEST_EXTRA="-I${FOUNDATION_BUILD_DIR}/Foundation" DOTEST_EXTRA="${DOTEST_EXTRA} -I${FOUNDATION_BUILD_DIR}/Foundation/usr/lib/swift" DOTEST_EXTRA="${DOTEST_EXTRA} -I${LIBDISPATCH_SOURCE_DIR}" DOTEST_EXTRA="${DOTEST_EXTRA} -L${FOUNDATION_BUILD_DIR}/Foundation" DOTEST_EXTRA="${DOTEST_EXTRA} -L${LIBDISPATCH_BUILD_DIR}" DOTEST_EXTRA="${DOTEST_EXTRA} -L${LIBDISPATCH_BUILD_DIR}/src" fi call mkdir -p "${results_dir}" # Prefer to use lldb-dotest, as building it guarantees that we build all # test dependencies. Ultimately we want to delete as much lldb-specific logic # from this file as possible and just have a single call to lldb-dotest. if [[ "$using_xcodebuild" == "FALSE" ]] ; then with_pushd ${lldb_build_dir} \ ${NINJA_BIN} lldb-dotest lldb_dotest="${lldb_build_dir}"/bin/lldb-dotest with_pushd ${results_dir} \ call "${lldb_dotest}" \ ${LLDB_TEST_SUBDIR_CLAUSE} \ ${LLDB_TEST_CATEGORIES} \ ${LLDB_FORMATTER_OPTS} \ --build-dir "${lldb_build_dir}/lldb-test-build.noindex" \ -E "${DOTEST_EXTRA}" else with_pushd "${results_dir}" \ call env SWIFTC="$(build_directory $LOCAL_HOST swift)/bin/swiftc" \ SWIFTLIBS="${swift_build_dir}/lib/swift" \ "${LLDB_SOURCE_DIR}"/test/dotest.py \ --executable "${lldb_executable}" \ ${LLDB_TEST_DEBUG_SERVER} \ ${LLDB_TEST_SUBDIR_CLAUSE} \ ${LLDB_TEST_CATEGORIES} \ ${LLDB_DOTEST_CC_OPTS} \ ${LLDB_FORMATTER_OPTS} \ --build-dir "${lldb_build_dir}/lldb-test-build.noindex" \ -E "${DOTEST_EXTRA}" fi continue ;; llbuild) if [[ "${SKIP_TEST_LLBUILD}" ]]; then continue fi results_targets=("test") executable_target="" ;; swiftpm) if [[ "${SKIP_TEST_SWIFTPM}" ]]; then continue fi echo "--- Running tests for ${product} ---" call "${swiftpm_bootstrap_command[@]}" test --test-parallel # As swiftpm tests itself, we break early here. continue ;; xctest) if [[ "${SKIP_TEST_XCTEST}" ]]; then continue fi # If libdispatch is being built then XCTest will need access to it if [[ ! "${SKIP_BUILD_LIBDISPATCH}" ]] ; then LIBDISPATCH_BUILD_DIR="$(build_directory ${host} libdispatch)" LIBDISPATCH_BUILD_ARGS="--libdispatch-src-dir=${LIBDISPATCH_SOURCE_DIR} --libdispatch-build-dir=${LIBDISPATCH_BUILD_DIR}" fi # Use XCTEST_BUILD_TYPE to build either --debug or --release. if [[ "${XCTEST_BUILD_TYPE}" == "Debug" ]] ; then XCTEST_BUILD_ARGS="--debug" else XCTEST_BUILD_ARGS="--release" fi echo "--- Running tests for ${product} ---" SWIFTC_BIN="$(build_directory_bin ${LOCAL_HOST} swift)/swiftc" FOUNDATION_BUILD_DIR=$(build_directory ${host} foundation) XCTEST_BUILD_DIR=$(build_directory ${host} xctest) call "${XCTEST_SOURCE_DIR}"/build_script.py test \ --swiftc="${SWIFTC_BIN}" \ --lit="${LLVM_SOURCE_DIR}/utils/lit/lit.py" \ --foundation-build-dir="${FOUNDATION_BUILD_DIR}/Foundation" \ ${LIBDISPATCH_BUILD_ARGS} \ $XCTEST_BUILD_ARGS \ "${XCTEST_BUILD_DIR}" echo "--- Finished tests for ${product} ---" continue ;; foundation) # FIXME: Foundation doesn't build from the script on OS X if [[ ${host} == "macosx"* ]]; then echo "Skipping Foundation on OS X -- use the Xcode project instead" continue fi if [[ "${SKIP_TEST_FOUNDATION}" ]]; then continue fi # If libdispatch is being built, TestFoundation will need access to it if [[ ! "${SKIP_BUILD_LIBDISPATCH}" ]] ; then LIBDISPATCH_LIB_DIR=":$(build_directory ${host} libdispatch)/src/.libs" else LIBDISPATCH_LIB_DIR="" fi echo "--- Running tests for ${product} ---" build_dir=$(build_directory ${host} ${product}) XCTEST_BUILD_DIR=$(build_directory ${host} xctest) with_pushd "${FOUNDATION_SOURCE_DIR}" \ call ${NINJA_BIN} TestFoundation call env LD_LIBRARY_PATH="$(get_host_install_destdir ${host})$(get_host_install_prefix ${host})"/lib/swift/:"${build_dir}/Foundation":"${XCTEST_BUILD_DIR}""${LIBDISPATCH_LIB_DIR}":${LD_LIBRARY_PATH} "${build_dir}"/TestFoundation/TestFoundation echo "--- Finished tests for ${product} ---" continue ;; libdispatch) if [[ "${SKIP_TEST_LIBDISPATCH}" ]]; then continue fi case "${host}" in macosx-*) LIBDISPATCH_BUILD_DIR=$(build_directory ${host} ${product}) echo "--- Running tests for ${product} ---" with_pushd "${LIBDISPATCH_BUILD_DIR}" \ call env VERBOSE=1 make check echo "--- Finished tests for ${product} ---" continue ;; *) results_targets=( "test" ) executable_target="" ;; esac ;; libicu) if [[ "${SKIP_TEST_LIBICU}" ]]; then continue fi LIBICU_BUILD_DIR=$(build_directory ${host} ${product}) echo "--- Running tests for ${product} ---" with_pushd "${LIBICU_BUILD_DIR}/test" \ call make echo "--- Finished tests for ${product} ---" continue ;; playgroundsupport) if [[ "${SKIP_TEST_PLAYGROUNDSUPPORT}" ]]; then continue fi if [[ "${host}" != "macosx"* ]]; then echo "Skipping PlaygroundLogger tests on non-macOS platform" continue fi PLAYGROUNDSUPPORT_BUILD_DIR=$(build_directory ${host} ${product}) SWIFTC_BIN="$(build_directory_bin ${host} swift)/swiftc" SWIFT_LIB_DIR="$(build_directory ${host} swift)"/lib/swift/ set -x with_pushd "${PLAYGROUNDSUPPORT_SOURCE_DIR}" \ "xcodebuild" test-without-building -configuration Debug -workspace swift-xcode-playground-support.xcworkspace -scheme BuildScript-Test-PlaygroundLogger-macOS -sdk macosx -arch x86_64 -derivedDataPath "${PLAYGROUNDSUPPORT_BUILD_DIR}"/DerivedData SWIFT_EXEC="${SWIFTC_BIN}" SWIFT_LIBRARY_PATH="${SWIFT_LIB_DIR}/\$(PLATFORM_NAME)" ONLY_ACTIVE_ARCH=NO { set +x; } 2>/dev/null continue ;; *) echo "error: unknown product: ${product}" exit 1 ;; esac trap "tests_busted ${product} ''" ERR build_dir=$(build_directory ${host} ${product}) build_cmd=("${CMAKE_BUILD[@]}" "${build_dir}" $(cmake_config_opt ${product}) -- "${BUILD_ARGS[@]}") if [[ "${executable_target}" != "" ]]; then echo "--- Building tests for ${product} ---" call "${build_cmd[@]}" ${BUILD_TARGET_FLAG} "${executable_target}" fi # We can only run tests built for the host machine, because # cross-compiled hosts only build their native target. See: get_stdlib_targets_for_host() if [[ $(is_cross_tools_host ${host}) ]]; then echo "--- Can't execute tests for ${host}, skipping... ---" continue fi echo "--- Running tests for ${product} ---" for target in "${results_targets[@]}"; do if [[ "${target}" != "" ]]; then echo "--- ${target} ---" trap "tests_busted ${product} '(${target})'" ERR test_target="$target" test_paths=() if [[ ${test_target} == check-swift* ]]; then if [[ "${TEST_PATHS}" ]]; then test_target="${test_target}-custom" for path in ${TEST_PATHS}; do test_paths+=( "${build_dir}/$(echo ${path} | sed -E "s/^(validation-test|test)/\1-${host}/")" ) done fi fi # NOTE: In dry-run mode, build_dir might not exist yet. In that # case, -n query will fail. So, in dry-run mode, # we don't expand test script. if [[ ! "${DRY_RUN}" && "${CMAKE_GENERATOR}" == Ninja ]] && !( "${build_cmd[@]}" --version 2>&1 | grep -i -q llbuild ) && [[ -z "${DISTCC_PUMP}" ]]; then # Ninja buffers command output to avoid scrambling the output # of parallel jobs, which is awesome... except that it # interferes with the progress meter when testing. Instead of # executing ninja directly, have it dump the commands it would # run, strip Ninja's progress prefix with sed, and tell the # shell to execute that. # However, if we do this in a subshell in the ``sh -e -x -c`` line, # errors in the command will not stop the script as they should. echo "Generating dry run test command from: ${build_cmd[@]} -n -v ${test_target}" dry_run_command_output="$(${build_cmd[@]} -n -v ${test_target} | sed -e 's/[^]]*] //')" echo "Test command: ${dry_run_command_output}" if [[ ! "${test_paths}" ]]; then env bash -ex <(echo -e "${dry_run_command_output}") else env bash -ex <(echo -e "${dry_run_command_output}" "${test_paths[@]}") fi else call "${build_cmd[@]}" ${BUILD_TARGET_FLAG} ${test_target} fi echo "-- ${target} finished --" fi done trap - ERR echo "--- Finished tests for ${product} ---" done done # END OF TEST PHASE LIPO_SRC_DIRS=() for host in "${ALL_HOSTS[@]}"; do # Skip this pass when the only action to execute can't match. if ! [[ $(should_execute_host_actions_for_phase ${host} install) ]]; then continue fi # Skip this pass if flag is set and we are cross compiling and it's the local host. if [[ "${SKIP_LOCAL_HOST_INSTALL}" ]] && [[ $(has_cross_compile_hosts) ]] && [[ ${host} == ${LOCAL_HOST} ]]; then continue fi # Calculate the directory to install products in to. host_install_destdir=$(get_host_install_destdir ${host}) host_install_prefix=$(get_host_install_prefix ${host}) if [[ $(should_include_host_in_lipo ${host}) ]]; then LIPO_SRC_DIRS+=( "${host_install_destdir}" ) fi # Set the build options for this host set_build_options_for_host $host for product in "${PRODUCTS[@]}"; do # Check if we should perform this action. if ! [[ $(should_execute_action "${host}-${product}-install") ]]; then continue fi INSTALL_TARGETS="install" case ${product} in cmark) if [[ -z "${INSTALL_CMARK}" ]] ; then continue fi ;; llvm) if [[ -z "${LLVM_INSTALL_COMPONENTS}" ]] ; then continue fi INSTALL_TARGETS=install-$(echo ${LLVM_INSTALL_COMPONENTS} | sed -E 's/;/ install-/g') ;; swift) if [[ -z "${INSTALL_SWIFT}" ]] ; then continue fi ;; llbuild) if [[ -z "${INSTALL_LLBUILD}" ]] ; then continue fi INSTALL_TARGETS="install-swift-build-tool install-libllbuildSwift" ;; # Products from this here install themselves; they don't fall-through. lldb) if [[ -z "${INSTALL_LLDB}" ]] ; then continue fi if [[ -z "${INSTALL_DESTDIR}" ]] ; then echo "--install-destdir is required to install products." exit 1 fi case ${host} in linux-*) ;; freebsd-*) ;; cygwin-*) ;; haiku-*) ;; macosx-*) set_lldb_build_mode with_pushd ${LLDB_SOURCE_DIR} \ call xcodebuild -target toolchain -configuration ${LLDB_BUILD_MODE} install ${lldb_xcodebuild_options[@]} DSTROOT="${host_install_destdir}" LLDB_TOOLCHAIN_PREFIX="${TOOLCHAIN_PREFIX}" continue ;; esac ;; swiftpm) if [[ -z "${INSTALL_SWIFTPM}" ]] ; then continue fi if [[ -z "${INSTALL_DESTDIR}" ]] ; then echo "--install-destdir is required to install products." exit 1 fi echo "--- Installing ${product} ---" call "${swiftpm_bootstrap_command[@]}" --prefix="${host_install_destdir}${host_install_prefix}" install # As swiftpm bootstraps the installation itself, we break early here. continue ;; xctest) if [[ -z "${INSTALL_XCTEST}" ]] ; then continue fi if [[ -z "${INSTALL_DESTDIR}" ]] ; then echo "--install-destdir is required to install products." exit 1 fi case ${host} in linux-*) LIB_TARGET="linux" ;; freebsd-*) LIB_TARGET="freebsd" ;; cygwin-*) LIB_TARGET="windows" ;; haiku-*) LIB_TARGET="haiku" ;; *) echo "error: --install-xctest is not supported on this platform" exit 1 ;; esac echo "--- Installing ${product} ---" XCTEST_BUILD_DIR=$(build_directory ${host} xctest) XCTEST_INSTALL_PREFIX="${host_install_destdir}${host_install_prefix}/lib/swift/${LIB_TARGET}" if [ $(true_false "${BUILD_SWIFT_STATIC_STDLIB}") == "TRUE" ]; then XCTEST_STATIC_INSTALL_PREFIX="${host_install_destdir}${host_install_prefix}/lib/swift_static/${LIB_TARGET}" xctest_static_install="--static-library-install-path=${XCTEST_STATIC_INSTALL_PREFIX}" else xctest_static_install="" fi # Note that installing directly to /usr/lib/swift usually # requires root permissions. call "${XCTEST_SOURCE_DIR}"/build_script.py install \ --library-install-path="${XCTEST_INSTALL_PREFIX}" ${xctest_static_install} \ --module-install-path="${XCTEST_INSTALL_PREFIX}"/"${SWIFT_HOST_VARIANT_ARCH}" \ "${XCTEST_BUILD_DIR}" # As XCTest installation is self-contained, we break early here. continue ;; foundation) # FIXME: Foundation doesn't build from the script on OS X if [[ ${host} == "macosx"* ]]; then echo "Skipping Foundation on OS X -- use the Xcode project instead" continue fi if [[ -z "${INSTALL_FOUNDATION}" ]] ; then continue fi if [[ -z "${INSTALL_DESTDIR}" ]] ; then echo "--install-destdir is required to install products." exit 1 fi echo "--- Installing ${product} ---" build_dir=$(build_directory ${host} ${product}) with_pushd "${FOUNDATION_SOURCE_DIR}" \ call ${NINJA_BIN} install # As foundation installation is self-contained, we break early here. continue ;; libdispatch) if [[ -z "${INSTALL_LIBDISPATCH}" ]] ; then continue fi case "${host}" in macosx-*) if [[ -z "${INSTALL_DESTDIR}" ]] ; then echo "--install-destdir is required to install products." exit 1 fi echo "--- Installing ${product} ---" LIBDISPATCH_BUILD_DIR=$(build_directory ${host} ${product}) with_pushd "${LIBDISPATCH_BUILD_DIR}" \ call make install DISPATCH_LIBDIR="${host_install_destdir}${host_install_prefix}/lib/swift/${SWIFT_HOST_VARIANT}" DISPATCH_LIBDIR_STATIC="${host_install_destdir}${host_install_prefix}/lib/swift_static/${SWIFT_HOST_VARIANT}" if [ -f "$DISPATCH_LIBDIR/libdispatch.a" ]; then mv "$DISPATCH_LIBDIR/libdispatch.a" "$DISPATCH_LIBDIR_STATIC" fi # As libdispatch installation is self-contained, we break early here. continue ;; *) ;; esac ;; libicu) if [[ -z "${INSTALL_LIBICU}" ]]; then continue fi if [[ -z "${INSTALL_DESTDIR}" ]] ; then echo "--install-destdir is required to install products." exit 1 fi echo "--- Installing ${product} ---" LIBICU_BUILD_DIR=$(build_directory ${host} ${product}) ICU_LIBDIR="$(build_directory ${host} swift)/lib/swift/${SWIFT_HOST_VARIANT}/${SWIFT_HOST_VARIANT_ARCH}" LIBICU_DEST_DIR="$(get_host_install_destdir ${host})$(get_host_install_prefix ${host})lib/swift/${SWIFT_HOST_VARIANT}" LIBICU_DEST_DIR_STATIC="$(get_host_install_destdir ${host})$(get_host_install_prefix ${host})lib/swift_static/${SWIFT_HOST_VARIANT}" mkdir -p ${LIBICU_DEST_DIR} mkdir -p ${LIBICU_DEST_DIR_STATIC} for l in uc i18n data do lib=${ICU_LIBDIR}/libicu${l} echo "${lib} => ${LIBICU_DEST_DIR}" cp -d ${lib}.so ${lib}.so.* ${LIBICU_DEST_DIR} cp -d ${lib}.so ${lib}.so.* ${LIBICU_DEST_DIR} cp -d ${lib}.a ${LIBICU_DEST_DIR_STATIC} cp -d ${lib}.a ${LIBICU_DEST_DIR_STATIC} done continue ;; playgroundsupport) set -x if [[ -z "${INSTALL_PLAYGROUNDSUPPORT}" ]] ; then continue fi if [[ -z "${INSTALL_DESTDIR}" ]] ; then echo "--install-destdir is required to install products." exit 1 fi echo "--- Installing ${product} ---" PLAYGROUNDSUPPORT_BUILD_DIR=$(build_directory ${host} ${product}) case "$(uname -s)" in Darwin) pushd "${PLAYGROUNDSUPPORT_SOURCE_DIR}" if [[ $(not ${SKIP_BUILD_OSX}) ]]; then "xcodebuild" install -configuration "${PLAYGROUNDSUPPORT_BUILD_TYPE}" -workspace swift-xcode-playground-support.xcworkspace -scheme BuildScript-macOS -sdk macosx -arch x86_64 -derivedDataPath "${PLAYGROUNDSUPPORT_BUILD_DIR}"/DerivedData SWIFT_EXEC="${SWIFTC_BIN}" SWIFT_LIBRARY_PATH="${SWIFT_LIB_DIR}/\$(PLATFORM_NAME)" ONLY_ACTIVE_ARCH=NO DSTROOT="$(get_host_install_destdir ${host})" TOOLCHAIN_INSTALL_DIR="${TOOLCHAIN_PREFIX}" BUILD_PLAYGROUNDLOGGER_TESTS=NO fi if [[ $(not ${SKIP_BUILD_IOS_SIMULATOR}) ]]; then "xcodebuild" install -configuration "${PLAYGROUNDSUPPORT_BUILD_TYPE}" -workspace swift-xcode-playground-support.xcworkspace -scheme BuildScript-iOS -sdk iphonesimulator -arch x86_64 -derivedDataPath "${PLAYGROUNDSUPPORT_BUILD_DIR}"/DerivedData SWIFT_EXEC="${SWIFTC_BIN}" SWIFT_LIBRARY_PATH="${SWIFT_LIB_DIR}/\$(PLATFORM_NAME)" ONLY_ACTIVE_ARCH=NO DSTROOT="$(get_host_install_destdir ${host})" TOOLCHAIN_INSTALL_DIR="${TOOLCHAIN_PREFIX}" BUILD_PLAYGROUNDLOGGER_TESTS=NO fi if [[ $(not ${SKIP_BUILD_TVOS_SIMULATOR}) ]]; then "xcodebuild" install -configuration "${PLAYGROUNDSUPPORT_BUILD_TYPE}" -workspace swift-xcode-playground-support.xcworkspace -scheme BuildScript-tvOS -sdk appletvsimulator -arch x86_64 -derivedDataPath "${PLAYGROUNDSUPPORT_BUILD_DIR}"/DerivedData SWIFT_EXEC="${SWIFTC_BIN}" SWIFT_LIBRARY_PATH="${SWIFT_LIB_DIR}/\$(PLATFORM_NAME)" ONLY_ACTIVE_ARCH=NO DSTROOT="$(get_host_install_destdir ${host})" TOOLCHAIN_INSTALL_DIR="${TOOLCHAIN_PREFIX}" BUILD_PLAYGROUNDLOGGER_TESTS=NO fi popd continue ;; *) echo "error: --install-playgroundsupport is not supported on this platform" exit 1 ;; esac { set +x; } 2>/dev/null ;; *) echo "error: unknown product: ${product}" exit 1 ;; esac if [[ -z "${INSTALL_DESTDIR}" ]] ; then echo "--install-destdir is required to install products." exit 1 fi echo "--- Installing ${product} ---" build_dir=$(build_directory ${host} ${product}) call env DESTDIR="${host_install_destdir}" "${CMAKE_BUILD[@]}" "${build_dir}" -- ${INSTALL_TARGETS} done if [[ "${DARWIN_INSTALL_EXTRACT_SYMBOLS}" ]] && [[ $(host_has_darwin_symbols ${host}) ]]; then echo "--- Extracting symbols ---" # FIXME: Since it's hard to trace output pipe call, # For now, We don't support dry-run trace for this block # Instead, just echo we do "darwin_intall_extract_symbols". if [[ "${DRY_RUN}" ]]; then call darwin_install_extract_symbols else set -x # Copy executables and shared libraries from the `host_install_destdir` to # INSTALL_SYMROOT and run dsymutil on them. (cd "${host_install_destdir}" && find ./"${TOOLCHAIN_PREFIX}" -perm -0111 -type f -print | cpio --insecure -pdm "${INSTALL_SYMROOT}") # Run dsymutil on executables and shared libraries. # # Exclude shell scripts. (cd "${INSTALL_SYMROOT}" && find ./"${TOOLCHAIN_PREFIX}" -perm -0111 -type f -print | \ grep -v crashlog.py | \ grep -v symbolication.py | \ xargs -n 1 -P ${BUILD_JOBS} $(xcrun_find_tool dsymutil)) # Strip executables, shared libraries and static libraries in # `host_install_destdir`. find "${host_install_destdir}${TOOLCHAIN_PREFIX}/" \ '(' -perm -0111 -or -name "*.a" ')' -type f -print | \ xargs -n 1 -P ${BUILD_JOBS} $(xcrun_find_tool strip) -S { set +x; } 2>/dev/null fi fi done # Everything is 'installed', but some products may be awaiting lipo. function build_and_test_installable_package() { local host="$1" if [[ "${INSTALLABLE_PACKAGE}" ]] ; then # Get the directory where the products where installed. # If INSTALL_DESTDIR not given, we couldn't have installed anything. if [[ -z "${INSTALL_DESTDIR}" ]] ; then echo "--install-destdir required to build a package. Skipping." return fi local host_install_destdir="$(get_host_install_destdir ${host})" local host_install_prefix="$(get_host_install_prefix ${host})" if [[ $(has_cross_compile_hosts) ]]; then package_for_host="${INSTALLABLE_PACKAGE}-${host}" else package_for_host="${INSTALLABLE_PACKAGE}" fi echo "--- Creating installable package ---" echo "-- Package file: ${package_for_host} --" # Assume the lipo builds are (or include) an OS X host and build an xctoolchain if [[ "${host}" == "macosx-"* ]] || [[ "${host}" == "merged-hosts" ]]; then # Create plist for xctoolchain. echo "-- Create Info.plist --" PLISTBUDDY_BIN="/usr/libexec/PlistBuddy" DARWIN_TOOLCHAIN_INSTALL_LOCATION="/Library/Developer/Toolchains/${DARWIN_TOOLCHAIN_NAME}.xctoolchain" DARWIN_TOOLCHAIN_INFO_PLIST="${host_install_destdir}${TOOLCHAIN_PREFIX}/Info.plist" DARWIN_TOOLCHAIN_REPORT_URL="https://bugs.swift.org/" COMPATIBILITY_VERSION=2 COMPATIBILITY_VERSION_DISPLAY_STRING="Xcode 8.0" DARWIN_TOOLCHAIN_CREATED_DATE="$(date -u +'%a %b %d %T GMT %Y')" echo "-- Removing: ${DARWIN_TOOLCHAIN_INFO_PLIST}" call rm -f ${DARWIN_TOOLCHAIN_INFO_PLIST} call ${PLISTBUDDY_BIN} -c "Add DisplayName string '${DARWIN_TOOLCHAIN_DISPLAY_NAME}'" "${DARWIN_TOOLCHAIN_INFO_PLIST}" call ${PLISTBUDDY_BIN} -c "Add ShortDisplayName string '${DARWIN_TOOLCHAIN_DISPLAY_NAME_SHORT}'" "${DARWIN_TOOLCHAIN_INFO_PLIST}" call ${PLISTBUDDY_BIN} -c "Add CreatedDate date '${DARWIN_TOOLCHAIN_CREATED_DATE}'" "${DARWIN_TOOLCHAIN_INFO_PLIST}" call ${PLISTBUDDY_BIN} -c "Add CompatibilityVersion integer ${COMPATIBILITY_VERSION}" "${DARWIN_TOOLCHAIN_INFO_PLIST}" call ${PLISTBUDDY_BIN} -c "Add CompatibilityVersionDisplayString string ${COMPATIBILITY_VERSION_DISPLAY_STRING}" "${DARWIN_TOOLCHAIN_INFO_PLIST}" call ${PLISTBUDDY_BIN} -c "Add Version string '${DARWIN_TOOLCHAIN_VERSION}'" "${DARWIN_TOOLCHAIN_INFO_PLIST}" call ${PLISTBUDDY_BIN} -c "Add CFBundleIdentifier string '${DARWIN_TOOLCHAIN_BUNDLE_IDENTIFIER}'" "${DARWIN_TOOLCHAIN_INFO_PLIST}" call ${PLISTBUDDY_BIN} -c "Add ReportProblemURL string '${DARWIN_TOOLCHAIN_REPORT_URL}'" "${DARWIN_TOOLCHAIN_INFO_PLIST}" call ${PLISTBUDDY_BIN} -c "Add Aliases array" "${DARWIN_TOOLCHAIN_INFO_PLIST}" call ${PLISTBUDDY_BIN} -c "Add Aliases:0 string '${DARWIN_TOOLCHAIN_ALIAS}'" "${DARWIN_TOOLCHAIN_INFO_PLIST}" call ${PLISTBUDDY_BIN} -c "Add OverrideBuildSettings dict" "${DARWIN_TOOLCHAIN_INFO_PLIST}" call ${PLISTBUDDY_BIN} -c "Add OverrideBuildSettings:ENABLE_BITCODE string 'NO'" "${DARWIN_TOOLCHAIN_INFO_PLIST}" call ${PLISTBUDDY_BIN} -c "Add OverrideBuildSettings:SWIFT_DISABLE_REQUIRED_ARCLITE string 'YES'" "${DARWIN_TOOLCHAIN_INFO_PLIST}" call ${PLISTBUDDY_BIN} -c "Add OverrideBuildSettings:SWIFT_LINK_OBJC_RUNTIME string 'YES'" "${DARWIN_TOOLCHAIN_INFO_PLIST}" call chmod a+r "${DARWIN_TOOLCHAIN_INFO_PLIST}" if [[ "${DARWIN_TOOLCHAIN_APPLICATION_CERT}" ]] ; then echo "-- Codesign xctoolchain --" call "${SWIFT_SOURCE_DIR}/utils/toolchain-codesign" "${DARWIN_TOOLCHAIN_APPLICATION_CERT}" "${host_install_destdir}${TOOLCHAIN_PREFIX}/" fi if [[ "${DARWIN_TOOLCHAIN_INSTALLER_PACKAGE}" ]] ; then echo "-- Create Installer --" call "${SWIFT_SOURCE_DIR}/utils/toolchain-installer" "${host_install_destdir}${TOOLCHAIN_PREFIX}/" "${DARWIN_TOOLCHAIN_BUNDLE_IDENTIFIER}" \ "${DARWIN_TOOLCHAIN_INSTALLER_CERT}" "${DARWIN_TOOLCHAIN_INSTALLER_PACKAGE}" "${DARWIN_TOOLCHAIN_INSTALL_LOCATION}" \ "${DARWIN_TOOLCHAIN_VERSION}" "${SWIFT_SOURCE_DIR}/utils/darwin-installer-scripts" fi # host_install_destdir contains the toolchain prefix. # We want to create the package in host_install_destdir_nonprefixed. with_pushd "${host_install_destdir}" \ call tar -c -z -f "${package_for_host}" "${TOOLCHAIN_PREFIX/#\/}" else # BSD tar doesn't support --owner/--group. if [[ "$(uname -s)" == "Darwin" || "$(uname -s)" == "FreeBSD" ]] ; then with_pushd "${host_install_destdir}" \ tar -c -z -f "${package_for_host}" "${host_install_prefix/#\/}" else with_pushd "${host_install_destdir}" \ tar -c -z -f "${package_for_host}" --owner=0 --group=0 "${host_install_prefix/#\/}" fi fi if [[ "${TEST_INSTALLABLE_PACKAGE}" ]] ; then PKG_TESTS_SOURCE_DIR="${WORKSPACE}/swift-integration-tests" PKG_TESTS_SANDBOX_PARENT="$(build_directory swift_package_sandbox_${host} none)" PKG_TESTS_TEMPS="${PKG_TESTS_SANDBOX_PARENT}"/"tests" if [[ "${host}" == "macosx-"* ]] ; then PKG_TESTS_SANDBOX="${PKG_TESTS_SANDBOX_PARENT}"/"${TOOLCHAIN_PREFIX}" else # Linux PKG_TESTS_SANDBOX="${PKG_TESTS_SANDBOX_PARENT}" fi LIT_EXECUTABLE_PATH="${LLVM_SOURCE_DIR}/utils/lit/lit.py" LLVM_BIN_DIR="$(build_directory_bin ${LOCAL_HOST} llvm)" echo "-- Test Installable Package --" call rm -rf "${PKG_TESTS_SANDBOX_PARENT}" call mkdir -p "${PKG_TESTS_SANDBOX}" with_pushd "${PKG_TESTS_SANDBOX_PARENT}" \ call tar xzf "${package_for_host}" with_pushd "${PKG_TESTS_SOURCE_DIR}" \ call python "${LIT_EXECUTABLE_PATH}" . -sv --param package-path="${PKG_TESTS_SANDBOX}" --param test-exec-root="${PKG_TESTS_TEMPS}" --param llvm-bin-dir="${LLVM_BIN_DIR}" fi fi } # Build and test packages. for host in "${ALL_HOSTS[@]}"; do # Check if we should perform this action. if ! [[ $(should_execute_action "${host}-package") ]]; then continue fi if [[ $(should_include_host_in_lipo ${host}) ]]; then continue fi build_and_test_installable_package ${host} done # Lipo those products which require it, optionally build and test an installable package. if [[ ${#LIPO_SRC_DIRS[@]} -gt 0 ]]; then # This is from multiple hosts; Which host should we say it is? # Let's call it 'merged-hosts' so that we can identify it. mergedHost="merged-hosts" # Check if we should perform this action. if ! [[ $(should_execute_action "${mergedHost}-lipo") ]]; then continue fi echo "--- Merging and running lipo ---" # Allow passing lipo with --host-lipo if [[ -z "${HOST_LIPO}" ]] ; then LIPO_PATH=$(xcrun_find_tool lipo) else LIPO_PATH="${HOST_LIPO}" fi call "${SWIFT_SOURCE_DIR}"/utils/recursive-lipo --lipo=${LIPO_PATH} --copy-subdirs="$(get_host_install_prefix ${host})lib/swift $(get_host_install_prefix ${host})lib/swift_static" --destination="$(get_host_install_destdir ${mergedHost})" ${LIPO_SRC_DIRS[@]} # Build and test the lipo-ed package. build_and_test_installable_package ${mergedHost} fi # END