Merge branch 'main' into wip-experimental-isolated-deinit

Author: ktoso

CMakeLists.txt

@@ -155,6 +155,8 @@ else()
     set(SWIFT_HOST_VARIANT_SDK_default "ANDROID")
   elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
     set(SWIFT_HOST_VARIANT_SDK_default "OSX")
+  elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "WASI")
+    set(SWIFT_HOST_VARIANT_SDK_default "WASI")
   else()
     message(FATAL_ERROR "Unable to detect SDK for host system: ${CMAKE_SYSTEM_NAME}")
   endif()
@@ -419,6 +421,17 @@ set(SWIFT_STDLIB_MSVC_RUNTIME_LIBRARY
   ${SWIFT_STDLIB_MSVC_RUNTIME_LIBRARY_default}
   CACHE STRING "MSVC Runtime Library for the standard library")
 
+if("${CMAKE_SYSTEM_NAME}" STREQUAL "Windows" AND BOOTSTRAPPING_MODE STREQUAL "HOSTTOOLS" AND
+    CMAKE_BUILD_TYPE STREQUAL "Debug")
+  # Building with the host Swift toolchain requires linking just-built binaries
+  # against the host Swift runtime. In debug builds, that means linking a debug
+  # binary against a release binary. The MSVC linker does not normally permit
+  # this, since debug builds enable bounds-checked C++ iterators by default,
+  # which are not ABI-compatible with regular iterators. Let's instruct MSVC to
+  # disable bounds-checked iterators to make it possible to do a debug build of
+  # the Swift compiler with a host toolchain.
+  add_definitions(-D_ITERATOR_DEBUG_LEVEL=0)
+endif()
 
 if(BRIDGING_MODE STREQUAL "DEFAULT" OR NOT BRIDGING_MODE)
   if(CMAKE_BUILD_TYPE STREQUAL "Debug" OR "${SWIFT_HOST_VARIANT_SDK}" STREQUAL "WINDOWS" OR (CMAKE_Swift_COMPILER AND CMAKE_Swift_COMPILER_VERSION VERSION_LESS 5.8))
@@ -703,10 +716,6 @@ option(SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED
   "Enable experimental distributed actors and functions"
   FALSE)
 
-option(SWIFT_ENABLE_EXPERIMENTAL_NONESCAPABLE_TYPES
-  "Enable experimental NonescapableTypes"
-  FALSE)
-
 option(SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING
   "Enable experimental string processing"
   FALSE)
@@ -1385,7 +1394,6 @@ if(SWIFT_BUILD_STDLIB OR SWIFT_BUILD_SDK_OVERLAY)
   message(STATUS "Differentiable Programming Support: ${SWIFT_ENABLE_EXPERIMENTAL_DIFFERENTIABLE_PROGRAMMING}")
   message(STATUS "Concurrency Support:                ${SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY}")
   message(STATUS "Distributed Support:                ${SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED}")
-  message(STATUS "NonEscapableTypes Support:          ${SWIFT_ENABLE_EXPERIMENTAL_NONESCAPABLE_TYPES}")
   message(STATUS "String Processing Support:          ${SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING}")
   message(STATUS "Backtracing Support:                ${SWIFT_ENABLE_BACKTRACING}")
   message(STATUS "Unicode Support:                    ${SWIFT_STDLIB_ENABLE_UNICODE_DATA}")

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBuiltin.swift

