build-script-impl

#!/bin/bash
#===--- build-script-impl - Implementation details of build-script ---------===#
#
## This source file is part of the Swift.org open source project
##
## Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
## Licensed under Apache License v2.0 with Runtime Library Exception
##
## See http://swift.org/LICENSE.txt for license information
## See http://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

#
# Options that can be "configured" by editing this file.
#
# These options are not exposed as command line options on purpose.  If you
# need to change any of these, you should do so on trunk or in a branch.
#

LLVM_TARGETS_TO_BUILD="X86;ARM;AArch64"

#
# End of configurable options.
#

# 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 substituded 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
    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**"
    darwin-xcrun-toolchain      "default"        "the name of the toolchain to use on Darwin"
    build-ninja                 ""               "build the Ninja tool"
    skip-build-swig             ""               "don't build the Swig tool, even if we're building lldb"
    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-test-with-curses       ""               "run test lldb test runner using curses terminal control"
    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"
    llvm-build-type             "Debug"          "the CMake build variant for LLVM and Clang (Debug, RelWithDebInfo, Release, MinSizeRel).  Defaults to Debug."
    llvm-enable-assertions      "1"              "enable assertions in LLVM and Clang"
    swift-build-type            "Debug"          "the CMake build variant for Swift"
    swift-enable-assertions     "1"              "enable assertions in Swift"
    swift-stdlib-build-type     "Debug"          "the CMake build variant for Swift"
    swift-stdlib-enable-assertions "1"           "enable assertions in Swift"
    lldb-build-type             "Debug"          "the CMake build variant for LLDB"
    llbuild-build-type          "Debug"          "the CMake build variant for llbuild"
    foundation-build-type       "Debug"          "the build variant for Foundation"
    llbuild-enable-assertions   "1"              "enable assertions in llbuild"
    enable-asan                 ""               "enable AddressSanitizer"
    cmake                       ""               "path to the cmake binary"
    distcc                      ""               "use distcc in pump mode"
    user-config-args            ""               "User-supplied arguments to cmake when used to do configuration"
    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"
    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"
    symbols-package             ""               "the path to the archive of the symbols directory"
    show-sdks                   ""               "print installed Xcode and SDK versions"
    reconfigure                 ""               "force a CMake configuration run even if CMakeCache.txt already exists"
    swift-sdks                  ""               "build target binaries only for specified SDKs (semicolon-separated list)"
    swift-primary-variant-sdk   ""               "default SDK for target binaries"
    swift-primary-variant-arch  ""               "default arch for target binaries"
    skip-ios                    ""               "set to skip everything iOS-related"
    skip-tvos                   ""               "set to skip everything tvOS-related"
    skip-watchos                ""               "set to skip everything watchOS-related"
    skip-build                  ""               "set to skip building anything"
    skip-build-cmark            ""               "set to skip building CommonMark"
    skip-build-llvm             ""               "set to skip building LLVM/Clang"
    skip-build-swift            ""               "set to skip building Swift"
    skip-build-osx              ""               "set to skip building Swift stdlibs for OSX"
    skip-build-ios              ""               "set to skip building Swift stdlibs for iOS"
    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             ""               "set to skip building Swift stdlibs for tvOS"
    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          ""               "set to skip building Swift stdlibs for Apple watchOS"
    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-lldb             ""               "set to skip building LLDB"
    skip-build-llbuild          ""               "set to skip buildling llbuild"
    skip-build-swiftpm          ""               "set to skip buildling swiftpm"
    skip-build-xctest           ""               "set to skip buildling xctest"
    skip-build-foundation       ""               "set to skip buildling foundation"
    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-osx               ""               "set to skip testing Swift stdlibs for OSX"
    skip-test-ios               ""               "set to skip testing Swift stdlibs for iOS"
    skip-test-ios-simulator     ""               "set to skip testing Swift stdlibs for iOS simulators (i.e. test devices only)"
    skip-test-tvos              ""               "set to skip testing Swift stdlibs for tvOS"
    skip-test-tvos-simulator    ""               "set to skip testing Swift stdlibs for tvOS simulators (i.e. test devices only)"
    skip-test-watchos           ""               "set to skip testing Swift stdlibs for Apple watchOS"
    skip-test-watchos-simulator  ""              "set to skip testing Swift stdlibs for Apple watchOS simulators (i.e. test devices only)"
    skip-test-validation        ""               "set to skip validation test suite"
    skip-test-optimized         ""               "set to skip testing the test suite in optimized mode"
    stress-test-sourcekit       ""               "set to run the stress-SourceKit target"
    xcode-ide-only              ""               "set to configure Xcode project for IDE use only, not building"
    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-stdlib          "1"              "set to 1 to build the Swift standard library"
    build-swift-sdk-overlay     "1"              "set to 1 to build the Swift SDK overlay"
    build-swift-static-stdlib   "0"              "set to 1 to build static versions of the Swift standard library and SDK overlay"
    build-swift-examples        "1"              "set to 1 to build examples"
    build-swift-perf-testsuite  "0"              "set to 1 to build perf test suite"
    source-tree-includes-tests  "1"              "set to 0 to allow 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"
    compiler-vendor             "none"           "compiler vendor name [none,apple]"
    swift-compiler-version      ""               "string that indicates a compiler version for Swift"
    clang-compiler-version      ""               "string that indicates a compiler version for Clang"
    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"
    darwin-install-extract-symbols ""            "whether to extract symbols with dsymutil during installations"
    cross-compile-tools-deployment-targets ""    "space-separated list of targets to cross-compile host Swift tools for"
    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-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 be run after every SIL pass"
    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-enable-target-linux   "1"              "Enable compiler support for targeting Linux"
    swift-enable-target-appletvos "1"            "Enable compiler support for targeting tvOS"
    swift-runtime-enable-dtrace "0"              "Enable runtime dtrace support"
    swift-runtime-enable-leak-checker   "0"              "Enable leaks checking routines in the runtime"
    use-gold-linker             ""               "Enable using the gold linker"
)

function toupper() {
    echo "$@" | tr '[:lower:]' '[:upper:]'
}

function to_varname() {
    toupper "${1//-/_}"
}

function get_make_parallelism() {
    if [ "$(uname -s)" == "Darwin" ] ; then
        sysctl -n hw.activecpu
    else
        echo 8
    fi
}

function get_dsymutil_parallelism() {
    get_make_parallelism
}

function set_lldb_build_mode() {
    LLDB_BUILD_MODE="CustomSwift-${LLDB_BUILD_TYPE}"
}

