[llvm-branch-commits] [clang] release/23.x: [X86][AVX10.2] Fix mask type and variable name mistakes (#244095) (PR #244877)

via llvm-branch-commits llvm-branch-commits at lists.llvm.org
Sat Nov 21 04:58:41 PST 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-backend-x86

Author: llvmbot

<details>
<summary>Changes</summary>

Backport 87764a902a9bdc02c52818ec4f226b962843f9c1

Requested by: @<!-- -->phoebewang

---
Full diff: https://github.com/llvm/llvm-project/pull/244877.diff


4 Files Affected:

- (modified) clang/lib/Headers/avx10_2_512minmaxintrin.h (+1-1) 
- (modified) clang/lib/Headers/avx10_2minmaxintrin.h (+1-1) 
- (modified) clang/test/CodeGen/X86/avx10_2_512minmax-builtins.c (+16-3) 
- (modified) clang/test/CodeGen/X86/avx10_2minmax-builtins.c (+36-36) 


``````````diff
diff --git a/clang/lib/Headers/avx10_2_512minmaxintrin.h b/clang/lib/Headers/avx10_2_512minmaxintrin.h
index fbc7fbadbc6b2d..361c2c21ccd515 100644
--- a/clang/lib/Headers/avx10_2_512minmaxintrin.h
+++ b/clang/lib/Headers/avx10_2_512minmaxintrin.h
@@ -16,7 +16,7 @@
 
 #define _mm512_minmax_pbh(A, B, C)                                             \
   ((__m512bh)__builtin_ia32_vminmaxbf16512((__v32bf)(__m512bh)(A),             \
-                                           (__v32bf)(__m512bh)(A), (int)(C)))
+                                           (__v32bf)(__m512bh)(B), (int)(C)))
 
 #define _mm512_mask_minmax_pbh(W, U, A, B, C)                                  \
   ((__m512bh)__builtin_ia32_selectpbf_512(                                     \
diff --git a/clang/lib/Headers/avx10_2minmaxintrin.h b/clang/lib/Headers/avx10_2minmaxintrin.h
index 809a01b04f13ef..cd7aab024ece63 100644
--- a/clang/lib/Headers/avx10_2minmaxintrin.h
+++ b/clang/lib/Headers/avx10_2minmaxintrin.h
@@ -88,7 +88,7 @@
 #define _mm_mask_minmax_ph(W, U, A, B, C)                                      \
   ((__m128h)__builtin_ia32_vminmaxph128_mask(                                  \
       (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (int)(C),                    \
-      (__v8hf)(__m128h)(W), (__mmask16)-1))
+      (__v8hf)(__m128h)(W), (__mmask8)(U)))
 
 #define _mm_maskz_minmax_ph(U, A, B, C)                                        \
   ((__m128h)__builtin_ia32_vminmaxph128_mask(                                  \
diff --git a/clang/test/CodeGen/X86/avx10_2_512minmax-builtins.c b/clang/test/CodeGen/X86/avx10_2_512minmax-builtins.c
index fa338253f58dfb..8824654feb7e60 100644
--- a/clang/test/CodeGen/X86/avx10_2_512minmax-builtins.c
+++ b/clang/test/CodeGen/X86/avx10_2_512minmax-builtins.c
@@ -7,20 +7,33 @@
 
 __m512bh test_mm512_minmax_pbh(__m512bh __A, __m512bh __B) {
   // CHECK-LABEL: @test_mm512_minmax_pbh(
-  // CHECK: call <32 x bfloat> @llvm.x86.avx10.vminmaxbf16512(
+  // CHECK: store <32 x bfloat> %{{.*}}, ptr [[AADDR:%[^,]+]],
+  // CHECK: store <32 x bfloat> %{{.*}}, ptr [[BADDR:%[^,]+]],
+  // CHECK: [[X:%.+]] = load <32 x bfloat>, ptr [[AADDR]],
+  // CHECK: [[Y:%.+]] = load <32 x bfloat>, ptr [[BADDR]],
+  // CHECK: call <32 x bfloat> @llvm.x86.avx10.vminmaxbf16512(<32 x bfloat> [[X]], <32 x bfloat> [[Y]], i32 127)
   return _mm512_minmax_pbh(__A, __B, 127);
 }
 
 __m512bh test_mm512_mask_minmax_pbh(__m512bh __A, __mmask32 __B, __m512bh __C, __m512bh __D) {
   // CHECK-LABEL: @test_mm512_mask_minmax_pbh(
-  // CHECK: call <32 x bfloat> @llvm.x86.avx10.vminmaxbf16512(
+  // CHECK: store <32 x bfloat> %{{.*}}, ptr [[AADDR:%[^,]+]],
+  // CHECK: store <32 x bfloat> %{{.*}}, ptr [[CADDR:%[^,]+]],
+  // CHECK: store <32 x bfloat> %{{.*}}, ptr [[DADDR:%[^,]+]],
+  // CHECK: [[X:%.+]] = load <32 x bfloat>, ptr [[CADDR]],
+  // CHECK: [[Y:%.+]] = load <32 x bfloat>, ptr [[DADDR]],
+  // CHECK: call <32 x bfloat> @llvm.x86.avx10.vminmaxbf16512(<32 x bfloat> [[X]], <32 x bfloat> [[Y]], i32 127)
   // CHECK: select <32 x i1> %{{.*}}, <32 x bfloat> %{{.*}}, <32 x bfloat> %{{.*}}
   return _mm512_mask_minmax_pbh(__A, __B, __C, __D, 127);
 }
 
 __m512bh test_mm512_maskz_minmax_pbh(__mmask32 __A, __m512bh __B, __m512bh __C) {
   // CHECK-LABEL: @test_mm512_maskz_minmax_pbh(
-  // CHECK: call <32 x bfloat> @llvm.x86.avx10.vminmaxbf16512(
+  // CHECK: store <32 x bfloat> %{{.*}}, ptr [[BADDR:%[^,]+]],
+  // CHECK: store <32 x bfloat> %{{.*}}, ptr [[CADDR:%[^,]+]],
+  // CHECK: [[X:%.+]] = load <32 x bfloat>, ptr [[BADDR]],
+  // CHECK: [[Y:%.+]] = load <32 x bfloat>, ptr [[CADDR]],
+  // CHECK: call <32 x bfloat> @llvm.x86.avx10.vminmaxbf16512(<32 x bfloat> [[X]], <32 x bfloat> [[Y]], i32 127)
   // CHECK: zeroinitializer
   // CHECK: select <32 x i1> %{{.*}}, <32 x bfloat> %{{.*}}, <32 x bfloat> %{{.*}}
   return _mm512_maskz_minmax_pbh(__A, __B, __C, 127);
diff --git a/clang/test/CodeGen/X86/avx10_2minmax-builtins.c b/clang/test/CodeGen/X86/avx10_2minmax-builtins.c
index 97faaf1ef4e120..fad4d07098ad79 100644
--- a/clang/test/CodeGen/X86/avx10_2minmax-builtins.c
+++ b/clang/test/CodeGen/X86/avx10_2minmax-builtins.c
@@ -49,216 +49,216 @@ __m256bh test_mm256_maskz_minmax_pbh(__mmask16 __A, __m256bh __B, __m256bh __C)
 
 __m128d test_mm_minmax_pd(__m128d __A, __m128d __B) {
   // CHECK-LABEL: @test_mm_minmax_pd(
-  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxpd128(
+  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxpd128({{.*}}, i8 -1)
   return _mm_minmax_pd(__A, __B, 127);
 }
 
 __m128d test_mm_mask_minmax_pd(__m128d __A, __mmask8 __B, __m128d __C, __m128d __D) {
   // CHECK-LABEL: @test_mm_mask_minmax_pd(
-  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxpd128(
+  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxpd128({{.*}}, i8 %{{.*}})
   return _mm_mask_minmax_pd(__A, __B, __C, __D, 127);
 }
 
 __m128d test_mm_maskz_minmax_pd(__mmask8 __A, __m128d __B, __m128d __C) {
   // CHECK-LABEL: @test_mm_maskz_minmax_pd(
-  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxpd128(
+  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxpd128({{.*}}, i8 %{{.*}})
   return _mm_maskz_minmax_pd(__A, __B, __C, 127);
 }
 
 __m256d test_mm256_minmax_pd(__m256d __A, __m256d __B) {
   // CHECK-LABEL: @test_mm256_minmax_pd(
-  // CHECK: call <4 x double> @llvm.x86.avx10.mask.vminmaxpd256(
+  // CHECK: call <4 x double> @llvm.x86.avx10.mask.vminmaxpd256({{.*}}, i8 -1)
   return _mm256_minmax_pd(__A, __B, 127);
 }
 
 __m256d test_mm256_mask_minmax_pd(__m256d __A, __mmask8 __B, __m256d __C, __m256d __D) {
   // CHECK-LABEL: @test_mm256_mask_minmax_pd(
-  // CHECK: call <4 x double> @llvm.x86.avx10.mask.vminmaxpd256(
+  // CHECK: call <4 x double> @llvm.x86.avx10.mask.vminmaxpd256({{.*}}, i8 %{{.*}})
   return _mm256_mask_minmax_pd(__A, __B, __C, __D, 127);
 }
 
 __m256d test_mm256_maskz_minmax_pd(__mmask8 __A, __m256d __B, __m256d __C) {
   // CHECK-LABEL: @test_mm256_maskz_minmax_pd(
-  // CHECK: call <4 x double> @llvm.x86.avx10.mask.vminmaxpd256(
+  // CHECK: call <4 x double> @llvm.x86.avx10.mask.vminmaxpd256({{.*}}, i8 %{{.*}})
   return _mm256_maskz_minmax_pd(__A, __B, __C, 127);
 }
 
 __m128h test_mm_minmax_ph(__m128h __A, __m128h __B) {
   // CHECK-LABEL: @test_mm_minmax_ph(
-  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxph128(
+  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxph128({{.*}}, i8 -1)
   return _mm_minmax_ph(__A, __B, 127);
 }
 
 __m128h test_mm_mask_minmax_ph(__m128h __A, __mmask8 __B, __m128h __C, __m128h __D) {
   // CHECK-LABEL: @test_mm_mask_minmax_ph(
-  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxph128(
+  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxph128({{.*}}, i8 %{{.*}})
   return _mm_mask_minmax_ph(__A, __B, __C, __D, 127);
 }
 
 __m128h test_mm_maskz_minmax_ph(__mmask8 __A, __m128h __B, __m128h __C) {
   // CHECK-LABEL: @test_mm_maskz_minmax_ph(
-  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxph128(
+  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxph128({{.*}}, i8 %{{.*}})
   return _mm_maskz_minmax_ph(__A, __B, __C, 127);
 }
 
 __m256h test_mm256_minmax_ph(__m256h __A, __m256h __B) {
   // CHECK-LABEL: @test_mm256_minmax_ph(
-  // CHECK: call <16 x half> @llvm.x86.avx10.mask.vminmaxph256(
+  // CHECK: call <16 x half> @llvm.x86.avx10.mask.vminmaxph256({{.*}}, i16 -1)
   return _mm256_minmax_ph(__A, __B, 127);
 }
 
 __m256h test_mm256_mask_minmax_ph(__m256h __A, __mmask16 __B, __m256h __C, __m256h __D) {
   // CHECK-LABEL: @test_mm256_mask_minmax_ph(
-  // CHECK: call <16 x half> @llvm.x86.avx10.mask.vminmaxph256(
+  // CHECK: call <16 x half> @llvm.x86.avx10.mask.vminmaxph256({{.*}}, i16 %{{.*}})
   return _mm256_mask_minmax_ph(__A, __B, __C, __D, 127);
 }
 
 __m256h test_mm256_maskz_minmax_ph(__mmask16 __A, __m256h __B, __m256h __C) {
   // CHECK-LABEL: @test_mm256_maskz_minmax_ph(
-  // CHECK: call <16 x half> @llvm.x86.avx10.mask.vminmaxph256(
+  // CHECK: call <16 x half> @llvm.x86.avx10.mask.vminmaxph256({{.*}}, i16 %{{.*}})
   return _mm256_maskz_minmax_ph(__A, __B, __C, 127);
 }
 
 __m128 test_mm_minmax_ps(__m128 __A, __m128 __B) {
   // CHECK-LABEL: @test_mm_minmax_ps(
-  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxps128(
+  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxps128({{.*}}, i8 -1)
   return _mm_minmax_ps(__A, __B, 127);
 }
 
 __m128 test_mm_mask_minmax_ps(__m128 __A, __mmask8 __B, __m128 __C, __m128 __D) {
   // CHECK-LABEL: @test_mm_mask_minmax_ps(
-  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxps128(
+  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxps128({{.*}}, i8 %{{.*}})
   return _mm_mask_minmax_ps(__A, __B, __C, __D, 127);
 }
 
 __m128 test_mm_maskz_minmax_ps(__mmask8 __A, __m128 __B, __m128 __C) {
   // CHECK-LABEL: @test_mm_maskz_minmax_ps(
-  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxps128(
+  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxps128({{.*}}, i8 %{{.*}})
   return _mm_maskz_minmax_ps(__A, __B, __C, 127);
 }
 
 __m256 test_mm256_minmax_ps(__m256 __A, __m256 __B) {
   // CHECK-LABEL: @test_mm256_minmax_ps(
-  // CHECK: call <8 x float> @llvm.x86.avx10.mask.vminmaxps256(
+  // CHECK: call <8 x float> @llvm.x86.avx10.mask.vminmaxps256({{.*}}, i8 -1)
   return _mm256_minmax_ps(__A, __B, 127);
 }
 
 __m256 test_mm256_mask_minmax_ps(__m256 __A, __mmask8 __B, __m256 __C, __m256 __D) {
   // CHECK-LABEL: @test_mm256_mask_minmax_ps(
-  // CHECK: call <8 x float> @llvm.x86.avx10.mask.vminmaxps256(
+  // CHECK: call <8 x float> @llvm.x86.avx10.mask.vminmaxps256({{.*}}, i8 %{{.*}})
   return _mm256_mask_minmax_ps(__A, __B, __C, __D, 127);
 }
 
 __m256 test_mm256_maskz_minmax_ps(__mmask8 __A, __m256 __B, __m256 __C) {
   // CHECK-LABEL: @test_mm256_maskz_minmax_ps(
-  // CHECK: call <8 x float> @llvm.x86.avx10.mask.vminmaxps256(
+  // CHECK: call <8 x float> @llvm.x86.avx10.mask.vminmaxps256({{.*}}, i8 %{{.*}})
   return _mm256_maskz_minmax_ps(__A, __B, __C, 127);
 }
 
 __m128d test_mm_minmax_sd(__m128d __A, __m128d __B) {
   // CHECK-LABEL: @test_mm_minmax_sd(
-  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxsd.round(
+  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxsd.round({{.*}}, i8 -1, i32 {{.*}})
   return _mm_minmax_sd(__A, __B, 127);
 }
 
 __m128d test_mm_mask_minmax_sd(__m128d __A, __mmask8 __B, __m128d __C, __m128d __D) {
   // CHECK-LABEL: @test_mm_mask_minmax_sd(
-  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxsd.round(
+  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxsd.round({{.*}}, i8 %{{.*}}, i32 {{.*}})
   return _mm_mask_minmax_sd(__A, __B, __C, __D, 127);
 }
 
 __m128d test_mm_maskz_minmax_sd(__mmask8 __A, __m128d __B, __m128d __C) {
   // CHECK-LABEL: @test_mm_maskz_minmax_sd(
-  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxsd.round(
+  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxsd.round({{.*}}, i8 %{{.*}}, i32 {{.*}})
   return _mm_maskz_minmax_sd(__A, __B, __C, 127);
 }
 
 __m128d test_mm_minmax_round_sd(__m128d __A, __m128d __B) {
   // CHECK-LABEL: @test_mm_minmax_round_sd(
-  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxsd.round(
+  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxsd.round({{.*}}, i8 -1, i32 {{.*}})
   return _mm_minmax_round_sd(__A, __B, 127, _MM_FROUND_NO_EXC);
 }
 
 __m128d test_mm_mask_minmax_round_sd(__m128d __A, __mmask8 __B, __m128d __C, __m128d __D) {
   // CHECK-LABEL: @test_mm_mask_minmax_round_sd(
-  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxsd.round(
+  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxsd.round({{.*}}, i8 %{{.*}}, i32 {{.*}})
   return _mm_mask_minmax_round_sd(__A, __B, __C, __D, 127, _MM_FROUND_NO_EXC);
 }
 
 __m128d test_mm_maskz_minmax_round_sd(__mmask8 __A, __m128d __B, __m128d __C) {
   // CHECK-LABEL: @test_mm_maskz_minmax_round_sd(
-  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxsd.round(
+  // CHECK: call <2 x double> @llvm.x86.avx10.mask.vminmaxsd.round({{.*}}, i8 %{{.*}}, i32 {{.*}})
   return _mm_maskz_minmax_round_sd(__A, __B, __C, 127, _MM_FROUND_NO_EXC);
 }
 
 __m128h test_mm_minmax_sh(__m128h __A, __m128h __B) {
   // CHECK-LABEL: @test_mm_minmax_sh(
-  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxsh.round(
+  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxsh.round({{.*}}, i8 -1, i32 {{.*}})
   return _mm_minmax_sh(__A, __B, 127);
 }
 
 __m128h test_mm_mask_minmax_sh(__m128h __A, __mmask8 __B, __m128h __C, __m128h __D) {
   // CHECK-LABEL: @test_mm_mask_minmax_sh(
-  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxsh.round(
+  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxsh.round({{.*}}, i8 %{{.*}}, i32 {{.*}})
   return _mm_mask_minmax_sh(__A, __B, __C, __D, 127);
 }
 
 __m128h test_mm_maskz_minmax_sh(__mmask8 __A, __m128h __B, __m128h __C) {
   // CHECK-LABEL: @test_mm_maskz_minmax_sh(
-  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxsh.round(
+  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxsh.round({{.*}}, i8 %{{.*}}, i32 {{.*}})
   return _mm_maskz_minmax_sh(__A, __B, __C, 127);
 }
 
 __m128h test_mm_minmax_round_sh(__m128h __A, __m128h __B) {
   // CHECK-LABEL: @test_mm_minmax_round_sh(
-  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxsh.round(
+  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxsh.round({{.*}}, i8 -1, i32 {{.*}})
   return _mm_minmax_round_sh(__A, __B, 127, _MM_FROUND_NO_EXC);
 }
 
 __m128h test_mm_mask_minmax_round_sh(__m128h __A, __mmask8 __B, __m128h __C, __m128h __D) {
   // CHECK-LABEL: @test_mm_mask_minmax_round_sh(
-  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxsh.round(
+  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxsh.round({{.*}}, i8 %{{.*}}, i32 {{.*}})
   return _mm_mask_minmax_round_sh(__A, __B, __C, __D, 127, _MM_FROUND_NO_EXC);
 }
 
 __m128h test_mm_maskz_minmax_round_sh(__mmask8 __A, __m128h __B, __m128h __C) {
   // CHECK-LABEL: @test_mm_maskz_minmax_round_sh(
-  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxsh.round(
+  // CHECK: call <8 x half> @llvm.x86.avx10.mask.vminmaxsh.round({{.*}}, i8 %{{.*}}, i32 {{.*}})
   return _mm_maskz_minmax_round_sh(__A, __B, __C, 127, _MM_FROUND_NO_EXC);
 }
 
 __m128 test_mm_minmax_ss(__m128 __A, __m128 __B) {
   // CHECK-LABEL: @test_mm_minmax_ss(
-  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxss.round(
+  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxss.round({{.*}}, i8 -1, i32 {{.*}})
   return _mm_minmax_ss(__A, __B, 127);
 }
 
 __m128 test_mm_mask_minmax_ss(__m128 __A, __mmask8 __B, __m128 __C, __m128 __D) {
   // CHECK-LABEL: @test_mm_mask_minmax_ss(
-  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxss.round(
+  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxss.round({{.*}}, i8 %{{.*}}, i32 {{.*}})
   return _mm_mask_minmax_ss(__A, __B, __C, __D, 127);
 }
 
 __m128 test_mm_maskz_minmax_ss(__mmask8 __A, __m128 __B, __m128 __C) {
   // CHECK-LABEL: @test_mm_maskz_minmax_ss(
-  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxss.round(
+  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxss.round({{.*}}, i8 %{{.*}}, i32 {{.*}})
   return _mm_maskz_minmax_ss(__A, __B, __C, 127);
 }
 
 __m128 test_mm_minmax_round_ss(__m128 __A, __m128 __B) {
   // CHECK-LABEL: @test_mm_minmax_round_ss(
-  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxss.round(
+  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxss.round({{.*}}, i8 -1, i32 {{.*}})
   return _mm_minmax_round_ss(__A, __B, 127, _MM_FROUND_NO_EXC);
 }
 
 __m128 test_mm_mask_minmax_round_ss(__m128 __A, __mmask8 __B, __m128 __C, __m128 __D) {
   // CHECK-LABEL: @test_mm_mask_minmax_round_ss(
-  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxss.round(
+  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxss.round({{.*}}, i8 %{{.*}}, i32 {{.*}})
   return _mm_mask_minmax_round_ss(__A, __B, __C, __D, 127, _MM_FROUND_NO_EXC);
 }
 
 __m128 test_mm_maskz_minmax_round_ss(__mmask8 __A, __m128 __B, __m128 __C) {
   // CHECK-LABEL: @test_mm_maskz_minmax_round_ss(
-  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxss.round(
+  // CHECK: call <4 x float> @llvm.x86.avx10.mask.vminmaxss.round({{.*}}, i8 %{{.*}}, i32 {{.*}})
   return _mm_maskz_minmax_round_ss(__A, __B, __C, 127, _MM_FROUND_NO_EXC);
 }

``````````

</details>


https://github.com/llvm/llvm-project/pull/244877


More information about the llvm-branch-commits mailing list