[CMake/Tests] CMake and lit.cfg support for running macCatalyst tests

Add support for testing with macCatalyst to lit.cfg and the test CMake.

This adds lit test features for whether the standard library and runtime was
built with macCatalyst support:

  REQUIRES: maccatalyst_support

The test suite can also be run in two modes: one where the macOS tests
are run as usual (against a zippered standard library, runtime, and overlays)
and another where iOS tests are compiled with the macCatalyst target
triple and executed as macCatalyst processes.

The iOS tests for macCatalyst can be run by passing `--maccatalyst-ios-tests`
to build-script. There are new lit test features to enable a test to specify
whether it supports that environment:

  REQUIRES: OS=maccatalyst
  UNSUPPORTED: OS=macCatalyst

Author: devincoughlin

test/CMakeLists.txt

@@ -163,10 +163,28 @@ endif()
 
 foreach(SDK ${SWIFT_SDKS})
   foreach(ARCH ${SWIFT_SDK_${SDK}_ARCHITECTURES})
+    # macCatalyst needs to run two sets of tests: one with the normal macosx target triple
+    # and one with the the macCatalyst ios-macabi triple.  The build_flavors list will
+    # have have only the "default" flavor for all SDKs and architectures except
+    # OSX when macCatalyst support is enabled.
+    set(build_flavors "default")
+    if(SWIFT_ENABLE_MACCATALYST AND "${SDK}" STREQUAL "OSX")
+      list(APPEND build_flavors "ios-like" )
+    endif()
+
+    foreach(BUILD_FLAVOR ${build_flavors})
     # Configure variables for this subdirectory.
     set(VARIANT_SUFFIX "-${SWIFT_SDK_${SDK}_LIB_SUBDIR}-${ARCH}")
     set(VARIANT_TRIPLE "${SWIFT_SDK_${SDK}_ARCH_${ARCH}_TRIPLE}${SWIFT_SDK_${SDK}_DEPLOYMENT_VERSION}")
     set(VARIANT_SDK "${SWIFT_SDK_${SDK}_ARCH_${ARCH}_PATH}")
