[IR] Clarify that expect intrinsics may take vector types

[frasercrmck]

Summary

This wasn't clear in the LangRef, nor was it tested.

The LowerExpectIntrinsic pass doesn't currently add branch weights to
those intrinsics using vector types, but the intrinsics are still
lowered.

[nikic]

I doubt that this was an intended feature -- just a side effect of how the intrinsic type constraints work. They always assume vectors are allowed for llvm_anyint_ty.

[frasercrmck]

In D144951#4157914, @nikic wrote:

I doubt that this was an intended feature -- just a side effect of how the intrinsic type constraints work. They always assume vectors are allowed for llvm_anyint_ty.

Yeah, I suspect so too. I think there are legitimate uses of the vector forms, though; better vectorization is one of them. Conceptually I don't see a problem with vector forms, either.

llvm/docs/LangRef.rst

 returns ``i32/i64 -1 or 0`` (depending on the ``min`` argument).
 
 '``llvm.expect``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
-This is an overloaded intrinsic. You can use ``llvm.expect`` on any
-integer bit width.
+This is an overloaded intrinsic. You can use ``llvm.expect`` on any scalar or
+vector integer type.
 
 ::
 
       declare i1 @llvm.expect.i1(i1 <val>, i1 <expected_val>)
       declare i32 @llvm.expect.i32(i32 <val>, i32 <expected_val>)
       declare i64 @llvm.expect.i64(i64 <val>, i64 <expected_val>)
+      declare <4 x i64> @llvm.expect.v4i64(<4 x i64> <val>, <4 x i64> <expected_val>)
+      declare <vscale x 1 x i8> @llvm.expect.nxv1i8(<vscale x 1 x i8> <val>, <vscale x 1 x i8> <expected_val>)
 
 Overview:
 """""""""
 
 The ``llvm.expect`` intrinsic provides information about expected (the
 most probable) value of ``val``, which can be used by optimizers.
 
 Arguments:

 
 '``llvm.expect.with.probability``' Intrinsic
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 This intrinsic is similar to ``llvm.expect``. This is an overloaded intrinsic.
-You can use ``llvm.expect.with.probability`` on any integer bit width.
+You can use ``llvm.expect.with.probability`` on any scalar or vector integer
+type.
 
 ::
 
       declare i1 @llvm.expect.with.probability.i1(i1 <val>, i1 <expected_val>, double <prob>)
       declare i32 @llvm.expect.with.probability.i32(i32 <val>, i32 <expected_val>, double <prob>)
       declare i64 @llvm.expect.with.probability.i64(i64 <val>, i64 <expected_val>, double <prob>)
+      declare <2 x i8> @llvm.expect.with.probability.v2i8(<2 x i8> <val>, <2 x i8> <expected_val>, double <prob>)
+      declare <vscale x 1 x i1> @llvm.expect.with.probability.nxv1i1(<vscale x 1 x i1> <val>, <vscale x 1 x i1> <expected_val>, double <prob>)
 
 Overview:
 """""""""
 
 The ``llvm.expect.with.probability`` intrinsic provides information about
