mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
159eab1e24
The configuration script for Foundation respects debug and release builds so a new option for foundation-build-type has been added to control the build variant of Foundation. Resolve the FIXME for adding a mechanism for a custom invocation of running the Foundation unit tests Foundation now has an install target provided from the generated ninja script such that the potentially error prone install script is dramatically simplified into a single encapsulation of a ninja phony target of "install"; so adopt this new target for installation
2183 lines
87 KiB
Bash
Executable File
2183 lines
87 KiB
Bash
Executable File
#!/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}" 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
|
||
|