build-script

#!/usr/bin/env python

# This source file is part of the Swift.org open source project
#
# Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
# Licensed under Apache License v2.0 with Runtime Library Exception
#
# See https://swift.org/LICENSE.txt for license information
# See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors


"""
The ultimate tool for building Swift.
"""


from __future__ importabsolute_import, print_function, unicode_literals

importjson
importos
importpipes
importplatform
importsys
importtime

frombuild_swift.build_swiftimportargparse
frombuild_swift.build_swiftimportdefaults
frombuild_swift.build_swiftimportdriver_arguments
frombuild_swift.build_swiftimportmigration
frombuild_swift.build_swiftimportpresets
frombuild_swift.build_swift.constantsimportBUILD_SCRIPT_IMPL_PATH
frombuild_swift.build_swift.constantsimportSWIFT_BUILD_ROOT
frombuild_swift.build_swift.constantsimportSWIFT_REPO_NAME
frombuild_swift.build_swift.constantsimportSWIFT_SOURCE_ROOT

importsix

fromswift_build_support.swift_build_supportimportbuild_graph
fromswift_build_support.swift_build_supportimportproducts
fromswift_build_support.swift_build_supportimportshell
fromswift_build_support.swift_build_supportimporttargets
fromswift_build_support.swift_build_supportimportworkspace
fromswift_build_support.swift_build_support.cmakeimportCMake
fromswift_build_support.swift_build_support.host_specific_configuration \
importHostSpecificConfiguration
fromswift_build_support.swift_build_support.targetsimportStdlibDeploymentTarget
fromswift_build_support.swift_build_support.toolchainimporthost_toolchain


# -----------------------------------------------------------------------------
# Constants

# These versions are community sourced. At any given time only the Xcode
# version used by Swift CI is officially supported. See ci.swift.org
_SUPPORTED_XCODE_BUILDS= [
 ("12.2 beta 3", "12B5035g"),
 ("12.2 Release Candidate", "12B5044c"),
 ("12.2", "12B45b"),
 ("12.3", "12C33"),
 ("12.4", "12D4e"),
 ("12.5 beta 3", "12E5244e"),
 ("12.5", "12E262"),
 ("13.0 beta", "13A5154h"),
 ("13.0 beta 4", "13A5201i")
]

# -----------------------------------------------------------------------------
# Helpers


defprint_note(message, stream=sys.stdout):
"""Writes a diagnostic message to the given stream. By default this
 function outputs to stdout.
 """

stream.write('[{}] NOTE: {}\n'.format(sys.argv[0], message))
stream.flush()


deffatal_error(message, stream=sys.stderr):
"""Writes a message to the given stream and exits. By default this
 function outputs to stderr.
 """

stream.write('[{}] ERROR: {}\n'.format(sys.argv[0], message))
stream.flush()
sys.exit(1)


defclean_delay():
"""Provide a short delay so accidentally invoked clean builds can be
 canceled.
 """

sys.stdout.write('Starting clean build in ')
foriinrange(3, 0, -1):
sys.stdout.write('\b%d'%i)
sys.stdout.flush()
time.sleep(1)
print('\b\b\b\bnow.')


defexit_rejecting_arguments(message, parser=None):
print(message, file=sys.stderr)
ifparser:
parser.print_usage(sys.stderr)
sys.exit(2) # 2 is the same as `argparse` error exit code.


definitialize_runtime_environment():
"""Change the program environment for building.
 """

# Set an appropriate default umask.
os.umask(0o022)

# Unset environment variables that might affect how tools behave.
forvin [
'MAKEFLAGS',
'SDKROOT',
'MACOSX_DEPLOYMENT_TARGET',
'IPHONEOS_DEPLOYMENT_TARGET',
'TVOS_DEPLOYMENT_TARGET',
'WATCHOS_DEPLOYMENT_TARGET']:
os.environ.pop(v, None)

# Set NINJA_STATUS to format ninja output
os.environ['NINJA_STATUS'] ='[%f/%t][%p][%es] '


classJSONDumper(json.JSONEncoder):
def__init__(self, *args, **kwargs):
json.JSONEncoder.__init__(
self, indent=2, separators=(',', ': '), sort_keys=True,
*args, **kwargs)

defdefault(self, o):
ifhasattr(o, '__dict__'):
returnvars(o)
returnsix.text_type(o)


defprint_xcodebuild_versions(file=sys.stdout):
"""
 Print the host machine's `xcodebuild` version, as well as version
 information for all available SDKs.
 """
