Merge remote-tracking branch 'upstream/master' into explicit_true

Author: texasmichelle

CMakeLists.txt

@@ -458,6 +458,12 @@ if(SWIFT_PATH_TO_CMARK_BUILD)
 endif()
 message(STATUS "")
 
+if("${SWIFT_NATIVE_LLVM_TOOLS_PATH}" STREQUAL "")
+  set(SWIFT_CROSS_COMPILING FALSE)
+else()
+  set(SWIFT_CROSS_COMPILING TRUE)
+endif()
+
 include(SwiftSharedCMakeConfig)
 
 # NOTE: We include this before SwiftComponents as it relies on some LLVM CMake

README.md

@@ -241,7 +241,7 @@ various products. These incremental builds are a big timesaver when developing
 and debugging.
 
     cd ${SWIFT_BUILD_DIR}
-    ninja swift
+    ninja swift-frontend
 
 This will build the Swift compiler, but will not rebuild the standard library or
 any other target. Building the `swift-stdlib` target as an additional layer of
@@ -258,7 +258,7 @@ To open the Swift project in Xcode, open `${SWIFT_BUILD_DIR}/Swift.xcodeproj`.
 It will auto-create a *lot* of schemes for all of the available targets. A
 common debug flow would involve:
 
- - Select the 'swift' scheme.
+ - Select the 'swift-frontend' scheme.
  - Pull up the scheme editor (⌘⇧<).
  - Select the 'Arguments' tab and click the '+'.
  - Add the command line options.

benchmark/cmake/modules/AddSwiftBenchmarkSuite.cmake

@@ -105,7 +105,7 @@ macro(configure_build)
 endmacro()
 
 macro(configure_sdks_darwin)
-  set(macosx_arch "x86_64")
+  set(macosx_arch "x86_64" "arm64")
   set(iphoneos_arch "arm64" "arm64e" "armv7")
   set(appletvos_arch "arm64")
   set(watchos_arch "armv7k")
@@ -609,11 +609,7 @@ function (swift_benchmark_compile_archopts)
 
   if(is_darwin)
     # If host == target.
-    if("${BENCH_COMPILE_ARCHOPTS_PLATFORM}" STREQUAL "macosx")
-      set(OUTPUT_EXEC "${benchmark-bin-dir}/Benchmark_${BENCH_COMPILE_ARCHOPTS_OPT}")
-    else()
-      set(OUTPUT_EXEC "${benchmark-bin-dir}/Benchmark_${BENCH_COMPILE_ARCHOPTS_OPT}-${target}")
-    endif()
+    set(OUTPUT_EXEC "${benchmark-bin-dir}/Benchmark_${BENCH_COMPILE_ARCHOPTS_OPT}-${target}")
   else()
     # If we are on Linux, we do not support cross compiling.
     set(OUTPUT_EXEC "${benchmark-bin-dir}/Benchmark_${BENCH_COMPILE_ARCHOPTS_OPT}")

benchmark/scripts/Benchmark_Driver

@@ -73,7 +73,25 @@ class BenchmarkDriver(object):
     def test_harness(self):
         """Full path to test harness binary."""
         suffix = self.args.optimization if hasattr(self.args, "optimization") else "O"
-        return os.path.join(self.args.tests, "Benchmark_" + suffix)
+        if hasattr(self.args, "architecture") and self.args.architecture:
+            suffix += "-" + self.args.architecture + "*"
+        pattern = os.path.join(self.args.tests, "Benchmark_" + suffix)
+        executables = []
+        if hasattr(self._subprocess, "test_mode") and self._subprocess.test_mode:
+            executables = [pattern]
+        else:
+            executables = glob.glob(pattern)
+        if len(executables) == 0:
+            raise ValueError(
+                "No benchmark executable for file name pattern " +
+                pattern + " found")
+        if len(executables) > 1:
+            raise ValueError(
+                "Multiple benchmark executables for file name pattern " +
+                pattern + " found\n" +
+                str(executables) +
+                "\nSpecify the architecture to select the right benchmark executable")
+        return executables[0]
 
     def _git(self, cmd):
         """Execute the Git command in the `swift-repo`."""

