Jump thread llvm.expect

[pete]

Summary

When jump threading this code

%B = phi i32 [%v1, %T1], [12, %F1]
%A = icmp ne i32 %B, 42

in asserts builds its common to have an expect in between:

%B = phi i64 [%v1, %T1], [12, %F1]
%expect = call i64 @llvm.expect.i64(i64 %B, i64 42)
%A = icmp ne i64 %expect, 42

This patch teaches JumpThreading about this case so that when we fail to find a PHI, we look through an llvm.expect to see if a PHI is its first source.

Reduces the size of an LTO'd llc by almost 2.5%.

[reames]

Looks straight forward. Provided your confident of the answer to my inline question, LGTM.

lib/Transforms/Scalar/JumpThreading.cpp

520

Can the PHITranslation now fail with your change?

test/Transforms/JumpThreading/expect.ll

10

Please use CHECK-LABEL so this file is easy to extend later.

Also, comment description at top of file should be clearer.

[pete]

http://reviews.llvm.org/D7183 supersedes this. Thanks to Chandler for the idea.

lib/Transforms/Scalar/JumpThreading.cpp

// Try to simplify some other binary operator values.
 
     return !Result.empty();
   }
 
   // Handle compare with phi operand, where the PHI is defined in this block.
   if (CmpInst *Cmp = dyn_cast<CmpInst>(I)) {
     assert(Preference == WantInteger && "Compares only produce integers");
     PHINode *PN = dyn_cast<PHINode>(Cmp->getOperand(0));
+
+    // Look through llvm.expect as its source value could be a PHI.
+    if (!PN) {
+      if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(Cmp->getOperand(0)))
+        if (II->getIntrinsicID() == Intrinsic::expect)
+          PN = dyn_cast<PHINode>(II->getArgOperand(0));
+    }
     if (PN && PN->getParent() == BB) {
       // We can do this simplification if any comparisons fold to true or false.
       // See if any do.
       for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
         BasicBlock *PredBB = PN->getIncomingBlock(i);
         Value *LHS = PN->getIncomingValue(i);
         Value *RHS = Cmp->getOperand(1)->DoPHITranslation(BB, PredBB);
 
         Value *Res = SimplifyCmpInst(Cmp->getPredicate(), LHS, RHS, DL);
         if (!Res) {
           if (!isa<Constant>(RHS))
             continue;
 
           LazyValueInfo::Tristate
             ResT = LVI->getPredicateOnEdge(Cmp->getPredicate(), LHS,

test/Transforms/JumpThreading/expect.ll

+; There should be no phi nodes left.
+; RUN: opt < %s -jump-threading -S | FileCheck %s
+
+; CHECK-NOT: phi
+
+declare i64 @f1()
+declare i64 @f2()
+declare void @f3()
+
+define i64 @test(i1 %cond) {
+  br i1 %cond, label %T1, label %F1
+
+T1:
+  %v1 = call i64 @f1()
+  br label %Merge
+
+F1:
+  %v2 = call i64 @f2()
+  br label %Merge
+
+Merge:
+  %B = phi i64 [%v1, %T1], [12, %F1]
+  %expect = call i64 @llvm.expect.i64(i64 %B, i64 42)
+  %A = icmp ne i64 %expect, 42
+  br i1 %A, label %T2, label %F2
+
+T2:
+  call void @f3()
+  ret i64 1
+
+F2:
+  ret i64 0
+}
+
+declare i64 @llvm.expect.i64(i64, i64)