version=shell.capture(
 ['xcodebuild', '-version'], dry_run=False, echo=False).rstrip()
# Allow non-zero exit codes. Under certain obscure circumstances
# xcodebuild can exit with a non-zero exit code even when the SDK is
# usable.
sdks=shell.capture(
 ['xcodebuild', '-version', '-sdk'], dry_run=False, echo=False,
allow_non_zero_exit=True).rstrip()
fmt='{version}\n\n--- SDK versions ---\n{sdks}\n'

print(fmt.format(version=version, sdks=sdks), file=file)
file.flush()


defvalidate_xcode_compatibility():
ifsys.platform!='darwin':
return

ifos.getenv("SKIP_XCODE_VERSION_CHECK"):
print("note: skipping Xcode version check")
return

version=shell.capture(
 ['xcodebuild', '-version'], dry_run=False, echo=False).strip()

valid_build_numbers=tuple(x[1] forxin_SUPPORTED_XCODE_BUILDS)
ifnotversion.endswith(valid_build_numbers):
valid_versions_string="\n".join(
"{} ({})".format(*x) forxin_SUPPORTED_XCODE_BUILDS)
raiseSystemExit(
"error: using unsupported Xcode version:\n\n{}\n\n"
"Install one of:\n{}\n\n"
"Or set 'SKIP_XCODE_VERSION_CHECK=1' in the environment".format(
version, valid_versions_string
 )
 )


deftar(source, destination):
"""
 Create a gzip archive of the file at 'source' at the given
 'destination' path.
 """
# We do not use `tarfile` here because:
# - We wish to support LZMA2 compression while also supporting Python 2.7.
# - We wish to explicitly set the owner and group of the archive.
args= ['tar', '-c', '-z', '-f', destination]

ifplatform.system() !='Darwin'andplatform.system() !='Windows':
args+= ['--owner=0', '--group=0']

# Discard stderr output such as 'tar: Failed to open ...'. We'll detect
# these cases using the exit code, which should cause 'shell.call' to
# raise.
shell.call(args+ [source], stderr=shell.DEVNULL)


# -----------------------------------------------------------------------------
# Argument Validation

defvalidate_arguments(toolchain, args):
iftoolchain.ccisNoneortoolchain.cxxisNone:
fatal_error(
"can't find clang (please install clang-3.5 or a "
"later version)")

iftoolchain.cmakeisNone:
fatal_error("can't find CMake (please install CMake)")

ifargs.distcc:
iftoolchain.distccisNone:
fatal_error(
"can't find distcc (please install distcc)")
iftoolchain.distcc_pumpisNone:
fatal_error(
"can't find distcc-pump (please install distcc-pump)")

ifargs.sccache:
iftoolchain.sccacheisNone:
fatal_error(
"can't find sccache (please install sccache)")

ifargs.host_targetisNoneorargs.stdlib_deployment_targetsisNone:
fatal_error("unknown operating system")

ifargs.symbols_package:
ifnotos.path.isabs(args.symbols_package):
print(
'--symbols-package must be an absolute path '
'(was \'{}\')'.format(args.symbols_package))
return1
ifnotargs.install_symroot:
fatal_error(
"--install-symroot is required when specifying "
"--symbols-package.")

ifargs.android:
ifargs.android_ndkisNoneor \
args.android_api_levelisNoneor \
args.android_icu_ucisNoneor \
args.android_icu_uc_includeisNoneor \
args.android_icu_i18nisNoneor \
args.android_icu_i18n_includeisNoneor \
args.android_icu_dataisNone:
fatal_error(
"when building for Android, --android-ndk, "
"--android-api-level, --android-icu-uc, "
"--android-icu-uc-include, --android-icu-i18n, "
"--android-icu-i18n-include, and --android-icu-data "
"must be specified")

targets_needing_toolchain= [
'build_indexstoredb',
'build_playgroundsupport',
'build_sourcekitlsp',
'build_toolchainbenchmarks',
'build_swift_inspect',
'tsan_libdispatch_test',
 ]
has_target_needing_toolchain= \
bool(sum(getattr(args, x) forxintargets_needing_toolchain))
ifargs.legacy_implandhas_target_needing_toolchain:
fatal_error(
"--legacy-impl is incompatible with building packages needing "
"a toolchain (%s)"%", ".join(targets_needing_toolchain))


defdefault_stdlib_deployment_targets(args):
"""
 Return targets for the Swift stdlib, based on the build machine.
 If the build machine is not one of the recognized ones, return None.
 """

