[SCCP] Remove manual folding of terminator instructions.

[trentxintong]

Summary

BranchInst, SwitchInst (with non-default case) with Undef as input is not
possible at this point. As we always default-fold terminator to one target in
ResolvedUndefsIn and set the input accordingly.

So we should only have constantint/blockaddress here.

If ConstantFoldTerminator fails, that could mean 2 things.

1. ConstantFoldTerminator is doing something unexpected, i.e. not folding on constantint

or blockaddress and not making blocks that should be dead dead.

2. This is not a terminator on constantint or blockaddress. Its on a constant or

overdefined, then this block should not be dead.

In both cases, we should assert.

[trentxintong]

I understand there was a previous attempt at removing these code before and it caused a build break.

8ea5797013603a088dd6be6ad49d1a117f1955e2
[SCCP] Remove manual folding of terminator instructions.

4b6e5ecd86de0863546ab2ecf3a8f979f0d1a8a0
Revert "[SCCP] Remove manual folding of terminator instructions."
This reverts commit r288725 as it broke a bot.

I think the problem might be with the ConstantFoldTerminator in the assert(), should not
assert() be null'ed in release build ?

With this patch, I ran LTO on CPU2006 C/C++ benchmarks locally, they compiled and ran fine.

I also checked when the manual folding code is added, it is added in
ddaaa374879f2f736f7bfa20f4b25202fcb85708 at which time we only mark an edge executable
when its branching on an undef, but not setting its value to a constant.

[davide]

I actually forgot to recommit this one :(
The issue with the original patch was that I folded the call inside the assert so ConstantFoldTerminator() was compiled away in !DEBUG mode.
Oh, well. Your reasoning is correct (actually, was my original reasoning when I committed the patch).

[trentxintong]

@davide Thanks for taking a quick look !

lib/Transforms/Scalar/SCCP.cpp

for (unsigned i = 0, e = BlocksToErase.size(); i != e; ++i) {
         // will be deleted. Step past all adjacent uses from the same user.
         auto *I = dyn_cast<Instruction>(*UI);
         do { ++UI; } while (UI != UE && *UI == I);
 
         // Ignore blockaddress users; BasicBlock's dtor will handle them.
         if (!I) continue;
 
         bool Folded = ConstantFoldTerminator(I->getParent());
-        if (!Folded) {
-          // The constant folder may not have been able to fold the terminator
-          // if this is a branch or switch on undef.  Fold it manually as a
-          // branch to the first successor.
-#ifndef NDEBUG
-          if (auto *BI = dyn_cast<BranchInst>(I)) {
-            assert(BI->isConditional() && isa<UndefValue>(BI->getCondition()) &&
-                   "Branch should be foldable!");
-          } else if (auto *SI = dyn_cast<SwitchInst>(I)) {
-            assert(isa<UndefValue>(SI->getCondition()) && "Switch should fold");
-          } else {
-            llvm_unreachable("Didn't fold away reference to block!");
-          }
-#endif
-
-          // Make this an uncond branch to the first successor.
-          TerminatorInst *TI = I->getParent()->getTerminator();
-          BranchInst::Create(TI->getSuccessor(0), TI);
-
-          // Remove entries in successor phi nodes to remove edges.
-          for (unsigned i = 1, e = TI->getNumSuccessors(); i != e; ++i)
-            TI->getSuccessor(i)->removePredecessor(TI->getParent());
-
-          // Remove the old terminator.
-          TI->eraseFromParent();
-        }
+        assert(Folded &&
+              "Expect TermInst on constantint or blockaddress to be folded");
+        (void) Folded;
       }
 
       // Finally, delete the basic block.
       F.getBasicBlockList().erase(DeadBB);
     }
     BlocksToErase.clear();
   }