1 // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +avx -emit-llvm -o - -Werror | FileCheck %s 2 // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +avx -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 <x86intrin.h> 8 9 // NOTE: This should match the tests in llvm/test/CodeGen/X86/sse-intrinsics-fast-isel.ll 10 11 __m256d test_mm256_add_pd(__m256d A, __m256d B) { 12 // CHECK-LABEL: test_mm256_add_pd 13 // CHECK: fadd <4 x double> 14 return _mm256_add_pd(A, B); 15 } 16 17 __m256 test_mm256_add_ps(__m256 A, __m256 B) { 18 // CHECK-LABEL: test_mm256_add_ps 19 // CHECK: fadd <8 x float> 20 return _mm256_add_ps(A, B); 21 } 22 23 __m256d test_mm256_addsub_pd(__m256d A, __m256d B) { 24 // CHECK-LABEL: test_mm256_addsub_pd 25 // CHECK: call <4 x double> @llvm.x86.avx.addsub.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}) 26 return _mm256_addsub_pd(A, B); 27 } 28 29 __m256 test_mm256_addsub_ps(__m256 A, __m256 B) { 30 // CHECK-LABEL: test_mm256_addsub_ps 31 // CHECK: call <8 x float> @llvm.x86.avx.addsub.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}) 32 return _mm256_addsub_ps(A, B); 33 } 34 35 __m256d test_mm256_and_pd(__m256d A, __m256d B) { 36 // CHECK-LABEL: test_mm256_and_pd 37 // CHECK: and <4 x i64> 38 return _mm256_and_pd(A, B); 39 } 40 41 __m256 test_mm256_and_ps(__m256 A, __m256 B) { 42 // CHECK-LABEL: test_mm256_and_ps 43 // CHECK: and <8 x i32> 44 return _mm256_and_ps(A, B); 45 } 46 47 __m256d test_mm256_andnot_pd(__m256d A, __m256d B) { 48 // CHECK-LABEL: test_mm256_andnot_pd 49 // CHECK: xor <4 x i64> %{{.*}}, <i64 -1, i64 -1, i64 -1, i64 -1> 50 // CHECK: and <4 x i64> 51 return _mm256_andnot_pd(A, B); 52 } 53 54 __m256 test_mm256_andnot_ps(__m256 A, __m256 B) { 55 // CHECK-LABEL: test_mm256_andnot_ps 56 // CHECK: xor <8 x i32> %{{.*}}, <i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1> 57 // CHECK: and <8 x i32> 58 return _mm256_andnot_ps(A, B); 59 } 60 61 __m256d test_mm256_blend_pd(__m256d A, __m256d B) { 62 // CHECK-LABEL: test_mm256_blend_pd 63 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 4, i32 1, i32 6, i32 3> 64 return _mm256_blend_pd(A, B, 0x35); 65 } 66 67 __m256 test_mm256_blend_ps(__m256 A, __m256 B) { 68 // CHECK-LABEL: test_mm256_blend_ps 69 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 8, i32 1, i32 10, i32 3, i32 12, i32 13, i32 6, i32 7> 70 return _mm256_blend_ps(A, B, 0x35); 71 } 72 73 __m256d test_mm256_blendv_pd(__m256d V1, __m256d V2, __m256d V3) { 74 // CHECK-LABEL: test_mm256_blendv_pd 75 // CHECK: call <4 x double> @llvm.x86.avx.blendv.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) 76 return _mm256_blendv_pd(V1, V2, V3); 77 } 78 79 __m256 test_mm256_blendv_ps(__m256 V1, __m256 V2, __m256 V3) { 80 // CHECK-LABEL: test_mm256_blendv_ps 81 // CHECK: call <8 x float> @llvm.x86.avx.blendv.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}) 82 return _mm256_blendv_ps(V1, V2, V3); 83 } 84 85 __m256d test_mm256_broadcast_pd(__m128d* A) { 86 // CHECK-LABEL: test_mm256_broadcast_pd 87 // CHECK: call <4 x double> @llvm.x86.avx.vbroadcastf128.pd.256(i8* %{{.*}}) 88 return _mm256_broadcast_pd(A); 89 } 90 91 __m256 test_mm256_broadcast_ps(__m128* A) { 92 // CHECK-LABEL: test_mm256_broadcast_ps 93 // CHECK: call <8 x float> @llvm.x86.avx.vbroadcastf128.ps.256(i8* %{{.*}}) 94 return _mm256_broadcast_ps(A); 95 } 96 97 __m256d test_mm256_broadcast_sd(double* A) { 98 // CHECK-LABEL: test_mm256_broadcast_sd 99 // CHECK: load double, double* %{{.*}} 100 // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0 101 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1 102 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2 103 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3 104 return _mm256_broadcast_sd(A); 105 } 106 107 __m128d test_mm_broadcast_ss(float* A) { 108 // CHECK-LABEL: test_mm_broadcast_ss 109 // CHECK: load float, float* %{{.*}} 110 // CHECK: insertelement <4 x float> undef, float %{{.*}}, i32 0 111 // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 1 112 // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 2 113 // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 3 114 return _mm_broadcast_ss(A); 115 } 116 117 __m256d test_mm256_broadcast_ss(float* A) { 118 // CHECK-LABEL: test_mm256_broadcast_ss 119 // CHECK: load float, float* %{{.*}} 120 // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0 121 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1 122 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2 123 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3 124 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4 125 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5 126 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6 127 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7 128 return _mm256_broadcast_ss(A); 129 } 130 131 __m256 test_mm256_castpd_ps(__m256d A) { 132 // CHECK-LABEL: test_mm256_castpd_ps 133 // CHECK: bitcast <4 x double> %{{.*}} to <8 x float> 134 return _mm256_castpd_ps(A); 135 } 136 137 __m256i test_mm256_castpd_si256(__m256d A) { 138 // CHECK-LABEL: test_mm256_castpd_si256 139 // CHECK: bitcast <4 x double> %{{.*}} to <4 x i64> 140 return _mm256_castpd_si256(A); 141 } 142 143 __m256d test_mm256_castpd128_pd256(__m128d A) { 144 // CHECK-LABEL: test_mm256_castpd128_pd256 145 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> 146 return _mm256_castpd128_pd256(A); 147 } 148 149 __m128d test_mm256_castpd256_pd128(__m256d A) { 150 // CHECK-LABEL: test_mm256_castpd256_pd128 151 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <2 x i32> <i32 0, i32 1> 152 return _mm256_castpd256_pd128(A); 153 } 154 155 __m256d test_mm256_castps_pd(__m256 A) { 156 // CHECK-LABEL: test_mm256_castps_pd 157 // CHECK: bitcast <8 x float> %{{.*}} to <4 x double> 158 return _mm256_castps_pd(A); 159 } 160 161 __m256i test_mm256_castps_si256(__m256 A) { 162 // CHECK-LABEL: test_mm256_castps_si256 163 // CHECK: bitcast <8 x float> %{{.*}} to <4 x i64> 164 return _mm256_castps_si256(A); 165 } 166 167 __m256 test_mm256_castps128_ps256(__m128 A) { 168 // CHECK-LABEL: test_mm256_castps128_ps256 169 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef> 170 return _mm256_castps128_ps256(A); 171 } 172 173 __m128 test_mm256_castps256_ps128(__m256 A) { 174 // CHECK-LABEL: test_mm256_castps256_ps128 175 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 176 return _mm256_castps256_ps128(A); 177 } 178 179 __m256i test_mm256_castsi128_si256(__m128i A) { 180 // CHECK-LABEL: test_mm256_castsi128_si256 181 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> 182 return _mm256_castsi128_si256(A); 183 } 184 185 __m256d test_mm256_castsi256_pd(__m256i A) { 186 // CHECK-LABEL: test_mm256_castsi256_pd 187 // CHECK: bitcast <4 x i64> %{{.*}} to <4 x double> 188 return _mm256_castsi256_pd(A); 189 } 190 191 __m256 test_mm256_castsi256_ps(__m256i A) { 192 // CHECK-LABEL: test_mm256_castsi256_ps 193 // CHECK: bitcast <4 x i64> %{{.*}} to <8 x float> 194 return _mm256_castsi256_ps(A); 195 } 196 197 __m128i test_mm256_castsi256_si128(__m256i A) { 198 // CHECK-LABEL: test_mm256_castsi256_si128 199 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <2 x i32> <i32 0, i32 1> 200 return _mm256_castsi256_si128(A); 201 } 202 203 __m256d test_mm256_ceil_pd(__m256d x) { 204 // CHECK-LABEL: test_mm256_ceil_pd 205 // CHECK: call <4 x double> @llvm.x86.avx.round.pd.256(<4 x double> %{{.*}}, i32 2) 206 return _mm256_ceil_pd(x); 207 } 208 209 __m256 test_mm_ceil_ps(__m256 x) { 210 // CHECK-LABEL: test_mm_ceil_ps 211 // CHECK: call <8 x float> @llvm.x86.avx.round.ps.256(<8 x float> %{{.*}}, i32 2) 212 return _mm256_ceil_ps(x); 213 } 214 215 __m128d test_mm_cmp_pd(__m128d A, __m128d B) { 216 // CHECK-LABEL: test_mm_cmp_pd 217 // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 13) 218 return _mm_cmp_pd(A, B, _CMP_GE_OS); 219 } 220 221 __m256d test_mm256_cmp_pd(__m256d A, __m256d B) { 222 // CHECK-LABEL: test_mm256_cmp_pd 223 // CHECK: call <4 x double> @llvm.x86.avx.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i8 13) 224 return _mm256_cmp_pd(A, B, _CMP_GE_OS); 225 } 226 227 __m128 test_mm_cmp_ps(__m128 A, __m128 B) { 228 // CHECK-LABEL: test_mm_cmp_ps 229 // CHECK: call <4 x float> @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 13) 230 return _mm_cmp_ps(A, B, _CMP_GE_OS); 231 } 232 233 __m256 test_mm256_cmp_ps(__m256d A, __m256d B) { 234 // CHECK-LABEL: test_mm256_cmp_ps 235 // CHECK: call <8 x float> @llvm.x86.avx.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i8 13) 236 return _mm256_cmp_ps(A, B, _CMP_GE_OS); 237 } 238 239 __m128d test_mm_cmp_sd(__m128d A, __m128d B) { 240 // CHECK-LABEL: test_mm_cmp_sd 241 // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 13) 242 return _mm_cmp_sd(A, B, _CMP_GE_OS); 243 } 244 245 __m128 test_mm_cmp_ss(__m128 A, __m128 B) { 246 // CHECK-LABEL: test_mm_cmp_ss 247 // CHECK: call <4 x float> @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 13) 248 return _mm_cmp_ss(A, B, _CMP_GE_OS); 249 } 250 251 __m256d test_mm256_cvtepi32_pd(__m128i A) { 252 // CHECK-LABEL: test_mm256_cvtepi32_pd 253 // CHECK: sitofp <4 x i32> %{{.*}} to <4 x double> 254 return _mm256_cvtepi32_pd(A); 255 } 256 257 __m256 test_mm256_cvtepi32_ps(__m256i A) { 258 // CHECK-LABEL: test_mm256_cvtepi32_ps 259 // CHECK: call <8 x float> @llvm.x86.avx.cvtdq2.ps.256(<8 x i32> %{{.*}}) 260 return _mm256_cvtepi32_ps(A); 261 } 262 263 __m128i test_mm256_cvtpd_epi32(__m256d A) { 264 // CHECK-LABEL: test_mm256_cvtpd_epi32 265 // CHECK: call <4 x i32> @llvm.x86.avx.cvt.pd2dq.256(<4 x double> %{{.*}}) 266 return _mm256_cvtpd_epi32(A); 267 } 268 269 __m128 test_mm256_cvtpd_ps(__m256d A) { 270 // CHECK-LABEL: test_mm256_cvtpd_ps 271 // CHECK: call <4 x float> @llvm.x86.avx.cvt.pd2.ps.256(<4 x double> %{{.*}}) 272 return _mm256_cvtpd_ps(A); 273 } 274 275 __m256i test_mm256_cvtps_epi32(__m256 A) { 276 // CHECK-LABEL: test_mm256_cvtps_epi32 277 // CHECK: call <8 x i32> @llvm.x86.avx.cvt.ps2dq.256(<8 x float> %{{.*}}) 278 return _mm256_cvtps_epi32(A); 279 } 280 281 __m256d test_mm256_cvtps_pd(__m128 A) { 282 // CHECK-LABEL: test_mm256_cvtps_pd 283 // CHECK: fpext <4 x float> %{{.*}} to <4 x double> 284 return _mm256_cvtps_pd(A); 285 } 286 287 __m128i test_mm256_cvttpd_epi32(__m256d A) { 288 // CHECK-LABEL: test_mm256_cvttpd_epi32 289 // CHECK: fptosi <4 x double> %{{.*}} to <4 x i32> 290 return _mm256_cvttpd_epi32(A); 291 } 292 293 __m256i test_mm256_cvttps_epi32(__m256 A) { 294 // CHECK-LABEL: test_mm256_cvttps_epi32 295 // CHECK: fptosi <8 x float> %{{.*}} to <8 x i32> 296 return _mm256_cvttps_epi32(A); 297 } 298 299 __m256d test_mm256_div_pd(__m256d A, __m256d B) { 300 // CHECK-LABEL: test_mm256_div_pd 301 // CHECK: fdiv <4 x double> 302 return _mm256_div_pd(A, B); 303 } 304 305 __m256 test_mm256_div_ps(__m256 A, __m256 B) { 306 // CHECK-LABEL: test_mm256_div_ps 307 // CHECK: fdiv <8 x float> 308 return _mm256_div_ps(A, B); 309 } 310 311 __m256 test_mm256_dp_ps(__m256 A, __m256 B) { 312 // CHECK-LABEL: test_mm256_dp_ps 313 // CHECK: call <8 x float> @llvm.x86.avx.dp.ps.256(<8 x float> {{.*}}, <8 x float> {{.*}}, i8 7) 314 return _mm256_dp_ps(A, B, 7); 315 } 316 317 int test_mm256_extract_epi8(__m256i A) { 318 // CHECK-LABEL: test_mm256_extract_epi8 319 // CHECK: and i32 %{{.*}}, 31 320 // CHECK: extractelement <32 x i8> %{{.*}}, i32 %{{.*}} 321 // CHECK: zext i8 %{{.*}} to i32 322 return _mm256_extract_epi8(A, 32); 323 } 324 325 int test_mm256_extract_epi16(__m256i A) { 326 // CHECK-LABEL: test_mm256_extract_epi16 327 // CHECK: and i32 %{{.*}}, 15 328 // CHECK: extractelement <16 x i16> %{{.*}}, i32 %{{.*}} 329 // CHECK: zext i16 %{{.*}} to i32 330 return _mm256_extract_epi16(A, 16); 331 } 332 333 int test_mm256_extract_epi32(__m256i A) { 334 // CHECK-LABEL: test_mm256_extract_epi32 335 // CHECK: and i32 %{{.*}}, 7 336 // CHECK: extractelement <8 x i32> %{{.*}}, i32 %{{.*}} 337 return _mm256_extract_epi32(A, 8); 338 } 339 340 long long test_mm256_extract_epi64(__m256i A) { 341 // CHECK-LABEL: test_mm256_extract_epi64 342 // CHECK: and i32 %{{.*}}, 3 343 // CHECK: extractelement <4 x i64> %{{.*}}, i32 %{{.*}} 344 return _mm256_extract_epi64(A, 5); 345 } 346 347 __m128d test_mm256_extractf128_pd(__m256d A) { 348 // CHECK-LABEL: test_mm256_extractf128_pd 349 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> undef, <2 x i32> <i32 2, i32 3> 350 return _mm256_extractf128_pd(A, 1); 351 } 352 353 __m128 test_mm256_extractf128_ps(__m256 A) { 354 // CHECK-LABEL: test_mm256_extractf128_ps 355 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7> 356 return _mm256_extractf128_ps(A, 1); 357 } 358 359 __m128i test_mm256_extractf128_si256(__m256i A) { 360 // CHECK-LABEL: test_mm256_extractf128_si256 361 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> undef, <2 x i32> <i32 2, i32 3> 362 return _mm256_extractf128_si256(A, 1); 363 } 364 365 __m256d test_mm256_floor_pd(__m256d x) { 366 // CHECK-LABEL: test_mm256_floor_pd 367 // CHECK: call <4 x double> @llvm.x86.avx.round.pd.256(<4 x double> %{{.*}}, i32 1) 368 return _mm256_floor_pd(x); 369 } 370 371 __m256 test_mm_floor_ps(__m256 x) { 372 // CHECK-LABEL: test_mm_floor_ps 373 // CHECK: call <8 x float> @llvm.x86.avx.round.ps.256(<8 x float> %{{.*}}, i32 1) 374 return _mm256_floor_ps(x); 375 } 376 377 __m256d test_mm256_hadd_pd(__m256d A, __m256d B) { 378 // CHECK-LABEL: test_mm256_hadd_pd 379 // CHECK: call <4 x double> @llvm.x86.avx.hadd.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}) 380 return _mm256_hadd_pd(A, B); 381 } 382 383 __m256 test_mm256_hadd_ps(__m256 A, __m256 B) { 384 // CHECK-LABEL: test_mm256_hadd_ps 385 // CHECK: call <8 x float> @llvm.x86.avx.hadd.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}) 386 return _mm256_hadd_ps(A, B); 387 } 388 389 __m256d test_mm256_hsub_pd(__m256d A, __m256d B) { 390 // CHECK-LABEL: test_mm256_hsub_pd 391 // CHECK: call <4 x double> @llvm.x86.avx.hsub.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}) 392 return _mm256_hsub_pd(A, B); 393 } 394 395 __m256 test_mm256_hsub_ps(__m256 A, __m256 B) { 396 // CHECK-LABEL: test_mm256_hsub_ps 397 // CHECK: call <8 x float> @llvm.x86.avx.hsub.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}) 398 return _mm256_hsub_ps(A, B); 399 } 400 401 __m256i test_mm256_insert_epi8(__m256i x, char b) { 402 // CHECK-LABEL: test_mm256_insert_epi8 403 // CHECK: and i32 %{{.*}}, 31 404 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 %{{.*}} 405 return _mm256_insert_epi8(x, b, 17); 406 } 407 408 __m256i test_mm256_insert_epi16(__m256i x, int b) { 409 // CHECK-LABEL: test_mm256_insert_epi16 410 // CHECK: and i32 %{{.*}}, 15 411 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 %{{.*}} 412 return _mm256_insert_epi16(x, b, 4); 413 } 414 415 __m256i test_mm256_insert_epi32(__m256i x, int b) { 416 // CHECK-LABEL: test_mm256_insert_epi32 417 // CHECK: and i32 %{{.*}}, 7 418 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 %{{.*}} 419 return _mm256_insert_epi32(x, b, 5); 420 } 421 422 __m256i test_mm256_insert_epi64(__m256i x, long long b) { 423 // CHECK-LABEL: test_mm256_insert_epi64 424 // CHECK: and i32 %{{.*}}, 3 425 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 %{{.*}} 426 return _mm256_insert_epi64(x, b, 2); 427 } 428 429 __m256d test_mm256_insertf128_pd(__m256d A, __m128d B) { 430 // CHECK-LABEL: test_mm256_insertf128_pd 431 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> 432 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 4, i32 5, i32 2, i32 3> 433 return _mm256_insertf128_pd(A, B, 0); 434 } 435 436 __m256 test_mm256_insertf128_ps(__m256 A, __m128 B) { 437 // CHECK-LABEL: test_mm256_insertf128_ps 438 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef> 439 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11> 440 return _mm256_insertf128_ps(A, B, 1); 441 } 442 443 __m256i test_mm256_insertf128_si256(__m256i A, __m128i B) { 444 // CHECK-LABEL: test_mm256_insertf128_si256 445 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> 446 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 4, i32 5, i32 2, i32 3> 447 return _mm256_insertf128_si256(A, B, 0); 448 } 449 450 __m256i test_mm256_lddqu_si256(__m256i* A) { 451 // CHECK-LABEL: test_mm256_lddqu_si256 452 // CHECK: call <32 x i8> @llvm.x86.avx.ldu.dq.256(i8* %{{.*}}) 453 return _mm256_lddqu_si256(A); 454 } 455 456 __m256d test_mm256_load_pd(double* A) { 457 // CHECK-LABEL: test_mm256_load_pd 458 // CHECK: load <4 x double>, <4 x double>* %{{.*}}, align 32 459 return _mm256_load_pd(A); 460 } 461 462 __m256 test_mm256_load_ps(float* A) { 463 // CHECK-LABEL: test_mm256_load_ps 464 // CHECK: load <8 x float>, <8 x float>* %{{.*}}, align 32 465 return _mm256_load_ps(A); 466 } 467 468 __m256i test_mm256_load_si256(__m256i* A) { 469 // CHECK-LABEL: test_mm256_load_si256 470 // CHECK: load <4 x i64>, <4 x i64>* %{{.*}}, align 32 471 return _mm256_load_si256(A); 472 } 473 474 __m256d test_mm256_loadu_pd(double* A) { 475 // CHECK-LABEL: test_mm256_loadu_pd 476 // CHECK: load <4 x double>, <4 x double>* %{{.*}}, align 1{{$}} 477 return _mm256_loadu_pd(A); 478 } 479 480 __m256 test_mm256_loadu_ps(float* A) { 481 // CHECK-LABEL: test_mm256_loadu_ps 482 // CHECK: load <8 x float>, <8 x float>* %{{.*}}, align 1{{$}} 483 return _mm256_loadu_ps(A); 484 } 485 486 __m256i test_mm256_loadu_si256(__m256i* A) { 487 // CHECK-LABEL: test_mm256_loadu_si256 488 // CHECK: load <4 x i64>, <4 x i64>* %{{.+}}, align 1{{$}} 489 return _mm256_loadu_si256(A); 490 } 491 492 __m256 test_mm256_loadu2_m128(float* A, float* B) { 493 // CHECK-LABEL: test_mm256_loadu2_m128 494 // CHECK: load <4 x float>, <4 x float>* %{{.*}}, align 1{{$}} 495 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef> 496 // CHECK: load <4 x float>, <4 x float>* %{{.*}}, align 1{{$}} 497 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef> 498 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11> 499 return _mm256_loadu2_m128(A, B); 500 } 501 502 __m256d test_mm256_loadu2_m128d(double* A, double* B) { 503 // CHECK-LABEL: test_mm256_loadu2_m128d 504 // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 1{{$}} 505 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> 506 // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 1{{$}} 507 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> 508 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 4, i32 5> 509 return _mm256_loadu2_m128d(A, B); 510 } 511 512 __m256i test_mm256_loadu2_m128i(__m128i* A, __m128i* B) { 513 // CHECK-LABEL: test_mm256_loadu2_m128i 514 // CHECK: load <2 x i64>, <2 x i64>* %{{.*}}, align 1{{$}} 515 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> 516 // CHECK: load <2 x i64>, <2 x i64>* %{{.*}}, align 1{{$}} 517 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> 518 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 4, i32 5> 519 return _mm256_loadu2_m128i(A, B); 520 } 521 522 __m128d test_mm_maskload_pd(double* A, __m128i B) { 523 // CHECK-LABEL: test_mm_maskload_pd 524 // CHECK: call <2 x double> @llvm.x86.avx.maskload.pd(i8* %{{.*}}, <2 x i64> %{{.*}}) 525 return _mm_maskload_pd(A, B); 526 } 527 528 __m256d test_mm256_maskload_pd(double* A, __m256i B) { 529 // CHECK-LABEL: test_mm256_maskload_pd 530 // CHECK: call <4 x double> @llvm.x86.avx.maskload.pd.256(i8* %{{.*}}, <4 x i64> %{{.*}}) 531 return _mm256_maskload_pd(A, B); 532 } 533 534 __m128 test_mm_maskload_ps(float* A, __m128i B) { 535 // CHECK-LABEL: test_mm_maskload_ps 536 // CHECK: call <4 x float> @llvm.x86.avx.maskload.ps(i8* %{{.*}}, <4 x i32> %{{.*}}) 537 return _mm_maskload_ps(A, B); 538 } 539 540 __m256d test_mm256_maskload_ps(float* A, __m256i B) { 541 // CHECK-LABEL: test_mm256_maskload_ps 542 // CHECK: call <8 x float> @llvm.x86.avx.maskload.ps.256(i8* %{{.*}}, <8 x i32> %{{.*}}) 543 return _mm256_maskload_ps(A, B); 544 } 545 546 void test_mm_maskstore_pd(double* A, __m128i B, __m128d C) { 547 // CHECK-LABEL: test_mm_maskstore_pd 548 // CHECK: call void @llvm.x86.avx.maskstore.pd(i8* %{{.*}}, <2 x i64> %{{.*}}, <2 x double> %{{.*}}) 549 _mm_maskstore_pd(A, B, C); 550 } 551 552 void test_mm256_maskstore_pd(double* A, __m256i B, __m256d C) { 553 // CHECK-LABEL: test_mm256_maskstore_pd 554 // CHECK: call void @llvm.x86.avx.maskstore.pd.256(i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x double> %{{.*}}) 555 _mm256_maskstore_pd(A, B, C); 556 } 557 558 void test_mm_maskstore_ps(float* A, __m128i B, __m128 C) { 559 // CHECK-LABEL: test_mm_maskstore_ps 560 // CHECK: call void @llvm.x86.avx.maskstore.ps(i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x float> %{{.*}}) 561 _mm_maskstore_ps(A, B, C); 562 } 563 564 void test_mm256_maskstore_ps(float* A, __m256i B, __m256 C) { 565 // CHECK-LABEL: test_mm256_maskstore_ps 566 // CHECK: call void @llvm.x86.avx.maskstore.ps.256(i8* %{{.*}}, <8 x i32> %{{.*}}, <8 x float> %{{.*}}) 567 _mm256_maskstore_ps(A, B, C); 568 } 569 570 __m256d test_mm256_max_pd(__m256d A, __m256d B) { 571 // CHECK-LABEL: test_mm256_max_pd 572 // CHECK: call <4 x double> @llvm.x86.avx.max.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}) 573 return _mm256_max_pd(A, B); 574 } 575 576 __m256 test_mm256_max_ps(__m256 A, __m256 B) { 577 // CHECK-LABEL: test_mm256_max_ps 578 // CHECK: call <8 x float> @llvm.x86.avx.max.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}) 579 return _mm256_max_ps(A, B); 580 } 581 582 __m256d test_mm256_min_pd(__m256d A, __m256d B) { 583 // CHECK-LABEL: test_mm256_min_pd 584 // CHECK: call <4 x double> @llvm.x86.avx.min.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}) 585 return _mm256_min_pd(A, B); 586 } 587 588 __m256 test_mm256_min_ps(__m256 A, __m256 B) { 589 // CHECK-LABEL: test_mm256_min_ps 590 // CHECK: call <8 x float> @llvm.x86.avx.min.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}) 591 return _mm256_min_ps(A, B); 592 } 593 594 __m256d test_mm256_movedup_pd(__m256d A) { 595 // CHECK-LABEL: test_mm256_movedup_pd 596 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2> 597 return _mm256_movedup_pd(A); 598 } 599 600 __m256 test_mm256_movehdup_ps(__m256 A) { 601 // CHECK-LABEL: test_mm256_movehdup_ps 602 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 1, i32 1, i32 3, i32 3, i32 5, i32 5, i32 7, i32 7> 603 return _mm256_movehdup_ps(A); 604 } 605 606 __m256 test_mm256_moveldup_ps(__m256 A) { 607 // CHECK-LABEL: test_mm256_moveldup_ps 608 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 0, i32 0, i32 2, i32 2, i32 4, i32 4, i32 6, i32 6> 609 return _mm256_moveldup_ps(A); 610 } 611 612 int test_mm256_movemask_pd(__m256d A) { 613 // CHECK-LABEL: test_mm256_movemask_pd 614 // CHECK: call i32 @llvm.x86.avx.movmsk.pd.256(<4 x double> %{{.*}}) 615 return _mm256_movemask_pd(A); 616 } 617 618 int test_mm256_movemask_ps(__m256 A) { 619 // CHECK-LABEL: test_mm256_movemask_ps 620 // CHECK: call i32 @llvm.x86.avx.movmsk.ps.256(<8 x float> %{{.*}}) 621 return _mm256_movemask_ps(A); 622 } 623 624 __m256d test_mm256_mul_pd(__m256d A, __m256d B) { 625 // CHECK-LABEL: test_mm256_mul_pd 626 // CHECK: fmul <4 x double> 627 return _mm256_mul_pd(A, B); 628 } 629 630 __m256 test_mm256_mul_ps(__m256 A, __m256 B) { 631 // CHECK-LABEL: test_mm256_mul_ps 632 // CHECK: fmul <8 x float> 633 return _mm256_mul_ps(A, B); 634 } 635 636 __m256d test_mm256_or_pd(__m256d A, __m256d B) { 637 // CHECK-LABEL: test_mm256_or_pd 638 // CHECK: or <4 x i64> 639 return _mm256_or_pd(A, B); 640 } 641 642 __m256 test_mm256_or_ps(__m256 A, __m256 B) { 643 // CHECK-LABEL: test_mm256_or_ps 644 // CHECK: or <8 x i32> 645 return _mm256_or_ps(A, B); 646 } 647 648 __m128d test_mm_permute_pd(__m128d A) { 649 // CHECK-LABEL: test_mm_permute_pd 650 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> <i32 1, i32 0> 651 return _mm_permute_pd(A, 1); 652 } 653 654 __m256d test_mm256_permute_pd(__m256d A) { 655 // CHECK-LABEL: test_mm256_permute_pd 656 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> undef, <4 x i32> <i32 1, i32 0, i32 3, i32 2> 657 return _mm256_permute_pd(A, 5); 658 } 659 660 __m128 test_mm_permute_ps(__m128 A) { 661 // CHECK-LABEL: test_mm_permute_ps 662 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <4 x i32> <i32 3, i32 2, i32 1, i32 0> 663 return _mm_permute_ps(A, 0x1b); 664 } 665 666 // Test case for PR12401 667 __m128 test2_mm_permute_ps(__m128 a) { 668 // CHECK-LABEL: test2_mm_permute_ps 669 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <4 x i32> <i32 2, i32 1, i32 2, i32 3> 670 return _mm_permute_ps(a, 0xe6); 671 } 672 673 __m256 test_mm256_permute_ps(__m256 A) { 674 // CHECK-LABEL: test_mm256_permute_ps 675 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> undef, <8 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4> 676 return _mm256_permute_ps(A, 0x1b); 677 } 678 679 __m256d test_mm256_permute2f128_pd(__m256d A, __m256d B) { 680 // CHECK-LABEL: test_mm256_permute2f128_pd 681 // CHECK: call <4 x double> @llvm.x86.avx.vperm2f128.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i8 49) 682 return _mm256_permute2f128_pd(A, B, 0x31); 683 } 684 685 __m256 test_mm256_permute2f128_ps(__m256 A, __m256 B) { 686 // CHECK-LABEL: test_mm256_permute2f128_ps 687 // CHECK: call <8 x float> @llvm.x86.avx.vperm2f128.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i8 19) 688 return _mm256_permute2f128_ps(A, B, 0x13); 689 } 690 691 __m256i test_mm256_permute2f128_si256(__m256i A, __m256i B) { 692 // CHECK-LABEL: test_mm256_permute2f128_si256 693 // CHECK: call <8 x i32> @llvm.x86.avx.vperm2f128.si.256(<8 x i32> %{{.*}}, <8 x i32> %{{.*}}, i8 32) 694 return _mm256_permute2f128_si256(A, B, 0x20); 695 } 696 697 __m128d test_mm_permutevar_pd(__m128d A, __m128i B) { 698 // CHECK-LABEL: test_mm_permutevar_pd 699 // CHECK: call <2 x double> @llvm.x86.avx.vpermilvar.pd(<2 x double> %{{.*}}, <2 x i64> %{{.*}}) 700 return _mm_permutevar_pd(A, B); 701 } 702 703 __m256d test_mm256_permutevar_pd(__m256d A, __m256i B) { 704 // CHECK-LABEL: test_mm256_permutevar_pd 705 // CHECK: call <4 x double> @llvm.x86.avx.vpermilvar.pd.256(<4 x double> %{{.*}}, <4 x i64> %{{.*}}) 706 return _mm256_permutevar_pd(A, B); 707 } 708 709 __m128 test_mm_permutevar_ps(__m128 A, __m128i B) { 710 // CHECK-LABEL: test_mm_permutevar_ps 711 // CHECK: call <4 x float> @llvm.x86.avx.vpermilvar.ps(<4 x float> %{{.*}}, <4 x i32> %{{.*}}) 712 return _mm_permutevar_ps(A, B); 713 } 714 715 __m256 test_mm256_permutevar_ps(__m256 A, __m256i B) { 716 // CHECK-LABEL: test_mm256_permutevar_ps 717 // CHECK: call <8 x float> @llvm.x86.avx.vpermilvar.ps.256(<8 x float> %{{.*}}, <8 x i32> %{{.*}}) 718 return _mm256_permutevar_ps(A, B); 719 } 720 721 __m256 test_mm256_rcp_ps(__m256 A) { 722 // CHECK-LABEL: test_mm256_rcp_ps 723 // CHECK: call <8 x float> @llvm.x86.avx.rcp.ps.256(<8 x float> %{{.*}}) 724 return _mm256_rcp_ps(A); 725 } 726 727 __m256d test_mm256_round_pd(__m256d x) { 728 // CHECK-LABEL: test_mm256_round_pd 729 // CHECK: call <4 x double> @llvm.x86.avx.round.pd.256(<4 x double> %{{.*}}, i32 4) 730 return _mm256_round_pd(x, 4); 731 } 732 733 __m256 test_mm256_round_ps(__m256 x) { 734 // CHECK-LABEL: test_mm256_round_ps 735 // CHECK: call <8 x float> @llvm.x86.avx.round.ps.256(<8 x float> %{{.*}}, i32 4) 736 return _mm256_round_ps(x, 4); 737 } 738 739 __m256 test_mm256_rsqrt_ps(__m256 A) { 740 // CHECK-LABEL: test_mm256_rsqrt_ps 741 // CHECK: call <8 x float> @llvm.x86.avx.rsqrt.ps.256(<8 x float> %{{.*}}) 742 return _mm256_rsqrt_ps(A); 743 } 744 745 __m256i test_mm256_set_epi8(char A0, char A1, char A2, char A3, char A4, char A5, char A6, char A7, 746 char A8, char A9, char A10, char A11, char A12, char A13, char A14, char A15, 747 char A16, char A17, char A18, char A19, char A20, char A21, char A22, char A23, 748 char A24, char A25, char A26, char A27, char A28, char A29, char A30, char A31) { 749 // CHECK-LABEL: test_mm256_set_epi8 750 // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0 751 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1 752 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2 753 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3 754 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4 755 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5 756 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6 757 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7 758 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8 759 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9 760 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10 761 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11 762 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12 763 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13 764 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14 765 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15 766 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16 767 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17 768 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18 769 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19 770 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20 771 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21 772 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22 773 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23 774 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24 775 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25 776 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26 777 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27 778 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28 779 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29 780 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30 781 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31 782 return _mm256_set_epi8(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31); 783 } 784 785 __m256i test_mm256_set_epi16(short A0, short A1, short A2, short A3, short A4, short A5, short A6, short A7, 786 short A8, short A9, short A10, short A11, short A12, short A13, short A14, short A15) { 787 // CHECK-LABEL: test_mm256_set_epi16 788 // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0 789 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1 790 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2 791 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3 792 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4 793 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5 794 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6 795 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7 796 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8 797 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9 798 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10 799 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11 800 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12 801 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13 802 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14 803 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15 804 return _mm256_set_epi16(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15); 805 } 806 807 __m256i test_mm256_set_epi32(int A0, int A1, int A2, int A3, int A4, int A5, int A6, int A7) { 808 // CHECK-LABEL: test_mm256_set_epi32 809 // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0 810 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1 811 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2 812 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3 813 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4 814 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5 815 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6 816 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7 817 return _mm256_set_epi32(A0, A1, A2, A3, A4, A5, A6, A7); 818 } 819 820 __m256i test_mm256_set_epi64x(long long A0, long long A1, long long A2, long long A3) { 821 // CHECK-LABEL: test_mm256_set_epi64x 822 // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0 823 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1 824 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2 825 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3 826 return _mm256_set_epi64x(A0, A1, A2, A3); 827 } 828 829 __m256 test_mm256_set_m128(__m128 A, __m128 B) { 830 // CHECK-LABEL: test_mm256_set_m128 831 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 832 return _mm256_set_m128(A, B); 833 } 834 835 __m256d test_mm256_set_m128d(__m128d A, __m128d B) { 836 // CHECK-LABEL: test_mm256_set_m128d 837 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 838 return _mm256_set_m128d(A, B); 839 } 840 841 __m256i test_mm256_set_m128i(__m128i A, __m128i B) { 842 // CHECK-LABEL: test_mm256_set_m128i 843 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 844 return _mm256_set_m128i(A, B); 845 } 846 847 __m256d test_mm256_set_pd(double A0, double A1, double A2, double A3) { 848 // CHECK-LABEL: test_mm256_set_pd 849 // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0 850 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1 851 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2 852 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3 853 return _mm256_set_pd(A0, A1, A2, A3); 854 } 855 856 __m256 test_mm256_set_ps(float A0, float A1, float A2, float A3, float A4, float A5, float A6, float A7) { 857 // CHECK-LABEL: test_mm256_set_ps 858 // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0 859 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1 860 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2 861 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3 862 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4 863 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5 864 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6 865 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7 866 return _mm256_set_ps(A0, A1, A2, A3, A4, A5, A6, A7); 867 } 868 869 __m256i test_mm256_set1_epi8(char A) { 870 // CHECK-LABEL: test_mm256_set1_epi8 871 // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0 872 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1 873 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2 874 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3 875 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4 876 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5 877 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6 878 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7 879 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8 880 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9 881 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10 882 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11 883 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12 884 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13 885 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14 886 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15 887 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16 888 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17 889 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18 890 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19 891 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20 892 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21 893 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22 894 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23 895 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24 896 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25 897 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26 898 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27 899 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28 900 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29 901 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30 902 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31 903 return _mm256_set1_epi8(A); 904 } 905 906 __m256i test_mm256_set1_epi16(short A) { 907 // CHECK-LABEL: test_mm256_set1_epi16 908 // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0 909 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1 910 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2 911 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3 912 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4 913 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5 914 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6 915 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7 916 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8 917 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9 918 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10 919 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11 920 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12 921 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13 922 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14 923 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15 924 return _mm256_set1_epi16(A); 925 } 926 927 __m256i test_mm256_set1_epi32(int A) { 928 // CHECK-LABEL: test_mm256_set1_epi32 929 // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0 930 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1 931 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2 932 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3 933 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4 934 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5 935 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6 936 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7 937 return _mm256_set1_epi32(A); 938 } 939 940 __m256i test_mm256_set1_epi64x(long long A) { 941 // CHECK-LABEL: test_mm256_set1_epi64x 942 // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0 943 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1 944 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2 945 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3 946 return _mm256_set1_epi64x(A); 947 } 948 949 __m256d test_mm256_set1_pd(double A) { 950 // CHECK-LABEL: test_mm256_set1_pd 951 // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0 952 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1 953 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2 954 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3 955 return _mm256_set1_pd(A); 956 } 957 958 __m256 test_mm256_set1_ps(float A) { 959 // CHECK-LABEL: test_mm256_set1_ps 960 // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0 961 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1 962 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2 963 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3 964 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4 965 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5 966 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6 967 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7 968 return _mm256_set1_ps(A); 969 } 970 971 __m256i test_mm256_setr_epi8(char A0, char A1, char A2, char A3, char A4, char A5, char A6, char A7, 972 char A8, char A9, char A10, char A11, char A12, char A13, char A14, char A15, 973 char A16, char A17, char A18, char A19, char A20, char A21, char A22, char A23, 974 char A24, char A25, char A26, char A27, char A28, char A29, char A30, char A31) { 975 // CHECK-LABEL: test_mm256_setr_epi8 976 // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0 977 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1 978 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2 979 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3 980 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4 981 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5 982 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6 983 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7 984 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8 985 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9 986 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10 987 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11 988 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12 989 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13 990 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14 991 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15 992 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16 993 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17 994 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18 995 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19 996 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20 997 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21 998 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22 999 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23 1000 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24 1001 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25 1002 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26 1003 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27 1004 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28 1005 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29 1006 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30 1007 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31 1008 return _mm256_setr_epi8(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31); 1009 } 1010 1011 __m256i test_mm256_setr_epi16(short A0, short A1, short A2, short A3, short A4, short A5, short A6, short A7, 1012 short A8, short A9, short A10, short A11, short A12, short A13, short A14, short A15) { 1013 // CHECK-LABEL: test_mm256_setr_epi16 1014 // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0 1015 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1 1016 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2 1017 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3 1018 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4 1019 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5 1020 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6 1021 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7 1022 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8 1023 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9 1024 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10 1025 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11 1026 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12 1027 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13 1028 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14 1029 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15 1030 return _mm256_setr_epi16(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15); 1031 } 1032 1033 __m256i test_mm256_setr_epi32(int A0, int A1, int A2, int A3, int A4, int A5, int A6, int A7) { 1034 // CHECK-LABEL: test_mm256_setr_epi32 1035 // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0 1036 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1 1037 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2 1038 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3 1039 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4 1040 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5 1041 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6 1042 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7 1043 return _mm256_setr_epi32(A0, A1, A2, A3, A4, A5, A6, A7); 1044 } 1045 1046 __m256i test_mm256_setr_epi64x(long long A0, long long A1, long long A2, long long A3) { 1047 // CHECK-LABEL: test_mm256_setr_epi64x 1048 // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0 1049 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1 1050 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2 1051 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3 1052 return _mm256_setr_epi64x(A0, A1, A2, A3); 1053 } 1054 1055 __m256 test_mm256_setr_m128(__m128 A, __m128 B) { 1056 // CHECK-LABEL: test_mm256_setr_m128 1057 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 1058 return _mm256_setr_m128(A, B); 1059 } 1060 1061 __m256d test_mm256_setr_m128d(__m128d A, __m128d B) { 1062 // CHECK-LABEL: test_mm256_setr_m128d 1063 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 1064 return _mm256_setr_m128d(A, B); 1065 } 1066 1067 __m256i test_mm256_setr_m128i(__m128i A, __m128i B) { 1068 // CHECK-LABEL: test_mm256_setr_m128i 1069 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 1070 return _mm256_setr_m128i(A, B); 1071 } 1072 1073 __m256d test_mm256_setr_pd(double A0, double A1, double A2, double A3) { 1074 // CHECK-LABEL: test_mm256_setr_pd 1075 // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0 1076 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1 1077 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2 1078 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3 1079 return _mm256_setr_pd(A0, A1, A2, A3); 1080 } 1081 1082 __m256 test_mm256_setr_ps(float A0, float A1, float A2, float A3, float A4, float A5, float A6, float A7) { 1083 // CHECK-LABEL: test_mm256_setr_ps 1084 // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0 1085 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1 1086 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2 1087 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3 1088 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4 1089 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5 1090 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6 1091 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7 1092 return _mm256_setr_ps(A0, A1, A2, A3, A4, A5, A6, A7); 1093 } 1094 1095 __m256d test_mm256_setzero_pd() { 1096 // CHECK-LABEL: test_mm256_setzero_pd 1097 // CHECK: store <4 x double> zeroinitializer 1098 return _mm256_setzero_pd(); 1099 } 1100 1101 __m256 test_mm256_setzero_ps() { 1102 // CHECK-LABEL: test_mm256_setzero_ps 1103 // CHECK: store <8 x float> zeroinitializer 1104 return _mm256_setzero_ps(); 1105 } 1106 1107 __m256i test_mm256_setzero_si256() { 1108 // CHECK-LABEL: test_mm256_setzero_si256 1109 // CHECK: store <4 x i64> zeroinitializer 1110 return _mm256_setzero_si256(); 1111 } 1112 1113 __m256d test_mm256_shuffle_pd(__m256d A, __m256d B) { 1114 // CHECK-LABEL: test_mm256_shuffle_pd 1115 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6> 1116 return _mm256_shuffle_pd(A, B, 0); 1117 } 1118 1119 __m256 test_mm256_shuffle_ps(__m256 A, __m256 B) { 1120 // CHECK-LABEL: test_mm256_shuffle_ps 1121 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 0, i32 0, i32 8, i32 8, i32 4, i32 4, i32 12, i32 12> 1122 return _mm256_shuffle_ps(A, B, 0); 1123 } 1124 1125 __m256d test_mm256_sqrt_pd(__m256d A) { 1126 // CHECK-LABEL: test_mm256_sqrt_pd 1127 // CHECK: call <4 x double> @llvm.x86.avx.sqrt.pd.256(<4 x double> %{{.*}}) 1128 return _mm256_sqrt_pd(A); 1129 } 1130 1131 __m256 test_mm256_sqrt_ps(__m256 A) { 1132 // CHECK-LABEL: test_mm256_sqrt_ps 1133 // CHECK: call <8 x float> @llvm.x86.avx.sqrt.ps.256(<8 x float> %{{.*}}) 1134 return _mm256_sqrt_ps(A); 1135 } 1136 1137 void test_mm256_store_pd(double* A, __m256d B) { 1138 // CHECK-LABEL: test_mm256_store_pd 1139 // CHECK: store <4 x double> %{{.*}}, <4 x double>* %{{.*}}, align 32 1140 _mm256_store_pd(A, B); 1141 } 1142 1143 void test_mm256_store_ps(float* A, __m256 B) { 1144 // CHECK-LABEL: test_mm256_store_ps 1145 // CHECK: store <8 x float> %{{.*}}, <8 x float>* %{{.*}}, align 32 1146 _mm256_store_ps(A, B); 1147 } 1148 1149 void test_mm256_store_si256(__m256i* A, __m256i B) { 1150 // CHECK-LABEL: test_mm256_store_si256 1151 // CHECK: store <4 x i64> %{{.*}}, <4 x i64>* %{{.*}}, align 32 1152 _mm256_store_si256(A, B); 1153 } 1154 1155 void test_mm256_storeu_pd(double* A, __m256d B) { 1156 // CHECK-LABEL: test_mm256_storeu_pd 1157 // CHECK: store <4 x double> %{{.*}}, <4 x double>* %{{.*}}, align 1{{$}} 1158 // CHECK-NEXT: ret void 1159 _mm256_storeu_pd(A, B); 1160 } 1161 1162 void test_mm256_storeu_ps(float* A, __m256 B) { 1163 // CHECK-LABEL: test_mm256_storeu_ps 1164 // CHECK: store <8 x float> %{{.*}}, <8 x float>* %{{.*}}, align 1{{$}} 1165 // CHECk-NEXT: ret void 1166 _mm256_storeu_ps(A, B); 1167 } 1168 1169 void test_mm256_storeu_si256(__m256i* A, __m256i B) { 1170 // CHECK-LABEL: test_mm256_storeu_si256 1171 // CHECK: store <4 x i64> %{{.*}}, <4 x i64>* %{{.*}}, align 1{{$}} 1172 // CHECk-NEXT: ret void 1173 _mm256_storeu_si256(A, B); 1174 } 1175 1176 void test_mm256_storeu2_m128(float* A, float* B, __m256 C) { 1177 // CHECK-LABEL: test_mm256_storeu2_m128 1178 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 1179 // CHECK: store <4 x float> %{{.*}}, <4 x float>* %{{.*}}, align 1{{$}} 1180 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7> 1181 // CHECK: store <4 x float> %{{.*}}, <4 x float>* %{{.*}}, align 1{{$}} 1182 _mm256_storeu2_m128(A, B, C); 1183 } 1184 1185 void test_mm256_storeu2_m128d(double* A, double* B, __m256d C) { 1186 // CHECK-LABEL: test_mm256_storeu2_m128d 1187 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <2 x i32> <i32 0, i32 1> 1188 // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 1{{$}} 1189 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> undef, <2 x i32> <i32 2, i32 3> 1190 // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 1{{$}} 1191 _mm256_storeu2_m128d(A, B, C); 1192 } 1193 1194 void test_mm256_storeu2_m128i(__m128i* A, __m128i* B, __m256i C) { 1195 // CHECK-LABEL: test_mm256_storeu2_m128i 1196 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <2 x i32> <i32 0, i32 1> 1197 // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 1{{$}} 1198 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> undef, <2 x i32> <i32 2, i32 3> 1199 // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 1{{$}} 1200 _mm256_storeu2_m128i(A, B, C); 1201 } 1202 1203 void test_mm256_stream_pd(double* A, __m256d B) { 1204 // CHECK-LABEL: test_mm256_stream_pd 1205 // CHECK: store <4 x double> %{{.*}}, <4 x double>* %{{.*}}, align 32, !nontemporal 1206 _mm256_stream_pd(A, B); 1207 } 1208 1209 void test_mm256_stream_ps(float* A, __m256 B) { 1210 // CHECK-LABEL: test_mm256_stream_ps 1211 // CHECK: store <8 x float> %{{.*}}, <8 x float>* %{{.*}}, align 32, !nontemporal 1212 _mm256_stream_ps(A, B); 1213 } 1214 1215 void test_mm256_stream_si256(__m256i* A, __m256i B) { 1216 // CHECK-LABEL: test_mm256_stream_si256 1217 // CHECK: store <4 x i64> %{{.*}}, <4 x i64>* %{{.*}}, align 32, !nontemporal 1218 _mm256_stream_si256(A, B); 1219 } 1220 1221 __m256d test_mm256_sub_pd(__m256d A, __m256d B) { 1222 // CHECK-LABEL: test_mm256_sub_pd 1223 // CHECK: fsub <4 x double> 1224 return _mm256_sub_pd(A, B); 1225 } 1226 1227 __m256 test_mm256_sub_ps(__m256 A, __m256 B) { 1228 // CHECK-LABEL: test_mm256_sub_ps 1229 // CHECK: fsub <8 x float> 1230 return _mm256_sub_ps(A, B); 1231 } 1232 1233 int test_mm_testc_pd(__m128d A, __m128d B) { 1234 // CHECK-LABEL: test_mm_testc_pd 1235 // CHECK: call i32 @llvm.x86.avx.vtestc.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1236 return _mm_testc_pd(A, B); 1237 } 1238 1239 int test_mm256_testc_pd(__m256d A, __m256d B) { 1240 // CHECK-LABEL: test_mm256_testc_pd 1241 // CHECK: call i32 @llvm.x86.avx.vtestc.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}) 1242 return _mm256_testc_pd(A, B); 1243 } 1244 1245 int test_mm_testc_ps(__m128 A, __m128 B) { 1246 // CHECK-LABEL: test_mm_testc_ps 1247 // CHECK: call i32 @llvm.x86.avx.vtestc.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 1248 return _mm_testc_ps(A, B); 1249 } 1250 1251 int test_mm256_testc_ps(__m256 A, __m256 B) { 1252 // CHECK-LABEL: test_mm256_testc_ps 1253 // CHECK: call i32 @llvm.x86.avx.vtestc.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}) 1254 return _mm256_testc_ps(A, B); 1255 } 1256 1257 int test_mm256_testc_si256(__m256 A, __m256 B) { 1258 // CHECK-LABEL: test_mm256_testc_si256 1259 // CHECK: call i32 @llvm.x86.avx.ptestc.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}}) 1260 return _mm256_testc_si256(A, B); 1261 } 1262 1263 int test_mm_testnzc_pd(__m128d A, __m128d B) { 1264 // CHECK-LABEL: test_mm_testnzc_pd 1265 // CHECK: call i32 @llvm.x86.avx.vtestnzc.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1266 return _mm_testnzc_pd(A, B); 1267 } 1268 1269 int test_mm256_testnzc_pd(__m256d A, __m256d B) { 1270 // CHECK-LABEL: test_mm256_testnzc_pd 1271 // CHECK: call i32 @llvm.x86.avx.vtestnzc.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}) 1272 return _mm256_testnzc_pd(A, B); 1273 } 1274 1275 int test_mm_testnzc_ps(__m128 A, __m128 B) { 1276 // CHECK-LABEL: test_mm_testnzc_ps 1277 // CHECK: call i32 @llvm.x86.avx.vtestnzc.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 1278 return _mm_testnzc_ps(A, B); 1279 } 1280 1281 int test_mm256_testnzc_ps(__m256 A, __m256 B) { 1282 // CHECK-LABEL: test_mm256_testnzc_ps 1283 // CHECK: call i32 @llvm.x86.avx.vtestnzc.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}) 1284 return _mm256_testnzc_ps(A, B); 1285 } 1286 1287 int test_mm256_testnzc_si256(__m256 A, __m256 B) { 1288 // CHECK-LABEL: test_mm256_testnzc_si256 1289 // CHECK: call i32 @llvm.x86.avx.ptestnzc.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}}) 1290 return _mm256_testnzc_si256(A, B); 1291 } 1292 1293 int test_mm_testz_pd(__m128d A, __m128d B) { 1294 // CHECK-LABEL: test_mm_testz_pd 1295 // CHECK: call i32 @llvm.x86.avx.vtestz.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1296 return _mm_testz_pd(A, B); 1297 } 1298 1299 int test_mm256_testz_pd(__m256d A, __m256d B) { 1300 // CHECK-LABEL: test_mm256_testz_pd 1301 // CHECK: call i32 @llvm.x86.avx.vtestz.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}) 1302 return _mm256_testz_pd(A, B); 1303 } 1304 1305 int test_mm_testz_ps(__m128 A, __m128 B) { 1306 // CHECK-LABEL: test_mm_testz_ps 1307 // CHECK: call i32 @llvm.x86.avx.vtestz.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 1308 return _mm_testz_ps(A, B); 1309 } 1310 1311 int test_mm256_testz_ps(__m256 A, __m256 B) { 1312 // CHECK-LABEL: test_mm256_testz_ps 1313 // CHECK: call i32 @llvm.x86.avx.vtestz.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}) 1314 return _mm256_testz_ps(A, B); 1315 } 1316 1317 int test_mm256_testz_si256(__m256 A, __m256 B) { 1318 // CHECK-LABEL: test_mm256_testz_si256 1319 // CHECK: call i32 @llvm.x86.avx.ptestz.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}}) 1320 return _mm256_testz_si256(A, B); 1321 } 1322 1323 __m256 test_mm256_undefined_ps() { 1324 // CHECK-LABEL: @test_mm256_undefined_ps 1325 // CHECK: ret <8 x float> undef 1326 return _mm256_undefined_ps(); 1327 } 1328 1329 __m256d test_mm256_undefined_pd() { 1330 // CHECK-LABEL: @test_mm256_undefined_pd 1331 // CHECK: ret <4 x double> undef 1332 return _mm256_undefined_pd(); 1333 } 1334 1335 __m256i test_mm256_undefined_si256() { 1336 // CHECK-LABEL: @test_mm256_undefined_si256 1337 // CHECK: ret <4 x i64> undef 1338 return _mm256_undefined_si256(); 1339 } 1340 1341 __m256d test_mm256_unpackhi_pd(__m256d A, __m256d B) { 1342 // CHECK-LABEL: test_mm256_unpackhi_pd 1343 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 1, i32 5, i32 3, i32 7> 1344 return _mm256_unpackhi_pd(A, B); 1345 } 1346 1347 __m256 test_mm256_unpackhi_ps(__m256 A, __m256 B) { 1348 // CHECK-LABEL: test_mm256_unpackhi_ps 1349 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 2, i32 10, i32 3, i32 11, i32 6, i32 14, i32 7, i32 15> 1350 return _mm256_unpackhi_ps(A, B); 1351 } 1352 1353 __m256d test_mm256_unpacklo_pd(__m256d A, __m256d B) { 1354 // CHECK-LABEL: test_mm256_unpacklo_pd 1355 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6> 1356 return _mm256_unpacklo_pd(A, B); 1357 } 1358 1359 __m256 test_mm256_unpacklo_ps(__m256 A, __m256 B) { 1360 // CHECK-LABEL: test_mm256_unpacklo_ps 1361 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 4, i32 12, i32 5, i32 13> 1362 return _mm256_unpacklo_ps(A, B); 1363 } 1364 1365 __m256d test_mm256_xor_pd(__m256d A, __m256d B) { 1366 // CHECK-LABEL: test_mm256_xor_pd 1367 // CHECK: xor <4 x i64> 1368 return _mm256_xor_pd(A, B); 1369 } 1370 1371 __m256 test_mm256_xor_ps(__m256 A, __m256 B) { 1372 // CHECK-LABEL: test_mm256_xor_ps 1373 // CHECK: xor <8 x i32> 1374 return _mm256_xor_ps(A, B); 1375 } 1376 1377 void test_mm256_zeroall() { 1378 // CHECK-LABEL: test_mm256_zeroall 1379 // CHECK: call void @llvm.x86.avx.vzeroall() 1380 return _mm256_zeroall(); 1381 } 1382 1383 void test_mm256_zeroupper() { 1384 // CHECK-LABEL: test_mm256_zeroupper 1385 // CHECK: call void @llvm.x86.avx.vzeroupper() 1386 return _mm256_zeroupper(); 1387 } 1388 1389 double test_mm256_cvtsd_f64(__m256d __a) 1390 { 1391 // CHECK-LABEL: @test_mm256_cvtsd_f64 1392 // CHECK: extractelement <4 x double> %{{.*}}, i32 0 1393 return _mm256_cvtsd_f64(__a); 1394 } 1395 1396 int test_mm256_cvtsi256_si32(__m256i __a) 1397 { 1398 // CHECK-LABEL: @test_mm256_cvtsi256_si32 1399 // CHECK: extractelement <8 x i32> %{{.*}}, i32 0 1400 return _mm256_cvtsi256_si32(__a); 1401 } 1402 1403 float test_mm256_cvtss_f32(__m256 __a) 1404 { 1405 // CHECK-LABEL: @test_mm256_cvtss_f32 1406 // CHECK: extractelement <8 x float> %{{.*}}, i32 0 1407 return _mm256_cvtss_f32(__a); 1408 } 1409
