Merge branch 'main' into c++20-compatibility

Author: redsun82

SwiftCompilerSources/CMakeLists.txt

@@ -256,7 +256,6 @@ else()
   #         The swift modules can now depend on that target.
   #         Note that this library is unused, i.e. not linked to anything.   
   add_library(importedHeaderDependencies "${CMAKE_CURRENT_BINARY_DIR}/HeaderDependencies.cpp")
-  add_dependencies(importedHeaderDependencies swift-ast-generated-headers)
   target_include_directories(importedHeaderDependencies PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../include/swift")
 
   if(BOOTSTRAPPING_MODE MATCHES "HOSTTOOLS|CROSSCOMPILE")

SwiftCompilerSources/Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.3
+// swift-tools-version:5.9
 //===--- Package.swift.in - SwiftCompiler SwiftPM package -----------------===//
 //
 // This source file is part of the Swift.org open source project
@@ -14,20 +14,6 @@
 import PackageDescription
 
 private extension Target {
-  static let defaultSwiftSettings: [SwiftSetting] = [
-    .unsafeFlags([
-      "-Xfrontend", "-validate-tbd-against-ir=none",
-      "-Xfrontend", "-enable-experimental-cxx-interop",
-      // Bridging modules and headers
-      "-Xcc", "-I", "-Xcc", "../include",
-      // LLVM modules and headers
-      "-Xcc", "-I", "-Xcc", "../../llvm-project/llvm/include",
-      // Clang modules and headers
-      "-Xcc", "-I", "-Xcc", "../../llvm-project/clang/include",
-      "-cross-module-optimization"
-    ]),
-  ]
-
   static func compilerModuleTarget(
     name: String,
     dependencies: [Dependency],
@@ -40,7 +26,15 @@ private extension Target {
         path: path ?? "Sources/\(name)",
         exclude: ["CMakeLists.txt"],
         sources: sources,
-        swiftSettings: defaultSwiftSettings + swiftSettings)
+        cxxSettings: [
+          .headerSearchPath("../include"),
+          .headerSearchPath("../../llvm-project/llvm/include"),
+          .headerSearchPath("../../llvm-project/clang/include"),
+        ],
+        swiftSettings: [
+          .interoperabilityMode(.Cxx),
+          .unsafeFlags(["-cross-module-optimization"]),
+        ] + swiftSettings)
     }
 }
 
@@ -86,5 +80,6 @@ let package = Package(
     .compilerModuleTarget(
       name: "Optimizer",
       dependencies: ["Basic", "SIL", "Parse"]),
-  ]
+  ],
+  cxxLanguageStandard: .cxx17
 )

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AssumeSingleThreaded.swift

@@ -27,12 +27,12 @@
 
 import SIL
 