host_target=StdlibDeploymentTarget.host_target()
ifhost_targetisNone:
returnNone

# OS X build machines configure all Darwin platforms by default.
# Put iOS native targets last so that we test them last
# (it takes a long time).
ifhost_target==StdlibDeploymentTarget.OSX.x86_64:
targets= [host_target]
ifargs.build_iosandargs.build_ios_simulator:
targets.extend(StdlibDeploymentTarget.iOSSimulator.targets)
ifargs.build_iosandargs.build_ios_device:
targets.extend(StdlibDeploymentTarget.iOS.targets)
ifargs.build_tvosandargs.build_tvos_simulator:
targets.extend(StdlibDeploymentTarget.AppleTVSimulator.targets)
ifargs.build_tvosandargs.build_tvos_device:
targets.extend(StdlibDeploymentTarget.AppleTV.targets)
ifargs.build_watchosandargs.build_watchos_simulator:
targets.extend(StdlibDeploymentTarget
 .AppleWatchSimulator.targets)
ifargs.build_watchosandargs.build_watchos_device:
targets.extend(StdlibDeploymentTarget.AppleWatch.targets)
returntargets
else:
# All other machines only configure their host stdlib by default.
return [host_target]


defapply_default_arguments(toolchain, args):
# Infer if ninja is required
ninja_required= (
args.build_foundationor
args.build_indexstoredbor
args.build_sourcekitlspor
args.cmake_generator=='Ninja'
 )
ifninja_requiredandtoolchain.ninjaisNone:
args.build_ninja=True

# Set the default stdlib-deployment-targets, if none were provided.
ifargs.stdlib_deployment_targetsisNone:
stdlib_targets=default_stdlib_deployment_targets(args)
args.stdlib_deployment_targets= [
target.namefortargetinstdlib_targets]

# SwiftPM and XCTest have a dependency on Foundation.
# On OS X, Foundation is built automatically using xcodebuild.
# On Linux, we must ensure that it is built manually.
if ((args.build_swiftpmorargs.build_xctest) and
platform.system() !="Darwin"):
args.build_foundation=True

# Foundation has a dependency on libdispatch.
# On OS X, libdispatch is provided by the OS.
# On Linux, we must ensure that it is built manually.
if (args.build_foundationand
platform.system() !="Darwin"):
args.build_libdispatch=True

ifargs.build_subdirisNone:
args.build_subdir= \
workspace.compute_build_subdir(args)

ifargs.relocate_xdg_cache_home_under_build_subdir:
cache_under_build_subdir=os.path.join(
SWIFT_BUILD_ROOT, args.build_subdir, '.cache')
ifargs.verbose_build:
print("Relocating XDG_CACHE_HOME to {}".format(cache_under_build_subdir))
workspace.relocate_xdg_cache_home_under(cache_under_build_subdir)

ifargs.install_destdirisNone:
args.install_destdir=os.path.join(
SWIFT_BUILD_ROOT, args.build_subdir,
'{}-{}'.format('toolchain', args.host_target))

# Add optional stdlib-deployment-targets
ifargs.android:
ifargs.android_arch=="armv7":
args.stdlib_deployment_targets.append(
StdlibDeploymentTarget.Android.armv7.name)
elifargs.android_arch=="aarch64":
args.stdlib_deployment_targets.append(
StdlibDeploymentTarget.Android.aarch64.name)
elifargs.android_arch=="x86_64":
args.stdlib_deployment_targets.append(
StdlibDeploymentTarget.Android.x86_64.name)

# Infer platform flags from manually-specified configure targets.
# This doesn't apply to Darwin platforms, as they are
# already configured. No building without the platform flag, though.

android_tgts= [tgtfortgtinargs.stdlib_deployment_targets
ifStdlibDeploymentTarget.Android.contains(tgt)]
ifnotargs.androidandlen(android_tgts) >0:
# If building natively on an Android host, avoid the NDK
# cross-compilation configuration.
ifnotStdlibDeploymentTarget.Android.contains(StdlibDeploymentTarget
 .host_target().name):
args.android=True
args.build_android=False

# Include the Darwin supported architectures in the CMake options.
ifargs.swift_darwin_supported_archs:
args.extra_cmake_options.append(
'-DSWIFT_DARWIN_SUPPORTED_ARCHS:STRING={}'.format(
args.swift_darwin_supported_archs))

# Remove unsupported Darwin archs from the standard library
# deployment targets.
supported_archs=args.swift_darwin_supported_archs.split(';')
targets=StdlibDeploymentTarget.get_targets_by_name(
args.stdlib_deployment_targets)