function set_deployment_target_based_options() {
    llvm_cmake_options=()
    swift_cmake_options=()
    cmark_cmake_options=()
    swiftpm_bootstrap_options=()

    case $deployment_target in
        linux-x86_64)
            SWIFT_HOST_VARIANT_ARCH="x86_64"
            ;;
        macosx-* | iphoneos-* | iphonesimulator-* | \
          appletvos-* | appletvsimulator-* | \
            watchos-* | watchsimulator-*)
            case ${deployment_target} in
                macosx-x86_64)
                    xcrun_sdk_name="macosx"
                    llvm_host_triple="x86_64-apple-macosx${DARWIN_DEPLOYMENT_VERSION_OSX}"
                    llvm_target_arch=""
                    cmake_osx_deployment_target="${DARWIN_DEPLOYMENT_VERSION_OSX}"
                    cmark_cmake_options=(
                        -DCMAKE_C_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_CXX_FLAGS="$(cmark_c_flags $deployment_target)"
                        -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_host_triple="i386-apple-ios${DARWIN_DEPLOYMENT_VERSION_IOS}"
                    llvm_target_arch="X86"
                    cmake_osx_deployment_target=""
                    cmark_cmake_options=(
                        -DCMAKE_C_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_CXX_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk $xcrun_sdk_name --show-sdk-path)"
                    )
                    swift_cmake_options=(
                        -DSWIFT_HOST_VARIANT="iphonesimulator"
                        -DSWIFT_HOST_VARIANT_SDK="IOS_SIMULATOR"
                        -DSWIFT_HOST_VARIANT_ARCH="i386"
                    )
                    ;;
                iphonesimulator-x86_64)
                    xcrun_sdk_name="iphonesimulator"
                    llvm_host_triple="x86_64-apple-ios${DARWIN_DEPLOYMENT_VERSION_IOS}"
                    llvm_target_arch="X86"
                    cmake_osx_deployment_target=""
                    cmark_cmake_options=(
                        -DCMAKE_C_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_CXX_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk $xcrun_sdk_name --show-sdk-path)"
                    )
                    swift_cmake_options=(
                        -DSWIFT_HOST_VARIANT="iphonesimulator"
                        -DSWIFT_HOST_VARIANT_SDK="IOS_SIMULATOR"
                        -DSWIFT_HOST_VARIANT_ARCH="x86_64"
                    )
                    ;;
                iphoneos-armv7)
                    xcrun_sdk_name="iphoneos"
                    llvm_host_triple="armv7-apple-ios${DARWIN_DEPLOYMENT_VERSION_IOS}"
                    llvm_target_arch="ARM"
                    cmake_osx_deployment_target=""
                    cmark_cmake_options=(
                        -DCMAKE_C_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_CXX_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk $xcrun_sdk_name --show-sdk-path)"
                    )
                    swift_cmake_options=(
                        -DSWIFT_HOST_VARIANT="iphoneos"
                        -DSWIFT_HOST_VARIANT_SDK="IOS"
                        -DSWIFT_HOST_VARIANT_ARCH="armv7"
                    )
                    ;;
                iphoneos-arm64)
                    xcrun_sdk_name="iphoneos"
                    llvm_host_triple="arm64-apple-ios${DARWIN_DEPLOYMENT_VERSION_IOS}"
                    llvm_target_arch="AArch64"
                    cmake_osx_deployment_target=""
                    cmark_cmake_options=(
                        -DCMAKE_C_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_CXX_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk $xcrun_sdk_name --show-sdk-path)"
                    )
                    swift_cmake_options=(
                        -DSWIFT_HOST_VARIANT="iphoneos"
                        -DSWIFT_HOST_VARIANT_SDK="IOS"
                        -DSWIFT_HOST_VARIANT_ARCH="arm64"
                    )
                    ;;
                appletvsimulator-x86_64)
                    xcrun_sdk_name="appletvsimulator"
                    llvm_host_triple="x86_64-apple-tvos${DARWIN_DEPLOYMENT_VERSION_TVOS}"
                    llvm_target_arch="X86"
                    cmake_osx_deployment_target=""
                    cmark_cmake_options=(
                        -DCMAKE_C_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_CXX_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk $xcrun_sdk_name --show-sdk-path)"
                    )
                    swift_cmake_options=(
                        -DSWIFT_HOST_VARIANT="appletvsimulator"
                        -DSWIFT_HOST_VARIANT_SDK="TVOS_SIMULATOR"
                        -DSWIFT_HOST_VARIANT_ARCH="x86_64"
                    )
                    ;;
                appletvos-arm64)
                    xcrun_sdk_name="appletvos"
                    llvm_host_triple="arm64-apple-tvos${DARWIN_DEPLOYMENT_VERSION_TVOS}"
                    llvm_target_arch="AArch64"
                    cmake_osx_deployment_target=""
                    cmark_cmake_options=(
                        -DCMAKE_C_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_CXX_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk $xcrun_sdk_name --show-sdk-path)"
                    )
                    swift_cmake_options=(
                        -DSWIFT_HOST_VARIANT="appletvos"
                        -DSWIFT_HOST_VARIANT_SDK="TVOS"
                        -DSWIFT_HOST_VARIANT_ARCH="arm64"
                    )
                    ;;
                watchsimulator-i386)
                    xcrun_sdk_name="watchsimulator"
                    llvm_host_triple="i386-apple-watchos${DARWIN_DEPLOYMENT_VERSION_WATCHOS}"
                    llvm_target_arch="X86"
                    cmake_osx_deployment_target=""
                    cmark_cmake_options=(
                        -DCMAKE_C_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_CXX_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk $xcrun_sdk_name --show-sdk-path)"
                    )
                    swift_cmake_options=(
                        -DSWIFT_HOST_VARIANT="watchsimulator"
                        -DSWIFT_HOST_VARIANT_SDK="WATCHOS_SIMULATOR"
                        -DSWIFT_HOST_VARIANT_ARCH="i386"
                    )
                    ;;
                watchos-armv7k)
                    xcrun_sdk_name="watchos"
                    llvm_host_triple="armv7k-apple-watchos${DARWIN_DEPLOYMENT_VERSION_WATCHOS}"
                    llvm_target_arch="ARM"
                    cmake_osx_deployment_target=""
                    cmark_cmake_options=(
                        -DCMAKE_C_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_CXX_FLAGS="$(cmark_c_flags $deployment_target)"
                        -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk $xcrun_sdk_name --show-sdk-path)"
                    )
                    swift_cmake_options=(
                        -DSWIFT_HOST_VARIANT="watchos"
                        -DSWIFT_HOST_VARIANT_SDK="WATCHOS"
                        -DSWIFT_HOST_VARIANT_ARCH="armv7k"
                    )
                    ;;
                *)
                    echo "Unknown deployment target"
                    exit 1
                    ;;
            esac

            native_llvm_build=$(build_directory macosx-x86_64 llvm)
            llvm_cmake_options=(
                -DCMAKE_OSX_DEPLOYMENT_TARGET:STRING="${cmake_osx_deployment_target}"
                -DCMAKE_OSX_SYSROOT:PATH="$(xcrun --sdk $xcrun_sdk_name --show-sdk-path)"
                -DLLVM_HOST_TRIPLE:STRING="${llvm_host_triple}"
            )
            swift_cmake_options=(
                "${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}"
            )

            if [[ "${llvm_target_arch}" ]] ; then
                llvm_cmake_options=(
                    "${llvm_cmake_options[@]}"
                    -DLLVM_TARGET_ARCH="${llvm_target_arch}"
                )
            fi

            ;;
        *)
            echo "Unknown compiler deployment target: $deployment_target"
            exit 1
            ;;
    esac

}

