Constant fold llvm.expect(c, ...) -> c

[pete]

Summary

This teaches the constant folder that an llvm.expect intrinsic with a constant as the first operand will return that constant.

This reduces the size of an LTO'd llc by over 1% due to branches which can be removed once the constant is propagated.

[reames]

LGTM w/the addition of a negative test. (i.e. show constant fold not happening when the first operand isn't constant)

[pete]

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

lib/Analysis/ConstantFolding.cpp

 
 //===----------------------------------------------------------------------===//
 //  Constant Folding for Calls
 //
 
 /// Return true if it's even possible to fold a call to the specified function.
 bool llvm::canConstantFoldCallTo(const Function *F) {
   switch (F->getIntrinsicID()) {
+  case Intrinsic::expect:
   case Intrinsic::fabs:
   case Intrinsic::minnum:
   case Intrinsic::maxnum:
   case Intrinsic::log:
   case Intrinsic::log2:
   case Intrinsic::log10:
   case Intrinsic::exp:
   case Intrinsic::exp2:
if (ConstantInt *Op1 = dyn_cast<ConstantInt>(Operands[0])) {
         case Intrinsic::cttz:
           if (Op2->isOne() && Op1->isZero()) // cttz(0, 1) is undef.
             return UndefValue::get(Ty);
           return ConstantInt::get(Ty, Op1->getValue().countTrailingZeros());
         case Intrinsic::ctlz:
           if (Op2->isOne() && Op1->isZero()) // ctlz(0, 1) is undef.
             return UndefValue::get(Ty);
           return ConstantInt::get(Ty, Op1->getValue().countLeadingZeros());
+        case Intrinsic::expect:
+          // llvm.expect(constant, ...) -> constant
+          return Op1;
         }
       }
 
       return nullptr;
     }
     return nullptr;
   }
 

test/Transforms/InstSimplify/call.ll

cast.end:                                         ; preds = %cast.notnull, %entry
   %cast.result = phi i8* [ %add.ptr, %cast.notnull ], [ null, %entry ]
   ret i8* %cast.result
 
 ; CHECK-LABEL: @malloc_can_return_null
 ; CHECK: br i1 %cmp, label %cast.end, label %cast.notnull
 }
 
 declare noalias i8* @malloc(i64)
+
+; Constant fold llvm.expect(c, ...) -> c
+define i64 @constant_fold_expect() {
+  %c = call i64 @llvm.expect.i64(i64 1, i64 0)
+  ret i64 %c
+
+; CHECK-LABEL: @constant_fold_expect
+; CHECK: ret i64 1
+}
+
+declare i64 @llvm.expect.i64(i64, i64)