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

   1 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512bw -emit-llvm -o - -Wall -Werror -Wsign-conversion | FileCheck %s
   2 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512bw -fno-signed-char -emit-llvm -o - -Wall -Werror -Wsign-conversion | FileCheck %s
   3
   4
   5 #include <immintrin.h>
   6
   7 __mmask32 test_knot_mask32(__mmask32 a) {
   8   // CHECK-LABEL: @test_knot_mask32
   9   // CHECK: [[IN:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
  10   // CHECK: [[NOT:%.*]] = xor <32 x i1> [[IN]], splat (i1 true)
  11   return _knot_mask32(a);
  12 }
  13
  14 __mmask64 test_knot_mask64(__mmask64 a) {
  15   // CHECK-LABEL: @test_knot_mask64
  16   // CHECK: [[IN:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
  17   // CHECK: [[NOT:%.*]] = xor <64 x i1> [[IN]], splat (i1 true)
  18   return _knot_mask64(a);
  19 }
  20
  21 __mmask32 test_kand_mask32(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
  22   // CHECK-LABEL: @test_kand_mask32
  23   // CHECK: [[LHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
  24   // CHECK: [[RHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
  25   // CHECK: [[RES:%.*]] = and <32 x i1> [[LHS]], [[RHS]]
  26   return _mm512_mask_cmpneq_epu16_mask(_kand_mask32(_mm512_cmpneq_epu16_mask(__A, __B),
  27                                                     _mm512_cmpneq_epu16_mask(__C, __D)),
  28                                                     __E, __F);
  29 }
  30
  31 __mmask64 test_kand_mask64(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
  32   // CHECK-LABEL: @test_kand_mask64
  33   // CHECK: [[LHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
  34   // CHECK: [[RHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
  35   // CHECK: [[RES:%.*]] = and <64 x i1> [[LHS]], [[RHS]]
  36   return _mm512_mask_cmpneq_epu8_mask(_kand_mask64(_mm512_cmpneq_epu8_mask(__A, __B),
  37                                                    _mm512_cmpneq_epu8_mask(__C, __D)),
  38                                                    __E, __F);
  39 }
  40
  41 __mmask32 test_kandn_mask32(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
  42   // CHECK-LABEL: @test_kandn_mask32
  43   // CHECK: [[LHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
  44   // CHECK: [[RHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
  45   // CHECK: [[NOT:%.*]] = xor <32 x i1> [[LHS]], splat (i1 true)
  46   // CHECK: [[RES:%.*]] = and <32 x i1> [[NOT]], [[RHS]]
  47   return _mm512_mask_cmpneq_epu16_mask(_kandn_mask32(_mm512_cmpneq_epu16_mask(__A, __B),
  48                                                      _mm512_cmpneq_epu16_mask(__C, __D)),
  49                                                      __E, __F);
  50 }
  51
  52 __mmask64 test_kandn_mask64(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
  53   // CHECK-LABEL: @test_kandn_mask64
  54   // CHECK: [[LHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
  55   // CHECK: [[RHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
  56   // CHECK: [[NOT:%.*]] = xor <64 x i1> [[LHS]], splat (i1 true)
  57   // CHECK: [[RES:%.*]] = and <64 x i1> [[NOT]], [[RHS]]
  58   return _mm512_mask_cmpneq_epu8_mask(_kandn_mask64(_mm512_cmpneq_epu8_mask(__A, __B),
  59                                                     _mm512_cmpneq_epu8_mask(__C, __D)),
  60                                                     __E, __F);
  61 }
  62
  63 __mmask32 test_kor_mask32(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
  64   // CHECK-LABEL: @test_kor_mask32
  65   // CHECK: [[LHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
  66   // CHECK: [[RHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
  67   // CHECK: [[RES:%.*]] = or <32 x i1> [[LHS]], [[RHS]]
  68   return _mm512_mask_cmpneq_epu16_mask(_kor_mask32(_mm512_cmpneq_epu16_mask(__A, __B),
  69                                                    _mm512_cmpneq_epu16_mask(__C, __D)),
  70                                                    __E, __F);
  71 }
  72
  73 __mmask64 test_kor_mask64(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
  74   // CHECK-LABEL: @test_kor_mask64
  75   // CHECK: [[LHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
  76   // CHECK: [[RHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
  77   // CHECK: [[RES:%.*]] = or <64 x i1> [[LHS]], [[RHS]]
  78   return _mm512_mask_cmpneq_epu8_mask(_kor_mask64(_mm512_cmpneq_epu8_mask(__A, __B),
  79                                                   _mm512_cmpneq_epu8_mask(__C, __D)),
  80                                                   __E, __F);
  81 }
  82
  83 __mmask32 test_kxnor_mask32(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
  84   // CHECK-LABEL: @test_kxnor_mask32
  85   // CHECK: [[LHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
  86   // CHECK: [[RHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
  87   // CHECK: [[NOT:%.*]] = xor <32 x i1> [[LHS]], splat (i1 true)
  88   // CHECK: [[RES:%.*]] = xor <32 x i1> [[NOT]], [[RHS]]
  89   return _mm512_mask_cmpneq_epu16_mask(_kxnor_mask32(_mm512_cmpneq_epu16_mask(__A, __B),
  90                                                      _mm512_cmpneq_epu16_mask(__C, __D)),
  91                                                      __E, __F);
  92 }
  93
  94 __mmask64 test_kxnor_mask64(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
  95   // CHECK-LABEL: @test_kxnor_mask64
  96   // CHECK: [[LHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
  97   // CHECK: [[RHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
  98   // CHECK: [[NOT:%.*]] = xor <64 x i1> [[LHS]], splat (i1 true)
  99   // CHECK: [[RES:%.*]] = xor <64 x i1> [[NOT]], [[RHS]]
 100   return _mm512_mask_cmpneq_epu8_mask(_kxnor_mask64(_mm512_cmpneq_epu8_mask(__A, __B),
 101                                                     _mm512_cmpneq_epu8_mask(__C, __D)),
 102                                                     __E, __F);
 103 }
 104
 105 __mmask32 test_kxor_mask32(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
 106   // CHECK-LABEL: @test_kxor_mask32
 107   // CHECK: [[LHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 108   // CHECK: [[RHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 109   // CHECK: [[RES:%.*]] = xor <32 x i1> [[LHS]], [[RHS]]
 110   return _mm512_mask_cmpneq_epu16_mask(_kxor_mask32(_mm512_cmpneq_epu16_mask(__A, __B),
 111                                                     _mm512_cmpneq_epu16_mask(__C, __D)),
 112                                                     __E, __F);
 113 }
 114
 115 __mmask64 test_kxor_mask64(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
 116   // CHECK-LABEL: @test_kxor_mask64
 117   // CHECK: [[LHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 118   // CHECK: [[RHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 119   // CHECK: [[RES:%.*]] = xor <64 x i1> [[LHS]], [[RHS]]
 120   return _mm512_mask_cmpneq_epu8_mask(_kxor_mask64(_mm512_cmpneq_epu8_mask(__A, __B),
 121                                                    _mm512_cmpneq_epu8_mask(__C, __D)),
 122                                                    __E, __F);
 123 }
 124
 125 unsigned char test_kortestz_mask32_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D) {
 126   // CHECK-LABEL: @test_kortestz_mask32_u8
 127   // CHECK: [[LHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 128   // CHECK: [[RHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 129   // CHECK: [[OR:%.*]] = or <32 x i1> [[LHS]], [[RHS]]
 130   // CHECK: [[CAST:%.*]] = bitcast <32 x i1> [[OR]] to i32
 131   // CHECK: [[CMP:%.*]] = icmp eq i32 [[CAST]], 0
 132   // CHECK: [[ZEXT:%.*]] = zext i1 [[CMP]] to i32
 133   // CHECK: trunc i32 [[ZEXT]] to i8
 134   return _kortestz_mask32_u8(_mm512_cmpneq_epu16_mask(__A, __B),
 135                              _mm512_cmpneq_epu16_mask(__C, __D));
 136 }
 137
 138 unsigned char test_kortestc_mask32_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D) {
 139   // CHECK-LABEL: @test_kortestc_mask32_u8
 140   // CHECK: [[LHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 141   // CHECK: [[RHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 142   // CHECK: [[OR:%.*]] = or <32 x i1> [[LHS]], [[RHS]]
 143   // CHECK: [[CAST:%.*]] = bitcast <32 x i1> [[OR]] to i32
 144   // CHECK: [[CMP:%.*]] = icmp eq i32 [[CAST]], -1
 145   // CHECK: [[ZEXT:%.*]] = zext i1 [[CMP]] to i32
 146   // CHECK: trunc i32 [[ZEXT]] to i8
 147   return _kortestc_mask32_u8(_mm512_cmpneq_epu16_mask(__A, __B),
 148                              _mm512_cmpneq_epu16_mask(__C, __D));
 149 }
 150
 151 unsigned char test_kortest_mask32_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D, unsigned char *CF) {
 152   // CHECK-LABEL: @test_kortest_mask32_u8
 153   // CHECK: [[LHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 154   // CHECK: [[RHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 155   // CHECK: [[OR:%.*]] = or <32 x i1> [[LHS]], [[RHS]]
 156   // CHECK: [[CAST:%.*]] = bitcast <32 x i1> [[OR]] to i32
 157   // CHECK: [[CMP:%.*]] = icmp eq i32 [[CAST]], -1
 158   // CHECK: [[ZEXT:%.*]] = zext i1 [[CMP]] to i32
 159   // CHECK: trunc i32 [[ZEXT]] to i8
 160   // CHECK: [[LHS2:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 161   // CHECK: [[RHS2:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 162   // CHECK: [[OR2:%.*]] = or <32 x i1> [[LHS2]], [[RHS2]]
 163   // CHECK: [[CAST2:%.*]] = bitcast <32 x i1> [[OR2]] to i32
 164   // CHECK: [[CMP2:%.*]] = icmp eq i32 [[CAST2]], 0
 165   // CHECK: [[ZEXT2:%.*]] = zext i1 [[CMP2]] to i32
 166   // CHECK: trunc i32 [[ZEXT2]] to i8
 167   return _kortest_mask32_u8(_mm512_cmpneq_epu16_mask(__A, __B),
 168                             _mm512_cmpneq_epu16_mask(__C, __D), CF);
 169 }
 170
 171 unsigned char test_kortestz_mask64_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D) {
 172   // CHECK-LABEL: @test_kortestz_mask64_u8
 173   // CHECK: [[LHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 174   // CHECK: [[RHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 175   // CHECK: [[OR:%.*]] = or <64 x i1> [[LHS]], [[RHS]]
 176   // CHECK: [[CAST:%.*]] = bitcast <64 x i1> [[OR]] to i64
 177   // CHECK: [[CMP:%.*]] = icmp eq i64 [[CAST]], 0
 178   // CHECK: [[ZEXT:%.*]] = zext i1 [[CMP]] to i32
 179   // CHECK: trunc i32 [[ZEXT]] to i8
 180   return _kortestz_mask64_u8(_mm512_cmpneq_epu8_mask(__A, __B),
 181                              _mm512_cmpneq_epu8_mask(__C, __D));
 182 }
 183
 184 unsigned char test_kortestc_mask64_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D) {
 185   // CHECK-LABEL: @test_kortestc_mask64_u8
 186   // CHECK: [[LHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 187   // CHECK: [[RHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 188   // CHECK: [[OR:%.*]] = or <64 x i1> [[LHS]], [[RHS]]
 189   // CHECK: [[CAST:%.*]] = bitcast <64 x i1> [[OR]] to i64
 190   // CHECK: [[CMP:%.*]] = icmp eq i64 [[CAST]], -1
 191   // CHECK: [[ZEXT:%.*]] = zext i1 [[CMP]] to i32
 192   // CHECK: trunc i32 [[ZEXT]] to i8
 193   return _kortestc_mask64_u8(_mm512_cmpneq_epu8_mask(__A, __B),
 194                              _mm512_cmpneq_epu8_mask(__C, __D));
 195 }
 196
 197 unsigned char test_kortest_mask64_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D, unsigned char *CF) {
 198   // CHECK-LABEL: @test_kortest_mask64_u8
 199   // CHECK: [[LHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 200   // CHECK: [[RHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 201   // CHECK: [[OR:%.*]] = or <64 x i1> [[LHS]], [[RHS]]
 202   // CHECK: [[CAST:%.*]] = bitcast <64 x i1> [[OR]] to i64
 203   // CHECK: [[CMP:%.*]] = icmp eq i64 [[CAST]], -1
 204   // CHECK: [[ZEXT:%.*]] = zext i1 [[CMP]] to i32
 205   // CHECK: trunc i32 [[ZEXT]] to i8
 206   // CHECK: [[LHS2:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 207   // CHECK: [[RHS2:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 208   // CHECK: [[OR2:%.*]] = or <64 x i1> [[LHS2]], [[RHS2]]
 209   // CHECK: [[CAST2:%.*]] = bitcast <64 x i1> [[OR2]] to i64
 210   // CHECK: [[CMP2:%.*]] = icmp eq i64 [[CAST2]], 0
 211   // CHECK: [[ZEXT2:%.*]] = zext i1 [[CMP2]] to i32
 212   // CHECK: trunc i32 [[ZEXT2]] to i8
 213   return _kortest_mask64_u8(_mm512_cmpneq_epu8_mask(__A, __B),
 214                             _mm512_cmpneq_epu8_mask(__C, __D), CF);
 215 }
 216
 217 unsigned char test_ktestz_mask32_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D) {
 218   // CHECK-LABEL: @test_ktestz_mask32_u8
 219   // CHECK: [[LHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 220   // CHECK: [[RHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 221   // CHECK: [[RES:%.*]] = call i32 @llvm.x86.avx512.ktestz.d(<32 x i1> [[LHS]], <32 x i1> [[RHS]])
 222   // CHECK: trunc i32 [[RES]] to i8
 223   return _ktestz_mask32_u8(_mm512_cmpneq_epu16_mask(__A, __B),
 224                            _mm512_cmpneq_epu16_mask(__C, __D));
 225 }
 226
 227 unsigned char test_ktestc_mask32_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D) {
 228   // CHECK-LABEL: @test_ktestc_mask32_u8
 229   // CHECK: [[LHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 230   // CHECK: [[RHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 231   // CHECK: [[RES:%.*]] = call i32 @llvm.x86.avx512.ktestc.d(<32 x i1> [[LHS]], <32 x i1> [[RHS]])
 232   // CHECK: trunc i32 [[RES]] to i8
 233   return _ktestc_mask32_u8(_mm512_cmpneq_epu16_mask(__A, __B),
 234                            _mm512_cmpneq_epu16_mask(__C, __D));
 235 }
 236
 237 unsigned char test_ktest_mask32_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D, unsigned char *CF) {
 238   // CHECK-LABEL: @test_ktest_mask32_u8
 239   // CHECK: [[LHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 240   // CHECK: [[RHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 241   // CHECK: [[RES:%.*]] = call i32 @llvm.x86.avx512.ktestc.d(<32 x i1> [[LHS]], <32 x i1> [[RHS]])
 242   // CHECK: trunc i32 [[RES]] to i8
 243   // CHECK: [[LHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 244   // CHECK: [[RHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 245   // CHECK: [[RES:%.*]] = call i32 @llvm.x86.avx512.ktestz.d(<32 x i1> [[LHS]], <32 x i1> [[RHS]])
 246   // CHECK: trunc i32 [[RES]] to i8
 247   return _ktest_mask32_u8(_mm512_cmpneq_epu16_mask(__A, __B),
 248                           _mm512_cmpneq_epu16_mask(__C, __D), CF);
 249 }
 250
 251 unsigned char test_ktestz_mask64_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D) {
 252   // CHECK-LABEL: @test_ktestz_mask64_u8
 253   // CHECK: [[LHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 254   // CHECK: [[RHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 255   // CHECK: [[RES:%.*]] = call i32 @llvm.x86.avx512.ktestz.q(<64 x i1> [[LHS]], <64 x i1> [[RHS]])
 256   // CHECK: trunc i32 [[RES]] to i8
 257   return _ktestz_mask64_u8(_mm512_cmpneq_epu8_mask(__A, __B),
 258                            _mm512_cmpneq_epu8_mask(__C, __D));
 259 }
 260
 261 unsigned char test_ktestc_mask64_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D) {
 262   // CHECK-LABEL: @test_ktestc_mask64_u8
 263   // CHECK: [[LHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 264   // CHECK: [[RHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 265   // CHECK: [[RES:%.*]] = call i32 @llvm.x86.avx512.ktestc.q(<64 x i1> [[LHS]], <64 x i1> [[RHS]])
 266   // CHECK: trunc i32 [[RES]] to i8
 267   return _ktestc_mask64_u8(_mm512_cmpneq_epu8_mask(__A, __B),
 268                            _mm512_cmpneq_epu8_mask(__C, __D));
 269 }
 270
 271 unsigned char test_ktest_mask64_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D, unsigned char *CF) {
 272   // CHECK-LABEL: @test_ktest_mask64_u8
 273   // CHECK: [[LHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 274   // CHECK: [[RHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 275   // CHECK: [[RES:%.*]] = call i32 @llvm.x86.avx512.ktestc.q(<64 x i1> [[LHS]], <64 x i1> [[RHS]])
 276   // CHECK: trunc i32 [[RES]] to i8
 277   // CHECK: [[LHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 278   // CHECK: [[RHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 279   // CHECK: [[RES:%.*]] = call i32 @llvm.x86.avx512.ktestz.q(<64 x i1> [[LHS]], <64 x i1> [[RHS]])
 280   // CHECK: trunc i32 [[RES]] to i8
 281   return _ktest_mask64_u8(_mm512_cmpneq_epu8_mask(__A, __B),
 282                           _mm512_cmpneq_epu8_mask(__C, __D), CF);
 283 }
 284
 285 __mmask32 test_kadd_mask32(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
 286   // CHECK-LABEL: @test_kadd_mask32
 287   // CHECK: [[LHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 288   // CHECK: [[RHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 289   // CHECK: [[RES:%.*]] = call <32 x i1> @llvm.x86.avx512.kadd.d(<32 x i1> [[LHS]], <32 x i1> [[RHS]])
 290   return _mm512_mask_cmpneq_epu16_mask(_kadd_mask32(_mm512_cmpneq_epu16_mask(__A, __B),
 291                                                     _mm512_cmpneq_epu16_mask(__C, __D)),
 292                                                     __E, __F);
 293 }
 294
 295 __mmask64 test_kadd_mask64(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
 296   // CHECK-LABEL: @test_kadd_mask64
 297   // CHECK: [[LHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 298   // CHECK: [[RHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 299   // CHECK: [[RES:%.*]] = call <64 x i1> @llvm.x86.avx512.kadd.q(<64 x i1> [[LHS]], <64 x i1> [[RHS]])
 300   return _mm512_mask_cmpneq_epu8_mask(_kadd_mask64(_mm512_cmpneq_epu8_mask(__A, __B),
 301                                                    _mm512_cmpneq_epu8_mask(__C, __D)),
 302                                                    __E, __F);
 303 }
 304
 305 __mmask32 test_kshiftli_mask32(__m512i A, __m512i B, __m512i C, __m512i D) {
 306   // CHECK-LABEL: @test_kshiftli_mask32
 307   // CHECK: [[VAL:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 308   // CHECK: [[RES:%.*]] = shufflevector <32 x i1> zeroinitializer, <32 x i1> [[VAL]], <32 x i32> <i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 32>
 309   return _mm512_mask_cmpneq_epu16_mask(_kshiftli_mask32(_mm512_cmpneq_epu16_mask(A, B), 31), C, D);
 310 }
 311
 312 __mmask32 test_kshiftri_mask32(__m512i A, __m512i B, __m512i C, __m512i D) {
 313   // CHECK-LABEL: @test_kshiftri_mask32
 314   // CHECK: [[VAL:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
 315   // CHECK: [[RES:%.*]] = shufflevector <32 x i1> [[VAL]], <32 x i1> zeroinitializer, <32 x i32> <i32 31, i32 32, i32 33, i32 34, i32 35, i32 36, i32 37, i32 38, i32 39, i32 40, i32 41, i32 42, i32 43, i32 44, i32 45, i32 46, i32 47, i32 48, i32 49, i32 50, i32 51, i32 52, i32 53, i32 54, i32 55, i32 56, i32 57, i32 58, i32 59, i32 60, i32 61, i32 62>
 316   return _mm512_mask_cmpneq_epu16_mask(_kshiftri_mask32(_mm512_cmpneq_epu16_mask(A, B), 31), C, D);
 317 }
 318
 319 __mmask64 test_kshiftli_mask64(__m512i A, __m512i B, __m512i C, __m512i D) {
 320   // CHECK-LABEL: @test_kshiftli_mask64
 321   // CHECK: [[VAL:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 322   // CHECK: [[RES:%.*]] = shufflevector <64 x i1> zeroinitializer, <64 x i1> [[VAL]], <64 x i32> <i32 32, i32 33, i32 34, i32 35, i32 36, i32 37, i32 38, i32 39, i32 40, i32 41, i32 42, i32 43, i32 44, i32 45, i32 46, i32 47, i32 48, i32 49, i32 50, i32 51, i32 52, i32 53, i32 54, i32 55, i32 56, i32 57, i32 58, i32 59, i32 60, i32 61, i32 62, i32 63, i32 64, i32 65, i32 66, i32 67, i32 68, i32 69, i32 70, i32 71, i32 72, i32 73, i32 74, i32 75, i32 76, i32 77, i32 78, i32 79, i32 80, i32 81, i32 82, i32 83, i32 84, i32 85, i32 86, i32 87, i32 88, i32 89, i32 90, i32 91, i32 92, i32 93, i32 94, i32 95>
 323   return _mm512_mask_cmpneq_epu8_mask(_kshiftli_mask64(_mm512_cmpneq_epu8_mask(A, B), 32), C, D);
 324 }
 325
 326 __mmask64 test_kshiftri_mask64(__m512i A, __m512i B, __m512i C, __m512i D) {
 327   // CHECK-LABEL: @test_kshiftri_mask64
 328   // CHECK: [[VAL:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
 329   // CHECK: [[RES:%.*]] = shufflevector <64 x i1> [[VAL]], <64 x i1> zeroinitializer, <64 x i32> <i32 32, i32 33, i32 34, i32 35, i32 36, i32 37, i32 38, i32 39, i32 40, i32 41, i32 42, i32 43, i32 44, i32 45, i32 46, i32 47, i32 48, i32 49, i32 50, i32 51, i32 52, i32 53, i32 54, i32 55, i32 56, i32 57, i32 58, i32 59, i32 60, i32 61, i32 62, i32 63, i32 64, i32 65, i32 66, i32 67, i32 68, i32 69, i32 70, i32 71, i32 72, i32 73, i32 74, i32 75, i32 76, i32 77, i32 78, i32 79, i32 80, i32 81, i32 82, i32 83, i32 84, i32 85, i32 86, i32 87, i32 88, i32 89, i32 90, i32 91, i32 92, i32 93, i32 94, i32 95>
 330   return _mm512_mask_cmpneq_epu8_mask(_kshiftri_mask64(_mm512_cmpneq_epu8_mask(A, B), 32), C, D);
 331 }
 332
 333 unsigned int test_cvtmask32_u32(__m512i A, __m512i B) {
 334   // CHECK-LABEL: @test_cvtmask32_u32
 335   return _cvtmask32_u32(_mm512_cmpneq_epu16_mask(A, B));
 336 }
 337
 338 unsigned long long test_cvtmask64_u64(__m512i A, __m512i B) {
 339   // CHECK-LABEL: @test_cvtmask64_u64
 340   return _cvtmask64_u64(_mm512_cmpneq_epu8_mask(A, B));
 341 }
 342
 343 __mmask32 test_cvtu32_mask32(__m512i A, __m512i B, unsigned int C) {
 344   // CHECK-LABEL: @test_cvtu32_mask32
 345   return _mm512_mask_cmpneq_epu16_mask(_cvtu32_mask32(C), A, B);
 346 }
 347
 348 __mmask64 test_cvtu64_mask64(__m512i A, __m512i B, unsigned long long C) {
 349   // CHECK-LABEL: @test_cvtu64_mask64
 350   return _mm512_mask_cmpneq_epu8_mask(_cvtu64_mask64(C), A, B);
 351 }
 352
 353 __mmask32 test_load_mask32(__mmask32 *A, __m512i B, __m512i C) {
 354   // CHECK-LABEL: @test_load_mask32
 355   // CHECK: [[LOAD:%.*]] = load i32, ptr %{{.*}}
 356   return _mm512_mask_cmpneq_epu16_mask(_load_mask32(A), B, C);
 357 }
 358
 359 __mmask64 test_load_mask64(__mmask64 *A, __m512i B, __m512i C) {
 360   // CHECK-LABEL: @test_load_mask64
 361   // CHECK: [[LOAD:%.*]] = load i64, ptr %{{.*}}
 362   return _mm512_mask_cmpneq_epu8_mask(_load_mask64(A), B, C);
 363 }
 364
 365 void test_store_mask32(__mmask32 *A, __m512i B, __m512i C) {
 366   // CHECK-LABEL: @test_store_mask32
 367   // CHECK: store i32 %{{.*}}, ptr %{{.*}}
 368   _store_mask32(A, _mm512_cmpneq_epu16_mask(B, C));
 369 }
 370
 371 void test_store_mask64(__mmask64 *A, __m512i B, __m512i C) {
 372   // CHECK-LABEL: @test_store_mask64
 373   // CHECK: store i64 %{{.*}}, ptr %{{.*}}
 374   _store_mask64(A, _mm512_cmpneq_epu8_mask(B, C));
 375 }
 376
 377 __mmask64 test_mm512_cmpeq_epi8_mask(__m512i __a, __m512i __b) {
 378   // CHECK-LABEL: @test_mm512_cmpeq_epi8_mask
 379   // CHECK: icmp eq <64 x i8> %{{.*}}, %{{.*}}
 380   return (__mmask64)_mm512_cmpeq_epi8_mask(__a, __b);
 381 }
 382
 383 __mmask64 test_mm512_mask_cmpeq_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) {
 384   // CHECK-LABEL: @test_mm512_mask_cmpeq_epi8_mask
 385   // CHECK: icmp eq <64 x i8> %{{.*}}, %{{.*}}
 386   // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
 387   return (__mmask64)_mm512_mask_cmpeq_epi8_mask(__u, __a, __b);
 388 }
 389
 390 __mmask32 test_mm512_cmpeq_epi16_mask(__m512i __a, __m512i __b) {
 391   // CHECK-LABEL: @test_mm512_cmpeq_epi16_mask
 392   // CHECK: icmp eq <32 x i16> %{{.*}}, %{{.*}}
 393   return (__mmask32)_mm512_cmpeq_epi16_mask(__a, __b);
 394 }
 395
 396 __mmask32 test_mm512_mask_cmpeq_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) {
 397   // CHECK-LABEL: @test_mm512_mask_cmpeq_epi16_mask
 398   // CHECK: icmp eq <32 x i16> %{{.*}}, %{{.*}}
 399   // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
 400   return (__mmask32)_mm512_mask_cmpeq_epi16_mask(__u, __a, __b);
 401 }
 402
 403 __mmask64 test_mm512_cmpgt_epi8_mask(__m512i __a, __m512i __b) {
 404   // CHECK-LABEL: @test_mm512_cmpgt_epi8_mask
 405   // CHECK: icmp sgt <64 x i8> %{{.*}}, %{{.*}}
 406   return (__mmask64)_mm512_cmpgt_epi8_mask(__a, __b);
 407 }
 408
 409 __mmask64 test_mm512_mask_cmpgt_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) {
 410   // CHECK-LABEL: @test_mm512_mask_cmpgt_epi8_mask
 411   // CHECK: icmp sgt <64 x i8> %{{.*}}, %{{.*}}
 412   // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
 413   return (__mmask64)_mm512_mask_cmpgt_epi8_mask(__u, __a, __b);
 414 }
 415
 416 __mmask32 test_mm512_cmpgt_epi16_mask(__m512i __a, __m512i __b) {
 417   // CHECK-LABEL: @test_mm512_cmpgt_epi16_mask
 418   // CHECK: icmp sgt <32 x i16> %{{.*}}, %{{.*}}
 419   return (__mmask32)_mm512_cmpgt_epi16_mask(__a, __b);
 420 }
 421
 422 __mmask32 test_mm512_mask_cmpgt_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) {
 423   // CHECK-LABEL: @test_mm512_mask_cmpgt_epi16_mask
 424   // CHECK: icmp sgt <32 x i16> %{{.*}}, %{{.*}}
 425   // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
 426   return (__mmask32)_mm512_mask_cmpgt_epi16_mask(__u, __a, __b);
 427 }
 428
 429 __mmask64 test_mm512_cmpeq_epu8_mask(__m512i __a, __m512i __b) {
 430   // CHECK-LABEL: @test_mm512_cmpeq_epu8_mask
 431   // CHECK: icmp eq <64 x i8> %{{.*}}, %{{.*}}
 432   return (__mmask64)_mm512_cmpeq_epu8_mask(__a, __b);
 433 }
 434
 435 __mmask64 test_mm512_mask_cmpeq_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) {
 436   // CHECK-LABEL: @test_mm512_mask_cmpeq_epu8_mask
 437   // CHECK: icmp eq <64 x i8> %{{.*}}, %{{.*}}
 438   // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
 439   return (__mmask64)_mm512_mask_cmpeq_epu8_mask(__u, __a, __b);
 440 }
 441
 442 __mmask32 test_mm512_cmpeq_epu16_mask(__m512i __a, __m512i __b) {
 443   // CHECK-LABEL: @test_mm512_cmpeq_epu16_mask
 444   // CHECK: icmp eq <32 x i16> %{{.*}}, %{{.*}}
 445   return (__mmask32)_mm512_cmpeq_epu16_mask(__a, __b);
 446 }
 447
 448 __mmask32 test_mm512_mask_cmpeq_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) {
 449   // CHECK-LABEL: @test_mm512_mask_cmpeq_epu16_mask
 450   // CHECK: icmp eq <32 x i16> %{{.*}}, %{{.*}}
 451   // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
 452   return (__mmask32)_mm512_mask_cmpeq_epu16_mask(__u, __a, __b);
 453 }
 454
 455 __mmask64 test_mm512_cmpgt_epu8_mask(__m512i __a, __m512i __b) {
 456   // CHECK-LABEL: @test_mm512_cmpgt_epu8_mask
 457   // CHECK: icmp ugt <64 x i8> %{{.*}}, %{{.*}}
 458   return (__mmask64)_mm512_cmpgt_epu8_mask(__a, __b);
 459 }
 460
 461 __mmask64 test_mm512_mask_cmpgt_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) {
 462   // CHECK-LABEL: @test_mm512_mask_cmpgt_epu8_mask
 463   // CHECK: icmp ugt <64 x i8> %{{.*}}, %{{.*}}
 464   // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
 465   return (__mmask64)_mm512_mask_cmpgt_epu8_mask(__u, __a, __b);
 466 }
 467
 468 __mmask32 test_mm512_cmpgt_epu16_mask(__m512i __a, __m512i __b) {
 469   // CHECK-LABEL: @test_mm512_cmpgt_epu16_mask
 470   // CHECK: icmp ugt <32 x i16> %{{.*}}, %{{.*}}
 471   return (__mmask32)_mm512_cmpgt_epu16_mask(__a, __b);
 472 }
 473
 474 __mmask32 test_mm512_mask_cmpgt_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) {
 475   // CHECK-LABEL: @test_mm512_mask_cmpgt_epu16_mask
 476   // CHECK: icmp ugt <32 x i16> %{{.*}}, %{{.*}}
 477   // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
 478   return (__mmask32)_mm512_mask_cmpgt_epu16_mask(__u, __a, __b);
 479 }
 480
 481 __mmask64 test_mm512_cmpge_epi8_mask(__m512i __a, __m512i __b) {
 482   // CHECK-LABEL: @test_mm512_cmpge_epi8_mask
 483   // CHECK: icmp sge <64 x i8> %{{.*}}, %{{.*}}
 484   return (__mmask64)_mm512_cmpge_epi8_mask(__a, __b);
 485 }
 486
 487 __mmask64 test_mm512_mask_cmpge_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) {
 488   // CHECK-LABEL: @test_mm512_mask_cmpge_epi8_mask
 489   // CHECK: icmp sge <64 x i8> %{{.*}}, %{{.*}}
 490   // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
 491   return (__mmask64)_mm512_mask_cmpge_epi8_mask(__u, __a, __b);
 492 }
 493
 494 __mmask64 test_mm512_cmpge_epu8_mask(__m512i __a, __m512i __b) {
 495   // CHECK-LABEL: @test_mm512_cmpge_epu8_mask
 496   // CHECK: icmp uge <64 x i8> %{{.*}}, %{{.*}}
 497   return (__mmask64)_mm512_cmpge_epu8_mask(__a, __b);
 498 }
 499
 500 __mmask64 test_mm512_mask_cmpge_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) {
 501   // CHECK-LABEL: @test_mm512_mask_cmpge_epu8_mask
 502   // CHECK: icmp uge <64 x i8> %{{.*}}, %{{.*}}
 503   // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
 504   return (__mmask64)_mm512_mask_cmpge_epu8_mask(__u, __a, __b);
 505 }
 506
 507 __mmask32 test_mm512_cmpge_epi16_mask(__m512i __a, __m512i __b) {
 508   // CHECK-LABEL: @test_mm512_cmpge_epi16_mask
 509   // CHECK: icmp sge <32 x i16> %{{.*}}, %{{.*}}
 510   return (__mmask32)_mm512_cmpge_epi16_mask(__a, __b);
 511 }
 512
 513 __mmask32 test_mm512_mask_cmpge_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) {
 514   // CHECK-LABEL: @test_mm512_mask_cmpge_epi16_mask
 515   // CHECK: icmp sge <32 x i16> %{{.*}}, %{{.*}}
 516   // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
 517   return (__mmask32)_mm512_mask_cmpge_epi16_mask(__u, __a, __b);
 518 }
 519
 520 __mmask32 test_mm512_cmpge_epu16_mask(__m512i __a, __m512i __b) {
 521   // CHECK-LABEL: @test_mm512_cmpge_epu16_mask
 522   // CHECK: icmp uge <32 x i16> %{{.*}}, %{{.*}}
 523   return (__mmask32)_mm512_cmpge_epu16_mask(__a, __b);
 524 }
 525
 526 __mmask32 test_mm512_mask_cmpge_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) {
 527   // CHECK-LABEL: @test_mm512_mask_cmpge_epu16_mask
 528   // CHECK: icmp uge <32 x i16> %{{.*}}, %{{.*}}
 529   // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
 530   return (__mmask32)_mm512_mask_cmpge_epu16_mask(__u, __a, __b);
 531 }
 532
 533 __mmask64 test_mm512_cmple_epi8_mask(__m512i __a, __m512i __b) {
 534   // CHECK-LABEL: @test_mm512_cmple_epi8_mask
 535   // CHECK: icmp sle <64 x i8> %{{.*}}, %{{.*}}
 536   return (__mmask64)_mm512_cmple_epi8_mask(__a, __b);
 537 }
 538
 539 __mmask64 test_mm512_mask_cmple_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) {
 540   // CHECK-LABEL: @test_mm512_mask_cmple_epi8_mask
 541   // CHECK: icmp sle <64 x i8> %{{.*}}, %{{.*}}
 542   // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
 543   return (__mmask64)_mm512_mask_cmple_epi8_mask(__u, __a, __b);
 544 }
 545
 546 __mmask64 test_mm512_cmple_epu8_mask(__m512i __a, __m512i __b) {
 547   // CHECK-LABEL: @test_mm512_cmple_epu8_mask
 548   // CHECK: icmp ule <64 x i8> %{{.*}}, %{{.*}}
 549   return (__mmask64)_mm512_cmple_epu8_mask(__a, __b);
 550 }
 551
 552 __mmask64 test_mm512_mask_cmple_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) {
 553   // CHECK-LABEL: @test_mm512_mask_cmple_epu8_mask
 554   // CHECK: icmp ule <64 x i8> %{{.*}}, %{{.*}}
 555   // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
 556   return (__mmask64)_mm512_mask_cmple_epu8_mask(__u, __a, __b);
 557 }
 558
 559 __mmask32 test_mm512_cmple_epi16_mask(__m512i __a, __m512i __b) {
 560   // CHECK-LABEL: @test_mm512_cmple_epi16_mask
 561   // CHECK: icmp sle <32 x i16> %{{.*}}, %{{.*}}
 562   return (__mmask32)_mm512_cmple_epi16_mask(__a, __b);
 563 }
 564
 565 __mmask32 test_mm512_mask_cmple_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) {
 566   // CHECK-LABEL: @test_mm512_mask_cmple_epi16_mask
 567   // CHECK: icmp sle <32 x i16> %{{.*}}, %{{.*}}
 568   // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
 569   return (__mmask32)_mm512_mask_cmple_epi16_mask(__u, __a, __b);
 570 }
 571
 572 __mmask32 test_mm512_cmple_epu16_mask(__m512i __a, __m512i __b) {
 573   // CHECK-LABEL: @test_mm512_cmple_epu16_mask
 574   // CHECK: icmp ule <32 x i16> %{{.*}}, %{{.*}}
 575   return (__mmask32)_mm512_cmple_epu16_mask(__a, __b);
 576 }
 577
 578 __mmask32 test_mm512_mask_cmple_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) {
 579   // CHECK-LABEL: @test_mm512_mask_cmple_epu16_mask
 580   // CHECK: icmp ule <32 x i16> %{{.*}}, %{{.*}}
 581   // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
 582   return (__mmask32)_mm512_mask_cmple_epu16_mask(__u, __a, __b);
 583 }
 584
 585 __mmask64 test_mm512_cmplt_epi8_mask(__m512i __a, __m512i __b) {
 586   // CHECK-LABEL: @test_mm512_cmplt_epi8_mask
 587   // CHECK: icmp slt <64 x i8> %{{.*}}, %{{.*}}
 588   return (__mmask64)_mm512_cmplt_epi8_mask(__a, __b);
 589 }
 590
 591 __mmask64 test_mm512_mask_cmplt_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) {
 592   // CHECK-LABEL: @test_mm512_mask_cmplt_epi8_mask
 593   // CHECK: icmp slt <64 x i8> %{{.*}}, %{{.*}}
 594   // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
 595   return (__mmask64)_mm512_mask_cmplt_epi8_mask(__u, __a, __b);
 596 }
 597
 598 __mmask64 test_mm512_cmplt_epu8_mask(__m512i __a, __m512i __b) {
 599   // CHECK-LABEL: @test_mm512_cmplt_epu8_mask
 600   // CHECK: icmp ult <64 x i8> %{{.*}}, %{{.*}}
 601   return (__mmask64)_mm512_cmplt_epu8_mask(__a, __b);
 602 }
 603
 604 __mmask64 test_mm512_mask_cmplt_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) {
 605   // CHECK-LABEL: @test_mm512_mask_cmplt_epu8_mask
 606   // CHECK: icmp ult <64 x i8> %{{.*}}, %{{.*}}
 607   // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
 608   return (__mmask64)_mm512_mask_cmplt_epu8_mask(__u, __a, __b);
 609 }
 610
 611 __mmask32 test_mm512_cmplt_epi16_mask(__m512i __a, __m512i __b) {
 612   // CHECK-LABEL: @test_mm512_cmplt_epi16_mask
 613   // CHECK: icmp slt <32 x i16> %{{.*}}, %{{.*}}
 614   return (__mmask32)_mm512_cmplt_epi16_mask(__a, __b);
 615 }
 616
 617 __mmask32 test_mm512_mask_cmplt_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) {
 618   // CHECK-LABEL: @test_mm512_mask_cmplt_epi16_mask
 619   // CHECK: icmp slt <32 x i16> %{{.*}}, %{{.*}}
 620   // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
 621   return (__mmask32)_mm512_mask_cmplt_epi16_mask(__u, __a, __b);
 622 }
 623
 624 __mmask32 test_mm512_cmplt_epu16_mask(__m512i __a, __m512i __b) {
 625   // CHECK-LABEL: @test_mm512_cmplt_epu16_mask
 626   // CHECK: icmp ult <32 x i16> %{{.*}}, %{{.*}}
 627   return (__mmask32)_mm512_cmplt_epu16_mask(__a, __b);
 628 }
 629
 630 __mmask32 test_mm512_mask_cmplt_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) {
 631   // CHECK-LABEL: @test_mm512_mask_cmplt_epu16_mask
 632   // CHECK: icmp ult <32 x i16> %{{.*}}, %{{.*}}
 633   // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
 634   return (__mmask32)_mm512_mask_cmplt_epu16_mask(__u, __a, __b);
 635 }
 636
 637 __mmask64 test_mm512_cmpneq_epi8_mask(__m512i __a, __m512i __b) {
 638   // CHECK-LABEL: @test_mm512_cmpneq_epi8_mask
 639   // CHECK: icmp ne <64 x i8> %{{.*}}, %{{.*}}
 640   return (__mmask64)_mm512_cmpneq_epi8_mask(__a, __b);
 641 }
 642
 643 __mmask64 test_mm512_mask_cmpneq_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) {
 644   // CHECK-LABEL: @test_mm512_mask_cmpneq_epi8_mask
 645   // CHECK: icmp ne <64 x i8> %{{.*}}, %{{.*}}
 646   // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
 647   return (__mmask64)_mm512_mask_cmpneq_epi8_mask(__u, __a, __b);
 648 }
 649
 650 __mmask64 test_mm512_cmpneq_epu8_mask(__m512i __a, __m512i __b) {
 651   // CHECK-LABEL: @test_mm512_cmpneq_epu8_mask
 652   // CHECK: icmp ne <64 x i8> %{{.*}}, %{{.*}}
 653   return (__mmask64)_mm512_cmpneq_epu8_mask(__a, __b);
 654 }
 655
 656 __mmask64 test_mm512_mask_cmpneq_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) {
 657   // CHECK-LABEL: @test_mm512_mask_cmpneq_epu8_mask
 658   // CHECK: icmp ne <64 x i8> %{{.*}}, %{{.*}}
 659   // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
 660   return (__mmask64)_mm512_mask_cmpneq_epu8_mask(__u, __a, __b);
 661 }
 662
 663 __mmask32 test_mm512_cmpneq_epi16_mask(__m512i __a, __m512i __b) {
 664   // CHECK-LABEL: @test_mm512_cmpneq_epi16_mask
 665   // CHECK: icmp ne <32 x i16> %{{.*}}, %{{.*}}
 666   return (__mmask32)_mm512_cmpneq_epi16_mask(__a, __b);
 667 }
 668
 669 __mmask32 test_mm512_mask_cmpneq_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) {
 670   // CHECK-LABEL: @test_mm512_mask_cmpneq_epi16_mask
 671   // CHECK: icmp ne <32 x i16> %{{.*}}, %{{.*}}
 672   // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
 673   return (__mmask32)_mm512_mask_cmpneq_epi16_mask(__u, __a, __b);
 674 }
 675
 676 __mmask32 test_mm512_cmpneq_epu16_mask(__m512i __a, __m512i __b) {
 677   // CHECK-LABEL: @test_mm512_cmpneq_epu16_mask
 678   // CHECK: icmp ne <32 x i16> %{{.*}}, %{{.*}}
 679   return (__mmask32)_mm512_cmpneq_epu16_mask(__a, __b);
 680 }
 681
 682 __mmask32 test_mm512_mask_cmpneq_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) {
 683   // CHECK-LABEL: @test_mm512_mask_cmpneq_epu16_mask
 684   // CHECK: icmp ne <32 x i16> %{{.*}}, %{{.*}}
 685   // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
 686   return (__mmask32)_mm512_mask_cmpneq_epu16_mask(__u, __a, __b);
 687 }
 688
 689 __mmask64 test_mm512_cmp_epi8_mask(__m512i __a, __m512i __b) {
 690   // CHECK-LABEL: @test_mm512_cmp_epi8_mask
 691   // CHECK: icmp eq <64 x i8> %{{.*}}, %{{.*}}
 692   return (__mmask64)_mm512_cmp_epi8_mask(__a, __b, 0);
 693 }
 694
 695 __mmask64 test_mm512_mask_cmp_epi8_mask(__mmask64 __u, __m512i __a, __m512i __b) {
 696   // CHECK-LABEL: @test_mm512_mask_cmp_epi8_mask
 697   // CHECK: icmp eq <64 x i8> %{{.*}}, %{{.*}}
 698   // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
 699   return (__mmask64)_mm512_mask_cmp_epi8_mask(__u, __a, __b, 0);
 700 }
 701
 702 __mmask64 test_mm512_cmp_epu8_mask(__m512i __a, __m512i __b) {
 703   // CHECK-LABEL: @test_mm512_cmp_epu8_mask
 704   // CHECK: icmp eq <64 x i8> %{{.*}}, %{{.*}}
 705   return (__mmask64)_mm512_cmp_epu8_mask(__a, __b, 0);
 706 }
 707
 708 __mmask64 test_mm512_mask_cmp_epu8_mask(__mmask64 __u, __m512i __a, __m512i __b) {
 709   // CHECK-LABEL: @test_mm512_mask_cmp_epu8_mask
 710   // CHECK: icmp eq <64 x i8> %{{.*}}, %{{.*}}
 711   // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
 712   return (__mmask64)_mm512_mask_cmp_epu8_mask(__u, __a, __b, 0);
 713 }
 714
 715 __mmask32 test_mm512_cmp_epi16_mask(__m512i __a, __m512i __b) {
 716   // CHECK-LABEL: @test_mm512_cmp_epi16_mask
 717   // CHECK: icmp eq <32 x i16> %{{.*}}, %{{.*}}
 718   return (__mmask32)_mm512_cmp_epi16_mask(__a, __b, 0);
 719 }
 720
 721 __mmask32 test_mm512_mask_cmp_epi16_mask(__mmask32 __u, __m512i __a, __m512i __b) {
 722   // CHECK-LABEL: @test_mm512_mask_cmp_epi16_mask
 723   // CHECK: icmp eq <32 x i16> %{{.*}}, %{{.*}}
 724   // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
 725   return (__mmask32)_mm512_mask_cmp_epi16_mask(__u, __a, __b, 0);
 726 }
 727
 728 __mmask32 test_mm512_cmp_epu16_mask(__m512i __a, __m512i __b) {
 729   // CHECK-LABEL: @test_mm512_cmp_epu16_mask
 730   // CHECK: icmp eq <32 x i16> %{{.*}}, %{{.*}}
 731   return (__mmask32)_mm512_cmp_epu16_mask(__a, __b, 0);
 732 }
 733
 734 __mmask32 test_mm512_mask_cmp_epu16_mask(__mmask32 __u, __m512i __a, __m512i __b) {
 735   // CHECK-LABEL: @test_mm512_mask_cmp_epu16_mask
 736   // CHECK: icmp eq <32 x i16> %{{.*}}, %{{.*}}
 737   // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
 738   return (__mmask32)_mm512_mask_cmp_epu16_mask(__u, __a, __b, 0);
 739 }
 740
 741 __m512i test_mm512_add_epi8 (__m512i __A, __m512i __B) {
 742   //CHECK-LABEL: @test_mm512_add_epi8
 743   //CHECK: add <64 x i8>
 744   return _mm512_add_epi8(__A,__B);
 745 }
 746
 747 __m512i test_mm512_mask_add_epi8 (__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) {
 748   //CHECK-LABEL: @test_mm512_mask_add_epi8
 749   //CHECK: add <64 x i8> %{{.*}}, %{{.*}}
 750   //CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
 751   return _mm512_mask_add_epi8(__W, __U, __A, __B);
 752 }
 753
 754 __m512i test_mm512_maskz_add_epi8 (__mmask64 __U, __m512i __A, __m512i __B) {
 755   //CHECK-LABEL: @test_mm512_maskz_add_epi8
 756   //CHECK: add <64 x i8> %{{.*}}, %{{.*}}
 757   //CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
 758   return _mm512_maskz_add_epi8(__U, __A, __B);
 759 }
 760
 761 __m512i test_mm512_sub_epi8 (__m512i __A, __m512i __B) {
 762   //CHECK-LABEL: @test_mm512_sub_epi8
 763   //CHECK: sub <64 x i8>
 764   return _mm512_sub_epi8(__A, __B);
 765 }
 766
 767 __m512i test_mm512_mask_sub_epi8 (__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) {
 768   //CHECK-LABEL: @test_mm512_mask_sub_epi8
 769   //CHECK: sub <64 x i8> %{{.*}}, %{{.*}}
 770   //CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
 771   return _mm512_mask_sub_epi8(__W, __U, __A, __B);
 772 }
 773
 774 __m512i test_mm512_maskz_sub_epi8 (__mmask64 __U, __m512i __A, __m512i __B) {
 775   //CHECK-LABEL: @test_mm512_maskz_sub_epi8
 776   //CHECK: sub <64 x i8> %{{.*}}, %{{.*}}
 777   //CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
 778   return _mm512_maskz_sub_epi8(__U, __A, __B);
 779 }
 780
 781 __m512i test_mm512_add_epi16 (__m512i __A, __m512i __B) {
 782   //CHECK-LABEL: @test_mm512_add_epi16
 783   //CHECK: add <32 x i16>
 784   return _mm512_add_epi16(__A, __B);
 785 }
 786
 787 __m512i test_mm512_mask_add_epi16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
 788   //CHECK-LABEL: @test_mm512_mask_add_epi16
 789   //CHECK: add <32 x i16> %{{.*}}, %{{.*}}
 790   //CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
 791   return _mm512_mask_add_epi16(__W, __U, __A, __B);
 792 }
 793
 794 __m512i test_mm512_maskz_add_epi16 (__mmask32 __U, __m512i __A, __m512i __B) {
 795   //CHECK-LABEL: @test_mm512_maskz_add_epi16
 796   //CHECK: add <32 x i16> %{{.*}}, %{{.*}}
 797   //CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
 798   return _mm512_maskz_add_epi16(__U, __A, __B);
 799 }
 800
 801 __m512i test_mm512_sub_epi16 (__m512i __A, __m512i __B) {
 802   //CHECK-LABEL: @test_mm512_sub_epi16
 803   //CHECK: sub <32 x i16>
 804   return _mm512_sub_epi16(__A, __B);
 805 }
 806
 807 __m512i test_mm512_mask_sub_epi16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
 808   //CHECK-LABEL: @test_mm512_mask_sub_epi16
 809   //CHECK: sub <32 x i16> %{{.*}}, %{{.*}}
 810   //CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
 811   return _mm512_mask_sub_epi16(__W, __U, __A, __B);
 812 }
 813
 814 __m512i test_mm512_maskz_sub_epi16 (__mmask32 __U, __m512i __A, __m512i __B) {
 815   //CHECK-LABEL: @test_mm512_maskz_sub_epi16
 816   //CHECK: sub <32 x i16> %{{.*}}, %{{.*}}
 817   //CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
 818   return _mm512_maskz_sub_epi16(__U, __A, __B);
 819 }
 820
 821 __m512i test_mm512_mullo_epi16 (__m512i __A, __m512i __B) {
 822   //CHECK-LABEL: @test_mm512_mullo_epi16
 823   //CHECK: mul <32 x i16>
 824   return _mm512_mullo_epi16(__A, __B);
 825 }
 826
 827 __m512i test_mm512_mask_mullo_epi16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
 828   //CHECK-LABEL: @test_mm512_mask_mullo_epi16
 829   //CHECK: mul <32 x i16> %{{.*}}, %{{.*}}
 830   //CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
 831   return _mm512_mask_mullo_epi16(__W, __U, __A, __B);
 832 }
 833
 834 __m512i test_mm512_maskz_mullo_epi16 (__mmask32 __U, __m512i __A, __m512i __B) {
 835   //CHECK-LABEL: @test_mm512_maskz_mullo_epi16
 836   //CHECK: mul <32 x i16> %{{.*}}, %{{.*}}
 837   //CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
 838   return _mm512_maskz_mullo_epi16(__U, __A, __B);
 839 }
 840
 841 __m512i test_mm512_mask_blend_epi8(__mmask64 __U, __m512i __A, __m512i __W) {
 842   // CHECK-LABEL: @test_mm512_mask_blend_epi8
 843   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
 844   return _mm512_mask_blend_epi8(__U,__A,__W);
 845 }
 846 __m512i test_mm512_mask_blend_epi16(__mmask32 __U, __m512i __A, __m512i __W) {
 847   // CHECK-LABEL: @test_mm512_mask_blend_epi16
 848   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
 849   return _mm512_mask_blend_epi16(__U,__A,__W);
 850 }
 851 __m512i test_mm512_abs_epi8(__m512i __A) {
 852   // CHECK-LABEL: @test_mm512_abs_epi8
 853   // CHECK: [[ABS:%.*]] = call <64 x i8> @llvm.abs.v64i8(<64 x i8> %{{.*}}, i1 false)
 854   return _mm512_abs_epi8(__A);
 855 }
 856 __m512i test_mm512_mask_abs_epi8(__m512i __W, __mmask64 __U, __m512i __A) {
 857   // CHECK-LABEL: @test_mm512_mask_abs_epi8
 858   // CHECK: [[ABS:%.*]] = call <64 x i8> @llvm.abs.v64i8(<64 x i8> %{{.*}}, i1 false)
 859   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> [[ABS]], <64 x i8> %{{.*}}
 860   return _mm512_mask_abs_epi8(__W,__U,__A);
 861 }
 862 __m512i test_mm512_maskz_abs_epi8(__mmask64 __U, __m512i __A) {
 863   // CHECK-LABEL: @test_mm512_maskz_abs_epi8
 864   // CHECK: [[ABS:%.*]] = call <64 x i8> @llvm.abs.v64i8(<64 x i8> %{{.*}}, i1 false)
 865   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> [[ABS]], <64 x i8> %{{.*}}
 866   return _mm512_maskz_abs_epi8(__U,__A);
 867 }
 868 __m512i test_mm512_abs_epi16(__m512i __A) {
 869   // CHECK-LABEL: @test_mm512_abs_epi16
 870   // CHECK: [[ABS:%.*]] = call <32 x i16> @llvm.abs.v32i16(<32 x i16> %{{.*}}, i1 false)
 871   return _mm512_abs_epi16(__A);
 872 }
 873 __m512i test_mm512_mask_abs_epi16(__m512i __W, __mmask32 __U, __m512i __A) {
 874   // CHECK-LABEL: @test_mm512_mask_abs_epi16
 875   // CHECK: [[ABS:%.*]] = call <32 x i16> @llvm.abs.v32i16(<32 x i16> %{{.*}}, i1 false)
 876   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> [[ABS]], <32 x i16> %{{.*}}
 877   return _mm512_mask_abs_epi16(__W,__U,__A);
 878 }
 879 __m512i test_mm512_maskz_abs_epi16(__mmask32 __U, __m512i __A) {
 880   // CHECK-LABEL: @test_mm512_maskz_abs_epi16
 881   // CHECK: [[ABS:%.*]] = call <32 x i16> @llvm.abs.v32i16(<32 x i16> %{{.*}}, i1 false)
 882   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> [[ABS]], <32 x i16> %{{.*}}
 883   return _mm512_maskz_abs_epi16(__U,__A);
 884 }
 885 __m512i test_mm512_packs_epi32(__m512i __A, __m512i __B) {
 886   // CHECK-LABEL: @test_mm512_packs_epi32
 887   // CHECK: @llvm.x86.avx512.packssdw.512
 888   return _mm512_packs_epi32(__A,__B);
 889 }
 890 __m512i test_mm512_maskz_packs_epi32(__mmask32 __M, __m512i __A, __m512i __B) {
 891   // CHECK-LABEL: @test_mm512_maskz_packs_epi32
 892   // CHECK: @llvm.x86.avx512.packssdw.512
 893   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
 894   return _mm512_maskz_packs_epi32(__M,__A,__B);
 895 }
 896 __m512i test_mm512_mask_packs_epi32(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B) {
 897   // CHECK-LABEL: @test_mm512_mask_packs_epi32
 898   // CHECK: @llvm.x86.avx512.packssdw.512
 899   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
 900   return _mm512_mask_packs_epi32(__W,__M,__A,__B);
 901 }
 902 __m512i test_mm512_packs_epi16(__m512i __A, __m512i __B) {
 903   // CHECK-LABEL: @test_mm512_packs_epi16
 904   // CHECK: @llvm.x86.avx512.packsswb.512
 905   return _mm512_packs_epi16(__A,__B);
 906 }
 907 __m512i test_mm512_mask_packs_epi16(__m512i __W, __mmask64 __M, __m512i __A, __m512i __B) {
 908   // CHECK-LABEL: @test_mm512_mask_packs_epi16
 909   // CHECK: @llvm.x86.avx512.packsswb.512
 910   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
 911   return _mm512_mask_packs_epi16(__W,__M,__A,__B);
 912 }
 913 __m512i test_mm512_maskz_packs_epi16(__mmask64 __M, __m512i __A, __m512i __B) {
 914   // CHECK-LABEL: @test_mm512_maskz_packs_epi16
 915   // CHECK: @llvm.x86.avx512.packsswb.512
 916   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
 917   return _mm512_maskz_packs_epi16(__M,__A,__B);
 918 }
 919 __m512i test_mm512_packus_epi32(__m512i __A, __m512i __B) {
 920   // CHECK-LABEL: @test_mm512_packus_epi32
 921   // CHECK: @llvm.x86.avx512.packusdw.512
 922   return _mm512_packus_epi32(__A,__B);
 923 }
 924 __m512i test_mm512_maskz_packus_epi32(__mmask32 __M, __m512i __A, __m512i __B) {
 925   // CHECK-LABEL: @test_mm512_maskz_packus_epi32
 926   // CHECK: @llvm.x86.avx512.packusdw.512
 927   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
 928   return _mm512_maskz_packus_epi32(__M,__A,__B);
 929 }
 930 __m512i test_mm512_mask_packus_epi32(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B) {
 931   // CHECK-LABEL: @test_mm512_mask_packus_epi32
 932   // CHECK: @llvm.x86.avx512.packusdw.512
 933   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
 934   return _mm512_mask_packus_epi32(__W,__M,__A,__B);
 935 }
 936 __m512i test_mm512_packus_epi16(__m512i __A, __m512i __B) {
 937   // CHECK-LABEL: @test_mm512_packus_epi16
 938   // CHECK: @llvm.x86.avx512.packuswb.512
 939   return _mm512_packus_epi16(__A,__B);
 940 }
 941 __m512i test_mm512_mask_packus_epi16(__m512i __W, __mmask64 __M, __m512i __A, __m512i __B) {
 942   // CHECK-LABEL: @test_mm512_mask_packus_epi16
 943   // CHECK: @llvm.x86.avx512.packuswb.512
 944   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
 945   return _mm512_mask_packus_epi16(__W,__M,__A,__B);
 946 }
 947 __m512i test_mm512_maskz_packus_epi16(__mmask64 __M, __m512i __A, __m512i __B) {
 948   // CHECK-LABEL: @test_mm512_maskz_packus_epi16
 949   // CHECK: @llvm.x86.avx512.packuswb.512
 950   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
 951   return _mm512_maskz_packus_epi16(__M,__A,__B);
 952 }
 953 __m512i test_mm512_adds_epi8(__m512i __A, __m512i __B) {
 954   // CHECK-LABEL: @test_mm512_adds_epi8
 955   // CHECK: @llvm.sadd.sat.v64i8
 956   return _mm512_adds_epi8(__A,__B);
 957 }
 958 __m512i test_mm512_mask_adds_epi8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) {
 959   // CHECK-LABEL: @test_mm512_mask_adds_epi8
 960   // CHECK: @llvm.sadd.sat.v64i8
 961   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
 962  return _mm512_mask_adds_epi8(__W,__U,__A,__B);
 963 }
 964 __m512i test_mm512_maskz_adds_epi8(__mmask64 __U, __m512i __A, __m512i __B) {
 965   // CHECK-LABEL: @test_mm512_maskz_adds_epi8
 966   // CHECK: @llvm.sadd.sat.v64i8
 967   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
 968   return _mm512_maskz_adds_epi8(__U,__A,__B);
 969 }
 970 __m512i test_mm512_adds_epi16(__m512i __A, __m512i __B) {
 971   // CHECK-LABEL: @test_mm512_adds_epi16
 972   // CHECK: @llvm.sadd.sat.v32i16
 973  return _mm512_adds_epi16(__A,__B);
 974 }
 975 __m512i test_mm512_mask_adds_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
 976   // CHECK-LABEL: @test_mm512_mask_adds_epi16
 977   // CHECK: @llvm.sadd.sat.v32i16
 978   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
 979   return _mm512_mask_adds_epi16(__W,__U,__A,__B);
 980 }
 981 __m512i test_mm512_maskz_adds_epi16(__mmask32 __U, __m512i __A, __m512i __B) {
 982   // CHECK-LABEL: @test_mm512_maskz_adds_epi16
 983   // CHECK: @llvm.sadd.sat.v32i16
 984   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
 985 return _mm512_maskz_adds_epi16(__U,__A,__B);
 986 }
 987 __m512i test_mm512_adds_epu8(__m512i __A, __m512i __B) {
 988   // CHECK-LABEL: @test_mm512_adds_epu8
 989   // CHECK-NOT: @llvm.x86.avx512.mask.paddus.b.512
 990   // CHECK: call <64 x i8> @llvm.uadd.sat.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
 991   return _mm512_adds_epu8(__A,__B);
 992 }
 993 __m512i test_mm512_mask_adds_epu8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) {
 994   // CHECK-LABEL: @test_mm512_mask_adds_epu8
 995   // CHECK-NOT: @llvm.x86.avx512.mask.paddus.b.512
 996   // CHECK: call <64 x i8> @llvm.uadd.sat.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
 997   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
 998   return _mm512_mask_adds_epu8(__W,__U,__A,__B);
 999 }