args.stdlib_deployment_targets= [
target.name
fortargetintargets
if (target.platform.is_darwinand
target.archinsupported_archs)
 ]

# Filter out any macOS stdlib deployment targets that are not supported
# by the macOS SDK.
targets=StdlibDeploymentTarget.get_targets_by_name(
args.stdlib_deployment_targets)
args.stdlib_deployment_targets= [
target.name
fortargetintargets
if (nottarget.platform.is_darwinor
target.platform.sdk_supports_architecture(
target.arch, args.darwin_xcrun_toolchain))
 ]

# Include the Darwin module-only architectures in the CMake options.
ifargs.swift_darwin_module_archs:
args.extra_cmake_options.append(
'-DSWIFT_DARWIN_MODULE_ARCHS:STRING={}'.format(
args.swift_darwin_module_archs))


# -----------------------------------------------------------------------------
# Build Script Impl Wrapping

classBuildScriptInvocation(object):
"""Represent a single build script invocation.
 """

def__init__(self, toolchain, args):
self.toolchain=toolchain
self.args=args

self.workspace=workspace.Workspace(
source_root=SWIFT_SOURCE_ROOT,
build_root=os.path.join(SWIFT_BUILD_ROOT, args.build_subdir))

self.build_libparser_only=args.build_libparser_only

@property
definstall_all(self):
returnself.args.install_allorself.args.infer_dependencies

defbuild_ninja(self):
ifnotos.path.exists(self.workspace.source_dir("ninja")):
fatal_error(
"can't find source directory for ninja "
"(tried %s)"% (self.workspace.source_dir("ninja")))

ninja_build=products.Ninja.new_builder(
args=self.args,
toolchain=self.toolchain,
workspace=self.workspace,
host=StdlibDeploymentTarget.get_target_for_name(
self.args.host_target))
ninja_build.build()
self.toolchain.ninja=ninja_build.ninja_bin_path

defconvert_to_impl_arguments(self):
"""convert_to_impl_arguments() -> (env, args)

 Convert the invocation to an environment and list of arguments suitable
 for invoking `build-script-impl`.
 """

# Create local shadows, for convenience.
args=self.args
toolchain=self.toolchain

cmake=CMake(args=args,
toolchain=self.toolchain)

impl_args= [
"--workspace", self.workspace.source_root,
"--build-dir", self.workspace.build_root,
"--install-prefix", args.install_prefix,
"--host-target", args.host_target,
"--stdlib-deployment-targets={}".format(
" ".join(args.stdlib_deployment_targets)),
"--host-cc", toolchain.cc,
"--host-cxx", toolchain.cxx,
"--darwin-xcrun-toolchain", args.darwin_xcrun_toolchain,
"--darwin-deployment-version-osx=%s"% (
args.darwin_deployment_version_osx),
"--darwin-deployment-version-ios=%s"% (
args.darwin_deployment_version_ios),
"--darwin-deployment-version-tvos=%s"% (
args.darwin_deployment_version_tvos),
"--darwin-deployment-version-watchos=%s"% (
args.darwin_deployment_version_watchos),
"--cmake", toolchain.cmake,
"--cmark-build-type", args.cmark_build_variant,
"--llvm-build-type", args.llvm_build_variant,
"--swift-build-type", args.swift_build_variant,
"--swift-stdlib-build-type", args.swift_stdlib_build_variant,
"--lldb-build-type", args.lldb_build_variant,
"--foundation-build-type", args.foundation_build_variant,
"--libdispatch-build-type", args.libdispatch_build_variant,
"--libicu-build-type", args.libicu_build_variant,
"--xctest-build-type", args.build_variant,
"--llbuild-build-type", args.build_variant,
"--swift-enable-assertions", str(args.swift_assertions).lower(),
"--swift-stdlib-enable-assertions", str(
args.swift_stdlib_assertions).lower(),
"--swift-analyze-code-coverage", str(
args.swift_analyze_code_coverage).lower(),
"--llbuild-enable-assertions", str(
args.llbuild_assertions).lower(),
"--lldb-assertions", str(
args.lldb_assertions).lower(),
"--cmake-generator", args.cmake_generator,
"--build-jobs", str(args.build_jobs),
"--common-cmake-options=%s"%' '.join(
pipes.quote(opt) foroptincmake.common_options()),
"--build-args=%s"%' '.join(
pipes.quote(arg) forargincmake.build_args()),
"--dsymutil-jobs", str(args.dsymutil_jobs),
 ]

