Home | History | Annotate | Download | only in CodeGen 
      1 // RUN: %clang_cc1 %s -O0 -triple=x86_64-apple-darwin -ffreestanding -target-feature +avx512f -target-feature +avx512vl -emit-llvm -o - -Werror | FileCheck %s
      2 
      3 #include <immintrin.h>
      4 
      5 __mmask8 test_mm256_cmpeq_epi32_mask(__m256i __a, __m256i __b) {
      6   // CHECK-LABEL: @test_mm256_cmpeq_epi32_mask
      7   // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.256
      8   return (__mmask8)_mm256_cmpeq_epi32_mask(__a, __b);
      9 }
     10 
     11 __mmask8 test_mm256_mask_cmpeq_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
     12   // CHECK-LABEL: @test_mm256_mask_cmpeq_epi32_mask
     13   // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.256
     14   return (__mmask8)_mm256_mask_cmpeq_epi32_mask(__u, __a, __b);
     15 }
     16 
     17 __mmask8 test_mm_cmpeq_epi32_mask(__m128i __a, __m128i __b) {
     18   // CHECK-LABEL: @test_mm_cmpeq_epi32_mask
     19   // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.128
     20   return (__mmask8)_mm_cmpeq_epi32_mask(__a, __b);
     21 }
     22 
     23 __mmask8 test_mm_mask_cmpeq_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
     24   // CHECK-LABEL: @test_mm_mask_cmpeq_epi32_mask
     25   // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.128
     26   return (__mmask8)_mm_mask_cmpeq_epi32_mask(__u, __a, __b);
     27 }
     28 
     29 __mmask8 test_mm256_cmpeq_epi64_mask(__m256i __a, __m256i __b) {
     30   // CHECK-LABEL: @test_mm256_cmpeq_epi64_mask
     31   // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.256
     32   return (__mmask8)_mm256_cmpeq_epi64_mask(__a, __b);
     33 }
     34 
     35 __mmask8 test_mm256_mask_cmpeq_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
     36   // CHECK-LABEL: @test_mm256_mask_cmpeq_epi64_mask
     37   // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.256
     38   return (__mmask8)_mm256_mask_cmpeq_epi64_mask(__u, __a, __b);
     39 }
     40 
     41 __mmask8 test_mm_cmpeq_epi64_mask(__m128i __a, __m128i __b) {
     42   // CHECK-LABEL: @test_mm_cmpeq_epi64_mask
     43   // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.128
     44   return (__mmask8)_mm_cmpeq_epi64_mask(__a, __b);
     45 }
     46 
     47 __mmask8 test_mm_mask_cmpeq_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
     48   // CHECK-LABEL: @test_mm_mask_cmpeq_epi64_mask
     49   // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.128
     50   return (__mmask8)_mm_mask_cmpeq_epi64_mask(__u, __a, __b);
     51 }
     52 
     53 __mmask8 test_mm256_cmpgt_epi32_mask(__m256i __a, __m256i __b) {
     54   // CHECK-LABEL: @test_mm256_cmpgt_epi32_mask
     55   // CHECK: @llvm.x86.avx512.mask.pcmpgt.d.256
     56   return (__mmask8)_mm256_cmpgt_epi32_mask(__a, __b);
     57 }
     58 
     59 __mmask8 test_mm256_mask_cmpgt_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
     60   // CHECK-LABEL: @test_mm256_mask_cmpgt_epi32_mask
     61   // CHECK: @llvm.x86.avx512.mask.pcmpgt.d.256
     62   return (__mmask8)_mm256_mask_cmpgt_epi32_mask(__u, __a, __b);
     63 }
     64 
     65 __mmask8 test_mm_cmpgt_epi32_mask(__m128i __a, __m128i __b) {
     66   // CHECK-LABEL: @test_mm_cmpgt_epi32_mask
     67   // CHECK: @llvm.x86.avx512.mask.pcmpgt.d.128
     68   return (__mmask8)_mm_cmpgt_epi32_mask(__a, __b);
     69 }
     70 
     71 __mmask8 test_mm_mask_cmpgt_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
     72   // CHECK-LABEL: @test_mm_mask_cmpgt_epi32_mask
     73   // CHECK: @llvm.x86.avx512.mask.pcmpgt.d.128
     74   return (__mmask8)_mm_mask_cmpgt_epi32_mask(__u, __a, __b);
     75 }
     76 
     77 __mmask8 test_mm256_cmpgt_epi64_mask(__m256i __a, __m256i __b) {
     78   // CHECK-LABEL: @test_mm256_cmpgt_epi64_mask
     79   // CHECK: @llvm.x86.avx512.mask.pcmpgt.q.256
     80   return (__mmask8)_mm256_cmpgt_epi64_mask(__a, __b);
     81 }
     82 
     83 __mmask8 test_mm256_mask_cmpgt_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
     84   // CHECK-LABEL: @test_mm256_mask_cmpgt_epi64_mask
     85   // CHECK: @llvm.x86.avx512.mask.pcmpgt.q.256
     86   return (__mmask8)_mm256_mask_cmpgt_epi64_mask(__u, __a, __b);
     87 }
     88 
     89 __mmask8 test_mm_cmpgt_epi64_mask(__m128i __a, __m128i __b) {
     90   // CHECK-LABEL: @test_mm_cmpgt_epi64_mask
     91   // CHECK: @llvm.x86.avx512.mask.pcmpgt.q.128
     92   return (__mmask8)_mm_cmpgt_epi64_mask(__a, __b);
     93 }
     94 
     95 __mmask8 test_mm_mask_cmpgt_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
     96   // CHECK-LABEL: @test_mm_mask_cmpgt_epi64_mask
     97   // CHECK: @llvm.x86.avx512.mask.pcmpgt.q.128
     98   return (__mmask8)_mm_mask_cmpgt_epi64_mask(__u, __a, __b);
     99 }
    100 
    101 __mmask8 test_mm_cmpeq_epu32_mask(__m128i __a, __m128i __b) {
    102   // CHECK-LABEL: @test_mm_cmpeq_epu32_mask
    103   // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 0, i8 -1)
    104   return (__mmask8)_mm_cmpeq_epu32_mask(__a, __b);
    105 }
    106 
    107 __mmask8 test_mm_mask_cmpeq_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    108   // CHECK-LABEL: @test_mm_mask_cmpeq_epu32_mask
    109   // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 0, i8 {{.*}})
    110   return (__mmask8)_mm_mask_cmpeq_epu32_mask(__u, __a, __b);
    111 }
    112 
    113 __mmask8 test_mm_cmpeq_epu64_mask(__m128i __a, __m128i __b) {
    114   // CHECK-LABEL: @test_mm_cmpeq_epu64_mask
    115   // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 0, i8 -1)
    116   return (__mmask8)_mm_cmpeq_epu64_mask(__a, __b);
    117 }
    118 
    119 __mmask8 test_mm_mask_cmpeq_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    120   // CHECK-LABEL: @test_mm_mask_cmpeq_epu64_mask
    121   // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 0, i8 {{.*}})
    122   return (__mmask8)_mm_mask_cmpeq_epu64_mask(__u, __a, __b);
    123 }
    124 
    125 __mmask8 test_mm_cmpge_epi32_mask(__m128i __a, __m128i __b) {
    126   // CHECK-LABEL: @test_mm_cmpge_epi32_mask
    127   // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 5, i8 -1)
    128   return (__mmask8)_mm_cmpge_epi32_mask(__a, __b);
    129 }
    130 
    131 __mmask8 test_mm_mask_cmpge_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    132   // CHECK-LABEL: @test_mm_mask_cmpge_epi32_mask
    133   // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 5, i8 {{.*}})
    134   return (__mmask8)_mm_mask_cmpge_epi32_mask(__u, __a, __b);
    135 }
    136 
    137 __mmask8 test_mm_cmpge_epi64_mask(__m128i __a, __m128i __b) {
    138   // CHECK-LABEL: @test_mm_cmpge_epi64_mask
    139   // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 5, i8 -1)
    140   return (__mmask8)_mm_cmpge_epi64_mask(__a, __b);
    141 }
    142 
    143 __mmask8 test_mm_mask_cmpge_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    144   // CHECK-LABEL: @test_mm_mask_cmpge_epi64_mask
    145   // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 5, i8 {{.*}})
    146   return (__mmask8)_mm_mask_cmpge_epi64_mask(__u, __a, __b);
    147 }
    148 
    149 __mmask8 test_mm256_cmpge_epi32_mask(__m256i __a, __m256i __b) {
    150   // CHECK-LABEL: @test_mm256_cmpge_epi32_mask
    151   // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 5, i8 -1)
    152   return (__mmask8)_mm256_cmpge_epi32_mask(__a, __b);
    153 }
    154 
    155 __mmask8 test_mm256_mask_cmpge_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    156   // CHECK-LABEL: @test_mm256_mask_cmpge_epi32_mask
    157   // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 5, i8 {{.*}})
    158   return (__mmask8)_mm256_mask_cmpge_epi32_mask(__u, __a, __b);
    159 }
    160 
    161 __mmask8 test_mm256_cmpge_epi64_mask(__m256i __a, __m256i __b) {
    162   // CHECK-LABEL: @test_mm256_cmpge_epi64_mask
    163   // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 5, i8 -1)
    164   return (__mmask8)_mm256_cmpge_epi64_mask(__a, __b);
    165 }
    166 
    167 __mmask8 test_mm256_mask_cmpge_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    168   // CHECK-LABEL: @test_mm256_mask_cmpge_epi64_mask
    169   // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 5, i8 {{.*}})
    170   return (__mmask8)_mm256_mask_cmpge_epi64_mask(__u, __a, __b);
    171 }
    172 
    173 __mmask8 test_mm_cmpge_epu32_mask(__m128i __a, __m128i __b) {
    174   // CHECK-LABEL: @test_mm_cmpge_epu32_mask
    175   // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 5, i8 -1)
    176   return (__mmask8)_mm_cmpge_epu32_mask(__a, __b);
    177 }
    178 
    179 __mmask8 test_mm_mask_cmpge_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    180   // CHECK-LABEL: @test_mm_mask_cmpge_epu32_mask
    181   // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 5, i8 {{.*}})
    182   return (__mmask8)_mm_mask_cmpge_epu32_mask(__u, __a, __b);
    183 }
    184 
    185 __mmask8 test_mm_cmpge_epu64_mask(__m128i __a, __m128i __b) {
    186   // CHECK-LABEL: @test_mm_cmpge_epu64_mask
    187   // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 5, i8 -1)
    188   return (__mmask8)_mm_cmpge_epu64_mask(__a, __b);
    189 }
    190 
    191 __mmask8 test_mm_mask_cmpge_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    192   // CHECK-LABEL: @test_mm_mask_cmpge_epu64_mask
    193   // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 5, i8 {{.*}})
    194   return (__mmask8)_mm_mask_cmpge_epu64_mask(__u, __a, __b);
    195 }
    196 
    197 __mmask8 test_mm256_cmpge_epu32_mask(__m256i __a, __m256i __b) {
    198   // CHECK-LABEL: @test_mm256_cmpge_epu32_mask
    199   // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 5, i8 -1)
    200   return (__mmask8)_mm256_cmpge_epu32_mask(__a, __b);
    201 }
    202 
    203 __mmask8 test_mm256_mask_cmpge_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    204   // CHECK-LABEL: @test_mm256_mask_cmpge_epu32_mask
    205   // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 5, i8 {{.*}})
    206   return (__mmask8)_mm256_mask_cmpge_epu32_mask(__u, __a, __b);
    207 }
    208 
    209 __mmask8 test_mm256_cmpge_epu64_mask(__m256i __a, __m256i __b) {
    210   // CHECK-LABEL: @test_mm256_cmpge_epu64_mask
    211   // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 5, i8 -1)
    212   return (__mmask8)_mm256_cmpge_epu64_mask(__a, __b);
    213 }
    214 
    215 __mmask8 test_mm256_mask_cmpge_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    216   // CHECK-LABEL: @test_mm256_mask_cmpge_epu64_mask
    217   // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 5, i8 {{.*}})
    218   return (__mmask8)_mm256_mask_cmpge_epu64_mask(__u, __a, __b);
    219 }
    220 
    221 __mmask8 test_mm_cmpgt_epu32_mask(__m128i __a, __m128i __b) {
    222   // CHECK-LABEL: @test_mm_cmpgt_epu32_mask
    223   // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 6, i8 -1)
    224   return (__mmask8)_mm_cmpgt_epu32_mask(__a, __b);
    225 }
    226 
    227 __mmask8 test_mm_mask_cmpgt_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    228   // CHECK-LABEL: @test_mm_mask_cmpgt_epu32_mask
    229   // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 6, i8 {{.*}})
    230   return (__mmask8)_mm_mask_cmpgt_epu32_mask(__u, __a, __b);
    231 }
    232 
    233 __mmask8 test_mm_cmpgt_epu64_mask(__m128i __a, __m128i __b) {
    234   // CHECK-LABEL: @test_mm_cmpgt_epu64_mask
    235   // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 6, i8 -1)
    236   return (__mmask8)_mm_cmpgt_epu64_mask(__a, __b);
    237 }
    238 
    239 __mmask8 test_mm_mask_cmpgt_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    240   // CHECK-LABEL: @test_mm_mask_cmpgt_epu64_mask
    241   // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 6, i8 {{.*}})
    242   return (__mmask8)_mm_mask_cmpgt_epu64_mask(__u, __a, __b);
    243 }
    244 
    245 __mmask8 test_mm256_cmpgt_epu32_mask(__m256i __a, __m256i __b) {
    246   // CHECK-LABEL: @test_mm256_cmpgt_epu32_mask
    247   // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 6, i8 -1)
    248   return (__mmask8)_mm256_cmpgt_epu32_mask(__a, __b);
    249 }
    250 
    251 __mmask8 test_mm256_mask_cmpgt_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    252   // CHECK-LABEL: @test_mm256_mask_cmpgt_epu32_mask
    253   // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 6, i8 {{.*}})
    254   return (__mmask8)_mm256_mask_cmpgt_epu32_mask(__u, __a, __b);
    255 }
    256 
    257 __mmask8 test_mm256_cmpgt_epu64_mask(__m256i __a, __m256i __b) {
    258   // CHECK-LABEL: @test_mm256_cmpgt_epu64_mask
    259   // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 6, i8 -1)
    260   return (__mmask8)_mm256_cmpgt_epu64_mask(__a, __b);
    261 }
    262 
    263 __mmask8 test_mm256_mask_cmpgt_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    264   // CHECK-LABEL: @test_mm256_mask_cmpgt_epu64_mask
    265   // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 6, i8 {{.*}})
    266   return (__mmask8)_mm256_mask_cmpgt_epu64_mask(__u, __a, __b);
    267 }
    268 
    269 __mmask8 test_mm_cmple_epi32_mask(__m128i __a, __m128i __b) {
    270   // CHECK-LABEL: @test_mm_cmple_epi32_mask
    271   // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 2, i8 -1)
    272   return (__mmask8)_mm_cmple_epi32_mask(__a, __b);
    273 }
    274 
    275 __mmask8 test_mm_mask_cmple_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    276   // CHECK-LABEL: @test_mm_mask_cmple_epi32_mask
    277   // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 2, i8 {{.*}})
    278   return (__mmask8)_mm_mask_cmple_epi32_mask(__u, __a, __b);
    279 }
    280 
    281 __mmask8 test_mm_cmple_epi64_mask(__m128i __a, __m128i __b) {
    282   // CHECK-LABEL: @test_mm_cmple_epi64_mask
    283   // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 2, i8 -1)
    284   return (__mmask8)_mm_cmple_epi64_mask(__a, __b);
    285 }
    286 
    287 __mmask8 test_mm_mask_cmple_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    288   // CHECK-LABEL: @test_mm_mask_cmple_epi64_mask
    289   // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 2, i8 {{.*}})
    290   return (__mmask8)_mm_mask_cmple_epi64_mask(__u, __a, __b);
    291 }
    292 
    293 __mmask8 test_mm256_cmple_epi32_mask(__m256i __a, __m256i __b) {
    294   // CHECK-LABEL: @test_mm256_cmple_epi32_mask
    295   // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 2, i8 -1)
    296   return (__mmask8)_mm256_cmple_epi32_mask(__a, __b);
    297 }
    298 
    299 __mmask8 test_mm256_mask_cmple_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    300   // CHECK-LABEL: @test_mm256_mask_cmple_epi32_mask
    301   // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 2, i8 {{.*}})
    302   return (__mmask8)_mm256_mask_cmple_epi32_mask(__u, __a, __b);
    303 }
    304 
    305 __mmask8 test_mm256_cmple_epi64_mask(__m256i __a, __m256i __b) {
    306   // CHECK-LABEL: @test_mm256_cmple_epi64_mask
    307   // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 2, i8 -1)
    308   return (__mmask8)_mm256_cmple_epi64_mask(__a, __b);
    309 }
    310 
    311 __mmask8 test_mm256_mask_cmple_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    312   // CHECK-LABEL: @test_mm256_mask_cmple_epi64_mask
    313   // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 2, i8 {{.*}})
    314   return (__mmask8)_mm256_mask_cmple_epi64_mask(__u, __a, __b);
    315 }
    316 
    317 __mmask8 test_mm_cmple_epu32_mask(__m128i __a, __m128i __b) {
    318   // CHECK-LABEL: @test_mm_cmple_epu32_mask
    319   // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 2, i8 -1)
    320   return (__mmask8)_mm_cmple_epu32_mask(__a, __b);
    321 }
    322 
    323 __mmask8 test_mm_mask_cmple_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    324   // CHECK-LABEL: @test_mm_mask_cmple_epu32_mask
    325   // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 2, i8 {{.*}})
    326   return (__mmask8)_mm_mask_cmple_epu32_mask(__u, __a, __b);
    327 }
    328 
    329 __mmask8 test_mm_cmple_epu64_mask(__m128i __a, __m128i __b) {
    330   // CHECK-LABEL: @test_mm_cmple_epu64_mask
    331   // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 2, i8 -1)
    332   return (__mmask8)_mm_cmple_epu64_mask(__a, __b);
    333 }
    334 
    335 __mmask8 test_mm_mask_cmple_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    336   // CHECK-LABEL: @test_mm_mask_cmple_epu64_mask
    337   // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 2, i8 {{.*}})
    338   return (__mmask8)_mm_mask_cmple_epu64_mask(__u, __a, __b);
    339 }
    340 
    341 __mmask8 test_mm256_cmple_epu32_mask(__m256i __a, __m256i __b) {
    342   // CHECK-LABEL: @test_mm256_cmple_epu32_mask
    343   // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 2, i8 -1)
    344   return (__mmask8)_mm256_cmple_epu32_mask(__a, __b);
    345 }
    346 
    347 __mmask8 test_mm256_mask_cmple_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    348   // CHECK-LABEL: @test_mm256_mask_cmple_epu32_mask
    349   // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 2, i8 {{.*}})
    350   return (__mmask8)_mm256_mask_cmple_epu32_mask(__u, __a, __b);
    351 }
    352 
    353 __mmask8 test_mm256_cmple_epu64_mask(__m256i __a, __m256i __b) {
    354   // CHECK-LABEL: @test_mm256_cmple_epu64_mask
    355   // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 2, i8 -1)
    356   return (__mmask8)_mm256_cmple_epu64_mask(__a, __b);
    357 }
    358 
    359 __mmask8 test_mm256_mask_cmple_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    360   // CHECK-LABEL: @test_mm256_mask_cmple_epu64_mask
    361   // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 2, i8 {{.*}})
    362   return (__mmask8)_mm256_mask_cmple_epu64_mask(__u, __a, __b);
    363 }
    364 
    365 __mmask8 test_mm_cmplt_epi32_mask(__m128i __a, __m128i __b) {
    366   // CHECK-LABEL: @test_mm_cmplt_epi32_mask
    367   // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 1, i8 -1)
    368   return (__mmask8)_mm_cmplt_epi32_mask(__a, __b);
    369 }
    370 
    371 __mmask8 test_mm_mask_cmplt_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    372   // CHECK-LABEL: @test_mm_mask_cmplt_epi32_mask
    373   // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 1, i8 {{.*}})
    374   return (__mmask8)_mm_mask_cmplt_epi32_mask(__u, __a, __b);
    375 }
    376 
    377 __mmask8 test_mm_cmplt_epi64_mask(__m128i __a, __m128i __b) {
    378   // CHECK-LABEL: @test_mm_cmplt_epi64_mask
    379   // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 1, i8 -1)
    380   return (__mmask8)_mm_cmplt_epi64_mask(__a, __b);
    381 }
    382 
    383 __mmask8 test_mm_mask_cmplt_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    384   // CHECK-LABEL: @test_mm_mask_cmplt_epi64_mask
    385   // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 1, i8 {{.*}})
    386   return (__mmask8)_mm_mask_cmplt_epi64_mask(__u, __a, __b);
    387 }
    388 
    389 __mmask8 test_mm256_cmplt_epi32_mask(__m256i __a, __m256i __b) {
    390   // CHECK-LABEL: @test_mm256_cmplt_epi32_mask
    391   // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 1, i8 -1)
    392   return (__mmask8)_mm256_cmplt_epi32_mask(__a, __b);
    393 }
    394 
    395 __mmask8 test_mm256_mask_cmplt_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    396   // CHECK-LABEL: @test_mm256_mask_cmplt_epi32_mask
    397   // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 1, i8 {{.*}})
    398   return (__mmask8)_mm256_mask_cmplt_epi32_mask(__u, __a, __b);
    399 }
    400 
    401 __mmask8 test_mm256_cmplt_epi64_mask(__m256i __a, __m256i __b) {
    402   // CHECK-LABEL: @test_mm256_cmplt_epi64_mask
    403   // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 1, i8 -1)
    404   return (__mmask8)_mm256_cmplt_epi64_mask(__a, __b);
    405 }
    406 
    407 __mmask8 test_mm256_mask_cmplt_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    408   // CHECK-LABEL: @test_mm256_mask_cmplt_epi64_mask
    409   // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 1, i8 {{.*}})
    410   return (__mmask8)_mm256_mask_cmplt_epi64_mask(__u, __a, __b);
    411 }
    412 
    413 __mmask8 test_mm_cmplt_epu32_mask(__m128i __a, __m128i __b) {
    414   // CHECK-LABEL: @test_mm_cmplt_epu32_mask
    415   // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 1, i8 -1)
    416   return (__mmask8)_mm_cmplt_epu32_mask(__a, __b);
    417 }
    418 
    419 __mmask8 test_mm_mask_cmplt_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    420   // CHECK-LABEL: @test_mm_mask_cmplt_epu32_mask
    421   // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 1, i8 {{.*}})
    422   return (__mmask8)_mm_mask_cmplt_epu32_mask(__u, __a, __b);
    423 }
    424 
    425 __mmask8 test_mm_cmplt_epu64_mask(__m128i __a, __m128i __b) {
    426   // CHECK-LABEL: @test_mm_cmplt_epu64_mask
    427   // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 1, i8 -1)
    428   return (__mmask8)_mm_cmplt_epu64_mask(__a, __b);
    429 }
    430 
    431 __mmask8 test_mm_mask_cmplt_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    432   // CHECK-LABEL: @test_mm_mask_cmplt_epu64_mask
    433   // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 1, i8 {{.*}})
    434   return (__mmask8)_mm_mask_cmplt_epu64_mask(__u, __a, __b);
    435 }
    436 
    437 __mmask8 test_mm256_cmplt_epu32_mask(__m256i __a, __m256i __b) {
    438   // CHECK-LABEL: @test_mm256_cmplt_epu32_mask
    439   // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 1, i8 -1)
    440   return (__mmask8)_mm256_cmplt_epu32_mask(__a, __b);
    441 }
    442 
    443 __mmask8 test_mm256_mask_cmplt_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    444   // CHECK-LABEL: @test_mm256_mask_cmplt_epu32_mask
    445   // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 1, i8 {{.*}})
    446   return (__mmask8)_mm256_mask_cmplt_epu32_mask(__u, __a, __b);
    447 }
    448 
    449 __mmask8 test_mm256_cmplt_epu64_mask(__m256i __a, __m256i __b) {
    450   // CHECK-LABEL: @test_mm256_cmplt_epu64_mask
    451   // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 1, i8 -1)
    452   return (__mmask8)_mm256_cmplt_epu64_mask(__a, __b);
    453 }
    454 
    455 __mmask8 test_mm256_mask_cmplt_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    456   // CHECK-LABEL: @test_mm256_mask_cmplt_epu64_mask
    457   // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 1, i8 {{.*}})
    458   return (__mmask8)_mm256_mask_cmplt_epu64_mask(__u, __a, __b);
    459 }
    460 
    461 __mmask8 test_mm_cmpneq_epi32_mask(__m128i __a, __m128i __b) {
    462   // CHECK-LABEL: @test_mm_cmpneq_epi32_mask
    463   // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 4, i8 -1)
    464   return (__mmask8)_mm_cmpneq_epi32_mask(__a, __b);
    465 }
    466 
    467 __mmask8 test_mm_mask_cmpneq_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    468   // CHECK-LABEL: @test_mm_mask_cmpneq_epi32_mask
    469   // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 4, i8 {{.*}})
    470   return (__mmask8)_mm_mask_cmpneq_epi32_mask(__u, __a, __b);
    471 }
    472 
    473 __mmask8 test_mm_cmpneq_epi64_mask(__m128i __a, __m128i __b) {
    474   // CHECK-LABEL: @test_mm_cmpneq_epi64_mask
    475   // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 4, i8 -1)
    476   return (__mmask8)_mm_cmpneq_epi64_mask(__a, __b);
    477 }
    478 
    479 __mmask8 test_mm_mask_cmpneq_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    480   // CHECK-LABEL: @test_mm_mask_cmpneq_epi64_mask
    481   // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 4, i8 {{.*}})
    482   return (__mmask8)_mm_mask_cmpneq_epi64_mask(__u, __a, __b);
    483 }
    484 
    485 __mmask8 test_mm256_cmpneq_epi32_mask(__m256i __a, __m256i __b) {
    486   // CHECK-LABEL: @test_mm256_cmpneq_epi32_mask
    487   // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 4, i8 -1)
    488   return (__mmask8)_mm256_cmpneq_epi32_mask(__a, __b);
    489 }
    490 
    491 __mmask8 test_mm256_mask_cmpneq_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    492   // CHECK-LABEL: @test_mm256_mask_cmpneq_epi32_mask
    493   // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 4, i8 {{.*}})
    494   return (__mmask8)_mm256_mask_cmpneq_epi32_mask(__u, __a, __b);
    495 }
    496 
    497 __mmask8 test_mm256_cmpneq_epi64_mask(__m256i __a, __m256i __b) {
    498   // CHECK-LABEL: @test_mm256_cmpneq_epi64_mask
    499   // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 4, i8 -1)
    500   return (__mmask8)_mm256_cmpneq_epi64_mask(__a, __b);
    501 }
    502 
    503 __mmask8 test_mm256_mask_cmpneq_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    504   // CHECK-LABEL: @test_mm256_mask_cmpneq_epi64_mask
    505   // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 4, i8 {{.*}})
    506   return (__mmask8)_mm256_mask_cmpneq_epi64_mask(__u, __a, __b);
    507 }
    508 
    509 __mmask8 test_mm_cmpneq_epu32_mask(__m128i __a, __m128i __b) {
    510   // CHECK-LABEL: @test_mm_cmpneq_epu32_mask
    511   // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 4, i8 -1)
    512   return (__mmask8)_mm_cmpneq_epu32_mask(__a, __b);
    513 }
    514 
    515 __mmask8 test_mm_mask_cmpneq_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    516   // CHECK-LABEL: @test_mm_mask_cmpneq_epu32_mask
    517   // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 4, i8 {{.*}})
    518   return (__mmask8)_mm_mask_cmpneq_epu32_mask(__u, __a, __b);
    519 }
    520 
    521 __mmask8 test_mm_cmpneq_epu64_mask(__m128i __a, __m128i __b) {
    522   // CHECK-LABEL: @test_mm_cmpneq_epu64_mask
    523   // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 4, i8 -1)
    524   return (__mmask8)_mm_cmpneq_epu64_mask(__a, __b);
    525 }
    526 
    527 __mmask8 test_mm_mask_cmpneq_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    528   // CHECK-LABEL: @test_mm_mask_cmpneq_epu64_mask
    529   // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 4, i8 {{.*}})
    530   return (__mmask8)_mm_mask_cmpneq_epu64_mask(__u, __a, __b);
    531 }
    532 
    533 __mmask8 test_mm256_cmpneq_epu32_mask(__m256i __a, __m256i __b) {
    534   // CHECK-LABEL: @test_mm256_cmpneq_epu32_mask
    535   // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 4, i8 -1)
    536   return (__mmask8)_mm256_cmpneq_epu32_mask(__a, __b);
    537 }
    538 
    539 __mmask8 test_mm256_mask_cmpneq_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    540   // CHECK-LABEL: @test_mm256_mask_cmpneq_epu32_mask
    541   // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 4, i8 {{.*}})
    542   return (__mmask8)_mm256_mask_cmpneq_epu32_mask(__u, __a, __b);
    543 }
    544 
    545 __mmask8 test_mm256_cmpneq_epu64_mask(__m256i __a, __m256i __b) {
    546   // CHECK-LABEL: @test_mm256_cmpneq_epu64_mask
    547   // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 4, i8 -1)
    548   return (__mmask8)_mm256_cmpneq_epu64_mask(__a, __b);
    549 }
    550 
    551 __mmask8 test_mm256_mask_cmpneq_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    552   // CHECK-LABEL: @test_mm256_mask_cmpneq_epu64_mask
    553   // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 4, i8 {{.*}})
    554   return (__mmask8)_mm256_mask_cmpneq_epu64_mask(__u, __a, __b);
    555 }
    556 
    557 __mmask8 test_mm_cmp_epi32_mask(__m128i __a, __m128i __b) {
    558   // CHECK-LABEL: @test_mm_cmp_epi32_mask
    559   // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 7, i8 -1)
    560   return (__mmask8)_mm_cmp_epi32_mask(__a, __b, 7);
    561 }
    562 
    563 __mmask8 test_mm_mask_cmp_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    564   // CHECK-LABEL: @test_mm_mask_cmp_epi32_mask
    565   // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 7, i8 {{.*}})
    566   return (__mmask8)_mm_mask_cmp_epi32_mask(__u, __a, __b, 7);
    567 }
    568 
    569 __mmask8 test_mm_cmp_epi64_mask(__m128i __a, __m128i __b) {
    570   // CHECK-LABEL: @test_mm_cmp_epi64_mask
    571   // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 7, i8 -1)
    572   return (__mmask8)_mm_cmp_epi64_mask(__a, __b, 7);
    573 }
    574 
    575 __mmask8 test_mm_mask_cmp_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    576   // CHECK-LABEL: @test_mm_mask_cmp_epi64_mask
    577   // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 7, i8 {{.*}})
    578   return (__mmask8)_mm_mask_cmp_epi64_mask(__u, __a, __b, 7);
    579 }
    580 
    581 __mmask8 test_mm256_cmp_epi32_mask(__m256i __a, __m256i __b) {
    582   // CHECK-LABEL: @test_mm256_cmp_epi32_mask
    583   // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 7, i8 -1)
    584   return (__mmask8)_mm256_cmp_epi32_mask(__a, __b, 7);
    585 }
    586 
    587 __mmask8 test_mm256_mask_cmp_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    588   // CHECK-LABEL: @test_mm256_mask_cmp_epi32_mask
    589   // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 7, i8 {{.*}})
    590   return (__mmask8)_mm256_mask_cmp_epi32_mask(__u, __a, __b, 7);
    591 }
    592 
    593 __mmask8 test_mm256_cmp_epi64_mask(__m256i __a, __m256i __b) {
    594   // CHECK-LABEL: @test_mm256_cmp_epi64_mask
    595   // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 7, i8 -1)
    596   return (__mmask8)_mm256_cmp_epi64_mask(__a, __b, 7);
    597 }
    598 
    599 __mmask8 test_mm256_mask_cmp_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    600   // CHECK-LABEL: @test_mm256_mask_cmp_epi64_mask
    601   // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 7, i8 {{.*}})
    602   return (__mmask8)_mm256_mask_cmp_epi64_mask(__u, __a, __b, 7);
    603 }
    604 
    605 __mmask8 test_mm_cmp_epu32_mask(__m128i __a, __m128i __b) {
    606   // CHECK-LABEL: @test_mm_cmp_epu32_mask
    607   // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 7, i8 -1)
    608   return (__mmask8)_mm_cmp_epu32_mask(__a, __b, 7);
    609 }
    610 
    611 __mmask8 test_mm_mask_cmp_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    612   // CHECK-LABEL: @test_mm_mask_cmp_epu32_mask
    613   // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 7, i8 {{.*}})
    614   return (__mmask8)_mm_mask_cmp_epu32_mask(__u, __a, __b, 7);
    615 }
    616 
    617 __mmask8 test_mm_cmp_epu64_mask(__m128i __a, __m128i __b) {
    618   // CHECK-LABEL: @test_mm_cmp_epu64_mask
    619   // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 7, i8 -1)
    620   return (__mmask8)_mm_cmp_epu64_mask(__a, __b, 7);
    621 }
    622 
    623 __mmask8 test_mm_mask_cmp_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
    624   // CHECK-LABEL: @test_mm_mask_cmp_epu64_mask
    625   // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 7, i8 {{.*}})
    626   return (__mmask8)_mm_mask_cmp_epu64_mask(__u, __a, __b, 7);
    627 }
    628 
    629 __mmask8 test_mm256_cmp_epu32_mask(__m256i __a, __m256i __b) {
    630   // CHECK-LABEL: @test_mm256_cmp_epu32_mask
    631   // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 7, i8 -1)
    632   return (__mmask8)_mm256_cmp_epu32_mask(__a, __b, 7);
    633 }
    634 
    635 __mmask8 test_mm256_mask_cmp_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    636   // CHECK-LABEL: @test_mm256_mask_cmp_epu32_mask
    637   // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 7, i8 {{.*}})
    638   return (__mmask8)_mm256_mask_cmp_epu32_mask(__u, __a, __b, 7);
    639 }
    640 
    641 __mmask8 test_mm256_cmp_epu64_mask(__m256i __a, __m256i __b) {
    642   // CHECK-LABEL: @test_mm256_cmp_epu64_mask
    643   // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 7, i8 -1)
    644   return (__mmask8)_mm256_cmp_epu64_mask(__a, __b, 7);
    645 }
    646 
    647 __mmask8 test_mm256_mask_cmp_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
    648   // CHECK-LABEL: @test_mm256_mask_cmp_epu64_mask
    649   // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 7, i8 {{.*}})
    650   return (__mmask8)_mm256_mask_cmp_epu64_mask(__u, __a, __b, 7);
    651 }
    652