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

   1 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512dq -emit-llvm -o - -Wall -Werror | FileCheck %s
   2
   3
   4 #include <immintrin.h>
   5
   6 __mmask8 test_knot_mask8(__mmask8 a) {
   7   // CHECK-LABEL: @test_knot_mask8
   8   // CHECK: [[IN:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
   9   // CHECK: [[NOT:%.*]] = xor <8 x i1> [[IN]], splat (i1 true)
  10   return _knot_mask8(a);
  11 }
  12
  13 __mmask8 test_kand_mask8(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
  14   // CHECK-LABEL: @test_kand_mask8
  15   // CHECK: [[LHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
  16   // CHECK: [[RHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
  17   // CHECK: [[RES:%.*]] = and <8 x i1> [[LHS]], [[RHS]]
  18   return _mm512_mask_cmpneq_epu64_mask(_kand_mask8(_mm512_cmpneq_epu64_mask(__A, __B),
  19                                                    _mm512_cmpneq_epu64_mask(__C, __D)),
  20                                                    __E, __F);
  21 }
  22
  23 __mmask8 test_kandn_mask8(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
  24   // CHECK-LABEL: @test_kandn_mask8
  25   // CHECK: [[LHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
  26   // CHECK: [[RHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
  27   // CHECK: [[NOT:%.*]] = xor <8 x i1> [[LHS]], splat (i1 true)
  28   // CHECK: [[RES:%.*]] = and <8 x i1> [[NOT]], [[RHS]]
  29   return _mm512_mask_cmpneq_epu64_mask(_kandn_mask8(_mm512_cmpneq_epu64_mask(__A, __B),
  30                                                     _mm512_cmpneq_epu64_mask(__C, __D)),
  31                                                     __E, __F);
  32 }
  33
  34 __mmask8 test_kor_mask8(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
  35   // CHECK-LABEL: @test_kor_mask8
  36   // CHECK: [[LHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
  37   // CHECK: [[RHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
  38   // CHECK: [[RES:%.*]] = or <8 x i1> [[LHS]], [[RHS]]
  39   return _mm512_mask_cmpneq_epu64_mask(_kor_mask8(_mm512_cmpneq_epu64_mask(__A, __B),
  40                                                   _mm512_cmpneq_epu64_mask(__C, __D)),
  41                                                   __E, __F);
  42 }
  43
  44 __mmask8 test_kxnor_mask8(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
  45   // CHECK-LABEL: @test_kxnor_mask8
  46   // CHECK: [[LHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
  47   // CHECK: [[RHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
  48   // CHECK: [[NOT:%.*]] = xor <8 x i1> [[LHS]], splat (i1 true)
  49   // CHECK: [[RES:%.*]] = xor <8 x i1> [[NOT]], [[RHS]]
  50   return _mm512_mask_cmpneq_epu64_mask(_kxnor_mask8(_mm512_cmpneq_epu64_mask(__A, __B),
  51                                                     _mm512_cmpneq_epu64_mask(__C, __D)),
  52                                                     __E, __F);
  53 }
  54
  55 __mmask8 test_kxor_mask8(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
  56   // CHECK-LABEL: @test_kxor_mask8
  57   // CHECK: [[LHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
  58   // CHECK: [[RHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
  59   // CHECK: [[RES:%.*]] = xor <8 x i1> [[LHS]], [[RHS]]
  60   return _mm512_mask_cmpneq_epu64_mask(_kxor_mask8(_mm512_cmpneq_epu64_mask(__A, __B),
  61                                                    _mm512_cmpneq_epu64_mask(__C, __D)),
  62                                                    __E, __F);
  63 }
  64
  65 unsigned char test_kortestz_mask8_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D) {
  66   // CHECK-LABEL: @test_kortestz_mask8_u8
  67   // CHECK: [[LHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
  68   // CHECK: [[RHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
  69   // CHECK: [[OR:%.*]] = or <8 x i1> [[LHS]], [[RHS]]
  70   // CHECK: [[CAST:%.*]] = bitcast <8 x i1> [[OR]] to i8
  71   // CHECK: [[CMP:%.*]] = icmp eq i8 [[CAST]], 0
  72   // CHECK: [[ZEXT:%.*]] = zext i1 [[CMP]] to i32
  73   // CHECK: trunc i32 [[ZEXT]] to i8
  74   return _kortestz_mask8_u8(_mm512_cmpneq_epu64_mask(__A, __B),
  75                             _mm512_cmpneq_epu64_mask(__C, __D));
  76 }
  77
  78 unsigned char test_kortestc_mask8_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D) {
  79   // CHECK-LABEL: @test_kortestc_mask8_u8
  80   // CHECK: [[LHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
  81   // CHECK: [[RHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
  82   // CHECK: [[OR:%.*]] = or <8 x i1> [[LHS]], [[RHS]]
  83   // CHECK: [[CAST:%.*]] = bitcast <8 x i1> [[OR]] to i8
  84   // CHECK: [[CMP:%.*]] = icmp eq i8 [[CAST]], -1
  85   // CHECK: [[ZEXT:%.*]] = zext i1 [[CMP]] to i32
  86   // CHECK: trunc i32 [[ZEXT]] to i8
  87   return _kortestc_mask8_u8(_mm512_cmpneq_epu64_mask(__A, __B),
  88                             _mm512_cmpneq_epu64_mask(__C, __D));
  89 }
  90
  91 unsigned char test_kortest_mask8_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D, unsigned char *CF) {
  92   // CHECK-LABEL: @test_kortest_mask8_u8
  93   // CHECK: [[LHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
  94   // CHECK: [[RHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
  95   // CHECK: [[OR:%.*]] = or <8 x i1> [[LHS]], [[RHS]]
  96   // CHECK: [[CAST:%.*]] = bitcast <8 x i1> [[OR]] to i8
  97   // CHECK: [[CMP:%.*]] = icmp eq i8 [[CAST]], -1
  98   // CHECK: [[ZEXT:%.*]] = zext i1 [[CMP]] to i32
  99   // CHECK: trunc i32 [[ZEXT]] to i8
 100   // CHECK: [[LHS2:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
 101   // CHECK: [[RHS2:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
 102   // CHECK: [[OR2:%.*]] = or <8 x i1> [[LHS2]], [[RHS2]]
 103   // CHECK: [[CAST2:%.*]] = bitcast <8 x i1> [[OR2]] to i8
 104   // CHECK: [[CMP2:%.*]] = icmp eq i8 [[CAST2]], 0
 105   // CHECK: [[ZEXT2:%.*]] = zext i1 [[CMP2]] to i32
 106   // CHECK: trunc i32 [[ZEXT2]] to i8
 107   return _kortest_mask8_u8(_mm512_cmpneq_epu64_mask(__A, __B),
 108                            _mm512_cmpneq_epu64_mask(__C, __D), CF);
 109 }
 110
 111 unsigned char test_ktestz_mask8_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D) {
 112   // CHECK-LABEL: @test_ktestz_mask8_u8
 113   // CHECK: [[LHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
 114   // CHECK: [[RHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
 115   // CHECK: [[RES:%.*]] = call i32 @llvm.x86.avx512.ktestz.b(<8 x i1> [[LHS]], <8 x i1> [[RHS]])
 116   // CHECK: trunc i32 [[RES]] to i8
 117   return _ktestz_mask8_u8(_mm512_cmpneq_epu64_mask(__A, __B),
 118                           _mm512_cmpneq_epu64_mask(__C, __D));
 119 }
 120
 121 unsigned char test_ktestc_mask8_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D) {
 122   // CHECK-LABEL: @test_ktestc_mask8_u8
 123   // CHECK: [[LHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
 124   // CHECK: [[RHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
 125   // CHECK: [[RES:%.*]] = call i32 @llvm.x86.avx512.ktestc.b(<8 x i1> [[LHS]], <8 x i1> [[RHS]])
 126   // CHECK: trunc i32 [[RES]] to i8
 127   return _ktestc_mask8_u8(_mm512_cmpneq_epu64_mask(__A, __B),
 128                           _mm512_cmpneq_epu64_mask(__C, __D));
 129 }
 130
 131 unsigned char test_ktest_mask8_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D, unsigned char *CF) {
 132   // CHECK-LABEL: @test_ktest_mask8_u8
 133   // CHECK: [[LHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
 134   // CHECK: [[RHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
 135   // CHECK: [[RES:%.*]] = call i32 @llvm.x86.avx512.ktestc.b(<8 x i1> [[LHS]], <8 x i1> [[RHS]])
 136   // CHECK: trunc i32 [[RES]] to i8
 137   // CHECK: [[LHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
 138   // CHECK: [[RHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
 139   // CHECK: [[RES:%.*]] = call i32 @llvm.x86.avx512.ktestz.b(<8 x i1> [[LHS]], <8 x i1> [[RHS]])
 140   // CHECK: trunc i32 [[RES]] to i8
 141   return _ktest_mask8_u8(_mm512_cmpneq_epu64_mask(__A, __B),
 142                          _mm512_cmpneq_epu64_mask(__C, __D), CF);
 143 }
 144
 145 unsigned char test_ktestz_mask16_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D) {
 146   // CHECK-LABEL: @test_ktestz_mask16_u8
 147   // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1>
 148   // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1>
 149   // CHECK: [[RES:%.*]] = call i32 @llvm.x86.avx512.ktestz.w(<16 x i1> [[LHS]], <16 x i1> [[RHS]])
 150   // CHECK: trunc i32 [[RES]] to i8
 151   return _ktestz_mask16_u8(_mm512_cmpneq_epu32_mask(__A, __B),
 152                            _mm512_cmpneq_epu32_mask(__C, __D));
 153 }
 154
 155 unsigned char test_ktestc_mask16_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D) {
 156   // CHECK-LABEL: @test_ktestc_mask16_u8
 157   // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1>
 158   // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1>
 159   // CHECK: [[RES:%.*]] = call i32 @llvm.x86.avx512.ktestc.w(<16 x i1> [[LHS]], <16 x i1> [[RHS]])
 160   // CHECK: trunc i32 [[RES]] to i8
 161   return _ktestc_mask16_u8(_mm512_cmpneq_epu32_mask(__A, __B),
 162                            _mm512_cmpneq_epu32_mask(__C, __D));
 163 }
 164
 165 unsigned char test_ktest_mask16_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D, unsigned char *CF) {
 166   // CHECK-LABEL: @test_ktest_mask16_u8
 167   // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1>
 168   // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1>
 169   // CHECK: [[RES:%.*]] = call i32 @llvm.x86.avx512.ktestc.w(<16 x i1> [[LHS]], <16 x i1> [[RHS]])
 170   // CHECK: trunc i32 [[RES]] to i8
 171   // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1>
 172   // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1>
 173   // CHECK: [[RES:%.*]] = call i32 @llvm.x86.avx512.ktestz.w(<16 x i1> [[LHS]], <16 x i1> [[RHS]])
 174   // CHECK: trunc i32 [[RES]] to i8
 175   return _ktest_mask16_u8(_mm512_cmpneq_epu32_mask(__A, __B),
 176                           _mm512_cmpneq_epu32_mask(__C, __D), CF);
 177 }
 178
 179 __mmask8 test_kadd_mask8(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
 180   // CHECK-LABEL: @test_kadd_mask8
 181   // CHECK: [[LHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
 182   // CHECK: [[RHS:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
 183   // CHECK: [[RES:%.*]] = call <8 x i1> @llvm.x86.avx512.kadd.b(<8 x i1> [[LHS]], <8 x i1> [[RHS]])
 184   return _mm512_mask_cmpneq_epu64_mask(_kadd_mask8(_mm512_cmpneq_epu64_mask(__A, __B),
 185                                                    _mm512_cmpneq_epu64_mask(__C, __D)),
 186                                                    __E, __F);
 187 }
 188
 189 __mmask16 test_kadd_mask16(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
 190   // CHECK-LABEL: @test_kadd_mask16
 191   // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1>
 192   // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1>
 193   // CHECK: [[RES:%.*]] = call <16 x i1> @llvm.x86.avx512.kadd.w(<16 x i1> [[LHS]], <16 x i1> [[RHS]])
 194   return _mm512_mask_cmpneq_epu32_mask(_kadd_mask16(_mm512_cmpneq_epu32_mask(__A, __B),
 195                                                     _mm512_cmpneq_epu32_mask(__C, __D)),
 196                                                     __E, __F);
 197 }
 198
 199 __mmask8 test_kshiftli_mask8(__m512i A, __m512i B, __m512i C, __m512i D) {
 200   // CHECK-LABEL: @test_kshiftli_mask8
 201   // CHECK: [[VAL:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
 202   // CHECK: [[RES:%.*]] = shufflevector <8 x i1> zeroinitializer, <8 x i1> [[VAL]], <8 x i32> <i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13>
 203   return _mm512_mask_cmpneq_epu64_mask(_kshiftli_mask8(_mm512_cmpneq_epu64_mask(A, B), 2), C, D);
 204 }
 205
 206 __mmask8 test_kshiftri_mask8(__m512i A, __m512i B, __m512i C, __m512i D) {
 207   // CHECK-LABEL: @test_kshiftri_mask8
 208   // CHECK: [[VAL:%.*]] = bitcast i8 %{{.*}} to <8 x i1>
 209   // CHECK: [[RES:%.*]] = shufflevector <8 x i1> [[VAL]], <8 x i1> zeroinitializer, <8 x i32> <i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9>
 210   return _mm512_mask_cmpneq_epu64_mask(_kshiftri_mask8(_mm512_cmpneq_epu64_mask(A, B), 2), C, D);
 211 }
 212
 213 unsigned int test_cvtmask8_u32(__m512i A, __m512i B) {
 214   // CHECK-LABEL: @test_cvtmask8_u32
 215   // CHECK: zext i8 %{{.*}} to i32
 216   return _cvtmask8_u32(_mm512_cmpneq_epu64_mask(A, B));
 217 }
 218
 219 __mmask8 test_cvtu32_mask8(__m512i A, __m512i B, unsigned int C) {
 220   // CHECK-LABEL: @test_cvtu32_mask8
 221   // CHECK: trunc i32 %{{.*}} to i8
 222   return _mm512_mask_cmpneq_epu64_mask(_cvtu32_mask8(C), A, B);
 223 }
 224
 225 __mmask8 test_load_mask8(__mmask8 *A, __m512i B, __m512i C) {
 226   // CHECK-LABEL: @test_load_mask8
 227   // CHECK: [[LOAD:%.*]] = load i8, ptr %{{.*}}
 228   return _mm512_mask_cmpneq_epu64_mask(_load_mask8(A), B, C);
 229 }
 230
 231 void test_store_mask8(__mmask8 *A, __m512i B, __m512i C) {
 232   // CHECK-LABEL: @test_store_mask8
 233   // CHECK: store i8 %{{.*}}, ptr %{{.*}}
 234   _store_mask8(A, _mm512_cmpneq_epu64_mask(B, C));
 235 }
 236
 237 __m512i test_mm512_mullo_epi64 (__m512i __A, __m512i __B) {
 238   // CHECK-LABEL: @test_mm512_mullo_epi64
 239   // CHECK: mul <8 x i64>
 240   return (__m512i) _mm512_mullo_epi64(__A, __B);
 241 }
 242
 243 __m512i test_mm512_mask_mullo_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) {
 244   // CHECK-LABEL: @test_mm512_mask_mullo_epi64
 245   // CHECK: mul <8 x i64> %{{.*}}, %{{.*}}
 246   // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}}
 247   return (__m512i) _mm512_mask_mullo_epi64(__W, __U, __A, __B);
 248 }
 249
 250 __m512i test_mm512_maskz_mullo_epi64 (__mmask8 __U, __m512i __A, __m512i __B) {
 251   // CHECK-LABEL: @test_mm512_maskz_mullo_epi64
 252   // CHECK: mul <8 x i64> %{{.*}}, %{{.*}}
 253   // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}}
 254   return (__m512i) _mm512_maskz_mullo_epi64(__U, __A, __B);
 255 }
 256
 257 __m512d test_mm512_xor_pd (__m512d __A, __m512d __B) {
 258   // CHECK-LABEL: @test_mm512_xor_pd
 259   // CHECK: xor <8 x i64>
 260   return (__m512d) _mm512_xor_pd(__A, __B);
 261 }
 262
 263 __m512d test_mm512_mask_xor_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) {
 264   // CHECK-LABEL: @test_mm512_mask_xor_pd
 265   // CHECK: xor <8 x i64>
 266   // CHECK: %[[MASK:.*]] = bitcast i8 %{{.*}} to <8 x i1>
 267   // CHECK: select <8 x i1> %[[MASK]], <8 x double> %{{.*}}, <8 x double> %{{.*}}
 268   return (__m512d) _mm512_mask_xor_pd(__W, __U, __A, __B);
 269 }
 270
 271 __m512d test_mm512_maskz_xor_pd (__mmask8 __U, __m512d __A, __m512d __B) {
 272   // CHECK-LABEL: @test_mm512_maskz_xor_pd
 273   // CHECK: xor <8 x i64>
 274   // CHECK: %[[MASK:.*]] = bitcast i8 %{{.*}} to <8 x i1>
 275   // CHECK: select <8 x i1> %[[MASK]], <8 x double> %{{.*}}, <8 x double> %{{.*}}
 276   return (__m512d) _mm512_maskz_xor_pd(__U, __A, __B);
 277 }
 278
 279 __m512 test_mm512_xor_ps (__m512 __A, __m512 __B) {
 280   // CHECK-LABEL: @test_mm512_xor_ps
 281   // CHECK: xor <16 x i32>
 282   return (__m512) _mm512_xor_ps(__A, __B);
 283 }
 284
 285 __m512 test_mm512_mask_xor_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) {
 286   // CHECK-LABEL: @test_mm512_mask_xor_ps
 287   // CHECK: xor <16 x i32>
 288   // CHECK: %[[MASK:.*]] = bitcast i16 %{{.*}} to <16 x i1>
 289   // CHECK: select <16 x i1> %[[MASK]], <16 x float> %{{.*}}, <16 x float> %{{.*}}
 290   return (__m512) _mm512_mask_xor_ps(__W, __U, __A, __B);
 291 }
 292
 293 __m512 test_mm512_maskz_xor_ps (__mmask16 __U, __m512 __A, __m512 __B) {
 294   // CHECK-LABEL: @test_mm512_maskz_xor_ps
 295   // CHECK: xor <16 x i32>
 296   // CHECK: %[[MASK:.*]] = bitcast i16 %{{.*}} to <16 x i1>
 297   // CHECK: select <16 x i1> %[[MASK]], <16 x float> %{{.*}}, <16 x float> %{{.*}}
 298   return (__m512) _mm512_maskz_xor_ps(__U, __A, __B);
 299 }
 300
 301 __m512d test_mm512_or_pd (__m512d __A, __m512d __B) {
 302   // CHECK-LABEL: @test_mm512_or_pd
 303   // CHECK: or <8 x i64>
 304   return (__m512d) _mm512_or_pd(__A, __B);
 305 }
 306
 307 __m512d test_mm512_mask_or_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) {
 308   // CHECK-LABEL: @test_mm512_mask_or_pd
 309   // CHECK: or <8 x i64>
 310   // CHECK: %[[MASK:.*]] = bitcast i8 %{{.*}} to <8 x i1>
 311   // CHECK: select <8 x i1> %[[MASK]], <8 x double> %{{.*}}, <8 x double> %{{.*}}
 312   return (__m512d) _mm512_mask_or_pd(__W, __U, __A, __B);
 313 }
 314
 315 __m512d test_mm512_maskz_or_pd (__mmask8 __U, __m512d __A, __m512d __B) {
 316   // CHECK-LABEL: @test_mm512_maskz_or_pd
 317   // CHECK: or <8 x i64>
 318   // CHECK: %[[MASK:.*]] = bitcast i8 %{{.*}} to <8 x i1>
 319   // CHECK: select <8 x i1> %[[MASK]], <8 x double> %{{.*}}, <8 x double> %{{.*}}
 320   return (__m512d) _mm512_maskz_or_pd(__U, __A, __B);
 321 }
 322
 323 __m512 test_mm512_or_ps (__m512 __A, __m512 __B) {
 324   // CHECK-LABEL: @test_mm512_or_ps
 325   // CHECK: or <16 x i32>
 326   return (__m512) _mm512_or_ps(__A, __B);
 327 }
 328
 329 __m512 test_mm512_mask_or_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) {
 330   // CHECK-LABEL: @test_mm512_mask_or_ps
 331   // CHECK: or <16 x i32>
 332   // CHECK: %[[MASK:.*]] = bitcast i16 %{{.*}} to <16 x i1>
 333   // CHECK: select <16 x i1> %[[MASK]], <16 x float> %{{.*}}, <16 x float> %{{.*}}
 334   return (__m512) _mm512_mask_or_ps(__W, __U, __A, __B);
 335 }
 336
 337 __m512 test_mm512_maskz_or_ps (__mmask16 __U, __m512 __A, __m512 __B) {
 338   // CHECK-LABEL: @test_mm512_maskz_or_ps
 339   // CHECK: or <16 x i32>
 340   // CHECK: %[[MASK:.*]] = bitcast i16 %{{.*}} to <16 x i1>
 341   // CHECK: select <16 x i1> %[[MASK]], <16 x float> %{{.*}}, <16 x float> %{{.*}}
 342   return (__m512) _mm512_maskz_or_ps(__U, __A, __B);
 343 }
 344
 345 __m512d test_mm512_and_pd (__m512d __A, __m512d __B) {
 346   // CHECK-LABEL: @test_mm512_and_pd
 347   // CHECK: and <8 x i64>
 348   return (__m512d) _mm512_and_pd(__A, __B);
 349 }
 350
 351 __m512d test_mm512_mask_and_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) {
 352   // CHECK-LABEL: @test_mm512_mask_and_pd
 353   // CHECK: and <8 x i64>
 354   // CHECK: %[[MASK:.*]] = bitcast i8 %{{.*}} to <8 x i1>
 355   // CHECK: select <8 x i1> %[[MASK]], <8 x double> %{{.*}}, <8 x double> %{{.*}}
 356   return (__m512d) _mm512_mask_and_pd(__W, __U, __A, __B);
 357 }
 358
 359 __m512d test_mm512_maskz_and_pd (__mmask8 __U, __m512d __A, __m512d __B) {
 360   // CHECK-LABEL: @test_mm512_maskz_and_pd
 361   // CHECK: and <8 x i64>
 362   // CHECK: %[[MASK:.*]] = bitcast i8 %{{.*}} to <8 x i1>
 363   // CHECK: select <8 x i1> %[[MASK]], <8 x double> %{{.*}}, <8 x double> %{{.*}}
 364   return (__m512d) _mm512_maskz_and_pd(__U, __A, __B);
 365 }
 366
 367 __m512 test_mm512_and_ps (__m512 __A, __m512 __B) {
 368   // CHECK-LABEL: @test_mm512_and_ps
 369   // CHECK: and <16 x i32>
 370   return (__m512) _mm512_and_ps(__A, __B);
 371 }
 372
 373 __m512 test_mm512_mask_and_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) {
 374   // CHECK-LABEL: @test_mm512_mask_and_ps
 375   // CHECK: and <16 x i32>
 376   // CHECK: %[[MASK:.*]] = bitcast i16 %{{.*}} to <16 x i1>
 377   // CHECK: select <16 x i1> %[[MASK]], <16 x float> %{{.*}}, <16 x float> %{{.*}}
 378   return (__m512) _mm512_mask_and_ps(__W, __U, __A, __B);
 379 }
 380
 381 __m512 test_mm512_maskz_and_ps (__mmask16 __U, __m512 __A, __m512 __B) {
 382   // CHECK-LABEL: @test_mm512_maskz_and_ps
 383   // CHECK: and <16 x i32>
 384   // CHECK: %[[MASK:.*]] = bitcast i16 %{{.*}} to <16 x i1>
 385   // CHECK: select <16 x i1> %[[MASK]], <16 x float> %{{.*}}, <16 x float> %{{.*}}
 386   return (__m512) _mm512_maskz_and_ps(__U, __A, __B);
 387 }
 388
 389 __m512d test_mm512_andnot_pd (__m512d __A, __m512d __B) {
 390   // CHECK-LABEL: @test_mm512_andnot_pd
 391   // CHECK: xor <8 x i64> %{{.*}}, splat (i64 -1)
 392   // CHECK: and <8 x i64>
 393   return (__m512d) _mm512_andnot_pd(__A, __B);
 394 }
 395
 396 __m512d test_mm512_mask_andnot_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) {
 397   // CHECK-LABEL: @test_mm512_mask_andnot_pd
 398   // CHECK: xor <8 x i64> %{{.*}}, splat (i64 -1)
 399   // CHECK: and <8 x i64> %{{.*}}, %{{.*}}
 400   // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}
 401   return (__m512d) _mm512_mask_andnot_pd(__W, __U, __A, __B);
 402 }
 403
 404 __m512d test_mm512_maskz_andnot_pd (__mmask8 __U, __m512d __A, __m512d __B) {
 405   // CHECK-LABEL: @test_mm512_maskz_andnot_pd
 406   // CHECK: xor <8 x i64> %{{.*}}, splat (i64 -1)
 407   // CHECK: and <8 x i64> %{{.*}}, %{{.*}}
 408   // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}
 409   return (__m512d) _mm512_maskz_andnot_pd(__U, __A, __B);
 410 }
 411
 412 __m512 test_mm512_andnot_ps (__m512 __A, __m512 __B) {
 413   // CHECK-LABEL: @test_mm512_andnot_ps
 414   // CHECK: xor <16 x i32> %{{.*}}, splat (i32 -1)
 415   // CHECK: and <16 x i32>
 416   return (__m512) _mm512_andnot_ps(__A, __B);
 417 }
 418
 419 __m512 test_mm512_mask_andnot_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) {
 420   // CHECK-LABEL: @test_mm512_mask_andnot_ps
 421   // CHECK: xor <16 x i32> %{{.*}}, splat (i32 -1)
 422   // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
 423   // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
 424   return (__m512) _mm512_mask_andnot_ps(__W, __U, __A, __B);
 425 }
 426
 427 __m512 test_mm512_maskz_andnot_ps (__mmask16 __U, __m512 __A, __m512 __B) {
 428   // CHECK-LABEL: @test_mm512_maskz_andnot_ps
 429   // CHECK: xor <16 x i32> %{{.*}}, splat (i32 -1)
 430   // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
 431   // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
 432   return (__m512) _mm512_maskz_andnot_ps(__U, __A, __B);
 433 }
 434
 435 __m512i test_mm512_cvtpd_epi64(__m512d __A) {
 436   // CHECK-LABEL: @test_mm512_cvtpd_epi64
 437   // CHECK: @llvm.x86.avx512.mask.cvtpd2qq.512
 438   return _mm512_cvtpd_epi64(__A);
 439 }
 440
 441 __m512i test_mm512_mask_cvtpd_epi64(__m512i __W, __mmask8 __U, __m512d __A) {
 442   // CHECK-LABEL: @test_mm512_mask_cvtpd_epi64
 443   // CHECK: @llvm.x86.avx512.mask.cvtpd2qq.512
 444   return _mm512_mask_cvtpd_epi64(__W, __U, __A);
 445 }
 446
 447 __m512i test_mm512_maskz_cvtpd_epi64(__mmask8 __U, __m512d __A) {
 448   // CHECK-LABEL: @test_mm512_maskz_cvtpd_epi64
 449   // CHECK: @llvm.x86.avx512.mask.cvtpd2qq.512
 450   return _mm512_maskz_cvtpd_epi64(__U, __A);
 451 }
 452
 453 __m512i test_mm512_cvt_roundpd_epi64(__m512d __A) {
 454   // CHECK-LABEL: @test_mm512_cvt_roundpd_epi64
 455   // CHECK: @llvm.x86.avx512.mask.cvtpd2qq.512
 456   return _mm512_cvt_roundpd_epi64(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 457 }
 458
 459 __m512i test_mm512_mask_cvt_roundpd_epi64(__m512i __W, __mmask8 __U, __m512d __A) {
 460   // CHECK-LABEL: @test_mm512_mask_cvt_roundpd_epi64
 461   // CHECK: @llvm.x86.avx512.mask.cvtpd2qq.512
 462   return _mm512_mask_cvt_roundpd_epi64(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 463 }
 464
 465 __m512i test_mm512_maskz_cvt_roundpd_epi64(__mmask8 __U, __m512d __A) {
 466   // CHECK-LABEL: @test_mm512_maskz_cvt_roundpd_epi64
 467   // CHECK: @llvm.x86.avx512.mask.cvtpd2qq.512
 468   return _mm512_maskz_cvt_roundpd_epi64(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 469 }
 470
 471 __m512i test_mm512_cvtpd_epu64(__m512d __A) {
 472   // CHECK-LABEL: @test_mm512_cvtpd_epu64
 473   // CHECK: @llvm.x86.avx512.mask.cvtpd2uqq.512
 474   return _mm512_cvtpd_epu64(__A);
 475 }
 476
 477 __m512i test_mm512_mask_cvtpd_epu64(__m512i __W, __mmask8 __U, __m512d __A) {
 478   // CHECK-LABEL: @test_mm512_mask_cvtpd_epu64
 479   // CHECK: @llvm.x86.avx512.mask.cvtpd2uqq.512
 480   return _mm512_mask_cvtpd_epu64(__W, __U, __A);
 481 }
 482
 483 __m512i test_mm512_maskz_cvtpd_epu64(__mmask8 __U, __m512d __A) {
 484   // CHECK-LABEL: @test_mm512_maskz_cvtpd_epu64
 485   // CHECK: @llvm.x86.avx512.mask.cvtpd2uqq.512
 486   return _mm512_maskz_cvtpd_epu64(__U, __A);
 487 }
 488
 489 __m512i test_mm512_cvt_roundpd_epu64(__m512d __A) {
 490   // CHECK-LABEL: @test_mm512_cvt_roundpd_epu64
 491   // CHECK: @llvm.x86.avx512.mask.cvtpd2uqq.512
 492   return _mm512_cvt_roundpd_epu64(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 493 }
 494
 495 __m512i test_mm512_mask_cvt_roundpd_epu64(__m512i __W, __mmask8 __U, __m512d __A) {
 496   // CHECK-LABEL: @test_mm512_mask_cvt_roundpd_epu64
 497   // CHECK: @llvm.x86.avx512.mask.cvtpd2uqq.512
 498   return _mm512_mask_cvt_roundpd_epu64(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 499 }
 500
 501 __m512i test_mm512_maskz_cvt_roundpd_epu64(__mmask8 __U, __m512d __A) {
 502   // CHECK-LABEL: @test_mm512_maskz_cvt_roundpd_epu64
 503   // CHECK: @llvm.x86.avx512.mask.cvtpd2uqq.512
 504   return _mm512_maskz_cvt_roundpd_epu64(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 505 }
 506
 507 __m512i test_mm512_cvtps_epi64(__m256 __A) {
 508   // CHECK-LABEL: @test_mm512_cvtps_epi64
 509   // CHECK: @llvm.x86.avx512.mask.cvtps2qq.512
 510   return _mm512_cvtps_epi64(__A);
 511 }
 512
 513 __m512i test_mm512_mask_cvtps_epi64(__m512i __W, __mmask8 __U, __m256 __A) {
 514   // CHECK-LABEL: @test_mm512_mask_cvtps_epi64
 515   // CHECK: @llvm.x86.avx512.mask.cvtps2qq.512
 516   return _mm512_mask_cvtps_epi64(__W, __U, __A);
 517 }
 518
 519 __m512i test_mm512_maskz_cvtps_epi64(__mmask8 __U, __m256 __A) {
 520   // CHECK-LABEL: @test_mm512_maskz_cvtps_epi64
 521   // CHECK: @llvm.x86.avx512.mask.cvtps2qq.512
 522   return _mm512_maskz_cvtps_epi64(__U, __A);
 523 }
 524
 525 __m512i test_mm512_cvt_roundps_epi64(__m256 __A) {
 526   // CHECK-LABEL: @test_mm512_cvt_roundps_epi64
 527   // CHECK: @llvm.x86.avx512.mask.cvtps2qq.512
 528   return _mm512_cvt_roundps_epi64(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 529 }
 530
 531 __m512i test_mm512_mask_cvt_roundps_epi64(__m512i __W, __mmask8 __U, __m256 __A) {
 532   // CHECK-LABEL: @test_mm512_mask_cvt_roundps_epi64
 533   // CHECK: @llvm.x86.avx512.mask.cvtps2qq.512
 534   return _mm512_mask_cvt_roundps_epi64(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 535 }
 536
 537 __m512i test_mm512_maskz_cvt_roundps_epi64(__mmask8 __U, __m256 __A) {
 538   // CHECK-LABEL: @test_mm512_maskz_cvt_roundps_epi64
 539   // CHECK: @llvm.x86.avx512.mask.cvtps2qq.512
 540   return _mm512_maskz_cvt_roundps_epi64(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 541 }
 542
 543 __m512i test_mm512_cvtps_epu64(__m256 __A) {
 544   // CHECK-LABEL: @test_mm512_cvtps_epu64
 545   // CHECK: @llvm.x86.avx512.mask.cvtps2uqq.512
 546   return _mm512_cvtps_epu64(__A);
 547 }
 548
 549 __m512i test_mm512_mask_cvtps_epu64(__m512i __W, __mmask8 __U, __m256 __A) {
 550   // CHECK-LABEL: @test_mm512_mask_cvtps_epu64
 551   // CHECK: @llvm.x86.avx512.mask.cvtps2uqq.512
 552   return _mm512_mask_cvtps_epu64(__W, __U, __A);
 553 }
 554
 555 __m512i test_mm512_maskz_cvtps_epu64(__mmask8 __U, __m256 __A) {
 556   // CHECK-LABEL: @test_mm512_maskz_cvtps_epu64
 557   // CHECK: @llvm.x86.avx512.mask.cvtps2uqq.512
 558   return _mm512_maskz_cvtps_epu64(__U, __A);
 559 }
 560
 561 __m512i test_mm512_cvt_roundps_epu64(__m256 __A) {
 562   // CHECK-LABEL: @test_mm512_cvt_roundps_epu64
 563   // CHECK: @llvm.x86.avx512.mask.cvtps2uqq.512
 564   return _mm512_cvt_roundps_epu64(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 565 }
 566
 567 __m512i test_mm512_mask_cvt_roundps_epu64(__m512i __W, __mmask8 __U, __m256 __A) {
 568   // CHECK-LABEL: @test_mm512_mask_cvt_roundps_epu64
 569   // CHECK: @llvm.x86.avx512.mask.cvtps2uqq.512
 570   return _mm512_mask_cvt_roundps_epu64(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 571 }
 572
 573 __m512i test_mm512_maskz_cvt_roundps_epu64(__mmask8 __U, __m256 __A) {
 574   // CHECK-LABEL: @test_mm512_maskz_cvt_roundps_epu64
 575   // CHECK: @llvm.x86.avx512.mask.cvtps2uqq.512
 576   return _mm512_maskz_cvt_roundps_epu64(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 577 }
 578
 579 __m512d test_mm512_cvtepi64_pd(__m512i __A) {
 580   // CHECK-LABEL: @test_mm512_cvtepi64_pd
 581   // CHECK: sitofp <8 x i64> %{{.*}} to <8 x double>
 582   return _mm512_cvtepi64_pd(__A);
 583 }
 584
 585 __m512d test_mm512_mask_cvtepi64_pd(__m512d __W, __mmask8 __U, __m512i __A) {
 586   // CHECK-LABEL: @test_mm512_mask_cvtepi64_pd
 587   // CHECK: sitofp <8 x i64> %{{.*}} to <8 x double>
 588   // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}
 589   return _mm512_mask_cvtepi64_pd(__W, __U, __A);
 590 }
 591
 592 __m512d test_mm512_maskz_cvtepi64_pd(__mmask8 __U, __m512i __A) {
 593   // CHECK-LABEL: @test_mm512_maskz_cvtepi64_pd
 594   // CHECK: sitofp <8 x i64> %{{.*}} to <8 x double>
 595   // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}
 596   return _mm512_maskz_cvtepi64_pd(__U, __A);
 597 }
 598
 599 __m512d test_mm512_cvt_roundepi64_pd(__m512i __A) {
 600   // CHECK-LABEL: @test_mm512_cvt_roundepi64_pd
 601   // CHECK: @llvm.x86.avx512.sitofp.round.v8f64.v8i64
 602   return _mm512_cvt_roundepi64_pd(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 603 }
 604
 605 __m512d test_mm512_mask_cvt_roundepi64_pd(__m512d __W, __mmask8 __U, __m512i __A) {
 606   // CHECK-LABEL: @test_mm512_mask_cvt_roundepi64_pd
 607   // CHECK: @llvm.x86.avx512.sitofp.round.v8f64.v8i64
 608   // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}
 609   return _mm512_mask_cvt_roundepi64_pd(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 610 }
 611
 612 __m512d test_mm512_maskz_cvt_roundepi64_pd(__mmask8 __U, __m512i __A) {
 613   // CHECK-LABEL: @test_mm512_maskz_cvt_roundepi64_pd
 614   // CHECK: @llvm.x86.avx512.sitofp.round.v8f64.v8i64
 615   // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}
 616   return _mm512_maskz_cvt_roundepi64_pd(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 617 }
 618
 619 __m256 test_mm512_cvtepi64_ps(__m512i __A) {
 620   // CHECK-LABEL: @test_mm512_cvtepi64_ps
 621   // CHECK: sitofp <8 x i64> %{{.*}} to <8 x float>
 622   return _mm512_cvtepi64_ps(__A);
 623 }
 624
 625 __m256 test_mm512_mask_cvtepi64_ps(__m256 __W, __mmask8 __U, __m512i __A) {
 626   // CHECK-LABEL: @test_mm512_mask_cvtepi64_ps
 627   // CHECK: sitofp <8 x i64> %{{.*}} to <8 x float>
 628   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 629   return _mm512_mask_cvtepi64_ps(__W, __U, __A);
 630 }
 631
 632 __m256 test_mm512_maskz_cvtepi64_ps(__mmask8 __U, __m512i __A) {
 633   // CHECK-LABEL: @test_mm512_maskz_cvtepi64_ps
 634   // CHECK: sitofp <8 x i64> %{{.*}} to <8 x float>
 635   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 636   return _mm512_maskz_cvtepi64_ps(__U, __A);
 637 }
 638
 639 __m256 test_mm512_cvt_roundepi64_ps(__m512i __A) {
 640   // CHECK-LABEL: @test_mm512_cvt_roundepi64_ps
 641   // CHECK: @llvm.x86.avx512.sitofp.round.v8f32.v8i64
 642   return _mm512_cvt_roundepi64_ps(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 643 }
 644
 645 __m256 test_mm512_mask_cvt_roundepi64_ps(__m256 __W, __mmask8 __U, __m512i __A) {
 646   // CHECK-LABEL: @test_mm512_mask_cvt_roundepi64_ps
 647   // CHECK: @llvm.x86.avx512.sitofp.round.v8f32.v8i64
 648   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 649   return _mm512_mask_cvt_roundepi64_ps(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 650 }
 651
 652 __m256 test_mm512_maskz_cvt_roundepi64_ps(__mmask8 __U, __m512i __A) {
 653   // CHECK-LABEL: @test_mm512_maskz_cvt_roundepi64_ps
 654   // CHECK: @llvm.x86.avx512.sitofp.round.v8f32.v8i64
 655   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 656   return _mm512_maskz_cvt_roundepi64_ps(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 657 }
 658
 659 __m512i test_mm512_cvttpd_epi64(__m512d __A) {
 660   // CHECK-LABEL: @test_mm512_cvttpd_epi64
 661   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.512
 662   return _mm512_cvttpd_epi64(__A);
 663 }
 664
 665 __m512i test_mm512_mask_cvttpd_epi64(__m512i __W, __mmask8 __U, __m512d __A) {
 666   // CHECK-LABEL: @test_mm512_mask_cvttpd_epi64
 667   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.512
 668   return _mm512_mask_cvttpd_epi64(__W, __U, __A);
 669 }
 670
 671 __m512i test_mm512_maskz_cvttpd_epi64(__mmask8 __U, __m512d __A) {
 672   // CHECK-LABEL: @test_mm512_maskz_cvttpd_epi64
 673   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.512
 674   return _mm512_maskz_cvttpd_epi64(__U, __A);
 675 }
 676
 677 __m512i test_mm512_cvtt_roundpd_epi64(__m512d __A) {
 678   // CHECK-LABEL: @test_mm512_cvtt_roundpd_epi64
 679   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.512
 680   return _mm512_cvtt_roundpd_epi64(__A, _MM_FROUND_NO_EXC);
 681 }
 682
 683 __m512i test_mm512_mask_cvtt_roundpd_epi64(__m512i __W, __mmask8 __U, __m512d __A) {
 684   // CHECK-LABEL: @test_mm512_mask_cvtt_roundpd_epi64
 685   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.512
 686   return _mm512_mask_cvtt_roundpd_epi64(__W, __U, __A, _MM_FROUND_NO_EXC);
 687 }
 688
 689 __m512i test_mm512_maskz_cvtt_roundpd_epi64(__mmask8 __U, __m512d __A) {
 690   // CHECK-LABEL: @test_mm512_maskz_cvtt_roundpd_epi64
 691   // CHECK: @llvm.x86.avx512.mask.cvttpd2qq.512
 692   return _mm512_maskz_cvtt_roundpd_epi64(__U, __A, _MM_FROUND_NO_EXC);
 693 }
 694
 695 __m512i test_mm512_cvttpd_epu64(__m512d __A) {
 696   // CHECK-LABEL: @test_mm512_cvttpd_epu64
 697   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.512
 698   return _mm512_cvttpd_epu64(__A);
 699 }
 700
 701 __m512i test_mm512_mask_cvttpd_epu64(__m512i __W, __mmask8 __U, __m512d __A) {
 702   // CHECK-LABEL: @test_mm512_mask_cvttpd_epu64
 703   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.512
 704   return _mm512_mask_cvttpd_epu64(__W, __U, __A);
 705 }
 706
 707 __m512i test_mm512_maskz_cvttpd_epu64(__mmask8 __U, __m512d __A) {
 708   // CHECK-LABEL: @test_mm512_maskz_cvttpd_epu64
 709   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.512
 710   return _mm512_maskz_cvttpd_epu64(__U, __A);
 711 }
 712
 713 __m512i test_mm512_cvtt_roundpd_epu64(__m512d __A) {
 714   // CHECK-LABEL: @test_mm512_cvtt_roundpd_epu64
 715   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.512
 716   return _mm512_cvtt_roundpd_epu64(__A, _MM_FROUND_NO_EXC);
 717 }
 718
 719 __m512i test_mm512_mask_cvtt_roundpd_epu64(__m512i __W, __mmask8 __U, __m512d __A) {
 720   // CHECK-LABEL: @test_mm512_mask_cvtt_roundpd_epu64
 721   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.512
 722   return _mm512_mask_cvtt_roundpd_epu64(__W, __U, __A, _MM_FROUND_NO_EXC);
 723 }
 724
 725 __m512i test_mm512_maskz_cvtt_roundpd_epu64(__mmask8 __U, __m512d __A) {
 726   // CHECK-LABEL: @test_mm512_maskz_cvtt_roundpd_epu64
 727   // CHECK: @llvm.x86.avx512.mask.cvttpd2uqq.512
 728   return _mm512_maskz_cvtt_roundpd_epu64(__U, __A, _MM_FROUND_NO_EXC);
 729 }
 730
 731 __m512i test_mm512_cvttps_epi64(__m256 __A) {
 732   // CHECK-LABEL: @test_mm512_cvttps_epi64
 733   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.512
 734   return _mm512_cvttps_epi64(__A);
 735 }
 736
 737 __m512i test_mm512_mask_cvttps_epi64(__m512i __W, __mmask8 __U, __m256 __A) {
 738   // CHECK-LABEL: @test_mm512_mask_cvttps_epi64
 739   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.512
 740   return _mm512_mask_cvttps_epi64(__W, __U, __A);
 741 }
 742
 743 __m512i test_mm512_maskz_cvttps_epi64(__mmask8 __U, __m256 __A) {
 744   // CHECK-LABEL: @test_mm512_maskz_cvttps_epi64
 745   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.512
 746   return _mm512_maskz_cvttps_epi64(__U, __A);
 747 }
 748
 749 __m512i test_mm512_cvtt_roundps_epi64(__m256 __A) {
 750   // CHECK-LABEL: @test_mm512_cvtt_roundps_epi64
 751   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.512
 752   return _mm512_cvtt_roundps_epi64(__A, _MM_FROUND_NO_EXC);
 753 }
 754
 755 __m512i test_mm512_mask_cvtt_roundps_epi64(__m512i __W, __mmask8 __U, __m256 __A) {
 756   // CHECK-LABEL: @test_mm512_mask_cvtt_roundps_epi64
 757   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.512
 758   return _mm512_mask_cvtt_roundps_epi64(__W, __U, __A, _MM_FROUND_NO_EXC);
 759 }
 760
 761 __m512i test_mm512_maskz_cvtt_roundps_epi64(__mmask8 __U, __m256 __A) {
 762   // CHECK-LABEL: @test_mm512_maskz_cvtt_roundps_epi64
 763   // CHECK: @llvm.x86.avx512.mask.cvttps2qq.512
 764   return _mm512_maskz_cvtt_roundps_epi64(__U, __A, _MM_FROUND_NO_EXC);
 765 }
 766
 767 __m512i test_mm512_cvttps_epu64(__m256 __A) {
 768   // CHECK-LABEL: @test_mm512_cvttps_epu64
 769   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.512
 770   return _mm512_cvttps_epu64(__A);
 771 }
 772
 773 __m512i test_mm512_mask_cvttps_epu64(__m512i __W, __mmask8 __U, __m256 __A) {
 774   // CHECK-LABEL: @test_mm512_mask_cvttps_epu64
 775   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.512
 776   return _mm512_mask_cvttps_epu64(__W, __U, __A);
 777 }
 778
 779 __m512i test_mm512_maskz_cvttps_epu64(__mmask8 __U, __m256 __A) {
 780   // CHECK-LABEL: @test_mm512_maskz_cvttps_epu64
 781   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.512
 782   return _mm512_maskz_cvttps_epu64(__U, __A);
 783 }
 784
 785 __m512i test_mm512_cvtt_roundps_epu64(__m256 __A) {
 786   // CHECK-LABEL: @test_mm512_cvtt_roundps_epu64
 787   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.512
 788   return _mm512_cvtt_roundps_epu64(__A, _MM_FROUND_NO_EXC);
 789 }
 790
 791 __m512i test_mm512_mask_cvtt_roundps_epu64(__m512i __W, __mmask8 __U, __m256 __A) {
 792   // CHECK-LABEL: @test_mm512_mask_cvtt_roundps_epu64
 793   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.512
 794   return _mm512_mask_cvtt_roundps_epu64(__W, __U, __A, _MM_FROUND_NO_EXC);
 795 }
 796
 797 __m512i test_mm512_maskz_cvtt_roundps_epu64(__mmask8 __U, __m256 __A) {
 798   // CHECK-LABEL: @test_mm512_maskz_cvtt_roundps_epu64
 799   // CHECK: @llvm.x86.avx512.mask.cvttps2uqq.512
 800   return _mm512_maskz_cvtt_roundps_epu64(__U, __A, _MM_FROUND_NO_EXC);
 801 }
 802
 803 __m512d test_mm512_cvtepu64_pd(__m512i __A) {
 804   // CHECK-LABEL: @test_mm512_cvtepu64_pd
 805   // CHECK: uitofp <8 x i64> %{{.*}} to <8 x double>
 806   return _mm512_cvtepu64_pd(__A);
 807 }
 808
 809 __m512d test_mm512_mask_cvtepu64_pd(__m512d __W, __mmask8 __U, __m512i __A) {
 810   // CHECK-LABEL: @test_mm512_mask_cvtepu64_pd
 811   // CHECK: uitofp <8 x i64> %{{.*}} to <8 x double>
 812   // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}
 813   return _mm512_mask_cvtepu64_pd(__W, __U, __A);
 814 }
 815
 816 __m512d test_mm512_maskz_cvtepu64_pd(__mmask8 __U, __m512i __A) {
 817   // CHECK-LABEL: @test_mm512_maskz_cvtepu64_pd
 818   // CHECK: uitofp <8 x i64> %{{.*}} to <8 x double>
 819   // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}
 820   return _mm512_maskz_cvtepu64_pd(__U, __A);
 821 }
 822
 823 __m512d test_mm512_cvt_roundepu64_pd(__m512i __A) {
 824   // CHECK-LABEL: @test_mm512_cvt_roundepu64_pd
 825   // CHECK: @llvm.x86.avx512.uitofp.round.v8f64.v8i64
 826   return _mm512_cvt_roundepu64_pd(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 827 }
 828
 829 __m512d test_mm512_mask_cvt_roundepu64_pd(__m512d __W, __mmask8 __U, __m512i __A) {
 830   // CHECK-LABEL: @test_mm512_mask_cvt_roundepu64_pd
 831   // CHECK: @llvm.x86.avx512.uitofp.round.v8f64.v8i64
 832   // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}
 833   return _mm512_mask_cvt_roundepu64_pd(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 834 }
 835
 836 __m512d test_mm512_maskz_cvt_roundepu64_pd(__mmask8 __U, __m512i __A) {
 837   // CHECK-LABEL: @test_mm512_maskz_cvt_roundepu64_pd
 838   // CHECK: @llvm.x86.avx512.uitofp.round.v8f64.v8i64
 839   // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}
 840   return _mm512_maskz_cvt_roundepu64_pd(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 841 }
 842
 843 __m256 test_mm512_cvtepu64_ps(__m512i __A) {
 844   // CHECK-LABEL: @test_mm512_cvtepu64_ps
 845   // CHECK: uitofp <8 x i64> %{{.*}} to <8 x float>
 846   return _mm512_cvtepu64_ps(__A);
 847 }
 848
 849 __m256 test_mm512_mask_cvtepu64_ps(__m256 __W, __mmask8 __U, __m512i __A) {
 850   // CHECK-LABEL: @test_mm512_mask_cvtepu64_ps
 851   // CHECK: uitofp <8 x i64> %{{.*}} to <8 x float>
 852   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 853   return _mm512_mask_cvtepu64_ps(__W, __U, __A);
 854 }
 855
 856 __m256 test_mm512_maskz_cvtepu64_ps(__mmask8 __U, __m512i __A) {
 857   // CHECK-LABEL: @test_mm512_maskz_cvtepu64_ps
 858   // CHECK: uitofp <8 x i64> %{{.*}} to <8 x float>
 859   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 860   return _mm512_maskz_cvtepu64_ps(__U, __A);
 861 }
 862
 863 __m256 test_mm512_cvt_roundepu64_ps(__m512i __A) {
 864   // CHECK-LABEL: @test_mm512_cvt_roundepu64_ps
 865   // CHECK: @llvm.x86.avx512.uitofp.round.v8f32.v8i64
 866   return _mm512_cvt_roundepu64_ps(__A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 867 }
 868
 869 __m256 test_mm512_mask_cvt_roundepu64_ps(__m256 __W, __mmask8 __U, __m512i __A) {
 870   // CHECK-LABEL: @test_mm512_mask_cvt_roundepu64_ps
 871   // CHECK: @llvm.x86.avx512.uitofp.round.v8f32.v8i64
 872   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 873   return _mm512_mask_cvt_roundepu64_ps(__W, __U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 874 }
 875
 876 __m256 test_mm512_maskz_cvt_roundepu64_ps(__mmask8 __U, __m512i __A) {
 877   // CHECK-LABEL: @test_mm512_maskz_cvt_roundepu64_ps
 878   // CHECK: @llvm.x86.avx512.uitofp.round.v8f32.v8i64
 879   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
 880   return _mm512_maskz_cvt_roundepu64_ps(__U, __A, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC);
 881 }
 882
 883 __m512d test_mm512_range_pd(__m512d __A, __m512d __B) {
 884   // CHECK-LABEL: @test_mm512_range_pd
 885   // CHECK: @llvm.x86.avx512.mask.range.pd.512
 886   return _mm512_range_pd(__A, __B, 4);
 887 }
 888
 889 __m512d test_mm512_mask_range_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) {
 890   // CHECK-LABEL: @test_mm512_mask_range_pd
 891   // CHECK: @llvm.x86.avx512.mask.range.pd.512
 892   return _mm512_mask_range_pd(__W, __U, __A, __B, 4);
 893 }
 894
 895 __m512d test_mm512_maskz_range_pd(__mmask8 __U, __m512d __A, __m512d __B) {
 896   // CHECK-LABEL: @test_mm512_maskz_range_pd
 897   // CHECK: @llvm.x86.avx512.mask.range.pd.512
 898   return _mm512_maskz_range_pd(__U, __A, __B, 4);
 899 }
 900
 901 __m512d test_mm512_range_round_pd(__m512d __A, __m512d __B) {
 902   // CHECK-LABEL: @test_mm512_range_round_pd
 903   // CHECK: @llvm.x86.avx512.mask.range.pd.512
 904   return _mm512_range_round_pd(__A, __B, 4, 8);
 905 }
 906
 907 __m512d test_mm512_mask_range_round_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) {
 908   // CHECK-LABEL: @test_mm512_mask_range_round_pd
 909   // CHECK: @llvm.x86.avx512.mask.range.pd.512
 910   return _mm512_mask_range_round_pd(__W, __U, __A, __B, 4, 8);
 911 }
 912
 913 __m512d test_mm512_maskz_range_round_pd(__mmask8 __U, __m512d __A, __m512d __B) {
 914   // CHECK-LABEL: @test_mm512_maskz_range_round_pd
 915   // CHECK: @llvm.x86.avx512.mask.range.pd.512
 916   return _mm512_maskz_range_round_pd(__U, __A, __B, 4, 8);
 917 }
 918
 919 __m128d test_mm512_range_round_sd(__m128d __A, __m128d __B) {
 920   // CHECK-LABEL: @test_mm512_range_round_sd
 921   // CHECK: @llvm.x86.avx512.mask.range.sd
 922   return _mm_range_round_sd(__A, __B, 4, 8);
 923 }
 924
 925 __m128d test_mm512_mask_range_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
 926   // CHECK-LABEL: test_mm512_mask_range_round_sd
 927   // CHECK: @llvm.x86.avx512.mask.range.sd
 928   return _mm_mask_range_round_sd(__W, __U, __A, __B, 4, 8);
 929 }
 930
 931 __m128d test_mm512_maskz_range_round_sd(__mmask8 __U, __m128d __A, __m128d __B) {
 932   // CHECK-LABEL: @test_mm512_maskz_range_round_sd
 933   // CHECK: @llvm.x86.avx512.mask.range.sd
 934   return _mm_maskz_range_round_sd(__U, __A, __B, 4, 8);
 935 }
 936
 937 __m128 test_mm512_range_round_ss(__m128 __A, __m128 __B) {
 938   // CHECK-LABEL: @test_mm512_range_round_ss
 939   // CHECK: @llvm.x86.avx512.mask.range.ss
 940   return _mm_range_round_ss(__A, __B, 4, 8);
 941 }
 942
 943 __m128 test_mm512_mask_range_round_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
 944   // CHECK-LABEL: @test_mm512_mask_range_round_ss
 945   // CHECK: @llvm.x86.avx512.mask.range.ss
 946   return _mm_mask_range_round_ss(__W, __U, __A, __B, 4, 8);
 947 }
 948
 949 __m128 test_mm512_maskz_range_round_ss(__mmask8 __U, __m128 __A, __m128 __B) {
 950   // CHECK-LABEL: @test_mm512_maskz_range_round_ss
 951   // CHECK: @llvm.x86.avx512.mask.range.ss
 952   return _mm_maskz_range_round_ss(__U, __A, __B, 4, 8);
 953 }
 954
 955 __m128d test_mm_range_sd(__m128d __A, __m128d __B) {
 956   // CHECK-LABEL: @test_mm_range_sd
 957   // CHECK: @llvm.x86.avx512.mask.range.sd
 958   return _mm_range_sd(__A, __B, 4);
 959 }
 960
 961 __m128d test_mm_mask_range_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
 962   // CHECK-LABEL: test_mm_mask_range_sd
 963   // CHECK: @llvm.x86.avx512.mask.range.sd
 964   return _mm_mask_range_sd(__W, __U, __A, __B, 4);
 965 }
 966
 967 __m128d test_mm_maskz_range_sd(__mmask8 __U, __m128d __A, __m128d __B) {
 968   // CHECK-LABEL: @test_mm_maskz_range_sd
 969   // CHECK: @llvm.x86.avx512.mask.range.sd
 970   return _mm_maskz_range_sd(__U, __A, __B, 4);
 971 }
 972
 973 __m128 test_mm_range_ss(__m128 __A, __m128 __B) {
 974   // CHECK-LABEL: @test_mm_range_ss
 975   // CHECK: @llvm.x86.avx512.mask.range.ss
 976   return _mm_range_ss(__A, __B, 4);
 977 }
 978
 979 __m128 test_mm_mask_range_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
 980   // CHECK-LABEL: @test_mm_mask_range_ss
 981   // CHECK: @llvm.x86.avx512.mask.range.ss
 982   return _mm_mask_range_ss(__W, __U, __A, __B, 4);
 983 }
 984
 985 __m128 test_mm_maskz_range_ss(__mmask8 __U, __m128 __A, __m128 __B) {
 986   // CHECK-LABEL: @test_mm_maskz_range_ss
 987   // CHECK: @llvm.x86.avx512.mask.range.ss
 988   return _mm_maskz_range_ss(__U, __A, __B, 4);
 989 }
 990
 991 __m512 test_mm512_range_ps(__m512 __A, __m512 __B) {
 992   // CHECK-LABEL: @test_mm512_range_ps
 993   // CHECK: @llvm.x86.avx512.mask.range.ps.512
 994   return _mm512_range_ps(__A, __B, 4);
 995 }
 996
 997 __m512 test_mm512_mask_range_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) {
 998   // CHECK-LABEL: @test_mm512_mask_range_ps
 999   // CHECK: @llvm.x86.avx512.mask.range.ps.512
1000   return _mm512_mask_range_ps(__W, __U, __A, __B, 4);
1001 }
1002
1003 __m512 test_mm512_maskz_range_ps(__mmask16 __U, __m512 __A, __m512 __B) {
1004   // CHECK-LABEL: @test_mm512_maskz_range_ps
1005   // CHECK: @llvm.x86.avx512.mask.range.ps.512
1006   return _mm512_maskz_range_ps(__U, __A, __B, 4);
1007 }
1008
1009 __m512 test_mm512_range_round_ps(__m512 __A, __m512 __B) {
1010   // CHECK-LABEL: @test_mm512_range_round_ps
1011   // CHECK: @llvm.x86.avx512.mask.range.ps.512
1012   return _mm512_range_round_ps(__A, __B, 4, 8);
1013 }
1014
1015 __m512 test_mm512_mask_range_round_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) {
1016   // CHECK-LABEL: @test_mm512_mask_range_round_ps
1017   // CHECK: @llvm.x86.avx512.mask.range.ps.512
1018   return _mm512_mask_range_round_ps(__W, __U, __A, __B, 4, 8);
1019 }
1020
1021 __m512 test_mm512_maskz_range_round_ps(__mmask16 __U, __m512 __A, __m512 __B) {
1022   // CHECK-LABEL: @test_mm512_maskz_range_round_ps
1023   // CHECK: @llvm.x86.avx512.mask.range.ps.512
1024   return _mm512_maskz_range_round_ps(__U, __A, __B, 4, 8);
1025 }
1026
1027 __m512d test_mm512_reduce_pd(__m512d __A) {
1028   // CHECK-LABEL: @test_mm512_reduce_pd
1029   // CHECK: @llvm.x86.avx512.mask.reduce.pd.512
1030   return _mm512_reduce_pd(__A, 4);
1031 }
1032
1033 __m512d test_mm512_mask_reduce_pd(__m512d __W, __mmask8 __U, __m512d __A) {
1034   // CHECK-LABEL: @test_mm512_mask_reduce_pd
1035   // CHECK: @llvm.x86.avx512.mask.reduce.pd.512
1036   return _mm512_mask_reduce_pd(__W, __U, __A, 4);
1037 }
1038
1039 __m512d test_mm512_maskz_reduce_pd(__mmask8 __U, __m512d __A) {
1040   // CHECK-LABEL: @test_mm512_maskz_reduce_pd
1041   // CHECK: @llvm.x86.avx512.mask.reduce.pd.512
1042   return _mm512_maskz_reduce_pd(__U, __A, 4);
1043 }
1044
1045 __m512 test_mm512_reduce_ps(__m512 __A) {
1046   // CHECK-LABEL: @test_mm512_reduce_ps
1047   // CHECK: @llvm.x86.avx512.mask.reduce.ps.512
1048   return _mm512_reduce_ps(__A, 4);
1049 }
1050
1051 __m512 test_mm512_mask_reduce_ps(__m512 __W, __mmask16 __U, __m512 __A) {
1052   // CHECK-LABEL: @test_mm512_mask_reduce_ps
1053   // CHECK: @llvm.x86.avx512.mask.reduce.ps.512
1054   return _mm512_mask_reduce_ps(__W, __U, __A, 4);
1055 }
1056
1057 __m512 test_mm512_maskz_reduce_ps(__mmask16 __U, __m512 __A) {
1058   // CHECK-LABEL: @test_mm512_maskz_reduce_ps
1059   // CHECK: @llvm.x86.avx512.mask.reduce.ps.512
1060   return _mm512_maskz_reduce_ps(__U, __A, 4);
1061 }
1062
1063 __m512d test_mm512_reduce_round_pd(__m512d __A) {
1064   // CHECK-LABEL: @test_mm512_reduce_round_pd
1065   // CHECK: @llvm.x86.avx512.mask.reduce.pd.512
1066   return _mm512_reduce_round_pd(__A, 4, 8);
1067 }
1068
1069 __m512d test_mm512_mask_reduce_round_pd(__m512d __W, __mmask8 __U, __m512d __A) {
1070   // CHECK-LABEL: @test_mm512_mask_reduce_round_pd
1071   // CHECK: @llvm.x86.avx512.mask.reduce.pd.512
1072   return _mm512_mask_reduce_round_pd(__W, __U, __A, 4, 8);
1073 }
1074
1075 __m512d test_mm512_maskz_reduce_round_pd(__mmask8 __U, __m512d __A) {
1076   // CHECK-LABEL: @test_mm512_maskz_reduce_round_pd
1077   // CHECK: @llvm.x86.avx512.mask.reduce.pd.512
1078   return _mm512_maskz_reduce_round_pd(__U, __A, 4, 8);
1079 }
1080
1081 __m512 test_mm512_reduce_round_ps(__m512 __A) {
1082   // CHECK-LABEL: @test_mm512_reduce_round_ps
1083   // CHECK: @llvm.x86.avx512.mask.reduce.ps.512
1084   return _mm512_reduce_round_ps(__A, 4, 8);
1085 }
1086
1087 __m512 test_mm512_mask_reduce_round_ps(__m512 __W, __mmask16 __U, __m512 __A) {
1088   // CHECK-LABEL: @test_mm512_mask_reduce_round_ps
1089   // CHECK: @llvm.x86.avx512.mask.reduce.ps.512
1090   return _mm512_mask_reduce_round_ps(__W, __U, __A, 4, 8);
1091 }
1092
1093 __m512 test_mm512_maskz_reduce_round_ps(__mmask16 __U, __m512 __A) {
1094   // CHECK-LABEL: @test_mm512_maskz_reduce_round_ps
1095   // CHECK: @llvm.x86.avx512.mask.reduce.ps.512
1096   return _mm512_maskz_reduce_round_ps(__U, __A, 4, 8);
1097 }
1098
1099 __m128 test_mm_reduce_ss(__m128 __A, __m128 __B) {
1100   // CHECK-LABEL: @test_mm_reduce_ss
1101   // CHECK: @llvm.x86.avx512.mask.reduce.ss
1102   return _mm_reduce_ss(__A, __B, 4);
1103 }
1104
1105 __m128 test_mm_mask_reduce_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
1106   // CHECK-LABEL: @test_mm_mask_reduce_ss
1107   // CHECK: @llvm.x86.avx512.mask.reduce.ss
1108   return _mm_mask_reduce_ss(__W, __U, __A, __B, 4);
1109 }
1110
1111 __m128 test_mm_maskz_reduce_ss(__mmask8 __U, __m128 __A, __m128 __B) {
1112   // CHECK-LABEL: @test_mm_maskz_reduce_ss
1113   // CHECK: @llvm.x86.avx512.mask.reduce.ss
1114   return _mm_maskz_reduce_ss(__U, __A, __B, 4);
1115 }
1116
1117 __m128 test_mm_reduce_round_ss(__m128 __A, __m128 __B) {
1118   // CHECK-LABEL: @test_mm_reduce_round_ss
1119   // CHECK: @llvm.x86.avx512.mask.reduce.ss
1120   return _mm_reduce_round_ss(__A, __B, 4, 8);
1121 }
1122
1123 __m128 test_mm_mask_reduce_round_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
1124   // CHECK-LABEL: @test_mm_mask_reduce_round_ss
1125   // CHECK: @llvm.x86.avx512.mask.reduce.ss
1126   return _mm_mask_reduce_round_ss(__W, __U, __A, __B, 4, 8);
1127 }
1128
1129 __m128 test_mm_maskz_reduce_round_ss(__mmask8 __U, __m128 __A, __m128 __B) {
1130   // CHECK-LABEL: @test_mm_maskz_reduce_round_ss
1131   // CHECK: @llvm.x86.avx512.mask.reduce.ss
1132   return _mm_maskz_reduce_round_ss(__U, __A, __B, 4, 8);
1133 }
1134
1135 __m128d test_mm_reduce_sd(__m128d __A, __m128d __B) {
1136   // CHECK-LABEL: @test_mm_reduce_sd
1137   // CHECK: @llvm.x86.avx512.mask.reduce.sd
1138   return _mm_reduce_sd(__A, __B, 4);
1139 }
1140
1141 __m128d test_mm_mask_reduce_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
1142   // CHECK-LABEL: @test_mm_mask_reduce_sd
1143   // CHECK: @llvm.x86.avx512.mask.reduce.sd
1144   return _mm_mask_reduce_sd(__W, __U, __A, __B, 4);
1145 }
1146
1147 __m128d test_mm_maskz_reduce_sd(__mmask8 __U, __m128d __A, __m128d __B) {
1148   // CHECK-LABEL: @test_mm_maskz_reduce_sd
1149   // CHECK: @llvm.x86.avx512.mask.reduce.sd
1150   return _mm_maskz_reduce_sd(__U, __A, __B, 4);
1151 }
1152
1153 __m128d test_mm_reduce_round_sd(__m128d __A, __m128d __B) {
1154   // CHECK-LABEL: @test_mm_reduce_round_sd
1155   // CHECK: @llvm.x86.avx512.mask.reduce.sd
1156   return _mm_reduce_round_sd(__A, __B, 4, 8);
1157 }
1158
1159 __m128d test_mm_mask_reduce_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
1160   // CHECK-LABEL: @test_mm_mask_reduce_round_sd
1161   // CHECK: @llvm.x86.avx512.mask.reduce.sd
1162   return _mm_mask_reduce_round_sd(__W, __U, __A, __B, 4, 8);
1163 }
1164
1165 __m128d test_mm_maskz_reduce_round_sd(__mmask8 __U, __m128d __A, __m128d __B) {
1166   // CHECK-LABEL: @test_mm_maskz_reduce_round_sd
1167   // CHECK: @llvm.x86.avx512.mask.reduce.sd
1168   return _mm_maskz_reduce_round_sd(__U, __A, __B, 4, 8);
1169 }
1170
1171 __mmask16 test_mm512_movepi32_mask(__m512i __A) {
1172   // CHECK-LABEL: @test_mm512_movepi32_mask
1173   // CHECK: [[CMP:%.*]] = icmp slt <16 x i32> %{{.*}}, zeroinitializer
1174   return _mm512_movepi32_mask(__A);
1175 }
1176
1177 __m512i test_mm512_movm_epi32(__mmask16 __A) {
1178   // CHECK-LABEL: @test_mm512_movm_epi32
1179   // CHECK: %{{.*}} = bitcast i16 %{{.*}} to <16 x i1>
1180   // CHECK: %vpmovm2.i = sext <16 x i1> %{{.*}} to <16 x i32>
1181   return _mm512_movm_epi32(__A);
1182 }
1183
1184 __m512i test_mm512_movm_epi64(__mmask8 __A) {
1185   // CHECK-LABEL: @test_mm512_movm_epi64
1186   // CHECK: %{{.*}} = bitcast i8 %{{.*}} to <8 x i1>
1187   // CHECK: %vpmovm2.i = sext <8 x i1> %{{.*}} to <8 x i64>
1188   return _mm512_movm_epi64(__A);
1189 }
1190
1191 __mmask8 test_mm512_movepi64_mask(__m512i __A) {
1192   // CHECK-LABEL: @test_mm512_movepi64_mask
1193   // CHECK: [[CMP:%.*]] = icmp slt <8 x i64> %{{.*}}, zeroinitializer
1194   return _mm512_movepi64_mask(__A);
1195 }
1196
1197 __m512 test_mm512_broadcast_f32x2(__m128 __A) {
1198   // CHECK-LABEL: @test_mm512_broadcast_f32x2
1199   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
1200   return _mm512_broadcast_f32x2(__A);
1201 }
1202
1203 __m512 test_mm512_mask_broadcast_f32x2(__m512 __O, __mmask16 __M, __m128 __A) {
1204   // CHECK-LABEL: @test_mm512_mask_broadcast_f32x2
1205   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
1206   // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
1207   return _mm512_mask_broadcast_f32x2(__O, __M, __A);
1208 }
1209
1210 __m512 test_mm512_maskz_broadcast_f32x2(__mmask16 __M, __m128 __A) {
1211   // CHECK-LABEL: @test_mm512_maskz_broadcast_f32x2
1212   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
1213   // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
1214   return _mm512_maskz_broadcast_f32x2(__M, __A);
1215 }
1216
1217 __m512 test_mm512_broadcast_f32x8(float const* __A) {
1218   // CHECK-LABEL: @test_mm512_broadcast_f32x8
1219   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1220   return _mm512_broadcast_f32x8(_mm256_loadu_ps(__A));
1221 }
1222
1223 __m512 test_mm512_mask_broadcast_f32x8(__m512 __O, __mmask16 __M, float const* __A) {
1224   // CHECK-LABEL: @test_mm512_mask_broadcast_f32x8
1225   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1226   // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
1227   return _mm512_mask_broadcast_f32x8(__O, __M, _mm256_loadu_ps(__A));
1228 }
1229
1230 __m512 test_mm512_maskz_broadcast_f32x8(__mmask16 __M, float const* __A) {
1231   // CHECK-LABEL: @test_mm512_maskz_broadcast_f32x8
1232   // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1233   // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
1234   return _mm512_maskz_broadcast_f32x8(__M, _mm256_loadu_ps(__A));
1235 }
1236
1237 __m512d test_mm512_broadcast_f64x2(double const* __A) {
1238   // CHECK-LABEL: @test_mm512_broadcast_f64x2
1239   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
1240   return _mm512_broadcast_f64x2(_mm_loadu_pd(__A));
1241 }
1242
1243 __m512d test_mm512_mask_broadcast_f64x2(__m512d __O, __mmask8 __M, double const* __A) {
1244   // CHECK-LABEL: @test_mm512_mask_broadcast_f64x2
1245   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
1246   // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}
1247   return _mm512_mask_broadcast_f64x2(__O, __M, _mm_loadu_pd(__A));
1248 }
1249
1250 __m512d test_mm512_maskz_broadcast_f64x2(__mmask8 __M, double const* __A) {
1251   // CHECK-LABEL: @test_mm512_maskz_broadcast_f64x2
1252   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
1253   // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}
1254   return _mm512_maskz_broadcast_f64x2(__M, _mm_loadu_pd(__A));
1255 }
1256
1257 __m512i test_mm512_broadcast_i32x2(__m128i __A) {
1258   // CHECK-LABEL: @test_mm512_broadcast_i32x2
1259   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
1260   return _mm512_broadcast_i32x2(__A);
1261 }
1262
1263 __m512i test_mm512_mask_broadcast_i32x2(__m512i __O, __mmask16 __M, __m128i __A) {
1264   // CHECK-LABEL: @test_mm512_mask_broadcast_i32x2
1265   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
1266   // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}}
1267   return _mm512_mask_broadcast_i32x2(__O, __M, __A);
1268 }
1269
1270 __m512i test_mm512_maskz_broadcast_i32x2(__mmask16 __M, __m128i __A) {
1271   // CHECK-LABEL: @test_mm512_maskz_broadcast_i32x2
1272   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
1273   // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}}
1274   return _mm512_maskz_broadcast_i32x2(__M, __A);
1275 }
1276
1277 __m512i test_mm512_broadcast_i32x8(__m256i const* __A) {
1278   // CHECK-LABEL: @test_mm512_broadcast_i32x8
1279   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1280   return _mm512_broadcast_i32x8(_mm256_loadu_si256(__A));
1281 }
1282
1283 __m512i test_mm512_mask_broadcast_i32x8(__m512i __O, __mmask16 __M, __m256i const* __A) {
1284   // CHECK-LABEL: @test_mm512_mask_broadcast_i32x8
1285   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1286   // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}}
1287   return _mm512_mask_broadcast_i32x8(__O, __M, _mm256_loadu_si256(__A));
1288 }
1289
1290 __m512i test_mm512_maskz_broadcast_i32x8(__mmask16 __M, __m256i const* __A) {
1291   // CHECK-LABEL: @test_mm512_maskz_broadcast_i32x8
1292   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1293   // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}}
1294   return _mm512_maskz_broadcast_i32x8(__M, _mm256_loadu_si256(__A));
1295 }
1296
1297 __m512i test_mm512_broadcast_i64x2(__m128i const* __A) {
1298   // CHECK-LABEL: @test_mm512_broadcast_i64x2
1299   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
1300   return _mm512_broadcast_i64x2(_mm_loadu_si128(__A));
1301 }
1302
1303 __m512i test_mm512_mask_broadcast_i64x2(__m512i __O, __mmask8 __M, __m128i const* __A) {
1304   // CHECK-LABEL: @test_mm512_mask_broadcast_i64x2
1305   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
1306   // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}}
1307   return _mm512_mask_broadcast_i64x2(__O, __M, _mm_loadu_si128(__A));
1308 }
1309
1310 __m512i test_mm512_maskz_broadcast_i64x2(__mmask8 __M, __m128i const* __A) {
1311   // CHECK-LABEL: @test_mm512_maskz_broadcast_i64x2
1312   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 0, i32 1, i32 0, i32 1, i32 0, i32 1>
1313   // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}}
1314   return _mm512_maskz_broadcast_i64x2(__M, _mm_loadu_si128(__A));
1315 }
1316
1317 __m256 test_mm512_extractf32x8_ps(__m512 __A) {
1318   // CHECK-LABEL: @test_mm512_extractf32x8_ps
1319   // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> poison, <8 x i32> <i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
1320   return _mm512_extractf32x8_ps(__A, 1);
1321 }
1322
1323 __m256 test_mm512_mask_extractf32x8_ps(__m256 __W, __mmask8 __U, __m512 __A) {
1324   // CHECK-LABEL: @test_mm512_mask_extractf32x8_ps
1325   // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> poison, <8 x i32> <i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
1326   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
1327   return _mm512_mask_extractf32x8_ps(__W, __U, __A, 1);
1328 }
1329
1330 __m256 test_mm512_maskz_extractf32x8_ps(__mmask8 __U, __m512 __A) {
1331   // CHECK-LABEL: @test_mm512_maskz_extractf32x8_ps
1332   // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> poison, <8 x i32> <i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
1333   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
1334   return _mm512_maskz_extractf32x8_ps(__U, __A, 1);
1335 }
1336
1337 __m128d test_mm512_extractf64x2_pd(__m512d __A) {
1338   // CHECK-LABEL: @test_mm512_extractf64x2_pd
1339   // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> poison, <2 x i32> <i32 6, i32 7>
1340   return _mm512_extractf64x2_pd(__A, 3);
1341 }
1342
1343 __m128d test_mm512_mask_extractf64x2_pd(__m128d __W, __mmask8 __U, __m512d __A) {
1344   // CHECK-LABEL: @test_mm512_mask_extractf64x2_pd
1345   // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> poison, <2 x i32> <i32 6, i32 7>
1346   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
1347   return _mm512_mask_extractf64x2_pd(__W, __U, __A, 3);
1348 }
1349
1350 __m128d test_mm512_maskz_extractf64x2_pd(__mmask8 __U, __m512d __A) {
1351   // CHECK-LABEL: @test_mm512_maskz_extractf64x2_pd
1352   // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> poison, <2 x i32> <i32 6, i32 7>
1353   // CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
1354   return _mm512_maskz_extractf64x2_pd(__U, __A, 3);
1355 }
1356
1357 __m256i test_mm512_extracti32x8_epi32(__m512i __A) {
1358   // CHECK-LABEL: @test_mm512_extracti32x8_epi32
1359   // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> poison, <8 x i32> <i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
1360   return _mm512_extracti32x8_epi32(__A, 1);
1361 }
1362
1363 __m256i test_mm512_mask_extracti32x8_epi32(__m256i __W, __mmask8 __U, __m512i __A) {
1364   // CHECK-LABEL: @test_mm512_mask_extracti32x8_epi32
1365   // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> poison, <8 x i32> <i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
1366   // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
1367   return _mm512_mask_extracti32x8_epi32(__W, __U, __A, 1);
1368 }
1369
1370 __m256i test_mm512_maskz_extracti32x8_epi32(__mmask8 __U, __m512i __A) {
1371   // CHECK-LABEL: @test_mm512_maskz_extracti32x8_epi32
1372   // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> poison, <8 x i32> <i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
1373   // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
1374   return _mm512_maskz_extracti32x8_epi32(__U, __A, 1);
1375 }
1376
1377 __m128i test_mm512_extracti64x2_epi64(__m512i __A) {
1378   // CHECK-LABEL: @test_mm512_extracti64x2_epi64
1379   // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> poison, <2 x i32> <i32 6, i32 7>
1380   return _mm512_extracti64x2_epi64(__A, 3);
1381 }
1382
1383 __m128i test_mm512_mask_extracti64x2_epi64(__m128i __W, __mmask8 __U, __m512i __A) {
1384   // CHECK-LABEL: @test_mm512_mask_extracti64x2_epi64
1385   // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> poison, <2 x i32> <i32 6, i32 7>
1386   // CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
1387   return _mm512_mask_extracti64x2_epi64(__W, __U, __A, 3);
1388 }
1389
1390 __m128i test_mm512_maskz_extracti64x2_epi64(__mmask8 __U, __m512i __A) {
1391   // CHECK-LABEL: @test_mm512_maskz_extracti64x2_epi64
1392   // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> poison, <2 x i32> <i32 6, i32 7>
1393   // CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
1394   return _mm512_maskz_extracti64x2_epi64(__U, __A, 3);
1395 }
1396
1397 __m512 test_mm512_insertf32x8(__m512 __A, __m256 __B) {
1398   // CHECK-LABEL: @test_mm512_insertf32x8
1399   // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23>
1400   return _mm512_insertf32x8(__A, __B, 1);
1401 }
1402
1403 __m512 test_mm512_mask_insertf32x8(__m512 __W, __mmask16 __U, __m512 __A, __m256 __B) {
1404   // CHECK-LABEL: @test_mm512_mask_insertf32x8
1405   // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23>
1406   // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
1407   return _mm512_mask_insertf32x8(__W, __U, __A, __B, 1);
1408 }
1409
1410 __m512 test_mm512_maskz_insertf32x8(__mmask16 __U, __m512 __A, __m256 __B) {
1411   // CHECK-LABEL: @test_mm512_maskz_insertf32x8
1412   // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23>
1413   // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}
1414   return _mm512_maskz_insertf32x8(__U, __A, __B, 1);
1415 }
1416
1417 __m512d test_mm512_insertf64x2(__m512d __A, __m128d __B) {
1418   // CHECK-LABEL: @test_mm512_insertf64x2
1419   // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 9>
1420   return _mm512_insertf64x2(__A, __B, 3);
1421 }
1422
1423 __m512d test_mm512_mask_insertf64x2(__m512d __W, __mmask8 __U, __m512d __A, __m128d __B) {
1424   // CHECK-LABEL: @test_mm512_mask_insertf64x2
1425   // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 9>
1426   // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}
1427   return _mm512_mask_insertf64x2(__W, __U, __A, __B, 3);
1428 }
1429
1430 __m512d test_mm512_maskz_insertf64x2(__mmask8 __U, __m512d __A, __m128d __B) {
1431   // CHECK-LABEL: @test_mm512_maskz_insertf64x2
1432   // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 9>
1433   // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}
1434   return _mm512_maskz_insertf64x2(__U, __A, __B, 3);
1435 }
1436
1437 __m512i test_mm512_inserti32x8(__m512i __A, __m256i __B) {
1438   // CHECK-LABEL: @test_mm512_inserti32x8
1439   // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23>
1440   return _mm512_inserti32x8(__A, __B, 1);
1441 }
1442
1443 __m512i test_mm512_mask_inserti32x8(__m512i __W, __mmask16 __U, __m512i __A, __m256i __B) {
1444   // CHECK-LABEL: @test_mm512_mask_inserti32x8
1445   // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23>
1446   // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}}
1447   return _mm512_mask_inserti32x8(__W, __U, __A, __B, 1);
1448 }
1449
1450 __m512i test_mm512_maskz_inserti32x8(__mmask16 __U, __m512i __A, __m256i __B) {
1451   // CHECK-LABEL: @test_mm512_maskz_inserti32x8
1452   // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23>
1453   // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}}
1454   return _mm512_maskz_inserti32x8(__U, __A, __B, 1);
1455 }
1456
1457 __m512i test_mm512_inserti64x2(__m512i __A, __m128i __B) {
1458   // CHECK-LABEL: @test_mm512_inserti64x2
1459   // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 8, i32 9, i32 4, i32 5, i32 6, i32 7>
1460   return _mm512_inserti64x2(__A, __B, 1);
1461 }
1462
1463 __m512i test_mm512_mask_inserti64x2(__m512i __W, __mmask8 __U, __m512i __A, __m128i __B) {
1464   // CHECK-LABEL: @test_mm512_mask_inserti64x2
1465   // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 8, i32 9, i32 4, i32 5, i32 6, i32 7>
1466   // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}}
1467   return _mm512_mask_inserti64x2(__W, __U, __A, __B, 1);
1468 }
1469
1470 __m512i test_mm512_maskz_inserti64x2(__mmask8 __U, __m512i __A, __m128i __B) {
1471   // CHECK-LABEL: @test_mm512_maskz_inserti64x2
1472   // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 8, i32 9, i32 4, i32 5, i32 6, i32 7>
1473   // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}}
1474   return _mm512_maskz_inserti64x2(__U, __A, __B, 1);
1475 }
1476 __mmask8 test_mm512_mask_fpclass_pd_mask(__mmask8 __U, __m512d __A) {
1477   // CHECK-LABEL: @test_mm512_mask_fpclass_pd_mask
1478   // CHECK: @llvm.x86.avx512.fpclass.pd.512
1479   return _mm512_mask_fpclass_pd_mask(__U, __A, 4);
1480 }
1481
1482 __mmask8 test_mm512_fpclass_pd_mask(__m512d __A) {
1483   // CHECK-LABEL: @test_mm512_fpclass_pd_mask
1484   // CHECK: @llvm.x86.avx512.fpclass.pd.512
1485   return _mm512_fpclass_pd_mask(__A, 4);
1486 }
1487
1488 __mmask16 test_mm512_mask_fpclass_ps_mask(__mmask16 __U, __m512 __A) {
1489   // CHECK-LABEL: @test_mm512_mask_fpclass_ps_mask
1490   // CHECK: @llvm.x86.avx512.fpclass.ps.512
1491   return _mm512_mask_fpclass_ps_mask(__U, __A, 4);
1492 }
1493
1494 __mmask16 test_mm512_fpclass_ps_mask(__m512 __A) {
1495   // CHECK-LABEL: @test_mm512_fpclass_ps_mask
1496   // CHECK: @llvm.x86.avx512.fpclass.ps.512
1497   return _mm512_fpclass_ps_mask(__A, 4);
1498 }
1499
1500 __mmask8 test_mm_fpclass_sd_mask(__m128d __A)  {
1501   // CHECK-LABEL: @test_mm_fpclass_sd_mask
1502   // CHECK: @llvm.x86.avx512.mask.fpclass.sd
1503  return _mm_fpclass_sd_mask (__A, 2);
1504 }
1505
1506 __mmask8 test_mm_mask_fpclass_sd_mask(__mmask8 __U, __m128d __A)  {
1507  // CHECK-LABEL: @test_mm_mask_fpclass_sd_mask
1508  // CHECK: @llvm.x86.avx512.mask.fpclass.sd
1509  return _mm_mask_fpclass_sd_mask (__U,  __A, 2);
1510 }
1511
1512 __mmask8 test_mm_fpclass_ss_mask(__m128 __A)  {
1513  // CHECK-LABEL: @test_mm_fpclass_ss_mask
1514  // CHECK: @llvm.x86.avx512.mask.fpclass.ss
1515  return _mm_fpclass_ss_mask ( __A, 2);
1516 }
1517
1518 __mmask8 test_mm_mask_fpclass_ss_mask(__mmask8 __U, __m128 __A)  {
1519  // CHECK-LABEL: @test_mm_mask_fpclass_ss_mask
1520  // CHECK: @llvm.x86.avx512.mask.fpclass.ss
1521  return _mm_mask_fpclass_ss_mask (__U, __A, 2);
1522 }
1523