Improve the AddressUtils and OwnershipLiveness APIs

Author: atrick

SwiftCompilerSources/Sources/Optimizer/Utilities/AddressUtils.swift

@@ -34,13 +34,19 @@ protocol AddressUseVisitor {
   /// An access scope: begin_access, begin_apply, load_borrow.
   mutating func scopedAddressUse(of operand: Operand) -> WalkResult
 
+  /// end_access, end_apply, abort_apply, end_borrow.
+  mutating func scopeEndingAddressUse(of operand: Operand) -> WalkResult
+
   /// A address leaf use cannot propagate the address bits beyond the
   /// instruction.
   ///
-  /// An apply or builtin propagates an address into the callee, but
-  /// it is considered a leaf use as long as the argument does not escape.
+  /// StoringInstructions are leaf uses.
   mutating func leafAddressUse(of operand: Operand) -> WalkResult
 
+  /// An address used by an apply.
+  mutating func appliedAddressUse(of operand: Operand, by apply: FullApplySite)
+    -> WalkResult
+
   /// A loaded address use propagates the value at the address.
   mutating func loadedAddressUse(of operand: Operand, into value: Value)
     -> WalkResult
@@ -67,10 +73,12 @@ extension AddressUseVisitor {
   /// protocol methods above.
   mutating func classifyAddress(operand: Operand) -> WalkResult {
     switch operand.instruction {
-    case is BeginAccessInst, is BeginApplyInst, is LoadBorrowInst,
-         is StoreBorrowInst:
+    case is BeginAccessInst, is LoadBorrowInst, is StoreBorrowInst:
       return scopedAddressUse(of: operand)
 
+    case is EndAccessInst, is EndApplyInst, is AbortApplyInst, is EndBorrowInst:
+      return scopeEndingAddressUse(of: operand)
+
     case let markDep as MarkDependenceInst:
       if markDep.valueOperand == operand {
         return projectedAddressUse(of: operand, into: markDep)
@@ -81,7 +89,7 @@ extension AddressUseVisitor {
       if markDep.type.isAddress {
         return projectedAddressUse(of: operand, into: markDep)
       }
-      if LifetimeDependence(markDependence: markDep, context) != nil {
+      if LifetimeDependence(markDep, context) != nil {
         // This is unreachable from InteriorUseVisitor because the
         // base address of a `mark_dependence [nonescaping]` must be a
         // `begin_access`, and interior liveness does not check uses of
@@ -97,7 +105,7 @@ extension AddressUseVisitor {
     case let pai as PartialApplyInst where !pai.isOnStack:
       return escapingAddressUse(of: operand)
 
-    case is AddressToPointerInst:
+    case is ReturnInst, is ThrowInst, is YieldInst, is AddressToPointerInst:
       return escapingAddressUse(of: operand)
 
     case is StructElementAddrInst, is TupleElementAddrInst,
@@ -113,16 +121,18 @@ extension AddressUseVisitor {
       let svi = operand.instruction as! SingleValueInstruction
       return projectedAddressUse(of: operand, into: svi)
 
-    case is ReturnInst, is ThrowInst, is YieldInst, is TryApplyInst,
-         is SwitchEnumAddrInst, is CheckedCastAddrBranchInst,
+    case let apply as FullApplySite:
+      return appliedAddressUse(of: operand, by: apply)
+
+    case is SwitchEnumAddrInst, is CheckedCastAddrBranchInst,
          is SelectEnumAddrInst, is InjectEnumAddrInst,
          is StoreInst, is StoreUnownedInst, is StoreWeakInst,
          is AssignInst, is AssignByWrapperInst, is AssignOrInitInst,
          is TupleAddrConstructorInst, is InitBlockStorageHeaderInst,
          is RetainValueAddrInst, is ReleaseValueAddrInst,
          is DestroyAddrInst, is DeallocStackInst, 
          is DeinitExistentialAddrInst,
-         is EndApplyInst, is IsUniqueInst, is MarkFunctionEscapeInst,
+         is IsUniqueInst, is MarkFunctionEscapeInst,
          is PackElementSetInst:
       return leafAddressUse(of: operand)
 

SwiftCompilerSources/Sources/Optimizer/Utilities/OwnershipLiveness.swift

@@ -631,6 +631,14 @@ extension InteriorUseWalker: AddressUseVisitor {
     return walkDownAddressUses(of: value)
   }
 
+  mutating func appliedAddressUse(of operand: Operand, by apply: FullApplySite)
+    -> WalkResult {
+    if apply is BeginApplyInst {
+      return scopedAddressUse(of: operand)
+    }
+    return leafAddressUse(of: operand)
+  }
+
   mutating func scopedAddressUse(of operand: Operand) -> WalkResult {
     switch operand.instruction {
     case let ba as BeginAccessInst:
@@ -664,6 +672,10 @@ extension InteriorUseWalker: AddressUseVisitor {
     }
   }
 
+  mutating func scopeEndingAddressUse(of operand: Operand) -> WalkResult {
+    return .continueWalk
+  }
+
   mutating func leafAddressUse(of operand: Operand) -> WalkResult {
     return .continueWalk
   }

SwiftCompilerSources/Sources/SIL/Utilities/AccessUtils.swift

@@ -575,6 +575,10 @@ extension Value {
 ///   %addr = struct_element_addr %base : $X, #X.e
 ///   store %v to [trivial] %addr : $*Int
 /// ```
+///
+/// Warning: This does not find the correct storage root of the
+/// lifetime of an object projection, such as .box or .class because
+/// ValueUseDefWalker ignores ownership and, for example, walks past copies.
 extension ValueUseDefWalker where Path == SmallProjectionPath {
   /// The main entry point.
   /// Given an `accessPath` where the access base is a reference (class, tail, box), call