# Compute any product specific cmake arguments.
#
# NOTE: The sum(list(...)) is b/c compute_product_classes returns a
# tuple of lists of which the first is the build-script-impl products
# and the second is the non-build-script-impl-products. It guarantees
# that when we concatenate these two lists together we get a valid
# dependency graph.
forproduct_classinsum(list(self.compute_product_classes()), []):
ifnotproduct_class.is_build_script_impl_product():
continue

product_name=product_class.product_name()
product_source_name=product_class.product_source_name()
source_dir=self.workspace.source_dir(product_source_name)

ifnotos.path.exists(source_dir):
fatal_error(
"can't find source directory for %s "
"(tried %s)"% (product_name, source_dir))

product=product_class(
args=args,
toolchain=self.toolchain,
source_dir=source_dir,
# FIXME: This is incorrect since it always assumes the host
# target I think?
build_dir=self.workspace.build_dir(
args.host_target, product_name))
cmake_opts=product.cmake_options

# FIXME: We should be using pipes.quote here but we run into issues
# with build-script-impl/cmake not being happy with all of the
# extra "'" in the strings. To fix this easily, we really need to
# just invoke cmake from build-script directly rather than futzing
# with build-script-impl. This makes even more sense since there
# really isn't a security issue here.
ifcmake_opts:
impl_args+= [
"--{}-cmake-options={}".format(
product_name, ' '.join(cmake_opts))
 ]

ifargs.build_stdlib_deployment_targets:
impl_args+= [
"--build-stdlib-deployment-targets", " ".join(
args.build_stdlib_deployment_targets)]
ifargs.cross_compile_hosts:
impl_args+= [
"--cross-compile-hosts", " ".join(args.cross_compile_hosts)]

ifargs.test_paths:
impl_args+= ["--test-paths", " ".join(args.test_paths)]

iftoolchain.ninja:
impl_args+= ["--ninja-bin=%s"%toolchain.ninja]
ifargs.distcc:
impl_args+= [
"--distcc",
"--distcc-pump=%s"%toolchain.distcc_pump
 ]
ifargs.sccache:
args.cmake_c_launcher=toolchain.sccache
args.cmake_cxx_launcher=toolchain.sccache

# *NOTE* We use normal cmake to pass through tsan/ubsan options. We do
# NOT pass them to build-script-impl.
ifargs.enable_asan:
impl_args+= ["--enable-asan"]
# If we are on linux, disable leak detection when running ASAN. We
# have a separate bot that checks for leaks.
ifplatform.system() =='Linux':
os.environ['ASAN_OPTIONS'] ='detect_leaks=0'
ifargs.enable_ubsan:
impl_args+= ["--enable-ubsan"]

# If we have lsan, we need to export our suppression list. The actual
# passing in of the LSAN flag is done via the normal cmake method. We
# do not pass the flag to build-script-impl.
ifargs.enable_lsan:
supp_file=os.path.join(SWIFT_SOURCE_ROOT, SWIFT_REPO_NAME,
"utils",
"lsan_leaks_suppression_list.txt")
os.environ['LSAN_OPTIONS'] ='suppressions={}'.format(supp_file)
ifargs.verbose_build:
impl_args+= ["--verbose-build"]
ifargs.install_symroot:
impl_args+= [
"--install-symroot", os.path.abspath(args.install_symroot)
 ]
ifargs.install_destdir:
impl_args+= [
"--install-destdir", os.path.abspath(args.install_destdir)
 ]

ifargs.skip_build:
impl_args+= ["--skip-build"]
ifnotargs.build_benchmarks:
impl_args+= ["--skip-build-benchmarks"]

ifargs.swift_disable_dead_stripping:
args.extra_cmake_options.append('-DSWIFT_DISABLE_DEAD_STRIPPING:BOOL=TRUE')

# Then add subproject install flags that either skip building them /or/
# if we are going to build them and install_all is set, we also install
# them.
conditional_subproject_configs= [
 (args.build_cmark, "cmark"),
 (args.build_llvm, "llvm"),
 (args.build_swift, "swift"),
 (args.build_foundation, "foundation"),
 (args.build_xctest, "xctest"),
 (args.build_lldb, "lldb"),
 (args.build_llbuild, "llbuild"),
 (args.build_libcxx, "libcxx"),
 (args.build_libdispatch, "libdispatch"),
 (args.build_libicu, "libicu")
 ]
