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

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