#!/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" 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 return $(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}" (cd "${build_dir}" && python ./configure.py --bootstrap) { set +x; } 2>/dev/null 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.1" 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) ]]; 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) 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}" ./configure $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 # FIXME: We don't test foundation, yet... 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}" DSTROOT="${INSTALL_DESTDIR}" BUILD_DIR="${build_dir}" ./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