1 // RUN: %clang_cc1 %s -O3 -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({{.*}}, {{.*}}, i32 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: @llvm.x86.avx2.psrl.dq({{.*}}, i32 8) 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 __m256i test_mm256_blend_epi16(__m256i a, __m256i b) { 180 // CHECK: @llvm.x86.avx2.pblendw(<16 x i16> %{{.*}}, <16 x i16> %{{.*}}, i32 2) 181 return _mm256_blend_epi16(a, b, 2); 182 } 183 184 __m256i test_mm256_cmpeq_epi8(__m256i a, __m256i b) { 185 // CHECK: icmp eq <32 x i8> 186 return _mm256_cmpeq_epi8(a, b); 187 } 188 189 __m256i test_mm256_cmpeq_epi16(__m256i a, __m256i b) { 190 // CHECK: icmp eq <16 x i16> 191 return _mm256_cmpeq_epi16(a, b); 192 } 193 194 __m256i test_mm256_cmpeq_epi32(__m256i a, __m256i b) { 195 // CHECK: icmp eq <8 x i32> 196 return _mm256_cmpeq_epi32(a, b); 197 } 198 199 __m256i test_mm256_cmpeq_epi64(__m256i a, __m256i b) { 200 // CHECK: icmp eq <4 x i64> 201 return _mm256_cmpeq_epi64(a, b); 202 } 203 204 __m256i test_mm256_cmpgt_epi8(__m256i a, __m256i b) { 205 // CHECK: icmp sgt <32 x i8> 206 return _mm256_cmpgt_epi8(a, b); 207 } 208 209 __m256i test_mm256_cmpgt_epi16(__m256i a, __m256i b) { 210 // CHECK: icmp sgt <16 x i16> 211 return _mm256_cmpgt_epi16(a, b); 212 } 213 214 __m256i test_mm256_cmpgt_epi32(__m256i a, __m256i b) { 215 // CHECK: icmp sgt <8 x i32> 216 return _mm256_cmpgt_epi32(a, b); 217 } 218 219 __m256i test_mm256_cmpgt_epi64(__m256i a, __m256i b) { 220 // CHECK: icmp sgt <4 x i64> 221 return _mm256_cmpgt_epi64(a, b); 222 } 223 224 __m256i test_mm256_hadd_epi16(__m256i a, __m256i b) { 225 // CHECK: @llvm.x86.avx2.phadd.w 226 return _mm256_hadd_epi16(a, b); 227 } 228 229 __m256i test_mm256_hadd_epi32(__m256i a, __m256i b) { 230 // CHECK: @llvm.x86.avx2.phadd.d 231 return _mm256_hadd_epi32(a, b); 232 } 233 234 __m256i test_mm256_hadds_epi16(__m256i a, __m256i b) { 235 // CHECK: @llvm.x86.avx2.phadd.sw 236 return _mm256_hadds_epi16(a, b); 237 } 238 239 __m256i test_mm256_hsub_epi16(__m256i a, __m256i b) { 240 // CHECK: @llvm.x86.avx2.phsub.w 241 return _mm256_hsub_epi16(a, b); 242 } 243 244 __m256i test_mm256_hsub_epi32(__m256i a, __m256i b) { 245 // CHECK: @llvm.x86.avx2.phsub.d 246 return _mm256_hsub_epi32(a, b); 247 } 248 249 __m256i test_mm256_hsubs_epi16(__m256i a, __m256i b) { 250 // CHECK: @llvm.x86.avx2.phsub.sw 251 return _mm256_hsubs_epi16(a, b); 252 } 253 254 __m256i test_mm256_maddubs_epi16(__m256i a, __m256i b) { 255 // CHECK: @llvm.x86.avx2.pmadd.ub.sw 256 return _mm256_maddubs_epi16(a, b); 257 } 258 259 __m256i test_mm256_madd_epi16(__m256i a, __m256i b) { 260 // CHECK: @llvm.x86.avx2.pmadd.wd 261 return _mm256_madd_epi16(a, b); 262 } 263 264 __m256i test_mm256_max_epi8(__m256i a, __m256i b) { 265 // CHECK: @llvm.x86.avx2.pmaxs.b 266 return _mm256_max_epi8(a, b); 267 } 268 269 __m256i test_mm256_max_epi16(__m256i a, __m256i b) { 270 // CHECK: @llvm.x86.avx2.pmaxs.w 271 return _mm256_max_epi16(a, b); 272 } 273 274 __m256i test_mm256_max_epi32(__m256i a, __m256i b) { 275 // CHECK: @llvm.x86.avx2.pmaxs.d 276 return _mm256_max_epi32(a, b); 277 } 278 279 __m256i test_mm256_max_epu8(__m256i a, __m256i b) { 280 // CHECK: @llvm.x86.avx2.pmaxu.b 281 return _mm256_max_epu8(a, b); 282 } 283 284 __m256i test_mm256_max_epu16(__m256i a, __m256i b) { 285 // CHECK: @llvm.x86.avx2.pmaxu.w 286 return _mm256_max_epu16(a, b); 287 } 288 289 __m256i test_mm256_max_epu32(__m256i a, __m256i b) { 290 // CHECK: @llvm.x86.avx2.pmaxu.d 291 return _mm256_max_epu32(a, b); 292 } 293 294 __m256i test_mm256_min_epi8(__m256i a, __m256i b) { 295 // CHECK: @llvm.x86.avx2.pmins.b 296 return _mm256_min_epi8(a, b); 297 } 298 299 __m256i test_mm256_min_epi16(__m256i a, __m256i b) { 300 // CHECK: @llvm.x86.avx2.pmins.w 301 return _mm256_min_epi16(a, b); 302 } 303 304 __m256i test_mm256_min_epi32(__m256i a, __m256i b) { 305 // CHECK: @llvm.x86.avx2.pmins.d 306 return _mm256_min_epi32(a, b); 307 } 308 309 __m256i test_mm256_min_epu8(__m256i a, __m256i b) { 310 // CHECK: @llvm.x86.avx2.pminu.b 311 return _mm256_min_epu8(a, b); 312 } 313 314 __m256i test_mm256_min_epu16(__m256i a, __m256i b) { 315 // CHECK: @llvm.x86.avx2.pminu.w 316 return _mm256_min_epu16(a, b); 317 } 318 319 __m256i test_mm256_min_epu32(__m256i a, __m256i b) { 320 // CHECK: @llvm.x86.avx2.pminu.d 321 return _mm256_min_epu32(a, b); 322 } 323 324 int test_mm256_movemask_epi8(__m256i a) { 325 // CHECK: @llvm.x86.avx2.pmovmskb 326 return _mm256_movemask_epi8(a); 327 } 328 329 __m256i test_mm256_cvtepi8_epi16(__m128i a) { 330 // CHECK: @llvm.x86.avx2.pmovsxbw 331 return _mm256_cvtepi8_epi16(a); 332 } 333 334 __m256i test_mm256_cvtepi8_epi32(__m128i a) { 335 // CHECK: @llvm.x86.avx2.pmovsxbd 336 return _mm256_cvtepi8_epi32(a); 337 } 338 339 __m256i test_mm256_cvtepi8_epi64(__m128i a) { 340 // CHECK: @llvm.x86.avx2.pmovsxbq 341 return _mm256_cvtepi8_epi64(a); 342 } 343 344 __m256i test_mm256_cvtepi16_epi32(__m128i a) { 345 // CHECK: @llvm.x86.avx2.pmovsxwd 346 return _mm256_cvtepi16_epi32(a); 347 } 348 349 __m256i test_mm256_cvtepi16_epi64(__m128i a) { 350 // CHECK: @llvm.x86.avx2.pmovsxwq 351 return _mm256_cvtepi16_epi64(a); 352 } 353 354 __m256i test_mm256_cvtepi32_epi64(__m128i a) { 355 // CHECK: @llvm.x86.avx2.pmovsxdq 356 return _mm256_cvtepi32_epi64(a); 357 } 358 359 __m256i test_mm256_cvtepu8_epi16(__m128i a) { 360 // CHECK: @llvm.x86.avx2.pmovzxbw 361 return _mm256_cvtepu8_epi16(a); 362 } 363 364 __m256i test_mm256_cvtepu8_epi32(__m128i a) { 365 // CHECK: @llvm.x86.avx2.pmovzxbd 366 return _mm256_cvtepu8_epi32(a); 367 } 368 369 __m256i test_mm256_cvtepu8_epi64(__m128i a) { 370 // CHECK: @llvm.x86.avx2.pmovzxbq 371 return _mm256_cvtepu8_epi64(a); 372 } 373 374 __m256i test_mm256_cvtepu16_epi32(__m128i a) { 375 // CHECK: @llvm.x86.avx2.pmovzxwd 376 return _mm256_cvtepu16_epi32(a); 377 } 378 379 __m256i test_mm256_cvtepu16_epi64(__m128i a) { 380 // CHECK: @llvm.x86.avx2.pmovzxwq 381 return _mm256_cvtepu16_epi64(a); 382 } 383 384 __m256i test_mm256_cvtepu32_epi64(__m128i a) { 385 // CHECK: @llvm.x86.avx2.pmovzxdq 386 return _mm256_cvtepu32_epi64(a); 387 } 388 389 __m256i test_mm256_mul_epi32(__m256i a, __m256i b) { 390 // CHECK: @llvm.x86.avx2.pmul.dq 391 return _mm256_mul_epi32(a, b); 392 } 393 394 __m256i test_mm256_mulhrs_epi16(__m256i a, __m256i b) { 395 // CHECK: @llvm.x86.avx2.pmul.hr.sw 396 return _mm256_mulhrs_epi16(a, b); 397 } 398 399 __m256i test_mm256_mulhi_epu16(__m256i a, __m256i b) { 400 // CHECK: @llvm.x86.avx2.pmulhu.w 401 return _mm256_mulhi_epu16(a, b); 402 } 403 404 __m256i test_mm256_mulhi_epi16(__m256i a, __m256i b) { 405 // CHECK: @llvm.x86.avx2.pmulh.w 406 return _mm256_mulhi_epi16(a, b); 407 } 408 409 __m256i test_mm256_mullo_epi16(__m256i a, __m256i b) { 410 // CHECK: mul <16 x i16> 411 return _mm256_mullo_epi16(a, b); 412 } 413 414 __m256i test_mm256_mullo_epi32(__m256i a, __m256i b) { 415 // CHECK: mul <8 x i32> 416 return _mm256_mullo_epi32(a, b); 417 } 418 419 __m256i test_mm256_mul_epu32(__m256i a, __m256i b) { 420 // CHECK: @llvm.x86.avx2.pmulu.dq 421 return _mm256_mul_epu32(a, b); 422 } 423 424 __m256i test_mm256_shuffle_epi8(__m256i a, __m256i b) { 425 // CHECK: @llvm.x86.avx2.pshuf.b 426 return _mm256_shuffle_epi8(a, b); 427 } 428 429 __m256i test_mm256_shuffle_epi32(__m256i a) { 430 // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> undef, <8 x i32> <i32 3, i32 3, i32 0, i32 0, i32 7, i32 7, i32 4, i32 4> 431 return _mm256_shuffle_epi32(a, 15); 432 } 433 434 __m256i test_mm256_shufflehi_epi16(__m256i a) { 435 // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> undef, <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> 436 return _mm256_shufflehi_epi16(a, 107); 437 } 438 439 __m256i test_mm256_shufflelo_epi16(__m256i a) { 440 // CHECK: shufflevector <16 x i16> %{{.*}}, <16 x i16> undef, <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> 441 return _mm256_shufflelo_epi16(a, 83); 442 } 443 444 __m256i test_mm256_sign_epi8(__m256i a, __m256i b) { 445 // CHECK: @llvm.x86.avx2.psign.b 446 return _mm256_sign_epi8(a, b); 447 } 448 449 __m256i test_mm256_sign_epi16(__m256i a, __m256i b) { 450 // CHECK: @llvm.x86.avx2.psign.w 451 return _mm256_sign_epi16(a, b); 452 } 453 454 __m256i test_mm256_sign_epi32(__m256i a, __m256i b) { 455 // CHECK: @llvm.x86.avx2.psign.d 456 return _mm256_sign_epi32(a, b); 457 } 458 459 __m256i test_mm256_slli_si256(__m256i a) { 460 // CHECK: @llvm.x86.avx2.psll.dq 461 return _mm256_slli_si256(a, 3); 462 } 463 464 __m256i test_mm256_slli_epi16(__m256i a) { 465 // CHECK: @llvm.x86.avx2.pslli.w 466 return _mm256_slli_epi16(a, 3); 467 } 468 469 __m256i test_mm256_sll_epi16(__m256i a, __m128i b) { 470 // CHECK: @llvm.x86.avx2.psll.w 471 return _mm256_sll_epi16(a, b); 472 } 473 474 __m256i test_mm256_slli_epi32(__m256i a) { 475 // CHECK: @llvm.x86.avx2.pslli.d 476 return _mm256_slli_epi32(a, 3); 477 } 478 479 __m256i test_mm256_sll_epi32(__m256i a, __m128i b) { 480 // CHECK: @llvm.x86.avx2.psll.d 481 return _mm256_sll_epi32(a, b); 482 } 483 484 __m256i test_mm256_slli_epi64(__m256i a) { 485 // CHECK: @llvm.x86.avx2.pslli.q 486 return _mm256_slli_epi64(a, 3); 487 } 488 489 __m256i test_mm256_sll_epi64(__m256i a, __m128i b) { 490 // CHECK: @llvm.x86.avx2.psll.q 491 return _mm256_sll_epi64(a, b); 492 } 493 494 __m256i test_mm256_srai_epi16(__m256i a) { 495 // CHECK: @llvm.x86.avx2.psrai.w 496 return _mm256_srai_epi16(a, 3); 497 } 498 499 __m256i test_mm256_sra_epi16(__m256i a, __m128i b) { 500 // CHECK: @llvm.x86.avx2.psra.w 501 return _mm256_sra_epi16(a, b); 502 } 503 504 __m256i test_mm256_srai_epi32(__m256i a) { 505 // CHECK: @llvm.x86.avx2.psrai.d 506 return _mm256_srai_epi32(a, 3); 507 } 508 509 __m256i test_mm256_sra_epi32(__m256i a, __m128i b) { 510 // CHECK: @llvm.x86.avx2.psra.d 511 return _mm256_sra_epi32(a, b); 512 } 513 514 __m256i test_mm256_srli_si256(__m256i a) { 515 // CHECK: @llvm.x86.avx2.psrl.dq 516 return _mm256_srli_si256(a, 3); 517 } 518 519 __m256i test_mm256_srli_epi16(__m256i a) { 520 // CHECK: @llvm.x86.avx2.psrli.w 521 return _mm256_srli_epi16(a, 3); 522 } 523 524 __m256i test_mm256_srl_epi16(__m256i a, __m128i b) { 525 // CHECK: @llvm.x86.avx2.psrl.w 526 return _mm256_srl_epi16(a, b); 527 } 528 529 __m256i test_mm256_srli_epi32(__m256i a) { 530 // CHECK: @llvm.x86.avx2.psrli.d 531 return _mm256_srli_epi32(a, 3); 532 } 533 534 __m256i test_mm256_srl_epi32(__m256i a, __m128i b) { 535 // CHECK: @llvm.x86.avx2.psrl.d 536 return _mm256_srl_epi32(a, b); 537 } 538 539 __m256i test_mm256_srli_epi64(__m256i a) { 540 // CHECK: @llvm.x86.avx2.psrli.q 541 return _mm256_srli_epi64(a, 3); 542 } 543 544 __m256i test_mm256_srl_epi64(__m256i a, __m128i b) { 545 // CHECK: @llvm.x86.avx2.psrl.q 546 return _mm256_srl_epi64(a, b); 547 } 548 549 __m256i test_mm256_unpackhi_epi8(__m256i a, __m256i b) { 550 // 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> 551 return _mm256_unpackhi_epi8(a, b); 552 } 553 554 __m256i test_mm256_unpackhi_epi16(__m256i a, __m256i b) { 555 // 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> 556 return _mm256_unpackhi_epi16(a, b); 557 } 558 559 __m256i test_mm256_unpackhi_epi32(__m256i a, __m256i b) { 560 // 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> 561 return _mm256_unpackhi_epi32(a, b); 562 } 563 564 __m256i test_mm256_unpackhi_epi64(__m256i a, __m256i b) { 565 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 1, i32 5, i32 3, i32 7> 566 return _mm256_unpackhi_epi64(a, b); 567 } 568 569 __m256i test_mm256_unpacklo_epi8(__m256i a, __m256i b) { 570 // 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> 571 return _mm256_unpacklo_epi8(a, b); 572 } 573 574 __m256i test_mm256_unpacklo_epi16(__m256i a, __m256i b) { 575 // 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> 576 return _mm256_unpacklo_epi16(a, b); 577 } 578 579 __m256i test_mm256_unpacklo_epi32(__m256i a, __m256i b) { 580 // 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> 581 return _mm256_unpacklo_epi32(a, b); 582 } 583 584 __m256i test_mm256_unpacklo_epi64(__m256i a, __m256i b) { 585 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6> 586 return _mm256_unpacklo_epi64(a, b); 587 } 588 589 __m256i test_mm256_stream_load_si256(__m256i *a) { 590 // CHECK: @llvm.x86.avx2.movntdqa 591 return _mm256_stream_load_si256(a); 592 } 593 594 __m128 test_mm_broadcastss_ps(__m128 a) { 595 // CHECK: @llvm.x86.avx2.vbroadcast.ss.ps 596 return _mm_broadcastss_ps(a); 597 } 598 599 __m256 test_mm256_broadcastss_ps(__m128 a) { 600 // CHECK: @llvm.x86.avx2.vbroadcast.ss.ps.256 601 return _mm256_broadcastss_ps(a); 602 } 603 604 __m256d test_mm256_broadcastsd_pd(__m128d a) { 605 // check: @llvm.x86.avx2.vbroadcast.sd.pd.256 606 return _mm256_broadcastsd_pd(a); 607 } 608 609 __m256i test_mm256_broadcastsi128_si256(__m128i a) { 610 // CHECK: @llvm.x86.avx2.vbroadcasti128 611 return _mm256_broadcastsi128_si256(a); 612 } 613 614 __m128i test_mm_blend_epi32(__m128i a, __m128i b) { 615 // CHECK: @llvm.x86.avx2.pblendd.128 616 return _mm_blend_epi32(a, b, 57); 617 } 618 619 __m256i test_mm256_blend_epi32(__m256i a, __m256i b) { 620 // CHECK: @llvm.x86.avx2.pblendd.256 621 return _mm256_blend_epi32(a, b, 57); 622 } 623 624 __m256i test_mm256_broadcastb_epi8(__m128i a) { 625 // CHECK: @llvm.x86.avx2.pbroadcastb.256 626 return _mm256_broadcastb_epi8(a); 627 } 628 629 __m256i test_mm256_broadcastw_epi16(__m128i a) { 630 // CHECK: @llvm.x86.avx2.pbroadcastw.256 631 return _mm256_broadcastw_epi16(a); 632 } 633 634 __m256i test_mm256_broadcastd_epi32(__m128i a) { 635 // CHECK: @llvm.x86.avx2.pbroadcastd.256 636 return _mm256_broadcastd_epi32(a); 637 } 638 639 __m256i test_mm256_broadcastq_epi64(__m128i a) { 640 // CHECK: @llvm.x86.avx2.pbroadcastq.256 641 return _mm256_broadcastq_epi64(a); 642 } 643 644 __m128i test_mm_broadcastb_epi8(__m128i a) { 645 // CHECK: @llvm.x86.avx2.pbroadcastb.128 646 return _mm_broadcastb_epi8(a); 647 } 648 649 __m128i test_mm_broadcastw_epi16(__m128i a) { 650 // CHECK: @llvm.x86.avx2.pbroadcastw.128 651 return _mm_broadcastw_epi16(a); 652 } 653 654 __m128i test_mm_broadcastd_epi32(__m128i a) { 655 // CHECK: @llvm.x86.avx2.pbroadcastd.128 656 return _mm_broadcastd_epi32(a); 657 } 658 659 __m128i test_mm_broadcastq_epi64(__m128i a) { 660 // CHECK: @llvm.x86.avx2.pbroadcastq.128 661 return _mm_broadcastq_epi64(a); 662 } 663 664 __m256i test_mm256_permutevar8x32_epi32(__m256i a, __m256i b) { 665 // CHECK: @llvm.x86.avx2.permd 666 return _mm256_permutevar8x32_epi32(a, b); 667 } 668 669 __m256d test_mm256_permute4x64_pd(__m256d a) { 670 // CHECK: shufflevector{{.*}}<i32 1, i32 2, i32 1, i32 0> 671 return _mm256_permute4x64_pd(a, 25); 672 } 673 674 __m256 test_mm256_permutevar8x32_ps(__m256 a, __m256 b) { 675 // CHECK: @llvm.x86.avx2.permps 676 return _mm256_permutevar8x32_ps(a, b); 677 } 678 679 __m256i test_mm256_permute4x64_epi64(__m256i a) { 680 // CHECK: shufflevector{{.*}}<i32 3, i32 0, i32 2, i32 0> 681 return _mm256_permute4x64_epi64(a, 35); 682 } 683 684 __m256i test_mm256_permute2x128_si256(__m256i a, __m256i b) { 685 // CHECK: @llvm.x86.avx2.vperm2i128 686 return _mm256_permute2x128_si256(a, b, 0x31); 687 } 688 689 __m128i test_mm256_extracti128_si256(__m256i a) { 690 // CHECK: @llvm.x86.avx2.vextracti128 691 return _mm256_extracti128_si256(a, 1); 692 } 693 694 __m256i test_mm256_inserti128_si256(__m256i a, __m128i b) { 695 // CHECK: @llvm.x86.avx2.vinserti128 696 return _mm256_inserti128_si256(a, b, 1); 697 } 698 699 __m256i test_mm256_maskload_epi32(int const *a, __m256i m) { 700 // CHECK: @llvm.x86.avx2.maskload.d.256 701 return _mm256_maskload_epi32(a, m); 702 } 703 704 __m256i test_mm256_maskload_epi64(long long const *a, __m256i m) { 705 // CHECK: @llvm.x86.avx2.maskload.q.256 706 return _mm256_maskload_epi64(a, m); 707 } 708 709 __m128i test_mm_maskload_epi32(int const *a, __m128i m) { 710 // CHECK: @llvm.x86.avx2.maskload.d 711 return _mm_maskload_epi32(a, m); 712 } 713 714 __m128i test_mm_maskload_epi64(long long const *a, __m128i m) { 715 // CHECK: @llvm.x86.avx2.maskload.q 716 return _mm_maskload_epi64(a, m); 717 } 718 719 void test_mm256_maskstore_epi32(int *a, __m256i m, __m256i b) { 720 // CHECK: @llvm.x86.avx2.maskstore.d.256 721 _mm256_maskstore_epi32(a, m, b); 722 } 723 724 void test_mm256_maskstore_epi64(long long *a, __m256i m, __m256i b) { 725 // CHECK: @llvm.x86.avx2.maskstore.q.256 726 _mm256_maskstore_epi64(a, m, b); 727 } 728 729 void test_mm_maskstore_epi32(int *a, __m128i m, __m128i b) { 730 // CHECK: @llvm.x86.avx2.maskstore.d 731 _mm_maskstore_epi32(a, m, b); 732 } 733 734 void test_mm_maskstore_epi64(long long *a, __m128i m, __m128i b) { 735 // CHECK: @llvm.x86.avx2.maskstore.q 736 _mm_maskstore_epi64(a, m, b); 737 } 738 739 __m256i test_mm256_sllv_epi32(__m256i a, __m256i b) { 740 // CHECK: @llvm.x86.avx2.psllv.d.256 741 return _mm256_sllv_epi32(a, b); 742 } 743 744 __m128i test_mm_sllv_epi32(__m128i a, __m128i b) { 745 // CHECK: @llvm.x86.avx2.psllv.d 746 return _mm_sllv_epi32(a, b); 747 } 748 749 __m256i test_mm256_sllv_epi64(__m256i a, __m256i b) { 750 // CHECK: @llvm.x86.avx2.psllv.q.256 751 return _mm256_sllv_epi64(a, b); 752 } 753 754 __m128i test_mm_sllv_epi64(__m128i a, __m128i b) { 755 // CHECK: @llvm.x86.avx2.psllv.q 756 return _mm_sllv_epi64(a, b); 757 } 758 759 __m256i test_mm256_srav_epi32(__m256i a, __m256i b) { 760 // CHECK: @llvm.x86.avx2.psrav.d.256 761 return _mm256_srav_epi32(a, b); 762 } 763 764 __m128i test_mm_srav_epi32(__m128i a, __m128i b) { 765 // CHECK: @llvm.x86.avx2.psrav.d 766 return _mm_srav_epi32(a, b); 767 } 768 769 __m256i test_mm256_srlv_epi32(__m256i a, __m256i b) { 770 // CHECK: @llvm.x86.avx2.psrlv.d.256 771 return _mm256_srlv_epi32(a, b); 772 } 773 774 __m128i test_mm_srlv_epi32(__m128i a, __m128i b) { 775 // CHECK: @llvm.x86.avx2.psrlv.d 776 return _mm_srlv_epi32(a, b); 777 } 778 779 __m256i test_mm256_srlv_epi64(__m256i a, __m256i b) { 780 // CHECK: @llvm.x86.avx2.psrlv.q.256 781 return _mm256_srlv_epi64(a, b); 782 } 783 784 __m128i test_mm_srlv_epi64(__m128i a, __m128i b) { 785 // CHECK: @llvm.x86.avx2.psrlv.q 786 return _mm_srlv_epi64(a, b); 787 } 788 789 __m128d test_mm_mask_i32gather_pd(__m128d a, double const *b, __m128i c, 790 __m128d d) { 791 // CHECK: @llvm.x86.avx2.gather.d.pd 792 return _mm_mask_i32gather_pd(a, b, c, d, 2); 793 } 794 795 __m256d test_mm256_mask_i32gather_pd(__m256d a, double const *b, __m128i c, 796 __m256d d) { 797 // CHECK: @llvm.x86.avx2.gather.d.pd.256 798 return _mm256_mask_i32gather_pd(a, b, c, d, 2); 799 } 800 __m128d test_mm_mask_i64gather_pd(__m128d a, double const *b, __m128i c, 801 __m128d d) { 802 // CHECK: @llvm.x86.avx2.gather.q.pd 803 return _mm_mask_i64gather_pd(a, b, c, d, 2); 804 } 805 __m256d test_mm256_mask_i64gather_pd(__m256d a, double const *b, __m256i c, 806 __m256d d) { 807 // CHECK: @llvm.x86.avx2.gather.q.pd.256 808 return _mm256_mask_i64gather_pd(a, b, c, d, 2); 809 } 810 811 __m128 test_mm_mask_i32gather_ps(__m128 a, float const *b, __m128i c, 812 __m128 d) { 813 // CHECK: @llvm.x86.avx2.gather.d.ps 814 return _mm_mask_i32gather_ps(a, b, c, d, 2); 815 } 816 __m256 test_mm256_mask_i32gather_ps(__m256 a, float const *b, __m256i c, 817 __m256 d) { 818 // CHECK: @llvm.x86.avx2.gather.d.ps.256 819 return _mm256_mask_i32gather_ps(a, b, c, d, 2); 820 } 821 __m128 test_mm_mask_i64gather_ps(__m128 a, float const *b, __m128i c, 822 __m128 d) { 823 // CHECK: @llvm.x86.avx2.gather.q.ps 824 return _mm_mask_i64gather_ps(a, b, c, d, 2); 825 } 826 __m128 test_mm256_mask_i64gather_ps(__m128 a, float const *b, __m256i c, 827 __m128 d) { 828 // CHECK: @llvm.x86.avx2.gather.q.ps.256 829 return _mm256_mask_i64gather_ps(a, b, c, d, 2); 830 } 831 832 __m128i test_mm_mask_i32gather_epi32(__m128i a, int const *b, __m128i c, 833 __m128i d) { 834 // CHECK: @llvm.x86.avx2.gather.d.d 835 return _mm_mask_i32gather_epi32(a, b, c, d, 2); 836 } 837 __m256i test_mm256_mask_i32gather_epi32(__m256i a, int const *b, __m256i c, 838 __m256i d) { 839 // CHECK: @llvm.x86.avx2.gather.d.d.256 840 return _mm256_mask_i32gather_epi32(a, b, c, d, 2); 841 } 842 __m128i test_mm_mask_i64gather_epi32(__m128i a, int const *b, __m128i c, 843 __m128i d) { 844 // CHECK: @llvm.x86.avx2.gather.q.d 845 return _mm_mask_i64gather_epi32(a, b, c, d, 2); 846 } 847 __m128i test_mm256_mask_i64gather_epi32(__m128i a, int const *b, __m256i c, 848 __m128i d) { 849 // CHECK: @llvm.x86.avx2.gather.q.d.256 850 return _mm256_mask_i64gather_epi32(a, b, c, d, 2); 851 } 852 853 __m128i test_mm_mask_i32gather_epi64(__m128i a, long long const *b, __m128i c, 854 __m128i d) { 855 // CHECK: @llvm.x86.avx2.gather.d.q 856 return _mm_mask_i32gather_epi64(a, b, c, d, 2); 857 } 858 __m256i test_mm256_mask_i32gather_epi64(__m256i a, long long const *b, __m128i c, 859 __m256i d) { 860 // CHECK: @llvm.x86.avx2.gather.d.q.256 861 return _mm256_mask_i32gather_epi64(a, b, c, d, 2); 862 } 863 __m128i test_mm_mask_i64gather_epi64(__m128i a, long long const *b, __m128i c, 864 __m128i d) { 865 // CHECK: @llvm.x86.avx2.gather.q.q 866 return _mm_mask_i64gather_epi64(a, b, c, d, 2); 867 } 868 __m256i test_mm256_mask_i64gather_epi64(__m256i a, long long const *b, __m256i c, 869 __m256i d) { 870 // CHECK: @llvm.x86.avx2.gather.q.q.256 871 return _mm256_mask_i64gather_epi64(a, b, c, d, 2); 872 } 873 874 __m128d test_mm_i32gather_pd(double const *b, __m128i c) { 875 // CHECK: @llvm.x86.avx2.gather.d.pd 876 return _mm_i32gather_pd(b, c, 2); 877 } 878 __m256d test_mm256_i32gather_pd(double const *b, __m128i c) { 879 // CHECK: @llvm.x86.avx2.gather.d.pd.256 880 return _mm256_i32gather_pd(b, c, 2); 881 } 882 __m128d test_mm_i64gather_pd(double const *b, __m128i c) { 883 // CHECK: @llvm.x86.avx2.gather.q.pd 884 return _mm_i64gather_pd(b, c, 2); 885 } 886 __m256d test_mm256_i64gather_pd(double const *b, __m256i c) { 887 // CHECK: @llvm.x86.avx2.gather.q.pd.256 888 return _mm256_i64gather_pd(b, c, 2); 889 } 890 __m128 test_mm_i32gather_ps(float const *b, __m128i c) { 891 // CHECK: @llvm.x86.avx2.gather.d.ps 892 return _mm_i32gather_ps(b, c, 2); 893 } 894 __m256 test_mm256_i32gather_ps(float const *b, __m256i c) { 895 // CHECK: @llvm.x86.avx2.gather.d.ps.256 896 return _mm256_i32gather_ps(b, c, 2); 897 } 898 __m128 test_mm_i64gather_ps(float const *b, __m128i c) { 899 // CHECK: @llvm.x86.avx2.gather.q.ps 900 return _mm_i64gather_ps(b, c, 2); 901 } 902 __m128 test_mm256_i64gather_ps(float const *b, __m256i c) { 903 // CHECK: @llvm.x86.avx2.gather.q.ps.256 904 return _mm256_i64gather_ps(b, c, 2); 905 } 906 907 __m128i test_mm_i32gather_epi32(int const *b, __m128i c) { 908 // CHECK: @llvm.x86.avx2.gather.d.d 909 return _mm_i32gather_epi32(b, c, 2); 910 } 911 __m256i test_mm256_i32gather_epi32(int const *b, __m256i c) { 912 // CHECK: @llvm.x86.avx2.gather.d.d.256 913 return _mm256_i32gather_epi32(b, c, 2); 914 } 915 __m128i test_mm_i64gather_epi32(int const *b, __m128i c) { 916 // CHECK: @llvm.x86.avx2.gather.q.d 917 return _mm_i64gather_epi32(b, c, 2); 918 } 919 __m128i test_mm256_i64gather_epi32(int const *b, __m256i c) { 920 // CHECK: @llvm.x86.avx2.gather.q.d.256 921 return _mm256_i64gather_epi32(b, c, 2); 922 } 923 __m128i test_mm_i32gather_epi64(long long const *b, __m128i c) { 924 // CHECK: @llvm.x86.avx2.gather.d.q 925 return _mm_i32gather_epi64(b, c, 2); 926 } 927 __m256i test_mm256_i32gather_epi64(long long const *b, __m128i c) { 928 // CHECK: @llvm.x86.avx2.gather.d.q.256 929 return _mm256_i32gather_epi64(b, c, 2); 930 } 931 __m128i test_mm_i64gather_epi64(long long const *b, __m128i c) { 932 // CHECK: @llvm.x86.avx2.gather.q.q 933 return _mm_i64gather_epi64(b, c, 2); 934 } 935 __m256i test_mm256_i64gather_epi64(long long const *b, __m256i c) { 936 // CHECK: @llvm.x86.avx2.gather.q.q.256 937 return _mm256_i64gather_epi64(b, c, 2); 938 } 939