Merge pull request #38456 from atrick/ossa-jumpthread-test

OSSA: migrate & organize simplify-cfg tests

Author: atrick

include/swift/SIL/BasicBlockUtils.h

@@ -87,6 +87,10 @@ class DeadEndBlocks {
   /// Used to determine if we need to verify a DeadEndBlocks.
   bool isComputed() const { return didComputeValue; }
 
+  /// Add any (new) blocks that are backward-reachable from \p reachableBB to
+  /// the set of reachable blocks.
+  void updateForReachableBlock(SILBasicBlock *reachableBB);
+
   const SILFunction *getFunction() const { return f; }
 
   /// Performs a simple check if \p block (or its single successor) ends in an
@@ -95,6 +99,9 @@ class DeadEndBlocks {
   /// This handles the common case of failure-handling blocks, which e.g.
   /// contain a call to fatalError().
   static bool triviallyEndsInUnreachable(SILBasicBlock *block);
+
+protected:
+  void propagateNewlyReachableBlocks(unsigned startIdx);
 };
 
 /// Compute joint-postdominating set for \p dominatingBlock and \p

include/swift/SIL/SILArgument.h

@@ -183,7 +183,7 @@ class SILArgument : public ValueBase {
 
   /// Return the terminator instruction for which this argument is a result,
   /// otherwise return nullptr.
-  TermInst *getTerminatorForResultArg() const;
+  TermInst *getTerminatorForResult() const;
 
   /// Return the SILArgumentKind of this argument.
   SILArgumentKind getKind() const {
@@ -299,7 +299,7 @@ class SILPhiArgument : public SILArgument {
 
   /// Return the terminator instruction for which this argument is a result,
   /// otherwise return nullptr.
-  TermInst *getTerminatorForResultArg() const;
+  TermInst *getTerminatorForResult() const;
 
   static bool classof(const SILInstruction *) = delete;
   static bool classof(const SILUndef *) = delete;
@@ -445,10 +445,10 @@ inline TermInst *SILArgument::getSingleTerminator() const {
   llvm_unreachable("Covered switch is not covered?!");
 }
 
-inline TermInst *SILArgument::getTerminatorForResultArg() const {
+inline TermInst *SILArgument::getTerminatorForResult() const {
   switch (getKind()) {
   case SILArgumentKind::SILPhiArgument:
-    return cast<SILPhiArgument>(this)->getTerminatorForResultArg();
+    return cast<SILPhiArgument>(this)->getTerminatorForResult();
   case SILArgumentKind::SILFunctionArgument:
     return nullptr;
   }

include/swift/SILOptimizer/Utils/BasicBlockOptUtils.h

@@ -170,6 +170,9 @@ class BasicBlockCloner : public SILCloner<BasicBlockCloner> {
   /// state is reset each time analyzeAddressProjections is called.
   SinkAddressProjections sinkProj;
 
+  // If available, the current DeadEndBlocks for incremental update.
+  DeadEndBlocks *deBlocks;
+
 public:
   /// An ordered list of old to new available value pairs.
   ///
@@ -178,8 +181,8 @@ class BasicBlockCloner : public SILCloner<BasicBlockCloner> {
   SmallVector<std::pair<SILValue, SILValue>, 16> availVals;
 
   // Clone blocks starting at `origBB`, within the same function.
-  BasicBlockCloner(SILBasicBlock *origBB)
-      : SILCloner(*origBB->getParent()), origBB(origBB) {}
+  BasicBlockCloner(SILBasicBlock *origBB, DeadEndBlocks *deBlocks = nullptr)
+      : SILCloner(*origBB->getParent()), origBB(origBB), deBlocks(deBlocks) {}
 
   bool canCloneBlock() {
     for (auto &inst : *origBB) {
@@ -218,6 +221,12 @@ class BasicBlockCloner : public SILCloner<BasicBlockCloner> {
     successorBBs.reserve(origBB->getSuccessors().size());
     llvm::copy(origBB->getSuccessors(), std::back_inserter(successorBBs));
     cloneReachableBlocks(origBB, successorBBs, insertAfterBB);
+
+    if (deBlocks) {
+      for (auto *succBB : successorBBs) {
+        deBlocks->updateForReachableBlock(succBB);
+      }
+    }
   }
 
   /// Clone the given branch instruction's destination block, splitting

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -34,6 +34,7 @@
 namespace swift {
 
 class DominanceInfo;
+class DeadEndBlocks;
 template <class T> class NullablePtr;
 
 /// Transform a Use Range (Operand*) into a User Range (SILInstruction *)
@@ -202,8 +203,9 @@ SILLinkage getSpecializedLinkage(SILFunction *f, SILLinkage linkage);
 /// Tries to perform jump-threading on all checked_cast_br instruction in
 /// function \p Fn.
 bool tryCheckedCastBrJumpThreading(
-    SILFunction *fn, DominanceInfo *dt,
-    SmallVectorImpl<SILBasicBlock *> &blocksForWorklist);
+    SILFunction *fn, DominanceInfo *dt, DeadEndBlocks *deBlocks,
+    SmallVectorImpl<SILBasicBlock *> &blocksForWorklist,
+    bool EnableOSSARewriteTerminator);
 
 /// A utility for deleting one or more instructions belonging to a function, and
 /// cleaning up any dead code resulting from deleting those instructions. Use

lib/SIL/IR/SILArgument.cpp

@@ -316,7 +316,7 @@ TermInst *SILPhiArgument::getSingleTerminator() const {
   return const_cast<SILBasicBlock *>(predBlock)->getTerminator();
 }
 
-TermInst *SILPhiArgument::getTerminatorForResultArg() const {
+TermInst *SILPhiArgument::getTerminatorForResult() const {
   if (auto *termInst = getSingleTerminator()) {
     if (!isa<BranchInst>(termInst) && !isa<CondBranchInst>(termInst))
       return termInst;

lib/SIL/Utils/BasicBlockUtils.cpp

@@ -174,7 +174,8 @@ void swift::getEdgeArgs(TermInst *T, unsigned edgeIdx, SILBasicBlock *newEdgeBB,
     if (!succBB->getNumArguments())
       return;
     args.push_back(newEdgeBB->createPhiArgument(
-        succBB->getArgument(0)->getType(), OwnershipKind::Owned));
+        succBB->getArgument(0)->getType(),
+        succBB->getArgument(0)->getOwnershipKind()));
     return;
   }
 
@@ -186,7 +187,8 @@ void swift::getEdgeArgs(TermInst *T, unsigned edgeIdx, SILBasicBlock *newEdgeBB,
     if (!succBB->getNumArguments())
       return;
     args.push_back(newEdgeBB->createPhiArgument(
-        succBB->getArgument(0)->getType(), OwnershipKind::Owned));
+        succBB->getArgument(0)->getType(),
+        succBB->getArgument(0)->getOwnershipKind()));
     return;
   }
 
@@ -366,6 +368,15 @@ void swift::mergeBasicBlockWithSingleSuccessor(SILBasicBlock *BB,
 //                              DeadEndBlocks
 //===----------------------------------------------------------------------===//
 
+// Propagate the reachability up the control flow graph.
+void DeadEndBlocks::propagateNewlyReachableBlocks(unsigned startIdx) {
+  for (unsigned idx = startIdx; idx < reachableBlocks.size(); ++idx) {
+    const SILBasicBlock *bb = reachableBlocks[idx];
+    for (SILBasicBlock *predBB : bb->getPredecessorBlocks())
+      reachableBlocks.insert(predBB);
+  }
+}
+
 void DeadEndBlocks::compute() {
   assert(reachableBlocks.empty() && "Computed twice");
 
@@ -377,13 +388,19 @@ void DeadEndBlocks::compute() {
     if (TI->isFunctionExiting())
       reachableBlocks.insert(&BB);
   }
-  // Propagate the reachability up the control flow graph.
-  unsigned Idx = 0;
-  while (Idx < reachableBlocks.size()) {
-    const SILBasicBlock *BB = reachableBlocks[Idx++];
-    for (SILBasicBlock *Pred : BB->getPredecessorBlocks())
-      reachableBlocks.insert(Pred);
+  propagateNewlyReachableBlocks(0);
+}
+
+void DeadEndBlocks::updateForReachableBlock(SILBasicBlock *reachableBB) {
+  if (!didComputeValue)
+    return;
+
+  assert(reachableBlocks.count(reachableBB));
+  unsigned numReachable = reachableBlocks.size();
+  for (SILBasicBlock *predBB : reachableBB->getPredecessorBlocks()) {
+    reachableBlocks.insert(predBB);
   }
+  propagateNewlyReachableBlocks(numReachable);
 }
 
 bool DeadEndBlocks::triviallyEndsInUnreachable(SILBasicBlock *block) {