test/CodeGen/avx512vldq-builtins.c

   1 // RUN: %clang_cc1 -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> %{{.*}}, <i64 -1, i64 -1, i64 -1, 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> %{{.*}}, <i64 -1, i64 -1, i64 -1, 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> %{{.*}}, <i64 -1, 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> %{{.*}}, <i64 -1, 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> %{{.*}}, <i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, 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> %{{.*}}, <i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, 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> %{{.*}}, <i32 -1, i32 -1, i32 -1, 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> %{{.*}}, <i32 -1, i32 -1, i32 -1, 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: @llvm.x86.avx512.mask.cvtqq2ps.256
 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: @llvm.x86.avx512.mask.cvtqq2ps.256
 489   return _mm256_mask_cvtepi64_ps(__W, __U, __A);
 490 }
 491
 492 __m128 test_mm256_maskz_cvtepi64_ps(__mmask8 __U, __m256i __A) {
 493   // CHECK-LABEL: @test_mm256_maskz_cvtepi64_ps
 494   // CHECK: @llvm.x86.avx512.mask.cvtqq2ps.256
 495   return _mm256_maskz_cvtepi64_ps(__U, __A);
 496 }
 497
 498 __m128i test_mm_cvttpd_epi64(__m128d __A) {
 499   // CHECK-LABEL: @test_mm_cvttpd_epi64
 500   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.128
 501   return _mm_cvttpd_epi64(__A);
 502 }
 503
 504 __m128i test_mm_mask_cvttpd_epi64(__m128i __W, __mmask8 __U, __m128d __A) {
 505   // CHECK-LABEL: @test_mm_mask_cvttpd_epi64
 506   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.128
 507   return _mm_mask_cvttpd_epi64(__W, __U, __A);
 508 }
 509
 510 __m128i test_mm_maskz_cvttpd_epi64(__mmask8 __U, __m128d __A) {
 511   // CHECK-LABEL: @test_mm_maskz_cvttpd_epi64
 512   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.128
 513   return _mm_maskz_cvttpd_epi64(__U, __A);
 514 }
 515
 516 __m256i test_mm256_cvttpd_epi64(__m256d __A) {
 517   // CHECK-LABEL: @test_mm256_cvttpd_epi64
 518   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.256
 519   return _mm256_cvttpd_epi64(__A);
 520 }
 521
 522 __m256i test_mm256_mask_cvttpd_epi64(__m256i __W, __mmask8 __U, __m256d __A) {
 523   // CHECK-LABEL: @test_mm256_mask_cvttpd_epi64
 524   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.256
 525   return _mm256_mask_cvttpd_epi64(__W, __U, __A);
 526 }
 527
 528 __m256i test_mm256_maskz_cvttpd_epi64(__mmask8 __U, __m256d __A) {
 529   // CHECK-LABEL: @test_mm256_maskz_cvttpd_epi64
 530   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.256
 531   return _mm256_maskz_cvttpd_epi64(__U, __A);
 532 }
 533
 534 __m128i test_mm_cvttpd_epu64(__m128d __A) {
 535   // CHECK-LABEL: @test_mm_cvttpd_epu64
 536   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.128
 537   return _mm_cvttpd_epu64(__A);
 538 }
 539
 540 __m128i test_mm_mask_cvttpd_epu64(__m128i __W, __mmask8 __U, __m128d __A) {
 541   // CHECK-LABEL: @test_mm_mask_cvttpd_epu64
 542   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.128
 543   return _mm_mask_cvttpd_epu64(__W, __U, __A);
 544 }
 545
 546 __m128i test_mm_maskz_cvttpd_epu64(__mmask8 __U, __m128d __A) {
 547   // CHECK-LABEL: @test_mm_maskz_cvttpd_epu64
 548   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.128
 549   return _mm_maskz_cvttpd_epu64(__U, __A);
 550 }
 551
 552 __m256i test_mm256_cvttpd_epu64(__m256d __A) {
 553   // CHECK-LABEL: @test_mm256_cvttpd_epu64
 554   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.256
 555   return _mm256_cvttpd_epu64(__A);
 556 }
 557
 558 __m256i test_mm256_mask_cvttpd_epu64(__m256i __W, __mmask8 __U, __m256d __A) {
 559   // CHECK-LABEL: @test_mm256_mask_cvttpd_epu64
 560   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.256
 561   return _mm256_mask_cvttpd_epu64(__W, __U, __A);
 562 }
 563
 564 __m256i test_mm256_maskz_cvttpd_epu64(__mmask8 __U, __m256d __A) {
 565   // CHECK-LABEL: @test_mm256_maskz_cvttpd_epu64
 566   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.256
 567   return _mm256_maskz_cvttpd_epu64(__U, __A);
 568 }
 569
 570 __m128i test_mm_cvttps_epi64(__m128 __A) {
 571   // CHECK-LABEL: @test_mm_cvttps_epi64
 572   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.128
 573   return _mm_cvttps_epi64(__A);
 574 }
 575
 576 __m128i test_mm_mask_cvttps_epi64(__m128i __W, __mmask8 __U, __m128 __A) {
 577   // CHECK-LABEL: @test_mm_mask_cvttps_epi64
 578   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.128
 579   return _mm_mask_cvttps_epi64(__W, __U, __A);
 580 }
 581
 582 __m128i test_mm_maskz_cvttps_epi64(__mmask8 __U, __m128 __A) {
 583   // CHECK-LABEL: @test_mm_maskz_cvttps_epi64
 584   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.128
 585   return _mm_maskz_cvttps_epi64(__U, __A);
 586 }
 587
 588 __m256i test_mm256_cvttps_epi64(__m128 __A) {
 589   // CHECK-LABEL: @test_mm256_cvttps_epi64
 590   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.256
 591   return _mm256_cvttps_epi64(__A);
 592 }
 593
 594 __m256i test_mm256_mask_cvttps_epi64(__m256i __W, __mmask8 __U, __m128 __A) {
 595   // CHECK-LABEL: @test_mm256_mask_cvttps_epi64
 596   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.256
 597   return _mm256_mask_cvttps_epi64(__W, __U, __A);
 598 }
 599
 600 __m256i test_mm256_maskz_cvttps_epi64(__mmask8 __U, __m128 __A) {
 601   // CHECK-LABEL: @test_mm256_maskz_cvttps_epi64
 602   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.256
 603   return _mm256_maskz_cvttps_epi64(__U, __A);
 604 }
 605
 606 __m128i test_mm_cvttps_epu64(__m128 __A) {
 607   // CHECK-LABEL: @test_mm_cvttps_epu64
 608   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.128
 609   return _mm_cvttps_epu64(__A);
 610 }
 611
 612 __m128i test_mm_mask_cvttps_epu64(__m128i __W, __mmask8 __U, __m128 __A) {
 613   // CHECK-LABEL: @test_mm_mask_cvttps_epu64
 614   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.128
 615   return _mm_mask_cvttps_epu64(__W, __U, __A);
 616 }
 617
 618 __m128i test_mm_maskz_cvttps_epu64(__mmask8 __U, __m128 __A) {
 619   // CHECK-LABEL: @test_mm_maskz_cvttps_epu64
 620   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.128
 621   return _mm_maskz_cvttps_epu64(__U, __A);
 622 }
 623
 624 __m256i test_mm256_cvttps_epu64(__m128 __A) {
 625   // CHECK-LABEL: @test_mm256_cvttps_epu64
 626   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.256
 627   return _mm256_cvttps_epu64(__A);
 628 }
 629
 630 __m256i test_mm256_mask_cvttps_epu64(__m256i __W, __mmask8 __U, __m128 __A) {
 631   // CHECK-LABEL: @test_mm256_mask_cvttps_epu64
 632   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.256
 633   return _mm256_mask_cvttps_epu64(__W, __U, __A);
 634 }
 635
 636 __m256i test_mm256_maskz_cvttps_epu64(__mmask8 __U, __m128 __A) {
 637   // CHECK-LABEL: @test_mm256_maskz_cvttps_epu64
 638   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.256
 639   return _mm256_maskz_cvttps_epu64(__U, __A);
 640 }
 641
 642 __m128d test_mm_cvtepu64_pd(__m128i __A) {
 643   // CHECK-LABEL: @test_mm_cvtepu64_pd
 644   // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
 645   return _mm_cvtepu64_pd(__A);
 646 }
 647
 648 __m128d test_mm_mask_cvtepu64_pd(__m128d __W, __mmask8 __U, __m128i __A) {
 649   // CHECK-LABEL: @test_mm_mask_cvtepu64_pd
 650   // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
 651   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
 652   return _mm_mask_cvtepu64_pd(__W, __U, __A);
 653 }
 654
 655 __m128d test_mm_maskz_cvtepu64_pd(__mmask8 __U, __m128i __A) {
 656   // CHECK-LABEL: @test_mm_maskz_cvtepu64_pd
 657   // CHECK: uitofp <2 x i64> %{{.*}} to <2 x double>
 658   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
 659   return _mm_maskz_cvtepu64_pd(__U, __A);
 660 }
 661
 662 __m256d test_mm256_cvtepu64_pd(__m256i __A) {
 663   // CHECK-LABEL: @test_mm256_cvtepu64_pd
 664   // CHECK: uitofp <4 x i64> %{{.*}} to <4 x double>
 665   return _mm256_cvtepu64_pd(__A);
 666 }
 667
 668 __m256d test_mm256_mask_cvtepu64_pd(__m256d __W, __mmask8 __U, __m256i __A) {
 669   // CHECK-LABEL: @test_mm256_mask_cvtepu64_pd
 670   // CHECK: uitofp <4 x i64> %{{.*}} to <4 x double>
 671   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
 672   return _mm256_mask_cvtepu64_pd(__W, __U, __A);
 673 }
 674
 675 __m256d test_mm256_maskz_cvtepu64_pd(__mmask8 __U, __m256i __A) {
 676   // CHECK-LABEL: @test_mm256_maskz_cvtepu64_pd
 677   // CHECK: uitofp <4 x i64> %{{.*}} to <4 x double>
 678   // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}
 679   return _mm256_maskz_cvtepu64_pd(__U, __A);
 680 }
 681
 682 __m128 test_mm_cvtepu64_ps(__m128i __A) {
 683   // CHECK-LABEL: @test_mm_cvtepu64_ps
 684   // CHECK: @llvm.x86.avx512.mask.cvtuqq2ps.128
 685   return _mm_cvtepu64_ps(__A);
 686 }
 687
 688 __m128 test_mm_mask_cvtepu64_ps(__m128 __W, __mmask8 __U, __m128i __A) {
 689   // CHECK-LABEL: @test_mm_mask_cvtepu64_ps
 690   // CHECK: @llvm.x86.avx512.mask.cvtuqq2ps.128
 691   return _mm_mask_cvtepu64_ps(__W, __U, __A);
 692 }
 693
 694 __m128 test_mm_maskz_cvtepu64_ps(__mmask8 __U, __m128i __A) {
 695   // CHECK-LABEL: @test_mm_maskz_cvtepu64_ps
 696   // CHECK: @llvm.x86.avx512.mask.cvtuqq2ps.128
 697   return _mm_maskz_cvtepu64_ps(__U, __A);
 698 }
 699
 700 __m128 test_mm256_cvtepu64_ps(__m256i __A) {
 701   // CHECK-LABEL: @test_mm256_cvtepu64_ps
 702   // CHECK: @llvm.x86.avx512.mask.cvtuqq2ps.256
 703   return _mm256_cvtepu64_ps(__A);
 704 }
 705
 706 __m128 test_mm256_mask_cvtepu64_ps(__m128 __W, __mmask8 __U, __m256i __A) {
 707   // CHECK-LABEL: @test_mm256_mask_cvtepu64_ps
 708   // CHECK: @llvm.x86.avx512.mask.cvtuqq2ps.256
 709   return _mm256_mask_cvtepu64_ps(__W, __U, __A);
 710 }
 711
 712 __m128 test_mm256_maskz_cvtepu64_ps(__mmask8 __U, __m256i __A) {
 713   // CHECK-LABEL: @test_mm256_maskz_cvtepu64_ps
 714   // CHECK: @llvm.x86.avx512.mask.cvtuqq2ps.256
 715   return _mm256_maskz_cvtepu64_ps(__U, __A);
 716 }
 717
 718 __m128d test_mm_range_pd(__m128d __A, __m128d __B) {
 719   // CHECK-LABEL: @test_mm_range_pd
 720   // CHECK: @llvm.x86.avx512.mask.range.pd.128
 721   return _mm_range_pd(__A, __B, 4);
 722 }
 723
 724 __m128d test_mm_mask_range_pd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
 725   // CHECK-LABEL: @test_mm_mask_range_pd
 726   // CHECK: @llvm.x86.avx512.mask.range.pd.128
 727   return _mm_mask_range_pd(__W, __U, __A, __B, 4);
 728 }
 729
 730 __m128d test_mm_maskz_range_pd(__mmask8 __U, __m128d __A, __m128d __B) {
 731   // CHECK-LABEL: @test_mm_maskz_range_pd
 732   // CHECK: @llvm.x86.avx512.mask.range.pd.128
 733   return _mm_maskz_range_pd(__U, __A, __B, 4);
 734 }
 735
 736 __m256d test_mm256_range_pd(__m256d __A, __m256d __B) {
 737   // CHECK-LABEL: @test_mm256_range_pd
 738   // CHECK: @llvm.x86.avx512.mask.range.pd.256
 739   return _mm256_range_pd(__A, __B, 4);
 740 }
 741
 742 __m256d test_mm256_mask_range_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
 743   // CHECK-LABEL: @test_mm256_mask_range_pd
 744   // CHECK: @llvm.x86.avx512.mask.range.pd.256
 745   return _mm256_mask_range_pd(__W, __U, __A, __B, 4);
 746 }
 747
 748 __m256d test_mm256_maskz_range_pd(__mmask8 __U, __m256d __A, __m256d __B) {
 749   // CHECK-LABEL: @test_mm256_maskz_range_pd
 750   // CHECK: @llvm.x86.avx512.mask.range.pd.256
 751   return _mm256_maskz_range_pd(__U, __A, __B, 4);
 752 }
 753
 754 __m128 test_mm_range_ps(__m128 __A, __m128 __B) {
 755   // CHECK-LABEL: @test_mm_range_ps
 756   // CHECK: @llvm.x86.avx512.mask.range.ps.128
 757   return _mm_range_ps(__A, __B, 4);
 758 }
 759
 760 __m128 test_mm_mask_range_ps(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
 761   // CHECK-LABEL: @test_mm_mask_range_ps
 762   // CHECK: @llvm.x86.avx512.mask.range.ps.128
 763   return _mm_mask_range_ps(__W, __U, __A, __B, 4);
 764 }
 765
 766 __m128 test_mm_maskz_range_ps(__mmask8 __U, __m128 __A, __m128 __B) {
 767   // CHECK-LABEL: @test_mm_maskz_range_ps
 768   // CHECK: @llvm.x86.avx512.mask.range.ps.128
 769   return _mm_maskz_range_ps(__U, __A, __B, 4);
 770 }
 771
 772 __m256 test_mm256_range_ps(__m256 __A, __m256 __B) {
 773   // CHECK-LABEL: @test_mm256_range_ps
 774   // CHECK: @llvm.x86.avx512.mask.range.ps.256
 775   return _mm256_range_ps(__A, __B, 4);
 776 }
 777
 778 __m256 test_mm256_mask_range_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
 779   // CHECK-LABEL: @test_mm256_mask_range_ps
 780   // CHECK: @llvm.x86.avx512.mask.range.ps.256
 781   return _mm256_mask_range_ps(__W, __U, __A, __B, 4);
 782 }
 783
 784 __m256 test_mm256_maskz_range_ps(__mmask8 __U, __m256 __A, __m256 __B) {
 785   // CHECK-LABEL: @test_mm256_maskz_range_ps
 786   // CHECK: @llvm.x86.avx512.mask.range.ps.256
 787   return _mm256_maskz_range_ps(__U, __A, __B, 4);
 788 }
 789
 790 __m128d test_mm_reduce_pd(__m128d __A) {
 791   // CHECK-LABEL: @test_mm_reduce_pd
 792   // CHECK: @llvm.x86.avx512.mask.reduce.pd.128
 793   return _mm_reduce_pd(__A, 4);
 794 }
 795
 796 __m128d test_mm_mask_reduce_pd(__m128d __W, __mmask8 __U, __m128d __A) {
 797   // CHECK-LABEL: @test_mm_mask_reduce_pd
 798   // CHECK: @llvm.x86.avx512.mask.reduce.pd.128
 799   return _mm_mask_reduce_pd(__W, __U, __A, 4);
 800 }
 801
 802 __m128d test_mm_maskz_reduce_pd(__mmask8 __U, __m128d __A) {
 803   // CHECK-LABEL: @test_mm_maskz_reduce_pd
 804   // CHECK: @llvm.x86.avx512.mask.reduce.pd.128
 805   return _mm_maskz_reduce_pd(__U, __A, 4);
 806 }
 807
 808 __m256d test_mm256_reduce_pd(__m256d __A) {
 809   // CHECK-LABEL: @test_mm256_reduce_pd
 810   // CHECK: @llvm.x86.avx512.mask.reduce.pd.256
 811   return _mm256_reduce_pd(__A, 4);
 812 }
 813
 814 __m256d test_mm256_mask_reduce_pd(__m256d __W, __mmask8 __U, __m256d __A) {
 815   // CHECK-LABEL: @test_mm256_mask_reduce_pd
 816   // CHECK: @llvm.x86.avx512.mask.reduce.pd.256
 817   return _mm256_mask_reduce_pd(__W, __U, __A, 4);
 818 }
 819
 820 __m256d test_mm256_maskz_reduce_pd(__mmask8 __U, __m256d __A) {
 821   // CHECK-LABEL: @test_mm256_maskz_reduce_pd
 822   // CHECK: @llvm.x86.avx512.mask.reduce.pd.256
 823   return _mm256_maskz_reduce_pd(__U, __A, 4);
 824 }
 825
 826 __m128 test_mm_reduce_ps(__m128 __A) {
 827   // CHECK-LABEL: @test_mm_reduce_ps
 828   // CHECK: @llvm.x86.avx512.mask.reduce.ps.128
 829   return _mm_reduce_ps(__A, 4);
 830 }
 831
 832 __m128 test_mm_mask_reduce_ps(__m128 __W, __mmask8 __U, __m128 __A) {
 833   // CHECK-LABEL: @test_mm_mask_reduce_ps
 834   // CHECK: @llvm.x86.avx512.mask.reduce.ps.128
 835   return _mm_mask_reduce_ps(__W, __U, __A, 4);
 836 }
 837
 838 __m128 test_mm_maskz_reduce_ps(__mmask8 __U, __m128 __A) {
 839   // CHECK-LABEL: @test_mm_maskz_reduce_ps
 840   // CHECK: @llvm.x86.avx512.mask.reduce.ps.128
 841   return _mm_maskz_reduce_ps(__U, __A, 4);
 842 }
 843
 844 __m256 test_mm256_reduce_ps(__m256 __A) {
 845   // CHECK-LABEL: @test_mm256_reduce_ps
 846   // CHECK: @llvm.x86.avx512.mask.reduce.ps.256
 847   return _mm256_reduce_ps(__A, 4);
 848 }
 849
 850 __m256 test_mm256_mask_reduce_ps(__m256 __W, __mmask8 __U, __m256 __A) {
 851   // CHECK-LABEL: @test_mm256_mask_reduce_ps
 852   // CHECK: @llvm.x86.avx512.mask.reduce.ps.256
 853   return _mm256_mask_reduce_ps(__W, __U, __A, 4);
 854 }
 855
 856 __m256 test_mm256_maskz_reduce_ps(__mmask8 __U, __m256 __A) {
 857   // CHECK-LABEL: @test_mm256_maskz_reduce_ps
 858   // CHECK: @llvm.x86.avx512.mask.reduce.ps.256
 859   return _mm256_maskz_reduce_ps(__U, __A, 4);
 860 }
 861
 862 __mmask8 test_mm_movepi32_mask(__m128i __A) {
 863   // CHECK-LABEL: @test_mm_movepi32_mask
 864   // CHECK: [[CMP:%.*]] = icmp slt <4 x i32> %{{.*}}, zeroinitializer
 865   // 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>
 866   // CHECK: bitcast <8 x i1> [[SHUF]] to i8
 867   return _mm_movepi32_mask(__A);
 868 }
 869
 870 __mmask8 test_mm256_movepi32_mask(__m256i __A) {
 871   // CHECK-LABEL: @test_mm256_movepi32_mask
 872   // CHECK: [[CMP:%.*]] = icmp slt <8 x i32> %{{.*}}, zeroinitializer
 873   // CHECK: bitcast <8 x i1> [[CMP]] to i8
 874   return _mm256_movepi32_mask(__A);
 875 }
 876
 877 __m128i test_mm_movm_epi32(__mmask8 __A) {
 878   // CHECK-LABEL: @test_mm_movm_epi32
 879   // CHECK: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
 880   // CHECK: %extract.i = shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 881   // CHECK: %vpmovm2.i = sext <4 x i1> %extract.i to <4 x i32>
 882   return _mm_movm_epi32(__A);
 883 }
 884
 885 __m256i test_mm256_movm_epi32(__mmask8 __A) {
 886   // CHECK-LABEL: @test_mm256_movm_epi32
 887   // CHECK: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
 888   // CHECK: %vpmovm2.i = sext <8 x i1> %{{.*}} to <8 x i32>
 889   return _mm256_movm_epi32(__A);
 890 }
 891
 892 __m128i test_mm_movm_epi64(__mmask8 __A) {
 893   // CHECK-LABEL: @test_mm_movm_epi64
 894   // CHECK: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
 895   // CHECK: %extract.i = shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <2 x i32> <i32 0, i32 1>
 896   // CHECK: %vpmovm2.i = sext <2 x i1> %extract.i to <2 x i64>
 897   return _mm_movm_epi64(__A);
 898 }
 899
 900 __m256i test_mm256_movm_epi64(__mmask8 __A) {
 901   // CHECK-LABEL: @test_mm256_movm_epi64
 902   // CHECK: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
 903   // CHECK: %extract.i = shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 904   // CHECK: %vpmovm2.i = sext <4 x i1> %extract.i to <4 x i64>
 905   return _mm256_movm_epi64(__A);
 906 }
 907
 908 __mmask8 test_mm_movepi64_mask(__m128i __A) {
 909   // CHECK-LABEL: @test_mm_movepi64_mask
 910   // CHECK: [[CMP:%.*]] = icmp slt <2 x i64> %{{.*}}, zeroinitializer
 911   // 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>
 912   // CHECK: bitcast <8 x i1> [[SHUF]] to i8
 913   return _mm_movepi64_mask(__A);
 914 }
 915
 916 __mmask8 test_mm256_movepi64_mask(__m256i __A) {
 917   // CHECK-LABEL: @test_mm256_movepi64_mask
 918   // CHECK: [[CMP:%.*]] = icmp slt <4 x i64> %{{.*}}, zeroinitializer
 919   // 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>
 920   // CHECK: bitcast <8 x i1> [[SHUF]] to i8
 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> undef, <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> undef, <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> undef, <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> undef, <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> undef, <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> undef, <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 }