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