# Set up an "associative array" of settings for error checking, and set
# (or unset) each corresponding variable to its default value
# 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
# declare -A IS_KNOWN_SETTING
for ((i = 0; i < ${#KNOWN_SETTINGS[@]}; i += 3)); do
    setting="${KNOWN_SETTINGS[i]}"

    default_value="${KNOWN_SETTINGS[$((i+1))]}"

    varname="$(to_varname "${setting}")"    # upcase the setting name to get the variable
    eval "${varname}_IS_KNOWN_SETTING=1"

    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

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
            varname="$(to_varname "${setting}")"

            # check to see if this is a known option
            known_var_name="${varname}_IS_KNOWN_SETTING"
            if [[ ! "${!known_var_name}" ]] ; 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
            ;;

        *)
            usage
            exit 1
    esac
    shift
done

if [[ "$SKIP_BUILD" ]]; then
    SKIP_BUILD_CMARK=1
    SKIP_BUILD_LLVM=1
    SKIP_BUILD_SWIFT=1
    SKIP_BUILD_OSX=1
    SKIP_BUILD_IOS=1
    SKIP_BUILD_IOS_DEVICE=1
    SKIP_BUILD_IOS_SIMULATOR=1
    SKIP_BUILD_TVOS=1
    SKIP_BUILD_TVOS_DEVICE=1
    SKIP_BUILD_TVOS_SIMULATOR=1
    SKIP_BUILD_WATCHOS=1
    SKIP_BUILD_WATCHOS_DEVICE=1
    SKIP_BUILD_WATCHOS_SIMULATOR=1
    SKIP_BUILD_LLDB=1
    SKIP_BUILD_LLBUILD=1
    SKIP_BUILD_SWIFTPM=1
    SKIP_BUILD_XCTEST=1
    SKIP_BUILD_FOUNDATION=1
fi

if [[ "$SKIP_IOS" ]] ; then
    SKIP_BUILD_IOS=1
    SKIP_BUILD_IOS_DEVICE=1
    SKIP_BUILD_IOS_SIMULATOR=1
    SKIP_TEST_IOS=1
    SKIP_TEST_IOS_SIMULATOR=1
fi

if [[ "$SKIP_TVOS" ]] ; then
    SKIP_BUILD_TVOS=1
    SKIP_BUILD_TVOS_DEVICE=1
    SKIP_BUILD_TVOS_SIMULATOR=1
    SKIP_TEST_TVOS=1
    SKIP_TEST_TVOS_SIMULATOR=1
fi

if [[ "$SKIP_WATCHOS" ]] ; then
    SKIP_BUILD_WATCHOS=1
    SKIP_BUILD_WATCHOS_DEVICE=1
    SKIP_BUILD_WATCHOS_SIMULATOR=1
    SKIP_TEST_WATCHOS=1
    SKIP_TEST_WATCHOS_SIMULATOR=1
fi

if [[ "$SKIP_BUILD_IOS" ]] ; then
    SKIP_BUILD_IOS=1
    SKIP_BUILD_IOS_DEVICE=1
    SKIP_BUILD_IOS_SIMULATOR=1
    SKIP_TEST_IOS=1
    SKIP_TEST_IOS_SIMULATOR=1
fi

if [[ "$SKIP_BUILD_TVOS" ]] ; then
    SKIP_BUILD_TVOS=1
    SKIP_BUILD_TVOS_DEVICE=1
    SKIP_BUILD_TVOS_SIMULATOR=1
    SKIP_TEST_TVOS=1
    SKIP_TEST_TVOS_SIMULATOR=1
fi

if [[ "$SKIP_BUILD_WATCHOS" ]] ; then
    SKIP_BUILD_WATCHOS=1
    SKIP_BUILD_WATCHOS_DEVICE=1
    SKIP_BUILD_WATCHOS_SIMULATOR=1
    SKIP_TEST_WATCHOS=1
    SKIP_TEST_WATCHOS_SIMULATOR=1
fi

if [[ "$SKIP_BUILD_IOS_DEVICE" ]] ; then
    SKIP_BUILD_IOS_DEVICE=1
fi

if [[ "$SKIP_BUILD_TVOS_DEVICE" ]] ; then
    SKIP_BUILD_TVOS_DEVICE=1
fi

if [[ "$SKIP_BUILD_WATCHOS_DEVICE" ]] ; then
    SKIP_BUILD_WATCHOS_DEVICE=1
fi

if [[ "$SKIP_BUILD_IOS_SIMULATOR" ]] ; then
    SKIP_BUILD_IOS_SIMULATOR=1
    SKIP_TEST_IOS_SIMULATOR=1
fi

if [[ "$SKIP_BUILD_TVOS_SIMULATOR" ]] ; then
    SKIP_BUILD_TVOS_SIMULATOR=1
    SKIP_TEST_TVOS_SIMULATOR=1
fi

if [[ "$SKIP_BUILD_WATCHOS_SIMULATOR" ]] ; then
    SKIP_BUILD_WATCHOS_SIMULATOR=1
    SKIP_TEST_WATCHOS_SIMULATOR=1
fi

if [[ "$SKIP_TEST_IOS" ]] ; then
    SKIP_TEST_IOS_SIMULATOR=1
fi

if [[ "$SKIP_TEST_TVOS" ]] ; then
    SKIP_TEST_TVOS_SIMULATOR=1
fi

if [[ "$SKIP_TEST_WATCHOS" ]] ; then
    SKIP_TEST_WATCHOS_SIMULATOR=1
fi

if [[ "${CMAKE_GENERATOR}" == "Ninja" ]] && [[ -z "$(which ninja)" ]] ; then
    BUILD_NINJA=1
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
case "${SYMBOLS_PACKAGE}" in
    /*) ;;
    "") ;;
    *)
        echo "symbols-package must be an absolute path (was '${SYMBOLS_PACKAGE}')"
        exit 1
        ;;
esac

# WORKSPACE must exist
if [ ! -e "$WORKSPACE" ] ; then
    echo "Workspace does not exist (tried $WORKSPACE)"
    exit 1
fi

function xcrun_find_tool() {
  xcrun --sdk macosx --toolchain "${DARWIN_XCRUN_TOOLCHAIN}" --find "$@"
}

function not() {
    if [[ ! "$1" ]] ; then
        echo 1
    fi
}

function true_false() {
    case "$1" in
        false | 0)
            echo "FALSE"
            ;;
        true | 1)
            echo "TRUE"
            ;;
        *)
            echo "true_false: unknown value: $1" >&2
            exit 1
            ;;
    esac
}

#
# Set default values for command-line parameters.
#

if [[ "${CMAKE}" == "" ]] ; then
    if [[ "$(uname -s)" == "Darwin" ]] ; then
        CMAKE="$(xcrun_find_tool cmake)"
    else
        CMAKE="$(which cmake || echo /usr/local/bin/cmake)"
    fi
fi

if [[ "${INSTALL_PREFIX}" == "" ]] ; then
    if [[ "$(uname -s)" == "Darwin" ]] ; then
        INSTALL_PREFIX="/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr"
    else
        INSTALL_PREFIX="/usr"
    fi
fi

if [[ "$(uname -s)" == "Darwin" ]] ; then
    TOOLCHAIN_PREFIX=$(echo ${INSTALL_PREFIX} | sed -E 's/\/usr$//')
fi

# A list of deployment targets to compile the Swift host tools for, in case when
# we can run the resulting binaries natively on the build machine.
NATIVE_TOOLS_DEPLOYMENT_TARGETS=()

# A list of deployment targets to cross-compile the Swift host tools for.
# We can't run the resulting binaries on the build machine.
CROSS_TOOLS_DEPLOYMENT_TARGETS=()

# Determine the native deployment target for the build machine, that will be
# used to jumpstart the standard library build when cross-compiling.
case "$(uname -s)" in
    Linux)
        NATIVE_TOOLS_DEPLOYMENT_TARGETS=(
            "linux-x86_64"
        )
        ;;

    Darwin)
        NATIVE_TOOLS_DEPLOYMENT_TARGETS=(
            "macosx-x86_64"
        )
        ;;

    *)
        echo "Unknown operating system"
        exit 1
        ;;
esac

# Sanitize the list of cross-compilation targets.
for t in ${CROSS_COMPILE_TOOLS_DEPLOYMENT_TARGETS} ; do
    case ${t} in
        iphonesimulator-i386 | iphonesimulator-x86_64 | \
        iphoneos-arm64 | iphoneos-armv7 | \
        appletvos-arm64 | appletvsimulator-x86_64 | \
        watchos-armv7k | watchsimulator-i386)
            CROSS_TOOLS_DEPLOYMENT_TARGETS=(
                "${CROSS_TOOLS_DEPLOYMENT_TARGETS[@]}"
                "${t}"
            )
            ;;
        *)
            echo "Unknown deployment target"
            exit 1
            ;;
    esac
done

function is_native_tools_deployment_target() {
    local deployment_target="$1"
    for t in "${NATIVE_TOOLS_DEPLOYMENT_TARGETS[@]}" ; do
        if [ "${deployment_target}" == "${t}" ] ; then
            echo 1
        fi
    done
}

function is_cross_tools_deployment_target() {
    local deployment_target="$1"
    for t in "${CROSS_TOOLS_DEPLOYMENT_TARGETS[@]}" ; do
        if [ "${deployment_target}" == "${t}" ] ; then
            echo 1
        fi
    done
}

# A list of deployment targets that we compile or cross-compile the
# Swift standard library for.
STDLIB_DEPLOYMENT_TARGETS=()

case "$(uname -s)" in
    Linux)
        STDLIB_DEPLOYMENT_TARGETS=(
            "linux-x86_64"
        )
        ;;

    Darwin)
        STDLIB_DEPLOYMENT_TARGETS=(
            "macosx-x86_64"
            "iphonesimulator-i386"
            "iphonesimulator-x86_64"
            "appletvsimulator-x86_64"
            "watchsimulator-i386"

            # Put iOS native targets last so that we test them last (it takes a
            # long time).
            "iphoneos-arm64"
            "iphoneos-armv7"
            "appletvos-arm64"
            "watchos-armv7k"
        )
        ;;

    *)
        echo "Unknown operating system"
        exit 1
        ;;
esac

#
# Calculate source directories for each product.
#
NINJA_SOURCE_DIR="$WORKSPACE/ninja"
SWIG_SOURCE_DIR="$WORKSPACE/swig"
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/XCTest"
FOUNDATION_SOURCE_DIR="$WORKSPACE/Foundation"

if [[ "$SKIP_BUILD_LLDB" ]]; then
  SKIP_BUILD_SWIG=1
fi

if [[ ! "$SKIP_BUILD_SWIG" ]]; then
  if [[ ! -d $SWIG_SOURCE_DIR ]]; then
    (echo "swig isn't in the tree and can't be checked out by RC.  Please provide a swig-1 source directory at $SWIG_SOURCE_DIR." && \
     exit 1)
  fi
fi

if [[ ! -d $CMARK_SOURCE_DIR ]]; then
  echo "$CMARK_SOURCE_DIR not found. Attempting to clone ..."
  git clone git@github.com/apple/swift-cmark.git "$CMARK_SOURCE_DIR" || \
    (echo "Couldn't clone cmark. Please check README.md and visit https:/github.com/apple/swift-cmark for details." && \
    exit 1)
fi

if [[ ! "$SKIP_BUILD_LLBUILD" && ! -d $LLBUILD_SOURCE_DIR ]]; then
    echo "Couldn't find llbuild source directory."
    exit 1
fi

if [[ ! "$SKIP_BUILD_SWIFTPM" && ! -d $SWIFTPM_SOURCE_DIR ]]; then
    echo "Couldn't find swiftpm source directory."
    exit 1
fi

if [[ ! "$SKIP_BUILD_XCTEST" && ! -d $XCTEST_SOURCE_DIR ]]; then
    echo "Couldn't find XCTest source directory."
    exit 1
fi

if [[ ! "$SKIP_BUILD_FOUNDATION" && ! -d $FOUNDATION_SOURCE_DIR ]]; then
    echo "Couldn't find Foundation 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
    ln -sf "${WORKSPACE}/clang" "${CLANG_SOURCE_DIR}"
fi

PRODUCTS=(cmark llvm swift)
if [[ ! "${SKIP_BUILD_SWIG}" ]] ; then
     PRODUCTS=("${PRODUCTS[@]}" swig)
fi
if [[ ! "${SKIP_BUILD_LLDB}" ]] ; then
     PRODUCTS=("${PRODUCTS[@]}" lldb)
fi
if [[ ! "${SKIP_BUILD_LLBUILD}" ]] ; then
     PRODUCTS=("${PRODUCTS[@]}" llbuild)
fi
if [[ ! "${SKIP_BUILD_SWIFTPM}" ]] ; then
     PRODUCTS=("${PRODUCTS[@]}" swiftpm)
fi
if [[ ! "${SKIP_BUILD_XCTEST}" ]] ; then
     PRODUCTS=("${PRODUCTS[@]}" xctest)
fi
if [[ ! "${SKIP_BUILD_FOUNDATION}" ]] ; then
     PRODUCTS=("${PRODUCTS[@]}" foundation)
fi

SWIFT_STDLIB_TARGETS=()
SWIFT_TEST_TARGETS=()
for deployment_target in "${STDLIB_DEPLOYMENT_TARGETS[@]}"; do
    build_for_this_target=1
    test_this_target=1
    case $deployment_target in
        linux-*)
            build_for_this_target=1
            test_this_target=1
            ;;
        macosx-*)
            build_for_this_target=$(not $SKIP_BUILD_OSX)
            test_this_target=$(not $SKIP_TEST_OSX)
            ;;
        iphoneos-*)
            build_for_this_target=$(not $SKIP_BUILD_IOS_DEVICE)
            test_this_target=
            ;;
        iphonesimulator-*)
            build_for_this_target=$(not $SKIP_BUILD_IOS_SIMULATOR)
            test_this_target=$(not $SKIP_TEST_IOS_SIMULATOR)
            ;;
        appletvos-*)
            build_for_this_target=$(not $SKIP_BUILD_TVOS_DEVICE)
            test_this_target=
            ;;
        appletvsimulator-*)
            build_for_this_target=$(not $SKIP_BUILD_TVOS_SIMULATOR)
            test_this_target=$(not $SKIP_TEST_TVOS_SIMULATOR)
            ;;
        watchos-*)
            build_for_this_target=$(not $SKIP_BUILD_WATCHOS_DEVICE)
            test_this_target=
            ;;
        watchsimulator-*)
            build_for_this_target=$(not $SKIP_BUILD_WATCHOS_SIMULATOR)
            test_this_target=$(not $SKIP_TEST_WATCHOS_SIMULATOR)
            ;;
        *)
            echo "Unknown compiler deployment target: $deployment_target"
            exit 1
            ;;
    esac
    if [[ "$build_for_this_target" ]] ; then
        SWIFT_STDLIB_TARGETS=(
            "${SWIFT_STDLIB_TARGETS[@]}" "swift-stdlib-${deployment_target}")
    fi
    if [[ "$test_this_target" ]] ; then
        if [[ "$SKIP_TEST_VALIDATION" ]] ; then
            SWIFT_TEST_TARGETS=(
                "${SWIFT_TEST_TARGETS[@]}" "check-swift-${deployment_target}")
            if [[ $(not $SKIP_TEST_OPTIMIZED) ]] ; then
              SWIFT_TEST_TARGETS=(
                 "${SWIFT_TEST_TARGETS[@]}" "check-swift-optimize-${deployment_target}")
            fi
        else
            SWIFT_TEST_TARGETS=(
                "${SWIFT_TEST_TARGETS[@]}" "check-swift-all-${deployment_target}")
            if [[ $(not $SKIP_TEST_OPTIMIZED) ]] ; then
              SWIFT_TEST_TARGETS=(
                 "${SWIFT_TEST_TARGETS[@]}" "check-swift-all-optimize-${deployment_target}")
            fi

        fi
    fi
done

echo "Building the standard library for: ${SWIFT_STDLIB_TARGETS[@]}"
echo "Running Swift tests for: ${SWIFT_TEST_TARGETS[@]}"
echo

# CMake options used for all targets, including LLVM/Clang
COMMON_CMAKE_OPTIONS=(
    -G "${CMAKE_GENERATOR}"
)

COMMON_C_FLAGS=""
COMMON_CXX_FLAGS=""

if [[ "${ENABLE_ASAN}" ]] ; then
    COMMON_CMAKE_OPTIONS=(
        "${COMMON_CMAKE_OPTIONS[@]}"
        -DLLVM_USE_SANITIZER="Address"
    )
fi

if [ -z "${HOST_CC}" ] ; then
    if [ "$(uname -s)" == "Darwin" ] ; then
        HOST_CC="$(xcrun_find_tool clang)"
        HOST_CXX="$(xcrun_find_tool clang++)"
    else
        for clang_candidate_suffix in "" "-3.8" "-3.7" "-3.6" "-3.5" ; do
            if which "clang${clang_candidate_suffix}" > /dev/null ; then
                HOST_CC="clang${clang_candidate_suffix}"
                HOST_CXX="clang++${clang_candidate_suffix}"
                break
            fi
        done
    fi
fi
if [ -z "${HOST_CC}" ] ; then
    echo "Can't find clang.  Please install clang-3.5 or a later version."
    exit 1
fi

if [[ "$DISTCC" ]] ; then
    # On some platforms, 'pump' may be unrelated to distcc, in which case it's
    # called 'distcc-pump'.
    DISTCC_PUMP="$(which distcc-pump || which pump)"
    COMMON_CMAKE_OPTIONS=(
        "${COMMON_CMAKE_OPTIONS[@]}"
        -DCMAKE_C_COMPILER:PATH="$(which distcc)"
        -DCMAKE_C_COMPILER_ARG1="${HOST_CC}"
        -DCMAKE_CXX_COMPILER:PATH="$(which distcc)"
        -DCMAKE_CXX_COMPILER_ARG1="${HOST_CXX}"
    )
else
    COMMON_CMAKE_OPTIONS=(
        "${COMMON_CMAKE_OPTIONS[@]}"
        -DCMAKE_C_COMPILER:PATH="${HOST_CC}"
        -DCMAKE_CXX_COMPILER:PATH="${HOST_CXX}"
    )
fi

if [[ "$DISTCC" ]] ; then
    BUILD_ARGS="${BUILD_ARGS} -j $(distcc -j)"
fi

case "${CMAKE_GENERATOR}" in
    Ninja)
        if [[ "${VERBOSE_BUILD}" ]] ; then
            BUILD_ARGS="${BUILD_ARGS} -v"
        fi
        ;;
    'Unix Makefiles')
        BUILD_ARGS="${BUILD_ARGS:--j$(get_make_parallelism)}"
        if [[ "${VERBOSE_BUILD}" ]] ; then
            BUILD_ARGS="${BUILD_ARGS} VERBOSE=1"
        fi
        ;;
    Xcode)
        # -parallelizeTargets is an unsupported flag from the Xcode 3 days,
        # but since we're not using proper Xcode 4 schemes, this is the
        # only way to get target-level parallelism.
        BUILD_ARGS="${BUILD_ARGS} -parallelizeTargets"
        BUILD_TARGET_FLAG="-target"
        COMMON_CMAKE_OPTIONS=(
            "${COMMON_CMAKE_OPTIONS[@]}"
            -DCMAKE_CONFIGURATION_TYPES="Debug;Release;MinSizeRel;RelWithDebInfo"
        )
        if [[ "${XCODE_IDE_ONLY}" ]]; then
          COMMON_CMAKE_OPTIONS=(
              "${COMMON_CMAKE_OPTIONS[@]}"
              -DSWIFT_XCODE_GENERATE_FOR_IDE_ONLY=ON
          )
        fi
        ;;
esac

if [[ "${CLANG_COMPILER_VERSION}" ]] ; then
    major_version=$(echo "${CLANG_COMPILER_VERSION}" | sed -e 's/\([0-9]*\).*/\1/')
    minor_version=$(echo "${CLANG_COMPILER_VERSION}" | sed -e 's/[^.]*\.\([0-9]*\).*/\1/')
    patch_version=$(echo "${CLANG_COMPILER_VERSION}" | sed -e 's/[^.]*\.[^.]*\.\([0-9]*\)/\1/')
    COMMON_CMAKE_OPTIONS=(
        "${COMMON_CMAKE_OPTIONS[@]}"
        -DLLVM_VERSION_MAJOR:STRING="${major_version}"
        -DLLVM_VERSION_MINOR:STRING="${minor_version}"
        -DLLVM_VERSION_PATCH:STRING="${patch_version}"
    )
fi

#
# Record SDK and tools versions for posterity
#
if [[ "$SHOW_SDKS" ]] ; then
    echo "--- SDK versions ---"
    xcodebuild -version || :
    echo
    if [[ ! "$SKIP_IOS" ]] ; then
        xcodebuild -version -sdk iphonesimulator || :
    fi
    if [[ ! "$SKIP_TVOS" ]] ; then
        xcodebuild -version -sdk appletvsimulator || :
    fi
    if [[ ! "$SKIP_WATCHOS" ]] ; then
        xcodebuild -version -sdk watchsimulator || :
    fi
fi

function build_directory() {
    deployment_target=$1
    product=$2
    echo "$BUILD_DIR/$product-$deployment_target"
}

function build_directory_bin() {
    deployment_target=$1
    product=$2
    root="$(build_directory $deployment_target $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"
                ;;
            swig)
                echo "${root}"
                ;;
            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"
                ;;
            *)
                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 common_cross_c_flags() {
    echo -n "${COMMON_C_FLAGS}"

    case $1 in
        iphonesimulator-i386)
            echo "-arch i386 -mios-simulator-version-min=${DARWIN_DEPLOYMENT_VERSION_IOS}"
            ;;
        iphonesimulator-x86_64)
            echo "-arch x86_64 -mios-simulator-version-min=${DARWIN_DEPLOYMENT_VERSION_IOS}"
            ;;
        iphoneos-armv7)
            echo "-arch armv7 -miphoneos-version-min=${DARWIN_DEPLOYMENT_VERSION_IOS}"
            ;;
        iphoneos-arm64)
            echo "-arch arm64 -miphoneos-version-min=${DARWIN_DEPLOYMENT_VERSION_IOS}"
            ;;
        appletvsimulator-x86_64)
            echo "-arch x86_64 -mtvos-simulator-version-min=${DARWIN_DEPLOYMENT_VERSION_TVOS}"
            ;;
        appletvos-arm64)
            echo "-arch arm64 -mtvos-version-min=${DARWIN_DEPLOYMENT_VERSION_TVOS}"
            ;;
        watchsimulator-i386)
            echo "-arch i386 -mwatchos-simulator-version-min=${DARWIN_DEPLOYMENT_VERSION_WATCHOS}"
            ;;
        watchos-armv7k)
            echo "-arch armv7k -mwatchos-version-min=${DARWIN_DEPLOYMENT_VERSION_WATCHOS}"
            ;;
    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
}

