[NFC] LifetimeCompletion: Clarify modes.

Completion is done along a boundary, either the availability or the
liveness boundary.  Represent which with a type.  Update docs and names.

Author: nate-chandler

include/swift/SIL/OSSALifetimeCompletion.h

@@ -50,22 +50,54 @@ class OSSALifetimeCompletion {
   OSSALifetimeCompletion(SILFunction *function, const DominanceInfo *domInfo)
     : domInfo(domInfo), completedValues(function) {}
 
+  // The kind of boundary at which to complete the lifetime.
+  //
+  // Liveness: "As early as possible."  Consume the value after the last
+  //           non-consuming uses.
+  // Availability: "As late as possible."  Consume the value in the last blocks
+  //               beyond the non-consuming uses in which the value has been
+  //               consumed on no incoming paths.
+  struct Boundary {
+    enum Value : uint8_t {
+      Liveness,
+      Availability,
+    };
+    Value value;
+
+    Boundary(Value value) : value(value){};
+    operator Value() const { return value; }
+
+    static std::optional<Boundary> getForcingLiveness(bool force) {
+      if (!force)
+        return {};
+      return {Liveness};
+    }
+
+    bool isLiveness() { return value == Liveness; }
+    bool isAvailable() { return !isLiveness(); }
+  };
+
   /// Insert a lifetime-ending instruction on every path to complete the OSSA
-  /// lifetime of \p value. Lifetime completion is only relevant for owned
+  /// lifetime of \p value along \p boundary.
+  ///
+  /// If \p boundary is not specified, the following boundary will be used:
+  ///   \p value is lexical -> Boundary::Availability
+  ///   \p value is non-lexical -> Boundary::Liveness
+  ///
+  /// Lifetime completion is only relevant for owned
   /// values or borrow introducers.
-  /// For lexical values lifetime is completed at unreachable instructions.
-  /// For non-lexical values lifetime is completed at the lifetime boundary.
-  /// When \p forceBoundaryCompletion is true, the client is able to guarantee
-  /// that lifetime completion of lexical values at the lifetime boundary is
-  /// sufficient.
-  /// Currently \p forceBoundaryCompletion is used by mem2reg and temprvalueopt
-  /// to complete lexical enum values on trivial paths.
+  ///
+  /// Currently \p boundary == {Boundary::Availability} is used by Mem2Reg and
+  /// TempRValueOpt and PredicatbleMemOpt to complete lexical enum values on
+  /// trivial paths.
+  ///
   /// Returns true if any new instructions were created to complete the
   /// lifetime.
   ///
   /// TODO: We also need to complete scoped addresses (e.g. store_borrow)!
   LifetimeCompletion
-  completeOSSALifetime(SILValue value, bool forceBoundaryCompletion = false) {
+  completeOSSALifetime(SILValue value,
+                       std::optional<Boundary> boundary = std::nullopt) {
     if (value->getOwnershipKind() == OwnershipKind::None)
       return LifetimeCompletion::NoLifetime;
 
@@ -80,7 +112,7 @@ class OSSALifetimeCompletion {
     if (!completedValues.insert(value))
       return LifetimeCompletion::AlreadyComplete;
 
-    return analyzeAndUpdateLifetime(value, forceBoundaryCompletion)
+    return analyzeAndUpdateLifetime(value, boundary)
                ? LifetimeCompletion::WasCompleted
                : LifetimeCompletion::AlreadyComplete;
   }
@@ -90,7 +122,8 @@ class OSSALifetimeCompletion {
       llvm::function_ref<void(SILInstruction *)> visit);
 
 protected:
-  bool analyzeAndUpdateLifetime(SILValue value, bool forceBoundaryCompletion);
+  bool analyzeAndUpdateLifetime(SILValue value,
+                                std::optional<Boundary> boundary);
 };
 
 //===----------------------------------------------------------------------===//

lib/SIL/Utils/OSSALifetimeCompletion.cpp

@@ -70,8 +70,8 @@ static SILInstruction *endOSSALifetime(SILValue value, SILBuilder &builder) {
   return builder.createEndBorrow(loc, value);
 }
 
-static bool endLifetimeAtBoundary(SILValue value,
-                                  const SSAPrunedLiveness &liveness) {
+static bool endLifetimeAtLivenessBoundary(SILValue value,
+                                          const SSAPrunedLiveness &liveness) {
   PrunedLivenessBoundary boundary;
   liveness.computeBoundary(boundary);
 
@@ -322,8 +322,9 @@ void OSSALifetimeCompletion::visitUnreachableLifetimeEnds(
   visitor.visitAvailabilityBoundary(result, visit);
 }
 
-static bool endLifetimeAtUnreachableBlocks(SILValue value,
-                                           const SSAPrunedLiveness &liveness) {
+static bool
+endLifetimeAtAvailabilityBoundary(SILValue value,
+                                  const SSAPrunedLiveness &liveness) {
   bool changed = false;
   OSSALifetimeCompletion::visitUnreachableLifetimeEnds(
       value, liveness, [&](auto *unreachable) {
@@ -337,12 +338,8 @@ static bool endLifetimeAtUnreachableBlocks(SILValue value,
 /// End the lifetime of \p value at unreachable instructions.
 ///
 /// Returns true if any new instructions were created to complete the lifetime.
-///
-/// This is only meant to cleanup lifetimes that lead to dead-end blocks. After
-/// recursively completing all nested scopes, it then simply ends the lifetime
-/// at the Unreachable instruction.
 bool OSSALifetimeCompletion::analyzeAndUpdateLifetime(
-    SILValue value, bool forceBoundaryCompletion) {
+    SILValue value, std::optional<Boundary> maybeBoundary) {
   // Called for inner borrows, inner adjacent reborrows, inner reborrows, and
   // scoped addresses.
   auto handleInnerScope = [this](SILValue innerBorrowedValue) {
@@ -351,11 +348,17 @@ bool OSSALifetimeCompletion::analyzeAndUpdateLifetime(
   InteriorLiveness liveness(value);
   liveness.compute(domInfo, handleInnerScope);
 
+  Boundary boundary = maybeBoundary.value_or(
+      value->isLexical() ? Boundary::Availability : Boundary::Liveness);
+
   bool changed = false;
-  if (value->isLexical() && !forceBoundaryCompletion) {
-    changed |= endLifetimeAtUnreachableBlocks(value, liveness.getLiveness());
-  } else {
-    changed |= endLifetimeAtBoundary(value, liveness.getLiveness());
+  switch (boundary) {
+  case Boundary::Availability:
+    changed |= endLifetimeAtAvailabilityBoundary(value, liveness.getLiveness());
+    break;
+  case Boundary::Liveness:
+    changed |= endLifetimeAtLivenessBoundary(value, liveness.getLiveness());
+    break;
   }
   // TODO: Rebuild outer adjacent phis on demand (SILGen does not currently
   // produce guaranteed phis). See FindEnclosingDefs &
@@ -374,9 +377,15 @@ static FunctionTest OSSALifetimeCompletionTest(
     "ossa-lifetime-completion",
     [](auto &function, auto &arguments, auto &test) {
       SILValue value = arguments.takeValue();
+      std::optional<OSSALifetimeCompletion::Boundary> kind = std::nullopt;
+      if (arguments.hasUntaken()) {
+        kind = arguments.takeBool()
+                   ? OSSALifetimeCompletion::Boundary::Liveness
+                   : OSSALifetimeCompletion::Boundary::Availability;
+      }
       llvm::outs() << "OSSA lifetime completion: " << value;
       OSSALifetimeCompletion completion(&function, /*domInfo*/ nullptr);
-      completion.completeOSSALifetime(value);
+      completion.completeOSSALifetime(value, kind);
       function.print(llvm::outs());
     });
 } // end namespace swift::test

lib/SILOptimizer/Mandatory/PredictableMemOpt.cpp

@@ -2673,10 +2673,11 @@ bool AllocOptimize::tryToRemoveDeadAllocation() {
     // Lexical enums can have incomplete lifetimes in non payload paths that
     // don't end in unreachable. Force their lifetime to end immediately after
     // the last use instead.
-    bool forceBoundaryCompletion = v->getType().isOrHasEnum();
+    auto boundary = OSSALifetimeCompletion::Boundary::getForcingLiveness(
+        v->getType().isOrHasEnum());
     LLVM_DEBUG(llvm::dbgs() << "Completing lifetime of: ");
     LLVM_DEBUG(v->dump());
-    completion.completeOSSALifetime(v, forceBoundaryCompletion);
+    completion.completeOSSALifetime(v, boundary);
   }
 
   return true;

lib/SILOptimizer/Transforms/SILMem2Reg.cpp

@@ -1754,7 +1754,8 @@ void StackAllocationPromoter::run(BasicBlockSetVector &livePhiBlocks) {
   for (auto it : valuesToComplete) {
     // Set forceBoundaryCompletion as true so that we complete at boundary for
     // lexical values as well.
-    completion.completeOSSALifetime(it, /* forceBoundaryCompletion */ true);
+    completion.completeOSSALifetime(it,
+                                    OSSALifetimeCompletion::Boundary::Liveness);
   }
 }
 

lib/SILOptimizer/Transforms/TempRValueElimination.cpp

@@ -964,7 +964,8 @@ void TempRValueOptPass::run() {
   // Call the utlity to complete ossa lifetime.
   OSSALifetimeCompletion completion(function, da->get(function));
   for (auto it : valuesToComplete) {
-    completion.completeOSSALifetime(it, /* forceBoundaryCompletion */ true);
+    completion.completeOSSALifetime(it,
+                                    OSSALifetimeCompletion::Boundary::Liveness);
   }
 }