@@ -150,19 +150,20 @@ private extension BuiltinInst {
   }
 
   func optimizeAssertConfig(_ context: SimplifyContext) {
-    let literal: IntegerLiteralInst
-    switch context.options.assertConfiguration {
-    case .enabled:
-      let builder = Builder(before: self, context)
-      literal = builder.createIntegerLiteral(1,  type: type)
-    case .disabled:
+    // The values for the assert_configuration call are:
+    // 0: Debug
+    // 1: Release
+    // 2: Fast / Unchecked
+    let config = context.options.assertConfiguration
+    switch config {
+    case .debug, .release, .unchecked:
       let builder = Builder(before: self, context)
-      literal = builder.createIntegerLiteral(0,  type: type)
-    default:
+      let literal = builder.createIntegerLiteral(config.integerValue, type: type)
+      uses.replaceAll(with: literal, context)
+      context.erase(instruction: self)
+    case .unknown:
       return
     }
-    uses.replaceAll(with: literal, context)
-    context.erase(instruction: self)
   }
 
   func optimizeTargetTypeConst(_ context: SimplifyContext) {

SwiftCompilerSources/Sources/Optimizer/PassManager/Options.swift

@@ -36,16 +36,31 @@ struct Options {
     _bridged.hasFeature(feature)
   }
 
+  // The values for the assert_configuration call are:
+  // 0: Debug
+  // 1: Release
+  // 2: Fast / Unchecked
   enum AssertConfiguration {
-    case enabled
-    case disabled
+    case debug
+    case release
+    case unchecked
     case unknown
+
+    var integerValue: Int {
+      switch self {
+      case .debug:      return 0
+      case .release:    return 1
+      case .unchecked:  return 2
+      case .unknown:    fatalError()
+      }
+    }
   }
 
   var assertConfiguration: AssertConfiguration {
     switch _bridged.getAssertConfiguration() {
-      case .Debug:               return .enabled
-      case .Release, .Unchecked: return .disabled
+      case .Debug:               return .debug
+      case .Release:             return .release
+      case .Unchecked:           return .unchecked
       default:                   return .unknown
     }
   }

SwiftCompilerSources/Sources/Optimizer/Utilities/StaticInitCloner.swift

@@ -46,7 +46,16 @@ struct StaticInitCloner<Context: MutatingContext> {
       return getClonedValue(of: value)
     }
 
+    if let beginAccess = value as? BeginAccessInst {
+      // Skip access instructions, which might be generated for UnsafePointer globals which point to other globals.
+      let clonedOperand = clone(beginAccess.address)
+      bridged.recordFoldedValue(beginAccess.bridged, clonedOperand.bridged)
+      return clonedOperand
+    }
+
     let inst = value.definingInstruction!
+    assert(!(inst is ScopedInstruction), "global init value must not contain a scoped instruction")
+
     for op in inst.operands {
       _ = clone(op.value)
     }

benchmark/CMakeLists.txt

@@ -210,6 +210,7 @@ set(SWIFT_BENCH_MODULES
     single-source/XorLoop
     cxx-source/CreateObjects
     cxx-source/CxxSetToCollection
+    cxx-source/CxxSpanTests
     cxx-source/CxxStringConversion
     cxx-source/CxxVectorSum
     # TODO: rdar://92120528

benchmark/Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.4
+// swift-tools-version:5.9
 
 import PackageDescription
 import Foundation
@@ -127,8 +127,8 @@ targets.append(
     dependencies: swiftBenchDeps,
     path: "utils",
     sources: ["main.swift"],
-    swiftSettings: [.unsafeFlags(["-cxx-interoperability-mode=default",
-                                  "-I",
+    swiftSettings: [.interoperabilityMode(.Cxx),
+                    .unsafeFlags(["-I",
                                   "utils/CxxTests"])]))
 
 #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
@@ -165,8 +165,8 @@ targets += cxxSingleSourceLibraries.map { name in
     dependencies: singleSourceDeps,
     path: "cxx-source",
     sources: ["\(name).swift"],
-    swiftSettings: [.unsafeFlags(["-cxx-interoperability-mode=default",
-                                  "-I",
+    swiftSettings: [.interoperabilityMode(.Cxx),
+                    .unsafeFlags(["-I",
                                   "utils/CxxTests",
                                   // FIXME: https://github.com/apple/swift/issues/61453
                                   "-Xfrontend", "-validate-tbd-against-ir=none"])])

benchmark/cxx-source/CxxSpanTests.swift

@@ -0,0 +1,121 @@
+//===--- CxxSpanTests.swift ----------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 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
+//
+//===----------------------------------------------------------------------===//
+
+import TestsUtils
+import CxxStdlibPerformance
+
+let iterRepeatFactor = 7
+
+// FIXME swift-ci linux tests do not support std::span
+#if os(Linux)
+public let benchmarks = [BenchmarkInfo]()
+#else
+
+public let benchmarks = [
+  BenchmarkInfo(
+    name: "CxxSpanTests.raw.iterator",
+    runFunction: run_CxxSpanOfU32_RawIterator,
+    tags: [.validation, .bridging, .cxxInterop],
+    setUpFunction: makeSpanOnce),
+  BenchmarkInfo(
+    name: "CxxSpanTests.index.subscript",
+    runFunction: run_CxxSpanOfU32_IndexAndSubscript,
+    tags: [.validation, .bridging, .cxxInterop],
+    setUpFunction: makeSpanOnce),
+  BenchmarkInfo(
+    name: "CxxSpanTests.for.loop",
+    runFunction: run_CxxSpanOfU32_ForInLoop,
+    tags: [.validation, .bridging, .cxxInterop],
+    setUpFunction: makeSpanOnce),
+  BenchmarkInfo(
+    name: "CxxSpanTests.map",
+    runFunction: run_CxxSpanOfU32_MapSpan,
+    tags: [.validation, .bridging, .cxxInterop],
+    setUpFunction: makeSpanOnce),
+  BenchmarkInfo(
+    name: "CxxSpanTests.filter",
+    runFunction: run_CxxSpanOfU32_FilterSpan,
+    tags: [.validation, .bridging, .cxxInterop],
+    setUpFunction: makeSpanOnce),
+  BenchmarkInfo(
+    name: "CxxSpanTests.reduce",
+    runFunction: run_CxxSpanOfU32_ReduceSpan,
+    tags: [.validation, .bridging, .cxxInterop],
+    setUpFunction: makeSpanOnce),
+]
+
+func makeSpanOnce() {
+  initSpan()
+}
+
+@inline(never)
+public func run_CxxSpanOfU32_RawIterator(_ n: Int) {
+  var sum: UInt32 = 0
+  for _ in 0..<(n * iterRepeatFactor * 2) {
+    var b = span.__beginUnsafe()
+    let e = span.__endUnsafe()
+    while b != e {
+      sum = sum &+ b.pointee
+      b = b.successor()
+    }
+  }
+  blackHole(sum)
+}
+
+@inline(never)
+public func run_CxxSpanOfU32_IndexAndSubscript(_ n: Int) {
+  var sum: UInt32 = 0
+  for _ in 0..<(n * iterRepeatFactor * 2) {
+    for i in 0..<span.size() {
+      sum = sum &+ span[i]
+    }
+  }
+  blackHole(sum)
+}
+
+@inline(never)
+public func run_CxxSpanOfU32_ForInLoop(_ n: Int) {
+  var sum: UInt32 = 0
+  for _ in 0..<(n * iterRepeatFactor * 2) {
+    for x in span {
+      sum = sum &+ x
+    }
+  }
+  blackHole(sum)
+}
+
+@inline(never)
+public func run_CxxSpanOfU32_MapSpan(_ n: Int) {
+  for _ in 0..<(n * iterRepeatFactor) {
+    let result = span.map { $0 &+ 5 }
+    blackHole(result)
+  }
+}
+
+@inline(never)
+public func run_CxxSpanOfU32_FilterSpan(_ n: Int) {
+  for _ in 0..<(n * iterRepeatFactor) {
+    let result = span.filter { $0 % 2 == 0 }
+    blackHole(result)
+  }
+}
+
+@inline(never)
+public func run_CxxSpanOfU32_ReduceSpan(_ n: Int) {
+  var sum: UInt32 = 0
+  for _ in 0..<(n * iterRepeatFactor * 2) {
+    sum = sum &+ span.reduce(sum, &+)
+  }
+  blackHole(sum)
+}
+
+#endif

benchmark/utils/CxxTests/CxxStdlibPerformance.h

@@ -4,11 +4,26 @@
 #include <vector>
 #include <set>
 
+// FIXME swift-ci linux tests do not support std::span
+#ifndef __linux__
+#include <span>
+#endif
+
+static const size_t spanSize = 50000;
+
 using VectorOfU32 = std::vector<uint32_t>;
 using SetOfU32 = std::set<uint32_t>;
+#ifndef __linux__
+using ArrayOfU32 = uint32_t[spanSize];
+using SpanOfU32 = std::span<uint32_t>;
+#endif
 
 static inline VectorOfU32 vec;
 static inline SetOfU32 set;
+#ifndef __linux__
+static inline ArrayOfU32 array;
+static inline SpanOfU32 span;
+#endif
 
 inline void initVector(size_t size) {
     if (!vec.empty()) {
@@ -29,6 +44,18 @@ inline void initSet(size_t size) {
     }
 }
 
+#ifndef __linux__
+inline void initSpan() {
+    if (!span.empty()) {
+        return;
+    }
+    for (size_t i = 0; i < spanSize; ++i) {
+        array[i] = uint32_t(i);
+    }
+    span = SpanOfU32(array);
+}
+#endif
+
 inline VectorOfU32 makeVector32(size_t size) {
     initVector(size);
     return vec;

benchmark/utils/main.swift

@@ -57,6 +57,7 @@ import CountAlgo
 import CreateObjects
 // rdar://128520766
 // import CxxSetToCollection
+import CxxSpanTests
 import CxxStringConversion
 // rdar://128520766
 // import CxxVectorSum
@@ -255,6 +256,7 @@ register(ClassArrayGetter.benchmarks)
 register(CreateObjects.benchmarks)
 // rdar://128520766
 // register(CxxSetToCollection.benchmarks)
+register(CxxSpanTests.benchmarks)
 register(CxxStringConversion.benchmarks)
 // rdar://128520766
 // register(CxxVectorSum.benchmarks)

cmake/caches/Linux-x86_64.cmake

@@ -142,12 +142,14 @@ set(LLDB_TOOLS
 set(SWIFT_INSTALL_COMPONENTS
       autolink-driver
       compiler
+      compiler-swift-syntax-lib
       clang-builtin-headers
       editor-integration
       tools
       sourcekit-inproc
       swift-remote-mirror
       swift-remote-mirror-headers
+      swift-syntax-lib
     CACHE STRING "")
 
 set(LLVM_DISTRIBUTION_COMPONENTS