Optimizer: add a utility to replaces phis with the unique incoming values if all incoming values are the same

This is needed after running the SSAUpdater for an existing OSSA value, because the updater can
insert unnecessary phis in the middle of the original liverange which breaks up the original
liverange into smaller ones:

```
   %1 = def_of_owned_value
   %2 = begin_borrow %1
   ...
   br bb2(%1)
 bb2(%3 : @owned $T): // inserted by SSAUpdater
   ...
   end_borrow %2      // use after end-of-lifetime!
   destroy_value %3
```

It's not needed to run this utility if SSAUpdater is used to create a _new_ OSSA liverange.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Utilities/GuaranteedPhiUpdater.swift

@@ -152,13 +152,100 @@ private func addEnclosingValues(
   return true
 }
 
+/// Replaces a phi with the unique incoming value if all incoming values are the same:
+/// ```
+///   bb1:
+///     br bb3(%1)
+///   bb2:
+///     br bb3(%1)
+///   bb3(%2 : $T):   // Predecessors: bb1, bb2
+///     use(%2)
+/// ```
+/// ->
+/// ```
+///   bb1:
+///     br bb3
+///   bb2:
+///     br bb3
+///   bb3:
+///     use(%1)
+/// ```
+///
+func replacePhiWithIncomingValue(phi: Phi, _ context: some MutatingContext) -> Bool {
+  if phi.predecessors.isEmpty {
+    return false
+  }
+  let uniqueIncomingValue = phi.incomingValues.first!
+  if !uniqueIncomingValue.parentFunction.hasOwnership {
+    // For the SSAUpdater it's only required to simplify phis in OSSA.
+    // This avoids that we need to handle cond_br instructions below.
+    return false
+  }
+  if phi.incomingValues.contains(where: { $0 != uniqueIncomingValue }) {
+    return false
+  }
+  if let borrowedFrom = phi.borrowedFrom {
+    borrowedFrom.uses.replaceAll(with: uniqueIncomingValue, context)
+    context.erase(instruction: borrowedFrom)
+  } else {
+    phi.value.uses.replaceAll(with: uniqueIncomingValue, context)
+  }
+
+  let block = phi.value.parentBlock
+  for incomingOp in phi.incomingOperands {
+    let existingBranch = incomingOp.instruction as! BranchInst
+    let argsWithRemovedPhiOp = existingBranch.operands.filter{ $0 != incomingOp }.map{ $0.value }
+    Builder(before: existingBranch, context).createBranch(to: block, arguments: argsWithRemovedPhiOp)
+    context.erase(instruction: existingBranch)
+  }
+  block.eraseArgument(at: phi.value.index, context)
+  return true
+}
+
+/// Replaces phis with the unique incoming values if all incoming values are the same.
+/// This is needed after running the SSAUpdater for an existing OSSA value, because the updater can
+/// insert unnecessary phis in the middle of the original liverange which breaks up the original
+/// liverange into smaller ones:
+/// ```
+///    %1 = def_of_owned_value
+///    %2 = begin_borrow %1
+///    ...
+///    br bb2(%1)
+///  bb2(%3 : @owned $T): // inserted by SSAUpdater
+///    ...
+///    end_borrow %2      // use after end-of-lifetime!
+///    destroy_value %3
+/// ```
+///
+/// It's not needed to run this utility if SSAUpdater is used to create a _new_ OSSA liverange.
+///
+func replacePhisWithIncomingValues(phis: [Phi], _ context: some MutatingContext) {
+  var currentPhis = phis
+  // Do this in a loop because replacing one phi might open up the opportunity for another phi
+  // and the order of phis in the array can be arbitrary.
+  while true {
+    var newPhis = [Phi]()
+    for phi in currentPhis {
+      if !replacePhiWithIncomingValue(phi: phi, context) {
+        newPhis.append(phi)
+      }
+    }
+    if newPhis.count == currentPhis.count {
+      return
+    }
+    currentPhis = newPhis
+  }
+}
+
 func registerGuaranteedPhiUpdater() {
   BridgedUtilities.registerGuaranteedPhiUpdater(
+    // updateAllGuaranteedPhis
     { (bridgedCtxt: BridgedPassContext, bridgedFunction: BridgedFunction) in
       let context = FunctionPassContext(_bridged: bridgedCtxt)
       let function = bridgedFunction.function;
       updateGuaranteedPhis(in: function, context)
     },
+    // updateGuaranteedPhis
     { (bridgedCtxt: BridgedPassContext, bridgedPhiArray: BridgedArrayRef) in
       let context = FunctionPassContext(_bridged: bridgedCtxt)
       var guaranteedPhis = Stack<Phi>(context)
@@ -172,6 +259,15 @@ func registerGuaranteedPhiUpdater() {
         }
       }
       updateGuaranteedPhis(phis: guaranteedPhis, context)
+    },
+    // replacePhisWithIncomingValues
+    { (bridgedCtxt: BridgedPassContext, bridgedPhiArray: BridgedArrayRef) in
+      let context = FunctionPassContext(_bridged: bridgedCtxt)
+      var phis = [Phi]()
+      bridgedPhiArray.withElements(ofType: BridgedValue.self) {
+        phis = $0.map { Phi($0.value)! }
+      }
+      replacePhisWithIncomingValues(phis: phis, context)
     }
   )
 }