function cmark_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
}

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
}

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}"
                ;;
            swig)
                ;;
            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}"
                ;;            
            *)
                echo "error: unknown product: ${product}"
                exit 1
                ;;
        esac
    fi
}

function should_build_perftestsuite() {
    if [ "$(uname -s)" != Darwin ]; then
        echo "FALSE"
        return
    fi

    echo $(true_false "${BUILD_SWIFT_PERF_TESTSUITE}")
}

mkdir -p "${BUILD_DIR}"

#
# Build Ninja
#
if [[ "${BUILD_NINJA}" ]] ; then
    build_dir=$(build_directory build ninja)
    if [ ! -f "${build_dir}/ninja" ] ; then
        if [ ! -d "${NINJA_SOURCE_DIR}" ] ; then
          echo "Can't find source directory for ninja (tried ${NINJA_SOURCE_DIR})"
          exit 1
        fi

        # Ninja can only be built in-tree.  Copy the source tree to the build
        # directory.
        set -x
        rm -rf "${build_dir}"
        cp -r "${NINJA_SOURCE_DIR}" "${build_dir}"
        if [[ $(uname -s) == "Darwin" ]]; then
          (cd "${build_dir}" && env CXX=$(xcrun --sdk macosx -find clang++) CFLAGS="-isysroot $(xcrun --sdk macosx --show-sdk-path)" python ./configure.py --bootstrap)
          { set +x; } 2>/dev/null
        else
          (cd "${build_dir}" && python ./configure.py --bootstrap)
          { set +x; } 2>/dev/null
        fi
    fi
    export PATH="${build_dir}:${PATH}"