for (should_build, string_name) inconditional_subproject_configs:
ifnotshould_buildandnotself.args.infer_dependencies:
impl_args+= ["--skip-build-{}".format(string_name)]
elifself.install_all:
impl_args+= ["--install-{}".format(string_name)]

ifargs.build_swift_dynamic_stdlib:
impl_args+= ["--build-swift-dynamic-stdlib"]
ifargs.build_swift_static_stdlib:
impl_args+= ["--build-swift-static-stdlib"]
ifargs.build_swift_stdlib_unittest_extra:
impl_args+= ["--build-swift-stdlib-unittest-extra"]
ifargs.build_swift_dynamic_sdk_overlay:
impl_args+= ["--build-swift-dynamic-sdk-overlay"]
ifargs.build_swift_static_sdk_overlay:
impl_args+= ["--build-swift-static-sdk-overlay"]

ifnotargs.build_android:
impl_args+= ["--skip-build-android"]
ifnotargs.build_clang_tools_extra:
impl_args+= ["--skip-build-clang-tools-extra"]

ifnotargs.testandnotargs.long_testandnotargs.stress_test:
impl_args+= ["--skip-test-swift"]
ifnotargs.test:
impl_args+= [
"--skip-test-cmark",
"--skip-test-lldb",
"--skip-test-llbuild",
"--skip-test-xctest",
"--skip-test-foundation",
"--skip-test-libdispatch",
"--skip-test-libicu",
 ]
ifargs.build_runtime_with_host_compiler:
impl_args+= ["--build-runtime-with-host-compiler"]
ifargs.validation_test:
impl_args+= ["--validation-test"]
ifargs.long_test:
impl_args+= ["--long-test"]
ifargs.stress_test:
impl_args+= ["--stress-test"]
ifargs.skip_local_build:
impl_args+= ["--skip-local-build"]
ifargs.only_executable_test:
impl_args+= ["--only-executable-test"]
ifnotargs.benchmark:
impl_args+= ["--skip-test-benchmarks"]
ifargs.build_libparser_only:
impl_args+= ["--build-libparser-only"]
ifargs.android:
impl_args+= [
"--android-arch", args.android_arch,
"--android-ndk", args.android_ndk,
"--android-api-level", args.android_api_level,
"--android-ndk-gcc-version", args.android_ndk_gcc_version,
"--android-icu-uc", args.android_icu_uc,
"--android-icu-uc-include", args.android_icu_uc_include,
"--android-icu-i18n", args.android_icu_i18n,
"--android-icu-i18n-include", args.android_icu_i18n_include,
"--android-icu-data", args.android_icu_data,
 ]
# If building natively on an Android host, only pass the API level.
ifStdlibDeploymentTarget.Android.contains(StdlibDeploymentTarget
 .host_target().name):
impl_args+= ["--android-api-level", args.android_api_level]
ifargs.android_deploy_device_path:
impl_args+= [
"--android-deploy-device-path",
args.android_deploy_device_path,
 ]

ifplatform.system() =='Darwin':
impl_args+= [
"--toolchain-prefix",
targets.darwin_toolchain_prefix(
args.install_prefix),
"--host-lipo", toolchain.lipo,
 ]

# Isolate build from the system; Darwin toolchains build against SDKs.
# For additional isolation, disable pkg-config. Homebrew's pkg-config
# prioritizes CommandLineTools paths, resulting in compile errors.
args.extra_cmake_options+= [
'-DCMAKE_IGNORE_PATH=/usr/lib;/usr/local/lib;/lib',
'-DPKG_CONFIG_EXECUTABLE=/usr/bin/false',
 ]

iftoolchain.libtoolisnotNone:
impl_args+= [
"--host-libtool", toolchain.libtool,
 ]
ifargs.native_clang_tools_pathisnotNone:
impl_args+= [
"--native-clang-tools-path=%s"%args.native_clang_tools_path
 ]
ifargs.native_llvm_tools_pathisnotNone:
impl_args+= [
"--native-llvm-tools-path=%s"%args.native_llvm_tools_path
 ]
ifargs.native_swift_tools_pathisnotNone:
impl_args+= [
"--native-swift-tools-path=%s"%args.native_swift_tools_path
 ]

# If we have extra_swift_args, combine all of them together and then
# add them as one command.
ifargs.extra_swift_args:
impl_args+= [
"--extra-swift-args=%s"%';'.join(args.extra_swift_args)
 ]

# Enable macCatalyst
ifargs.maccatalyst:
 (args.extra_cmake_options
 .append('-DSWIFT_ENABLE_MACCATALYST:BOOL=TRUE'))
