Merge pull request #71826 from atrick/forwarding-utils

SwiftCompilerSources: support for ForwardingInstructions, ConversionInstructions, OwnershipTransitionInstruction

Author: atrick

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/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/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/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