[JumpThread] Do RAUW in case Cond folds to a constant in the CFG

[trentxintong]

Summary

This is done in ProcessThreadableEdges where we compute all the possible
values from all predecessors.

This depends on https://reviews.llvm.org/D30869

[trentxintong]

Update comments.

[trentxintong]

This has been checked in in a different commit.

lib/Transforms/Scalar/JumpThreading.cpp

bool JumpThreadingPass::ProcessThreadableEdges(Value *Cond, BasicBlock *BB,
   // a list of known destinations for each pred.  This also discards duplicate
   // predecessors and keeps track of the undefined inputs (which are represented
   // as a null dest in the PredToDestList).
   SmallPtrSet<BasicBlock*, 16> SeenPreds;
   SmallVector<std::pair<BasicBlock*, BasicBlock*>, 16> PredToDestList;
 
   BasicBlock *OnlyDest = nullptr;
   BasicBlock *MultipleDestSentinel = (BasicBlock*)(intptr_t)~0ULL;
+  Constant *OnlyVal = nullptr;
+  Constant *MultipleDestVal = (Constant *)(intptr_t)~0ULL;
 
   unsigned PredWithKnownSuccessor = 0;
   for (const auto &PredValue : PredValues) {
     BasicBlock *Pred = PredValue.second;
     if (!SeenPreds.insert(Pred).second)
       continue;  // Duplicate predecessor entry.
 
     Constant *Val = PredValue.first;
 
     BasicBlock *DestBB;
     if (isa<UndefValue>(Val))
       DestBB = nullptr;
     else if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator()))
       DestBB = BI->getSuccessor(cast<ConstantInt>(Val)->isZero());
     else if (SwitchInst *SI = dyn_cast<SwitchInst>(BB->getTerminator())) {
       DestBB = SI->findCaseValue(cast<ConstantInt>(Val)).getCaseSuccessor();
     } else {
       assert(isa<IndirectBrInst>(BB->getTerminator())
               && "Unexpected terminator");
       DestBB = cast<BlockAddress>(Val)->getBasicBlock();
     }
 
     // If we have exactly one destination, remember it for efficiency below.
-    if (PredToDestList.empty())
+    if (PredToDestList.empty()) {
       OnlyDest = DestBB;
-    else if (OnlyDest != DestBB)
+      OnlyVal = Val;
+    } else {
+      if (OnlyDest != DestBB)
         OnlyDest = MultipleDestSentinel;
+      // It possible we have same destination, but different value, e.g. default
+      // case in switchinst.
+      if (Val != OnlyVal)
+        OnlyVal = MultipleDestVal;
+    }
 
     // We know where this predecessor will go.
     PredWithKnownSuccessor++;
 
     // If the predecessor ends with an indirect goto, we can't change its
     // destination, so do not push it into the PredToDestList. However, it
     // is still a predecessor with known successor target.
     if (isa<IndirectBrInst>(Pred->getTerminator()))
if (PredWithKnownSuccessor ==
       BranchInst::Create(OnlyDest, Term);
       Term->eraseFromParent();
 
       // If the condition is now dead due to the removal of the old terminator,
       // erase it.
       auto *CondInst = dyn_cast<Instruction>(Cond);
       if (CondInst && CondInst->use_empty())
         CondInst->eraseFromParent();
-      // FIXME: in case this instruction is defined in the current BB and it
-      // resolves to a single value from all predecessors, we can do RAUW.
+      else if (CondInst && OnlyVal && OnlyVal != MultipleDestVal &&
+               CondInst->getParent() == BB) {
+        // If the fact we just learned is the same value for all uses of the
+        // condition, replace it with a constant value
+        CondInst->replaceAllUsesWith(OnlyVal);
+        CondInst->eraseFromParent();
+      }
       return true;
     }
   }
 
   // Determine which is the most common successor.  If we have many inputs and
   // this block is a switch, we want to start by threading the batch that goes
   // to the most popular destination first.  If we only know about one
   // threadable destination (the common case) we can avoid this.

test/Transforms/JumpThreading/basic.ll

 ; RUN: opt -jump-threading -S < %s | FileCheck %s
 
 declare i32 @f1()
 declare i32 @f2()
 declare void @f3()
+declare void @f4(i32)
+
+; Make sure we can do the RAUW for %add...
+;
+; CHECK-LABEL: @rauw_if_possible(
+; CHECK: call void @f4(i32 96) 
+define void @rauw_if_possible(i32 %value) nounwind {
+entry:
+  %cmp = icmp eq i32 %value, 32
+  br i1 %cmp, label %L0, label %L3 
+L0:
+  call i32 @f2()
+  call i32 @f2()
+  %add = add i32 %value, 64
+  switch i32 %add, label %L3 [
+    i32 32, label %L1
+    i32 96, label %L2
+    ]
+
+L1:
+  call void @f3()
+  ret void
+L2:
+  call void @f4(i32 %add)
+  ret void
+L3:
+  call void @f3()
+  ret void
+}
 
 ; Make sure we can fold this branch ... We will not be able to thread it as
 ; L0 is too big to duplicate.
 ;
 ; CHECK-LABEL: @test_br_folding_not_threading(
 ; CHECK: L1:
 ; CHECK: call i32 @f2()
 ; CHECK: call void @f3()
L1:
   ret void
 L2:
   call void @f3()
   ret void
 L3:
   call void @f3()
   ret void
 }
-
 define i32 @test1(i1 %cond) {
 ; CHECK-LABEL: @test1(
 
   br i1 %cond, label %T1, label %F1
 
 T1:
   %v1 = call i32 @f1()
   br label %Merge