-let assumeSingleThreadedPass = FunctionPass(
-  name: "sil-assume-single-threaded", { function, context in
-    for inst in function.instructions {
-      guard let rcInst = inst as? RefCountingInst else { continue }
+let assumeSingleThreadedPass = FunctionPass(name: "sil-assume-single-threaded") {
+  (function: Function, context: FunctionPassContext) in
 
-      rcInst.setAtomicity(isAtomic: false, context)
-    }
+  for inst in function.instructions {
+    guard let rcInst = inst as? RefCountingInst else { continue }
+
+    rcInst.setAtomicity(isAtomic: false, context)
   }
-)
+}

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEscapeEffects.swift

@@ -25,7 +25,7 @@ import SIL
 /// ```
 /// The pass does not try to change or re-compute _defined_ effects.
 ///
-let computeEscapeEffects = FunctionPass(name: "compute-escape-effects", {
+let computeEscapeEffects = FunctionPass(name: "compute-escape-effects") {
   (function: Function, context: FunctionPassContext) in
 
   var newEffects = function.effects.escapeEffects.arguments.filter {!$0.isDerived }
@@ -73,8 +73,7 @@ let computeEscapeEffects = FunctionPass(name: "compute-escape-effects", {
   context.modifyEffects(in: function) { (effects: inout FunctionEffects) in
     effects.escapeEffects.arguments = newEffects
   }
-})
-
+}
 
 /// Returns true if an argument effect was added.
 private

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -24,7 +24,7 @@ import SIL
 /// ```
 /// are computed.
 ///
-let computeSideEffects = FunctionPass(name: "compute-side-effects", {
+let computeSideEffects = FunctionPass(name: "compute-side-effects") {
   (function: Function, context: FunctionPassContext) in
 
   if function.isAvailableExternally {
@@ -71,7 +71,7 @@ let computeSideEffects = FunctionPass(name: "compute-side-effects", {
   context.modifyEffects(in: function) { (effects: inout FunctionEffects) in
     effects.sideEffects = SideEffects(arguments: collectedEffects.argumentEffects, global: collectedEffects.globalEffects)
   }
-})
+}
 
 /// The collected argument and global side effects of the function.
 private struct CollectedEffects {

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjCBridgingOptimization.swift

@@ -31,7 +31,7 @@ import SIL
 ///   br continue_bb(%5)
 /// continue_bb(%bridgedOptionalSwiftValue):
 /// ```
-let objCBridgingOptimization = FunctionPass(name: "objc-bridging-opt", {
+let objCBridgingOptimization = FunctionPass(name: "objc-bridging-opt") {
   (function: Function, context: FunctionPassContext) in
 
   if !function.hasOwnership { return }
@@ -54,7 +54,7 @@ let objCBridgingOptimization = FunctionPass(name: "objc-bridging-opt", {
       }
     }
   }
-})
+}
 
 //===----------------------------------------------------------------------===//
 //                      Top-level optimization functions

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ReleaseDevirtualizer.swift

@@ -30,42 +30,42 @@ import SIL
 /// The optimization is only done for stack promoted objects because they are
 /// known to have no associated objects (which are not explicitly released
 /// in the deinit method).
-let releaseDevirtualizerPass = FunctionPass(
-  name: "release-devirtualizer", { function, context in
-    for block in function.blocks {
-      // The last `release_value`` or `strong_release`` instruction before the
-      // deallocation.
-      var lastRelease: RefCountingInst?
-
-      for instruction in block.instructions {
-        if let release = lastRelease {
-          // We only do the optimization for stack promoted object, because for
-          // these we know that they don't have associated objects, which are
-          // _not_ released by the deinit method.
-          if let deallocStackRef = instruction as? DeallocStackRefInst {
-            if !context.continueWithNextSubpassRun(for: release) {
-              return
-            }
-            tryDevirtualizeReleaseOfObject(context, release, deallocStackRef)
-            lastRelease = nil
-            continue
+let releaseDevirtualizerPass = FunctionPass(name: "release-devirtualizer") {
+  (function: Function, context: FunctionPassContext) in
+
+  for block in function.blocks {
+    // The last `release_value`` or `strong_release`` instruction before the
+    // deallocation.
+    var lastRelease: RefCountingInst?
+
+    for instruction in block.instructions {
+      if let release = lastRelease {
+        // We only do the optimization for stack promoted object, because for
+        // these we know that they don't have associated objects, which are
+        // _not_ released by the deinit method.
+        if let deallocStackRef = instruction as? DeallocStackRefInst {
+          if !context.continueWithNextSubpassRun(for: release) {
+            return
           }
+          tryDevirtualizeReleaseOfObject(context, release, deallocStackRef)
+          lastRelease = nil
+          continue
         }
+      }
 
-        switch instruction {
-          case is ReleaseValueInst, is StrongReleaseInst:
-            lastRelease = instruction as? RefCountingInst
-          case is DeallocRefInst, is SetDeallocatingInst:
+      switch instruction {
+        case is ReleaseValueInst, is StrongReleaseInst:
+          lastRelease = instruction as? RefCountingInst
+        case is DeallocRefInst, is SetDeallocatingInst:
+          lastRelease = nil
+        default:
+          if instruction.mayRelease {
             lastRelease = nil
-          default:
-            if instruction.mayRelease {
-              lastRelease = nil
-            }
-        }
+          }
       }
     }
   }
-)
+}
 
 /// Tries to de-virtualize the final release of a stack-promoted object.
 private func tryDevirtualizeReleaseOfObject(

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBuiltin.swift

@@ -28,6 +28,10 @@ extension BuiltinInst : OnoneSimplifyable {
         optimizeCanBeClass(context)
       case .AssertConf:
         optimizeAssertConfig(context)
+      case .Sizeof,
+           .Strideof,
+           .Alignof:
+        optimizeTargetTypeConst(context)
       default:
         if let literal = constantFold(context) {
           uses.replaceAll(with: literal, context)
@@ -131,6 +135,33 @@ private extension BuiltinInst {
     uses.replaceAll(with: literal, context)
     context.erase(instruction: self)
   }
+  
+  func optimizeTargetTypeConst(_ context: SimplifyContext) {
+    guard let ty = substitutionMap.replacementTypes[0] else {
+      return
+    }
+    
+    let value: Int?
+    switch id {
+    case .Sizeof:
+      value = ty.getStaticSize(context: context)
+    case .Strideof:
+      value = ty.getStaticStride(context: context)
+    case .Alignof:
+      value = ty.getStaticAlignment(context: context)
+    default:
+      fatalError()
+    }
+    
+    guard let value else {
+      return
+    }
+    
+    let builder = Builder(before: self, context)
+    let literal = builder.createIntegerLiteral(value, type: type)
+    uses.replaceAll(with: literal, context)
+    context.erase(instruction: self)
+  }
 }
 
 private func hasSideEffectForBuiltinOnce(_ instruction: Instruction) -> Bool {

SwiftCompilerSources/Sources/Optimizer/ModulePasses/StackProtection.swift

@@ -38,22 +38,22 @@ private func log(_ message: @autoclosure () -> String) {
 /// inter-procedural analysis. If this is not possible and the `enableMoveInoutStackProtection`
 /// option is set, the fallback is to move the argument into a temporary `alloc_stack`
 /// and do the unsafe pointer operations on the temporary.
-let stackProtection = ModulePass(name: "stack-protection", {
-    (context: ModulePassContext) in
+let stackProtection = ModulePass(name: "stack-protection") {
+  (context: ModulePassContext) in
 
   if !context.options.enableStackProtection {
     return
   }
 
   var optimization = StackProtectionOptimization(enableMoveInout: context.options.enableMoveInoutStackProtection)
   optimization.processModule(context)
-})
+}
 
 /// The stack-protection optimization on function-level.
 ///
 /// In contrast to the `stack-protection` pass, this pass doesn't do any inter-procedural
 /// analysis. It runs at Onone.
-let functionStackProtection = FunctionPass(name: "function-stack-protection", {
+let functionStackProtection = FunctionPass(name: "function-stack-protection") {
   (function: Function, context: FunctionPassContext) in
 
   if !context.options.enableStackProtection {
@@ -62,7 +62,7 @@ let functionStackProtection = FunctionPass(name: "function-stack-protection", {
 
   var optimization = StackProtectionOptimization(enableMoveInout: context.options.enableMoveInoutStackProtection)
   optimization.process(function: function, context)
-})
+}
 
 /// The optimization algorithm.
 private struct StackProtectionOptimization {

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -279,6 +279,23 @@ struct SimplifyContext : MutatingContext {
   let preserveDebugInfo: Bool
 }
 
+extension Type {
+  func getStaticSize(context: SimplifyContext) -> Int? {
+    let v = context._bridged.getStaticSize(self.bridged)
+    return v == -1 ? nil : v
+  }
+  
+  func getStaticAlignment(context: SimplifyContext) -> Int? {
+    let v = context._bridged.getStaticAlignment(self.bridged)
+    return v == -1 ? nil : v
+  }
+  
+  func getStaticStride(context: SimplifyContext) -> Int? {
+    let v = context._bridged.getStaticStride(self.bridged)
+    return v == -1 ? nil : v
+  }
+}
+
 //===----------------------------------------------------------------------===//
 //                          Builder initialization
 //===----------------------------------------------------------------------===//

SwiftCompilerSources/Sources/Optimizer/TestPasses/AccessDumper.swift

@@ -19,7 +19,7 @@ import SIL
 /// dumps anything, but aborts if the result is wrong.
 ///
 /// This pass is used for testing `AccessUtils`.
-let accessDumper = FunctionPass(name: "dump-access", {
+let accessDumper = FunctionPass(name: "dump-access") {
   (function: Function, context: FunctionPassContext) in
   print("Accesses for \(function.name)")
 
@@ -46,7 +46,7 @@ let accessDumper = FunctionPass(name: "dump-access", {
   }
 
   print("End accesses for \(function.name)")
-})
+}
 
 private struct AccessStoragePathVisitor : ValueUseDefWalker {
   var walkUpCache = WalkerCache<Path>()

SwiftCompilerSources/Sources/Optimizer/TestPasses/DeadEndBlockDumper.swift

@@ -12,15 +12,14 @@
 
 import SIL
 
-let deadEndBlockDumper = FunctionPass(name: "dump-deadendblocks", {
+let deadEndBlockDumper = FunctionPass(name: "dump-deadendblocks") {
   (function: Function, context: FunctionPassContext) in
 
-  
   print("Function \(function.name)")
 
   var deadEndBlocks = DeadEndBlocks(function: function, context)
   print(deadEndBlocks)
   defer { deadEndBlocks.deinitialize() }
 
   print("end function \(function.name)")
-})
+}

SwiftCompilerSources/Sources/Optimizer/TestPasses/EscapeInfoDumper.swift

@@ -17,7 +17,7 @@ import SIL
 /// Dumps the EscapeInfo query results for all `alloc_stack` instructions in a function.
 ///
 /// This pass is used for testing EscapeInfo.
-let escapeInfoDumper = FunctionPass(name: "dump-escape-info", {
+let escapeInfoDumper = FunctionPass(name: "dump-escape-info") {
   (function: Function, context: FunctionPassContext) in
 
   print("Escape information for \(function.name):")
@@ -60,16 +60,15 @@ let escapeInfoDumper = FunctionPass(name: "dump-escape-info", {
     }
   }
   print("End function \(function.name)\n")
-})
-
+}
 
 /// Dumps the results of address-related escape analysis.
 ///
 /// Dumps the EscapeInfo query results for addresses escaping to function calls.
 /// The `fix_lifetime` instruction is used as marker for addresses and values to query.
 ///
 /// This pass is used for testing EscapeInfo.
-let addressEscapeInfoDumper = FunctionPass(name: "dump-addr-escape-info", {
+let addressEscapeInfoDumper = FunctionPass(name: "dump-addr-escape-info") {
   (function: Function, context: FunctionPassContext) in
 
   print("Address escape information for \(function.name):")
@@ -159,4 +158,4 @@ let addressEscapeInfoDumper = FunctionPass(name: "dump-addr-escape-info", {
   }
 
   print("End function \(function.name)\n")
-})
+}

SwiftCompilerSources/Sources/Optimizer/TestPasses/FunctionUsesDumper.swift

@@ -12,7 +12,7 @@
 
 import SIL
 
-let functionUsesDumper = ModulePass(name: "dump-function-uses", {
+let functionUsesDumper = ModulePass(name: "dump-function-uses") {
     (context: ModulePassContext) in
 
   var functionUses = FunctionUses()
@@ -25,4 +25,4 @@ let functionUsesDumper = ModulePass(name: "dump-function-uses", {
     print(uses)
     print("End function \(function.name)\n")
   }
-})
+}