include/swift/SILOptimizer/OptimizerBridging.h

@@ -135,7 +135,8 @@ struct BridgedUtilities {
 
   static void registerVerifier(VerifyFunctionFn verifyFunctionFn);
   static void registerGuaranteedPhiUpdater(UpdateFunctionFn updateBorrowedFromFn,
-                                           UpdatePhisFn updateBorrowedFromPhisFn);
+                                           UpdatePhisFn updateBorrowedFromPhisFn,
+                                           UpdatePhisFn replacePhisWithIncomingValuesFn);
 };
 
 struct BridgedBasicBlockSet {

include/swift/SILOptimizer/Utils/OwnershipOptUtils.h

@@ -364,6 +364,9 @@ void updateAllGuaranteedPhis(SILPassManager *pm, SILFunction *f);
 /// Updates the reborrow flags and the borrowed-from instructions for all `phis`.
 void updateGuaranteedPhis(SILPassManager *pm, ArrayRef<SILPhiArgument *> phis);
 
+/// Replaces phis with the unique incoming values if all incoming values are the same.
+void replacePhisWithIncomingValues(SILPassManager *pm, ArrayRef<SILPhiArgument *> phis);
+
 } // namespace swift
 
 #endif

lib/SILOptimizer/Utils/OwnershipOptUtils.cpp

@@ -1915,11 +1915,14 @@ bool swift::extendStoreBorrow(StoreBorrowInst *sbi,
 
 static BridgedUtilities::UpdateFunctionFn updateAllGuaranteedPhisFunction;
 static BridgedUtilities::UpdatePhisFn updateGuaranteedPhisFunction;
+static BridgedUtilities::UpdatePhisFn replacePhisWithIncomingValuesFunction;
 
 void BridgedUtilities::registerGuaranteedPhiUpdater(UpdateFunctionFn updateAllGuaranteedPhisFn,
-                                                    UpdatePhisFn updateGuaranteedPhisFn) {
+                                                    UpdatePhisFn updateGuaranteedPhisFn,
+                                                    UpdatePhisFn replacePhisWithIncomingValuesFn) {
   updateAllGuaranteedPhisFunction = updateAllGuaranteedPhisFn;
   updateGuaranteedPhisFunction = updateGuaranteedPhisFn;
+  replacePhisWithIncomingValuesFunction = replacePhisWithIncomingValuesFn;
 }
 
 void swift::updateAllGuaranteedPhis(SILPassManager *pm, SILFunction *f) {
@@ -1937,3 +1940,14 @@ void swift::updateGuaranteedPhis(SILPassManager *pm, ArrayRef<SILPhiArgument *>
   }
   updateGuaranteedPhisFunction({pm->getSwiftPassInvocation()}, ArrayRef(bridgedPhis));
 }
+
+void swift::replacePhisWithIncomingValues(SILPassManager *pm, ArrayRef<SILPhiArgument *> phis) {
+  if (!replacePhisWithIncomingValuesFunction)
+    return;
+
+  llvm::SmallVector<BridgedValue, 8> bridgedPhis;
+  for (SILPhiArgument *phi : phis) {
+    bridgedPhis.push_back({phi});
+  }
+  replacePhisWithIncomingValuesFunction({pm->getSwiftPassInvocation()}, ArrayRef(bridgedPhis));
+}