Cleanup PrunedLiveness interface.

In preparation for adding OwnershipLiveness.

Rename Simple LiveRangeSummary to LiveRangeSummary.

Add initializeDefNode helpers to avoid confusion about the argument
type.

Add defBegin/defEnd iterators in MultiDefPrunedLiveness.

Author: atrick

include/swift/SIL/PrunedLiveness.h

@@ -410,21 +410,21 @@ inline InnerBorrowKind meet(InnerBorrowKind lhs, InnerBorrowKind rhs) {
 /// Summarize reborrows and pointer escapes that affect a live range. Reborrows
 /// and pointer escapes that are encapsulated in a nested borrow don't affect
 /// the outer live range.
-struct SimpleLiveRangeSummary {
+struct LiveRangeSummary {
   InnerBorrowKind innerBorrowKind;
   AddressUseKind addressUseKind;
 
-  SimpleLiveRangeSummary(): innerBorrowKind(InnerBorrowKind::Contained),
-                            addressUseKind(AddressUseKind::NonEscaping)
-  {}
+  LiveRangeSummary()
+      : innerBorrowKind(InnerBorrowKind::Contained),
+        addressUseKind(AddressUseKind::NonEscaping) {}
 
   void meet(const InnerBorrowKind lhs) {
     innerBorrowKind = swift::meet(innerBorrowKind, lhs);
   }
   void meet(const AddressUseKind lhs) {
     addressUseKind = swift::meet(addressUseKind, lhs);
   }
-  void meet(const SimpleLiveRangeSummary lhs) {
+  void meet(const LiveRangeSummary lhs) {
     meet(lhs.innerBorrowKind);
     meet(lhs.addressUseKind);
   }
@@ -601,13 +601,15 @@ class PrunedLiveRange : public PrunedLiveness {
   PrunedLiveRange(SmallVectorImpl<SILBasicBlock *> *discoveredBlocks = nullptr)
       : PrunedLiveness(discoveredBlocks) {}
 
-  SimpleLiveRangeSummary recursivelyUpdateForDef(SILValue initialDef,
-                                                 ValueSet &visited,
-                                                 SILValue value);
+  LiveRangeSummary recursivelyUpdateForDef(SILValue initialDef,
+                                           ValueSet &visited,
+                                           SILValue value);
 
 public:
-  /// Update liveness for all direct uses of \p def.
-  SimpleLiveRangeSummary updateForDef(SILValue def);
+  /// Update liveness for all direct uses of \p def. Transitively follows
+  /// guaranteed forwards up to but not including guaranteed phis. If \p def is
+  /// used by a guaranteed phi return InnerBorrowKind::Reborrowed.
+  LiveRangeSummary updateForDef(SILValue def);
 
   /// Check if \p inst occurs in between the definition this def and the
   /// liveness boundary.
@@ -716,7 +718,7 @@ class SSAPrunedLiveness : public PrunedLiveRange<SSAPrunedLiveness> {
   /// jointly-post dominate if dead-end blocks are present. Nested scopes may
   /// also lack scope-ending instructions, so the liveness of their nested uses
   /// may be ignored.
-  SimpleLiveRangeSummary computeSimple() {
+  LiveRangeSummary computeSimple() {
     assert(def && "SSA def uninitialized");
     return updateForDef(def);
   }
@@ -730,6 +732,13 @@ class MultiDefPrunedLiveness : public PrunedLiveRange<MultiDefPrunedLiveness> {
   NodeSetVector defs;
   BasicBlockSet defBlocks;
 
+  void initializeDefNode(SILNode *def) {
+    defs.insert(def);
+    auto *block = def->getParentBlock();
+    defBlocks.insert(block);
+    initializeDefBlock(block);
+  }
+
 public:
   MultiDefPrunedLiveness(
       SILFunction *function,
@@ -741,16 +750,25 @@ class MultiDefPrunedLiveness : public PrunedLiveRange<MultiDefPrunedLiveness> {
     llvm_unreachable("multi-def liveness cannot be reused");
   }
 
-  void initializeDef(SILNode *def) {
-    assert(isa<SILInstruction>(def) || isa<SILArgument>(def));
-    defs.insert(def);
-    auto *block = def->getParentBlock();
-    defBlocks.insert(block);
-    initializeDefBlock(block);
+  void initializeDef(SILInstruction *defInst) {
+    initializeDefNode(defInst->asSILNode());
+  }
+
+  void initializeDef(SILArgument *defArg) { initializeDefNode(defArg); }
+
+  void initializeDef(SILValue value) {
+    if (auto arg = dyn_cast<SILArgument>(value)) {
+      initializeDefNode(arg);
+    } else {
+      initializeDef(value->getDefiningInstruction());
+    }
   }
 
   bool isInitialized() const { return !defs.empty(); }
 
+  NodeSetVector::iterator defBegin() const { return defs.begin(); }
+  NodeSetVector::iterator defEnd() const { return defs.end(); }
+
   bool isDef(SILInstruction *inst) const {
     return defs.contains(cast<SILNode>(inst));
   }
@@ -779,7 +797,7 @@ class MultiDefPrunedLiveness : public PrunedLiveRange<MultiDefPrunedLiveness> {
   /// jointly-post dominate if dead-end blocks are present. Nested scopes may
   /// also lack scope-ending instructions, so the liveness of their nested uses
   /// may be ignored.
-  SimpleLiveRangeSummary computeSimple();
+  LiveRangeSummary computeSimple();
 };
 
 //===----------------------------------------------------------------------===//

lib/SIL/Utils/OwnershipUtils.cpp

@@ -1131,7 +1131,7 @@ bool AddressOwnership::areUsesWithinLifetime(
   // Compute the reference value's liveness.
   SSAPrunedLiveness liveness;
   liveness.initializeDef(root);
-  SimpleLiveRangeSummary summary = liveness.computeSimple();
+  LiveRangeSummary summary = liveness.computeSimple();
   // Conservatively ignore InnerBorrowKind::Reborrowed and
   // AddressUseKind::PointerEscape and Reborrowed. The resulting liveness at
   // least covers the known uses.

lib/SIL/Utils/PrunedLiveness.cpp

@@ -275,18 +275,15 @@ void PrunedLivenessBoundary::visitInsertionPoints(
 //===----------------------------------------------------------------------===//
 
 template <typename LivenessWithDefs>
-SimpleLiveRangeSummary
-PrunedLiveRange<LivenessWithDefs>::updateForDef(SILValue def) {
+LiveRangeSummary PrunedLiveRange<LivenessWithDefs>::updateForDef(SILValue def) {
   ValueSet visited(def->getFunction());
   return recursivelyUpdateForDef(def, visited, def);
 }
 
 template <typename LivenessWithDefs>
-SimpleLiveRangeSummary
-PrunedLiveRange<LivenessWithDefs>::recursivelyUpdateForDef(SILValue initialDef,
-                                                           ValueSet &visited,
-                                                           SILValue value) {
-  SimpleLiveRangeSummary summary;
+LiveRangeSummary PrunedLiveRange<LivenessWithDefs>::recursivelyUpdateForDef(
+    SILValue initialDef, ValueSet &visited, SILValue value) {
+  LiveRangeSummary summary;
 
   if (!visited.insert(value))
     return summary;
@@ -620,10 +617,10 @@ void MultiDefPrunedLiveness::findBoundariesInBlock(
          && "findBoundariesInBlock must be called on a live block");
 }
 
-SimpleLiveRangeSummary MultiDefPrunedLiveness::computeSimple() {
+LiveRangeSummary MultiDefPrunedLiveness::computeSimple() {
   assert(isInitialized() && "defs uninitialized");
 
-  SimpleLiveRangeSummary summary;
+  LiveRangeSummary summary;
   for (SILNode *defNode : defs) {
     if (auto *arg = dyn_cast<SILArgument>(defNode))
       summary.meet(updateForDef(arg));

lib/SILOptimizer/Mandatory/MoveKillsCopyableAddressesChecker.cpp

@@ -722,7 +722,7 @@ void ClosureArgDataflowState::classifyUses(BasicBlockSet &initBlocks,
   for (auto *user : useState.inits) {
     if (upwardScanForInit(user, useState)) {
       LLVM_DEBUG(llvm::dbgs() << "    Found init block at: " << *user);
-      livenessForConsumes.initializeDef(cast<SILNode>(user));
+      livenessForConsumes.initializeDef(user);
       initBlocks.insert(user->getParent());
     }
   }

lib/SILOptimizer/Mandatory/MoveKillsCopyableValuesChecker.cpp

@@ -165,10 +165,8 @@ bool CheckerLivenessInfo::compute() {
         // just mark it as extending liveness and look through it.
         liveness.updateForUse(user, /*lifetimeEnding*/ false);
         ForwardingOperand(use).visitForwardedValues([&](SILValue result) {
-          if (auto *arg = dyn_cast<SILPhiArgument>(result)) {
-            if (arg->isTerminatorResult()) {
-              return true;
-            }
+          if (SILArgument::isTerminatorResult(result)) {
+            return true;
           }
           if (result->getOwnershipKind() == OwnershipKind::Guaranteed)
             defUseWorklist.insert(result);

lib/SILOptimizer/UtilityPasses/UnitTestRunner.cpp

@@ -301,7 +301,7 @@ struct SSALivenessTest : UnitTest {
     SmallVector<SILBasicBlock *, 8> discoveredBlocks;
     SSAPrunedLiveness liveness(&discoveredBlocks);
     liveness.initializeDef(value);
-    SimpleLiveRangeSummary summary = liveness.computeSimple();
+    LiveRangeSummary summary = liveness.computeSimple();
     if (summary.innerBorrowKind == InnerBorrowKind::Reborrowed)
       llvm::outs() << "Incomplete liveness: Reborrowed inner scope\n";