1000 __m512i test_mm512_maskz_adds_epu8(__mmask64 __U, __m512i __A, __m512i __B) {
1001   // CHECK-LABEL: @test_mm512_maskz_adds_epu8
1002   // CHECK-NOT: @llvm.x86.avx512.mask.paddus.b.512
1003   // CHECK: call <64 x i8> @llvm.uadd.sat.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
1004   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
1005   return _mm512_maskz_adds_epu8(__U,__A,__B);
1006 }
1007 __m512i test_mm512_adds_epu16(__m512i __A, __m512i __B) {
1008   // CHECK-LABEL: @test_mm512_adds_epu16
1009   // CHECK-NOT: @llvm.x86.avx512.mask.paddus.w.512
1010   // CHECK: call <32 x i16> @llvm.uadd.sat.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1011   return _mm512_adds_epu16(__A,__B);
1012 }
1013 __m512i test_mm512_mask_adds_epu16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
1014   // CHECK-LABEL: @test_mm512_mask_adds_epu16
1015   // CHECK-NOT: @llvm.x86.avx512.mask.paddus.w.512
1016   // CHECK: call <32 x i16> @llvm.uadd.sat.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1017   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1018   return _mm512_mask_adds_epu16(__W,__U,__A,__B);
1019 }
1020 __m512i test_mm512_maskz_adds_epu16(__mmask32 __U, __m512i __A, __m512i __B) {
1021   // CHECK-LABEL: @test_mm512_maskz_adds_epu16
1022   // CHECK-NOT: @llvm.x86.avx512.mask.paddus.w.512
1023   // CHECK: call <32 x i16> @llvm.uadd.sat.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1024   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1025   return _mm512_maskz_adds_epu16(__U,__A,__B);
1026 }
1027 __m512i test_mm512_avg_epu8(__m512i __A, __m512i __B) {
1028   // CHECK-LABEL: @test_mm512_avg_epu8
1029   // CHECK: @llvm.x86.avx512.pavg.b.512
1030   return _mm512_avg_epu8(__A,__B);
1031 }
1032 __m512i test_mm512_mask_avg_epu8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) {
1033   // CHECK-LABEL: @test_mm512_mask_avg_epu8
1034   // CHECK: @llvm.x86.avx512.pavg.b.512
1035   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
1036   return _mm512_mask_avg_epu8(__W,__U,__A,__B);
1037 }
1038 __m512i test_mm512_maskz_avg_epu8(__mmask64 __U, __m512i __A, __m512i __B) {
1039   // CHECK-LABEL: @test_mm512_maskz_avg_epu8
1040   // CHECK: @llvm.x86.avx512.pavg.b.512
1041   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
1042   return _mm512_maskz_avg_epu8(__U,__A,__B);
1043 }
1044 __m512i test_mm512_avg_epu16(__m512i __A, __m512i __B) {
1045   // CHECK-LABEL: @test_mm512_avg_epu16
1046   // CHECK: @llvm.x86.avx512.pavg.w.512
1047   return _mm512_avg_epu16(__A,__B);
1048 }
1049 __m512i test_mm512_mask_avg_epu16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
1050   // CHECK-LABEL: @test_mm512_mask_avg_epu16
1051   // CHECK: @llvm.x86.avx512.pavg.w.512
1052   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1053   return _mm512_mask_avg_epu16(__W,__U,__A,__B);
1054 }
1055 __m512i test_mm512_maskz_avg_epu16(__mmask32 __U, __m512i __A, __m512i __B) {
1056   // CHECK-LABEL: @test_mm512_maskz_avg_epu16
1057   // CHECK: @llvm.x86.avx512.pavg.w.512
1058   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1059   return _mm512_maskz_avg_epu16(__U,__A,__B);
1060 }
1061 __m512i test_mm512_max_epi8(__m512i __A, __m512i __B) {
1062   // CHECK-LABEL: @test_mm512_max_epi8
1063   // CHECK:       [[RES:%.*]] = call <64 x i8> @llvm.smax.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
1064   return _mm512_max_epi8(__A,__B);
1065 }
1066 __m512i test_mm512_maskz_max_epi8(__mmask64 __M, __m512i __A, __m512i __B) {
1067   // CHECK-LABEL: @test_mm512_maskz_max_epi8
1068   // CHECK:       [[RES:%.*]] = call <64 x i8> @llvm.smax.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
1069   // CHECK:       select <64 x i1> {{.*}}, <64 x i8> [[RES]], <64 x i8> {{.*}}
1070   return _mm512_maskz_max_epi8(__M,__A,__B);
1071 }
1072 __m512i test_mm512_mask_max_epi8(__m512i __W, __mmask64 __M, __m512i __A, __m512i __B) {
1073   // CHECK-LABEL: @test_mm512_mask_max_epi8
1074   // CHECK:       [[RES:%.*]] = call <64 x i8> @llvm.smax.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
1075   // CHECK:       select <64 x i1> {{.*}}, <64 x i8> [[RES]], <64 x i8> {{.*}}
1076   return _mm512_mask_max_epi8(__W,__M,__A,__B);
1077 }
1078 __m512i test_mm512_max_epi16(__m512i __A, __m512i __B) {
1079   // CHECK-LABEL: @test_mm512_max_epi16
1080   // CHECK:       [[RES:%.*]] = call <32 x i16> @llvm.smax.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1081   return _mm512_max_epi16(__A,__B);
1082 }
1083 __m512i test_mm512_maskz_max_epi16(__mmask32 __M, __m512i __A, __m512i __B) {
1084   // CHECK-LABEL: @test_mm512_maskz_max_epi16
1085   // CHECK:       [[RES:%.*]] = call <32 x i16> @llvm.smax.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1086   // CHECK:       select <32 x i1> {{.*}}, <32 x i16> [[RES]], <32 x i16> {{.*}}
1087   return _mm512_maskz_max_epi16(__M,__A,__B);
1088 }
1089 __m512i test_mm512_mask_max_epi16(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B) {
1090   // CHECK-LABEL: @test_mm512_mask_max_epi16
1091   // CHECK:       [[RES:%.*]] = call <32 x i16> @llvm.smax.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1092   // CHECK:       select <32 x i1> {{.*}}, <32 x i16> [[RES]], <32 x i16> {{.*}}
1093   return _mm512_mask_max_epi16(__W,__M,__A,__B);
1094 }
1095 __m512i test_mm512_max_epu8(__m512i __A, __m512i __B) {
1096   // CHECK-LABEL: @test_mm512_max_epu8
1097   // CHECK:       [[RES:%.*]] = call <64 x i8> @llvm.umax.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
1098   return _mm512_max_epu8(__A,__B);
1099 }
1100 __m512i test_mm512_maskz_max_epu8(__mmask64 __M, __m512i __A, __m512i __B) {
1101   // CHECK-LABEL: @test_mm512_maskz_max_epu8
1102   // CHECK:       [[RES:%.*]] = call <64 x i8> @llvm.umax.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
1103   // CHECK:       select <64 x i1> {{.*}}, <64 x i8> [[RES]], <64 x i8> {{.*}}
1104   return _mm512_maskz_max_epu8(__M,__A,__B);
1105 }
1106 __m512i test_mm512_mask_max_epu8(__m512i __W, __mmask64 __M, __m512i __A, __m512i __B) {
1107   // CHECK-LABEL: @test_mm512_mask_max_epu8
1108   // CHECK:       [[RES:%.*]] = call <64 x i8> @llvm.umax.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
1109   // CHECK:       select <64 x i1> {{.*}}, <64 x i8> [[RES]], <64 x i8> {{.*}}
1110   return _mm512_mask_max_epu8(__W,__M,__A,__B);
1111 }
1112 __m512i test_mm512_max_epu16(__m512i __A, __m512i __B) {
1113   // CHECK-LABEL: @test_mm512_max_epu16
1114   // CHECK:       [[RES:%.*]] = call <32 x i16> @llvm.umax.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1115   return _mm512_max_epu16(__A,__B);
1116 }
1117 __m512i test_mm512_maskz_max_epu16(__mmask32 __M, __m512i __A, __m512i __B) {
1118   // CHECK-LABEL: @test_mm512_maskz_max_epu16
1119   // CHECK:       [[RES:%.*]] = call <32 x i16> @llvm.umax.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1120   // CHECK:       select <32 x i1> {{.*}}, <32 x i16> [[RES]], <32 x i16> {{.*}}
1121   return _mm512_maskz_max_epu16(__M,__A,__B);
1122 }
1123 __m512i test_mm512_mask_max_epu16(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B) {
1124   // CHECK-LABEL: @test_mm512_mask_max_epu16
1125   // CHECK:       [[RES:%.*]] = call <32 x i16> @llvm.umax.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1126   // CHECK:       select <32 x i1> {{.*}}, <32 x i16> [[RES]], <32 x i16> {{.*}}
1127   return _mm512_mask_max_epu16(__W,__M,__A,__B);
1128 }
1129 __m512i test_mm512_min_epi8(__m512i __A, __m512i __B) {
1130   // CHECK-LABEL: @test_mm512_min_epi8
1131   // CHECK:       [[RES:%.*]] = call <64 x i8> @llvm.smin.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
1132   return _mm512_min_epi8(__A,__B);
1133 }
1134 __m512i test_mm512_maskz_min_epi8(__mmask64 __M, __m512i __A, __m512i __B) {
1135   // CHECK-LABEL: @test_mm512_maskz_min_epi8
1136   // CHECK:       [[RES:%.*]] = call <64 x i8> @llvm.smin.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
1137   // CHECK:       select <64 x i1> {{.*}}, <64 x i8> [[RES]], <64 x i8> {{.*}}
1138   return _mm512_maskz_min_epi8(__M,__A,__B);
1139 }
1140 __m512i test_mm512_mask_min_epi8(__m512i __W, __mmask64 __M, __m512i __A, __m512i __B) {
1141   // CHECK-LABEL: @test_mm512_mask_min_epi8
1142   // CHECK:       [[RES:%.*]] = call <64 x i8> @llvm.smin.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
1143   // CHECK:       select <64 x i1> {{.*}}, <64 x i8> [[RES]], <64 x i8> {{.*}}
1144   return _mm512_mask_min_epi8(__W,__M,__A,__B);
1145 }
1146 __m512i test_mm512_min_epi16(__m512i __A, __m512i __B) {
1147   // CHECK-LABEL: @test_mm512_min_epi16
1148   // CHECK:       [[RES:%.*]] = call <32 x i16> @llvm.smin.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1149   return _mm512_min_epi16(__A,__B);
1150 }
1151 __m512i test_mm512_maskz_min_epi16(__mmask32 __M, __m512i __A, __m512i __B) {
1152   // CHECK-LABEL: @test_mm512_maskz_min_epi16
1153   // CHECK:       [[RES:%.*]] = call <32 x i16> @llvm.smin.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1154   // CHECK:       select <32 x i1> {{.*}}, <32 x i16> [[RES]], <32 x i16> {{.*}}
1155   return _mm512_maskz_min_epi16(__M,__A,__B);
1156 }
1157 __m512i test_mm512_mask_min_epi16(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B) {
1158   // CHECK-LABEL: @test_mm512_mask_min_epi16
1159   // CHECK:       [[RES:%.*]] = call <32 x i16> @llvm.smin.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1160   // CHECK:       select <32 x i1> {{.*}}, <32 x i16> [[RES]], <32 x i16> {{.*}}
1161   return _mm512_mask_min_epi16(__W,__M,__A,__B);
1162 }
1163 __m512i test_mm512_min_epu8(__m512i __A, __m512i __B) {
1164   // CHECK-LABEL: @test_mm512_min_epu8
1165   // CHECK:       [[RES:%.*]] = call <64 x i8> @llvm.umin.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
1166   return _mm512_min_epu8(__A,__B);
1167 }
1168 __m512i test_mm512_maskz_min_epu8(__mmask64 __M, __m512i __A, __m512i __B) {
1169   // CHECK-LABEL: @test_mm512_maskz_min_epu8
1170   // CHECK:       [[RES:%.*]] = call <64 x i8> @llvm.umin.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
1171   // CHECK:       select <64 x i1> {{.*}}, <64 x i8> [[RES]], <64 x i8> {{.*}}
1172   return _mm512_maskz_min_epu8(__M,__A,__B);
1173 }
1174 __m512i test_mm512_mask_min_epu8(__m512i __W, __mmask64 __M, __m512i __A, __m512i __B) {
1175   // CHECK-LABEL: @test_mm512_mask_min_epu8
1176   // CHECK:       [[RES:%.*]] = call <64 x i8> @llvm.umin.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
1177   // CHECK:       select <64 x i1> {{.*}}, <64 x i8> [[RES]], <64 x i8> {{.*}}
1178   return _mm512_mask_min_epu8(__W,__M,__A,__B);
1179 }
1180 __m512i test_mm512_min_epu16(__m512i __A, __m512i __B) {
1181   // CHECK-LABEL: @test_mm512_min_epu16
1182   // CHECK:       [[RES:%.*]] = call <32 x i16> @llvm.umin.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1183   return _mm512_min_epu16(__A,__B);
1184 }
1185 __m512i test_mm512_maskz_min_epu16(__mmask32 __M, __m512i __A, __m512i __B) {
1186   // CHECK-LABEL: @test_mm512_maskz_min_epu16
1187   // CHECK:       [[RES:%.*]] = call <32 x i16> @llvm.umin.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1188   // CHECK:       select <32 x i1> {{.*}}, <32 x i16> [[RES]], <32 x i16> {{.*}}
1189   return _mm512_maskz_min_epu16(__M,__A,__B);
1190 }
1191 __m512i test_mm512_mask_min_epu16(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B) {
1192   // CHECK-LABEL: @test_mm512_mask_min_epu16
1193   // CHECK:       [[RES:%.*]] = call <32 x i16> @llvm.umin.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1194   // CHECK:       select <32 x i1> {{.*}}, <32 x i16> [[RES]], <32 x i16> {{.*}}
1195   return _mm512_mask_min_epu16(__W,__M,__A,__B);
1196 }
1197 __m512i test_mm512_shuffle_epi8(__m512i __A, __m512i __B) {
1198   // CHECK-LABEL: @test_mm512_shuffle_epi8
1199   // CHECK: @llvm.x86.avx512.pshuf.b.512
1200   return _mm512_shuffle_epi8(__A,__B);
1201 }
1202 __m512i test_mm512_mask_shuffle_epi8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) {
1203   // CHECK-LABEL: @test_mm512_mask_shuffle_epi8
1204   // CHECK: @llvm.x86.avx512.pshuf.b.512
1205   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
1206   return _mm512_mask_shuffle_epi8(__W,__U,__A,__B);
1207 }
1208 __m512i test_mm512_maskz_shuffle_epi8(__mmask64 __U, __m512i __A, __m512i __B) {
1209   // CHECK-LABEL: @test_mm512_maskz_shuffle_epi8
1210   // CHECK: @llvm.x86.avx512.pshuf.b.512
1211   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
1212   return _mm512_maskz_shuffle_epi8(__U,__A,__B);
1213 }
1214 __m512i test_mm512_subs_epi8(__m512i __A, __m512i __B) {
1215   // CHECK-LABEL: @test_mm512_subs_epi8
1216   // CHECK: @llvm.ssub.sat.v64i8
1217 return _mm512_subs_epi8(__A,__B);
1218 }
1219 __m512i test_mm512_mask_subs_epi8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) {
1220   // CHECK-LABEL: @test_mm512_mask_subs_epi8
1221   // CHECK: @llvm.ssub.sat.v64i8
1222   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
1223 return _mm512_mask_subs_epi8(__W,__U,__A,__B);
1224 }
1225 __m512i test_mm512_maskz_subs_epi8(__mmask64 __U, __m512i __A, __m512i __B) {
1226   // CHECK-LABEL: @test_mm512_maskz_subs_epi8
1227   // CHECK: @llvm.ssub.sat.v64i8
1228   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
1229 return _mm512_maskz_subs_epi8(__U,__A,__B);
1230 }
1231 __m512i test_mm512_subs_epi16(__m512i __A, __m512i __B) {
1232   // CHECK-LABEL: @test_mm512_subs_epi16
1233   // CHECK: @llvm.ssub.sat.v32i16
1234 return _mm512_subs_epi16(__A,__B);
1235 }
1236 __m512i test_mm512_mask_subs_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
1237   // CHECK-LABEL: @test_mm512_mask_subs_epi16
1238   // CHECK: @llvm.ssub.sat.v32i16
1239   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1240 return _mm512_mask_subs_epi16(__W,__U,__A,__B);
1241 }
1242 __m512i test_mm512_maskz_subs_epi16(__mmask32 __U, __m512i __A, __m512i __B) {
1243   // CHECK-LABEL: @test_mm512_maskz_subs_epi16
1244   // CHECK: @llvm.ssub.sat.v32i16
1245   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1246 return _mm512_maskz_subs_epi16(__U,__A,__B);
1247 }
1248 __m512i test_mm512_subs_epu8(__m512i __A, __m512i __B) {
1249   // CHECK-LABEL: @test_mm512_subs_epu8
1250   // CHECK-NOT: @llvm.x86.avx512.mask.psubus.b.512
1251   // CHECK: call <64 x i8> @llvm.usub.sat.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
1252 return _mm512_subs_epu8(__A,__B);
1253 }
1254 __m512i test_mm512_mask_subs_epu8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) {
1255   // CHECK-LABEL: @test_mm512_mask_subs_epu8
1256   // CHECK-NOT: @llvm.x86.avx512.mask.psubus.b.512
1257   // CHECK: call <64 x i8> @llvm.usub.sat.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
1258   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
1259 return _mm512_mask_subs_epu8(__W,__U,__A,__B);
1260 }
1261 __m512i test_mm512_maskz_subs_epu8(__mmask64 __U, __m512i __A, __m512i __B) {
1262   // CHECK-LABEL: @test_mm512_maskz_subs_epu8
1263   // CHECK-NOT: @llvm.x86.avx512.mask.psubus.b.512
1264   // CHECK: call <64 x i8> @llvm.usub.sat.v64i8(<64 x i8> %{{.*}}, <64 x i8> %{{.*}})
1265   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
1266 return _mm512_maskz_subs_epu8(__U,__A,__B);
1267 }
1268 __m512i test_mm512_subs_epu16(__m512i __A, __m512i __B) {
1269   // CHECK-LABEL: @test_mm512_subs_epu16
1270   // CHECK-NOT: @llvm.x86.avx512.mask.psubus.w.512
1271   // CHECK: call <32 x i16> @llvm.usub.sat.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1272 return _mm512_subs_epu16(__A,__B);
1273 }
1274 __m512i test_mm512_mask_subs_epu16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
1275   // CHECK-LABEL: @test_mm512_mask_subs_epu16
1276   // CHECK-NOT: @llvm.x86.avx512.mask.psubus.w.512
1277   // CHECK: call <32 x i16> @llvm.usub.sat.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1278   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1279 return _mm512_mask_subs_epu16(__W,__U,__A,__B);
1280 }
1281 __m512i test_mm512_maskz_subs_epu16(__mmask32 __U, __m512i __A, __m512i __B) {
1282   // CHECK-LABEL: @test_mm512_maskz_subs_epu16
1283   // CHECK-NOT: @llvm.x86.avx512.mask.psubus.w.512
1284   // CHECK: call <32 x i16> @llvm.usub.sat.v32i16(<32 x i16> %{{.*}}, <32 x i16> %{{.*}})
1285   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1286 return _mm512_maskz_subs_epu16(__U,__A,__B);
1287 }
1288 __m512i test_mm512_mask2_permutex2var_epi16(__m512i __A, __m512i __I, __mmask32 __U, __m512i __B) {
1289   // CHECK-LABEL: @test_mm512_mask2_permutex2var_epi16
1290   // CHECK: @llvm.x86.avx512.vpermi2var.hi.512
1291   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1292   return _mm512_mask2_permutex2var_epi16(__A,__I,__U,__B);
1293 }
1294 __m512i test_mm512_permutex2var_epi16(__m512i __A, __m512i __I, __m512i __B) {
1295   // CHECK-LABEL: @test_mm512_permutex2var_epi16
1296   // CHECK: @llvm.x86.avx512.vpermi2var.hi.512
1297   return _mm512_permutex2var_epi16(__A,__I,__B);
1298 }
1299 __m512i test_mm512_mask_permutex2var_epi16(__m512i __A, __mmask32 __U, __m512i __I, __m512i __B) {
1300   // CHECK-LABEL: @test_mm512_mask_permutex2var_epi16
1301   // CHECK: @llvm.x86.avx512.vpermi2var.hi.512
1302   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1303   return _mm512_mask_permutex2var_epi16(__A,__U,__I,__B);
1304 }
1305 __m512i test_mm512_maskz_permutex2var_epi16(__mmask32 __U, __m512i __A, __m512i __I, __m512i __B) {
1306   // CHECK-LABEL: @test_mm512_maskz_permutex2var_epi16
1307   // CHECK: @llvm.x86.avx512.vpermi2var.hi.512
1308   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1309   return _mm512_maskz_permutex2var_epi16(__U,__A,__I,__B);
1310 }
1311
1312 __m512i test_mm512_mulhrs_epi16(__m512i __A, __m512i __B) {
1313   // CHECK-LABEL: @test_mm512_mulhrs_epi16
1314   // CHECK: @llvm.x86.avx512.pmul.hr.sw.512
1315   return _mm512_mulhrs_epi16(__A,__B);
1316 }
1317 __m512i test_mm512_mask_mulhrs_epi16(__m512i __W, __mmask32 __U, __m512i __A,        __m512i __B) {
1318   // CHECK-LABEL: @test_mm512_mask_mulhrs_epi16
1319   // CHECK: @llvm.x86.avx512.pmul.hr.sw.512
1320   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1321   return _mm512_mask_mulhrs_epi16(__W,__U,__A,__B);
1322 }
1323 __m512i test_mm512_maskz_mulhrs_epi16(__mmask32 __U, __m512i __A, __m512i __B) {
1324   // CHECK-LABEL: @test_mm512_maskz_mulhrs_epi16
1325   // CHECK: @llvm.x86.avx512.pmul.hr.sw.512
1326   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1327   return _mm512_maskz_mulhrs_epi16(__U,__A,__B);
1328 }
1329 __m512i test_mm512_mulhi_epi16(__m512i __A, __m512i __B) {
1330   // CHECK-LABEL: @test_mm512_mulhi_epi16
1331   // CHECK: @llvm.x86.avx512.pmulh.w.512
1332   return _mm512_mulhi_epi16(__A,__B);
1333 }
1334 __m512i test_mm512_mask_mulhi_epi16(__m512i __W, __mmask32 __U, __m512i __A,       __m512i __B) {
1335   // CHECK-LABEL: @test_mm512_mask_mulhi_epi16
1336   // CHECK: @llvm.x86.avx512.pmulh.w.512
1337   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1338   return _mm512_mask_mulhi_epi16(__W,__U,__A,__B);
1339 }
1340 __m512i test_mm512_maskz_mulhi_epi16(__mmask32 __U, __m512i __A, __m512i __B) {
1341   // CHECK-LABEL: @test_mm512_maskz_mulhi_epi16
1342   // CHECK: @llvm.x86.avx512.pmulh.w.512
1343   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1344   return _mm512_maskz_mulhi_epi16(__U,__A,__B);
1345 }
1346 __m512i test_mm512_mulhi_epu16(__m512i __A, __m512i __B) {
1347   // CHECK-LABEL: @test_mm512_mulhi_epu16
1348   // CHECK: @llvm.x86.avx512.pmulhu.w.512
1349   return _mm512_mulhi_epu16(__A,__B);
1350 }
1351 __m512i test_mm512_mask_mulhi_epu16(__m512i __W, __mmask32 __U, __m512i __A,       __m512i __B) {
1352   // CHECK-LABEL: @test_mm512_mask_mulhi_epu16
1353   // CHECK: @llvm.x86.avx512.pmulhu.w.512
1354   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1355   return _mm512_mask_mulhi_epu16(__W,__U,__A,__B);
1356 }
1357 __m512i test_mm512_maskz_mulhi_epu16(__mmask32 __U, __m512i __A, __m512i __B) {
1358   // CHECK-LABEL: @test_mm512_maskz_mulhi_epu16
1359   // CHECK: @llvm.x86.avx512.pmulhu.w.512
1360   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1361   return _mm512_maskz_mulhi_epu16(__U,__A,__B);
1362 }
1363
1364 __m512i test_mm512_maddubs_epi16(__m512i __X, __m512i __Y) {
1365   // CHECK-LABEL: @test_mm512_maddubs_epi16
1366   // CHECK: @llvm.x86.avx512.pmaddubs.w.512
1367   return _mm512_maddubs_epi16(__X,__Y);
1368 }
1369 __m512i test_mm512_mask_maddubs_epi16(__m512i __W, __mmask32 __U, __m512i __X,         __m512i __Y) {
1370   // CHECK-LABEL: @test_mm512_mask_maddubs_epi16
1371   // CHECK: @llvm.x86.avx512.pmaddubs.w.512
1372   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1373   return _mm512_mask_maddubs_epi16(__W,__U,__X,__Y);
1374 }
1375 __m512i test_mm512_maskz_maddubs_epi16(__mmask32 __U, __m512i __X, __m512i __Y) {
1376   // CHECK-LABEL: @test_mm512_maskz_maddubs_epi16
1377   // CHECK: @llvm.x86.avx512.pmaddubs.w.512
1378   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1379   return _mm512_maskz_maddubs_epi16(__U,__X,__Y);
1380 }
1381 __m512i test_mm512_madd_epi16(__m512i __A, __m512i __B) {
1382   // CHECK-LABEL: @test_mm512_madd_epi16
1383   // CHECK: @llvm.x86.avx512.pmaddw.d.512
1384   return _mm512_madd_epi16(__A,__B);
1385 }
1386 __m512i test_mm512_mask_madd_epi16(__m512i __W, __mmask16 __U, __m512i __A,      __m512i __B) {
1387   // CHECK-LABEL: @test_mm512_mask_madd_epi16
1388   // CHECK: @llvm.x86.avx512.pmaddw.d.512
1389   // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}}
1390   return _mm512_mask_madd_epi16(__W,__U,__A,__B);
1391 }
1392 __m512i test_mm512_maskz_madd_epi16(__mmask16 __U, __m512i __A, __m512i __B) {
1393   // CHECK-LABEL: @test_mm512_maskz_madd_epi16
1394   // CHECK: @llvm.x86.avx512.pmaddw.d.512
1395   // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}}
1396   return _mm512_maskz_madd_epi16(__U,__A,__B);
1397 }
1398
1399 __m256i test_mm512_cvtsepi16_epi8(__m512i __A) {
1400   // CHECK-LABEL: @test_mm512_cvtsepi16_epi8
1401   // CHECK: @llvm.x86.avx512.mask.pmovs.wb.512
1402   return _mm512_cvtsepi16_epi8(__A);
1403 }
1404
1405 __m256i test_mm512_mask_cvtsepi16_epi8(__m256i __O, __mmask32 __M, __m512i __A) {
1406   // CHECK-LABEL: @test_mm512_mask_cvtsepi16_epi8
1407   // CHECK: @llvm.x86.avx512.mask.pmovs.wb.512
1408   return _mm512_mask_cvtsepi16_epi8(__O, __M, __A);
1409 }
1410
1411 __m256i test_mm512_maskz_cvtsepi16_epi8(__mmask32 __M, __m512i __A) {
1412   // CHECK-LABEL: @test_mm512_maskz_cvtsepi16_epi8
1413   // CHECK: @llvm.x86.avx512.mask.pmovs.wb.512
1414   return _mm512_maskz_cvtsepi16_epi8(__M, __A);
1415 }
1416
1417 __m256i test_mm512_cvtusepi16_epi8(__m512i __A) {
1418   // CHECK-LABEL: @test_mm512_cvtusepi16_epi8
1419   // CHECK: @llvm.x86.avx512.mask.pmovus.wb.512
1420   return _mm512_cvtusepi16_epi8(__A);
1421 }
1422
1423 __m256i test_mm512_mask_cvtusepi16_epi8(__m256i __O, __mmask32 __M, __m512i __A) {
1424   // CHECK-LABEL: @test_mm512_mask_cvtusepi16_epi8
1425   // CHECK: @llvm.x86.avx512.mask.pmovus.wb.512
1426   return _mm512_mask_cvtusepi16_epi8(__O, __M, __A);
1427 }
1428
1429 __m256i test_mm512_maskz_cvtusepi16_epi8(__mmask32 __M, __m512i __A) {
1430   // CHECK-LABEL: @test_mm512_maskz_cvtusepi16_epi8
1431   // CHECK: @llvm.x86.avx512.mask.pmovus.wb.512
1432   return _mm512_maskz_cvtusepi16_epi8(__M, __A);
1433 }
1434
1435 __m256i test_mm512_cvtepi16_epi8(__m512i __A) {
1436   // CHECK-LABEL: @test_mm512_cvtepi16_epi8
1437   // CHECK: trunc <32 x i16> %{{.*}} to <32 x i8>
1438   return _mm512_cvtepi16_epi8(__A);
1439 }
1440
1441 __m256i test_mm512_mask_cvtepi16_epi8(__m256i __O, __mmask32 __M, __m512i __A) {
1442   // CHECK-LABEL: @test_mm512_mask_cvtepi16_epi8
1443   // CHECK: trunc <32 x i16> %{{.*}} to <32 x i8>
1444   // CHECK: select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}}
1445   return _mm512_mask_cvtepi16_epi8(__O, __M, __A);
1446 }
1447
1448 __m256i test_mm512_maskz_cvtepi16_epi8(__mmask32 __M, __m512i __A) {
1449   // CHECK-LABEL: @test_mm512_maskz_cvtepi16_epi8
1450   // CHECK: trunc <32 x i16> %{{.*}} to <32 x i8>
1451   // CHECK: select <32 x i1> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}}
1452   return _mm512_maskz_cvtepi16_epi8(__M, __A);
1453 }
1454
1455 __m512i test_mm512_unpackhi_epi8(__m512i __A, __m512i __B) {
1456   // CHECK-LABEL: @test_mm512_unpackhi_epi8
1457   // CHECK: shufflevector <64 x i8> %{{.*}}, <64 x i8> %{{.*}}, <64 x i32> <i32 8, i32 72, i32 9, i32 73, i32 10, i32 74, i32 11, i32 75, i32 12, i32 76, i32 13, i32 77, i32 14, i32 78, i32 15, i32 79, i32 24, i32 88, i32 25, i32 89, i32 26, i32 90, i32 27, i32 91, i32 28, i32 92, i32 29, i32 93, i32 30, i32 94, i32 31, i32 95, i32 40, i32 104, i32 41, i32 105, i32 42, i32 106, i32 43, i32 107, i32 44, i32 108, i32 45, i32 109, i32 46, i32 110, i32 47, i32 111, i32 56, i32 120, i32 57, i32 121, i32 58, i32 122, i32 59, i32 123, i32 60, i32 124, i32 61, i32 125, i32 62, i32 126, i32 63, i32 127>
1458   return _mm512_unpackhi_epi8(__A, __B);
1459 }
1460
1461 __m512i test_mm512_mask_unpackhi_epi8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) {
1462   // CHECK-LABEL: @test_mm512_mask_unpackhi_epi8
1463   // CHECK: shufflevector <64 x i8> %{{.*}}, <64 x i8> %{{.*}}, <64 x i32> <i32 8, i32 72, i32 9, i32 73, i32 10, i32 74, i32 11, i32 75, i32 12, i32 76, i32 13, i32 77, i32 14, i32 78, i32 15, i32 79, i32 24, i32 88, i32 25, i32 89, i32 26, i32 90, i32 27, i32 91, i32 28, i32 92, i32 29, i32 93, i32 30, i32 94, i32 31, i32 95, i32 40, i32 104, i32 41, i32 105, i32 42, i32 106, i32 43, i32 107, i32 44, i32 108, i32 45, i32 109, i32 46, i32 110, i32 47, i32 111, i32 56, i32 120, i32 57, i32 121, i32 58, i32 122, i32 59, i32 123, i32 60, i32 124, i32 61, i32 125, i32 62, i32 126, i32 63, i32 127>
1464   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
1465   return _mm512_mask_unpackhi_epi8(__W, __U, __A, __B);
1466 }
1467
1468 __m512i test_mm512_maskz_unpackhi_epi8(__mmask64 __U, __m512i __A, __m512i __B) {
1469   // CHECK-LABEL: @test_mm512_maskz_unpackhi_epi8
1470   // CHECK: shufflevector <64 x i8> %{{.*}}, <64 x i8> %{{.*}}, <64 x i32> <i32 8, i32 72, i32 9, i32 73, i32 10, i32 74, i32 11, i32 75, i32 12, i32 76, i32 13, i32 77, i32 14, i32 78, i32 15, i32 79, i32 24, i32 88, i32 25, i32 89, i32 26, i32 90, i32 27, i32 91, i32 28, i32 92, i32 29, i32 93, i32 30, i32 94, i32 31, i32 95, i32 40, i32 104, i32 41, i32 105, i32 42, i32 106, i32 43, i32 107, i32 44, i32 108, i32 45, i32 109, i32 46, i32 110, i32 47, i32 111, i32 56, i32 120, i32 57, i32 121, i32 58, i32 122, i32 59, i32 123, i32 60, i32 124, i32 61, i32 125, i32 62, i32 126, i32 63, i32 127>
1471   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
1472   return _mm512_maskz_unpackhi_epi8(__U, __A, __B);
1473 }
1474
1475 __m512i test_mm512_unpackhi_epi16(__m512i __A, __m512i __B) {
1476   // CHECK-LABEL: @test_mm512_unpackhi_epi16
1477   // CHECK: shufflevector <32 x i16> %{{.*}}, <32 x i16> %{{.*}}, <32 x i32> <i32 4, i32 36, i32 5, i32 37, i32 6, i32 38, i32 7, i32 39, i32 12, i32 44, i32 13, i32 45, i32 14, i32 46, i32 15, i32 47, i32 20, i32 52, i32 21, i32 53, i32 22, i32 54, i32 23, i32 55, i32 28, i32 60, i32 29, i32 61, i32 30, i32 62, i32 31, i32 63>
1478   return _mm512_unpackhi_epi16(__A, __B);
1479 }
1480
1481 __m512i test_mm512_mask_unpackhi_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
1482   // CHECK-LABEL: @test_mm512_mask_unpackhi_epi16
1483   // CHECK: shufflevector <32 x i16> %{{.*}}, <32 x i16> %{{.*}}, <32 x i32> <i32 4, i32 36, i32 5, i32 37, i32 6, i32 38, i32 7, i32 39, i32 12, i32 44, i32 13, i32 45, i32 14, i32 46, i32 15, i32 47, i32 20, i32 52, i32 21, i32 53, i32 22, i32 54, i32 23, i32 55, i32 28, i32 60, i32 29, i32 61, i32 30, i32 62, i32 31, i32 63>
1484   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1485   return _mm512_mask_unpackhi_epi16(__W, __U, __A, __B);
1486 }
1487
1488 __m512i test_mm512_maskz_unpackhi_epi16(__mmask32 __U, __m512i __A, __m512i __B) {
1489   // CHECK-LABEL: @test_mm512_maskz_unpackhi_epi16
1490   // CHECK: shufflevector <32 x i16> %{{.*}}, <32 x i16> %{{.*}}, <32 x i32> <i32 4, i32 36, i32 5, i32 37, i32 6, i32 38, i32 7, i32 39, i32 12, i32 44, i32 13, i32 45, i32 14, i32 46, i32 15, i32 47, i32 20, i32 52, i32 21, i32 53, i32 22, i32 54, i32 23, i32 55, i32 28, i32 60, i32 29, i32 61, i32 30, i32 62, i32 31, i32 63>
1491   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1492   return _mm512_maskz_unpackhi_epi16(__U, __A, __B);
1493 }
1494
1495 __m512i test_mm512_unpacklo_epi8(__m512i __A, __m512i __B) {
1496   // CHECK-LABEL: @test_mm512_unpacklo_epi8
1497   // CHECK: shufflevector <64 x i8> %{{.*}}, <64 x i8> %{{.*}}, <64 x i32> <i32 0, i32 64, i32 1, i32 65, i32 2, i32 66, i32 3, i32 67, i32 4, i32 68, i32 5, i32 69, i32 6, i32 70, i32 7, i32 71, i32 16, i32 80, i32 17, i32 81, i32 18, i32 82, i32 19, i32 83, i32 20, i32 84, i32 21, i32 85, i32 22, i32 86, i32 23, i32 87, i32 32, i32 96, i32 33, i32 97, i32 34, i32 98, i32 35, i32 99, i32 36, i32 100, i32 37, i32 101, i32 38, i32 102, i32 39, i32 103, i32 48, i32 112, i32 49, i32 113, i32 50, i32 114, i32 51, i32 115, i32 52, i32 116, i32 53, i32 117, i32 54, i32 118, i32 55, i32 119>
1498   return _mm512_unpacklo_epi8(__A, __B);
1499 }
1500
1501 __m512i test_mm512_mask_unpacklo_epi8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) {
1502   // CHECK-LABEL: @test_mm512_mask_unpacklo_epi8
1503   // CHECK: shufflevector <64 x i8> %{{.*}}, <64 x i8> %{{.*}}, <64 x i32> <i32 0, i32 64, i32 1, i32 65, i32 2, i32 66, i32 3, i32 67, i32 4, i32 68, i32 5, i32 69, i32 6, i32 70, i32 7, i32 71, i32 16, i32 80, i32 17, i32 81, i32 18, i32 82, i32 19, i32 83, i32 20, i32 84, i32 21, i32 85, i32 22, i32 86, i32 23, i32 87, i32 32, i32 96, i32 33, i32 97, i32 34, i32 98, i32 35, i32 99, i32 36, i32 100, i32 37, i32 101, i32 38, i32 102, i32 39, i32 103, i32 48, i32 112, i32 49, i32 113, i32 50, i32 114, i32 51, i32 115, i32 52, i32 116, i32 53, i32 117, i32 54, i32 118, i32 55, i32 119>
1504   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
1505   return _mm512_mask_unpacklo_epi8(__W, __U, __A, __B);
1506 }
1507
1508 __m512i test_mm512_maskz_unpacklo_epi8(__mmask64 __U, __m512i __A, __m512i __B) {
1509   // CHECK-LABEL: @test_mm512_maskz_unpacklo_epi8
1510   // CHECK: shufflevector <64 x i8> %{{.*}}, <64 x i8> %{{.*}}, <64 x i32> <i32 0, i32 64, i32 1, i32 65, i32 2, i32 66, i32 3, i32 67, i32 4, i32 68, i32 5, i32 69, i32 6, i32 70, i32 7, i32 71, i32 16, i32 80, i32 17, i32 81, i32 18, i32 82, i32 19, i32 83, i32 20, i32 84, i32 21, i32 85, i32 22, i32 86, i32 23, i32 87, i32 32, i32 96, i32 33, i32 97, i32 34, i32 98, i32 35, i32 99, i32 36, i32 100, i32 37, i32 101, i32 38, i32 102, i32 39, i32 103, i32 48, i32 112, i32 49, i32 113, i32 50, i32 114, i32 51, i32 115, i32 52, i32 116, i32 53, i32 117, i32 54, i32 118, i32 55, i32 119>
1511   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
1512   return _mm512_maskz_unpacklo_epi8(__U, __A, __B);
1513 }
1514
1515 __m512i test_mm512_unpacklo_epi16(__m512i __A, __m512i __B) {
1516   // CHECK-LABEL: @test_mm512_unpacklo_epi16
1517   // CHECK: shufflevector <32 x i16> %{{.*}}, <32 x i16> %{{.*}}, <32 x i32> <i32 0, i32 32, i32 1, i32 33, i32 2, i32 34, i32 3, i32 35, i32 8, i32 40, i32 9, i32 41, i32 10, i32 42, i32 11, i32 43, i32 16, i32 48, i32 17, i32 49, i32 18, i32 50, i32 19, i32 51, i32 24, i32 56, i32 25, i32 57, i32 26, i32 58, i32 27, i32 59>
1518   return _mm512_unpacklo_epi16(__A, __B);
1519 }
1520
1521 __m512i test_mm512_mask_unpacklo_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
1522   // CHECK-LABEL: @test_mm512_mask_unpacklo_epi16
1523   // CHECK: shufflevector <32 x i16> %{{.*}}, <32 x i16> %{{.*}}, <32 x i32> <i32 0, i32 32, i32 1, i32 33, i32 2, i32 34, i32 3, i32 35, i32 8, i32 40, i32 9, i32 41, i32 10, i32 42, i32 11, i32 43, i32 16, i32 48, i32 17, i32 49, i32 18, i32 50, i32 19, i32 51, i32 24, i32 56, i32 25, i32 57, i32 26, i32 58, i32 27, i32 59>
1524   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1525   return _mm512_mask_unpacklo_epi16(__W, __U, __A, __B);
1526 }
1527
1528 __m512i test_mm512_maskz_unpacklo_epi16(__mmask32 __U, __m512i __A, __m512i __B) {
1529   // CHECK-LABEL: @test_mm512_maskz_unpacklo_epi16
1530   // CHECK: shufflevector <32 x i16> %{{.*}}, <32 x i16> %{{.*}}, <32 x i32> <i32 0, i32 32, i32 1, i32 33, i32 2, i32 34, i32 3, i32 35, i32 8, i32 40, i32 9, i32 41, i32 10, i32 42, i32 11, i32 43, i32 16, i32 48, i32 17, i32 49, i32 18, i32 50, i32 19, i32 51, i32 24, i32 56, i32 25, i32 57, i32 26, i32 58, i32 27, i32 59>
1531   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1532   return _mm512_maskz_unpacklo_epi16(__U, __A, __B);
1533 }
1534
1535 __m512i test_mm512_cvtepi8_epi16(__m256i __A) {
1536   // CHECK-LABEL: @test_mm512_cvtepi8_epi16
1537   // CHECK: sext <32 x i8> %{{.*}} to <32 x i16>
1538   return _mm512_cvtepi8_epi16(__A);
1539 }
1540
1541 __m512i test_mm512_mask_cvtepi8_epi16(__m512i __W, __mmask32 __U, __m256i __A) {
1542   // CHECK-LABEL: @test_mm512_mask_cvtepi8_epi16
1543   // CHECK: sext <32 x i8> %{{.*}} to <32 x i16>
1544   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1545   return _mm512_mask_cvtepi8_epi16(__W, __U, __A);
1546 }
1547
1548 __m512i test_mm512_maskz_cvtepi8_epi16(__mmask32 __U, __m256i __A) {
1549   // CHECK-LABEL: @test_mm512_maskz_cvtepi8_epi16
1550   // CHECK: sext <32 x i8> %{{.*}} to <32 x i16>
1551   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1552   return _mm512_maskz_cvtepi8_epi16(__U, __A);
1553 }
1554
1555 __m512i test_mm512_cvtepu8_epi16(__m256i __A) {
1556   // CHECK-LABEL: @test_mm512_cvtepu8_epi16
1557   // CHECK: zext <32 x i8> %{{.*}} to <32 x i16>
1558   return _mm512_cvtepu8_epi16(__A);
1559 }
1560
1561 __m512i test_mm512_mask_cvtepu8_epi16(__m512i __W, __mmask32 __U, __m256i __A) {
1562   // CHECK-LABEL: @test_mm512_mask_cvtepu8_epi16
1563   // CHECK: zext <32 x i8> %{{.*}} to <32 x i16>
1564   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1565   return _mm512_mask_cvtepu8_epi16(__W, __U, __A);
1566 }
1567
1568 __m512i test_mm512_maskz_cvtepu8_epi16(__mmask32 __U, __m256i __A) {
1569   // CHECK-LABEL: @test_mm512_maskz_cvtepu8_epi16
1570   // CHECK: zext <32 x i8> %{{.*}} to <32 x i16>
1571   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1572   return _mm512_maskz_cvtepu8_epi16(__U, __A);
1573 }
1574
1575 __m512i test_mm512_shufflehi_epi16(__m512i __A) {
1576   // CHECK-LABEL: @test_mm512_shufflehi_epi16
1577   // CHECK: shufflevector <32 x i16> %{{.*}}, <32 x i16> poison, <32 x i32> <i32 0, i32 1, i32 2, i32 3, i32 5, i32 5, i32 4, i32 4, i32 8, i32 9, i32 10, i32 11, i32 13, i32 13, i32 12, i32 12, i32 16, i32 17, i32 18, i32 19, i32 21, i32 21, i32 20, i32 20, i32 24, i32 25, i32 26, i32 27, i32 29, i32 29, i32 28, i32 28>
1578   return _mm512_shufflehi_epi16(__A, 5);
1579 }
1580
1581 __m512i test_mm512_mask_shufflehi_epi16(__m512i __W, __mmask32 __U, __m512i __A) {
1582   // CHECK-LABEL: @test_mm512_mask_shufflehi_epi16
1583   // CHECK: shufflevector <32 x i16> %{{.*}}, <32 x i16> poison, <32 x i32> <i32 0, i32 1, i32 2, i32 3, i32 5, i32 5, i32 4, i32 4, i32 8, i32 9, i32 10, i32 11, i32 13, i32 13, i32 12, i32 12, i32 16, i32 17, i32 18, i32 19, i32 21, i32 21, i32 20, i32 20, i32 24, i32 25, i32 26, i32 27, i32 29, i32 29, i32 28, i32 28>
1584   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1585   return _mm512_mask_shufflehi_epi16(__W, __U, __A, 5);
1586 }
1587
1588 __m512i test_mm512_maskz_shufflehi_epi16(__mmask32 __U, __m512i __A) {
1589   // CHECK-LABEL: @test_mm512_maskz_shufflehi_epi16
1590   // CHECK: shufflevector <32 x i16> %{{.*}}, <32 x i16> poison, <32 x i32> <i32 0, i32 1, i32 2, i32 3, i32 5, i32 5, i32 4, i32 4, i32 8, i32 9, i32 10, i32 11, i32 13, i32 13, i32 12, i32 12, i32 16, i32 17, i32 18, i32 19, i32 21, i32 21, i32 20, i32 20, i32 24, i32 25, i32 26, i32 27, i32 29, i32 29, i32 28, i32 28>
1591   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1592   return _mm512_maskz_shufflehi_epi16(__U, __A, 5);
1593 }
1594
1595 __m512i test_mm512_shufflelo_epi16(__m512i __A) {
1596   // CHECK-LABEL: @test_mm512_shufflelo_epi16
1597   // CHECK: shufflevector <32 x i16> %{{.*}}, <32 x i16> poison, <32 x i32> <i32 1, i32 1, i32 0, i32 0, i32 4, i32 5, i32 6, i32 7, i32 9, i32 9, i32 8, i32 8, i32 12, i32 13, i32 14, i32 15, i32 17, i32 17, i32 16, i32 16, i32 20, i32 21, i32 22, i32 23, i32 25, i32 25, i32 24, i32 24, i32 28, i32 29, i32 30, i32 31>
1598   return _mm512_shufflelo_epi16(__A, 5);
1599 }
1600
1601 __m512i test_mm512_mask_shufflelo_epi16(__m512i __W, __mmask32 __U, __m512i __A) {
1602   // CHECK-LABEL: @test_mm512_mask_shufflelo_epi16
1603   // CHECK: shufflevector <32 x i16> %{{.*}}, <32 x i16> poison, <32 x i32> <i32 1, i32 1, i32 0, i32 0, i32 4, i32 5, i32 6, i32 7, i32 9, i32 9, i32 8, i32 8, i32 12, i32 13, i32 14, i32 15, i32 17, i32 17, i32 16, i32 16, i32 20, i32 21, i32 22, i32 23, i32 25, i32 25, i32 24, i32 24, i32 28, i32 29, i32 30, i32 31>
1604   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1605   return _mm512_mask_shufflelo_epi16(__W, __U, __A, 5);
1606 }
1607
1608 __m512i test_mm512_maskz_shufflelo_epi16(__mmask32 __U, __m512i __A) {
1609   // CHECK-LABEL: @test_mm512_maskz_shufflelo_epi16
1610   // CHECK: shufflevector <32 x i16> %{{.*}}, <32 x i16> poison, <32 x i32> <i32 1, i32 1, i32 0, i32 0, i32 4, i32 5, i32 6, i32 7, i32 9, i32 9, i32 8, i32 8, i32 12, i32 13, i32 14, i32 15, i32 17, i32 17, i32 16, i32 16, i32 20, i32 21, i32 22, i32 23, i32 25, i32 25, i32 24, i32 24, i32 28, i32 29, i32 30, i32 31>
1611   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1612   return _mm512_maskz_shufflelo_epi16(__U, __A, 5);
1613 }
1614
1615 __m512i test_mm512_sllv_epi16(__m512i __A, __m512i __B) {
1616   // CHECK-LABEL: @test_mm512_sllv_epi16
1617   // CHECK: @llvm.x86.avx512.psllv.w.512(
1618   return _mm512_sllv_epi16(__A, __B);
1619 }
1620
1621 __m512i test_mm512_mask_sllv_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
1622   // CHECK-LABEL: @test_mm512_mask_sllv_epi16
1623   // CHECK: @llvm.x86.avx512.psllv.w.512(
1624   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1625   return _mm512_mask_sllv_epi16(__W, __U, __A, __B);
1626 }
1627
1628 __m512i test_mm512_maskz_sllv_epi16(__mmask32 __U, __m512i __A, __m512i __B) {
1629   // CHECK-LABEL: @test_mm512_maskz_sllv_epi16
1630   // CHECK: @llvm.x86.avx512.psllv.w.512(
1631   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1632   return _mm512_maskz_sllv_epi16(__U, __A, __B);
1633 }
1634
1635 __m512i test_mm512_sll_epi16(__m512i __A, __m128i __B) {
1636   // CHECK-LABEL: @test_mm512_sll_epi16
1637   // CHECK: @llvm.x86.avx512.psll.w.512
1638   return _mm512_sll_epi16(__A, __B);
1639 }
1640
1641 __m512i test_mm512_mask_sll_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m128i __B) {
1642   // CHECK-LABEL: @test_mm512_mask_sll_epi16
1643   // CHECK: @llvm.x86.avx512.psll.w.512
1644   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1645   return _mm512_mask_sll_epi16(__W, __U, __A, __B);
1646 }
1647
1648 __m512i test_mm512_maskz_sll_epi16(__mmask32 __U, __m512i __A, __m128i __B) {
1649   // CHECK-LABEL: @test_mm512_maskz_sll_epi16
1650   // CHECK: @llvm.x86.avx512.psll.w.512
1651   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1652   return _mm512_maskz_sll_epi16(__U, __A, __B);
1653 }
1654
1655 __m512i test_mm512_slli_epi16(__m512i __A) {
1656   // CHECK-LABEL: @test_mm512_slli_epi16
1657   // CHECK: @llvm.x86.avx512.pslli.w.512
1658   return _mm512_slli_epi16(__A, 5);
1659 }
1660
1661 __m512i test_mm512_slli_epi16_2(__m512i __A, unsigned int __B) {
1662   // CHECK-LABEL: @test_mm512_slli_epi16_2
1663   // CHECK: @llvm.x86.avx512.pslli.w.512
1664   return _mm512_slli_epi16(__A, __B);
1665 }
1666
1667 __m512i test_mm512_mask_slli_epi16(__m512i __W, __mmask32 __U, __m512i __A) {
1668   // CHECK-LABEL: @test_mm512_mask_slli_epi16
1669   // CHECK: @llvm.x86.avx512.pslli.w.512
1670   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1671   return _mm512_mask_slli_epi16(__W, __U, __A, 5);
1672 }
1673
1674 __m512i test_mm512_mask_slli_epi16_2(__m512i __W, __mmask32 __U, __m512i __A, unsigned int __B) {
1675   // CHECK-LABEL: @test_mm512_mask_slli_epi16_2
1676   // CHECK: @llvm.x86.avx512.pslli.w.512
1677   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1678   return _mm512_mask_slli_epi16(__W, __U, __A, __B);
1679 }
1680
1681 __m512i test_mm512_maskz_slli_epi16(__mmask32 __U, __m512i __A) {
1682   // CHECK-LABEL: @test_mm512_maskz_slli_epi16
1683   // CHECK: @llvm.x86.avx512.pslli.w.512
1684   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1685   return _mm512_maskz_slli_epi16(__U, __A, 5);
1686 }
1687
1688 __m512i test_mm512_maskz_slli_epi16_2(__mmask32 __U, __m512i __A, unsigned int __B) {
1689   // CHECK-LABEL: @test_mm512_maskz_slli_epi16_2
1690   // CHECK: @llvm.x86.avx512.pslli.w.512
1691   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1692   return _mm512_maskz_slli_epi16(__U, __A, __B);
1693 }
1694
1695 __m512i test_mm512_bslli_epi128(__m512i __A) {
1696   // CHECK-LABEL: @test_mm512_bslli_epi128
1697   // CHECK: shufflevector <64 x i8> zeroinitializer, <64 x i8> %{{.*}}, <64 x i32> <i32 11, i32 12, i32 13, i32 14, i32 15, i32 64, i32 65, i32 66, i32 67, i32 68, i32 69, i32 70, i32 71, i32 72, i32 73, i32 74, i32 27, i32 28, i32 29, i32 30, i32 31, i32 80, i32 81, i32 82, i32 83, i32 84, i32 85, i32 86, i32 87, i32 88, i32 89, i32 90, i32 43, i32 44, i32 45, i32 46, i32 47, i32 96, i32 97, i32 98, i32 99, i32 100, i32 101, i32 102, i32 103, i32 104, i32 105, i32 106, i32 59, i32 60, i32 61, i32 62, i32 63, i32 112, i32 113, i32 114, i32 115, i32 116, i32 117, i32 118, i32 119, i32 120, i32 121, i32 122>
1698   return _mm512_bslli_epi128(__A, 5);
1699 }
1700
1701 __m512i test_mm512_srlv_epi16(__m512i __A, __m512i __B) {
1702   // CHECK-LABEL: @test_mm512_srlv_epi16
1703   // CHECK: @llvm.x86.avx512.psrlv.w.512(
1704   return _mm512_srlv_epi16(__A, __B);
1705 }
1706
1707 __m512i test_mm512_mask_srlv_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
1708   // CHECK-LABEL: @test_mm512_mask_srlv_epi16
1709   // CHECK: @llvm.x86.avx512.psrlv.w.512(
1710   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1711   return _mm512_mask_srlv_epi16(__W, __U, __A, __B);
1712 }
1713
1714 __m512i test_mm512_maskz_srlv_epi16(__mmask32 __U, __m512i __A, __m512i __B) {
1715   // CHECK-LABEL: @test_mm512_maskz_srlv_epi16
1716   // CHECK: @llvm.x86.avx512.psrlv.w.512(
1717   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1718   return _mm512_maskz_srlv_epi16(__U, __A, __B);
1719 }
1720
1721 __m512i test_mm512_srav_epi16(__m512i __A, __m512i __B) {
1722   // CHECK-LABEL: @test_mm512_srav_epi16
1723   // CHECK: @llvm.x86.avx512.psrav.w.512(
1724   return _mm512_srav_epi16(__A, __B);
1725 }
1726
1727 __m512i test_mm512_mask_srav_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
1728   // CHECK-LABEL: @test_mm512_mask_srav_epi16
1729   // CHECK: @llvm.x86.avx512.psrav.w.512(
1730   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1731   return _mm512_mask_srav_epi16(__W, __U, __A, __B);
1732 }
1733
1734 __m512i test_mm512_maskz_srav_epi16(__mmask32 __U, __m512i __A, __m512i __B) {
1735   // CHECK-LABEL: @test_mm512_maskz_srav_epi16
1736   // CHECK: @llvm.x86.avx512.psrav.w.512(
1737   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1738   return _mm512_maskz_srav_epi16(__U, __A, __B);
1739 }
1740
1741 __m512i test_mm512_sra_epi16(__m512i __A, __m128i __B) {
1742   // CHECK-LABEL: @test_mm512_sra_epi16
1743   // CHECK: @llvm.x86.avx512.psra.w.512
1744   return _mm512_sra_epi16(__A, __B);
1745 }
1746
1747 __m512i test_mm512_mask_sra_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m128i __B) {
1748   // CHECK-LABEL: @test_mm512_mask_sra_epi16
1749   // CHECK: @llvm.x86.avx512.psra.w.512
1750   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1751   return _mm512_mask_sra_epi16(__W, __U, __A, __B);
1752 }
1753
1754 __m512i test_mm512_maskz_sra_epi16(__mmask32 __U, __m512i __A, __m128i __B) {
1755   // CHECK-LABEL: @test_mm512_maskz_sra_epi16
1756   // CHECK: @llvm.x86.avx512.psra.w.512
1757   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1758   return _mm512_maskz_sra_epi16(__U, __A, __B);
1759 }
1760
1761 __m512i test_mm512_srai_epi16(__m512i __A) {
1762   // CHECK-LABEL: @test_mm512_srai_epi16
1763   // CHECK: @llvm.x86.avx512.psrai.w.512
1764   return _mm512_srai_epi16(__A, 5);
1765 }
1766
1767 __m512i test_mm512_srai_epi16_2(__m512i __A, unsigned int __B) {
1768   // CHECK-LABEL: @test_mm512_srai_epi16_2
1769   // CHECK: @llvm.x86.avx512.psrai.w.512
1770   return _mm512_srai_epi16(__A, __B);
1771 }
1772
1773 __m512i test_mm512_mask_srai_epi16(__m512i __W, __mmask32 __U, __m512i __A) {
1774   // CHECK-LABEL: @test_mm512_mask_srai_epi16
1775   // CHECK: @llvm.x86.avx512.psrai.w.512
1776   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1777   return _mm512_mask_srai_epi16(__W, __U, __A, 5);
1778 }
1779
1780 __m512i test_mm512_mask_srai_epi16_2(__m512i __W, __mmask32 __U, __m512i __A, unsigned int __B) {
1781   // CHECK-LABEL: @test_mm512_mask_srai_epi16_2
1782   // CHECK: @llvm.x86.avx512.psrai.w.512
1783   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1784   return _mm512_mask_srai_epi16(__W, __U, __A, __B);
1785 }
1786
1787 __m512i test_mm512_maskz_srai_epi16(__mmask32 __U, __m512i __A) {
1788   // CHECK-LABEL: @test_mm512_maskz_srai_epi16
1789   // CHECK: @llvm.x86.avx512.psrai.w.512
1790   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1791   return _mm512_maskz_srai_epi16(__U, __A, 5);
1792 }
1793
1794 __m512i test_mm512_maskz_srai_epi16_2(__mmask32 __U, __m512i __A, unsigned int __B) {
1795   // CHECK-LABEL: @test_mm512_maskz_srai_epi16_2
1796   // CHECK: @llvm.x86.avx512.psrai.w.512
1797   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1798   return _mm512_maskz_srai_epi16(__U, __A, __B);
1799 }
1800
1801 __m512i test_mm512_srl_epi16(__m512i __A, __m128i __B) {
1802   // CHECK-LABEL: @test_mm512_srl_epi16
1803   // CHECK: @llvm.x86.avx512.psrl.w.512
1804   return _mm512_srl_epi16(__A, __B);
1805 }
1806
1807 __m512i test_mm512_mask_srl_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m128i __B) {
1808   // CHECK-LABEL: @test_mm512_mask_srl_epi16
1809   // CHECK: @llvm.x86.avx512.psrl.w.512
1810   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1811   return _mm512_mask_srl_epi16(__W, __U, __A, __B);
1812 }
1813
1814 __m512i test_mm512_maskz_srl_epi16(__mmask32 __U, __m512i __A, __m128i __B) {
1815   // CHECK-LABEL: @test_mm512_maskz_srl_epi16
1816   // CHECK: @llvm.x86.avx512.psrl.w.512
1817   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1818   return _mm512_maskz_srl_epi16(__U, __A, __B);
1819 }
1820
1821 __m512i test_mm512_srli_epi16(__m512i __A) {
1822   // CHECK-LABEL: @test_mm512_srli_epi16
1823   // CHECK: @llvm.x86.avx512.psrli.w.512
1824   return _mm512_srli_epi16(__A, 5);
1825 }
1826
1827 __m512i test_mm512_srli_epi16_2(__m512i __A, unsigned int __B) {
1828   // CHECK-LABEL: @test_mm512_srli_epi16_2
1829   // CHECK: @llvm.x86.avx512.psrli.w.512
1830   return _mm512_srli_epi16(__A, __B);
1831 }
1832
1833 __m512i test_mm512_mask_srli_epi16(__m512i __W, __mmask32 __U, __m512i __A) {
1834   // CHECK-LABEL: @test_mm512_mask_srli_epi16
1835   // CHECK: @llvm.x86.avx512.psrli.w.512
1836   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1837   return _mm512_mask_srli_epi16(__W, __U, __A, 5);
1838 }
1839
1840 __m512i test_mm512_mask_srli_epi16_2(__m512i __W, __mmask32 __U, __m512i __A, unsigned int __B) {
1841   // CHECK-LABEL: @test_mm512_mask_srli_epi16_2
1842   // CHECK: @llvm.x86.avx512.psrli.w.512
1843   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1844   return _mm512_mask_srli_epi16(__W, __U, __A, __B);
1845 }
1846
1847 __m512i test_mm512_maskz_srli_epi16(__mmask32 __U, __m512i __A) {
1848   // CHECK-LABEL: @test_mm512_maskz_srli_epi16
1849   // CHECK: @llvm.x86.avx512.psrli.w.512
1850   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1851   return _mm512_maskz_srli_epi16(__U, __A, 5);
1852 }
1853
1854 __m512i test_mm512_maskz_srli_epi16_2(__mmask32 __U, __m512i __A, int __B) {
1855   // CHECK-LABEL: @test_mm512_maskz_srli_epi16_2
1856   // CHECK: @llvm.x86.avx512.psrli.w.512
1857   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1858   return _mm512_maskz_srli_epi16(__U, __A, __B);
1859 }
1860
1861 __m512i test_mm512_bsrli_epi128(__m512i __A) {
1862   // CHECK-LABEL: @test_mm512_bsrli_epi128
1863   // CHECK: shufflevector <64 x i8> %{{.*}}, <64 x i8> zeroinitializer, <64 x i32> <i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 64, i32 65, i32 66, i32 67, i32 68, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 80, i32 81, i32 82, i32 83, i32 84, i32 37, i32 38, i32 39, i32 40, i32 41, i32 42, i32 43, i32 44, i32 45, i32 46, i32 47, i32 96, i32 97, i32 98, i32 99, i32 100, i32 53, i32 54, i32 55, i32 56, i32 57, i32 58, i32 59, i32 60, i32 61, i32 62, i32 63, i32 112, i32 113, i32 114, i32 115, i32 116>
1864   return _mm512_bsrli_epi128(__A, 5);
1865 }
1866 __m512i test_mm512_mask_mov_epi16(__m512i __W, __mmask32 __U, __m512i __A) {
1867   // CHECK-LABEL: @test_mm512_mask_mov_epi16
1868   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1869   return _mm512_mask_mov_epi16(__W, __U, __A);
1870 }
1871
1872 __m512i test_mm512_maskz_mov_epi16(__mmask32 __U, __m512i __A) {
1873   // CHECK-LABEL: @test_mm512_maskz_mov_epi16
1874   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
1875   return _mm512_maskz_mov_epi16(__U, __A);
1876 }
1877
1878 __m512i test_mm512_mask_mov_epi8(__m512i __W, __mmask64 __U, __m512i __A) {
1879   // CHECK-LABEL: @test_mm512_mask_mov_epi8
1880   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
1881   return _mm512_mask_mov_epi8(__W, __U, __A);
1882 }
1883
1884 __m512i test_mm512_maskz_mov_epi8(__mmask64 __U, __m512i __A) {
1885   // CHECK-LABEL: @test_mm512_maskz_mov_epi8
1886   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
1887   return _mm512_maskz_mov_epi8(__U, __A);
1888 }
1889
1890 __m512i test_mm512_mask_set1_epi8(__m512i __O, __mmask64 __M, char __A) {
1891   // CHECK-LABEL: @test_mm512_mask_set1_epi8
1892   // CHECK: insertelement <64 x i8> poison, i8 %{{.*}}, i32 0
1893   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 1
1894   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 2
1895   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 3
1896   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 4
1897   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 5
1898   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 6
1899   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 7
1900   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 8
1901   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 9
1902   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 10
1903   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 11
1904   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 12
1905   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 13
1906   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 14
1907   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 15
1908   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 16
1909   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 17
1910   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 18
1911   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 19
1912   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 20
1913   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 21
1914   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 22
1915   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 23
1916   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 24
1917   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 25
1918   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 26
1919   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 27
1920   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 28
1921   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 29
1922   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 30
1923   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 31
1924   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 34
1925   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 35
1926   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 36
1927   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 37
1928   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 38
1929   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 39
1930   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 40
1931   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 41
1932   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 42
1933   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 43
1934   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 44
1935   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 45
1936   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 46
1937   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 47
1938   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 48
1939   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 49
1940   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 50
1941   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 51
1942   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 52
1943   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 53
1944   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 54
1945   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 55
1946   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 56
1947   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 57
1948   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 58
1949   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 59
1950   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 60
1951   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 61
1952   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 62
1953   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 63
1954   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
1955   return _mm512_mask_set1_epi8(__O, __M, __A);
1956 }
1957
1958 __m512i test_mm512_maskz_set1_epi8(__mmask64 __M, char __A) {
1959   // CHECK-LABEL: @test_mm512_maskz_set1_epi8
1960   // CHECK: insertelement <64 x i8> poison, i8 %{{.*}}, i32 0
1961   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 1
1962   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 2
1963   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 3
1964   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 4
1965   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 5
1966   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 6
1967   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 7
1968   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 8
1969   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 9
1970   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 10
1971   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 11
1972   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 12
1973   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 13
1974   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 14
1975   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 15
1976   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 16
1977   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 17
1978   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 18
1979   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 19
1980   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 20
1981   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 21
1982   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 22
1983   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 23
1984   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 24
1985   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 25
1986   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 26
1987   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 27
1988   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 28
1989   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 29
1990   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 30
1991   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 31
1992   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 32
1993   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 33
1994   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 34
1995   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 35
1996   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 36
1997   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 37
1998   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 38
1999   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 39
2000   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 40
2001   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 41
2002   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 42
2003   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 43
2004   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 44
2005   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 45
2006   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 46
2007   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 47
2008   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 48
2009   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 49
2010   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 50
2011   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 51
2012   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 52
2013   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 53
2014   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 54
2015   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 55
2016   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 56
2017   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 57
2018   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 58
2019   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 59
2020   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 60
2021   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 61
2022   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 62
2023   // CHECK: insertelement <64 x i8> %{{.*}}, i8 %{{.*}}, i32 63
2024   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
2025   return _mm512_maskz_set1_epi8(__M, __A);
2026 }
2027
2028 __mmask64 test_mm512_kunpackd(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
2029   // CHECK-LABEL: @test_mm512_kunpackd
2030   // CHECK: [[LHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
2031   // CHECK: [[RHS:%.*]] = bitcast i64 %{{.*}} to <64 x i1>
2032   // CHECK: [[LHS2:%.*]] = shufflevector <64 x i1> [[LHS]], <64 x i1> [[LHS]], <32 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31>
2033   // CHECK: [[RHS2:%.*]] = shufflevector <64 x i1> [[RHS]], <64 x i1> [[RHS]], <32 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31>
2034   // CHECK: [[CONCAT:%.*]] = shufflevector <32 x i1> [[RHS2]], <32 x i1> [[LHS2]], <64 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 32, i32 33, i32 34, i32 35, i32 36, i32 37, i32 38, i32 39, i32 40, i32 41, i32 42, i32 43, i32 44, i32 45, i32 46, i32 47, i32 48, i32 49, i32 50, i32 51, i32 52, i32 53, i32 54, i32 55, i32 56, i32 57, i32 58, i32 59, i32 60, i32 61, i32 62, i32 63>
2035   return _mm512_mask_cmpneq_epu8_mask(_mm512_kunpackd(_mm512_cmpneq_epu8_mask(__B, __A),_mm512_cmpneq_epu8_mask(__C, __D)), __E, __F);
2036 }
2037
2038 __mmask32 test_mm512_kunpackw(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) {
2039   // CHECK-LABEL: @test_mm512_kunpackw
2040   // CHECK: [[LHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
2041   // CHECK: [[RHS:%.*]] = bitcast i32 %{{.*}} to <32 x i1>
2042   // CHECK: [[LHS2:%.*]] = shufflevector <32 x i1> [[LHS]], <32 x i1> [[LHS]], <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
2043   // CHECK: [[RHS2:%.*]] = shufflevector <32 x i1> [[RHS]], <32 x i1> [[RHS]], <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
2044   // CHECK: [[CONCAT:%.*]] = shufflevector <16 x i1> [[RHS2]], <16 x i1> [[LHS2]], <32 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31>
2045   return _mm512_mask_cmpneq_epu16_mask(_mm512_kunpackw(_mm512_cmpneq_epu16_mask(__B, __A),_mm512_cmpneq_epu16_mask(__C, __D)), __E, __F);
2046 }
2047
2048 __m512i test_mm512_loadu_epi16 (void *__P)
2049 {
2050   // CHECK-LABEL: @test_mm512_loadu_epi16
2051   // CHECK: load <8 x i64>, ptr %{{.*}}, align 1{{$}}
2052   return _mm512_loadu_epi16 (__P);
2053 }
2054
2055 __m512i test_mm512_mask_loadu_epi16(__m512i __W, __mmask32 __U, void const *__P) {
2056   // CHECK-LABEL: @test_mm512_mask_loadu_epi16
2057   // CHECK: @llvm.masked.load.v32i16.p0(ptr %{{.*}}, i32 1, <32 x i1> %{{.*}}, <32 x i16> %{{.*}})
2058   return _mm512_mask_loadu_epi16(__W, __U, __P);
2059 }
2060
2061 __m512i test_mm512_maskz_loadu_epi16(__mmask32 __U, void const *__P) {
2062   // CHECK-LABEL: @test_mm512_maskz_loadu_epi16
2063   // CHECK: @llvm.masked.load.v32i16.p0(ptr %{{.*}}, i32 1, <32 x i1> %{{.*}}, <32 x i16> %{{.*}})
2064   return _mm512_maskz_loadu_epi16(__U, __P);
2065 }
2066
2067 __m512i test_mm512_loadu_epi8 (void *__P)
2068 {
2069   // CHECK-LABEL: @test_mm512_loadu_epi8
2070   // CHECK: load <8 x i64>, ptr %{{.*}}, align 1{{$}}
2071   return _mm512_loadu_epi8 (__P);
2072 }
2073
2074 __m512i test_mm512_mask_loadu_epi8(__m512i __W, __mmask64 __U, void const *__P) {
2075   // CHECK-LABEL: @test_mm512_mask_loadu_epi8
2076   // CHECK: @llvm.masked.load.v64i8.p0(ptr %{{.*}}, i32 1, <64 x i1> %{{.*}}, <64 x i8> %{{.*}})
2077   return _mm512_mask_loadu_epi8(__W, __U, __P);
2078 }
2079
2080 __m512i test_mm512_maskz_loadu_epi8(__mmask64 __U, void const *__P) {
2081   // CHECK-LABEL: @test_mm512_maskz_loadu_epi8
2082   // CHECK: @llvm.masked.load.v64i8.p0(ptr %{{.*}}, i32 1, <64 x i1> %{{.*}}, <64 x i8> %{{.*}})
2083   return _mm512_maskz_loadu_epi8(__U, __P);
2084 }
2085
2086 void test_mm512_storeu_epi16(void *__P, __m512i __A) {
2087   // CHECK-LABEL: @test_mm512_storeu_epi16
2088   // CHECK: store <8 x i64> %{{.*}}, ptr %{{.*}}, align 1{{$}}
2089   return _mm512_storeu_epi16(__P, __A);
2090 }
2091
2092 void test_mm512_mask_storeu_epi16(void *__P, __mmask32 __U, __m512i __A) {
2093   // CHECK-LABEL: @test_mm512_mask_storeu_epi16
2094   // CHECK: @llvm.masked.store.v32i16.p0(<32 x i16> %{{.*}}, ptr %{{.*}}, i32 1, <32 x i1> %{{.*}})
2095   return _mm512_mask_storeu_epi16(__P, __U, __A);
2096 }
2097
2098 __mmask64 test_mm512_test_epi8_mask(__m512i __A, __m512i __B) {
2099   // CHECK-LABEL: @test_mm512_test_epi8_mask
2100   // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
2101   // CHECK: icmp ne <64 x i8> %{{.*}}, %{{.*}}
2102   return _mm512_test_epi8_mask(__A, __B);
2103 }
2104
2105 void test_mm512_storeu_epi8(void *__P, __m512i __A) {
2106   // CHECK-LABEL: @test_mm512_storeu_epi8
2107   // CHECK: store <8 x i64> %{{.*}}, ptr %{{.*}}, align 1{{$}}
2108   return _mm512_storeu_epi8(__P, __A);
2109 }
2110
2111 void test_mm512_mask_storeu_epi8(void *__P, __mmask64 __U, __m512i __A) {
2112   // CHECK-LABEL: @test_mm512_mask_storeu_epi8
2113   // CHECK: @llvm.masked.store.v64i8.p0(<64 x i8> %{{.*}}, ptr %{{.*}}, i32 1, <64 x i1> %{{.*}})
2114   return _mm512_mask_storeu_epi8(__P, __U, __A);
2115 }
2116 __mmask64 test_mm512_mask_test_epi8_mask(__mmask64 __U, __m512i __A, __m512i __B) {
2117   // CHECK-LABEL: @test_mm512_mask_test_epi8_mask
2118   // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
2119   // CHECK: icmp ne <64 x i8> %{{.*}}, %{{.*}}
2120   // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
2121   return _mm512_mask_test_epi8_mask(__U, __A, __B);
2122 }
2123
2124 __mmask32 test_mm512_test_epi16_mask(__m512i __A, __m512i __B) {
2125   // CHECK-LABEL: @test_mm512_test_epi16_mask
2126   // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
2127   // CHECK: icmp ne <32 x i16> %{{.*}}, %{{.*}}
2128   return _mm512_test_epi16_mask(__A, __B);
2129 }
2130
2131 __mmask32 test_mm512_mask_test_epi16_mask(__mmask32 __U, __m512i __A, __m512i __B) {
2132   // CHECK-LABEL: @test_mm512_mask_test_epi16_mask
2133   // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
2134   // CHECK: icmp ne <32 x i16> %{{.*}}, %{{.*}}
2135   // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
2136   return _mm512_mask_test_epi16_mask(__U, __A, __B);
2137 }
2138
2139 __mmask64 test_mm512_testn_epi8_mask(__m512i __A, __m512i __B) {
2140   // CHECK-LABEL: @test_mm512_testn_epi8_mask
2141   // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
2142   // CHECK: icmp eq <64 x i8> %{{.*}}, %{{.*}}
2143   return _mm512_testn_epi8_mask(__A, __B);
2144 }
2145
2146 __mmask64 test_mm512_mask_testn_epi8_mask(__mmask64 __U, __m512i __A, __m512i __B) {
2147   // CHECK-LABEL: @test_mm512_mask_testn_epi8_mask
2148   // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
2149   // CHECK: icmp eq <64 x i8> %{{.*}}, %{{.*}}
2150   // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
2151   return _mm512_mask_testn_epi8_mask(__U, __A, __B);
2152 }
2153
2154 __mmask32 test_mm512_testn_epi16_mask(__m512i __A, __m512i __B) {
2155   // CHECK-LABEL: @test_mm512_testn_epi16_mask
2156   // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
2157   // CHECK: icmp eq <32 x i16> %{{.*}}, %{{.*}}
2158   return _mm512_testn_epi16_mask(__A, __B);
2159 }
2160
2161 __mmask32 test_mm512_mask_testn_epi16_mask(__mmask32 __U, __m512i __A, __m512i __B) {
2162   // CHECK-LABEL: @test_mm512_mask_testn_epi16_mask
2163   // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
2164   // CHECK: icmp eq <32 x i16> %{{.*}}, %{{.*}}
2165   // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
2166   return _mm512_mask_testn_epi16_mask(__U, __A, __B);
2167 }
2168
2169 __mmask64 test_mm512_movepi8_mask(__m512i __A) {
2170   // CHECK-LABEL: @test_mm512_movepi8_mask
2171   // CHECK: [[CMP:%.*]] = icmp slt <64 x i8> %{{.*}}, zeroinitializer
2172   return _mm512_movepi8_mask(__A);
2173 }
2174
2175 __m512i test_mm512_movm_epi8(__mmask64 __A) {
2176   // CHECK-LABEL: @test_mm512_movm_epi8
2177   // CHECK:  %{{.*}} = bitcast i64 %{{.*}} to <64 x i1>
2178   // CHECK:  %vpmovm2.i = sext <64 x i1> %{{.*}} to <64 x i8>
2179   return _mm512_movm_epi8(__A);
2180 }
2181
2182 __m512i test_mm512_movm_epi16(__mmask32 __A) {
2183   // CHECK-LABEL: @test_mm512_movm_epi16
2184   // CHECK:  %{{.*}} = bitcast i32 %{{.*}} to <32 x i1>
2185   // CHECK:  %vpmovm2.i = sext <32 x i1> %{{.*}} to <32 x i16>
2186   return _mm512_movm_epi16(__A);
2187 }
2188
2189 __m512i test_mm512_broadcastb_epi8(__m128i __A) {
2190   // CHECK-LABEL: @test_mm512_broadcastb_epi8
2191   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <64 x i32> zeroinitializer
2192   return _mm512_broadcastb_epi8(__A);
2193 }
2194
2195 __m512i test_mm512_mask_broadcastb_epi8(__m512i __O, __mmask64 __M, __m128i __A) {
2196   // CHECK-LABEL: @test_mm512_mask_broadcastb_epi8
2197   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <64 x i32> zeroinitializer
2198   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
2199   return _mm512_mask_broadcastb_epi8(__O, __M, __A);
2200 }
2201
2202 __m512i test_mm512_maskz_broadcastb_epi8(__mmask64 __M, __m128i __A) {
2203   // CHECK-LABEL: @test_mm512_maskz_broadcastb_epi8
2204   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <64 x i32> zeroinitializer
2205   // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
2206   return _mm512_maskz_broadcastb_epi8(__M, __A);
2207 }
2208
2209 __m512i test_mm512_broadcastw_epi16(__m128i __A) {
2210   // CHECK-LABEL: @test_mm512_broadcastw_epi16
2211   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <32 x i32> zeroinitializer
2212   return _mm512_broadcastw_epi16(__A);
2213 }
2214
2215 __m512i test_mm512_mask_broadcastw_epi16(__m512i __O, __mmask32 __M, __m128i __A) {
2216   // CHECK-LABEL: @test_mm512_mask_broadcastw_epi16
2217   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <32 x i32> zeroinitializer
2218   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
2219   return _mm512_mask_broadcastw_epi16(__O, __M, __A);
2220 }
2221
2222 __m512i test_mm512_maskz_broadcastw_epi16(__mmask32 __M, __m128i __A) {
2223   // CHECK-LABEL: @test_mm512_maskz_broadcastw_epi16
2224   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <32 x i32> zeroinitializer
2225   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
2226   return _mm512_maskz_broadcastw_epi16(__M, __A);
2227 }
2228
2229 __m512i test_mm512_mask_set1_epi16(__m512i __O, __mmask32 __M, short __A) {
2230   // CHECK-LABEL: @test_mm512_mask_set1_epi16
2231   // CHECK: insertelement <32 x i16> poison, i16 %{{.*}}, i32 0
2232   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 1
2233   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 2
2234   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 3
2235   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 4
2236   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 5
2237   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 6
2238   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 7
2239   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 8
2240   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 9
2241   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 10
2242   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 11
2243   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 12
2244   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 13
2245   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 14
2246   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 15
2247   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 16
2248   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 17
2249   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 18
2250   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 19
2251   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 20
2252   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 21
2253   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 22
2254   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 23
2255   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 24
2256   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 25
2257   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 26
2258   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 27
2259   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 28
2260   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 29
2261   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 30
2262   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 31
2263   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
2264   return _mm512_mask_set1_epi16(__O, __M, __A);
2265 }
2266
2267 __m512i test_mm512_maskz_set1_epi16(__mmask32 __M, short __A) {
2268   // CHECK-LABEL: @test_mm512_maskz_set1_epi16
2269   // CHECK: insertelement <32 x i16> poison, i16 %{{.*}}, i32 0
2270   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 1
2271   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 2
2272   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 3
2273   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 4
2274   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 5
2275   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 6
2276   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 7
2277   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 8
2278   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 9
2279   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 10
2280   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 11
2281   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 12
2282   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 13
2283   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 14
2284   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 15
2285   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 16
2286   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 17
2287   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 18
2288   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 19
2289   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 20
2290   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 21
2291   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 22
2292   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 23
2293   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 24
2294   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 25
2295   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 26
2296   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 27
2297   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 28
2298   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 29
2299   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 30
2300   // CHECK: insertelement <32 x i16> %{{.*}}, i16 %{{.*}}, i32 31
2301   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
2302   return _mm512_maskz_set1_epi16(__M, __A);
2303 }
2304 __m512i test_mm512_permutexvar_epi16(__m512i __A, __m512i __B) {
2305   // CHECK-LABEL: @test_mm512_permutexvar_epi16
2306   // CHECK: @llvm.x86.avx512.permvar.hi.512
2307  return _mm512_permutexvar_epi16(__A, __B);
2308 }
2309
2310 __m512i test_mm512_maskz_permutexvar_epi16(__mmask32 __M, __m512i __A, __m512i __B) {
2311  // CHECK-LABEL: @test_mm512_maskz_permutexvar_epi16
2312   // CHECK: @llvm.x86.avx512.permvar.hi.512
2313   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
2314   return _mm512_maskz_permutexvar_epi16(__M, __A, __B);
2315 }
2316
2317 __m512i test_mm512_mask_permutexvar_epi16(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B) {
2318   // CHECK-LABEL: @test_mm512_mask_permutexvar_epi16
2319   // CHECK: @llvm.x86.avx512.permvar.hi.512
2320   // CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
2321   return _mm512_mask_permutexvar_epi16(__W, __M, __A, __B);
2322 }
2323 __m512i test_mm512_alignr_epi8(__m512i __A,__m512i __B){
2324     // CHECK-LABEL: @test_mm512_alignr_epi8
2325     // CHECK: shufflevector <64 x i8> %{{.*}}, <64 x i8> %{{.*}}, <64 x i32> <i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 64, i32 65, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 80, i32 81, i32 34, i32 35, i32 36, i32 37, i32 38, i32 39, i32 40, i32 41, i32 42, i32 43, i32 44, i32 45, i32 46, i32 47, i32 96, i32 97, i32 50, i32 51, i32 52, i32 53, i32 54, i32 55, i32 56, i32 57, i32 58, i32 59, i32 60, i32 61, i32 62, i32 63, i32 112, i32 113>
2326     return _mm512_alignr_epi8(__A, __B, 2);
2327 }
2328
2329 __m512i test_mm512_mask_alignr_epi8(__m512i __W, __mmask64 __U, __m512i __A,__m512i __B){
2330     // CHECK-LABEL: @test_mm512_mask_alignr_epi8
2331     // CHECK: shufflevector <64 x i8> %{{.*}}, <64 x i8> %{{.*}}, <64 x i32> <i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 64, i32 65, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 80, i32 81, i32 34, i32 35, i32 36, i32 37, i32 38, i32 39, i32 40, i32 41, i32 42, i32 43, i32 44, i32 45, i32 46, i32 47, i32 96, i32 97, i32 50, i32 51, i32 52, i32 53, i32 54, i32 55, i32 56, i32 57, i32 58, i32 59, i32 60, i32 61, i32 62, i32 63, i32 112, i32 113>
2332     // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
2333     return _mm512_mask_alignr_epi8(__W, __U, __A, __B, 2);
2334 }
2335
2336 __m512i test_mm512_maskz_alignr_epi8(__mmask64 __U, __m512i __A,__m512i __B){
2337     // CHECK-LABEL: @test_mm512_maskz_alignr_epi8
2338     // CHECK: shufflevector <64 x i8> %{{.*}}, <64 x i8> %{{.*}}, <64 x i32> <i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 64, i32 65, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 31, i32 80, i32 81, i32 34, i32 35, i32 36, i32 37, i32 38, i32 39, i32 40, i32 41, i32 42, i32 43, i32 44, i32 45, i32 46, i32 47, i32 96, i32 97, i32 50, i32 51, i32 52, i32 53, i32 54, i32 55, i32 56, i32 57, i32 58, i32 59, i32 60, i32 61, i32 62, i32 63, i32 112, i32 113>
2339     // CHECK: select <64 x i1> %{{.*}}, <64 x i8> %{{.*}}, <64 x i8> %{{.*}}
2340    return _mm512_maskz_alignr_epi8(__U, __A, __B, 2);
2341 }
2342
2343
2344
2345 __m512i test_mm512_mm_dbsad_epu8(__m512i __A, __m512i __B) {
2346   // CHECK-LABEL: @test_mm512_mm_dbsad_epu8
2347   // CHECK: @llvm.x86.avx512.dbpsadbw.512
2348   return _mm512_dbsad_epu8(__A, __B, 170);
2349 }
2350
2351 __m512i test_mm512_mm_mask_dbsad_epu8(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
2352   // CHECK-LABEL: @test_mm512_mm_mask_dbsad_epu8
2353   // CHECK: @llvm.x86.avx512.dbpsadbw.512
2354   //CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
2355   return _mm512_mask_dbsad_epu8(__W, __U, __A, __B, 170);
2356 }
2357
2358 __m512i test_mm512_mm_maskz_dbsad_epu8(__mmask32 __U, __m512i __A, __m512i __B) {
2359   // CHECK-LABEL: @test_mm512_mm_maskz_dbsad_epu8
2360   // CHECK: @llvm.x86.avx512.dbpsadbw.512
2361   //CHECK: select <32 x i1> %{{.*}}, <32 x i16> %{{.*}}, <32 x i16> %{{.*}}
2362   return _mm512_maskz_dbsad_epu8(__U, __A, __B, 170);
2363 }
2364
2365 __m512i test_mm512_sad_epu8(__m512i __A, __m512i __B) {
2366   // CHECK-LABEL: @test_mm512_sad_epu8
2367   // CHECK: @llvm.x86.avx512.psad.bw.512
2368   return _mm512_sad_epu8(__A, __B);
2369 }
2370
2371 __mmask32 test_mm512_movepi16_mask(__m512i __A) {
2372   // CHECK-LABEL: @test_mm512_movepi16_mask
2373   // CHECK: [[CMP:%.*]] = icmp slt <32 x i16> %{{.*}}, zeroinitializer
2374   return _mm512_movepi16_mask(__A);
2375 }
2376
2377 void test_mm512_mask_cvtepi16_storeu_epi8 (void * __P, __mmask32 __M, __m512i __A)
2378 {
2379  // CHECK-LABEL: @test_mm512_mask_cvtepi16_storeu_epi8
2380  // CHECK: @llvm.x86.avx512.mask.pmov.wb.mem.512
2381  _mm512_mask_cvtepi16_storeu_epi8 ( __P,  __M, __A);
2382 }
2383
2384 void test_mm512_mask_cvtsepi16_storeu_epi8 (void * __P, __mmask32 __M, __m512i __A)
2385 {
2386  // CHECK-LABEL: @test_mm512_mask_cvtsepi16_storeu_epi8
2387  // CHECK: @llvm.x86.avx512.mask.pmovs.wb.mem.512
2388  _mm512_mask_cvtsepi16_storeu_epi8 ( __P,  __M, __A);
2389 }
2390
2391 void test_mm512_mask_cvtusepi16_storeu_epi8 (void * __P, __mmask32 __M, __m512i __A)
2392 {
2393  // CHECK-LABEL: @test_mm512_mask_cvtusepi16_storeu_epi8
2394  // CHECK: @llvm.x86.avx512.mask.pmovus.wb.mem.512
2395  _mm512_mask_cvtusepi16_storeu_epi8 ( __P, __M, __A);
2396 }