1 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx -emit-llvm -o - -Wall -Werror | FileCheck %s 2 // RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx -fno-signed-char -emit-llvm -o - -Wall -Werror | FileCheck %s 3 4 5 #include <immintrin.h> 6 7 // NOTE: This should match the tests in llvm/test/CodeGen/X86/sse-intrinsics-fast-isel.ll 8 9 __m256d test_mm256_add_pd(__m256d A, __m256d B) { 10 // CHECK-LABEL: test_mm256_add_pd 11 // CHECK: fadd <4 x double> 12 return _mm256_add_pd(A, B); 13 } 14 15 __m256 test_mm256_add_ps(__m256 A, __m256 B) { 16 // CHECK-LABEL: test_mm256_add_ps 17 // CHECK: fadd <8 x float> 18 return _mm256_add_ps(A, B); 19 } 20 21 __m256d test_mm256_addsub_pd(__m256d A, __m256d B) { 22 // CHECK-LABEL: test_mm256_addsub_pd 23 // CHECK: call <4 x double> @llvm.x86.avx.addsub.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}) 24 return _mm256_addsub_pd(A, B); 25 } 26 27 __m256 test_mm256_addsub_ps(__m256 A, __m256 B) { 28 // CHECK-LABEL: test_mm256_addsub_ps 29 // CHECK: call <8 x float> @llvm.x86.avx.addsub.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}) 30 return _mm256_addsub_ps(A, B); 31 } 32 33 __m256d test_mm256_and_pd(__m256d A, __m256d B) { 34 // CHECK-LABEL: test_mm256_and_pd 35 // CHECK: and <4 x i64> 36 return _mm256_and_pd(A, B); 37 } 38 39 __m256 test_mm256_and_ps(__m256 A, __m256 B) { 40 // CHECK-LABEL: test_mm256_and_ps 41 // CHECK: and <8 x i32> 42 return _mm256_and_ps(A, B); 43 } 44 45 __m256d test_mm256_andnot_pd(__m256d A, __m256d B) { 46 // CHECK-LABEL: test_mm256_andnot_pd 47 // CHECK: xor <4 x i64> %{{.*}}, <i64 -1, i64 -1, i64 -1, i64 -1> 48 // CHECK: and <4 x i64> 49 return _mm256_andnot_pd(A, B); 50 } 51 52 __m256 test_mm256_andnot_ps(__m256 A, __m256 B) { 53 // CHECK-LABEL: test_mm256_andnot_ps 54 // CHECK: xor <8 x i32> %{{.*}}, <i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1> 55 // CHECK: and <8 x i32> 56 return _mm256_andnot_ps(A, B); 57 } 58 59 __m256d test_mm256_blend_pd(__m256d A, __m256d B) { 60 // CHECK-LABEL: test_mm256_blend_pd 61 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 4, i32 1, i32 6, i32 3> 62 return _mm256_blend_pd(A, B, 0x05); 63 } 64 65 __m256 test_mm256_blend_ps(__m256 A, __m256 B) { 66 // CHECK-LABEL: test_mm256_blend_ps 67 // 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> 68 return _mm256_blend_ps(A, B, 0x35); 69 } 70 71 __m256d test_mm256_blendv_pd(__m256d V1, __m256d V2, __m256d V3) { 72 // CHECK-LABEL: test_mm256_blendv_pd 73 // CHECK: call <4 x double> @llvm.x86.avx.blendv.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) 74 return _mm256_blendv_pd(V1, V2, V3); 75 } 76 77 __m256 test_mm256_blendv_ps(__m256 V1, __m256 V2, __m256 V3) { 78 // CHECK-LABEL: test_mm256_blendv_ps 79 // CHECK: call <8 x float> @llvm.x86.avx.blendv.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}) 80 return _mm256_blendv_ps(V1, V2, V3); 81 } 82 83 __m256d test_mm256_broadcast_pd(__m128d* A) { 84 // CHECK-LABEL: test_mm256_broadcast_pd 85 // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 1{{$}} 86 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 0, i32 1> 87 return _mm256_broadcast_pd(A); 88 } 89 90 __m256 test_mm256_broadcast_ps(__m128* A) { 91 // CHECK-LABEL: test_mm256_broadcast_ps 92 // CHECK: load <4 x float>, <4 x float>* %{{.*}}, align 1{{$}} 93 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3> 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 __m256d test_mm256_cmp_pd_eq_oq(__m256d a, __m256d b) { 216 // CHECK-LABEL: @test_mm256_cmp_pd_eq_oq 217 // CHECK: fcmp oeq <4 x double> %{{.*}}, %{{.*}} 218 return _mm256_cmp_pd(a, b, _CMP_EQ_OQ); 219 } 220 221 __m256d test_mm256_cmp_pd_lt_os(__m256d a, __m256d b) { 222 // CHECK-LABEL: test_mm256_cmp_pd_lt_os 223 // CHECK: fcmp olt <4 x double> %{{.*}}, %{{.*}} 224 return _mm256_cmp_pd(a, b, _CMP_LT_OS); 225 } 226 227 __m256d test_mm256_cmp_pd_le_os(__m256d a, __m256d b) { 228 // CHECK-LABEL: test_mm256_cmp_pd_le_os 229 // CHECK: fcmp ole <4 x double> %{{.*}}, %{{.*}} 230 return _mm256_cmp_pd(a, b, _CMP_LE_OS); 231 } 232 233 __m256d test_mm256_cmp_pd_unord_q(__m256d a, __m256d b) { 234 // CHECK-LABEL: test_mm256_cmp_pd_unord_q 235 // CHECK: fcmp uno <4 x double> %{{.*}}, %{{.*}} 236 return _mm256_cmp_pd(a, b, _CMP_UNORD_Q); 237 } 238 239 __m256d test_mm256_cmp_pd_neq_uq(__m256d a, __m256d b) { 240 // CHECK-LABEL: test_mm256_cmp_pd_neq_uq 241 // CHECK: fcmp une <4 x double> %{{.*}}, %{{.*}} 242 return _mm256_cmp_pd(a, b, _CMP_NEQ_UQ); 243 } 244 245 __m256d test_mm256_cmp_pd_nlt_us(__m256d a, __m256d b) { 246 // CHECK-LABEL: test_mm256_cmp_pd_nlt_us 247 // CHECK: fcmp uge <4 x double> %{{.*}}, %{{.*}} 248 return _mm256_cmp_pd(a, b, _CMP_NLT_US); 249 } 250 251 __m256d test_mm256_cmp_pd_nle_us(__m256d a, __m256d b) { 252 // CHECK-LABEL: test_mm256_cmp_pd_nle_us 253 // CHECK: fcmp ugt <4 x double> %{{.*}}, %{{.*}} 254 return _mm256_cmp_pd(a, b, _CMP_NLE_US); 255 } 256 257 __m256d test_mm256_cmp_pd_ord_q(__m256d a, __m256d b) { 258 // CHECK-LABEL: test_mm256_cmp_pd_ord_q 259 // CHECK: fcmp ord <4 x double> %{{.*}}, %{{.*}} 260 return _mm256_cmp_pd(a, b, _CMP_ORD_Q); 261 } 262 263 __m256d test_mm256_cmp_pd_eq_uq(__m256d a, __m256d b) { 264 // CHECK-LABEL: test_mm256_cmp_pd_eq_uq 265 // CHECK: fcmp ueq <4 x double> %{{.*}}, %{{.*}} 266 return _mm256_cmp_pd(a, b, _CMP_EQ_UQ); 267 } 268 269 __m256d test_mm256_cmp_pd_nge_us(__m256d a, __m256d b) { 270 // CHECK-LABEL: test_mm256_cmp_pd_nge_us 271 // CHECK: fcmp ult <4 x double> %{{.*}}, %{{.*}} 272 return _mm256_cmp_pd(a, b, _CMP_NGE_US); 273 } 274 275 __m256d test_mm256_cmp_pd_ngt_us(__m256d a, __m256d b) { 276 // CHECK-LABEL: test_mm256_cmp_pd_ngt_us 277 // CHECK: fcmp ule <4 x double> %{{.*}}, %{{.*}} 278 return _mm256_cmp_pd(a, b, _CMP_NGT_US); 279 } 280 281 __m256d test_mm256_cmp_pd_false_oq(__m256d a, __m256d b) { 282 // CHECK-LABEL: test_mm256_cmp_pd_false_oq 283 // CHECK: fcmp false <4 x double> %{{.*}}, %{{.*}} 284 return _mm256_cmp_pd(a, b, _CMP_FALSE_OQ); 285 } 286 287 __m256d test_mm256_cmp_pd_neq_oq(__m256d a, __m256d b) { 288 // CHECK-LABEL: test_mm256_cmp_pd_neq_oq 289 // CHECK: fcmp one <4 x double> %{{.*}}, %{{.*}} 290 return _mm256_cmp_pd(a, b, _CMP_NEQ_OQ); 291 } 292 293 __m256d test_mm256_cmp_pd_ge_os(__m256d a, __m256d b) { 294 // CHECK-LABEL: test_mm256_cmp_pd_ge_os 295 // CHECK: fcmp oge <4 x double> %{{.*}}, %{{.*}} 296 return _mm256_cmp_pd(a, b, _CMP_GE_OS); 297 } 298 299 __m256d test_mm256_cmp_pd_gt_os(__m256d a, __m256d b) { 300 // CHECK-LABEL: test_mm256_cmp_pd_gt_os 301 // CHECK: fcmp ogt <4 x double> %{{.*}}, %{{.*}} 302 return _mm256_cmp_pd(a, b, _CMP_GT_OS); 303 } 304 305 __m256d test_mm256_cmp_pd_true_uq(__m256d a, __m256d b) { 306 // CHECK-LABEL: test_mm256_cmp_pd_true_uq 307 // CHECK: fcmp true <4 x double> %{{.*}}, %{{.*}} 308 return _mm256_cmp_pd(a, b, _CMP_TRUE_UQ); 309 } 310 311 __m256d test_mm256_cmp_pd_eq_os(__m256d a, __m256d b) { 312 // CHECK-LABEL: test_mm256_cmp_pd_eq_os 313 // CHECK: fcmp oeq <4 x double> %{{.*}}, %{{.*}} 314 return _mm256_cmp_pd(a, b, _CMP_EQ_OS); 315 } 316 317 __m256d test_mm256_cmp_pd_lt_oq(__m256d a, __m256d b) { 318 // CHECK-LABEL: test_mm256_cmp_pd_lt_oq 319 // CHECK: fcmp olt <4 x double> %{{.*}}, %{{.*}} 320 return _mm256_cmp_pd(a, b, _CMP_LT_OQ); 321 } 322 323 __m256d test_mm256_cmp_pd_le_oq(__m256d a, __m256d b) { 324 // CHECK-LABEL: test_mm256_cmp_pd_le_oq 325 // CHECK: fcmp ole <4 x double> %{{.*}}, %{{.*}} 326 return _mm256_cmp_pd(a, b, _CMP_LE_OQ); 327 } 328 329 __m256d test_mm256_cmp_pd_unord_s(__m256d a, __m256d b) { 330 // CHECK-LABEL: test_mm256_cmp_pd_unord_s 331 // CHECK: fcmp uno <4 x double> %{{.*}}, %{{.*}} 332 return _mm256_cmp_pd(a, b, _CMP_UNORD_S); 333 } 334 335 __m256d test_mm256_cmp_pd_neq_us(__m256d a, __m256d b) { 336 // CHECK-LABEL: test_mm256_cmp_pd_neq_us 337 // CHECK: fcmp une <4 x double> %{{.*}}, %{{.*}} 338 return _mm256_cmp_pd(a, b, _CMP_NEQ_US); 339 } 340 341 __m256d test_mm256_cmp_pd_nlt_uq(__m256d a, __m256d b) { 342 // CHECK-LABEL: test_mm256_cmp_pd_nlt_uq 343 // CHECK: fcmp uge <4 x double> %{{.*}}, %{{.*}} 344 return _mm256_cmp_pd(a, b, _CMP_NLT_UQ); 345 } 346 347 __m256d test_mm256_cmp_pd_nle_uq(__m256d a, __m256d b) { 348 // CHECK-LABEL: test_mm256_cmp_pd_nle_uq 349 // CHECK: fcmp ugt <4 x double> %{{.*}}, %{{.*}} 350 return _mm256_cmp_pd(a, b, _CMP_NLE_UQ); 351 } 352 353 __m256d test_mm256_cmp_pd_ord_s(__m256d a, __m256d b) { 354 // CHECK-LABEL: test_mm256_cmp_pd_ord_s 355 // CHECK: fcmp ord <4 x double> %{{.*}}, %{{.*}} 356 return _mm256_cmp_pd(a, b, _CMP_ORD_S); 357 } 358 359 __m256d test_mm256_cmp_pd_eq_us(__m256d a, __m256d b) { 360 // CHECK-LABEL: test_mm256_cmp_pd_eq_us 361 // CHECK: fcmp ueq <4 x double> %{{.*}}, %{{.*}} 362 return _mm256_cmp_pd(a, b, _CMP_EQ_US); 363 } 364 365 __m256d test_mm256_cmp_pd_nge_uq(__m256d a, __m256d b) { 366 // CHECK-LABEL: test_mm256_cmp_pd_nge_uq 367 // CHECK: fcmp ult <4 x double> %{{.*}}, %{{.*}} 368 return _mm256_cmp_pd(a, b, _CMP_NGE_UQ); 369 } 370 371 __m256d test_mm256_cmp_pd_ngt_uq(__m256d a, __m256d b) { 372 // CHECK-LABEL: test_mm256_cmp_pd_ngt_uq 373 // CHECK: fcmp ule <4 x double> %{{.*}}, %{{.*}} 374 return _mm256_cmp_pd(a, b, _CMP_NGT_UQ); 375 } 376 377 __m256d test_mm256_cmp_pd_false_os(__m256d a, __m256d b) { 378 // CHECK-LABEL: test_mm256_cmp_pd_false_os 379 // CHECK: fcmp false <4 x double> %{{.*}}, %{{.*}} 380 return _mm256_cmp_pd(a, b, _CMP_FALSE_OS); 381 } 382 383 __m256d test_mm256_cmp_pd_neq_os(__m256d a, __m256d b) { 384 // CHECK-LABEL: test_mm256_cmp_pd_neq_os 385 // CHECK: fcmp one <4 x double> %{{.*}}, %{{.*}} 386 return _mm256_cmp_pd(a, b, _CMP_NEQ_OS); 387 } 388 389 __m256d test_mm256_cmp_pd_ge_oq(__m256d a, __m256d b) { 390 // CHECK-LABEL: test_mm256_cmp_pd_ge_oq 391 // CHECK: fcmp oge <4 x double> %{{.*}}, %{{.*}} 392 return _mm256_cmp_pd(a, b, _CMP_GE_OQ); 393 } 394 395 __m256d test_mm256_cmp_pd_gt_oq(__m256d a, __m256d b) { 396 // CHECK-LABEL: test_mm256_cmp_pd_gt_oq 397 // CHECK: fcmp ogt <4 x double> %{{.*}}, %{{.*}} 398 return _mm256_cmp_pd(a, b, _CMP_GT_OQ); 399 } 400 401 __m256d test_mm256_cmp_pd_true_us(__m256d a, __m256d b) { 402 // CHECK-LABEL: test_mm256_cmp_pd_true_us 403 // CHECK: fcmp true <4 x double> %{{.*}}, %{{.*}} 404 return _mm256_cmp_pd(a, b, _CMP_TRUE_US); 405 } 406 407 __m256 test_mm256_cmp_ps_eq_oq(__m256 a, __m256 b) { 408 // CHECK-LABEL: @test_mm256_cmp_ps_eq_oq 409 // CHECK: fcmp oeq <8 x float> %{{.*}}, %{{.*}} 410 return _mm256_cmp_ps(a, b, _CMP_EQ_OQ); 411 } 412 413 __m256 test_mm256_cmp_ps_lt_os(__m256 a, __m256 b) { 414 // CHECK-LABEL: test_mm256_cmp_ps_lt_os 415 // CHECK: fcmp olt <8 x float> %{{.*}}, %{{.*}} 416 return _mm256_cmp_ps(a, b, _CMP_LT_OS); 417 } 418 419 __m256 test_mm256_cmp_ps_le_os(__m256 a, __m256 b) { 420 // CHECK-LABEL: test_mm256_cmp_ps_le_os 421 // CHECK: fcmp ole <8 x float> %{{.*}}, %{{.*}} 422 return _mm256_cmp_ps(a, b, _CMP_LE_OS); 423 } 424 425 __m256 test_mm256_cmp_ps_unord_q(__m256 a, __m256 b) { 426 // CHECK-LABEL: test_mm256_cmp_ps_unord_q 427 // CHECK: fcmp uno <8 x float> %{{.*}}, %{{.*}} 428 return _mm256_cmp_ps(a, b, _CMP_UNORD_Q); 429 } 430 431 __m256 test_mm256_cmp_ps_neq_uq(__m256 a, __m256 b) { 432 // CHECK-LABEL: test_mm256_cmp_ps_neq_uq 433 // CHECK: fcmp une <8 x float> %{{.*}}, %{{.*}} 434 return _mm256_cmp_ps(a, b, _CMP_NEQ_UQ); 435 } 436 437 __m256 test_mm256_cmp_ps_nlt_us(__m256 a, __m256 b) { 438 // CHECK-LABEL: test_mm256_cmp_ps_nlt_us 439 // CHECK: fcmp uge <8 x float> %{{.*}}, %{{.*}} 440 return _mm256_cmp_ps(a, b, _CMP_NLT_US); 441 } 442 443 __m256 test_mm256_cmp_ps_nle_us(__m256 a, __m256 b) { 444 // CHECK-LABEL: test_mm256_cmp_ps_nle_us 445 // CHECK: fcmp ugt <8 x float> %{{.*}}, %{{.*}} 446 return _mm256_cmp_ps(a, b, _CMP_NLE_US); 447 } 448 449 __m256 test_mm256_cmp_ps_ord_q(__m256 a, __m256 b) { 450 // CHECK-LABEL: test_mm256_cmp_ps_ord_q 451 // CHECK: fcmp ord <8 x float> %{{.*}}, %{{.*}} 452 return _mm256_cmp_ps(a, b, _CMP_ORD_Q); 453 } 454 455 __m256 test_mm256_cmp_ps_eq_uq(__m256 a, __m256 b) { 456 // CHECK-LABEL: test_mm256_cmp_ps_eq_uq 457 // CHECK: fcmp ueq <8 x float> %{{.*}}, %{{.*}} 458 return _mm256_cmp_ps(a, b, _CMP_EQ_UQ); 459 } 460 461 __m256 test_mm256_cmp_ps_nge_us(__m256 a, __m256 b) { 462 // CHECK-LABEL: test_mm256_cmp_ps_nge_us 463 // CHECK: fcmp ult <8 x float> %{{.*}}, %{{.*}} 464 return _mm256_cmp_ps(a, b, _CMP_NGE_US); 465 } 466 467 __m256 test_mm256_cmp_ps_ngt_us(__m256 a, __m256 b) { 468 // CHECK-LABEL: test_mm256_cmp_ps_ngt_us 469 // CHECK: fcmp ule <8 x float> %{{.*}}, %{{.*}} 470 return _mm256_cmp_ps(a, b, _CMP_NGT_US); 471 } 472 473 __m256 test_mm256_cmp_ps_false_oq(__m256 a, __m256 b) { 474 // CHECK-LABEL: test_mm256_cmp_ps_false_oq 475 // CHECK: fcmp false <8 x float> %{{.*}}, %{{.*}} 476 return _mm256_cmp_ps(a, b, _CMP_FALSE_OQ); 477 } 478 479 __m256 test_mm256_cmp_ps_neq_oq(__m256 a, __m256 b) { 480 // CHECK-LABEL: test_mm256_cmp_ps_neq_oq 481 // CHECK: fcmp one <8 x float> %{{.*}}, %{{.*}} 482 return _mm256_cmp_ps(a, b, _CMP_NEQ_OQ); 483 } 484 485 __m256 test_mm256_cmp_ps_ge_os(__m256 a, __m256 b) { 486 // CHECK-LABEL: test_mm256_cmp_ps_ge_os 487 // CHECK: fcmp oge <8 x float> %{{.*}}, %{{.*}} 488 return _mm256_cmp_ps(a, b, _CMP_GE_OS); 489 } 490 491 __m256 test_mm256_cmp_ps_gt_os(__m256 a, __m256 b) { 492 // CHECK-LABEL: test_mm256_cmp_ps_gt_os 493 // CHECK: fcmp ogt <8 x float> %{{.*}}, %{{.*}} 494 return _mm256_cmp_ps(a, b, _CMP_GT_OS); 495 } 496 497 __m256 test_mm256_cmp_ps_true_uq(__m256 a, __m256 b) { 498 // CHECK-LABEL: test_mm256_cmp_ps_true_uq 499 // CHECK: fcmp true <8 x float> %{{.*}}, %{{.*}} 500 return _mm256_cmp_ps(a, b, _CMP_TRUE_UQ); 501 } 502 503 __m256 test_mm256_cmp_ps_eq_os(__m256 a, __m256 b) { 504 // CHECK-LABEL: test_mm256_cmp_ps_eq_os 505 // CHECK: fcmp oeq <8 x float> %{{.*}}, %{{.*}} 506 return _mm256_cmp_ps(a, b, _CMP_EQ_OS); 507 } 508 509 __m256 test_mm256_cmp_ps_lt_oq(__m256 a, __m256 b) { 510 // CHECK-LABEL: test_mm256_cmp_ps_lt_oq 511 // CHECK: fcmp olt <8 x float> %{{.*}}, %{{.*}} 512 return _mm256_cmp_ps(a, b, _CMP_LT_OQ); 513 } 514 515 __m256 test_mm256_cmp_ps_le_oq(__m256 a, __m256 b) { 516 // CHECK-LABEL: test_mm256_cmp_ps_le_oq 517 // CHECK: fcmp ole <8 x float> %{{.*}}, %{{.*}} 518 return _mm256_cmp_ps(a, b, _CMP_LE_OQ); 519 } 520 521 __m256 test_mm256_cmp_ps_unord_s(__m256 a, __m256 b) { 522 // CHECK-LABEL: test_mm256_cmp_ps_unord_s 523 // CHECK: fcmp uno <8 x float> %{{.*}}, %{{.*}} 524 return _mm256_cmp_ps(a, b, _CMP_UNORD_S); 525 } 526 527 __m256 test_mm256_cmp_ps_neq_us(__m256 a, __m256 b) { 528 // CHECK-LABEL: test_mm256_cmp_ps_neq_us 529 // CHECK: fcmp une <8 x float> %{{.*}}, %{{.*}} 530 return _mm256_cmp_ps(a, b, _CMP_NEQ_US); 531 } 532 533 __m256 test_mm256_cmp_ps_nlt_uq(__m256 a, __m256 b) { 534 // CHECK-LABEL: test_mm256_cmp_ps_nlt_uq 535 // CHECK: fcmp uge <8 x float> %{{.*}}, %{{.*}} 536 return _mm256_cmp_ps(a, b, _CMP_NLT_UQ); 537 } 538 539 __m256 test_mm256_cmp_ps_nle_uq(__m256 a, __m256 b) { 540 // CHECK-LABEL: test_mm256_cmp_ps_nle_uq 541 // CHECK: fcmp ugt <8 x float> %{{.*}}, %{{.*}} 542 return _mm256_cmp_ps(a, b, _CMP_NLE_UQ); 543 } 544 545 __m256 test_mm256_cmp_ps_ord_s(__m256 a, __m256 b) { 546 // CHECK-LABEL: test_mm256_cmp_ps_ord_s 547 // CHECK: fcmp ord <8 x float> %{{.*}}, %{{.*}} 548 return _mm256_cmp_ps(a, b, _CMP_ORD_S); 549 } 550 551 __m256 test_mm256_cmp_ps_eq_us(__m256 a, __m256 b) { 552 // CHECK-LABEL: test_mm256_cmp_ps_eq_us 553 // CHECK: fcmp ueq <8 x float> %{{.*}}, %{{.*}} 554 return _mm256_cmp_ps(a, b, _CMP_EQ_US); 555 } 556 557 __m256 test_mm256_cmp_ps_nge_uq(__m256 a, __m256 b) { 558 // CHECK-LABEL: test_mm256_cmp_ps_nge_uq 559 // CHECK: fcmp ult <8 x float> %{{.*}}, %{{.*}} 560 return _mm256_cmp_ps(a, b, _CMP_NGE_UQ); 561 } 562 563 __m256 test_mm256_cmp_ps_ngt_uq(__m256 a, __m256 b) { 564 // CHECK-LABEL: test_mm256_cmp_ps_ngt_uq 565 // CHECK: fcmp ule <8 x float> %{{.*}}, %{{.*}} 566 return _mm256_cmp_ps(a, b, _CMP_NGT_UQ); 567 } 568 569 __m256 test_mm256_cmp_ps_false_os(__m256 a, __m256 b) { 570 // CHECK-LABEL: test_mm256_cmp_ps_false_os 571 // CHECK: fcmp false <8 x float> %{{.*}}, %{{.*}} 572 return _mm256_cmp_ps(a, b, _CMP_FALSE_OS); 573 } 574 575 __m256 test_mm256_cmp_ps_neq_os(__m256 a, __m256 b) { 576 // CHECK-LABEL: test_mm256_cmp_ps_neq_os 577 // CHECK: fcmp one <8 x float> %{{.*}}, %{{.*}} 578 return _mm256_cmp_ps(a, b, _CMP_NEQ_OS); 579 } 580 581 __m256 test_mm256_cmp_ps_ge_oq(__m256 a, __m256 b) { 582 // CHECK-LABEL: test_mm256_cmp_ps_ge_oq 583 // CHECK: fcmp oge <8 x float> %{{.*}}, %{{.*}} 584 return _mm256_cmp_ps(a, b, _CMP_GE_OQ); 585 } 586 587 __m256 test_mm256_cmp_ps_gt_oq(__m256 a, __m256 b) { 588 // CHECK-LABEL: test_mm256_cmp_ps_gt_oq 589 // CHECK: fcmp ogt <8 x float> %{{.*}}, %{{.*}} 590 return _mm256_cmp_ps(a, b, _CMP_GT_OQ); 591 } 592 593 __m256 test_mm256_cmp_ps_true_us(__m256 a, __m256 b) { 594 // CHECK-LABEL: test_mm256_cmp_ps_true_us 595 // CHECK: fcmp true <8 x float> %{{.*}}, %{{.*}} 596 return _mm256_cmp_ps(a, b, _CMP_TRUE_US); 597 } 598 599 __m128d test_mm_cmp_pd_eq_oq(__m128d a, __m128d b) { 600 // CHECK-LABEL: @test_mm_cmp_pd_eq_oq 601 // CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}} 602 return _mm_cmp_pd(a, b, _CMP_EQ_OQ); 603 } 604 605 __m128d test_mm_cmp_pd_lt_os(__m128d a, __m128d b) { 606 // CHECK-LABEL: test_mm_cmp_pd_lt_os 607 // CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}} 608 return _mm_cmp_pd(a, b, _CMP_LT_OS); 609 } 610 611 __m128d test_mm_cmp_pd_le_os(__m128d a, __m128d b) { 612 // CHECK-LABEL: test_mm_cmp_pd_le_os 613 // CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}} 614 return _mm_cmp_pd(a, b, _CMP_LE_OS); 615 } 616 617 __m128d test_mm_cmp_pd_unord_q(__m128d a, __m128d b) { 618 // CHECK-LABEL: test_mm_cmp_pd_unord_q 619 // CHECK: fcmp uno <2 x double> %{{.*}}, %{{.*}} 620 return _mm_cmp_pd(a, b, _CMP_UNORD_Q); 621 } 622 623 __m128d test_mm_cmp_pd_neq_uq(__m128d a, __m128d b) { 624 // CHECK-LABEL: test_mm_cmp_pd_neq_uq 625 // CHECK: fcmp une <2 x double> %{{.*}}, %{{.*}} 626 return _mm_cmp_pd(a, b, _CMP_NEQ_UQ); 627 } 628 629 __m128d test_mm_cmp_pd_nlt_us(__m128d a, __m128d b) { 630 // CHECK-LABEL: test_mm_cmp_pd_nlt_us 631 // CHECK: fcmp uge <2 x double> %{{.*}}, %{{.*}} 632 return _mm_cmp_pd(a, b, _CMP_NLT_US); 633 } 634 635 __m128d test_mm_cmp_pd_nle_us(__m128d a, __m128d b) { 636 // CHECK-LABEL: test_mm_cmp_pd_nle_us 637 // CHECK: fcmp ugt <2 x double> %{{.*}}, %{{.*}} 638 return _mm_cmp_pd(a, b, _CMP_NLE_US); 639 } 640 641 __m128d test_mm_cmp_pd_ord_q(__m128d a, __m128d b) { 642 // CHECK-LABEL: test_mm_cmp_pd_ord_q 643 // CHECK: fcmp ord <2 x double> %{{.*}}, %{{.*}} 644 return _mm_cmp_pd(a, b, _CMP_ORD_Q); 645 } 646 647 __m128d test_mm_cmp_pd_eq_uq(__m128d a, __m128d b) { 648 // CHECK-LABEL: test_mm_cmp_pd_eq_uq 649 // CHECK: fcmp ueq <2 x double> %{{.*}}, %{{.*}} 650 return _mm_cmp_pd(a, b, _CMP_EQ_UQ); 651 } 652 653 __m128d test_mm_cmp_pd_nge_us(__m128d a, __m128d b) { 654 // CHECK-LABEL: test_mm_cmp_pd_nge_us 655 // CHECK: fcmp ult <2 x double> %{{.*}}, %{{.*}} 656 return _mm_cmp_pd(a, b, _CMP_NGE_US); 657 } 658 659 __m128d test_mm_cmp_pd_ngt_us(__m128d a, __m128d b) { 660 // CHECK-LABEL: test_mm_cmp_pd_ngt_us 661 // CHECK: fcmp ule <2 x double> %{{.*}}, %{{.*}} 662 return _mm_cmp_pd(a, b, _CMP_NGT_US); 663 } 664 665 __m128d test_mm_cmp_pd_false_oq(__m128d a, __m128d b) { 666 // CHECK-LABEL: test_mm_cmp_pd_false_oq 667 // CHECK: fcmp false <2 x double> %{{.*}}, %{{.*}} 668 return _mm_cmp_pd(a, b, _CMP_FALSE_OQ); 669 } 670 671 __m128d test_mm_cmp_pd_neq_oq(__m128d a, __m128d b) { 672 // CHECK-LABEL: test_mm_cmp_pd_neq_oq 673 // CHECK: fcmp one <2 x double> %{{.*}}, %{{.*}} 674 return _mm_cmp_pd(a, b, _CMP_NEQ_OQ); 675 } 676 677 __m128d test_mm_cmp_pd_ge_os(__m128d a, __m128d b) { 678 // CHECK-LABEL: test_mm_cmp_pd_ge_os 679 // CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}} 680 return _mm_cmp_pd(a, b, _CMP_GE_OS); 681 } 682 683 __m128d test_mm_cmp_pd_gt_os(__m128d a, __m128d b) { 684 // CHECK-LABEL: test_mm_cmp_pd_gt_os 685 // CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}} 686 return _mm_cmp_pd(a, b, _CMP_GT_OS); 687 } 688 689 __m128d test_mm_cmp_pd_true_uq(__m128d a, __m128d b) { 690 // CHECK-LABEL: test_mm_cmp_pd_true_uq 691 // CHECK: fcmp true <2 x double> %{{.*}}, %{{.*}} 692 return _mm_cmp_pd(a, b, _CMP_TRUE_UQ); 693 } 694 695 __m128d test_mm_cmp_pd_eq_os(__m128d a, __m128d b) { 696 // CHECK-LABEL: test_mm_cmp_pd_eq_os 697 // CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}} 698 return _mm_cmp_pd(a, b, _CMP_EQ_OS); 699 } 700 701 __m128d test_mm_cmp_pd_lt_oq(__m128d a, __m128d b) { 702 // CHECK-LABEL: test_mm_cmp_pd_lt_oq 703 // CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}} 704 return _mm_cmp_pd(a, b, _CMP_LT_OQ); 705 } 706 707 __m128d test_mm_cmp_pd_le_oq(__m128d a, __m128d b) { 708 // CHECK-LABEL: test_mm_cmp_pd_le_oq 709 // CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}} 710 return _mm_cmp_pd(a, b, _CMP_LE_OQ); 711 } 712 713 __m128d test_mm_cmp_pd_unord_s(__m128d a, __m128d b) { 714 // CHECK-LABEL: test_mm_cmp_pd_unord_s 715 // CHECK: fcmp uno <2 x double> %{{.*}}, %{{.*}} 716 return _mm_cmp_pd(a, b, _CMP_UNORD_S); 717 } 718 719 __m128d test_mm_cmp_pd_neq_us(__m128d a, __m128d b) { 720 // CHECK-LABEL: test_mm_cmp_pd_neq_us 721 // CHECK: fcmp une <2 x double> %{{.*}}, %{{.*}} 722 return _mm_cmp_pd(a, b, _CMP_NEQ_US); 723 } 724 725 __m128d test_mm_cmp_pd_nlt_uq(__m128d a, __m128d b) { 726 // CHECK-LABEL: test_mm_cmp_pd_nlt_uq 727 // CHECK: fcmp uge <2 x double> %{{.*}}, %{{.*}} 728 return _mm_cmp_pd(a, b, _CMP_NLT_UQ); 729 } 730 731 __m128d test_mm_cmp_pd_nle_uq(__m128d a, __m128d b) { 732 // CHECK-LABEL: test_mm_cmp_pd_nle_uq 733 // CHECK: fcmp ugt <2 x double> %{{.*}}, %{{.*}} 734 return _mm_cmp_pd(a, b, _CMP_NLE_UQ); 735 } 736 737 __m128d test_mm_cmp_pd_ord_s(__m128d a, __m128d b) { 738 // CHECK-LABEL: test_mm_cmp_pd_ord_s 739 // CHECK: fcmp ord <2 x double> %{{.*}}, %{{.*}} 740 return _mm_cmp_pd(a, b, _CMP_ORD_S); 741 } 742 743 __m128d test_mm_cmp_pd_eq_us(__m128d a, __m128d b) { 744 // CHECK-LABEL: test_mm_cmp_pd_eq_us 745 // CHECK: fcmp ueq <2 x double> %{{.*}}, %{{.*}} 746 return _mm_cmp_pd(a, b, _CMP_EQ_US); 747 } 748 749 __m128d test_mm_cmp_pd_nge_uq(__m128d a, __m128d b) { 750 // CHECK-LABEL: test_mm_cmp_pd_nge_uq 751 // CHECK: fcmp ult <2 x double> %{{.*}}, %{{.*}} 752 return _mm_cmp_pd(a, b, _CMP_NGE_UQ); 753 } 754 755 __m128d test_mm_cmp_pd_ngt_uq(__m128d a, __m128d b) { 756 // CHECK-LABEL: test_mm_cmp_pd_ngt_uq 757 // CHECK: fcmp ule <2 x double> %{{.*}}, %{{.*}} 758 return _mm_cmp_pd(a, b, _CMP_NGT_UQ); 759 } 760 761 __m128d test_mm_cmp_pd_false_os(__m128d a, __m128d b) { 762 // CHECK-LABEL: test_mm_cmp_pd_false_os 763 // CHECK: fcmp false <2 x double> %{{.*}}, %{{.*}} 764 return _mm_cmp_pd(a, b, _CMP_FALSE_OS); 765 } 766 767 __m128d test_mm_cmp_pd_neq_os(__m128d a, __m128d b) { 768 // CHECK-LABEL: test_mm_cmp_pd_neq_os 769 // CHECK: fcmp one <2 x double> %{{.*}}, %{{.*}} 770 return _mm_cmp_pd(a, b, _CMP_NEQ_OS); 771 } 772 773 __m128d test_mm_cmp_pd_ge_oq(__m128d a, __m128d b) { 774 // CHECK-LABEL: test_mm_cmp_pd_ge_oq 775 // CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}} 776 return _mm_cmp_pd(a, b, _CMP_GE_OQ); 777 } 778 779 __m128d test_mm_cmp_pd_gt_oq(__m128d a, __m128d b) { 780 // CHECK-LABEL: test_mm_cmp_pd_gt_oq 781 // CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}} 782 return _mm_cmp_pd(a, b, _CMP_GT_OQ); 783 } 784 785 __m128d test_mm_cmp_pd_true_us(__m128d a, __m128d b) { 786 // CHECK-LABEL: test_mm_cmp_pd_true_us 787 // CHECK: fcmp true <2 x double> %{{.*}}, %{{.*}} 788 return _mm_cmp_pd(a, b, _CMP_TRUE_US); 789 } 790 791 __m128 test_mm_cmp_ps_eq_oq(__m128 a, __m128 b) { 792 // CHECK-LABEL: @test_mm_cmp_ps_eq_oq 793 // CHECK: fcmp oeq <4 x float> %{{.*}}, %{{.*}} 794 return _mm_cmp_ps(a, b, _CMP_EQ_OQ); 795 } 796 797 __m128 test_mm_cmp_ps_lt_os(__m128 a, __m128 b) { 798 // CHECK-LABEL: test_mm_cmp_ps_lt_os 799 // CHECK: fcmp olt <4 x float> %{{.*}}, %{{.*}} 800 return _mm_cmp_ps(a, b, _CMP_LT_OS); 801 } 802 803 __m128 test_mm_cmp_ps_le_os(__m128 a, __m128 b) { 804 // CHECK-LABEL: test_mm_cmp_ps_le_os 805 // CHECK: fcmp ole <4 x float> %{{.*}}, %{{.*}} 806 return _mm_cmp_ps(a, b, _CMP_LE_OS); 807 } 808 809 __m128 test_mm_cmp_ps_unord_q(__m128 a, __m128 b) { 810 // CHECK-LABEL: test_mm_cmp_ps_unord_q 811 // CHECK: fcmp uno <4 x float> %{{.*}}, %{{.*}} 812 return _mm_cmp_ps(a, b, _CMP_UNORD_Q); 813 } 814 815 __m128 test_mm_cmp_ps_neq_uq(__m128 a, __m128 b) { 816 // CHECK-LABEL: test_mm_cmp_ps_neq_uq 817 // CHECK: fcmp une <4 x float> %{{.*}}, %{{.*}} 818 return _mm_cmp_ps(a, b, _CMP_NEQ_UQ); 819 } 820 821 __m128 test_mm_cmp_ps_nlt_us(__m128 a, __m128 b) { 822 // CHECK-LABEL: test_mm_cmp_ps_nlt_us 823 // CHECK: fcmp uge <4 x float> %{{.*}}, %{{.*}} 824 return _mm_cmp_ps(a, b, _CMP_NLT_US); 825 } 826 827 __m128 test_mm_cmp_ps_nle_us(__m128 a, __m128 b) { 828 // CHECK-LABEL: test_mm_cmp_ps_nle_us 829 // CHECK: fcmp ugt <4 x float> %{{.*}}, %{{.*}} 830 return _mm_cmp_ps(a, b, _CMP_NLE_US); 831 } 832 833 __m128 test_mm_cmp_ps_ord_q(__m128 a, __m128 b) { 834 // CHECK-LABEL: test_mm_cmp_ps_ord_q 835 // CHECK: fcmp ord <4 x float> %{{.*}}, %{{.*}} 836 return _mm_cmp_ps(a, b, _CMP_ORD_Q); 837 } 838 839 __m128 test_mm_cmp_ps_eq_uq(__m128 a, __m128 b) { 840 // CHECK-LABEL: test_mm_cmp_ps_eq_uq 841 // CHECK: fcmp ueq <4 x float> %{{.*}}, %{{.*}} 842 return _mm_cmp_ps(a, b, _CMP_EQ_UQ); 843 } 844 845 __m128 test_mm_cmp_ps_nge_us(__m128 a, __m128 b) { 846 // CHECK-LABEL: test_mm_cmp_ps_nge_us 847 // CHECK: fcmp ult <4 x float> %{{.*}}, %{{.*}} 848 return _mm_cmp_ps(a, b, _CMP_NGE_US); 849 } 850 851 __m128 test_mm_cmp_ps_ngt_us(__m128 a, __m128 b) { 852 // CHECK-LABEL: test_mm_cmp_ps_ngt_us 853 // CHECK: fcmp ule <4 x float> %{{.*}}, %{{.*}} 854 return _mm_cmp_ps(a, b, _CMP_NGT_US); 855 } 856 857 __m128 test_mm_cmp_ps_false_oq(__m128 a, __m128 b) { 858 // CHECK-LABEL: test_mm_cmp_ps_false_oq 859 // CHECK: fcmp false <4 x float> %{{.*}}, %{{.*}} 860 return _mm_cmp_ps(a, b, _CMP_FALSE_OQ); 861 } 862 863 __m128 test_mm_cmp_ps_neq_oq(__m128 a, __m128 b) { 864 // CHECK-LABEL: test_mm_cmp_ps_neq_oq 865 // CHECK: fcmp one <4 x float> %{{.*}}, %{{.*}} 866 return _mm_cmp_ps(a, b, _CMP_NEQ_OQ); 867 } 868 869 __m128 test_mm_cmp_ps_ge_os(__m128 a, __m128 b) { 870 // CHECK-LABEL: test_mm_cmp_ps_ge_os 871 // CHECK: fcmp oge <4 x float> %{{.*}}, %{{.*}} 872 return _mm_cmp_ps(a, b, _CMP_GE_OS); 873 } 874 875 __m128 test_mm_cmp_ps_gt_os(__m128 a, __m128 b) { 876 // CHECK-LABEL: test_mm_cmp_ps_gt_os 877 // CHECK: fcmp ogt <4 x float> %{{.*}}, %{{.*}} 878 return _mm_cmp_ps(a, b, _CMP_GT_OS); 879 } 880 881 __m128 test_mm_cmp_ps_true_uq(__m128 a, __m128 b) { 882 // CHECK-LABEL: test_mm_cmp_ps_true_uq 883 // CHECK: fcmp true <4 x float> %{{.*}}, %{{.*}} 884 return _mm_cmp_ps(a, b, _CMP_TRUE_UQ); 885 } 886 887 __m128 test_mm_cmp_ps_eq_os(__m128 a, __m128 b) { 888 // CHECK-LABEL: test_mm_cmp_ps_eq_os 889 // CHECK: fcmp oeq <4 x float> %{{.*}}, %{{.*}} 890 return _mm_cmp_ps(a, b, _CMP_EQ_OS); 891 } 892 893 __m128 test_mm_cmp_ps_lt_oq(__m128 a, __m128 b) { 894 // CHECK-LABEL: test_mm_cmp_ps_lt_oq 895 // CHECK: fcmp olt <4 x float> %{{.*}}, %{{.*}} 896 return _mm_cmp_ps(a, b, _CMP_LT_OQ); 897 } 898 899 __m128 test_mm_cmp_ps_le_oq(__m128 a, __m128 b) { 900 // CHECK-LABEL: test_mm_cmp_ps_le_oq 901 // CHECK: fcmp ole <4 x float> %{{.*}}, %{{.*}} 902 return _mm_cmp_ps(a, b, _CMP_LE_OQ); 903 } 904 905 __m128 test_mm_cmp_ps_unord_s(__m128 a, __m128 b) { 906 // CHECK-LABEL: test_mm_cmp_ps_unord_s 907 // CHECK: fcmp uno <4 x float> %{{.*}}, %{{.*}} 908 return _mm_cmp_ps(a, b, _CMP_UNORD_S); 909 } 910 911 __m128 test_mm_cmp_ps_neq_us(__m128 a, __m128 b) { 912 // CHECK-LABEL: test_mm_cmp_ps_neq_us 913 // CHECK: fcmp une <4 x float> %{{.*}}, %{{.*}} 914 return _mm_cmp_ps(a, b, _CMP_NEQ_US); 915 } 916 917 __m128 test_mm_cmp_ps_nlt_uq(__m128 a, __m128 b) { 918 // CHECK-LABEL: test_mm_cmp_ps_nlt_uq 919 // CHECK: fcmp uge <4 x float> %{{.*}}, %{{.*}} 920 return _mm_cmp_ps(a, b, _CMP_NLT_UQ); 921 } 922 923 __m128 test_mm_cmp_ps_nle_uq(__m128 a, __m128 b) { 924 // CHECK-LABEL: test_mm_cmp_ps_nle_uq 925 // CHECK: fcmp ugt <4 x float> %{{.*}}, %{{.*}} sysctl( name: *mut ::c_int, namelen: ::c_int, oldp: *mut ::c_void, oldlenp: *mut ::size_t, newp: *mut ::c_void, newlen: ::size_t, ) -> ::c_int926 return _mm_cmp_ps(a, b, _CMP_NLE_UQ); 927 } 928 929 __m128 test_mm_cmp_ps_ord_s(__m128 a, __m128 b) { 930 // CHECK-LABEL: test_mm_cmp_ps_ord_s 931 // CHECK: fcmp ord <4 x float> %{{.*}}, %{{.*}} 932 return _mm_cmp_ps(a, b, _CMP_ORD_S); 933 } 934 935 __m128 test_mm_cmp_ps_eq_us(__m128 a, __m128 b) { 936 // CHECK-LABEL: test_mm_cmp_ps_eq_us 937 // CHECK: fcmp ueq <4 x float> %{{.*}}, %{{.*}} 938 return _mm_cmp_ps(a, b, _CMP_EQ_US); 939 } 940 941 __m128 test_mm_cmp_ps_nge_uq(__m128 a, __m128 b) { 942 // CHECK-LABEL: test_mm_cmp_ps_nge_uq 943 // CHECK: fcmp ult <4 x float> %{{.*}}, %{{.*}} 944 return _mm_cmp_ps(a, b, _CMP_NGE_UQ); 945 } 946 947 __m128 test_mm_cmp_ps_ngt_uq(__m128 a, __m128 b) { 948 // CHECK-LABEL: test_mm_cmp_ps_ngt_uq 949 // CHECK: fcmp ule <4 x float> %{{.*}}, %{{.*}} 950 return _mm_cmp_ps(a, b, _CMP_NGT_UQ); 951 } 952 953 __m128 test_mm_cmp_ps_false_os(__m128 a, __m128 b) { 954 // CHECK-LABEL: test_mm_cmp_ps_false_os 955 // CHECK: fcmp false <4 x float> %{{.*}}, %{{.*}} 956 return _mm_cmp_ps(a, b, _CMP_FALSE_OS); 957 } 958 959 __m128 test_mm_cmp_ps_neq_os(__m128 a, __m128 b) { 960 // CHECK-LABEL: test_mm_cmp_ps_neq_os 961 // CHECK: fcmp one <4 x float> %{{.*}}, %{{.*}} 962 return _mm_cmp_ps(a, b, _CMP_NEQ_OS); 963 } 964 965 __m128 test_mm_cmp_ps_ge_oq(__m128 a, __m128 b) { 966 // CHECK-LABEL: test_mm_cmp_ps_ge_oq 967 // CHECK: fcmp oge <4 x float> %{{.*}}, %{{.*}} 968 return _mm_cmp_ps(a, b, _CMP_GE_OQ); 969 } 970 971 __m128 test_mm_cmp_ps_gt_oq(__m128 a, __m128 b) { 972 // CHECK-LABEL: test_mm_cmp_ps_gt_oq 973 // CHECK: fcmp ogt <4 x float> %{{.*}}, %{{.*}} 974 return _mm_cmp_ps(a, b, _CMP_GT_OQ); 975 } 976 977 __m128 test_mm_cmp_ps_true_us(__m128 a, __m128 b) { 978 // CHECK-LABEL: test_mm_cmp_ps_true_us 979 // CHECK: fcmp true <4 x float> %{{.*}}, %{{.*}} 980 return _mm_cmp_ps(a, b, _CMP_TRUE_US); 981 } 982 983 __m128d test_mm_cmp_sd(__m128d A, __m128d B) { 984 // CHECK-LABEL: test_mm_cmp_sd 985 // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 13) 986 return _mm_cmp_sd(A, B, _CMP_GE_OS); 987 } 988 989 __m128 test_mm_cmp_ss(__m128 A, __m128 B) { 990 // CHECK-LABEL: test_mm_cmp_ss 991 // CHECK: call <4 x float> @llvm.x86.sse.cmp.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 13) 992 return _mm_cmp_ss(A, B, _CMP_GE_OS); 993 } 994 995 __m256d test_mm256_cvtepi32_pd(__m128i A) { 996 // CHECK-LABEL: test_mm256_cvtepi32_pd 997 // CHECK: sitofp <4 x i32> %{{.*}} to <4 x double> 998 return _mm256_cvtepi32_pd(A); 999 } 1000 1001 __m256 test_mm256_cvtepi32_ps(__m256i A) { 1002 // CHECK-LABEL: test_mm256_cvtepi32_ps 1003 // CHECK: sitofp <8 x i32> %{{.*}} to <8 x float> 1004 return _mm256_cvtepi32_ps(A); 1005 } 1006 1007 __m128i test_mm256_cvtpd_epi32(__m256d A) { 1008 // CHECK-LABEL: test_mm256_cvtpd_epi32 1009 // CHECK: call <4 x i32> @llvm.x86.avx.cvt.pd2dq.256(<4 x double> %{{.*}}) 1010 return _mm256_cvtpd_epi32(A); 1011 } 1012 1013 __m128 test_mm256_cvtpd_ps(__m256d A) { 1014 // CHECK-LABEL: test_mm256_cvtpd_ps 1015 // CHECK: call <4 x float> @llvm.x86.avx.cvt.pd2.ps.256(<4 x double> %{{.*}}) 1016 return _mm256_cvtpd_ps(A); 1017 } 1018 1019 __m256i test_mm256_cvtps_epi32(__m256 A) { 1020 // CHECK-LABEL: test_mm256_cvtps_epi32 1021 // CHECK: call <8 x i32> @llvm.x86.avx.cvt.ps2dq.256(<8 x float> %{{.*}}) 1022 return _mm256_cvtps_epi32(A); 1023 } 1024 1025 __m256d test_mm256_cvtps_pd(__m128 A) { 1026 // CHECK-LABEL: test_mm256_cvtps_pd 1027 // CHECK: fpext <4 x float> %{{.*}} to <4 x double> 1028 return _mm256_cvtps_pd(A); 1029 } 1030 1031 __m128i test_mm256_cvttpd_epi32(__m256d A) { 1032 // CHECK-LABEL: test_mm256_cvttpd_epi32 1033 // CHECK: call <4 x i32> @llvm.x86.avx.cvtt.pd2dq.256(<4 x double> %{{.*}}) 1034 return _mm256_cvttpd_epi32(A); 1035 } 1036 1037 __m256i test_mm256_cvttps_epi32(__m256 A) { 1038 // CHECK-LABEL: test_mm256_cvttps_epi32 1039 // CHECK: call <8 x i32> @llvm.x86.avx.cvtt.ps2dq.256(<8 x float> %{{.*}}) 1040 return _mm256_cvttps_epi32(A); 1041 } 1042 1043 __m256d test_mm256_div_pd(__m256d A, __m256d B) { 1044 // CHECK-LABEL: test_mm256_div_pd 1045 // CHECK: fdiv <4 x double> 1046 return _mm256_div_pd(A, B); 1047 } 1048 1049 __m256 test_mm256_div_ps(__m256 A, __m256 B) { 1050 // CHECK-LABEL: test_mm256_div_ps 1051 // CHECK: fdiv <8 x float> 1052 return _mm256_div_ps(A, B); 1053 } 1054 1055 __m256 test_mm256_dp_ps(__m256 A, __m256 B) { 1056 // CHECK-LABEL: test_mm256_dp_ps 1057 // CHECK: call <8 x float> @llvm.x86.avx.dp.ps.256(<8 x float> {{.*}}, <8 x float> {{.*}}, i8 7) 1058 return _mm256_dp_ps(A, B, 7); 1059 } 1060 1061 int test_mm256_extract_epi8(__m256i A) { 1062 // CHECK-LABEL: test_mm256_extract_epi8 1063 // CHECK: extractelement <32 x i8> %{{.*}}, {{i32|i64}} 31 1064 // CHECK: zext i8 %{{.*}} to i32 1065 return _mm256_extract_epi8(A, 31); 1066 } 1067 1068 int test_mm256_extract_epi16(__m256i A) { 1069 // CHECK-LABEL: test_mm256_extract_epi16 1070 // CHECK: extractelement <16 x i16> %{{.*}}, {{i32|i64}} 15 1071 // CHECK: zext i16 %{{.*}} to i32 1072 return _mm256_extract_epi16(A, 15); 1073 } 1074 1075 int test_mm256_extract_epi32(__m256i A) { 1076 // CHECK-LABEL: test_mm256_extract_epi32 1077 // CHECK: extractelement <8 x i32> %{{.*}}, {{i32|i64}} 7 1078 return _mm256_extract_epi32(A, 7); 1079 } 1080 1081 long long test_mm256_extract_epi64(__m256i A) { 1082 // CHECK-LABEL: test_mm256_extract_epi64 1083 // CHECK: extractelement <4 x i64> %{{.*}}, {{i32|i64}} 3 1084 return _mm256_extract_epi64(A, 3); 1085 } 1086 1087 __m128d test_mm256_extractf128_pd(__m256d A) { 1088 // CHECK-LABEL: test_mm256_extractf128_pd 1089 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> undef, <2 x i32> <i32 2, i32 3> 1090 return _mm256_extractf128_pd(A, 1); 1091 } 1092 1093 __m128 test_mm256_extractf128_ps(__m256 A) { 1094 // CHECK-LABEL: test_mm256_extractf128_ps 1095 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7> 1096 return _mm256_extractf128_ps(A, 1); 1097 } 1098 1099 __m128i test_mm256_extractf128_si256(__m256i A) { 1100 // CHECK-LABEL: test_mm256_extractf128_si256 1101 // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7> 1102 return _mm256_extractf128_si256(A, 1); 1103 } 1104 1105 __m256d test_mm256_floor_pd(__m256d x) { 1106 // CHECK-LABEL: test_mm256_floor_pd 1107 // CHECK: call <4 x double> @llvm.x86.avx.round.pd.256(<4 x double> %{{.*}}, i32 1) 1108 return _mm256_floor_pd(x); 1109 } 1110 1111 __m256 test_mm_floor_ps(__m256 x) { 1112 // CHECK-LABEL: test_mm_floor_ps 1113 // CHECK: call <8 x float> @llvm.x86.avx.round.ps.256(<8 x float> %{{.*}}, i32 1) 1114 return _mm256_floor_ps(x); 1115 } 1116 1117 __m256d test_mm256_hadd_pd(__m256d A, __m256d B) { 1118 // CHECK-LABEL: test_mm256_hadd_pd 1119 // CHECK: call <4 x double> @llvm.x86.avx.hadd.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}) 1120 return _mm256_hadd_pd(A, B); 1121 } 1122 1123 __m256 test_mm256_hadd_ps(__m256 A, __m256 B) { 1124 // CHECK-LABEL: test_mm256_hadd_ps 1125 // CHECK: call <8 x float> @llvm.x86.avx.hadd.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}) 1126 return _mm256_hadd_ps(A, B); 1127 } 1128 1129 __m256d test_mm256_hsub_pd(__m256d A, __m256d B) { 1130 // CHECK-LABEL: test_mm256_hsub_pd 1131 // CHECK: call <4 x double> @llvm.x86.avx.hsub.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}) 1132 return _mm256_hsub_pd(A, B); 1133 } 1134 1135 __m256 test_mm256_hsub_ps(__m256 A, __m256 B) { 1136 // CHECK-LABEL: test_mm256_hsub_ps 1137 // CHECK: call <8 x float> @llvm.x86.avx.hsub.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}) 1138 return _mm256_hsub_ps(A, B); 1139 } 1140 1141 __m256i test_mm256_insert_epi8(__m256i x, char b) { 1142 // CHECK-LABEL: test_mm256_insert_epi8 1143 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, {{i32|i64}} 14 1144 return _mm256_insert_epi8(x, b, 14); 1145 } 1146 1147 __m256i test_mm256_insert_epi16(__m256i x, int b) { 1148 // CHECK-LABEL: test_mm256_insert_epi16 1149 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, {{i32|i64}} 4 1150 return _mm256_insert_epi16(x, b, 4); 1151 } 1152 1153 __m256i test_mm256_insert_epi32(__m256i x, int b) { 1154 // CHECK-LABEL: test_mm256_insert_epi32 1155 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, {{i32|i64}} 5 1156 return _mm256_insert_epi32(x, b, 5); 1157 } 1158 1159 __m256i test_mm256_insert_epi64(__m256i x, long long b) { 1160 // CHECK-LABEL: test_mm256_insert_epi64 1161 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, {{i32|i64}} 2 1162 return _mm256_insert_epi64(x, b, 2); 1163 } 1164 1165 __m256d test_mm256_insertf128_pd(__m256d A, __m128d B) { 1166 // CHECK-LABEL: test_mm256_insertf128_pd 1167 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 1168 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 4, i32 5, i32 2, i32 3> 1169 return _mm256_insertf128_pd(A, B, 0); 1170 } 1171 1172 __m256 test_mm256_insertf128_ps(__m256 A, __m128 B) { 1173 // CHECK-LABEL: test_mm256_insertf128_ps 1174 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 1175 // 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> 1176 return _mm256_insertf128_ps(A, B, 1); 1177 } 1178 1179 __m256i test_mm256_insertf128_si256(__m256i A, __m128i B) { 1180 // CHECK-LABEL: test_mm256_insertf128_si256 1181 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 1182 // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 8, i32 9, i32 10, i32 11, i32 4, i32 5, i32 6, i32 7> 1183 return _mm256_insertf128_si256(A, B, 0); 1184 } 1185 1186 __m256i test_mm256_lddqu_si256(__m256i* A) { 1187 // CHECK-LABEL: test_mm256_lddqu_si256 1188 // CHECK: call <32 x i8> @llvm.x86.avx.ldu.dq.256(i8* %{{.*}}) 1189 return _mm256_lddqu_si256(A); 1190 } 1191 1192 __m256d test_mm256_load_pd(double* A) { 1193 // CHECK-LABEL: test_mm256_load_pd 1194 // CHECK: load <4 x double>, <4 x double>* %{{.*}}, align 32 1195 return _mm256_load_pd(A); 1196 } 1197 1198 __m256 test_mm256_load_ps(float* A) { 1199 // CHECK-LABEL: test_mm256_load_ps 1200 // CHECK: load <8 x float>, <8 x float>* %{{.*}}, align 32 1201 return _mm256_load_ps(A); 1202 } 1203 1204 __m256i test_mm256_load_si256(__m256i* A) { 1205 // CHECK-LABEL: test_mm256_load_si256 1206 // CHECK: load <4 x i64>, <4 x i64>* %{{.*}}, align 32 1207 return _mm256_load_si256(A); 1208 } 1209 1210 __m256d test_mm256_loadu_pd(double* A) { 1211 // CHECK-LABEL: test_mm256_loadu_pd 1212 // CHECK: load <4 x double>, <4 x double>* %{{.*}}, align 1{{$}} 1213 return _mm256_loadu_pd(A); 1214 } 1215 1216 __m256 test_mm256_loadu_ps(float* A) { 1217 // CHECK-LABEL: test_mm256_loadu_ps 1218 // CHECK: load <8 x float>, <8 x float>* %{{.*}}, align 1{{$}} 1219 return _mm256_loadu_ps(A); 1220 } 1221 1222 __m256i test_mm256_loadu_si256(__m256i* A) { 1223 // CHECK-LABEL: test_mm256_loadu_si256 1224 // CHECK: load <4 x i64>, <4 x i64>* %{{.+}}, align 1{{$}} 1225 return _mm256_loadu_si256(A); 1226 } 1227 1228 __m256 test_mm256_loadu2_m128(float* A, float* B) { 1229 // CHECK-LABEL: test_mm256_loadu2_m128 1230 // CHECK: load <4 x float>, <4 x float>* %{{.*}}, align 1{{$}} 1231 // 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> 1232 // CHECK: load <4 x float>, <4 x float>* %{{.*}}, align 1{{$}} 1233 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 1234 // 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> 1235 return _mm256_loadu2_m128(A, B); 1236 } 1237 1238 __m256d test_mm256_loadu2_m128d(double* A, double* B) { 1239 // CHECK-LABEL: test_mm256_loadu2_m128d 1240 // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 1{{$}} 1241 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> 1242 // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 1{{$}} 1243 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 1244 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 4, i32 5> 1245 return _mm256_loadu2_m128d(A, B); 1246 } 1247 1248 __m256i test_mm256_loadu2_m128i(__m128i* A, __m128i* B) { 1249 // CHECK-LABEL: test_mm256_loadu2_m128i 1250 // CHECK: load <2 x i64>, <2 x i64>* %{{.*}}, align 1{{$}} 1251 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef> 1252 // CHECK: load <2 x i64>, <2 x i64>* %{{.*}}, align 1{{$}} 1253 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> undef, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 1254 // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11> 1255 return _mm256_loadu2_m128i(A, B); 1256 } 1257 1258 __m128d test_mm_maskload_pd(double* A, __m128i B) { 1259 // CHECK-LABEL: test_mm_maskload_pd 1260 // CHECK: call <2 x double> @llvm.x86.avx.maskload.pd(i8* %{{.*}}, <2 x i64> %{{.*}}) 1261 return _mm_maskload_pd(A, B); 1262 } 1263 1264 __m256d test_mm256_maskload_pd(double* A, __m256i B) { 1265 // CHECK-LABEL: test_mm256_maskload_pd 1266 // CHECK: call <4 x double> @llvm.x86.avx.maskload.pd.256(i8* %{{.*}}, <4 x i64> %{{.*}}) 1267 return _mm256_maskload_pd(A, B); 1268 } 1269 1270 __m128 test_mm_maskload_ps(float* A, __m128i B) { 1271 // CHECK-LABEL: test_mm_maskload_ps 1272 // CHECK: call <4 x float> @llvm.x86.avx.maskload.ps(i8* %{{.*}}, <4 x i32> %{{.*}}) 1273 return _mm_maskload_ps(A, B); 1274 } 1275 1276 __m256d test_mm256_maskload_ps(float* A, __m256i B) { 1277 // CHECK-LABEL: test_mm256_maskload_ps 1278 // CHECK: call <8 x float> @llvm.x86.avx.maskload.ps.256(i8* %{{.*}}, <8 x i32> %{{.*}}) 1279 return _mm256_maskload_ps(A, B); 1280 } 1281 1282 void test_mm_maskstore_pd(double* A, __m128i B, __m128d C) { 1283 // CHECK-LABEL: test_mm_maskstore_pd 1284 // CHECK: call void @llvm.x86.avx.maskstore.pd(i8* %{{.*}}, <2 x i64> %{{.*}}, <2 x double> %{{.*}}) 1285 _mm_maskstore_pd(A, B, C); 1286 } 1287 1288 void test_mm256_maskstore_pd(double* A, __m256i B, __m256d C) { 1289 // CHECK-LABEL: test_mm256_maskstore_pd 1290 // CHECK: call void @llvm.x86.avx.maskstore.pd.256(i8* %{{.*}}, <4 x i64> %{{.*}}, <4 x double> %{{.*}}) 1291 _mm256_maskstore_pd(A, B, C); 1292 } 1293 1294 void test_mm_maskstore_ps(float* A, __m128i B, __m128 C) { 1295 // CHECK-LABEL: test_mm_maskstore_ps 1296 // CHECK: call void @llvm.x86.avx.maskstore.ps(i8* %{{.*}}, <4 x i32> %{{.*}}, <4 x float> %{{.*}}) 1297 _mm_maskstore_ps(A, B, C); 1298 } 1299 1300 void test_mm256_maskstore_ps(float* A, __m256i B, __m256 C) { 1301 // CHECK-LABEL: test_mm256_maskstore_ps 1302 // CHECK: call void @llvm.x86.avx.maskstore.ps.256(i8* %{{.*}}, <8 x i32> %{{.*}}, <8 x float> %{{.*}}) 1303 _mm256_maskstore_ps(A, B, C); 1304 } 1305 1306 __m256d test_mm256_max_pd(__m256d A, __m256d B) { 1307 // CHECK-LABEL: test_mm256_max_pd 1308 // CHECK: call <4 x double> @llvm.x86.avx.max.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}) 1309 return _mm256_max_pd(A, B); 1310 } 1311 1312 __m256 test_mm256_max_ps(__m256 A, __m256 B) { 1313 // CHECK-LABEL: test_mm256_max_ps 1314 // CHECK: call <8 x float> @llvm.x86.avx.max.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}) 1315 return _mm256_max_ps(A, B); 1316 } 1317 1318 __m256d test_mm256_min_pd(__m256d A, __m256d B) { 1319 // CHECK-LABEL: test_mm256_min_pd 1320 // CHECK: call <4 x double> @llvm.x86.avx.min.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}) 1321 return _mm256_min_pd(A, B); 1322 } 1323 1324 __m256 test_mm256_min_ps(__m256 A, __m256 B) { 1325 // CHECK-LABEL: test_mm256_min_ps 1326 // CHECK: call <8 x float> @llvm.x86.avx.min.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}) 1327 return _mm256_min_ps(A, B); 1328 } 1329 1330 __m256d test_mm256_movedup_pd(__m256d A) { 1331 // CHECK-LABEL: test_mm256_movedup_pd 1332 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 0, i32 2, i32 2> 1333 return _mm256_movedup_pd(A); 1334 } 1335 1336 __m256 test_mm256_movehdup_ps(__m256 A) { 1337 // CHECK-LABEL: test_mm256_movehdup_ps 1338 // 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> 1339 return _mm256_movehdup_ps(A); 1340 } 1341 1342 __m256 test_mm256_moveldup_ps(__m256 A) { 1343 // CHECK-LABEL: test_mm256_moveldup_ps 1344 // 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> 1345 return _mm256_moveldup_ps(A); 1346 } 1347 1348 int test_mm256_movemask_pd(__m256d A) { 1349 // CHECK-LABEL: test_mm256_movemask_pd 1350 // CHECK: call i32 @llvm.x86.avx.movmsk.pd.256(<4 x double> %{{.*}}) 1351 return _mm256_movemask_pd(A); 1352 } 1353 1354 int test_mm256_movemask_ps(__m256 A) { 1355 // CHECK-LABEL: test_mm256_movemask_ps 1356 // CHECK: call i32 @llvm.x86.avx.movmsk.ps.256(<8 x float> %{{.*}}) 1357 return _mm256_movemask_ps(A); 1358 } 1359 1360 __m256d test_mm256_mul_pd(__m256d A, __m256d B) { 1361 // CHECK-LABEL: test_mm256_mul_pd 1362 // CHECK: fmul <4 x double> 1363 return _mm256_mul_pd(A, B); 1364 } 1365 1366 __m256 test_mm256_mul_ps(__m256 A, __m256 B) { 1367 // CHECK-LABEL: test_mm256_mul_ps 1368 // CHECK: fmul <8 x float> 1369 return _mm256_mul_ps(A, B); 1370 } 1371 1372 __m256d test_mm256_or_pd(__m256d A, __m256d B) { 1373 // CHECK-LABEL: test_mm256_or_pd 1374 // CHECK: or <4 x i64> 1375 return _mm256_or_pd(A, B); 1376 } 1377 1378 __m256 test_mm256_or_ps(__m256 A, __m256 B) { 1379 // CHECK-LABEL: test_mm256_or_ps 1380 // CHECK: or <8 x i32> 1381 return _mm256_or_ps(A, B); 1382 } 1383 1384 __m128d test_mm_permute_pd(__m128d A) { 1385 // CHECK-LABEL: test_mm_permute_pd 1386 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> undef, <2 x i32> <i32 1, i32 0> 1387 return _mm_permute_pd(A, 1); 1388 } 1389 1390 __m256d test_mm256_permute_pd(__m256d A) { 1391 // CHECK-LABEL: test_mm256_permute_pd 1392 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> undef, <4 x i32> <i32 1, i32 0, i32 3, i32 2> 1393 return _mm256_permute_pd(A, 5); 1394 } 1395 1396 __m128 test_mm_permute_ps(__m128 A) { 1397 // CHECK-LABEL: test_mm_permute_ps 1398 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <4 x i32> <i32 3, i32 2, i32 1, i32 0> 1399 return _mm_permute_ps(A, 0x1b); 1400 } 1401 1402 // Test case for PR12401 1403 __m128 test2_mm_permute_ps(__m128 a) { 1404 // CHECK-LABEL: test2_mm_permute_ps 1405 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> undef, <4 x i32> <i32 2, i32 1, i32 2, i32 3> 1406 return _mm_permute_ps(a, 0xe6); 1407 } 1408 1409 __m256 test_mm256_permute_ps(__m256 A) { 1410 // CHECK-LABEL: test_mm256_permute_ps 1411 // 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> 1412 return _mm256_permute_ps(A, 0x1b); 1413 } 1414 1415 __m256d test_mm256_permute2f128_pd(__m256d A, __m256d B) { 1416 // CHECK-LABEL: test_mm256_permute2f128_pd 1417 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 2, i32 3, i32 6, i32 7> 1418 return _mm256_permute2f128_pd(A, B, 0x31); 1419 } 1420 1421 __m256 test_mm256_permute2f128_ps(__m256 A, __m256 B) { 1422 // CHECK-LABEL: test_mm256_permute2f128_ps 1423 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x i32> <i32 4, i32 5, i32 6, i32 7, i32 12, i32 13, i32 14, i32 15> 1424 return _mm256_permute2f128_ps(A, B, 0x13); 1425 } 1426 1427 __m256i test_mm256_permute2f128_si256(__m256i A, __m256i B) { 1428 // CHECK-LABEL: test_mm256_permute2f128_si256 1429 // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11> 1430 return _mm256_permute2f128_si256(A, B, 0x20); 1431 } 1432 1433 __m128d test_mm_permutevar_pd(__m128d A, __m128i B) { 1434 // CHECK-LABEL: test_mm_permutevar_pd 1435 // CHECK: call <2 x double> @llvm.x86.avx.vpermilvar.pd(<2 x double> %{{.*}}, <2 x i64> %{{.*}}) 1436 return _mm_permutevar_pd(A, B); 1437 } 1438 1439 __m256d test_mm256_permutevar_pd(__m256d A, __m256i B) { 1440 // CHECK-LABEL: test_mm256_permutevar_pd 1441 // CHECK: call <4 x double> @llvm.x86.avx.vpermilvar.pd.256(<4 x double> %{{.*}}, <4 x i64> %{{.*}}) 1442 return _mm256_permutevar_pd(A, B); 1443 } 1444 1445 __m128 test_mm_permutevar_ps(__m128 A, __m128i B) { 1446 // CHECK-LABEL: test_mm_permutevar_ps 1447 // CHECK: call <4 x float> @llvm.x86.avx.vpermilvar.ps(<4 x float> %{{.*}}, <4 x i32> %{{.*}}) 1448 return _mm_permutevar_ps(A, B); 1449 } 1450 1451 __m256 test_mm256_permutevar_ps(__m256 A, __m256i B) { 1452 // CHECK-LABEL: test_mm256_permutevar_ps 1453 // CHECK: call <8 x float> @llvm.x86.avx.vpermilvar.ps.256(<8 x float> %{{.*}}, <8 x i32> %{{.*}}) 1454 return _mm256_permutevar_ps(A, B); 1455 } 1456 1457 __m256 test_mm256_rcp_ps(__m256 A) { 1458 // CHECK-LABEL: test_mm256_rcp_ps 1459 // CHECK: call <8 x float> @llvm.x86.avx.rcp.ps.256(<8 x float> %{{.*}}) 1460 return _mm256_rcp_ps(A); 1461 } 1462 1463 __m256d test_mm256_round_pd(__m256d x) { 1464 // CHECK-LABEL: test_mm256_round_pd 1465 // CHECK: call <4 x double> @llvm.x86.avx.round.pd.256(<4 x double> %{{.*}}, i32 4) 1466 return _mm256_round_pd(x, 4); 1467 } 1468 1469 __m256 test_mm256_round_ps(__m256 x) { 1470 // CHECK-LABEL: test_mm256_round_ps 1471 // CHECK: call <8 x float> @llvm.x86.avx.round.ps.256(<8 x float> %{{.*}}, i32 4) 1472 return _mm256_round_ps(x, 4); 1473 } 1474 1475 __m256 test_mm256_rsqrt_ps(__m256 A) { 1476 // CHECK-LABEL: test_mm256_rsqrt_ps 1477 // CHECK: call <8 x float> @llvm.x86.avx.rsqrt.ps.256(<8 x float> %{{.*}}) 1478 return _mm256_rsqrt_ps(A); 1479 } 1480 1481 __m256i test_mm256_set_epi8(char A0, char A1, char A2, char A3, char A4, char A5, char A6, char A7, 1482 char A8, char A9, char A10, char A11, char A12, char A13, char A14, char A15, 1483 char A16, char A17, char A18, char A19, char A20, char A21, char A22, char A23, 1484 char A24, char A25, char A26, char A27, char A28, char A29, char A30, char A31) { 1485 // CHECK-LABEL: test_mm256_set_epi8 1486 // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0 1487 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1 1488 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2 1489 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3 1490 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4 1491 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5 1492 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6 1493 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7 1494 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8 1495 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9 1496 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10 1497 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11 1498 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12 1499 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13 1500 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14 1501 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15 1502 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16 1503 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17 1504 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18 1505 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19 1506 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20 1507 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21 1508 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22 1509 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23 1510 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24 1511 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25 1512 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26 1513 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27 1514 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28 1515 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29 1516 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30 1517 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31 1518 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); 1519 } 1520 1521 __m256i test_mm256_set_epi16(short A0, short A1, short A2, short A3, short A4, short A5, short A6, short A7, 1522 short A8, short A9, short A10, short A11, short A12, short A13, short A14, short A15) { 1523 // CHECK-LABEL: test_mm256_set_epi16 1524 // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0 1525 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1 1526 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2 1527 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3 1528 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4 1529 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5 1530 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6 1531 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7 1532 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8 1533 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9 1534 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10 1535 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11 1536 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12 1537 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13 1538 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14 1539 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15 1540 return _mm256_set_epi16(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15); 1541 } 1542 1543 __m256i test_mm256_set_epi32(int A0, int A1, int A2, int A3, int A4, int A5, int A6, int A7) { 1544 // CHECK-LABEL: test_mm256_set_epi32 1545 // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0 1546 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1 1547 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2 1548 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3 1549 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4 1550 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5 1551 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6 1552 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7 1553 return _mm256_set_epi32(A0, A1, A2, A3, A4, A5, A6, A7); 1554 } 1555 1556 __m256i test_mm256_set_epi64x(long long A0, long long A1, long long A2, long long A3) { 1557 // CHECK-LABEL: test_mm256_set_epi64x 1558 // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0 1559 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1 1560 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2 1561 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3 1562 return _mm256_set_epi64x(A0, A1, A2, A3); 1563 } 1564 1565 __m256 test_mm256_set_m128(__m128 A, __m128 B) { 1566 // CHECK-LABEL: test_mm256_set_m128 1567 // 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> 1568 return _mm256_set_m128(A, B); 1569 } 1570 1571 __m256d test_mm256_set_m128d(__m128d A, __m128d B) { 1572 // CHECK-LABEL: test_mm256_set_m128d 1573 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 1574 return _mm256_set_m128d(A, B); 1575 } 1576 1577 __m256i test_mm256_set_m128i(__m128i A, __m128i B) { 1578 // CHECK-LABEL: test_mm256_set_m128i 1579 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 1580 return _mm256_set_m128i(A, B); 1581 } 1582 1583 __m256d test_mm256_set_pd(double A0, double A1, double A2, double A3) { 1584 // CHECK-LABEL: test_mm256_set_pd 1585 // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0 1586 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1 1587 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2 1588 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3 1589 return _mm256_set_pd(A0, A1, A2, A3); 1590 } 1591 1592 __m256 test_mm256_set_ps(float A0, float A1, float A2, float A3, float A4, float A5, float A6, float A7) { 1593 // CHECK-LABEL: test_mm256_set_ps 1594 // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0 1595 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1 1596 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2 1597 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3 1598 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4 1599 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5 1600 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6 1601 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7 1602 return _mm256_set_ps(A0, A1, A2, A3, A4, A5, A6, A7); 1603 } 1604 1605 __m256i test_mm256_set1_epi8(char A) { 1606 // CHECK-LABEL: test_mm256_set1_epi8 1607 // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0 1608 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1 1609 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2 1610 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3 1611 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4 1612 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5 1613 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6 1614 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7 1615 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8 1616 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9 1617 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10 1618 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11 1619 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12 1620 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13 1621 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14 1622 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15 1623 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16 1624 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17 1625 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18 1626 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19 1627 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20 1628 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21 1629 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22 1630 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23 1631 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24 1632 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25 1633 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26 1634 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27 1635 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28 1636 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29 1637 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30 1638 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31 1639 return _mm256_set1_epi8(A); 1640 } 1641 1642 __m256i test_mm256_set1_epi16(short A) { 1643 // CHECK-LABEL: test_mm256_set1_epi16 1644 // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0 1645 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1 1646 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2 1647 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3 1648 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4 1649 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5 1650 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6 1651 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7 1652 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8 1653 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9 1654 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10 1655 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11 1656 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12 1657 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13 1658 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14 1659 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15 1660 return _mm256_set1_epi16(A); 1661 } 1662 1663 __m256i test_mm256_set1_epi32(int A) { 1664 // CHECK-LABEL: test_mm256_set1_epi32 1665 // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0 1666 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1 1667 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2 1668 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3 1669 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4 1670 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5 1671 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6 1672 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7 1673 return _mm256_set1_epi32(A); 1674 } 1675 1676 __m256i test_mm256_set1_epi64x(long long A) { 1677 // CHECK-LABEL: test_mm256_set1_epi64x 1678 // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0 1679 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1 1680 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2 1681 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3 1682 return _mm256_set1_epi64x(A); 1683 } 1684 1685 __m256d test_mm256_set1_pd(double A) { 1686 // CHECK-LABEL: test_mm256_set1_pd 1687 // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0 1688 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1 1689 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2 1690 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3 1691 return _mm256_set1_pd(A); 1692 } 1693 1694 __m256 test_mm256_set1_ps(float A) { 1695 // CHECK-LABEL: test_mm256_set1_ps 1696 // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0 1697 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1 1698 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2 1699 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3 1700 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4 1701 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5 1702 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6 1703 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7 1704 return _mm256_set1_ps(A); 1705 } 1706 1707 __m256i test_mm256_setr_epi8(char A0, char A1, char A2, char A3, char A4, char A5, char A6, char A7, 1708 char A8, char A9, char A10, char A11, char A12, char A13, char A14, char A15, 1709 char A16, char A17, char A18, char A19, char A20, char A21, char A22, char A23, 1710 char A24, char A25, char A26, char A27, char A28, char A29, char A30, char A31) { 1711 // CHECK-LABEL: test_mm256_setr_epi8 1712 // CHECK: insertelement <32 x i8> undef, i8 %{{.*}}, i32 0 1713 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 1 1714 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 2 1715 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 3 1716 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 4 1717 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 5 1718 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 6 1719 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 7 1720 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 8 1721 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 9 1722 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 10 1723 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 11 1724 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 12 1725 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 13 1726 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 14 1727 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 15 1728 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 16 1729 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 17 1730 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 18 1731 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 19 1732 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 20 1733 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 21 1734 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 22 1735 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 23 1736 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 24 1737 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 25 1738 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 26 1739 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 27 1740 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 28 1741 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 29 1742 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 30 1743 // CHECK: insertelement <32 x i8> %{{.*}}, i8 %{{.*}}, i32 31 1744 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); 1745 } 1746 1747 __m256i test_mm256_setr_epi16(short A0, short A1, short A2, short A3, short A4, short A5, short A6, short A7, 1748 short A8, short A9, short A10, short A11, short A12, short A13, short A14, short A15) { 1749 // CHECK-LABEL: test_mm256_setr_epi16 1750 // CHECK: insertelement <16 x i16> undef, i16 %{{.*}}, i32 0 1751 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 1 1752 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 2 1753 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 3 1754 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 4 1755 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 5 1756 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 6 1757 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 7 1758 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 8 1759 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 9 1760 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 10 1761 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 11 1762 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 12 1763 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 13 1764 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 14 1765 // CHECK: insertelement <16 x i16> %{{.*}}, i16 %{{.*}}, i32 15 1766 return _mm256_setr_epi16(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15); 1767 } 1768 1769 __m256i test_mm256_setr_epi32(int A0, int A1, int A2, int A3, int A4, int A5, int A6, int A7) { 1770 // CHECK-LABEL: test_mm256_setr_epi32 1771 // CHECK: insertelement <8 x i32> undef, i32 %{{.*}}, i32 0 1772 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 1 1773 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 2 1774 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 3 1775 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 4 1776 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 5 1777 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 6 1778 // CHECK: insertelement <8 x i32> %{{.*}}, i32 %{{.*}}, i32 7 1779 return _mm256_setr_epi32(A0, A1, A2, A3, A4, A5, A6, A7); 1780 } 1781 1782 __m256i test_mm256_setr_epi64x(long long A0, long long A1, long long A2, long long A3) { 1783 // CHECK-LABEL: test_mm256_setr_epi64x 1784 // CHECK: insertelement <4 x i64> undef, i64 %{{.*}}, i32 0 1785 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 1 1786 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 2 1787 // CHECK: insertelement <4 x i64> %{{.*}}, i64 %{{.*}}, i32 3 1788 return _mm256_setr_epi64x(A0, A1, A2, A3); 1789 } 1790 1791 __m256 test_mm256_setr_m128(__m128 A, __m128 B) { 1792 // CHECK-LABEL: test_mm256_setr_m128 1793 // 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> 1794 return _mm256_setr_m128(A, B); 1795 } 1796 1797 __m256d test_mm256_setr_m128d(__m128d A, __m128d B) { 1798 // CHECK-LABEL: test_mm256_setr_m128d 1799 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 1800 return _mm256_setr_m128d(A, B); 1801 } 1802 1803 __m256i test_mm256_setr_m128i(__m128i A, __m128i B) { 1804 // CHECK-LABEL: test_mm256_setr_m128i 1805 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 1806 return _mm256_setr_m128i(A, B); 1807 } 1808 1809 __m256d test_mm256_setr_pd(double A0, double A1, double A2, double A3) { 1810 // CHECK-LABEL: test_mm256_setr_pd 1811 // CHECK: insertelement <4 x double> undef, double %{{.*}}, i32 0 1812 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 1 1813 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 2 1814 // CHECK: insertelement <4 x double> %{{.*}}, double %{{.*}}, i32 3 1815 return _mm256_setr_pd(A0, A1, A2, A3); 1816 } 1817 1818 __m256 test_mm256_setr_ps(float A0, float A1, float A2, float A3, float A4, float A5, float A6, float A7) { 1819 // CHECK-LABEL: test_mm256_setr_ps 1820 // CHECK: insertelement <8 x float> undef, float %{{.*}}, i32 0 1821 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 1 1822 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 2 1823 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 3 1824 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 4 1825 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 5 1826 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 6 1827 // CHECK: insertelement <8 x float> %{{.*}}, float %{{.*}}, i32 7 1828 return _mm256_setr_ps(A0, A1, A2, A3, A4, A5, A6, A7); 1829 } 1830 1831 __m256d test_mm256_setzero_pd() { 1832 // CHECK-LABEL: test_mm256_setzero_pd 1833 // CHECK: store <4 x double> zeroinitializer 1834 return _mm256_setzero_pd(); 1835 } 1836 1837 __m256 test_mm256_setzero_ps() { 1838 // CHECK-LABEL: test_mm256_setzero_ps 1839 // CHECK: store <8 x float> zeroinitializer 1840 return _mm256_setzero_ps(); 1841 } 1842 1843 __m256i test_mm256_setzero_si256() { 1844 // CHECK-LABEL: test_mm256_setzero_si256 1845 // CHECK: store <4 x i64> zeroinitializer 1846 return _mm256_setzero_si256(); 1847 } 1848 1849 __m256d test_mm256_shuffle_pd(__m256d A, __m256d B) { 1850 // CHECK-LABEL: test_mm256_shuffle_pd 1851 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6> 1852 return _mm256_shuffle_pd(A, B, 0); 1853 } 1854 1855 __m256 test_mm256_shuffle_ps(__m256 A, __m256 B) { 1856 // CHECK-LABEL: test_mm256_shuffle_ps 1857 // 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> 1858 return _mm256_shuffle_ps(A, B, 0); 1859 } 1860 1861 __m256d test_mm256_sqrt_pd(__m256d A) { 1862 // CHECK-LABEL: test_mm256_sqrt_pd 1863 // CHECK: call <4 x double> @llvm.sqrt.v4f64(<4 x double> %{{.*}}) 1864 return _mm256_sqrt_pd(A); 1865 } 1866 1867 __m256 test_mm256_sqrt_ps(__m256 A) { 1868 // CHECK-LABEL: test_mm256_sqrt_ps 1869 // CHECK: call <8 x float> @llvm.sqrt.v8f32(<8 x float> %{{.*}}) 1870 return _mm256_sqrt_ps(A); 1871 } 1872 1873 void test_mm256_store_pd(double* A, __m256d B) { 1874 // CHECK-LABEL: test_mm256_store_pd 1875 // CHECK: store <4 x double> %{{.*}}, <4 x double>* %{{.*}}, align 32 1876 _mm256_store_pd(A, B); 1877 } 1878 1879 void test_mm256_store_ps(float* A, __m256 B) { 1880 // CHECK-LABEL: test_mm256_store_ps 1881 // CHECK: store <8 x float> %{{.*}}, <8 x float>* %{{.*}}, align 32 1882 _mm256_store_ps(A, B); 1883 } 1884 1885 void test_mm256_store_si256(__m256i* A, __m256i B) { 1886 // CHECK-LABEL: test_mm256_store_si256 1887 // CHECK: store <4 x i64> %{{.*}}, <4 x i64>* %{{.*}}, align 32 1888 _mm256_store_si256(A, B); 1889 } 1890 1891 void test_mm256_storeu_pd(double* A, __m256d B) { 1892 // CHECK-LABEL: test_mm256_storeu_pd 1893 // CHECK: store <4 x double> %{{.*}}, <4 x double>* %{{.*}}, align 1{{$}} 1894 // CHECK-NEXT: ret void 1895 _mm256_storeu_pd(A, B); 1896 } 1897 1898 void test_mm256_storeu_ps(float* A, __m256 B) { 1899 // CHECK-LABEL: test_mm256_storeu_ps 1900 // CHECK: store <8 x float> %{{.*}}, <8 x float>* %{{.*}}, align 1{{$}} 1901 // CHECk-NEXT: ret void 1902 _mm256_storeu_ps(A, B); 1903 } 1904 1905 void test_mm256_storeu_si256(__m256i* A, __m256i B) { 1906 // CHECK-LABEL: test_mm256_storeu_si256 1907 // CHECK: store <4 x i64> %{{.*}}, <4 x i64>* %{{.*}}, align 1{{$}} 1908 // CHECk-NEXT: ret void 1909 _mm256_storeu_si256(A, B); 1910 } 1911 1912 void test_mm256_storeu2_m128(float* A, float* B, __m256 C) { 1913 // CHECK-LABEL: test_mm256_storeu2_m128 1914 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 1915 // CHECK: store <4 x float> %{{.*}}, <4 x float>* %{{.*}}, align 1{{$}} 1916 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7> 1917 // CHECK: store <4 x float> %{{.*}}, <4 x float>* %{{.*}}, align 1{{$}} 1918 _mm256_storeu2_m128(A, B, C); 1919 } 1920 1921 void test_mm256_storeu2_m128d(double* A, double* B, __m256d C) { 1922 // CHECK-LABEL: test_mm256_storeu2_m128d 1923 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <2 x i32> <i32 0, i32 1> 1924 // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 1{{$}} 1925 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> undef, <2 x i32> <i32 2, i32 3> 1926 // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 1{{$}} 1927 _mm256_storeu2_m128d(A, B, C); 1928 } 1929 1930 void test_mm256_storeu2_m128i(__m128i* A, __m128i* B, __m256i C) { 1931 // CHECK-LABEL: test_mm256_storeu2_m128i 1932 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <2 x i32> <i32 0, i32 1> 1933 // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 1{{$}} 1934 // CHECK: shufflevector <8 x i32> %{{.*}}, <8 x i32> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7> 1935 // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 1{{$}} 1936 _mm256_storeu2_m128i(A, B, C); 1937 } 1938 1939 void test_mm256_stream_pd(double* A, __m256d B) { 1940 // CHECK-LABEL: test_mm256_stream_pd 1941 // CHECK: store <4 x double> %{{.*}}, <4 x double>* %{{.*}}, align 32, !nontemporal 1942 _mm256_stream_pd(A, B); 1943 } 1944 1945 void test_mm256_stream_ps(float* A, __m256 B) { 1946 // CHECK-LABEL: test_mm256_stream_ps 1947 // CHECK: store <8 x float> %{{.*}}, <8 x float>* %{{.*}}, align 32, !nontemporal 1948 _mm256_stream_ps(A, B); 1949 } 1950 1951 void test_mm256_stream_si256(__m256i* A, __m256i B) { 1952 // CHECK-LABEL: test_mm256_stream_si256 1953 // CHECK: store <4 x i64> %{{.*}}, <4 x i64>* %{{.*}}, align 32, !nontemporal 1954 _mm256_stream_si256(A, B); 1955 } 1956 1957 __m256d test_mm256_sub_pd(__m256d A, __m256d B) { 1958 // CHECK-LABEL: test_mm256_sub_pd 1959 // CHECK: fsub <4 x double> 1960 return _mm256_sub_pd(A, B); 1961 } 1962 1963 __m256 test_mm256_sub_ps(__m256 A, __m256 B) { 1964 // CHECK-LABEL: test_mm256_sub_ps 1965 // CHECK: fsub <8 x float> 1966 return _mm256_sub_ps(A, B); 1967 } 1968 1969 int test_mm_testc_pd(__m128d A, __m128d B) { 1970 // CHECK-LABEL: test_mm_testc_pd 1971 // CHECK: call i32 @llvm.x86.avx.vtestc.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 1972 return _mm_testc_pd(A, B); 1973 } 1974 1975 int test_mm256_testc_pd(__m256d A, __m256d B) { 1976 // CHECK-LABEL: test_mm256_testc_pd 1977 // CHECK: call i32 @llvm.x86.avx.vtestc.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}) 1978 return _mm256_testc_pd(A, B); 1979 } 1980 1981 int test_mm_testc_ps(__m128 A, __m128 B) { 1982 // CHECK-LABEL: test_mm_testc_ps 1983 // CHECK: call i32 @llvm.x86.avx.vtestc.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 1984 return _mm_testc_ps(A, B); 1985 } 1986 1987 int test_mm256_testc_ps(__m256 A, __m256 B) { 1988 // CHECK-LABEL: test_mm256_testc_ps 1989 // CHECK: call i32 @llvm.x86.avx.vtestc.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}) 1990 return _mm256_testc_ps(A, B); 1991 } 1992 1993 int test_mm256_testc_si256(__m256i A, __m256i B) { 1994 // CHECK-LABEL: test_mm256_testc_si256 1995 // CHECK: call i32 @llvm.x86.avx.ptestc.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}}) 1996 return _mm256_testc_si256(A, B); 1997 } 1998 1999 int test_mm_testnzc_pd(__m128d A, __m128d B) { 2000 // CHECK-LABEL: test_mm_testnzc_pd 2001 // CHECK: call i32 @llvm.x86.avx.vtestnzc.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 2002 return _mm_testnzc_pd(A, B); 2003 } 2004 2005 int test_mm256_testnzc_pd(__m256d A, __m256d B) { 2006 // CHECK-LABEL: test_mm256_testnzc_pd 2007 // CHECK: call i32 @llvm.x86.avx.vtestnzc.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}) 2008 return _mm256_testnzc_pd(A, B); 2009 } 2010 2011 int test_mm_testnzc_ps(__m128 A, __m128 B) { 2012 // CHECK-LABEL: test_mm_testnzc_ps 2013 // CHECK: call i32 @llvm.x86.avx.vtestnzc.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 2014 return _mm_testnzc_ps(A, B); 2015 } 2016 2017 int test_mm256_testnzc_ps(__m256 A, __m256 B) { 2018 // CHECK-LABEL: test_mm256_testnzc_ps 2019 // CHECK: call i32 @llvm.x86.avx.vtestnzc.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}) 2020 return _mm256_testnzc_ps(A, B); 2021 } 2022 2023 int test_mm256_testnzc_si256(__m256i A, __m256i B) { 2024 // CHECK-LABEL: test_mm256_testnzc_si256 2025 // CHECK: call i32 @llvm.x86.avx.ptestnzc.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}}) 2026 return _mm256_testnzc_si256(A, B); 2027 } 2028 2029 int test_mm_testz_pd(__m128d A, __m128d B) { 2030 // CHECK-LABEL: test_mm_testz_pd 2031 // CHECK: call i32 @llvm.x86.avx.vtestz.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}) 2032 return _mm_testz_pd(A, B); 2033 } 2034 2035 int test_mm256_testz_pd(__m256d A, __m256d B) { 2036 // CHECK-LABEL: test_mm256_testz_pd 2037 // CHECK: call i32 @llvm.x86.avx.vtestz.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}) 2038 return _mm256_testz_pd(A, B); 2039 } 2040 2041 int test_mm_testz_ps(__m128 A, __m128 B) { 2042 // CHECK-LABEL: test_mm_testz_ps 2043 // CHECK: call i32 @llvm.x86.avx.vtestz.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}) 2044 return _mm_testz_ps(A, B); 2045 } 2046 2047 int test_mm256_testz_ps(__m256 A, __m256 B) { 2048 // CHECK-LABEL: test_mm256_testz_ps 2049 // CHECK: call i32 @llvm.x86.avx.vtestz.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}) 2050 return _mm256_testz_ps(A, B); 2051 } 2052 2053 int test_mm256_testz_si256(__m256i A, __m256i B) { 2054 // CHECK-LABEL: test_mm256_testz_si256 2055 // CHECK: call i32 @llvm.x86.avx.ptestz.256(<4 x i64> %{{.*}}, <4 x i64> %{{.*}}) 2056 return _mm256_testz_si256(A, B); 2057 } 2058 2059 __m256 test_mm256_undefined_ps() { 2060 // CHECK-LABEL: @test_mm256_undefined_ps 2061 // CHECK: ret <8 x float> zeroinitializer 2062 return _mm256_undefined_ps(); 2063 } 2064 2065 __m256d test_mm256_undefined_pd() { 2066 // CHECK-LABEL: @test_mm256_undefined_pd 2067 // CHECK: ret <4 x double> zeroinitializer 2068 return _mm256_undefined_pd(); 2069 } 2070 2071 __m256i test_mm256_undefined_si256() { 2072 // CHECK-LABEL: @test_mm256_undefined_si256 2073 // CHECK: ret <4 x i64> zeroinitializer 2074 return _mm256_undefined_si256(); 2075 } 2076 2077 __m256d test_mm256_unpackhi_pd(__m256d A, __m256d B) { 2078 // CHECK-LABEL: test_mm256_unpackhi_pd 2079 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 1, i32 5, i32 3, i32 7> 2080 return _mm256_unpackhi_pd(A, B); 2081 } 2082 2083 __m256 test_mm256_unpackhi_ps(__m256 A, __m256 B) { 2084 // CHECK-LABEL: test_mm256_unpackhi_ps 2085 // 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> 2086 return _mm256_unpackhi_ps(A, B); 2087 } 2088 2089 __m256d test_mm256_unpacklo_pd(__m256d A, __m256d B) { 2090 // CHECK-LABEL: test_mm256_unpacklo_pd 2091 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x i32> <i32 0, i32 4, i32 2, i32 6> 2092 return _mm256_unpacklo_pd(A, B); 2093 } 2094 2095 __m256 test_mm256_unpacklo_ps(__m256 A, __m256 B) { 2096 // CHECK-LABEL: test_mm256_unpacklo_ps 2097 // 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> 2098 return _mm256_unpacklo_ps(A, B); 2099 } 2100 2101 __m256d test_mm256_xor_pd(__m256d A, __m256d B) { 2102 // CHECK-LABEL: test_mm256_xor_pd 2103 // CHECK: xor <4 x i64> 2104 return _mm256_xor_pd(A, B); 2105 } 2106 2107 __m256 test_mm256_xor_ps(__m256 A, __m256 B) { 2108 // CHECK-LABEL: test_mm256_xor_ps 2109 // CHECK: xor <8 x i32> 2110 return _mm256_xor_ps(A, B); 2111 } 2112 2113 void test_mm256_zeroall() { 2114 // CHECK-LABEL: test_mm256_zeroall 2115 // CHECK: call void @llvm.x86.avx.vzeroall() 2116 return _mm256_zeroall(); 2117 } 2118 2119 void test_mm256_zeroupper() { 2120 // CHECK-LABEL: test_mm256_zeroupper 2121 // CHECK: call void @llvm.x86.avx.vzeroupper() 2122 return _mm256_zeroupper(); 2123 } 2124 2125 __m256d test_mm256_zextpd128_pd256(__m128d A) { 2126 // CHECK-LABEL: test_mm256_zextpd128_pd256 2127 // CHECK: store <2 x double> zeroinitializer 2128 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 2129 return _mm256_zextpd128_pd256(A); 2130 } 2131 2132 __m256 test_mm256_zextps128_ps256(__m128 A) { 2133 // CHECK-LABEL: test_mm256_zextps128_ps256 2134 // CHECK: store <4 x float> zeroinitializer 2135 // 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> 2136 return _mm256_zextps128_ps256(A); 2137 } 2138 2139 __m256i test_mm256_zextsi128_si256(__m128i A) { 2140 // CHECK-LABEL: test_mm256_zextsi128_si256 2141 // CHECK: store <2 x i64> zeroinitializer 2142 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 2143 return _mm256_zextsi128_si256(A); 2144 } 2145 2146 double test_mm256_cvtsd_f64(__m256d __a) 2147 { 2148 // CHECK-LABEL: @test_mm256_cvtsd_f64 2149 // CHECK: extractelement <4 x double> %{{.*}}, i32 0 2150 return _mm256_cvtsd_f64(__a); 2151 } 2152 2153 int test_mm256_cvtsi256_si32(__m256i __a) 2154 { 2155 // CHECK-LABEL: @test_mm256_cvtsi256_si32 2156 // CHECK: extractelement <8 x i32> %{{.*}}, i32 0 2157 return _mm256_cvtsi256_si32(__a); 2158 } 2159 2160 float test_mm256_cvtss_f32(__m256 __a) 2161 { 2162 // CHECK-LABEL: @test_mm256_cvtss_f32 2163 // CHECK: extractelement <8 x float> %{{.*}}, i32 0 2164 return _mm256_cvtss_f32(__a); 2165 } 2166