+    set(DEFAULT_OSX_VARIANT_SUFFIX "")
+
+    if(BUILD_FLAVOR STREQUAL "ios-like")
+      set(DEFAULT_OSX_VARIANT_SUFFIX "${VARIANT_SUFFIX}")
+      # Use the macCatalyst target triple and compiler resources for the iOS-like build flavor.
+      set(VARIANT_SUFFIX "-${SWIFT_SDK_${SDK}_LIB_SUBDIR}-maccatalyst-${ARCH}")
+      set(VARIANT_TRIPLE "${ARCH}-apple-ios13.0-macabi")
+    endif()
 
     # A directory where to put the xUnit-style XML test results.
     set(SWIFT_TEST_RESULTS_DIR
@@ -232,8 +250,17 @@ _Block_release(void) { }\n")
     if(SWIFT_BUILD_STDLIB AND SWIFT_INCLUDE_TESTS)
       list(APPEND test_dependencies
           "swift-test-stdlib-${SWIFT_SDK_${SDK}_LIB_SUBDIR}")
-      list(APPEND test_dependencies
-          "swift-reflection-test${VARIANT_SUFFIX}_signed")
+
+      if(BUILD_FLAVOR STREQUAL "ios-like")
+        # When testing the iOS-like build flavor, use the the normal macOS
+        # swift-reflection-test-tool. That tool runs out of process so it
+        # doesn't need to be build for macCatalyst.
+        list(APPEND test_dependencies
+            "swift-reflection-test${DEFAULT_OSX_VARIANT_SUFFIX}")
+      else()
+        list(APPEND test_dependencies
+            "swift-reflection-test${VARIANT_SUFFIX}_signed")
+      endif()
     endif()
 
     if(NOT "${COVERAGE_DB}" STREQUAL "")
@@ -391,6 +418,7 @@ _Block_release(void) { }\n")
       endforeach()
     endforeach()
   endforeach()
+  endforeach()
 endforeach()
 
 # Add shortcuts for the default variant.

test/lit.cfg

@@ -319,6 +319,10 @@ lit_config.note('Using resource dir: ' + test_resource_dir)
 
 # Parse the variant triple.
 (run_cpu, run_vendor, run_os, run_vers) = re.match('([^-]+)-([^-]+)-([^0-9]+)(.*)', config.variant_triple).groups()
+if run_os == 'ios' and run_vers.endswith('-macabi'):
+    run_vers = run_vers[0:-len('-macabi')]
+    run_os = 'maccatalyst'
+
 run_ptrsize = '64' if ('64' in run_cpu or run_cpu == "s390x") else '32'
 run_endian = 'little' if run_cpu != 's390x' else 'big'
 
@@ -602,7 +606,12 @@ if config.benchmark_o != 'Benchmark_O':
 config.substitutions.append(('%target-triple', config.variant_triple))
 
 if run_vendor == 'apple':
-    if True:
+    if run_os == 'maccatalyst':
+        config.stable_abi_triple = '%s-%s-ios13.0-macabi' % (run_cpu, run_vendor)
+        config.pre_stable_abi_triple = config.stable_abi_triple
+        config.next_stable_abi_triple = config.stable_abi_triple
+        config.available_features.add('swift_stable_abi')
+    else:
         # iOS 12.2 does not support 32-bit targets, so we cannot run tests that
         # want to deploy to an iOS that has Swift in the OS.
         if run_os == 'ios' and run_ptrsize == '32':
@@ -612,6 +621,7 @@ if run_vendor == 'apple':
             PRE_STABLE_VERSION = {
                 'macosx': '10.14.3',
                 'ios': '12.1',
+                'maccatalyst': '12.1',
                 'tvos': '12.1',
                 'watchos': '5.1'
             }
@@ -622,6 +632,7 @@ if run_vendor == 'apple':
         STABLE_VERSION = {
             'macosx': '10.14.4',
             'ios': '12.2',
+            'maccatalyst': '12.2',
             'tvos': '12.2',
             'watchos': '5.2'
         }
@@ -632,6 +643,7 @@ if run_vendor == 'apple':
         NEXT_STABLE_VERSION = {
             'macosx': '10.15',
             'ios': '13',
+            'maccatalyst': '13',
             'tvos': '13',
             'watchos': '6'
         }
@@ -668,6 +680,17 @@ config.substitutions.append(('%sanitizers-target-triple',
     config.variant_triple.replace("ios7", "ios8")))
 
 config.substitutions.append(('%target-cpu', run_cpu))
+
+target_os_abi = run_os
+target_os_is_maccatalyst = "FALSE"
+if (run_os == 'maccatalyst'):
+  # For purposes of ABI, treat maccatalyst as macosx since the maccatalyst ABI
+  # must match the macosx ABI.
+  target_os_abi = 'macosx'
+  target_os_is_maccatalyst = "TRUE"
+  config.available_features.add("OS=ios")
+config.substitutions.append(('%target-os-abi', target_os_abi))
+config.substitutions.append(('%target-os-is-maccatalyst', target_os_is_maccatalyst))
 config.substitutions.append(('%target-endian', run_endian))
 config.substitutions.append(('%target-os', run_os))
 config.substitutions.append(('%target-ptrsize', run_ptrsize))
@@ -703,7 +726,12 @@ if 'swift_interpreter' in config.available_features:
 
 config.target_runtime = "unknown"
 
-swift_reflection_test_name = 'swift-reflection-test' + config.variant_suffix
+if (getattr(config, 'darwin_enable_maccatalyst', False) and
+    config.darwin_maccatalyst_build_flavor == "ios-like"):
+    variant_suffix = config.darwin_osx_variant_suffix
+else:
+    variant_suffix = config.variant_suffix
+swift_reflection_test_name = 'swift-reflection-test' + variant_suffix
 
 def use_interpreter_for_simple_runs():
     def make_simple_target_run(gyb=False, stdlib=False, parameterized=False):
@@ -858,25 +886,49 @@ if run_vendor == 'apple':
             lit_config.fatal('Could not get or decode sw_vers output. ' +
                              'Perhaps the simulator is not working.')
 
-    elif run_os == 'macosx':
+    elif run_os == 'macosx' or run_os == 'maccatalyst':
         # OS X
         lit_config.note("Testing OS X " + config.variant_triple)
 
         xcrun_sdk_name = "macosx"
-        config.target_cc_options = (
-            "-arch %s -m%s-version-min=%s %s" %
-            (run_cpu, run_os, run_vers, clang_mcp_opt))
+
+        if run_os == 'maccatalyst':
+            # For maccatalyst, pass the target triple to clang
+            # rather than arch and version separately.
+            config.target_cc_options = (
+                "-target %s %s" %
+                (config.variant_triple, clang_mcp_opt))
+        else:
+            config.target_cc_options = (
+                "-arch %s -m%s-version-min=%s %s" %
+                (run_cpu, run_os, run_vers, clang_mcp_opt))
+
+        maccatalyst_frameworks_component = ""
+        if run_os == 'maccatalyst':
+            # Additional framework search paths for macCatalyst.
+            # These have to come before other search paths so that for
+            # unzippered twin frameworks the unzippered twin version
+            # is favored under macCatalyst.
+          maccatalyst_frameworks_dir = make_path(config.variant_sdk,
+                 "System", "iOSSupport", "System", "Library", "Frameworks")
+          maccatalyst_frameworks_component = ( "-F %r" % maccatalyst_frameworks_dir )
+            # Module triples end in ios-macabi.
+          target_specific_module_triple = '{}-apple-ios-macabi'.format(
+              { 'aarch64': 'arm64', 'amd64': 'x86_64' }.get(run_cpu, run_cpu)
+          )
 
         config.target_build_swift = (
-            ("%s %s %s -F %r -toolchain-stdlib-rpath "
+            ("%s %s %s %s -F %r -toolchain-stdlib-rpath "
              + "-Xlinker -rpath -Xlinker %r %s %s %s %s "
              + "-F %r -Xlinker -rpath -Xlinker %r")
             % (xcrun_prefix, config.swiftc, target_options,
+               maccatalyst_frameworks_component,
                extra_frameworks_dir, extra_frameworks_dir,
                sdk_overlay_linker_opt, config.swift_test_options,
                config.swift_driver_test_options,
                swift_execution_tests_extra_flags, sourcekitd_framework_dir,
                sourcekitd_framework_dir))
+
         config.target_run = ""
         target_future_version = "10.99"
 
@@ -896,9 +948,13 @@ if run_vendor == 'apple':
 
     config.target_sdk_name = xcrun_sdk_name
     config.target_ld = "%s ld -L%r" % (xcrun_prefix, make_path(test_resource_dir, config.target_sdk_name))
+
+    maccatalyst_extra_frameworks = ""
+    if run_os == 'maccatalyst':
+        maccatalyst_extra_frameworks = "-F {}/System/iOSSupport/System/Library/Frameworks".format(config.variant_sdk)
     config.target_swift_frontend = (
-        "%s -frontend %s -sdk %r %s %s" %
-        (config.swiftc, target_options, config.variant_sdk,
+        "%s -frontend %s -sdk %r %s %s %s" %
+        (config.swiftc, target_options, config.variant_sdk, maccatalyst_extra_frameworks,
          config.swift_test_options, config.swift_frontend_test_options))
     subst_target_swift_frontend_mock_sdk = (
         "%s -frontend %s -sdk %r %s %s" %
@@ -940,6 +996,7 @@ if run_vendor == 'apple':
     config.target_add_rpath = r'-Xlinker -rpath -Xlinker \1'
 
     target_future = format('%s-apple-%s%s' % (run_cpu, run_os, target_future_version))
+    config.otool_classic = ("%s otool-classic" % (xcrun_prefix))
 
 elif run_os in ['windows-msvc']:
     lit_config.note('Testing Windows ' + config.variant_triple)
@@ -1480,6 +1537,13 @@ if platform.system() != 'Darwin' or swift_test_mode == 'optimize_none_with_impli
 platform_module_dir = make_path(test_resource_dir, config.target_sdk_name)
 if run_vendor != 'apple':
     platform_module_dir = make_path(platform_module_dir, run_cpu)
+
+platform_dylib_dir = platform_module_dir
+if run_os == 'maccatalyst' and config.darwin_maccatalyst_build_flavor == "ios-like":
+    # When using the ios-macabi triple, look for module files
+    # in the 'maccatalyst' compiler resource directory.
+    platform_module_dir = make_path(test_resource_dir, 'maccatalyst')
+
 lit_config.note('Using platform module dir: ' + platform_module_dir)
 if test_sdk_overlay_dir:
     platform_sdk_overlay_dir = test_sdk_overlay_dir
@@ -1496,10 +1560,15 @@ if os.path.exists(static_libswiftCore_path):
 
 # Set up testing with the standard libraries coming from the OS / just-built libraries
 # default Swift tests to use the just-built libraries
-target_stdlib_path = platform_module_dir
+target_stdlib_path = platform_dylib_dir
 if not kIsWindows:
 	libdispatch_path = getattr(config, 'libdispatch_artifact_dir', '')
 	if 'use_os_stdlib' not in lit_config.params:
+		if run_os == 'maccatalyst':
+		    # Under macCatalyst we need to have the unzippered twin dylib dir come before
+		    # the zippered/macosx dylib dir so that unzippered twins are picked upload_dylibs
+		    # before the macOS variant.
+		    target_stdlib_path = "{0}:{1}".format(platform_module_dir, target_stdlib_path)
 		lit_config.note('Testing with the just-built libraries at ' + target_stdlib_path)
 		config.target_run = (
 			"/usr/bin/env "
@@ -1513,6 +1582,8 @@ if not kIsWindows:
 		if run_vendor == 'apple':
 			#If we get swift-in-the-OS for non-Apple platforms, add a condition here
 			os_stdlib_path = "/usr/lib/swift"
+			if run_os == 'maccatalyst':
+			    os_stdlib_path = "/System/iOSSupport/usr/lib/swift:/usr/lib/swift"
 		all_stdlib_path = os.path.pathsep.join((os_stdlib_path, target_stdlib_path))
 		lit_config.note('Testing with the standard libraries coming from the OS ' + all_stdlib_path)
 		config.target_run = (
@@ -1667,6 +1738,8 @@ config.substitutions.append(('%target-swift-emit-pcm',
 
 config.substitutions.insert(0, ('%platform-module-dir', platform_module_dir))
 config.substitutions.insert(0, ('%platform-sdk-overlay-dir', platform_sdk_overlay_dir))
+config.substitutions.insert(0, ('%platform-dylib-dir', platform_dylib_dir))
+config.substitutions.insert(0, ('%test-resource-dir', test_resource_dir))
 
 if run_vendor != 'apple':
     extra_frameworks_dir = ''
@@ -1690,6 +1763,9 @@ config.substitutions.append(('%target-resilience-test', config.target_resilience
 config.substitutions.append(('%llvm-profdata', config.llvm_profdata))
 config.substitutions.append(('%llvm-cov', config.llvm_cov))
 
+if hasattr(config, 'otool_classic'):
+    config.substitutions.append(('%otool-classic', config.otool_classic))
+
 config.substitutions.append(('%FileCheck',
                              '%r %r --sanitize BUILD_DIR=%r --sanitize SOURCE_DIR=%r --use-filecheck %r %s' % (
         sys.executable,

test/lit.site.cfg.in

@@ -51,6 +51,10 @@ msvc_runtime_flags = {
 config.swift_stdlib_msvc_runtime = \
     msvc_runtime_flags["@SWIFT_STDLIB_MSVC_RUNTIME_LIBRARY@"]
 
+config.darwin_enable_maccatalyst = "@SWIFT_ENABLE_MACCATALYST@" == "TRUE"
+config.darwin_maccatalyst_build_flavor = "@BUILD_FLAVOR@"
+config.darwin_osx_variant_suffix = "@DEFAULT_OSX_VARIANT_SUFFIX@"
+
 # Please remember to handle empty strings and/or unset variables correctly.
 
 if "@SWIFT_ASAN_BUILD@" == "TRUE":
@@ -103,6 +107,9 @@ if "@CMAKE_GENERATOR@" == "Xcode":
 
 config.available_features.add("CMAKE_GENERATOR=@CMAKE_GENERATOR@")
 
+if "@SWIFT_ENABLE_MACCATALYST@" == "TRUE":
+    config.available_features.add('maccatalyst_support')
+
 if "@SWIFT_BUILD_SYNTAXPARSERLIB@" == "TRUE":
     config.available_features.add('syntax_parser_lib')
 

utils/build-script

@@ -599,6 +599,8 @@ class BuildScriptInvocation(object):
         # Enable macCatalyst
         if args.maccatalyst:
             args.extra_cmake_options.append('-DSWIFT_ENABLE_MACCATALYST:BOOL=TRUE')
+        if args.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.

utils/build-script-impl

@@ -175,6 +175,7 @@ KNOWN_SETTINGS=(
     skip-test-linux                               ""                "set to skip testing Swift stdlibs for Linux"
     skip-test-llbuild                             ""                "set to skip testing llbuild"
     skip-test-lldb                                ""                "set to skip testing lldb"
+    skip-test-maccatalyst                         ""                "set to skip testing Swift stdlibs for macCatalyst"
     skip-test-osx                                 ""                "set to skip testing Swift stdlibs for OS X"
     skip-test-playgroundsupport                   ""                "set to skip testing PlaygroundSupport"
     skip-test-swift                               ""                "set to skip testing Swift"

utils/build_swift/build_swift/driver_arguments.py

@@ -338,6 +338,9 @@ def create_argument_parser():
     option('--maccatalyst', toggle_true,
            help='Enable building Swift with macCatalyst support')
 
+    option('--maccatalyst-ios-tests', toggle_true,
+           help='When building for macCatalyst run tests with iOS-like target triple')
+
     option('--android', toggle_true,
            help='also build for Android')
 

utils/swift_build_support/swift_build_support/host_specific_configuration.py

@@ -149,8 +149,15 @@ def __init__(self, host_target, args):
                     subset_suffix = "-only_stress"
                 else:
                     subset_suffix = ""
-                self.swift_test_run_targets.append("check-swift{}{}-{}".format(
-                    subset_suffix, suffix, name))
+
+                # Support for running the macCatalyst tests with
+                # the iOS-like target triple.
+                if name == "macosx-x86_64" and args.maccatalyst and args.maccatalyst_ios_tests:
+                    self.swift_test_run_targets.append("check-swift{}{}-{}".format(
+                        subset_suffix, suffix, "macosx-maccatalyst-x86_64"))
+                else:
+                    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(