Merge pull request #36465 from atrick/ossa-guaranteed-phi

Author: swift-ci

include/swift/SIL/OwnershipUtils.h

@@ -75,6 +75,31 @@ inline bool isForwardingConsume(SILValue value) {
   return canOpcodeForwardOwnedValues(value);
 }
 
+/// Find all "use points" of \p guaranteedValue that determine its lifetime
+/// requirement.
+///
+/// Precondition: \p guaranteedValue is not a BorrowedValue.
+///
+/// In general, if the client does not know whether \p guaranteed value
+/// introduces a borrow scope or not, it should instead call
+/// findTransitiveGuaranteedUses() which efficiently gathers use
+/// points for arbitrary guaranteed values, including those that introduce a
+/// borrow scope and may be reborrowed.
+///
+/// In valid OSSA, this should never be called on values that introduce a new
+/// scope (doing so would be extremely innefficient). The lifetime of a borrow
+/// introducing instruction is always determined by its direct EndBorrow uses
+/// (see BorrowedValue::visitLocalScopeEndingUses). None of the non-scope-ending
+/// uses are relevant, and there's no need to transively follow forwarding
+/// uses. However, this utility may be used on borrow-introducing values when
+/// updating OSSA form to place EndBorrow uses after introducing new phis.
+///
+/// When this is called on a value that does not introduce a new scope, none of
+/// the use points can be EndBorrows or Reborrows. Those uses are only allowed
+/// on borrow-introducing values.
+bool findInnerTransitiveGuaranteedUses(SILValue guaranteedValue,
+                                       SmallVectorImpl<Operand *> &usePoints);
+
 /// Find all "use points" of a guaranteed value within its enclosing borrow
 /// scope (without looking through reborrows). To find the use points of the
 /// extended borrow scope, after looking through reborrows, use