benchmark/scripts/run_smoke_bench

@@ -48,12 +48,13 @@ VERBOSE = False
 class DriverArgs(object):
     """Arguments for BenchmarkDriver."""
 
-    def __init__(self, tests, optimization="O"):
+    def __init__(self, tests, optimization="O", architecture=None):
         """Initialize with path to the build-dir and optimization level."""
         self.benchmarks = None
         self.filters = None
         self.tests = os.path.join(tests, "bin")
         self.optimization = optimization
+        self.architecture = architecture
 
 
 def log(msg):
@@ -126,6 +127,12 @@ def main():
         help="The number of re-runs until it's assumed to be a real change",
         default=8,
     )
+    argparser.add_argument(
+        "-arch",
+        type=str,
+        help="The architecture. The default is x86_64",
+        default="x86_64",
+    )
     argparser.add_argument(
         "-platform", type=str, help="The benchmark build platform", default="macosx"
     )
@@ -158,6 +165,7 @@ def test_opt_levels(args):
                 args.num_samples,
                 args.num_reruns,
                 output_file,
+                args.arch
             ):
                 changes = True
 
@@ -167,6 +175,7 @@ def test_opt_levels(args):
                 opt_level,
                 args.oldbuilddir[0],
                 args.newbuilddir[0],
+                args.arch,
                 args.platform,
                 output_file,
             ):
@@ -177,6 +186,7 @@ def test_opt_levels(args):
             "swiftlibs",
             args.oldbuilddir[0],
             args.newbuilddir[0],
+            args.arch,
             args.platform,
             output_file,
         ):
