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