llvmbot wrote:

<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-clang

Author: Simon Pilgrim (RKSimon)

<details>
<summary>Changes</summary>



---

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


1 Files Affected:

- (modified) clang/test/CodeGen/X86/avx512vl-builtins.c (+1283-1282) 


``````````diff
diff --git a/clang/test/CodeGen/X86/avx512vl-builtins.c 
b/clang/test/CodeGen/X86/avx512vl-builtins.c
index 1c2d467a47428..ac7aa3eedbb99 100644
--- a/clang/test/CodeGen/X86/avx512vl-builtins.c
+++ b/clang/test/CodeGen/X86/avx512vl-builtins.c
@@ -1,602 +1,603 @@
-// RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s 
-triple=x86_64-apple-darwin -target-feature +avx512f -target-feature +avx512vl 
-emit-llvm -o - -Wall -Werror -Wsign-conversion | FileCheck %s
+// RUN: %clang_cc1 -x c -flax-vector-conversions=none -ffreestanding %s 
-triple=x86_64-apple-darwin -target-feature +avx512f -target-feature +avx512vl 
-emit-llvm -o - -Wall -Werror -Wsign-conversion | FileCheck %s
+// RUN: %clang_cc1 -x c++ -flax-vector-conversions=none -ffreestanding %s 
-triple=x86_64-apple-darwin -target-feature +avx512f -target-feature +avx512vl 
-emit-llvm -o - -Wall -Werror -Wsign-conversion | FileCheck %s
 
 #include <immintrin.h>
 
 __mmask8 test_mm_cmpeq_epu32_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmpeq_epu32_mask
+  // CHECK-LABEL: test_mm_cmpeq_epu32_mask
   // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
   // CHECK: shufflevector <4 x i1> %{{.*}}, <4 x i1> zeroinitializer, <8 x 