fi

#
# Configure and build each product
#
# Start with native deployment targets because the resulting tools are used during cross-compilation.
for deployment_target in "${NATIVE_TOOLS_DEPLOYMENT_TARGETS[@]}" "${CROSS_TOOLS_DEPLOYMENT_TARGETS[@]}"; do
    set_deployment_target_based_options

    case "${COMPILER_VENDOR}" in
        none)
            ;;
        apple)
            # User-visible versions of the compiler.
            CLANG_USER_VISIBLE_VERSION="6.1.0"
            SWIFT_USER_VISIBLE_VERSION="2.2"

            llvm_cmake_options=(
                "${llvm_cmake_options[@]}"
                -DCLANG_VENDOR=Apple
                -DCLANG_VENDOR_UTI=com.apple.compilers.llvm.clang
                -DPACKAGE_VERSION="${CLANG_USER_VISIBLE_VERSION}"
            )
            swift_cmake_options=(
                "${swift_cmake_options[@]}"
                -DSWIFT_VENDOR=Apple
                -DSWIFT_VENDOR_UTI=com.apple.compilers.llvm.swift
                -DSWIFT_VERSION="${SWIFT_USER_VISIBLE_VERSION}"
                -DSWIFT_COMPILER_VERSION="${SWIFT_COMPILER_VERSION}"
            )
            ;;
        *)
            echo "unknown compiler vendor"
            exit 1
            ;;
    esac

    llvm_cmake_options=(
        "${llvm_cmake_options[@]}"
        -DCMAKE_INSTALL_PREFIX:PATH="${INSTALL_PREFIX}"
        -DINTERNAL_INSTALL_PREFIX="local"
    )

    if [[ "${CLANG_COMPILER_VERSION}" ]] ; then
        llvm_cmake_options=(
            "${llvm_cmake_options[@]}"
            -DCLANG_REPOSITORY_STRING="clang-${CLANG_COMPILER_VERSION}"
        )
        swift_cmake_options=(
            "${swift_cmake_options[@]}"
            -DCLANG_COMPILER_VERSION="${CLANG_COMPILER_VERSION}"
            -DSWIFT_COMPILER_VERSION="${SWIFT_COMPILER_VERSION}"
        )
    fi
    if [[ "${SWIFT_COMPILER_VERSION}" ]] ; then
        swift_cmake_options=(
            "${swift_cmake_options[@]}"
            -DSWIFT_COMPILER_VERSION="${SWIFT_COMPILER_VERSION}"
        )
    fi

    if [[ "${ENABLE_ASAN}" ]] ; 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

    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

    if [[ $(should_build_perftestsuite) == "TRUE" ]]; then
        swift_cmake_options=(
            "${swift_cmake_options[@]}"
            -DSWIFT_INCLUDE_PERF_TESTSUITE=YES
        )
    fi

    swift_cmake_options=(
        "${swift_cmake_options[@]}"
        -DSWIFT_AST_VERIFIER:BOOL=$(true_false "${SWIFT_ENABLE_AST_VERIFIER}")
        -DSWIFT_VERIFY_ALL:BOOL=$(true_false "${SIL_VERIFY_ALL}")
        -DSWIFT_RUNTIME_ENABLE_DTRACE:BOOL=$(true_false "${SWIFT_RUNTIME_ENABLE_DTRACE}")
        -DSWIFT_RUNTIME_ENABLE_LEAK_CHECKER:BOOL=$(true_false "${SWIFT_RUNTIME_ENABLE_LEAK_CHECKER}")
        -DSWIFT_ENABLE_TARGET_LINUX:BOOL=$(true_false "${SWIFT_ENABLE_TARGET_LINUX}")
    )

    for product in "${PRODUCTS[@]}"; do
        unset skip_build
        build_dir=$(build_directory $deployment_target $product)
        build_targets=(all)
        cmake_options=("${COMMON_CMAKE_OPTIONS[@]}")

        # Add in gold linker support if requested.
        if [[ "$USE_GOLD_LINKER" ]]; then
            echo "${product}: using gold linker"
            if [[ "${product}" != "swift" ]]; then
                # All other projects override the linker flags to add in
                # gold linker support.
                cmake_options=(
                    "${cmake_options[@]}"
                    -DCMAKE_EXE_LINKER_FLAGS:STRING="-fuse-ld=gold"
                    -DCMAKE_SHARED_LINKER_FLAGS:STRING="-fuse-ld=gold"
                )
            fi
        else
            echo "${product}: using standard linker"
        fi

        PRODUCT=$(toupper $product)
        llvm_build_dir=$(build_directory $deployment_target llvm)
        module_cache="${build_dir}/module-cache"
        swift_cmake_options=(
            "${swift_cmake_options[@]}"
            -DCMAKE_INSTALL_PREFIX:PATH="${INSTALL_PREFIX}"
            -DLLVM_CONFIG:PATH="$(build_directory_bin $deployment_target llvm)/llvm-config"
            -D${PRODUCT}_PATH_TO_CLANG_SOURCE:PATH="${CLANG_SOURCE_DIR}"
            -D${PRODUCT}_PATH_TO_CLANG_BUILD:PATH="${llvm_build_dir}"
            -D${PRODUCT}_PATH_TO_LLVM_SOURCE:PATH="${LLVM_SOURCE_DIR}"
            -D${PRODUCT}_PATH_TO_LLVM_BUILD:PATH="${llvm_build_dir}"
            -D${PRODUCT}_PATH_TO_CMARK_SOURCE:PATH="${CMARK_SOURCE_DIR}"
            -D${PRODUCT}_PATH_TO_CMARK_BUILD:PATH="$(build_directory $deployment_target cmark)"
            -DSWIFT_ENABLE_TARGET_APPLETVOS:BOOL=$(true_false "${SWIFT_ENABLE_TARGET_APPLETVOS}")
        )

        if [[ "${CMAKE_GENERATOR}" != "Ninja" ]] ; then
            swift_cmake_options=(
                "${swift_cmake_options[@]-}"
                -D${PRODUCT}_CMARK_LIBRARY_DIR:PATH=$(build_directory $deployment_target cmark)/src/$CMARK_BUILD_TYPE
            )
        else
            swift_cmake_options=(
                "${swift_cmake_options[@]-}"
                -D${PRODUCT}_CMARK_LIBRARY_DIR:PATH=$(build_directory $deployment_target cmark)/src
            )
        fi

        case $product in
            cmark)
                cmake_options=(
                  "${cmake_options[@]}"
                  -DCMAKE_BUILD_TYPE:STRING="${LLVM_BUILD_TYPE}"
                  "${cmark_cmake_options[@]}"
                  "${CMARK_SOURCE_DIR}"
                )
                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-config llvm-tblgen clang-headers)
                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 $deployment_target)"
                    -DCMAKE_CXX_FLAGS="$(llvm_c_flags $deployment_target)"
                    -DCMAKE_BUILD_TYPE:STRING="${LLVM_BUILD_TYPE}"
                    -DLLVM_ENABLE_ASSERTIONS:BOOL=$(true_false "${LLVM_ENABLE_ASSERTIONS}")
                    -DLLVM_TOOL_SWIFT_BUILD:BOOL=NO
                    -DLLVM_TARGETS_TO_BUILD="${LLVM_TARGETS_TO_BUILD}"
                    -DLLVM_INCLUDE_TESTS:BOOL=$(true_false "${SOURCE_TREE_INCLUDES_TESTS}")
                    -LLVM_INCLUDE_DOCS:BOOL=TRUE
                    "${llvm_cmake_options[@]}"
                    "${LLVM_SOURCE_DIR}"
                )
                if [[ $(is_cross_tools_deployment_target $deployment_target) ]] ; then
                    # FIXME: don't hardcode macosx-x86_64.
                    cmake_options=(
                        "${cmake_options[@]}"
                        -DLLVM_TABLEGEN=$(build_directory macosx-x86_64 llvm)/bin/llvm-tblgen
                        -DCLANG_TABLEGEN=$(build_directory macosx-x86_64 llvm)/bin/clang-tblgen
                    )
                fi

                ;;

            swift)
                cmake_options=(${COMMON_CMAKE_OPTIONS[@]})
                if [[ "$USE_GOLD_LINKER" ]]; then
                    # Swift will selectively use the gold linker on all
                    # parts except building the standard library.  We
                    # let the Swift cmake setup figure out how to apply
                    # that.
                    cmake_options=(
                        "${cmake_options[@]}"
                        -DSWIFT_ENABLE_GOLD_LINKER=TRUE
                    )
                fi

                native_llvm_tools_path=""
                native_clang_tools_path=""
                native_swift_tools_path=""
                if [[ $(is_cross_tools_deployment_target $deployment_target) ]] ; then
                    build_tests_this_time=false

                    # FIXME: don't hardcode macosx-x86_64.
                    native_llvm_tools_path="$(build_directory macosx-x86_64 llvm)/bin"
                    native_clang_tools_path="$(build_directory macosx-x86_64 llvm)/bin"
                    native_swift_tools_path="$(build_directory macosx-x86_64 swift)/bin"

                    cmake_options=(
                        "${cmake_options[@]}"
                        -DLLVM_TOOLS_BINARY_DIR:PATH=$(build_directory $deployment_target llvm)/bin
                        -DLLVM_LIBRARY_DIR:PATH=$(build_directory $deployment_target llvm)/lib
                        -DLLVM_MAIN_INCLUDE_DIR:PATH=$(build_directory $deployment_target llvm)/include
                        -DLLVM_BINARY_DIR:PATH=$(build_directory $deployment_target llvm)
                        -DLLVM_MAIN_SRC_DIR:PATH="${LLVM_SOURCE_DIR}"
                    )
                else
                    build_tests_this_time=${SOURCE_TREE_INCLUDES_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
                        -DLLVM_LIBRARY_DIR:PATH="${build_dir}"
                        -DLLVM_MAIN_INCLUDE_DIR:PATH=/tmp/dummy
                        -DLLVM_BINARY_DIR:PATH=$(build_directory $deployment_target llvm)
                        -DLLVM_MAIN_SRC_DIR:PATH="${LLVM_SOURCE_DIR}"
                    )
                fi

                cmake_options=(
                    "${cmake_options[@]}"
                    -DCMAKE_C_FLAGS="$(swift_c_flags $deployment_target)"
                    -DCMAKE_CXX_FLAGS="$(swift_c_flags $deployment_target)"
                    -DCMAKE_BUILD_TYPE:STRING="${SWIFT_BUILD_TYPE}"
                    -DLLVM_ENABLE_ASSERTIONS:BOOL=$(true_false "${SWIFT_ENABLE_ASSERTIONS}")
                    -DSWIFT_STDLIB_BUILD_TYPE:STRING="${SWIFT_STDLIB_BUILD_TYPE}"
                    -DSWIFT_STDLIB_ASSERTIONS:BOOL=$(true_false "${SWIFT_STDLIB_ENABLE_ASSERTIONS}")
                    -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_BUILD_TOOLS:BOOL=$(true_false "${BUILD_SWIFT_TOOLS}")
                    -DSWIFT_BUILD_STDLIB:BOOL=$(true_false "${BUILD_SWIFT_STDLIB}")
                    -DSWIFT_BUILD_SDK_OVERLAY:BOOL=$(true_false "${BUILD_SWIFT_SDK_OVERLAY}")
                    -DSWIFT_BUILD_STATIC_STDLIB:BOOL=$(true_false "${BUILD_SWIFT_STATIC_STDLIB}")
                    -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}")
                    "${swift_cmake_options[@]}"
                    "${SWIFT_SOURCE_DIR}"
                )
                if [[ "${SWIFT_SDKS}" ]] ; then
                    cmake_options=(
                        "${cmake_options[@]}"
                        -DSWIFT_SDKS:STRING="${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

                build_targets=(all "${SWIFT_STDLIB_TARGETS[@]}")
                if [[ $(should_build_perftestsuite) == "TRUE" ]]; then
                    build_targets=("${build_targets[@]}" benchmark-swift)
                fi
                skip_build=$SKIP_BUILD_SWIFT
                ;;

            swig)
                swig_build_dir=$(build_directory $deployment_target swig)
                if [[ "${RECONFIGURE}" || ! -f "${swig_build_dir}/Install/bin/swig" ]] ; then
                    swig_install_dir="${swig_build_dir}/Install"
                    mkdir -p ${swig_install_dir}
                    pushd ${swig_build_dir}
                    "${SWIG_SOURCE_DIR}"/configure --prefix="${swig_install_dir}"
                    make
                    make install
                    popd
                fi
                continue
                ;;

            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
                swig_build_dir=$(build_directory $deployment_target swig)
                cmark_build_dir=$(build_directory $deployment_target cmark)
                lldb_build_dir=$(build_directory $deployment_target lldb)
                swift_build_dir=$(build_directory $deployment_target swift)

                # Add any lldb extra cmake arguments here.
                if [ ! -z "$LLDB_EXTRA_CMAKE_ARGS" ]; then
                    cmake_options=(
                        "${cmake_options[@]}"
                        $LLDB_EXTRA_CMAKE_ARGS
                        )
                fi

                case "$(uname -s)" in
                    Linux)
                        cmake_options=(
                            "${cmake_options[@]}"
                            -DCMAKE_BUILD_TYPE:STRING="${LLDB_BUILD_TYPE}"
                            -DCMAKE_INSTALL_PREFIX:PATH="${INSTALL_PREFIX}"
                            -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_PATH_TO_SWIG_BIN:PATH="${swig_build_dir}/Install/bin"
                            "${LLDB_SOURCE_DIR}"
                        )
                        ;;
                    Darwin)
                        # Set up flags to pass to xcodebuild
                        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_PATH_TO_SWIG="${swig_build_dir}/Install/bin/swig"
                            SYMROOT="${lldb_build_dir}"
                            OBJROOT="${lldb_build_dir}"
                        )
                        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
                        set_lldb_build_mode
                        pushd ${LLDB_SOURCE_DIR}
                        xcodebuild -target desktop -configuration ${LLDB_BUILD_MODE} ${lldb_xcodebuild_options[@]}
                        popd
                        continue
                        ;;
                esac
                ;;
            llbuild)
                cmake_options=(
                    "${cmake_options[@]}"
                    -DCMAKE_INSTALL_PREFIX:PATH="${INSTALL_PREFIX}"
                    -DLIT_EXECUTABLE:PATH="${LLVM_SOURCE_DIR}/utils/lit/lit.py"
                    -DFILECHECK_EXECUTABLE:PATH="$(build_directory_bin $deployment_target llvm)/FileCheck"
                    -DCMAKE_BUILD_TYPE:STRING="${LLBUILD_BUILD_TYPE}"
                    -DLLVM_ENABLE_ASSERTIONS:BOOL=$(true_false "${LLBUILD_ENABLE_ASSERTIONS}")
                    "${LLBUILD_SOURCE_DIR}"
                )
                ;;
            swiftpm)
                SWIFTC_BIN="$(build_directory_bin $deployment_target swift)/swiftc"
                LLBUILD_BIN="$(build_directory_bin $deployment_target llbuild)/swift-build-tool"
                if [ ! -e "${LLBUILD_BIN}" ]; then
                    echo "Error: Cannot build swiftpm without llbuild (swift-build-tool)."
                    exit 1
                fi
                set -x
                "$SWIFTPM_SOURCE_DIR"/Utilities/bootstrap -v "${swiftpm_bootstrap_options[@]}" \
                                     --swiftc="${SWIFTC_BIN}" --sbt="${LLBUILD_BIN}" \
                                     --build="${build_dir}"
                { set +x; } 2>/dev/null
                
                # swiftpm installs itself with a bootstrap method. No further cmake building is performed.
                continue
                ;;
            xctest)
                SWIFTC_BIN="$(build_directory_bin $deployment_target swift)/swiftc"
                SWIFT_BUILD_PATH="$(build_directory $deployment_target swift)"
                set -x
                "$XCTEST_SOURCE_DIR"/build_script.py --swiftc="${SWIFTC_BIN}" --build-dir="${build_dir}" --swift-build-dir="${SWIFT_BUILD_PATH}"
                { set +x; } 2>/dev/null

                # 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
                XCTEST_BUILD_DIR=$(build_directory $deployment_target xctest)
                SWIFTC_BIN="$(build_directory_bin $deployment_target swift)/swiftc"
                SWIFT_BIN="$(build_directory_bin $deployment_target swift)/swift"
                SWIFT_BUILD_PATH="$(build_directory $deployment_target swift)"
                LLVM_BIN="$(build_directory_bin $deployment_target llvm)"
                NINJA_BIN="ninja"

                if [[ "${BUILD_NINJA}" ]]; then
                    NINJA_BUILD_DIR=$(build_directory build ninja)
                    NINJA_BIN="${NINJA_BUILD_DIR}/ninja"
                fi
                
                set -x
                pushd "${FOUNDATION_SOURCE_DIR}"
                SWIFTC="${SWIFTC_BIN}" CLANG="${LLVM_BIN}"/clang SWIFT="${SWIFT_BIN}" \
                      SDKROOT="${SWIFT_BUILD_PATH}" BUILD_DIR="${build_dir}" DSTROOT="${INSTALL_DESTDIR}" PREFIX="${INSTALL_PREFIX}" SWIFTCFLAGS="-I${XCTEST_BUILD_DIR}" LDFLAGS="-L${XCTEST_BUILD_DIR}" ./configure "${FOUNDATION_BUILD_TYPE}"
                $NINJA_BIN
                popd
                { set +x; } 2>/dev/null

                # Foundation builds itself and doesn't use cmake
                continue
                ;;
            *)
                echo "error: unknown product: ${product}"
                exit 1
                ;;
        esac

        # Clean the product-local module cache.
        rm -rf "${module_cache}"
        mkdir -p "${module_cache}"

        # 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.
        if [[  "${RECONFIGURE}" || ! -f "${build_dir}/CMakeCache.txt" || \
                    ( ! -z "${generator_output_path}" && ! -f "${generator_output_path}" ) ]] ; then
            mkdir -p "${build_dir}"
            set -x
            (cd "${build_dir}" && "$CMAKE" "${cmake_options[@]}" ${USER_CONFIG_ARGS})
            { set +x; } 2>/dev/null
        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.
                set -x
                ${DISTCC_PUMP} "$CMAKE" --build "${build_dir}" $(cmake_config_opt $product)
                { set +x; } 2>/dev/null
            fi

            set -x
            ${DISTCC_PUMP} "$CMAKE" --build "${build_dir}" $(cmake_config_opt $product) -- ${BUILD_ARGS} ${build_targets[@]}
            { set +x; } 2>/dev/null
        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 deployment_target in "${STDLIB_DEPLOYMENT_TARGETS[@]}"; do
    case $deployment_target in
        linux-* | macosx-*)
            # OK, we can run tests directly.
            ;;
        iphoneos-* | iphonesimulator-* | appletvos-* | appletvsimulator-* | watchos-* | watchsimulator-*)
            # FIXME: remove this
            # echo "Don't know how to run tests for $deployment_target"
            continue
            ;;
        *)
            echo "Unknown compiler deployment target: $deployment_target"
            exit 1
            ;;
    esac

    # Run the tests for each product
    for product in "${PRODUCTS[@]}"; do
        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)
                if [[ "$SKIP_TEST_SWIFT" ]]; then
                    continue
                fi
                executable_target=SwiftUnitTests
                results_targets=("${SWIFT_TEST_TARGETS[@]}")
                if [[ "$STRESS_TEST_SOURCEKIT" ]]; then
                    results_targets=(
                        "${results_targets[@]}"
                        stress-SourceKit
                    )
                fi
                ;;
            swig)
                continue # We don't test swig.
                ;;
            lldb)
                if [[ "$SKIP_TEST_LLDB" ]]; then
                    continue
                fi
                lldb_build_dir=$(build_directory $deployment_target lldb)
                swift_build_dir=$(build_directory $deployment_target swift)
                # Setup lldb executable path
                if [[ "$(uname -s)" == "Darwin" ]] ; 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"
                mkdir -p "$results_dir"
                pushd "$results_dir"

                # Handle test results formatter
                if [[ "$LLDB_TEST_WITH_CURSES" ]]; then
                    # Setup the curses results formatter.
                    LLDB_FORMATTER_OPTS="\
                                       --results-formatter lldbsuite.test.curses_results.Curses \
                                       --results-file /dev/stdout"
                else
                    LLDB_FORMATTER_OPTS="--results-file $results_dir/results.xml \
                                         -O--xpass=ignore"
                    # 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

                SWIFTCC="$swift_build_dir/bin/swiftc" SWIFTLIBS="$swift_build_dir/lib/swift" "$LLDB_SOURCE_DIR"/test/dotest.py --executable "$lldb_executable" -C $HOST_CC $LLDB_FORMATTER_OPTS
                popd
                continue
                ;;
            llbuild)
                if [[ "$SKIP_TEST_LLBUILD" ]]; then
                    continue
                fi
                results_targets=("test")
                executable_target=""
                ;;
            swiftpm)
                if [[ "$SKIP_TEST_SWIFTPM" ]]; then
                    continue
                fi
                # FIXME: We don't test swiftpm, yet...
                continue
                ;;
            xctest)
                if [[ "$SKIP_TEST_XCTEST" ]]; then
                    continue
                fi
                # FIXME: We don't test xctest, yet...
                continue
                ;;
            foundation)
                if [[ "$SKIP_TEST_FOUNDATION" ]]; then
                    continue
                fi
                build_dir=$(build_directory $deployment_target $product)
                XCTEST_BUILD_DIR=$(build_directory $deployment_target xctest)
                pushd "${FOUNDATION_SOURCE_DIR}"
                $NINJA_BIN TestFoundation
                LD_LIBRARY_PATH="${INSTALL_DESTDIR}"/"${INSTALL_PREFIX}"/lib/swift/:"${build_dir}/Foundation":"${XCTEST_BUILD_DIR}":$LD_LIBRARY_PATH "${build_dir}"/TestFoundation/TestFoundation
                popd
                continue
                ;;
            *)
                echo "error: unknown product: ${product}"
                exit 1
                ;;
        esac

        trap "tests_busted ${product} ''" ERR
        build_dir=$(build_directory $deployment_target $product)
        build_cmd=("$CMAKE" --build "${build_dir}" $(cmake_config_opt $product) -- ${BUILD_ARGS})

        if [[ "${executable_target}" != "" ]]; then
            echo "--- Building tests for ${product} ---"
            set -x
            ${DISTCC_PUMP} "${build_cmd[@]}" ${BUILD_TARGET_FLAG} "${executable_target}"
            { set +x; } 2>/dev/null
        fi

        echo "--- Running tests for ${product} ---"
        for target in "${results_targets[@]}"; do
            echo "--- $target ---"
            trap "tests_busted ${product} '(${target})'" ERR
            if [[ "${CMAKE_GENERATOR}" == Ninja ]] && !( "${build_cmd[@]}" --version 2>&1 | grep -i -q llbuild ); 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.
                sh -c "set -x && $("${build_cmd[@]}" -n -v ${target} | sed -e 's/[^]]*] //')"
            else
                set -x
                "${build_cmd[@]}" ${BUILD_TARGET_FLAG} ${target}
                { set +x; } 2>/dev/null
            fi
            echo "-- $target finished --"
        done

        trap - ERR
        echo "--- Finished tests for ${product} ---"
    done