@@ -221,7 +231,8 @@ def merge(results, other_results):
 
 
 def test_performance(
-    opt_level, old_dir, new_dir, threshold, num_samples, num_reruns, output_file
+    opt_level, old_dir, new_dir, threshold, num_samples, num_reruns,
+    output_file, arch
 ):
     """Detect performance changes in benchmarks.
 
@@ -231,7 +242,7 @@ def test_performance(
 
     i, unchanged_length_count = 0, 0
     old, new = [
-        BenchmarkDriver(DriverArgs(dir, optimization=opt_level))
+        BenchmarkDriver(DriverArgs(dir, optimization=opt_level, architecture=arch))
         for dir in [old_dir, new_dir]
     ]
     results = [measure(driver, driver.tests, i) for driver in [old, new]]
@@ -260,12 +271,13 @@ def test_performance(
     )
 
 
-def report_code_size(opt_level, old_dir, new_dir, platform, output_file):
+def report_code_size(opt_level, old_dir, new_dir, architecture, platform, output_file):
     if opt_level == "swiftlibs":
         files = glob.glob(os.path.join(old_dir, "lib", "swift", platform, "*.dylib"))
     else:
         files = glob.glob(
-            os.path.join(old_dir, opt_level + "-*" + platform + "*", "*.o")
+            os.path.join(old_dir, opt_level + "-" + architecture + "*" +
+                         platform + "*", "*.o")
         )
 
     idx = 1
@@ -370,8 +382,8 @@ performance team (@eeckstein).
 
 
 def check_added(args, output_file=None):
-    old = BenchmarkDriver(DriverArgs(args.oldbuilddir[0]))
-    new = BenchmarkDriver(DriverArgs(args.newbuilddir[0]))
+    old = BenchmarkDriver(DriverArgs(args.oldbuilddir[0], architecture=args.arch))
+    new = BenchmarkDriver(DriverArgs(args.newbuilddir[0], architecture=args.arch))
     added = set(new.tests).difference(set(old.tests))
     new.tests = list(added)
     doctor = BenchmarkDoctor(args, driver=new)

benchmark/scripts/test_Benchmark_Driver.py

@@ -198,6 +198,9 @@ def record_and_respond(self, args, stdin, stdout, stderr, shell):
         self.calls.append(args)
         return self.respond.get(args, "")
 
+    def test_mode():
+        return True
+
 
 class TestBenchmarkDriverInitialization(unittest.TestCase):
     def setUp(self):
@@ -206,13 +209,19 @@ def setUp(self):
 
     def test_test_harness(self):
         self.assertEqual(
-            BenchmarkDriver(self.args, tests=["ignored"]).test_harness,
+            BenchmarkDriver(
+                self.args,
+                tests=["ignored"],
+                _subprocess=self.subprocess_mock).test_harness,
             "/benchmarks/Benchmark_O",
         )
         self.args.tests = "/path"
         self.args.optimization = "Suffix"
         self.assertEqual(
-            BenchmarkDriver(self.args, tests=["ignored"]).test_harness,
+            BenchmarkDriver(
+                self.args,
+                tests=["ignored"],
+                _subprocess=self.subprocess_mock).test_harness,
             "/path/Benchmark_Suffix",
         )
 
@@ -271,6 +280,7 @@ def test_log_file(self):
                 swift_repo=None,
             ),
             tests=["ignored"],
+            _subprocess=self.subprocess_mock
         )
         self.assertEqual(driver.log_file, "/path/Benchmark_Suffix-" + now + ".log")
 

cmake/modules/DarwinSDKs.cmake

@@ -4,17 +4,17 @@ option(SWIFT_ENABLE_IOS32
 
 if(SWIFT_ENABLE_IOS32)
 set(SUPPORTED_IOS_ARCHS "armv7;armv7s;arm64;arm64e")
-set(SUPPORTED_IOS_SIMULATOR_ARCHS "i386;x86_64")
+set(SUPPORTED_IOS_SIMULATOR_ARCHS "i386;x86_64;arm64")
 else()
 set(SUPPORTED_IOS_ARCHS "arm64;arm64e")
-set(SUPPORTED_IOS_SIMULATOR_ARCHS "x86_64")
+set(SUPPORTED_IOS_SIMULATOR_ARCHS "x86_64;arm64")
 endif()
 
 set(SUPPORTED_TVOS_ARCHS "arm64")
-set(SUPPORTED_TVOS_SIMULATOR_ARCHS "x86_64")
+set(SUPPORTED_TVOS_SIMULATOR_ARCHS "x86_64;arm64")
 set(SUPPORTED_WATCHOS_ARCHS "armv7k")
-set(SUPPORTED_WATCHOS_SIMULATOR_ARCHS "i386")
-set(SUPPORTED_OSX_ARCHS "x86_64")
+set(SUPPORTED_WATCHOS_SIMULATOR_ARCHS "i386;arm64")
+set(SUPPORTED_OSX_ARCHS "x86_64;arm64;arm64e")
 
 is_sdk_requested(OSX swift_build_osx)
 if(swift_build_osx)

cmake/modules/SwiftConfigureSDK.cmake

@@ -85,6 +85,38 @@ function(_report_sdk prefix)
   message(STATUS "")
 endfunction()
 
+# Remove architectures not supported by the SDK from the given list.
+function(remove_sdk_unsupported_archs name os sdk_path architectures_var)
+  execute_process(COMMAND
+      /usr/libexec/PlistBuddy -c "Print :SupportedTargets:${os}:Archs" ${sdk_path}/SDKSettings.plist
+    OUTPUT_VARIABLE sdk_supported_archs
+    RESULT_VARIABLE plist_error)
+
+  if (NOT plist_error EQUAL 0)
+    message(STATUS "${os} SDK at ${sdk_path} does not publish its supported architectures")
+    return()
+  endif()
+
+  set(architectures)
+  foreach(arch ${${architectures_var}})
+    if(sdk_supported_archs MATCHES "${arch}\n")
+      list(APPEND architectures ${arch})
+    elseif(arch MATCHES "^armv7(s)?$" AND os STREQUAL "iphoneos")
+      # 32-bit iOS is not listed explicitly in SDK settings.
+      message(STATUS "Assuming ${name} SDK at ${sdk_path} supports architecture ${arch}")
+      list(APPEND architectures ${arch})
+    elseif(arch STREQUAL "i386" AND os STREQUAL "iphonesimulator")
+      # 32-bit iOS simulatoris not listed explicitly in SDK settings.
+      message(STATUS "Assuming ${name} SDK at ${sdk_path} supports architecture ${arch}")
+      list(APPEND architectures ${arch})
+    else()
+      message(STATUS "${name} SDK at ${sdk_path} does not support architecture ${arch}")
+    endif()
+  endforeach()
+
+  set("${architectures_var}" ${architectures} PARENT_SCOPE)
+endfunction()
+
 # Configure an SDK
 #
 # Usage:
@@ -164,6 +196,9 @@ macro(configure_sdk_darwin
       SWIFT_SDK_${prefix}_ARCHITECTURES)  # result
   endif()
 
+  # Remove any architectures not supported by the SDK.
+  remove_sdk_unsupported_archs(${name} ${xcrun_name} ${SWIFT_SDK_${prefix}_PATH} SWIFT_SDK_${prefix}_ARCHITECTURES)
+
   list_intersect(
     "${SWIFT_DARWIN_MODULE_ARCHS}"            # lhs
     "${architectures}"                        # rhs

cmake/modules/SwiftSharedCMakeConfig.cmake

@@ -58,7 +58,7 @@ macro(swift_common_standalone_build_config_llvm product)
     fix_imported_targets_for_xcode("${LLVM_EXPORTED_TARGETS}")
   endif()
 
-  if(NOT CMAKE_CROSSCOMPILING)
+  if(NOT CMAKE_CROSSCOMPILING AND NOT SWIFT_CROSS_COMPILING)
     set(${product}_NATIVE_LLVM_TOOLS_PATH "${LLVM_TOOLS_BINARY_DIR}")
   endif()
 

include/swift/AST/AvailabilitySpec.h

@@ -68,16 +68,33 @@ class PlatformVersionConstraintAvailabilitySpec : public AvailabilitySpec {
   SourceLoc PlatformLoc;
 
   llvm::VersionTuple Version;
+
+  // For macOS Big Sur, we canonicalize 10.16 to 11.0 for compile-time
+  // checking since clang canonicalizes availability markup. However, to
+  // support Beta versions of macOS Big Sur where the OS
+  // reports 10.16 at run time, we need to compare against 10.16,
+  //
+  // This means for:
+  //
+  // if #available(macOS 10.16, *) { ... }
+  //
+  // we need to keep around both a canonical version for use in compile-time
+  // checks and an uncanonicalized version for the version to actually codegen
+  // with.
+  llvm::VersionTuple RuntimeVersion;
+
   SourceRange VersionSrcRange;
 
 public:
   PlatformVersionConstraintAvailabilitySpec(PlatformKind Platform,
                                             SourceLoc PlatformLoc,
                                             llvm::VersionTuple Version,
+                                            llvm::VersionTuple RuntimeVersion,
                                             SourceRange VersionSrcRange)
     : AvailabilitySpec(AvailabilitySpecKind::PlatformVersionConstraint),
       Platform(Platform),
       PlatformLoc(PlatformLoc), Version(Version),
+      RuntimeVersion(RuntimeVersion),
       VersionSrcRange(VersionSrcRange) {}
 
   /// The required platform.
@@ -93,6 +110,11 @@ class PlatformVersionConstraintAvailabilitySpec : public AvailabilitySpec {
   llvm::VersionTuple getVersion() const { return Version; }
   SourceRange getVersionSrcRange() const { return VersionSrcRange; }
 
+  // The version to be used in codegen for version comparisons at run time.
+  // This is required to support beta versions of macOS Big Sur that
+  // report 10.16 at run time.
+  llvm::VersionTuple getRuntimeVersion() const { return RuntimeVersion; }
+
   SourceRange getSourceRange() const;
 
   void print(raw_ostream &OS, unsigned Indent) const;