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

   1 // RUN: %clang_cc1 -x c -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx2 -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK,X64
   2 // RUN: %clang_cc1 -x c -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx2 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK,X64
   3 // RUN: %clang_cc1 -x c -flax-vector-conversions=none -ffreestanding %s -triple=i386-apple-darwin -target-feature +avx2 -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK,X86
   4 // RUN: %clang_cc1 -x c -flax-vector-conversions=none -ffreestanding %s -triple=i386-apple-darwin -target-feature +avx2 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK,X86
   5 // RUN: %clang_cc1 -x c++ -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx2 -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK,X64
   6 // RUN: %clang_cc1 -x c++ -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx2 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK,X64
   7 // RUN: %clang_cc1 -x c++ -flax-vector-conversions=none -ffreestanding %s -triple=i386-apple-darwin -target-feature +avx2 -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK,X86
   8 // RUN: %clang_cc1 -x c++ -flax-vector-conversions=none -ffreestanding %s -triple=i386-apple-darwin -target-feature +avx2 -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s --check-prefixes=CHECK,X86
   9
  10
  11 #include <immintrin.h>
  12
  13 // NOTE: This should match the tests in llvm/test/CodeGen/X86/avx2-intrinsics-fast-isel.ll
  14
  15 __m256i test_mm256_abs_epi8(__m256i a) {
  16   // CHECK-LABEL: test_mm256_abs_epi8
  17   // CHECK: [[ABS:%.*]] = call <32 x i8> @llvm.abs.v32i8(<32 x i8> %{{.*}}, i1 false)
  18   return _mm256_abs_epi8(a);
  19 }
  20
  21 __m256i test_mm256_abs_epi16(__m256i a) {
  22   // CHECK-LABEL: test_mm256_abs_epi16
  23   // CHECK: [[ABS:%.*]] = call <16 x i16> @llvm.abs.v16i16(<16 x i16> %{{.*}}, i1 false)
  24   return _mm256_abs_epi16(a);
  25 }
  26
  27 __m256i test_mm256_abs_epi32(__m256i a) {
  28   // CHECK-LABEL: test_mm256_abs_epi32
  29   // CHECK: [[ABS:%.*]] = call <8 x i32> @llvm.abs.v8i32(<8 x i32> %{{.*}}, i1 false)
  30   return _mm256_abs_epi32(a);
  31 }
  32
  33 __m256i test_mm256_add_epi8(__m256i a, __m256i b) {
  34   // CHECK-LABEL: test_mm256_add_epi8
  35   // CHECK: add <32 x i8>
  36   return _mm256_add_epi8(a, b);
  37 }
  38
  39 __m256i test_mm256_add_epi16(__m256i a, __m256i b) {
  40   // CHECK-LABEL: test_mm256_add_epi16
  41   // CHECK: add <16 x i16>
  42   return _mm256_add_epi16(a, b);
  43 }
  44
  45 __m256i test_mm256_add_epi32(__m256i a, __m256i b) {
  46   // CHECK-LABEL: test_mm256_add_epi32
  47   // CHECK: add <8 x i32>
  48   return _mm256_add_epi32(a, b);
  49 }
  50
  51 __m256i test_mm256_add_epi64(__m256i a, __m256i b) {
  52   // CHECK-LABEL: test_mm256_add_epi64
  53   // CHECK: add <4 x i64>
  54   return _mm256_add_epi64(a, b);
  55 }
  56
  57 __m256i test_mm256_adds_epi8(__m256i a, __m256i b) {
  58   // CHECK-LABEL: test_mm256_adds_epi8
  59   // CHECK: call <32 x i8> @llvm.sadd.sat.v32i8(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
  60   return _mm256_adds_epi8(a, b);
  61 }
  62
  63 __m256i test_mm256_adds_epi16(__m256i a, __m256i b) {
  64   // CHECK-LABEL: test_mm256_adds_epi16
  65   // CHECK: call <16 x i16> @llvm.sadd.sat.v16i16(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
  66   return _mm256_adds_epi16(a, b);
  67 }
  68
  69 __m256i test_mm256_adds_epu8(__m256i a, __m256i b) {
  70   // CHECK-LABEL: test_mm256_adds_epu8
  71   // CHECK-NOT: call <32 x i8> @llvm.x86.avx2.paddus.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
  72   // CHECK: call <32 x i8> @llvm.uadd.sat.v32i8(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
  73   return _mm256_adds_epu8(a, b);
  74 }
  75
  76 __m256i test_mm256_adds_epu16(__m256i a, __m256i b) {
  77   // CHECK-LABEL: test_mm256_adds_epu16
  78   // CHECK-NOT: call <16 x i16> @llvm.x86.avx2.paddus.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
  79   // CHECK: call <16 x i16> @llvm.uadd.sat.v16i16(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
  80   return _mm256_adds_epu16(a, b);
  81 }
  82
  83 __m256i test_mm256_alignr_epi8(__m256i a, __m256i b) {
  84   // CHECK-LABEL: test_mm256_alignr_epi8
  85   // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> %{{.*}}, <32 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 32, i32 33, 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 48, i32 49>
  86   return _mm256_alignr_epi8(a, b, 2);
  87 }
  88
  89 __m256i test2_mm256_alignr_epi8(__m256i a, __m256i b) {
  90   // CHECK-LABEL: test2_mm256_alignr_epi8
  91   // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> zeroinitializer, <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 32, 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 48>
  92   return _mm256_alignr_epi8(a, b, 17);
  93 }
  94
  95 __m256i test_mm256_and_si256(__m256i a, __m256i b) {
  96   // CHECK-LABEL: test_mm256_and_si256
  97   // CHECK: and <4 x i64>
  98   return _mm256_and_si256(a, b);
  99 }
 100
 101 __m256i test_mm256_andnot_si256(__m256i a, __m256i b) {
 102   // CHECK-LABEL: test_mm256_andnot_si256
 103   // CHECK: xor <4 x i64>
 104   // CHECK: and <4 x i64>
 105   return _mm256_andnot_si256(a, b);
 106 }
 107
 108 __m256i test_mm256_avg_epu8(__m256i a, __m256i b) {
 109   // CHECK-LABEL: test_mm256_avg_epu8
 110   // CHECK: call <32 x i8> @llvm.x86.avx2.pavg.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
 111   return _mm256_avg_epu8(a, b);
 112 }
 113
 114 __m256i test_mm256_avg_epu16(__m256i a, __m256i b) {
 115   // CHECK-LABEL: test_mm256_avg_epu16
 116   // CHECK: call <16 x i16> @llvm.x86.avx2.pavg.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
 117   return _mm256_avg_epu16(a, b);
 118 }
 119
 120 // FIXME: We should also lower the __builtin_ia32_pblendw128 (and similar)
 121 // functions to this IR. In the future we could delete the corresponding
 122 // intrinsic in LLVM if it's not being used anymore.
 123 __m256i test_mm256_blend_epi16(__m256i a, __m256i b) {
 124   // CHECK-LABEL: test_mm256_blend_epi16
 125   // CHECK-NOT: @llvm.x86.avx2.pblendw
 126   // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> %{{.*}}, <16 x i32> <i32 0, i32 17, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 25, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
 127   return _mm256_blend_epi16(a, b, 2);
 128 }
 129
 130 __m128i test_mm_blend_epi32(__m128i a, __m128i b) {
 131   // CHECK-LABEL: test_mm_blend_epi32
 132   // CHECK-NOT: @llvm.x86.avx2.pblendd.128
 133   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 4, i32 1, i32 6, i32 3>
 134   return _mm_blend_epi32(a, b, 0x05);
 135 }
 136
 137 __m256i test_mm256_blend_epi32(__m256i a, __m256i b) {
 138   // CHECK-LABEL: test_mm256_blend_epi32
 139   // CHECK-NOT: @llvm.x86.avx2.pblendd.256
 140   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 8, i32 1, i32 10, i32 3, i32 12, i32 13, i32 6, i32 7>
 141   return _mm256_blend_epi32(a, b, 0x35);
 142 }
 143
 144 __m256i test_mm256_blendv_epi8(__m256i a, __m256i b, __m256i m) {
 145   // CHECK-LABEL: test_mm256_blendv_epi8
 146   // CHECK: call <32 x i8> @llvm.x86.avx2.pblendvb(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}, <32 x i8> %{{.*}})
 147   return _mm256_blendv_epi8(a, b, m);
 148 }
 149
 150 __m128i test_mm_broadcastb_epi8(__m128i a) {
 151   // CHECK-LABEL: test_mm_broadcastb_epi8
 152   // CHECK-NOT: @llvm.x86.avx2.pbroadcastb.128
 153   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> zeroinitializer
 154   return _mm_broadcastb_epi8(a);
 155 }
 156
 157 __m256i test_mm256_broadcastb_epi8(__m128i a) {
 158   // CHECK-LABEL: test_mm256_broadcastb_epi8
 159   // CHECK-NOT: @llvm.x86.avx2.pbroadcastb.256
 160   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <32 x i32> zeroinitializer
 161   return _mm256_broadcastb_epi8(a);
 162 }
 163
 164 __m128i test_mm_broadcastd_epi32(__m128i a) {
 165   // CHECK-LABEL: test_mm_broadcastd_epi32
 166   // CHECK-NOT: @llvm.x86.avx2.pbroadcastd.128
 167   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> zeroinitializer
 168   return _mm_broadcastd_epi32(a);
 169 }
 170
 171 __m256i test_mm256_broadcastd_epi32(__m128i a) {
 172   // CHECK-LABEL: test_mm256_broadcastd_epi32
 173   // CHECK-NOT: @llvm.x86.avx2.pbroadcastd.256
 174   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <8 x i32> zeroinitializer
 175   return _mm256_broadcastd_epi32(a);
 176 }
 177
 178 __m128i test_mm_broadcastq_epi64(__m128i a) {
 179   // CHECK-LABEL: test_mm_broadcastq_epi64
 180   // CHECK-NOT: @llvm.x86.avx2.pbroadcastq.128
 181   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> zeroinitializer
 182   return _mm_broadcastq_epi64(a);
 183 }
 184
 185 __m256i test_mm256_broadcastq_epi64(__m128i a) {
 186   // CHECK-LABEL: test_mm256_broadcastq_epi64
 187   // CHECK-NOT: @llvm.x86.avx2.pbroadcastq.256
 188   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> zeroinitializer
 189   return _mm256_broadcastq_epi64(a);
 190 }
 191
 192 __m128d test_mm_broadcastsd_pd(__m128d a) {
 193   // CHECK-LABEL: test_mm_broadcastsd_pd
 194   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> zeroinitializer
 195   return _mm_broadcastsd_pd(a);
 196 }
 197
 198 __m256d test_mm256_broadcastsd_pd(__m128d a) {
 199   // CHECK-LABEL: test_mm256_broadcastsd_pd
 200   // CHECK-NOT: @llvm.x86.avx2.vbroadcast.sd.pd.256
 201   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> zeroinitializer
 202   return _mm256_broadcastsd_pd(a);
 203 }
 204
 205 __m256i test_mm256_broadcastsi128_si256(__m128i a) {
 206   // CHECK-LABEL: test_mm256_broadcastsi128_si256
 207   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
 208   return _mm256_broadcastsi128_si256(a);
 209 }
 210
 211 __m256i test_mm_broadcastsi128_si256(__m128i a) {
 212   // CHECK-LABEL: test_mm_broadcastsi128_si256
 213   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
 214   return _mm_broadcastsi128_si256(a);
 215 }
 216
 217 __m128 test_mm_broadcastss_ps(__m128 a) {
 218   // CHECK-LABEL: test_mm_broadcastss_ps
 219   // CHECK-NOT: @llvm.x86.avx2.vbroadcast.ss.ps
 220   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> zeroinitializer
 221   return _mm_broadcastss_ps(a);
 222 }
 223
 224 __m256 test_mm256_broadcastss_ps(__m128 a) {
 225   // CHECK-LABEL: test_mm256_broadcastss_ps
 226   // CHECK-NOT: @llvm.x86.avx2.vbroadcast.ss.ps.256
 227   // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> zeroinitializer
 228   return _mm256_broadcastss_ps(a);
 229 }
 230
 231 __m128i test_mm_broadcastw_epi16(__m128i a) {
 232   // CHECK-LABEL: test_mm_broadcastw_epi16
 233   // CHECK-NOT: @llvm.x86.avx2.pbroadcastw.128
 234   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> zeroinitializer
 235   return _mm_broadcastw_epi16(a);
 236 }
 237
 238 __m256i test_mm256_broadcastw_epi16(__m128i a) {
 239   // CHECK-LABEL: test_mm256_broadcastw_epi16
 240   // CHECK-NOT: @llvm.x86.avx2.pbroadcastw.256
 241   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <16 x i32> zeroinitializer
 242   return _mm256_broadcastw_epi16(a);
 243 }
 244
 245 __m256i test_mm256_bslli_epi128(__m256i a) {
 246   // CHECK-LABEL: test_mm256_bslli_epi128
 247   // CHECK: shufflevector <32 x i8> zeroinitializer, <32 x i8> %{{.*}}, <32 x i32> <i32 13, i32 14, i32 15, 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 29, i32 30, i32 31, 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>
 248   return _mm256_bslli_epi128(a, 3);
 249 }
 250
 251 __m256i test_mm256_bsrli_epi128(__m256i a) {
 252   // CHECK-LABEL: test_mm256_bsrli_epi128
 253   // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> zeroinitializer, <32 x i32> <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 32, i32 33, i32 34, 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 48, i32 49, i32 50>
 254   return _mm256_bsrli_epi128(a, 3);
 255 }
 256
 257 __m256i test_mm256_cmpeq_epi8(__m256i a, __m256i b) {
 258   // CHECK-LABEL: test_mm256_cmpeq_epi8
 259   // CHECK: icmp eq <32 x i8>
 260   return _mm256_cmpeq_epi8(a, b);
 261 }
 262
 263 __m256i test_mm256_cmpeq_epi16(__m256i a, __m256i b) {
 264   // CHECK-LABEL: test_mm256_cmpeq_epi16
 265   // CHECK: icmp eq <16 x i16>
 266   return _mm256_cmpeq_epi16(a, b);
 267 }
 268
 269 __m256i test_mm256_cmpeq_epi32(__m256i a, __m256i b) {
 270   // CHECK-LABEL: test_mm256_cmpeq_epi32
 271   // CHECK: icmp eq <8 x i32>
 272   return _mm256_cmpeq_epi32(a, b);
 273 }
 274
 275 __m256i test_mm256_cmpeq_epi64(__m256i a, __m256i b) {
 276   // CHECK-LABEL: test_mm256_cmpeq_epi64
 277   // CHECK: icmp eq <4 x i64>
 278   return _mm256_cmpeq_epi64(a, b);
 279 }
 280
 281 __m256i test_mm256_cmpgt_epi8(__m256i a, __m256i b) {
 282   // CHECK-LABEL: test_mm256_cmpgt_epi8
 283   // CHECK: icmp sgt <32 x i8>
 284   return _mm256_cmpgt_epi8(a, b);
 285 }
 286
 287 __m256i test_mm256_cmpgt_epi16(__m256i a, __m256i b) {
 288   // CHECK-LABEL: test_mm256_cmpgt_epi16
 289   // CHECK: icmp sgt <16 x i16>
 290   return _mm256_cmpgt_epi16(a, b);
 291 }
 292
 293 __m256i test_mm256_cmpgt_epi32(__m256i a, __m256i b) {
 294   // CHECK-LABEL: test_mm256_cmpgt_epi32
 295   // CHECK: icmp sgt <8 x i32>
 296   return _mm256_cmpgt_epi32(a, b);
 297 }
 298
 299 __m256i test_mm256_cmpgt_epi64(__m256i a, __m256i b) {
 300   // CHECK-LABEL: test_mm256_cmpgt_epi64
 301   // CHECK: icmp sgt <4 x i64>
 302   return _mm256_cmpgt_epi64(a, b);
 303 }
 304
 305 __m256i test_mm256_cvtepi8_epi16(__m128i a) {
 306   // CHECK-LABEL: test_mm256_cvtepi8_epi16
 307   // CHECK: sext <16 x i8> %{{.*}} to <16 x i16>
 308   return _mm256_cvtepi8_epi16(a);
 309 }
 310
 311 __m256i test_mm256_cvtepi8_epi32(__m128i a) {
 312   // CHECK-LABEL: test_mm256_cvtepi8_epi32
 313   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
 314   // CHECK: sext <8 x i8> %{{.*}} to <8 x i32>
 315   return _mm256_cvtepi8_epi32(a);
 316 }
 317
 318 __m256i test_mm256_cvtepi8_epi64(__m128i a) {
 319   // CHECK-LABEL: test_mm256_cvtepi8_epi64
 320   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 321   // CHECK: sext <4 x i8> %{{.*}} to <4 x i64>
 322   return _mm256_cvtepi8_epi64(a);
 323 }
 324
 325 __m256i test_mm256_cvtepi16_epi32(__m128i a) {
 326   // CHECK-LABEL: test_mm256_cvtepi16_epi32
 327   // CHECK: sext <8 x i16> %{{.*}} to <8 x i32>
 328   return _mm256_cvtepi16_epi32(a);
 329 }
 330
 331 __m256i test_mm256_cvtepi16_epi64(__m128i a) {
 332   // CHECK-LABEL: test_mm256_cvtepi16_epi64
 333   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 334   // CHECK: sext <4 x i16> %{{.*}} to <4 x i64>
 335   return _mm256_cvtepi16_epi64(a);
 336 }
 337
 338 __m256i test_mm256_cvtepi32_epi64(__m128i a) {
 339   // CHECK-LABEL: test_mm256_cvtepi32_epi64
 340   // CHECK: sext <4 x i32> %{{.*}} to <4 x i64>
 341   return _mm256_cvtepi32_epi64(a);
 342 }
 343
 344 __m256i test_mm256_cvtepu8_epi16(__m128i a) {
 345   // CHECK-LABEL: test_mm256_cvtepu8_epi16
 346   // CHECK: zext <16 x i8> %{{.*}} to <16 x i16>
 347   return _mm256_cvtepu8_epi16(a);
 348 }
 349
 350 __m256i test_mm256_cvtepu8_epi32(__m128i a) {
 351   // CHECK-LABEL: test_mm256_cvtepu8_epi32
 352   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
 353   // CHECK: zext <8 x i8> %{{.*}} to <8 x i32>
 354   return _mm256_cvtepu8_epi32(a);
 355 }
 356
 357 __m256i test_mm256_cvtepu8_epi64(__m128i a) {
 358   // CHECK-LABEL: test_mm256_cvtepu8_epi64
 359   // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 360   // CHECK: zext <4 x i8> %{{.*}} to <4 x i64>
 361   return _mm256_cvtepu8_epi64(a);
 362 }
 363
 364 __m256i test_mm256_cvtepu16_epi32(__m128i a) {
 365   // CHECK-LABEL: test_mm256_cvtepu16_epi32
 366   // CHECK: zext <8 x i16> {{.*}} to <8 x i32>
 367   return _mm256_cvtepu16_epi32(a);
 368 }
 369
 370 __m256i test_mm256_cvtepu16_epi64(__m128i a) {
 371   // CHECK-LABEL: test_mm256_cvtepu16_epi64
 372   // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 373   // CHECK: zext <4 x i16> %{{.*}} to <4 x i64>
 374   return _mm256_cvtepu16_epi64(a);
 375 }
 376
 377 __m256i test_mm256_cvtepu32_epi64(__m128i a) {
 378   // CHECK-LABEL: test_mm256_cvtepu32_epi64
 379   // CHECK: zext <4 x i32> %{{.*}} to <4 x i64>
 380   return _mm256_cvtepu32_epi64(a);
 381 }
 382
 383 __m128i test0_mm256_extracti128_si256_0(__m256i a) {
 384   // CHECK-LABEL: test0_mm256_extracti128_si256
 385   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> poison, <2 x i32> <i32 0, i32 1>
 386   return _mm256_extracti128_si256(a, 0);
 387 }
 388
 389 __m128i test1_mm256_extracti128_si256_1(__m256i a) {
 390   // CHECK-LABEL: test1_mm256_extracti128_si256
 391   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> poison, <2 x i32> <i32 2, i32 3>
 392   return _mm256_extracti128_si256(a, 1);
 393 }
 394
 395 // Immediate should be truncated to one bit.
 396 __m128i test2_mm256_extracti128_si256(__m256i a) {
 397   // CHECK-LABEL: test2_mm256_extracti128_si256
 398   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> poison, <2 x i32> <i32 0, i32 1>
 399   return _mm256_extracti128_si256(a, 0);
 400 }
 401
 402 __m256i test_mm256_hadd_epi16(__m256i a, __m256i b) {
 403   // CHECK-LABEL: test_mm256_hadd_epi16
 404   // CHECK: call <16 x i16> @llvm.x86.avx2.phadd.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
 405   return _mm256_hadd_epi16(a, b);
 406 }
 407
 408 __m256i test_mm256_hadd_epi32(__m256i a, __m256i b) {
 409   // CHECK-LABEL: test_mm256_hadd_epi32
 410   // CHECK: call <8 x i32> @llvm.x86.avx2.phadd.d(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 411   return _mm256_hadd_epi32(a, b);
 412 }
 413
 414 __m256i test_mm256_hadds_epi16(__m256i a, __m256i b) {
 415   // CHECK-LABEL: test_mm256_hadds_epi16
 416   // CHECK:call <16 x i16> @llvm.x86.avx2.phadd.sw(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
 417   return _mm256_hadds_epi16(a, b);
 418 }
 419
 420 __m256i test_mm256_hsub_epi16(__m256i a, __m256i b) {
 421   // CHECK-LABEL: test_mm256_hsub_epi16
 422   // CHECK: call <16 x i16> @llvm.x86.avx2.phsub.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
 423   return _mm256_hsub_epi16(a, b);
 424 }
 425
 426 __m256i test_mm256_hsub_epi32(__m256i a, __m256i b) {
 427   // CHECK-LABEL: test_mm256_hsub_epi32
 428   // CHECK: call <8 x i32> @llvm.x86.avx2.phsub.d(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 429   return _mm256_hsub_epi32(a, b);
 430 }
 431
 432 __m256i test_mm256_hsubs_epi16(__m256i a, __m256i b) {
 433   // CHECK-LABEL: test_mm256_hsubs_epi16
 434   // CHECK:call <16 x i16> @llvm.x86.avx2.phsub.sw(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
 435   return _mm256_hsubs_epi16(a, b);
 436 }
 437
 438 __m128i test_mm_i32gather_epi32(int const *b, __m128i c) {
 439   // CHECK-LABEL: test_mm_i32gather_epi32
 440   // CHECK: call <4 x i32> @llvm.x86.avx2.gather.d.d(<4 x i32> %{{.*}}, ptr %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i8 2)
 441   return _mm_i32gather_epi32(b, c, 2);
 442 }
 443
 444 __m128i test_mm_mask_i32gather_epi32(__m128i a, int const *b, __m128i c, __m128i d) {
 445   // CHECK-LABEL: test_mm_mask_i32gather_epi32
 446   // CHECK: call <4 x i32> @llvm.x86.avx2.gather.d.d(<4 x i32> %{{.*}}, ptr %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, i8 2)
 447   return _mm_mask_i32gather_epi32(a, b, c, d, 2);
 448 }
 449
 450 __m256i test_mm256_i32gather_epi32(int const *b, __m256i c) {
 451   // CHECK-LABEL: test_mm256_i32gather_epi32
 452   // CHECK: call <8 x i32> @llvm.x86.avx2.gather.d.d.256(<8 x i32> %{{.*}}, ptr %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, i8 2)
 453   return _mm256_i32gather_epi32(b, c, 2);
 454 }
 455
 456 __m256i test_mm256_mask_i32gather_epi32(__m256i a, int const *b, __m256i c, __m256i d) {
 457   // CHECK-LABEL: test_mm256_mask_i32gather_epi32
 458   // CHECK: call <8 x i32> @llvm.x86.avx2.gather.d.d.256(<8 x i32> %{{.*}}, ptr %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, i8 2)
 459   return _mm256_mask_i32gather_epi32(a, b, c, d, 2);
 460 }
 461
 462 __m128i test_mm_i32gather_epi64(long long const *b, __m128i c) {
 463   // CHECK-LABEL: test_mm_i32gather_epi64
 464   // CHECK: call {{.*}}<2 x i64> @llvm.x86.avx2.gather.d.q(<2 x i64> zeroinitializer, ptr %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}}, i8 2)
 465   return _mm_i32gather_epi64(b, c, 2);
 466 }
 467
 468 __m128i test_mm_mask_i32gather_epi64(__m128i a, long long const *b, __m128i c, __m128i d) {
 469   // CHECK-LABEL: test_mm_mask_i32gather_epi64
 470   // CHECK: call {{.*}}<2 x i64> @llvm.x86.avx2.gather.d.q(<2 x i64> %{{.*}}, ptr %{{.*}}, <4 x i32> %{{.*}}, <2 x i64> %{{.*}}, i8 2)
 471   return _mm_mask_i32gather_epi64(a, b, c, d, 2);
 472 }
 473
 474 __m256i test_mm256_i32gather_epi64(long long const *b, __m128i c) {
 475   // X64-LABEL: test_mm256_i32gather_epi64
 476   // X64: call {{.*}}<4 x i64> @llvm.x86.avx2.gather.d.q.256(<4 x i64> zeroinitializer, ptr %{{.*}}, <4 x i32> %{{.*}}, <4 x i64> %{{.*}}, i8 2)
 477   //
 478   // X86-LABEL: test_mm256_i32gather_epi64
 479   // X86: call {{.*}}<4 x i64> @llvm.x86.avx2.gather.d.q.256(<4 x i64> %{{.*}}, ptr %{{.*}}, <4 x i32> %{{.*}}, <4 x i64> %{{.*}}, i8 2)
 480   return _mm256_i32gather_epi64(b, c, 2);
 481 }
 482
 483 __m256i test_mm256_mask_i32gather_epi64(__m256i a, long long const *b, __m128i c, __m256i d) {
 484   // CHECK-LABEL: test_mm256_mask_i32gather_epi64
 485   // CHECK: call {{.*}}<4 x i64> @llvm.x86.avx2.gather.d.q.256(<4 x i64> %{{.*}}, ptr %{{.*}}, <4 x i32> %{{.*}}, <4 x i64> %{{.*}}, i8 2)
 486   return _mm256_mask_i32gather_epi64(a, b, c, d, 2);
 487 }
 488
 489 __m128d test_mm_i32gather_pd(double const *b, __m128i c) {
 490   // X64-LABEL: test_mm_i32gather_pd
 491   // X64:         [[CMP:%.*]] = fcmp oeq <2 x double>
 492   // X64-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
 493   // X64-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
 494   // X64: call <2 x double> @llvm.x86.avx2.gather.d.pd(<2 x double> zeroinitializer, ptr %{{.*}}, <4 x i32> %{{.*}}, <2 x double> %{{.*}}, i8 2)
 495   //
 496   // X86-LABEL: test_mm_i32gather_pd
 497   // X86:         [[CMP:%.*]] = fcmp oeq <2 x double>
 498   // X86-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
 499   // X86-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
 500   // X86: call <2 x double> @llvm.x86.avx2.gather.d.pd(<2 x double> %{{.*}}, ptr %{{.*}}, <4 x i32> %{{.*}}, <2 x double> %{{.*}}, i8 2)
 501   return _mm_i32gather_pd(b, c, 2);
 502 }
 503
 504 __m128d test_mm_mask_i32gather_pd(__m128d a, double const *b, __m128i c, __m128d d) {
 505   // CHECK-LABEL: test_mm_mask_i32gather_pd
 506   // CHECK: call <2 x double> @llvm.x86.avx2.gather.d.pd(<2 x double> %{{.*}}, ptr %{{.*}}, <4 x i32> %{{.*}}, <2 x double> %{{.*}}, i8 2)
 507   return _mm_mask_i32gather_pd(a, b, c, d, 2);
 508 }
 509
 510 __m256d test_mm256_i32gather_pd(double const *b, __m128i c) {
 511   // X64-LABEL: test_mm256_i32gather_pd
 512   // X64:         [[CMP:%.*]] = fcmp oeq <4 x double>
 513   // X64-NEXT:    [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i64>
 514   // X64-NEXT:    [[BC:%.*]] = bitcast <4 x i64> [[SEXT]] to <4 x double>
 515   // X64: call <4 x double> @llvm.x86.avx2.gather.d.pd.256(<4 x double> zeroinitializer, ptr %{{.*}}, <4 x i32> %{{.*}}, <4 x double> %{{.*}}, i8 2)
 516   //
 517   // X86-LABEL: test_mm256_i32gather_pd
 518   // X86:         [[CMP:%.*]] = fcmp oeq <4 x double>
 519   // X86-NEXT:    [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i64>
 520   // X86-NEXT:    [[BC:%.*]] = bitcast <4 x i64> [[SEXT]] to <4 x double>
 521   // X86: call <4 x double> @llvm.x86.avx2.gather.d.pd.256(<4 x double> %{{.*}}, ptr %{{.*}}, <4 x i32> %{{.*}}, <4 x double> %{{.*}}, i8 2)
 522   return _mm256_i32gather_pd(b, c, 2);
 523 }
 524
 525 __m256d test_mm256_mask_i32gather_pd(__m256d a, double const *b, __m128i c, __m256d d) {
 526   // CHECK-LABEL: test_mm256_mask_i32gather_pd
 527   // CHECK: call <4 x double> @llvm.x86.avx2.gather.d.pd.256(<4 x double> %{{.*}}, ptr %{{.*}}, <4 x i32> %{{.*}}, <4 x double> %{{.*}}, i8 2)
 528   return _mm256_mask_i32gather_pd(a, b, c, d, 2);
 529 }
 530
 531 __m128 test_mm_i32gather_ps(float const *b, __m128i c) {
 532   // X64-LABEL: test_mm_i32gather_ps
 533   // X64:         [[CMP:%.*]] = fcmp oeq <4 x float>
 534   // X64-NEXT:    [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i32>
 535   // X64-NEXT:    [[BC:%.*]] = bitcast <4 x i32> [[SEXT]] to <4 x float>
 536   // X64: call <4 x float> @llvm.x86.avx2.gather.d.ps(<4 x float> zeroinitializer, ptr %{{.*}}, <4 x i32> %{{.*}}, <4 x float> %{{.*}}, i8 2)
 537   //
 538   // X86-LABEL: test_mm_i32gather_ps
 539   // X86:         [[CMP:%.*]] = fcmp oeq <4 x float>
 540   // X86-NEXT:    [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i32>
 541   // X86-NEXT:    [[BC:%.*]] = bitcast <4 x i32> [[SEXT]] to <4 x float>
 542   // X86: call <4 x float> @llvm.x86.avx2.gather.d.ps(<4 x float> %{{.*}}, ptr %{{.*}}, <4 x i32> %{{.*}}, <4 x float> %{{.*}}, i8 2)
 543   return _mm_i32gather_ps(b, c, 2);
 544 }
 545
 546 __m128 test_mm_mask_i32gather_ps(__m128 a, float const *b, __m128i c, __m128 d) {
 547   // CHECK-LABEL: test_mm_mask_i32gather_ps
 548   // CHECK: call <4 x float> @llvm.x86.avx2.gather.d.ps(<4 x float> %{{.*}}, ptr %{{.*}}, <4 x i32> %{{.*}}, <4 x float> %{{.*}}, i8 2)
 549   return _mm_mask_i32gather_ps(a, b, c, d, 2);
 550 }
 551
 552 __m256 test_mm256_i32gather_ps(float const *b, __m256i c) {
 553   // X64-LABEL: test_mm256_i32gather_ps
 554   // X64:         [[CMP:%.*]] = fcmp oeq <8 x float>
 555   // X64-NEXT:    [[SEXT:%.*]] = sext <8 x i1> [[CMP]] to <8 x i32>
 556   // X64-NEXT:    [[BC:%.*]] = bitcast <8 x i32> [[SEXT]] to <8 x float>
 557   // X64: call <8 x float> @llvm.x86.avx2.gather.d.ps.256(<8 x float> zeroinitializer, ptr %{{.*}}, <8 x i32> %{{.*}}, <8 x float> %{{.*}}, i8 2)
 558   //
 559   // X86-LABEL: test_mm256_i32gather_ps
 560   // X86:         [[CMP:%.*]] = fcmp oeq <8 x float>
 561   // X86-NEXT:    [[SEXT:%.*]] = sext <8 x i1> [[CMP]] to <8 x i32>
 562   // X86-NEXT:    [[BC:%.*]] = bitcast <8 x i32> [[SEXT]] to <8 x float>
 563   // X86: call <8 x float> @llvm.x86.avx2.gather.d.ps.256(<8 x float> %{{.*}}, ptr %{{.*}}, <8 x i32> %{{.*}}, <8 x float> %{{.*}}, i8 2)
 564   return _mm256_i32gather_ps(b, c, 2);
 565 }
 566
 567 __m256 test_mm256_mask_i32gather_ps(__m256 a, float const *b, __m256i c, __m256 d) {
 568   // CHECK-LABEL: test_mm256_mask_i32gather_ps
 569   // CHECK: call <8 x float> @llvm.x86.avx2.gather.d.ps.256(<8 x float> %{{.*}}, ptr %{{.*}}, <8 x i32> %{{.*}}, <8 x float> %{{.*}}, i8 2)
 570   return _mm256_mask_i32gather_ps(a, b, c, d, 2);
 571 }
 572
 573 __m128i test_mm_i64gather_epi32(int const *b, __m128i c) {
 574   // CHECK-LABEL: test_mm_i64gather_epi32
 575   // CHECK: call <4 x i32> @llvm.x86.avx2.gather.q.d(<4 x i32> %{{.*}}, ptr %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> %{{.*}}, i8 2)
 576   return _mm_i64gather_epi32(b, c, 2);
 577 }
 578
 579 __m128i test_mm_mask_i64gather_epi32(__m128i a, int const *b, __m128i c, __m128i d) {
 580   // CHECK-LABEL: test_mm_mask_i64gather_epi32
 581   // CHECK: call <4 x i32> @llvm.x86.avx2.gather.q.d(<4 x i32> %{{.*}}, ptr %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> %{{.*}}, i8 2)
 582   return _mm_mask_i64gather_epi32(a, b, c, d, 2);
 583 }
 584
 585 __m128i test_mm256_i64gather_epi32(int const *b, __m256i c) {
 586   // CHECK-LABEL: test_mm256_i64gather_epi32
 587   // CHECK: call <4 x i32> @llvm.x86.avx2.gather.q.d.256(<4 x i32> %{{.*}}, ptr %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> %{{.*}}, i8 2)
 588   return _mm256_i64gather_epi32(b, c, 2);
 589 }
 590
 591 __m128i test_mm256_mask_i64gather_epi32(__m128i a, int const *b, __m256i c, __m128i d) {
 592   // CHECK-LABEL: test_mm256_mask_i64gather_epi32
 593   // CHECK: call <4 x i32> @llvm.x86.avx2.gather.q.d.256(<4 x i32> %{{.*}}, ptr %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> %{{.*}}, i8 2)
 594   return _mm256_mask_i64gather_epi32(a, b, c, d, 2);
 595 }
 596
 597 __m128i test_mm_i64gather_epi64(long long const *b, __m128i c) {
 598   // CHECK-LABEL: test_mm_i64gather_epi64
 599   // CHECK: call {{.*}}<2 x i64> @llvm.x86.avx2.gather.q.q(<2 x i64> zeroinitializer, ptr %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i8 2)
 600   return _mm_i64gather_epi64(b, c, 2);
 601 }
 602
 603 __m128i test_mm_mask_i64gather_epi64(__m128i a, long long const *b, __m128i c, __m128i d) {
 604   // CHECK-LABEL: test_mm_mask_i64gather_epi64
 605   // CHECK: call {{.*}}<2 x i64> @llvm.x86.avx2.gather.q.q(<2 x i64> %{{.*}}, ptr %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, i8 2)
 606   return _mm_mask_i64gather_epi64(a, b, c, d, 2);
 607 }
 608
 609 __m256i test_mm256_i64gather_epi64(long long const *b, __m256i c) {
 610   // X64-LABEL: test_mm256_i64gather_epi64
 611   // X64: call {{.*}}<4 x i64> @llvm.x86.avx2.gather.q.q.256(<4 x i64> zeroinitializer, ptr %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, i8 2)
 612   //
 613   // X86-LABEL: test_mm256_i64gather_epi64
 614   // X86: call {{.*}}<4 x i64> @llvm.x86.avx2.gather.q.q.256(<4 x i64> %{{.*}}, ptr %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, i8 2)
 615   return _mm256_i64gather_epi64(b, c, 2);
 616 }
 617
 618 __m256i test_mm256_mask_i64gather_epi64(__m256i a, long long const *b, __m256i c, __m256i d) {
 619   // CHECK-LABEL: test_mm256_mask_i64gather_epi64
 620   // CHECK: call {{.*}}<4 x i64> @llvm.x86.avx2.gather.q.q.256(<4 x i64> %{{.*}}, ptr %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, i8 2)
 621   return _mm256_mask_i64gather_epi64(a, b, c, d, 2);
 622 }
 623
 624 __m128d test_mm_i64gather_pd(double const *b, __m128i c) {
 625   // X64-LABEL: test_mm_i64gather_pd
 626   // X64:         [[CMP:%.*]] = fcmp oeq <2 x double>
 627   // X64-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
 628   // X64-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
 629   // X64: call <2 x double> @llvm.x86.avx2.gather.q.pd(<2 x double> zeroinitializer, ptr %{{.*}}, <2 x i64> %{{.*}}, <2 x double> %{{.*}}, i8 2)
 630   //
 631   // X86-LABEL: test_mm_i64gather_pd
 632   // X86:         [[CMP:%.*]] = fcmp oeq <2 x double>
 633   // X86-NEXT:    [[SEXT:%.*]] = sext <2 x i1> [[CMP]] to <2 x i64>
 634   // X86-NEXT:    [[BC:%.*]] = bitcast <2 x i64> [[SEXT]] to <2 x double>
 635   // X86: call <2 x double> @llvm.x86.avx2.gather.q.pd(<2 x double> %{{.*}}, ptr %{{.*}}, <2 x i64> %{{.*}}, <2 x double> %{{.*}}, i8 2)
 636   return _mm_i64gather_pd(b, c, 2);
 637 }
 638
 639 __m128d test_mm_mask_i64gather_pd(__m128d a, double const *b, __m128i c, __m128d d) {
 640   // CHECK-LABEL: test_mm_mask_i64gather_pd
 641   // CHECK: call <2 x double> @llvm.x86.avx2.gather.q.pd(<2 x double> %{{.*}}, ptr %{{.*}}, <2 x i64> %{{.*}}, <2 x double> %{{.*}}, i8 2)
 642   return _mm_mask_i64gather_pd(a, b, c, d, 2);
 643 }
 644
 645 __m256d test_mm256_i64gather_pd(double const *b, __m256i c) {
 646   // X64-LABEL: test_mm256_i64gather_pd
 647   // X64: fcmp oeq <4 x double> %{{.*}}, %{{.*}}
 648   // X64: call <4 x double> @llvm.x86.avx2.gather.q.pd.256(<4 x double> zeroinitializer, ptr %{{.*}}, <4 x i64> %{{.*}}, <4 x double> %{{.*}}, i8 2)
 649   //
 650   // X86-LABEL: test_mm256_i64gather_pd
 651   // X86: fcmp oeq <4 x double> %{{.*}}, %{{.*}}
 652   // X86: call <4 x double> @llvm.x86.avx2.gather.q.pd.256(<4 x double> %{{.*}}, ptr %{{.*}}, <4 x i64> %{{.*}}, <4 x double> %{{.*}}, i8 2)
 653   return _mm256_i64gather_pd(b, c, 2);
 654 }
 655
 656 __m256d test_mm256_mask_i64gather_pd(__m256d a, double const *b, __m256i c, __m256d d) {
 657   // CHECK-LABEL: test_mm256_mask_i64gather_pd
 658   // CHECK: call <4 x double> @llvm.x86.avx2.gather.q.pd.256(<4 x double> %{{.*}}, ptr %{{.*}}, <4 x i64> %{{.*}}, <4 x double> %{{.*}}, i8 2)
 659   return _mm256_mask_i64gather_pd(a, b, c, d, 2);
 660 }
 661
 662 __m128 test_mm_i64gather_ps(float const *b, __m128i c) {
 663   // X64-LABEL: test_mm_i64gather_ps
 664   // X64:         [[CMP:%.*]] = fcmp oeq <4 x float>
 665   // X64-NEXT:    [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i32>
 666   // X64-NEXT:    [[BC:%.*]] = bitcast <4 x i32> [[SEXT]] to <4 x float>
 667   // X64: call <4 x float> @llvm.x86.avx2.gather.q.ps(<4 x float> zeroinitializer, ptr %{{.*}}, <2 x i64> %{{.*}}, <4 x float> %{{.*}}, i8 2)
 668   //
 669   // X86-LABEL: test_mm_i64gather_ps
 670   // X86:         [[CMP:%.*]] = fcmp oeq <4 x float>
 671   // X86-NEXT:    [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i32>
 672   // X86-NEXT:    [[BC:%.*]] = bitcast <4 x i32> [[SEXT]] to <4 x float>
 673   // X86: call <4 x float> @llvm.x86.avx2.gather.q.ps(<4 x float> %{{.*}}, ptr %{{.*}}, <2 x i64> %{{.*}}, <4 x float> %{{.*}}, i8 2)
 674   return _mm_i64gather_ps(b, c, 2);
 675 }
 676
 677 __m128 test_mm_mask_i64gather_ps(__m128 a, float const *b, __m128i c, __m128 d) {
 678   // CHECK-LABEL: test_mm_mask_i64gather_ps
 679   // CHECK: call <4 x float> @llvm.x86.avx2.gather.q.ps(<4 x float> %{{.*}}, ptr %{{.*}}, <2 x i64> %{{.*}}, <4 x float> %{{.*}}, i8 2)
 680   return _mm_mask_i64gather_ps(a, b, c, d, 2);
 681 }
 682
 683 __m128 test_mm256_i64gather_ps(float const *b, __m256i c) {
 684   // X64-LABEL: test_mm256_i64gather_ps
 685   // X64:         [[CMP:%.*]] = fcmp oeq <4 x float>
 686   // X64-NEXT:    [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i32>
 687   // X64-NEXT:    [[BC:%.*]] = bitcast <4 x i32> [[SEXT]] to <4 x float>
 688   // X64: call <4 x float> @llvm.x86.avx2.gather.q.ps.256(<4 x float> zeroinitializer, ptr %{{.*}}, <4 x i64> %{{.*}}, <4 x float> %{{.*}}, i8 2)
 689   //
 690   // X86-LABEL: test_mm256_i64gather_ps
 691   // X86:         [[CMP:%.*]] = fcmp oeq <4 x float>
 692   // X86-NEXT:    [[SEXT:%.*]] = sext <4 x i1> [[CMP]] to <4 x i32>
 693   // X86-NEXT:    [[BC:%.*]] = bitcast <4 x i32> [[SEXT]] to <4 x float>
 694   // X86: call <4 x float> @llvm.x86.avx2.gather.q.ps.256(<4 x float> %{{.*}}, ptr %{{.*}}, <4 x i64> %{{.*}}, <4 x float> %{{.*}}, i8 2)
 695   return _mm256_i64gather_ps(b, c, 2);
 696 }
 697
 698 __m128 test_mm256_mask_i64gather_ps(__m128 a, float const *b, __m256i c, __m128 d) {
 699   // CHECK-LABEL: test_mm256_mask_i64gather_ps
 700   // CHECK: call <4 x float> @llvm.x86.avx2.gather.q.ps.256(<4 x float> %{{.*}}, ptr %{{.*}}, <4 x i64> %{{.*}}, <4 x float> %{{.*}}, i8 2)
 701   return _mm256_mask_i64gather_ps(a, b, c, d, 2);
 702 }
 703
 704 __m256i test0_mm256_inserti128_si256(__m256i a, __m128i b) {
 705   // CHECK-LABEL: test0_mm256_inserti128_si256
 706   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 707   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 4, i32 5, i32 2, i32 3>
 708   return _mm256_inserti128_si256(a, b, 0);
 709 }
 710
 711 __m256i test1_mm256_inserti128_si256(__m256i a, __m128i b) {
 712   // CHECK-LABEL: test1_mm256_inserti128_si256
 713   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 714   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
 715   return _mm256_inserti128_si256(a, b, 1);
 716 }
 717
 718 // Immediate should be truncated to one bit.
 719 __m256i test2_mm256_inserti128_si256(__m256i a, __m128i b) {
 720   // CHECK-LABEL: test2_mm256_inserti128_si256
 721   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 722   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 4, i32 5, i32 2, i32 3>
 723   return _mm256_inserti128_si256(a, b, 0);
 724 }
 725
 726 __m256i test_mm256_madd_epi16(__m256i a, __m256i b) {
 727   // CHECK-LABEL: test_mm256_madd_epi16
 728   // CHECK: call <8 x i32> @llvm.x86.avx2.pmadd.wd(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
 729   return _mm256_madd_epi16(a, b);
 730 }
 731
 732 __m256i test_mm256_maddubs_epi16(__m256i a, __m256i b) {
 733   // CHECK-LABEL: test_mm256_maddubs_epi16
 734   // CHECK: call <16 x i16> @llvm.x86.avx2.pmadd.ub.sw(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
 735   return _mm256_maddubs_epi16(a, b);
 736 }
 737
 738 __m128i test_mm_maskload_epi32(int const *a, __m128i m) {
 739   // CHECK-LABEL: test_mm_maskload_epi32
 740   // CHECK: call <4 x i32> @llvm.x86.avx2.maskload.d(ptr %{{.*}}, <4 x i32> %{{.*}})
 741   return _mm_maskload_epi32(a, m);
 742 }
 743
 744 __m256i test_mm256_maskload_epi32(int const *a, __m256i m) {
 745   // CHECK-LABEL: test_mm256_maskload_epi32
 746   // CHECK: call <8 x i32> @llvm.x86.avx2.maskload.d.256(ptr %{{.*}}, <8 x i32> %{{.*}})
 747   return _mm256_maskload_epi32(a, m);
 748 }
 749
 750 __m128i test_mm_maskload_epi64(long long const *a, __m128i m) {
 751   // CHECK-LABEL: test_mm_maskload_epi64
 752   // CHECK: call {{.*}}<2 x i64> @llvm.x86.avx2.maskload.q(ptr %{{.*}}, <2 x i64> %{{.*}})
 753   return _mm_maskload_epi64(a, m);
 754 }
 755
 756 __m256i test_mm256_maskload_epi64(long long const *a, __m256i m) {
 757   // CHECK-LABEL: test_mm256_maskload_epi64
 758   // CHECK: call {{.*}}<4 x i64> @llvm.x86.avx2.maskload.q.256(ptr %{{.*}}, <4 x i64> %{{.*}})
 759   return _mm256_maskload_epi64(a, m);
 760 }
 761
 762 void test_mm_maskstore_epi32(int *a, __m128i m, __m128i b) {
 763   // CHECK-LABEL: test_mm_maskstore_epi32
 764   // CHECK: call void @llvm.x86.avx2.maskstore.d(ptr %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}})
 765   _mm_maskstore_epi32(a, m, b);
 766 }
 767
 768 void test_mm256_maskstore_epi32(int *a, __m256i m, __m256i b) {
 769   // CHECK-LABEL: test_mm256_maskstore_epi32
 770   // CHECK: call void @llvm.x86.avx2.maskstore.d.256(ptr %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 771   _mm256_maskstore_epi32(a, m, b);
 772 }
 773
 774 void test_mm_maskstore_epi64(long long *a, __m128i m, __m128i b) {
 775   // CHECK-LABEL: test_mm_maskstore_epi64
 776   // CHECK: call void @llvm.x86.avx2.maskstore.q(ptr %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}})
 777   _mm_maskstore_epi64(a, m, b);
 778 }
 779
 780 void test_mm256_maskstore_epi64(long long *a, __m256i m, __m256i b) {
 781   // CHECK-LABEL: test_mm256_maskstore_epi64
 782   // CHECK: call void @llvm.x86.avx2.maskstore.q.256(ptr %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}})
 783   _mm256_maskstore_epi64(a, m, b);
 784 }
 785
 786 __m256i test_mm256_max_epi8(__m256i a, __m256i b) {
 787   // CHECK-LABEL: test_mm256_max_epi8
 788   // CHECK: call <32 x i8> @llvm.smax.v32i8(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
 789   return _mm256_max_epi8(a, b);
 790 }
 791
 792 __m256i test_mm256_max_epi16(__m256i a, __m256i b) {
 793   // CHECK-LABEL: test_mm256_max_epi16
 794   // CHECK: call <16 x i16> @llvm.smax.v16i16(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
 795   return _mm256_max_epi16(a, b);
 796 }
 797
 798 __m256i test_mm256_max_epi32(__m256i a, __m256i b) {
 799   // CHECK-LABEL: test_mm256_max_epi32
 800   // CHECK: call <8 x i32> @llvm.smax.v8i32(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 801   return _mm256_max_epi32(a, b);
 802 }
 803
 804 __m256i test_mm256_max_epu8(__m256i a, __m256i b) {
 805   // CHECK-LABEL: test_mm256_max_epu8
 806   // CHECK: call <32 x i8> @llvm.umax.v32i8(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
 807   return _mm256_max_epu8(a, b);
 808 }
 809
 810 __m256i test_mm256_max_epu16(__m256i a, __m256i b) {
 811   // CHECK-LABEL: test_mm256_max_epu16
 812   // CHECK: call <16 x i16> @llvm.umax.v16i16(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
 813   return _mm256_max_epu16(a, b);
 814 }
 815
 816 __m256i test_mm256_max_epu32(__m256i a, __m256i b) {
 817   // CHECK-LABEL: test_mm256_max_epu32
 818   // CHECK: call <8 x i32> @llvm.umax.v8i32(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 819   return _mm256_max_epu32(a, b);
 820 }
 821
 822 __m256i test_mm256_min_epi8(__m256i a, __m256i b) {
 823   // CHECK-LABEL: test_mm256_min_epi8
 824   // CHECK: call <32 x i8> @llvm.smin.v32i8(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
 825   return _mm256_min_epi8(a, b);
 826 }
 827
 828 __m256i test_mm256_min_epi16(__m256i a, __m256i b) {
 829   // CHECK-LABEL: test_mm256_min_epi16
 830   // CHECK: call <16 x i16> @llvm.smin.v16i16(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
 831   return _mm256_min_epi16(a, b);
 832 }
 833
 834 __m256i test_mm256_min_epi32(__m256i a, __m256i b) {
 835   // CHECK-LABEL: test_mm256_min_epi32
 836   // CHECK: call <8 x i32> @llvm.smin.v8i32(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 837   return _mm256_min_epi32(a, b);
 838 }
 839
 840 __m256i test_mm256_min_epu8(__m256i a, __m256i b) {
 841   // CHECK-LABEL: test_mm256_min_epu8
 842   // CHECK: call <32 x i8> @llvm.umin.v32i8(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
 843   return _mm256_min_epu8(a, b);
 844 }
 845
 846 __m256i test_mm256_min_epu16(__m256i a, __m256i b) {
 847   // CHECK-LABEL: test_mm256_min_epu16
 848   // CHECK: call <16 x i16> @llvm.umin.v16i16(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
 849   return _mm256_min_epu16(a, b);
 850 }
 851
 852 __m256i test_mm256_min_epu32(__m256i a, __m256i b) {
 853   // CHECK-LABEL: test_mm256_min_epu32
 854   // CHECK: call <8 x i32> @llvm.umin.v8i32(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 855   return _mm256_min_epu32(a, b);
 856 }
 857
 858 int test_mm256_movemask_epi8(__m256i a) {
 859   // CHECK-LABEL: test_mm256_movemask_epi8
 860   // CHECK: call {{.*}}i32 @llvm.x86.avx2.pmovmskb(<32 x i8> %{{.*}})
 861   return _mm256_movemask_epi8(a);
 862 }
 863
 864 __m256i test_mm256_mpsadbw_epu8(__m256i x, __m256i y) {
 865   // CHECK-LABEL: test_mm256_mpsadbw_epu8
 866   // CHECK: call <16 x i16> @llvm.x86.avx2.mpsadbw(<32 x i8> %{{.*}}, <32 x i8> %{{.*}}, i8 3)
 867   return _mm256_mpsadbw_epu8(x, y, 3);
 868 }
 869
 870 __m256i test_mm256_mul_epi32(__m256i a, __m256i b) {
 871   // CHECK-LABEL: test_mm256_mul_epi32
 872   // CHECK: shl <4 x i64> %{{.*}}, splat (i64 32)
 873   // CHECK: ashr <4 x i64> %{{.*}}, splat (i64 32)
 874   // CHECK: shl <4 x i64> %{{.*}}, splat (i64 32)
 875   // CHECK: ashr <4 x i64> %{{.*}}, splat (i64 32)
 876   // CHECK: mul <4 x i64> %{{.*}}, %{{.*}}
 877   return _mm256_mul_epi32(a, b);
 878 }
 879
 880 __m256i test_mm256_mul_epu32(__m256i a, __m256i b) {
 881   // CHECK-LABEL: test_mm256_mul_epu32
 882   // CHECK: and <4 x i64> %{{.*}}, splat (i64 4294967295)
 883   // CHECK: and <4 x i64> %{{.*}}, splat (i64 4294967295)
 884   // CHECK: mul <4 x i64> %{{.*}}, %{{.*}}
 885   return _mm256_mul_epu32(a, b);
 886 }
 887
 888 __m256i test_mm256_mulhi_epu16(__m256i a, __m256i b) {
 889   // CHECK-LABEL: test_mm256_mulhi_epu16
 890   // CHECK: call <16 x i16> @llvm.x86.avx2.pmulhu.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
 891   return _mm256_mulhi_epu16(a, b);
 892 }
 893
 894 __m256i test_mm256_mulhi_epi16(__m256i a, __m256i b) {
 895   // CHECK-LABEL: test_mm256_mulhi_epi16
 896   // CHECK: call <16 x i16> @llvm.x86.avx2.pmulh.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
 897   return _mm256_mulhi_epi16(a, b);
 898 }
 899
 900 __m256i test_mm256_mulhrs_epi16(__m256i a, __m256i b) {
 901   // CHECK-LABEL: test_mm256_mulhrs_epi16
 902   // CHECK: call <16 x i16> @llvm.x86.avx2.pmul.hr.sw(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
 903   return _mm256_mulhrs_epi16(a, b);
 904 }
 905
 906 __m256i test_mm256_mullo_epi16(__m256i a, __m256i b) {
 907   // CHECK-LABEL: test_mm256_mullo_epi16
 908   // CHECK: mul <16 x i16>
 909   return _mm256_mullo_epi16(a, b);
 910 }
 911
 912 __m256i test_mm256_mullo_epi32(__m256i a, __m256i b) {
 913   // CHECK-LABEL: test_mm256_mullo_epi32
 914   // CHECK: mul <8 x i32>
 915   return _mm256_mullo_epi32(a, b);
 916 }
 917
 918 __m256i test_mm256_or_si256(__m256i a, __m256i b) {
 919   // CHECK-LABEL: test_mm256_or_si256
 920   // CHECK: or <4 x i64>
 921   return _mm256_or_si256(a, b);
 922 }
 923
 924 __m256i test_mm256_packs_epi16(__m256i a, __m256i b) {
 925   // CHECK-LABEL: test_mm256_packs_epi16
 926   // CHECK: call <32 x i8> @llvm.x86.avx2.packsswb(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
 927   return _mm256_packs_epi16(a, b);
 928 }
 929
 930 __m256i test_mm256_packs_epi32(__m256i a, __m256i b) {
 931   // CHECK-LABEL: test_mm256_packs_epi32
 932   // CHECK: call <16 x i16> @llvm.x86.avx2.packssdw(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 933   return _mm256_packs_epi32(a, b);
 934 }
 935
 936 __m256i test_mm256_packs_epu16(__m256i a, __m256i b) {
 937   // CHECK-LABEL: test_mm256_packs_epu16
 938   // CHECK:  call <32 x i8> @llvm.x86.avx2.packuswb(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
 939   return _mm256_packus_epi16(a, b);
 940 }
 941
 942 __m256i test_mm256_packs_epu32(__m256i a, __m256i b) {
 943   // CHECK-LABEL: test_mm256_packs_epu32
 944   // CHECK: call <16 x i16> @llvm.x86.avx2.packusdw(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 945   return _mm256_packus_epi32(a, b);
 946 }
 947
 948 __m256i test_mm256_permute2x128_si256(__m256i a, __m256i b) {
 949   // CHECK-LABEL: test_mm256_permute2x128_si256
 950   // CHECK: shufflevector <4 x i64> zeroinitializer, <4 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 6, i32 7>
 951   return _mm256_permute2x128_si256(a, b, 0x38);
 952 }
 953
 954 __m256i test_mm256_permute4x64_epi64(__m256i a) {
 955   // CHECK-LABEL: test_mm256_permute4x64_epi64
 956   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> poison, <4 x i32> <i32 3, i32 0, i32 2, i32 0>
 957   return _mm256_permute4x64_epi64(a, 35);
 958 }
 959
 960 __m256d test_mm256_permute4x64_pd(__m256d a) {
 961   // CHECK-LABEL: test_mm256_permute4x64_pd
 962   // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> poison, <4 x i32> <i32 1, i32 2, i32 1, i32 0>
 963   return _mm256_permute4x64_pd(a, 25);
 964 }
 965
 966 __m256i test_mm256_permutevar8x32_epi32(__m256i a, __m256i b) {
 967   // CHECK-LABEL: test_mm256_permutevar8x32_epi32
 968   // CHECK: call <8 x i32> @llvm.x86.avx2.permd(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
 969   return _mm256_permutevar8x32_epi32(a, b);
 970 }
 971
 972 __m256 test_mm256_permutevar8x32_ps(__m256 a, __m256i b) {
 973   // CHECK-LABEL: test_mm256_permutevar8x32_ps
 974   // CHECK: call {{.*}}<8 x float> @llvm.x86.avx2.permps(<8 x float> %{{.*}}, <8 x i32> %{{.*}})
 975   return _mm256_permutevar8x32_ps(a, b);
 976 }
 977
 978 __m256i test_mm256_sad_epu8(__m256i x, __m256i y) {
 979   // CHECK-LABEL: test_mm256_sad_epu8
 980   // CHECK: call {{.*}}<4 x i64> @llvm.x86.avx2.psad.bw(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
 981   return _mm256_sad_epu8(x, y);
 982 }
 983
 984 __m256i test_mm256_shuffle_epi8(__m256i a, __m256i b) {
 985   // CHECK-LABEL: test_mm256_shuffle_epi8
 986   // CHECK: call <32 x i8> @llvm.x86.avx2.pshuf.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
 987   return _mm256_shuffle_epi8(a, b);
 988 }
 989
 990 __m256i test_mm256_shuffle_epi32(__m256i a) {
 991   // CHECK-LABEL: test_mm256_shuffle_epi32
 992   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> poison, <8 x i32> <i32 3, i32 3, i32 0, i32 0, i32 7, i32 7, i32 4, i32 4>
 993   return _mm256_shuffle_epi32(a, 15);
 994 }
 995
 996 __m256i test_mm256_shufflehi_epi16(__m256i a) {
 997   // CHECK-LABEL: test_mm256_shufflehi_epi16
 998   // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 7, i32 6, i32 6, i32 5, i32 8, i32 9, i32 10, i32 11, i32 15, i32 14, i32 14, i32 13>
 999   return _mm256_shufflehi_epi16(a, 107);
1000 }
1001
1002 __m256i test_mm256_shufflelo_epi16(__m256i a) {
1003   // CHECK-LABEL: test_mm256_shufflelo_epi16
1004   // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> poison, <16 x i32> <i32 3, i32 0, i32 1, i32 1, i32 4, i32 5, i32 6, i32 7, i32 11, i32 8, i32 9, i32 9, i32 12, i32 13, i32 14, i32 15>
1005   return _mm256_shufflelo_epi16(a, 83);
1006 }
1007
1008 __m256i test_mm256_sign_epi8(__m256i a, __m256i b) {
1009   // CHECK-LABEL: test_mm256_sign_epi8
1010   // CHECK: call <32 x i8> @llvm.x86.avx2.psign.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
1011   return _mm256_sign_epi8(a, b);
1012 }
1013
1014 __m256i test_mm256_sign_epi16(__m256i a, __m256i b) {
1015   // CHECK-LABEL: test_mm256_sign_epi16
1016   // CHECK: call <16 x i16> @llvm.x86.avx2.psign.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
1017   return _mm256_sign_epi16(a, b);
1018 }
1019
1020 __m256i test_mm256_sign_epi32(__m256i a, __m256i b) {
1021   // CHECK-LABEL: test_mm256_sign_epi32
1022   // CHECK: call <8 x i32> @llvm.x86.avx2.psign.d(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
1023   return _mm256_sign_epi32(a, b);
1024 }
1025
1026 __m256i test_mm256_slli_epi16(__m256i a) {
1027   // CHECK-LABEL: test_mm256_slli_epi16
1028   // CHECK: call <16 x i16> @llvm.x86.avx2.pslli.w(<16 x i16> %{{.*}}, i32 %{{.*}})
1029   return _mm256_slli_epi16(a, 3);
1030 }
1031
1032 __m256i test_mm256_slli_epi16_2(__m256i a, int b) {
1033   // CHECK-LABEL: test_mm256_slli_epi16_2
1034   // CHECK: call <16 x i16> @llvm.x86.avx2.pslli.w(<16 x i16> %{{.*}}, i32 %{{.*}})
1035   return _mm256_slli_epi16(a, b);
1036 }
1037
1038 __m256i test_mm256_slli_epi32(__m256i a) {
1039   // CHECK-LABEL: test_mm256_slli_epi32
1040   // CHECK: call <8 x i32> @llvm.x86.avx2.pslli.d(<8 x i32> %{{.*}}, i32 %{{.*}})
1041   return _mm256_slli_epi32(a, 3);
1042 }
1043
1044 __m256i test_mm256_slli_epi32_2(__m256i a, int b) {
1045   // CHECK-LABEL: test_mm256_slli_epi32_2
1046   // CHECK: call <8 x i32> @llvm.x86.avx2.pslli.d(<8 x i32> %{{.*}}, i32 %{{.*}})
1047   return _mm256_slli_epi32(a, b);
1048 }
1049
1050 __m256i test_mm256_slli_epi64(__m256i a) {
1051   // CHECK-LABEL: test_mm256_slli_epi64
1052   // CHECK: call {{.*}}<4 x i64> @llvm.x86.avx2.pslli.q(<4 x i64> %{{.*}}, i32 %{{.*}})
1053   return _mm256_slli_epi64(a, 3);
1054 }
1055
1056 __m256i test_mm256_slli_epi64_2(__m256i a, int b) {
1057   // CHECK-LABEL: test_mm256_slli_epi64_2
1058   // CHECK: call {{.*}}<4 x i64> @llvm.x86.avx2.pslli.q(<4 x i64> %{{.*}}, i32 %{{.*}})
1059   return _mm256_slli_epi64(a, b);
1060 }
1061
1062 __m256i test_mm256_slli_si256(__m256i a) {
1063   // CHECK-LABEL: test_mm256_slli_si256
1064   // CHECK: shufflevector <32 x i8> zeroinitializer, <32 x i8> %{{.*}}, <32 x i32> <i32 13, i32 14, i32 15, 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 29, i32 30, i32 31, 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>
1065   return _mm256_slli_si256(a, 3);
1066 }
1067
1068 __m128i test_mm_sllv_epi32(__m128i a, __m128i b) {
1069   // CHECK-LABEL: test_mm_sllv_epi32
1070   // CHECK: call <4 x i32> @llvm.x86.avx2.psllv.d(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1071   return _mm_sllv_epi32(a, b);
1072 }
1073
1074 __m256i test_mm256_sllv_epi32(__m256i a, __m256i b) {
1075   // CHECK-LABEL: test_mm256_sllv_epi32
1076   // CHECK: call <8 x i32> @llvm.x86.avx2.psllv.d.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
1077   return _mm256_sllv_epi32(a, b);
1078 }
1079
1080 __m128i test_mm_sllv_epi64(__m128i a, __m128i b) {
1081   // CHECK-LABEL: test_mm_sllv_epi64
1082   // CHECK: call {{.*}}<2 x i64> @llvm.x86.avx2.psllv.q(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1083   return _mm_sllv_epi64(a, b);
1084 }
1085
1086 __m256i test_mm256_sllv_epi64(__m256i a, __m256i b) {
1087   // CHECK-LABEL: test_mm256_sllv_epi64
1088   // CHECK: call {{.*}}<4 x i64> @llvm.x86.avx2.psllv.q.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}})
1089   return _mm256_sllv_epi64(a, b);
1090 }
1091
1092 __m256i test_mm256_sra_epi16(__m256i a, __m128i b) {
1093   // CHECK-LABEL: test_mm256_sra_epi16
1094   // CHECK: call <16 x i16> @llvm.x86.avx2.psra.w(<16 x i16> %{{.*}}, <8 x i16> %{{.*}})
1095   return _mm256_sra_epi16(a, b);
1096 }
1097
1098 __m256i test_mm256_sra_epi32(__m256i a, __m128i b) {
1099   // CHECK-LABEL: test_mm256_sra_epi32
1100   // CHECK: call <8 x i32> @llvm.x86.avx2.psra.d(<8 x i32> %{{.*}}, <4 x i32> %{{.*}})
1101   return _mm256_sra_epi32(a, b);
1102 }
1103
1104 __m256i test_mm256_srai_epi16(__m256i a) {
1105   // CHECK-LABEL: test_mm256_srai_epi16
1106   // CHECK: call <16 x i16> @llvm.x86.avx2.psrai.w(<16 x i16> %{{.*}}, i32 %{{.*}})
1107   return _mm256_srai_epi16(a, 3);
1108 }
1109
1110 __m256i test_mm256_srai_epi16_2(__m256i a, int b) {
1111   // CHECK-LABEL: test_mm256_srai_epi16_2
1112   // CHECK: call <16 x i16> @llvm.x86.avx2.psrai.w(<16 x i16> %{{.*}}, i32 %{{.*}})
1113   return _mm256_srai_epi16(a, b);
1114 }
1115
1116 __m256i test_mm256_srai_epi32(__m256i a) {
1117   // CHECK-LABEL: test_mm256_srai_epi32
1118   // CHECK: call <8 x i32> @llvm.x86.avx2.psrai.d(<8 x i32> %{{.*}}, i32 %{{.*}})
1119   return _mm256_srai_epi32(a, 3);
1120 }
1121
1122 __m256i test_mm256_srai_epi32_2(__m256i a, int b) {
1123   // CHECK-LABEL: test_mm256_srai_epi32_2
1124   // CHECK: call <8 x i32> @llvm.x86.avx2.psrai.d(<8 x i32> %{{.*}}, i32 %{{.*}})
1125   return _mm256_srai_epi32(a, b);
1126 }
1127
1128 __m128i test_mm_srav_epi32(__m128i a, __m128i b) {
1129   // CHECK-LABEL: test_mm_srav_epi32
1130   // CHECK: call <4 x i32> @llvm.x86.avx2.psrav.d(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1131   return _mm_srav_epi32(a, b);
1132 }
1133
1134 __m256i test_mm256_srav_epi32(__m256i a, __m256i b) {
1135   // CHECK-LABEL: test_mm256_srav_epi32
1136   // CHECK: call <8 x i32> @llvm.x86.avx2.psrav.d.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
1137   return _mm256_srav_epi32(a, b);
1138 }
1139
1140 __m256i test_mm256_srl_epi16(__m256i a, __m128i b) {
1141   // CHECK-LABEL: test_mm256_srl_epi16
1142   // CHECK: call <16 x i16> @llvm.x86.avx2.psrl.w(<16 x i16> %{{.*}}, <8 x i16> %{{.*}})
1143   return _mm256_srl_epi16(a, b);
1144 }
1145
1146 __m256i test_mm256_srl_epi32(__m256i a, __m128i b) {
1147   // CHECK-LABEL: test_mm256_srl_epi32
1148   // CHECK:call <8 x i32> @llvm.x86.avx2.psrl.d(<8 x i32> %{{.*}}, <4 x i32> %{{.*}})
1149   return _mm256_srl_epi32(a, b);
1150 }
1151
1152 __m256i test_mm256_srl_epi64(__m256i a, __m128i b) {
1153   // CHECK-LABEL: test_mm256_srl_epi64
1154   // CHECK: call {{.*}}<4 x i64> @llvm.x86.avx2.psrl.q(<4 x i64> %{{.*}}, <2 x i64> %{{.*}})
1155   return _mm256_srl_epi64(a, b);
1156 }
1157
1158 __m256i test_mm256_srli_epi16(__m256i a) {
1159   // CHECK-LABEL: test_mm256_srli_epi16
1160   // CHECK: call <16 x i16> @llvm.x86.avx2.psrli.w(<16 x i16> %{{.*}}, i32 %{{.*}})
1161   return _mm256_srli_epi16(a, 3);
1162 }
1163
1164 __m256i test_mm256_srli_epi16_2(__m256i a, int b) {
1165   // CHECK-LABEL: test_mm256_srli_epi16_2
1166   // CHECK: call <16 x i16> @llvm.x86.avx2.psrli.w(<16 x i16> %{{.*}}, i32 %{{.*}})
1167   return _mm256_srli_epi16(a, b);
1168 }
1169
1170 __m256i test_mm256_srli_epi32(__m256i a) {
1171   // CHECK-LABEL: test_mm256_srli_epi32
1172   // CHECK: call <8 x i32> @llvm.x86.avx2.psrli.d(<8 x i32> %{{.*}}, i32 %{{.*}})
1173   return _mm256_srli_epi32(a, 3);
1174 }
1175
1176 __m256i test_mm256_srli_epi32_2(__m256i a, int b) {
1177   // CHECK-LABEL: test_mm256_srli_epi32_2
1178   // CHECK: call <8 x i32> @llvm.x86.avx2.psrli.d(<8 x i32> %{{.*}}, i32 %{{.*}})
1179   return _mm256_srli_epi32(a, b);
1180 }
1181
1182 __m256i test_mm256_srli_epi64(__m256i a) {
1183   // CHECK-LABEL: test_mm256_srli_epi64
1184   // CHECK: call {{.*}}<4 x i64> @llvm.x86.avx2.psrli.q(<4 x i64> %{{.*}}, i32 %{{.*}})
1185   return _mm256_srli_epi64(a, 3);
1186 }
1187
1188 __m256i test_mm256_srli_epi64_2(__m256i a, int b) {
1189   // CHECK-LABEL: test_mm256_srli_epi64_2
1190   // CHECK: call {{.*}}<4 x i64> @llvm.x86.avx2.psrli.q(<4 x i64> %{{.*}}, i32 %{{.*}})
1191   return _mm256_srli_epi64(a, b);
1192 }
1193
1194 __m256i test_mm256_srli_si256(__m256i a) {
1195   // CHECK-LABEL: test_mm256_srli_si256
1196   // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> zeroinitializer, <32 x i32> <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 32, i32 33, i32 34, 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 48, i32 49, i32 50>
1197   return _mm256_srli_si256(a, 3);
1198 }
1199
1200 __m128i test_mm_srlv_epi32(__m128i a, __m128i b) {
1201   // CHECK-LABEL: test_mm_srlv_epi32
1202   // CHECK: call <4 x i32> @llvm.x86.avx2.psrlv.d(<4 x i32> %{{.*}}, <4 x i32> %{{.*}})
1203   return _mm_srlv_epi32(a, b);
1204 }
1205
1206 __m256i test_mm256_srlv_epi32(__m256i a, __m256i b) {
1207   // CHECK-LABEL: test_mm256_srlv_epi32
1208   // CHECK: call <8 x i32> @llvm.x86.avx2.psrlv.d.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}})
1209   return _mm256_srlv_epi32(a, b);
1210 }
1211
1212 __m128i test_mm_srlv_epi64(__m128i a, __m128i b) {
1213   // CHECK-LABEL: test_mm_srlv_epi64
1214   // CHECK: call {{.*}}<2 x i64> @llvm.x86.avx2.psrlv.q(<2 x i64> %{{.*}}, <2 x i64> %{{.*}})
1215   return _mm_srlv_epi64(a, b);
1216 }
1217
1218 __m256i test_mm256_srlv_epi64(__m256i a, __m256i b) {
1219   // CHECK-LABEL: test_mm256_srlv_epi64
1220   // CHECK: call {{.*}}<4 x i64> @llvm.x86.avx2.psrlv.q.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}})
1221   return _mm256_srlv_epi64(a, b);
1222 }
1223
1224 __m256i test_mm256_stream_load_si256(__m256i const *a) {
1225   // CHECK-LABEL: test_mm256_stream_load_si256
1226   // CHECK: load <4 x i64>, ptr %{{.*}}, align 32, !nontemporal
1227   return _mm256_stream_load_si256(a);
1228 }
1229
1230 __m256i test_mm256_stream_load_si256_void(const void *a) {
1231   // CHECK-LABEL: test_mm256_stream_load_si256_void
1232   // CHECK: load <4 x i64>, ptr %{{.*}}, align 32, !nontemporal
1233   return _mm256_stream_load_si256(a);
1234 }
1235
1236 __m256i test_mm256_sub_epi8(__m256i a, __m256i b) {
1237   // CHECK-LABEL: test_mm256_sub_epi8
1238   // CHECK: sub <32 x i8>
1239   return _mm256_sub_epi8(a, b);
1240 }
1241
1242 __m256i test_mm256_sub_epi16(__m256i a, __m256i b) {
1243   // CHECK-LABEL: test_mm256_sub_epi16
1244   // CHECK: sub <16 x i16>
1245   return _mm256_sub_epi16(a, b);
1246 }
1247
1248 __m256i test_mm256_sub_epi32(__m256i a, __m256i b) {
1249   // CHECK-LABEL: test_mm256_sub_epi32
1250   // CHECK: sub <8 x i32>
1251   return _mm256_sub_epi32(a, b);
1252 }
1253
1254 __m256i test_mm256_sub_epi64(__m256i a, __m256i b) {
1255   // CHECK-LABEL: test_mm256_sub_epi64
1256   // CHECK: sub <4 x i64>
1257   return _mm256_sub_epi64(a, b);
1258 }
1259
1260 __m256i test_mm256_subs_epi8(__m256i a, __m256i b) {
1261   // CHECK-LABEL: test_mm256_subs_epi8
1262   // CHECK: call <32 x i8> @llvm.ssub.sat.v32i8(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
1263   return _mm256_subs_epi8(a, b);
1264 }
1265
1266 __m256i test_mm256_subs_epi16(__m256i a, __m256i b) {
1267   // CHECK-LABEL: test_mm256_subs_epi16
1268   // CHECK: call <16 x i16> @llvm.ssub.sat.v16i16(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
1269   return _mm256_subs_epi16(a, b);
1270 }
1271
1272 __m256i test_mm256_subs_epu8(__m256i a, __m256i b) {
1273   // CHECK-LABEL: test_mm256_subs_epu8
1274   // CHECK-NOT: call <32 x i8> @llvm.x86.avx2.psubus.b(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
1275   // CHECK: call <32 x i8> @llvm.usub.sat.v32i8(<32 x i8> %{{.*}}, <32 x i8> %{{.*}})
1276   return _mm256_subs_epu8(a, b);
1277 }
1278
1279 __m256i test_mm256_subs_epu16(__m256i a, __m256i b) {
1280   // CHECK-LABEL: test_mm256_subs_epu16
1281   // CHECK-NOT: call <16 x i16> @llvm.x86.avx2.psubus.w(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
1282   // CHECK: call <16 x i16> @llvm.usub.sat.v16i16(<16 x i16> %{{.*}}, <16 x i16> %{{.*}})
1283   return _mm256_subs_epu16(a, b);
1284 }
1285
1286 __m256i test_mm256_unpackhi_epi8(__m256i a, __m256i b) {
1287   // CHECK-LABEL: test_mm256_unpackhi_epi8
1288   // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> %{{.*}}, <32 x i32> <i32 8, i32 40, i32 9, i32 41, i32 10, i32 42, i32 11, i32 43, i32 12, i32 44, i32 13, i32 45, i32 14, i32 46, i32 15, i32 47, i32 24, i32 56, i32 25, i32 57, i32 26, i32 58, i32 27, i32 59, i32 28, i32 60, i32 29, i32 61, i32 30, i32 62, i32 31, i32 63>
1289   return _mm256_unpackhi_epi8(a, b);
1290 }
1291
1292 __m256i test_mm256_unpackhi_epi16(__m256i a, __m256i b) {
1293   // CHECK-LABEL: test_mm256_unpackhi_epi16
1294   // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> %{{.*}}, <16 x i32> <i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
1295   return _mm256_unpackhi_epi16(a, b);
1296 }
1297
1298 __m256i test_mm256_unpackhi_epi32(__m256i a, __m256i b) {
1299   // CHECK-LABEL: test_mm256_unpackhi_epi32
1300   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 2, i32 10, i32 3, i32 11, i32 6, i32 14, i32 7, i32 15>
1301   return _mm256_unpackhi_epi32(a, b);
1302 }
1303
1304 __m256i test_mm256_unpackhi_epi64(__m256i a, __m256i b) {
1305   // CHECK-LABEL: test_mm256_unpackhi_epi64
1306   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
1307   return _mm256_unpackhi_epi64(a, b);
1308 }
1309
1310 __m256i test_mm256_unpacklo_epi8(__m256i a, __m256i b) {
1311   // CHECK-LABEL: test_mm256_unpacklo_epi8
1312   // CHECK: shufflevector <32 x i8> %{{.*}}, <32 x i8> %{{.*}}, <32 x i32> <i32 0, i32 32, i32 1, i32 33, i32 2, i32 34, i32 3, i32 35, i32 4, i32 36, i32 5, i32 37, i32 6, i32 38, i32 7, i32 39, i32 16, i32 48, i32 17, i32 49, i32 18, i32 50, i32 19, i32 51, i32 20, i32 52, i32 21, i32 53, i32 22, i32 54, i32 23, i32 55>
1313   return _mm256_unpacklo_epi8(a, b);
1314 }
1315
1316 __m256i test_mm256_unpacklo_epi16(__m256i a, __m256i b) {
1317   // CHECK-LABEL: test_mm256_unpacklo_epi16
1318   // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27>
1319   return _mm256_unpacklo_epi16(a, b);
1320 }
1321
1322 __m256i test_mm256_unpacklo_epi32(__m256i a, __m256i b) {
1323   // CHECK-LABEL: test_mm256_unpacklo_epi32
1324   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 4, i32 12, i32 5, i32 13>
1325   return _mm256_unpacklo_epi32(a, b);
1326 }
1327
1328 __m256i test_mm256_unpacklo_epi64(__m256i a, __m256i b) {
1329   // CHECK-LABEL: test_mm256_unpacklo_epi64
1330   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
1331   return _mm256_unpacklo_epi64(a, b);
1332 }
1333
1334 __m256i test_mm256_xor_si256(__m256i a, __m256i b) {
1335   // CHECK-LABEL: test_mm256_xor_si256
1336   // CHECK: xor <4 x i64>
1337   return _mm256_xor_si256(a, b);
1338 }