test/CodeGen/avx2-builtins.c

   1 // RUN: %clang_cc1 %s -O0 -triple=x86_64-apple-darwin -target-feature +avx2 -emit-llvm -o - -Werror | FileCheck %s
   2
   3 // Don't include mm_malloc.h, it's system specific.
   4 #define __MM_MALLOC_H
   5
   6 #include <immintrin.h>
   7
   8 __m256i test_mm256_mpsadbw_epu8(__m256i x, __m256i y) {
   9   // CHECK: @llvm.x86.avx2.mpsadbw({{.*}}, {{.*}}, i8 3)
  10   return _mm256_mpsadbw_epu8(x, y, 3);
  11 }
  12
  13 __m256i test_mm256_sad_epu8(__m256i x, __m256i y) {
  14   // CHECK: @llvm.x86.avx2.psad.bw
  15   return _mm256_sad_epu8(x, y);
  16 }
  17
  18 __m256i test_mm256_abs_epi8(__m256i a) {
  19   // CHECK: @llvm.x86.avx2.pabs.b
  20   return _mm256_abs_epi8(a);
  21 }
  22
  23 __m256i test_mm256_abs_epi16(__m256i a) {
  24   // CHECK: @llvm.x86.avx2.pabs.w
  25   return _mm256_abs_epi16(a);
  26 }
  27
  28 __m256i test_mm256_abs_epi32(__m256i a) {
  29   // CHECK: @llvm.x86.avx2.pabs.d
  30   return _mm256_abs_epi32(a);
  31 }
  32
  33 __m256i test_mm256_packs_epi16(__m256i a, __m256i b) {
  34   // CHECK: @llvm.x86.avx2.packsswb
  35   return _mm256_packs_epi16(a, b);
  36 }
  37
  38 __m256i test_mm256_packs_epi32(__m256i a, __m256i b) {
  39   // CHECK: @llvm.x86.avx2.packssdw
  40   return _mm256_packs_epi32(a, b);
  41 }
  42
  43 __m256i test_mm256_packs_epu16(__m256i a, __m256i b) {
  44   // CHECK: @llvm.x86.avx2.packuswb
  45   return _mm256_packus_epi16(a, b);
  46 }
  47
  48 __m256i test_mm256_packs_epu32(__m256i a, __m256i b) {
  49   // CHECK: @llvm.x86.avx2.packusdw
  50   return _mm256_packus_epi32(a, b);
  51 }
  52
  53 __m256i test_mm256_add_epi8(__m256i a, __m256i b) {
  54   // CHECK: add <32 x i8>
  55   return _mm256_add_epi8(a, b);
  56 }
  57
  58 __m256i test_mm256_add_epi16(__m256i a, __m256i b) {
  59   // CHECK: add <16 x i16>
  60   return _mm256_add_epi16(a, b);
  61 }
  62
  63 __m256i test_mm256_add_epi32(__m256i a, __m256i b) {
  64   // CHECK: add <8 x i32>
  65   return _mm256_add_epi32(a, b);
  66 }
  67
  68 __m256i test_mm256_add_epi64(__m256i a, __m256i b) {
  69   // CHECK: add <4 x i64>
  70   return _mm256_add_epi64(a, b);
  71 }
  72
  73 __m256i test_mm256_adds_epi8(__m256i a, __m256i b) {
  74   // CHECK: @llvm.x86.avx2.padds.b
  75   return _mm256_adds_epi8(a, b);
  76 }
  77
  78 __m256i test_mm256_adds_epi16(__m256i a, __m256i b) {
  79   // CHECK: @llvm.x86.avx2.padds.w
  80   return _mm256_adds_epi16(a, b);
  81 }
  82
  83 __m256i test_mm256_adds_epu8(__m256i a, __m256i b) {
  84   // CHECK: @llvm.x86.avx2.paddus.b
  85   return _mm256_adds_epu8(a, b);
  86 }
  87
  88 __m256i test_mm256_adds_epu16(__m256i a, __m256i b) {
  89   // CHECK: @llvm.x86.avx2.paddus.w
  90   return _mm256_adds_epu16(a, b);
  91 }
  92
  93 __m256i test_mm256_alignr_epi8(__m256i a, __m256i b) {
  94   // 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>
  95   return _mm256_alignr_epi8(a, b, 2);
  96 }
  97
  98 __m256i test2_mm256_alignr_epi8(__m256i a, __m256i b) {
  99   // 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>
 100   return _mm256_alignr_epi8(a, b, 17);
 101 }
 102
 103 __m256i test_mm256_sub_epi8(__m256i a, __m256i b) {
 104   // CHECK: sub <32 x i8>
 105   return _mm256_sub_epi8(a, b);
 106 }
 107
 108 __m256i test_mm256_sub_epi16(__m256i a, __m256i b) {
 109   // CHECK: sub <16 x i16>
 110   return _mm256_sub_epi16(a, b);
 111 }
 112
 113 __m256i test_mm256_sub_epi32(__m256i a, __m256i b) {
 114   // CHECK: sub <8 x i32>
 115   return _mm256_sub_epi32(a, b);
 116 }
 117
 118 __m256i test_mm256_sub_epi64(__m256i a, __m256i b) {
 119   // CHECK: sub <4 x i64>
 120   return _mm256_sub_epi64(a, b);
 121 }
 122
 123 __m256i test_mm256_subs_epi8(__m256i a, __m256i b) {
 124   // CHECK: @llvm.x86.avx2.psubs.b
 125   return _mm256_subs_epi8(a, b);
 126 }
 127
 128 __m256i test_mm256_subs_epi16(__m256i a, __m256i b) {
 129   // CHECK: @llvm.x86.avx2.psubs.w
 130   return _mm256_subs_epi16(a, b);
 131 }
 132
 133 __m256i test_mm256_subs_epu8(__m256i a, __m256i b) {
 134   // CHECK: @llvm.x86.avx2.psubus.b
 135   return _mm256_subs_epu8(a, b);
 136 }
 137
 138 __m256i test_mm256_subs_epu16(__m256i a, __m256i b) {
 139   // CHECK: @llvm.x86.avx2.psubus.w
 140   return _mm256_subs_epu16(a, b);
 141 }
 142
 143 __m256i test_mm256_and_si256(__m256i a, __m256i b) {
 144   // CHECK: and <4 x i64>
 145   return _mm256_and_si256(a, b);
 146 }
 147
 148 __m256i test_mm256_andnot_si256(__m256i a, __m256i b) {
 149   // CHECK: xor <4 x i64>
 150   // CHECK: and <4 x i64>
 151   return _mm256_andnot_si256(a, b);
 152 }
 153
 154 __m256i test_mm256_or_si256(__m256i a, __m256i b) {
 155   // CHECK: or <4 x i64>
 156   return _mm256_or_si256(a, b);
 157 }
 158
 159 __m256i test_mm256_xor_si256(__m256i a, __m256i b) {
 160   // CHECK: xor <4 x i64>
 161   return _mm256_xor_si256(a, b);
 162 }
 163
 164 __m256i test_mm256_avg_epu8(__m256i a, __m256i b) {
 165   // CHECK: @llvm.x86.avx2.pavg.b
 166   return _mm256_avg_epu8(a, b);
 167 }
 168
 169 __m256i test_mm256_avg_epu16(__m256i a, __m256i b) {
 170   // CHECK: @llvm.x86.avx2.pavg.w
 171   return _mm256_avg_epu16(a, b);
 172 }
 173
 174 __m256i test_mm256_blendv_epi8(__m256i a, __m256i b, __m256i m) {
 175   // CHECK: @llvm.x86.avx2.pblendvb
 176   return _mm256_blendv_epi8(a, b, m);
 177 }
 178
 179 // FIXME: We should also lower the __builtin_ia32_pblendw128 (and similar)
 180 // functions to this IR. In the future we could delete the corresponding
 181 // intrinsic in LLVM if it's not being used anymore.
 182 __m256i test_mm256_blend_epi16(__m256i a, __m256i b) {
 183   // CHECK-LABEL: test_mm256_blend_epi16
 184   // CHECK-NOT: @llvm.x86.avx2.pblendw
 185   // 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>
 186   return _mm256_blend_epi16(a, b, 2);
 187 }
 188
 189 __m256i test_mm256_cmpeq_epi8(__m256i a, __m256i b) {
 190   // CHECK: icmp eq <32 x i8>
 191   return _mm256_cmpeq_epi8(a, b);
 192 }
 193
 194 __m256i test_mm256_cmpeq_epi16(__m256i a, __m256i b) {
 195   // CHECK: icmp eq <16 x i16>
 196   return _mm256_cmpeq_epi16(a, b);
 197 }
 198
 199 __m256i test_mm256_cmpeq_epi32(__m256i a, __m256i b) {
 200   // CHECK: icmp eq <8 x i32>
 201   return _mm256_cmpeq_epi32(a, b);
 202 }
 203
 204 __m256i test_mm256_cmpeq_epi64(__m256i a, __m256i b) {
 205   // CHECK: icmp eq <4 x i64>
 206   return _mm256_cmpeq_epi64(a, b);
 207 }
 208
 209 __m256i test_mm256_cmpgt_epi8(__m256i a, __m256i b) {
 210   // CHECK: icmp sgt <32 x i8>
 211   return _mm256_cmpgt_epi8(a, b);
 212 }
 213
 214 __m256i test_mm256_cmpgt_epi16(__m256i a, __m256i b) {
 215   // CHECK: icmp sgt <16 x i16>
 216   return _mm256_cmpgt_epi16(a, b);
 217 }
 218
 219 __m256i test_mm256_cmpgt_epi32(__m256i a, __m256i b) {
 220   // CHECK: icmp sgt <8 x i32>
 221   return _mm256_cmpgt_epi32(a, b);
 222 }
 223
 224 __m256i test_mm256_cmpgt_epi64(__m256i a, __m256i b) {
 225   // CHECK: icmp sgt <4 x i64>
 226   return _mm256_cmpgt_epi64(a, b);
 227 }
 228
 229 __m256i test_mm256_hadd_epi16(__m256i a, __m256i b) {
 230   // CHECK: @llvm.x86.avx2.phadd.w
 231   return _mm256_hadd_epi16(a, b);
 232 }
 233
 234 __m256i test_mm256_hadd_epi32(__m256i a, __m256i b) {
 235   // CHECK: @llvm.x86.avx2.phadd.d
 236   return _mm256_hadd_epi32(a, b);
 237 }
 238
 239 __m256i test_mm256_hadds_epi16(__m256i a, __m256i b) {
 240   // CHECK: @llvm.x86.avx2.phadd.sw
 241   return _mm256_hadds_epi16(a, b);
 242 }
 243
 244 __m256i test_mm256_hsub_epi16(__m256i a, __m256i b) {
 245   // CHECK: @llvm.x86.avx2.phsub.w
 246   return _mm256_hsub_epi16(a, b);
 247 }
 248
 249 __m256i test_mm256_hsub_epi32(__m256i a, __m256i b) {
 250   // CHECK: @llvm.x86.avx2.phsub.d
 251   return _mm256_hsub_epi32(a, b);
 252 }
 253
 254 __m256i test_mm256_hsubs_epi16(__m256i a, __m256i b) {
 255   // CHECK: @llvm.x86.avx2.phsub.sw
 256   return _mm256_hsubs_epi16(a, b);
 257 }
 258
 259 __m256i test_mm256_maddubs_epi16(__m256i a, __m256i b) {
 260   // CHECK: @llvm.x86.avx2.pmadd.ub.sw
 261   return _mm256_maddubs_epi16(a, b);
 262 }
 263
 264 __m256i test_mm256_madd_epi16(__m256i a, __m256i b) {
 265   // CHECK: @llvm.x86.avx2.pmadd.wd
 266   return _mm256_madd_epi16(a, b);
 267 }
 268
 269 __m256i test_mm256_max_epi8(__m256i a, __m256i b) {
 270   // CHECK: @llvm.x86.avx2.pmaxs.b
 271   return _mm256_max_epi8(a, b);
 272 }
 273
 274 __m256i test_mm256_max_epi16(__m256i a, __m256i b) {
 275   // CHECK: @llvm.x86.avx2.pmaxs.w
 276   return _mm256_max_epi16(a, b);
 277 }
 278
 279 __m256i test_mm256_max_epi32(__m256i a, __m256i b) {
 280   // CHECK: @llvm.x86.avx2.pmaxs.d
 281   return _mm256_max_epi32(a, b);
 282 }
 283
 284 __m256i test_mm256_max_epu8(__m256i a, __m256i b) {
 285   // CHECK: @llvm.x86.avx2.pmaxu.b
 286   return _mm256_max_epu8(a, b);
 287 }
 288
 289 __m256i test_mm256_max_epu16(__m256i a, __m256i b) {
 290   // CHECK: @llvm.x86.avx2.pmaxu.w
 291   return _mm256_max_epu16(a, b);
 292 }
 293
 294 __m256i test_mm256_max_epu32(__m256i a, __m256i b) {
 295   // CHECK: @llvm.x86.avx2.pmaxu.d
 296   return _mm256_max_epu32(a, b);
 297 }
 298
 299 __m256i test_mm256_min_epi8(__m256i a, __m256i b) {
 300   // CHECK: @llvm.x86.avx2.pmins.b
 301   return _mm256_min_epi8(a, b);
 302 }
 303
 304 __m256i test_mm256_min_epi16(__m256i a, __m256i b) {
 305   // CHECK: @llvm.x86.avx2.pmins.w
 306   return _mm256_min_epi16(a, b);
 307 }
 308
 309 __m256i test_mm256_min_epi32(__m256i a, __m256i b) {
 310   // CHECK: @llvm.x86.avx2.pmins.d
 311   return _mm256_min_epi32(a, b);
 312 }
 313
 314 __m256i test_mm256_min_epu8(__m256i a, __m256i b) {
 315   // CHECK: @llvm.x86.avx2.pminu.b
 316   return _mm256_min_epu8(a, b);
 317 }
 318
 319 __m256i test_mm256_min_epu16(__m256i a, __m256i b) {
 320   // CHECK: @llvm.x86.avx2.pminu.w
 321   return _mm256_min_epu16(a, b);
 322 }
 323
 324 __m256i test_mm256_min_epu32(__m256i a, __m256i b) {
 325   // CHECK: @llvm.x86.avx2.pminu.d
 326   return _mm256_min_epu32(a, b);
 327 }
 328
 329 int test_mm256_movemask_epi8(__m256i a) {
 330   // CHECK: @llvm.x86.avx2.pmovmskb
 331   return _mm256_movemask_epi8(a);
 332 }
 333
 334 __m256i test_mm256_cvtepi8_epi16(__m128i a) {
 335   // CHECK: @llvm.x86.avx2.pmovsxbw
 336   return _mm256_cvtepi8_epi16(a);
 337 }
 338
 339 __m256i test_mm256_cvtepi8_epi32(__m128i a) {
 340   // CHECK: @llvm.x86.avx2.pmovsxbd
 341   return _mm256_cvtepi8_epi32(a);
 342 }
 343
 344 __m256i test_mm256_cvtepi8_epi64(__m128i a) {
 345   // CHECK: @llvm.x86.avx2.pmovsxbq
 346   return _mm256_cvtepi8_epi64(a);
 347 }
 348
 349 __m256i test_mm256_cvtepi16_epi32(__m128i a) {
 350   // CHECK: @llvm.x86.avx2.pmovsxwd
 351   return _mm256_cvtepi16_epi32(a);
 352 }
 353
 354 __m256i test_mm256_cvtepi16_epi64(__m128i a) {
 355   // CHECK: @llvm.x86.avx2.pmovsxwq
 356   return _mm256_cvtepi16_epi64(a);
 357 }
 358
 359 __m256i test_mm256_cvtepi32_epi64(__m128i a) {
 360   // CHECK: @llvm.x86.avx2.pmovsxdq
 361   return _mm256_cvtepi32_epi64(a);
 362 }
 363
 364 __m256i test_mm256_cvtepu8_epi16(__m128i a) {
 365   // CHECK: @llvm.x86.avx2.pmovzxbw
 366   return _mm256_cvtepu8_epi16(a);
 367 }
 368
 369 __m256i test_mm256_cvtepu8_epi32(__m128i a) {
 370   // CHECK: @llvm.x86.avx2.pmovzxbd
 371   return _mm256_cvtepu8_epi32(a);
 372 }
 373
 374 __m256i test_mm256_cvtepu8_epi64(__m128i a) {
 375   // CHECK: @llvm.x86.avx2.pmovzxbq
 376   return _mm256_cvtepu8_epi64(a);
 377 }
 378
 379 __m256i test_mm256_cvtepu16_epi32(__m128i a) {
 380   // CHECK: @llvm.x86.avx2.pmovzxwd
 381   return _mm256_cvtepu16_epi32(a);
 382 }
 383
 384 __m256i test_mm256_cvtepu16_epi64(__m128i a) {
 385   // CHECK: @llvm.x86.avx2.pmovzxwq
 386   return _mm256_cvtepu16_epi64(a);
 387 }
 388
 389 __m256i test_mm256_cvtepu32_epi64(__m128i a) {
 390   // CHECK: @llvm.x86.avx2.pmovzxdq
 391   return _mm256_cvtepu32_epi64(a);
 392 }
 393
 394 __m256i test_mm256_mul_epi32(__m256i a, __m256i b) {
 395   // CHECK: @llvm.x86.avx2.pmul.dq
 396   return _mm256_mul_epi32(a, b);
 397 }
 398
 399 __m256i test_mm256_mulhrs_epi16(__m256i a, __m256i b) {
 400   // CHECK: @llvm.x86.avx2.pmul.hr.sw
 401   return _mm256_mulhrs_epi16(a, b);
 402 }
 403
 404 __m256i test_mm256_mulhi_epu16(__m256i a, __m256i b) {
 405   // CHECK: @llvm.x86.avx2.pmulhu.w
 406   return _mm256_mulhi_epu16(a, b);
 407 }
 408
 409 __m256i test_mm256_mulhi_epi16(__m256i a, __m256i b) {
 410   // CHECK: @llvm.x86.avx2.pmulh.w
 411   return _mm256_mulhi_epi16(a, b);
 412 }
 413
 414 __m256i test_mm256_mullo_epi16(__m256i a, __m256i b) {
 415   // CHECK: mul <16 x i16>
 416   return _mm256_mullo_epi16(a, b);
 417 }
 418
 419 __m256i test_mm256_mullo_epi32(__m256i a, __m256i b) {
 420   // CHECK: mul <8 x i32>
 421   return _mm256_mullo_epi32(a, b);
 422 }
 423
 424 __m256i test_mm256_mul_epu32(__m256i a, __m256i b) {
 425   // CHECK: @llvm.x86.avx2.pmulu.dq
 426   return _mm256_mul_epu32(a, b);
 427 }
 428
 429 __m256i test_mm256_shuffle_epi8(__m256i a, __m256i b) {
 430   // CHECK: @llvm.x86.avx2.pshuf.b
 431   return _mm256_shuffle_epi8(a, b);
 432 }
 433
 434 __m256i test_mm256_shuffle_epi32(__m256i a) {
 435   // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 3, i32 3, i32 0, i32 0, i32 7, i32 7, i32 4, i32 4>
 436   return _mm256_shuffle_epi32(a, 15);
 437 }
 438
 439 __m256i test_mm256_shufflehi_epi16(__m256i a) {
 440   // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> %{{.*}}, <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>
 441   return _mm256_shufflehi_epi16(a, 107);
 442 }
 443
 444 __m256i test_mm256_shufflelo_epi16(__m256i a) {
 445   // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> %{{.*}}, <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>
 446   return _mm256_shufflelo_epi16(a, 83);
 447 }
 448
 449 __m256i test_mm256_sign_epi8(__m256i a, __m256i b) {
 450   // CHECK: @llvm.x86.avx2.psign.b
 451   return _mm256_sign_epi8(a, b);
 452 }
 453
 454 __m256i test_mm256_sign_epi16(__m256i a, __m256i b) {
 455   // CHECK: @llvm.x86.avx2.psign.w
 456   return _mm256_sign_epi16(a, b);
 457 }
 458
 459 __m256i test_mm256_sign_epi32(__m256i a, __m256i b) {
 460   // CHECK: @llvm.x86.avx2.psign.d
 461   return _mm256_sign_epi32(a, b);
 462 }
 463
 464 __m256i test_mm256_slli_si256(__m256i a) {
 465   // 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>
 466   return _mm256_slli_si256(a, 3);
 467 }
 468
 469 __m256i test_mm256_bslli_epi128(__m256i a) {
 470   // 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>
 471   return _mm256_bslli_epi128(a, 3);
 472 }
 473
 474 __m256i test_mm256_slli_epi16(__m256i a) {
 475   // CHECK: @llvm.x86.avx2.pslli.w
 476   return _mm256_slli_epi16(a, 3);
 477 }
 478
 479 __m256i test_mm256_sll_epi16(__m256i a, __m128i b) {
 480   // CHECK: @llvm.x86.avx2.psll.w
 481   return _mm256_sll_epi16(a, b);
 482 }
 483
 484 __m256i test_mm256_slli_epi32(__m256i a) {
 485   // CHECK: @llvm.x86.avx2.pslli.d
 486   return _mm256_slli_epi32(a, 3);
 487 }
 488
 489 __m256i test_mm256_sll_epi32(__m256i a, __m128i b) {
 490   // CHECK: @llvm.x86.avx2.psll.d
 491   return _mm256_sll_epi32(a, b);
 492 }
 493
 494 __m256i test_mm256_slli_epi64(__m256i a) {
 495   // CHECK: @llvm.x86.avx2.pslli.q
 496   return _mm256_slli_epi64(a, 3);
 497 }
 498
 499 __m256i test_mm256_sll_epi64(__m256i a, __m128i b) {
 500   // CHECK: @llvm.x86.avx2.psll.q
 501   return _mm256_sll_epi64(a, b);
 502 }
 503
 504 __m256i test_mm256_srai_epi16(__m256i a) {
 505   // CHECK: @llvm.x86.avx2.psrai.w
 506   return _mm256_srai_epi16(a, 3);
 507 }
 508
 509 __m256i test_mm256_sra_epi16(__m256i a, __m128i b) {
 510   // CHECK: @llvm.x86.avx2.psra.w
 511   return _mm256_sra_epi16(a, b);
 512 }
 513
 514 __m256i test_mm256_srai_epi32(__m256i a) {
 515   // CHECK: @llvm.x86.avx2.psrai.d
 516   return _mm256_srai_epi32(a, 3);
 517 }
 518
 519 __m256i test_mm256_sra_epi32(__m256i a, __m128i b) {
 520   // CHECK: @llvm.x86.avx2.psra.d
 521   return _mm256_sra_epi32(a, b);
 522 }
 523
 524 __m256i test_mm256_srli_si256(__m256i a) {
 525   // 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>
 526   return _mm256_srli_si256(a, 3);
 527 }
 528
 529 __m256i test_mm256_bsrli_epi128(__m256i a) {
 530   // 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>
 531   return _mm256_bsrli_epi128(a, 3);
 532 }
 533
 534 __m256i test_mm256_srli_epi16(__m256i a) {
 535   // CHECK: @llvm.x86.avx2.psrli.w
 536   return _mm256_srli_epi16(a, 3);
 537 }
 538
 539 __m256i test_mm256_srl_epi16(__m256i a, __m128i b) {
 540   // CHECK: @llvm.x86.avx2.psrl.w
 541   return _mm256_srl_epi16(a, b);
 542 }
 543
 544 __m256i test_mm256_srli_epi32(__m256i a) {
 545   // CHECK: @llvm.x86.avx2.psrli.d
 546   return _mm256_srli_epi32(a, 3);
 547 }
 548
 549 __m256i test_mm256_srl_epi32(__m256i a, __m128i b) {
 550   // CHECK: @llvm.x86.avx2.psrl.d
 551   return _mm256_srl_epi32(a, b);
 552 }
 553
 554 __m256i test_mm256_srli_epi64(__m256i a) {
 555   // CHECK: @llvm.x86.avx2.psrli.q
 556   return _mm256_srli_epi64(a, 3);
 557 }
 558
 559 __m256i test_mm256_srl_epi64(__m256i a, __m128i b) {
 560   // CHECK: @llvm.x86.avx2.psrl.q
 561   return _mm256_srl_epi64(a, b);
 562 }
 563
 564 __m256i test_mm256_unpackhi_epi8(__m256i a, __m256i b) {
 565   // 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>
 566   return _mm256_unpackhi_epi8(a, b);
 567 }
 568
 569 __m256i test_mm256_unpackhi_epi16(__m256i a, __m256i b) {
 570   // 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>
 571   return _mm256_unpackhi_epi16(a, b);
 572 }
 573
 574 __m256i test_mm256_unpackhi_epi32(__m256i a, __m256i b) {
 575   // 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>
 576   return _mm256_unpackhi_epi32(a, b);
 577 }
 578
 579 __m256i test_mm256_unpackhi_epi64(__m256i a, __m256i b) {
 580   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
 581   return _mm256_unpackhi_epi64(a, b);
 582 }
 583
 584 __m256i test_mm256_unpacklo_epi8(__m256i a, __m256i b) {
 585   // 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>
 586   return _mm256_unpacklo_epi8(a, b);
 587 }
 588
 589 __m256i test_mm256_unpacklo_epi16(__m256i a, __m256i b) {
 590   // 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>
 591   return _mm256_unpacklo_epi16(a, b);
 592 }
 593
 594 __m256i test_mm256_unpacklo_epi32(__m256i a, __m256i b) {
 595   // 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>
 596   return _mm256_unpacklo_epi32(a, b);
 597 }
 598
 599 __m256i test_mm256_unpacklo_epi64(__m256i a, __m256i b) {
 600   // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
 601   return _mm256_unpacklo_epi64(a, b);
 602 }
 603
 604 __m256i test_mm256_stream_load_si256(__m256i *a) {
 605   // CHECK: @llvm.x86.avx2.movntdqa
 606   return _mm256_stream_load_si256(a);
 607 }
 608
 609 __m128 test_mm_broadcastss_ps(__m128 a) {
 610   // CHECK: @llvm.x86.avx2.vbroadcast.ss.ps
 611   return _mm_broadcastss_ps(a);
 612 }
 613
 614 __m128d test_mm_broadcastsd_pd(__m128d a) {
 615   // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> zeroinitializer
 616   return _mm_broadcastsd_pd(a);
 617 }
 618
 619 __m256 test_mm256_broadcastss_ps(__m128 a) {
 620   // CHECK: @llvm.x86.avx2.vbroadcast.ss.ps.256
 621   return _mm256_broadcastss_ps(a);
 622 }
 623
 624 __m256d test_mm256_broadcastsd_pd(__m128d a) {
 625   // check: @llvm.x86.avx2.vbroadcast.sd.pd.256
 626   return _mm256_broadcastsd_pd(a);
 627 }
 628
 629 __m256i test_mm256_broadcastsi128_si256(__m128i a) {
 630   // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
 631   return _mm256_broadcastsi128_si256(a);
 632 }
 633
 634 __m128i test_mm_blend_epi32(__m128i a, __m128i b) {
 635   // CHECK-LABEL: test_mm_blend_epi32
 636   // CHECK-NOT: @llvm.x86.avx2.pblendd.128
 637   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 4, i32 1, i32 6, i32 3>
 638   return _mm_blend_epi32(a, b, 0x35);
 639 }
 640
 641 __m256i test_mm256_blend_epi32(__m256i a, __m256i b) {
 642   // CHECK-LABEL: test_mm256_blend_epi32
 643   // CHECK-NOT: @llvm.x86.avx2.pblendd.256
 644   // 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>
 645   return _mm256_blend_epi32(a, b, 0x35);
 646 }
 647
 648 __m256i test_mm256_broadcastb_epi8(__m128i a) {
 649   // CHECK: @llvm.x86.avx2.pbroadcastb.256
 650   return _mm256_broadcastb_epi8(a);
 651 }
 652
 653 __m256i test_mm256_broadcastw_epi16(__m128i a) {
 654   // CHECK: @llvm.x86.avx2.pbroadcastw.256
 655   return _mm256_broadcastw_epi16(a);
 656 }
 657
 658 __m256i test_mm256_broadcastd_epi32(__m128i a) {
 659   // CHECK: @llvm.x86.avx2.pbroadcastd.256
 660   return _mm256_broadcastd_epi32(a);
 661 }
 662
 663 __m256i test_mm256_broadcastq_epi64(__m128i a) {
 664   // CHECK: @llvm.x86.avx2.pbroadcastq.256
 665   return _mm256_broadcastq_epi64(a);
 666 }
 667
 668 __m128i test_mm_broadcastb_epi8(__m128i a) {
 669   // CHECK: @llvm.x86.avx2.pbroadcastb.128
 670   return _mm_broadcastb_epi8(a);
 671 }
 672
 673 __m128i test_mm_broadcastw_epi16(__m128i a) {
 674   // CHECK: @llvm.x86.avx2.pbroadcastw.128
 675   return _mm_broadcastw_epi16(a);
 676 }
 677
 678 __m128i test_mm_broadcastd_epi32(__m128i a) {
 679   // CHECK: @llvm.x86.avx2.pbroadcastd.128
 680   return _mm_broadcastd_epi32(a);
 681 }
 682
 683 __m128i test_mm_broadcastq_epi64(__m128i a) {
 684   // CHECK: @llvm.x86.avx2.pbroadcastq.128
 685   return _mm_broadcastq_epi64(a);
 686 }
 687
 688 __m256i test_mm256_permutevar8x32_epi32(__m256i a, __m256i b) {
 689   // CHECK: @llvm.x86.avx2.permd
 690   return _mm256_permutevar8x32_epi32(a, b);
 691 }
 692
 693 __m256d test_mm256_permute4x64_pd(__m256d a) {
 694   // CHECK: shufflevector{{.*}}<i32 1, i32 2, i32 1, i32 0>
 695   return _mm256_permute4x64_pd(a, 25);
 696 }
 697
 698 __m256 test_mm256_permutevar8x32_ps(__m256 a, __m256 b) {
 699   // CHECK: @llvm.x86.avx2.permps
 700   return _mm256_permutevar8x32_ps(a, b);
 701 }
 702
 703 __m256i test_mm256_permute4x64_epi64(__m256i a) {
 704   // CHECK: shufflevector{{.*}}<i32 3, i32 0, i32 2, i32 0>
 705   return _mm256_permute4x64_epi64(a, 35);
 706 }
 707
 708 __m256i test_mm256_permute2x128_si256(__m256i a, __m256i b) {
 709   // CHECK: @llvm.x86.avx2.vperm2i128
 710   return _mm256_permute2x128_si256(a, b, 0x31);
 711 }
 712
 713 __m128i test_mm256_extracti128_si256_0(__m256i a) {
 714   // CHECK-LABEL: @test_mm256_extracti128_si256_0
 715   // CHECK: shufflevector{{.*}}<i32 0, i32 1>
 716   return _mm256_extracti128_si256(a, 0);
 717 }
 718
 719 __m128i test_mm256_extracti128_si256_1(__m256i a) {
 720   // CHECK-LABEL: @test_mm256_extracti128_si256_1
 721   // CHECK: shufflevector{{.*}}<i32 2, i32 3>
 722   return _mm256_extracti128_si256(a, 1);
 723 }
 724
 725 // Immediate should be truncated to one bit.
 726 __m128i test_mm256_extracti128_si256_2(__m256i a) {
 727   // CHECK-LABEL: @test_mm256_extracti128_si256_2
 728   // CHECK: shufflevector{{.*}}<i32 0, i32 1>
 729   return _mm256_extracti128_si256(a, 2);
 730 }
 731
 732 __m256i test_mm256_inserti128_si256_0(__m256i a, __m128i b) {
 733   // CHECK-LABEL: @test_mm256_inserti128_si256_0
 734   // CHECK: shufflevector{{.*}}<i32 4, i32 5, i32 2, i32 3>
 735   return _mm256_inserti128_si256(a, b, 0);
 736 }
 737
 738 __m256i test_mm256_inserti128_si256_1(__m256i a, __m128i b) {
 739   // CHECK-LABEL: @test_mm256_inserti128_si256_1
 740   // CHECK: shufflevector{{.*}}<i32 0, i32 1, i32 4, i32 5>
 741   return _mm256_inserti128_si256(a, b, 1);
 742 }
 743
 744 // Immediate should be truncated to one bit.
 745 __m256i test_mm256_inserti128_si256_2(__m256i a, __m128i b) {
 746   // CHECK-LABEL: @test_mm256_inserti128_si256_2
 747   // CHECK: shufflevector{{.*}}<i32 4, i32 5, i32 2, i32 3>
 748   return _mm256_inserti128_si256(a, b, 2);
 749 }
 750
 751 __m256i test_mm256_maskload_epi32(int const *a, __m256i m) {
 752   // CHECK: @llvm.x86.avx2.maskload.d.256
 753   return _mm256_maskload_epi32(a, m);
 754 }
 755
 756 __m256i test_mm256_maskload_epi64(long long const *a, __m256i m) {
 757   // CHECK: @llvm.x86.avx2.maskload.q.256
 758   return _mm256_maskload_epi64(a, m);
 759 }
 760
 761 __m128i test_mm_maskload_epi32(int const *a, __m128i m) {
 762   // CHECK: @llvm.x86.avx2.maskload.d
 763   return _mm_maskload_epi32(a, m);
 764 }
 765
 766 __m128i test_mm_maskload_epi64(long long const *a, __m128i m) {
 767   // CHECK: @llvm.x86.avx2.maskload.q
 768   return _mm_maskload_epi64(a, m);
 769 }
 770
 771 void test_mm256_maskstore_epi32(int *a, __m256i m, __m256i b) {
 772   // CHECK: @llvm.x86.avx2.maskstore.d.256
 773   _mm256_maskstore_epi32(a, m, b);
 774 }
 775
 776 void test_mm256_maskstore_epi64(long long *a, __m256i m, __m256i b) {
 777   // CHECK: @llvm.x86.avx2.maskstore.q.256
 778   _mm256_maskstore_epi64(a, m, b);
 779 }
 780
 781 void test_mm_maskstore_epi32(int *a, __m128i m, __m128i b) {
 782   // CHECK: @llvm.x86.avx2.maskstore.d
 783   _mm_maskstore_epi32(a, m, b);
 784 }
 785
 786 void test_mm_maskstore_epi64(long long *a, __m128i m, __m128i b) {
 787   // CHECK: @llvm.x86.avx2.maskstore.q
 788   _mm_maskstore_epi64(a, m, b);
 789 }
 790
 791 __m256i test_mm256_sllv_epi32(__m256i a, __m256i b) {
 792   // CHECK: @llvm.x86.avx2.psllv.d.256
 793   return _mm256_sllv_epi32(a, b);
 794 }
 795
 796 __m128i test_mm_sllv_epi32(__m128i a, __m128i b) {
 797   // CHECK: @llvm.x86.avx2.psllv.d
 798   return _mm_sllv_epi32(a, b);
 799 }
 800
 801 __m256i test_mm256_sllv_epi64(__m256i a, __m256i b) {
 802   // CHECK: @llvm.x86.avx2.psllv.q.256
 803   return _mm256_sllv_epi64(a, b);
 804 }
 805
 806 __m128i test_mm_sllv_epi64(__m128i a, __m128i b) {
 807   // CHECK: @llvm.x86.avx2.psllv.q
 808   return _mm_sllv_epi64(a, b);
 809 }
 810
 811 __m256i test_mm256_srav_epi32(__m256i a, __m256i b) {
 812   // CHECK: @llvm.x86.avx2.psrav.d.256
 813   return _mm256_srav_epi32(a, b);
 814 }
 815
 816 __m128i test_mm_srav_epi32(__m128i a, __m128i b) {
 817   // CHECK: @llvm.x86.avx2.psrav.d
 818   return _mm_srav_epi32(a, b);
 819 }
 820
 821 __m256i test_mm256_srlv_epi32(__m256i a, __m256i b) {
 822   // CHECK: @llvm.x86.avx2.psrlv.d.256
 823   return _mm256_srlv_epi32(a, b);
 824 }
 825
 826 __m128i test_mm_srlv_epi32(__m128i a, __m128i b) {
 827   // CHECK: @llvm.x86.avx2.psrlv.d
 828   return _mm_srlv_epi32(a, b);
 829 }
 830
 831 __m256i test_mm256_srlv_epi64(__m256i a, __m256i b) {
 832   // CHECK: @llvm.x86.avx2.psrlv.q.256
 833   return _mm256_srlv_epi64(a, b);
 834 }
 835
 836 __m128i test_mm_srlv_epi64(__m128i a, __m128i b) {
 837   // CHECK: @llvm.x86.avx2.psrlv.q
 838   return _mm_srlv_epi64(a, b);
 839 }
 840
 841 __m128d test_mm_mask_i32gather_pd(__m128d a, double const *b, __m128i c,
 842                                   __m128d d) {
 843   // CHECK: @llvm.x86.avx2.gather.d.pd
 844   return _mm_mask_i32gather_pd(a, b, c, d, 2);
 845 }
 846
 847 __m256d test_mm256_mask_i32gather_pd(__m256d a, double const *b, __m128i c,
 848                                       __m256d d) {
 849   // CHECK: @llvm.x86.avx2.gather.d.pd.256
 850   return _mm256_mask_i32gather_pd(a, b, c, d, 2);
 851 }
 852 __m128d test_mm_mask_i64gather_pd(__m128d a, double const *b, __m128i c,
 853                                   __m128d d) {
 854   // CHECK: @llvm.x86.avx2.gather.q.pd
 855   return _mm_mask_i64gather_pd(a, b, c, d, 2);
 856 }
 857 __m256d test_mm256_mask_i64gather_pd(__m256d a, double const *b, __m256i c,
 858                                       __m256d d) {
 859   // CHECK: @llvm.x86.avx2.gather.q.pd.256
 860   return _mm256_mask_i64gather_pd(a, b, c, d, 2);
 861 }
 862
 863 __m128 test_mm_mask_i32gather_ps(__m128 a, float const *b, __m128i c,
 864                                  __m128 d) {
 865   // CHECK: @llvm.x86.avx2.gather.d.ps
 866   return _mm_mask_i32gather_ps(a, b, c, d, 2);
 867 }
 868 __m256 test_mm256_mask_i32gather_ps(__m256 a, float const *b, __m256i c,
 869                                      __m256 d) {
 870   // CHECK: @llvm.x86.avx2.gather.d.ps.256
 871   return _mm256_mask_i32gather_ps(a, b, c, d, 2);
 872 }
 873 __m128 test_mm_mask_i64gather_ps(__m128 a, float const *b, __m128i c,
 874                                  __m128 d) {
 875   // CHECK: @llvm.x86.avx2.gather.q.ps
 876   return _mm_mask_i64gather_ps(a, b, c, d, 2);
 877 }
 878 __m128 test_mm256_mask_i64gather_ps(__m128 a, float const *b, __m256i c,
 879                                     __m128 d) {
 880   // CHECK: @llvm.x86.avx2.gather.q.ps.256
 881   return _mm256_mask_i64gather_ps(a, b, c, d, 2);
 882 }
 883
 884 __m128i test_mm_mask_i32gather_epi32(__m128i a, int const *b, __m128i c,
 885                                      __m128i d) {
 886   // CHECK: @llvm.x86.avx2.gather.d.d
 887   return _mm_mask_i32gather_epi32(a, b, c, d, 2);
 888 }
 889 __m256i test_mm256_mask_i32gather_epi32(__m256i a, int const *b, __m256i c,
 890                                         __m256i d) {
 891   // CHECK: @llvm.x86.avx2.gather.d.d.256
 892   return _mm256_mask_i32gather_epi32(a, b, c, d, 2);
 893 }
 894 __m128i test_mm_mask_i64gather_epi32(__m128i a, int const *b, __m128i c,
 895                                      __m128i d) {
 896   // CHECK: @llvm.x86.avx2.gather.q.d
 897   return _mm_mask_i64gather_epi32(a, b, c, d, 2);
 898 }
 899 __m128i test_mm256_mask_i64gather_epi32(__m128i a, int const *b, __m256i c,
 900                                         __m128i d) {
 901   // CHECK: @llvm.x86.avx2.gather.q.d.256
 902   return _mm256_mask_i64gather_epi32(a, b, c, d, 2);
 903 }
 904
 905 __m128i test_mm_mask_i32gather_epi64(__m128i a, long long const *b, __m128i c,
 906                                      __m128i d) {
 907   // CHECK: @llvm.x86.avx2.gather.d.q
 908   return _mm_mask_i32gather_epi64(a, b, c, d, 2);
 909 }
 910 __m256i test_mm256_mask_i32gather_epi64(__m256i a, long long const *b, __m128i c,
 911                                         __m256i d) {
 912   // CHECK: @llvm.x86.avx2.gather.d.q.256
 913   return _mm256_mask_i32gather_epi64(a, b, c, d, 2);
 914 }
 915 __m128i test_mm_mask_i64gather_epi64(__m128i a, long long const *b, __m128i c,
 916                                      __m128i d) {
 917   // CHECK: @llvm.x86.avx2.gather.q.q
 918   return _mm_mask_i64gather_epi64(a, b, c, d, 2);
 919 }
 920 __m256i test_mm256_mask_i64gather_epi64(__m256i a, long long const *b, __m256i c,
 921                                         __m256i d) {
 922   // CHECK: @llvm.x86.avx2.gather.q.q.256
 923   return _mm256_mask_i64gather_epi64(a, b, c, d, 2);
 924 }
 925
 926 __m128d test_mm_i32gather_pd(double const *b, __m128i c) {
 927   // CHECK: @llvm.x86.avx2.gather.d.pd
 928   return _mm_i32gather_pd(b, c, 2);
 929 }
 930 __m256d test_mm256_i32gather_pd(double const *b, __m128i c) {
 931   // CHECK: @llvm.x86.avx2.gather.d.pd.256
 932   return _mm256_i32gather_pd(b, c, 2);
 933 }
 934 __m128d test_mm_i64gather_pd(double const *b, __m128i c) {
 935   // CHECK: @llvm.x86.avx2.gather.q.pd
 936   return _mm_i64gather_pd(b, c, 2);
 937 }
 938 __m256d test_mm256_i64gather_pd(double const *b, __m256i c) {
 939   // CHECK: @llvm.x86.avx2.gather.q.pd.256
 940   return _mm256_i64gather_pd(b, c, 2);
 941 }
 942 __m128 test_mm_i32gather_ps(float const *b, __m128i c) {
 943   // CHECK: @llvm.x86.avx2.gather.d.ps
 944   return _mm_i32gather_ps(b, c, 2);
 945 }
 946 __m256 test_mm256_i32gather_ps(float const *b, __m256i c) {
 947   // CHECK: @llvm.x86.avx2.gather.d.ps.256
 948   return _mm256_i32gather_ps(b, c, 2);
 949 }
 950 __m128 test_mm_i64gather_ps(float const *b, __m128i c) {
 951   // CHECK: @llvm.x86.avx2.gather.q.ps
 952   return _mm_i64gather_ps(b, c, 2);
 953 }
 954 __m128 test_mm256_i64gather_ps(float const *b, __m256i c) {
 955   // CHECK: @llvm.x86.avx2.gather.q.ps.256
 956   return _mm256_i64gather_ps(b, c, 2);
 957 }
 958
 959 __m128i test_mm_i32gather_epi32(int const *b, __m128i c) {
 960   // CHECK: @llvm.x86.avx2.gather.d.d
 961   return _mm_i32gather_epi32(b, c, 2);
 962 }
 963 __m256i test_mm256_i32gather_epi32(int const *b, __m256i c) {
 964   // CHECK: @llvm.x86.avx2.gather.d.d.256
 965   return _mm256_i32gather_epi32(b, c, 2);
 966 }
 967 __m128i test_mm_i64gather_epi32(int const *b, __m128i c) {
 968   // CHECK: @llvm.x86.avx2.gather.q.d
 969   return _mm_i64gather_epi32(b, c, 2);
 970 }
 971 __m128i test_mm256_i64gather_epi32(int const *b, __m256i c) {
 972   // CHECK: @llvm.x86.avx2.gather.q.d.256
 973   return _mm256_i64gather_epi32(b, c, 2);
 974 }
 975 __m128i test_mm_i32gather_epi64(long long const *b, __m128i c) {
 976   // CHECK: @llvm.x86.avx2.gather.d.q
 977   return _mm_i32gather_epi64(b, c, 2);
 978 }
 979 __m256i test_mm256_i32gather_epi64(long long const *b, __m128i c) {
 980   // CHECK: @llvm.x86.avx2.gather.d.q.256
 981   return _mm256_i32gather_epi64(b, c, 2);
 982 }
 983 __m128i test_mm_i64gather_epi64(long long const *b, __m128i c) {
 984   // CHECK: @llvm.x86.avx2.gather.q.q
 985   return _mm_i64gather_epi64(b, c, 2);
 986 }
 987 __m256i test_mm256_i64gather_epi64(long long const *b, __m256i c) {
 988   // CHECK: @llvm.x86.avx2.gather.q.q.256
 989   return _mm256_i64gather_epi64(b, c, 2);
 990 }