Add store_borrow support.

Author: MAJKFL

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/InitializeStaticGlobals.swift

@@ -289,7 +289,7 @@ private indirect enum GlobalInitValue {
       fatalError("cannot materialize undefined init value")
 
     case .constant(let value):
-      return cloner.cloneRecursivelyToGlobal(value: value)
+      return cloner.cloneRecursively(globalInitValue: value)
 
     case .aggregate(let fields):
       if type.isStruct {

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LoopInvariantCodeMotion.swift

@@ -649,6 +649,19 @@ private extension MovableInstructions {
     var changed = false
 
     for scopedInst in scopedInsts {
+      if let storeBorrowInst = scopedInst as? StoreBorrowInst {
+        _ = storeBorrowInst.allocStack.hoist(outOf: loop, context)
+        
+        var sankFirst = false
+        for deallocStack in storeBorrowInst.allocStack.deallocations {
+          if sankFirst {
+            context.erase(instruction: deallocStack)
+          } else {
+            sankFirst = deallocStack.sink(outOf: loop, context)
+          }
+        }
+      }
+
       guard scopedInst.hoist(outOf: loop, context) else {
         continue
       }
@@ -706,7 +719,7 @@ private extension MovableInstructions {
     var ssaUpdater = SSAUpdater(
       function: firstStore.parentFunction,
       type: firstStore.destination.type.objectType,
-      ownership: firstStore.storeOwnership == .initialize ? .owned : .none,
+      ownership: firstStore.source.ownership,
       context
     )
 
@@ -868,7 +881,7 @@ private extension Instruction {
     }
 
     if let singleValueInst = self as? SingleValueInstruction,
-       !(self is BeginAccessInst),
+       !(self is ScopedInstruction),
        let identicalInst = (loop.preheader!.instructions.first { otherInst in
          return singleValueInst != otherInst && singleValueInst.isIdenticalTo(otherInst)
     }) {
@@ -1070,43 +1083,70 @@ private extension ScopedInstruction where Self: UnaryInstruction {
       return false
     }
 
-    let areBeginAccessesSafe = analyzedInstructions.scopedInsts
-      .allSatisfy { otherScopedInst in
-        guard self != otherScopedInst else { return true }
+    // Instruction specific preconditions
+    switch self {
+    case is BeginAccessInst, is LoadBorrowInst:
+      guard (analyzedInstructions.scopedInsts
+        .allSatisfy { otherScopedInst in
+          guard self != otherScopedInst else { return true }
 
-        return operand.value.accessPath.isDistinct(from: otherScopedInst.operand.value.accessPath)
+          return operand.value.accessPath.isDistinct(from: otherScopedInst.operand.value.accessPath)
+        }) else {
+        return false
       }
-
-    guard areBeginAccessesSafe else { return false }
+    default:
+      break
+    }
 
     var scope = InstructionRange(begin: self, ends: endInstructions, context)
     defer { scope.deinitialize() }
-
-    for fullApplyInst in analyzedInstructions.fullApplies {
-      guard mayWriteToMemory && fullApplyInst.mayReadOrWrite(address: operand.value, context.aliasAnalysis) ||
-            !mayWriteToMemory && fullApplyInst.mayWrite(toAddress: operand.value, context.aliasAnalysis) else {
-        continue
-      }
-
-      // After hoisting the begin/end_access the apply will be within the scope, so it must not have a conflicting access.
-      if !scope.contains(fullApplyInst) {
-        return false
+    
+    // Instruction specific range related conditions
+    switch self {
+    case is BeginApplyInst:
+      return false // TODO: Add support. Like read-only apply hoist + end_apply sink.
+    case is LoadBorrowInst:
+      for storeInst in analyzedInstructions.stores {
+        if storeInst.mayWrite(toAddress: operand.value, context.aliasAnalysis) {
+          if !scope.contains(storeInst) {
+            return false
+          }
+        }
       }
-    }
+      
+      fallthrough
+    case is BeginAccessInst:
+      for fullApplyInst in analyzedInstructions.fullApplies {
+        guard mayWriteToMemory && fullApplyInst.mayReadOrWrite(address: operand.value, context.aliasAnalysis) ||
+              !mayWriteToMemory && fullApplyInst.mayWrite(toAddress: operand.value, context.aliasAnalysis) else {
+          continue
+        }
 
-    switch operand.value.accessPath.base {
-    case .class, .global:
-      for sideEffect in analyzedInstructions.loopSideEffects where sideEffect.mayRelease {
-        // Since a class might have a deinitializer, hoisting begin/end_access pair could violate
-        // exclusive access if the deinitializer accesses address used by begin_access.
-        if !scope.contains(sideEffect) {
+        // After hoisting the begin/end_access the apply will be within the scope, so it must not have a conflicting access.
+        if !scope.contains(fullApplyInst) {
           return false
         }
       }
+      
+      switch operand.value.accessPath.base {
+      case .class, .global:
+        for sideEffect in analyzedInstructions.loopSideEffects where sideEffect.mayRelease {
+          // Since a class might have a deinitializer, hoisting begin/end_access pair could violate
+          // exclusive access if the deinitializer accesses address used by begin_access.
+          if !scope.contains(sideEffect) {
+            return false
+          }
+        }
 
-      return true
+        return true
+      default:
+        return true
+      }
+    case is BeginBorrowInst, is StoreBorrowInst:
+      // Ensure the value is produced outside the loop.
+      return !loop.contains(block: operand.value.parentBlock)
     default:
-      return true
+      return false
     }
   }
 }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjectOutliner.swift

@@ -370,7 +370,7 @@ private func constructObject(of allocRef: AllocRefInstBase,
   // Create the initializers for the fields
   var objectArgs = [Value]()
   for store in storesToClassFields {
-    objectArgs.append(cloner.cloneRecursivelyToGlobal(value: store.source as! SingleValueInstruction))
+    objectArgs.append(cloner.cloneRecursively(globalInitValue: store.source as! SingleValueInstruction))
   }
   let globalBuilder = Builder(staticInitializerOf: global, context)
 
@@ -382,15 +382,15 @@ private func constructObject(of allocRef: AllocRefInstBase,
       for elementIdx in 0..<allocRef.numTailElements! {
         let tupleElems = (0..<numTailTupleElems).map { tupleIdx in
             let store = storesToTailElements[elementIdx * numTailTupleElems + tupleIdx]
-            return cloner.cloneRecursivelyToGlobal(value: store.source as! SingleValueInstruction)
+            return cloner.cloneRecursively(globalInitValue: store.source as! SingleValueInstruction)
         }
         let tuple = globalBuilder.createTuple(type: allocRef.tailAllocatedTypes[0], elements: tupleElems)
         objectArgs.append(tuple)
       }
     } else {
       // The non-tuple element case.
       for store in storesToTailElements {
-        objectArgs.append(cloner.cloneRecursivelyToGlobal(value: store.source as! SingleValueInstruction))
+        objectArgs.append(cloner.cloneRecursively(globalInitValue: store.source as! SingleValueInstruction))
       }
     }
   }

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyLoad.swift

@@ -107,7 +107,7 @@ extension LoadInst : OnoneSimplifiable, SILCombineSimplifiable {
     var cloner = Cloner(cloneBefore: self, context)
     defer { cloner.deinitialize() }
 
-    let initVal = cloner.cloneRecursivelyToGlobal(value: globalInitVal)
+    let initVal = cloner.cloneRecursively(globalInitValue: globalInitVal)
 
     uses.replaceAll(with: initVal, context)
     // Also erases a builtin "once" on which the global_addr depends on. This is fine

SwiftCompilerSources/Sources/SIL/Utilities/Cloner.swift

@@ -72,14 +72,14 @@ public struct Cloner<Context: MutatingContext> {
     return cloned
   }
 
-  public mutating func cloneRecursivelyToGlobal(value: Value) -> Value {
-    guard let cloned = cloneRecursively(value: value, customGetCloned: { value, cloner in
+  public mutating func cloneRecursively(globalInitValue: Value) -> Value {
+    guard let cloned = cloneRecursively(value: globalInitValue, customGetCloned: { value, cloner in
       guard let beginAccess = value as? BeginAccessInst else {
         return .defaultValue
       }
 
       // Skip access instructions, which might be generated for UnsafePointer globals which point to other globals.
-      let clonedOperand = cloner.cloneRecursivelyToGlobal(value: beginAccess.address)
+      let clonedOperand = cloner.cloneRecursively(globalInitValue: beginAccess.address)
       cloner.recordFoldedValue(beginAccess, mappedTo: clonedOperand)
       return .customValue(clonedOperand)
     }) else {

test/SILOptimizer/licm.sil

@@ -1643,6 +1643,31 @@ bb3:
   return %r : $()
 }
 
+// CHECK-LABEL: sil [ossa] @hoist_store_borrow :
+// CHECK:       bb0(%0 : @guaranteed $S):
+// CHECK-NEXT:    alloc_stack
+// CHECK-NEXT:    store_borrow
+// CHECK:       bb3:
+// CHECK-NEXT:    end_borrow
+// CHECK-NEXT:    dealloc_stack
+// CHECK:       } // end sil function 'hoist_store_borrow'
+sil [ossa] @hoist_store_borrow : $@convention(thin) (@guaranteed S) -> () {
+bb0(%0 : @guaranteed $S):
+  br bb1
+bb1:
+  %s = alloc_stack $S
+  %2 = store_borrow %0 to %s
+  fix_lifetime %2
+  end_borrow %2
+  dealloc_stack %s
+  cond_br undef, bb2, bb3
+bb2:
+  br bb1
+bb3:
+  %r = tuple ()
+  return %r : $()
+}
+
 sil @foo : $@convention(thin) (@guaranteed { var Int }) -> ()
 
 // CHECK-LABEL: sil [ossa] @test_begin_access : $@convention(thin) (Int) -> () {