clang/test/CodeGen/X86/avx512vldq-builtins.c

   1 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512dq -target-feature +avx512vl -emit-llvm -o - -Wall -Werror | FileCheck %s
   2
   3
   4 #include <immintrin.h>
   5
   6 __m256i test_mm256_mullo_epi64 (__m256i __A, __m256i __B) {
   7   // CHECK-LABEL: @test_mm256_mullo_epi64
   8   // CHECK: mul <4 x i64>
   9   return _mm256_mullo_epi64(__A, __B);
  10 }
  11
  12 __m256i test_mm256_mask_mullo_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
  13   // CHECK-LABEL: @test_mm256_mask_mullo_epi64
  14   // CHECK: mul <4 x i64> %{{.*}}, %{{.*}}
  15   // CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
  16   return (__m256i) _mm256_mask_mullo_epi64 ( __W, __U, __A, __B);
  17 }
  18
  19 __m256i test_mm256_maskz_mullo_epi64 (__mmask8 __U, __m256i __A, __m256i __B) {
  20   // CHECK-LABEL: @test_mm256_maskz_mullo_epi64
  21   // CHECK: mul <4 x i64> %{{.*}}, %{{.*}}
  22   // CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
  23   return (__m256i) _mm256_maskz_mullo_epi64 (__U, __A, __B);
  24 }
  25
  26 __m128i test_mm_mullo_epi64 (__m128i __A, __m128i __B) {
  27   // CHECK-LABEL: @test_mm_mullo_epi64
  28   // CHECK: mul <2 x i64>
  29   return (__m128i) _mm_mullo_epi64(__A, __B);
  30 }
  31
  32 __m128i test_mm_mask_mullo_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
  33   // CHECK-LABEL: @test_mm_mask_mullo_epi64
  34   // CHECK: mul <2 x i64> %{{.*}}, %{{.*}}
  35   // CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
  36   return (__m128i) _mm_mask_mullo_epi64 ( __W, __U, __A, __B);
  37 }
  38
  39 __m128i test_mm_maskz_mullo_epi64 (__mmask8 __U, __m128i __A, __m128i __B) {
  40   // CHECK-LABEL: @test_mm_maskz_mullo_epi64
  41   // CHECK: mul <2 x i64> %{{.*}}, %{{.*}}
  42   // CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
  43   return (__m128i) _mm_maskz_mullo_epi64 (__U, __A, __B);
  44 }
  45
  46 __m256d test_mm256_mask_andnot_pd (__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
  47   // CHECK-LABEL: @test_mm256_mask_andnot_pd
  48   // CHECK: xor <4 x i64> %{{.*}}, splat (i64 -1)
  49   // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
  50   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
  51   return (__m256d) _mm256_mask_andnot_pd ( __W, __U, __A, __B);
  52 }
  53
  54 __m256d test_mm256_maskz_andnot_pd (__mmask8 __U, __m256d __A, __m256d __B) {
  55   // CHECK-LABEL: @test_mm256_maskz_andnot_pd
  56   // CHECK: xor <4 x i64> %{{.*}}, splat (i64 -1)
  57   // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
  58   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
  59   return (__m256d) _mm256_maskz_andnot_pd (__U, __A, __B);
  60 }
  61
  62 __m128d test_mm_mask_andnot_pd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
  63   // CHECK-LABEL: @test_mm_mask_andnot_pd
  64   // CHECK: xor <2 x i64> %{{.*}}, splat (i64 -1)
  65   // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
  66   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
  67   return (__m128d) _mm_mask_andnot_pd ( __W, __U, __A, __B);
  68 }
  69
  70 __m128d test_mm_maskz_andnot_pd (__mmask8 __U, __m128d __A, __m128d __B) {
  71   // CHECK-LABEL: @test_mm_maskz_andnot_pd
  72   // CHECK: xor <2 x i64> %{{.*}}, splat (i64 -1)
  73   // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
  74   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
  75   return (__m128d) _mm_maskz_andnot_pd (__U, __A, __B);
  76 }
  77
  78 __m256 test_mm256_mask_andnot_ps (__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
  79   // CHECK-LABEL: @test_mm256_mask_andnot_ps
  80   // CHECK: xor <8 x i32> %{{.*}}, splat (i32 -1)
  81   // CHECK: and <8 x i32> %{{.*}}, %{{.*}}
  82   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
  83   return (__m256) _mm256_mask_andnot_ps ( __W, __U, __A, __B);
  84 }
  85
  86 __m256 test_mm256_maskz_andnot_ps (__mmask8 __U, __m256 __A, __m256 __B) {
  87   // CHECK-LABEL: @test_mm256_maskz_andnot_ps
  88   // CHECK: xor <8 x i32> %{{.*}}, splat (i32 -1)
  89   // CHECK: and <8 x i32> %{{.*}}, %{{.*}}
  90   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
  91   return (__m256) _mm256_maskz_andnot_ps (__U, __A, __B);
  92 }
  93
  94 __m128 test_mm_mask_andnot_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
  95   // CHECK-LABEL: @test_mm_mask_andnot_ps
  96   // CHECK: xor <4 x i32> %{{.*}}, splat (i32 -1)
  97   // CHECK: and <4 x i32> %{{.*}}, %{{.*}}
  98   // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
  99   return (__m128) _mm_mask_andnot_ps ( __W, __U, __A, __B);
 100 }
 101
 102 __m128 test_mm_maskz_andnot_ps (__mmask8 __U, __m128 __A, __m128 __B) {
 103   // CHECK-LABEL: @test_mm_maskz_andnot_ps
 104   // CHECK: xor <4 x i32> %{{.*}}, splat (i32 -1)
 105   // CHECK: and <4 x i32> %{{.*}}, %{{.*}}
 106   // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
 107   return (__m128) _mm_maskz_andnot_ps (__U, __A, __B);
 108 }
 109
 110 __m256d test_mm256_mask_and_pd (__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
 111   // CHECK-LABEL: @test_mm256_mask_and_pd
 112   // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
 113   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
 114   return (__m256d) _mm256_mask_and_pd ( __W, __U, __A, __B);
 115 }
 116
 117 __m256d test_mm256_maskz_and_pd (__mmask8 __U, __m256d __A, __m256d __B) {
 118   // CHECK-LABEL: @test_mm256_maskz_and_pd
 119   // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
 120   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
 121   return (__m256d) _mm256_maskz_and_pd (__U, __A, __B);
 122 }
 123
 124 __m128d test_mm_mask_and_pd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
 125   // CHECK-LABEL: @test_mm_mask_and_pd
 126   // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
 127   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
 128   return (__m128d) _mm_mask_and_pd ( __W, __U, __A, __B);
 129 }
 130
 131 __m128d test_mm_maskz_and_pd (__mmask8 __U, __m128d __A, __m128d __B) {
 132   // CHECK-LABEL: @test_mm_maskz_and_pd
 133   // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
 134   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
 135   return (__m128d) _mm_maskz_and_pd (__U, __A, __B);
 136 }
 137
 138 __m256 test_mm256_mask_and_ps (__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
 139   // CHECK-LABEL: @test_mm256_mask_and_ps
 140   // CHECK: and <8 x i32> %{{.*}}, %{{.*}}
 141   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 142   return (__m256) _mm256_mask_and_ps ( __W, __U, __A, __B);
 143 }
 144
 145 __m256 test_mm256_maskz_and_ps (__mmask8 __U, __m256 __A, __m256 __B) {
 146   // CHECK-LABEL: @test_mm256_maskz_and_ps
 147   // CHECK: and <8 x i32> %{{.*}}, %{{.*}}
 148   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 149   return (__m256) _mm256_maskz_and_ps (__U, __A, __B);
 150 }
 151
 152 __m128 test_mm_mask_and_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
 153   // CHECK-LABEL: @test_mm_mask_and_ps
 154   // CHECK: and <4 x i32> %{{.*}}, %{{.*}}
 155   // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
 156   return (__m128) _mm_mask_and_ps ( __W, __U, __A, __B);
 157 }
 158
 159 __m128 test_mm_maskz_and_ps (__mmask8 __U, __m128 __A, __m128 __B) {
 160   // CHECK-LABEL: @test_mm_maskz_and_ps
 161   // CHECK: and <4 x i32> %{{.*}}, %{{.*}}
 162   // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
 163   return (__m128) _mm_maskz_and_ps (__U, __A, __B);
 164 }
 165
 166 __m256d test_mm256_mask_xor_pd (__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
 167   // CHECK-LABEL: @test_mm256_mask_xor_pd
 168   // CHECK: xor <4 x i64> %{{.*}}, %{{.*}}
 169   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
 170   return (__m256d) _mm256_mask_xor_pd ( __W, __U, __A, __B);
 171 }
 172
 173 __m256d test_mm256_maskz_xor_pd (__mmask8 __U, __m256d __A, __m256d __B) {
 174   // CHECK-LABEL: @test_mm256_maskz_xor_pd
 175   // CHECK: xor <4 x i64> %{{.*}}, %{{.*}}
 176   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
 177   return (__m256d) _mm256_maskz_xor_pd (__U, __A, __B);
 178 }
 179
 180 __m128d test_mm_mask_xor_pd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
 181   // CHECK-LABEL: @test_mm_mask_xor_pd
 182   // CHECK: xor <2 x i64> %{{.*}}, %{{.*}}
 183   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
 184   return (__m128d) _mm_mask_xor_pd ( __W, __U, __A, __B);
 185 }
 186
 187 __m128d test_mm_maskz_xor_pd (__mmask8 __U, __m128d __A, __m128d __B) {
 188   // CHECK-LABEL: @test_mm_maskz_xor_pd
 189   // CHECK: xor <2 x i64> %{{.*}}, %{{.*}}
 190   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
 191   return (__m128d) _mm_maskz_xor_pd (__U, __A, __B);
 192 }
 193
 194 __m256 test_mm256_mask_xor_ps (__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
 195   // CHECK-LABEL: @test_mm256_mask_xor_ps
 196   // CHECK: xor <8 x i32> %{{.*}}, %{{.*}}
 197   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 198   return (__m256) _mm256_mask_xor_ps ( __W, __U, __A, __B);
 199 }
 200
 201 __m256 test_mm256_maskz_xor_ps (__mmask8 __U, __m256 __A, __m256 __B) {
 202   // CHECK-LABEL: @test_mm256_maskz_xor_ps
 203   // CHECK: xor <8 x i32> %{{.*}}, %{{.*}}
 204   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 205   return (__m256) _mm256_maskz_xor_ps (__U, __A, __B);
 206 }
 207
 208 __m128 test_mm_mask_xor_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
 209   // CHECK-LABEL: @test_mm_mask_xor_ps
 210   // CHECK: xor <4 x i32> %{{.*}}, %{{.*}}
 211   // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
 212   return (__m128) _mm_mask_xor_ps ( __W, __U, __A, __B);
 213 }
 214
 215 __m128 test_mm_maskz_xor_ps (__mmask8 __U, __m128 __A, __m128 __B) {
 216   // CHECK-LABEL: @test_mm_maskz_xor_ps
 217   // CHECK: xor <4 x i32> %{{.*}}, %{{.*}}
 218   // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
 219   return (__m128) _mm_maskz_xor_ps (__U, __A, __B);
 220 }
 221
 222 __m256d test_mm256_mask_or_pd (__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
 223   // CHECK-LABEL: @test_mm256_mask_or_pd
 224   // CHECK: or <4 x i64> %{{.*}}, %{{.*}}
 225   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
 226   return (__m256d) _mm256_mask_or_pd ( __W, __U, __A, __B);
 227 }
 228
 229 __m256d test_mm256_maskz_or_pd (__mmask8 __U, __m256d __A, __m256d __B) {
 230   // CHECK-LABEL: @test_mm256_maskz_or_pd
 231   // CHECK: or <4 x i64> %{{.*}}, %{{.*}}
 232   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
 233   return (__m256d) _mm256_maskz_or_pd (__U, __A, __B);
 234 }
 235
 236 __m128d test_mm_mask_or_pd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
 237   // CHECK-LABEL: @test_mm_mask_or_pd
 238   // CHECK: or <2 x i64> %{{.*}}, %{{.*}}
 239   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
 240   return (__m128d) _mm_mask_or_pd ( __W, __U, __A, __B);
 241 }
 242
 243 __m128d test_mm_maskz_or_pd (__mmask8 __U, __m128d __A, __m128d __B) {
 244   // CHECK-LABEL: @test_mm_maskz_or_pd
 245   // CHECK: or <2 x i64> %{{.*}}, %{{.*}}
 246   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
 247   return (__m128d) _mm_maskz_or_pd (__U, __A, __B);
 248 }
 249
 250 __m256 test_mm256_mask_or_ps (__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
 251   // CHECK-LABEL: @test_mm256_mask_or_ps
 252   // CHECK: or <8 x i32> %{{.*}}, %{{.*}}
 253   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 254   return (__m256) _mm256_mask_or_ps ( __W, __U, __A, __B);
 255 }
 256
 257 __m256 test_mm256_maskz_or_ps (__mmask8 __U, __m256 __A, __m256 __B) {
 258   // CHECK-LABEL: @test_mm256_maskz_or_ps
 259   // CHECK: or <8 x i32> %{{.*}}, %{{.*}}
 260   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 261   return (__m256) _mm256_maskz_or_ps (__U, __A, __B);
 262 }
 263
 264 __m128 test_mm_mask_or_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
 265   // CHECK-LABEL: @test_mm_mask_or_ps
 266   // CHECK: or <4 x i32> %{{.*}}, %{{.*}}
 267   // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
 268   return (__m128) _mm_mask_or_ps ( __W, __U, __A, __B);
 269 }
 270
 271 __m128 test_mm_maskz_or_ps (__mmask8 __U, __m128 __A, __m128 __B) {
 272   // CHECK-LABEL: @test_mm_maskz_or_ps
 273   // CHECK: or <4 x i32> %{{.*}}, %{{.*}}
 274   // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
 275   return (__m128) _mm_maskz_or_ps(__U, __A, __B);
 276 }
 277
 278 __m128i test_mm_cvtpd_epi64(__m128d __A) {
 279   // CHECK-LABEL: @test_mm_cvtpd_epi64
 280   // CHECK: @llvm.x86.avx512.mask.cvtpd2qq.128
 281   return _mm_cvtpd_epi64(__A);
 282 }
 283
 284 __m128i test_mm_mask_cvtpd_epi64(__m128i __W, __mmask8 __U, __m128d __A) {
 285   // CHECK-LABEL: @test_mm_mask_cvtpd_epi64
 286   // CHECK: @llvm.x86.avx512.mask.cvtpd2qq.128
 287   return _mm_mask_cvtpd_epi64(__W, __U, __A);
 288 }
 289
 290 __m128i test_mm_maskz_cvtpd_epi64(__mmask8 __U, __m128d __A) {
 291   // CHECK-LABEL: @test_mm_maskz_cvtpd_epi64
 292   // CHECK: @llvm.x86.avx512.mask.cvtpd2qq.128
 293   return _mm_maskz_cvtpd_epi64(__U, __A);
 294 }
 295
 296 __m256i test_mm256_cvtpd_epi64(__m256d __A) {
 297   // CHECK-LABEL: @test_mm256_cvtpd_epi64
 298   // CHECK: @llvm.x86.avx512.mask.cvtpd2qq.256
 299   return _mm256_cvtpd_epi64(__A);
 300 }
 301
 302 __m256i test_mm256_mask_cvtpd_epi64(__m256i __W, __mmask8 __U, __m256d __A) {
 303   // CHECK-LABEL: @test_mm256_mask_cvtpd_epi64
 304   // CHECK: @llvm.x86.avx512.mask.cvtpd2qq.256
 305   return _mm256_mask_cvtpd_epi64(__W, __U, __A);
 306 }
 307
 308 __m256i test_mm256_maskz_cvtpd_epi64(__mmask8 __U, __m256d __A) {
 309   // CHECK-LABEL: @test_mm256_maskz_cvtpd_epi64
 310   // CHECK: @llvm.x86.avx512.mask.cvtpd2qq.256
 311   return _mm256_maskz_cvtpd_epi64(__U, __A);
 312 }
 313
 314 __m128i test_mm_cvtpd_epu64(__m128d __A) {
 315   // CHECK-LABEL: @test_mm_cvtpd_epu64
 316   // CHECK: @llvm.x86.avx512.mask.cvtpd2uqq.128
 317   return _mm_cvtpd_epu64(__A);
 318 }
 319
 320 __m128i test_mm_mask_cvtpd_epu64(__m128i __W, __mmask8 __U, __m128d __A) {
 321   // CHECK-LABEL: @test_mm_mask_cvtpd_epu64
 322   // CHECK: @llvm.x86.avx512.mask.cvtpd2uqq.128
 323   return _mm_mask_cvtpd_epu64(__W, __U, __A);
 324 }
 325
 326 __m128i test_mm_maskz_cvtpd_epu64(__mmask8 __U, __m128d __A) {
 327   // CHECK-LABEL: @test_mm_maskz_cvtpd_epu64
 328   // CHECK: @llvm.x86.avx512.mask.cvtpd2uqq.128
 329   return _mm_maskz_cvtpd_epu64(__U, __A);
 330 }
 331
 332 __m256i test_mm256_cvtpd_epu64(__m256d __A) {
 333   // CHECK-LABEL: @test_mm256_cvtpd_epu64
 334   // CHECK: @llvm.x86.avx512.mask.cvtpd2uqq.256
 335   return _mm256_cvtpd_epu64(__A);
 336 }
 337
 338 __m256i test_mm256_mask_cvtpd_epu64(__m256i __W, __mmask8 __U, __m256d __A) {
 339   // CHECK-LABEL: @test_mm256_mask_cvtpd_epu64
 340   // CHECK: @llvm.x86.avx512.mask.cvtpd2uqq.256
 341   return _mm256_mask_cvtpd_epu64(__W, __U, __A);
 342 }
 343
 344 __m256i test_mm256_maskz_cvtpd_epu64(__mmask8 __U, __m256d __A) {
 345   // CHECK-LABEL: @test_mm256_maskz_cvtpd_epu64
 346   // CHECK: @llvm.x86.avx512.mask.cvtpd2uqq.256
 347   return _mm256_maskz_cvtpd_epu64(__U, __A);
 348 }
 349
 350 __m128i test_mm_cvtps_epi64(__m128 __A) {
 351   // CHECK-LABEL: @test_mm_cvtps_epi64
 352   // CHECK: @llvm.x86.avx512.mask.cvtps2qq.128
 353   return _mm_cvtps_epi64(__A);
 354 }
 355
 356 __m128i test_mm_mask_cvtps_epi64(__m128i __W, __mmask8 __U, __m128 __A) {
 357   // CHECK-LABEL: @test_mm_mask_cvtps_epi64
 358   // CHECK: @llvm.x86.avx512.mask.cvtps2qq.128
 359   return _mm_mask_cvtps_epi64(__W, __U, __A);
 360 }
 361
 362 __m128i test_mm_maskz_cvtps_epi64(__mmask8 __U, __m128 __A) {
 363   // CHECK-LABEL: @test_mm_maskz_cvtps_epi64
 364   // CHECK: @llvm.x86.avx512.mask.cvtps2qq.128
 365   return _mm_maskz_cvtps_epi64(__U, __A);
 366 }
 367
 368 __m256i test_mm256_cvtps_epi64(__m128 __A) {
 369   // CHECK-LABEL: @test_mm256_cvtps_epi64
 370   // CHECK: @llvm.x86.avx512.mask.cvtps2qq.256
 371   return _mm256_cvtps_epi64(__A);
 372 }
 373
 374 __m256i test_mm256_mask_cvtps_epi64(__m256i __W, __mmask8 __U, __m128 __A) {
 375   // CHECK-LABEL: @test_mm256_mask_cvtps_epi64
 376   // CHECK: @llvm.x86.avx512.mask.cvtps2qq.256
 377   return _mm256_mask_cvtps_epi64(__W, __U, __A);
 378 }
 379
 380 __m256i test_mm256_maskz_cvtps_epi64(__mmask8 __U, __m128 __A) {
 381   // CHECK-LABEL: @test_mm256_maskz_cvtps_epi64
 382   // CHECK: @llvm.x86.avx512.mask.cvtps2qq.256
 383   return _mm256_maskz_cvtps_epi64(__U, __A);
 384 }
 385
 386 __m128i test_mm_cvtps_epu64(__m128 __A) {
 387   // CHECK-LABEL: @test_mm_cvtps_epu64
 388   // CHECK: @llvm.x86.avx512.mask.cvtps2uqq.128
 389   return _mm_cvtps_epu64(__A);
 390 }
 391
 392 __m128i test_mm_mask_cvtps_epu64(__m128i __W, __mmask8 __U, __m128 __A) {
 393   // CHECK-LABEL: @test_mm_mask_cvtps_epu64
 394   // CHECK: @llvm.x86.avx512.mask.cvtps2uqq.128
 395   return _mm_mask_cvtps_epu64(__W, __U, __A);
 396 }
 397
 398 __m128i test_mm_maskz_cvtps_epu64(__mmask8 __U, __m128 __A) {
 399   // CHECK-LABEL: @test_mm_maskz_cvtps_epu64
 400   // CHECK: @llvm.x86.avx512.mask.cvtps2uqq.128
 401   return _mm_maskz_cvtps_epu64(__U, __A);
 402 }
 403
 404 __m256i test_mm256_cvtps_epu64(__m128 __A) {
 405   // CHECK-LABEL: @test_mm256_cvtps_epu64
 406   // CHECK: @llvm.x86.avx512.mask.cvtps2uqq.256
 407   return _mm256_cvtps_epu64(__A);
 408 }
 409
 410 __m256i test_mm256_mask_cvtps_epu64(__m256i __W, __mmask8 __U, __m128 __A) {
 411   // CHECK-LABEL: @test_mm256_mask_cvtps_epu64
 412   // CHECK: @llvm.x86.avx512.mask.cvtps2uqq.256
 413   return _mm256_mask_cvtps_epu64(__W, __U, __A);
 414 }
 415
 416 __m256i test_mm256_maskz_cvtps_epu64(__mmask8 __U, __m128 __A) {
 417   // CHECK-LABEL: @test_mm256_maskz_cvtps_epu64
 418   // CHECK: @llvm.x86.avx512.mask.cvtps2uqq.256
 419   return _mm256_maskz_cvtps_epu64(__U, __A);
 420 }
 421
 422 __m128d test_mm_cvtepi64_pd(__m128i __A) {
 423   // CHECK-LABEL: @test_mm_cvtepi64_pd
 424   // CHECK: sitofp <2 x i64> %{{.*}} to <2 x double>
 425   return _mm_cvtepi64_pd(__A);
 426 }
 427
 428 __m128d test_mm_mask_cvtepi64_pd(__m128d __W, __mmask8 __U, __m128i __A) {
 429   // CHECK-LABEL: @test_mm_mask_cvtepi64_pd
 430   // CHECK: sitofp <2 x i64> %{{.*}} to <2 x double>
 431   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
 432   return _mm_mask_cvtepi64_pd(__W, __U, __A);
 433 }
 434
 435 __m128d test_mm_maskz_cvtepi64_pd(__mmask8 __U, __m128i __A) {
 436   // CHECK-LABEL: @test_mm_maskz_cvtepi64_pd
 437   // CHECK: sitofp <2 x i64> %{{.*}} to <2 x double>
 438   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
 439   return _mm_maskz_cvtepi64_pd(__U, __A);
 440 }
 441
 442 __m256d test_mm256_cvtepi64_pd(__m256i __A) {
 443   // CHECK-LABEL: @test_mm256_cvtepi64_pd
 444   // CHECK: sitofp <4 x i64> %{{.*}} to <4 x double>
 445   return _mm256_cvtepi64_pd(__A);
 446 }
 447
 448 __m256d test_mm256_mask_cvtepi64_pd(__m256d __W, __mmask8 __U, __m256i __A) {
 449   // CHECK-LABEL: @test_mm256_mask_cvtepi64_pd
 450   // CHECK: sitofp <4 x i64> %{{.*}} to <4 x double>
 451   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
 452   return _mm256_mask_cvtepi64_pd(__W, __U, __A);
 453 }
 454
 455 __m256d test_mm256_maskz_cvtepi64_pd(__mmask8 __U, __m256i __A) {
 456   // CHECK-LABEL: @test_mm256_maskz_cvtepi64_pd
 457   // CHECK: sitofp <4 x i64> %{{.*}} to <4 x double>
 458   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
 459   return _mm256_maskz_cvtepi64_pd(__U, __A);
 460 }
 461
 462 __m128 test_mm_cvtepi64_ps(__m128i __A) {
 463   // CHECK-LABEL: @test_mm_cvtepi64_ps
 464   // CHECK: @llvm.x86.avx512.mask.cvtqq2ps.128
 465   return _mm_cvtepi64_ps(__A);
 466 }
 467
 468 __m128 test_mm_mask_cvtepi64_ps(__m128 __W, __mmask8 __U, __m128i __A) {
 469   // CHECK-LABEL: @test_mm_mask_cvtepi64_ps
 470   // CHECK: @llvm.x86.avx512.mask.cvtqq2ps.128
 471   return _mm_mask_cvtepi64_ps(__W, __U, __A);
 472 }
 473
 474 __m128 test_mm_maskz_cvtepi64_ps(__mmask8 __U, __m128i __A) {
 475   // CHECK-LABEL: @test_mm_maskz_cvtepi64_ps
 476   // CHECK: @llvm.x86.avx512.mask.cvtqq2ps.128
 477   return _mm_maskz_cvtepi64_ps(__U, __A);
 478 }
 479
 480 __m128 test_mm256_cvtepi64_ps(__m256i __A) {
 481   // CHECK-LABEL: @test_mm256_cvtepi64_ps
 482   // CHECK: sitofp <4 x i64> %{{.*}} to <4 x float>
 483   return _mm256_cvtepi64_ps(__A);
 484 }
 485
 486 __m128 test_mm256_mask_cvtepi64_ps(__m128 __W, __mmask8 __U, __m256i __A) {
 487   // CHECK-LABEL: @test_mm256_mask_cvtepi64_ps
 488   // CHECK: sitofp <4 x i64> %{{.*}} to <4 x float>
 489   // select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
 490   return _mm256_mask_cvtepi64_ps(__W, __U, __A);
 491 }
 492
 493 __m128 test_mm256_maskz_cvtepi64_ps(__mmask8 __U, __m256i __A) {
 494   // CHECK-LABEL: @test_mm256_maskz_cvtepi64_ps
 495   // CHECK: sitofp <4 x i64> %{{.*}} to <4 x float>
 496   // select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
 497   return _mm256_maskz_cvtepi64_ps(__U, __A);
 498 }
 499
 500 __m128i test_mm_cvttpd_epi64(__m128d __A) {
 501   // CHECK-LABEL: @test_mm_cvttpd_epi64
 502   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.128
 503   return _mm_cvttpd_epi64(__A);
 504 }
 505
 506 __m128i test_mm_mask_cvttpd_epi64(__m128i __W, __mmask8 __U, __m128d __A) {
 507   // CHECK-LABEL: @test_mm_mask_cvttpd_epi64
 508   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.128
 509   return _mm_mask_cvttpd_epi64(__W, __U, __A);
 510 }
 511
 512 __m128i test_mm_maskz_cvttpd_epi64(__mmask8 __U, __m128d __A) {
 513   // CHECK-LABEL: @test_mm_maskz_cvttpd_epi64
 514   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.128
 515   return _mm_maskz_cvttpd_epi64(__U, __A);
 516 }
 517
 518 __m256i test_mm256_cvttpd_epi64(__m256d __A) {
 519   // CHECK-LABEL: @test_mm256_cvttpd_epi64
 520   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.256
 521   return _mm256_cvttpd_epi64(__A);
 522 }
 523
 524 __m256i test_mm256_mask_cvttpd_epi64(__m256i __W, __mmask8 __U, __m256d __A) {
 525   // CHECK-LABEL: @test_mm256_mask_cvttpd_epi64
 526   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.256
 527   return _mm256_mask_cvttpd_epi64(__W, __U, __A);
 528 }
 529
 530 __m256i test_mm256_maskz_cvttpd_epi64(__mmask8 __U, __m256d __A) {
 531   // CHECK-LABEL: @test_mm256_maskz_cvttpd_epi64
 532   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.256
 533   return _mm256_maskz_cvttpd_epi64(__U, __A);
 534 }
 535
 536 __m128i test_mm_cvttpd_epu64(__m128d __A) {
 537   // CHECK-LABEL: @test_mm_cvttpd_epu64
 538   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.128
 539   return _mm_cvttpd_epu64(__A);
 540 }
 541
 542 __m128i test_mm_mask_cvttpd_epu64(__m128i __W, __mmask8 __U, __m128d __A) {
 543   // CHECK-LABEL: @test_mm_mask_cvttpd_epu64
 544   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.128
 545   return _mm_mask_cvttpd_epu64(__W, __U, __A);
 546 }
 547
 548 __m128i test_mm_maskz_cvttpd_epu64(__mmask8 __U, __m128d __A) {
 549   // CHECK-LABEL: @test_mm_maskz_cvttpd_epu64
 550   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.128
 551   return _mm_maskz_cvttpd_epu64(__U, __A);
 552 }
 553
 554 __m256i test_mm256_cvttpd_epu64(__m256d __A) {
 555   // CHECK-LABEL: @test_mm256_cvttpd_epu64
 556   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.256
 557   return _mm256_cvttpd_epu64(__A);
 558 }
 559
 560 __m256i test_mm256_mask_cvttpd_epu64(__m256i __W, __mmask8 __U, __m256d __A) {
 561   // CHECK-LABEL: @test_mm256_mask_cvttpd_epu64
 562   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.256
 563   return _mm256_mask_cvttpd_epu64(__W, __U, __A);
 564 }
 565
 566 __m256i test_mm256_maskz_cvttpd_epu64(__mmask8 __U, __m256d __A) {
 567   // CHECK-LABEL: @test_mm256_maskz_cvttpd_epu64
 568   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.256
 569   return _mm256_maskz_cvttpd_epu64(__U, __A);
 570 }
 571
 572 __m128i test_mm_cvttps_epi64(__m128 __A) {
 573   // CHECK-LABEL: @test_mm_cvttps_epi64
 574   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.128
 575   return _mm_cvttps_epi64(__A);
 576 }
 577
 578 __m128i test_mm_mask_cvttps_epi64(__m128i __W, __mmask8 __U, __m128 __A) {
 579   // CHECK-LABEL: @test_mm_mask_cvttps_epi64
 580   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.128
 581   return _mm_mask_cvttps_epi64(__W, __U, __A);
 582 }
 583
 584 __m128i test_mm_maskz_cvttps_epi64(__mmask8 __U, __m128 __A) {
 585   // CHECK-LABEL: @test_mm_maskz_cvttps_epi64
 586   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.128
 587   return _mm_maskz_cvttps_epi64(__U, __A);
 588 }
 589
 590 __m256i test_mm256_cvttps_epi64(__m128 __A) {
 591   // CHECK-LABEL: @test_mm256_cvttps_epi64
 592   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.256
 593   return _mm256_cvttps_epi64(__A);
 594 }
 595
 596 __m256i test_mm256_mask_cvttps_epi64(__m256i __W, __mmask8 __U, __m128 __A) {
 597   // CHECK-LABEL: @test_mm256_mask_cvttps_epi64
 598   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.256
 599   return _mm256_mask_cvttps_epi64(__W, __U, __A);
 600 }
 601
 602 __m256i test_mm256_maskz_cvttps_epi64(__mmask8 __U, __m128 __A) {
 603   // CHECK-LABEL: @test_mm256_maskz_cvttps_epi64
 604   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.256
 605   return _mm256_maskz_cvttps_epi64(__U, __A);
 606 }
 607
 608 __m128i test_mm_cvttps_epu64(__m128 __A) {
 609   // CHECK-LABEL: @test_mm_cvttps_epu64
 610   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.128
 611   return _mm_cvttps_epu64(__A);
 612 }
 613
 614 __m128i test_mm_mask_cvttps_epu64(__m128i __W, __mmask8 __U, __m128 __A) {
 615   // CHECK-LABEL: @test_mm_mask_cvttps_epu64
 616   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.128
 617   return _mm_mask_cvttps_epu64(__W, __U, __A);
 618 }
 619
 620 __m128i test_mm_maskz_cvttps_epu64(__mmask8 __U, __m128 __A) {
 621   // CHECK-LABEL: @test_mm_maskz_cvttps_epu64
 622   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.128
 623   return _mm_maskz_cvttps_epu64(__U, __A);
 624 }
 625
 626 __m256i test_mm256_cvttps_epu64(__m128 __A) {
 627   // CHECK-LABEL: @test_mm256_cvttps_epu64
 628   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.256
 629   return _mm256_cvttps_epu64(__A);
 630 }
 631
 632 __m256i test_mm256_mask_cvttps_epu64(__m256i __W, __mmask8 __U, __m128 __A) {
 633   // CHECK-LABEL: @test_mm256_mask_cvttps_epu64
 634   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.256
 635   return _mm256_mask_cvttps_epu64(__W, __U, __A);
 636 }
 637
 638 __m256i test_mm256_maskz_cvttps_epu64(__mmask8 __U, __m128 __A) {
 639   // CHECK-LABEL: @test_mm256_maskz_cvttps_epu64
 640   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.256
 641   return _mm256_maskz_cvttps_epu64(__U, __A);
 642 }
 643
 644 __m128d test_mm_cvtepu64_pd(__m128i __A) {
 645   // CHECK-LABEL: @test_mm_cvtepu64_pd
 646   // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
 647   return _mm_cvtepu64_pd(__A);
 648 }
 649
 650 __m128d test_mm_mask_cvtepu64_pd(__m128d __W, __mmask8 __U, __m128i __A) {
 651   // CHECK-LABEL: @test_mm_mask_cvtepu64_pd
 652   // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
 653   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
 654   return _mm_mask_cvtepu64_pd(__W, __U, __A);
 655 }
 656
 657 __m128d test_mm_maskz_cvtepu64_pd(__mmask8 __U, __m128i __A) {
 658   // CHECK-LABEL: @test_mm_maskz_cvtepu64_pd
 659   // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
 660   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
 661   return _mm_maskz_cvtepu64_pd(__U, __A);
 662 }
 663
 664 __m256d test_mm256_cvtepu64_pd(__m256i __A) {
 665   // CHECK-LABEL: @test_mm256_cvtepu64_pd
 666   // CHECK: uitofp <4 x i64> %{{.*}} to <4 x double>
 667   return _mm256_cvtepu64_pd(__A);
 668 }
 669
 670 __m256d test_mm256_mask_cvtepu64_pd(__m256d __W, __mmask8 __U, __m256i __A) {
 671   // CHECK-LABEL: @test_mm256_mask_cvtepu64_pd
 672   // CHECK: uitofp <4 x i64> %{{.*}} to <4 x double>
 673   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
 674   return _mm256_mask_cvtepu64_pd(__W, __U, __A);
 675 }
 676
 677 __m256d test_mm256_maskz_cvtepu64_pd(__mmask8 __U, __m256i __A) {
 678   // CHECK-LABEL: @test_mm256_maskz_cvtepu64_pd
 679   // CHECK: uitofp <4 x i64> %{{.*}} to <4 x double>
 680   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
 681   return _mm256_maskz_cvtepu64_pd(__U, __A);
 682 }
 683
 684 __m128 test_mm_cvtepu64_ps(__m128i __A) {
 685   // CHECK-LABEL: @test_mm_cvtepu64_ps
 686   // CHECK: @llvm.x86.avx512.mask.cvtuqq2ps.128
 687   return _mm_cvtepu64_ps(__A);
 688 }
 689
 690 __m128 test_mm_mask_cvtepu64_ps(__m128 __W, __mmask8 __U, __m128i __A) {
 691   // CHECK-LABEL: @test_mm_mask_cvtepu64_ps
 692   // CHECK: @llvm.x86.avx512.mask.cvtuqq2ps.128
 693   return _mm_mask_cvtepu64_ps(__W, __U, __A);
 694 }
 695
 696 __m128 test_mm_maskz_cvtepu64_ps(__mmask8 __U, __m128i __A) {
 697   // CHECK-LABEL: @test_mm_maskz_cvtepu64_ps
 698   // CHECK: @llvm.x86.avx512.mask.cvtuqq2ps.128
 699   return _mm_maskz_cvtepu64_ps(__U, __A);
 700 }
 701
 702 __m128 test_mm256_cvtepu64_ps(__m256i __A) {
 703   // CHECK-LABEL: @test_mm256_cvtepu64_ps
 704   // CHECK: uitofp <4 x i64> %{{.*}} to <4 x float>
 705   return _mm256_cvtepu64_ps(__A);
 706 }
 707
 708 __m128 test_mm256_mask_cvtepu64_ps(__m128 __W, __mmask8 __U, __m256i __A) {
 709   // CHECK-LABEL: @test_mm256_mask_cvtepu64_ps
 710   // CHECK: uitofp <4 x i64> %{{.*}} to <4 x float>
 711   // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
 712   return _mm256_mask_cvtepu64_ps(__W, __U, __A);
 713 }
 714
 715 __m128 test_mm256_maskz_cvtepu64_ps(__mmask8 __U, __m256i __A) {
 716   // CHECK-LABEL: @test_mm256_maskz_cvtepu64_ps
 717   // CHECK: uitofp <4 x i64> %{{.*}} to <4 x float>
 718   // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}
 719   return _mm256_maskz_cvtepu64_ps(__U, __A);
 720 }
 721
 722 __m128d test_mm_range_pd(__m128d __A, __m128d __B) {
 723   // CHECK-LABEL: @test_mm_range_pd
 724   // CHECK: @llvm.x86.avx512.mask.range.pd.128
 725   return _mm_range_pd(__A, __B, 4);
 726 }
 727
 728 __m128d test_mm_mask_range_pd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
 729   // CHECK-LABEL: @test_mm_mask_range_pd
 730   // CHECK: @llvm.x86.avx512.mask.range.pd.128
 731   return _mm_mask_range_pd(__W, __U, __A, __B, 4);
 732 }
 733
 734 __m128d test_mm_maskz_range_pd(__mmask8 __U, __m128d __A, __m128d __B) {
 735   // CHECK-LABEL: @test_mm_maskz_range_pd
 736   // CHECK: @llvm.x86.avx512.mask.range.pd.128
 737   return _mm_maskz_range_pd(__U, __A, __B, 4);
 738 }
 739
 740 __m256d test_mm256_range_pd(__m256d __A, __m256d __B) {
 741   // CHECK-LABEL: @test_mm256_range_pd
 742   // CHECK: @llvm.x86.avx512.mask.range.pd.256
 743   return _mm256_range_pd(__A, __B, 4);
 744 }
 745
 746 __m256d test_mm256_mask_range_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
 747   // CHECK-LABEL: @test_mm256_mask_range_pd
 748   // CHECK: @llvm.x86.avx512.mask.range.pd.256
 749   return _mm256_mask_range_pd(__W, __U, __A, __B, 4);
 750 }
 751
 752 __m256d test_mm256_maskz_range_pd(__mmask8 __U, __m256d __A, __m256d __B) {
 753   // CHECK-LABEL: @test_mm256_maskz_range_pd
 754   // CHECK: @llvm.x86.avx512.mask.range.pd.256
 755   return _mm256_maskz_range_pd(__U, __A, __B, 4);
 756 }
 757
 758 __m128 test_mm_range_ps(__m128 __A, __m128 __B) {
 759   // CHECK-LABEL: @test_mm_range_ps
 760   // CHECK: @llvm.x86.avx512.mask.range.ps.128
 761   return _mm_range_ps(__A, __B, 4);
 762 }
 763
 764 __m128 test_mm_mask_range_ps(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
 765   // CHECK-LABEL: @test_mm_mask_range_ps
 766   // CHECK: @llvm.x86.avx512.mask.range.ps.128
 767   return _mm_mask_range_ps(__W, __U, __A, __B, 4);
 768 }
 769
 770 __m128 test_mm_maskz_range_ps(__mmask8 __U, __m128 __A, __m128 __B) {
 771   // CHECK-LABEL: @test_mm_maskz_range_ps
 772   // CHECK: @llvm.x86.avx512.mask.range.ps.128
 773   return _mm_maskz_range_ps(__U, __A, __B, 4);
 774 }
 775
 776 __m256 test_mm256_range_ps(__m256 __A, __m256 __B) {
 777   // CHECK-LABEL: @test_mm256_range_ps
 778   // CHECK: @llvm.x86.avx512.mask.range.ps.256
 779   return _mm256_range_ps(__A, __B, 4);
 780 }
 781
 782 __m256 test_mm256_mask_range_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
 783   // CHECK-LABEL: @test_mm256_mask_range_ps
 784   // CHECK: @llvm.x86.avx512.mask.range.ps.256
 785   return _mm256_mask_range_ps(__W, __U, __A, __B, 4);
 786 }
 787
 788 __m256 test_mm256_maskz_range_ps(__mmask8 __U, __m256 __A, __m256 __B) {
 789   // CHECK-LABEL: @test_mm256_maskz_range_ps
 790   // CHECK: @llvm.x86.avx512.mask.range.ps.256
 791   return _mm256_maskz_range_ps(__U, __A, __B, 4);
 792 }
 793
 794 __m128d test_mm_reduce_pd(__m128d __A) {
 795   // CHECK-LABEL: @test_mm_reduce_pd
 796   // CHECK: @llvm.x86.avx512.mask.reduce.pd.128
 797   return _mm_reduce_pd(__A, 4);
 798 }
 799
 800 __m128d test_mm_mask_reduce_pd(__m128d __W, __mmask8 __U, __m128d __A) {
 801   // CHECK-LABEL: @test_mm_mask_reduce_pd
 802   // CHECK: @llvm.x86.avx512.mask.reduce.pd.128
 803   return _mm_mask_reduce_pd(__W, __U, __A, 4);
 804 }
 805
 806 __m128d test_mm_maskz_reduce_pd(__mmask8 __U, __m128d __A) {
 807   // CHECK-LABEL: @test_mm_maskz_reduce_pd
 808   // CHECK: @llvm.x86.avx512.mask.reduce.pd.128
 809   return _mm_maskz_reduce_pd(__U, __A, 4);
 810 }
 811
 812 __m256d test_mm256_reduce_pd(__m256d __A) {
 813   // CHECK-LABEL: @test_mm256_reduce_pd
 814   // CHECK: @llvm.x86.avx512.mask.reduce.pd.256
 815   return _mm256_reduce_pd(__A, 4);
 816 }
 817
 818 __m256d test_mm256_mask_reduce_pd(__m256d __W, __mmask8 __U, __m256d __A) {
 819   // CHECK-LABEL: @test_mm256_mask_reduce_pd
 820   // CHECK: @llvm.x86.avx512.mask.reduce.pd.256
 821   return _mm256_mask_reduce_pd(__W, __U, __A, 4);
 822 }
 823
 824 __m256d test_mm256_maskz_reduce_pd(__mmask8 __U, __m256d __A) {
 825   // CHECK-LABEL: @test_mm256_maskz_reduce_pd
 826   // CHECK: @llvm.x86.avx512.mask.reduce.pd.256
 827   return _mm256_maskz_reduce_pd(__U, __A, 4);
 828 }
 829
 830 __m128 test_mm_reduce_ps(__m128 __A) {
 831   // CHECK-LABEL: @test_mm_reduce_ps
 832   // CHECK: @llvm.x86.avx512.mask.reduce.ps.128
 833   return _mm_reduce_ps(__A, 4);
 834 }
 835
 836 __m128 test_mm_mask_reduce_ps(__m128 __W, __mmask8 __U, __m128 __A) {
 837   // CHECK-LABEL: @test_mm_mask_reduce_ps
 838   // CHECK: @llvm.x86.avx512.mask.reduce.ps.128
 839   return _mm_mask_reduce_ps(__W, __U, __A, 4);
 840 }
 841
 842 __m128 test_mm_maskz_reduce_ps(__mmask8 __U, __m128 __A) {
 843   // CHECK-LABEL: @test_mm_maskz_reduce_ps
 844   // CHECK: @llvm.x86.avx512.mask.reduce.ps.128
 845   return _mm_maskz_reduce_ps(__U, __A, 4);
 846 }
 847
 848 __m256 test_mm256_reduce_ps(__m256 __A) {
 849   // CHECK-LABEL: @test_mm256_reduce_ps
 850   // CHECK: @llvm.x86.avx512.mask.reduce.ps.256
 851   return _mm256_reduce_ps(__A, 4);
 852 }
 853
 854 __m256 test_mm256_mask_reduce_ps(__m256 __W, __mmask8 __U, __m256 __A) {
 855   // CHECK-LABEL: @test_mm256_mask_reduce_ps
 856   // CHECK: @llvm.x86.avx512.mask.reduce.ps.256
 857   return _mm256_mask_reduce_ps(__W, __U, __A, 4);
 858 }
 859
 860 __m256 test_mm256_maskz_reduce_ps(__mmask8 __U, __m256 __A) {
 861   // CHECK-LABEL: @test_mm256_maskz_reduce_ps
 862   // CHECK: @llvm.x86.avx512.mask.reduce.ps.256
 863   return _mm256_maskz_reduce_ps(__U, __A, 4);
 864 }
 865
 866 __mmask8 test_mm_movepi32_mask(__m128i __A) {
 867   // CHECK-LABEL: @test_mm_movepi32_mask
 868   // CHECK: [[CMP:%.*]] = icmp slt <4 x i32> %{{.*}}, zeroinitializer
 869   // CHECK: [[SHUF:%.*]] = shufflevector <4 x i1> [[CMP]], <4 x i1> zeroinitializer, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
 870   return _mm_movepi32_mask(__A);
 871 }
 872
 873 __mmask8 test_mm256_movepi32_mask(__m256i __A) {
 874   // CHECK-LABEL: @test_mm256_movepi32_mask
 875   // CHECK: [[CMP:%.*]] = icmp slt <8 x i32> %{{.*}}, zeroinitializer
 876   return _mm256_movepi32_mask(__A);
 877 }
 878
 879 __m128i test_mm_movm_epi32(__mmask8 __A) {
 880   // CHECK-LABEL: @test_mm_movm_epi32
 881   // CHECK: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
 882   // CHECK: %extract.i = shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 883   // CHECK: %vpmovm2.i = sext <4 x i1> %extract.i to <4 x i32>
 884   return _mm_movm_epi32(__A);
 885 }
 886
 887 __m256i test_mm256_movm_epi32(__mmask8 __A) {
 888   // CHECK-LABEL: @test_mm256_movm_epi32
 889   // CHECK: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
 890   // CHECK: %vpmovm2.i = sext <8 x i1> %{{.*}} to <8 x i32>
 891   return _mm256_movm_epi32(__A);
 892 }
 893
 894 __m128i test_mm_movm_epi64(__mmask8 __A) {
 895   // CHECK-LABEL: @test_mm_movm_epi64
 896   // CHECK: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
 897   // CHECK: %extract.i = shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <2 x i32> <i32 0, i32 1>
 898   // CHECK: %vpmovm2.i = sext <2 x i1> %extract.i to <2 x i64>
 899   return _mm_movm_epi64(__A);
 900 }
 901
 902 __m256i test_mm256_movm_epi64(__mmask8 __A) {
 903   // CHECK-LABEL: @test_mm256_movm_epi64
 904   // CHECK: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
 905   // CHECK: %extract.i = shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 906   // CHECK: %vpmovm2.i = sext <4 x i1> %extract.i to <4 x i64>
 907   return _mm256_movm_epi64(__A);
 908 }
 909
 910 __mmask8 test_mm_movepi64_mask(__m128i __A) {
 911   // CHECK-LABEL: @test_mm_movepi64_mask
 912   // CHECK: [[CMP:%.*]] = icmp slt <2 x i64> %{{.*}}, zeroinitializer
 913   // CHECK: [[SHUF:%.*]] = shufflevector <2 x i1> [[CMP]], <2 x i1> zeroinitializer, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 2, i32 3, i32 2, i32 3>
 914   return _mm_movepi64_mask(__A);
 915 }
 916
 917 __mmask8 test_mm256_movepi64_mask(__m256i __A) {
 918   // CHECK-LABEL: @test_mm256_movepi64_mask
 919   // CHECK: [[CMP:%.*]] = icmp slt <4 x i64> %{{.*}}, zeroinitializer
 920   // CHECK: [[SHUF:%.*]] = shufflevector <4 x i1> [[CMP]], <4 x i1> zeroinitializer, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
 921   return _mm256_movepi64_mask(__A);
 922 }
 923
 924
 925 __m256 test_mm256_broadcast_f32x2(__m128 __A) {
 926   // CHECK-LABEL: @test_mm256_broadcast_f32x2
 927   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
 928   return _mm256_broadcast_f32x2(__A);
 929 }
 930
 931 __m256 test_mm256_mask_broadcast_f32x2(__m256 __O, __mmask8 __M, __m128 __A) {
 932   // CHECK-LABEL: @test_mm256_mask_broadcast_f32x2
 933   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
 934   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 935   return _mm256_mask_broadcast_f32x2(__O, __M, __A);
 936 }
 937
 938 __m256 test_mm256_maskz_broadcast_f32x2(__mmask8 __M, __m128 __A) {
 939   // CHECK-LABEL: @test_mm256_maskz_broadcast_f32x2
 940   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
 941   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 942   return _mm256_maskz_broadcast_f32x2(__M, __A);
 943 }
 944
 945 __m256d test_mm256_broadcast_f64x2(double const* __A) {
 946   // CHECK-LABEL: @test_mm256_broadcast_f64x2
 947   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
 948   return _mm256_broadcast_f64x2(_mm_loadu_pd(__A));
 949 }
 950
 951 __m256d test_mm256_mask_broadcast_f64x2(__m256d __O, __mmask8 __M, double const* __A) {
 952   // CHECK-LABEL: @test_mm256_mask_broadcast_f64x2
 953   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
 954   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
 955   return _mm256_mask_broadcast_f64x2(__O, __M, _mm_loadu_pd(__A));
 956 }
 957
 958 __m256d test_mm256_maskz_broadcast_f64x2(__mmask8 __M, double const* __A) {
 959   // CHECK-LABEL: @test_mm256_maskz_broadcast_f64x2
 960   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
 961   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
 962   return _mm256_maskz_broadcast_f64x2(__M, _mm_loadu_pd(__A));
 963 }
 964
 965 __m128i test_mm_broadcast_i32x2(__m128i __A) {
 966   // CHECK-LABEL: @test_mm_broadcast_i32x2
 967   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
 968   return _mm_broadcast_i32x2(__A);
 969 }
 970
 971 __m128i test_mm_mask_broadcast_i32x2(__m128i __O, __mmask8 __M, __m128i __A) {
 972   // CHECK-LABEL: @test_mm_mask_broadcast_i32x2
 973   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
 974   // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 975   return _mm_mask_broadcast_i32x2(__O, __M, __A);
 976 }
 977
 978 __m128i test_mm_maskz_broadcast_i32x2(__mmask8 __M, __m128i __A) {
 979   // CHECK-LABEL: @test_mm_maskz_broadcast_i32x2
 980   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
 981   // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
 982   return _mm_maskz_broadcast_i32x2(__M, __A);
 983 }
 984
 985 __m256i test_mm256_broadcast_i32x2(__m128i __A) {
 986   // CHECK-LABEL: @test_mm256_broadcast_i32x2
 987   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
 988   return _mm256_broadcast_i32x2(__A);
 989 }
 990
 991 __m256i test_mm256_mask_broadcast_i32x2(__m256i __O, __mmask8 __M, __m128i __A) {
 992   // CHECK-LABEL: @test_mm256_mask_broadcast_i32x2
 993   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
 994   // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
 995   return _mm256_mask_broadcast_i32x2(__O, __M, __A);
 996 }
 997
 998 __m256i test_mm256_maskz_broadcast_i32x2(__mmask8 __M, __m128i __A) {
 999   // CHECK-LABEL: @test_mm256_maskz_broadcast_i32x2
1000   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
1001   // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
1002   return _mm256_maskz_broadcast_i32x2(__M, __A);
1003 }
1004
1005 __m256i test_mm256_broadcast_i64x2(__m128i const* __A) {
1006   // CHECK-LABEL: @test_mm256_broadcast_i64x2
1007   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
1008   return _mm256_broadcast_i64x2(_mm_loadu_si128(__A));
1009 }
1010
1011 __m256i test_mm256_mask_broadcast_i64x2(__m256i __O, __mmask8 __M, __m128i const* __A) {
1012   // CHECK-LABEL: @test_mm256_mask_broadcast_i64x2
1013   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
1014   // CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
1015   return _mm256_mask_broadcast_i64x2(__O, __M, _mm_loadu_si128(__A));
1016 }
1017
1018 __m256i test_mm256_maskz_broadcast_i64x2(__mmask8 __M, __m128i const* __A) {
1019   // CHECK-LABEL: @test_mm256_maskz_broadcast_i64x2
1020   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
1021   // CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
1022   return _mm256_maskz_broadcast_i64x2(__M, _mm_loadu_si128(__A));
1023 }
1024
1025 __m128d test_mm256_extractf64x2_pd(__m256d __A) {
1026   // CHECK-LABEL: @test_mm256_extractf64x2_pd
1027   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> poison, <2 x i32> <i32 2, i32 3>
1028   return _mm256_extractf64x2_pd(__A, 1);
1029 }
1030
1031 __m128d test_mm256_mask_extractf64x2_pd(__m128d __W, __mmask8 __U, __m256d __A) {
1032   // CHECK-LABEL: @test_mm256_mask_extractf64x2_pd
1033   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> poison, <2 x i32> <i32 2, i32 3>
1034   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
1035   return _mm256_mask_extractf64x2_pd(__W, __U, __A, 1);
1036 }
1037
1038 __m128d test_mm256_maskz_extractf64x2_pd(__mmask8 __U, __m256d __A) {
1039   // CHECK-LABEL: @test_mm256_maskz_extractf64x2_pd
1040   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> poison, <2 x i32> <i32 2, i32 3>
1041   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
1042   return _mm256_maskz_extractf64x2_pd(__U, __A, 1);
1043 }
1044
1045 __m128i test_mm256_extracti64x2_epi64(__m256i __A) {
1046   // CHECK-LABEL: @test_mm256_extracti64x2_epi64
1047   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> poison, <2 x i32> <i32 2, i32 3>
1048   return _mm256_extracti64x2_epi64(__A, 1);
1049 }
1050
1051 __m128i test_mm256_mask_extracti64x2_epi64(__m128i __W, __mmask8 __U, __m256i __A) {
1052   // CHECK-LABEL: @test_mm256_mask_extracti64x2_epi64
1053   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> poison, <2 x i32> <i32 2, i32 3>
1054   // CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
1055   return _mm256_mask_extracti64x2_epi64(__W, __U, __A, 1);
1056 }
1057
1058 __m128i test_mm256_maskz_extracti64x2_epi64(__mmask8 __U, __m256i __A) {
1059   // CHECK-LABEL: @test_mm256_maskz_extracti64x2_epi64
1060   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> poison, <2 x i32> <i32 2, i32 3>
1061   // CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
1062   return _mm256_maskz_extracti64x2_epi64(__U, __A, 1);
1063 }
1064
1065 __m256d test_mm256_insertf64x2(__m256d __A, __m128d __B) {
1066   // CHECK-LABEL: @test_mm256_insertf64x2
1067   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
1068   return _mm256_insertf64x2(__A, __B, 1);
1069 }
1070
1071 __m256d test_mm256_mask_insertf64x2(__m256d __W, __mmask8 __U, __m256d __A, __m128d __B) {
1072   // CHECK-LABEL: @test_mm256_mask_insertf64x2
1073   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
1074   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
1075   return _mm256_mask_insertf64x2(__W, __U, __A, __B, 1);
1076 }
1077
1078 __m256d test_mm256_maskz_insertf64x2(__mmask8 __U, __m256d __A, __m128d __B) {
1079   // CHECK-LABEL: @test_mm256_maskz_insertf64x2
1080   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
1081   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
1082   return _mm256_maskz_insertf64x2(__U, __A, __B, 1);
1083 }
1084
1085 __m256i test_mm256_inserti64x2(__m256i __A, __m128i __B) {
1086   // CHECK-LABEL: @test_mm256_inserti64x2
1087   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
1088   return _mm256_inserti64x2(__A, __B, 1);
1089 }
1090
1091 __m256i test_mm256_mask_inserti64x2(__m256i __W, __mmask8 __U, __m256i __A, __m128i __B) {
1092   // CHECK-LABEL: @test_mm256_mask_inserti64x2
1093   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
1094   // CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
1095   return _mm256_mask_inserti64x2(__W, __U, __A, __B, 1);
1096 }
1097
1098 __m256i test_mm256_maskz_inserti64x2(__mmask8 __U, __m256i __A, __m128i __B) {
1099   // CHECK-LABEL: @test_mm256_maskz_inserti64x2
1100   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
1101   // CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
1102   return _mm256_maskz_inserti64x2(__U, __A, __B, 1);
1103 }
1104
1105 __mmask8 test_mm_mask_fpclass_pd_mask(__mmask8 __U, __m128d __A) {
1106   // CHECK-LABEL: @test_mm_mask_fpclass_pd_mask
1107   // CHECK: @llvm.x86.avx512.fpclass.pd.128
1108   return _mm_mask_fpclass_pd_mask(__U, __A, 2);
1109 }
1110
1111 __mmask8 test_mm_fpclass_pd_mask(__m128d __A) {
1112   // CHECK-LABEL: @test_mm_fpclass_pd_mask
1113   // CHECK: @llvm.x86.avx512.fpclass.pd.128
1114   return _mm_fpclass_pd_mask(__A, 2);
1115 }
1116
1117 __mmask8 test_mm256_mask_fpclass_pd_mask(__mmask8 __U, __m256d __A) {
1118   // CHECK-LABEL: @test_mm256_mask_fpclass_pd_mask
1119   // CHECK: @llvm.x86.avx512.fpclass.pd.256
1120   return _mm256_mask_fpclass_pd_mask(__U, __A, 2);
1121 }
1122
1123 __mmask8 test_mm256_fpclass_pd_mask(__m256d __A) {
1124   // CHECK-LABEL: @test_mm256_fpclass_pd_mask
1125   // CHECK: @llvm.x86.avx512.fpclass.pd.256
1126   return _mm256_fpclass_pd_mask(__A, 2);
1127 }
1128
1129 __mmask8 test_mm_mask_fpclass_ps_mask(__mmask8 __U, __m128 __A) {
1130   // CHECK-LABEL: @test_mm_mask_fpclass_ps_mask
1131   // CHECK: @llvm.x86.avx512.fpclass.ps.128
1132   return _mm_mask_fpclass_ps_mask(__U, __A, 2);
1133 }
1134
1135 __mmask8 test_mm_fpclass_ps_mask(__m128 __A) {
1136   // CHECK-LABEL: @test_mm_fpclass_ps_mask
1137   // CHECK: @llvm.x86.avx512.fpclass.ps.128
1138   return _mm_fpclass_ps_mask(__A, 2);
1139 }
1140
1141 __mmask8 test_mm256_mask_fpclass_ps_mask(__mmask8 __U, __m256 __A) {
1142   // CHECK-LABEL: @test_mm256_mask_fpclass_ps_mask
1143   // CHECK: @llvm.x86.avx512.fpclass.ps.256
1144   return _mm256_mask_fpclass_ps_mask(__U, __A, 2);
1145 }
1146
1147 __mmask8 test_mm256_fpclass_ps_mask(__m256 __A) {
1148   // CHECK-LABEL: @test_mm256_fpclass_ps_mask
1149   // CHECK: @llvm.x86.avx512.fpclass.ps.256
1150   return _mm256_fpclass_ps_mask(__A, 2);
1151 }