[LICM] *Actually* disable ControlFlowHoisting.

[asbirlea]

Summary

The remaining code paths that ControlFlowHoisting introduced that were
not disabled, increased compile time by 3x for some benchmarks.
The time is spent in DominatorTree updates.

llvm/trunk/lib/Transforms/Scalar/LICM.cpp

for (auto &Pair : HoistableBranches) {
       }
     }
     // PredecessorBlocks will now be empty if for every predecessor of BB we
     // found a hoistable branch source.
     return PredecessorBlocks.empty();
   }
 
   BasicBlock *getOrCreateHoistedBlock(BasicBlock *BB) {
+    if (!ControlFlowHoisting)
+      return CurLoop->getLoopPreheader();
     // If BB has already been hoisted, return that
     if (HoistDestinationMap.count(BB))
       return HoistDestinationMap[BB];
 
     // Check if this block is conditional based on a pending branch
     auto HasBBAsSuccessor =
         [&](DenseMap<BranchInst *, BasicBlock *>::value_type &Pair) {
           return BB != Pair.second && (Pair.first->getSuccessor(0) == BB ||
bool llvm::hoistRegion(DomTreeNode *N, AliasAnalysis *AA, LoopInfo *LI,
   // If we hoisted instructions to a conditional block they may not dominate
   // their uses that weren't hoisted (such as phis where some operands are not
   // loop invariant). If so make them unconditional by moving them to their
   // immediate dominator. We iterate through the instructions in reverse order
   // which ensures that when we rehoist an instruction we rehoist its operands,
   // and also keep track of where in the block we are rehoisting to to make sure
   // that we rehoist instructions before the instructions that use them.
   Instruction *HoistPoint = nullptr;
+  if (ControlFlowHoisting) {
     for (Instruction *I : reverse(HoistedInstructions)) {
-    if (!llvm::all_of(I->uses(), [&](Use &U) { return DT->dominates(I, U); })) {
+      if (!llvm::all_of(I->uses(),
+                        [&](Use &U) { return DT->dominates(I, U); })) {
         BasicBlock *Dominator =
             DT->getNode(I->getParent())->getIDom()->getBlock();
-      LLVM_DEBUG(dbgs() << "LICM rehoisting to " << Dominator->getName() << ": "
-                        << *I << "\n");
+        LLVM_DEBUG(dbgs() << "LICM rehoisting to " << Dominator->getName()
+                          << ": " << *I << "\n");
         if (!HoistPoint || HoistPoint->getParent() != Dominator) {
           if (HoistPoint)
             assert(DT->dominates(Dominator, HoistPoint->getParent()) &&
                    "New hoist point expected to dominate old hoist point");
           HoistPoint = Dominator->getTerminator();
         }
         moveInstructionBefore(*I, *HoistPoint, *SafetyInfo);
         HoistPoint = I;
         Changed = true;
       }
     }
+  }
 
   // Now that we've finished hoisting make sure that LI and DT are still valid.
 #ifndef NDEBUG
   if (Changed) {
     assert(DT->verify(DominatorTree::VerificationLevel::Fast) &&
            "Dominator tree verification failed");
     LI->verify(*DT);
   }