ifargs.maccatalyst_ios_tests:
impl_args+= ["--darwin-test-maccatalyst-ios-like=1"]

# If we have extra_cmake_options, combine all of them together and then
# add them as one command.
ifargs.extra_cmake_options:
impl_args+= [
"--extra-cmake-options=%s"%' '.join(
pipes.quote(opt) foroptinargs.extra_cmake_options)
 ]

ifargs.lto_typeisnotNone:
impl_args+= [
"--llvm-enable-lto=%s"%args.lto_type,
"--swift-tools-enable-lto=%s"%args.lto_type
 ]
ifargs.llvm_max_parallel_lto_link_jobsisnotNone:
impl_args+= [
"--llvm-num-parallel-lto-link-jobs=%s"%
min(args.llvm_max_parallel_lto_link_jobs, args.build_jobs)
 ]
ifargs.swift_tools_max_parallel_lto_link_jobsisnotNone:
impl_args+= [
"--swift-tools-num-parallel-lto-link-jobs=%s"%
min(args.swift_tools_max_parallel_lto_link_jobs,
args.build_jobs)
 ]

impl_args+=args.build_script_impl_args

ifargs.dry_run:
impl_args+= ["--dry-run"]

ifargs.clang_profile_instr_use:
impl_args+= [
"--clang-profile-instr-use=%s"%
os.path.abspath(args.clang_profile_instr_use)
 ]

ifargs.lit_args:
impl_args+= ["--llvm-lit-args=%s"%args.lit_args]

ifargs.coverage_db:
impl_args+= [
"--coverage-db=%s"%
os.path.abspath(args.coverage_db)
 ]

ifargs.llvm_install_components:
impl_args+= [
"--llvm-install-components=%s"%args.llvm_install_components
 ]

ifnotargs.clean_llbuild:
impl_args+= [
"--skip-clean-llbuild"
 ]

ifargs.llvm_ninja_targets:
impl_args+= [
"--llvm-ninja-targets=%s"%' '.join(args.llvm_ninja_targets)
 ]

ifargs.llvm_ninja_targets_for_cross_compile_hosts:
impl_args+= [
"--llvm-ninja-targets-for-cross-compile-hosts=%s"%
' '.join(args.llvm_ninja_targets_for_cross_compile_hosts)
 ]

# Compute the set of host-specific variables, which we pass through to
# the build script via environment variables.
host_specific_variables=self.compute_host_specific_variables()
impl_env= {}
for (host_target, options) inhost_specific_variables.items():
for (name, value) inoptions.items():
# We mangle into an environment variable we can easily evaluate
# from the `build-script-impl`.
impl_env["HOST_VARIABLE_{}__{}".format(
host_target.replace("-", "_"), name)] =value

return (impl_env, impl_args)

defcompute_host_specific_variables(self):
"""compute_host_specific_variables(args) -> dict

 Compute the host-specific options, organized as a dictionary keyed by
 host of options.
 """

args=self.args
args.build_root=self.workspace.build_root

options= {}
forhost_targetin [args.host_target] +args.cross_compile_hosts:
# Compute the host specific configuration.
try:
config=HostSpecificConfiguration(host_target, args)
exceptargparse.ArgumentErrorase:
exit_rejecting_arguments(six.text_type(e))

# Convert into `build-script-impl` style variables.
options[host_target] = {
"SWIFT_SDKS": " ".join(sorted(
config.sdks_to_configure)),
"SWIFT_STDLIB_TARGETS": " ".join(
config.swift_stdlib_build_targets),
"SWIFT_BENCHMARK_TARGETS": " ".join(
config.swift_benchmark_build_targets),
"SWIFT_RUN_BENCHMARK_TARGETS": " ".join(
config.swift_benchmark_run_targets),
"SWIFT_TEST_TARGETS": " ".join(
config.swift_test_run_targets),
"SWIFT_FLAGS": config.swift_flags,
"SWIFT_TARGET_CMAKE_OPTIONS": config.cmake_options,
 }

returnoptions

defcompute_product_classes(self):
"""compute_product_classes() -> (list, list)

 Compute the list first of all build-script-impl products and then all
 non-build-script-impl products. It is assumed that concatenating the two
 lists together will result in a valid dependency graph for the
 compilation.

 """

# FIXME: This is a weird division (returning a list of class objects),
# but it matches the existing structure of the `build-script-impl`.
impl_product_classes= []
ifself.args.build_cmark:
impl_product_classes.append(products.CMark)

