SDK Autodetection now happens in build script

springsup · springsup · commit 0b6790ced2ea · 2016-05-30T09:04:10.000+02:00
The old 'swift-sdks' option is migrated for presets
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -469,15 +469,11 @@ function(is_sdk_requested name result_var_name)
   if("${SWIFT_HOST_VARIANT_SDK}" STREQUAL "${name}")
     set("${result_var_name}" "TRUE" PARENT_SCOPE)
   else()
-    if("${SWIFT_SDKS}" STREQUAL "")
-      set("${result_var_name}" "TRUE" PARENT_SCOPE)
+    list(FIND SWIFT_SDKS "${name}" sdk_index)
+    if(${sdk_index} EQUAL -1)
+      set("${result_var_name}" "FALSE" PARENT_SCOPE)
     else()
-      list(FIND SWIFT_SDKS "${name}" sdk_index)
-      if(${sdk_index} EQUAL -1)
-        set("${result_var_name}" "FALSE" PARENT_SCOPE)
-      else()
-        set("${result_var_name}" "TRUE" PARENT_SCOPE)
-      endif()
+      set("${result_var_name}" "TRUE" PARENT_SCOPE)
     endif()
   endif()
 endfunction()
diff --git a/utils/SwiftBuildSupport.py b/utils/SwiftBuildSupport.py
@@ -194,6 +194,35 @@ def get_preset_options(substitutions, preset_file_names, preset_name):
                          "': " + ", ".join(missing_opts))
         sys.exit(1)
 
+    # Migrate 'swift-sdks' parameter to 'stdlib-deployment-targets'
+    for opt in build_script_impl_opts:
+        if opt.startswith("--swift-sdks"):
+            sdksToConfigure = opt.split("=")[1].split(";")
+            tgts = []
+            # Expand SDKs in to their deployment targets
+            from swift_build_support.targets import StdlibDeploymentTarget
+            for sdk in sdksToConfigure:
+                if sdk == "OSX":
+                    tgts += StdlibDeploymentTarget.OSX.allArchs
+                elif sdk == "IOS":
+                    tgts += StdlibDeploymentTarget.iOS.allArchs
+                elif sdk == "IOS_SIMULATOR":
+                    tgts += StdlibDeploymentTarget.iOSSimulator.allArchs
+                elif sdk == "TVOS":
+                    tgts += StdlibDeploymentTarget.AppleTV.allArchs
+                elif sdk == "TVOS_SIMULATOR":
+                    tgts += StdlibDeploymentTarget.AppleTVSimulator.allArchs
+                elif sdk == "WATCHOS":
+                    tgts += StdlibDeploymentTarget.AppleWatch.allArchs
+                elif sdk == "WATCHOS_SIMULATOR":
+                    tgts += StdlibDeploymentTarget.AppleWatchSimulator.allArchs
+
+            build_script_opts.append("--stdlib-deployment-targets=" +
+                                     " ".join(tgts))
+    # Filter the swift-sdks parameter
+    build_script_impl_opts = [opt for opt in build_script_impl_opts
+                              if not opt.startswith("--swift-sdks")]
+
     return build_script_opts + ["--"] + build_script_impl_opts
 
 
diff --git a/utils/build-script b/utils/build-script
@@ -47,6 +47,7 @@ from swift_build_support import products  # noqa (E402)
 from swift_build_support import shell  # noqa (E402)
 import swift_build_support.tar        # noqa (E402)
 import swift_build_support.targets    # noqa (E402)
+from swift_build_support.targets import StdlibDeploymentTarget  # noqa (E402)
 from swift_build_support.cmake import CMake  # noqa (E402)
 from swift_build_support.workspace import Workspace  # noqa(E402)
 from swift_build_support.workspace import compute_build_subdir  # noqa(E402)
@@ -353,13 +354,13 @@ details of the setups of other systems or automated environments.""")
         help="The host target. LLVM, Clang, and Swift will be built for this "
              "target. The built LLVM and Clang will be used to compile Swift "
              "for the cross-compilation targets.",
-        default=swift_build_support.targets.host_target())
+        default=StdlibDeploymentTarget.host_target())
     targets_group.add_argument(
         "--stdlib-deployment-targets",
         help="list of targets to compile or cross-compile the Swift standard "
              "library for. %(default)s by default.",
         nargs="*",
-        default=swift_build_support.targets.stdlib_deployment_targets())
+        default=StdlibDeploymentTarget.default_stdlib_deployment_targets())
 
     projects_group = parser.add_argument_group(
         title="Options to select projects")
@@ -1226,6 +1227,11 @@ details of the setups of other systems or automated environments.""")
     if args.build_subdir is None:
         args.build_subdir = compute_build_subdir(args)
 
