Don't generate llvm.expect in IRGen when using -O0

[pete]

Summary

This patch stops us from generating llvm.expect when using -O0.

The backend only removes these intrinsics when the optimizer is run, and libLTO doesn't remove them at all. In a debug LTO build, this results in many constant llvm.expect calls which are never optimized out.

[chandlerc]

Awesome, thanks!

cfe/trunk/lib/CodeGen/CGBuiltin.cpp

if (Result->getType() != ResultType)
       Result = Builder.CreateIntCast(Result, ResultType, /*isSigned*/true,
                                      "cast");
     return RValue::get(Result);
   }
   case Builtin::BI__builtin_expect: {
     Value *ArgValue = EmitScalarExpr(E->getArg(0));
     llvm::Type *ArgType = ArgValue->getType();
 
-    Value *FnExpect = CGM.getIntrinsic(Intrinsic::expect, ArgType);
     Value *ExpectedValue = EmitScalarExpr(E->getArg(1));
+    // Don't generate llvm.expect on -O0 as the backend won't use it for
+    // anything.
+    // Note, we still IRGen ExpectedValue because it could have side-effects.
+    if (CGM.getCodeGenOpts().OptimizationLevel == 0)
+      return RValue::get(ArgValue);
 
+    Value *FnExpect = CGM.getIntrinsic(Intrinsic::expect, ArgType);
     Value *Result = Builder.CreateCall2(FnExpect, ArgValue, ExpectedValue,
                                         "expval");
     return RValue::get(Result);
   }
   case Builtin::BI__builtin_assume_aligned: {
     Value *PtrValue = EmitScalarExpr(E->getArg(0));
     Value *OffsetValue =
       (E->getNumArgs() > 2) ? EmitScalarExpr(E->getArg(2)) : nullptr;

cfe/trunk/test/CodeGen/builtin-expect.c

 // RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s -O0 | FileCheck %s --check-prefix=CHECK_O0
 
 int x;
 int y(void);
 void foo();
 void FUNC() {
+// CHECK-LABEL: define void @FUNC()
 // CHECK: [[call:%.*]] = call i32 @y
+// CHECK_O0: [[call:%.*]] = call i32 @y
+// CHECK_O0-NOT: call i64 @llvm.expect
   if (__builtin_expect (x, y()))
     foo ();
 }
 
 // rdar://9330105
 void isigprocmask(void);
 long bar();
 
 int main() {
     (void) __builtin_expect((isigprocmask(), 0), bar());
 }
 
+// CHECK-LABEL: define i32 @main()
 // CHECK: call void @isigprocmask()
 // CHECK: [[C:%.*]] = call i64 (...)* @bar()
+// CHECK_O0: call void @isigprocmask()
+// CHECK_O0: [[C:%.*]] = call i64 (...)* @bar()
+// CHECK_O0-NOT: call i64 @llvm.expect
 
 
-// CHECK: @test1
+// CHECK-LABEL: define i32 @test1
 int test1(int x) {
-// CHECK: @llvm.expect
+// CHECK_O0-NOT: call i64 @llvm.expect
   if (__builtin_expect (x, 1))
     return 0;
   return x;
 }
 
-// CHECK: @test2
+// CHECK: define i32 @test2
 int test2(int x) {
-// CHECK: @llvm.expect
+// CHECK_O0-NOT: call i64 @llvm.expect
   switch(__builtin_expect(x, 5)) {
   default:
     return 0;
   case 0:
   case 1:
   case 2:
     return 1;
   case 5:
     return 5;
   };
 
   return 0;
 }