i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
   return (__mmask8)_mm_cmpeq_epu32_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmpeq_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) 
{
-  // CHECK-LABEL: @test_mm_mask_cmpeq_epu32_mask
+  // CHECK-LABEL: test_mm_mask_cmpeq_epu32_mask
   // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmpeq_epu32_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmpeq_epu64_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmpeq_epu64_mask
+  // CHECK-LABEL: test_mm_cmpeq_epu64_mask
   // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
   // CHECK: shufflevector <2 x i1> %{{.*}}, <2 x i1> zeroinitializer, <8 x 
i32> <i32 0, i32 1, i32 2, i32 3, i32 2, i32 3, i32 2, i32 3>
   return (__mmask8)_mm_cmpeq_epu64_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmpeq_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) 
{
-  // CHECK-LABEL: @test_mm_mask_cmpeq_epu64_mask
+  // CHECK-LABEL: test_mm_mask_cmpeq_epu64_mask
   // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
   // CHECK: and <2 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmpeq_epu64_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmpge_epi32_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmpge_epi32_mask
+  // CHECK-LABEL: test_mm_cmpge_epi32_mask
   // CHECK: icmp sge <4 x i32> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmpge_epi32_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmpge_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) 
{
-  // CHECK-LABEL: @test_mm_mask_cmpge_epi32_mask
+  // CHECK-LABEL: test_mm_mask_cmpge_epi32_mask
   // CHECK: icmp sge <4 x i32> %{{.*}}, %{{.*}}
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmpge_epi32_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmpge_epi64_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmpge_epi64_mask
+  // CHECK-LABEL: test_mm_cmpge_epi64_mask
   // CHECK: icmp sge <2 x i64> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmpge_epi64_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmpge_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) 
{
-  // CHECK-LABEL: @test_mm_mask_cmpge_epi64_mask
+  // CHECK-LABEL: test_mm_mask_cmpge_epi64_mask
   // CHECK: icmp sge <2 x i64> %{{.*}}, %{{.*}}
   // CHECK: and <2 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmpge_epi64_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm256_cmpge_epi32_mask(__m256i __a, __m256i __b) {
-  // CHECK-LABEL: @test_mm256_cmpge_epi32_mask
+  // CHECK-LABEL: test_mm256_cmpge_epi32_mask
   // CHECK: icmp sge <8 x i32> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_cmpge_epi32_mask(__a, __b);
 }
 
 __mmask8 test_mm256_mask_cmpge_epi32_mask(__mmask8 __u, __m256i __a, __m256i 
__b) {
-  // CHECK-LABEL: @test_mm256_mask_cmpge_epi32_mask
+  // CHECK-LABEL: test_mm256_mask_cmpge_epi32_mask
   // CHECK: icmp sge <8 x i32> %{{.*}}, %{{.*}}
   // CHECK: and <8 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_mask_cmpge_epi32_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm256_cmpge_epi64_mask(__m256i __a, __m256i __b) {
-  // CHECK-LABEL: @test_mm256_cmpge_epi64_mask
+  // CHECK-LABEL: test_mm256_cmpge_epi64_mask
   // CHECK: icmp sge <4 x i64> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_cmpge_epi64_mask(__a, __b);
 }
 
 __mmask8 test_mm256_mask_cmpge_epi64_mask(__mmask8 __u, __m256i __a, __m256i 
__b) {
-  // CHECK-LABEL: @test_mm256_mask_cmpge_epi64_mask
+  // CHECK-LABEL: test_mm256_mask_cmpge_epi64_mask
   // CHECK: icmp sge <4 x i64> %{{.*}}, %{{.*}}
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_mask_cmpge_epi64_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmpge_epu32_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmpge_epu32_mask
+  // CHECK-LABEL: test_mm_cmpge_epu32_mask
   // CHECK: icmp uge <4 x i32> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmpge_epu32_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmpge_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) 
{
-  // CHECK-LABEL: @test_mm_mask_cmpge_epu32_mask
+  // CHECK-LABEL: test_mm_mask_cmpge_epu32_mask
   // CHECK: icmp uge <4 x i32> %{{.*}}, %{{.*}}
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmpge_epu32_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmpge_epu64_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmpge_epu64_mask
+  // CHECK-LABEL: test_mm_cmpge_epu64_mask
   // CHECK: icmp uge <2 x i64> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmpge_epu64_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmpge_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) 
{
-  // CHECK-LABEL: @test_mm_mask_cmpge_epu64_mask
+  // CHECK-LABEL: test_mm_mask_cmpge_epu64_mask
   // CHECK: icmp uge <2 x i64> %{{.*}}, %{{.*}}
   // CHECK: and <2 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmpge_epu64_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm256_cmpge_epu32_mask(__m256i __a, __m256i __b) {
-  // CHECK-LABEL: @test_mm256_cmpge_epu32_mask
+  // CHECK-LABEL: test_mm256_cmpge_epu32_mask
   // CHECK: icmp uge <8 x i32> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_cmpge_epu32_mask(__a, __b);
 }
 
 __mmask8 test_mm256_mask_cmpge_epu32_mask(__mmask8 __u, __m256i __a, __m256i 
__b) {
-  // CHECK-LABEL: @test_mm256_mask_cmpge_epu32_mask
+  // CHECK-LABEL: test_mm256_mask_cmpge_epu32_mask
   // CHECK: icmp uge <8 x i32> %{{.*}}, %{{.*}}
   // CHECK: and <8 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_mask_cmpge_epu32_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm256_cmpge_epu64_mask(__m256i __a, __m256i __b) {
-  // CHECK-LABEL: @test_mm256_cmpge_epu64_mask
+  // CHECK-LABEL: test_mm256_cmpge_epu64_mask
   // CHECK: icmp uge <4 x i64> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_cmpge_epu64_mask(__a, __b);
 }
 
 __mmask8 test_mm256_mask_cmpge_epu64_mask(__mmask8 __u, __m256i __a, __m256i 
__b) {
-  // CHECK-LABEL: @test_mm256_mask_cmpge_epu64_mask
+  // CHECK-LABEL: test_mm256_mask_cmpge_epu64_mask
   // CHECK: icmp uge <4 x i64> %{{.*}}, %{{.*}}
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_mask_cmpge_epu64_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmpgt_epu32_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmpgt_epu32_mask
+  // CHECK-LABEL: test_mm_cmpgt_epu32_mask
   // CHECK: icmp ugt <4 x i32> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmpgt_epu32_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmpgt_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) 
{
-  // CHECK-LABEL: @test_mm_mask_cmpgt_epu32_mask
+  // CHECK-LABEL: test_mm_mask_cmpgt_epu32_mask
   // CHECK: icmp ugt <4 x i32> %{{.*}}, %{{.*}}
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmpgt_epu32_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmpgt_epu64_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmpgt_epu64_mask
+  // CHECK-LABEL: test_mm_cmpgt_epu64_mask
   // CHECK: icmp ugt <2 x i64> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmpgt_epu64_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmpgt_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) 
{
-  // CHECK-LABEL: @test_mm_mask_cmpgt_epu64_mask
+  // CHECK-LABEL: test_mm_mask_cmpgt_epu64_mask
   // CHECK: icmp ugt <2 x i64> %{{.*}}, %{{.*}}
   // CHECK: and <2 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmpgt_epu64_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm256_cmpgt_epu32_mask(__m256i __a, __m256i __b) {
-  // CHECK-LABEL: @test_mm256_cmpgt_epu32_mask
+  // CHECK-LABEL: test_mm256_cmpgt_epu32_mask
   // CHECK: icmp ugt <8 x i32> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_cmpgt_epu32_mask(__a, __b);
 }
 
 __mmask8 test_mm256_mask_cmpgt_epu32_mask(__mmask8 __u, __m256i __a, __m256i 
__b) {
-  // CHECK-LABEL: @test_mm256_mask_cmpgt_epu32_mask
+  // CHECK-LABEL: test_mm256_mask_cmpgt_epu32_mask
   // CHECK: icmp ugt <8 x i32> %{{.*}}, %{{.*}}
   // CHECK: and <8 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_mask_cmpgt_epu32_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm256_cmpgt_epu64_mask(__m256i __a, __m256i __b) {
-  // CHECK-LABEL: @test_mm256_cmpgt_epu64_mask
+  // CHECK-LABEL: test_mm256_cmpgt_epu64_mask
   // CHECK: icmp ugt <4 x i64> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_cmpgt_epu64_mask(__a, __b);
 }
 
 __mmask8 test_mm256_mask_cmpgt_epu64_mask(__mmask8 __u, __m256i __a, __m256i 
__b) {
-  // CHECK-LABEL: @test_mm256_mask_cmpgt_epu64_mask
+  // CHECK-LABEL: test_mm256_mask_cmpgt_epu64_mask
   // CHECK: icmp ugt <4 x i64> %{{.*}}, %{{.*}}
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_mask_cmpgt_epu64_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmple_epi32_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmple_epi32_mask
+  // CHECK-LABEL: test_mm_cmple_epi32_mask
   // CHECK: icmp sle <4 x i32> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmple_epi32_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmple_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) 
{
-  // CHECK-LABEL: @test_mm_mask_cmple_epi32_mask
+  // CHECK-LABEL: test_mm_mask_cmple_epi32_mask
   // CHECK: icmp sle <4 x i32> %{{.*}}, %{{.*}}
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmple_epi32_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmple_epi64_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmple_epi64_mask
+  // CHECK-LABEL: test_mm_cmple_epi64_mask
   // CHECK: icmp sle <2 x i64> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmple_epi64_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmple_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) 
{
-  // CHECK-LABEL: @test_mm_mask_cmple_epi64_mask
+  // CHECK-LABEL: test_mm_mask_cmple_epi64_mask
   // CHECK: icmp sle <2 x i64> %{{.*}}, %{{.*}}
   // CHECK: and <2 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmple_epi64_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm256_cmple_epi32_mask(__m256i __a, __m256i __b) {
-  // CHECK-LABEL: @test_mm256_cmple_epi32_mask
+  // CHECK-LABEL: test_mm256_cmple_epi32_mask
   // CHECK: icmp sle <8 x i32> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_cmple_epi32_mask(__a, __b);
 }
 
 __mmask8 test_mm256_mask_cmple_epi32_mask(__mmask8 __u, __m256i __a, __m256i 
__b) {
-  // CHECK-LABEL: @test_mm256_mask_cmple_epi32_mask
+  // CHECK-LABEL: test_mm256_mask_cmple_epi32_mask
   // CHECK: icmp sle <8 x i32> %{{.*}}, %{{.*}}
   // CHECK: and <8 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_mask_cmple_epi32_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm256_cmple_epi64_mask(__m256i __a, __m256i __b) {
-  // CHECK-LABEL: @test_mm256_cmple_epi64_mask
+  // CHECK-LABEL: test_mm256_cmple_epi64_mask
   // CHECK: icmp sle <4 x i64> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_cmple_epi64_mask(__a, __b);
 }
 
 __mmask8 test_mm256_mask_cmple_epi64_mask(__mmask8 __u, __m256i __a, __m256i 
__b) {
-  // CHECK-LABEL: @test_mm256_mask_cmple_epi64_mask
+  // CHECK-LABEL: test_mm256_mask_cmple_epi64_mask
   // CHECK: icmp sle <4 x i64> %{{.*}}, %{{.*}}
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_mask_cmple_epi64_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmple_epu32_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmple_epu32_mask
+  // CHECK-LABEL: test_mm_cmple_epu32_mask
   // CHECK: icmp ule <4 x i32> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmple_epu32_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmple_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) 
{
-  // CHECK-LABEL: @test_mm_mask_cmple_epu32_mask
+  // CHECK-LABEL: test_mm_mask_cmple_epu32_mask
   // CHECK: icmp ule <4 x i32> %{{.*}}, %{{.*}}
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmple_epu32_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmple_epu64_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmple_epu64_mask
+  // CHECK-LABEL: test_mm_cmple_epu64_mask
   // CHECK: icmp ule <2 x i64> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmple_epu64_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmple_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) 
{
-  // CHECK-LABEL: @test_mm_mask_cmple_epu64_mask
+  // CHECK-LABEL: test_mm_mask_cmple_epu64_mask
   // CHECK: icmp ule <2 x i64> %{{.*}}, %{{.*}}
   // CHECK: and <2 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmple_epu64_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm256_cmple_epu32_mask(__m256i __a, __m256i __b) {
-  // CHECK-LABEL: @test_mm256_cmple_epu32_mask
+  // CHECK-LABEL: test_mm256_cmple_epu32_mask
   // CHECK: icmp ule <8 x i32> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_cmple_epu32_mask(__a, __b);
 }
 
 __mmask8 test_mm256_mask_cmple_epu32_mask(__mmask8 __u, __m256i __a, __m256i 
__b) {
-  // CHECK-LABEL: @test_mm256_mask_cmple_epu32_mask
+  // CHECK-LABEL: test_mm256_mask_cmple_epu32_mask
   // CHECK: icmp ule <8 x i32> %{{.*}}, %{{.*}}
   // CHECK: and <8 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_mask_cmple_epu32_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm256_cmple_epu64_mask(__m256i __a, __m256i __b) {
-  // CHECK-LABEL: @test_mm256_cmple_epu64_mask
+  // CHECK-LABEL: test_mm256_cmple_epu64_mask
   // CHECK: icmp ule <4 x i64> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_cmple_epu64_mask(__a, __b);
 }
 
 __mmask8 test_mm256_mask_cmple_epu64_mask(__mmask8 __u, __m256i __a, __m256i 
__b) {
-  // CHECK-LABEL: @test_mm256_mask_cmple_epu64_mask
+  // CHECK-LABEL: test_mm256_mask_cmple_epu64_mask
   // CHECK: icmp ule <4 x i64> %{{.*}}, %{{.*}}
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_mask_cmple_epu64_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmplt_epi32_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmplt_epi32_mask
+  // CHECK-LABEL: test_mm_cmplt_epi32_mask
   // CHECK: icmp slt <4 x i32> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmplt_epi32_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmplt_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) 
{
-  // CHECK-LABEL: @test_mm_mask_cmplt_epi32_mask
+  // CHECK-LABEL: test_mm_mask_cmplt_epi32_mask
   // CHECK: icmp slt <4 x i32> %{{.*}}, %{{.*}}
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmplt_epi32_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmplt_epi64_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmplt_epi64_mask
+  // CHECK-LABEL: test_mm_cmplt_epi64_mask
   // CHECK: icmp slt <2 x i64> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmplt_epi64_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmplt_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) 
{
-  // CHECK-LABEL: @test_mm_mask_cmplt_epi64_mask
+  // CHECK-LABEL: test_mm_mask_cmplt_epi64_mask
   // CHECK: icmp slt <2 x i64> %{{.*}}, %{{.*}}
   // CHECK: and <2 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmplt_epi64_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm256_cmplt_epi32_mask(__m256i __a, __m256i __b) {
-  // CHECK-LABEL: @test_mm256_cmplt_epi32_mask
+  // CHECK-LABEL: test_mm256_cmplt_epi32_mask
   // CHECK: icmp slt <8 x i32> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_cmplt_epi32_mask(__a, __b);
 }
 
 __mmask8 test_mm256_mask_cmplt_epi32_mask(__mmask8 __u, __m256i __a, __m256i 
__b) {
-  // CHECK-LABEL: @test_mm256_mask_cmplt_epi32_mask
+  // CHECK-LABEL: test_mm256_mask_cmplt_epi32_mask
   // CHECK: icmp slt <8 x i32> %{{.*}}, %{{.*}}
   // CHECK: and <8 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_mask_cmplt_epi32_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm256_cmplt_epi64_mask(__m256i __a, __m256i __b) {
-  // CHECK-LABEL: @test_mm256_cmplt_epi64_mask
+  // CHECK-LABEL: test_mm256_cmplt_epi64_mask
   // CHECK: icmp slt <4 x i64> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_cmplt_epi64_mask(__a, __b);
 }
 
 __mmask8 test_mm256_mask_cmplt_epi64_mask(__mmask8 __u, __m256i __a, __m256i 
__b) {
-  // CHECK-LABEL: @test_mm256_mask_cmplt_epi64_mask
+  // CHECK-LABEL: test_mm256_mask_cmplt_epi64_mask
   // CHECK: icmp slt <4 x i64> %{{.*}}, %{{.*}}
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_mask_cmplt_epi64_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmplt_epu32_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmplt_epu32_mask
+  // CHECK-LABEL: test_mm_cmplt_epu32_mask
   // CHECK: icmp ult <4 x i32> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmplt_epu32_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmplt_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) 
{
-  // CHECK-LABEL: @test_mm_mask_cmplt_epu32_mask
+  // CHECK-LABEL: test_mm_mask_cmplt_epu32_mask
   // CHECK: icmp ult <4 x i32> %{{.*}}, %{{.*}}
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmplt_epu32_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmplt_epu64_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmplt_epu64_mask
+  // CHECK-LABEL: test_mm_cmplt_epu64_mask
   // CHECK: icmp ult <2 x i64> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmplt_epu64_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmplt_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) 
{
-  // CHECK-LABEL: @test_mm_mask_cmplt_epu64_mask
+  // CHECK-LABEL: test_mm_mask_cmplt_epu64_mask
   // CHECK: icmp ult <2 x i64> %{{.*}}, %{{.*}}
   // CHECK: and <2 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmplt_epu64_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm256_cmplt_epu32_mask(__m256i __a, __m256i __b) {
-  // CHECK-LABEL: @test_mm256_cmplt_epu32_mask
+  // CHECK-LABEL: test_mm256_cmplt_epu32_mask
   // CHECK: icmp ult <8 x i32> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_cmplt_epu32_mask(__a, __b);
 }
 
 __mmask8 test_mm256_mask_cmplt_epu32_mask(__mmask8 __u, __m256i __a, __m256i 
__b) {
-  // CHECK-LABEL: @test_mm256_mask_cmplt_epu32_mask
+  // CHECK-LABEL: test_mm256_mask_cmplt_epu32_mask
   // CHECK: icmp ult <8 x i32> %{{.*}}, %{{.*}}
   // CHECK: and <8 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_mask_cmplt_epu32_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm256_cmplt_epu64_mask(__m256i __a, __m256i __b) {
-  // CHECK-LABEL: @test_mm256_cmplt_epu64_mask
+  // CHECK-LABEL: test_mm256_cmplt_epu64_mask
   // CHECK: icmp ult <4 x i64> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_cmplt_epu64_mask(__a, __b);
 }
 
 __mmask8 test_mm256_mask_cmplt_epu64_mask(__mmask8 __u, __m256i __a, __m256i 
__b) {
-  // CHECK-LABEL: @test_mm256_mask_cmplt_epu64_mask
+  // CHECK-LABEL: test_mm256_mask_cmplt_epu64_mask
   // CHECK: icmp ult <4 x i64> %{{.*}}, %{{.*}}
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_mask_cmplt_epu64_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmpneq_epi32_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmpneq_epi32_mask
+  // CHECK-LABEL: test_mm_cmpneq_epi32_mask
   // CHECK: icmp ne <4 x i32> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmpneq_epi32_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmpneq_epi32_mask(__mmask8 __u, __m128i __a, __m128i 
__b) {
-  // CHECK-LABEL: @test_mm_mask_cmpneq_epi32_mask
+  // CHECK-LABEL: test_mm_mask_cmpneq_epi32_mask
   // CHECK: icmp ne <4 x i32> %{{.*}}, %{{.*}}
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_mask_cmpneq_epi32_mask(__u, __a, __b);
 }
 
 __mmask8 test_mm_cmpneq_epi64_mask(__m128i __a, __m128i __b) {
-  // CHECK-LABEL: @test_mm_cmpneq_epi64_mask
+  // CHECK-LABEL: test_mm_cmpneq_epi64_mask
   // CHECK: icmp ne <2 x i64> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmpneq_epi64_mask(__a, __b);
 }
 
 __mmask8 test_mm_mask_cmpneq_epi64_mask(__mmask8 __u, __m128i __a, __m128i 
__b) {
-  // CHECK-LABEL: @test_mm_mask_cmpneq_epi64_mask
+ ...
[truncated]

``````````

</details>


https://github.com/llvm/llvm-project/pull/152765
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

Reply via email to