+    # Add optional stdlib-deployment-targets
+    if args.android:
+        args.stdlib_deployment_targets.append(
+            StdlibDeploymentTarget.Android.armv7)
+
     workspace = Workspace(
         source_root=SWIFT_SOURCE_ROOT,
         build_root=os.path.join(SWIFT_BUILD_ROOT, args.build_subdir))
diff --git a/utils/swift_build_support/swift_build_support/targets.py b/utils/swift_build_support/swift_build_support/targets.py
@@ -12,98 +12,127 @@
 import platform
 
 
-def host_target():
-    """
-    Return the build target for the current host machine, if it is one of the
-    recognized targets. Otherwise, return None.
-    """
-    system = platform.system()
-    machine = platform.machine()
-
-    if system == 'Linux':
-        if machine == 'x86_64':
-            return 'linux-x86_64'
-        elif machine.startswith('armv7'):
-            # linux-armv7* is canonicalized to 'linux-armv7'
-            return 'linux-armv7'
-        elif machine.startswith('armv6'):
-            # linux-armv6* is canonicalized to 'linux-armv6'
-            return 'linux-armv6'
-        elif machine == 'aarch64':
-            return 'linux-aarch64'
-        elif machine == 'ppc64':
-            return 'linux-powerpc64'
-        elif machine == 'ppc64le':
-            return 'linux-powerpc64le'
-        elif machine == 's390x':
-            return 'linux-s390x'
-
-    elif system == 'Darwin':
-        if machine == 'x86_64':
-            return 'macosx-x86_64'
-
-    elif system == 'FreeBSD':
-        if machine == 'amd64':
-            return 'freebsd-x86_64'
-
-    elif system == 'CYGWIN_NT-10.0':
-        if machine == 'x86_64':
-            return 'cygwin-x86_64'
-
-    return None
-
-
-def stdlib_deployment_targets():
-    """
-    Return deployment targets for the Swift stdlib, based on the host machine.
-    If the host machine is not one of the recognized ones, return None.
-    """
-    system = platform.system()
-    machine = platform.machine()
-
-    if system == 'Linux':
-        if machine == 'x86_64':
-            return [
-                'linux-x86_64',
-                'android-armv7',
-            ]
-        elif machine.startswith('armv6'):
-            # linux-armv6* is canonicalized to 'linux-armv6'
-            return ['linux-armv6']
-        elif machine.startswith('armv7'):
-            # linux-armv7* is canonicalized to 'linux-armv7'
-            return ['linux-armv7']
-        elif machine == 'aarch64':
-            return ['linux-aarch64']
-        elif machine == 'ppc64':
-            return ['linux-powerpc64']
-        elif machine == 'ppc64le':
-            return ['linux-powerpc64le']
-        elif machine == 's390x':
-            return ['linux-s390x']
-    elif system == 'Darwin':
-        if machine == 'x86_64':
-            return [
-                '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',
-            ]
-    elif system == 'FreeBSD':
-        if machine == 'amd64':
-            return ['freebsd-x86_64']
-    elif system == 'CYGWIN_NT-10.0':
-        if machine == 'x86_64':
-            return ['cygwin-x86_64']
-
-    return None
+class StdlibDeploymentTarget(object):
+
+    class OSX(object):
+        x86_64 = 'macosx-x86_64'
+        allArchs = [x86_64]
+
+    class iOS(object):
+        armv7 = 'iphoneos-armv7'
+        armv7s = 'iphoneos-armv7s'
+        arm64 = 'iphoneos-arm64'
+        allArchs = [armv7, armv7s, arm64]
+
+    class iOSSimulator(object):
+        i386 = 'iphonesimulator-i386'
+        x86_64 = 'iphonesimulator-x86_64'
+        allArchs = [i386, x86_64]
+
+    class AppleTV(object):
+        arm64 = 'appletvos-arm64'
+        allArchs = [arm64]
+
+    class AppleTVSimulator(object):
+        x86_64 = 'appletvsimulator-x86_64'
+        allArchs = [x86_64]
+
+    class AppleWatch(object):
+        armv7k = 'watchos-armv7k'
+        allArchs = [armv7k]
+
+    class AppleWatchSimulator(object):
+        i386 = 'watchsimulator-i386'
+        allArchs = [i386]
+
+    class Linux(object):
+        x86_64 = 'linux-x86_64'
+        armv6 = 'linux-armv6'
+        armv7 = 'linux-armv7'
+        aarch64 = 'linux-aarch64'
+        ppc64 = 'linux-ppc64'
+        ppc64le = 'linux-ppc64le'
+        s390x = 'linux-s390x'
+        allArchs = [x86_64, armv6, armv7, aarch64, ppc64, ppc64le, s390x]
+
+    class FreeBSD(object):
+        amd64 = 'freebsd-x86_64'
+        allArchs = [amd64]
+
+    class Cygwin(object):
+        x86_64 = 'cygwin-x86_64'
+        allArchs = [x86_64]
+
+    class Android(object):
+        armv7 = 'android-armv7'
+        allArchs = [armv7]
+
+    @staticmethod
+    def host_target():
+        """
+        Return the host target for the build machine, if it is one of
+        the recognized targets. Otherwise, return None.
+        """
+        system = platform.system()
+        machine = platform.machine()
+
+        if system == 'Linux':
+            if machine == 'x86_64':
+                return StdlibDeploymentTarget.Linux.x86_64
+            elif machine.startswith('armv7'):
+                # linux-armv7* is canonicalized to 'linux-armv7'
+                return StdlibDeploymentTarget.Linux.armv7
+            elif machine.startswith('armv6'):
+                # linux-armv6* is canonicalized to 'linux-armv6'
+                return StdlibDeploymentTarget.Linux.armv6
+            elif machine == 'aarch64':
+                return StdlibDeploymentTarget.Linux.aarch64
+            elif machine == 'ppc64':
+                return StdlibDeploymentTarget.Linux.ppc64
+            elif machine == 'ppc64le':
+                return StdlibDeploymentTarget.Linux.ppc64le
+            elif machine == 's390x':
+                return StdlibDeploymentTarget.Linux.s390x
+
+        elif system == 'Darwin':
+            if machine == 'x86_64':
+                return StdlibDeploymentTarget.OSX.x86_64
+
+        elif system == 'FreeBSD':
+            if machine == 'amd64':
+                return StdlibDeploymentTarget.FreeBSD.amd64
+
+        elif system == 'CYGWIN_NT-10.0':
+            if machine == 'x86_64':
+                return StdlibDeploymentTarget.Cygwin.x86_64
+
+        return None
+
+    @staticmethod
+    def default_stdlib_deployment_targets():
+        """
+        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()
+        if host_target is None:
+            return None
+
+        # OSX build machines configure all Darwin platforms by default.
+        # Put iOS native targets last so that we test them last
+        # (it takes a long time).
+        if host_target == StdlibDeploymentTarget.OSX.x86_64:
+            return [host_target] + \
+                StdlibDeploymentTarget.iOSSimulator.allArchs + \
+                StdlibDeploymentTarget.AppleTVSimulator.allArchs + \
+                StdlibDeploymentTarget.AppleWatchSimulator.allArchs + \
+                StdlibDeploymentTarget.iOS.allArchs + \
+                StdlibDeploymentTarget.AppleTV.allArchs + \
+                StdlibDeploymentTarget.AppleWatch.allArchs
+        else:
+            # All other machines only configure their host stdlib by default.
+            return [host_target]
 
 
 def install_prefix():
diff --git a/utils/swift_build_support/tests/test_targets.py b/utils/swift_build_support/tests/test_targets.py
@@ -10,12 +10,12 @@
 
 import unittest
 
-from swift_build_support.targets import host_target
+from swift_build_support.targets import StdlibDeploymentTarget
 
 
 class HostTargetTestCase(unittest.TestCase):
     def test_is_not_none_on_this_platform(self):
-        self.assertIsNotNone(host_target())
+        self.assertIsNotNone(StdlibDeploymentTarget.host_target())
 
 
 if __name__ == '__main__':