# If --skip-build-llvm is passed in, LLVM cannot be completely disabled, as
# Swift still needs a few LLVM targets like tblgen to be built for it to be
# configured. Instead, handle this in build-script-impl for now.
impl_product_classes.append(products.LLVM)
ifself.args.build_libcxx:
impl_product_classes.append(products.LibCXX)
ifself.args.build_libicu:
impl_product_classes.append(products.LibICU)
ifself.args.build_swift:
impl_product_classes.append(products.Swift)
ifself.args.build_lldb:
impl_product_classes.append(products.LLDB)
ifself.args.build_libdispatch:
impl_product_classes.append(products.LibDispatch)
ifself.args.build_foundation:
impl_product_classes.append(products.Foundation)
ifself.args.build_xctest:
impl_product_classes.append(products.XCTest)
ifself.args.build_llbuild:
impl_product_classes.append(products.LLBuild)
# Sanity check that all of our impl classes are actually
# build_script_impl products.
forprodinimpl_product_classes:
assert(prod.is_build_script_impl_product())

product_classes= []
ifself.args.build_swiftpm:
product_classes.append(products.SwiftPM)
ifself.args.build_swiftsyntax:
product_classes.append(products.SwiftSyntax)
ifself.args.build_skstresstester:
product_classes.append(products.SKStressTester)
ifself.args.build_swiftformat:
product_classes.append(products.SwiftFormat)
ifself.args.build_swiftevolve:
product_classes.append(products.SwiftEvolve)
ifself.args.build_indexstoredb:
product_classes.append(products.IndexStoreDB)
ifself.args.build_playgroundsupport:
product_classes.append(products.PlaygroundSupport)
ifself.args.build_sourcekitlsp:
product_classes.append(products.SourceKitLSP)
ifself.args.build_toolchainbenchmarks:
product_classes.append(products.Benchmarks)
ifself.args.build_swift_inspect:
product_classes.append(products.SwiftInspect)
ifself.args.tsan_libdispatch_test:
product_classes.append(products.TSanLibDispatch)

# Keep SwiftDriver at last.
# swift-driver's integration with the build scripts is not fully
# supported. Using swift-driver to build these products may hit
# failures.
ifself.args.build_swift_driverorself.args.install_swift_driver:
product_classes.append(products.SwiftDriver)
# Sanity check that all of our non-impl classes are actually
# not build_script_impl products.
forprodinproduct_classes:
assert(notprod.is_build_script_impl_product())

# Now that we have our two lists of product_classes, if we are asked to
# infer dependencies, infer the dependencies now and then re-split the
# list.
ifself.args.infer_dependencies:
combined=impl_product_classes+product_classes
ifself.args.verbose_build:
print("-- Build Graph Inference --")
print("Initial Product List:")
forpincombined:
print(" {}".format(p.product_name()))

# Now that we have produced the schedule, resplit. We require our
# dependencies to respect our build-script-impl property. This means
# that no build-script-impl products can have dependencies on
# non-build-script-impl products. Otherwise, it would be unsafe to
# re-order build-script-impl products in front of non
# build-script-impl products.
impl_product_classes= []
product_classes= []
is_darwin=platform.system() =='Darwin'
final_schedule=build_graph.produce_scheduled_build(combined)[0]
forpinfinal_schedule:
ifis_darwinandp.is_nondarwin_only_build_product():
continue

ifp.is_build_script_impl_product():
impl_product_classes.append(p)
else:
product_classes.append(p)
ifself.args.verbose_build:
print("Final Build Order:")
forpinimpl_product_classes:
print(" {}".format(p.product_name()))
forpinproduct_classes:
print(" {}".format(p.product_name()))
return (impl_product_classes, product_classes)

defexecute(self):
"""Execute the invocation with the configured arguments."""

# Convert to a build-script-impl invocation.
 (self.impl_env, self.impl_args) =self.convert_to_impl_arguments()

# If using the legacy implementation, delegate all behavior to
# `build-script-impl`.
ifself.args.legacy_impl:
# Execute the underlying build script implementation.
shell.call_without_sleeping([BUILD_SCRIPT_IMPL_PATH] +self.impl_args,
env=self.impl_env, echo=True)
return

# Otherwise, we compute and execute the individual actions ourselves.

# Compute the list of hosts to operate on.
all_host_names= [
self.args.host_target] +self.args.cross_compile_hosts
all_hosts= [StdlibDeploymentTarget.get_target_for_name(name)