-expected value of ``val`` with probability(or confidence) ``prob``, which can
+expected value of ``val`` with probability (or confidence) ``prob``, which can
 be used by optimizers.
 
 Arguments:
 """"""""""
 
 The ``llvm.expect.with.probability`` intrinsic takes three arguments. The first
 argument is a value. The second argument is an expected value. The third
 argument is a probability.

llvm/test/Transforms/LowerExpectIntrinsic/basic.ll

 define i32 @test10(i64 %t6) {
   %t7 = call i64 @llvm.expect.i64(i64 %t6, i64 0)
   %t8 = icmp ne i64 %t7, 0
   %t9 = select i1 %t8, i32 1, i32 2
 ; CHECK: select{{.*}}, !prof !1
   ret i32 %t9
 }
 
+; CHECK-LABEL: @test11(
+define <4 x i32> @test11(<4 x i64> %x, <4 x i32> %tval, <4 x i32> %fval) {
+  %expval = call <4 x i64> @llvm.expect.v4i64(<4 x i64> %x, <4 x i64> zeroinitializer)
+  %cmp = icmp ne <4 x i64> %expval, zeroinitializer
+  %sel = select <4 x i1> %cmp, <4 x i32> %tval, <4 x i32> %fval
+; CHECK-NOT: @llvm.expect
+; FIXME: We don't add branch weights to vector values
+; CHECK: select{{.*}}
+  ret <4 x i32> %sel
+}
+
+declare <4 x i64> @llvm.expect.v4i64(<4 x i64>, <4 x i64>) nounwind readnone
+
+; CHECK-LABEL: @test12(
+define <vscale x 1 x i32> @test12(<vscale x 1 x i64> %x, <vscale x 1 x i32> %tval, <vscale x 1 x i32> %fval) {
+  %expval = call <vscale x 1 x i64> @llvm.expect.nxv1i64(<vscale x 1 x i64> %x, <vscale x 1 x i64> zeroinitializer)
+  %cmp = icmp ne <vscale x 1 x i64> %expval, zeroinitializer
+  %sel = select <vscale x 1 x i1> %cmp, <vscale x 1 x i32> %tval, <vscale x 1 x i32> %fval
+; CHECK-NOT: @llvm.expect
+; FIXME: We don't add branch weights to vector values
+; CHECK: select{{.*}}
+  ret <vscale x 1 x i32> %sel
+}
+
+declare <vscale x 1 x i64> @llvm.expect.nxv1i64(<vscale x 1 x i64>, <vscale x 1 x i64>) nounwind readnone
 
 declare i1 @llvm.expect.i1(i1, i1) nounwind readnone
 
 ; CHECK: !0 = !{!"branch_weights", i32 2000, i32 1}
 ; CHECK: !1 = !{!"branch_weights", i32 1, i32 2000}
 ; CHECK: !2 = !{!"branch_weights", i32 1, i32 1, i32 2000}
 ; CHECK: !3 = !{!"branch_weights", i32 2000, i32 1, i32 1}

llvm/test/Transforms/LowerExpectIntrinsic/expect-with-probability.ll

 define i32 @test10(i64 %t6) {
   %t7 = call i64 @llvm.expect.with.probability.i64(i64 %t6, i64 0, double 8.000000e-01)
   %t8 = icmp ne i64 %t7, 0
   %t9 = select i1 %t8, i32 1, i32 2
 ; CHECK: select{{.*}}, !prof !1
   ret i32 %t9
 }
 
+; CHECK-LABEL: @test11(
+define <2 x i8> @test11(<2 x i8> %x) {
+  %expval = call <2 x i8> @llvm.expect.with.probability.v2i8(<2 x i8> %x, <2 x i8> zeroinitializer, double 8.000000e-01)
+  %cmp = icmp ne <2 x i8> %expval, zeroinitializer
+  %sel = select <2 x i1> %cmp, <2 x i8> <i8 1, i8 1>, <2 x i8> <i8 2, i8 2>
+; FIXME: We don't add branch weights to vector values
+; CHECK: select{{.*}}
+  ret <2 x i8> %sel
+}
+
+declare <2 x i8> @llvm.expect.with.probability.v2i8(<2 x i8>, <2 x i8>, double) nounwind readnone
+
+; CHECK-LABEL: @test12(
+define <vscale x 2 x i8> @test12(<vscale x 2 x i8> %x, <vscale x 2 x i8> %tval, <vscale x 2 x i8> %fval) {
+  %expval = call <vscale x 2 x i8> @llvm.expect.with.probability.nxv2i8(<vscale x 2 x i8> %x, <vscale x 2 x i8> zeroinitializer, double 8.000000e-01)
+  %cmp = icmp ne <vscale x 2 x i8> %expval, zeroinitializer
+  %sel = select <vscale x 2 x i1> %cmp, <vscale x 2 x i8> %tval, <vscale x 2 x i8> %fval
+; FIXME: We don't add branch weights to vector values
+; CHECK: select{{.*}}
+  ret <vscale x 2 x i8> %sel
+}
+
+declare <vscale x 2 x i8> @llvm.expect.with.probability.nxv2i8(<vscale x 2 x i8>, <vscale x 2 x i8>, double) nounwind readnone
 
 declare i1 @llvm.expect.with.probability.i1(i1, i1, double) nounwind readnone
 
 ; CHECK: !0 = !{!"branch_weights", i32 1717986918, i32 429496731}
 ; CHECK: !1 = !{!"branch_weights", i32 429496731, i32 1717986918}
 ; CHECK: !2 = !{!"branch_weights", i32 214748366, i32 214748366, i32 1717986918}
 ; CHECK: !3 = !{!"branch_weights", i32 1717986918, i32 214748366, i32 214748366}