Merge branch 'apple:main' into my-branch

Author: li3zhen1

CHANGELOG.md

@@ -3,7 +3,7 @@
 > **Note**\
 > This is in reverse chronological order, so newer entries are added to the top.
 
-## Swift 5.11
+## Swift 6.0
 * [SE-0422][]:
   Non-built-in expression macros can now be used as default arguments that
   expand at each call site. For example, a custom `#CurrentFile` macro used as

CMakeLists.txt

@@ -238,6 +238,10 @@ option(SWIFT_STDLIB_ENABLE_UNICODE_DATA
     NOTE: Disabling this will cause many String methods to crash."
     TRUE)
 
+option(SWIFT_BUILD_CLANG_OVERLAYS
+  "Build Swift overlays for the clang builtin modules"
+  TRUE)
+
 option(SWIFT_BUILD_DYNAMIC_SDK_OVERLAY
     "Build dynamic variants of the Swift SDK overlay"
     TRUE)
@@ -1381,14 +1385,6 @@ endif()
 add_subdirectory(include)
 
 if(SWIFT_INCLUDE_TOOLS)
-  # TODO Remove this once release/5.9 is done and we can finish migrating Swift
-  #      off of `llvm::None`/`llvm::Optional`, and `llvm::makeArrayRef`.
-  # This is to silence the avalanche of deprecation warnings from LLVM headers
-  # until we can actually do something about them. This is nasty, but it's
-  # better than losing context due to the sheer number in-actionable deprecation
-  # warnings or the massive number of merge-conflicts we would get otherwise.
-  add_definitions(-DSWIFT_TARGET)
-
   add_subdirectory(lib)
 
   add_subdirectory(SwiftCompilerSources)

SwiftCompilerSources/README.md

@@ -129,8 +129,6 @@ For example, to add a new instruction class:
 *  if needed, add bridging functions to access the instruction's data fields.
 
 
-No yet implemented instruction classes are mapped to a "placeholder" instruction, e.g `UnimplementedInstruction`. This ensures that optimizations can process any kind of SIL, even if some instructions don't have a representation in Swift yet.
-
 ## The Optimizer
 
 Similar to SIL, the optimizer also uses a small bridging layer (`OptimizerBridging.h`).

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LetPropertyLowering.swift

