[cfg] Extract out erasePhiArgument utility from SimplifyCFG -> CFG.h.

I needed this functionality to fix an edge case bug in closure lifetime fixup.

Author: gottesmm

include/swift/SILOptimizer/Utils/CFG.h

@@ -45,6 +45,18 @@ TermInst *addNewEdgeValueToBranch(TermInst *Branch, SILBasicBlock *Dest,
 TermInst *changeEdgeValue(TermInst *Branch, SILBasicBlock *Dest, size_t Idx,
                           SILValue Val);
 
+/// Deletes the edge value between a branch and a destination basic block at the
+/// specified index. Asserts internally that the argument along the edge does
+/// not have uses.
+TermInst *deleteEdgeValue(TermInst *branch, SILBasicBlock *destBlock,
+                          size_t argIndex);
+
+/// Erase the \p argIndex phi argument from \p block. Asserts that the argument
+/// is a /real/ phi argument. Removes all incoming values for the argument from
+/// predecessor terminators. Asserts internally that it only ever is given
+/// "true" phi argument.
+void erasePhiArgument(SILBasicBlock *block, unsigned argIndex);
+
 /// Replace a branch target.
 ///
 /// \param T The terminating instruction to modify.

lib/SILOptimizer/Transforms/SimplifyCFG.cpp

@@ -2712,84 +2712,6 @@ bool SimplifyCFG::tailDuplicateObjCMethodCallSuccessorBlocks() {
   return Changed;
 }
 
-static void
-deleteTriviallyDeadOperandsOfDeadArgument(MutableArrayRef<Operand> TermOperands,
-                                          unsigned DeadArgIndex) {
-  Operand &Op = TermOperands[DeadArgIndex];
-  auto *I = Op.get()->getDefiningInstruction();
-  if (!I)
-    return;
-  Op.set(SILUndef::get(Op.get()->getType(), *I->getFunction()));
-  recursivelyDeleteTriviallyDeadInstructions(I);
-}
-
-static void removeArgumentFromTerminator(SILBasicBlock *BB, SILBasicBlock *Dest,
-                                         int idx) {
-  TermInst *Branch = BB->getTerminator();
-  SILBuilderWithScope Builder(Branch);
-  LLVM_DEBUG(llvm::dbgs() << "remove dead argument " << idx << " from "
-                          << *Branch);
-
-  if (auto *CBI = dyn_cast<CondBranchInst>(Branch)) {
-    SmallVector<SILValue, 8> TrueArgs;
-    SmallVector<SILValue, 8> FalseArgs;
-
-    for (auto A : CBI->getTrueArgs())
-      TrueArgs.push_back(A);
-
-    for (auto A : CBI->getFalseArgs())
-      FalseArgs.push_back(A);
-
-    if (Dest == CBI->getTrueBB()) {
-      deleteTriviallyDeadOperandsOfDeadArgument(CBI->getTrueOperands(), idx);
-      TrueArgs.erase(TrueArgs.begin() + idx);
-    }
-
-    if (Dest == CBI->getFalseBB()) {
-      deleteTriviallyDeadOperandsOfDeadArgument(CBI->getFalseOperands(), idx);
-      FalseArgs.erase(FalseArgs.begin() + idx);
-    }
-
-    Builder.createCondBranch(CBI->getLoc(), CBI->getCondition(),
-                             CBI->getTrueBB(), TrueArgs, CBI->getFalseBB(),
-                             FalseArgs, CBI->getTrueBBCount(),
-                             CBI->getFalseBBCount());
-    Branch->eraseFromParent();
-    return;
-  }
-
-  if (auto *BI = dyn_cast<BranchInst>(Branch)) {
-    SmallVector<SILValue, 8> Args;
-
-    for (auto A : BI->getArgs())
-      Args.push_back(A);
-
-    deleteTriviallyDeadOperandsOfDeadArgument(BI->getAllOperands(), idx);
-    Args.erase(Args.begin() + idx);
-    Builder.createBranch(BI->getLoc(), BI->getDestBB(), Args);
-    Branch->eraseFromParent();
-    return;
-  }
-  llvm_unreachable("unsupported terminator");
-}
-
-static void removeArgument(SILBasicBlock *BB, unsigned i) {
-  NumDeadArguments++;
-  BB->eraseArgument(i);
-
-  // Determine the set of predecessors in case any predecessor has
-  // two edges to this block (e.g. a conditional branch where both
-  // sides reach this block).
-  llvm::SetVector<SILBasicBlock *,SmallVector<SILBasicBlock *, 8>,
-                  SmallPtrSet<SILBasicBlock *, 8>> PredBBs;
-
-  for (auto *Pred : BB->getPredecessorBlocks())
-    PredBBs.insert(Pred);
-
-  for (auto *Pred : PredBBs)
-    removeArgumentFromTerminator(Pred, BB, i);
-}
-
 namespace {
 
 class ArgumentSplitter {
@@ -3026,7 +2948,8 @@ bool ArgumentSplitter::split() {
       Worklist.push_back(A);
       continue;
     }
-    removeArgument(ParentBB, i);
+    erasePhiArgument(ParentBB, i);
+    ++NumDeadArguments;
   }
 
   return true;
@@ -3766,7 +3689,8 @@ bool SimplifyCFG::simplifyArgs(SILBasicBlock *BB) {
       continue;
     }
 
-    removeArgument(BB, i);
+    erasePhiArgument(BB, i);
+    ++NumDeadArguments;
     Changed = true;
   }
 

lib/SILOptimizer/Utils/CFG.cpp

@@ -77,6 +77,77 @@ TermInst *swift::addNewEdgeValueToBranch(TermInst *Branch, SILBasicBlock *Dest,
   return NewBr;
 }
 
+static void
+deleteTriviallyDeadOperandsOfDeadArgument(MutableArrayRef<Operand> termOperands,
+                                          unsigned deadArgIndex) {
+  Operand &op = termOperands[deadArgIndex];
+  auto *i = op.get()->getDefiningInstruction();
+  if (!i)
+    return;
+  op.set(SILUndef::get(op.get()->getType(), *i->getFunction()));
+  recursivelyDeleteTriviallyDeadInstructions(i);
+}
+
+// Our implementation assumes that our caller is attempting to remove a dead
+// SILPhiArgument from a SILBasicBlock and has already RAUWed the argument.
+TermInst *swift::deleteEdgeValue(TermInst *branch, SILBasicBlock *destBlock,
+                                 size_t argIndex) {
+  if (auto *cbi = dyn_cast<CondBranchInst>(branch)) {
+    SmallVector<SILValue, 8> trueArgs;
+    SmallVector<SILValue, 8> falseArgs;
+
+    copy(cbi->getTrueArgs(), std::back_inserter(trueArgs));
+    copy(cbi->getFalseArgs(), std::back_inserter(falseArgs));
+
+    if (destBlock == cbi->getTrueBB()) {
+      deleteTriviallyDeadOperandsOfDeadArgument(cbi->getTrueOperands(), argIndex);
+      trueArgs.erase(trueArgs.begin() + argIndex);
+    }
+
+    if (destBlock == cbi->getFalseBB()) {
+      deleteTriviallyDeadOperandsOfDeadArgument(cbi->getFalseOperands(), argIndex);
+      falseArgs.erase(falseArgs.begin() + argIndex);
+    }
+
+    SILBuilderWithScope builder(cbi);
+    auto *result = builder.createCondBranch(cbi->getLoc(), cbi->getCondition(),
+                             cbi->getTrueBB(), trueArgs, cbi->getFalseBB(),
+                             falseArgs, cbi->getTrueBBCount(),
+                             cbi->getFalseBBCount());
+    branch->eraseFromParent();
+    return result;
+  }
+
+  if (auto *bi = dyn_cast<BranchInst>(branch)) {
+    SmallVector<SILValue, 8> args;
+    copy(bi->getArgs(), std::back_inserter(args));
+
+    deleteTriviallyDeadOperandsOfDeadArgument(bi->getAllOperands(), argIndex);
+    args.erase(args.begin() + argIndex);
+    auto *result = SILBuilderWithScope(bi).createBranch(bi->getLoc(), bi->getDestBB(), args);
+    branch->eraseFromParent();
+    return result;
+  }
+
+  llvm_unreachable("unsupported terminator");
+}
+
+void swift::erasePhiArgument(SILBasicBlock *block, unsigned argIndex) {
+  assert(block->getArgument(argIndex)->isPhiArgument() &&
+         "Only should be used on phi arguments");
+  block->eraseArgument(argIndex);
+
+  // Determine the set of predecessors in case any predecessor has
+  // two edges to this block (e.g. a conditional branch where both
+  // sides reach this block).
+  SmallVector<SILBasicBlock *, 8> predBlocks(block->pred_begin(),
+                                             block->pred_end());
+  sortUnique(predBlocks);
+
+  for (auto *pred : predBlocks)
+    deleteEdgeValue(pred->getTerminator(), block, argIndex);
+}
+
 /// Changes the edge value between a branch and destination basic block
 /// at the specified index. Changes all edges from \p Branch to \p Dest to carry
 /// the value.