| # swift_build_support/host_configuration_support.py -------------*- python -*- |
| # |
| # This source file is part of the Swift.org open source project |
| # |
| # Copyright (c) 2014 - 2019 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 |
| # |
| # ---------------------------------------------------------------------------- |
| |
| from argparse import ArgumentError |
| |
| import diagnostics |
| |
| from .targets import StdlibDeploymentTarget |
| |
| |
| class HostSpecificConfiguration(object): |
| |
| """Configuration information for an individual host.""" |
| |
| def __init__(self, host_target, args): |
| """Initialize for the given `host_target`.""" |
| |
| # Compute the set of deployment targets to configure/build. |
| if host_target == args.host_target: |
| # This host is the user's desired product, so honor the requested |
| # set of targets to configure/build. |
| stdlib_targets_to_configure = args.stdlib_deployment_targets |
| if "all" in args.build_stdlib_deployment_targets: |
| stdlib_targets_to_build = set(stdlib_targets_to_configure) |
| else: |
| stdlib_targets_to_build = set( |
| args.build_stdlib_deployment_targets).intersection( |
| set(args.stdlib_deployment_targets)) |
| else: |
| # Otherwise, this is a host we are building as part of |
| # cross-compiling, so we only need the target itself. |
| stdlib_targets_to_configure = [host_target] |
| stdlib_targets_to_build = set(stdlib_targets_to_configure) |
| |
| # Compute derived information from the arguments. |
| # |
| # FIXME: We should move the platform-derived arguments to be entirely |
| # data driven, so that we can eliminate this code duplication and just |
| # iterate over all supported platforms. |
| platforms_to_skip_build = self.__platforms_to_skip_build(args) |
| platforms_to_skip_test = self.__platforms_to_skip_test(args) |
| platforms_archs_to_skip_test = \ |
| self.__platforms_archs_to_skip_test(args) |
| platforms_to_skip_test_host = self.__platforms_to_skip_test_host(args) |
| |
| # Compute the lists of **CMake** targets for each use case (configure |
| # vs. build vs. run) and the SDKs to configure with. |
| self.sdks_to_configure = set() |
| self.swift_stdlib_build_targets = [] |
| self.swift_test_run_targets = [] |
| self.swift_benchmark_build_targets = [] |
| self.swift_benchmark_run_targets = [] |
| for deployment_target_name in stdlib_targets_to_configure: |
| # Get the target object. |
| deployment_target = StdlibDeploymentTarget.get_target_for_name( |
| deployment_target_name) |
| if deployment_target is None: |
| diagnostics.fatal("unknown target: %r" % ( |
| deployment_target_name,)) |
| |
| # Add the SDK to use. |
| deployment_platform = deployment_target.platform |
| self.sdks_to_configure.add(deployment_platform.sdk_name) |
| |
| # If we aren't actually building this target (only configuring |
| # it), do nothing else. |
| if deployment_target_name not in stdlib_targets_to_build: |
| continue |
| |
| # Compute which actions are desired. |
| build = ( |
| deployment_platform not in platforms_to_skip_build) |
| test = ( |
| deployment_platform not in platforms_to_skip_test) |
| test_host_only = None |
| dt_supports_benchmark = deployment_target.supports_benchmark |
| build_benchmarks = build and dt_supports_benchmark |
| build_external_benchmarks = all([build, dt_supports_benchmark, |
| args.build_external_benchmarks]) |
| |
| # FIXME: Note, `build-script-impl` computed a property here |
| # w.r.t. testing, but it was actually unused. |
| |
| # For platforms which normally require a connected device to |
| # test, the default behavior is to run tests that only require |
| # the host (i.e., they do not attempt to execute). |
| if deployment_platform.uses_host_tests and \ |
| deployment_platform not in \ |
| platforms_to_skip_test_host: |
| test_host_only = True |
| |
| name = deployment_target.name |
| |
| for skip_test_arch in platforms_archs_to_skip_test: |
| if deployment_target.name == skip_test_arch.name: |
| test = False |
| |
| if build: |
| # Validation, long, and stress tests require building the full |
| # standard library, whereas the other targets can build a |
| # slightly smaller subset which is faster to build. |
| if args.build_swift_stdlib_unittest_extra or \ |
| args.validation_test or args.long_test or \ |
| args.stress_test: |
| self.swift_stdlib_build_targets.append( |
| "swift-stdlib-" + name) |
| else: |
| self.swift_stdlib_build_targets.append( |
| "swift-test-stdlib-" + name) |
| if build_benchmarks: |
| self.swift_benchmark_build_targets.append( |
| "swift-benchmark-" + name) |
| if args.benchmark: |
| self.swift_benchmark_run_targets.append( |
| "check-swift-benchmark-" + name) |
| |
| if build_external_benchmarks: |
| # Add support for the external benchmarks. |
| self.swift_benchmark_build_targets.append( |
| "swift-benchmark-{}-external".format(name)) |
| if args.benchmark: |
| self.swift_benchmark_run_targets.append( |
| "check-swift-benchmark-{}-external".format(name)) |
| if test: |
| if test_host_only: |
| suffix = "-only_non_executable" |
| elif args.only_executable_test: |
| suffix = "-only_executable" |
| else: |
| suffix = "" |
| subset_suffix = "" |
| if args.validation_test and args.long_test and \ |
| args.stress_test: |
| subset_suffix = "-all" |
| elif args.validation_test: |
| subset_suffix = "-validation" |
| elif args.long_test: |
| subset_suffix = "-only_long" |
| elif args.stress_test: |
| subset_suffix = "-only_stress" |
| else: |
| subset_suffix = "" |
| self.swift_test_run_targets.append("check-swift{}{}-{}".format( |
| subset_suffix, suffix, name)) |
| if args.test_optimized and not test_host_only: |
| self.swift_test_run_targets.append( |
| "check-swift{}-optimize-{}".format( |
| subset_suffix, name)) |
| if args.test_optimize_for_size and not test_host_only: |
| self.swift_test_run_targets.append( |
| "check-swift{}-optimize_size-{}".format( |
| subset_suffix, name)) |
| if args.test_optimize_none_with_implicit_dynamic and \ |
| not test_host_only: |
| self.swift_test_run_targets.append( |
| "check-swift{}-optimize_none_with_implicit_dynamic-{}" |
| .format(subset_suffix, name)) |
| |
| def __platforms_to_skip_build(self, args): |
| platforms_to_skip_build = set() |
| if not args.build_linux: |
| platforms_to_skip_build.add(StdlibDeploymentTarget.Linux) |
| if not args.build_freebsd: |
| platforms_to_skip_build.add(StdlibDeploymentTarget.FreeBSD) |
| if not args.build_cygwin: |
| platforms_to_skip_build.add(StdlibDeploymentTarget.Cygwin) |
| if not args.build_osx: |
| platforms_to_skip_build.add(StdlibDeploymentTarget.OSX) |
| if not args.build_ios_device: |
| platforms_to_skip_build.add(StdlibDeploymentTarget.iOS) |
| if not args.build_ios_simulator: |
| platforms_to_skip_build.add(StdlibDeploymentTarget.iOSSimulator) |
| if not args.build_tvos_device: |
| platforms_to_skip_build.add(StdlibDeploymentTarget.AppleTV) |
| if not args.build_tvos_simulator: |
| platforms_to_skip_build.add( |
| StdlibDeploymentTarget.AppleTVSimulator) |
| if not args.build_watchos_device: |
| platforms_to_skip_build.add(StdlibDeploymentTarget.AppleWatch) |
| if not args.build_watchos_simulator: |
| platforms_to_skip_build.add( |
| StdlibDeploymentTarget.AppleWatchSimulator) |
| if not args.build_android: |
| platforms_to_skip_build.add(StdlibDeploymentTarget.Android) |
| return platforms_to_skip_build |
| |
| def __platforms_to_skip_test(self, args): |
| platforms_to_skip_test = set() |
| if not args.test_linux: |
| platforms_to_skip_test.add(StdlibDeploymentTarget.Linux) |
| if not args.test_freebsd: |
| platforms_to_skip_test.add(StdlibDeploymentTarget.FreeBSD) |
| if not args.test_cygwin: |
| platforms_to_skip_test.add(StdlibDeploymentTarget.Cygwin) |
| if not args.test_osx: |
| platforms_to_skip_test.add(StdlibDeploymentTarget.OSX) |
| if not args.test_ios_host: |
| platforms_to_skip_test.add(StdlibDeploymentTarget.iOS) |
| else: |
| raise ArgumentError(None, |
| "error: iOS device tests are not " + |
| "supported in open-source Swift.") |
| if not args.test_ios_simulator: |
| platforms_to_skip_test.add(StdlibDeploymentTarget.iOSSimulator) |
| if not args.test_tvos_host: |
| platforms_to_skip_test.add(StdlibDeploymentTarget.AppleTV) |
| else: |
| raise ArgumentError(None, |
| "error: tvOS device tests are not " + |
| "supported in open-source Swift.") |
| if not args.test_tvos_simulator: |
| platforms_to_skip_test.add(StdlibDeploymentTarget.AppleTVSimulator) |
| if not args.test_watchos_host: |
| platforms_to_skip_test.add(StdlibDeploymentTarget.AppleWatch) |
| else: |
| raise ArgumentError(None, |
| "error: watchOS device tests are not " + |
| "supported in open-source Swift.") |
| if not args.test_watchos_simulator: |
| platforms_to_skip_test.add( |
| StdlibDeploymentTarget.AppleWatchSimulator) |
| if not args.test_android: |
| platforms_to_skip_test.add(StdlibDeploymentTarget.Android) |
| |
| return platforms_to_skip_test |
| |
| def __platforms_archs_to_skip_test(self, args): |
| platforms_archs_to_skip_test = set() |
| if not args.test_ios_32bit_simulator: |
| platforms_archs_to_skip_test.add( |
| StdlibDeploymentTarget.iOSSimulator.i386) |
| return platforms_archs_to_skip_test |
| |
| def __platforms_to_skip_test_host(self, args): |
| platforms_to_skip_test_host = set() |
| if not args.test_android_host: |
| platforms_to_skip_test_host.add(StdlibDeploymentTarget.Android) |
| if not args.test_ios_host: |
| platforms_to_skip_test_host.add(StdlibDeploymentTarget.iOS) |
| if not args.test_tvos_host: |
| platforms_to_skip_test_host.add(StdlibDeploymentTarget.AppleTV) |
| if not args.test_watchos_host: |
| platforms_to_skip_test_host.add(StdlibDeploymentTarget.AppleWatch) |
| return platforms_to_skip_test_host |
