Skip to content

[X86] avx512fp16-builtins.c - add C/C++ and 32/64-bit test coverage #152997

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom
Merged
merged 1 commit into from
Aug 11, 2025
Merged

[X86] avx512fp16-builtins.c - add C/C++ and 32/64-bit test coverage #152997

merged 1 commit into from
Aug 11, 2025

Conversation

RKSimon
Copy link
Collaborator

@RKSimon RKSimon commented Aug 11, 2025

Helps testing for #152910

@llvmbot llvmbot added clang Clang issues not falling into any other category backend:X86 labels Aug 11, 2025
@llvmbot
Copy link
Member

llvmbot commented Aug 11, 2025 •
edited
Loading

@llvm/pr-subscribers-backend-x86

@llvm/pr-subscribers-clang

Author: Simon Pilgrim (RKSimon)

Changes

Helps testing for #152910

Patch is 210.15 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/152997.diff

2 Files Affected:

  • (modified) clang/test/CodeGen/X86/avx512fp16-builtins.c (+445-442)
  • (modified) clang/test/CodeGen/X86/avx512vlfp16-builtins.c (+273-270)
diff --git a/clang/test/CodeGen/X86/avx512fp16-builtins.c b/clang/test/CodeGen/X86/avx512fp16-builtins.c
index d277d053147fd..d7ac2c94be62d 100644
--- a/clang/test/CodeGen/X86/avx512fp16-builtins.c
+++ b/clang/test/CodeGen/X86/avx512fp16-builtins.c
@@ -1,51 +1,54 @@
-// RUN: %clang_cc1 -ffreestanding -flax-vector-conversions=none %s -triple=x86_64-unknown-unknown -target-feature +avx512fp16 -emit-llvm -o - -Wall -Werror | FileCheck %s
+// RUN: %clang_cc1 -x c -ffreestanding -flax-vector-conversions=none %s -triple=x86_64-unknown-unknown -target-feature +avx512fp16 -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK,X64
+// RUN: %clang_cc1 -x c -ffreestanding -flax-vector-conversions=none %s -triple=i686-unknown-unknown -target-feature +avx512fp16 -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK
+// RUN: %clang_cc1 -x c++ -ffreestanding -flax-vector-conversions=none %s -triple=x86_64-unknown-unknown -target-feature +avx512fp16 -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK,X64
+// RUN: %clang_cc1 -x c++ -ffreestanding -flax-vector-conversions=none %s -triple=i686-unknown-unknown -target-feature +avx512fp16 -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK
 
 #include <immintrin.h>
 
 _Float16 test_mm512_cvtsh_h(__m512h __A) {
-  // CHECK-LABEL: @test_mm512_cvtsh_h
+  // CHECK-LABEL: test_mm512_cvtsh_h
   // CHECK: extractelement <32 x half> %{{.*}}, i32 0
   return _mm512_cvtsh_h(__A);
 }
 
 __m128h test_mm_setzero_ph(void) {
-  // CHECK-LABEL: @test_mm_setzero_ph
+  // CHECK-LABEL: test_mm_setzero_ph
   // CHECK: zeroinitializer
   return _mm_setzero_ph();
 }
 
 __m256h test_mm256_setzero_ph(void) {
-  // CHECK-LABEL: @test_mm256_setzero_ph
+  // CHECK-LABEL: test_mm256_setzero_ph
   // CHECK: zeroinitializer
   return _mm256_setzero_ph();
 }
 
 __m256h test_mm256_undefined_ph(void) {
-  // CHECK-LABEL: @test_mm256_undefined_ph
+  // CHECK-LABEL: test_mm256_undefined_ph
   // CHECK: ret <16 x half> zeroinitializer
   return _mm256_undefined_ph();
 }
 
 __m512h test_mm512_setzero_ph(void) {
-  // CHECK-LABEL: @test_mm512_setzero_ph
+  // CHECK-LABEL: test_mm512_setzero_ph
   // CHECK: zeroinitializer
   return _mm512_setzero_ph();
 }
 
 __m128h test_mm_undefined_ph(void) {
-  // CHECK-LABEL: @test_mm_undefined_ph
+  // CHECK-LABEL: test_mm_undefined_ph
   // CHECK: ret <8 x half> zeroinitializer
   return _mm_undefined_ph();
 }
 
 __m512h test_mm512_undefined_ph(void) {
-  // CHECK-LABEL: @test_mm512_undefined_ph
+  // CHECK-LABEL: test_mm512_undefined_ph
   // CHECK: ret <32 x half> zeroinitializer
   return _mm512_undefined_ph();
 }
 
 __m512h test_mm512_set1_ph(_Float16 h) {
-  // CHECK-LABEL: @test_mm512_set1_ph
+  // CHECK-LABEL: test_mm512_set1_ph
   // CHECK: insertelement <32 x half> {{.*}}, i32 0
   // CHECK: insertelement <32 x half> {{.*}}, i32 1
   // CHECK: insertelement <32 x half> {{.*}}, i32 2
@@ -82,7 +85,7 @@ __m512h test_mm512_set1_ph(_Float16 h) {
 }
 
 __m512h test_mm512_set1_pch(_Float16 _Complex h) {
-  // CHECK-LABEL: @test_mm512_set1_pch
+  // CHECK-LABEL: test_mm512_set1_pch
   // CHECK: insertelement <16 x float> {{.*}}, i32 0
   // CHECK: insertelement <16 x float> {{.*}}, i32 1
   // CHECK: insertelement <16 x float> {{.*}}, i32 2
@@ -111,7 +114,7 @@ __m512h test_mm512_set_ph(_Float16 __h1, _Float16 __h2, _Float16 __h3, _Float16
                           _Float16 __h21, _Float16 __h22, _Float16 __h23, _Float16 __h24,
                           _Float16 __h25, _Float16 __h26, _Float16 __h27, _Float16 __h28,
                           _Float16 __h29, _Float16 __h30, _Float16 __h31, _Float16 __h32) {
-  // CHECK-LABEL: @test_mm512_set_ph
+  // CHECK-LABEL: test_mm512_set_ph
   // CHECK: insertelement <32 x half> {{.*}}, i32 0
   // CHECK: insertelement <32 x half> {{.*}}, i32 1
   // CHECK: insertelement <32 x half> {{.*}}, i32 2
@@ -158,7 +161,7 @@ __m512h test_mm512_setr_ph(_Float16 __h1, _Float16 __h2, _Float16 __h3, _Float16
                            _Float16 __h21, _Float16 __h22, _Float16 __h23, _Float16 __h24,
                            _Float16 __h25, _Float16 __h26, _Float16 __h27, _Float16 __h28,
                            _Float16 __h29, _Float16 __h30, _Float16 __h31, _Float16 __h32) {
-  // CHECK-LABEL: @test_mm512_setr_ph
+  // CHECK-LABEL: test_mm512_setr_ph
   // CHECK: insertelement <32 x half> {{.*}}, i32 0
   // CHECK: insertelement <32 x half> {{.*}}, i32 1
   // CHECK: insertelement <32 x half> {{.*}}, i32 2
@@ -368,327 +371,327 @@ __m512h test_mm512_zextph256_ph512(__m256h __a) {
 
 int test_mm_comi_round_sh(__m128h __A, __m128h __B) {
   // CHECK-LABEL: test_mm_comi_round_sh
-  // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 0, i32 8)
+  // CHECK: @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 0, i32 8)
   return _mm_comi_round_sh(__A, __B, 0, _MM_FROUND_NO_EXC);
 }
 
 int test_mm_comi_sh(__m128h __A, __m128h __B) {
   // CHECK-LABEL: test_mm_comi_sh
-  // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 0, i32 4)
+  // CHECK: @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 0, i32 4)
   return _mm_comi_sh(__A, __B, 0);
 }
 
 int test_mm_comieq_sh(__m128h __A, __m128h __B) {
   // CHECK-LABEL: test_mm_comieq_sh
-  // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 16, i32 4)
+  // CHECK: @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 16, i32 4)
   return _mm_comieq_sh(__A, __B);
 }
 
 int test_mm_comilt_sh(__m128h __A, __m128h __B) {
   // CHECK-LABEL: test_mm_comilt_sh
-  // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 1, i32 4)
+  // CHECK: @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 1, i32 4)
   return _mm_comilt_sh(__A, __B);
 }
 
 int test_mm_comile_sh(__m128h __A, __m128h __B) {
   // CHECK-LABEL: test_mm_comile_sh
-  // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 2, i32 4)
+  // CHECK: @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 2, i32 4)
   return _mm_comile_sh(__A, __B);
 }
 
 int test_mm_comigt_sh(__m128h __A, __m128h __B) {
   // CHECK-LABEL: test_mm_comigt_sh
-  // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 14, i32 4)
+  // CHECK: @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 14, i32 4)
   return _mm_comigt_sh(__A, __B);
 }
 
 int test_mm_comige_sh(__m128h __A, __m128h __B) {
   // CHECK-LABEL: test_mm_comige_sh
-  // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 13, i32 4)
+  // CHECK: @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 13, i32 4)
   return _mm_comige_sh(__A, __B);
 }
 
 int test_mm_comineq_sh(__m128h __A, __m128h __B) {
   // CHECK-LABEL: test_mm_comineq_sh
-  // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 20, i32 4)
+  // CHECK: @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 20, i32 4)
   return _mm_comineq_sh(__A, __B);
 }
 
 int test_mm_ucomieq_sh(__m128h __A, __m128h __B) {
   // CHECK-LABEL: test_mm_ucomieq_sh
-  // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 0, i32 4)
+  // CHECK: @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 0, i32 4)
   return _mm_ucomieq_sh(__A, __B);
 }
 
 int test_mm_ucomilt_sh(__m128h __A, __m128h __B) {
   // CHECK-LABEL: test_mm_ucomilt_sh
-  // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 17, i32 4)
+  // CHECK: @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 17, i32 4)
   return _mm_ucomilt_sh(__A, __B);
 }
 
 int test_mm_ucomile_sh(__m128h __A, __m128h __B) {
   // CHECK-LABEL: test_mm_ucomile_sh
-  // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 18, i32 4)
+  // CHECK: @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 18, i32 4)
   return _mm_ucomile_sh(__A, __B);
 }
 
 int test_mm_ucomigt_sh(__m128h __A, __m128h __B) {
   // CHECK-LABEL: test_mm_ucomigt_sh
-  // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 30, i32 4)
+  // CHECK: @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 30, i32 4)
   return _mm_ucomigt_sh(__A, __B);
 }
 
 int test_mm_ucomige_sh(__m128h __A, __m128h __B) {
   // CHECK-LABEL: test_mm_ucomige_sh
-  // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 29, i32 4)
+  // CHECK: @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 29, i32 4)
   return _mm_ucomige_sh(__A, __B);
 }
 
 int test_mm_ucomineq_sh(__m128h __A, __m128h __B) {
   // CHECK-LABEL: test_mm_ucomineq_sh
-  // CHECK: %{{.}} = call i32 @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 4, i32 4)
+  // CHECK: @llvm.x86.avx512fp16.vcomi.sh(<8 x half> %{{.}}, <8 x half> %{{.}}, i32 4, i32 4)
   return _mm_ucomineq_sh(__A, __B);
 }
 
 __m512h test_mm512_add_ph(__m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_add_ph
+  // CHECK-LABEL: test_mm512_add_ph
   // CHECK: %{{.*}} = fadd <32 x half> %{{.*}}, %{{.*}}
   return _mm512_add_ph(__A, __B);
 }
 
 __m512h test_mm512_mask_add_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_mask_add_ph
+  // CHECK-LABEL: test_mm512_mask_add_ph
   // CHECK: %{{.*}} = fadd <32 x half> %{{.*}}, %{{.*}}
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return (__m512h)_mm512_mask_add_ph(__W, __U, __A, __B);
 }
 
 __m512h test_mm512_maskz_add_ph(__mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_maskz_add_ph
+  // CHECK-LABEL: test_mm512_maskz_add_ph
   // CHECK: %{{.*}} = fadd <32 x half> %{{.*}}, %{{.*}}
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return _mm512_maskz_add_ph(__U, __A, __B);
 }
 
 __m512h test_mm512_add_round_ph(__m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_add_round_ph
+  // CHECK-LABEL: test_mm512_add_round_ph
   // CHECK: @llvm.x86.avx512fp16.add.ph.512
   return _mm512_add_round_ph(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 }
 __m512h test_mm512_mask_add_round_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_mask_add_round_ph
+  // CHECK-LABEL: test_mm512_mask_add_round_ph
   // CHECK: @llvm.x86.avx512fp16.add.ph.512
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return _mm512_mask_add_round_ph(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 }
 __m512h test_mm512_maskz_add_round_ph(__mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_maskz_add_round_ph
+  // CHECK-LABEL: test_mm512_maskz_add_round_ph
   // CHECK: @llvm.x86.avx512fp16.add.ph.512
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return _mm512_maskz_add_round_ph(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 }
 
 __m512h test_mm512_sub_ph(__m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_sub_ph
+  // CHECK-LABEL: test_mm512_sub_ph
   // CHECK: %{{.*}} = fsub <32 x half> %{{.*}}, %{{.*}}
   return _mm512_sub_ph(__A, __B);
 }
 
 __m512h test_mm512_mask_sub_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_mask_sub_ph
+  // CHECK-LABEL: test_mm512_mask_sub_ph
   // CHECK: %{{.*}} = fsub <32 x half> %{{.*}}, %{{.*}}
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return (__m512h)_mm512_mask_sub_ph(__W, __U, __A, __B);
 }
 
 __m512h test_mm512_maskz_sub_ph(__mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_maskz_sub_ph
+  // CHECK-LABEL: test_mm512_maskz_sub_ph
   // CHECK: %{{.*}} = fsub <32 x half> %{{.*}}, %{{.*}}
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return _mm512_maskz_sub_ph(__U, __A, __B);
 }
 
 __m512h test_mm512_sub_round_ph(__m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_sub_round_ph
+  // CHECK-LABEL: test_mm512_sub_round_ph
   // CHECK: @llvm.x86.avx512fp16.sub.ph.512
   return _mm512_sub_round_ph(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 }
 __m512h test_mm512_mask_sub_round_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_mask_sub_round_ph
+  // CHECK-LABEL: test_mm512_mask_sub_round_ph
   // CHECK: @llvm.x86.avx512fp16.sub.ph.512
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return _mm512_mask_sub_round_ph(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 }
 __m512h test_mm512_maskz_sub_round_ph(__mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_maskz_sub_round_ph
+  // CHECK-LABEL: test_mm512_maskz_sub_round_ph
   // CHECK: @llvm.x86.avx512fp16.sub.ph.512
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return _mm512_maskz_sub_round_ph(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 }
 
 __m512h test_mm512_mul_ph(__m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_mul_ph
+  // CHECK-LABEL: test_mm512_mul_ph
   // CHECK: %{{.*}} = fmul <32 x half> %{{.*}}, %{{.*}}
   return _mm512_mul_ph(__A, __B);
 }
 
 __m512h test_mm512_mask_mul_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_mask_mul_ph
+  // CHECK-LABEL: test_mm512_mask_mul_ph
   // CHECK: %{{.*}} = fmul <32 x half> %{{.*}}, %{{.*}}
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return (__m512h)_mm512_mask_mul_ph(__W, __U, __A, __B);
 }
 
 __m512h test_mm512_maskz_mul_ph(__mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_maskz_mul_ph
+  // CHECK-LABEL: test_mm512_maskz_mul_ph
   // CHECK: %{{.*}} = fmul <32 x half> %{{.*}}, %{{.*}}
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return _mm512_maskz_mul_ph(__U, __A, __B);
 }
 
 __m512h test_mm512_mul_round_ph(__m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_mul_round_ph
+  // CHECK-LABEL: test_mm512_mul_round_ph
   // CHECK: @llvm.x86.avx512fp16.mul.ph.512
   return _mm512_mul_round_ph(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 }
 __m512h test_mm512_mask_mul_round_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_mask_mul_round_ph
+  // CHECK-LABEL: test_mm512_mask_mul_round_ph
   // CHECK: @llvm.x86.avx512fp16.mul.ph.512
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return _mm512_mask_mul_round_ph(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 }
 __m512h test_mm512_maskz_mul_round_ph(__mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_maskz_mul_round_ph
+  // CHECK-LABEL: test_mm512_maskz_mul_round_ph
   // CHECK: @llvm.x86.avx512fp16.mul.ph.512
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return _mm512_maskz_mul_round_ph(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 }
 
 __m512h test_mm512_div_ph(__m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_div_ph
+  // CHECK-LABEL: test_mm512_div_ph
   // CHECK: %{{.*}} = fdiv <32 x half> %{{.*}}, %{{.*}}
   return _mm512_div_ph(__A, __B);
 }
 
 __m512h test_mm512_mask_div_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_mask_div_ph
+  // CHECK-LABEL: test_mm512_mask_div_ph
   // CHECK: %{{.*}} = fdiv <32 x half> %{{.*}}, %{{.*}}
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return (__m512h)_mm512_mask_div_ph(__W, __U, __A, __B);
 }
 
 __m512h test_mm512_maskz_div_ph(__mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_maskz_div_ph
+  // CHECK-LABEL: test_mm512_maskz_div_ph
   // CHECK: %{{.*}} = fdiv <32 x half> %{{.*}}, %{{.*}}
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return _mm512_maskz_div_ph(__U, __A, __B);
 }
 
 __m512h test_mm512_div_round_ph(__m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_div_round_ph
+  // CHECK-LABEL: test_mm512_div_round_ph
   // CHECK: @llvm.x86.avx512fp16.div.ph.512
   return _mm512_div_round_ph(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 }
 __m512h test_mm512_mask_div_round_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_mask_div_round_ph
+  // CHECK-LABEL: test_mm512_mask_div_round_ph
   // CHECK: @llvm.x86.avx512fp16.div.ph.512
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return _mm512_mask_div_round_ph(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 }
 __m512h test_mm512_maskz_div_round_ph(__mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_maskz_div_round_ph
+  // CHECK-LABEL: test_mm512_maskz_div_round_ph
   // CHECK: @llvm.x86.avx512fp16.div.ph.512
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return _mm512_maskz_div_round_ph(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 }
 
 __m512h test_mm512_min_ph(__m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_min_ph
+  // CHECK-LABEL: test_mm512_min_ph
   // CHECK: @llvm.x86.avx512fp16.min.ph.512
   return _mm512_min_ph(__A, __B);
 }
 
 __m512h test_mm512_mask_min_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_mask_min_ph
+  // CHECK-LABEL: test_mm512_mask_min_ph
   // CHECK: @llvm.x86.avx512fp16.min.ph.512
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return (__m512h)_mm512_mask_min_ph(__W, __U, __A, __B);
 }
 
 __m512h test_mm512_maskz_min_ph(__mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_maskz_min_ph
+  // CHECK-LABEL: test_mm512_maskz_min_ph
   // CHECK: @llvm.x86.avx512fp16.min.ph.512
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return _mm512_maskz_min_ph(__U, __A, __B);
 }
 
 __m512h test_mm512_min_round_ph(__m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_min_round_ph
+  // CHECK-LABEL: test_mm512_min_round_ph
   // CHECK: @llvm.x86.avx512fp16.min.ph.512
   return _mm512_min_round_ph(__A, __B, _MM_FROUND_NO_EXC);
 }
 __m512h test_mm512_mask_min_round_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_mask_min_round_ph
+  // CHECK-LABEL: test_mm512_mask_min_round_ph
   // CHECK: @llvm.x86.avx512fp16.min.ph.512
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return _mm512_mask_min_round_ph(__W, __U, __A, __B, _MM_FROUND_NO_EXC);
 }
 __m512h test_mm512_maskz_min_round_ph(__mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_maskz_min_round_ph
+  // CHECK-LABEL: test_mm512_maskz_min_round_ph
   // CHECK: @llvm.x86.avx512fp16.min.ph.512
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return _mm512_maskz_min_round_ph(__U, __A, __B, _MM_FROUND_NO_EXC);
 }
 
 __m512h test_mm512_max_ph(__m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_max_ph
+  // CHECK-LABEL: test_mm512_max_ph
   // CHECK: @llvm.x86.avx512fp16.max.ph.512
 
   return _mm512_max_ph(__A, __B);
 }
 
 __m512h test_mm512_mask_max_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_mask_max_ph
+  // CHECK-LABEL: test_mm512_mask_max_ph
   // CHECK: @llvm.x86.avx512fp16.max.ph.512
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return (__m512h)_mm512_mask_max_ph(__W, __U, __A, __B);
 }
 
 __m512h test_mm512_maskz_max_ph(__mmask32 __U, __m512h __A, __m512h __B) {
-  // CHECK-LABEL: @test_mm512_maskz_max_ph
+  // CHECK-LABEL: test_mm512_maskz_max_ph
   // CHECK: @llvm.x86.avx512fp16.max.ph.512
   // CHECK: select <32 x i1> %{{.*}}, <32 x half> %{{.*}}, <32 x half> %{{.*}}
   return _mm512_maskz_max_ph(__U, __A, __B);
 }
 
 __m512h test_mm512_max_round_ph(__m512h __A, __m512h __B) {...
[truncated]

@RKSimon RKSimon mentioned this pull request Aug 11, 2025
Merged
@RKSimon RKSimon merged commit 880d15e into llvm:main Aug 11, 2025
12 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Reviewers
No reviews
Assignees
No one assigned
Labels
backend:X86 clang Clang issues not falling into any other category
Projects
None yet
Milestone
No milestone
Development

Successfully merging this pull request may close these issues.
2 participants
@RKSimon @llvmbot