done

for deployment_target in "${NATIVE_TOOLS_DEPLOYMENT_TARGETS[@]}" "${CROSS_TOOLS_DEPLOYMENT_TARGETS[@]}"; do
    set_deployment_target_based_options

    for product in "${PRODUCTS[@]}"; do

        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
                ;;
            swig)
                continue # We don't install swig.
                ;;
            lldb)
                if [[ -z "${INSTALL_LLDB}" ]] ; then
                    continue
                fi
                case "$(uname -s)" in
                    Linux)
                        ;;
                    Darwin)
                        set_lldb_build_mode
                        pushd ${LLDB_SOURCE_DIR}
                        xcodebuild -target toolchain -configuration ${LLDB_BUILD_MODE} install ${lldb_xcodebuild_options[@]} DSTROOT="${INSTALL_DESTDIR}" LLDB_TOOLCHAIN_PREFIX="${TOOLCHAIN_PREFIX}"
                        popd
                        continue
                        ;;
                esac
                ;;
            llbuild)
                if [[ -z "${INSTALL_LLBUILD}" ]] ; then
                    continue
                fi
                ;;
            swiftpm)
                if [[ -z "${INSTALL_SWIFTPM}" ]] ; then
                    continue
                fi
                SWIFTC_BIN="$(build_directory_bin $deployment_target swift)/swiftc"
                LLBUILD_BIN="$(build_directory_bin $deployment_target llbuild)/swift-build-tool"
                if [ ! -e "${LLBUILD_BIN}" ]; then
                    echo "Error: Cannot install swiftpm without llbuild (swift-build-tool)."
                    exit 1
                fi

                if [[ -z "${INSTALL_DESTDIR}" ]] ; then
                    echo "error: --install-destdir is required"
                    exit 1
                fi

                echo "--- Installing ${product} ---"
                build_dir=$(build_directory $deployment_target $product)
                set -x
                "$SWIFTPM_SOURCE_DIR"/Utilities/bootstrap -v "${swiftpm_bootstrap_options[@]}" \
                                     --swiftc="${SWIFTC_BIN}" --sbt="${LLBUILD_BIN}" \
                                     --build="${build_dir}" --prefix="${INSTALL_DESTDIR}"/"${INSTALL_PREFIX}" install
                { set +x; } 2>/dev/null
                # As swiftpm bootstraps the installation itself, we break early here.
                continue
                ;;
            xctest)
                if [[ -z "${INSTALL_XCTEST}" ]] ; then
                    continue
                fi
                LIB_TARGET="linux"
                if [[ `uname -s` == "Darwin" ]]; then
                    LIB_TARGET="macosx"
                fi
                XCTEST_INSTALL_PREFIX="${INSTALL_DESTDIR}"/"${INSTALL_PREFIX}"/lib/swift/"${LIB_TARGET}"
                echo "--- Installing ${product} ---"
                set -x
                "$XCTEST_SOURCE_DIR"/build_script.py --swiftc="${SWIFTC_BIN}" \
                                    --build-dir="${build_dir}" \
                                    --library-install-path="${XCTEST_INSTALL_PREFIX}" \
                                    --module-install-path="${XCTEST_INSTALL_PREFIX}"/"${SWIFT_HOST_VARIANT_ARCH}" \
                                    --swift-build-dir="${SWIFT_BUILD_PATH}"
                { set +x; } 2>/dev/null
                
                # As XCTest installation is self-contained, we break early here.
                continue
                ;;
            foundation)
                if [[ -z "${INSTALL_FOUNDATION}" ]] ; then
                    continue
                fi
                echo "--- Installing ${product} ---"
								build_dir=$(build_directory $deployment_target $product)
                set -x
                pushd "${FOUNDATION_SOURCE_DIR}"
                $NINJA_BIN install
                popd
                { set +x; } 2>/dev/null

                # As foundation installation is self-contained, we break early here.
                continue
                ;;
            *)
                echo "error: unknown product: ${product}"
                exit 1
                ;;
        esac

        if [[ -z "${INSTALL_DESTDIR}" ]] ; then
            echo "error: --install-destdir is required"
            exit 1
        fi

        if [ "$CROSS_COMPILE_TOOLS_DEPLOYMENT_TARGETS" ] ; then
            # If cross compiling tools, install into a deployment target specific subdirectory.
            if [[ ! "${SKIP_MERGE_LIPO_CROSS_COMPILE_TOOLS}" ]] ; then
                target_install_destdir="${BUILD_DIR}"/intermediate-install/"${deployment_target}"
            else
                target_install_destdir="${INSTALL_DESTDIR}"/"${deployment_target}"
            fi
        else
            target_install_destdir="${INSTALL_DESTDIR}"
        fi

        echo "--- Installing ${product} ---"
        build_dir=$(build_directory $deployment_target $product)

        set -x

        DESTDIR="${target_install_destdir}" "$CMAKE" --build "${build_dir}" -- ${INSTALL_TARGETS}
        { set +x; } 2>/dev/null
    done

