SimplifyCFG: don't recalculate the dominator tree for each jump threaded checked_cast_br instruction.

This is done by splitting the transformation into an analysis phase and a transformation phase (which does not use the dominator tree anymore).
The domintator tree is recalucated once after the whole function is processed.

This change eventually solves the compile time problem of rdar://problem/24410167.

Author: eeckstein

include/swift/SILOptimizer/Utils/Local.h

@@ -158,9 +158,13 @@ SILLinkage getSpecializedLinkage(SILFunction *F, SILLinkage L);
 /// string literals. Returns a new instruction if optimization was possible.
 SILInstruction *tryToConcatenateStrings(ApplyInst *AI, SILBuilder &B);
 
-/// Tries to perform jump-threading on a given checked_cast_br terminator.
-bool tryCheckedCastBrJumpThreading(TermInst *Term, DominanceInfo *DT,
-                                   SmallVectorImpl<SILBasicBlock *> &BBs);
+
+/// Tries to perform jump-threading on all checked_cast_br instruction in
+/// function \p Fn.
+bool tryCheckedCastBrJumpThreading(SILFunction *Fn, DominanceInfo *DT,
+                          SmallVectorImpl<SILBasicBlock *> &BlocksForWorklist);
+
+void recalcDomTreeForCCBOpt(DominanceInfo *DT, SILFunction &F);
 
 /// Checks if a symbol with a given linkage can be referenced from fragile
 /// functions.

lib/SILOptimizer/Transforms/SimplifyCFG.cpp

@@ -170,7 +170,6 @@ namespace {
     bool simplifyProgramTerminationBlock(SILBasicBlock *BB);
     bool simplifyArgument(SILBasicBlock *BB, unsigned i);
     bool simplifyArgs(SILBasicBlock *BB);
-    bool trySimplifyCheckedCastBr(TermInst *Term, DominanceInfo *DT);
     void findLoopHeaders();
   };
 
@@ -239,28 +238,6 @@ void swift::updateSSAAfterCloning(BaseThreadingCloner &Cloner,
   }
 }
 
-/// Perform a dominator-based jump-threading for checked_cast_br [exact]
-/// instructions if they use the same condition (modulo upcasts and downcasts).
-/// This is very beneficial for code that:
-///  - references the same object multiple times (e.g. x.f1() + x.f2())
-///  - and for method invocation chaining (e.g. x.f3().f4().f5())
-bool
-SimplifyCFG::trySimplifyCheckedCastBr(TermInst *Term, DominanceInfo *DT) {
-  // Ignore unreachable blocks.
-  if (!DT->getNode(Term->getParent()))
-    return false;
-
-  SmallVector<SILBasicBlock *, 16> BBs;
-  auto Result = tryCheckedCastBrJumpThreading(Term, DT, BBs);
-
-  if (Result) {
-    for (auto BB: BBs)
-      addToWorklist(BB);
-  }
-
-  return Result;
-}
-
 static SILValue getTerminatorCondition(TermInst *Term) {
   if (auto *CondBr = dyn_cast<CondBranchInst>(Term))
     return stripExpectIntrinsic(CondBr->getCondition());
@@ -670,6 +647,7 @@ bool SimplifyCFG::dominatorBasedSimplify(DominanceAnalysis *DA) {
       EnableJumpThread ? splitAllCriticalEdges(Fn, false, DT, nullptr) : false;
 
   unsigned MaxIter = MaxIterationsOfDominatorBasedSimplify;
+  SmallVector<SILBasicBlock *, 16> BlocksForWorklist;
 
   bool HasChangedInCurrentIter;
   do {
@@ -678,26 +656,14 @@ bool SimplifyCFG::dominatorBasedSimplify(DominanceAnalysis *DA) {
     // Do dominator based simplification of terminator condition. This does not
     // and MUST NOT change the CFG without updating the dominator tree to
     // reflect such change.
-    for (auto &BB : Fn) {
-      // Any method called from this loop should update
-      // the DT if it changes anything related to dominators.
-      TermInst *Term = BB.getTerminator();
-      switch (Term->getKind()) {
-      case ValueKind::SwitchValueInst:
-        // TODO: handle switch_value
-        break;
-      case ValueKind::CheckedCastBranchInst:
-        if (trySimplifyCheckedCastBr(BB.getTerminator(), DT)) {
-          HasChangedInCurrentIter = true;
-          // FIXME: trySimplifyCheckedCastBr function should preserve the
-          // dominator tree but its code to do so is buggy.
-          DT->recalculate(Fn);
-        }
-        break;
-      default:
-        break;
-      }
+    if (tryCheckedCastBrJumpThreading(&Fn, DT, BlocksForWorklist)) {
+      for (auto BB: BlocksForWorklist)
+        addToWorklist(BB);
+
+      HasChangedInCurrentIter = true;
+      DT->recalculate(Fn);
     }
+    BlocksForWorklist.clear();
 
     if (ShouldVerify)
       DT->verify();