@@ -156,17 +156,17 @@ private func constructLetInitRegion(
       initRegion.insert(inst)
 
     case let beginAccess as BeginAccessInst
-         where beginAccess.accessKind == .Deinit &&
+         where beginAccess.accessKind == .deinit &&
                beginAccess.address.isLetFieldAddress(of: markUninitialized):
       // Include let-field partial de-initializations in the region.
       initRegion.insert(inst)
 
     case let beginBorrow as BeginBorrowInst
-         where beginBorrow.borrowedValue.referenceRoot == markUninitialized:
+           where beginBorrow.borrowedValue.isReferenceDerived(from: markUninitialized):
       borrows.append(beginBorrow)
 
     case let storeBorrow as StoreBorrowInst
-         where storeBorrow.source.referenceRoot == markUninitialized:
+           where storeBorrow.source.isReferenceDerived(from: markUninitialized):
       borrows.append(storeBorrow)
 
     default:
@@ -202,10 +202,28 @@ private extension RefElementAddrInst {
 }
 
 private extension Value {
+  func isReferenceDerived(from root: Value) -> Bool {
+    var parent: Value = self
+    while true {
+      if parent == root {
+        return true
+      }
+      if let operand = parent.forwardingInstruction?.singleForwardedOperand {
+        parent = operand.value
+        continue
+      }
+      if let transition = parent.definingInstruction as? OwnershipTransitionInstruction {
+        parent = transition.operand.value
+        continue
+      }
+      return false
+    }
+  }
+
   func isLetFieldAddress(of markUninitialized: MarkUninitializedInst) -> Bool {
     if case .class(let rea) = self.accessBase,
        rea.fieldIsLet,
-       rea.instance.referenceRoot == markUninitialized
+       rea.instance.isReferenceDerived(from: markUninitialized)
     {
       return true
     }

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyDestructure.swift

@@ -12,7 +12,7 @@
 
 import SIL
 
-extension DestructureTupleInst : OnoneSimplifyable {
+extension DestructureTupleInst : OnoneSimplifyable, SILCombineSimplifyable {
   func simplify(_ context: SimplifyContext) {
 
     // Eliminate the redundant instruction pair
@@ -28,7 +28,7 @@ extension DestructureTupleInst : OnoneSimplifyable {
   }
 }
 
-extension DestructureStructInst : OnoneSimplifyable {
+extension DestructureStructInst : OnoneSimplifyable, SILCombineSimplifyable {
   func simplify(_ context: SimplifyContext) {
 
     switch self.struct {

SwiftCompilerSources/Sources/Optimizer/ModulePasses/StackProtection.swift

@@ -355,7 +355,7 @@ private struct StackProtectionOptimization {
   /// Moves the value of a `beginAccess` to a temporary stack location, if possible.
   private func moveToTemporary(scope beginAccess: BeginAccessInst, mustFixStackNesting: inout Bool,
                                _ context: FunctionPassContext) {
-    if beginAccess.accessKind != .Modify {
+    if beginAccess.accessKind != .modify {
       // We can only move from a `modify` access.
       // Also, read-only accesses shouldn't be subject to buffer overflows (because
       // no one should ever write to such a storage).

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -17,6 +17,7 @@ import OptimizerBridging
 public func initializeSwiftModules() {
   registerSILClasses()
   registerSwiftAnalyses()
+  registerUtilities()
   registerSwiftPasses()
   registerOptimizerTests()
 }
@@ -102,6 +103,8 @@ private func registerSwiftPasses() {
   registerForSILCombine(LoadInst.self,             { run(LoadInst.self, $0) })
   registerForSILCombine(CopyValueInst.self,        { run(CopyValueInst.self, $0) })
   registerForSILCombine(DestroyValueInst.self,     { run(DestroyValueInst.self, $0) })
+  registerForSILCombine(DestructureStructInst.self, { run(DestructureStructInst.self, $0) })
+  registerForSILCombine(DestructureTupleInst.self, { run(DestructureTupleInst.self, $0) })
 
   // Test passes
   registerPass(functionUsesDumper, { functionUsesDumper.run($0) })
@@ -120,3 +123,7 @@ private func registerSwiftAnalyses() {
   AliasAnalysis.register()
   CalleeAnalysis.register()
 }
+
+private func registerUtilities() {
+  registerVerifier()
+}

SwiftCompilerSources/Sources/Optimizer/Utilities/AddressUtils.swift

@@ -192,8 +192,7 @@ extension AccessBase {
   /// with the initialized address. This does not guarantee that all
   /// uses of that address are dominated by the store or even that the
   /// store is a direct use of `address`.
-  func findSingleInitializer(_ context: some Context)
-    -> (initialAddress: Value, initializingStore: Instruction)? {
+  func findSingleInitializer(_ context: some Context) -> (initialAddress: Value, initializingStore: Instruction)? {
     let baseAddr: Value
     switch self {
     case let .stack(allocStack):
@@ -206,15 +205,7 @@ extension AccessBase {
     default:
       return nil
     }
-    var walker = AddressInitializationWalker(context: context)
-    if walker.walkDownUses(ofAddress: baseAddr, path: SmallProjectionPath())
-         == .abortWalk {
-      return nil
-    }
-    guard let initializingStore = walker.initializingStore else {
-      return nil
-    }
-    return (initialAddress: baseAddr, initializingStore: initializingStore)
+    return AddressInitializationWalker.findSingleInitializer(ofAddress: baseAddr, context: context)
   }
 }
 
@@ -223,6 +214,9 @@ extension AccessBase {
 // Implements AddressUseVisitor to guarantee that we can't miss any
 // stores. This separates escapingAddressUse from leafAddressUse.
 //
+// Main entry point:
+//  static func findSingleInitializer(ofAddress: Value, context: some Context)
+//
 // TODO: Make AddressDefUseWalker always conform to AddressUseVisitor once we're
 // ready to debug changes to escape analysis etc...
 //
@@ -249,6 +243,19 @@ struct AddressInitializationWalker: AddressDefUseWalker, AddressUseVisitor {
   var isProjected = false
   var initializingStore: Instruction?
 
+  static func findSingleInitializer(ofAddress baseAddr: Value, context: some Context)
+    -> (initialAddress: Value, initializingStore: Instruction)? {
+
+    var walker = AddressInitializationWalker(context: context)
+    if walker.walkDownUses(ofAddress: baseAddr, path: SmallProjectionPath()) == .abortWalk {
+      return nil
+    }
+    guard let initializingStore = walker.initializingStore else {
+      return nil
+    }
+    return (initialAddress: baseAddr, initializingStore: initializingStore)
+  }
+
   private mutating func setInitializer(instruction: Instruction) -> WalkResult {
     // An initializer must be unique and store the full value.
     if initializingStore != nil || isProjected {

SwiftCompilerSources/Sources/Optimizer/Utilities/CMakeLists.txt

@@ -20,4 +20,5 @@ swift_compiler_sources(Optimizer
   SSAUpdater.swift
   StaticInitCloner.swift
   Test.swift
+  Verifier.swift
 )

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -706,12 +706,8 @@ extension LifetimeDependenceUseDefWalker {
   mutating func walkUpDefault(dependent value: Value, owner: Value?)
     -> WalkResult {
     switch value.definingInstruction {
-    case let copyInst as CopyValueInst:
-      return walkUp(newLifetime: copyInst.fromValue)
-    case let moveInst as MoveValueInst:
-      return walkUp(value: moveInst.fromValue, owner)
-    case let borrow as BeginBorrowInst:
-      return walkUp(newLifetime: borrow.borrowedValue)
+    case let transition as OwnershipTransitionInstruction:
+      return walkUp(newLifetime: transition.operand.value)
     case let load as LoadInstruction:
       return walkUp(address: load.address)
     case let markDep as MarkDependenceInst:
@@ -862,11 +858,8 @@ extension LifetimeDependenceDefUseWalker {
       return leafUse(of: operand)
     }
     switch operand.instruction {
-    case let copy as CopyingInstruction:
-      return walkDownUses(of: copy, using: operand)
-
-    case let move as MoveValueInst:
-      return walkDownUses(of: move, using: operand)
+    case let transition as OwnershipTransitionInstruction:
+      return walkDownUses(of: transition.ownershipResult, using: operand)
 
     case let mdi as MarkDependenceInst where mdi.isUnresolved:
       // Override mark_dependence [unresolved] to handle them just