done

if [[ "${CROSS_COMPILE_TOOLS_DEPLOYMENT_TARGETS}" ]] && [[ ! "${SKIP_MERGE_LIPO_CROSS_COMPILE_TOOLS}" ]] ; then
    echo "--- Merging and running lipo for ${CROSS_TOOLS_DEPLOYMENT_TARGETS[@]} ---"
    lipo_src_dirs=()
    for deployment_target in "${CROSS_TOOLS_DEPLOYMENT_TARGETS[@]}"; do
        lipo_src_dirs=(
            "${lipo_src_dirs[@]}"
            "${BUILD_DIR}"/intermediate-install/"${deployment_target}"
        )
    done
    "${SWIFT_SOURCE_DIR}"/utils/recursive-lipo --lipo=$(xcrun_find_tool lipo) --copy-subdirs="${INSTALL_PREFIX}/lib/swift ${INSTALL_PREFIX}/lib/swift_static" --destination="${INSTALL_DESTDIR}" ${lipo_src_dirs[@]}
fi

if [[ "${DARWIN_INSTALL_EXTRACT_SYMBOLS}" ]] ; then
    set -x
    # Copy executables and shared libraries from the INSTALL_DESTDIR to
    # INSTALL_SYMROOT and run dsymutil on them.
    (cd "${INSTALL_DESTDIR}" &&
     find ./"${INSTALL_PREFIX}" -perm -0111 -type f -print | cpio -pdm "${INSTALL_SYMROOT}")

    # Run dsymutil on executables and shared libraries.
    #
    # Exclude shell scripts.
    (cd "${INSTALL_SYMROOT}" &&
     find ./"${INSTALL_PREFIX}" -perm -0111 -type f -print | \
       grep -v swift-stdlib-tool | \
       xargs -n 1 -P $(get_dsymutil_parallelism) $(xcrun_find_tool dsymutil))

    # Strip executables, shared libraries and static libraries in
    # INSTALL_DESTDIR.
    find "${INSTALL_DESTDIR}"/"${INSTALL_PREFIX}" \
      \( -perm -0111 -or -name "*.a" \) -type f -print | \
      xargs -n 1 -P $(get_dsymutil_parallelism) $(xcrun_find_tool strip) -S

    { set +x; } 2>/dev/null
