diff --git a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst
--- a/llvm/docs/LangRef.rst
+++ b/llvm/docs/LangRef.rst
@@ -25476,14 +25476,16 @@
 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:
 """""""""
@@ -25509,19 +25511,22 @@
 """""""
 
 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:
diff --git a/llvm/test/Transforms/LowerExpectIntrinsic/basic.ll b/llvm/test/Transforms/LowerExpectIntrinsic/basic.ll
--- a/llvm/test/Transforms/LowerExpectIntrinsic/basic.ll
+++ b/llvm/test/Transforms/LowerExpectIntrinsic/basic.ll
@@ -281,6 +281,31 @@
   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
 
diff --git a/llvm/test/Transforms/LowerExpectIntrinsic/expect-with-probability.ll b/llvm/test/Transforms/LowerExpectIntrinsic/expect-with-probability.ll
--- a/llvm/test/Transforms/LowerExpectIntrinsic/expect-with-probability.ll
+++ b/llvm/test/Transforms/LowerExpectIntrinsic/expect-with-probability.ll
@@ -281,6 +281,29 @@
   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