Remove immarg from llvm.expect

[arsenm]

Summary

The LangRef claimed this was required to be a constant, but this
appears to be wrong.

Fixes bug 41079.

[hfinkel]

LGTM. Maybe we can also add the test case from the PR as one of Clang's regression tests?

[arsenm]

r356353, r356354

docs/LangRef.rst

 
 The ``llvm.expect`` intrinsic provides information about expected (the
 most probable) value of ``val``, which can be used by optimizers.
 
 Arguments:
 """"""""""
 
 The ``llvm.expect`` intrinsic takes two arguments. The first argument is
-a value. The second argument is an expected value, this needs to be a
-constant value, variables are not allowed.
+a value. The second argument is an expected value.
 
 Semantics:
 """"""""""
 
 This intrinsic is lowered to the ``val``.
 
 .. _int_assume:
 

include/llvm/IR/Intrinsics.td

def int_experimental_constrained_round : Intrinsic<[ llvm_anyfloat_ty ],
                                                       llvm_metadata_ty,
                                                       llvm_metadata_ty ]>;
   def int_experimental_constrained_trunc : Intrinsic<[ llvm_anyfloat_ty ],
                                                      [ LLVMMatchType<0>,
                                                        llvm_metadata_ty,
                                                        llvm_metadata_ty ]>;
 }
 // FIXME: Add intrinsics for fcmp, fptrunc, fpext, fptoui and fptosi.
-// FIXME: Add intrinsics for fabs and copysign? 
+// FIXME: Add intrinsics for fabs and copysign?
 
 
 //===------------------------- Expect Intrinsics --------------------------===//
 //
 def int_expect : Intrinsic<[llvm_anyint_ty],
-  [LLVMMatchType<0>, LLVMMatchType<0>], [IntrNoMem, ImmArg<1>]>;
+  [LLVMMatchType<0>, LLVMMatchType<0>], [IntrNoMem]>;
 
 //===-------------------- Bit Manipulation Intrinsics ---------------------===//
 //
 
 // None of these intrinsics accesses memory at all.
 let IntrProperties = [IntrNoMem, IntrSpeculatable] in {
   def int_bswap: Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>]>;
   def int_ctpop: Intrinsic<[llvm_anyint_ty], [LLVMMatchType<0>]>;

test/Transforms/LowerExpectIntrinsic/PR33346.ll

 ; RUN: opt -lower-expect -S < %s
 ; RUN: opt -passes='function(lower-expect)' -S < %s
 
 define i64 @foo(i64 %arg) #0 {
 bb:
   %tmp = alloca i64, align 8
   store i64 %arg, i64* %tmp, align 8
   %tmp1 = load i64, i64* %tmp, align 8
   %tmp2 = load i64, i64* %tmp, align 8
-  %tmp3 = call i64 @llvm.expect.i64(i64 %tmp1, i64 123)
+  %tmp3 = call i64 @llvm.expect.i64(i64 %tmp1, i64 %tmp2)
   ret i64 %tmp3
 }
 
 ; Function Attrs: nounwind readnone
-declare i64 @llvm.expect.i64(i64, i64 immarg)
+declare i64 @llvm.expect.i64(i64, i64)
 
 
 !llvm.module.flags = !{!0}
 !llvm.ident = !{!1}
 
 !0 = !{i32 1, !"wchar_size", i32 4}
 !1 = !{!"clang version 5.0.0 (trunk 304723)"}

test/Verifier/intrinsic-immarg.ll

define void @objectsize(i8* %ptr, i1 %a, i1 %b, i1 %c) {
 
   ; CHECK: immarg operand has non-immediate parameter
   ; CHECK-NEXT: i1 %c
   ; CHECK-NEXT: %val2 = call i64 @llvm.objectsize.i64.p0i8(i8* %ptr, i1 false, i1 false, i1 %c)
   %val2 = call i64 @llvm.objectsize.i64.p0i8(i8* %ptr, i1 false, i1 false, i1 %c)
   ret void
 }
 
-declare i8 @llvm.expect.i8(i8, i8)
-define i8 @expect(i8 %arg0, i8 %arg1) {
-  ; CHECK: immarg operand has non-immediate parameter
-  ; CHECK-NEXT: i8 %arg1
-  ; CHECK-NEXT: %ret = call i8 @llvm.expect.i8(i8 %arg0, i8 %arg1)
-  %ret = call i8 @llvm.expect.i8(i8 %arg0, i8 %arg1)
-  ret i8 %ret
-}
-
 declare i64 @llvm.smul.fix.i64(i64, i64, i32)
 define i64 @smul_fix(i64 %arg0, i64 %arg1, i32 %arg2) {
   ; CHECK: immarg operand has non-immediate parameter
   ; CHECK-NEXT: i32 %arg2
   ; CHECK-NEXT: %ret = call i64 @llvm.smul.fix.i64(i64 %arg0, i64 %arg1, i32 %arg2)
   %ret = call i64 @llvm.smul.fix.i64(i64 %arg0, i64 %arg1, i32 %arg2)
   ret i64 %ret
 }