fi

if [[ "${INSTALLABLE_PACKAGE}" ]] ; then
    echo "--- Creating installable package ---"
    echo "-- Package file: ${INSTALLABLE_PACKAGE} --"
    if [[ "$(uname -s)" == "Darwin" ]] ; then
      if [ ! -f "${INSTALL_DESTDIR}/${INSTALL_PREFIX}/bin/swift-stdlib-tool" ] ; then
        echo "--- Copy swift-stdlib-tool ---"
        cp "${SWIFT_SOURCE_DIR}/utils/swift-stdlib-tool-substitute" "${INSTALL_DESTDIR}/${INSTALL_PREFIX}/bin/swift-stdlib-tool"
      fi
      (cd "${INSTALL_DESTDIR}" &&
        tar -c -z -f "${INSTALLABLE_PACKAGE}" "${TOOLCHAIN_PREFIX/#\/}")
    else
      (cd "${INSTALL_DESTDIR}" &&
        tar -c -z -f "${INSTALLABLE_PACKAGE}" --owner=0 --group=0 "${INSTALL_PREFIX/#\/}")
    fi
    if [[ "${TEST_INSTALLABLE_PACKAGE}" ]] ; then
        PKG_TESTS_SOURCE_DIR="${WORKSPACE}/swift-package-tests"
        PKG_TESTS_SANDBOX="/tmp/swift_package_sandbox"
        LIT_EXECUTABLE_PATH="${LLVM_SOURCE_DIR}/utils/lit/lit.py"
        FILECHECK_EXECUTABLE_PATH="$(build_directory_bin $deployment_target llvm)/FileCheck"

        rm -rf "${PKG_TESTS_SANDBOX}"
        mkdir "${PKG_TESTS_SANDBOX}"
        pushd "${PKG_TESTS_SANDBOX}"
        tar xzf "${INSTALLABLE_PACKAGE}"
        popd
        (cd "${PKG_TESTS_SOURCE_DIR}" &&
                python "${LIT_EXECUTABLE_PATH}" . -sv --param package-path="${PKG_TESTS_SANDBOX}" --param filecheck="${FILECHECK_EXECUTABLE_PATH}")
    fi
fi

if [[ "${SYMBOLS_PACKAGE}" ]] ; then
    echo "--- Creating symbols package ---"
    echo "-- Package file: ${SYMBOLS_PACKAGE} --"
    if [[ "$(uname -s)" == "Darwin" ]] ; then
      (cd "${INSTALL_SYMROOT}" &&
        tar -c -z -f "${SYMBOLS_PACKAGE}" "${TOOLCHAIN_PREFIX/#\/}")
    else
      (cd "${INSTALL_SYMROOT}" &&
        tar -c -z -f "${SYMBOLS_PACKAGE}" --owner=0 --group=0 "${INSTALL_PREFIX/#\/}")
    fi
fi

# FIXME(before commit): assertion modes:
# On:
#   SWIFT_VERIFY_ALL:BOOL=TRUE
# Off:
#   SWIFT_VERIFY_ALL:BOOL=FALSE