Merge pull request #61558 from atrick/scoped-liveness

Handle scoped address in PrunedLiveness

Author: atrick

include/swift/SIL/PrunedLiveness.h

@@ -83,6 +83,34 @@
 /// | Use | [LiveWithin]
 ///  -----
 ///
+/// ---------------------------------------------------------------------------
+///
+/// "Use points" are the instructions that "generate" liveness for a given
+/// operand. A generalized use point visitor would look like this:
+///
+/// Given an \p operand, visit the use points relevant for liveness. For most
+/// operands, this is simply the user instruction. For scoped operands, each
+/// scope-ending instruction is a separate use point.
+/// template<typename Operation>
+/// inline bool visitUsePoints(Operand *use, Operation visitUsePoint) {
+///   // Handle TrivialUse operands: begin_access & store_borrow address
+///   // Handle InteriorPointer operands: store_borrow source
+///   if (auto scopedAddress = ScopedAddressValue::forUse(use)) {
+///     return scopedAddress.visitScopeEndingUses(visitUsePoint);
+///   }
+///   // Handle Borrow operands...
+///   // Handles borrow scope introducers: begin_borrow & load_borrow.
+///   // Handles guaranteed return values: begin_apply.
+///   if (!BorrowingOperand(operand).visitScopeEndingUses([this](Operand *end) {
+///     if (!visitUsePoint(end))
+///       return false;
+///     return true;
+///   }
+///   return visitUsePoint(use);
+/// }
+///
+/// The visitors that switch on OperandOwnership use a specialized
+/// implementation because each case above is specific to an ownership case.
 //===----------------------------------------------------------------------===//
 
 #ifndef SWIFT_SILOPTIMIZER_UTILS_PRUNEDLIVENESS_H

include/swift/SIL/ScopedAddressUtils.h

@@ -74,6 +74,15 @@ struct ScopedAddressValue {
     return kind != ScopedAddressValueKind::Invalid && value;
   }
 
+  // Both the store_borrow source and address operands are effectively used for
+  // the duration of the address scope.
+  static ScopedAddressValue forUse(Operand *use) {
+    if (auto svi = dyn_cast<SingleValueInstruction>(use->getUser()))
+      return ScopedAddressValue(svi);
+
+    return ScopedAddressValue();
+  }
+
   void print(llvm::raw_ostream &os) const;
   SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
 

lib/SIL/Utils/PrunedLiveness.cpp

@@ -136,14 +136,12 @@ InnerBorrowKind PrunedLiveness::updateForBorrowingOperand(Operand *operand) {
 AddressUseKind PrunedLiveness::checkAndUpdateInteriorPointer(Operand *operand) {
   assert(operand->getOperandOwnership() == OperandOwnership::InteriorPointer);
 
-  if (auto *svi = dyn_cast<SingleValueInstruction>(operand->getUser())) {
-    if (auto scopedAddress = ScopedAddressValue(svi)) {
-      scopedAddress.visitScopeEndingUses([this](Operand *end) {
-        updateForUse(end->getUser(), /*lifetimeEnding*/ false);
-        return true;
-      });
-      return AddressUseKind::NonEscaping;
-    }
+  if (auto scopedAddress = ScopedAddressValue::forUse(operand)) {
+    scopedAddress.visitScopeEndingUses([this](Operand *end) {
+      updateForUse(end->getUser(), /*lifetimeEnding*/ false);
+      return true;
+    });
+    return AddressUseKind::NonEscaping;
   }
   // FIXME: findTransitiveUses should be a visitor so we're not recursively
   // allocating use vectors and potentially merging the use points.
@@ -152,6 +150,10 @@ AddressUseKind PrunedLiveness::checkAndUpdateInteriorPointer(Operand *operand) {
   for (auto *use : uses) {
     updateForUse(use->getUser(), /*lifetimeEnding*/ false);
   }
+  if (uses.empty()) {
+    // Handle a dead address
+    updateForUse(operand->getUser(), /*lifetimeEnding*/ false);
+  }
   return useKind;
 }
 
@@ -303,6 +305,16 @@ SimpleLiveRangeSummary PrunedLiveRange<LivenessWithDefs>::updateForDef(SILValue
       });
       break;
     }
+    case OperandOwnership::TrivialUse: {
+      if (auto scopedAddress = ScopedAddressValue::forUse(use)) {
+        scopedAddress.visitScopeEndingUses([this](Operand *end) {
+          updateForUse(end->getUser(), /*lifetimeEnding*/false);
+          return true;
+        });
+      }
+      updateForUse(use->getUser(), /*lifetimeEnding*/false);
+      break;
+    }
     default:
       updateForUse(use->getUser(), use->isLifetimeEnding());
       break;

test/SILOptimizer/ossa_lifetime_analysis.sil

@@ -22,6 +22,7 @@ case some(T)
 class C {}
 class D {
   var object: C
+  @_borrowed @_hasStorage var borrowed: C { get set }
 }
 
 // CHECK-LABEL: @testSelfLoop
@@ -132,3 +133,45 @@ bb0(%0 : @owned $D):
   %99 = tuple()
   return %99 : $()
 }
+
+// CHECK-LABEL: @testGuaranteedResult
+// CHECK: SSA lifetime analysis: %0 = argument of bb0 : $D
+// CHECK: bb0: LiveWithin
+// CHECK: last user:   end_apply
+sil [ossa] @testGuaranteedResult : $@convention(thin) (@guaranteed D) -> () {
+bb0(%0 : @guaranteed $D):
+  debug_value [trace] %0 : $D
+  %2 = class_method %0 : $D, #D.borrowed!read : (D) -> () -> (), $@yield_once @convention(method) (@guaranteed D) -> @yields @guaranteed C
+  (%3, %4) = begin_apply %2(%0) : $@yield_once @convention(method) (@guaranteed D) -> @yields @guaranteed C
+  end_apply %4
+  %99 = tuple()
+  return %99 : $()
+}
+
+// CHECK-LABEL: @testScopedAddress
+// CHECK: SSA lifetime analysis: %{{.*}} = ref_element_addr %0
+// CHECK: bb0: LiveWithin
+// CHECK: last user: end_access
+sil [ossa] @testScopedAddress : $@convention(thin) (@guaranteed D) -> () {
+bb0(%0 : @guaranteed $D):
+  %f = ref_element_addr %0 : $D, #D.object
+  debug_value [trace] %f : $*C
+  %access = begin_access [read] [static] %f : $*C
+  %o = load [copy] %access : $*C
+  end_access %access : $*C
+  destroy_value %o : $C
+  %99 = tuple()
+  return %99 : $()
+}
+
+// CHECK-LABEL: @testDeadAddress
+// CHECK: SSA lifetime analysis: %0 = argument of bb0 : $D
+// CHECK: bb0: LiveWithin
+// CHECK: last user: %{{.*}} = ref_element_addr
+sil [ossa] @testDeadAddress : $@convention(thin) (@guaranteed D) -> () {
+bb0(%0 : @guaranteed $D):
+  debug_value [trace] %0 : $D
+  %f = ref_element_addr %0 : $D, #D.object
+  %99 = tuple()
+  return %99 : $()
+}