Add AccessBase.storeBorrow.

Don't treat StoreBorrow addresses as unknown bases. While they are never the base of a formal access, they are returned
as the AccessBase when querying the enclosing scope of an address.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -297,6 +297,8 @@ private struct LifetimeVariable {
       // TODO: bridge VarDecl for FunctionConvention.Yields
       self.varDecl = nil
       self.sourceLoc = result.parentInstruction.location.sourceLoc
+    case .storeBorrow(let sb):
+      self = .init(dependent: sb.source, context)
     case .pointer(let ptrToAddr):
       self.varDecl = nil
       self.sourceLoc = ptrToAddr.location.sourceLoc

SwiftCompilerSources/Sources/Optimizer/ModulePasses/StackProtection.swift

@@ -455,7 +455,7 @@ private extension AccessBase {
 
   var isStackAllocated: IsStackAllocatedResult {
     switch self {
-      case .stack:
+      case .stack, .storeBorrow:
         return .yes
       case .box, .global:
         return .no

SwiftCompilerSources/Sources/Optimizer/Utilities/AddressUtils.swift

@@ -458,6 +458,8 @@ enum AddressOwnershipLiveRange : CustomStringConvertible {
       default:
         return nil
       }
+    case .storeBorrow(let sb):
+      return computeValueLiveRange(of: sb.source, context)
     case .pointer, .unidentified:
       return nil
     }

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -369,6 +369,11 @@ extension LifetimeDependence.Scope {
         }
       case let .yield(result):
         self = Self(yield: result)
+      case .storeBorrow(let sb):
+        guard let scope = Self(base: sb.source, context) else {
+          return nil
+        }
+        self = scope
       case .pointer, .unidentified:
         self = .unknown(address)
       }
@@ -1084,7 +1089,8 @@ extension LifetimeDependenceDefUseWalker {
         return returnedDependence(address: arg, using: operand)
       }
       break
-    case .global, .class, .tail, .yield, .pointer, .unidentified:
+    case .global, .class, .tail, .yield, .storeBorrow, .pointer, .unidentified:
+      // An address produced by .storeBorrow should never be stored into.
       break
     }
     if let allocation = allocation {

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -1230,7 +1230,15 @@ final public class BeginBorrowInst : SingleValueInstruction, UnaryInstruction, B
 
 final public class LoadBorrowInst : SingleValueInstruction, LoadInstruction, BorrowIntroducingInstruction {}
 
-final public class StoreBorrowInst : SingleValueInstruction, StoringInstruction, BorrowIntroducingInstruction { }
+final public class StoreBorrowInst : SingleValueInstruction, StoringInstruction, BorrowIntroducingInstruction {
+  var allocStack: AllocStackInst {
+    var dest = destination
+    if let mark = dest as? MarkUnresolvedNonCopyableValueInst {
+      dest = mark.operand.value
+    }
+    return dest as! AllocStackInst
+  }
+}
 
 final public class BeginAccessInst : SingleValueInstruction, UnaryInstruction {
   // The raw values must match SILAccessKind.

SwiftCompilerSources/Sources/SIL/Utilities/AccessUtils.swift

@@ -69,6 +69,12 @@ public enum AccessBase : CustomStringConvertible, Hashable {
   /// An indirect result of a `begin_apply`.
   case yield(MultipleValueInstructionResult)
 
+  /// store_borrow is never the base of a formal access, but calling Value.enclosingScope on an arbitrary address will
+  /// return it as the accessBase. A store_borrow always stores into an alloc_stack, but it is handled separately
+  /// because it may be useful for clients to know which value was stored in the temporary stack location for the
+  /// duration of this borrow scope.
+  case storeBorrow(StoreBorrowInst)
+
   /// An address which is derived from a `Builtin.RawPointer`.
   case pointer(PointerToAddressInst)
 
@@ -90,6 +96,8 @@ public enum AccessBase : CustomStringConvertible, Hashable {
       } else {
         self = .unidentified
       }
+    case let sb as StoreBorrowInst:
+      self = .storeBorrow(sb)
     default:
       self = .unidentified
     }
@@ -105,6 +113,7 @@ public enum AccessBase : CustomStringConvertible, Hashable {
       case .tail(let rta):     return "tail - \(rta.instance)"
       case .argument(let arg): return "argument - \(arg)"
       case .yield(let result): return "yield - \(result)"
+      case .storeBorrow(let sb): return "storeBorrow - \(sb)"
       case .pointer(let p):    return "pointer - \(p)"
     }
   }
@@ -114,7 +123,7 @@ public enum AccessBase : CustomStringConvertible, Hashable {
     switch self {
       case .class, .tail:
         return true
-      case .box, .stack, .global, .argument, .yield, .pointer, .unidentified:
+      case .box, .stack, .global, .argument, .yield, .storeBorrow, .pointer, .unidentified:
         return false
     }
   }
@@ -125,7 +134,7 @@ public enum AccessBase : CustomStringConvertible, Hashable {
       case .box(let pbi):      return pbi.box
       case .class(let rea):    return rea.instance
       case .tail(let rta):     return rta.instance
-      case .stack, .global, .argument, .yield, .pointer, .unidentified:
+      case .stack, .global, .argument, .yield, .storeBorrow, .pointer, .unidentified:
         return nil
     }
   }
@@ -153,7 +162,7 @@ public enum AccessBase : CustomStringConvertible, Hashable {
     switch self {
       case .class(let rea):    return rea.fieldIsLet
       case .global(let g):     return g.isLet
-      case .box, .stack, .tail, .argument, .yield, .pointer, .unidentified:
+      case .box, .stack, .tail, .argument, .yield, .storeBorrow, .pointer, .unidentified:
         return false
     }
   }
@@ -164,7 +173,7 @@ public enum AccessBase : CustomStringConvertible, Hashable {
     case .box(let pbi):      return pbi.box.referenceRoot is AllocBoxInst
     case .class(let rea):    return rea.instance.referenceRoot is AllocRefInstBase
     case .tail(let rta):     return rta.instance.referenceRoot is AllocRefInstBase
-    case .stack:             return true
+    case .stack, .storeBorrow: return true
     case .global, .argument, .yield, .pointer, .unidentified:
       return false
     }
@@ -173,7 +182,7 @@ public enum AccessBase : CustomStringConvertible, Hashable {
   /// True, if the kind of storage of the access is known (e.g. a class property, or global variable).
   public var hasKnownStorageKind: Bool {
     switch self {
-      case .box, .class, .tail, .stack, .global:
+      case .box, .class, .tail, .stack, .storeBorrow, .global:
         return true
       case .argument, .yield, .pointer, .unidentified:
         return false
@@ -203,6 +212,8 @@ public enum AccessBase : CustomStringConvertible, Hashable {
       return arg1 == arg2
     case (.yield(let baResult1), .yield(let baResult2)):
       return baResult1 == baResult2
+    case (.storeBorrow(let sb1), .storeBorrow(let sb2)):
+      return sb1 == sb2
     case (.pointer(let p1), .pointer(let p2)):
       return p1 == p2
     default:
@@ -260,6 +271,15 @@ public enum AccessBase : CustomStringConvertible, Hashable {
     case (_, .argument(let otherArg)):
       return argIsDistinct(otherArg, from: self)
 
+    case (.storeBorrow(let arg), .storeBorrow(let otherArg)):
+      return arg.allocStack != otherArg.allocStack
+
+    // A StoreBorrow location can only be used by other StoreBorrows.
+    case (.storeBorrow, _):
+      return true
+    case (_, .storeBorrow):
+      return true
+
     default:
       // As we already handled pairs of the same kind, here we handle pairs with different kinds.
       // Different storage kinds cannot alias, regardless where the storage comes from.
@@ -591,7 +611,7 @@ extension ValueUseDefWalker where Path == SmallProjectionPath {
         return walkUp(value: rea.instance, path: path.push(.classField, index: rea.fieldIndex)) != .abortWalk
       case .tail(let rta):
         return walkUp(value: rta.instance, path: path.push(.tailElements, index: 0)) != .abortWalk
-      case .stack, .global, .argument, .yield, .pointer, .unidentified:
+      case .stack, .global, .argument, .yield, .storeBorrow, .pointer, .unidentified:
         return false
     }
   }

test/SILOptimizer/accessutils.sil

@@ -27,6 +27,10 @@ struct Ptr {
   var p: Int64
 }
 
+class C {}
+
+sil @_getC : $@convention(thin) () -> @owned C
+
 // CHECK-LABEL: Accesses for readIdentifiedArg
 // CHECK-NEXT: Value: %0 = argument of bb0 : $*Int64
 // CHECK-NEXT:   Scope: base
@@ -522,3 +526,24 @@ bb0(%twoInts: $*TwoInts):
   %200 = tuple ()
   return %200 : $()
 }
+
+// CHECK-LABEL: Accesses for storeBorrow
+// CHECK: Value:   [[SB:%.*]] = store_borrow %0 to [[DEST:%.*]] : $*C
+// CHECK:   Scope: base
+// CHECK:   Base: storeBorrow -   [[SB]] = store_borrow %0 to [[DEST]] : $*C
+// CHECK:   Path: ""
+// CHECK:    no Storage paths
+// CHECK-LABEL: End accesses for storeBorrow
+sil [ossa] @storeBorrow : $@convention(thin) (@guaranteed C) -> @owned C {
+bb0(%0 : @guaranteed $C):
+  %1 = alloc_stack $C
+  %2 = store_borrow %0 to %1 : $*C
+  %3 = function_ref @_getC : $@convention(thin) () -> @owned C
+  %4 = apply %3() : $@convention(thin) () -> @owned C
+  %5 = mark_dependence [unresolved] %4 : $C on %2 : $*C
+  %6 = load [copy] %2 : $*C
+  destroy_value %5 : $C
+  end_borrow %2 : $*C
+  dealloc_stack %1 : $*C
+  return %6 : $C
+}