@@ -101,7 +126,7 @@ inline bool isForwardingConsume(SILValue value) {
 /// 2. If \p guaranteedValue does not introduce a borrow scope (it is not a
 /// valid BorrowedValue), then its uses are discovered transitively by looking
 /// through forwarding operations. If any use is a PointerEscape, then this
-/// returns false without adding more uses--the guaranteed values lifetime is
+/// returns false without adding more uses--the guaranteed value's lifetime is
 /// indeterminite. If a use introduces a nested borrow scope, it creates use
 /// points where the "extended" borrow scope ends. An extended borrow
 /// scope is found by looking through any reborrows that end the nested

include/swift/SIL/SILArgument.h

@@ -117,6 +117,9 @@ class SILArgument : public ValueBase {
   /// opposed to a cast or projection.
   bool isPhiArgument() const;
 
+  /// Return true if this block argument is a terminator result.
+  bool isTerminatorResult() const;
+
   /// If this argument is a phi, return the incoming phi value for the given
   /// predecessor BB. If this argument is not a phi, return an invalid SILValue.
   SILValue getIncomingPhiValue(SILBasicBlock *predBlock) const;
@@ -178,6 +181,10 @@ class SILArgument : public ValueBase {
   /// terminator has a single operand, return that terminator.
   TermInst *getSingleTerminator() const;
 
+  /// Return the terminator instruction for which this argument is a result,
+  /// otherwise return nullptr.
+  TermInst *getTerminatorForResultArg() const;
+
   /// Return the SILArgumentKind of this argument.
   SILArgumentKind getKind() const {
     return SILArgumentKind(ValueBase::getKind());
@@ -208,6 +215,9 @@ class SILPhiArgument : public SILArgument {
   /// opposed to a cast or projection.
   bool isPhiArgument() const;
 
+  /// Return true if this block argument is a terminator result.
+  bool isTerminatorResult() const { return !isPhiArgument(); }
+
   /// If this argument is a phi, return the incoming phi value for the given
   /// predecessor BB. If this argument is not a phi, return an invalid SILValue.
   ///
@@ -283,6 +293,10 @@ class SILPhiArgument : public SILArgument {
   /// terminator has a single operand, return that terminator.
   TermInst *getSingleTerminator() const;
 
+  /// Return the terminator instruction for which this argument is a result,
+  /// otherwise return nullptr.
+  TermInst *getTerminatorForResultArg() const;
+
   static bool classof(const SILInstruction *) = delete;
   static bool classof(const SILUndef *) = delete;
   static bool classof(SILNodePointer node) {
@@ -347,6 +361,16 @@ inline bool SILArgument::isPhiArgument() const {
   llvm_unreachable("Covered switch is not covered?!");
 }
 
+inline bool SILArgument::isTerminatorResult() const {
+  switch (getKind()) {
+  case SILArgumentKind::SILPhiArgument:
+    return cast<SILPhiArgument>(this)->isTerminatorResult();
+  case SILArgumentKind::SILFunctionArgument:
+    return false;
+  }
+  llvm_unreachable("Covered switch is not covered?!");
+}
+
 inline SILValue
 SILArgument::getIncomingPhiValue(SILBasicBlock *predBlock) const {
   switch (getKind()) {
@@ -417,6 +441,16 @@ inline TermInst *SILArgument::getSingleTerminator() const {
   llvm_unreachable("Covered switch is not covered?!");
 }
 
+inline TermInst *SILArgument::getTerminatorForResultArg() const {
+  switch (getKind()) {
+  case SILArgumentKind::SILPhiArgument:
+    return cast<SILPhiArgument>(this)->getTerminatorForResultArg();
+  case SILArgumentKind::SILFunctionArgument:
+    return nullptr;
+  }
+  llvm_unreachable("Covered switch is not covered?!");
+}
+
 inline bool SILArgument::getIncomingPhiOperands(
     SmallVectorImpl<Operand *> &returnedPhiOperands) const {
   switch (getKind()) {

include/swift/SILOptimizer/Utils/BasicBlockOptUtils.h

@@ -83,6 +83,19 @@ bool rotateLoop(SILLoop *loop, DominanceInfo *domInfo, SILLoopInfo *loopInfo,
                 bool rotateSingleBlockLoops, SILBasicBlock *upToBB,
                 bool shouldVerify);
 
+//===----------------------------------------------------------------------===//
+//                             BasicBlock Cloning
+//===----------------------------------------------------------------------===//
+
+/// Return true if the \p termInst can be cloned. If termInst produces a
+/// guaranteed result, then it must be possible to create a nested borrow scope
+/// for that result when the cloner generates a guaranteed phi.
+///
+/// Note: if all the terminators uses will also be cloned, then a guaranteed phi
+/// won't be necessary. This is one of the reasons that cloning a region is much
+/// better than cloning a single block at a time.
+bool canCloneTerminator(TermInst *termInst);
+
 /// Sink address projections to their out-of-block uses. This is
 /// required after cloning a block and before calling
 /// updateSSAAfterCloning to avoid address-type phis.
@@ -173,6 +186,7 @@ class BasicBlockCloner : public SILCloner<BasicBlockCloner> {
       if (!canCloneInstruction(&inst))
         return false;
     }
+    canCloneTerminator(origBB->getTerminator());
     return true;
   }
 
@@ -221,17 +235,34 @@ class BasicBlockCloner : public SILCloner<BasicBlockCloner> {
     bi->eraseFromParent();
   }
 
+  /// Create phis and maintain OSSA invariants.
+  ///
+  /// Note: This must be called after calling cloneBlock or cloneBranchTarget,
+  /// before using any OSSA utilities.
+  ///
+  /// The client may perform arbitrary branch fixups and dead block removal
+  /// after cloning and before calling this.
+  ///
+  /// WARNING: If client converts terminator results to phis (e.g. replaces a
+  /// switch_enum with a branch), then it must call this before performing that
+  /// transformation, or fix the OSSA representation of that value itself.
+  void updateOSSAAfterCloning();
+
   /// Get the newly cloned block corresponding to `origBB`.
   SILBasicBlock *getNewBB() {
     return remapBasicBlock(origBB);
   }
 
   bool wasCloned() { return isBlockCloned(origBB); }
 
-  /// Helper function to perform SSA updates after calling cloneBranchTarget.
-  void updateSSAAfterCloning();
-
 protected:
+  /// Helper function to perform SSA updates used by updateOSSAAfterCloning.
+  void updateSSAAfterCloning(SmallVectorImpl<SILPhiArgument *> &newPhis);
+
+  /// Given a terminator result, either from the original or the cloned block,
+  /// update OSSA for any phis created for the result during edge splitting.
+  void updateOSSATerminatorResult(SILPhiArgument *termResult);
+
   // MARK: CRTP overrides.
 
   /// Override getMappedValue to allow values defined outside the block to be

include/swift/SILOptimizer/Utils/OwnershipOptUtils.h

@@ -37,6 +37,19 @@ inline bool requiresOSSACleanup(SILValue v) {
 // Defined in BasicBlockUtils.h
 struct JointPostDominanceSetComputer;
 
+/// Given a new phi that may use a guaranteed value, create nested borrow scopes
+/// for its incoming operands and end_borrows that cover the phi's extended
+/// borrow scope, which transitively includes any phis that use this phi.
+///
+/// Returns true if any changes were made.
+///
+/// Note: \p newPhi itself might not have Guaranteed ownership. A phi that
+/// converts Guaranteed to None ownership still needs nested borrows.
+///
+/// Note: This may be called on partially invalid OSSA form, where multiple
+/// newly created phis do not yet have a borrow scope.
+bool createBorrowScopeForPhiOperands(SILPhiArgument *newPhi);
+
 /// A struct that contains context shared in between different operation +
 /// "ownership fixup" utilities. Please do not put actual methods on this, it is
 /// meant to be composed with.

lib/SIL/IR/SILArgument.cpp

@@ -316,6 +316,14 @@ TermInst *SILPhiArgument::getSingleTerminator() const {
   return const_cast<SILBasicBlock *>(predBlock)->getTerminator();
 }
 
+TermInst *SILPhiArgument::getTerminatorForResultArg() const {
+  if (auto *termInst = getSingleTerminator()) {
+    if (!isa<BranchInst>(termInst) && !isa<CondBranchInst>(termInst))
+      return termInst;
+  }
+  return nullptr;
+}
+
 SILPhiArgument *BranchInst::getArgForOperand(const Operand *oper) {
   assert(oper->getUser() == this);
   return cast<SILPhiArgument>(

lib/SIL/Utils/OwnershipUtils.cpp

@@ -147,21 +147,18 @@ bool swift::canOpcodeForwardOwnedValues(Operand *use) {
 //                 Guaranteed Use-Point (Lifetime) Discovery
 //===----------------------------------------------------------------------===//
 
-// Find all use points of \p guaranteedValue within its borrow scope where \p
-// guaranteedValue is not itself a BorrowedValue (it does not introduce a borrow
-// scope). This means there is no need to consider reborrows, and all uses are
-// naturally dominated by \p guaranteedValue. On the other hand, if a
-// PointerEscape is found, then no assumption can be made about \p
-// guaranteedValue's lifetime. Therefore the use points are incomplete and this
-// returns false.
+// Find all use points of \p guaranteedValue within its borrow scope. All uses
+// are naturally dominated by \p guaranteedValue. If a PointerEscape is found,
+// then no assumption can be made about \p guaranteedValue's lifetime. Therefore
+// the use points are incomplete and this returns false.
 //
 // Accumulate results in \p usePoints, ignoring existing elements.
 //
 // Skip over nested borrow scopes. Their scope-ending instructions are their use
 // points. Transitively find all nested scope-ending instructions by looking
 // through nested reborrows. Nested reborrows are not use points and \p
 // visitReborrow is not called for them.
-static bool
+bool swift::
 findInnerTransitiveGuaranteedUses(SILValue guaranteedValue,
                                   SmallVectorImpl<Operand *> &usePoints) {
   // Push the value's immediate uses.
@@ -195,7 +192,6 @@ findInnerTransitiveGuaranteedUses(SILValue guaranteedValue,
     case OperandOwnership::TrivialUse:
     case OperandOwnership::ForwardingConsume:
     case OperandOwnership::DestroyingConsume:
-    case OperandOwnership::Reborrow:
       llvm_unreachable("this operand cannot handle an inner guaranteed use");
 
     case OperandOwnership::ForwardingUnowned:
@@ -205,7 +201,12 @@ findInnerTransitiveGuaranteedUses(SILValue guaranteedValue,
     case OperandOwnership::InstantaneousUse:
     case OperandOwnership::UnownedInstantaneousUse:
     case OperandOwnership::BitwiseEscape:
-    // An end_borrow may be pushed as a use when processing a nested borrow.
+    // Reborrow only happens when this is called on a value that creates a
+    // borrow scope.
+    case OperandOwnership::Reborrow:
+    // EndBorrow either happens when this is called on a value that creates a
+    // borrow scope, or when it is pushed as a use when processing a nested
+    // borrow.
     case OperandOwnership::EndBorrow:
       break;
 

lib/SILOptimizer/Transforms/SimplifyCFG.cpp

@@ -382,7 +382,7 @@ bool SimplifyCFG::threadEdge(const ThreadInfo &ti) {
           dyn_cast<BranchInst>(ThreadedSuccessorBlock->getTerminator())) {
     simplifyBranchBlock(branchInst);
   }
-  Cloner.updateSSAAfterCloning();
+  Cloner.updateOSSAAfterCloning();
   return true;
 }
 
@@ -1149,7 +1149,7 @@ bool SimplifyCFG::tryJumpThreading(BranchInst *BI) {
   // Duplicate the destination block into this one, rewriting uses of the BBArgs
   // to use the branch arguments as we go.
   Cloner.cloneBranchTarget(BI);
-  Cloner.updateSSAAfterCloning();
+  Cloner.updateOSSAAfterCloning();
 
   // Once all the instructions are copied, we can nuke BI itself.  We also add
   // the threaded and edge block to the worklist now that they (likely) can be
@@ -3027,7 +3027,7 @@ bool SimplifyCFG::tailDuplicateObjCMethodCallSuccessorBlocks() {
       continue;
 
     Cloner.cloneBranchTarget(Branch);
-    Cloner.updateSSAAfterCloning();
+    Cloner.updateOSSAAfterCloning();
 
     Changed = true;
     // Simplify the cloned block and continue tail duplicating through its new