1 // RUN: %clang_cc1 -x c -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512f -emit-llvm -o - -Wall -Werror -Wsign-conversion | FileCheck %s 2 // RUN: %clang_cc1 -x c -flax-vector-conversions=none -fms-extensions -fms-compatibility -ffreestanding %s -triple=x86_64-windows-msvc -target-feature +avx512f -emit-llvm -o - -Wall -Werror -Wsign-conversion | FileCheck %s 3 // RUN: %clang_cc1 -x c++ -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512f -emit-llvm -o - -Wall -Werror -Wsign-conversion | FileCheck %s 4 // RUN: %clang_cc1 -x c++ -flax-vector-conversions=none -fms-extensions -fms-compatibility -ffreestanding %s -triple=x86_64-windows-msvc -target-feature +avx512f -emit-llvm -o - -Wall -Werror -Wsign-conversion | FileCheck %s 5 6 #include <immintrin.h> 7 #include "builtin_test_helpers.h" 8 9 __m512d test_mm512_sqrt_pd(__m512d a) 10 { 11 // CHECK-LABEL: test_mm512_sqrt_pd 12 // CHECK: call {{.*}}<8 x double> @llvm.sqrt.v8f64(<8 x double> %{{.*}}) 13 return _mm512_sqrt_pd(a); 14 } 15 16 __m512d test_mm512_mask_sqrt_pd (__m512d __W, __mmask8 __U, __m512d __A) 17 { 18 // CHECK-LABEL: test_mm512_mask_sqrt_pd 19 // CHECK: call {{.*}}<8 x double> @llvm.sqrt.v8f64(<8 x double> %{{.*}}) 20 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 21 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 22 return _mm512_mask_sqrt_pd (__W,__U,__A); 23 } 24 25 __m512d test_mm512_maskz_sqrt_pd (__mmask8 __U, __m512d __A) 26 { 27 // CHECK-LABEL: test_mm512_maskz_sqrt_pd 28 // CHECK: call {{.*}}<8 x double> @llvm.sqrt.v8f64(<8 x double> %{{.*}}) 29 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 30 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> {{.*}} 31 return _mm512_maskz_sqrt_pd (__U,__A); 32 } 33 34 __m512d test_mm512_mask_sqrt_round_pd(__m512d __W,__mmask8 __U,__m512d __A) 35 { 36 // CHECK-LABEL: test_mm512_mask_sqrt_round_pd 37 // CHECK: call {{.*}}<8 x double> @llvm.x86.avx512.sqrt.pd.512(<8 x double> %{{.*}}, i32 11) 38 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 39 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 40 return _mm512_mask_sqrt_round_pd(__W,__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 41 } 42 43 __m512d test_mm512_maskz_sqrt_round_pd(__mmask8 __U,__m512d __A) 44 { 45 // CHECK-LABEL: test_mm512_maskz_sqrt_round_pd 46 // CHECK: call {{.*}}<8 x double> @llvm.x86.avx512.sqrt.pd.512(<8 x double> %{{.*}}, i32 11) 47 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 48 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> {{.*}} 49 return _mm512_maskz_sqrt_round_pd(__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 50 } 51 52 __m512d test_mm512_sqrt_round_pd(__m512d __A) 53 { 54 // CHECK-LABEL: test_mm512_sqrt_round_pd 55 // CHECK: call {{.*}}<8 x double> @llvm.x86.avx512.sqrt.pd.512(<8 x double> %{{.*}}, i32 11) 56 return _mm512_sqrt_round_pd(__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 57 } 58 59 __m512 test_mm512_sqrt_ps(__m512 a) 60 { 61 // CHECK-LABEL: test_mm512_sqrt_ps 62 // CHECK: call {{.*}}<16 x float> @llvm.sqrt.v16f32(<16 x float> %{{.*}}) 63 return _mm512_sqrt_ps(a); 64 } 65 66 __m512 test_mm512_mask_sqrt_ps(__m512 __W, __mmask16 __U, __m512 __A) 67 { 68 // CHECK-LABEL: test_mm512_mask_sqrt_ps 69 // CHECK: call {{.*}}<16 x float> @llvm.sqrt.v16f32(<16 x float> %{{.*}}) 70 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 71 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 72 return _mm512_mask_sqrt_ps( __W, __U, __A); 73 } 74 75 __m512 test_mm512_maskz_sqrt_ps( __mmask16 __U, __m512 __A) 76 { 77 // CHECK-LABEL: test_mm512_maskz_sqrt_ps 78 // CHECK: call {{.*}}<16 x float> @llvm.sqrt.v16f32(<16 x float> %{{.*}}) 79 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 80 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> {{.*}} 81 return _mm512_maskz_sqrt_ps(__U ,__A); 82 } 83 84 __m512 test_mm512_mask_sqrt_round_ps(__m512 __W,__mmask16 __U,__m512 __A) 85 { 86 // CHECK-LABEL: test_mm512_mask_sqrt_round_ps 87 // CHECK: call {{.*}}<16 x float> @llvm.x86.avx512.sqrt.ps.512(<16 x float> %{{.*}}, i32 11) 88 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 89 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 90 return _mm512_mask_sqrt_round_ps(__W,__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 91 } 92 93 __m512 test_mm512_maskz_sqrt_round_ps(__mmask16 __U,__m512 __A) 94 { 95 // CHECK-LABEL: test_mm512_maskz_sqrt_round_ps 96 // CHECK: call {{.*}}<16 x float> @llvm.x86.avx512.sqrt.ps.512(<16 x float> %{{.*}}, i32 11) 97 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 98 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> {{.*}} 99 return _mm512_maskz_sqrt_round_ps(__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 100 } 101 102 __m512 test_mm512_sqrt_round_ps(__m512 __A) 103 { 104 // CHECK-LABEL: test_mm512_sqrt_round_ps 105 // CHECK: call {{.*}}<16 x float> @llvm.x86.avx512.sqrt.ps.512(<16 x float> %{{.*}}, i32 11) 106 return _mm512_sqrt_round_ps(__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 107 } 108 109 __m512d test_mm512_rsqrt14_pd(__m512d a) 110 { 111 // CHECK-LABEL: test_mm512_rsqrt14_pd 112 // CHECK: @llvm.x86.avx512.rsqrt14.pd.512 113 return _mm512_rsqrt14_pd(a); 114 } 115 116 __m512d test_mm512_mask_rsqrt14_pd (__m512d __W, __mmask8 __U, __m512d __A) 117 { 118 // CHECK-LABEL: test_mm512_mask_rsqrt14_pd 119 // CHECK: @llvm.x86.avx512.rsqrt14.pd.512 120 return _mm512_mask_rsqrt14_pd (__W,__U,__A); 121 } 122 123 __m512d test_mm512_maskz_rsqrt14_pd (__mmask8 __U, __m512d __A) 124 { 125 // CHECK-LABEL: test_mm512_maskz_rsqrt14_pd 126 // CHECK: @llvm.x86.avx512.rsqrt14.pd.512 127 return _mm512_maskz_rsqrt14_pd (__U,__A); 128 } 129 130 __m512 test_mm512_rsqrt14_ps(__m512 a) 131 { 132 // CHECK-LABEL: test_mm512_rsqrt14_ps 133 // CHECK: @llvm.x86.avx512.rsqrt14.ps.512 134 return _mm512_rsqrt14_ps(a); 135 } 136 137 __m512 test_mm512_mask_rsqrt14_ps (__m512 __W, __mmask16 __U, __m512 __A) 138 { 139 // CHECK-LABEL: test_mm512_mask_rsqrt14_ps 140 // CHECK: @llvm.x86.avx512.rsqrt14.ps.512 141 return _mm512_mask_rsqrt14_ps (__W,__U,__A); 142 } 143 144 __m512 test_mm512_maskz_rsqrt14_ps (__mmask16 __U, __m512 __A) 145 { 146 // CHECK-LABEL: test_mm512_maskz_rsqrt14_ps 147 // CHECK: @llvm.x86.avx512.rsqrt14.ps.512 148 return _mm512_maskz_rsqrt14_ps (__U,__A); 149 } 150 151 __m512 test_mm512_add_ps(__m512 a, __m512 b) 152 { 153 // CHECK-LABEL: test_mm512_add_ps 154 // CHECK: fadd <16 x float> 155 return _mm512_add_ps(a, b); 156 } 157 158 __m512d test_mm512_add_pd(__m512d a, __m512d b) 159 { 160 // CHECK-LABEL: test_mm512_add_pd 161 // CHECK: fadd <8 x double> 162 return _mm512_add_pd(a, b); 163 } 164 165 __m512 test_mm512_mul_ps(__m512 a, __m512 b) 166 { 167 // CHECK-LABEL: test_mm512_mul_ps 168 // CHECK: fmul <16 x float> 169 return _mm512_mul_ps(a, b); 170 } 171 172 __m512d test_mm512_mul_pd(__m512d a, __m512d b) 173 { 174 // CHECK-LABEL: test_mm512_mul_pd 175 // CHECK: fmul <8 x double> 176 return _mm512_mul_pd(a, b); 177 } 178 179 void test_mm512_storeu_si512 (void *__P, __m512i __A) 180 { 181 // CHECK-LABEL: test_mm512_storeu_si512 182 // CHECK: store <8 x i64> %{{.*}}, ptr %{{.*}}, align 1{{$}} 183 // CHECK-NEXT: ret void 184 _mm512_storeu_si512 ( __P,__A); 185 } 186 187 void test_mm512_storeu_ps(void *p, __m512 a) 188 { 189 // CHECK-LABEL: test_mm512_storeu_ps 190 // CHECK: store <16 x float> %{{.*}}, ptr %{{.*}}, align 1{{$}} 191 // CHECK-NEXT: ret void 192 _mm512_storeu_ps(p, a); 193 } 194 195 void test_mm512_storeu_pd(void *p, __m512d a) 196 { 197 // CHECK-LABEL: test_mm512_storeu_pd 198 // CHECK: store <8 x double> %{{.*}}, ptr %{{.*}}, align 1{{$}} 199 // CHECK-NEXT: ret void 200 _mm512_storeu_pd(p, a); 201 } 202 203 void test_mm512_mask_store_ps(void *p, __m512 a, __mmask16 m) 204 { 205 // CHECK-LABEL: test_mm512_mask_store_ps 206 // CHECK: @llvm.masked.store.v16f32.p0(<16 x float> %{{.*}}, ptr %{{.*}}, i32 64, <16 x i1> %{{.*}}) 207 _mm512_mask_store_ps(p, m, a); 208 } 209 210 void test_mm512_store_si512 (void *__P, __m512i __A) 211 { 212 // CHECK-LABEL: test_mm512_store_si512 213 // CHECK: load <8 x i64>, ptr %__A.addr.i, align 64{{$}} 214 // CHECK: [[SI512_3:%.+]] = load ptr, ptr %__P.addr.i, align 8{{$}} 215 // CHECK: store <8 x i64> 216 _mm512_store_si512 ( __P,__A); 217 } 218 219 void test_mm512_store_epi32 (void *__P, __m512i __A) 220 { 221 // CHECK-LABEL: test_mm512_store_epi32 222 // CHECK: load <8 x i64>, ptr %__A.addr.i, align 64{{$}} 223 // CHECK: [[Si32_3:%.+]] = load ptr, ptr %__P.addr.i, align 8{{$}} 224 // CHECK: store <8 x i64> 225 _mm512_store_epi32 ( __P,__A); 226 } 227 228 void test_mm512_store_epi64 (void *__P, __m512i __A) 229 { 230 // CHECK-LABEL: test_mm512_store_epi64 231 // CHECK: load <8 x i64>, ptr %__A.addr.i, align 64{{$}} 232 // CHECK: [[SI64_3:%.+]] = load ptr, ptr %__P.addr.i, align 8{{$}} 233 // CHECK: store <8 x i64> 234 _mm512_store_epi64 ( __P,__A); 235 } 236 237 void test_mm512_store_ps(void *p, __m512 a) 238 { 239 // CHECK-LABEL: test_mm512_store_ps 240 // CHECK: store <16 x float> 241 _mm512_store_ps(p, a); 242 } 243 244 void test_mm512_store_pd(void *p, __m512d a) 245 { 246 // CHECK-LABEL: test_mm512_store_pd 247 // CHECK: store <8 x double> 248 _mm512_store_pd(p, a); 249 } 250 251 void test_mm512_mask_store_pd(void *p, __m512d a, __mmask8 m) 252 { 253 // CHECK-LABEL: test_mm512_mask_store_pd 254 // CHECK: @llvm.masked.store.v8f64.p0(<8 x double> %{{.*}}, ptr %{{.*}}, i32 64, <8 x i1> %{{.*}}) 255 _mm512_mask_store_pd(p, m, a); 256 } 257 258 void test_mm512_storeu_epi32(void *__P, __m512i __A) { 259 // CHECK-LABEL: test_mm512_storeu_epi32 260 // CHECK: store <8 x i64> %{{.*}}, ptr %{{.*}}, align 1{{$}} 261 return _mm512_storeu_epi32(__P, __A); 262 } 263 264 void test_mm512_mask_storeu_epi32(void *__P, __mmask16 __U, __m512i __A) { 265 // CHECK-LABEL: test_mm512_mask_storeu_epi32 266 // CHECK: @llvm.masked.store.v16i32.p0(<16 x i32> %{{.*}}, ptr %{{.*}}, i32 1, <16 x i1> %{{.*}}) 267 return _mm512_mask_storeu_epi32(__P, __U, __A); 268 } 269 270 void test_mm512_storeu_epi64(void *__P, __m512i __A) { 271 // CHECK-LABEL: test_mm512_storeu_epi64 272 // CHECK: store <8 x i64> %{{.*}}, ptr %{{.*}}, align 1{{$}} 273 return _mm512_storeu_epi64(__P, __A); 274 } 275 276 void test_mm512_mask_storeu_epi64(void *__P, __mmask8 __U, __m512i __A) { 277 // CHECK-LABEL: test_mm512_mask_storeu_epi64 278 // CHECK: @llvm.masked.store.v8i64.p0(<8 x i64> %{{.*}}, ptr %{{.*}}, i32 1, <8 x i1> %{{.*}}) 279 return _mm512_mask_storeu_epi64(__P, __U, __A); 280 } 281 282 __m512i test_mm512_loadu_si512 (void *__P) 283 { 284 // CHECK-LABEL: test_mm512_loadu_si512 285 // CHECK: load <8 x i64>, ptr %{{.*}}, align 1{{$}} 286 return _mm512_loadu_si512 ( __P); 287 } 288 289 __m512i test_mm512_loadu_epi32 (void *__P) 290 { 291 // CHECK-LABEL: test_mm512_loadu_epi32 292 // CHECK: load <8 x i64>, ptr %{{.*}}, align 1{{$}} 293 return _mm512_loadu_epi32 (__P); 294 } 295 296 __m512i test_mm512_mask_loadu_epi32 (__m512i __W, __mmask16 __U, void *__P) 297 { 298 // CHECK-LABEL: test_mm512_mask_loadu_epi32 299 // CHECK: @llvm.masked.load.v16i32.p0(ptr %{{.*}}, i32 1, <16 x i1> %{{.*}}, <16 x i32> %{{.*}}) 300 return _mm512_mask_loadu_epi32 (__W,__U, __P); 301 } 302 303 __m512i test_mm512_maskz_loadu_epi32 (__mmask16 __U, void *__P) 304 { 305 // CHECK-LABEL: test_mm512_maskz_loadu_epi32 306 // CHECK: @llvm.masked.load.v16i32.p0(ptr %{{.*}}, i32 1, <16 x i1> %{{.*}}, <16 x i32> %{{.*}}) 307 return _mm512_maskz_loadu_epi32 (__U, __P); 308 } 309 310 __m512i test_mm512_loadu_epi64 (void *__P) 311 { 312 // CHECK-LABEL: test_mm512_loadu_epi64 313 // CHECK: load <8 x i64>, ptr %{{.*}}, align 1{{$}} 314 return _mm512_loadu_epi64 (__P); 315 } 316 317 __m512i test_mm512_mask_loadu_epi64 (__m512i __W, __mmask8 __U, void *__P) 318 { 319 // CHECK-LABEL: test_mm512_mask_loadu_epi64 320 // CHECK: @llvm.masked.load.v8i64.p0(ptr %{{.*}}, i32 1, <8 x i1> %{{.*}}, <8 x i64> %{{.*}}) 321 return _mm512_mask_loadu_epi64 (__W,__U, __P); 322 } 323 324 __m512i test_mm512_maskz_loadu_epi64 (__mmask16 __U, void *__P) 325 { 326 // CHECK-LABEL: test_mm512_maskz_loadu_epi64 327 // CHECK: @llvm.masked.load.v8i64.p0(ptr %{{.*}}, i32 1, <8 x i1> %{{.*}}, <8 x i64> %{{.*}}) 328 return _mm512_maskz_loadu_epi64 (__U, __P); 329 } 330 331 __m512 test_mm512_loadu_ps(void *p) 332 { 333 // CHECK-LABEL: test_mm512_loadu_ps 334 // CHECK: load <16 x float>, ptr {{.*}}, align 1{{$}} 335 return _mm512_loadu_ps(p); 336 } 337 338 __m512 test_mm512_mask_loadu_ps (__m512 __W, __mmask16 __U, void *__P) 339 { 340 // CHECK-LABEL: test_mm512_mask_loadu_ps 341 // CHECK: @llvm.masked.load.v16f32.p0(ptr %{{.*}}, i32 1, <16 x i1> %{{.*}}, <16 x float> %{{.*}}) 342 return _mm512_mask_loadu_ps (__W,__U, __P); 343 } 344 345 __m512d test_mm512_loadu_pd(void *p) 346 { 347 // CHECK-LABEL: test_mm512_loadu_pd 348 // CHECK: load <8 x double>, ptr {{.*}}, align 1{{$}} 349 return _mm512_loadu_pd(p); 350 } 351 352 __m512d test_mm512_mask_loadu_pd (__m512d __W, __mmask8 __U, void *__P) 353 { 354 // CHECK-LABEL: test_mm512_mask_loadu_pd 355 // CHECK: @llvm.masked.load.v8f64.p0(ptr %{{.*}}, i32 1, <8 x i1> %{{.*}}, <8 x double> %{{.*}}) 356 return _mm512_mask_loadu_pd (__W,__U, __P); 357 } 358 359 __m512i test_mm512_load_si512 (void *__P) 360 { 361 // CHECK-LABEL: test_mm512_load_si512 362 // CHECK: [[LI512_1:%.+]] = load ptr, ptr %__P.addr.i, align 8{{$}} 363 // CHECK: load <8 x i64>, ptr [[LI512_1]], align 64{{$}} 364 return _mm512_load_si512 ( __P); 365 } 366 367 __m512i test_mm512_load_epi32 (void *__P) 368 { 369 // CHECK-LABEL: test_mm512_load_epi32 370 // CHECK: [[LI32_1:%.+]] = load ptr, ptr %__P.addr.i, align 8{{$}} 371 // CHECK: load <8 x i64>, ptr [[LI32_1]], align 64{{$}} 372 return _mm512_load_epi32 ( __P); 373 } 374 375 __m512i test_mm512_load_epi64 (void *__P) 376 { 377 // CHECK-LABEL: test_mm512_load_epi64 378 // CHECK: [[LI64_1:%.+]] = load ptr, ptr %__P.addr.i, align 8{{$}} 379 // CHECK: load <8 x i64>, ptr [[LI64_1]], align 64{{$}} 380 return _mm512_load_epi64 ( __P); 381 } 382 383 __m512 test_mm512_load_ps(void *p) 384 { 385 // CHECK-LABEL: test_mm512_load_ps 386 // CHECK: load <16 x float>, ptr %{{.*}}, align 64{{$}} 387 return _mm512_load_ps(p); 388 } 389 390 __m512 test_mm512_mask_load_ps (__m512 __W, __mmask16 __U, void *__P) 391 { 392 // CHECK-LABEL: test_mm512_mask_load_ps 393 // CHECK: @llvm.masked.load.v16f32.p0(ptr %{{.*}}, i32 64, <16 x i1> %{{.*}}, <16 x float> %{{.*}}) 394 return _mm512_mask_load_ps (__W,__U, __P); 395 } 396 397 __m512 test_mm512_maskz_load_ps(__mmask16 __U, void *__P) 398 { 399 // CHECK-LABEL: test_mm512_maskz_load_ps 400 // CHECK: @llvm.masked.load.v16f32.p0(ptr %{{.*}}, i32 64, <16 x i1> %{{.*}}, <16 x float> %{{.*}}) 401 return _mm512_maskz_load_ps(__U, __P); 402 } 403 404 __m512d test_mm512_load_pd(void *p) 405 { 406 // CHECK-LABEL: test_mm512_load_pd 407 // CHECK: load <8 x double>, ptr %{{.*}}, align 64{{$}} 408 return _mm512_load_pd(p); 409 } 410 411 __m512d test_mm512_mask_load_pd (__m512d __W, __mmask8 __U, void *__P) 412 { 413 // CHECK-LABEL: test_mm512_mask_load_pd 414 // CHECK: @llvm.masked.load.v8f64.p0(ptr %{{.*}}, i32 64, <8 x i1> %{{.*}}, <8 x double> %{{.*}}) 415 return _mm512_mask_load_pd (__W,__U, __P); 416 } 417 418 __m512d test_mm512_maskz_load_pd(__mmask8 __U, void *__P) 419 { 420 // CHECK-LABEL: test_mm512_maskz_load_pd 421 // CHECK: @llvm.masked.load.v8f64.p0(ptr %{{.*}}, i32 64, <8 x i1> %{{.*}}, <8 x double> %{{.*}}) 422 return _mm512_maskz_load_pd(__U, __P); 423 } 424 425 __m512d test_mm512_set1_pd(double d) 426 { 427 // CHECK-LABEL: test_mm512_set1_pd 428 // CHECK: insertelement <8 x double> {{.*}}, i32 0 429 // CHECK: insertelement <8 x double> {{.*}}, i32 1 430 // CHECK: insertelement <8 x double> {{.*}}, i32 2 431 // CHECK: insertelement <8 x double> {{.*}}, i32 3 432 // CHECK: insertelement <8 x double> {{.*}}, i32 4 433 // CHECK: insertelement <8 x double> {{.*}}, i32 5 434 // CHECK: insertelement <8 x double> {{.*}}, i32 6 435 // CHECK: insertelement <8 x double> {{.*}}, i32 7 436 return _mm512_set1_pd(d); 437 } 438 439 __mmask16 test_mm512_knot(__mmask16 a) 440 { 441 // CHECK-LABEL: test_mm512_knot 442 // CHECK: [[IN:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 443 // CHECK: [[NOT:%.*]] = xor <16 x i1> [[IN]], splat (i1 true) 444 // CHECK: bitcast <16 x i1> [[NOT]] to i16 445 return _mm512_knot(a); 446 } 447 448 __m512i test_mm512_alignr_epi32(__m512i a, __m512i b) 449 { 450 // CHECK-LABEL: test_mm512_alignr_epi32 451 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17> 452 return _mm512_alignr_epi32(a, b, 2); 453 } 454 455 __m512i test_mm512_mask_alignr_epi32(__m512i w, __mmask16 u, __m512i a, __m512i b) 456 { 457 // CHECK-LABEL: test_mm512_mask_alignr_epi32 458 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17> 459 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> {{.*}} 460 return _mm512_mask_alignr_epi32(w, u, a, b, 2); 461 } 462 463 __m512i test_mm512_maskz_alignr_epi32( __mmask16 u, __m512i a, __m512i b) 464 { 465 // CHECK-LABEL: test_mm512_maskz_alignr_epi32 466 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16, i32 17> 467 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> {{.*}} 468 return _mm512_maskz_alignr_epi32(u, a, b, 2); 469 } 470 471 __m512i test_mm512_alignr_epi64(__m512i a, __m512i b) 472 { 473 // CHECK-LABEL: test_mm512_alignr_epi64 474 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9> 475 return _mm512_alignr_epi64(a, b, 2); 476 } 477 478 __m512i test_mm512_mask_alignr_epi64(__m512i w, __mmask8 u, __m512i a, __m512i b) 479 { 480 // CHECK-LABEL: test_mm512_mask_alignr_epi64 481 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9> 482 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> {{.*}} 483 return _mm512_mask_alignr_epi64(w, u, a, b, 2); 484 } 485 486 __m512i test_mm512_maskz_alignr_epi64( __mmask8 u, __m512i a, __m512i b) 487 { 488 // CHECK-LABEL: test_mm512_maskz_alignr_epi64 489 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9> 490 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> {{.*}} 491 return _mm512_maskz_alignr_epi64(u, a, b, 2); 492 } 493 494 __m512d test_mm512_fmadd_round_pd(__m512d __A, __m512d __B, __m512d __C) { 495 // CHECK-LABEL: test_mm512_fmadd_round_pd 496 // CHECK: @llvm.x86.avx512.vfmadd.pd.512 497 return _mm512_fmadd_round_pd(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 498 } 499 500 __m512d test_mm512_mask_fmadd_round_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { 501 // CHECK-LABEL: test_mm512_mask_fmadd_round_pd 502 // CHECK: @llvm.x86.avx512.vfmadd.pd.512 503 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 504 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 505 return _mm512_mask_fmadd_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 506 } 507 __m512d test_mm512_mask3_fmadd_round_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { 508 // CHECK-LABEL: test_mm512_mask3_fmadd_round_pd 509 // CHECK: @llvm.x86.avx512.vfmadd.pd.512 510 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 511 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 512 return _mm512_mask3_fmadd_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 513 } 514 __m512d test_mm512_maskz_fmadd_round_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { 515 // CHECK-LABEL: test_mm512_maskz_fmadd_round_pd 516 // CHECK: @llvm.x86.avx512.vfmadd.pd.512 517 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 518 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> zeroinitializer 519 return _mm512_maskz_fmadd_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 520 } 521 __m512d test_mm512_fmsub_round_pd(__m512d __A, __m512d __B, __m512d __C) { 522 // CHECK-LABEL: test_mm512_fmsub_round_pd 523 // CHECK: fneg <8 x double> 524 // CHECK: @llvm.x86.avx512.vfmadd.pd.512 525 return _mm512_fmsub_round_pd(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 526 } 527 __m512d test_mm512_mask_fmsub_round_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { 528 // CHECK-LABEL: test_mm512_mask_fmsub_round_pd 529 // CHECK: fneg <8 x double> 530 // CHECK: @llvm.x86.avx512.vfmadd.pd.512 531 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 532 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 533 return _mm512_mask_fmsub_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 534 } 535 __m512d test_mm512_maskz_fmsub_round_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { 536 // CHECK-LABEL: test_mm512_maskz_fmsub_round_pd 537 // CHECK: fneg <8 x double> 538 // CHECK: @llvm.x86.avx512.vfmadd.pd.512 539 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 540 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> zeroinitializer 541 return _mm512_maskz_fmsub_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 542 } 543 __m512d test_mm512_fnmadd_round_pd(__m512d __A, __m512d __B, __m512d __C) { 544 // CHECK-LABEL: test_mm512_fnmadd_round_pd 545 // CHECK: fneg <8 x double> 546 // CHECK: @llvm.x86.avx512.vfmadd.pd.512 547 return _mm512_fnmadd_round_pd(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 548 } 549 __m512d test_mm512_mask3_fnmadd_round_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { 550 // CHECK-LABEL: test_mm512_mask3_fnmadd_round_pd 551 // CHECK: fneg <8 x double> 552 // CHECK: @llvm.x86.avx512.vfmadd.pd.512 553 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 554 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 555 return _mm512_mask3_fnmadd_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 556 } 557 __m512d test_mm512_maskz_fnmadd_round_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { 558 // CHECK-LABEL: test_mm512_maskz_fnmadd_round_pd 559 // CHECK: fneg <8 x double> 560 // CHECK: @llvm.x86.avx512.vfmadd.pd.512 561 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 562 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> zeroinitializer 563 return _mm512_maskz_fnmadd_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 564 } 565 __m512d test_mm512_fnmsub_round_pd(__m512d __A, __m512d __B, __m512d __C) { 566 // CHECK-LABEL: test_mm512_fnmsub_round_pd 567 // CHECK: fneg <8 x double> 568 // CHECK: fneg <8 x double> 569 // CHECK: @llvm.x86.avx512.vfmadd.pd.512 570 return _mm512_fnmsub_round_pd(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 571 } 572 __m512d test_mm512_maskz_fnmsub_round_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { 573 // CHECK-LABEL: test_mm512_maskz_fnmsub_round_pd 574 // CHECK: fneg <8 x double> 575 // CHECK: fneg <8 x double> 576 // CHECK: @llvm.x86.avx512.vfmadd.pd.512 577 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 578 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> zeroinitializer 579 return _mm512_maskz_fnmsub_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 580 } 581 __m512d test_mm512_fmadd_pd(__m512d __A, __m512d __B, __m512d __C) { 582 // CHECK-LABEL: test_mm512_fmadd_pd 583 // CHECK: call {{.*}}<8 x double> @llvm.fma.v8f64(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}) 584 return _mm512_fmadd_pd(__A, __B, __C); 585 } 586 __m512d test_mm512_mask_fmadd_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { 587 // CHECK-LABEL: test_mm512_mask_fmadd_pd 588 // CHECK: call {{.*}}<8 x double> @llvm.fma.v8f64(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}) 589 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 590 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 591 return _mm512_mask_fmadd_pd(__A, __U, __B, __C); 592 } 593 __m512d test_mm512_mask3_fmadd_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { 594 // CHECK-LABEL: test_mm512_mask3_fmadd_pd 595 // CHECK: call {{.*}}<8 x double> @llvm.fma.v8f64(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}) 596 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 597 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 598 return _mm512_mask3_fmadd_pd(__A, __B, __C, __U); 599 } 600 __m512d test_mm512_maskz_fmadd_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { 601 // CHECK-LABEL: test_mm512_maskz_fmadd_pd 602 // CHECK: call {{.*}}<8 x double> @llvm.fma.v8f64(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}) 603 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 604 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> zeroinitializer 605 return _mm512_maskz_fmadd_pd(__U, __A, __B, __C); 606 } 607 __m512d test_mm512_fmsub_pd(__m512d __A, __m512d __B, __m512d __C) { 608 // CHECK-LABEL: test_mm512_fmsub_pd 609 // CHECK: fneg <8 x double> %{{.*}} 610 // CHECK: call {{.*}}<8 x double> @llvm.fma.v8f64(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}) 611 return _mm512_fmsub_pd(__A, __B, __C); 612 } 613 __m512d test_mm512_mask_fmsub_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { 614 // CHECK-LABEL: test_mm512_mask_fmsub_pd 615 // CHECK: fneg <8 x double> %{{.*}} 616 // CHECK: call {{.*}}<8 x double> @llvm.fma.v8f64(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}) 617 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 618 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 619 return _mm512_mask_fmsub_pd(__A, __U, __B, __C); 620 } 621 __m512d test_mm512_maskz_fmsub_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { 622 // CHECK-LABEL: test_mm512_maskz_fmsub_pd 623 // CHECK: fneg <8 x double> %{{.*}} 624 // CHECK: call {{.*}}<8 x double> @llvm.fma.v8f64(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}) 625 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 626 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> zeroinitializer 627 return _mm512_maskz_fmsub_pd(__U, __A, __B, __C); 628 } 629 __m512d test_mm512_fnmadd_pd(__m512d __A, __m512d __B, __m512d __C) { 630 // CHECK-LABEL: test_mm512_fnmadd_pd 631 // CHECK: fneg <8 x double> %{{.*}} 632 // CHECK: call {{.*}}<8 x double> @llvm.fma.v8f64(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}) 633 return _mm512_fnmadd_pd(__A, __B, __C); 634 } 635 __m512d test_mm512_mask3_fnmadd_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { 636 // CHECK-LABEL: test_mm512_mask3_fnmadd_pd 637 // CHECK: fneg <8 x double> %{{.*}} 638 // CHECK: call {{.*}}<8 x double> @llvm.fma.v8f64(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}) 639 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 640 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 641 return _mm512_mask3_fnmadd_pd(__A, __B, __C, __U); 642 } 643 __m512d test_mm512_maskz_fnmadd_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { 644 // CHECK-LABEL: test_mm512_maskz_fnmadd_pd 645 // CHECK: fneg <8 x double> %{{.*}} 646 // CHECK: call {{.*}}<8 x double> @llvm.fma.v8f64(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}) 647 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 648 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> zeroinitializer 649 return _mm512_maskz_fnmadd_pd(__U, __A, __B, __C); 650 } 651 __m512d test_mm512_fnmsub_pd(__m512d __A, __m512d __B, __m512d __C) { 652 // CHECK-LABEL: test_mm512_fnmsub_pd 653 // CHECK: fneg <8 x double> %{{.*}} 654 // CHECK: fneg <8 x double> %{{.*}} 655 // CHECK: call {{.*}}<8 x double> @llvm.fma.v8f64(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}) 656 return _mm512_fnmsub_pd(__A, __B, __C); 657 } 658 __m512d test_mm512_maskz_fnmsub_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { 659 // CHECK-LABEL: test_mm512_maskz_fnmsub_pd 660 // CHECK: fneg <8 x double> %{{.*}} 661 // CHECK: fneg <8 x double> %{{.*}} 662 // CHECK: call {{.*}}<8 x double> @llvm.fma.v8f64(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}) 663 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 664 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> zeroinitializer 665 return _mm512_maskz_fnmsub_pd(__U, __A, __B, __C); 666 } 667 __m512 test_mm512_fmadd_round_ps(__m512 __A, __m512 __B, __m512 __C) { 668 // CHECK-LABEL: test_mm512_fmadd_round_ps 669 // CHECK: @llvm.x86.avx512.vfmadd.ps.512 670 return _mm512_fmadd_round_ps(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 671 } 672 __m512 test_mm512_mask_fmadd_round_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { 673 // CHECK-LABEL: test_mm512_mask_fmadd_round_ps 674 // CHECK: @llvm.x86.avx512.vfmadd.ps.512 675 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 676 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 677 return _mm512_mask_fmadd_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 678 } 679 __m512 test_mm512_mask3_fmadd_round_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { 680 // CHECK-LABEL: test_mm512_mask3_fmadd_round_ps 681 // CHECK: @llvm.x86.avx512.vfmadd.ps.512 682 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 683 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 684 return _mm512_mask3_fmadd_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 685 } 686 __m512 test_mm512_maskz_fmadd_round_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { 687 // CHECK-LABEL: test_mm512_maskz_fmadd_round_ps 688 // CHECK: @llvm.x86.avx512.vfmadd.ps.512 689 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 690 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> zeroinitializer 691 return _mm512_maskz_fmadd_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 692 } 693 __m512 test_mm512_fmsub_round_ps(__m512 __A, __m512 __B, __m512 __C) { 694 // CHECK-LABEL: test_mm512_fmsub_round_ps 695 // CHECK: fneg <16 x float> %{{.*}} 696 // CHECK: @llvm.x86.avx512.vfmadd.ps.512 697 return _mm512_fmsub_round_ps(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 698 } 699 __m512 test_mm512_mask_fmsub_round_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { 700 // CHECK-LABEL: test_mm512_mask_fmsub_round_ps 701 // CHECK: fneg <16 x float> %{{.*}} 702 // CHECK: @llvm.x86.avx512.vfmadd.ps.512 703 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 704 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 705 return _mm512_mask_fmsub_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 706 } 707 __m512 test_mm512_maskz_fmsub_round_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { 708 // CHECK-LABEL: test_mm512_maskz_fmsub_round_ps 709 // CHECK: fneg <16 x float> %{{.*}} 710 // CHECK: @llvm.x86.avx512.vfmadd.ps.512 711 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 712 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> zeroinitializer 713 return _mm512_maskz_fmsub_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 714 } 715 __m512 test_mm512_fnmadd_round_ps(__m512 __A, __m512 __B, __m512 __C) { 716 // CHECK-LABEL: test_mm512_fnmadd_round_ps 717 // CHECK: fneg <16 x float> %{{.*}} 718 // CHECK: @llvm.x86.avx512.vfmadd.ps.512 719 return _mm512_fnmadd_round_ps(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 720 } 721 __m512 test_mm512_mask3_fnmadd_round_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { 722 // CHECK-LABEL: test_mm512_mask3_fnmadd_round_ps 723 // CHECK: fneg <16 x float> %{{.*}} 724 // CHECK: @llvm.x86.avx512.vfmadd.ps.512 725 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 726 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 727 return _mm512_mask3_fnmadd_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 728 } 729 __m512 test_mm512_maskz_fnmadd_round_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { 730 // CHECK-LABEL: test_mm512_maskz_fnmadd_round_ps 731 // CHECK: fneg <16 x float> %{{.*}} 732 // CHECK: @llvm.x86.avx512.vfmadd.ps.512 733 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 734 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> zeroinitializer 735 return _mm512_maskz_fnmadd_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 736 } 737 __m512 test_mm512_fnmsub_round_ps(__m512 __A, __m512 __B, __m512 __C) { 738 // CHECK-LABEL: test_mm512_fnmsub_round_ps 739 // CHECK: fneg <16 x float> %{{.*}} 740 // CHECK: fneg <16 x float> %{{.*}} 741 // CHECK: @llvm.x86.avx512.vfmadd.ps.512 742 return _mm512_fnmsub_round_ps(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 743 } 744 __m512 test_mm512_maskz_fnmsub_round_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { 745 // CHECK-LABEL: test_mm512_maskz_fnmsub_round_ps 746 // CHECK: fneg <16 x float> %{{.*}} 747 // CHECK: fneg <16 x float> %{{.*}} 748 // CHECK: @llvm.x86.avx512.vfmadd.ps.512 749 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 750 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> zeroinitializer 751 return _mm512_maskz_fnmsub_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 752 } 753 __m512 test_mm512_fmadd_ps(__m512 __A, __m512 __B, __m512 __C) { 754 // CHECK-LABEL: test_mm512_fmadd_ps 755 // CHECK: call {{.*}}<16 x float> @llvm.fma.v16f32(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}) 756 return _mm512_fmadd_ps(__A, __B, __C); 757 } 758 __m512 test_mm512_mask_fmadd_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { 759 // CHECK-LABEL: test_mm512_mask_fmadd_ps 760 // CHECK: call {{.*}}<16 x float> @llvm.fma.v16f32(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}) 761 return _mm512_mask_fmadd_ps(__A, __U, __B, __C); 762 } 763 __m512 test_mm512_mask3_fmadd_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { 764 // CHECK-LABEL: test_mm512_mask3_fmadd_ps 765 // CHECK: call {{.*}}<16 x float> @llvm.fma.v16f32(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}) 766 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 767 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 768 return _mm512_mask3_fmadd_ps(__A, __B, __C, __U); 769 } 770 __m512 test_mm512_maskz_fmadd_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { 771 // CHECK-LABEL: test_mm512_maskz_fmadd_ps 772 // CHECK: call {{.*}}<16 x float> @llvm.fma.v16f32(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}) 773 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 774 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> zeroinitializer 775 return _mm512_maskz_fmadd_ps(__U, __A, __B, __C); 776 } 777 __m512 test_mm512_fmsub_ps(__m512 __A, __m512 __B, __m512 __C) { 778 // CHECK-LABEL: test_mm512_fmsub_ps 779 // CHECK: fneg <16 x float> %{{.*}} 780 // CHECK: call {{.*}}<16 x float> @llvm.fma.v16f32(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}) 781 return _mm512_fmsub_ps(__A, __B, __C); 782 } 783 __m512 test_mm512_mask_fmsub_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { 784 // CHECK-LABEL: test_mm512_mask_fmsub_ps 785 // CHECK: fneg <16 x float> %{{.*}} 786 // CHECK: call {{.*}}<16 x float> @llvm.fma.v16f32(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}) 787 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 788 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 789 return _mm512_mask_fmsub_ps(__A, __U, __B, __C); 790 } 791 __m512 test_mm512_maskz_fmsub_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { 792 // CHECK-LABEL: test_mm512_maskz_fmsub_ps 793 // CHECK: fneg <16 x float> %{{.*}} 794 // CHECK: call {{.*}}<16 x float> @llvm.fma.v16f32(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}) 795 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 796 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> zeroinitializer 797 return _mm512_maskz_fmsub_ps(__U, __A, __B, __C); 798 } 799 __m512 test_mm512_fnmadd_ps(__m512 __A, __m512 __B, __m512 __C) { 800 // CHECK-LABEL: test_mm512_fnmadd_ps 801 // CHECK: fneg <16 x float> %{{.*}} 802 // CHECK: call {{.*}}<16 x float> @llvm.fma.v16f32(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}) 803 return _mm512_fnmadd_ps(__A, __B, __C); 804 } 805 __m512 test_mm512_mask3_fnmadd_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { 806 // CHECK-LABEL: test_mm512_mask3_fnmadd_ps 807 // CHECK: fneg <16 x float> %{{.*}} 808 // CHECK: call {{.*}}<16 x float> @llvm.fma.v16f32(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}) 809 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 810 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 811 return _mm512_mask3_fnmadd_ps(__A, __B, __C, __U); 812 } 813 __m512 test_mm512_maskz_fnmadd_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { 814 // CHECK-LABEL: test_mm512_maskz_fnmadd_ps 815 // CHECK: fneg <16 x float> %{{.*}} 816 // CHECK: call {{.*}}<16 x float> @llvm.fma.v16f32(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}) 817 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 818 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> zeroinitializer 819 return _mm512_maskz_fnmadd_ps(__U, __A, __B, __C); 820 } 821 __m512 test_mm512_fnmsub_ps(__m512 __A, __m512 __B, __m512 __C) { 822 // CHECK-LABEL: test_mm512_fnmsub_ps 823 // CHECK: fneg <16 x float> %{{.*}} 824 // CHECK: fneg <16 x float> %{{.*}} 825 // CHECK: call {{.*}}<16 x float> @llvm.fma.v16f32(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}) 826 return _mm512_fnmsub_ps(__A, __B, __C); 827 } 828 __m512 test_mm512_maskz_fnmsub_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { 829 // CHECK-LABEL: test_mm512_maskz_fnmsub_ps 830 // CHECK: fneg <16 x float> %{{.*}} 831 // CHECK: fneg <16 x float> %{{.*}} 832 // CHECK: call {{.*}}<16 x float> @llvm.fma.v16f32(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}) 833 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 834 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> zeroinitializer 835 return _mm512_maskz_fnmsub_ps(__U, __A, __B, __C); 836 } 837 __m512d test_mm512_fmaddsub_round_pd(__m512d __A, __m512d __B, __m512d __C) { 838 // CHECK-LABEL: test_mm512_fmaddsub_round_pd 839 // CHECK: @llvm.x86.avx512.vfmaddsub.pd.512 840 return _mm512_fmaddsub_round_pd(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 841 } 842 __m512d test_mm512_mask_fmaddsub_round_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { 843 // CHECK-LABEL: test_mm512_mask_fmaddsub_round_pd 844 // CHECK: @llvm.x86.avx512.vfmaddsub.pd.512 845 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 846 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 847 return _mm512_mask_fmaddsub_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 848 } 849 __m512d test_mm512_mask3_fmaddsub_round_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { 850 // CHECK-LABEL: test_mm512_mask3_fmaddsub_round_pd 851 // CHECK: @llvm.x86.avx512.vfmaddsub.pd.512 852 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 853 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 854 return _mm512_mask3_fmaddsub_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 855 } 856 __m512d test_mm512_maskz_fmaddsub_round_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { 857 // CHECK-LABEL: test_mm512_maskz_fmaddsub_round_pd 858 // CHECK: @llvm.x86.avx512.vfmaddsub.pd.512 859 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 860 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> zeroinitializer 861 return _mm512_maskz_fmaddsub_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 862 } 863 __m512d test_mm512_fmsubadd_round_pd(__m512d __A, __m512d __B, __m512d __C) { 864 // CHECK-LABEL: test_mm512_fmsubadd_round_pd 865 // CHECK: fneg <8 x double> %{{.*}} 866 // CHECK: @llvm.x86.avx512.vfmaddsub.pd.512 867 return _mm512_fmsubadd_round_pd(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 868 } 869 __m512d test_mm512_mask_fmsubadd_round_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { 870 // CHECK-LABEL: test_mm512_mask_fmsubadd_round_pd 871 // CHECK: fneg <8 x double> %{{.*}} 872 // CHECK: @llvm.x86.avx512.vfmaddsub.pd.512 873 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 874 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 875 return _mm512_mask_fmsubadd_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 876 } 877 __m512d test_mm512_maskz_fmsubadd_round_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { 878 // CHECK-LABEL: test_mm512_maskz_fmsubadd_round_pd 879 // CHECK: fneg <8 x double> %{{.*}} 880 // CHECK: @llvm.x86.avx512.vfmaddsub.pd.512 881 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 882 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> zeroinitializer 883 return _mm512_maskz_fmsubadd_round_pd(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 884 } 885 __m512d test_mm512_fmaddsub_pd(__m512d __A, __m512d __B, __m512d __C) { 886 // CHECK-LABEL: test_mm512_fmaddsub_pd 887 // CHECK-NOT: fneg 888 // CHECK: call {{.*}}<8 x double> @llvm.x86.avx512.vfmaddsub.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 4) 889 return _mm512_fmaddsub_pd(__A, __B, __C); 890 } 891 __m512d test_mm512_mask_fmaddsub_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { 892 // CHECK-LABEL: test_mm512_mask_fmaddsub_pd 893 // CHECK-NOT: fneg 894 // CHECK: call {{.*}}<8 x double> @llvm.x86.avx512.vfmaddsub.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 4) 895 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 896 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 897 return _mm512_mask_fmaddsub_pd(__A, __U, __B, __C); 898 } 899 __m512d test_mm512_mask3_fmaddsub_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { 900 // CHECK-LABEL: test_mm512_mask3_fmaddsub_pd 901 // CHECK-NOT: fneg 902 // CHECK: call {{.*}}<8 x double> @llvm.x86.avx512.vfmaddsub.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 4) 903 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 904 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 905 return _mm512_mask3_fmaddsub_pd(__A, __B, __C, __U); 906 } 907 __m512d test_mm512_maskz_fmaddsub_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { 908 // CHECK-LABEL: test_mm512_maskz_fmaddsub_pd 909 // CHECK-NOT: fneg 910 // CHECK: call {{.*}}<8 x double> @llvm.x86.avx512.vfmaddsub.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 4) 911 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 912 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> zeroinitializer 913 return _mm512_maskz_fmaddsub_pd(__U, __A, __B, __C); 914 } 915 __m512d test_mm512_fmsubadd_pd(__m512d __A, __m512d __B, __m512d __C) { 916 // CHECK-LABEL: test_mm512_fmsubadd_pd 917 // CHECK: [[NEG:%.+]] = fneg <8 x double> %{{.*}} 918 // CHECK: call {{.*}}<8 x double> @llvm.x86.avx512.vfmaddsub.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> [[NEG]], i32 4) 919 return _mm512_fmsubadd_pd(__A, __B, __C); 920 } 921 __m512d test_mm512_mask_fmsubadd_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { 922 // CHECK-LABEL: test_mm512_mask_fmsubadd_pd 923 // CHECK: [[NEG:%.+]] = fneg <8 x double> %{{.*}} 924 // CHECK: call {{.*}}<8 x double> @llvm.x86.avx512.vfmaddsub.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> [[NEG]], i32 4) 925 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 926 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 927 return _mm512_mask_fmsubadd_pd(__A, __U, __B, __C); 928 } 929 __m512d test_mm512_maskz_fmsubadd_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C) { 930 // CHECK-LABEL: test_mm512_maskz_fmsubadd_pd 931 // CHECK: [[NEG:%.+]] = fneg <8 x double> %{{.*}} 932 // CHECK: call {{.*}}<8 x double> @llvm.x86.avx512.vfmaddsub.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> [[NEG]], i32 4) 933 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 934 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> zeroinitializer 935 return _mm512_maskz_fmsubadd_pd(__U, __A, __B, __C); 936 } 937 __m512 test_mm512_fmaddsub_round_ps(__m512 __A, __m512 __B, __m512 __C) { 938 // CHECK-LABEL: test_mm512_fmaddsub_round_ps 939 // CHECK: @llvm.x86.avx512.vfmaddsub.ps.512 940 return _mm512_fmaddsub_round_ps(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 941 } 942 __m512 test_mm512_mask_fmaddsub_round_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { 943 // CHECK-LABEL: test_mm512_mask_fmaddsub_round_ps 944 // CHECK: @llvm.x86.avx512.vfmaddsub.ps.512 945 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 946 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 947 return _mm512_mask_fmaddsub_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 948 } 949 __m512 test_mm512_mask3_fmaddsub_round_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { 950 // CHECK-LABEL: test_mm512_mask3_fmaddsub_round_ps 951 // CHECK: @llvm.x86.avx512.vfmaddsub.ps.512 952 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 953 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 954 return _mm512_mask3_fmaddsub_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 955 } 956 __m512 test_mm512_maskz_fmaddsub_round_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { 957 // CHECK-LABEL: test_mm512_maskz_fmaddsub_round_ps 958 // CHECK: @llvm.x86.avx512.vfmaddsub.ps.512 959 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 960 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> zeroinitializer 961 return _mm512_maskz_fmaddsub_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 962 } 963 __m512 test_mm512_fmsubadd_round_ps(__m512 __A, __m512 __B, __m512 __C) { 964 // CHECK-LABEL: test_mm512_fmsubadd_round_ps 965 // CHECK: fneg <16 x float> %{{.*}} 966 // CHECK: @llvm.x86.avx512.vfmaddsub.ps.512 967 return _mm512_fmsubadd_round_ps(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 968 } 969 __m512 test_mm512_mask_fmsubadd_round_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { 970 // CHECK-LABEL: test_mm512_mask_fmsubadd_round_ps 971 // CHECK: fneg <16 x float> %{{.*}} 972 // CHECK: @llvm.x86.avx512.vfmaddsub.ps.512 973 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 974 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 975 return _mm512_mask_fmsubadd_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 976 } 977 __m512 test_mm512_maskz_fmsubadd_round_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { 978 // CHECK-LABEL: test_mm512_maskz_fmsubadd_round_ps 979 // CHECK: fneg <16 x float> %{{.*}} 980 // CHECK: @llvm.x86.avx512.vfmaddsub.ps.512 981 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 982 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> zeroinitializer 983 return _mm512_maskz_fmsubadd_round_ps(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 984 } 985 __m512 test_mm512_fmaddsub_ps(__m512 __A, __m512 __B, __m512 __C) { 986 // CHECK-LABEL: test_mm512_fmaddsub_ps 987 // CHECK-NOT: fneg 988 // CHECK: call {{.*}}<16 x float> @llvm.x86.avx512.vfmaddsub.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 4) 989 return _mm512_fmaddsub_ps(__A, __B, __C); 990 } 991 __m512 test_mm512_mask_fmaddsub_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { 992 // CHECK-LABEL: test_mm512_mask_fmaddsub_ps 993 // CHECK-NOT: fneg 994 // CHECK: call {{.*}}<16 x float> @llvm.x86.avx512.vfmaddsub.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 4) 995 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 996 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 997 return _mm512_mask_fmaddsub_ps(__A, __U, __B, __C); 998 } 999 __m512 test_mm512_mask3_fmaddsub_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { 1000 // CHECK-LABEL: test_mm512_mask3_fmaddsub_ps 1001 // CHECK-NOT: fneg 1002 // CHECK: call {{.*}}<16 x float> @llvm.x86.avx512.vfmaddsub.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 4) 1003 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 1004 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 1005 return _mm512_mask3_fmaddsub_ps(__A, __B, __C, __U); 1006 } 1007 __m512 test_mm512_maskz_fmaddsub_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { 1008 // CHECK-LABEL: test_mm512_maskz_fmaddsub_ps 1009 // CHECK-NOT: fneg 1010 // CHECK: call {{.*}}<16 x float> @llvm.x86.avx512.vfmaddsub.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 4) 1011 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 1012 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> zeroinitializer 1013 return _mm512_maskz_fmaddsub_ps(__U, __A, __B, __C); 1014 } 1015 __m512 test_mm512_fmsubadd_ps(__m512 __A, __m512 __B, __m512 __C) { 1016 // CHECK-LABEL: test_mm512_fmsubadd_ps 1017 // CHECK: [[NEG:%.+]] = fneg <16 x float> %{{.*}} 1018 // CHECK: call {{.*}}<16 x float> @llvm.x86.avx512.vfmaddsub.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> [[NEG]], i32 4) 1019 return _mm512_fmsubadd_ps(__A, __B, __C); 1020 } 1021 __m512 test_mm512_mask_fmsubadd_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { 1022 // CHECK-LABEL: test_mm512_mask_fmsubadd_ps 1023 // CHECK: [[NEG:%.+]] = fneg <16 x float> %{{.*}} 1024 // CHECK: call {{.*}}<16 x float> @llvm.x86.avx512.vfmaddsub.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> [[NEG]], i32 4) 1025 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 1026 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 1027 return _mm512_mask_fmsubadd_ps(__A, __U, __B, __C); 1028 } 1029 __m512 test_mm512_maskz_fmsubadd_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C) { 1030 // CHECK-LABEL: test_mm512_maskz_fmsubadd_ps 1031 // CHECK: [[NEG:%.+]] = fneg <16 x float> %{{.*}} 1032 // CHECK: call {{.*}}<16 x float> @llvm.x86.avx512.vfmaddsub.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> [[NEG]], i32 4) 1033 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 1034 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> zeroinitializer 1035 return _mm512_maskz_fmsubadd_ps(__U, __A, __B, __C); 1036 } 1037 __m512d test_mm512_mask3_fmsub_round_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { 1038 // CHECK-LABEL: test_mm512_mask3_fmsub_round_pd 1039 // CHECK: fneg <8 x double> %{{.*}} 1040 // CHECK: @llvm.x86.avx512.vfmadd.pd.512 1041 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 1042 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 1043 return _mm512_mask3_fmsub_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 1044 } 1045 __m512d test_mm512_mask3_fmsub_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { 1046 // CHECK-LABEL: test_mm512_mask3_fmsub_pd 1047 // CHECK: fneg <8 x double> %{{.*}} 1048 // CHECK: call {{.*}}<8 x double> @llvm.fma.v8f64(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}) 1049 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 1050 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 1051 return _mm512_mask3_fmsub_pd(__A, __B, __C, __U); 1052 } 1053 __m512 test_mm512_mask3_fmsub_round_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { 1054 // CHECK-LABEL: test_mm512_mask3_fmsub_round_ps 1055 // CHECK: fneg <16 x float> %{{.*}} 1056 // CHECK: @llvm.x86.avx512.vfmadd.ps.512 1057 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 1058 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 1059 return _mm512_mask3_fmsub_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 1060 } 1061 __m512 test_mm512_mask3_fmsub_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { 1062 // CHECK-LABEL: test_mm512_mask3_fmsub_ps 1063 // CHECK: fneg <16 x float> %{{.*}} 1064 // CHECK: call {{.*}}<16 x float> @llvm.fma.v16f32(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}) 1065 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 1066 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 1067 return _mm512_mask3_fmsub_ps(__A, __B, __C, __U); 1068 } 1069 __m512d test_mm512_mask3_fmsubadd_round_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { 1070 // CHECK-LABEL: test_mm512_mask3_fmsubadd_round_pd 1071 // CHECK: fneg <8 x double> %{{.*}} 1072 // CHECK: @llvm.x86.avx512.vfmaddsub.pd.512 1073 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 1074 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 1075 return _mm512_mask3_fmsubadd_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 1076 } 1077 __m512d test_mm512_mask3_fmsubadd_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { 1078 // CHECK-LABEL: test_mm512_mask3_fmsubadd_pd 1079 // CHECK: [[NEG:%.+]] = fneg <8 x double> %{{.*}} 1080 // CHECK: call {{.*}}<8 x double> @llvm.x86.avx512.vfmaddsub.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> [[NEG]], i32 4) 1081 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 1082 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 1083 return _mm512_mask3_fmsubadd_pd(__A, __B, __C, __U); 1084 } 1085 __m512 test_mm512_mask3_fmsubadd_round_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { 1086 // CHECK-LABEL: test_mm512_mask3_fmsubadd_round_ps 1087 // CHECK: fneg <16 x float> %{{.*}} 1088 // CHECK: @llvm.x86.avx512.vfmaddsub.ps.512 1089 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 1090 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 1091 return _mm512_mask3_fmsubadd_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 1092 } 1093 __m512 test_mm512_mask3_fmsubadd_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { 1094 // CHECK-LABEL: test_mm512_mask3_fmsubadd_ps 1095 // CHECK: [[NEG:%.+]] = fneg <16 x float> %{{.*}} 1096 // CHECK: call {{.*}}<16 x float> @llvm.x86.avx512.vfmaddsub.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> [[NEG]], i32 4) 1097 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 1098 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 1099 return _mm512_mask3_fmsubadd_ps(__A, __B, __C, __U); 1100 } 1101 __m512d test_mm512_mask_fnmadd_round_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { 1102 // CHECK-LABEL: test_mm512_mask_fnmadd_round_pd 1103 // CHECK: fneg <8 x double> 1104 // CHECK: @llvm.x86.avx512.vfmadd.pd.512 1105 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 1106 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 1107 return _mm512_mask_fnmadd_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 1108 } 1109 __m512d test_mm512_mask_fnmadd_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { 1110 // CHECK-LABEL: test_mm512_mask_fnmadd_pd 1111 // CHECK: fneg <8 x double> %{{.*}} 1112 // CHECK: call {{.*}}<8 x double> @llvm.fma.v8f64(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}) 1113 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 1114 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 1115 return _mm512_mask_fnmadd_pd(__A, __U, __B, __C); 1116 } 1117 __m512 test_mm512_mask_fnmadd_round_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { 1118 // CHECK-LABEL: test_mm512_mask_fnmadd_round_ps 1119 // CHECK: fneg <16 x float> %{{.*}} 1120 // CHECK: @llvm.x86.avx512.vfmadd.ps.512 1121 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 1122 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 1123 return _mm512_mask_fnmadd_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 1124 } 1125 __m512 test_mm512_mask_fnmadd_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { 1126 // CHECK-LABEL: test_mm512_mask_fnmadd_ps 1127 // CHECK: fneg <16 x float> %{{.*}} 1128 // CHECK: call {{.*}}<16 x float> @llvm.fma.v16f32(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}) 1129 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 1130 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 1131 return _mm512_mask_fnmadd_ps(__A, __U, __B, __C); 1132 } 1133 __m512d test_mm512_mask_fnmsub_round_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { 1134 // CHECK-LABEL: test_mm512_mask_fnmsub_round_pd 1135 // CHECK: fneg <8 x double> 1136 // CHECK: fneg <8 x double> 1137 // CHECK: @llvm.x86.avx512.vfmadd.pd.512 1138 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 1139 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 1140 return _mm512_mask_fnmsub_round_pd(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 1141 } 1142 __m512d test_mm512_mask3_fnmsub_round_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { 1143 // CHECK-LABEL: test_mm512_mask3_fnmsub_round_pd 1144 // CHECK: fneg <8 x double> 1145 // CHECK: fneg <8 x double> 1146 // CHECK: @llvm.x86.avx512.vfmadd.pd.512 1147 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 1148 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 1149 return _mm512_mask3_fnmsub_round_pd(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 1150 } 1151 __m512d test_mm512_mask_fnmsub_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C) { 1152 // CHECK-LABEL: test_mm512_mask_fnmsub_pd 1153 // CHECK: fneg <8 x double> %{{.*}} 1154 // CHECK: fneg <8 x double> %{{.*}} 1155 // CHECK: call {{.*}}<8 x double> @llvm.fma.v8f64(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}) 1156 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 1157 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 1158 return _mm512_mask_fnmsub_pd(__A, __U, __B, __C); 1159 } 1160 __m512d test_mm512_mask3_fnmsub_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U) { 1161 // CHECK-LABEL: test_mm512_mask3_fnmsub_pd 1162 // CHECK: fneg <8 x double> %{{.*}} 1163 // CHECK: fneg <8 x double> %{{.*}} 1164 // CHECK: call {{.*}}<8 x double> @llvm.fma.v8f64(<8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}}) 1165 // CHECK: bitcast i8 %{{.*}} to <8 x i1> 1166 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 1167 return _mm512_mask3_fnmsub_pd(__A, __B, __C, __U); 1168 } 1169 __m512 test_mm512_mask_fnmsub_round_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { 1170 // CHECK-LABEL: test_mm512_mask_fnmsub_round_ps 1171 // CHECK: fneg <16 x float> %{{.*}} 1172 // CHECK: fneg <16 x float> %{{.*}} 1173 // CHECK: @llvm.x86.avx512.vfmadd.ps.512 1174 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 1175 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 1176 return _mm512_mask_fnmsub_round_ps(__A, __U, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 1177 } 1178 __m512 test_mm512_mask3_fnmsub_round_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { 1179 // CHECK-LABEL: test_mm512_mask3_fnmsub_round_ps 1180 // CHECK: fneg <16 x float> %{{.*}} 1181 // CHECK: fneg <16 x float> %{{.*}} 1182 // CHECK: @llvm.x86.avx512.vfmadd.ps.512 1183 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 1184 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 1185 return _mm512_mask3_fnmsub_round_ps(__A, __B, __C, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 1186 } 1187 __m512 test_mm512_mask_fnmsub_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C) { 1188 // CHECK-LABEL: test_mm512_mask_fnmsub_ps 1189 // CHECK: fneg <16 x float> %{{.*}} 1190 // CHECK: fneg <16 x float> %{{.*}} 1191 // CHECK: call {{.*}}<16 x float> @llvm.fma.v16f32(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}) 1192 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 1193 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 1194 return _mm512_mask_fnmsub_ps(__A, __U, __B, __C); 1195 } 1196 __m512 test_mm512_mask3_fnmsub_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U) { 1197 // CHECK-LABEL: test_mm512_mask3_fnmsub_ps 1198 // CHECK: fneg <16 x float> %{{.*}} 1199 // CHECK: fneg <16 x float> %{{.*}} 1200 // CHECK: call {{.*}}<16 x float> @llvm.fma.v16f32(<16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}}) 1201 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 1202 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 1203 return _mm512_mask3_fnmsub_ps(__A, __B, __C, __U); 1204 } 1205 1206 __mmask16 test_mm512_cmpeq_epi32_mask(__m512i __a, __m512i __b) { 1207 // CHECK-LABEL: test_mm512_cmpeq_epi32_mask 1208 // CHECK: icmp eq <16 x i32> %{{.*}}, %{{.*}} 1209 return (__mmask16)_mm512_cmpeq_epi32_mask(__a, __b); 1210 } 1211 1212 __mmask16 test_mm512_mask_cmpeq_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { 1213 // CHECK-LABEL: test_mm512_mask_cmpeq_epi32_mask 1214 // CHECK: icmp eq <16 x i32> %{{.*}}, %{{.*}} 1215 // CHECK: and <16 x i1> %{{.*}}, %{{.*}} 1216 return (__mmask16)_mm512_mask_cmpeq_epi32_mask(__u, __a, __b); 1217 } 1218 1219 __mmask8 test_mm512_mask_cmpeq_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { 1220 // CHECK-LABEL: test_mm512_mask_cmpeq_epi64_mask 1221 // CHECK: icmp eq <8 x i64> %{{.*}}, %{{.*}} 1222 // CHECK: and <8 x i1> %{{.*}}, %{{.*}} 1223 return (__mmask8)_mm512_mask_cmpeq_epi64_mask(__u, __a, __b); 1224 } 1225 1226 __mmask8 test_mm512_cmpeq_epi64_mask(__m512i __a, __m512i __b) { 1227 // CHECK-LABEL: test_mm512_cmpeq_epi64_mask 1228 // CHECK: icmp eq <8 x i64> %{{.*}}, %{{.*}} 1229 return (__mmask8)_mm512_cmpeq_epi64_mask(__a, __b); 1230 } 1231 1232 __mmask16 test_mm512_cmpgt_epi32_mask(__m512i __a, __m512i __b) { 1233 // CHECK-LABEL: test_mm512_cmpgt_epi32_mask 1234 // CHECK: icmp sgt <16 x i32> %{{.*}}, %{{.*}} 1235 return (__mmask16)_mm512_cmpgt_epi32_mask(__a, __b); 1236 } 1237 1238 __mmask16 test_mm512_mask_cmpgt_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { 1239 // CHECK-LABEL: test_mm512_mask_cmpgt_epi32_mask 1240 // CHECK: icmp sgt <16 x i32> %{{.*}}, %{{.*}} 1241 // CHECK: and <16 x i1> %{{.*}}, %{{.*}} 1242 return (__mmask16)_mm512_mask_cmpgt_epi32_mask(__u, __a, __b); 1243 } 1244 1245 __mmask8 test_mm512_mask_cmpgt_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { 1246 // CHECK-LABEL: test_mm512_mask_cmpgt_epi64_mask 1247 // CHECK: icmp sgt <8 x i64> %{{.*}}, %{{.*}} 1248 // CHECK: and <8 x i1> %{{.*}}, %{{.*}} 1249 return (__mmask8)_mm512_mask_cmpgt_epi64_mask(__u, __a, __b); 1250 } 1251 1252 __mmask8 test_mm512_cmpgt_epi64_mask(__m512i __a, __m512i __b) { 1253 // CHECK-LABEL: test_mm512_cmpgt_epi64_mask 1254 // CHECK: icmp sgt <8 x i64> %{{.*}}, %{{.*}} 1255 return (__mmask8)_mm512_cmpgt_epi64_mask(__a, __b); 1256 } 1257 1258 __m512d test_mm512_unpackhi_pd(__m512d a, __m512d b) 1259 { 1260 // CHECK-LABEL: test_mm512_unpackhi_pd 1261 // CHECK: shufflevector <8 x double> {{.*}} <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15> 1262 return _mm512_unpackhi_pd(a, b); 1263 } 1264 1265 __m512d test_mm512_unpacklo_pd(__m512d a, __m512d b) 1266 { 1267 // CHECK-LABEL: test_mm512_unpacklo_pd 1268 // CHECK: shufflevector <8 x double> {{.*}} <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14> 1269 return _mm512_unpacklo_pd(a, b); 1270 } 1271 1272 __m512 test_mm512_unpackhi_ps(__m512 a, __m512 b) 1273 { 1274 // CHECK-LABEL: test_mm512_unpackhi_ps 1275 // CHECK: shufflevector <16 x float> {{.*}} <i32 2, i32 18, i32 3, i32 19, i32 6, i32 22, i32 7, i32 23, i32 10, i32 26, i32 11, i32 27, i32 14, i32 30, i32 15, i32 31> 1276 return _mm512_unpackhi_ps(a, b); 1277 } 1278 1279 __m512 test_mm512_unpacklo_ps(__m512 a, __m512 b) 1280 { 1281 // CHECK-LABEL: test_mm512_unpacklo_ps 1282 // CHECK: shufflevector <16 x float> {{.*}} <i32 0, i32 16, i32 1, i32 17, i32 4, i32 20, i32 5, i32 21, i32 8, i32 24, i32 9, i32 25, i32 12, i32 28, i32 13, i32 29> 1283 return _mm512_unpacklo_ps(a, b); 1284 } 1285 1286 __mmask16 test_mm512_cmp_round_ps_mask(__m512 a, __m512 b) { 1287 // CHECK-LABEL: test_mm512_cmp_round_ps_mask 1288 // CHECK: fcmp oeq <16 x float> %{{.*}}, %{{.*}} 1289 return _mm512_cmp_round_ps_mask(a, b, _CMP_EQ_OQ, _MM_FROUND_NO_EXC); 1290 } 1291 1292 __mmask16 test_mm512_mask_cmp_round_ps_mask(__mmask16 m, __m512 a, __m512 b) { 1293 // CHECK-LABEL: test_mm512_mask_cmp_round_ps_mask 1294 // CHECK: [[CMP:%.*]] = fcmp oeq <16 x float> %{{.*}}, %{{.*}} 1295 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1296 return _mm512_mask_cmp_round_ps_mask(m, a, b, _CMP_EQ_OQ, _MM_FROUND_NO_EXC); 1297 } 1298 1299 __mmask16 test_mm512_cmp_ps_mask_eq_oq(__m512 a, __m512 b) { 1300 // CHECK-LABEL: test_mm512_cmp_ps_mask_eq_oq 1301 // CHECK: fcmp oeq <16 x float> %{{.*}}, %{{.*}} 1302 return _mm512_cmp_ps_mask(a, b, _CMP_EQ_OQ); 1303 } 1304 1305 __mmask16 test_mm512_cmp_ps_mask_lt_os(__m512 a, __m512 b) { 1306 // CHECK-LABEL: test_mm512_cmp_ps_mask_lt_os 1307 // CHECK: fcmp olt <16 x float> %{{.*}}, %{{.*}} 1308 return _mm512_cmp_ps_mask(a, b, _CMP_LT_OS); 1309 } 1310 1311 __mmask16 test_mm512_cmp_ps_mask_le_os(__m512 a, __m512 b) { 1312 // CHECK-LABEL: test_mm512_cmp_ps_mask_le_os 1313 // CHECK: fcmp ole <16 x float> %{{.*}}, %{{.*}} 1314 return _mm512_cmp_ps_mask(a, b, _CMP_LE_OS); 1315 } 1316 1317 __mmask16 test_mm512_cmp_ps_mask_unord_q(__m512 a, __m512 b) { 1318 // CHECK-LABEL: test_mm512_cmp_ps_mask_unord_q 1319 // CHECK: fcmp uno <16 x float> %{{.*}}, %{{.*}} 1320 return _mm512_cmp_ps_mask(a, b, _CMP_UNORD_Q); 1321 } 1322 1323 __mmask16 test_mm512_cmp_ps_mask_neq_uq(__m512 a, __m512 b) { 1324 // CHECK-LABEL: test_mm512_cmp_ps_mask_neq_uq 1325 // CHECK: fcmp une <16 x float> %{{.*}}, %{{.*}} 1326 return _mm512_cmp_ps_mask(a, b, _CMP_NEQ_UQ); 1327 } 1328 1329 __mmask16 test_mm512_cmp_ps_mask_nlt_us(__m512 a, __m512 b) { 1330 // CHECK-LABEL: test_mm512_cmp_ps_mask_nlt_us 1331 // CHECK: fcmp uge <16 x float> %{{.*}}, %{{.*}} 1332 return _mm512_cmp_ps_mask(a, b, _CMP_NLT_US); 1333 } 1334 1335 __mmask16 test_mm512_cmp_ps_mask_nle_us(__m512 a, __m512 b) { 1336 // CHECK-LABEL: test_mm512_cmp_ps_mask_nle_us 1337 // CHECK: fcmp ugt <16 x float> %{{.*}}, %{{.*}} 1338 return _mm512_cmp_ps_mask(a, b, _CMP_NLE_US); 1339 } 1340 1341 __mmask16 test_mm512_cmp_ps_mask_ord_q(__m512 a, __m512 b) { 1342 // CHECK-LABEL: test_mm512_cmp_ps_mask_ord_q 1343 // CHECK: fcmp ord <16 x float> %{{.*}}, %{{.*}} 1344 return _mm512_cmp_ps_mask(a, b, _CMP_ORD_Q); 1345 } 1346 1347 __mmask16 test_mm512_cmp_ps_mask_eq_uq(__m512 a, __m512 b) { 1348 // CHECK-LABEL: test_mm512_cmp_ps_mask_eq_uq 1349 // CHECK: fcmp ueq <16 x float> %{{.*}}, %{{.*}} 1350 return _mm512_cmp_ps_mask(a, b, _CMP_EQ_UQ); 1351 } 1352 1353 __mmask16 test_mm512_cmp_ps_mask_nge_us(__m512 a, __m512 b) { 1354 // CHECK-LABEL: test_mm512_cmp_ps_mask_nge_us 1355 // CHECK: fcmp ult <16 x float> %{{.*}}, %{{.*}} 1356 return _mm512_cmp_ps_mask(a, b, _CMP_NGE_US); 1357 } 1358 1359 __mmask16 test_mm512_cmp_ps_mask_ngt_us(__m512 a, __m512 b) { 1360 // CHECK-LABEL: test_mm512_cmp_ps_mask_ngt_us 1361 // CHECK: fcmp ule <16 x float> %{{.*}}, %{{.*}} 1362 return _mm512_cmp_ps_mask(a, b, _CMP_NGT_US); 1363 } 1364 1365 __mmask16 test_mm512_cmp_ps_mask_false_oq(__m512 a, __m512 b) { 1366 // CHECK-LABEL: test_mm512_cmp_ps_mask_false_oq 1367 // CHECK: fcmp false <16 x float> %{{.*}}, %{{.*}} 1368 return _mm512_cmp_ps_mask(a, b, _CMP_FALSE_OQ); 1369 } 1370 1371 __mmask16 test_mm512_cmp_ps_mask_neq_oq(__m512 a, __m512 b) { 1372 // CHECK-LABEL: test_mm512_cmp_ps_mask_neq_oq 1373 // CHECK: fcmp one <16 x float> %{{.*}}, %{{.*}} 1374 return _mm512_cmp_ps_mask(a, b, _CMP_NEQ_OQ); 1375 } 1376 1377 __mmask16 test_mm512_cmp_ps_mask_ge_os(__m512 a, __m512 b) { 1378 // CHECK-LABEL: test_mm512_cmp_ps_mask_ge_os 1379 // CHECK: fcmp oge <16 x float> %{{.*}}, %{{.*}} 1380 return _mm512_cmp_ps_mask(a, b, _CMP_GE_OS); 1381 } 1382 1383 __mmask16 test_mm512_cmp_ps_mask_gt_os(__m512 a, __m512 b) { 1384 // CHECK-LABEL: test_mm512_cmp_ps_mask_gt_os 1385 // CHECK: fcmp ogt <16 x float> %{{.*}}, %{{.*}} 1386 return _mm512_cmp_ps_mask(a, b, _CMP_GT_OS); 1387 } 1388 1389 __mmask16 test_mm512_cmp_ps_mask_true_uq(__m512 a, __m512 b) { 1390 // CHECK-LABEL: test_mm512_cmp_ps_mask_true_uq 1391 // CHECK: fcmp true <16 x float> %{{.*}}, %{{.*}} 1392 return _mm512_cmp_ps_mask(a, b, _CMP_TRUE_UQ); 1393 } 1394 1395 __mmask16 test_mm512_cmp_ps_mask_eq_os(__m512 a, __m512 b) { 1396 // CHECK-LABEL: test_mm512_cmp_ps_mask_eq_os 1397 // CHECK: fcmp oeq <16 x float> %{{.*}}, %{{.*}} 1398 return _mm512_cmp_ps_mask(a, b, _CMP_EQ_OS); 1399 } 1400 1401 __mmask16 test_mm512_cmp_ps_mask_lt_oq(__m512 a, __m512 b) { 1402 // CHECK-LABEL: test_mm512_cmp_ps_mask_lt_oq 1403 // CHECK: fcmp olt <16 x float> %{{.*}}, %{{.*}} 1404 return _mm512_cmp_ps_mask(a, b, _CMP_LT_OQ); 1405 } 1406 1407 __mmask16 test_mm512_cmp_ps_mask_le_oq(__m512 a, __m512 b) { 1408 // CHECK-LABEL: test_mm512_cmp_ps_mask_le_oq 1409 // CHECK: fcmp ole <16 x float> %{{.*}}, %{{.*}} 1410 return _mm512_cmp_ps_mask(a, b, _CMP_LE_OQ); 1411 } 1412 1413 __mmask16 test_mm512_cmp_ps_mask_unord_s(__m512 a, __m512 b) { 1414 // CHECK-LABEL: test_mm512_cmp_ps_mask_unord_s 1415 // CHECK: fcmp uno <16 x float> %{{.*}}, %{{.*}} 1416 return _mm512_cmp_ps_mask(a, b, _CMP_UNORD_S); 1417 } 1418 1419 __mmask16 test_mm512_cmp_ps_mask_neq_us(__m512 a, __m512 b) { 1420 // CHECK-LABEL: test_mm512_cmp_ps_mask_neq_us 1421 // CHECK: fcmp une <16 x float> %{{.*}}, %{{.*}} 1422 return _mm512_cmp_ps_mask(a, b, _CMP_NEQ_US); 1423 } 1424 1425 __mmask16 test_mm512_cmp_ps_mask_nlt_uq(__m512 a, __m512 b) { 1426 // CHECK-LABEL: test_mm512_cmp_ps_mask_nlt_uq 1427 // CHECK: fcmp uge <16 x float> %{{.*}}, %{{.*}} 1428 return _mm512_cmp_ps_mask(a, b, _CMP_NLT_UQ); 1429 } 1430 1431 __mmask16 test_mm512_cmp_ps_mask_nle_uq(__m512 a, __m512 b) { 1432 // CHECK-LABEL: test_mm512_cmp_ps_mask_nle_uq 1433 // CHECK: fcmp ugt <16 x float> %{{.*}}, %{{.*}} 1434 return _mm512_cmp_ps_mask(a, b, _CMP_NLE_UQ); 1435 } 1436 1437 __mmask16 test_mm512_cmp_ps_mask_ord_s(__m512 a, __m512 b) { 1438 // CHECK-LABEL: test_mm512_cmp_ps_mask_ord_s 1439 // CHECK: fcmp ord <16 x float> %{{.*}}, %{{.*}} 1440 return _mm512_cmp_ps_mask(a, b, _CMP_ORD_S); 1441 } 1442 1443 __mmask16 test_mm512_cmp_ps_mask_eq_us(__m512 a, __m512 b) { 1444 // CHECK-LABEL: test_mm512_cmp_ps_mask_eq_us 1445 // CHECK: fcmp ueq <16 x float> %{{.*}}, %{{.*}} 1446 return _mm512_cmp_ps_mask(a, b, _CMP_EQ_US); 1447 } 1448 1449 __mmask16 test_mm512_cmp_ps_mask_nge_uq(__m512 a, __m512 b) { 1450 // CHECK-LABEL: test_mm512_cmp_ps_mask_nge_uq 1451 // CHECK: fcmp ult <16 x float> %{{.*}}, %{{.*}} 1452 return _mm512_cmp_ps_mask(a, b, _CMP_NGE_UQ); 1453 } 1454 1455 __mmask16 test_mm512_cmp_ps_mask_ngt_uq(__m512 a, __m512 b) { 1456 // CHECK-LABEL: test_mm512_cmp_ps_mask_ngt_uq 1457 // CHECK: fcmp ule <16 x float> %{{.*}}, %{{.*}} 1458 return _mm512_cmp_ps_mask(a, b, _CMP_NGT_UQ); 1459 } 1460 1461 __mmask16 test_mm512_cmp_ps_mask_false_os(__m512 a, __m512 b) { 1462 // CHECK-LABEL: test_mm512_cmp_ps_mask_false_os 1463 // CHECK: fcmp false <16 x float> %{{.*}}, %{{.*}} 1464 return _mm512_cmp_ps_mask(a, b, _CMP_FALSE_OS); 1465 } 1466 1467 __mmask16 test_mm512_cmp_ps_mask_neq_os(__m512 a, __m512 b) { 1468 // CHECK-LABEL: test_mm512_cmp_ps_mask_neq_os 1469 // CHECK: fcmp one <16 x float> %{{.*}}, %{{.*}} 1470 return _mm512_cmp_ps_mask(a, b, _CMP_NEQ_OS); 1471 } 1472 1473 __mmask16 test_mm512_cmp_ps_mask_ge_oq(__m512 a, __m512 b) { 1474 // CHECK-LABEL: test_mm512_cmp_ps_mask_ge_oq 1475 // CHECK: fcmp oge <16 x float> %{{.*}}, %{{.*}} 1476 return _mm512_cmp_ps_mask(a, b, _CMP_GE_OQ); 1477 } 1478 1479 __mmask16 test_mm512_cmp_ps_mask_gt_oq(__m512 a, __m512 b) { 1480 // CHECK-LABEL: test_mm512_cmp_ps_mask_gt_oq 1481 // CHECK: fcmp ogt <16 x float> %{{.*}}, %{{.*}} 1482 return _mm512_cmp_ps_mask(a, b, _CMP_GT_OQ); 1483 } 1484 1485 __mmask16 test_mm512_cmp_ps_mask_true_us(__m512 a, __m512 b) { 1486 // CHECK-LABEL: test_mm512_cmp_ps_mask_true_us 1487 // CHECK: fcmp true <16 x float> %{{.*}}, %{{.*}} 1488 return _mm512_cmp_ps_mask(a, b, _CMP_TRUE_US); 1489 } 1490 1491 __mmask16 test_mm512_mask_cmp_ps_mask_eq_oq(__mmask16 m, __m512 a, __m512 b) { 1492 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_eq_oq 1493 // CHECK: [[CMP:%.*]] = fcmp oeq <16 x float> %{{.*}}, %{{.*}} 1494 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1495 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_EQ_OQ); 1496 } 1497 1498 __mmask16 test_mm512_mask_cmp_ps_mask_lt_os(__mmask16 m, __m512 a, __m512 b) { 1499 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_lt_os 1500 // CHECK: [[CMP:%.*]] = fcmp olt <16 x float> %{{.*}}, %{{.*}} 1501 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1502 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_LT_OS); 1503 } 1504 1505 __mmask16 test_mm512_mask_cmp_ps_mask_le_os(__mmask16 m, __m512 a, __m512 b) { 1506 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_le_os 1507 // CHECK: [[CMP:%.*]] = fcmp ole <16 x float> %{{.*}}, %{{.*}} 1508 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1509 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_LE_OS); 1510 } 1511 1512 __mmask16 test_mm512_mask_cmp_ps_mask_unord_q(__mmask16 m, __m512 a, __m512 b) { 1513 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_unord_q 1514 // CHECK: [[CMP:%.*]] = fcmp uno <16 x float> %{{.*}}, %{{.*}} 1515 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1516 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_UNORD_Q); 1517 } 1518 1519 __mmask16 test_mm512_mask_cmp_ps_mask_neq_uq(__mmask16 m, __m512 a, __m512 b) { 1520 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_neq_uq 1521 // CHECK: [[CMP:%.*]] = fcmp une <16 x float> %{{.*}}, %{{.*}} 1522 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1523 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_UQ); 1524 } 1525 1526 __mmask16 test_mm512_mask_cmp_ps_mask_nlt_us(__mmask16 m, __m512 a, __m512 b) { 1527 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_nlt_us 1528 // CHECK: [[CMP:%.*]] = fcmp uge <16 x float> %{{.*}}, %{{.*}} 1529 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1530 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NLT_US); 1531 } 1532 1533 __mmask16 test_mm512_mask_cmp_ps_mask_nle_us(__mmask16 m, __m512 a, __m512 b) { 1534 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_nle_us 1535 // CHECK: [[CMP:%.*]] = fcmp ugt <16 x float> %{{.*}}, %{{.*}} 1536 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1537 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NLE_US); 1538 } 1539 1540 __mmask16 test_mm512_mask_cmp_ps_mask_ord_q(__mmask16 m, __m512 a, __m512 b) { 1541 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_ord_q 1542 // CHECK: [[CMP:%.*]] = fcmp ord <16 x float> %{{.*}}, %{{.*}} 1543 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1544 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_ORD_Q); 1545 } 1546 1547 __mmask16 test_mm512_mask_cmp_ps_mask_eq_uq(__mmask16 m, __m512 a, __m512 b) { 1548 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_eq_uq 1549 // CHECK: [[CMP:%.*]] = fcmp ueq <16 x float> %{{.*}}, %{{.*}} 1550 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1551 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_EQ_UQ); 1552 } 1553 1554 __mmask16 test_mm512_mask_cmp_ps_mask_nge_us(__mmask16 m, __m512 a, __m512 b) { 1555 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_nge_us 1556 // CHECK: [[CMP:%.*]] = fcmp ult <16 x float> %{{.*}}, %{{.*}} 1557 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1558 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NGE_US); 1559 } 1560 1561 __mmask16 test_mm512_mask_cmp_ps_mask_ngt_us(__mmask16 m, __m512 a, __m512 b) { 1562 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_ngt_us 1563 // CHECK: [[CMP:%.*]] = fcmp ule <16 x float> %{{.*}}, %{{.*}} 1564 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1565 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NGT_US); 1566 } 1567 1568 __mmask16 test_mm512_mask_cmp_ps_mask_false_oq(__mmask16 m, __m512 a, __m512 b) { 1569 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_false_oq 1570 // CHECK: [[CMP:%.*]] = fcmp false <16 x float> %{{.*}}, %{{.*}} 1571 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1572 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_FALSE_OQ); 1573 } 1574 1575 __mmask16 test_mm512_mask_cmp_ps_mask_neq_oq(__mmask16 m, __m512 a, __m512 b) { 1576 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_neq_oq 1577 // CHECK: [[CMP:%.*]] = fcmp one <16 x float> %{{.*}}, %{{.*}} 1578 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1579 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_OQ); 1580 } 1581 1582 __mmask16 test_mm512_mask_cmp_ps_mask_ge_os(__mmask16 m, __m512 a, __m512 b) { 1583 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_ge_os 1584 // CHECK: [[CMP:%.*]] = fcmp oge <16 x float> %{{.*}}, %{{.*}} 1585 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1586 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_GE_OS); 1587 } 1588 1589 __mmask16 test_mm512_mask_cmp_ps_mask_gt_os(__mmask16 m, __m512 a, __m512 b) { 1590 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_gt_os 1591 // CHECK: [[CMP:%.*]] = fcmp ogt <16 x float> %{{.*}}, %{{.*}} 1592 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1593 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_GT_OS); 1594 } 1595 1596 __mmask16 test_mm512_mask_cmp_ps_mask_true_uq(__mmask16 m, __m512 a, __m512 b) { 1597 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_true_uq 1598 // CHECK: [[CMP:%.*]] = fcmp true <16 x float> %{{.*}}, %{{.*}} 1599 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1600 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_TRUE_UQ); 1601 } 1602 1603 __mmask16 test_mm512_mask_cmp_ps_mask_eq_os(__mmask16 m, __m512 a, __m512 b) { 1604 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_eq_os 1605 // CHECK: [[CMP:%.*]] = fcmp oeq <16 x float> %{{.*}}, %{{.*}} 1606 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1607 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_EQ_OS); 1608 } 1609 1610 __mmask16 test_mm512_mask_cmp_ps_mask_lt_oq(__mmask16 m, __m512 a, __m512 b) { 1611 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_lt_oq 1612 // CHECK: [[CMP:%.*]] = fcmp olt <16 x float> %{{.*}}, %{{.*}} 1613 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1614 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_LT_OQ); 1615 } 1616 1617 __mmask16 test_mm512_mask_cmp_ps_mask_le_oq(__mmask16 m, __m512 a, __m512 b) { 1618 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_le_oq 1619 // CHECK: [[CMP:%.*]] = fcmp ole <16 x float> %{{.*}}, %{{.*}} 1620 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1621 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_LE_OQ); 1622 } 1623 1624 __mmask16 test_mm512_mask_cmp_ps_mask_unord_s(__mmask16 m, __m512 a, __m512 b) { 1625 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_unord_s 1626 // CHECK: [[CMP:%.*]] = fcmp uno <16 x float> %{{.*}}, %{{.*}} 1627 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1628 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_UNORD_S); 1629 } 1630 1631 __mmask16 test_mm512_mask_cmp_ps_mask_neq_us(__mmask16 m, __m512 a, __m512 b) { 1632 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_neq_us 1633 // CHECK: [[CMP:%.*]] = fcmp une <16 x float> %{{.*}}, %{{.*}} 1634 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1635 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_US); 1636 } 1637 1638 __mmask16 test_mm512_mask_cmp_ps_mask_nlt_uq(__mmask16 m, __m512 a, __m512 b) { 1639 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_nlt_uq 1640 // CHECK: [[CMP:%.*]] = fcmp uge <16 x float> %{{.*}}, %{{.*}} 1641 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1642 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NLT_UQ); 1643 } 1644 1645 __mmask16 test_mm512_mask_cmp_ps_mask_nle_uq(__mmask16 m, __m512 a, __m512 b) { 1646 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_nle_uq 1647 // CHECK: [[CMP:%.*]] = fcmp ugt <16 x float> %{{.*}}, %{{.*}} 1648 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1649 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NLE_UQ); 1650 } 1651 1652 __mmask16 test_mm512_mask_cmp_ps_mask_ord_s(__mmask16 m, __m512 a, __m512 b) { 1653 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_ord_s 1654 // CHECK: [[CMP:%.*]] = fcmp ord <16 x float> %{{.*}}, %{{.*}} 1655 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1656 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_ORD_S); 1657 } 1658 1659 __mmask16 test_mm512_mask_cmp_ps_mask_eq_us(__mmask16 m, __m512 a, __m512 b) { 1660 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_eq_us 1661 // CHECK: [[CMP:%.*]] = fcmp ueq <16 x float> %{{.*}}, %{{.*}} 1662 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1663 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_EQ_US); 1664 } 1665 1666 __mmask16 test_mm512_mask_cmp_ps_mask_nge_uq(__mmask16 m, __m512 a, __m512 b) { 1667 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_nge_uq 1668 // CHECK: [[CMP:%.*]] = fcmp ult <16 x float> %{{.*}}, %{{.*}} 1669 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1670 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NGE_UQ); 1671 } 1672 1673 __mmask16 test_mm512_mask_cmp_ps_mask_ngt_uq(__mmask16 m, __m512 a, __m512 b) { 1674 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_ngt_uq 1675 // CHECK: [[CMP:%.*]] = fcmp ule <16 x float> %{{.*}}, %{{.*}} 1676 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1677 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NGT_UQ); 1678 } 1679 1680 __mmask16 test_mm512_mask_cmp_ps_mask_false_os(__mmask16 m, __m512 a, __m512 b) { 1681 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_false_os 1682 // CHECK: [[CMP:%.*]] = fcmp false <16 x float> %{{.*}}, %{{.*}} 1683 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1684 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_FALSE_OS); 1685 } 1686 1687 __mmask16 test_mm512_mask_cmp_ps_mask_neq_os(__mmask16 m, __m512 a, __m512 b) { 1688 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_neq_os 1689 // CHECK: [[CMP:%.*]] = fcmp one <16 x float> %{{.*}}, %{{.*}} 1690 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1691 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_OS); 1692 } 1693 1694 __mmask16 test_mm512_mask_cmp_ps_mask_ge_oq(__mmask16 m, __m512 a, __m512 b) { 1695 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_ge_oq 1696 // CHECK: [[CMP:%.*]] = fcmp oge <16 x float> %{{.*}}, %{{.*}} 1697 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1698 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_GE_OQ); 1699 } 1700 1701 __mmask16 test_mm512_mask_cmp_ps_mask_gt_oq(__mmask16 m, __m512 a, __m512 b) { 1702 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_gt_oq 1703 // CHECK: [[CMP:%.*]] = fcmp ogt <16 x float> %{{.*}}, %{{.*}} 1704 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1705 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_GT_OQ); 1706 } 1707 1708 __mmask16 test_mm512_mask_cmp_ps_mask_true_us(__mmask16 m, __m512 a, __m512 b) { 1709 // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_true_us 1710 // CHECK: [[CMP:%.*]] = fcmp true <16 x float> %{{.*}}, %{{.*}} 1711 // CHECK: and <16 x i1> [[CMP]], {{.*}} 1712 return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_TRUE_US); 1713 } 1714 1715 __mmask8 test_mm512_cmp_round_pd_mask(__m512d a, __m512d b) { 1716 // CHECK-LABEL: test_mm512_cmp_round_pd_mask 1717 // CHECK: [[CMP:%.*]] = fcmp oeq <8 x double> %{{.*}}, %{{.*}} 1718 return _mm512_cmp_round_pd_mask(a, b, _CMP_EQ_OQ, _MM_FROUND_NO_EXC); 1719 } 1720 1721 __mmask8 test_mm512_mask_cmp_round_pd_mask(__mmask8 m, __m512d a, __m512d b) { 1722 // CHECK-LABEL: test_mm512_mask_cmp_round_pd_mask 1723 // CHECK: [[CMP:%.*]] = fcmp oeq <8 x double> %{{.*}}, %{{.*}} 1724 // CHECK: and <8 x i1> [[CMP]], {{.*}} 1725 return _mm512_mask_cmp_round_pd_mask(m, a, b, _CMP_EQ_OQ, _MM_FROUND_NO_EXC); 1726 } 1727 1728 __mmask8 test_mm512_cmp_pd_mask_eq_oq(__m512d a, __m512d b) { 1729 // CHECK-LABEL: test_mm512_cmp_pd_mask_eq_oq 1730 // CHECK: fcmp oeq <8 x double> %{{.*}}, %{{.*}} 1731 return _mm512_cmp_pd_mask(a, b, _CMP_EQ_OQ); 1732 } 1733 1734 __mmask8 test_mm512_cmp_pd_mask_lt_os(__m512d a, __m512d b) { 1735 // CHECK-LABEL: test_mm512_cmp_pd_mask_lt_os 1736 // CHECK: fcmp olt <8 x double> %{{.*}}, %{{.*}} 1737 return _mm512_cmp_pd_mask(a, b, _CMP_LT_OS); 1738 } 1739 1740 __mmask8 test_mm512_cmp_pd_mask_le_os(__m512d a, __m512d b) { 1741 // CHECK-LABEL: test_mm512_cmp_pd_mask_le_os 1742 // CHECK: fcmp ole <8 x double> %{{.*}}, %{{.*}} 1743 return _mm512_cmp_pd_mask(a, b, _CMP_LE_OS); 1744 } 1745 1746 __mmask8 test_mm512_cmp_pd_mask_unord_q(__m512d a, __m512d b) { 1747 // CHECK-LABEL: test_mm512_cmp_pd_mask_unord_q 1748 // CHECK: fcmp uno <8 x double> %{{.*}}, %{{.*}} 1749 return _mm512_cmp_pd_mask(a, b, _CMP_UNORD_Q); 1750 } 1751 1752 __mmask8 test_mm512_cmp_pd_mask_neq_uq(__m512d a, __m512d b) { 1753 // CHECK-LABEL: test_mm512_cmp_pd_mask_neq_uq 1754 // CHECK: fcmp une <8 x double> %{{.*}}, %{{.*}} 1755 return _mm512_cmp_pd_mask(a, b, _CMP_NEQ_UQ); 1756 } 1757 1758 __mmask8 test_mm512_cmp_pd_mask_nlt_us(__m512d a, __m512d b) { 1759 // CHECK-LABEL: test_mm512_cmp_pd_mask_nlt_us 1760 // CHECK: fcmp uge <8 x double> %{{.*}}, %{{.*}} 1761 return _mm512_cmp_pd_mask(a, b, _CMP_NLT_US); 1762 } 1763 1764 __mmask8 test_mm512_cmp_pd_mask_nle_us(__m512d a, __m512d b) { 1765 // CHECK-LABEL: test_mm512_cmp_pd_mask_nle_us 1766 // CHECK: fcmp ugt <8 x double> %{{.*}}, %{{.*}} 1767 return _mm512_cmp_pd_mask(a, b, _CMP_NLE_US); 1768 } 1769 1770 __mmask8 test_mm512_cmp_pd_mask_ord_q(__m512d a, __m512d b) { 1771 // CHECK-LABEL: test_mm512_cmp_pd_mask_ord_q 1772 // CHECK: fcmp ord <8 x double> %{{.*}}, %{{.*}} 1773 return _mm512_cmp_pd_mask(a, b, _CMP_ORD_Q); 1774 } 1775 1776 __mmask8 test_mm512_cmp_pd_mask_eq_uq(__m512d a, __m512d b) { 1777 // CHECK-LABEL: test_mm512_cmp_pd_mask_eq_uq 1778 // CHECK: fcmp ueq <8 x double> %{{.*}}, %{{.*}} 1779 return _mm512_cmp_pd_mask(a, b, _CMP_EQ_UQ); 1780 } 1781 1782 __mmask8 test_mm512_cmp_pd_mask_nge_us(__m512d a, __m512d b) { 1783 // CHECK-LABEL: test_mm512_cmp_pd_mask_nge_us 1784 // CHECK: fcmp ult <8 x double> %{{.*}}, %{{.*}} 1785 return _mm512_cmp_pd_mask(a, b, _CMP_NGE_US); 1786 } 1787 1788 __mmask8 test_mm512_cmp_pd_mask_ngt_us(__m512d a, __m512d b) { 1789 // CHECK-LABEL: test_mm512_cmp_pd_mask_ngt_us 1790 // CHECK: fcmp ule <8 x double> %{{.*}}, %{{.*}} 1791 return _mm512_cmp_pd_mask(a, b, _CMP_NGT_US); 1792 } 1793 1794 __mmask8 test_mm512_cmp_pd_mask_false_oq(__m512d a, __m512d b) { 1795 // CHECK-LABEL: test_mm512_cmp_pd_mask_false_oq 1796 // CHECK: fcmp false <8 x double> %{{.*}}, %{{.*}} 1797 return _mm512_cmp_pd_mask(a, b, _CMP_FALSE_OQ); 1798 } 1799 1800 __mmask8 test_mm512_cmp_pd_mask_neq_oq(__m512d a, __m512d b) { 1801 // CHECK-LABEL: test_mm512_cmp_pd_mask_neq_oq 1802 // CHECK: fcmp one <8 x double> %{{.*}}, %{{.*}} 1803 return _mm512_cmp_pd_mask(a, b, _CMP_NEQ_OQ); 1804 } 1805 1806 __mmask8 test_mm512_cmp_pd_mask_ge_os(__m512d a, __m512d b) { 1807 // CHECK-LABEL: test_mm512_cmp_pd_mask_ge_os 1808 // CHECK: fcmp oge <8 x double> %{{.*}}, %{{.*}} 1809 return _mm512_cmp_pd_mask(a, b, _CMP_GE_OS); 1810 } 1811 1812 __mmask8 test_mm512_cmp_pd_mask_gt_os(__m512d a, __m512d b) { 1813 // CHECK-LABEL: test_mm512_cmp_pd_mask_gt_os 1814 // CHECK: fcmp ogt <8 x double> %{{.*}}, %{{.*}} 1815 return _mm512_cmp_pd_mask(a, b, _CMP_GT_OS); 1816 } 1817 1818 __mmask8 test_mm512_cmp_pd_mask_true_uq(__m512d a, __m512d b) { 1819 // CHECK-LABEL: test_mm512_cmp_pd_mask_true_uq 1820 // CHECK: fcmp true <8 x double> %{{.*}}, %{{.*}} 1821 return _mm512_cmp_pd_mask(a, b, _CMP_TRUE_UQ); 1822 } 1823 1824 __mmask8 test_mm512_cmp_pd_mask_eq_os(__m512d a, __m512d b) { 1825 // CHECK-LABEL: test_mm512_cmp_pd_mask_eq_os 1826 // CHECK: fcmp oeq <8 x double> %{{.*}}, %{{.*}} 1827 return _mm512_cmp_pd_mask(a, b, _CMP_EQ_OS); 1828 } 1829 1830 __mmask8 test_mm512_cmp_pd_mask_lt_oq(__m512d a, __m512d b) { 1831 // CHECK-LABEL: test_mm512_cmp_pd_mask_lt_oq 1832 // CHECK: fcmp olt <8 x double> %{{.*}}, %{{.*}} 1833 return _mm512_cmp_pd_mask(a, b, _CMP_LT_OQ); 1834 } 1835 1836 __mmask8 test_mm512_cmp_pd_mask_le_oq(__m512d a, __m512d b) { 1837 // CHECK-LABEL: test_mm512_cmp_pd_mask_le_oq 1838 // CHECK: fcmp ole <8 x double> %{{.*}}, %{{.*}} 1839 return _mm512_cmp_pd_mask(a, b, _CMP_LE_OQ); 1840 } 1841 1842 __mmask8 test_mm512_cmp_pd_mask_unord_s(__m512d a, __m512d b) { 1843 // CHECK-LABEL: test_mm512_cmp_pd_mask_unord_s 1844 // CHECK: fcmp uno <8 x double> %{{.*}}, %{{.*}} 1845 return _mm512_cmp_pd_mask(a, b, _CMP_UNORD_S); 1846 } 1847 1848 __mmask8 test_mm512_cmp_pd_mask_neq_us(__m512d a, __m512d b) { 1849 // CHECK-LABEL: test_mm512_cmp_pd_mask_neq_us 1850 // CHECK: fcmp une <8 x double> %{{.*}}, %{{.*}} 1851 return _mm512_cmp_pd_mask(a, b, _CMP_NEQ_US); 1852 } 1853 1854 __mmask8 test_mm512_cmp_pd_mask_nlt_uq(__m512d a, __m512d b) { 1855 // CHECK-LABEL: test_mm512_cmp_pd_mask_nlt_uq 1856 // CHECK: fcmp uge <8 x double> %{{.*}}, %{{.*}} 1857 return _mm512_cmp_pd_mask(a, b, _CMP_NLT_UQ); 1858 } 1859 1860 __mmask8 test_mm512_cmp_pd_mask_nle_uq(__m512d a, __m512d b) { 1861 // CHECK-LABEL: test_mm512_cmp_pd_mask_nle_uq 1862 // CHECK: fcmp ugt <8 x double> %{{.*}}, %{{.*}} 1863 return _mm512_cmp_pd_mask(a, b, _CMP_NLE_UQ); 1864 } 1865 1866 __mmask8 test_mm512_cmp_pd_mask_ord_s(__m512d a, __m512d b) { 1867 // CHECK-LABEL: test_mm512_cmp_pd_mask_ord_s 1868 // CHECK: fcmp ord <8 x double> %{{.*}}, %{{.*}} 1869 return _mm512_cmp_pd_mask(a, b, _CMP_ORD_S); 1870 } 1871 1872 __mmask8 test_mm512_cmp_pd_mask_eq_us(__m512d a, __m512d b) { 1873 // CHECK-LABEL: test_mm512_cmp_pd_mask_eq_us 1874 // CHECK: fcmp ueq <8 x double> %{{.*}}, %{{.*}} 1875 return _mm512_cmp_pd_mask(a, b, _CMP_EQ_US); 1876 } 1877 1878 __mmask8 test_mm512_cmp_pd_mask_nge_uq(__m512d a, __m512d b) { 1879 // CHECK-LABEL: test_mm512_cmp_pd_mask_nge_uq 1880 // CHECK: fcmp ult <8 x double> %{{.*}}, %{{.*}} 1881 return _mm512_cmp_pd_mask(a, b, _CMP_NGE_UQ); 1882 } 1883 1884 __mmask8 test_mm512_cmp_pd_mask_ngt_uq(__m512d a, __m512d b) { 1885 // CHECK-LABEL: test_mm512_cmp_pd_mask_ngt_uq 1886 // CHECK: fcmp ule <8 x double> %{{.*}}, %{{.*}} 1887 return _mm512_cmp_pd_mask(a, b, _CMP_NGT_UQ); 1888 } 1889 1890 __mmask8 test_mm512_cmp_pd_mask_false_os(__m512d a, __m512d b) { 1891 // CHECK-LABEL: test_mm512_cmp_pd_mask_false_os 1892 // CHECK: fcmp false <8 x double> %{{.*}}, %{{.*}} 1893 return _mm512_cmp_pd_mask(a, b, _CMP_FALSE_OS); 1894 } 1895 1896 __mmask8 test_mm512_cmp_pd_mask_neq_os(__m512d a, __m512d b) { 1897 // CHECK-LABEL: test_mm512_cmp_pd_mask_neq_os 1898 // CHECK: fcmp one <8 x double> %{{.*}}, %{{.*}} 1899 return _mm512_cmp_pd_mask(a, b, _CMP_NEQ_OS); 1900 } 1901 1902 __mmask8 test_mm512_cmp_pd_mask_ge_oq(__m512d a, __m512d b) { 1903 // CHECK-LABEL: test_mm512_cmp_pd_mask_ge_oq 1904 // CHECK: fcmp oge <8 x double> %{{.*}}, %{{.*}} 1905 return _mm512_cmp_pd_mask(a, b, _CMP_GE_OQ); 1906 } 1907 1908 __mmask8 test_mm512_cmp_pd_mask_gt_oq(__m512d a, __m512d b) { 1909 // CHECK-LABEL: test_mm512_cmp_pd_mask_gt_oq 1910 // CHECK: fcmp ogt <8 x double> %{{.*}}, %{{.*}} 1911 return _mm512_cmp_pd_mask(a, b, _CMP_GT_OQ); 1912 } 1913 1914 __mmask8 test_mm512_cmp_pd_mask_true_us(__m512d a, __m512d b) { 1915 // CHECK-LABEL: test_mm512_cmp_pd_mask_true_us 1916 // CHECK: fcmp true <8 x double> %{{.*}}, %{{.*}} 1917 return _mm512_cmp_pd_mask(a, b, _CMP_TRUE_US); 1918 } 1919 1920 __mmask8 test_mm512_mask_cmp_pd_mask_eq_oq(__mmask8 m, __m512d a, __m512d b) { 1921 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_eq_oq 1922 // CHECK: [[CMP:%.*]] = fcmp oeq <8 x double> %{{.*}}, %{{.*}} 1923 // CHECK: and <8 x i1> [[CMP]], {{.*}} 1924 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_EQ_OQ); 1925 } 1926 1927 __mmask8 test_mm512_mask_cmp_pd_mask_lt_os(__mmask8 m, __m512d a, __m512d b) { 1928 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_lt_os 1929 // CHECK: [[CMP:%.*]] = fcmp olt <8 x double> %{{.*}}, %{{.*}} 1930 // CHECK: and <8 x i1> [[CMP]], {{.*}} 1931 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_LT_OS); 1932 } 1933 1934 __mmask8 test_mm512_mask_cmp_pd_mask_le_os(__mmask8 m, __m512d a, __m512d b) { 1935 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_le_os 1936 // CHECK: [[CMP:%.*]] = fcmp ole <8 x double> %{{.*}}, %{{.*}} 1937 // CHECK: and <8 x i1> [[CMP]], {{.*}} 1938 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_LE_OS); 1939 } 1940 1941 __mmask8 test_mm512_mask_cmp_pd_mask_unord_q(__mmask8 m, __m512d a, __m512d b) { 1942 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_unord_q 1943 // CHECK: [[CMP:%.*]] = fcmp uno <8 x double> %{{.*}}, %{{.*}} 1944 // CHECK: and <8 x i1> [[CMP]], {{.*}} 1945 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_UNORD_Q); 1946 } 1947 1948 __mmask8 test_mm512_mask_cmp_pd_mask_neq_uq(__mmask8 m, __m512d a, __m512d b) { 1949 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_neq_uq 1950 // CHECK: [[CMP:%.*]] = fcmp une <8 x double> %{{.*}}, %{{.*}} 1951 // CHECK: and <8 x i1> [[CMP]], {{.*}} 1952 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_UQ); 1953 } 1954 1955 __mmask8 test_mm512_mask_cmp_pd_mask_nlt_us(__mmask8 m, __m512d a, __m512d b) { 1956 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_nlt_us 1957 // CHECK: [[CMP:%.*]] = fcmp uge <8 x double> %{{.*}}, %{{.*}} 1958 // CHECK: and <8 x i1> [[CMP]], {{.*}} 1959 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NLT_US); 1960 } 1961 1962 __mmask8 test_mm512_mask_cmp_pd_mask_nle_us(__mmask8 m, __m512d a, __m512d b) { 1963 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_nle_us 1964 // CHECK: [[CMP:%.*]] = fcmp ugt <8 x double> %{{.*}}, %{{.*}} 1965 // CHECK: and <8 x i1> [[CMP]], {{.*}} 1966 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NLE_US); 1967 } 1968 1969 __mmask8 test_mm512_mask_cmp_pd_mask_ord_q(__mmask8 m, __m512d a, __m512d b) { 1970 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_ord_q 1971 // CHECK: [[CMP:%.*]] = fcmp ord <8 x double> %{{.*}}, %{{.*}} 1972 // CHECK: and <8 x i1> [[CMP]], {{.*}} 1973 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_ORD_Q); 1974 } 1975 1976 __mmask8 test_mm512_mask_cmp_pd_mask_eq_uq(__mmask8 m, __m512d a, __m512d b) { 1977 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_eq_uq 1978 // CHECK: [[CMP:%.*]] = fcmp ueq <8 x double> %{{.*}}, %{{.*}} 1979 // CHECK: and <8 x i1> [[CMP]], {{.*}} 1980 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_EQ_UQ); 1981 } 1982 1983 __mmask8 test_mm512_mask_cmp_pd_mask_nge_us(__mmask8 m, __m512d a, __m512d b) { 1984 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_nge_us 1985 // CHECK: [[CMP:%.*]] = fcmp ult <8 x double> %{{.*}}, %{{.*}} 1986 // CHECK: and <8 x i1> [[CMP]], {{.*}} 1987 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NGE_US); 1988 } 1989 1990 __mmask8 test_mm512_mask_cmp_pd_mask_ngt_us(__mmask8 m, __m512d a, __m512d b) { 1991 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_ngt_us 1992 // CHECK: [[CMP:%.*]] = fcmp ule <8 x double> %{{.*}}, %{{.*}} 1993 // CHECK: and <8 x i1> [[CMP]], {{.*}} 1994 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NGT_US); 1995 } 1996 1997 __mmask8 test_mm512_mask_cmp_pd_mask_false_oq(__mmask8 m, __m512d a, __m512d b) { 1998 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_false_oq 1999 // CHECK: [[CMP:%.*]] = fcmp false <8 x double> %{{.*}}, %{{.*}} 2000 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2001 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_FALSE_OQ); 2002 } 2003 2004 __mmask8 test_mm512_mask_cmp_pd_mask_neq_oq(__mmask8 m, __m512d a, __m512d b) { 2005 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_neq_oq 2006 // CHECK: [[CMP:%.*]] = fcmp one <8 x double> %{{.*}}, %{{.*}} 2007 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2008 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_OQ); 2009 } 2010 2011 __mmask8 test_mm512_mask_cmp_pd_mask_ge_os(__mmask8 m, __m512d a, __m512d b) { 2012 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_ge_os 2013 // CHECK: [[CMP:%.*]] = fcmp oge <8 x double> %{{.*}}, %{{.*}} 2014 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2015 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_GE_OS); 2016 } 2017 2018 __mmask8 test_mm512_mask_cmp_pd_mask_gt_os(__mmask8 m, __m512d a, __m512d b) { 2019 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_gt_os 2020 // CHECK: [[CMP:%.*]] = fcmp ogt <8 x double> %{{.*}}, %{{.*}} 2021 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2022 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_GT_OS); 2023 } 2024 2025 __mmask8 test_mm512_mask_cmp_pd_mask_true_uq(__mmask8 m, __m512d a, __m512d b) { 2026 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_true_uq 2027 // CHECK: [[CMP:%.*]] = fcmp true <8 x double> %{{.*}}, %{{.*}} 2028 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2029 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_TRUE_UQ); 2030 } 2031 2032 __mmask8 test_mm512_mask_cmp_pd_mask_eq_os(__mmask8 m, __m512d a, __m512d b) { 2033 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_eq_os 2034 // CHECK: [[CMP:%.*]] = fcmp oeq <8 x double> %{{.*}}, %{{.*}} 2035 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2036 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_EQ_OS); 2037 } 2038 2039 __mmask8 test_mm512_mask_cmp_pd_mask_lt_oq(__mmask8 m, __m512d a, __m512d b) { 2040 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_lt_oq 2041 // CHECK: [[CMP:%.*]] = fcmp olt <8 x double> %{{.*}}, %{{.*}} 2042 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2043 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_LT_OQ); 2044 } 2045 2046 __mmask8 test_mm512_mask_cmp_pd_mask_le_oq(__mmask8 m, __m512d a, __m512d b) { 2047 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_le_oq 2048 // CHECK: [[CMP:%.*]] = fcmp ole <8 x double> %{{.*}}, %{{.*}} 2049 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2050 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_LE_OQ); 2051 } 2052 2053 __mmask8 test_mm512_mask_cmp_pd_mask_unord_s(__mmask8 m, __m512d a, __m512d b) { 2054 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_unord_s 2055 // CHECK: [[CMP:%.*]] = fcmp uno <8 x double> %{{.*}}, %{{.*}} 2056 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2057 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_UNORD_S); 2058 } 2059 2060 __mmask8 test_mm512_mask_cmp_pd_mask_neq_us(__mmask8 m, __m512d a, __m512d b) { 2061 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_neq_us 2062 // CHECK: [[CMP:%.*]] = fcmp une <8 x double> %{{.*}}, %{{.*}} 2063 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2064 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_US); 2065 } 2066 2067 __mmask8 test_mm512_mask_cmp_pd_mask_nlt_uq(__mmask8 m, __m512d a, __m512d b) { 2068 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_nlt_uq 2069 // CHECK: [[CMP:%.*]] = fcmp uge <8 x double> %{{.*}}, %{{.*}} 2070 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2071 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NLT_UQ); 2072 } 2073 2074 __mmask8 test_mm512_mask_cmp_pd_mask_nle_uq(__mmask8 m, __m512d a, __m512d b) { 2075 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_nle_uq 2076 // CHECK: [[CMP:%.*]] = fcmp ugt <8 x double> %{{.*}}, %{{.*}} 2077 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2078 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NLE_UQ); 2079 } 2080 2081 __mmask8 test_mm512_mask_cmp_pd_mask_ord_s(__mmask8 m, __m512d a, __m512d b) { 2082 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_ord_s 2083 // CHECK: [[CMP:%.*]] = fcmp ord <8 x double> %{{.*}}, %{{.*}} 2084 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2085 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_ORD_S); 2086 } 2087 2088 __mmask8 test_mm512_mask_cmp_pd_mask_eq_us(__mmask8 m, __m512d a, __m512d b) { 2089 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_eq_us 2090 // CHECK: [[CMP:%.*]] = fcmp ueq <8 x double> %{{.*}}, %{{.*}} 2091 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2092 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_EQ_US); 2093 } 2094 2095 __mmask8 test_mm512_mask_cmp_pd_mask_nge_uq(__mmask8 m, __m512d a, __m512d b) { 2096 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_nge_uq 2097 // CHECK: [[CMP:%.*]] = fcmp ult <8 x double> %{{.*}}, %{{.*}} 2098 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2099 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NGE_UQ); 2100 } 2101 2102 __mmask8 test_mm512_mask_cmp_pd_mask_ngt_uq(__mmask8 m, __m512d a, __m512d b) { 2103 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_ngt_uq 2104 // CHECK: [[CMP:%.*]] = fcmp ule <8 x double> %{{.*}}, %{{.*}} 2105 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2106 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NGT_UQ); 2107 } 2108 2109 __mmask8 test_mm512_mask_cmp_pd_mask_false_os(__mmask8 m, __m512d a, __m512d b) { 2110 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_false_os 2111 // CHECK: [[CMP:%.*]] = fcmp false <8 x double> %{{.*}}, %{{.*}} 2112 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2113 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_FALSE_OS); 2114 } 2115 2116 __mmask8 test_mm512_mask_cmp_pd_mask_neq_os(__mmask8 m, __m512d a, __m512d b) { 2117 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_neq_os 2118 // CHECK: [[CMP:%.*]] = fcmp one <8 x double> %{{.*}}, %{{.*}} 2119 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2120 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_OS); 2121 } 2122 2123 __mmask8 test_mm512_mask_cmp_pd_mask_ge_oq(__mmask8 m, __m512d a, __m512d b) { 2124 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_ge_oq 2125 // CHECK: [[CMP:%.*]] = fcmp oge <8 x double> %{{.*}}, %{{.*}} 2126 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2127 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_GE_OQ); 2128 } 2129 2130 __mmask8 test_mm512_mask_cmp_pd_mask_gt_oq(__mmask8 m, __m512d a, __m512d b) { 2131 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_gt_oq 2132 // CHECK: [[CMP:%.*]] = fcmp ogt <8 x double> %{{.*}}, %{{.*}} 2133 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2134 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_GT_OQ); 2135 } 2136 2137 __mmask8 test_mm512_mask_cmp_pd_mask_true_us(__mmask8 m, __m512d a, __m512d b) { 2138 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_true_us 2139 // CHECK: [[CMP:%.*]] = fcmp true <8 x double> %{{.*}}, %{{.*}} 2140 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2141 return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_TRUE_US); 2142 } 2143 2144 __mmask8 test_mm512_mask_cmp_pd_mask(__mmask8 m, __m512d a, __m512d b) { 2145 // CHECK-LABEL: test_mm512_mask_cmp_pd_mask 2146 // CHECK: [[CMP:%.*]] = fcmp oeq <8 x double> %{{.*}}, %{{.*}} 2147 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2148 return _mm512_mask_cmp_pd_mask(m, a, b, 0); 2149 } 2150 2151 __mmask8 test_mm512_cmpeq_pd_mask(__m512d a, __m512d b) { 2152 // CHECK-LABEL: test_mm512_cmpeq_pd_mask 2153 // CHECK: fcmp oeq <8 x double> %{{.*}}, %{{.*}} 2154 return _mm512_cmpeq_pd_mask(a, b); 2155 } 2156 2157 __mmask16 test_mm512_cmpeq_ps_mask(__m512 a, __m512 b) { 2158 // CHECK-LABEL: test_mm512_cmpeq_ps_mask 2159 // CHECK: fcmp oeq <16 x float> %{{.*}}, %{{.*}} 2160 return _mm512_cmpeq_ps_mask(a, b); 2161 } 2162 2163 __mmask8 test_mm512_mask_cmpeq_pd_mask(__mmask8 k, __m512d a, __m512d b) { 2164 // CHECK-LABEL: test_mm512_mask_cmpeq_pd_mask 2165 // CHECK: [[CMP:%.*]] = fcmp oeq <8 x double> %{{.*}}, %{{.*}} 2166 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2167 return _mm512_mask_cmpeq_pd_mask(k, a, b); 2168 } 2169 2170 __mmask16 test_mm512_mask_cmpeq_ps_mask(__mmask16 k, __m512 a, __m512 b) { 2171 // CHECK-LABEL: test_mm512_mask_cmpeq_ps_mask 2172 // CHECK: [[CMP:%.*]] = fcmp oeq <16 x float> %{{.*}}, %{{.*}} 2173 // CHECK: and <16 x i1> [[CMP]], {{.*}} 2174 return _mm512_mask_cmpeq_ps_mask(k, a, b); 2175 } 2176 2177 __mmask8 test_mm512_cmple_pd_mask(__m512d a, __m512d b) { 2178 // CHECK-LABEL: test_mm512_cmple_pd_mask 2179 // CHECK: fcmp ole <8 x double> %{{.*}}, %{{.*}} 2180 return _mm512_cmple_pd_mask(a, b); 2181 } 2182 2183 __mmask16 test_mm512_cmple_ps_mask(__m512 a, __m512 b) { 2184 // CHECK-LABEL: test_mm512_cmple_ps_mask 2185 // CHECK: fcmp ole <16 x float> %{{.*}}, %{{.*}} 2186 return _mm512_cmple_ps_mask(a, b); 2187 } 2188 2189 __mmask8 test_mm512_mask_cmple_pd_mask(__mmask8 k, __m512d a, __m512d b) { 2190 // CHECK-LABEL: test_mm512_mask_cmple_pd_mask 2191 // CHECK: [[CMP:%.*]] = fcmp ole <8 x double> %{{.*}}, %{{.*}} 2192 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2193 return _mm512_mask_cmple_pd_mask(k, a, b); 2194 } 2195 2196 __mmask16 test_mm512_mask_cmple_ps_mask(__mmask16 k, __m512 a, __m512 b) { 2197 // CHECK-LABEL: test_mm512_mask_cmple_ps_mask 2198 // CHECK: [[CMP:%.*]] = fcmp ole <16 x float> %{{.*}}, %{{.*}} 2199 // CHECK: and <16 x i1> [[CMP]], {{.*}} 2200 return _mm512_mask_cmple_ps_mask(k, a, b); 2201 } 2202 2203 __mmask8 test_mm512_cmplt_pd_mask(__m512d a, __m512d b) { 2204 // CHECK-LABEL: test_mm512_cmplt_pd_mask 2205 // CHECK: fcmp olt <8 x double> %{{.*}}, %{{.*}} 2206 return _mm512_cmplt_pd_mask(a, b); 2207 } 2208 2209 __mmask16 test_mm512_cmplt_ps_mask(__m512 a, __m512 b) { 2210 // CHECK-LABEL: test_mm512_cmplt_ps_mask 2211 // CHECK: fcmp olt <16 x float> %{{.*}}, %{{.*}} 2212 return _mm512_cmplt_ps_mask(a, b); 2213 } 2214 2215 __mmask8 test_mm512_mask_cmplt_pd_mask(__mmask8 k, __m512d a, __m512d b) { 2216 // CHECK-LABEL: test_mm512_mask_cmplt_pd_mask 2217 // CHECK: [[CMP:%.*]] = fcmp olt <8 x double> %{{.*}}, %{{.*}} 2218 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2219 return _mm512_mask_cmplt_pd_mask(k, a, b); 2220 } 2221 2222 __mmask16 test_mm512_mask_cmplt_ps_mask(__mmask16 k, __m512 a, __m512 b) { 2223 // CHECK-LABEL: test_mm512_mask_cmplt_ps_mask 2224 // CHECK: [[CMP:%.*]] = fcmp olt <16 x float> %{{.*}}, %{{.*}} 2225 // CHECK: and <16 x i1> [[CMP]], {{.*}} 2226 return _mm512_mask_cmplt_ps_mask(k, a, b); 2227 } 2228 2229 __mmask8 test_mm512_cmpneq_pd_mask(__m512d a, __m512d b) { 2230 // CHECK-LABEL: test_mm512_cmpneq_pd_mask 2231 // CHECK: fcmp une <8 x double> %{{.*}}, %{{.*}} 2232 return _mm512_cmpneq_pd_mask(a, b); 2233 } 2234 2235 __mmask16 test_mm512_cmpneq_ps_mask(__m512 a, __m512 b) { 2236 // CHECK-LABEL: test_mm512_cmpneq_ps_mask 2237 // CHECK: fcmp une <16 x float> %{{.*}}, %{{.*}} 2238 return _mm512_cmpneq_ps_mask(a, b); 2239 } 2240 2241 __mmask8 test_mm512_mask_cmpneq_pd_mask(__mmask8 k, __m512d a, __m512d b) { 2242 // CHECK-LABEL: test_mm512_mask_cmpneq_pd_mask 2243 // CHECK: [[CMP:%.*]] = fcmp une <8 x double> %{{.*}}, %{{.*}} 2244 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2245 return _mm512_mask_cmpneq_pd_mask(k, a, b); 2246 } 2247 2248 __mmask16 test_mm512_mask_cmpneq_ps_mask(__mmask16 k, __m512 a, __m512 b) { 2249 // CHECK-LABEL: test_mm512_mask_cmpneq_ps_mask 2250 // CHECK: [[CMP:%.*]] = fcmp une <16 x float> %{{.*}}, %{{.*}} 2251 // CHECK: and <16 x i1> [[CMP]], {{.*}} 2252 return _mm512_mask_cmpneq_ps_mask(k, a, b); 2253 } 2254 2255 __mmask8 test_mm512_cmpnle_pd_mask(__m512d a, __m512d b) { 2256 // CHECK-LABEL: test_mm512_cmpnle_pd_mask 2257 // CHECK: fcmp ugt <8 x double> %{{.*}}, %{{.*}} 2258 return _mm512_cmpnle_pd_mask(a, b); 2259 } 2260 2261 __mmask16 test_mm512_cmpnle_ps_mask(__m512 a, __m512 b) { 2262 // CHECK-LABEL: test_mm512_cmpnle_ps_mask 2263 // CHECK: fcmp ugt <16 x float> %{{.*}}, %{{.*}} 2264 return _mm512_cmpnle_ps_mask(a, b); 2265 } 2266 2267 __mmask8 test_mm512_mask_cmpnle_pd_mask(__mmask8 k, __m512d a, __m512d b) { 2268 // CHECK-LABEL: test_mm512_mask_cmpnle_pd_mask 2269 // CHECK: [[CMP:%.*]] = fcmp ugt <8 x double> %{{.*}}, %{{.*}} 2270 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2271 return _mm512_mask_cmpnle_pd_mask(k, a, b); 2272 } 2273 2274 __mmask16 test_mm512_mask_cmpnle_ps_mask(__mmask16 k, __m512 a, __m512 b) { 2275 // CHECK-LABEL: test_mm512_mask_cmpnle_ps_mask 2276 // CHECK: [[CMP:%.*]] = fcmp ugt <16 x float> %{{.*}}, %{{.*}} 2277 // CHECK: and <16 x i1> [[CMP]], {{.*}} 2278 return _mm512_mask_cmpnle_ps_mask(k, a, b); 2279 } 2280 2281 __mmask8 test_mm512_cmpnlt_pd_mask(__m512d a, __m512d b) { 2282 // CHECK-LABEL: test_mm512_cmpnlt_pd_mask 2283 // CHECK: fcmp uge <8 x double> %{{.*}}, %{{.*}} 2284 return _mm512_cmpnlt_pd_mask(a, b); 2285 } 2286 2287 __mmask16 test_mm512_cmpnlt_ps_mask(__m512 a, __m512 b) { 2288 // CHECK-LABEL: test_mm512_cmpnlt_ps_mask 2289 // CHECK: fcmp uge <16 x float> %{{.*}}, %{{.*}} 2290 return _mm512_cmpnlt_ps_mask(a, b); 2291 } 2292 2293 __mmask8 test_mm512_mask_cmpnlt_pd_mask(__mmask8 k, __m512d a, __m512d b) { 2294 // CHECK-LABEL: test_mm512_mask_cmpnlt_pd_mask 2295 // CHECK: [[CMP:%.*]] = fcmp uge <8 x double> %{{.*}}, %{{.*}} 2296 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2297 return _mm512_mask_cmpnlt_pd_mask(k, a, b); 2298 } 2299 2300 __mmask16 test_mm512_mask_cmpnlt_ps_mask(__mmask16 k, __m512 a, __m512 b) { 2301 // CHECK-LABEL: test_mm512_mask_cmpnlt_ps_mask 2302 // CHECK: [[CMP:%.*]] = fcmp uge <16 x float> %{{.*}}, %{{.*}} 2303 // CHECK: and <16 x i1> [[CMP]], {{.*}} 2304 return _mm512_mask_cmpnlt_ps_mask(k, a, b); 2305 } 2306 2307 __mmask8 test_mm512_cmpord_pd_mask(__m512d a, __m512d b) { 2308 // CHECK-LABEL: test_mm512_cmpord_pd_mask 2309 // CHECK: fcmp ord <8 x double> %{{.*}}, %{{.*}} 2310 return _mm512_cmpord_pd_mask(a, b); 2311 } 2312 2313 __mmask16 test_mm512_cmpord_ps_mask(__m512 a, __m512 b) { 2314 // CHECK-LABEL: test_mm512_cmpord_ps_mask 2315 // CHECK: fcmp ord <16 x float> %{{.*}}, %{{.*}} 2316 return _mm512_cmpord_ps_mask(a, b); 2317 } 2318 2319 __mmask8 test_mm512_mask_cmpord_pd_mask(__mmask8 k, __m512d a, __m512d b) { 2320 // CHECK-LABEL: test_mm512_mask_cmpord_pd_mask 2321 // CHECK: [[CMP:%.*]] = fcmp ord <8 x double> %{{.*}}, %{{.*}} 2322 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2323 return _mm512_mask_cmpord_pd_mask(k, a, b); 2324 } 2325 2326 __mmask16 test_mm512_mask_cmpord_ps_mask(__mmask16 k, __m512 a, __m512 b) { 2327 // CHECK-LABEL: test_mm512_mask_cmpord_ps_mask 2328 // CHECK: [[CMP:%.*]] = fcmp ord <16 x float> %{{.*}}, %{{.*}} 2329 // CHECK: and <16 x i1> [[CMP]], {{.*}} 2330 return _mm512_mask_cmpord_ps_mask(k, a, b); 2331 } 2332 2333 __mmask8 test_mm512_cmpunord_pd_mask(__m512d a, __m512d b) { 2334 // CHECK-LABEL: test_mm512_cmpunord_pd_mask 2335 // CHECK: fcmp uno <8 x double> %{{.*}}, %{{.*}} 2336 return _mm512_cmpunord_pd_mask(a, b); 2337 } 2338 2339 __mmask16 test_mm512_cmpunord_ps_mask(__m512 a, __m512 b) { 2340 // CHECK-LABEL: test_mm512_cmpunord_ps_mask 2341 // CHECK: fcmp uno <16 x float> %{{.*}}, %{{.*}} 2342 return _mm512_cmpunord_ps_mask(a, b); 2343 } 2344 2345 __mmask8 test_mm512_mask_cmpunord_pd_mask(__mmask8 k, __m512d a, __m512d b) { 2346 // CHECK-LABEL: test_mm512_mask_cmpunord_pd_mask 2347 // CHECK: [[CMP:%.*]] = fcmp uno <8 x double> %{{.*}}, %{{.*}} 2348 // CHECK: and <8 x i1> [[CMP]], {{.*}} 2349 return _mm512_mask_cmpunord_pd_mask(k, a, b); 2350 } 2351 2352 __mmask16 test_mm512_mask_cmpunord_ps_mask(__mmask16 k, __m512 a, __m512 b) { 2353 // CHECK-LABEL: test_mm512_mask_cmpunord_ps_mask 2354 // CHECK: [[CMP:%.*]] = fcmp uno <16 x float> %{{.*}}, %{{.*}} 2355 // CHECK: and <16 x i1> [[CMP]], {{.*}} 2356 return _mm512_mask_cmpunord_ps_mask(k, a, b); 2357 } 2358 2359 __m256d test_mm512_extractf64x4_pd(__m512d a) 2360 { 2361 // CHECK-LABEL: test_mm512_extractf64x4_pd 2362 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7> 2363 return _mm512_extractf64x4_pd(a, 1); 2364 } 2365 2366 __m256d test_mm512_mask_extractf64x4_pd(__m256d __W,__mmask8 __U,__m512d __A){ 2367 // CHECK-LABEL: test_mm512_mask_extractf64x4_pd 2368 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7> 2369 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}} 2370 return _mm512_mask_extractf64x4_pd( __W, __U, __A, 1); 2371 } 2372 2373 __m256d test_mm512_maskz_extractf64x4_pd(__mmask8 __U,__m512d __A){ 2374 // CHECK-LABEL: test_mm512_maskz_extractf64x4_pd 2375 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7> 2376 // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}} 2377 return _mm512_maskz_extractf64x4_pd( __U, __A, 1); 2378 } 2379 2380 __m128 test_mm512_extractf32x4_ps(__m512 a) 2381 { 2382 // CHECK-LABEL: test_mm512_extractf32x4_ps 2383 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7> 2384 return _mm512_extractf32x4_ps(a, 1); 2385 } 2386 2387 __m128 test_mm512_mask_extractf32x4_ps(__m128 __W, __mmask8 __U,__m512 __A){ 2388 // CHECK-LABEL: test_mm512_mask_extractf32x4_ps 2389 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7> 2390 // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}} 2391 return _mm512_mask_extractf32x4_ps( __W, __U, __A, 1); 2392 } 2393 2394 __m128 test_mm512_maskz_extractf32x4_ps( __mmask8 __U,__m512 __A){ 2395 // CHECK-LABEL: test_mm512_maskz_extractf32x4_ps 2396 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7> 2397 // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}} 2398 return _mm512_maskz_extractf32x4_ps(__U, __A, 1); 2399 } 2400 2401 __mmask16 test_mm512_cmpeq_epu32_mask(__m512i __a, __m512i __b) { 2402 // CHECK-LABEL: test_mm512_cmpeq_epu32_mask 2403 // CHECK: icmp eq <16 x i32> %{{.*}}, %{{.*}} 2404 return (__mmask16)_mm512_cmpeq_epu32_mask(__a, __b); 2405 } 2406 2407 __mmask16 test_mm512_mask_cmpeq_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { 2408 // CHECK-LABEL: test_mm512_mask_cmpeq_epu32_mask 2409 // CHECK: icmp eq <16 x i32> %{{.*}}, %{{.*}} 2410 // CHECK: and <16 x i1> %{{.*}}, %{{.*}} 2411 return (__mmask16)_mm512_mask_cmpeq_epu32_mask(__u, __a, __b); 2412 } 2413 2414 __mmask8 test_mm512_cmpeq_epu64_mask(__m512i __a, __m512i __b) { 2415 // CHECK-LABEL: test_mm512_cmpeq_epu64_mask 2416 // CHECK: icmp eq <8 x i64> %{{.*}}, %{{.*}} 2417 return (__mmask8)_mm512_cmpeq_epu64_mask(__a, __b); 2418 } 2419 2420 __mmask8 test_mm512_mask_cmpeq_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { 2421 // CHECK-LABEL: test_mm512_mask_cmpeq_epu64_mask 2422 // CHECK: icmp eq <8 x i64> %{{.*}}, %{{.*}} 2423 // CHECK: and <8 x i1> %{{.*}}, %{{.*}} 2424 return (__mmask8)_mm512_mask_cmpeq_epu64_mask(__u, __a, __b); 2425 } 2426 2427 __mmask16 test_mm512_cmpge_epi32_mask(__m512i __a, __m512i __b) { 2428 // CHECK-LABEL: test_mm512_cmpge_epi32_mask 2429 // CHECK: icmp sge <16 x i32> %{{.*}}, %{{.*}} 2430 return (__mmask16)_mm512_cmpge_epi32_mask(__a, __b); 2431 } 2432 2433 __mmask16 test_mm512_mask_cmpge_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { 2434 // CHECK-LABEL: test_mm512_mask_cmpge_epi32_mask 2435 // CHECK: icmp sge <16 x i32> %{{.*}}, %{{.*}} 2436 // CHECK: and <16 x i1> %{{.*}}, %{{.*}} 2437 return (__mmask16)_mm512_mask_cmpge_epi32_mask(__u, __a, __b); 2438 } 2439 2440 __mmask8 test_mm512_cmpge_epi64_mask(__m512i __a, __m512i __b) { 2441 // CHECK-LABEL: test_mm512_cmpge_epi64_mask 2442 // CHECK: icmp sge <8 x i64> %{{.*}}, %{{.*}} 2443 return (__mmask8)_mm512_cmpge_epi64_mask(__a, __b); 2444 } 2445 2446 __mmask8 test_mm512_mask_cmpge_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { 2447 // CHECK-LABEL: test_mm512_mask_cmpge_epi64_mask 2448 // CHECK: icmp sge <8 x i64> %{{.*}}, %{{.*}} 2449 // CHECK: and <8 x i1> %{{.*}}, %{{.*}} 2450 return (__mmask8)_mm512_mask_cmpge_epi64_mask(__u, __a, __b); 2451 } 2452 2453 __mmask16 test_mm512_cmpge_epu32_mask(__m512i __a, __m512i __b) { 2454 // CHECK-LABEL: test_mm512_cmpge_epu32_mask 2455 // CHECK: icmp uge <16 x i32> %{{.*}}, %{{.*}} 2456 return (__mmask16)_mm512_cmpge_epu32_mask(__a, __b); 2457 } 2458 2459 __mmask16 test_mm512_mask_cmpge_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { 2460 // CHECK-LABEL: test_mm512_mask_cmpge_epu32_mask 2461 // CHECK: icmp uge <16 x i32> %{{.*}}, %{{.*}} 2462 // CHECK: and <16 x i1> %{{.*}}, %{{.*}} 2463 return (__mmask16)_mm512_mask_cmpge_epu32_mask(__u, __a, __b); 2464 } 2465 2466 __mmask8 test_mm512_cmpge_epu64_mask(__m512i __a, __m512i __b) { 2467 // CHECK-LABEL: test_mm512_cmpge_epu64_mask 2468 // CHECK: icmp uge <8 x i64> %{{.*}}, %{{.*}} 2469 return (__mmask8)_mm512_cmpge_epu64_mask(__a, __b); 2470 } 2471 2472 __mmask8 test_mm512_mask_cmpge_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { 2473 // CHECK-LABEL: test_mm512_mask_cmpge_epu64_mask 2474 // CHECK: icmp uge <8 x i64> %{{.*}}, %{{.*}} 2475 // CHECK: and <8 x i1> %{{.*}}, %{{.*}} 2476 return (__mmask8)_mm512_mask_cmpge_epu64_mask(__u, __a, __b); 2477 } 2478 2479 __mmask16 test_mm512_cmpgt_epu32_mask(__m512i __a, __m512i __b) { 2480 // CHECK-LABEL: test_mm512_cmpgt_epu32_mask 2481 // CHECK: icmp ugt <16 x i32> %{{.*}}, %{{.*}} 2482 return (__mmask16)_mm512_cmpgt_epu32_mask(__a, __b); 2483 } 2484 2485 __mmask16 test_mm512_mask_cmpgt_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { 2486 // CHECK-LABEL: test_mm512_mask_cmpgt_epu32_mask 2487 // CHECK: icmp ugt <16 x i32> %{{.*}}, %{{.*}} 2488 // CHECK: and <16 x i1> %{{.*}}, %{{.*}} 2489 return (__mmask16)_mm512_mask_cmpgt_epu32_mask(__u, __a, __b); 2490 } 2491 2492 __mmask8 test_mm512_cmpgt_epu64_mask(__m512i __a, __m512i __b) { 2493 // CHECK-LABEL: test_mm512_cmpgt_epu64_mask 2494 // CHECK: icmp ugt <8 x i64> %{{.*}}, %{{.*}} 2495 return (__mmask8)_mm512_cmpgt_epu64_mask(__a, __b); 2496 } 2497 2498 __mmask8 test_mm512_mask_cmpgt_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { 2499 // CHECK-LABEL: test_mm512_mask_cmpgt_epu64_mask 2500 // CHECK: icmp ugt <8 x i64> %{{.*}}, %{{.*}} 2501 // CHECK: and <8 x i1> %{{.*}}, %{{.*}} 2502 return (__mmask8)_mm512_mask_cmpgt_epu64_mask(__u, __a, __b); 2503 } 2504 2505 __mmask16 test_mm512_cmple_epi32_mask(__m512i __a, __m512i __b) { 2506 // CHECK-LABEL: test_mm512_cmple_epi32_mask 2507 // CHECK: icmp sle <16 x i32> %{{.*}}, %{{.*}} 2508 return (__mmask16)_mm512_cmple_epi32_mask(__a, __b); 2509 } 2510 2511 __mmask16 test_mm512_mask_cmple_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { 2512 // CHECK-LABEL: test_mm512_mask_cmple_epi32_mask 2513 // CHECK: icmp sle <16 x i32> %{{.*}}, %{{.*}} 2514 // CHECK: and <16 x i1> %{{.*}}, %{{.*}} 2515 return (__mmask16)_mm512_mask_cmple_epi32_mask(__u, __a, __b); 2516 } 2517 2518 __mmask8 test_mm512_cmple_epi64_mask(__m512i __a, __m512i __b) { 2519 // CHECK-LABEL: test_mm512_cmple_epi64_mask 2520 // CHECK: icmp sle <8 x i64> %{{.*}}, %{{.*}} 2521 return (__mmask8)_mm512_cmple_epi64_mask(__a, __b); 2522 } 2523 2524 __mmask8 test_mm512_mask_cmple_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { 2525 // CHECK-LABEL: test_mm512_mask_cmple_epi64_mask 2526 // CHECK: icmp sle <8 x i64> %{{.*}}, %{{.*}} 2527 // CHECK: and <8 x i1> %{{.*}}, %{{.*}} 2528 return (__mmask8)_mm512_mask_cmple_epi64_mask(__u, __a, __b); 2529 } 2530 2531 __mmask16 test_mm512_cmple_epu32_mask(__m512i __a, __m512i __b) { 2532 // CHECK-LABEL: test_mm512_cmple_epu32_mask 2533 // CHECK: icmp ule <16 x i32> %{{.*}}, %{{.*}} 2534 return (__mmask16)_mm512_cmple_epu32_mask(__a, __b); 2535 } 2536 2537 __mmask16 test_mm512_mask_cmple_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { 2538 // CHECK-LABEL: test_mm512_mask_cmple_epu32_mask 2539 // CHECK: icmp ule <16 x i32> %{{.*}}, %{{.*}} 2540 // CHECK: and <16 x i1> %{{.*}}, %{{.*}} 2541 return (__mmask16)_mm512_mask_cmple_epu32_mask(__u, __a, __b); 2542 } 2543 2544 __mmask8 test_mm512_cmple_epu64_mask(__m512i __a, __m512i __b) { 2545 // CHECK-LABEL: test_mm512_cmple_epu64_mask 2546 // CHECK: icmp ule <8 x i64> %{{.*}}, %{{.*}} 2547 return (__mmask8)_mm512_cmple_epu64_mask(__a, __b); 2548 } 2549 2550 __mmask8 test_mm512_mask_cmple_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { 2551 // CHECK-LABEL: test_mm512_mask_cmple_epu64_mask 2552 // CHECK: icmp ule <8 x i64> %{{.*}}, %{{.*}} 2553 // CHECK: and <8 x i1> %{{.*}}, %{{.*}} 2554 return (__mmask8)_mm512_mask_cmple_epu64_mask(__u, __a, __b); 2555 } 2556 2557 __mmask16 test_mm512_cmplt_epi32_mask(__m512i __a, __m512i __b) { 2558 // CHECK-LABEL: test_mm512_cmplt_epi32_mask 2559 // CHECK: icmp slt <16 x i32> %{{.*}}, %{{.*}} 2560 return (__mmask16)_mm512_cmplt_epi32_mask(__a, __b); 2561 } 2562 2563 __mmask16 test_mm512_mask_cmplt_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { 2564 // CHECK-LABEL: test_mm512_mask_cmplt_epi32_mask 2565 // CHECK: icmp slt <16 x i32> %{{.*}}, %{{.*}} 2566 // CHECK: and <16 x i1> %{{.*}}, %{{.*}} 2567 return (__mmask16)_mm512_mask_cmplt_epi32_mask(__u, __a, __b); 2568 } 2569 2570 __mmask8 test_mm512_cmplt_epi64_mask(__m512i __a, __m512i __b) { 2571 // CHECK-LABEL: test_mm512_cmplt_epi64_mask 2572 // CHECK: icmp slt <8 x i64> %{{.*}}, %{{.*}} 2573 return (__mmask8)_mm512_cmplt_epi64_mask(__a, __b); 2574 } 2575 2576 __mmask8 test_mm512_mask_cmplt_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { 2577 // CHECK-LABEL: test_mm512_mask_cmplt_epi64_mask 2578 // CHECK: icmp slt <8 x i64> %{{.*}}, %{{.*}} 2579 // CHECK: and <8 x i1> %{{.*}}, %{{.*}} 2580 return (__mmask8)_mm512_mask_cmplt_epi64_mask(__u, __a, __b); 2581 } 2582 2583 __mmask16 test_mm512_cmplt_epu32_mask(__m512i __a, __m512i __b) { 2584 // CHECK-LABEL: test_mm512_cmplt_epu32_mask 2585 // CHECK: icmp ult <16 x i32> %{{.*}}, %{{.*}} 2586 return (__mmask16)_mm512_cmplt_epu32_mask(__a, __b); 2587 } 2588 2589 __mmask16 test_mm512_mask_cmplt_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { 2590 // CHECK-LABEL: test_mm512_mask_cmplt_epu32_mask 2591 // CHECK: icmp ult <16 x i32> %{{.*}}, %{{.*}} 2592 // CHECK: and <16 x i1> %{{.*}}, %{{.*}} 2593 return (__mmask16)_mm512_mask_cmplt_epu32_mask(__u, __a, __b); 2594 } 2595 2596 __mmask8 test_mm512_cmplt_epu64_mask(__m512i __a, __m512i __b) { 2597 // CHECK-LABEL: test_mm512_cmplt_epu64_mask 2598 // CHECK: icmp ult <8 x i64> %{{.*}}, %{{.*}} 2599 return (__mmask8)_mm512_cmplt_epu64_mask(__a, __b); 2600 } 2601 2602 __mmask8 test_mm512_mask_cmplt_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { 2603 // CHECK-LABEL: test_mm512_mask_cmplt_epu64_mask 2604 // CHECK: icmp ult <8 x i64> %{{.*}}, %{{.*}} 2605 // CHECK: and <8 x i1> %{{.*}}, %{{.*}} 2606 return (__mmask8)_mm512_mask_cmplt_epu64_mask(__u, __a, __b); 2607 } 2608 2609 __mmask16 test_mm512_cmpneq_epi32_mask(__m512i __a, __m512i __b) { 2610 // CHECK-LABEL: test_mm512_cmpneq_epi32_mask 2611 // CHECK: icmp ne <16 x i32> %{{.*}}, %{{.*}} 2612 return (__mmask16)_mm512_cmpneq_epi32_mask(__a, __b); 2613 } 2614 2615 __mmask16 test_mm512_mask_cmpneq_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { 2616 // CHECK-LABEL: test_mm512_mask_cmpneq_epi32_mask 2617 // CHECK: icmp ne <16 x i32> %{{.*}}, %{{.*}} 2618 // CHECK: and <16 x i1> %{{.*}}, %{{.*}} 2619 return (__mmask16)_mm512_mask_cmpneq_epi32_mask(__u, __a, __b); 2620 } 2621 2622 __mmask8 test_mm512_cmpneq_epi64_mask(__m512i __a, __m512i __b) { 2623 // CHECK-LABEL: test_mm512_cmpneq_epi64_mask 2624 // CHECK: icmp ne <8 x i64> %{{.*}}, %{{.*}} 2625 return (__mmask8)_mm512_cmpneq_epi64_mask(__a, __b); 2626 } 2627 2628 __mmask8 test_mm512_mask_cmpneq_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { 2629 // CHECK-LABEL: test_mm512_mask_cmpneq_epi64_mask 2630 // CHECK: icmp ne <8 x i64> %{{.*}}, %{{.*}} 2631 // CHECK: and <8 x i1> %{{.*}}, %{{.*}} 2632 return (__mmask8)_mm512_mask_cmpneq_epi64_mask(__u, __a, __b); 2633 } 2634 2635 __mmask16 test_mm512_cmpneq_epu32_mask(__m512i __a, __m512i __b) { 2636 // CHECK-LABEL: test_mm512_cmpneq_epu32_mask 2637 // CHECK: icmp ne <16 x i32> %{{.*}}, %{{.*}} 2638 return (__mmask16)_mm512_cmpneq_epu32_mask(__a, __b); 2639 } 2640 2641 __mmask16 test_mm512_mask_cmpneq_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { 2642 // CHECK-LABEL: test_mm512_mask_cmpneq_epu32_mask 2643 // CHECK: icmp ne <16 x i32> %{{.*}}, %{{.*}} 2644 // CHECK: and <16 x i1> %{{.*}}, %{{.*}} 2645 return (__mmask16)_mm512_mask_cmpneq_epu32_mask(__u, __a, __b); 2646 } 2647 2648 __mmask8 test_mm512_cmpneq_epu64_mask(__m512i __a, __m512i __b) { 2649 // CHECK-LABEL: test_mm512_cmpneq_epu64_mask 2650 // CHECK: icmp ne <8 x i64> %{{.*}}, %{{.*}} 2651 return (__mmask8)_mm512_cmpneq_epu64_mask(__a, __b); 2652 } 2653 2654 __mmask8 test_mm512_mask_cmpneq_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { 2655 // CHECK-LABEL: test_mm512_mask_cmpneq_epu64_mask 2656 // CHECK: icmp ne <8 x i64> %{{.*}}, %{{.*}} 2657 // CHECK: and <8 x i1> %{{.*}}, %{{.*}} 2658 return (__mmask8)_mm512_mask_cmpneq_epu64_mask(__u, __a, __b); 2659 } 2660 2661 __mmask16 test_mm512_cmp_eq_epi32_mask(__m512i __a, __m512i __b) { 2662 // CHECK-LABEL: test_mm512_cmp_eq_epi32_mask 2663 // CHECK: icmp eq <16 x i32> %{{.*}}, %{{.*}} 2664 return (__mmask16)_mm512_cmp_epi32_mask(__a, __b, _MM_CMPINT_EQ); 2665 } 2666 2667 __mmask16 test_mm512_mask_cmp_eq_epi32_mask(__mmask16 __u, __m512i __a, __m512i __b) { 2668 // CHECK-LABEL: test_mm512_mask_cmp_eq_epi32_mask 2669 // CHECK: icmp eq <16 x i32> %{{.*}}, %{{.*}} 2670 // CHECK: and <16 x i1> %{{.*}}, %{{.*}} 2671 return (__mmask16)_mm512_mask_cmp_epi32_mask(__u, __a, __b, _MM_CMPINT_EQ); 2672 } 2673 2674 __mmask8 test_mm512_cmp_eq_epi64_mask(__m512i __a, __m512i __b) { 2675 // CHECK-LABEL: test_mm512_cmp_eq_epi64_mask 2676 // CHECK: icmp eq <8 x i64> %{{.*}}, %{{.*}} 2677 return (__mmask8)_mm512_cmp_epi64_mask(__a, __b, _MM_CMPINT_EQ); 2678 } 2679 2680 __mmask8 test_mm512_mask_cmp_eq_epi64_mask(__mmask8 __u, __m512i __a, __m512i __b) { 2681 // CHECK-LABEL: test_mm512_mask_cmp_eq_epi64_mask 2682 // CHECK: icmp eq <8 x i64> %{{.*}}, %{{.*}} 2683 // CHECK: and <8 x i1> %{{.*}}, %{{.*}} 2684 return (__mmask8)_mm512_mask_cmp_epi64_mask(__u, __a, __b, _MM_CMPINT_EQ); 2685 } 2686 2687 __mmask16 test_mm512_cmp_epu32_mask(__m512i __a, __m512i __b) { 2688 // CHECK-LABEL: test_mm512_cmp_epu32_mask 2689 // CHECK: icmp eq <16 x i32> %{{.*}}, %{{.*}} 2690 return (__mmask16)_mm512_cmp_epu32_mask(__a, __b, 0); 2691 } 2692 2693 __mmask16 test_mm512_mask_cmp_epu32_mask(__mmask16 __u, __m512i __a, __m512i __b) { 2694 // CHECK-LABEL: test_mm512_mask_cmp_epu32_mask 2695 // CHECK: icmp eq <16 x i32> %{{.*}}, %{{.*}} 2696 // CHECK: and <16 x i1> %{{.*}}, %{{.*}} 2697 return (__mmask16)_mm512_mask_cmp_epu32_mask(__u, __a, __b, 0); 2698 } 2699 2700 __mmask8 test_mm512_cmp_epu64_mask(__m512i __a, __m512i __b) { 2701 // CHECK-LABEL: test_mm512_cmp_epu64_mask 2702 // CHECK: icmp eq <8 x i64> %{{.*}}, %{{.*}} 2703 return (__mmask8)_mm512_cmp_epu64_mask(__a, __b, 0); 2704 } 2705 2706 __mmask8 test_mm512_mask_cmp_epu64_mask(__mmask8 __u, __m512i __a, __m512i __b) { 2707 // CHECK-LABEL: test_mm512_mask_cmp_epu64_mask 2708 // CHECK: icmp eq <8 x i64> %{{.*}}, %{{.*}} 2709 // CHECK: and <8 x i1> %{{.*}}, %{{.*}} 2710 return (__mmask8)_mm512_mask_cmp_epu64_mask(__u, __a, __b, 0); 2711 } 2712 2713 __m512i test_mm512_mask_and_epi32(__m512i __src,__mmask16 __k, __m512i __a, __m512i __b) { 2714 // CHECK-LABEL: test_mm512_mask_and_epi32 2715 // CHECK: and <16 x i32> 2716 // CHECK: %[[MASK:.*]] = bitcast i16 %{{.*}} to <16 x i1> 2717 // CHECK: select <16 x i1> %[[MASK]], <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 2718 return _mm512_mask_and_epi32(__src, __k,__a, __b); 2719 } 2720 2721 __m512i test_mm512_maskz_and_epi32(__mmask16 __k, __m512i __a, __m512i __b) { 2722 // CHECK-LABEL: test_mm512_maskz_and_epi32 2723 // CHECK: and <16 x i32> 2724 // CHECK: %[[MASK:.*]] = bitcast i16 %{{.*}} to <16 x i1> 2725 // CHECK: select <16 x i1> %[[MASK]], <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 2726 return _mm512_maskz_and_epi32(__k,__a, __b); 2727 } 2728 2729 __m512i test_mm512_mask_and_epi64(__m512i __src,__mmask8 __k, __m512i __a, __m512i __b) { 2730 // CHECK-LABEL: test_mm512_mask_and_epi64 2731 // CHECK: %[[AND_RES:.*]] = and <8 x i64> 2732 // CHECK: %[[MASK:.*]] = bitcast i8 %{{.*}} to <8 x i1> 2733 // CHECK: select <8 x i1> %[[MASK]], <8 x i64> %[[AND_RES]], <8 x i64> %{{.*}} 2734 return _mm512_mask_and_epi64(__src, __k,__a, __b); 2735 } 2736 2737 __m512i test_mm512_maskz_and_epi64(__mmask8 __k, __m512i __a, __m512i __b) { 2738 // CHECK-LABEL: test_mm512_maskz_and_epi64 2739 // CHECK: %[[AND_RES:.*]] = and <8 x i64> 2740 // CHECK: %[[MASK:.*]] = bitcast i8 %{{.*}} to <8 x i1> 2741 // CHECK: select <8 x i1> %[[MASK]], <8 x i64> %[[AND_RES]], <8 x i64> %{{.*}} 2742 return _mm512_maskz_and_epi64(__k,__a, __b); 2743 } 2744 2745 __m512i test_mm512_mask_or_epi32(__m512i __src,__mmask16 __k, __m512i __a, __m512i __b) { 2746 // CHECK-LABEL: test_mm512_mask_or_epi32 2747 // CHECK: or <16 x i32> 2748 // CHECK: %[[MASK:.*]] = bitcast i16 %{{.*}} to <16 x i1> 2749 // CHECK: select <16 x i1> %[[MASK]], <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 2750 return _mm512_mask_or_epi32(__src, __k,__a, __b); 2751 } 2752 2753 __m512i test_mm512_maskz_or_epi32(__mmask16 __k, __m512i __a, __m512i __b) { 2754 // CHECK-LABEL: test_mm512_maskz_or_epi32 2755 // CHECK: or <16 x i32> 2756 // CHECK: %[[MASK:.*]] = bitcast i16 %{{.*}} to <16 x i1> 2757 // CHECK: select <16 x i1> %[[MASK]], <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 2758 return _mm512_maskz_or_epi32(__k,__a, __b); 2759 } 2760 2761 __m512i test_mm512_mask_or_epi64(__m512i __src,__mmask8 __k, __m512i __a, __m512i __b) { 2762 // CHECK-LABEL: test_mm512_mask_or_epi64 2763 // CHECK: %[[OR_RES:.*]] = or <8 x i64> 2764 // CHECK: %[[MASK:.*]] = bitcast i8 %{{.*}} to <8 x i1> 2765 // CHECK: select <8 x i1> %[[MASK]], <8 x i64> %[[OR_RES]], <8 x i64> %{{.*}} 2766 return _mm512_mask_or_epi64(__src, __k,__a, __b); 2767 } 2768 2769 __m512i test_mm512_maskz_or_epi64(__mmask8 __k, __m512i __a, __m512i __b) { 2770 // CHECK-LABEL: test_mm512_maskz_or_epi64 2771 // CHECK: %[[OR_RES:.*]] = or <8 x i64> 2772 // CHECK: %[[MASK:.*]] = bitcast i8 %{{.*}} to <8 x i1> 2773 // CHECK: select <8 x i1> %[[MASK]], <8 x i64> %[[OR_RES]], <8 x i64> %{{.*}} 2774 return _mm512_maskz_or_epi64(__k,__a, __b); 2775 } 2776 2777 __m512i test_mm512_mask_xor_epi32(__m512i __src,__mmask16 __k, __m512i __a, __m512i __b) { 2778 // CHECK-LABEL: test_mm512_mask_xor_epi32 2779 // CHECK: xor <16 x i32> 2780 // CHECK: %[[MASK:.*]] = bitcast i16 %{{.*}} to <16 x i1> 2781 // CHECK: select <16 x i1> %[[MASK]], <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 2782 return _mm512_mask_xor_epi32(__src, __k,__a, __b); 2783 } 2784 2785 __m512i test_mm512_maskz_xor_epi32(__mmask16 __k, __m512i __a, __m512i __b) { 2786 // CHECK-LABEL: test_mm512_maskz_xor_epi32 2787 // CHECK: xor <16 x i32> 2788 // CHECK: %[[MASK:.*]] = bitcast i16 %{{.*}} to <16 x i1> 2789 // CHECK: select <16 x i1> %[[MASK]], <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 2790 return _mm512_maskz_xor_epi32(__k,__a, __b); 2791 } 2792 2793 __m512i test_mm512_mask_xor_epi64(__m512i __src,__mmask8 __k, __m512i __a, __m512i __b) { 2794 // CHECK-LABEL: test_mm512_mask_xor_epi64 2795 // CHECK: %[[XOR_RES:.*]] = xor <8 x i64> 2796 // CHECK: %[[MASK:.*]] = bitcast i8 %{{.*}} to <8 x i1> 2797 // CHECK: select <8 x i1> %[[MASK]], <8 x i64> %[[XOR_RES]], <8 x i64> %{{.*}} 2798 return _mm512_mask_xor_epi64(__src, __k,__a, __b); 2799 } 2800 2801 __m512i test_mm512_maskz_xor_epi64(__mmask8 __k, __m512i __a, __m512i __b) { 2802 // CHECK-LABEL: test_mm512_maskz_xor_epi64 2803 // CHECK: %[[XOR_RES:.*]] = xor <8 x i64> 2804 // CHECK: %[[MASK:.*]] = bitcast i8 %{{.*}} to <8 x i1> 2805 // CHECK: select <8 x i1> %[[MASK]], <8 x i64> %[[XOR_RES]], <8 x i64> %{{.*}} 2806 return _mm512_maskz_xor_epi64(__k,__a, __b); 2807 } 2808 2809 __m512i test_mm512_and_epi32(__m512i __src,__mmask16 __k, __m512i __a, __m512i __b) { 2810 // CHECK-LABEL: test_mm512_and_epi32 2811 // CHECK: and <16 x i32> 2812 return _mm512_and_epi32(__a, __b); 2813 } 2814 2815 __m512i test_mm512_and_epi64(__m512i __src,__mmask8 __k, __m512i __a, __m512i __b) { 2816 // CHECK-LABEL: test_mm512_and_epi64 2817 // CHECK: and <8 x i64> 2818 return _mm512_and_epi64(__a, __b); 2819 } 2820 2821 __m512i test_mm512_or_epi32(__m512i __src,__mmask16 __k, __m512i __a, __m512i __b) { 2822 // CHECK-LABEL: test_mm512_or_epi32 2823 // CHECK: or <16 x i32> 2824 return _mm512_or_epi32(__a, __b); 2825 } 2826 2827 __m512i test_mm512_or_epi64(__m512i __src,__mmask8 __k, __m512i __a, __m512i __b) { 2828 // CHECK-LABEL: test_mm512_or_epi64 2829 // CHECK: or <8 x i64> 2830 return _mm512_or_epi64(__a, __b); 2831 } 2832 2833 __m512i test_mm512_xor_epi32(__m512i __src,__mmask16 __k, __m512i __a, __m512i __b) { 2834 // CHECK-LABEL: test_mm512_xor_epi32 2835 // CHECK: xor <16 x i32> 2836 return _mm512_xor_epi32(__a, __b); 2837 } 2838 2839 __m512i test_mm512_xor_epi64(__m512i __src,__mmask8 __k, __m512i __a, __m512i __b) { 2840 // CHECK-LABEL: test_mm512_xor_epi64 2841 // CHECK: xor <8 x i64> 2842 return _mm512_xor_epi64(__a, __b); 2843 } 2844 2845 __m512i test_mm512_maskz_andnot_epi32 (__mmask16 __k,__m512i __A, __m512i __B){ 2846 // CHECK-LABEL: test_mm512_maskz_andnot_epi32 2847 // CHECK: xor <16 x i32> %{{.*}}, splat (i32 -1) 2848 // CHECK: and <16 x i32> %{{.*}}, %{{.*}} 2849 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 2850 return _mm512_maskz_andnot_epi32(__k,__A,__B); 2851 } 2852 2853 __m512i test_mm512_mask_andnot_epi32 (__mmask16 __k,__m512i __A, __m512i __B, 2854 __m512i __src) { 2855 // CHECK-LABEL: test_mm512_mask_andnot_epi32 2856 // CHECK: xor <16 x i32> %{{.*}}, splat (i32 -1) 2857 // CHECK: and <16 x i32> %{{.*}}, %{{.*}} 2858 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 2859 return _mm512_mask_andnot_epi32(__src,__k,__A,__B); 2860 } 2861 2862 __m512i test_mm512_andnot_si512(__m512i __A, __m512i __B) 2863 { 2864 //CHECK-LABEL: test_mm512_andnot_si512 2865 //CHECK: load {{.*}}%__A.addr.i, align 64 2866 //CHECK: %not.i = xor{{.*}}, splat (i64 -1) 2867 //CHECK: load {{.*}}%__B.addr.i, align 64 2868 //CHECK: and <8 x i64> %not.i,{{.*}} 2869 2870 return _mm512_andnot_si512(__A, __B); 2871 } 2872 2873 __m512i test_mm512_andnot_epi32(__m512i __A, __m512i __B) { 2874 // CHECK-LABEL: test_mm512_andnot_epi32 2875 // CHECK: xor <16 x i32> %{{.*}}, splat (i32 -1) 2876 // CHECK: and <16 x i32> %{{.*}}, %{{.*}} 2877 return _mm512_andnot_epi32(__A,__B); 2878 } 2879 2880 __m512i test_mm512_maskz_andnot_epi64 (__mmask8 __k,__m512i __A, __m512i __B) { 2881 // CHECK-LABEL: test_mm512_maskz_andnot_epi64 2882 // CHECK: xor <8 x i64> %{{.*}}, splat (i64 -1) 2883 // CHECK: and <8 x i64> %{{.*}}, %{{.*}} 2884 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 2885 return _mm512_maskz_andnot_epi64(__k,__A,__B); 2886 } 2887 2888 __m512i test_mm512_mask_andnot_epi64 (__mmask8 __k,__m512i __A, __m512i __B, 2889 __m512i __src) { 2890 //CHECK-LABEL: test_mm512_mask_andnot_epi64 2891 // CHECK: xor <8 x i64> %{{.*}}, splat (i64 -1) 2892 // CHECK: and <8 x i64> %{{.*}}, %{{.*}} 2893 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 2894 return _mm512_mask_andnot_epi64(__src,__k,__A,__B); 2895 } 2896 2897 __m512i test_mm512_andnot_epi64(__m512i __A, __m512i __B) { 2898 //CHECK-LABEL: test_mm512_andnot_epi64 2899 // CHECK: xor <8 x i64> %{{.*}}, splat (i64 -1) 2900 // CHECK: and <8 x i64> %{{.*}}, %{{.*}} 2901 return _mm512_andnot_epi64(__A,__B); 2902 } 2903 2904 __m512i test_mm512_maskz_sub_epi32 (__mmask16 __k,__m512i __A, __m512i __B) { 2905 //CHECK-LABEL: test_mm512_maskz_sub_epi32 2906 //CHECK: sub <16 x i32> %{{.*}}, %{{.*}} 2907 //CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 2908 return _mm512_maskz_sub_epi32(__k,__A,__B); 2909 } 2910 2911 __m512i test_mm512_mask_sub_epi32 (__mmask16 __k,__m512i __A, __m512i __B, 2912 __m512i __src) { 2913 //CHECK-LABEL: test_mm512_mask_sub_epi32 2914 //CHECK: sub <16 x i32> %{{.*}}, %{{.*}} 2915 //CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 2916 return _mm512_mask_sub_epi32(__src,__k,__A,__B); 2917 } 2918 2919 __m512i test_mm512_sub_epi32(__m512i __A, __m512i __B) { 2920 //CHECK-LABEL: test_mm512_sub_epi32 2921 //CHECK: sub <16 x i32> 2922 return _mm512_sub_epi32(__A,__B); 2923 } 2924 2925 __m512i test_mm512_maskz_sub_epi64 (__mmask8 __k,__m512i __A, __m512i __B) { 2926 //CHECK-LABEL: test_mm512_maskz_sub_epi64 2927 //CHECK: sub <8 x i64> %{{.*}}, %{{.*}} 2928 //CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 2929 return _mm512_maskz_sub_epi64(__k,__A,__B); 2930 } 2931 2932 __m512i test_mm512_mask_sub_epi64 (__mmask8 __k,__m512i __A, __m512i __B, 2933 __m512i __src) { 2934 //CHECK-LABEL: test_mm512_mask_sub_epi64 2935 //CHECK: sub <8 x i64> %{{.*}}, %{{.*}} 2936 //CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 2937 return _mm512_mask_sub_epi64(__src,__k,__A,__B); 2938 } 2939 2940 __m512i test_mm512_sub_epi64(__m512i __A, __m512i __B) { 2941 //CHECK-LABEL: test_mm512_sub_epi64 2942 //CHECK: sub <8 x i64> 2943 return _mm512_sub_epi64(__A,__B); 2944 } 2945 2946 __m512i test_mm512_maskz_add_epi32 (__mmask16 __k,__m512i __A, __m512i __B) { 2947 //CHECK-LABEL: test_mm512_maskz_add_epi32 2948 //CHECK: add <16 x i32> %{{.*}}, %{{.*}} 2949 //CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 2950 return _mm512_maskz_add_epi32(__k,__A,__B); 2951 } 2952 2953 __m512i test_mm512_mask_add_epi32 (__mmask16 __k,__m512i __A, __m512i __B, 2954 __m512i __src) { 2955 //CHECK-LABEL: test_mm512_mask_add_epi32 2956 //CHECK: add <16 x i32> %{{.*}}, %{{.*}} 2957 //CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 2958 return _mm512_mask_add_epi32(__src,__k,__A,__B); 2959 } 2960 2961 __m512i test_mm512_add_epi32(__m512i __A, __m512i __B) { 2962 //CHECK-LABEL: test_mm512_add_epi32 2963 //CHECK: add <16 x i32> 2964 return _mm512_add_epi32(__A,__B); 2965 } 2966 2967 __m512i test_mm512_maskz_add_epi64 (__mmask8 __k,__m512i __A, __m512i __B) { 2968 //CHECK-LABEL: test_mm512_maskz_add_epi64 2969 //CHECK: add <8 x i64> %{{.*}}, %{{.*}} 2970 //CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 2971 return _mm512_maskz_add_epi64(__k,__A,__B); 2972 } 2973 2974 __m512i test_mm512_mask_add_epi64 (__mmask8 __k,__m512i __A, __m512i __B, 2975 __m512i __src) { 2976 //CHECK-LABEL: test_mm512_mask_add_epi64 2977 //CHECK: add <8 x i64> %{{.*}}, %{{.*}} 2978 //CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 2979 return _mm512_mask_add_epi64(__src,__k,__A,__B); 2980 } 2981 2982 __m512i test_mm512_add_epi64(__m512i __A, __m512i __B) { 2983 //CHECK-LABEL: test_mm512_add_epi64 2984 //CHECK: add <8 x i64> 2985 return _mm512_add_epi64(__A,__B); 2986 } 2987 2988 __m512i test_mm512_mul_epi32(__m512i __A, __m512i __B) { 2989 //CHECK-LABEL: test_mm512_mul_epi32 2990 //CHECK: shl <8 x i64> %{{.*}}, splat (i64 32) 2991 //CHECK: ashr <8 x i64> %{{.*}}, splat (i64 32) 2992 //CHECK: shl <8 x i64> %{{.*}}, splat (i64 32) 2993 //CHECK: ashr <8 x i64> %{{.*}}, splat (i64 32) 2994 //CHECK: mul <8 x i64> %{{.*}}, %{{.*}} 2995 return _mm512_mul_epi32(__A,__B); 2996 } 2997 2998 __m512i test_mm512_maskz_mul_epi32 (__mmask8 __k,__m512i __A, __m512i __B) { 2999 //CHECK-LABEL: test_mm512_maskz_mul_epi32 3000 //CHECK: shl <8 x i64> %{{.*}}, splat (i64 32) 3001 //CHECK: ashr <8 x i64> %{{.*}}, splat (i64 32) 3002 //CHECK: shl <8 x i64> %{{.*}}, splat (i64 32) 3003 //CHECK: ashr <8 x i64> %{{.*}}, splat (i64 32) 3004 //CHECK: mul <8 x i64> %{{.*}}, %{{.*}} 3005 //CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3006 return _mm512_maskz_mul_epi32(__k,__A,__B); 3007 } 3008 3009 __m512i test_mm512_mask_mul_epi32 (__mmask8 __k,__m512i __A, __m512i __B, __m512i __src) { 3010 //CHECK-LABEL: test_mm512_mask_mul_epi32 3011 //CHECK: shl <8 x i64> %{{.*}}, splat (i64 32) 3012 //CHECK: ashr <8 x i64> %{{.*}}, splat (i64 32) 3013 //CHECK: shl <8 x i64> %{{.*}}, splat (i64 32) 3014 //CHECK: ashr <8 x i64> %{{.*}}, splat (i64 32) 3015 //CHECK: mul <8 x i64> %{{.*}}, %{{.*}} 3016 //CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3017 return _mm512_mask_mul_epi32(__src,__k,__A,__B); 3018 } 3019 3020 __m512i test_mm512_mul_epu32 (__m512i __A, __m512i __B) { 3021 //CHECK-LABEL: test_mm512_mul_epu32 3022 //CHECK: and <8 x i64> %{{.*}}, splat (i64 4294967295) 3023 //CHECK: and <8 x i64> %{{.*}}, splat (i64 4294967295) 3024 //CHECK: mul <8 x i64> %{{.*}}, %{{.*}} 3025 return _mm512_mul_epu32(__A,__B); 3026 } 3027 3028 __m512i test_mm512_maskz_mul_epu32 (__mmask8 __k,__m512i __A, __m512i __B) { 3029 //CHECK-LABEL: test_mm512_maskz_mul_epu32 3030 //CHECK: and <8 x i64> %{{.*}}, splat (i64 4294967295) 3031 //CHECK: and <8 x i64> %{{.*}}, splat (i64 4294967295) 3032 //CHECK: mul <8 x i64> %{{.*}}, %{{.*}} 3033 //CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3034 return _mm512_maskz_mul_epu32(__k,__A,__B); 3035 } 3036 3037 __m512i test_mm512_mask_mul_epu32 (__mmask8 __k,__m512i __A, __m512i __B, __m512i __src) { 3038 //CHECK-LABEL: test_mm512_mask_mul_epu32 3039 //CHECK: and <8 x i64> %{{.*}}, splat (i64 4294967295) 3040 //CHECK: and <8 x i64> %{{.*}}, splat (i64 4294967295) 3041 //CHECK: mul <8 x i64> %{{.*}}, %{{.*}} 3042 //CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3043 return _mm512_mask_mul_epu32(__src,__k,__A,__B); 3044 } 3045 3046 __m512i test_mm512_maskz_mullo_epi32 (__mmask16 __k,__m512i __A, __m512i __B) { 3047 //CHECK-LABEL: test_mm512_maskz_mullo_epi32 3048 //CHECK: mul <16 x i32> %{{.*}}, %{{.*}} 3049 //CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 3050 return _mm512_maskz_mullo_epi32(__k,__A,__B); 3051 } 3052 3053 __m512i test_mm512_mask_mullo_epi32 (__mmask16 __k,__m512i __A, __m512i __B, __m512i __src) { 3054 //CHECK-LABEL: test_mm512_mask_mullo_epi32 3055 //CHECK: mul <16 x i32> %{{.*}}, %{{.*}} 3056 //CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 3057 return _mm512_mask_mullo_epi32(__src,__k,__A,__B); 3058 } 3059 3060 __m512i test_mm512_mullo_epi32(__m512i __A, __m512i __B) { 3061 //CHECK-LABEL: test_mm512_mullo_epi32 3062 //CHECK: mul <16 x i32> 3063 return _mm512_mullo_epi32(__A,__B); 3064 } 3065 3066 __m512i test_mm512_mullox_epi64 (__m512i __A, __m512i __B) { 3067 // CHECK-LABEL: test_mm512_mullox_epi64 3068 // CHECK: mul <8 x i64> 3069 return (__m512i) _mm512_mullox_epi64(__A, __B); 3070 } 3071 3072 __m512i test_mm512_mask_mullox_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) { 3073 // CHECK-LABEL: test_mm512_mask_mullox_epi64 3074 // CHECK: mul <8 x i64> %{{.*}}, %{{.*}} 3075 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3076 return (__m512i) _mm512_mask_mullox_epi64(__W, __U, __A, __B); 3077 } 3078 3079 __m512d test_mm512_add_round_pd(__m512d __A, __m512d __B) { 3080 // CHECK-LABEL: test_mm512_add_round_pd 3081 // CHECK: @llvm.x86.avx512.add.pd.512 3082 return _mm512_add_round_pd(__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3083 } 3084 __m512d test_mm512_mask_add_round_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 3085 // CHECK-LABEL: test_mm512_mask_add_round_pd 3086 // CHECK: @llvm.x86.avx512.add.pd.512 3087 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 3088 return _mm512_mask_add_round_pd(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3089 } 3090 __m512d test_mm512_maskz_add_round_pd(__mmask8 __U, __m512d __A, __m512d __B) { 3091 // CHECK-LABEL: test_mm512_maskz_add_round_pd 3092 // CHECK: @llvm.x86.avx512.add.pd.512 3093 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 3094 return _mm512_maskz_add_round_pd(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3095 } 3096 __m512d test_mm512_mask_add_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 3097 // CHECK-LABEL: test_mm512_mask_add_pd 3098 // CHECK: fadd <8 x double> %{{.*}}, %{{.*}} 3099 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 3100 return _mm512_mask_add_pd(__W,__U,__A,__B); 3101 } 3102 __m512d test_mm512_maskz_add_pd(__mmask8 __U, __m512d __A, __m512d __B) { 3103 // CHECK-LABEL: test_mm512_maskz_add_pd 3104 // CHECK: fadd <8 x double> %{{.*}}, %{{.*}} 3105 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 3106 return _mm512_maskz_add_pd(__U,__A,__B); 3107 } 3108 __m512 test_mm512_add_round_ps(__m512 __A, __m512 __B) { 3109 // CHECK-LABEL: test_mm512_add_round_ps 3110 // CHECK: @llvm.x86.avx512.add.ps.512 3111 return _mm512_add_round_ps(__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3112 } 3113 __m512 test_mm512_mask_add_round_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 3114 // CHECK-LABEL: test_mm512_mask_add_round_ps 3115 // CHECK: @llvm.x86.avx512.add.ps.512 3116 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 3117 return _mm512_mask_add_round_ps(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3118 } 3119 __m512 test_mm512_maskz_add_round_ps(__mmask16 __U, __m512 __A, __m512 __B) { 3120 // CHECK-LABEL: test_mm512_maskz_add_round_ps 3121 // CHECK: @llvm.x86.avx512.add.ps.512 3122 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 3123 return _mm512_maskz_add_round_ps(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3124 } 3125 __m512 test_mm512_mask_add_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 3126 // CHECK-LABEL: test_mm512_mask_add_ps 3127 // CHECK: fadd <16 x float> %{{.*}}, %{{.*}} 3128 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 3129 return _mm512_mask_add_ps(__W,__U,__A,__B); 3130 } 3131 __m512 test_mm512_maskz_add_ps(__mmask16 __U, __m512 __A, __m512 __B) { 3132 // CHECK-LABEL: test_mm512_maskz_add_ps 3133 // CHECK: fadd <16 x float> %{{.*}}, %{{.*}} 3134 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 3135 return _mm512_maskz_add_ps(__U,__A,__B); 3136 } 3137 __m128 test_mm_add_round_ss(__m128 __A, __m128 __B) { 3138 // CHECK-LABEL: test_mm_add_round_ss 3139 // CHECK: @llvm.x86.avx512.mask.add.ss.round 3140 return _mm_add_round_ss(__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3141 } 3142 __m128 test_mm_mask_add_round_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { 3143 // CHECK-LABEL: test_mm_mask_add_round_ss 3144 // CHECK: @llvm.x86.avx512.mask.add.ss.round 3145 return _mm_mask_add_round_ss(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3146 } 3147 __m128 test_mm_maskz_add_round_ss(__mmask8 __U, __m128 __A, __m128 __B) { 3148 // CHECK-LABEL: test_mm_maskz_add_round_ss 3149 // CHECK: @llvm.x86.avx512.mask.add.ss.round 3150 return _mm_maskz_add_round_ss(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3151 } 3152 __m128 test_mm_mask_add_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { 3153 // CHECK-LABEL: test_mm_mask_add_ss 3154 // CHECK-NOT: @llvm.x86.avx512.mask.add.ss.round 3155 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 3156 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 3157 // CHECK: fadd float %{{.*}}, %{{.*}} 3158 // CHECK: insertelement <4 x float> %{{.*}}, i32 0 3159 // CHECK: extractelement <4 x float> %{{.*}}, i64 0 3160 // CHECK-NEXT: extractelement <4 x float> %{{.*}}, i64 0 3161 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 3162 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 3163 // CHECK-NEXT: select i1 %{{.*}}, float %{{.*}}, float %{{.*}} 3164 // CHECK-NEXT: insertelement <4 x float> %{{.*}}, float %{{.*}}, i64 0 3165 return _mm_mask_add_ss(__W,__U,__A,__B); 3166 } 3167 __m128 test_mm_maskz_add_ss(__mmask8 __U, __m128 __A, __m128 __B) { 3168 // CHECK-LABEL: test_mm_maskz_add_ss 3169 // CHECK-NOT: @llvm.x86.avx512.mask.add.ss.round 3170 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 3171 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 3172 // CHECK: fadd float %{{.*}}, %{{.*}} 3173 // CHECK: insertelement <4 x float> %{{.*}}, i32 0 3174 // CHECK: extractelement <4 x float> %{{.*}}, i64 0 3175 // CHECK-NEXT: extractelement <4 x float> %{{.*}}, i64 0 3176 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 3177 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 3178 // CHECK-NEXT: select i1 %{{.*}}, float %{{.*}}, float %{{.*}} 3179 // CHECK-NEXT: insertelement <4 x float> %{{.*}}, float %{{.*}}, i64 0 3180 return _mm_maskz_add_ss(__U,__A,__B); 3181 } 3182 __m128d test_mm_add_round_sd(__m128d __A, __m128d __B) { 3183 // CHECK-LABEL: test_mm_add_round_sd 3184 // CHECK: @llvm.x86.avx512.mask.add.sd.round 3185 return _mm_add_round_sd(__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3186 } 3187 __m128d test_mm_mask_add_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { 3188 // CHECK-LABEL: test_mm_mask_add_round_sd 3189 // CHECK: @llvm.x86.avx512.mask.add.sd.round 3190 return _mm_mask_add_round_sd(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3191 } 3192 __m128d test_mm_maskz_add_round_sd(__mmask8 __U, __m128d __A, __m128d __B) { 3193 // CHECK-LABEL: test_mm_maskz_add_round_sd 3194 // CHECK: @llvm.x86.avx512.mask.add.sd.round 3195 return _mm_maskz_add_round_sd(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3196 } 3197 __m128d test_mm_mask_add_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { 3198 // CHECK-LABEL: test_mm_mask_add_sd 3199 // CHECK-NOT: @llvm.x86.avx512.mask.add.sd.round 3200 // CHECK: extractelement <2 x double> %{{.*}}, i32 0 3201 // CHECK: extractelement <2 x double> %{{.*}}, i32 0 3202 // CHECK: fadd double %{{.*}}, %{{.*}} 3203 // CHECK: insertelement <2 x double> {{.*}}, i32 0 3204 // CHECK: extractelement <2 x double> %{{.*}}, i64 0 3205 // CHECK-NEXT: extractelement <2 x double> %{{.*}}, i64 0 3206 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 3207 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 3208 // CHECK-NEXT: select i1 %{{.*}}, double %{{.*}}, double %{{.*}} 3209 // CHECK-NEXT: insertelement <2 x double> %{{.*}}, double %{{.*}}, i64 0 3210 return _mm_mask_add_sd(__W,__U,__A,__B); 3211 } 3212 __m128d test_mm_maskz_add_sd(__mmask8 __U, __m128d __A, __m128d __B) { 3213 // CHECK-LABEL: test_mm_maskz_add_sd 3214 // CHECK-NOT: @llvm.x86.avx512.mask.add.sd.round 3215 // CHECK: extractelement <2 x double> %{{.*}}, i32 0 3216 // CHECK: extractelement <2 x double> %{{.*}}, i32 0 3217 // CHECK: fadd double %{{.*}}, %{{.*}} 3218 // CHECK: insertelement <2 x double> {{.*}}, i32 0 3219 // CHECK: extractelement <2 x double> %{{.*}}, i64 0 3220 // CHECK-NEXT: extractelement <2 x double> %{{.*}}, i64 0 3221 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 3222 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 3223 // CHECK-NEXT: select i1 %{{.*}}, double %{{.*}}, double %{{.*}} 3224 // CHECK-NEXT: insertelement <2 x double> %{{.*}}, double %{{.*}}, i64 0 3225 return _mm_maskz_add_sd(__U,__A,__B); 3226 } 3227 __m512d test_mm512_sub_round_pd(__m512d __A, __m512d __B) { 3228 // CHECK-LABEL: test_mm512_sub_round_pd 3229 // CHECK: @llvm.x86.avx512.sub.pd.512 3230 return _mm512_sub_round_pd(__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3231 } 3232 __m512d test_mm512_mask_sub_round_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 3233 // CHECK-LABEL: test_mm512_mask_sub_round_pd 3234 // CHECK: @llvm.x86.avx512.sub.pd.512 3235 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 3236 return _mm512_mask_sub_round_pd(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3237 } 3238 __m512d test_mm512_maskz_sub_round_pd(__mmask8 __U, __m512d __A, __m512d __B) { 3239 // CHECK-LABEL: test_mm512_maskz_sub_round_pd 3240 // CHECK: @llvm.x86.avx512.sub.pd.512 3241 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 3242 return _mm512_maskz_sub_round_pd(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3243 } 3244 __m512d test_mm512_mask_sub_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 3245 // CHECK-LABEL: test_mm512_mask_sub_pd 3246 // CHECK: fsub <8 x double> %{{.*}}, %{{.*}} 3247 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 3248 return _mm512_mask_sub_pd(__W,__U,__A,__B); 3249 } 3250 __m512d test_mm512_maskz_sub_pd(__mmask8 __U, __m512d __A, __m512d __B) { 3251 // CHECK-LABEL: test_mm512_maskz_sub_pd 3252 // CHECK: fsub <8 x double> %{{.*}}, %{{.*}} 3253 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 3254 return _mm512_maskz_sub_pd(__U,__A,__B); 3255 } 3256 __m512 test_mm512_sub_round_ps(__m512 __A, __m512 __B) { 3257 // CHECK-LABEL: test_mm512_sub_round_ps 3258 // CHECK: @llvm.x86.avx512.sub.ps.512 3259 return _mm512_sub_round_ps(__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3260 } 3261 __m512 test_mm512_mask_sub_round_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 3262 // CHECK-LABEL: test_mm512_mask_sub_round_ps 3263 // CHECK: @llvm.x86.avx512.sub.ps.512 3264 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 3265 return _mm512_mask_sub_round_ps(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3266 } 3267 __m512 test_mm512_maskz_sub_round_ps(__mmask16 __U, __m512 __A, __m512 __B) { 3268 // CHECK-LABEL: test_mm512_maskz_sub_round_ps 3269 // CHECK: @llvm.x86.avx512.sub.ps.512 3270 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 3271 return _mm512_maskz_sub_round_ps(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3272 } 3273 __m512 test_mm512_mask_sub_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 3274 // CHECK-LABEL: test_mm512_mask_sub_ps 3275 // CHECK: fsub <16 x float> %{{.*}}, %{{.*}} 3276 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 3277 return _mm512_mask_sub_ps(__W,__U,__A,__B); 3278 } 3279 __m512 test_mm512_maskz_sub_ps(__mmask16 __U, __m512 __A, __m512 __B) { 3280 // CHECK-LABEL: test_mm512_maskz_sub_ps 3281 // CHECK: fsub <16 x float> %{{.*}}, %{{.*}} 3282 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 3283 return _mm512_maskz_sub_ps(__U,__A,__B); 3284 } 3285 __m128 test_mm_sub_round_ss(__m128 __A, __m128 __B) { 3286 // CHECK-LABEL: test_mm_sub_round_ss 3287 // CHECK: @llvm.x86.avx512.mask.sub.ss.round 3288 return _mm_sub_round_ss(__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3289 } 3290 __m128 test_mm_mask_sub_round_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { 3291 // CHECK-LABEL: test_mm_mask_sub_round_ss 3292 // CHECK: @llvm.x86.avx512.mask.sub.ss.round 3293 return _mm_mask_sub_round_ss(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3294 } 3295 __m128 test_mm_maskz_sub_round_ss(__mmask8 __U, __m128 __A, __m128 __B) { 3296 // CHECK-LABEL: test_mm_maskz_sub_round_ss 3297 // CHECK: @llvm.x86.avx512.mask.sub.ss.round 3298 return _mm_maskz_sub_round_ss(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3299 } 3300 __m128 test_mm_mask_sub_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { 3301 // CHECK-LABEL: test_mm_mask_sub_ss 3302 // CHECK-NOT: @llvm.x86.avx512.mask.sub.ss.round 3303 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 3304 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 3305 // CHECK: fsub float %{{.*}}, %{{.*}} 3306 // CHECK: insertelement <4 x float> {{.*}}, i32 0 3307 // CHECK: extractelement <4 x float> %{{.*}}, i64 0 3308 // CHECK-NEXT: extractelement <4 x float> %{{.*}}, i64 0 3309 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 3310 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 3311 // CHECK-NEXT: select i1 %{{.*}}, float %{{.*}}, float %{{.*}} 3312 // CHECK-NEXT: insertelement <4 x float> %{{.*}}, float %{{.*}}, i64 0 3313 return _mm_mask_sub_ss(__W,__U,__A,__B); 3314 } 3315 __m128 test_mm_maskz_sub_ss(__mmask8 __U, __m128 __A, __m128 __B) { 3316 // CHECK-LABEL: test_mm_maskz_sub_ss 3317 // CHECK-NOT: @llvm.x86.avx512.mask.sub.ss.round 3318 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 3319 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 3320 // CHECK: fsub float %{{.*}}, %{{.*}} 3321 // CHECK: insertelement <4 x float> {{.*}}, i32 0 3322 // CHECK: extractelement <4 x float> %{{.*}}, i64 0 3323 // CHECK-NEXT: extractelement <4 x float> %{{.*}}, i64 0 3324 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 3325 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 3326 // CHECK-NEXT: select i1 %{{.*}}, float %{{.*}}, float %{{.*}} 3327 // CHECK-NEXT: insertelement <4 x float> %{{.*}}, float %{{.*}}, i64 0 3328 return _mm_maskz_sub_ss(__U,__A,__B); 3329 } 3330 __m128d test_mm_sub_round_sd(__m128d __A, __m128d __B) { 3331 // CHECK-LABEL: test_mm_sub_round_sd 3332 // CHECK: @llvm.x86.avx512.mask.sub.sd.round 3333 return _mm_sub_round_sd(__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3334 } 3335 __m128d test_mm_mask_sub_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { 3336 // CHECK-LABEL: test_mm_mask_sub_round_sd 3337 // CHECK: @llvm.x86.avx512.mask.sub.sd.round 3338 return _mm_mask_sub_round_sd(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3339 } 3340 __m128d test_mm_maskz_sub_round_sd(__mmask8 __U, __m128d __A, __m128d __B) { 3341 // CHECK-LABEL: test_mm_maskz_sub_round_sd 3342 // CHECK: @llvm.x86.avx512.mask.sub.sd.round 3343 return _mm_maskz_sub_round_sd(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3344 } 3345 __m128d test_mm_mask_sub_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { 3346 // CHECK-LABEL: test_mm_mask_sub_sd 3347 // CHECK-NOT: @llvm.x86.avx512.mask.sub.sd.round 3348 // CHECK: extractelement <2 x double> %{{.*}}, i32 0 3349 // CHECK: extractelement <2 x double> %{{.*}}, i32 0 3350 // CHECK: fsub double %{{.*}}, %{{.*}} 3351 // CHECK: insertelement <2 x double> {{.*}}, i32 0 3352 // CHECK: extractelement <2 x double> %{{.*}}, i64 0 3353 // CHECK-NEXT: extractelement <2 x double> %{{.*}}, i64 0 3354 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 3355 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 3356 // CHECK-NEXT: select i1 %{{.*}}, double %{{.*}}, double %{{.*}} 3357 // CHECK-NEXT: insertelement <2 x double> %{{.*}}, double %{{.*}}, i64 0 3358 return _mm_mask_sub_sd(__W,__U,__A,__B); 3359 } 3360 __m128d test_mm_maskz_sub_sd(__mmask8 __U, __m128d __A, __m128d __B) { 3361 // CHECK-LABEL: test_mm_maskz_sub_sd 3362 // CHECK-NOT: @llvm.x86.avx512.mask.sub.sd.round 3363 // CHECK: extractelement <2 x double> %{{.*}}, i32 0 3364 // CHECK: extractelement <2 x double> %{{.*}}, i32 0 3365 // CHECK: fsub double %{{.*}}, %{{.*}} 3366 // CHECK: insertelement <2 x double> {{.*}}, i32 0 3367 // CHECK: extractelement <2 x double> %{{.*}}, i64 0 3368 // CHECK-NEXT: extractelement <2 x double> %{{.*}}, i64 0 3369 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 3370 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 3371 // CHECK-NEXT: select i1 %{{.*}}, double %{{.*}}, double %{{.*}} 3372 // CHECK-NEXT: insertelement <2 x double> %{{.*}}, double %{{.*}}, i64 0 3373 return _mm_maskz_sub_sd(__U,__A,__B); 3374 } 3375 __m512d test_mm512_mul_round_pd(__m512d __A, __m512d __B) { 3376 // CHECK-LABEL: test_mm512_mul_round_pd 3377 // CHECK: @llvm.x86.avx512.mul.pd.512 3378 return _mm512_mul_round_pd(__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3379 } 3380 __m512d test_mm512_mask_mul_round_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 3381 // CHECK-LABEL: test_mm512_mask_mul_round_pd 3382 // CHECK: @llvm.x86.avx512.mul.pd.512 3383 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 3384 return _mm512_mask_mul_round_pd(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3385 } 3386 __m512d test_mm512_maskz_mul_round_pd(__mmask8 __U, __m512d __A, __m512d __B) { 3387 // CHECK-LABEL: test_mm512_maskz_mul_round_pd 3388 // CHECK: @llvm.x86.avx512.mul.pd.512 3389 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 3390 return _mm512_maskz_mul_round_pd(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3391 } 3392 __m512d test_mm512_mask_mul_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 3393 // CHECK-LABEL: test_mm512_mask_mul_pd 3394 // CHECK: fmul <8 x double> %{{.*}}, %{{.*}} 3395 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 3396 return _mm512_mask_mul_pd(__W,__U,__A,__B); 3397 } 3398 __m512d test_mm512_maskz_mul_pd(__mmask8 __U, __m512d __A, __m512d __B) { 3399 // CHECK-LABEL: test_mm512_maskz_mul_pd 3400 // CHECK: fmul <8 x double> %{{.*}}, %{{.*}} 3401 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 3402 return _mm512_maskz_mul_pd(__U,__A,__B); 3403 } 3404 __m512 test_mm512_mul_round_ps(__m512 __A, __m512 __B) { 3405 // CHECK-LABEL: test_mm512_mul_round_ps 3406 // CHECK: @llvm.x86.avx512.mul.ps.512 3407 return _mm512_mul_round_ps(__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3408 } 3409 __m512 test_mm512_mask_mul_round_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 3410 // CHECK-LABEL: test_mm512_mask_mul_round_ps 3411 // CHECK: @llvm.x86.avx512.mul.ps.512 3412 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 3413 return _mm512_mask_mul_round_ps(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3414 } 3415 __m512 test_mm512_maskz_mul_round_ps(__mmask16 __U, __m512 __A, __m512 __B) { 3416 // CHECK-LABEL: test_mm512_maskz_mul_round_ps 3417 // CHECK: @llvm.x86.avx512.mul.ps.512 3418 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 3419 return _mm512_maskz_mul_round_ps(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3420 } 3421 __m512 test_mm512_mask_mul_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 3422 // CHECK-LABEL: test_mm512_mask_mul_ps 3423 // CHECK: fmul <16 x float> %{{.*}}, %{{.*}} 3424 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 3425 return _mm512_mask_mul_ps(__W,__U,__A,__B); 3426 } 3427 __m512 test_mm512_maskz_mul_ps(__mmask16 __U, __m512 __A, __m512 __B) { 3428 // CHECK-LABEL: test_mm512_maskz_mul_ps 3429 // CHECK: fmul <16 x float> %{{.*}}, %{{.*}} 3430 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 3431 return _mm512_maskz_mul_ps(__U,__A,__B); 3432 } 3433 __m128 test_mm_mul_round_ss(__m128 __A, __m128 __B) { 3434 // CHECK-LABEL: test_mm_mul_round_ss 3435 // CHECK: @llvm.x86.avx512.mask.mul.ss.round 3436 return _mm_mul_round_ss(__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3437 } 3438 __m128 test_mm_mask_mul_round_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { 3439 // CHECK-LABEL: test_mm_mask_mul_round_ss 3440 // CHECK: @llvm.x86.avx512.mask.mul.ss.round 3441 return _mm_mask_mul_round_ss(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3442 } 3443 __m128 test_mm_maskz_mul_round_ss(__mmask8 __U, __m128 __A, __m128 __B) { 3444 // CHECK-LABEL: test_mm_maskz_mul_round_ss 3445 // CHECK: @llvm.x86.avx512.mask.mul.ss.round 3446 return _mm_maskz_mul_round_ss(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3447 } 3448 __m128 test_mm_mask_mul_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { 3449 // CHECK-LABEL: test_mm_mask_mul_ss 3450 // CHECK-NOT: @llvm.x86.avx512.mask.mul.ss.round 3451 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 3452 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 3453 // CHECK: fmul float %{{.*}}, %{{.*}} 3454 // CHECK: insertelement <4 x float> {{.*}}, i32 0 3455 // CHECK: extractelement <4 x float> %{{.*}}, i64 0 3456 // CHECK-NEXT: extractelement <4 x float> %{{.*}}, i64 0 3457 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 3458 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 3459 // CHECK-NEXT: select i1 %{{.*}}, float %{{.*}}, float %{{.*}} 3460 // CHECK-NEXT: insertelement <4 x float> %{{.*}}, float %{{.*}}, i64 0 3461 return _mm_mask_mul_ss(__W,__U,__A,__B); 3462 } 3463 __m128 test_mm_maskz_mul_ss(__mmask8 __U, __m128 __A, __m128 __B) { 3464 // CHECK-LABEL: test_mm_maskz_mul_ss 3465 // CHECK-NOT: @llvm.x86.avx512.mask.mul.ss.round 3466 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 3467 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 3468 // CHECK: fmul float %{{.*}}, %{{.*}} 3469 // CHECK: insertelement <4 x float> {{.*}}, i32 0 3470 // CHECK: extractelement <4 x float> %{{.*}}, i64 0 3471 // CHECK-NEXT: extractelement <4 x float> %{{.*}}, i64 0 3472 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 3473 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 3474 // CHECK-NEXT: select i1 %{{.*}}, float %{{.*}}, float %{{.*}} 3475 // CHECK-NEXT: insertelement <4 x float> %{{.*}}, float %{{.*}}, i64 0 3476 return _mm_maskz_mul_ss(__U,__A,__B); 3477 } 3478 __m128d test_mm_mul_round_sd(__m128d __A, __m128d __B) { 3479 // CHECK-LABEL: test_mm_mul_round_sd 3480 // CHECK: @llvm.x86.avx512.mask.mul.sd.round 3481 return _mm_mul_round_sd(__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3482 } 3483 __m128d test_mm_mask_mul_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { 3484 // CHECK-LABEL: test_mm_mask_mul_round_sd 3485 // CHECK: @llvm.x86.avx512.mask.mul.sd.round 3486 return _mm_mask_mul_round_sd(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3487 } 3488 __m128d test_mm_maskz_mul_round_sd(__mmask8 __U, __m128d __A, __m128d __B) { 3489 // CHECK-LABEL: test_mm_maskz_mul_round_sd 3490 // CHECK: @llvm.x86.avx512.mask.mul.sd.round 3491 return _mm_maskz_mul_round_sd(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3492 } 3493 __m128d test_mm_mask_mul_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { 3494 // CHECK-LABEL: test_mm_mask_mul_sd 3495 // CHECK-NOT: @llvm.x86.avx512.mask.mul.sd.round 3496 // CHECK: extractelement <2 x double> %{{.*}}, i32 0 3497 // CHECK: extractelement <2 x double> %{{.*}}, i32 0 3498 // CHECK: fmul double %{{.*}}, %{{.*}} 3499 // CHECK: insertelement <2 x double> {{.*}}, i32 0 3500 // CHECK: extractelement <2 x double> %{{.*}}, i64 0 3501 // CHECK-NEXT: extractelement <2 x double> %{{.*}}, i64 0 3502 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 3503 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 3504 // CHECK-NEXT: select i1 %{{.*}}, double %{{.*}}, double %{{.*}} 3505 // CHECK-NEXT: insertelement <2 x double> %{{.*}}, double %{{.*}}, i64 0 3506 return _mm_mask_mul_sd(__W,__U,__A,__B); 3507 } 3508 __m128d test_mm_maskz_mul_sd(__mmask8 __U, __m128d __A, __m128d __B) { 3509 // CHECK-LABEL: test_mm_maskz_mul_sd 3510 // CHECK-NOT: @llvm.x86.avx512.mask.mul.sd.round 3511 // CHECK: extractelement <2 x double> %{{.*}}, i32 0 3512 // CHECK: extractelement <2 x double> %{{.*}}, i32 0 3513 // CHECK: fmul double %{{.*}}, %{{.*}} 3514 // CHECK: insertelement <2 x double> {{.*}}, i32 0 3515 // CHECK: extractelement <2 x double> %{{.*}}, i64 0 3516 // CHECK-NEXT: extractelement <2 x double> %{{.*}}, i64 0 3517 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 3518 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 3519 // CHECK-NEXT: select i1 %{{.*}}, double %{{.*}}, double %{{.*}} 3520 // CHECK-NEXT: insertelement <2 x double> %{{.*}}, double %{{.*}}, i64 0 3521 return _mm_maskz_mul_sd(__U,__A,__B); 3522 } 3523 __m512d test_mm512_div_round_pd(__m512d __A, __m512d __B) { 3524 // CHECK-LABEL: test_mm512_div_round_pd 3525 // CHECK: @llvm.x86.avx512.div.pd.512 3526 return _mm512_div_round_pd(__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3527 } 3528 __m512d test_mm512_mask_div_round_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 3529 // CHECK-LABEL: test_mm512_mask_div_round_pd 3530 // CHECK: @llvm.x86.avx512.div.pd.512 3531 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 3532 return _mm512_mask_div_round_pd(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3533 } 3534 __m512d test_mm512_maskz_div_round_pd(__mmask8 __U, __m512d __A, __m512d __B) { 3535 // CHECK-LABEL: test_mm512_maskz_div_round_pd 3536 // CHECK: @llvm.x86.avx512.div.pd.512 3537 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 3538 return _mm512_maskz_div_round_pd(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3539 } 3540 __m512d test_mm512_div_pd(__m512d __a, __m512d __b) { 3541 // CHECK-LABEL: test_mm512_div_pd 3542 // CHECK: fdiv <8 x double> 3543 return _mm512_div_pd(__a,__b); 3544 } 3545 __m512d test_mm512_mask_div_pd(__m512d __w, __mmask8 __u, __m512d __a, __m512d __b) { 3546 // CHECK-LABEL: test_mm512_mask_div_pd 3547 // CHECK: fdiv <8 x double> %{{.*}}, %{{.*}} 3548 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 3549 return _mm512_mask_div_pd(__w,__u,__a,__b); 3550 } 3551 __m512d test_mm512_maskz_div_pd(__mmask8 __U, __m512d __A, __m512d __B) { 3552 // CHECK-LABEL: test_mm512_maskz_div_pd 3553 // CHECK: fdiv <8 x double> %{{.*}}, %{{.*}} 3554 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 3555 return _mm512_maskz_div_pd(__U,__A,__B); 3556 } 3557 __m512 test_mm512_div_round_ps(__m512 __A, __m512 __B) { 3558 // CHECK-LABEL: test_mm512_div_round_ps 3559 // CHECK: @llvm.x86.avx512.div.ps.512 3560 return _mm512_div_round_ps(__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3561 } 3562 __m512 test_mm512_mask_div_round_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 3563 // CHECK-LABEL: test_mm512_mask_div_round_ps 3564 // CHECK: @llvm.x86.avx512.div.ps.512 3565 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 3566 return _mm512_mask_div_round_ps(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3567 } 3568 __m512 test_mm512_maskz_div_round_ps(__mmask16 __U, __m512 __A, __m512 __B) { 3569 // CHECK-LABEL: test_mm512_maskz_div_round_ps 3570 // CHECK: @llvm.x86.avx512.div.ps.512 3571 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 3572 return _mm512_maskz_div_round_ps(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3573 } 3574 __m512 test_mm512_div_ps(__m512 __A, __m512 __B) { 3575 // CHECK-LABEL: test_mm512_div_ps 3576 // CHECK: fdiv <16 x float> 3577 return _mm512_div_ps(__A,__B); 3578 } 3579 __m512 test_mm512_mask_div_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 3580 // CHECK-LABEL: test_mm512_mask_div_ps 3581 // CHECK: fdiv <16 x float> %{{.*}}, %{{.*}} 3582 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 3583 return _mm512_mask_div_ps(__W,__U,__A,__B); 3584 } 3585 __m512 test_mm512_maskz_div_ps(__mmask16 __U, __m512 __A, __m512 __B) { 3586 // CHECK-LABEL: test_mm512_maskz_div_ps 3587 // CHECK: fdiv <16 x float> %{{.*}}, %{{.*}} 3588 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 3589 return _mm512_maskz_div_ps(__U,__A,__B); 3590 } 3591 __m128 test_mm_div_round_ss(__m128 __A, __m128 __B) { 3592 // CHECK-LABEL: test_mm_div_round_ss 3593 // CHECK: @llvm.x86.avx512.mask.div.ss.round 3594 return _mm_div_round_ss(__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3595 } 3596 __m128 test_mm_mask_div_round_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { 3597 // CHECK-LABEL: test_mm_mask_div_round_ss 3598 // CHECK: @llvm.x86.avx512.mask.div.ss.round 3599 return _mm_mask_div_round_ss(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3600 } 3601 __m128 test_mm_maskz_div_round_ss(__mmask8 __U, __m128 __A, __m128 __B) { 3602 // CHECK-LABEL: test_mm_maskz_div_round_ss 3603 // CHECK: @llvm.x86.avx512.mask.div.ss.round 3604 return _mm_maskz_div_round_ss(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3605 } 3606 __m128 test_mm_mask_div_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { 3607 // CHECK-LABEL: test_mm_mask_div_ss 3608 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 3609 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 3610 // CHECK: fdiv float %{{.*}}, %{{.*}} 3611 // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 0 3612 // CHECK: extractelement <4 x float> %{{.*}}, i64 0 3613 // CHECK-NEXT: extractelement <4 x float> %{{.*}}, i64 0 3614 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 3615 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 3616 // CHECK-NEXT: select i1 %{{.*}}, float %{{.*}}, float %{{.*}} 3617 // CHECK-NEXT: insertelement <4 x float> %{{.*}}, float %{{.*}}, i64 0 3618 return _mm_mask_div_ss(__W,__U,__A,__B); 3619 } 3620 __m128 test_mm_maskz_div_ss(__mmask8 __U, __m128 __A, __m128 __B) { 3621 // CHECK-LABEL: test_mm_maskz_div_ss 3622 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 3623 // CHECK: extractelement <4 x float> %{{.*}}, i32 0 3624 // CHECK: fdiv float %{{.*}}, %{{.*}} 3625 // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 0 3626 // CHECK: extractelement <4 x float> %{{.*}}, i64 0 3627 // CHECK-NEXT: extractelement <4 x float> %{{.*}}, i64 0 3628 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 3629 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 3630 // CHECK-NEXT: select i1 %{{.*}}, float %{{.*}}, float %{{.*}} 3631 // CHECK-NEXT: insertelement <4 x float> %{{.*}}, float %{{.*}}, i64 0 3632 return _mm_maskz_div_ss(__U,__A,__B); 3633 } 3634 __m128d test_mm_div_round_sd(__m128d __A, __m128d __B) { 3635 // CHECK-LABEL: test_mm_div_round_sd 3636 // CHECK: @llvm.x86.avx512.mask.div.sd.round 3637 return _mm_div_round_sd(__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3638 } 3639 __m128d test_mm_mask_div_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { 3640 // CHECK-LABEL: test_mm_mask_div_round_sd 3641 // CHECK: @llvm.x86.avx512.mask.div.sd.round 3642 return _mm_mask_div_round_sd(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3643 } 3644 __m128d test_mm_maskz_div_round_sd(__mmask8 __U, __m128d __A, __m128d __B) { 3645 // CHECK-LABEL: test_mm_maskz_div_round_sd 3646 // CHECK: @llvm.x86.avx512.mask.div.sd.round 3647 return _mm_maskz_div_round_sd(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 3648 } 3649 __m128d test_mm_mask_div_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { 3650 // CHECK-LABEL: test_mm_mask_div_sd 3651 // CHECK: extractelement <2 x double> %{{.*}}, i32 0 3652 // CHECK: extractelement <2 x double> %{{.*}}, i32 0 3653 // CHECK: fdiv double %{{.*}}, %{{.*}} 3654 // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0 3655 // CHECK: extractelement <2 x double> %{{.*}}, i64 0 3656 // CHECK-NEXT: extractelement <2 x double> %{{.*}}, i64 0 3657 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 3658 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 3659 // CHECK-NEXT: select i1 %{{.*}}, double %{{.*}}, double %{{.*}} 3660 // CHECK-NEXT: insertelement <2 x double> %{{.*}}, double %{{.*}}, i64 0 3661 return _mm_mask_div_sd(__W,__U,__A,__B); 3662 } 3663 __m128d test_mm_maskz_div_sd(__mmask8 __U, __m128d __A, __m128d __B) { 3664 // CHECK-LABEL: test_mm_maskz_div_sd 3665 // CHECK: extractelement <2 x double> %{{.*}}, i32 0 3666 // CHECK: extractelement <2 x double> %{{.*}}, i32 0 3667 // CHECK: fdiv double %{{.*}}, %{{.*}} 3668 // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0 3669 // CHECK: extractelement <2 x double> %{{.*}}, i64 0 3670 // CHECK-NEXT: extractelement <2 x double> %{{.*}}, i64 0 3671 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 3672 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 3673 // CHECK-NEXT: select i1 %{{.*}}, double %{{.*}}, double %{{.*}} 3674 // CHECK-NEXT: insertelement <2 x double> %{{.*}}, double %{{.*}}, i64 0 3675 return _mm_maskz_div_sd(__U,__A,__B); 3676 } 3677 __m128 test_mm_max_round_ss(__m128 __A, __m128 __B) { 3678 // CHECK-LABEL: test_mm_max_round_ss 3679 // CHECK: @llvm.x86.avx512.mask.max.ss.round 3680 return _mm_max_round_ss(__A,__B,0x08); 3681 } 3682 __m128 test_mm_mask_max_round_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { 3683 // CHECK-LABEL: test_mm_mask_max_round_ss 3684 // CHECK: @llvm.x86.avx512.mask.max.ss.round 3685 return _mm_mask_max_round_ss(__W,__U,__A,__B,0x08); 3686 } 3687 __m128 test_mm_maskz_max_round_ss(__mmask8 __U, __m128 __A, __m128 __B) { 3688 // CHECK-LABEL: test_mm_maskz_max_round_ss 3689 // CHECK: @llvm.x86.avx512.mask.max.ss.round 3690 return _mm_maskz_max_round_ss(__U,__A,__B,0x08); 3691 } 3692 __m128 test_mm_mask_max_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { 3693 // CHECK-LABEL: test_mm_mask_max_ss 3694 // CHECK: @llvm.x86.avx512.mask.max.ss.round 3695 return _mm_mask_max_ss(__W,__U,__A,__B); 3696 } 3697 __m128 test_mm_maskz_max_ss(__mmask8 __U, __m128 __A, __m128 __B) { 3698 // CHECK-LABEL: test_mm_maskz_max_ss 3699 // CHECK: @llvm.x86.avx512.mask.max.ss.round 3700 return _mm_maskz_max_ss(__U,__A,__B); 3701 } 3702 __m128d test_mm_max_round_sd(__m128d __A, __m128d __B) { 3703 // CHECK-LABEL: test_mm_max_round_sd 3704 // CHECK: @llvm.x86.avx512.mask.max.sd.round 3705 return _mm_max_round_sd(__A,__B,0x08); 3706 } 3707 __m128d test_mm_mask_max_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { 3708 // CHECK-LABEL: test_mm_mask_max_round_sd 3709 // CHECK: @llvm.x86.avx512.mask.max.sd.round 3710 return _mm_mask_max_round_sd(__W,__U,__A,__B,0x08); 3711 } 3712 __m128d test_mm_maskz_max_round_sd(__mmask8 __U, __m128d __A, __m128d __B) { 3713 // CHECK-LABEL: test_mm_maskz_max_round_sd 3714 // CHECK: @llvm.x86.avx512.mask.max.sd.round 3715 return _mm_maskz_max_round_sd(__U,__A,__B,0x08); 3716 } 3717 __m128d test_mm_mask_max_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { 3718 // CHECK-LABEL: test_mm_mask_max_sd 3719 // CHECK: @llvm.x86.avx512.mask.max.sd.round 3720 return _mm_mask_max_sd(__W,__U,__A,__B); 3721 } 3722 __m128d test_mm_maskz_max_sd(__mmask8 __U, __m128d __A, __m128d __B) { 3723 // CHECK-LABEL: test_mm_maskz_max_sd 3724 // CHECK: @llvm.x86.avx512.mask.max.sd.round 3725 return _mm_maskz_max_sd(__U,__A,__B); 3726 } 3727 __m128 test_mm_min_round_ss(__m128 __A, __m128 __B) { 3728 // CHECK-LABEL: test_mm_min_round_ss 3729 // CHECK: @llvm.x86.avx512.mask.min.ss.round 3730 return _mm_min_round_ss(__A,__B,0x08); 3731 } 3732 __m128 test_mm_mask_min_round_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { 3733 // CHECK-LABEL: test_mm_mask_min_round_ss 3734 // CHECK: @llvm.x86.avx512.mask.min.ss.round 3735 return _mm_mask_min_round_ss(__W,__U,__A,__B,0x08); 3736 } 3737 __m128 test_mm_maskz_min_round_ss(__mmask8 __U, __m128 __A, __m128 __B) { 3738 // CHECK-LABEL: test_mm_maskz_min_round_ss 3739 // CHECK: @llvm.x86.avx512.mask.min.ss.round 3740 return _mm_maskz_min_round_ss(__U,__A,__B,0x08); 3741 } 3742 __m128 test_mm_mask_min_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) { 3743 // CHECK-LABEL: test_mm_mask_min_ss 3744 // CHECK: @llvm.x86.avx512.mask.min.ss.round 3745 return _mm_mask_min_ss(__W,__U,__A,__B); 3746 } 3747 __m128 test_mm_maskz_min_ss(__mmask8 __U, __m128 __A, __m128 __B) { 3748 // CHECK-LABEL: test_mm_maskz_min_ss 3749 // CHECK: @llvm.x86.avx512.mask.min.ss.round 3750 return _mm_maskz_min_ss(__U,__A,__B); 3751 } 3752 __m128d test_mm_min_round_sd(__m128d __A, __m128d __B) { 3753 // CHECK-LABEL: test_mm_min_round_sd 3754 // CHECK: @llvm.x86.avx512.mask.min.sd.round 3755 return _mm_min_round_sd(__A,__B,0x08); 3756 } 3757 __m128d test_mm_mask_min_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { 3758 // CHECK-LABEL: test_mm_mask_min_round_sd 3759 // CHECK: @llvm.x86.avx512.mask.min.sd.round 3760 return _mm_mask_min_round_sd(__W,__U,__A,__B,0x08); 3761 } 3762 __m128d test_mm_maskz_min_round_sd(__mmask8 __U, __m128d __A, __m128d __B) { 3763 // CHECK-LABEL: test_mm_maskz_min_round_sd 3764 // CHECK: @llvm.x86.avx512.mask.min.sd.round 3765 return _mm_maskz_min_round_sd(__U,__A,__B,0x08); 3766 } 3767 __m128d test_mm_mask_min_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) { 3768 // CHECK-LABEL: test_mm_mask_min_sd 3769 // CHECK: @llvm.x86.avx512.mask.min.sd.round 3770 return _mm_mask_min_sd(__W,__U,__A,__B); 3771 } 3772 __m128d test_mm_maskz_min_sd(__mmask8 __U, __m128d __A, __m128d __B) { 3773 // CHECK-LABEL: test_mm_maskz_min_sd 3774 // CHECK: @llvm.x86.avx512.mask.min.sd.round 3775 return _mm_maskz_min_sd(__U,__A,__B); 3776 } 3777 3778 __m512 test_mm512_undefined(void) { 3779 // CHECK-LABEL: test_mm512_undefined 3780 // CHECK: ret <16 x float> zeroinitializer 3781 return _mm512_undefined(); 3782 } 3783 3784 __m512 test_mm512_undefined_ps(void) { 3785 // CHECK-LABEL: test_mm512_undefined_ps 3786 // CHECK: ret <16 x float> zeroinitializer 3787 return _mm512_undefined_ps(); 3788 } 3789 3790 __m512d test_mm512_undefined_pd(void) { 3791 // CHECK-LABEL: test_mm512_undefined_pd 3792 // CHECK: ret <8 x double> zeroinitializer 3793 return _mm512_undefined_pd(); 3794 } 3795 3796 __m512i test_mm512_undefined_epi32(void) { 3797 // CHECK-LABEL: test_mm512_undefined_epi32 3798 // CHECK: ret <8 x i64> zeroinitializer 3799 return _mm512_undefined_epi32(); 3800 } 3801 3802 __m512i test_mm512_cvtepi8_epi32(__m128i __A) { 3803 // CHECK-LABEL: test_mm512_cvtepi8_epi32 3804 // CHECK: sext <16 x i8> %{{.*}} to <16 x i32> 3805 return _mm512_cvtepi8_epi32(__A); 3806 } 3807 3808 __m512i test_mm512_mask_cvtepi8_epi32(__m512i __W, __mmask16 __U, __m128i __A) { 3809 // CHECK-LABEL: test_mm512_mask_cvtepi8_epi32 3810 // CHECK: sext <16 x i8> %{{.*}} to <16 x i32> 3811 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 3812 return _mm512_mask_cvtepi8_epi32(__W, __U, __A); 3813 } 3814 3815 __m512i test_mm512_maskz_cvtepi8_epi32(__mmask16 __U, __m128i __A) { 3816 // CHECK-LABEL: test_mm512_maskz_cvtepi8_epi32 3817 // CHECK: sext <16 x i8> %{{.*}} to <16 x i32> 3818 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 3819 return _mm512_maskz_cvtepi8_epi32(__U, __A); 3820 } 3821 3822 __m512i test_mm512_cvtepi8_epi64(__m128i __A) { 3823 // CHECK-LABEL: test_mm512_cvtepi8_epi64 3824 // CHECK: sext <8 x i8> %{{.*}} to <8 x i64> 3825 return _mm512_cvtepi8_epi64(__A); 3826 } 3827 3828 __m512i test_mm512_mask_cvtepi8_epi64(__m512i __W, __mmask8 __U, __m128i __A) { 3829 // CHECK-LABEL: test_mm512_mask_cvtepi8_epi64 3830 // CHECK: sext <8 x i8> %{{.*}} to <8 x i64> 3831 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3832 return _mm512_mask_cvtepi8_epi64(__W, __U, __A); 3833 } 3834 3835 __m512i test_mm512_maskz_cvtepi8_epi64(__mmask8 __U, __m128i __A) { 3836 // CHECK-LABEL: test_mm512_maskz_cvtepi8_epi64 3837 // CHECK: sext <8 x i8> %{{.*}} to <8 x i64> 3838 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3839 return _mm512_maskz_cvtepi8_epi64(__U, __A); 3840 } 3841 3842 __m512i test_mm512_cvtepi32_epi64(__m256i __X) { 3843 // CHECK-LABEL: test_mm512_cvtepi32_epi64 3844 // CHECK: sext <8 x i32> %{{.*}} to <8 x i64> 3845 return _mm512_cvtepi32_epi64(__X); 3846 } 3847 3848 __m512i test_mm512_mask_cvtepi32_epi64(__m512i __W, __mmask8 __U, __m256i __X) { 3849 // CHECK-LABEL: test_mm512_mask_cvtepi32_epi64 3850 // CHECK: sext <8 x i32> %{{.*}} to <8 x i64> 3851 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3852 return _mm512_mask_cvtepi32_epi64(__W, __U, __X); 3853 } 3854 3855 __m512i test_mm512_maskz_cvtepi32_epi64(__mmask8 __U, __m256i __X) { 3856 // CHECK-LABEL: test_mm512_maskz_cvtepi32_epi64 3857 // CHECK: sext <8 x i32> %{{.*}} to <8 x i64> 3858 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3859 return _mm512_maskz_cvtepi32_epi64(__U, __X); 3860 } 3861 3862 __m512i test_mm512_cvtepi16_epi32(__m256i __A) { 3863 // CHECK-LABEL: test_mm512_cvtepi16_epi32 3864 // CHECK: sext <16 x i16> %{{.*}} to <16 x i32> 3865 return _mm512_cvtepi16_epi32(__A); 3866 } 3867 3868 __m512i test_mm512_mask_cvtepi16_epi32(__m512i __W, __mmask16 __U, __m256i __A) { 3869 // CHECK-LABEL: test_mm512_mask_cvtepi16_epi32 3870 // CHECK: sext <16 x i16> %{{.*}} to <16 x i32> 3871 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 3872 return _mm512_mask_cvtepi16_epi32(__W, __U, __A); 3873 } 3874 3875 __m512i test_mm512_maskz_cvtepi16_epi32(__mmask16 __U, __m256i __A) { 3876 // CHECK-LABEL: test_mm512_maskz_cvtepi16_epi32 3877 // CHECK: sext <16 x i16> %{{.*}} to <16 x i32> 3878 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 3879 return _mm512_maskz_cvtepi16_epi32(__U, __A); 3880 } 3881 3882 __m512i test_mm512_cvtepi16_epi64(__m128i __A) { 3883 // CHECK-LABEL: test_mm512_cvtepi16_epi64 3884 // CHECK: sext <8 x i16> %{{.*}} to <8 x i64> 3885 return _mm512_cvtepi16_epi64(__A); 3886 } 3887 3888 __m512i test_mm512_mask_cvtepi16_epi64(__m512i __W, __mmask8 __U, __m128i __A) { 3889 // CHECK-LABEL: test_mm512_mask_cvtepi16_epi64 3890 // CHECK: sext <8 x i16> %{{.*}} to <8 x i64> 3891 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3892 return _mm512_mask_cvtepi16_epi64(__W, __U, __A); 3893 } 3894 3895 __m512i test_mm512_maskz_cvtepi16_epi64(__mmask8 __U, __m128i __A) { 3896 // CHECK-LABEL: test_mm512_maskz_cvtepi16_epi64 3897 // CHECK: sext <8 x i16> %{{.*}} to <8 x i64> 3898 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3899 return _mm512_maskz_cvtepi16_epi64(__U, __A); 3900 } 3901 3902 __m512i test_mm512_cvtepu8_epi32(__m128i __A) { 3903 // CHECK-LABEL: test_mm512_cvtepu8_epi32 3904 // CHECK: zext <16 x i8> %{{.*}} to <16 x i32> 3905 return _mm512_cvtepu8_epi32(__A); 3906 } 3907 3908 __m512i test_mm512_mask_cvtepu8_epi32(__m512i __W, __mmask16 __U, __m128i __A) { 3909 // CHECK-LABEL: test_mm512_mask_cvtepu8_epi32 3910 // CHECK: zext <16 x i8> %{{.*}} to <16 x i32> 3911 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 3912 return _mm512_mask_cvtepu8_epi32(__W, __U, __A); 3913 } 3914 3915 __m512i test_mm512_maskz_cvtepu8_epi32(__mmask16 __U, __m128i __A) { 3916 // CHECK-LABEL: test_mm512_maskz_cvtepu8_epi32 3917 // CHECK: zext <16 x i8> %{{.*}} to <16 x i32> 3918 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 3919 return _mm512_maskz_cvtepu8_epi32(__U, __A); 3920 } 3921 3922 __m512i test_mm512_cvtepu8_epi64(__m128i __A) { 3923 // CHECK-LABEL: test_mm512_cvtepu8_epi64 3924 // CHECK: zext <8 x i8> %{{.*}} to <8 x i64> 3925 return _mm512_cvtepu8_epi64(__A); 3926 } 3927 3928 __m512i test_mm512_mask_cvtepu8_epi64(__m512i __W, __mmask8 __U, __m128i __A) { 3929 // CHECK-LABEL: test_mm512_mask_cvtepu8_epi64 3930 // CHECK: zext <8 x i8> %{{.*}} to <8 x i64> 3931 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3932 return _mm512_mask_cvtepu8_epi64(__W, __U, __A); 3933 } 3934 3935 __m512i test_mm512_maskz_cvtepu8_epi64(__mmask8 __U, __m128i __A) { 3936 // CHECK-LABEL: test_mm512_maskz_cvtepu8_epi64 3937 // CHECK: zext <8 x i8> %{{.*}} to <8 x i64> 3938 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3939 return _mm512_maskz_cvtepu8_epi64(__U, __A); 3940 } 3941 3942 __m512i test_mm512_cvtepu32_epi64(__m256i __X) { 3943 // CHECK-LABEL: test_mm512_cvtepu32_epi64 3944 // CHECK: zext <8 x i32> %{{.*}} to <8 x i64> 3945 return _mm512_cvtepu32_epi64(__X); 3946 } 3947 3948 __m512i test_mm512_mask_cvtepu32_epi64(__m512i __W, __mmask8 __U, __m256i __X) { 3949 // CHECK-LABEL: test_mm512_mask_cvtepu32_epi64 3950 // CHECK: zext <8 x i32> %{{.*}} to <8 x i64> 3951 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3952 return _mm512_mask_cvtepu32_epi64(__W, __U, __X); 3953 } 3954 3955 __m512i test_mm512_maskz_cvtepu32_epi64(__mmask8 __U, __m256i __X) { 3956 // CHECK-LABEL: test_mm512_maskz_cvtepu32_epi64 3957 // CHECK: zext <8 x i32> %{{.*}} to <8 x i64> 3958 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3959 return _mm512_maskz_cvtepu32_epi64(__U, __X); 3960 } 3961 3962 __m512i test_mm512_cvtepu16_epi32(__m256i __A) { 3963 // CHECK-LABEL: test_mm512_cvtepu16_epi32 3964 // CHECK: zext <16 x i16> %{{.*}} to <16 x i32> 3965 return _mm512_cvtepu16_epi32(__A); 3966 } 3967 3968 __m512i test_mm512_mask_cvtepu16_epi32(__m512i __W, __mmask16 __U, __m256i __A) { 3969 // CHECK-LABEL: test_mm512_mask_cvtepu16_epi32 3970 // CHECK: zext <16 x i16> %{{.*}} to <16 x i32> 3971 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 3972 return _mm512_mask_cvtepu16_epi32(__W, __U, __A); 3973 } 3974 3975 __m512i test_mm512_maskz_cvtepu16_epi32(__mmask16 __U, __m256i __A) { 3976 // CHECK-LABEL: test_mm512_maskz_cvtepu16_epi32 3977 // CHECK: zext <16 x i16> %{{.*}} to <16 x i32> 3978 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 3979 return _mm512_maskz_cvtepu16_epi32(__U, __A); 3980 } 3981 3982 __m512i test_mm512_cvtepu16_epi64(__m128i __A) { 3983 // CHECK-LABEL: test_mm512_cvtepu16_epi64 3984 // CHECK: zext <8 x i16> %{{.*}} to <8 x i64> 3985 return _mm512_cvtepu16_epi64(__A); 3986 } 3987 3988 __m512i test_mm512_mask_cvtepu16_epi64(__m512i __W, __mmask8 __U, __m128i __A) { 3989 // CHECK-LABEL: test_mm512_mask_cvtepu16_epi64 3990 // CHECK: zext <8 x i16> %{{.*}} to <8 x i64> 3991 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3992 return _mm512_mask_cvtepu16_epi64(__W, __U, __A); 3993 } 3994 3995 __m512i test_mm512_maskz_cvtepu16_epi64(__mmask8 __U, __m128i __A) { 3996 // CHECK-LABEL: test_mm512_maskz_cvtepu16_epi64 3997 // CHECK: zext <8 x i16> %{{.*}} to <8 x i64> 3998 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 3999 return _mm512_maskz_cvtepu16_epi64(__U, __A); 4000 } 4001 4002 4003 __m512i test_mm512_rol_epi32(__m512i __A) { 4004 // CHECK-LABEL: test_mm512_rol_epi32 4005 // CHECK: @llvm.fshl.v16i32 4006 return _mm512_rol_epi32(__A, 5); 4007 } 4008 4009 __m512i test_mm512_mask_rol_epi32(__m512i __W, __mmask16 __U, __m512i __A) { 4010 // CHECK-LABEL: test_mm512_mask_rol_epi32 4011 // CHECK: @llvm.fshl.v16i32 4012 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4013 return _mm512_mask_rol_epi32(__W, __U, __A, 5); 4014 } 4015 4016 __m512i test_mm512_maskz_rol_epi32(__mmask16 __U, __m512i __A) { 4017 // CHECK-LABEL: test_mm512_maskz_rol_epi32 4018 // CHECK: @llvm.fshl.v16i32 4019 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4020 return _mm512_maskz_rol_epi32(__U, __A, 5); 4021 } 4022 4023 __m512i test_mm512_rol_epi64(__m512i __A) { 4024 // CHECK-LABEL: test_mm512_rol_epi64 4025 // CHECK: @llvm.fshl.v8i64 4026 return _mm512_rol_epi64(__A, 5); 4027 } 4028 4029 __m512i test_mm512_mask_rol_epi64(__m512i __W, __mmask8 __U, __m512i __A) { 4030 // CHECK-LABEL: test_mm512_mask_rol_epi64 4031 // CHECK: @llvm.fshl.v8i64 4032 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4033 return _mm512_mask_rol_epi64(__W, __U, __A, 5); 4034 } 4035 4036 __m512i test_mm512_maskz_rol_epi64(__mmask8 __U, __m512i __A) { 4037 // CHECK-LABEL: test_mm512_maskz_rol_epi64 4038 // CHECK: @llvm.fshl.v8i64 4039 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4040 return _mm512_maskz_rol_epi64(__U, __A, 5); 4041 } 4042 4043 __m512i test_mm512_rolv_epi32(__m512i __A, __m512i __B) { 4044 // CHECK-LABEL: test_mm512_rolv_epi32 4045 // CHECK: @llvm.fshl.v16i32 4046 return _mm512_rolv_epi32(__A, __B); 4047 } 4048 4049 __m512i test_mm512_mask_rolv_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) { 4050 // CHECK-LABEL: test_mm512_mask_rolv_epi32 4051 // CHECK: @llvm.fshl.v16i32 4052 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4053 return _mm512_mask_rolv_epi32(__W, __U, __A, __B); 4054 } 4055 4056 __m512i test_mm512_maskz_rolv_epi32(__mmask16 __U, __m512i __A, __m512i __B) { 4057 // CHECK-LABEL: test_mm512_maskz_rolv_epi32 4058 // CHECK: @llvm.fshl.v16i32 4059 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4060 return _mm512_maskz_rolv_epi32(__U, __A, __B); 4061 } 4062 4063 __m512i test_mm512_rolv_epi64(__m512i __A, __m512i __B) { 4064 // CHECK-LABEL: test_mm512_rolv_epi64 4065 // CHECK: @llvm.fshl.v8i64 4066 return _mm512_rolv_epi64(__A, __B); 4067 } 4068 4069 __m512i test_mm512_mask_rolv_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) { 4070 // CHECK-LABEL: test_mm512_mask_rolv_epi64 4071 // CHECK: @llvm.fshl.v8i64 4072 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4073 return _mm512_mask_rolv_epi64(__W, __U, __A, __B); 4074 } 4075 4076 __m512i test_mm512_maskz_rolv_epi64(__mmask8 __U, __m512i __A, __m512i __B) { 4077 // CHECK-LABEL: test_mm512_maskz_rolv_epi64 4078 // CHECK: @llvm.fshl.v8i64 4079 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4080 return _mm512_maskz_rolv_epi64(__U, __A, __B); 4081 } 4082 4083 __m512i test_mm512_ror_epi32(__m512i __A) { 4084 // CHECK-LABEL: test_mm512_ror_epi32 4085 // CHECK: @llvm.fshr.v16i32 4086 return _mm512_ror_epi32(__A, 5); 4087 } 4088 4089 __m512i test_mm512_mask_ror_epi32(__m512i __W, __mmask16 __U, __m512i __A) { 4090 // CHECK-LABEL: test_mm512_mask_ror_epi32 4091 // CHECK: @llvm.fshr.v16i32 4092 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4093 return _mm512_mask_ror_epi32(__W, __U, __A, 5); 4094 } 4095 4096 __m512i test_mm512_maskz_ror_epi32(__mmask16 __U, __m512i __A) { 4097 // CHECK-LABEL: test_mm512_maskz_ror_epi32 4098 // CHECK: @llvm.fshr.v16i32 4099 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4100 return _mm512_maskz_ror_epi32(__U, __A, 5); 4101 } 4102 4103 __m512i test_mm512_ror_epi64(__m512i __A) { 4104 // CHECK-LABEL: test_mm512_ror_epi64 4105 // CHECK: @llvm.fshr.v8i64 4106 return _mm512_ror_epi64(__A, 5); 4107 } 4108 4109 __m512i test_mm512_mask_ror_epi64(__m512i __W, __mmask8 __U, __m512i __A) { 4110 // CHECK-LABEL: test_mm512_mask_ror_epi64 4111 // CHECK: @llvm.fshr.v8i64 4112 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4113 return _mm512_mask_ror_epi64(__W, __U, __A, 5); 4114 } 4115 4116 __m512i test_mm512_maskz_ror_epi64(__mmask8 __U, __m512i __A) { 4117 // CHECK-LABEL: test_mm512_maskz_ror_epi64 4118 // CHECK: @llvm.fshr.v8i64 4119 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4120 return _mm512_maskz_ror_epi64(__U, __A, 5); 4121 } 4122 4123 4124 __m512i test_mm512_rorv_epi32(__m512i __A, __m512i __B) { 4125 // CHECK-LABEL: test_mm512_rorv_epi32 4126 // CHECK: @llvm.fshr.v16i32 4127 return _mm512_rorv_epi32(__A, __B); 4128 } 4129 4130 __m512i test_mm512_mask_rorv_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) { 4131 // CHECK-LABEL: test_mm512_mask_rorv_epi32 4132 // CHECK: @llvm.fshr.v16i32 4133 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4134 return _mm512_mask_rorv_epi32(__W, __U, __A, __B); 4135 } 4136 4137 __m512i test_mm512_maskz_rorv_epi32(__mmask16 __U, __m512i __A, __m512i __B) { 4138 // CHECK-LABEL: test_mm512_maskz_rorv_epi32 4139 // CHECK: @llvm.fshr.v16i32 4140 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4141 return _mm512_maskz_rorv_epi32(__U, __A, __B); 4142 } 4143 4144 __m512i test_mm512_rorv_epi64(__m512i __A, __m512i __B) { 4145 // CHECK-LABEL: test_mm512_rorv_epi64 4146 // CHECK: @llvm.fshr.v8i64 4147 return _mm512_rorv_epi64(__A, __B); 4148 } 4149 4150 __m512i test_mm512_mask_rorv_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) { 4151 // CHECK-LABEL: test_mm512_mask_rorv_epi64 4152 // CHECK: @llvm.fshr.v8i64 4153 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4154 return _mm512_mask_rorv_epi64(__W, __U, __A, __B); 4155 } 4156 4157 __m512i test_mm512_maskz_rorv_epi64(__mmask8 __U, __m512i __A, __m512i __B) { 4158 // CHECK-LABEL: test_mm512_maskz_rorv_epi64 4159 // CHECK: @llvm.fshr.v8i64 4160 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4161 return _mm512_maskz_rorv_epi64(__U, __A, __B); 4162 } 4163 4164 __m512i test_mm512_slli_epi32(__m512i __A) { 4165 // CHECK-LABEL: test_mm512_slli_epi32 4166 // CHECK: @llvm.x86.avx512.pslli.d.512 4167 return _mm512_slli_epi32(__A, 5); 4168 } 4169 4170 __m512i test_mm512_slli_epi32_2(__m512i __A, unsigned int __B) { 4171 // CHECK-LABEL: test_mm512_slli_epi32_2 4172 // CHECK: @llvm.x86.avx512.pslli.d.512 4173 return _mm512_slli_epi32(__A, __B); 4174 } 4175 4176 __m512i test_mm512_mask_slli_epi32(__m512i __W, __mmask16 __U, __m512i __A) { 4177 // CHECK-LABEL: test_mm512_mask_slli_epi32 4178 // CHECK: @llvm.x86.avx512.pslli.d.512 4179 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4180 return _mm512_mask_slli_epi32(__W, __U, __A, 5); 4181 } 4182 4183 __m512i test_mm512_mask_slli_epi32_2(__m512i __W, __mmask16 __U, __m512i __A, unsigned int __B) { 4184 // CHECK-LABEL: test_mm512_mask_slli_epi32_2 4185 // CHECK: @llvm.x86.avx512.pslli.d.512 4186 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4187 return _mm512_mask_slli_epi32(__W, __U, __A, __B); 4188 } 4189 4190 __m512i test_mm512_maskz_slli_epi32(__mmask16 __U, __m512i __A) { 4191 // CHECK-LABEL: test_mm512_maskz_slli_epi32 4192 // CHECK: @llvm.x86.avx512.pslli.d.512 4193 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4194 return _mm512_maskz_slli_epi32(__U, __A, 5); 4195 } 4196 4197 __m512i test_mm512_maskz_slli_epi32_2(__mmask16 __U, __m512i __A, unsigned int __B) { 4198 // CHECK-LABEL: test_mm512_maskz_slli_epi32_2 4199 // CHECK: @llvm.x86.avx512.pslli.d.512 4200 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4201 return _mm512_maskz_slli_epi32(__U, __A, __B); 4202 } 4203 4204 __m512i test_mm512_slli_epi64(__m512i __A) { 4205 // CHECK-LABEL: test_mm512_slli_epi64 4206 // CHECK: @llvm.x86.avx512.pslli.q.512 4207 return _mm512_slli_epi64(__A, 5); 4208 } 4209 4210 __m512i test_mm512_slli_epi64_2(__m512i __A, unsigned int __B) { 4211 // CHECK-LABEL: test_mm512_slli_epi64_2 4212 // CHECK: @llvm.x86.avx512.pslli.q.512 4213 return _mm512_slli_epi64(__A, __B); 4214 } 4215 4216 __m512i test_mm512_mask_slli_epi64(__m512i __W, __mmask8 __U, __m512i __A) { 4217 // CHECK-LABEL: test_mm512_mask_slli_epi64 4218 // CHECK: @llvm.x86.avx512.pslli.q.512 4219 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4220 return _mm512_mask_slli_epi64(__W, __U, __A, 5); 4221 } 4222 4223 __m512i test_mm512_mask_slli_epi64_2(__m512i __W, __mmask8 __U, __m512i __A, unsigned int __B) { 4224 // CHECK-LABEL: test_mm512_mask_slli_epi64_2 4225 // CHECK: @llvm.x86.avx512.pslli.q.512 4226 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4227 return _mm512_mask_slli_epi64(__W, __U, __A, __B); 4228 } 4229 4230 __m512i test_mm512_maskz_slli_epi64(__mmask8 __U, __m512i __A) { 4231 // CHECK-LABEL: test_mm512_maskz_slli_epi64 4232 // CHECK: @llvm.x86.avx512.pslli.q.512 4233 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4234 return _mm512_maskz_slli_epi64(__U, __A, 5); 4235 } 4236 4237 __m512i test_mm512_maskz_slli_epi64_2(__mmask8 __U, __m512i __A, unsigned int __B) { 4238 // CHECK-LABEL: test_mm512_maskz_slli_epi64_2 4239 // CHECK: @llvm.x86.avx512.pslli.q.512 4240 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4241 return _mm512_maskz_slli_epi64(__U, __A, __B); 4242 } 4243 4244 __m512i test_mm512_srli_epi32(__m512i __A) { 4245 // CHECK-LABEL: test_mm512_srli_epi32 4246 // CHECK: @llvm.x86.avx512.psrli.d.512 4247 return _mm512_srli_epi32(__A, 5); 4248 } 4249 4250 __m512i test_mm512_srli_epi32_2(__m512i __A, unsigned int __B) { 4251 // CHECK-LABEL: test_mm512_srli_epi32_2 4252 // CHECK: @llvm.x86.avx512.psrli.d.512 4253 return _mm512_srli_epi32(__A, __B); 4254 } 4255 4256 __m512i test_mm512_mask_srli_epi32(__m512i __W, __mmask16 __U, __m512i __A) { 4257 // CHECK-LABEL: test_mm512_mask_srli_epi32 4258 // CHECK: @llvm.x86.avx512.psrli.d.512 4259 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4260 return _mm512_mask_srli_epi32(__W, __U, __A, 5); 4261 } 4262 4263 __m512i test_mm512_mask_srli_epi32_2(__m512i __W, __mmask16 __U, __m512i __A, unsigned int __B) { 4264 // CHECK-LABEL: test_mm512_mask_srli_epi32_2 4265 // CHECK: @llvm.x86.avx512.psrli.d.512 4266 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4267 return _mm512_mask_srli_epi32(__W, __U, __A, __B); 4268 } 4269 4270 __m512i test_mm512_maskz_srli_epi32(__mmask16 __U, __m512i __A) { 4271 // CHECK-LABEL: test_mm512_maskz_srli_epi32 4272 // CHECK: @llvm.x86.avx512.psrli.d.512 4273 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4274 return _mm512_maskz_srli_epi32(__U, __A, 5); 4275 } 4276 4277 __m512i test_mm512_maskz_srli_epi32_2(__mmask16 __U, __m512i __A, unsigned int __B) { 4278 // CHECK-LABEL: test_mm512_maskz_srli_epi32_2 4279 // CHECK: @llvm.x86.avx512.psrli.d.512 4280 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4281 return _mm512_maskz_srli_epi32(__U, __A, __B); 4282 } 4283 4284 __m512i test_mm512_srli_epi64(__m512i __A) { 4285 // CHECK-LABEL: test_mm512_srli_epi64 4286 // CHECK: @llvm.x86.avx512.psrli.q.512 4287 return _mm512_srli_epi64(__A, 5); 4288 } 4289 4290 __m512i test_mm512_srli_epi64_2(__m512i __A, unsigned int __B) { 4291 // CHECK-LABEL: test_mm512_srli_epi64_2 4292 // CHECK: @llvm.x86.avx512.psrli.q.512 4293 return _mm512_srli_epi64(__A, __B); 4294 } 4295 4296 __m512i test_mm512_mask_srli_epi64(__m512i __W, __mmask8 __U, __m512i __A) { 4297 // CHECK-LABEL: test_mm512_mask_srli_epi64 4298 // CHECK: @llvm.x86.avx512.psrli.q.512 4299 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4300 return _mm512_mask_srli_epi64(__W, __U, __A, 5); 4301 } 4302 4303 __m512i test_mm512_mask_srli_epi64_2(__m512i __W, __mmask8 __U, __m512i __A, unsigned int __B) { 4304 // CHECK-LABEL: test_mm512_mask_srli_epi64_2 4305 // CHECK: @llvm.x86.avx512.psrli.q.512 4306 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4307 return _mm512_mask_srli_epi64(__W, __U, __A, __B); 4308 } 4309 4310 __m512i test_mm512_maskz_srli_epi64(__mmask8 __U, __m512i __A) { 4311 // CHECK-LABEL: test_mm512_maskz_srli_epi64 4312 // CHECK: @llvm.x86.avx512.psrli.q.512 4313 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4314 return _mm512_maskz_srli_epi64(__U, __A, 5); 4315 } 4316 4317 __m512i test_mm512_maskz_srli_epi64_2(__mmask8 __U, __m512i __A, unsigned int __B) { 4318 // CHECK-LABEL: test_mm512_maskz_srli_epi64_2 4319 // CHECK: @llvm.x86.avx512.psrli.q.512 4320 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4321 return _mm512_maskz_srli_epi64(__U, __A, __B); 4322 } 4323 4324 __m512i test_mm512_mask_load_epi32(__m512i __W, __mmask16 __U, void const *__P) { 4325 // CHECK-LABEL: test_mm512_mask_load_epi32 4326 // CHECK: @llvm.masked.load.v16i32.p0(ptr %{{.*}}, i32 64, <16 x i1> %{{.*}}, <16 x i32> %{{.*}}) 4327 return _mm512_mask_load_epi32(__W, __U, __P); 4328 } 4329 4330 __m512i test_mm512_maskz_load_epi32(__mmask16 __U, void const *__P) { 4331 // CHECK-LABEL: test_mm512_maskz_load_epi32 4332 // CHECK: @llvm.masked.load.v16i32.p0(ptr %{{.*}}, i32 64, <16 x i1> %{{.*}}, <16 x i32> %{{.*}}) 4333 return _mm512_maskz_load_epi32(__U, __P); 4334 } 4335 4336 __m512i test_mm512_mask_mov_epi32(__m512i __W, __mmask16 __U, __m512i __A) { 4337 // CHECK-LABEL: test_mm512_mask_mov_epi32 4338 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4339 return _mm512_mask_mov_epi32(__W, __U, __A); 4340 } 4341 4342 __m512i test_mm512_maskz_mov_epi32(__mmask16 __U, __m512i __A) { 4343 // CHECK-LABEL: test_mm512_maskz_mov_epi32 4344 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4345 return _mm512_maskz_mov_epi32(__U, __A); 4346 } 4347 4348 __m512i test_mm512_mask_mov_epi64(__m512i __W, __mmask8 __U, __m512i __A) { 4349 // CHECK-LABEL: test_mm512_mask_mov_epi64 4350 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4351 return _mm512_mask_mov_epi64(__W, __U, __A); 4352 } 4353 4354 __m512i test_mm512_maskz_mov_epi64(__mmask8 __U, __m512i __A) { 4355 // CHECK-LABEL: test_mm512_maskz_mov_epi64 4356 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 4357 return _mm512_maskz_mov_epi64(__U, __A); 4358 } 4359 4360 __m512i test_mm512_mask_load_epi64(__m512i __W, __mmask8 __U, void const *__P) { 4361 // CHECK-LABEL: test_mm512_mask_load_epi64 4362 // CHECK: @llvm.masked.load.v8i64.p0(ptr %{{.*}}, i32 64, <8 x i1> %{{.*}}, <8 x i64> %{{.*}}) 4363 return _mm512_mask_load_epi64(__W, __U, __P); 4364 } 4365 4366 __m512i test_mm512_maskz_load_epi64(__mmask8 __U, void const *__P) { 4367 // CHECK-LABEL: test_mm512_maskz_load_epi64 4368 // CHECK: @llvm.masked.load.v8i64.p0(ptr %{{.*}}, i32 64, <8 x i1> %{{.*}}, <8 x i64> %{{.*}}) 4369 return _mm512_maskz_load_epi64(__U, __P); 4370 } 4371 4372 void test_mm512_mask_store_epi32(void *__P, __mmask16 __U, __m512i __A) { 4373 // CHECK-LABEL: test_mm512_mask_store_epi32 4374 // CHECK: @llvm.masked.store.v16i32.p0(<16 x i32> %{{.*}}, ptr %{{.*}}, i32 64, <16 x i1> %{{.*}}) 4375 return _mm512_mask_store_epi32(__P, __U, __A); 4376 } 4377 4378 void test_mm512_mask_store_epi64(void *__P, __mmask8 __U, __m512i __A) { 4379 // CHECK-LABEL: test_mm512_mask_store_epi64 4380 // CHECK: @llvm.masked.store.v8i64.p0(<8 x i64> %{{.*}}, ptr %{{.*}}, i32 64, <8 x i1> %{{.*}}) 4381 return _mm512_mask_store_epi64(__P, __U, __A); 4382 } 4383 4384 __m512d test_mm512_movedup_pd(__m512d __A) { 4385 // CHECK-LABEL: test_mm512_movedup_pd 4386 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 0, i32 2, i32 2, i32 4, i32 4, i32 6, i32 6> 4387 return _mm512_movedup_pd(__A); 4388 } 4389 4390 __m512d test_mm512_mask_movedup_pd(__m512d __W, __mmask8 __U, __m512d __A) { 4391 // CHECK-LABEL: test_mm512_mask_movedup_pd 4392 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 0, i32 2, i32 2, i32 4, i32 4, i32 6, i32 6> 4393 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 4394 return _mm512_mask_movedup_pd(__W, __U, __A); 4395 } 4396 4397 __m512d test_mm512_maskz_movedup_pd(__mmask8 __U, __m512d __A) { 4398 // CHECK-LABEL: test_mm512_maskz_movedup_pd 4399 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 0, i32 2, i32 2, i32 4, i32 4, i32 6, i32 6> 4400 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 4401 return _mm512_maskz_movedup_pd(__U, __A); 4402 } 4403 4404 int test_mm_comi_round_sd(__m128d __A, __m128d __B) { 4405 // CHECK-LABEL: test_mm_comi_round_sd 4406 // CHECK: @llvm.x86.avx512.vcomi.sd 4407 return _mm_comi_round_sd(__A, __B, 5, _MM_FROUND_NO_EXC); 4408 } 4409 4410 int test_mm_comi_round_ss(__m128 __A, __m128 __B) { 4411 // CHECK-LABEL: test_mm_comi_round_ss 4412 // CHECK: @llvm.x86.avx512.vcomi.ss 4413 return _mm_comi_round_ss(__A, __B, 5, _MM_FROUND_NO_EXC); 4414 } 4415 4416 __m512d test_mm512_fixupimm_round_pd(__m512d __A, __m512d __B, __m512i __C) { 4417 // CHECK-LABEL: test_mm512_fixupimm_round_pd 4418 // CHECK: @llvm.x86.avx512.mask.fixupimm.pd.512 4419 return _mm512_fixupimm_round_pd(__A, __B, __C, 5, 8); 4420 } 4421 4422 __m512d test_mm512_mask_fixupimm_round_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512i __C) { 4423 // CHECK-LABEL: test_mm512_mask_fixupimm_round_pd 4424 // CHECK: @llvm.x86.avx512.mask.fixupimm.pd.512 4425 return _mm512_mask_fixupimm_round_pd(__A, __U, __B, __C, 5, 8); 4426 } 4427 4428 __m512d test_mm512_fixupimm_pd(__m512d __A, __m512d __B, __m512i __C) { 4429 // CHECK-LABEL: test_mm512_fixupimm_pd 4430 // CHECK: @llvm.x86.avx512.mask.fixupimm.pd.512 4431 return _mm512_fixupimm_pd(__A, __B, __C, 5); 4432 } 4433 4434 __m512d test_mm512_mask_fixupimm_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512i __C) { 4435 // CHECK-LABEL: test_mm512_mask_fixupimm_pd 4436 // CHECK: @llvm.x86.avx512.mask.fixupimm.pd.512 4437 return _mm512_mask_fixupimm_pd(__A, __U, __B, __C, 5); 4438 } 4439 4440 __m512d test_mm512_maskz_fixupimm_round_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512i __C) { 4441 // CHECK-LABEL: test_mm512_maskz_fixupimm_round_pd 4442 // CHECK: @llvm.x86.avx512.maskz.fixupimm.pd.512 4443 return _mm512_maskz_fixupimm_round_pd(__U, __A, __B, __C, 5, 8); 4444 } 4445 4446 __m512d test_mm512_maskz_fixupimm_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512i __C) { 4447 // CHECK-LABEL: test_mm512_maskz_fixupimm_pd 4448 // CHECK: @llvm.x86.avx512.maskz.fixupimm.pd.512 4449 return _mm512_maskz_fixupimm_pd(__U, __A, __B, __C, 5); 4450 } 4451 4452 __m512 test_mm512_fixupimm_round_ps(__m512 __A, __m512 __B, __m512i __C) { 4453 // CHECK-LABEL: test_mm512_fixupimm_round_ps 4454 // CHECK: @llvm.x86.avx512.mask.fixupimm.ps.512 4455 return _mm512_fixupimm_round_ps(__A, __B, __C, 5, 8); 4456 } 4457 4458 __m512 test_mm512_mask_fixupimm_round_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512i __C) { 4459 // CHECK-LABEL: test_mm512_mask_fixupimm_round_ps 4460 // CHECK: @llvm.x86.avx512.mask.fixupimm.ps.512 4461 return _mm512_mask_fixupimm_round_ps(__A, __U, __B, __C, 5, 8); 4462 } 4463 4464 __m512 test_mm512_fixupimm_ps(__m512 __A, __m512 __B, __m512i __C) { 4465 // CHECK-LABEL: test_mm512_fixupimm_ps 4466 // CHECK: @llvm.x86.avx512.mask.fixupimm.ps.512 4467 return _mm512_fixupimm_ps(__A, __B, __C, 5); 4468 } 4469 4470 __m512 test_mm512_mask_fixupimm_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512i __C) { 4471 // CHECK-LABEL: test_mm512_mask_fixupimm_ps 4472 // CHECK: @llvm.x86.avx512.mask.fixupimm.ps.512 4473 return _mm512_mask_fixupimm_ps(__A, __U, __B, __C, 5); 4474 } 4475 4476 __m512 test_mm512_maskz_fixupimm_round_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512i __C) { 4477 // CHECK-LABEL: test_mm512_maskz_fixupimm_round_ps 4478 // CHECK: @llvm.x86.avx512.maskz.fixupimm.ps.512 4479 return _mm512_maskz_fixupimm_round_ps(__U, __A, __B, __C, 5, 8); 4480 } 4481 4482 __m512 test_mm512_maskz_fixupimm_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512i __C) { 4483 // CHECK-LABEL: test_mm512_maskz_fixupimm_ps 4484 // CHECK: @llvm.x86.avx512.maskz.fixupimm.ps.512 4485 return _mm512_maskz_fixupimm_ps(__U, __A, __B, __C, 5); 4486 } 4487 4488 __m128d test_mm_fixupimm_round_sd(__m128d __A, __m128d __B, __m128i __C) { 4489 // CHECK-LABEL: test_mm_fixupimm_round_sd 4490 // CHECK: @llvm.x86.avx512.mask.fixupimm 4491 return _mm_fixupimm_round_sd(__A, __B, __C, 5, 8); 4492 } 4493 4494 __m128d test_mm_mask_fixupimm_round_sd(__m128d __A, __mmask8 __U, __m128d __B, __m128i __C) { 4495 // CHECK-LABEL: test_mm_mask_fixupimm_round_sd 4496 // CHECK: @llvm.x86.avx512.mask.fixupimm 4497 return _mm_mask_fixupimm_round_sd(__A, __U, __B, __C, 5, 8); 4498 } 4499 4500 __m128d test_mm_fixupimm_sd(__m128d __A, __m128d __B, __m128i __C) { 4501 // CHECK-LABEL: test_mm_fixupimm_sd 4502 // CHECK: @llvm.x86.avx512.mask.fixupimm 4503 return _mm_fixupimm_sd(__A, __B, __C, 5); 4504 } 4505 4506 __m128d test_mm_mask_fixupimm_sd(__m128d __A, __mmask8 __U, __m128d __B, __m128i __C) { 4507 // CHECK-LABEL: test_mm_mask_fixupimm_sd 4508 // CHECK: @llvm.x86.avx512.mask.fixupimm 4509 return _mm_mask_fixupimm_sd(__A, __U, __B, __C, 5); 4510 } 4511 4512 __m128d test_mm_maskz_fixupimm_round_sd(__mmask8 __U, __m128d __A, __m128d __B, __m128i __C) { 4513 // CHECK-LABEL: test_mm_maskz_fixupimm_round_sd 4514 // CHECK: @llvm.x86.avx512.maskz.fixupimm 4515 return _mm_maskz_fixupimm_round_sd(__U, __A, __B, __C, 5, 8); 4516 } 4517 4518 __m128d test_mm_maskz_fixupimm_sd(__mmask8 __U, __m128d __A, __m128d __B, __m128i __C) { 4519 // CHECK-LABEL: test_mm_maskz_fixupimm_sd 4520 // CHECK: @llvm.x86.avx512.maskz.fixupimm 4521 return _mm_maskz_fixupimm_sd(__U, __A, __B, __C, 5); 4522 } 4523 4524 __m128 test_mm_fixupimm_round_ss(__m128 __A, __m128 __B, __m128i __C) { 4525 // CHECK-LABEL: test_mm_fixupimm_round_ss 4526 // CHECK: @llvm.x86.avx512.mask.fixupimm 4527 return _mm_fixupimm_round_ss(__A, __B, __C, 5, 8); 4528 } 4529 4530 __m128 test_mm_mask_fixupimm_round_ss(__m128 __A, __mmask8 __U, __m128 __B, __m128i __C) { 4531 // CHECK-LABEL: test_mm_mask_fixupimm_round_ss 4532 // CHECK: @llvm.x86.avx512.mask.fixupimm 4533 return _mm_mask_fixupimm_round_ss(__A, __U, __B, __C, 5, 8); 4534 } 4535 4536 __m128 test_mm_fixupimm_ss(__m128 __A, __m128 __B, __m128i __C) { 4537 // CHECK-LABEL: test_mm_fixupimm_ss 4538 // CHECK: @llvm.x86.avx512.mask.fixupimm 4539 return _mm_fixupimm_ss(__A, __B, __C, 5); 4540 } 4541 4542 __m128 test_mm_mask_fixupimm_ss(__m128 __A, __mmask8 __U, __m128 __B, __m128i __C) { 4543 // CHECK-LABEL: test_mm_mask_fixupimm_ss 4544 // CHECK: @llvm.x86.avx512.mask.fixupimm 4545 return _mm_mask_fixupimm_ss(__A, __U, __B, __C, 5); 4546 } 4547 4548 __m128 test_mm_maskz_fixupimm_round_ss(__mmask8 __U, __m128 __A, __m128 __B, __m128i __C) { 4549 // CHECK-LABEL: test_mm_maskz_fixupimm_round_ss 4550 // CHECK: @llvm.x86.avx512.maskz.fixupimm 4551 return _mm_maskz_fixupimm_round_ss(__U, __A, __B, __C, 5, 8); 4552 } 4553 4554 __m128 test_mm_maskz_fixupimm_ss(__mmask8 __U, __m128 __A, __m128 __B, __m128i __C) { 4555 // CHECK-LABEL: test_mm_maskz_fixupimm_ss 4556 // CHECK: @llvm.x86.avx512.maskz.fixupimm 4557 return _mm_maskz_fixupimm_ss(__U, __A, __B, __C, 5); 4558 } 4559 4560 __m128d test_mm_getexp_round_sd(__m128d __A, __m128d __B) { 4561 // CHECK-LABEL: test_mm_getexp_round_sd 4562 // CHECK: @llvm.x86.avx512.mask.getexp.sd 4563 return _mm_getexp_round_sd(__A, __B, 8); 4564 } 4565 4566 __m128d test_mm_getexp_sd(__m128d __A, __m128d __B) { 4567 // CHECK-LABEL: test_mm_getexp_sd 4568 // CHECK: @llvm.x86.avx512.mask.getexp.sd 4569 return _mm_getexp_sd(__A, __B); 4570 } 4571 4572 __m128 test_mm_getexp_round_ss(__m128 __A, __m128 __B) { 4573 // CHECK-LABEL: test_mm_getexp_round_ss 4574 // CHECK: @llvm.x86.avx512.mask.getexp.ss 4575 return _mm_getexp_round_ss(__A, __B, 8); 4576 } 4577 4578 __m128 test_mm_getexp_ss(__m128 __A, __m128 __B) { 4579 // CHECK-LABEL: test_mm_getexp_ss 4580 // CHECK: @llvm.x86.avx512.mask.getexp.ss 4581 return _mm_getexp_ss(__A, __B); 4582 } 4583 4584 __m128d test_mm_getmant_round_sd(__m128d __A, __m128d __B) { 4585 // CHECK-LABEL: test_mm_getmant_round_sd 4586 // CHECK: @llvm.x86.avx512.mask.getmant.sd 4587 return _mm_getmant_round_sd(__A, __B, _MM_MANT_NORM_1_2, _MM_MANT_SIGN_src, 8); 4588 } 4589 4590 __m128d test_mm_getmant_sd(__m128d __A, __m128d __B) { 4591 // CHECK-LABEL: test_mm_getmant_sd 4592 // CHECK: @llvm.x86.avx512.mask.getmant.sd 4593 return _mm_getmant_sd(__A, __B, _MM_MANT_NORM_1_2, _MM_MANT_SIGN_src); 4594 } 4595 4596 __m128 test_mm_getmant_round_ss(__m128 __A, __m128 __B) { 4597 // CHECK-LABEL: test_mm_getmant_round_ss 4598 // CHECK: @llvm.x86.avx512.mask.getmant.ss 4599 return _mm_getmant_round_ss(__A, __B, _MM_MANT_NORM_1_2, _MM_MANT_SIGN_src, 8); 4600 } 4601 4602 __m128 test_mm_getmant_ss(__m128 __A, __m128 __B) { 4603 // CHECK-LABEL: test_mm_getmant_ss 4604 // CHECK: @llvm.x86.avx512.mask.getmant.ss 4605 return _mm_getmant_ss(__A, __B, _MM_MANT_NORM_1_2, _MM_MANT_SIGN_src); 4606 } 4607 4608 __mmask16 test_mm512_kmov(__mmask16 __A) { 4609 // CHECK-LABEL: test_mm512_kmov 4610 // CHECK: load i16, ptr %__A.addr.i, align 2{{$}} 4611 return _mm512_kmov(__A); 4612 } 4613 4614 __m512d test_mm512_mask_unpackhi_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 4615 // CHECK-LABEL: test_mm512_mask_unpackhi_pd 4616 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15> 4617 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 4618 return _mm512_mask_unpackhi_pd(__W, __U, __A, __B); 4619 } 4620 #if __x86_64__ 4621 long long test_mm_cvt_roundsd_si64(__m128d __A) { 4622 // CHECK-LABEL: test_mm_cvt_roundsd_si64 4623 // CHECK: @llvm.x86.avx512.vcvtsd2si64 4624 return _mm_cvt_roundsd_si64(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 4625 } 4626 #endif 4627 __m512i test_mm512_mask2_permutex2var_epi32(__m512i __A, __m512i __I, __mmask16 __U, __m512i __B) { 4628 // CHECK-LABEL: test_mm512_mask2_permutex2var_epi32 4629 // CHECK: @llvm.x86.avx512.vpermi2var.d.512 4630 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4631 return _mm512_mask2_permutex2var_epi32(__A, __I, __U, __B); 4632 } 4633 __m512i test_mm512_unpackhi_epi32(__m512i __A, __m512i __B) { 4634 // CHECK-LABEL: test_mm512_unpackhi_epi32 4635 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 2, i32 18, i32 3, i32 19, i32 6, i32 22, i32 7, i32 23, i32 10, i32 26, i32 11, i32 27, i32 14, i32 30, i32 15, i32 31> 4636 return _mm512_unpackhi_epi32(__A, __B); 4637 } 4638 4639 __m512d test_mm512_maskz_unpackhi_pd(__mmask8 __U, __m512d __A, __m512d __B) { 4640 // CHECK-LABEL: test_mm512_maskz_unpackhi_pd 4641 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15> 4642 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 4643 return _mm512_maskz_unpackhi_pd(__U, __A, __B); 4644 } 4645 #if __x86_64__ 4646 long long test_mm_cvt_roundsd_i64(__m128d __A) { 4647 // CHECK-LABEL: test_mm_cvt_roundsd_i64 4648 // CHECK: @llvm.x86.avx512.vcvtsd2si64 4649 return _mm_cvt_roundsd_i64(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 4650 } 4651 #endif 4652 __m512d test_mm512_mask2_permutex2var_pd(__m512d __A, __m512i __I, __mmask8 __U, __m512d __B) { 4653 // CHECK-LABEL: test_mm512_mask2_permutex2var_pd 4654 // CHECK: @llvm.x86.avx512.vpermi2var.pd.512 4655 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 4656 return _mm512_mask2_permutex2var_pd(__A, __I, __U, __B); 4657 } 4658 __m512i test_mm512_mask_unpackhi_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) { 4659 // CHECK-LABEL: test_mm512_mask_unpackhi_epi32 4660 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 2, i32 18, i32 3, i32 19, i32 6, i32 22, i32 7, i32 23, i32 10, i32 26, i32 11, i32 27, i32 14, i32 30, i32 15, i32 31> 4661 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 4662 return _mm512_mask_unpackhi_epi32(__W, __U, __A, __B); 4663 } 4664 4665 __m512 test_mm512_mask_unpackhi_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 4666 // CHECK-LABEL: test_mm512_mask_unpackhi_ps 4667 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 2, i32 18, i32 3, i32 19, i32 6, i32 22, i32 7, i32 23, i32 10, i32 26, i32 11, i32 27, i32 14, i32 30, i32 15, i32 31> 4668 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 4669 return _mm512_mask_unpackhi_ps(__W, __U, __A, __B); 4670 } 4671 4672 __m512 test_mm512_maskz_unpackhi_ps(__mmask16 __U, __m512 __A, __m512 __B) { 4673 // CHECK-LABEL: test_mm512_maskz_unpackhi_ps 4674 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 2, i32 18, i32 3, i32 19, i32 6, i32 22, i32 7, i32 23, i32 10, i32 26, i32 11, i32 27, i32 14, i32 30, i32 15, i32 31> 4675 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 4676 return _mm512_maskz_unpackhi_ps(__U, __A, __B); 4677 } 4678 4679 __m512d test_mm512_mask_unpacklo_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 4680 // CHECK-LABEL: test_mm512_mask_unpacklo_pd 4681 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14> 4682 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 4683 return _mm512_mask_unpacklo_pd(__W, __U, __A, __B); 4684 } 4685 4686 __m512d test_mm512_maskz_unpacklo_pd(__mmask8 __U, __m512d __A, __m512d __B) { 4687 // CHECK-LABEL: test_mm512_maskz_unpacklo_pd 4688 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14> 4689 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 4690 return _mm512_maskz_unpacklo_pd(__U, __A, __B); 4691 } 4692 4693 __m512 test_mm512_mask_unpacklo_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 4694 // CHECK-LABEL: test_mm512_mask_unpacklo_ps 4695 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 4, i32 20, i32 5, i32 21, i32 8, i32 24, i32 9, i32 25, i32 12, i32 28, i32 13, i32 29> 4696 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 4697 return _mm512_mask_unpacklo_ps(__W, __U, __A, __B); 4698 } 4699 4700 __m512 test_mm512_maskz_unpacklo_ps(__mmask16 __U, __m512 __A, __m512 __B) { 4701 // CHECK-LABEL: test_mm512_maskz_unpacklo_ps 4702 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 4, i32 20, i32 5, i32 21, i32 8, i32 24, i32 9, i32 25, i32 12, i32 28, i32 13, i32 29> 4703 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 4704 return _mm512_maskz_unpacklo_ps(__U, __A, __B); 4705 } 4706 int test_mm_cvt_roundsd_si32(__m128d __A) { 4707 // CHECK-LABEL: test_mm_cvt_roundsd_si32 4708 // CHECK: @llvm.x86.avx512.vcvtsd2si32 4709 return _mm_cvt_roundsd_si32(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 4710 } 4711 4712 int test_mm_cvt_roundsd_i32(__m128d __A) { 4713 // CHECK-LABEL: test_mm_cvt_roundsd_i32 4714 // CHECK: @llvm.x86.avx512.vcvtsd2si32 4715 return _mm_cvt_roundsd_i32(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 4716 } 4717 4718 unsigned test_mm_cvt_roundsd_u32(__m128d __A) { 4719 // CHECK-LABEL: test_mm_cvt_roundsd_u32 4720 // CHECK: @llvm.x86.avx512.vcvtsd2usi32 4721 return _mm_cvt_roundsd_u32(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 4722 } 4723 4724 unsigned test_mm_cvtsd_u32(__m128d __A) { 4725 // CHECK-LABEL: test_mm_cvtsd_u32 4726 // CHECK: @llvm.x86.avx512.vcvtsd2usi32 4727 return _mm_cvtsd_u32(__A); 4728 } 4729 4730 int test_mm512_cvtsi512_si32(__m512i a) { 4731 // CHECK-LABEL: test_mm512_cvtsi512_si32 4732 // CHECK: %{{.*}} = extractelement <16 x i32> %{{.*}}, i32 0 4733 return _mm512_cvtsi512_si32(a); 4734 } 4735 4736 #ifdef __x86_64__ 4737 unsigned long long test_mm_cvt_roundsd_u64(__m128d __A) { 4738 // CHECK-LABEL: test_mm_cvt_roundsd_u64 4739 // CHECK: @llvm.x86.avx512.vcvtsd2usi64 4740 return _mm_cvt_roundsd_u64(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 4741 } 4742 4743 unsigned long long test_mm_cvtsd_u64(__m128d __A) { 4744 // CHECK-LABEL: test_mm_cvtsd_u64 4745 // CHECK: @llvm.x86.avx512.vcvtsd2usi64 4746 return _mm_cvtsd_u64(__A); 4747 } 4748 #endif 4749 4750 int test_mm_cvt_roundss_si32(__m128 __A) { 4751 // CHECK-LABEL: test_mm_cvt_roundss_si32 4752 // CHECK: @llvm.x86.avx512.vcvtss2si32 4753 return _mm_cvt_roundss_si32(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 4754 } 4755 4756 int test_mm_cvt_roundss_i32(__m128 __A) { 4757 // CHECK-LABEL: test_mm_cvt_roundss_i32 4758 // CHECK: @llvm.x86.avx512.vcvtss2si32 4759 return _mm_cvt_roundss_i32(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 4760 } 4761 4762 #ifdef __x86_64__ 4763 long long test_mm_cvt_roundss_si64(__m128 __A) { 4764 // CHECK-LABEL: test_mm_cvt_roundss_si64 4765 // CHECK: @llvm.x86.avx512.vcvtss2si64 4766 return _mm_cvt_roundss_si64(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 4767 } 4768 4769 long long test_mm_cvt_roundss_i64(__m128 __A) { 4770 // CHECK-LABEL: test_mm_cvt_roundss_i64 4771 // CHECK: @llvm.x86.avx512.vcvtss2si64 4772 return _mm_cvt_roundss_i64(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 4773 } 4774 #endif 4775 4776 unsigned test_mm_cvt_roundss_u32(__m128 __A) { 4777 // CHECK-LABEL: test_mm_cvt_roundss_u32 4778 // CHECK: @llvm.x86.avx512.vcvtss2usi32 4779 return _mm_cvt_roundss_u32(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 4780 } 4781 4782 unsigned test_mm_cvtss_u32(__m128 __A) { 4783 // CHECK-LABEL: test_mm_cvtss_u32 4784 // CHECK: @llvm.x86.avx512.vcvtss2usi32 4785 return _mm_cvtss_u32(__A); 4786 } 4787 4788 #ifdef __x86_64__ 4789 unsigned long long test_mm_cvt_roundss_u64(__m128 __A) { 4790 // CHECK-LABEL: test_mm_cvt_roundss_u64 4791 // CHECK: @llvm.x86.avx512.vcvtss2usi64 4792 return _mm_cvt_roundss_u64(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 4793 } 4794 4795 unsigned long long test_mm_cvtss_u64(__m128 __A) { 4796 // CHECK-LABEL: test_mm_cvtss_u64 4797 // CHECK: @llvm.x86.avx512.vcvtss2usi64 4798 return _mm_cvtss_u64(__A); 4799 } 4800 #endif 4801 4802 int test_mm_cvtt_roundsd_i32(__m128d __A) { 4803 // CHECK-LABEL: test_mm_cvtt_roundsd_i32 4804 // CHECK: @llvm.x86.avx512.cvttsd2si 4805 return _mm_cvtt_roundsd_i32(__A, _MM_FROUND_NO_EXC); 4806 } 4807 4808 int test_mm_cvtt_roundsd_si32(__m128d __A) { 4809 // CHECK-LABEL: test_mm_cvtt_roundsd_si32 4810 // CHECK: @llvm.x86.avx512.cvttsd2si 4811 return _mm_cvtt_roundsd_si32(__A, _MM_FROUND_NO_EXC); 4812 } 4813 4814 int test_mm_cvttsd_i32(__m128d __A) { 4815 // CHECK-LABEL: test_mm_cvttsd_i32 4816 // CHECK: @llvm.x86.avx512.cvttsd2si 4817 return _mm_cvttsd_i32(__A); 4818 } 4819 4820 #ifdef __x86_64__ 4821 long long test_mm_cvtt_roundsd_si64(__m128d __A) { 4822 // CHECK-LABEL: test_mm_cvtt_roundsd_si64 4823 // CHECK: @llvm.x86.avx512.cvttsd2si64 4824 return _mm_cvtt_roundsd_si64(__A, _MM_FROUND_NO_EXC); 4825 } 4826 4827 long long test_mm_cvtt_roundsd_i64(__m128d __A) { 4828 // CHECK-LABEL: test_mm_cvtt_roundsd_i64 4829 // CHECK: @llvm.x86.avx512.cvttsd2si64 4830 return _mm_cvtt_roundsd_i64(__A, _MM_FROUND_NO_EXC); 4831 } 4832 4833 long long test_mm_cvttsd_i64(__m128d __A) { 4834 // CHECK-LABEL: test_mm_cvttsd_i64 4835 // CHECK: @llvm.x86.avx512.cvttsd2si64 4836 return _mm_cvttsd_i64(__A); 4837 } 4838 #endif 4839 4840 unsigned test_mm_cvtt_roundsd_u32(__m128d __A) { 4841 // CHECK-LABEL: test_mm_cvtt_roundsd_u32 4842 // CHECK: @llvm.x86.avx512.cvttsd2usi 4843 return _mm_cvtt_roundsd_u32(__A, _MM_FROUND_NO_EXC); 4844 } 4845 4846 unsigned test_mm_cvttsd_u32(__m128d __A) { 4847 // CHECK-LABEL: test_mm_cvttsd_u32 4848 // CHECK: @llvm.x86.avx512.cvttsd2usi 4849 return _mm_cvttsd_u32(__A); 4850 } 4851 4852 #ifdef __x86_64__ 4853 unsigned long long test_mm_cvtt_roundsd_u64(__m128d __A) { 4854 // CHECK-LABEL: test_mm_cvtt_roundsd_u64 4855 // CHECK: @llvm.x86.avx512.cvttsd2usi64 4856 return _mm_cvtt_roundsd_u64(__A, _MM_FROUND_NO_EXC); 4857 } 4858 4859 unsigned long long test_mm_cvttsd_u64(__m128d __A) { 4860 // CHECK-LABEL: test_mm_cvttsd_u64 4861 // CHECK: @llvm.x86.avx512.cvttsd2usi64 4862 return _mm_cvttsd_u64(__A); 4863 } 4864 #endif 4865 4866 int test_mm_cvtt_roundss_i32(__m128 __A) { 4867 // CHECK-LABEL: test_mm_cvtt_roundss_i32 4868 // CHECK: @llvm.x86.avx512.cvttss2si 4869 return _mm_cvtt_roundss_i32(__A, _MM_FROUND_NO_EXC); 4870 } 4871 4872 int test_mm_cvtt_roundss_si32(__m128 __A) { 4873 // CHECK-LABEL: test_mm_cvtt_roundss_si32 4874 // CHECK: @llvm.x86.avx512.cvttss2si 4875 return _mm_cvtt_roundss_si32(__A, _MM_FROUND_NO_EXC); 4876 } 4877 4878 int test_mm_cvttss_i32(__m128 __A) { 4879 // CHECK-LABEL: test_mm_cvttss_i32 4880 // CHECK: @llvm.x86.avx512.cvttss2si 4881 return _mm_cvttss_i32(__A); 4882 } 4883 4884 #ifdef __x86_64__ 4885 float test_mm_cvtt_roundss_i64(__m128 __A) { 4886 // CHECK-LABEL: test_mm_cvtt_roundss_i64 4887 // CHECK: @llvm.x86.avx512.cvttss2si64 4888 return _mm_cvtt_roundss_i64(__A, _MM_FROUND_NO_EXC); 4889 } 4890 4891 long long test_mm_cvtt_roundss_si64(__m128 __A) { 4892 // CHECK-LABEL: test_mm_cvtt_roundss_si64 4893 // CHECK: @llvm.x86.avx512.cvttss2si64 4894 return _mm_cvtt_roundss_si64(__A, _MM_FROUND_NO_EXC); 4895 } 4896 4897 long long test_mm_cvttss_i64(__m128 __A) { 4898 // CHECK-LABEL: test_mm_cvttss_i64 4899 // CHECK: @llvm.x86.avx512.cvttss2si64 4900 return _mm_cvttss_i64(__A); 4901 } 4902 #endif 4903 4904 unsigned test_mm_cvtt_roundss_u32(__m128 __A) { 4905 // CHECK-LABEL: test_mm_cvtt_roundss_u32 4906 // CHECK: @llvm.x86.avx512.cvttss2usi 4907 return _mm_cvtt_roundss_u32(__A, _MM_FROUND_NO_EXC); 4908 } 4909 4910 unsigned test_mm_cvttss_u32(__m128 __A) { 4911 // CHECK-LABEL: test_mm_cvttss_u32 4912 // CHECK: @llvm.x86.avx512.cvttss2usi 4913 return _mm_cvttss_u32(__A); 4914 } 4915 4916 #ifdef __x86_64__ 4917 unsigned long long test_mm_cvtt_roundss_u64(__m128 __A) { 4918 // CHECK-LABEL: test_mm_cvtt_roundss_u64 4919 // CHECK: @llvm.x86.avx512.cvttss2usi64 4920 return _mm_cvtt_roundss_u64(__A, _MM_FROUND_NO_EXC); 4921 } 4922 4923 unsigned long long test_mm_cvttss_u64(__m128 __A) { 4924 // CHECK-LABEL: test_mm_cvttss_u64 4925 // CHECK: @llvm.x86.avx512.cvttss2usi64 4926 return _mm_cvttss_u64(__A); 4927 } 4928 #endif 4929 4930 __m512i test_mm512_cvtt_roundps_epu32(__m512 __A) 4931 { 4932 // CHECK-LABEL: test_mm512_cvtt_roundps_epu32 4933 // CHECK: @llvm.x86.avx512.mask.cvttps2udq.512 4934 return _mm512_cvtt_roundps_epu32(__A, _MM_FROUND_NO_EXC); 4935 } 4936 4937 __m512i test_mm512_mask_cvtt_roundps_epu32(__m512i __W, __mmask16 __U, __m512 __A) 4938 { 4939 // CHECK-LABEL: test_mm512_mask_cvtt_roundps_epu32 4940 // CHECK: @llvm.x86.avx512.mask.cvttps2udq.512 4941 return _mm512_mask_cvtt_roundps_epu32(__W, __U, __A, _MM_FROUND_NO_EXC); 4942 } 4943 4944 __m512i test_mm512_maskz_cvtt_roundps_epu32( __mmask16 __U, __m512 __A) 4945 { 4946 // CHECK-LABEL: test_mm512_maskz_cvtt_roundps_epu32 4947 // CHECK: @llvm.x86.avx512.mask.cvttps2udq.512 4948 4949 return _mm512_maskz_cvtt_roundps_epu32(__U, __A, _MM_FROUND_NO_EXC); 4950 } 4951 4952 __m256i test_mm512_cvt_roundps_ph(__m512 __A) 4953 { 4954 // CHECK-LABEL: test_mm512_cvt_roundps_ph 4955 // CHECK: @llvm.x86.avx512.mask.vcvtps2ph.512 4956 return _mm512_cvt_roundps_ph(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 4957 } 4958 4959 __m256i test_mm512_mask_cvt_roundps_ph(__m256i __W , __mmask16 __U, __m512 __A) 4960 { 4961 // CHECK-LABEL: test_mm512_mask_cvt_roundps_ph 4962 // CHECK: @llvm.x86.avx512.mask.vcvtps2ph.512 4963 return _mm512_mask_cvt_roundps_ph(__W, __U, __A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 4964 } 4965 4966 __m256i test_mm512_maskz_cvt_roundps_ph(__mmask16 __U, __m512 __A) 4967 { 4968 // CHECK-LABEL: test_mm512_maskz_cvt_roundps_ph 4969 // CHECK: @llvm.x86.avx512.mask.vcvtps2ph.512 4970 return _mm512_maskz_cvt_roundps_ph(__U, __A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 4971 } 4972 4973 __m512 test_mm512_cvt_roundph_ps(__m256i __A) 4974 { 4975 // CHECK-LABEL: test_mm512_cvt_roundph_ps 4976 // CHECK: @llvm.x86.avx512.mask.vcvtph2ps.512( 4977 return _mm512_cvt_roundph_ps(__A, _MM_FROUND_NO_EXC); 4978 } 4979 4980 __m512 test_mm512_mask_cvt_roundph_ps(__m512 __W, __mmask16 __U, __m256i __A) 4981 { 4982 // CHECK-LABEL: test_mm512_mask_cvt_roundph_ps 4983 // CHECK: @llvm.x86.avx512.mask.vcvtph2ps.512( 4984 return _mm512_mask_cvt_roundph_ps(__W, __U, __A, _MM_FROUND_NO_EXC); 4985 } 4986 4987 __m512 test_mm512_maskz_cvt_roundph_ps(__mmask16 __U, __m256i __A) 4988 { 4989 // CHECK-LABEL: test_mm512_maskz_cvt_roundph_ps 4990 // CHECK: @llvm.x86.avx512.mask.vcvtph2ps.512( 4991 return _mm512_maskz_cvt_roundph_ps(__U, __A, _MM_FROUND_NO_EXC); 4992 } 4993 4994 __m512 test_mm512_cvt_roundepi32_ps( __m512i __A) 4995 { 4996 // CHECK-LABEL: test_mm512_cvt_roundepi32_ps 4997 // CHECK: @llvm.x86.avx512.sitofp.round.v16f32.v16i32 4998 return _mm512_cvt_roundepi32_ps(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 4999 } 5000 5001 __m512 test_mm512_mask_cvt_roundepi32_ps(__m512 __W, __mmask16 __U, __m512i __A) 5002 { 5003 // CHECK-LABEL: test_mm512_mask_cvt_roundepi32_ps 5004 // CHECK: @llvm.x86.avx512.sitofp.round.v16f32.v16i32 5005 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 5006 return _mm512_mask_cvt_roundepi32_ps(__W,__U,__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5007 } 5008 5009 __m512 test_mm512_maskz_cvt_roundepi32_ps(__mmask16 __U, __m512i __A) 5010 { 5011 // CHECK-LABEL: test_mm512_maskz_cvt_roundepi32_ps 5012 // CHECK: @llvm.x86.avx512.sitofp.round.v16f32.v16i32 5013 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 5014 return _mm512_maskz_cvt_roundepi32_ps(__U,__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5015 } 5016 5017 __m512 test_mm512_cvt_roundepu32_ps(__m512i __A) 5018 { 5019 // CHECK-LABEL: test_mm512_cvt_roundepu32_ps 5020 // CHECK: @llvm.x86.avx512.uitofp.round.v16f32.v16i32 5021 return _mm512_cvt_roundepu32_ps(__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5022 } 5023 5024 __m512 test_mm512_mask_cvt_roundepu32_ps(__m512 __W, __mmask16 __U,__m512i __A) 5025 { 5026 // CHECK-LABEL: test_mm512_mask_cvt_roundepu32_ps 5027 // CHECK: @llvm.x86.avx512.uitofp.round.v16f32.v16i32 5028 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 5029 return _mm512_mask_cvt_roundepu32_ps(__W,__U,__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5030 } 5031 5032 __m512 test_mm512_maskz_cvt_roundepu32_ps(__mmask16 __U,__m512i __A) 5033 { 5034 // CHECK-LABEL: test_mm512_maskz_cvt_roundepu32_ps 5035 // CHECK: @llvm.x86.avx512.uitofp.round.v16f32.v16i32 5036 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 5037 return _mm512_maskz_cvt_roundepu32_ps(__U,__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5038 } 5039 5040 __m256 test_mm512_cvt_roundpd_ps(__m512d A) 5041 { 5042 // CHECK-LABEL: test_mm512_cvt_roundpd_ps 5043 // CHECK: @llvm.x86.avx512.mask.cvtpd2ps.512 5044 return _mm512_cvt_roundpd_ps(A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5045 } 5046 5047 __m256 test_mm512_mask_cvt_roundpd_ps(__m256 W, __mmask8 U,__m512d A) 5048 { 5049 // CHECK-LABEL: test_mm512_mask_cvt_roundpd_ps 5050 // CHECK: @llvm.x86.avx512.mask.cvtpd2ps.512 5051 return _mm512_mask_cvt_roundpd_ps(W,U,A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5052 } 5053 5054 __m256 test_mm512_maskz_cvt_roundpd_ps(__mmask8 U, __m512d A) 5055 { 5056 // CHECK-LABEL: test_mm512_maskz_cvt_roundpd_ps 5057 // CHECK: @llvm.x86.avx512.mask.cvtpd2ps.512 5058 return _mm512_maskz_cvt_roundpd_ps(U,A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5059 } 5060 5061 __m256i test_mm512_cvtt_roundpd_epi32(__m512d A) 5062 { 5063 // CHECK-LABEL: test_mm512_cvtt_roundpd_epi32 5064 // CHECK: @llvm.x86.avx512.mask.cvttpd2dq.512 5065 return _mm512_cvtt_roundpd_epi32(A,_MM_FROUND_NO_EXC); 5066 } 5067 5068 __m256i test_mm512_mask_cvtt_roundpd_epi32(__m256i W, __mmask8 U, __m512d A) 5069 { 5070 // CHECK-LABEL: test_mm512_mask_cvtt_roundpd_epi32 5071 // CHECK: @llvm.x86.avx512.mask.cvttpd2dq.512 5072 return _mm512_mask_cvtt_roundpd_epi32(W,U,A,_MM_FROUND_NO_EXC); 5073 } 5074 5075 __m256i test_mm512_maskz_cvtt_roundpd_epi32(__mmask8 U, __m512d A) 5076 { 5077 // CHECK-LABEL: test_mm512_maskz_cvtt_roundpd_epi32 5078 // CHECK: @llvm.x86.avx512.mask.cvttpd2dq.512 5079 return _mm512_maskz_cvtt_roundpd_epi32(U,A,_MM_FROUND_NO_EXC); 5080 } 5081 5082 __m512i test_mm512_cvtt_roundps_epi32(__m512 A) 5083 { 5084 // CHECK-LABEL: test_mm512_cvtt_roundps_epi32 5085 // CHECK: @llvm.x86.avx512.mask.cvttps2dq.512 5086 return _mm512_cvtt_roundps_epi32(A,_MM_FROUND_NO_EXC); 5087 } 5088 5089 __m512i test_mm512_mask_cvtt_roundps_epi32(__m512i W,__mmask16 U, __m512 A) 5090 { 5091 // CHECK-LABEL: test_mm512_mask_cvtt_roundps_epi32 5092 // CHECK: @llvm.x86.avx512.mask.cvttps2dq.512 5093 return _mm512_mask_cvtt_roundps_epi32(W,U,A,_MM_FROUND_NO_EXC); 5094 } 5095 5096 __m512i test_mm512_maskz_cvtt_roundps_epi32(__mmask16 U, __m512 A) 5097 { 5098 // CHECK-LABEL: test_mm512_maskz_cvtt_roundps_epi32 5099 // CHECK: @llvm.x86.avx512.mask.cvttps2dq.512 5100 return _mm512_maskz_cvtt_roundps_epi32(U,A,_MM_FROUND_NO_EXC); 5101 } 5102 5103 __m512i test_mm512_cvt_roundps_epi32(__m512 __A) 5104 { 5105 // CHECK-LABEL: test_mm512_cvt_roundps_epi32 5106 // CHECK: @llvm.x86.avx512.mask.cvtps2dq.512 5107 return _mm512_cvt_roundps_epi32(__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5108 } 5109 5110 __m512i test_mm512_mask_cvt_roundps_epi32(__m512i __W,__mmask16 __U,__m512 __A) 5111 { 5112 // CHECK-LABEL: test_mm512_mask_cvt_roundps_epi32 5113 // CHECK: @llvm.x86.avx512.mask.cvtps2dq.512 5114 return _mm512_mask_cvt_roundps_epi32(__W,__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5115 } 5116 5117 __m512i test_mm512_maskz_cvt_roundps_epi32(__mmask16 __U, __m512 __A) 5118 { 5119 // CHECK-LABEL: test_mm512_maskz_cvt_roundps_epi32 5120 // CHECK: @llvm.x86.avx512.mask.cvtps2dq.512 5121 return _mm512_maskz_cvt_roundps_epi32(__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5122 } 5123 5124 __m256i test_mm512_cvt_roundpd_epi32(__m512d A) 5125 { 5126 // CHECK-LABEL: test_mm512_cvt_roundpd_epi32 5127 // CHECK: @llvm.x86.avx512.mask.cvtpd2dq.512 5128 return _mm512_cvt_roundpd_epi32(A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5129 } 5130 5131 __m256i test_mm512_mask_cvt_roundpd_epi32(__m256i W,__mmask8 U,__m512d A) 5132 { 5133 // CHECK-LABEL: test_mm512_mask_cvt_roundpd_epi32 5134 // CHECK: @llvm.x86.avx512.mask.cvtpd2dq.512 5135 return _mm512_mask_cvt_roundpd_epi32(W,U,A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5136 } 5137 5138 __m256i test_mm512_maskz_cvt_roundpd_epi32(__mmask8 U, __m512d A) 5139 { 5140 // CHECK-LABEL: test_mm512_maskz_cvt_roundpd_epi32 5141 // CHECK: @llvm.x86.avx512.mask.cvtpd2dq.512 5142 return _mm512_maskz_cvt_roundpd_epi32(U,A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5143 } 5144 5145 __m512i test_mm512_cvt_roundps_epu32(__m512 __A) 5146 { 5147 // CHECK-LABEL: test_mm512_cvt_roundps_epu32 5148 // CHECK: @llvm.x86.avx512.mask.cvtps2udq.512 5149 return _mm512_cvt_roundps_epu32(__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5150 } 5151 5152 __m512i test_mm512_mask_cvt_roundps_epu32(__m512i __W,__mmask16 __U,__m512 __A) 5153 { 5154 // CHECK-LABEL: test_mm512_mask_cvt_roundps_epu32 5155 // CHECK: @llvm.x86.avx512.mask.cvtps2udq.512 5156 return _mm512_mask_cvt_roundps_epu32(__W,__U,__A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5157 } 5158 5159 __m512i test_mm512_maskz_cvt_roundps_epu32(__mmask16 __U,__m512 __A) 5160 { 5161 // CHECK-LABEL: test_mm512_maskz_cvt_roundps_epu32 5162 // CHECK: @llvm.x86.avx512.mask.cvtps2udq.512 5163 return _mm512_maskz_cvt_roundps_epu32(__U,__A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5164 } 5165 5166 __m256i test_mm512_cvt_roundpd_epu32(__m512d A) 5167 { 5168 // CHECK-LABEL: test_mm512_cvt_roundpd_epu32 5169 // CHECK: @llvm.x86.avx512.mask.cvtpd2udq.512 5170 return _mm512_cvt_roundpd_epu32(A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5171 } 5172 5173 __m256i test_mm512_mask_cvt_roundpd_epu32(__m256i W, __mmask8 U, __m512d A) 5174 { 5175 // CHECK-LABEL: test_mm512_mask_cvt_roundpd_epu32 5176 // CHECK: @llvm.x86.avx512.mask.cvtpd2udq.512 5177 return _mm512_mask_cvt_roundpd_epu32(W,U,A,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5178 } 5179 5180 __m256i test_mm512_maskz_cvt_roundpd_epu32(__mmask8 U, __m512d A) 5181 { 5182 // CHECK-LABEL: test_mm512_maskz_cvt_roundpd_epu32 5183 // CHECK: @llvm.x86.avx512.mask.cvtpd2udq.512 5184 return _mm512_maskz_cvt_roundpd_epu32(U, A, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5185 } 5186 5187 __m512 test_mm512_mask2_permutex2var_ps(__m512 __A, __m512i __I, __mmask16 __U, __m512 __B) { 5188 // CHECK-LABEL: test_mm512_mask2_permutex2var_ps 5189 // CHECK: @llvm.x86.avx512.vpermi2var.ps.512 5190 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 5191 return _mm512_mask2_permutex2var_ps(__A, __I, __U, __B); 5192 } 5193 5194 __m512i test_mm512_mask2_permutex2var_epi64(__m512i __A, __m512i __I, __mmask8 __U, __m512i __B) { 5195 // CHECK-LABEL: test_mm512_mask2_permutex2var_epi64 5196 // CHECK: @llvm.x86.avx512.vpermi2var.q.512 5197 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5198 return _mm512_mask2_permutex2var_epi64(__A, __I, __U, __B); 5199 } 5200 5201 __m512d test_mm512_permute_pd(__m512d __X) { 5202 // CHECK-LABEL: test_mm512_permute_pd 5203 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 2, i32 4, i32 4, i32 6, i32 6> 5204 return _mm512_permute_pd(__X, 2); 5205 } 5206 5207 __m512d test_mm512_mask_permute_pd(__m512d __W, __mmask8 __U, __m512d __X) { 5208 // CHECK-LABEL: test_mm512_mask_permute_pd 5209 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 2, i32 4, i32 4, i32 6, i32 6> 5210 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 5211 return _mm512_mask_permute_pd(__W, __U, __X, 2); 5212 } 5213 5214 __m512d test_mm512_maskz_permute_pd(__mmask8 __U, __m512d __X) { 5215 // CHECK-LABEL: test_mm512_maskz_permute_pd 5216 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> poison, <8 x i32> <i32 0, i32 1, i32 2, i32 2, i32 4, i32 4, i32 6, i32 6> 5217 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 5218 return _mm512_maskz_permute_pd(__U, __X, 2); 5219 } 5220 5221 __m512 test_mm512_permute_ps(__m512 __X) { 5222 // CHECK-LABEL: test_mm512_permute_ps 5223 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> poison, <16 x i32> <i32 2, i32 0, i32 0, i32 0, i32 6, i32 4, i32 4, i32 4, i32 10, i32 8, i32 8, i32 8, i32 14, i32 12, i32 12, i32 12> 5224 return _mm512_permute_ps(__X, 2); 5225 } 5226 5227 __m512 test_mm512_mask_permute_ps(__m512 __W, __mmask16 __U, __m512 __X) { 5228 // CHECK-LABEL: test_mm512_mask_permute_ps 5229 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> poison, <16 x i32> <i32 2, i32 0, i32 0, i32 0, i32 6, i32 4, i32 4, i32 4, i32 10, i32 8, i32 8, i32 8, i32 14, i32 12, i32 12, i32 12> 5230 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 5231 return _mm512_mask_permute_ps(__W, __U, __X, 2); 5232 } 5233 5234 __m512 test_mm512_maskz_permute_ps(__mmask16 __U, __m512 __X) { 5235 // CHECK-LABEL: test_mm512_maskz_permute_ps 5236 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> poison, <16 x i32> <i32 2, i32 0, i32 0, i32 0, i32 6, i32 4, i32 4, i32 4, i32 10, i32 8, i32 8, i32 8, i32 14, i32 12, i32 12, i32 12> 5237 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 5238 return _mm512_maskz_permute_ps(__U, __X, 2); 5239 } 5240 5241 __m512d test_mm512_permutevar_pd(__m512d __A, __m512i __C) { 5242 // CHECK-LABEL: test_mm512_permutevar_pd 5243 // CHECK: @llvm.x86.avx512.vpermilvar.pd.512 5244 return _mm512_permutevar_pd(__A, __C); 5245 } 5246 5247 __m512d test_mm512_mask_permutevar_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512i __C) { 5248 // CHECK-LABEL: test_mm512_mask_permutevar_pd 5249 // CHECK: @llvm.x86.avx512.vpermilvar.pd.512 5250 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 5251 return _mm512_mask_permutevar_pd(__W, __U, __A, __C); 5252 } 5253 5254 __m512d test_mm512_maskz_permutevar_pd(__mmask8 __U, __m512d __A, __m512i __C) { 5255 // CHECK-LABEL: test_mm512_maskz_permutevar_pd 5256 // CHECK: @llvm.x86.avx512.vpermilvar.pd.512 5257 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 5258 return _mm512_maskz_permutevar_pd(__U, __A, __C); 5259 } 5260 5261 __m512 test_mm512_permutevar_ps(__m512 __A, __m512i __C) { 5262 // CHECK-LABEL: test_mm512_permutevar_ps 5263 // CHECK: @llvm.x86.avx512.vpermilvar.ps.512 5264 return _mm512_permutevar_ps(__A, __C); 5265 } 5266 5267 __m512 test_mm512_mask_permutevar_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512i __C) { 5268 // CHECK-LABEL: test_mm512_mask_permutevar_ps 5269 // CHECK: @llvm.x86.avx512.vpermilvar.ps.512 5270 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 5271 return _mm512_mask_permutevar_ps(__W, __U, __A, __C); 5272 } 5273 5274 __m512 test_mm512_maskz_permutevar_ps(__mmask16 __U, __m512 __A, __m512i __C) { 5275 // CHECK-LABEL: test_mm512_maskz_permutevar_ps 5276 // CHECK: @llvm.x86.avx512.vpermilvar.ps.512 5277 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 5278 return _mm512_maskz_permutevar_ps(__U, __A, __C); 5279 } 5280 5281 __m512i test_mm512_permutex2var_epi32(__m512i __A, __m512i __I, __m512i __B) { 5282 // CHECK-LABEL: test_mm512_permutex2var_epi32 5283 // CHECK: @llvm.x86.avx512.vpermi2var.d.512 5284 return _mm512_permutex2var_epi32(__A, __I, __B); 5285 } 5286 5287 __m512i test_mm512_maskz_permutex2var_epi32(__mmask16 __U, __m512i __A, __m512i __I, __m512i __B) { 5288 // CHECK-LABEL: test_mm512_maskz_permutex2var_epi32 5289 // CHECK: @llvm.x86.avx512.vpermi2var.d.512 5290 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5291 return _mm512_maskz_permutex2var_epi32(__U, __A, __I, __B); 5292 } 5293 5294 __m512i test_mm512_mask_permutex2var_epi32 (__m512i __A, __mmask16 __U, __m512i __I, __m512i __B) 5295 { 5296 // CHECK-LABEL: test_mm512_mask_permutex2var_epi32 5297 // CHECK: @llvm.x86.avx512.vpermi2var.d.512 5298 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5299 return _mm512_mask_permutex2var_epi32 (__A,__U,__I,__B); 5300 } 5301 5302 __m512d test_mm512_permutex2var_pd (__m512d __A, __m512i __I, __m512d __B) 5303 { 5304 // CHECK-LABEL: test_mm512_permutex2var_pd 5305 // CHECK: @llvm.x86.avx512.vpermi2var.pd.512 5306 return _mm512_permutex2var_pd (__A, __I,__B); 5307 } 5308 5309 __m512d test_mm512_mask_permutex2var_pd (__m512d __A, __mmask8 __U, __m512i __I, __m512d __B) 5310 { 5311 // CHECK-LABEL: test_mm512_mask_permutex2var_pd 5312 // CHECK: @llvm.x86.avx512.vpermi2var.pd.512 5313 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 5314 return _mm512_mask_permutex2var_pd (__A,__U,__I,__B); 5315 } 5316 5317 __m512d test_mm512_maskz_permutex2var_pd(__mmask8 __U, __m512d __A, __m512i __I, __m512d __B) { 5318 // CHECK-LABEL: test_mm512_maskz_permutex2var_pd 5319 // CHECK: @llvm.x86.avx512.vpermi2var.pd.512 5320 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 5321 return _mm512_maskz_permutex2var_pd(__U, __A, __I, __B); 5322 } 5323 5324 __m512 test_mm512_permutex2var_ps (__m512 __A, __m512i __I, __m512 __B) 5325 { 5326 // CHECK-LABEL: test_mm512_permutex2var_ps 5327 // CHECK: @llvm.x86.avx512.vpermi2var.ps.512 5328 return _mm512_permutex2var_ps (__A, __I, __B); 5329 } 5330 5331 __m512 test_mm512_mask_permutex2var_ps (__m512 __A, __mmask16 __U, __m512i __I, __m512 __B) 5332 { 5333 // CHECK-LABEL: test_mm512_mask_permutex2var_ps 5334 // CHECK: @llvm.x86.avx512.vpermi2var.ps.512 5335 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 5336 return _mm512_mask_permutex2var_ps (__A,__U,__I,__B); 5337 } 5338 5339 __m512 test_mm512_maskz_permutex2var_ps(__mmask16 __U, __m512 __A, __m512i __I, __m512 __B) { 5340 // CHECK-LABEL: test_mm512_maskz_permutex2var_ps 5341 // CHECK: @llvm.x86.avx512.vpermi2var.ps.512 5342 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 5343 return _mm512_maskz_permutex2var_ps(__U, __A, __I, __B); 5344 } 5345 5346 __m512i test_mm512_permutex2var_epi64 (__m512i __A, __m512i __I, __m512i __B){ 5347 // CHECK-LABEL: test_mm512_permutex2var_epi64 5348 // CHECK: @llvm.x86.avx512.vpermi2var.q.512 5349 return _mm512_permutex2var_epi64(__A, __I, __B); 5350 } 5351 5352 __m512i test_mm512_mask_permutex2var_epi64 (__m512i __A, __mmask8 __U, __m512i __I, __m512i __B){ 5353 // CHECK-LABEL: test_mm512_mask_permutex2var_epi64 5354 // CHECK: @llvm.x86.avx512.vpermi2var.q.512 5355 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5356 return _mm512_mask_permutex2var_epi64(__A, __U, __I, __B); 5357 } 5358 5359 __m512i test_mm512_maskz_permutex2var_epi64(__mmask8 __U, __m512i __A, __m512i __I, __m512i __B) { 5360 // CHECK-LABEL: test_mm512_maskz_permutex2var_epi64 5361 // CHECK: @llvm.x86.avx512.vpermi2var.q.512 5362 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5363 return _mm512_maskz_permutex2var_epi64(__U, __A, __I, __B); 5364 } 5365 __mmask16 test_mm512_testn_epi32_mask(__m512i __A, __m512i __B) { 5366 // CHECK-LABEL: test_mm512_testn_epi32_mask 5367 // CHECK: and <16 x i32> %{{.*}}, %{{.*}} 5368 // CHECK: icmp eq <16 x i32> %{{.*}}, %{{.*}} 5369 return _mm512_testn_epi32_mask(__A, __B); 5370 } 5371 5372 __mmask16 test_mm512_mask_testn_epi32_mask(__mmask16 __U, __m512i __A, __m512i __B) { 5373 // CHECK-LABEL: test_mm512_mask_testn_epi32_mask 5374 // CHECK: and <16 x i32> %{{.*}}, %{{.*}} 5375 // CHECK: icmp eq <16 x i32> %{{.*}}, %{{.*}} 5376 // CHECK: and <16 x i1> %{{.*}}, %{{.*}} 5377 return _mm512_mask_testn_epi32_mask(__U, __A, __B); 5378 } 5379 5380 __mmask8 test_mm512_testn_epi64_mask(__m512i __A, __m512i __B) { 5381 // CHECK-LABEL: test_mm512_testn_epi64_mask 5382 // CHECK: and <16 x i32> %{{.*}}, %{{.*}} 5383 // CHECK: icmp eq <8 x i64> %{{.*}}, %{{.*}} 5384 return _mm512_testn_epi64_mask(__A, __B); 5385 } 5386 5387 __mmask8 test_mm512_mask_testn_epi64_mask(__mmask8 __U, __m512i __A, __m512i __B) { 5388 // CHECK-LABEL: test_mm512_mask_testn_epi64_mask 5389 // CHECK: and <16 x i32> %{{.*}}, %{{.*}} 5390 // CHECK: icmp eq <8 x i64> %{{.*}}, %{{.*}} 5391 // CHECK: and <8 x i1> %{{.*}}, %{{.*}} 5392 return _mm512_mask_testn_epi64_mask(__U, __A, __B); 5393 } 5394 5395 __mmask16 test_mm512_mask_test_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B) 5396 { 5397 // CHECK-LABEL: test_mm512_mask_test_epi32_mask 5398 // CHECK: and <16 x i32> %{{.*}}, %{{.*}} 5399 // CHECK: icmp ne <16 x i32> %{{.*}}, %{{.*}} 5400 return _mm512_mask_test_epi32_mask (__U,__A,__B); 5401 } 5402 5403 __mmask8 test_mm512_mask_test_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B) 5404 { 5405 // CHECK-LABEL: test_mm512_mask_test_epi64_mask 5406 // CHECK: and <16 x i32> %{{.*}}, %{{.*}} 5407 // CHECK: icmp ne <8 x i64> %{{.*}}, %{{.*}} 5408 // CHECK: and <8 x i1> %{{.*}}, %{{.*}} 5409 return _mm512_mask_test_epi64_mask (__U,__A,__B); 5410 } 5411 5412 __m512i test_mm512_maskz_unpackhi_epi32(__mmask16 __U, __m512i __A, __m512i __B) { 5413 // CHECK-LABEL: test_mm512_maskz_unpackhi_epi32 5414 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 2, i32 18, i32 3, i32 19, i32 6, i32 22, i32 7, i32 23, i32 10, i32 26, i32 11, i32 27, i32 14, i32 30, i32 15, i32 31> 5415 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5416 return _mm512_maskz_unpackhi_epi32(__U, __A, __B); 5417 } 5418 5419 __m512i test_mm512_unpackhi_epi64(__m512i __A, __m512i __B) { 5420 // CHECK-LABEL: test_mm512_unpackhi_epi64 5421 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15> 5422 return _mm512_unpackhi_epi64(__A, __B); 5423 } 5424 5425 __m512i test_mm512_mask_unpackhi_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) { 5426 // CHECK-LABEL: test_mm512_mask_unpackhi_epi64 5427 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15> 5428 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5429 return _mm512_mask_unpackhi_epi64(__W, __U, __A, __B); 5430 } 5431 5432 __m512i test_mm512_maskz_unpackhi_epi64(__mmask8 __U, __m512i __A, __m512i __B) { 5433 // CHECK-LABEL: test_mm512_maskz_unpackhi_epi64 5434 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15> 5435 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5436 return _mm512_maskz_unpackhi_epi64(__U, __A, __B); 5437 } 5438 5439 __m512i test_mm512_unpacklo_epi32(__m512i __A, __m512i __B) { 5440 // CHECK-LABEL: test_mm512_unpacklo_epi32 5441 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 4, i32 20, i32 5, i32 21, i32 8, i32 24, i32 9, i32 25, i32 12, i32 28, i32 13, i32 29> 5442 return _mm512_unpacklo_epi32(__A, __B); 5443 } 5444 5445 __m512i test_mm512_mask_unpacklo_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) { 5446 // CHECK-LABEL: test_mm512_mask_unpacklo_epi32 5447 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 4, i32 20, i32 5, i32 21, i32 8, i32 24, i32 9, i32 25, i32 12, i32 28, i32 13, i32 29> 5448 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5449 return _mm512_mask_unpacklo_epi32(__W, __U, __A, __B); 5450 } 5451 5452 __m512i test_mm512_maskz_unpacklo_epi32(__mmask16 __U, __m512i __A, __m512i __B) { 5453 // CHECK-LABEL: test_mm512_maskz_unpacklo_epi32 5454 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 4, i32 20, i32 5, i32 21, i32 8, i32 24, i32 9, i32 25, i32 12, i32 28, i32 13, i32 29> 5455 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5456 return _mm512_maskz_unpacklo_epi32(__U, __A, __B); 5457 } 5458 5459 __m512i test_mm512_unpacklo_epi64(__m512i __A, __m512i __B) { 5460 // CHECK-LABEL: test_mm512_unpacklo_epi64 5461 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14> 5462 return _mm512_unpacklo_epi64(__A, __B); 5463 } 5464 5465 __m512i test_mm512_mask_unpacklo_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) { 5466 // CHECK-LABEL: test_mm512_mask_unpacklo_epi64 5467 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14> 5468 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5469 return _mm512_mask_unpacklo_epi64(__W, __U, __A, __B); 5470 } 5471 5472 __m512i test_mm512_maskz_unpacklo_epi64(__mmask8 __U, __m512i __A, __m512i __B) { 5473 // CHECK-LABEL: test_mm512_maskz_unpacklo_epi64 5474 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14> 5475 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5476 return _mm512_maskz_unpacklo_epi64(__U, __A, __B); 5477 } 5478 5479 __m128d test_mm_roundscale_round_sd(__m128d __A, __m128d __B) { 5480 // CHECK-LABEL: test_mm_roundscale_round_sd 5481 // CHECK: @llvm.x86.avx512.mask.rndscale.sd 5482 return _mm_roundscale_round_sd(__A, __B, 3, _MM_FROUND_NO_EXC); 5483 } 5484 5485 __m128d test_mm_roundscale_sd(__m128d __A, __m128d __B) { 5486 // CHECK-LABEL: test_mm_roundscale_sd 5487 // CHECK: @llvm.x86.avx512.mask.rndscale.sd 5488 return _mm_roundscale_sd(__A, __B, 3); 5489 } 5490 5491 __m128d test_mm_mask_roundscale_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 5492 // CHECK: @llvm.x86.avx512.mask.rndscale.sd 5493 return _mm_mask_roundscale_sd(__W,__U,__A,__B,3); 5494 } 5495 5496 __m128d test_mm_mask_roundscale_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 5497 // CHECK: @llvm.x86.avx512.mask.rndscale.sd 5498 return _mm_mask_roundscale_round_sd(__W,__U,__A,__B,3,_MM_FROUND_NO_EXC); 5499 } 5500 5501 __m128d test_mm_maskz_roundscale_sd(__mmask8 __U, __m128d __A, __m128d __B){ 5502 // CHECK: @llvm.x86.avx512.mask.rndscale.sd 5503 return _mm_maskz_roundscale_sd(__U,__A,__B,3); 5504 } 5505 5506 __m128d test_mm_maskz_roundscale_round_sd(__mmask8 __U, __m128d __A, __m128d __B){ 5507 // CHECK: @llvm.x86.avx512.mask.rndscale.sd 5508 return _mm_maskz_roundscale_round_sd(__U,__A,__B,3,_MM_FROUND_NO_EXC ); 5509 } 5510 5511 __m128 test_mm_roundscale_round_ss(__m128 __A, __m128 __B) { 5512 // CHECK-LABEL: test_mm_roundscale_round_ss 5513 // CHECK: @llvm.x86.avx512.mask.rndscale.ss 5514 return _mm_roundscale_round_ss(__A, __B, 3, _MM_FROUND_NO_EXC); 5515 } 5516 5517 __m128 test_mm_roundscale_ss(__m128 __A, __m128 __B) { 5518 // CHECK-LABEL: test_mm_roundscale_ss 5519 // CHECK: @llvm.x86.avx512.mask.rndscale.ss 5520 return _mm_roundscale_ss(__A, __B, 3); 5521 } 5522 5523 __m128 test_mm_mask_roundscale_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 5524 // CHECK-LABEL: test_mm_mask_roundscale_ss 5525 // CHECK: @llvm.x86.avx512.mask.rndscale.ss 5526 return _mm_mask_roundscale_ss(__W,__U,__A,__B,3); 5527 } 5528 5529 __m128 test_mm_maskz_roundscale_round_ss( __mmask8 __U, __m128 __A, __m128 __B){ 5530 // CHECK-LABEL: test_mm_maskz_roundscale_round_ss 5531 // CHECK: @llvm.x86.avx512.mask.rndscale.ss 5532 return _mm_maskz_roundscale_round_ss(__U,__A,__B,3,_MM_FROUND_NO_EXC); 5533 } 5534 5535 __m128 test_mm_maskz_roundscale_ss(__mmask8 __U, __m128 __A, __m128 __B){ 5536 // CHECK-LABEL: test_mm_maskz_roundscale_ss 5537 // CHECK: @llvm.x86.avx512.mask.rndscale.ss 5538 return _mm_maskz_roundscale_ss(__U,__A,__B,3); 5539 } 5540 5541 __m512d test_mm512_scalef_round_pd(__m512d __A, __m512d __B) { 5542 // CHECK-LABEL: test_mm512_scalef_round_pd 5543 // CHECK: @llvm.x86.avx512.mask.scalef.pd.512 5544 return _mm512_scalef_round_pd(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5545 } 5546 5547 __m512d test_mm512_mask_scalef_round_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 5548 // CHECK-LABEL: test_mm512_mask_scalef_round_pd 5549 // CHECK: @llvm.x86.avx512.mask.scalef.pd.512 5550 return _mm512_mask_scalef_round_pd(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5551 } 5552 5553 __m512d test_mm512_maskz_scalef_round_pd(__mmask8 __U, __m512d __A, __m512d __B) { 5554 // CHECK-LABEL: test_mm512_maskz_scalef_round_pd 5555 // CHECK: @llvm.x86.avx512.mask.scalef.pd.512 5556 return _mm512_maskz_scalef_round_pd(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5557 } 5558 5559 __m512d test_mm512_scalef_pd(__m512d __A, __m512d __B) { 5560 // CHECK-LABEL: test_mm512_scalef_pd 5561 // CHECK: @llvm.x86.avx512.mask.scalef.pd.512 5562 return _mm512_scalef_pd(__A, __B); 5563 } 5564 5565 __m512d test_mm512_mask_scalef_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 5566 // CHECK-LABEL: test_mm512_mask_scalef_pd 5567 // CHECK: @llvm.x86.avx512.mask.scalef.pd.512 5568 return _mm512_mask_scalef_pd(__W, __U, __A, __B); 5569 } 5570 5571 __m512d test_mm512_maskz_scalef_pd(__mmask8 __U, __m512d __A, __m512d __B) { 5572 // CHECK-LABEL: test_mm512_maskz_scalef_pd 5573 // CHECK: @llvm.x86.avx512.mask.scalef.pd.512 5574 return _mm512_maskz_scalef_pd(__U, __A, __B); 5575 } 5576 5577 __m512 test_mm512_scalef_round_ps(__m512 __A, __m512 __B) { 5578 // CHECK-LABEL: test_mm512_scalef_round_ps 5579 // CHECK: @llvm.x86.avx512.mask.scalef.ps.512 5580 return _mm512_scalef_round_ps(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5581 } 5582 5583 __m512 test_mm512_mask_scalef_round_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 5584 // CHECK-LABEL: test_mm512_mask_scalef_round_ps 5585 // CHECK: @llvm.x86.avx512.mask.scalef.ps.512 5586 return _mm512_mask_scalef_round_ps(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5587 } 5588 5589 __m512 test_mm512_maskz_scalef_round_ps(__mmask16 __U, __m512 __A, __m512 __B) { 5590 // CHECK-LABEL: test_mm512_maskz_scalef_round_ps 5591 // CHECK: @llvm.x86.avx512.mask.scalef.ps.512 5592 return _mm512_maskz_scalef_round_ps(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5593 } 5594 5595 __m512 test_mm512_scalef_ps(__m512 __A, __m512 __B) { 5596 // CHECK-LABEL: test_mm512_scalef_ps 5597 // CHECK: @llvm.x86.avx512.mask.scalef.ps.512 5598 return _mm512_scalef_ps(__A, __B); 5599 } 5600 5601 __m512 test_mm512_mask_scalef_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 5602 // CHECK-LABEL: test_mm512_mask_scalef_ps 5603 // CHECK: @llvm.x86.avx512.mask.scalef.ps.512 5604 return _mm512_mask_scalef_ps(__W, __U, __A, __B); 5605 } 5606 5607 __m512 test_mm512_maskz_scalef_ps(__mmask16 __U, __m512 __A, __m512 __B) { 5608 // CHECK-LABEL: test_mm512_maskz_scalef_ps 5609 // CHECK: @llvm.x86.avx512.mask.scalef.ps.512 5610 return _mm512_maskz_scalef_ps(__U, __A, __B); 5611 } 5612 5613 __m128d test_mm_scalef_round_sd(__m128d __A, __m128d __B) { 5614 // CHECK-LABEL: test_mm_scalef_round_sd 5615 // CHECK: @llvm.x86.avx512.mask.scalef.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %2, i8 -1, i32 11) 5616 return _mm_scalef_round_sd(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5617 } 5618 5619 __m128d test_mm_scalef_sd(__m128d __A, __m128d __B) { 5620 // CHECK-LABEL: test_mm_scalef_sd 5621 // CHECK: @llvm.x86.avx512.mask.scalef 5622 return _mm_scalef_sd(__A, __B); 5623 } 5624 5625 __m128d test_mm_mask_scalef_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 5626 // CHECK-LABEL: test_mm_mask_scalef_sd 5627 // CHECK: @llvm.x86.avx512.mask.scalef.sd 5628 return _mm_mask_scalef_sd(__W, __U, __A, __B); 5629 } 5630 5631 __m128d test_mm_mask_scalef_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 5632 // CHECK-LABEL: test_mm_mask_scalef_round_sd 5633 // CHECK: @llvm.x86.avx512.mask.scalef.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 %{{.*}}, i32 11) 5634 return _mm_mask_scalef_round_sd(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5635 } 5636 5637 __m128d test_mm_maskz_scalef_sd(__mmask8 __U, __m128d __A, __m128d __B){ 5638 // CHECK-LABEL: test_mm_maskz_scalef_sd 5639 // CHECK: @llvm.x86.avx512.mask.scalef.sd 5640 return _mm_maskz_scalef_sd(__U, __A, __B); 5641 } 5642 5643 __m128d test_mm_maskz_scalef_round_sd(__mmask8 __U, __m128d __A, __m128d __B){ 5644 // CHECK-LABEL: test_mm_maskz_scalef_round_sd 5645 // CHECK: @llvm.x86.avx512.mask.scalef.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 %{{.*}}, i32 11) 5646 return _mm_maskz_scalef_round_sd(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5647 } 5648 5649 __m128 test_mm_scalef_round_ss(__m128 __A, __m128 __B) { 5650 // CHECK-LABEL: test_mm_scalef_round_ss 5651 // CHECK: @llvm.x86.avx512.mask.scalef.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 -1, i32 11) 5652 return _mm_scalef_round_ss(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5653 } 5654 5655 __m128 test_mm_scalef_ss(__m128 __A, __m128 __B) { 5656 // CHECK-LABEL: test_mm_scalef_ss 5657 // CHECK: @llvm.x86.avx512.mask.scalef.ss 5658 return _mm_scalef_ss(__A, __B); 5659 } 5660 5661 __m128 test_mm_mask_scalef_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 5662 // CHECK-LABEL: test_mm_mask_scalef_ss 5663 // CHECK: @llvm.x86.avx512.mask.scalef.ss 5664 return _mm_mask_scalef_ss(__W, __U, __A, __B); 5665 } 5666 5667 __m128 test_mm_mask_scalef_round_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 5668 // CHECK-LABEL: test_mm_mask_scalef_round_ss 5669 // CHECK: @llvm.x86.avx512.mask.scalef.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 %{{.*}}, i32 11) 5670 return _mm_mask_scalef_round_ss(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5671 } 5672 5673 __m128 test_mm_maskz_scalef_ss(__mmask8 __U, __m128 __A, __m128 __B){ 5674 // CHECK-LABEL: test_mm_maskz_scalef_ss 5675 // CHECK: @llvm.x86.avx512.mask.scalef.ss 5676 return _mm_maskz_scalef_ss(__U, __A, __B); 5677 } 5678 5679 __m128 test_mm_maskz_scalef_round_ss(__mmask8 __U, __m128 __A, __m128 __B){ 5680 // CHECK-LABEL: test_mm_maskz_scalef_round_ss 5681 // CHECK: @llvm.x86.avx512.mask.scalef.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 %{{.*}}, i32 11) 5682 return _mm_maskz_scalef_round_ss(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 5683 } 5684 5685 __m512i test_mm512_srai_epi32(__m512i __A) { 5686 // CHECK-LABEL: test_mm512_srai_epi32 5687 // CHECK: @llvm.x86.avx512.psrai.d.512 5688 return _mm512_srai_epi32(__A, 5); 5689 } 5690 5691 __m512i test_mm512_srai_epi32_2(__m512i __A, unsigned int __B) { 5692 // CHECK-LABEL: test_mm512_srai_epi32_2 5693 // CHECK: @llvm.x86.avx512.psrai.d.512 5694 return _mm512_srai_epi32(__A, __B); 5695 } 5696 5697 __m512i test_mm512_mask_srai_epi32(__m512i __W, __mmask16 __U, __m512i __A) { 5698 // CHECK-LABEL: test_mm512_mask_srai_epi32 5699 // CHECK: @llvm.x86.avx512.psrai.d.512 5700 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5701 return _mm512_mask_srai_epi32(__W, __U, __A, 5); 5702 } 5703 5704 __m512i test_mm512_mask_srai_epi32_2(__m512i __W, __mmask16 __U, __m512i __A, unsigned int __B) { 5705 // CHECK-LABEL: test_mm512_mask_srai_epi32_2 5706 // CHECK: @llvm.x86.avx512.psrai.d.512 5707 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5708 return _mm512_mask_srai_epi32(__W, __U, __A, __B); 5709 } 5710 5711 __m512i test_mm512_maskz_srai_epi32(__mmask16 __U, __m512i __A) { 5712 // CHECK-LABEL: test_mm512_maskz_srai_epi32 5713 // CHECK: @llvm.x86.avx512.psrai.d.512 5714 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5715 return _mm512_maskz_srai_epi32(__U, __A, 5); 5716 } 5717 5718 __m512i test_mm512_maskz_srai_epi32_2(__mmask16 __U, __m512i __A, unsigned int __B) { 5719 // CHECK-LABEL: test_mm512_maskz_srai_epi32_2 5720 // CHECK: @llvm.x86.avx512.psrai.d.512 5721 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5722 return _mm512_maskz_srai_epi32(__U, __A, __B); 5723 } 5724 5725 __m512i test_mm512_srai_epi64(__m512i __A) { 5726 // CHECK-LABEL: test_mm512_srai_epi64 5727 // CHECK: @llvm.x86.avx512.psrai.q.512 5728 return _mm512_srai_epi64(__A, 5); 5729 } 5730 5731 __m512i test_mm512_srai_epi64_2(__m512i __A, unsigned int __B) { 5732 // CHECK-LABEL: test_mm512_srai_epi64_2 5733 // CHECK: @llvm.x86.avx512.psrai.q.512 5734 return _mm512_srai_epi64(__A, __B); 5735 } 5736 5737 __m512i test_mm512_mask_srai_epi64(__m512i __W, __mmask8 __U, __m512i __A) { 5738 // CHECK-LABEL: test_mm512_mask_srai_epi64 5739 // CHECK: @llvm.x86.avx512.psrai.q.512 5740 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5741 return _mm512_mask_srai_epi64(__W, __U, __A, 5); 5742 } 5743 5744 __m512i test_mm512_mask_srai_epi64_2(__m512i __W, __mmask8 __U, __m512i __A, unsigned int __B) { 5745 // CHECK-LABEL: test_mm512_mask_srai_epi64_2 5746 // CHECK: @llvm.x86.avx512.psrai.q.512 5747 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5748 return _mm512_mask_srai_epi64(__W, __U, __A, __B); 5749 } 5750 5751 __m512i test_mm512_maskz_srai_epi64(__mmask8 __U, __m512i __A) { 5752 // CHECK-LABEL: test_mm512_maskz_srai_epi64 5753 // CHECK: @llvm.x86.avx512.psrai.q.512 5754 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5755 return _mm512_maskz_srai_epi64(__U, __A, 5); 5756 } 5757 5758 __m512i test_mm512_maskz_srai_epi64_2(__mmask8 __U, __m512i __A, unsigned int __B) { 5759 // CHECK-LABEL: test_mm512_maskz_srai_epi64_2 5760 // CHECK: @llvm.x86.avx512.psrai.q.512 5761 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5762 return _mm512_maskz_srai_epi64(__U, __A, __B); 5763 } 5764 5765 __m512i test_mm512_sll_epi32(__m512i __A, __m128i __B) { 5766 // CHECK-LABEL: test_mm512_sll_epi32 5767 // CHECK: @llvm.x86.avx512.psll.d.512 5768 return _mm512_sll_epi32(__A, __B); 5769 } 5770 5771 __m512i test_mm512_mask_sll_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m128i __B) { 5772 // CHECK-LABEL: test_mm512_mask_sll_epi32 5773 // CHECK: @llvm.x86.avx512.psll.d.512 5774 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5775 return _mm512_mask_sll_epi32(__W, __U, __A, __B); 5776 } 5777 5778 __m512i test_mm512_maskz_sll_epi32(__mmask16 __U, __m512i __A, __m128i __B) { 5779 // CHECK-LABEL: test_mm512_maskz_sll_epi32 5780 // CHECK: @llvm.x86.avx512.psll.d.512 5781 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5782 return _mm512_maskz_sll_epi32(__U, __A, __B); 5783 } 5784 5785 __m512i test_mm512_sll_epi64(__m512i __A, __m128i __B) { 5786 // CHECK-LABEL: test_mm512_sll_epi64 5787 // CHECK: @llvm.x86.avx512.psll.q.512 5788 return _mm512_sll_epi64(__A, __B); 5789 } 5790 5791 __m512i test_mm512_mask_sll_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m128i __B) { 5792 // CHECK-LABEL: test_mm512_mask_sll_epi64 5793 // CHECK: @llvm.x86.avx512.psll.q.512 5794 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5795 return _mm512_mask_sll_epi64(__W, __U, __A, __B); 5796 } 5797 5798 __m512i test_mm512_maskz_sll_epi64(__mmask8 __U, __m512i __A, __m128i __B) { 5799 // CHECK-LABEL: test_mm512_maskz_sll_epi64 5800 // CHECK: @llvm.x86.avx512.psll.q.512 5801 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5802 return _mm512_maskz_sll_epi64(__U, __A, __B); 5803 } 5804 5805 __m512i test_mm512_sllv_epi32(__m512i __X, __m512i __Y) { 5806 // CHECK-LABEL: test_mm512_sllv_epi32 5807 // CHECK: @llvm.x86.avx512.psllv.d.512 5808 return _mm512_sllv_epi32(__X, __Y); 5809 } 5810 5811 __m512i test_mm512_mask_sllv_epi32(__m512i __W, __mmask16 __U, __m512i __X, __m512i __Y) { 5812 // CHECK-LABEL: test_mm512_mask_sllv_epi32 5813 // CHECK: @llvm.x86.avx512.psllv.d.512 5814 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5815 return _mm512_mask_sllv_epi32(__W, __U, __X, __Y); 5816 } 5817 5818 __m512i test_mm512_maskz_sllv_epi32(__mmask16 __U, __m512i __X, __m512i __Y) { 5819 // CHECK-LABEL: test_mm512_maskz_sllv_epi32 5820 // CHECK: @llvm.x86.avx512.psllv.d.512 5821 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5822 return _mm512_maskz_sllv_epi32(__U, __X, __Y); 5823 } 5824 5825 __m512i test_mm512_sllv_epi64(__m512i __X, __m512i __Y) { 5826 // CHECK-LABEL: test_mm512_sllv_epi64 5827 // CHECK: @llvm.x86.avx512.psllv.q.512 5828 return _mm512_sllv_epi64(__X, __Y); 5829 } 5830 5831 __m512i test_mm512_mask_sllv_epi64(__m512i __W, __mmask8 __U, __m512i __X, __m512i __Y) { 5832 // CHECK-LABEL: test_mm512_mask_sllv_epi64 5833 // CHECK: @llvm.x86.avx512.psllv.q.512 5834 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5835 return _mm512_mask_sllv_epi64(__W, __U, __X, __Y); 5836 } 5837 5838 __m512i test_mm512_maskz_sllv_epi64(__mmask8 __U, __m512i __X, __m512i __Y) { 5839 // CHECK-LABEL: test_mm512_maskz_sllv_epi64 5840 // CHECK: @llvm.x86.avx512.psllv.q.512 5841 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5842 return _mm512_maskz_sllv_epi64(__U, __X, __Y); 5843 } 5844 5845 __m512i test_mm512_sra_epi32(__m512i __A, __m128i __B) { 5846 // CHECK-LABEL: test_mm512_sra_epi32 5847 // CHECK: @llvm.x86.avx512.psra.d.512 5848 return _mm512_sra_epi32(__A, __B); 5849 } 5850 5851 __m512i test_mm512_mask_sra_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m128i __B) { 5852 // CHECK-LABEL: test_mm512_mask_sra_epi32 5853 // CHECK: @llvm.x86.avx512.psra.d.512 5854 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5855 return _mm512_mask_sra_epi32(__W, __U, __A, __B); 5856 } 5857 5858 __m512i test_mm512_maskz_sra_epi32(__mmask16 __U, __m512i __A, __m128i __B) { 5859 // CHECK-LABEL: test_mm512_maskz_sra_epi32 5860 // CHECK: @llvm.x86.avx512.psra.d.512 5861 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5862 return _mm512_maskz_sra_epi32(__U, __A, __B); 5863 } 5864 5865 __m512i test_mm512_sra_epi64(__m512i __A, __m128i __B) { 5866 // CHECK-LABEL: test_mm512_sra_epi64 5867 // CHECK: @llvm.x86.avx512.psra.q.512 5868 return _mm512_sra_epi64(__A, __B); 5869 } 5870 5871 __m512i test_mm512_mask_sra_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m128i __B) { 5872 // CHECK-LABEL: test_mm512_mask_sra_epi64 5873 // CHECK: @llvm.x86.avx512.psra.q.512 5874 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5875 return _mm512_mask_sra_epi64(__W, __U, __A, __B); 5876 } 5877 5878 __m512i test_mm512_maskz_sra_epi64(__mmask8 __U, __m512i __A, __m128i __B) { 5879 // CHECK-LABEL: test_mm512_maskz_sra_epi64 5880 // CHECK: @llvm.x86.avx512.psra.q.512 5881 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5882 return _mm512_maskz_sra_epi64(__U, __A, __B); 5883 } 5884 5885 __m512i test_mm512_srav_epi32(__m512i __X, __m512i __Y) { 5886 // CHECK-LABEL: test_mm512_srav_epi32 5887 // CHECK: @llvm.x86.avx512.psrav.d.512 5888 return _mm512_srav_epi32(__X, __Y); 5889 } 5890 5891 __m512i test_mm512_mask_srav_epi32(__m512i __W, __mmask16 __U, __m512i __X, __m512i __Y) { 5892 // CHECK-LABEL: test_mm512_mask_srav_epi32 5893 // CHECK: @llvm.x86.avx512.psrav.d.512 5894 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5895 return _mm512_mask_srav_epi32(__W, __U, __X, __Y); 5896 } 5897 5898 __m512i test_mm512_maskz_srav_epi32(__mmask16 __U, __m512i __X, __m512i __Y) { 5899 // CHECK-LABEL: test_mm512_maskz_srav_epi32 5900 // CHECK: @llvm.x86.avx512.psrav.d.512 5901 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5902 return _mm512_maskz_srav_epi32(__U, __X, __Y); 5903 } 5904 5905 __m512i test_mm512_srav_epi64(__m512i __X, __m512i __Y) { 5906 // CHECK-LABEL: test_mm512_srav_epi64 5907 // CHECK: @llvm.x86.avx512.psrav.q.512 5908 return _mm512_srav_epi64(__X, __Y); 5909 } 5910 5911 __m512i test_mm512_mask_srav_epi64(__m512i __W, __mmask8 __U, __m512i __X, __m512i __Y) { 5912 // CHECK-LABEL: test_mm512_mask_srav_epi64 5913 // CHECK: @llvm.x86.avx512.psrav.q.512 5914 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5915 return _mm512_mask_srav_epi64(__W, __U, __X, __Y); 5916 } 5917 5918 __m512i test_mm512_maskz_srav_epi64(__mmask8 __U, __m512i __X, __m512i __Y) { 5919 // CHECK-LABEL: test_mm512_maskz_srav_epi64 5920 // CHECK: @llvm.x86.avx512.psrav.q.512 5921 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5922 return _mm512_maskz_srav_epi64(__U, __X, __Y); 5923 } 5924 5925 __m512i test_mm512_srl_epi32(__m512i __A, __m128i __B) { 5926 // CHECK-LABEL: test_mm512_srl_epi32 5927 // CHECK: @llvm.x86.avx512.psrl.d.512 5928 return _mm512_srl_epi32(__A, __B); 5929 } 5930 5931 __m512i test_mm512_mask_srl_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m128i __B) { 5932 // CHECK-LABEL: test_mm512_mask_srl_epi32 5933 // CHECK: @llvm.x86.avx512.psrl.d.512 5934 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5935 return _mm512_mask_srl_epi32(__W, __U, __A, __B); 5936 } 5937 5938 __m512i test_mm512_maskz_srl_epi32(__mmask16 __U, __m512i __A, __m128i __B) { 5939 // CHECK-LABEL: test_mm512_maskz_srl_epi32 5940 // CHECK: @llvm.x86.avx512.psrl.d.512 5941 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5942 return _mm512_maskz_srl_epi32(__U, __A, __B); 5943 } 5944 5945 __m512i test_mm512_srl_epi64(__m512i __A, __m128i __B) { 5946 // CHECK-LABEL: test_mm512_srl_epi64 5947 // CHECK: @llvm.x86.avx512.psrl.q.512 5948 return _mm512_srl_epi64(__A, __B); 5949 } 5950 5951 __m512i test_mm512_mask_srl_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m128i __B) { 5952 // CHECK-LABEL: test_mm512_mask_srl_epi64 5953 // CHECK: @llvm.x86.avx512.psrl.q.512 5954 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5955 return _mm512_mask_srl_epi64(__W, __U, __A, __B); 5956 } 5957 5958 __m512i test_mm512_maskz_srl_epi64(__mmask8 __U, __m512i __A, __m128i __B) { 5959 // CHECK-LABEL: test_mm512_maskz_srl_epi64 5960 // CHECK: @llvm.x86.avx512.psrl.q.512 5961 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5962 return _mm512_maskz_srl_epi64(__U, __A, __B); 5963 } 5964 5965 __m512i test_mm512_srlv_epi32(__m512i __X, __m512i __Y) { 5966 // CHECK-LABEL: test_mm512_srlv_epi32 5967 // CHECK: @llvm.x86.avx512.psrlv.d.512 5968 return _mm512_srlv_epi32(__X, __Y); 5969 } 5970 5971 __m512i test_mm512_mask_srlv_epi32(__m512i __W, __mmask16 __U, __m512i __X, __m512i __Y) { 5972 // CHECK-LABEL: test_mm512_mask_srlv_epi32 5973 // CHECK: @llvm.x86.avx512.psrlv.d.512 5974 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5975 return _mm512_mask_srlv_epi32(__W, __U, __X, __Y); 5976 } 5977 5978 __m512i test_mm512_maskz_srlv_epi32(__mmask16 __U, __m512i __X, __m512i __Y) { 5979 // CHECK-LABEL: test_mm512_maskz_srlv_epi32 5980 // CHECK: @llvm.x86.avx512.psrlv.d.512 5981 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 5982 return _mm512_maskz_srlv_epi32(__U, __X, __Y); 5983 } 5984 5985 __m512i test_mm512_srlv_epi64(__m512i __X, __m512i __Y) { 5986 // CHECK-LABEL: test_mm512_srlv_epi64 5987 // CHECK: @llvm.x86.avx512.psrlv.q.512 5988 return _mm512_srlv_epi64(__X, __Y); 5989 } 5990 5991 __m512i test_mm512_mask_srlv_epi64(__m512i __W, __mmask8 __U, __m512i __X, __m512i __Y) { 5992 // CHECK-LABEL: test_mm512_mask_srlv_epi64 5993 // CHECK: @llvm.x86.avx512.psrlv.q.512 5994 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 5995 return _mm512_mask_srlv_epi64(__W, __U, __X, __Y); 5996 } 5997 5998 __m512i test_mm512_maskz_srlv_epi64(__mmask8 __U, __m512i __X, __m512i __Y) { 5999 // CHECK-LABEL: test_mm512_maskz_srlv_epi64 6000 // CHECK: @llvm.x86.avx512.psrlv.q.512 6001 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 6002 return _mm512_maskz_srlv_epi64(__U, __X, __Y); 6003 } 6004 6005 __m512i test_mm512_ternarylogic_epi32(__m512i __A, __m512i __B, __m512i __C) { 6006 // CHECK-LABEL: test_mm512_ternarylogic_epi32 6007 // CHECK: @llvm.x86.avx512.pternlog.d.512({{.*}}, i32 240) 6008 return _mm512_ternarylogic_epi32(__A, __B, __C, _MM_TERNLOG_A); 6009 } 6010 6011 __m512i test_mm512_mask_ternarylogic_epi32(__m512i __A, __mmask16 __U, __m512i __B, __m512i __C) { 6012 // CHECK-LABEL: test_mm512_mask_ternarylogic_epi32 6013 // CHECK: @llvm.x86.avx512.pternlog.d.512({{.*}}, i32 204) 6014 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 6015 return _mm512_mask_ternarylogic_epi32(__A, __U, __B, __C, _MM_TERNLOG_B); 6016 } 6017 6018 __m512i test_mm512_maskz_ternarylogic_epi32(__mmask16 __U, __m512i __A, __m512i __B, __m512i __C) { 6019 // CHECK-LABEL: test_mm512_maskz_ternarylogic_epi32 6020 // CHECK: @llvm.x86.avx512.pternlog.d.512({{.*}}, i32 170) 6021 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> zeroinitializer 6022 return _mm512_maskz_ternarylogic_epi32(__U, __A, __B, __C, _MM_TERNLOG_C); 6023 } 6024 6025 __m512i test_mm512_ternarylogic_epi64(__m512i __A, __m512i __B, __m512i __C) { 6026 // CHECK-LABEL: test_mm512_ternarylogic_epi64 6027 // CHECK: @llvm.x86.avx512.pternlog.q.512({{.*}}, i32 192) 6028 return _mm512_ternarylogic_epi64(__A, __B, __C, _MM_TERNLOG_A & _MM_TERNLOG_B); 6029 } 6030 6031 __m512i test_mm512_mask_ternarylogic_epi64(__m512i __A, __mmask8 __U, __m512i __B, __m512i __C) { 6032 // CHECK-LABEL: test_mm512_mask_ternarylogic_epi64 6033 // CHECK: @llvm.x86.avx512.pternlog.q.512({{.*}}, i32 238) 6034 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 6035 return _mm512_mask_ternarylogic_epi64(__A, __U, __B, __C, _MM_TERNLOG_B | _MM_TERNLOG_C); 6036 } 6037 6038 __m512i test_mm512_maskz_ternarylogic_epi64(__mmask8 __U, __m512i __A, __m512i __B, __m512i __C) { 6039 // CHECK-LABEL: test_mm512_maskz_ternarylogic_epi64 6040 // CHECK: @llvm.x86.avx512.pternlog.q.512({{.*}}, i32 111) 6041 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> zeroinitializer 6042 return _mm512_maskz_ternarylogic_epi64(__U, __A, __B, __C, ~_MM_TERNLOG_A | (_MM_TERNLOG_B ^ _MM_TERNLOG_C)); 6043 } 6044 6045 __m512 test_mm512_shuffle_f32x4(__m512 __A, __m512 __B) { 6046 // CHECK-LABEL: test_mm512_shuffle_f32x4 6047 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 16, i32 17, i32 18, i32 19> 6048 return _mm512_shuffle_f32x4(__A, __B, 4); 6049 } 6050 6051 __m512 test_mm512_mask_shuffle_f32x4(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) { 6052 // CHECK-LABEL: test_mm512_mask_shuffle_f32x4 6053 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 16, i32 17, i32 18, i32 19> 6054 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 6055 return _mm512_mask_shuffle_f32x4(__W, __U, __A, __B, 4); 6056 } 6057 6058 __m512 test_mm512_maskz_shuffle_f32x4(__mmask16 __U, __m512 __A, __m512 __B) { 6059 // CHECK-LABEL: test_mm512_maskz_shuffle_f32x4 6060 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 16, i32 17, i32 18, i32 19> 6061 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 6062 return _mm512_maskz_shuffle_f32x4(__U, __A, __B, 4); 6063 } 6064 6065 __m512d test_mm512_shuffle_f64x2(__m512d __A, __m512d __B) { 6066 // CHECK-LABEL: test_mm512_shuffle_f64x2 6067 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 8, i32 9> 6068 return _mm512_shuffle_f64x2(__A, __B, 4); 6069 } 6070 6071 __m512d test_mm512_mask_shuffle_f64x2(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) { 6072 // CHECK-LABEL: test_mm512_mask_shuffle_f64x2 6073 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 8, i32 9> 6074 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 6075 return _mm512_mask_shuffle_f64x2(__W, __U, __A, __B, 4); 6076 } 6077 6078 __m512d test_mm512_maskz_shuffle_f64x2(__mmask8 __U, __m512d __A, __m512d __B) { 6079 // CHECK-LABEL: test_mm512_maskz_shuffle_f64x2 6080 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 8, i32 9> 6081 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 6082 return _mm512_maskz_shuffle_f64x2(__U, __A, __B, 4); 6083 } 6084 6085 __m512i test_mm512_shuffle_i32x4(__m512i __A, __m512i __B) { 6086 // CHECK-LABEL: test_mm512_shuffle_i32x4 6087 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 16, i32 17, i32 18, i32 19> 6088 return _mm512_shuffle_i32x4(__A, __B, 4); 6089 } 6090 6091 __m512i test_mm512_mask_shuffle_i32x4(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) { 6092 // CHECK-LABEL: test_mm512_mask_shuffle_i32x4 6093 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 16, i32 17, i32 18, i32 19> 6094 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 6095 return _mm512_mask_shuffle_i32x4(__W, __U, __A, __B, 4); 6096 } 6097 6098 __m512i test_mm512_maskz_shuffle_i32x4(__mmask16 __U, __m512i __A, __m512i __B) { 6099 // CHECK-LABEL: test_mm512_maskz_shuffle_i32x4 6100 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 16, i32 17, i32 18, i32 19> 6101 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 6102 return _mm512_maskz_shuffle_i32x4(__U, __A, __B, 4); 6103 } 6104 6105 __m512i test_mm512_shuffle_i64x2(__m512i __A, __m512i __B) { 6106 // CHECK-LABEL: test_mm512_shuffle_i64x2 6107 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 8, i32 9> 6108 return _mm512_shuffle_i64x2(__A, __B, 4); 6109 } 6110 6111 __m512i test_mm512_mask_shuffle_i64x2(__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) { 6112 // CHECK-LABEL: test_mm512_mask_shuffle_i64x2 6113 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 8, i32 9> 6114 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 6115 return _mm512_mask_shuffle_i64x2(__W, __U, __A, __B, 4); 6116 } 6117 6118 __m512i test_mm512_maskz_shuffle_i64x2(__mmask8 __U, __m512i __A, __m512i __B) { 6119 // CHECK-LABEL: test_mm512_maskz_shuffle_i64x2 6120 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 8, i32 9> 6121 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 6122 return _mm512_maskz_shuffle_i64x2(__U, __A, __B, 4); 6123 } 6124 6125 __m512d test_mm512_shuffle_pd(__m512d __M, __m512d __V) { 6126 // CHECK-LABEL: test_mm512_shuffle_pd 6127 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 3, i32 10, i32 4, i32 12, i32 6, i32 14> 6128 return _mm512_shuffle_pd(__M, __V, 4); 6129 } 6130 6131 __m512d test_mm512_mask_shuffle_pd(__m512d __W, __mmask8 __U, __m512d __M, __m512d __V) { 6132 // CHECK-LABEL: test_mm512_mask_shuffle_pd 6133 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 3, i32 10, i32 4, i32 12, i32 6, i32 14> 6134 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 6135 return _mm512_mask_shuffle_pd(__W, __U, __M, __V, 4); 6136 } 6137 6138 __m512d test_mm512_maskz_shuffle_pd(__mmask8 __U, __m512d __M, __m512d __V) { 6139 // CHECK-LABEL: test_mm512_maskz_shuffle_pd 6140 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 8, i32 3, i32 10, i32 4, i32 12, i32 6, i32 14> 6141 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 6142 return _mm512_maskz_shuffle_pd(__U, __M, __V, 4); 6143 } 6144 6145 __m512 test_mm512_shuffle_ps(__m512 __M, __m512 __V) { 6146 // CHECK-LABEL: test_mm512_shuffle_ps 6147 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 16, i32 16, i32 4, i32 5, i32 20, i32 20, i32 8, i32 9, i32 24, i32 24, i32 12, i32 13, i32 28, i32 28> 6148 return _mm512_shuffle_ps(__M, __V, 4); 6149 } 6150 6151 __m512 test_mm512_mask_shuffle_ps(__m512 __W, __mmask16 __U, __m512 __M, __m512 __V) { 6152 // CHECK-LABEL: test_mm512_mask_shuffle_ps 6153 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 16, i32 16, i32 4, i32 5, i32 20, i32 20, i32 8, i32 9, i32 24, i32 24, i32 12, i32 13, i32 28, i32 28> 6154 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 6155 return _mm512_mask_shuffle_ps(__W, __U, __M, __V, 4); 6156 } 6157 6158 __m512 test_mm512_maskz_shuffle_ps(__mmask16 __U, __m512 __M, __m512 __V) { 6159 // CHECK-LABEL: test_mm512_maskz_shuffle_ps 6160 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 16, i32 16, i32 4, i32 5, i32 20, i32 20, i32 8, i32 9, i32 24, i32 24, i32 12, i32 13, i32 28, i32 28> 6161 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 6162 return _mm512_maskz_shuffle_ps(__U, __M, __V, 4); 6163 } 6164 6165 __m128d test_mm_sqrt_round_sd(__m128d __A, __m128d __B) { 6166 // CHECK-LABEL: test_mm_sqrt_round_sd 6167 // CHECK: call {{.*}}<2 x double> @llvm.x86.avx512.mask.sqrt.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 -1, i32 11) 6168 return _mm_sqrt_round_sd(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 6169 } 6170 6171 __m128d test_mm_mask_sqrt_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 6172 // CHECK-LABEL: test_mm_mask_sqrt_sd 6173 // CHECK: extractelement <2 x double> %{{.*}}, i64 0 6174 // CHECK-NEXT: call double @llvm.sqrt.f64(double %{{.*}}) 6175 // CHECK-NEXT: extractelement <2 x double> %{{.*}}, i64 0 6176 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 6177 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 6178 // CHECK-NEXT: select i1 {{.*}}, double {{.*}}, double {{.*}} 6179 // CHECK-NEXT: insertelement <2 x double> %{{.*}}, double {{.*}}, i64 0 6180 return _mm_mask_sqrt_sd(__W,__U,__A,__B); 6181 } 6182 6183 __m128d test_mm_mask_sqrt_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 6184 // CHECK-LABEL: test_mm_mask_sqrt_round_sd 6185 // CHECK: call {{.*}}<2 x double> @llvm.x86.avx512.mask.sqrt.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 %{{.*}}, i32 11) 6186 return _mm_mask_sqrt_round_sd(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 6187 } 6188 6189 __m128d test_mm_maskz_sqrt_sd(__mmask8 __U, __m128d __A, __m128d __B){ 6190 // CHECK-LABEL: test_mm_maskz_sqrt_sd 6191 // CHECK: extractelement <2 x double> %{{.*}}, i64 0 6192 // CHECK-NEXT: call double @llvm.sqrt.f64(double %{{.*}}) 6193 // CHECK-NEXT: extractelement <2 x double> %{{.*}}, i64 0 6194 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 6195 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 6196 // CHECK-NEXT: select i1 {{.*}}, double {{.*}}, double {{.*}} 6197 // CHECK-NEXT: insertelement <2 x double> %{{.*}}, double {{.*}}, i64 0 6198 return _mm_maskz_sqrt_sd(__U,__A,__B); 6199 } 6200 6201 __m128d test_mm_maskz_sqrt_round_sd(__mmask8 __U, __m128d __A, __m128d __B){ 6202 // CHECK-LABEL: test_mm_maskz_sqrt_round_sd 6203 // CHECK: call {{.*}}<2 x double> @llvm.x86.avx512.mask.sqrt.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 %{{.*}}, i32 11) 6204 return _mm_maskz_sqrt_round_sd(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 6205 } 6206 6207 __m128 test_mm_sqrt_round_ss(__m128 __A, __m128 __B) { 6208 // CHECK-LABEL: test_mm_sqrt_round_ss 6209 // CHECK: call {{.*}}<4 x float> @llvm.x86.avx512.mask.sqrt.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 -1, i32 11) 6210 return _mm_sqrt_round_ss(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 6211 } 6212 6213 __m128 test_mm_mask_sqrt_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 6214 // CHECK-LABEL: test_mm_mask_sqrt_ss 6215 // CHECK: extractelement <4 x float> %{{.*}}, i64 0 6216 // CHECK-NEXT: call float @llvm.sqrt.f32(float %{{.*}}) 6217 // CHECK-NEXT: extractelement <4 x float> %{{.*}}, i64 0 6218 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 6219 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 6220 // CHECK-NEXT: select i1 {{.*}}, float {{.*}}, float {{.*}} 6221 // CHECK-NEXT: insertelement <4 x float> %{{.*}}, float {{.*}}, i64 0 6222 return _mm_mask_sqrt_ss(__W,__U,__A,__B); 6223 } 6224 6225 __m128 test_mm_mask_sqrt_round_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 6226 // CHECK-LABEL: test_mm_mask_sqrt_round_ss 6227 // CHECK: call {{.*}}<4 x float> @llvm.x86.avx512.mask.sqrt.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 {{.*}}, i32 11) 6228 return _mm_mask_sqrt_round_ss(__W,__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 6229 } 6230 6231 __m128 test_mm_maskz_sqrt_ss(__mmask8 __U, __m128 __A, __m128 __B){ 6232 // CHECK-LABEL: test_mm_maskz_sqrt_ss 6233 // CHECK: extractelement <4 x float> %{{.*}}, i64 0 6234 // CHECK-NEXT: call float @llvm.sqrt.f32(float %{{.*}}) 6235 // CHECK-NEXT: extractelement <4 x float> %{{.*}}, i64 0 6236 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 6237 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 6238 // CHECK-NEXT: select i1 {{.*}}, float {{.*}}, float {{.*}} 6239 // CHECK-NEXT: insertelement <4 x float> %{{.*}}, float {{.*}}, i64 0 6240 return _mm_maskz_sqrt_ss(__U,__A,__B); 6241 } 6242 6243 __m128 test_mm_maskz_sqrt_round_ss(__mmask8 __U, __m128 __A, __m128 __B){ 6244 // CHECK-LABEL: test_mm_maskz_sqrt_round_ss 6245 // CHECK: call {{.*}}<4 x float> @llvm.x86.avx512.mask.sqrt.ss(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 {{.*}}, i32 11) 6246 return _mm_maskz_sqrt_round_ss(__U,__A,__B,_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 6247 } 6248 6249 __m512 test_mm512_broadcast_f32x4(float const* __A) { 6250 // CHECK-LABEL: test_mm512_broadcast_f32x4 6251 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3> 6252 return _mm512_broadcast_f32x4(_mm_loadu_ps(__A)); 6253 } 6254 6255 __m512 test_mm512_mask_broadcast_f32x4(__m512 __O, __mmask16 __M, float const* __A) { 6256 // CHECK-LABEL: test_mm512_mask_broadcast_f32x4 6257 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3> 6258 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 6259 return _mm512_mask_broadcast_f32x4(__O, __M, _mm_loadu_ps(__A)); 6260 } 6261 6262 __m512 test_mm512_maskz_broadcast_f32x4(__mmask16 __M, float const* __A) { 6263 // CHECK-LABEL: test_mm512_maskz_broadcast_f32x4 6264 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3> 6265 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 6266 return _mm512_maskz_broadcast_f32x4(__M, _mm_loadu_ps(__A)); 6267 } 6268 6269 __m512d test_mm512_broadcast_f64x4(double const* __A) { 6270 // CHECK-LABEL: test_mm512_broadcast_f64x4 6271 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3> 6272 return _mm512_broadcast_f64x4(_mm256_loadu_pd(__A)); 6273 } 6274 6275 __m512d test_mm512_mask_broadcast_f64x4(__m512d __O, __mmask8 __M, double const* __A) { 6276 // CHECK-LABEL: test_mm512_mask_broadcast_f64x4 6277 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3> 6278 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 6279 return _mm512_mask_broadcast_f64x4(__O, __M, _mm256_loadu_pd(__A)); 6280 } 6281 6282 __m512d test_mm512_maskz_broadcast_f64x4(__mmask8 __M, double const* __A) { 6283 // CHECK-LABEL: test_mm512_maskz_broadcast_f64x4 6284 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3> 6285 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 6286 return _mm512_maskz_broadcast_f64x4(__M, _mm256_loadu_pd(__A)); 6287 } 6288 6289 __m512i test_mm512_broadcast_i32x4(__m128i const* __A) { 6290 // CHECK-LABEL: test_mm512_broadcast_i32x4 6291 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3> 6292 return _mm512_broadcast_i32x4(_mm_loadu_si128(__A)); 6293 } 6294 6295 __m512i test_mm512_mask_broadcast_i32x4(__m512i __O, __mmask16 __M, __m128i const* __A) { 6296 // CHECK-LABEL: test_mm512_mask_broadcast_i32x4 6297 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3> 6298 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 6299 return _mm512_mask_broadcast_i32x4(__O, __M, _mm_loadu_si128(__A)); 6300 } 6301 6302 __m512i test_mm512_maskz_broadcast_i32x4(__mmask16 __M, __m128i const* __A) { 6303 // CHECK-LABEL: test_mm512_maskz_broadcast_i32x4 6304 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3> 6305 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 6306 return _mm512_maskz_broadcast_i32x4(__M, _mm_loadu_si128(__A)); 6307 } 6308 6309 __m512i test_mm512_broadcast_i64x4(__m256i const* __A) { 6310 // CHECK-LABEL: test_mm512_broadcast_i64x4 6311 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3> 6312 return _mm512_broadcast_i64x4(_mm256_loadu_si256(__A)); 6313 } 6314 6315 __m512i test_mm512_mask_broadcast_i64x4(__m512i __O, __mmask8 __M, __m256i const* __A) { 6316 // CHECK-LABEL: test_mm512_mask_broadcast_i64x4 6317 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3> 6318 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 6319 return _mm512_mask_broadcast_i64x4(__O, __M, _mm256_loadu_si256(__A)); 6320 } 6321 6322 __m512i test_mm512_maskz_broadcast_i64x4(__mmask8 __M, __m256i const* __A) { 6323 // CHECK-LABEL: test_mm512_maskz_broadcast_i64x4 6324 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 0, i32 1, i32 2, i32 3> 6325 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 6326 return _mm512_maskz_broadcast_i64x4(__M, _mm256_loadu_si256(__A)); 6327 } 6328 6329 __m512d test_mm512_broadcastsd_pd(__m128d __A) { 6330 // CHECK-LABEL: test_mm512_broadcastsd_pd 6331 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <8 x i32> zeroinitializer 6332 return _mm512_broadcastsd_pd(__A); 6333 } 6334 6335 __m512d test_mm512_mask_broadcastsd_pd(__m512d __O, __mmask8 __M, __m128d __A) { 6336 // CHECK-LABEL: test_mm512_mask_broadcastsd_pd 6337 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <8 x i32> zeroinitializer 6338 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 6339 return _mm512_mask_broadcastsd_pd(__O, __M, __A); 6340 } 6341 6342 __m512d test_mm512_maskz_broadcastsd_pd(__mmask8 __M, __m128d __A) { 6343 // CHECK-LABEL: test_mm512_maskz_broadcastsd_pd 6344 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <8 x i32> zeroinitializer 6345 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 6346 return _mm512_maskz_broadcastsd_pd(__M, __A); 6347 } 6348 6349 __m512 test_mm512_broadcastss_ps(__m128 __A) { 6350 // CHECK-LABEL: test_mm512_broadcastss_ps 6351 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <16 x i32> zeroinitializer 6352 return _mm512_broadcastss_ps(__A); 6353 } 6354 6355 __m512 test_mm512_mask_broadcastss_ps(__m512 __O, __mmask16 __M, __m128 __A) { 6356 // CHECK-LABEL: test_mm512_mask_broadcastss_ps 6357 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <16 x i32> zeroinitializer 6358 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 6359 return _mm512_mask_broadcastss_ps(__O, __M, __A); 6360 } 6361 6362 __m512 test_mm512_maskz_broadcastss_ps(__mmask16 __M, __m128 __A) { 6363 // CHECK-LABEL: test_mm512_maskz_broadcastss_ps 6364 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <16 x i32> zeroinitializer 6365 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 6366 return _mm512_maskz_broadcastss_ps(__M, __A); 6367 } 6368 6369 __m512i test_mm512_broadcastd_epi32(__m128i __A) { 6370 // CHECK-LABEL: test_mm512_broadcastd_epi32 6371 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i32> zeroinitializer 6372 return _mm512_broadcastd_epi32(__A); 6373 } 6374 6375 __m512i test_mm512_mask_broadcastd_epi32(__m512i __O, __mmask16 __M, __m128i __A) { 6376 // CHECK-LABEL: test_mm512_mask_broadcastd_epi32 6377 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i32> zeroinitializer 6378 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 6379 return _mm512_mask_broadcastd_epi32(__O, __M, __A); 6380 } 6381 6382 __m512i test_mm512_maskz_broadcastd_epi32(__mmask16 __M, __m128i __A) { 6383 // CHECK-LABEL: test_mm512_maskz_broadcastd_epi32 6384 // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <16 x i32> zeroinitializer 6385 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 6386 return _mm512_maskz_broadcastd_epi32(__M, __A); 6387 } 6388 6389 __m512i test_mm512_broadcastq_epi64(__m128i __A) { 6390 // CHECK-LABEL: test_mm512_broadcastq_epi64 6391 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <8 x i32> zeroinitializer 6392 return _mm512_broadcastq_epi64(__A); 6393 } 6394 6395 __m512i test_mm512_mask_broadcastq_epi64(__m512i __O, __mmask8 __M, __m128i __A) { 6396 // CHECK-LABEL: test_mm512_mask_broadcastq_epi64 6397 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <8 x i32> zeroinitializer 6398 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 6399 return _mm512_mask_broadcastq_epi64(__O, __M, __A); 6400 } 6401 6402 __m512i test_mm512_maskz_broadcastq_epi64(__mmask8 __M, __m128i __A) { 6403 // CHECK-LABEL: test_mm512_maskz_broadcastq_epi64 6404 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <8 x i32> zeroinitializer 6405 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 6406 return _mm512_maskz_broadcastq_epi64(__M, __A); 6407 } 6408 6409 __m128i test_mm512_cvtsepi32_epi8(__m512i __A) { 6410 // CHECK-LABEL: test_mm512_cvtsepi32_epi8 6411 // CHECK: @llvm.x86.avx512.mask.pmovs.db.512 6412 return _mm512_cvtsepi32_epi8(__A); 6413 } 6414 6415 __m128i test_mm512_mask_cvtsepi32_epi8(__m128i __O, __mmask16 __M, __m512i __A) { 6416 // CHECK-LABEL: test_mm512_mask_cvtsepi32_epi8 6417 // CHECK: @llvm.x86.avx512.mask.pmovs.db.512 6418 return _mm512_mask_cvtsepi32_epi8(__O, __M, __A); 6419 } 6420 6421 __m128i test_mm512_maskz_cvtsepi32_epi8(__mmask16 __M, __m512i __A) { 6422 // CHECK-LABEL: test_mm512_maskz_cvtsepi32_epi8 6423 // CHECK: @llvm.x86.avx512.mask.pmovs.db.512 6424 return _mm512_maskz_cvtsepi32_epi8(__M, __A); 6425 } 6426 6427 void test_mm512_mask_cvtsepi32_storeu_epi8(void * __P, __mmask16 __M, __m512i __A) { 6428 // CHECK-LABEL: test_mm512_mask_cvtsepi32_storeu_epi8 6429 // CHECK: @llvm.x86.avx512.mask.pmovs.db.mem.512 6430 return _mm512_mask_cvtsepi32_storeu_epi8(__P, __M, __A); 6431 } 6432 6433 __m256i test_mm512_cvtsepi32_epi16(__m512i __A) { 6434 // CHECK-LABEL: test_mm512_cvtsepi32_epi16 6435 // CHECK: @llvm.x86.avx512.mask.pmovs.dw.512 6436 return _mm512_cvtsepi32_epi16(__A); 6437 } 6438 6439 __m256i test_mm512_mask_cvtsepi32_epi16(__m256i __O, __mmask16 __M, __m512i __A) { 6440 // CHECK-LABEL: test_mm512_mask_cvtsepi32_epi16 6441 // CHECK: @llvm.x86.avx512.mask.pmovs.dw.512 6442 return _mm512_mask_cvtsepi32_epi16(__O, __M, __A); 6443 } 6444 6445 __m256i test_mm512_maskz_cvtsepi32_epi16(__mmask16 __M, __m512i __A) { 6446 // CHECK-LABEL: test_mm512_maskz_cvtsepi32_epi16 6447 // CHECK: @llvm.x86.avx512.mask.pmovs.dw.512 6448 return _mm512_maskz_cvtsepi32_epi16(__M, __A); 6449 } 6450 6451 void test_mm512_mask_cvtsepi32_storeu_epi16(void *__P, __mmask16 __M, __m512i __A) { 6452 // CHECK-LABEL: test_mm512_mask_cvtsepi32_storeu_epi16 6453 // CHECK: @llvm.x86.avx512.mask.pmovs.dw.mem.512 6454 return _mm512_mask_cvtsepi32_storeu_epi16(__P, __M, __A); 6455 } 6456 6457 __m128i test_mm512_cvtsepi64_epi8(__m512i __A) { 6458 // CHECK-LABEL: test_mm512_cvtsepi64_epi8 6459 // CHECK: @llvm.x86.avx512.mask.pmovs.qb.512 6460 return _mm512_cvtsepi64_epi8(__A); 6461 } 6462 6463 __m128i test_mm512_mask_cvtsepi64_epi8(__m128i __O, __mmask8 __M, __m512i __A) { 6464 // CHECK-LABEL: test_mm512_mask_cvtsepi64_epi8 6465 // CHECK: @llvm.x86.avx512.mask.pmovs.qb.512 6466 return _mm512_mask_cvtsepi64_epi8(__O, __M, __A); 6467 } 6468 6469 __m128i test_mm512_maskz_cvtsepi64_epi8(__mmask8 __M, __m512i __A) { 6470 // CHECK-LABEL: test_mm512_maskz_cvtsepi64_epi8 6471 // CHECK: @llvm.x86.avx512.mask.pmovs.qb.512 6472 return _mm512_maskz_cvtsepi64_epi8(__M, __A); 6473 } 6474 6475 void test_mm512_mask_cvtsepi64_storeu_epi8(void * __P, __mmask8 __M, __m512i __A) { 6476 // CHECK-LABEL: test_mm512_mask_cvtsepi64_storeu_epi8 6477 // CHECK: @llvm.x86.avx512.mask.pmovs.qb.mem.512 6478 return _mm512_mask_cvtsepi64_storeu_epi8(__P, __M, __A); 6479 } 6480 6481 __m256i test_mm512_cvtsepi64_epi32(__m512i __A) { 6482 // CHECK-LABEL: test_mm512_cvtsepi64_epi32 6483 // CHECK: @llvm.x86.avx512.mask.pmovs.qd.512 6484 return _mm512_cvtsepi64_epi32(__A); 6485 } 6486 6487 __m256i test_mm512_mask_cvtsepi64_epi32(__m256i __O, __mmask8 __M, __m512i __A) { 6488 // CHECK-LABEL: test_mm512_mask_cvtsepi64_epi32 6489 // CHECK: @llvm.x86.avx512.mask.pmovs.qd.512 6490 return _mm512_mask_cvtsepi64_epi32(__O, __M, __A); 6491 } 6492 6493 __m256i test_mm512_maskz_cvtsepi64_epi32(__mmask8 __M, __m512i __A) { 6494 // CHECK-LABEL: test_mm512_maskz_cvtsepi64_epi32 6495 // CHECK: @llvm.x86.avx512.mask.pmovs.qd.512 6496 return _mm512_maskz_cvtsepi64_epi32(__M, __A); 6497 } 6498 6499 void test_mm512_mask_cvtsepi64_storeu_epi32(void *__P, __mmask8 __M, __m512i __A) { 6500 // CHECK-LABEL: test_mm512_mask_cvtsepi64_storeu_epi32 6501 // CHECK: @llvm.x86.avx512.mask.pmovs.qd.mem.512 6502 return _mm512_mask_cvtsepi64_storeu_epi32(__P, __M, __A); 6503 } 6504 6505 __m128i test_mm512_cvtsepi64_epi16(__m512i __A) { 6506 // CHECK-LABEL: test_mm512_cvtsepi64_epi16 6507 // CHECK: @llvm.x86.avx512.mask.pmovs.qw.512 6508 return _mm512_cvtsepi64_epi16(__A); 6509 } 6510 6511 __m128i test_mm512_mask_cvtsepi64_epi16(__m128i __O, __mmask8 __M, __m512i __A) { 6512 // CHECK-LABEL: test_mm512_mask_cvtsepi64_epi16 6513 // CHECK: @llvm.x86.avx512.mask.pmovs.qw.512 6514 return _mm512_mask_cvtsepi64_epi16(__O, __M, __A); 6515 } 6516 6517 __m128i test_mm512_maskz_cvtsepi64_epi16(__mmask8 __M, __m512i __A) { 6518 // CHECK-LABEL: test_mm512_maskz_cvtsepi64_epi16 6519 // CHECK: @llvm.x86.avx512.mask.pmovs.qw.512 6520 return _mm512_maskz_cvtsepi64_epi16(__M, __A); 6521 } 6522 6523 void test_mm512_mask_cvtsepi64_storeu_epi16(void * __P, __mmask8 __M, __m512i __A) { 6524 // CHECK-LABEL: test_mm512_mask_cvtsepi64_storeu_epi16 6525 // CHECK: @llvm.x86.avx512.mask.pmovs.qw.mem.512 6526 return _mm512_mask_cvtsepi64_storeu_epi16(__P, __M, __A); 6527 } 6528 6529 __m128i test_mm512_cvtusepi32_epi8(__m512i __A) { 6530 // CHECK-LABEL: test_mm512_cvtusepi32_epi8 6531 // CHECK: @llvm.x86.avx512.mask.pmovus.db.512 6532 return _mm512_cvtusepi32_epi8(__A); 6533 } 6534 6535 __m128i test_mm512_mask_cvtusepi32_epi8(__m128i __O, __mmask16 __M, __m512i __A) { 6536 // CHECK-LABEL: test_mm512_mask_cvtusepi32_epi8 6537 // CHECK: @llvm.x86.avx512.mask.pmovus.db.512 6538 return _mm512_mask_cvtusepi32_epi8(__O, __M, __A); 6539 } 6540 6541 __m128i test_mm512_maskz_cvtusepi32_epi8(__mmask16 __M, __m512i __A) { 6542 // CHECK-LABEL: test_mm512_maskz_cvtusepi32_epi8 6543 // CHECK: @llvm.x86.avx512.mask.pmovus.db.512 6544 return _mm512_maskz_cvtusepi32_epi8(__M, __A); 6545 } 6546 6547 void test_mm512_mask_cvtusepi32_storeu_epi8(void * __P, __mmask16 __M, __m512i __A) { 6548 // CHECK-LABEL: test_mm512_mask_cvtusepi32_storeu_epi8 6549 // CHECK: @llvm.x86.avx512.mask.pmovus.db.mem.512 6550 return _mm512_mask_cvtusepi32_storeu_epi8(__P, __M, __A); 6551 } 6552 6553 __m256i test_mm512_cvtusepi32_epi16(__m512i __A) { 6554 // CHECK-LABEL: test_mm512_cvtusepi32_epi16 6555 // CHECK: @llvm.x86.avx512.mask.pmovus.dw.512 6556 return _mm512_cvtusepi32_epi16(__A); 6557 } 6558 6559 __m256i test_mm512_mask_cvtusepi32_epi16(__m256i __O, __mmask16 __M, __m512i __A) { 6560 // CHECK-LABEL: test_mm512_mask_cvtusepi32_epi16 6561 // CHECK: @llvm.x86.avx512.mask.pmovus.dw.512 6562 return _mm512_mask_cvtusepi32_epi16(__O, __M, __A); 6563 } 6564 6565 __m256i test_mm512_maskz_cvtusepi32_epi16(__mmask16 __M, __m512i __A) { 6566 // CHECK-LABEL: test_mm512_maskz_cvtusepi32_epi16 6567 // CHECK: @llvm.x86.avx512.mask.pmovus.dw.512 6568 return _mm512_maskz_cvtusepi32_epi16(__M, __A); 6569 } 6570 6571 void test_mm512_mask_cvtusepi32_storeu_epi16(void *__P, __mmask16 __M, __m512i __A) { 6572 // CHECK-LABEL: test_mm512_mask_cvtusepi32_storeu_epi16 6573 // CHECK: @llvm.x86.avx512.mask.pmovus.dw.mem.512 6574 return _mm512_mask_cvtusepi32_storeu_epi16(__P, __M, __A); 6575 } 6576 6577 __m128i test_mm512_cvtusepi64_epi8(__m512i __A) { 6578 // CHECK-LABEL: test_mm512_cvtusepi64_epi8 6579 // CHECK: @llvm.x86.avx512.mask.pmovus.qb.512 6580 return _mm512_cvtusepi64_epi8(__A); 6581 } 6582 6583 __m128i test_mm512_mask_cvtusepi64_epi8(__m128i __O, __mmask8 __M, __m512i __A) { 6584 // CHECK-LABEL: test_mm512_mask_cvtusepi64_epi8 6585 // CHECK: @llvm.x86.avx512.mask.pmovus.qb.512 6586 return _mm512_mask_cvtusepi64_epi8(__O, __M, __A); 6587 } 6588 6589 __m128i test_mm512_maskz_cvtusepi64_epi8(__mmask8 __M, __m512i __A) { 6590 // CHECK-LABEL: test_mm512_maskz_cvtusepi64_epi8 6591 // CHECK: @llvm.x86.avx512.mask.pmovus.qb.512 6592 return _mm512_maskz_cvtusepi64_epi8(__M, __A); 6593 } 6594 6595 void test_mm512_mask_cvtusepi64_storeu_epi8(void * __P, __mmask8 __M, __m512i __A) { 6596 // CHECK-LABEL: test_mm512_mask_cvtusepi64_storeu_epi8 6597 // CHECK: @llvm.x86.avx512.mask.pmovus.qb.mem.512 6598 return _mm512_mask_cvtusepi64_storeu_epi8(__P, __M, __A); 6599 } 6600 6601 __m256i test_mm512_cvtusepi64_epi32(__m512i __A) { 6602 // CHECK-LABEL: test_mm512_cvtusepi64_epi32 6603 // CHECK: @llvm.x86.avx512.mask.pmovus.qd.512 6604 return _mm512_cvtusepi64_epi32(__A); 6605 } 6606 6607 __m256i test_mm512_mask_cvtusepi64_epi32(__m256i __O, __mmask8 __M, __m512i __A) { 6608 // CHECK-LABEL: test_mm512_mask_cvtusepi64_epi32 6609 // CHECK: @llvm.x86.avx512.mask.pmovus.qd.512 6610 return _mm512_mask_cvtusepi64_epi32(__O, __M, __A); 6611 } 6612 6613 __m256i test_mm512_maskz_cvtusepi64_epi32(__mmask8 __M, __m512i __A) { 6614 // CHECK-LABEL: test_mm512_maskz_cvtusepi64_epi32 6615 // CHECK: @llvm.x86.avx512.mask.pmovus.qd.512 6616 return _mm512_maskz_cvtusepi64_epi32(__M, __A); 6617 } 6618 6619 void test_mm512_mask_cvtusepi64_storeu_epi32(void* __P, __mmask8 __M, __m512i __A) { 6620 // CHECK-LABEL: test_mm512_mask_cvtusepi64_storeu_epi32 6621 // CHECK: @llvm.x86.avx512.mask.pmovus.qd.mem.512 6622 return _mm512_mask_cvtusepi64_storeu_epi32(__P, __M, __A); 6623 } 6624 6625 __m128i test_mm512_cvtusepi64_epi16(__m512i __A) { 6626 // CHECK-LABEL: test_mm512_cvtusepi64_epi16 6627 // CHECK: @llvm.x86.avx512.mask.pmovus.qw.512 6628 return _mm512_cvtusepi64_epi16(__A); 6629 } 6630 6631 __m128i test_mm512_mask_cvtusepi64_epi16(__m128i __O, __mmask8 __M, __m512i __A) { 6632 // CHECK-LABEL: test_mm512_mask_cvtusepi64_epi16 6633 // CHECK: @llvm.x86.avx512.mask.pmovus.qw.512 6634 return _mm512_mask_cvtusepi64_epi16(__O, __M, __A); 6635 } 6636 6637 __m128i test_mm512_maskz_cvtusepi64_epi16(__mmask8 __M, __m512i __A) { 6638 // CHECK-LABEL: test_mm512_maskz_cvtusepi64_epi16 6639 // CHECK: @llvm.x86.avx512.mask.pmovus.qw.512 6640 return _mm512_maskz_cvtusepi64_epi16(__M, __A); 6641 } 6642 6643 void test_mm512_mask_cvtusepi64_storeu_epi16(void *__P, __mmask8 __M, __m512i __A) { 6644 // CHECK-LABEL: test_mm512_mask_cvtusepi64_storeu_epi16 6645 // CHECK: @llvm.x86.avx512.mask.pmovus.qw.mem.512 6646 return _mm512_mask_cvtusepi64_storeu_epi16(__P, __M, __A); 6647 } 6648 6649 __m128i test_mm512_cvtepi32_epi8(__m512i __A) { 6650 // CHECK-LABEL: test_mm512_cvtepi32_epi8 6651 // CHECK: trunc <16 x i32> %{{.*}} to <16 x i8> 6652 return _mm512_cvtepi32_epi8(__A); 6653 } 6654 6655 __m128i test_mm512_mask_cvtepi32_epi8(__m128i __O, __mmask16 __M, __m512i __A) { 6656 // CHECK-LABEL: test_mm512_mask_cvtepi32_epi8 6657 // CHECK: @llvm.x86.avx512.mask.pmov.db.512 6658 return _mm512_mask_cvtepi32_epi8(__O, __M, __A); 6659 } 6660 6661 __m128i test_mm512_maskz_cvtepi32_epi8(__mmask16 __M, __m512i __A) { 6662 // CHECK-LABEL: test_mm512_maskz_cvtepi32_epi8 6663 // CHECK: @llvm.x86.avx512.mask.pmov.db.512 6664 return _mm512_maskz_cvtepi32_epi8(__M, __A); 6665 } 6666 6667 void test_mm512_mask_cvtepi32_storeu_epi8(void * __P, __mmask16 __M, __m512i __A) { 6668 // CHECK-LABEL: test_mm512_mask_cvtepi32_storeu_epi8 6669 // CHECK: @llvm.x86.avx512.mask.pmov.db.mem.512 6670 return _mm512_mask_cvtepi32_storeu_epi8(__P, __M, __A); 6671 } 6672 6673 __m256i test_mm512_cvtepi32_epi16(__m512i __A) { 6674 // CHECK-LABEL: test_mm512_cvtepi32_epi16 6675 // CHECK: trunc <16 x i32> %{{.*}} to <16 x i16> 6676 return _mm512_cvtepi32_epi16(__A); 6677 } 6678 6679 __m256i test_mm512_mask_cvtepi32_epi16(__m256i __O, __mmask16 __M, __m512i __A) { 6680 // CHECK-LABEL: test_mm512_mask_cvtepi32_epi16 6681 // CHECK: @llvm.x86.avx512.mask.pmov.dw.512 6682 return _mm512_mask_cvtepi32_epi16(__O, __M, __A); 6683 } 6684 6685 __m256i test_mm512_maskz_cvtepi32_epi16(__mmask16 __M, __m512i __A) { 6686 // CHECK-LABEL: test_mm512_maskz_cvtepi32_epi16 6687 // CHECK: @llvm.x86.avx512.mask.pmov.dw.512 6688 return _mm512_maskz_cvtepi32_epi16(__M, __A); 6689 } 6690 6691 void test_mm512_mask_cvtepi32_storeu_epi16(void * __P, __mmask16 __M, __m512i __A) { 6692 // CHECK-LABEL: test_mm512_mask_cvtepi32_storeu_epi16 6693 // CHECK: @llvm.x86.avx512.mask.pmov.dw.mem.512 6694 return _mm512_mask_cvtepi32_storeu_epi16(__P, __M, __A); 6695 } 6696 6697 __m128i test_mm512_cvtepi64_epi8(__m512i __A) { 6698 // CHECK-LABEL: test_mm512_cvtepi64_epi8 6699 // CHECK: @llvm.x86.avx512.mask.pmov.qb.512 6700 return _mm512_cvtepi64_epi8(__A); 6701 } 6702 6703 __m128i test_mm512_mask_cvtepi64_epi8(__m128i __O, __mmask8 __M, __m512i __A) { 6704 // CHECK-LABEL: test_mm512_mask_cvtepi64_epi8 6705 // CHECK: @llvm.x86.avx512.mask.pmov.qb.512 6706 return _mm512_mask_cvtepi64_epi8(__O, __M, __A); 6707 } 6708 6709 __m128i test_mm512_maskz_cvtepi64_epi8(__mmask8 __M, __m512i __A) { 6710 // CHECK-LABEL: test_mm512_maskz_cvtepi64_epi8 6711 // CHECK: @llvm.x86.avx512.mask.pmov.qb.512 6712 return _mm512_maskz_cvtepi64_epi8(__M, __A); 6713 } 6714 6715 void test_mm512_mask_cvtepi64_storeu_epi8(void * __P, __mmask8 __M, __m512i __A) { 6716 // CHECK-LABEL: test_mm512_mask_cvtepi64_storeu_epi8 6717 // CHECK: @llvm.x86.avx512.mask.pmov.qb.mem.512 6718 return _mm512_mask_cvtepi64_storeu_epi8(__P, __M, __A); 6719 } 6720 6721 __m256i test_mm512_cvtepi64_epi32(__m512i __A) { 6722 // CHECK-LABEL: test_mm512_cvtepi64_epi32 6723 // CHECK: trunc <8 x i64> %{{.*}} to <8 x i32> 6724 return _mm512_cvtepi64_epi32(__A); 6725 } 6726 6727 __m256i test_mm512_mask_cvtepi64_epi32(__m256i __O, __mmask8 __M, __m512i __A) { 6728 // CHECK-LABEL: test_mm512_mask_cvtepi64_epi32 6729 // CHECK: trunc <8 x i64> %{{.*}} to <8 x i32> 6730 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}} 6731 return _mm512_mask_cvtepi64_epi32(__O, __M, __A); 6732 } 6733 6734 __m256i test_mm512_maskz_cvtepi64_epi32(__mmask8 __M, __m512i __A) { 6735 // CHECK-LABEL: test_mm512_maskz_cvtepi64_epi32 6736 // CHECK: trunc <8 x i64> %{{.*}} to <8 x i32> 6737 // CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}} 6738 return _mm512_maskz_cvtepi64_epi32(__M, __A); 6739 } 6740 6741 void test_mm512_mask_cvtepi64_storeu_epi32(void* __P, __mmask8 __M, __m512i __A) { 6742 // CHECK-LABEL: test_mm512_mask_cvtepi64_storeu_epi32 6743 // CHECK: @llvm.x86.avx512.mask.pmov.qd.mem.512 6744 return _mm512_mask_cvtepi64_storeu_epi32(__P, __M, __A); 6745 } 6746 6747 __m128i test_mm512_cvtepi64_epi16(__m512i __A) { 6748 // CHECK-LABEL: test_mm512_cvtepi64_epi16 6749 // CHECK: trunc <8 x i64> %{{.*}} to <8 x i16> 6750 return _mm512_cvtepi64_epi16(__A); 6751 } 6752 6753 __m128i test_mm512_mask_cvtepi64_epi16(__m128i __O, __mmask8 __M, __m512i __A) { 6754 // CHECK-LABEL: test_mm512_mask_cvtepi64_epi16 6755 // CHECK: @llvm.x86.avx512.mask.pmov.qw.512 6756 return _mm512_mask_cvtepi64_epi16(__O, __M, __A); 6757 } 6758 6759 __m128i test_mm512_maskz_cvtepi64_epi16(__mmask8 __M, __m512i __A) { 6760 // CHECK-LABEL: test_mm512_maskz_cvtepi64_epi16 6761 // CHECK: @llvm.x86.avx512.mask.pmov.qw.512 6762 return _mm512_maskz_cvtepi64_epi16(__M, __A); 6763 } 6764 6765 void test_mm512_mask_cvtepi64_storeu_epi16(void *__P, __mmask8 __M, __m512i __A) { 6766 // CHECK-LABEL: test_mm512_mask_cvtepi64_storeu_epi16 6767 // CHECK: @llvm.x86.avx512.mask.pmov.qw.mem.512 6768 return _mm512_mask_cvtepi64_storeu_epi16(__P, __M, __A); 6769 } 6770 6771 __m128i test_mm512_extracti32x4_epi32(__m512i __A) { 6772 // CHECK-LABEL: test_mm512_extracti32x4_epi32 6773 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> poison, <4 x i32> <i32 12, i32 13, i32 14, i32 15> 6774 return _mm512_extracti32x4_epi32(__A, 3); 6775 } 6776 6777 __m128i test_mm512_mask_extracti32x4_epi32(__m128i __W, __mmask8 __U, __m512i __A) { 6778 // CHECK-LABEL: test_mm512_mask_extracti32x4_epi32 6779 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> poison, <4 x i32> <i32 12, i32 13, i32 14, i32 15> 6780 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}} 6781 return _mm512_mask_extracti32x4_epi32(__W, __U, __A, 3); 6782 } 6783 6784 __m128i test_mm512_maskz_extracti32x4_epi32(__mmask8 __U, __m512i __A) { 6785 // CHECK-LABEL: test_mm512_maskz_extracti32x4_epi32 6786 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> poison, <4 x i32> <i32 12, i32 13, i32 14, i32 15> 6787 // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}} 6788 return _mm512_maskz_extracti32x4_epi32(__U, __A, 3); 6789 } 6790 6791 __m256i test_mm512_extracti64x4_epi64(__m512i __A) { 6792 // CHECK-LABEL: test_mm512_extracti64x4_epi64 6793 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7> 6794 return _mm512_extracti64x4_epi64(__A, 1); 6795 } 6796 6797 __m256i test_mm512_mask_extracti64x4_epi64(__m256i __W, __mmask8 __U, __m512i __A) { 6798 // CHECK-LABEL: test_mm512_mask_extracti64x4_epi64 6799 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7> 6800 // CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}} 6801 return _mm512_mask_extracti64x4_epi64(__W, __U, __A, 1); 6802 } 6803 6804 __m256i test_mm512_maskz_extracti64x4_epi64(__mmask8 __U, __m512i __A) { 6805 // CHECK-LABEL: test_mm512_maskz_extracti64x4_epi64 6806 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> poison, <4 x i32> <i32 4, i32 5, i32 6, i32 7> 6807 // CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}} 6808 return _mm512_maskz_extracti64x4_epi64(__U, __A, 1); 6809 } 6810 6811 __m512d test_mm512_insertf64x4(__m512d __A, __m256d __B) { 6812 // CHECK-LABEL: test_mm512_insertf64x4 6813 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11> 6814 return _mm512_insertf64x4(__A, __B, 1); 6815 } 6816 6817 __m512d test_mm512_mask_insertf64x4(__m512d __W, __mmask8 __U, __m512d __A, __m256d __B) { 6818 // CHECK-LABEL: test_mm512_mask_insertf64x4 6819 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11> 6820 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 6821 return _mm512_mask_insertf64x4(__W, __U, __A, __B, 1); 6822 } 6823 6824 __m512d test_mm512_maskz_insertf64x4(__mmask8 __U, __m512d __A, __m256d __B) { 6825 // CHECK-LABEL: test_mm512_maskz_insertf64x4 6826 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11> 6827 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 6828 return _mm512_maskz_insertf64x4(__U, __A, __B, 1); 6829 } 6830 6831 __m512i test_mm512_inserti64x4(__m512i __A, __m256i __B) { 6832 // CHECK-LABEL: test_mm512_inserti64x4 6833 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11> 6834 return _mm512_inserti64x4(__A, __B, 1); 6835 } 6836 6837 __m512i test_mm512_mask_inserti64x4(__m512i __W, __mmask8 __U, __m512i __A, __m256i __B) { 6838 // CHECK-LABEL: test_mm512_mask_inserti64x4 6839 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11> 6840 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 6841 return _mm512_mask_inserti64x4(__W, __U, __A, __B, 1); 6842 } 6843 6844 __m512i test_mm512_maskz_inserti64x4(__mmask8 __U, __m512i __A, __m256i __B) { 6845 // CHECK-LABEL: test_mm512_maskz_inserti64x4 6846 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 8, i32 9, i32 10, i32 11> 6847 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 6848 return _mm512_maskz_inserti64x4(__U, __A, __B, 1); 6849 } 6850 6851 __m512 test_mm512_insertf32x4(__m512 __A, __m128 __B) { 6852 // CHECK-LABEL: test_mm512_insertf32x4 6853 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 16, i32 17, i32 18, i32 19, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15> 6854 return _mm512_insertf32x4(__A, __B, 1); 6855 } 6856 6857 __m512 test_mm512_mask_insertf32x4(__m512 __W, __mmask16 __U, __m512 __A, __m128 __B) { 6858 // CHECK-LABEL: test_mm512_mask_insertf32x4 6859 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 16, i32 17, i32 18, i32 19, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15> 6860 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 6861 return _mm512_mask_insertf32x4(__W, __U, __A, __B, 1); 6862 } 6863 6864 __m512 test_mm512_maskz_insertf32x4(__mmask16 __U, __m512 __A, __m128 __B) { 6865 // CHECK-LABEL: test_mm512_maskz_insertf32x4 6866 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 16, i32 17, i32 18, i32 19, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15> 6867 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 6868 return _mm512_maskz_insertf32x4(__U, __A, __B, 1); 6869 } 6870 6871 __m512i test_mm512_inserti32x4(__m512i __A, __m128i __B) { 6872 // CHECK-LABEL: test_mm512_inserti32x4 6873 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 16, i32 17, i32 18, i32 19, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15> 6874 return _mm512_inserti32x4(__A, __B, 1); 6875 } 6876 6877 __m512i test_mm512_mask_inserti32x4(__m512i __W, __mmask16 __U, __m512i __A, __m128i __B) { 6878 // CHECK-LABEL: test_mm512_mask_inserti32x4 6879 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 16, i32 17, i32 18, i32 19, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15> 6880 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 6881 return _mm512_mask_inserti32x4(__W, __U, __A, __B, 1); 6882 } 6883 6884 __m512i test_mm512_maskz_inserti32x4(__mmask16 __U, __m512i __A, __m128i __B) { 6885 // CHECK-LABEL: test_mm512_maskz_inserti32x4 6886 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 16, i32 17, i32 18, i32 19, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15> 6887 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 6888 return _mm512_maskz_inserti32x4(__U, __A, __B, 1); 6889 } 6890 6891 __m512d test_mm512_getmant_round_pd(__m512d __A) { 6892 // CHECK-LABEL: test_mm512_getmant_round_pd 6893 // CHECK: @llvm.x86.avx512.mask.getmant.pd.512 6894 return _mm512_getmant_round_pd(__A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC); 6895 } 6896 6897 __m512d test_mm512_mask_getmant_round_pd(__m512d __W, __mmask8 __U, __m512d __A) { 6898 // CHECK-LABEL: test_mm512_mask_getmant_round_pd 6899 // CHECK: @llvm.x86.avx512.mask.getmant.pd.512 6900 return _mm512_mask_getmant_round_pd(__W, __U, __A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC); 6901 } 6902 6903 __m512d test_mm512_maskz_getmant_round_pd(__mmask8 __U, __m512d __A) { 6904 // CHECK-LABEL: test_mm512_maskz_getmant_round_pd 6905 // CHECK: @llvm.x86.avx512.mask.getmant.pd.512 6906 return _mm512_maskz_getmant_round_pd(__U, __A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC); 6907 } 6908 6909 __m512d test_mm512_getmant_pd(__m512d __A) { 6910 // CHECK-LABEL: test_mm512_getmant_pd 6911 // CHECK: @llvm.x86.avx512.mask.getmant.pd.512 6912 return _mm512_getmant_pd(__A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan); 6913 } 6914 6915 __m512d test_mm512_mask_getmant_pd(__m512d __W, __mmask8 __U, __m512d __A) { 6916 // CHECK-LABEL: test_mm512_mask_getmant_pd 6917 // CHECK: @llvm.x86.avx512.mask.getmant.pd.512 6918 return _mm512_mask_getmant_pd(__W, __U, __A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan); 6919 } 6920 6921 __m512d test_mm512_maskz_getmant_pd(__mmask8 __U, __m512d __A) { 6922 // CHECK-LABEL: test_mm512_maskz_getmant_pd 6923 // CHECK: @llvm.x86.avx512.mask.getmant.pd.512 6924 return _mm512_maskz_getmant_pd(__U, __A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan); 6925 } 6926 6927 __m512 test_mm512_getmant_round_ps(__m512 __A) { 6928 // CHECK-LABEL: test_mm512_getmant_round_ps 6929 // CHECK: @llvm.x86.avx512.mask.getmant.ps.512 6930 return _mm512_getmant_round_ps(__A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC); 6931 } 6932 6933 __m512 test_mm512_mask_getmant_round_ps(__m512 __W, __mmask16 __U, __m512 __A) { 6934 // CHECK-LABEL: test_mm512_mask_getmant_round_ps 6935 // CHECK: @llvm.x86.avx512.mask.getmant.ps.512 6936 return _mm512_mask_getmant_round_ps(__W, __U, __A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC); 6937 } 6938 6939 __m512 test_mm512_maskz_getmant_round_ps(__mmask16 __U, __m512 __A) { 6940 // CHECK-LABEL: test_mm512_maskz_getmant_round_ps 6941 // CHECK: @llvm.x86.avx512.mask.getmant.ps.512 6942 return _mm512_maskz_getmant_round_ps(__U, __A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC); 6943 } 6944 6945 __m512 test_mm512_getmant_ps(__m512 __A) { 6946 // CHECK-LABEL: test_mm512_getmant_ps 6947 // CHECK: @llvm.x86.avx512.mask.getmant.ps.512 6948 return _mm512_getmant_ps(__A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan); 6949 } 6950 6951 __m512 test_mm512_mask_getmant_ps(__m512 __W, __mmask16 __U, __m512 __A) { 6952 // CHECK-LABEL: test_mm512_mask_getmant_ps 6953 // CHECK: @llvm.x86.avx512.mask.getmant.ps.512 6954 return _mm512_mask_getmant_ps(__W, __U, __A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan); 6955 } 6956 6957 __m512 test_mm512_maskz_getmant_ps(__mmask16 __U, __m512 __A) { 6958 // CHECK-LABEL: test_mm512_maskz_getmant_ps 6959 // CHECK: @llvm.x86.avx512.mask.getmant.ps.512 6960 return _mm512_maskz_getmant_ps(__U, __A,_MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan); 6961 } 6962 6963 __m512d test_mm512_getexp_round_pd(__m512d __A) { 6964 // CHECK-LABEL: test_mm512_getexp_round_pd 6965 // CHECK: @llvm.x86.avx512.mask.getexp.pd.512 6966 return _mm512_getexp_round_pd(__A, _MM_FROUND_NO_EXC); 6967 } 6968 6969 __m512d test_mm512_mask_getexp_round_pd(__m512d __W, __mmask8 __U, __m512d __A) { 6970 // CHECK-LABEL: test_mm512_mask_getexp_round_pd 6971 // CHECK: @llvm.x86.avx512.mask.getexp.pd.512 6972 return _mm512_mask_getexp_round_pd(__W, __U, __A, _MM_FROUND_NO_EXC); 6973 } 6974 6975 __m512d test_mm512_maskz_getexp_round_pd(__mmask8 __U, __m512d __A) { 6976 // CHECK-LABEL: test_mm512_maskz_getexp_round_pd 6977 // CHECK: @llvm.x86.avx512.mask.getexp.pd.512 6978 return _mm512_maskz_getexp_round_pd(__U, __A, _MM_FROUND_NO_EXC); 6979 } 6980 6981 __m512d test_mm512_getexp_pd(__m512d __A) { 6982 // CHECK-LABEL: test_mm512_getexp_pd 6983 // CHECK: @llvm.x86.avx512.mask.getexp.pd.512 6984 return _mm512_getexp_pd(__A); 6985 } 6986 6987 __m512d test_mm512_mask_getexp_pd(__m512d __W, __mmask8 __U, __m512d __A) { 6988 // CHECK-LABEL: test_mm512_mask_getexp_pd 6989 // CHECK: @llvm.x86.avx512.mask.getexp.pd.512 6990 return _mm512_mask_getexp_pd(__W, __U, __A); 6991 } 6992 6993 __m512d test_mm512_maskz_getexp_pd(__mmask8 __U, __m512d __A) { 6994 // CHECK-LABEL: test_mm512_maskz_getexp_pd 6995 // CHECK: @llvm.x86.avx512.mask.getexp.pd.512 6996 return _mm512_maskz_getexp_pd(__U, __A); 6997 } 6998 6999 __m512 test_mm512_getexp_round_ps(__m512 __A) { 7000 // CHECK-LABEL: test_mm512_getexp_round_ps 7001 // CHECK: @llvm.x86.avx512.mask.getexp.ps.512 7002 return _mm512_getexp_round_ps(__A, _MM_FROUND_NO_EXC); 7003 } 7004 7005 __m512 test_mm512_mask_getexp_round_ps(__m512 __W, __mmask16 __U, __m512 __A) { 7006 // CHECK-LABEL: test_mm512_mask_getexp_round_ps 7007 // CHECK: @llvm.x86.avx512.mask.getexp.ps.512 7008 return _mm512_mask_getexp_round_ps(__W, __U, __A, _MM_FROUND_NO_EXC); 7009 } 7010 7011 __m512 test_mm512_maskz_getexp_round_ps(__mmask16 __U, __m512 __A) { 7012 // CHECK-LABEL: test_mm512_maskz_getexp_round_ps 7013 // CHECK: @llvm.x86.avx512.mask.getexp.ps.512 7014 return _mm512_maskz_getexp_round_ps(__U, __A, _MM_FROUND_NO_EXC); 7015 } 7016 7017 __m512 test_mm512_getexp_ps(__m512 __A) { 7018 // CHECK-LABEL: test_mm512_getexp_ps 7019 // CHECK: @llvm.x86.avx512.mask.getexp.ps.512 7020 return _mm512_getexp_ps(__A); 7021 } 7022 7023 __m512 test_mm512_mask_getexp_ps(__m512 __W, __mmask16 __U, __m512 __A) { 7024 // CHECK-LABEL: test_mm512_mask_getexp_ps 7025 // CHECK: @llvm.x86.avx512.mask.getexp.ps.512 7026 return _mm512_mask_getexp_ps(__W, __U, __A); 7027 } 7028 7029 __m512 test_mm512_maskz_getexp_ps(__mmask16 __U, __m512 __A) { 7030 // CHECK-LABEL: test_mm512_maskz_getexp_ps 7031 // CHECK: @llvm.x86.avx512.mask.getexp.ps.512 7032 return _mm512_maskz_getexp_ps(__U, __A); 7033 } 7034 7035 __m256 test_mm512_i64gather_ps(__m512i __index, void const *__addr) { 7036 // CHECK-LABEL: test_mm512_i64gather_ps 7037 // CHECK: @llvm.x86.avx512.mask.gather.qps.512 7038 return _mm512_i64gather_ps(__index, __addr, 2); 7039 } 7040 7041 __m256 test_mm512_mask_i64gather_ps(__m256 __v1_old, __mmask8 __mask, __m512i __index, void const *__addr) { 7042 // CHECK-LABEL: test_mm512_mask_i64gather_ps 7043 // CHECK: @llvm.x86.avx512.mask.gather.qps.512 7044 return _mm512_mask_i64gather_ps(__v1_old, __mask, __index, __addr, 2); 7045 } 7046 7047 __m256i test_mm512_i64gather_epi32(__m512i __index, void const *__addr) { 7048 // CHECK-LABEL: test_mm512_i64gather_epi32 7049 // CHECK: @llvm.x86.avx512.mask.gather.qpi.512 7050 return _mm512_i64gather_epi32(__index, __addr, 2); 7051 } 7052 7053 __m256i test_mm512_mask_i64gather_epi32(__m256i __v1_old, __mmask8 __mask, __m512i __index, void const *__addr) { 7054 // CHECK-LABEL: test_mm512_mask_i64gather_epi32 7055 // CHECK: @llvm.x86.avx512.mask.gather.qpi.512 7056 return _mm512_mask_i64gather_epi32(__v1_old, __mask, __index, __addr, 2); 7057 } 7058 7059 __m512d test_mm512_i64gather_pd(__m512i __index, void const *__addr) { 7060 // CHECK-LABEL: test_mm512_i64gather_pd 7061 // CHECK: @llvm.x86.avx512.mask.gather.qpd.512 7062 return _mm512_i64gather_pd(__index, __addr, 2); 7063 } 7064 7065 __m512d test_mm512_mask_i64gather_pd(__m512d __v1_old, __mmask8 __mask, __m512i __index, void const *__addr) { 7066 // CHECK-LABEL: test_mm512_mask_i64gather_pd 7067 // CHECK: @llvm.x86.avx512.mask.gather.qpd.512 7068 return _mm512_mask_i64gather_pd(__v1_old, __mask, __index, __addr, 2); 7069 } 7070 7071 __m512i test_mm512_i64gather_epi64(__m512i __index, void const *__addr) { 7072 // CHECK-LABEL: test_mm512_i64gather_epi64 7073 // CHECK: @llvm.x86.avx512.mask.gather.qpq.512 7074 return _mm512_i64gather_epi64(__index, __addr, 2); 7075 } 7076 7077 __m512i test_mm512_mask_i64gather_epi64(__m512i __v1_old, __mmask8 __mask, __m512i __index, void const *__addr) { 7078 // CHECK-LABEL: test_mm512_mask_i64gather_epi64 7079 // CHECK: @llvm.x86.avx512.mask.gather.qpq.512 7080 return _mm512_mask_i64gather_epi64(__v1_old, __mask, __index, __addr, 2); 7081 } 7082 7083 __m512 test_mm512_i32gather_ps(__m512i __index, void const *__addr) { 7084 // CHECK-LABEL: test_mm512_i32gather_ps 7085 // CHECK: @llvm.x86.avx512.mask.gather.dps.512 7086 return _mm512_i32gather_ps(__index, __addr, 2); 7087 } 7088 7089 __m512 test_mm512_mask_i32gather_ps(__m512 v1_old, __mmask16 __mask, __m512i __index, void const *__addr) { 7090 // CHECK-LABEL: test_mm512_mask_i32gather_ps 7091 // CHECK: @llvm.x86.avx512.mask.gather.dps.512 7092 return _mm512_mask_i32gather_ps(v1_old, __mask, __index, __addr, 2); 7093 } 7094 7095 __m512i test_mm512_i32gather_epi32(__m512i __index, void const *__addr) { 7096 // CHECK-LABEL: test_mm512_i32gather_epi32 7097 // CHECK: @llvm.x86.avx512.mask.gather.dpi.512 7098 return _mm512_i32gather_epi32(__index, __addr, 2); 7099 } 7100 7101 __m512i test_mm512_mask_i32gather_epi32(__m512i __v1_old, __mmask16 __mask, __m512i __index, void const *__addr) { 7102 // CHECK-LABEL: test_mm512_mask_i32gather_epi32 7103 // CHECK: @llvm.x86.avx512.mask.gather.dpi.512 7104 return _mm512_mask_i32gather_epi32(__v1_old, __mask, __index, __addr, 2); 7105 } 7106 7107 __m512d test_mm512_i32gather_pd(__m256i __index, void const *__addr) { 7108 // CHECK-LABEL: test_mm512_i32gather_pd 7109 // CHECK: @llvm.x86.avx512.mask.gather.dpd.512 7110 return _mm512_i32gather_pd(__index, __addr, 2); 7111 } 7112 7113 __m512d test_mm512_mask_i32gather_pd(__m512d __v1_old, __mmask8 __mask, __m256i __index, void const *__addr) { 7114 // CHECK-LABEL: test_mm512_mask_i32gather_pd 7115 // CHECK: @llvm.x86.avx512.mask.gather.dpd.512 7116 return _mm512_mask_i32gather_pd(__v1_old, __mask, __index, __addr, 2); 7117 } 7118 7119 __m512i test_mm512_i32gather_epi64(__m256i __index, void const *__addr) { 7120 // CHECK-LABEL: test_mm512_i32gather_epi64 7121 // CHECK: @llvm.x86.avx512.mask.gather.dpq.512 7122 return _mm512_i32gather_epi64(__index, __addr, 2); 7123 } 7124 7125 __m512i test_mm512_mask_i32gather_epi64(__m512i __v1_old, __mmask8 __mask, __m256i __index, void const *__addr) { 7126 // CHECK-LABEL: test_mm512_mask_i32gather_epi64 7127 // CHECK: @llvm.x86.avx512.mask.gather.dpq.512 7128 return _mm512_mask_i32gather_epi64(__v1_old, __mask, __index, __addr, 2); 7129 } 7130 7131 void test_mm512_i64scatter_ps(void *__addr, __m512i __index, __m256 __v1) { 7132 // CHECK-LABEL: test_mm512_i64scatter_ps 7133 // CHECK: @llvm.x86.avx512.mask.scatter.qps.512 7134 return _mm512_i64scatter_ps(__addr, __index, __v1, 2); 7135 } 7136 7137 void test_mm512_mask_i64scatter_ps(void *__addr, __mmask8 __mask, __m512i __index, __m256 __v1) { 7138 // CHECK-LABEL: test_mm512_mask_i64scatter_ps 7139 // CHECK: @llvm.x86.avx512.mask.scatter.qps.512 7140 return _mm512_mask_i64scatter_ps(__addr, __mask, __index, __v1, 2); 7141 } 7142 7143 void test_mm512_i64scatter_epi32(void *__addr, __m512i __index, __m256i __v1) { 7144 // CHECK-LABEL: test_mm512_i64scatter_epi32 7145 // CHECK: @llvm.x86.avx512.mask.scatter.qpi.512 7146 return _mm512_i64scatter_epi32(__addr, __index, __v1, 2); 7147 } 7148 7149 void test_mm512_mask_i64scatter_epi32(void *__addr, __mmask8 __mask, __m512i __index, __m256i __v1) { 7150 // CHECK-LABEL: test_mm512_mask_i64scatter_epi32 7151 // CHECK: @llvm.x86.avx512.mask.scatter.qpi.512 7152 return _mm512_mask_i64scatter_epi32(__addr, __mask, __index, __v1, 2); 7153 } 7154 7155 void test_mm512_i64scatter_pd(void *__addr, __m512i __index, __m512d __v1) { 7156 // CHECK-LABEL: test_mm512_i64scatter_pd 7157 // CHECK: @llvm.x86.avx512.mask.scatter.qpd.512 7158 return _mm512_i64scatter_pd(__addr, __index, __v1, 2); 7159 } 7160 7161 void test_mm512_mask_i64scatter_pd(void *__addr, __mmask8 __mask, __m512i __index, __m512d __v1) { 7162 // CHECK-LABEL: test_mm512_mask_i64scatter_pd 7163 // CHECK: @llvm.x86.avx512.mask.scatter.qpd.512 7164 return _mm512_mask_i64scatter_pd(__addr, __mask, __index, __v1, 2); 7165 } 7166 7167 void test_mm512_i64scatter_epi64(void *__addr, __m512i __index, __m512i __v1) { 7168 // CHECK-LABEL: test_mm512_i64scatter_epi64 7169 // CHECK: @llvm.x86.avx512.mask.scatter.qpq.512 7170 return _mm512_i64scatter_epi64(__addr, __index, __v1, 2); 7171 } 7172 7173 void test_mm512_mask_i64scatter_epi64(void *__addr, __mmask8 __mask, __m512i __index, __m512i __v1) { 7174 // CHECK-LABEL: test_mm512_mask_i64scatter_epi64 7175 // CHECK: @llvm.x86.avx512.mask.scatter.qpq.512 7176 return _mm512_mask_i64scatter_epi64(__addr, __mask, __index, __v1, 2); 7177 } 7178 7179 void test_mm512_i32scatter_ps(void *__addr, __m512i __index, __m512 __v1) { 7180 // CHECK-LABEL: test_mm512_i32scatter_ps 7181 // CHECK: @llvm.x86.avx512.mask.scatter.dps.512 7182 return _mm512_i32scatter_ps(__addr, __index, __v1, 2); 7183 } 7184 7185 void test_mm512_mask_i32scatter_ps(void *__addr, __mmask16 __mask, __m512i __index, __m512 __v1) { 7186 // CHECK-LABEL: test_mm512_mask_i32scatter_ps 7187 // CHECK: @llvm.x86.avx512.mask.scatter.dps.512 7188 return _mm512_mask_i32scatter_ps(__addr, __mask, __index, __v1, 2); 7189 } 7190 7191 void test_mm512_i32scatter_epi32(void *__addr, __m512i __index, __m512i __v1) { 7192 // CHECK-LABEL: test_mm512_i32scatter_epi32 7193 // CHECK: @llvm.x86.avx512.mask.scatter.dpi.512 7194 return _mm512_i32scatter_epi32(__addr, __index, __v1, 2); 7195 } 7196 7197 void test_mm512_mask_i32scatter_epi32(void *__addr, __mmask16 __mask, __m512i __index, __m512i __v1) { 7198 // CHECK-LABEL: test_mm512_mask_i32scatter_epi32 7199 // CHECK: @llvm.x86.avx512.mask.scatter.dpi.512 7200 return _mm512_mask_i32scatter_epi32(__addr, __mask, __index, __v1, 2); 7201 } 7202 7203 void test_mm512_i32scatter_pd(void *__addr, __m256i __index, __m512d __v1) { 7204 // CHECK-LABEL: test_mm512_i32scatter_pd 7205 // CHECK: @llvm.x86.avx512.mask.scatter.dpd.512 7206 return _mm512_i32scatter_pd(__addr, __index, __v1, 2); 7207 } 7208 7209 void test_mm512_mask_i32scatter_pd(void *__addr, __mmask8 __mask, __m256i __index, __m512d __v1) { 7210 // CHECK-LABEL: test_mm512_mask_i32scatter_pd 7211 // CHECK: @llvm.x86.avx512.mask.scatter.dpd.512 7212 return _mm512_mask_i32scatter_pd(__addr, __mask, __index, __v1, 2); 7213 } 7214 7215 void test_mm512_i32scatter_epi64(void *__addr, __m256i __index, __m512i __v1) { 7216 // CHECK-LABEL: test_mm512_i32scatter_epi64 7217 // CHECK: @llvm.x86.avx512.mask.scatter.dpq.512 7218 return _mm512_i32scatter_epi64(__addr, __index, __v1, 2); 7219 } 7220 7221 void test_mm512_mask_i32scatter_epi64(void *__addr, __mmask8 __mask, __m256i __index, __m512i __v1) { 7222 // CHECK-LABEL: test_mm512_mask_i32scatter_epi64 7223 // CHECK: @llvm.x86.avx512.mask.scatter.dpq.512 7224 return _mm512_mask_i32scatter_epi64(__addr, __mask, __index, __v1, 2); 7225 } 7226 7227 __m128d test_mm_mask_rsqrt14_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 7228 // CHECK-LABEL: test_mm_mask_rsqrt14_sd 7229 // CHECK: @llvm.x86.avx512.rsqrt14.sd 7230 return _mm_mask_rsqrt14_sd(__W, __U, __A, __B); 7231 } 7232 7233 __m128d test_mm_maskz_rsqrt14_sd(__mmask8 __U, __m128d __A, __m128d __B){ 7234 // CHECK-LABEL: test_mm_maskz_rsqrt14_sd 7235 // CHECK: @llvm.x86.avx512.rsqrt14.sd 7236 return _mm_maskz_rsqrt14_sd(__U, __A, __B); 7237 } 7238 7239 __m128 test_mm_mask_rsqrt14_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 7240 // CHECK-LABEL: test_mm_mask_rsqrt14_ss 7241 // CHECK: @llvm.x86.avx512.rsqrt14.ss 7242 return _mm_mask_rsqrt14_ss(__W, __U, __A, __B); 7243 } 7244 7245 __m128 test_mm_maskz_rsqrt14_ss(__mmask8 __U, __m128 __A, __m128 __B){ 7246 // CHECK-LABEL: test_mm_maskz_rsqrt14_ss 7247 // CHECK: @llvm.x86.avx512.rsqrt14.ss 7248 return _mm_maskz_rsqrt14_ss(__U, __A, __B); 7249 } 7250 7251 __m512d test_mm512_mask_rcp14_pd (__m512d __W, __mmask8 __U, __m512d __A) 7252 { 7253 // CHECK-LABEL: test_mm512_mask_rcp14_pd 7254 // CHECK: @llvm.x86.avx512.rcp14.pd.512 7255 return _mm512_mask_rcp14_pd (__W,__U,__A); 7256 } 7257 7258 __m512d test_mm512_maskz_rcp14_pd (__mmask8 __U, __m512d __A) 7259 { 7260 // CHECK-LABEL: test_mm512_maskz_rcp14_pd 7261 // CHECK: @llvm.x86.avx512.rcp14.pd.512 7262 return _mm512_maskz_rcp14_pd (__U,__A); 7263 } 7264 7265 __m512 test_mm512_mask_rcp14_ps (__m512 __W, __mmask16 __U, __m512 __A) 7266 { 7267 // CHECK-LABEL: test_mm512_mask_rcp14_ps 7268 // CHECK: @llvm.x86.avx512.rcp14.ps.512 7269 return _mm512_mask_rcp14_ps (__W,__U,__A); 7270 } 7271 7272 __m512 test_mm512_maskz_rcp14_ps (__mmask16 __U, __m512 __A) 7273 { 7274 // CHECK-LABEL: test_mm512_maskz_rcp14_ps 7275 // CHECK: @llvm.x86.avx512.rcp14.ps.512 7276 return _mm512_maskz_rcp14_ps (__U,__A); 7277 } 7278 7279 __m128d test_mm_mask_rcp14_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 7280 // CHECK-LABEL: test_mm_mask_rcp14_sd 7281 // CHECK: @llvm.x86.avx512.rcp14.sd 7282 return _mm_mask_rcp14_sd(__W, __U, __A, __B); 7283 } 7284 7285 __m128d test_mm_maskz_rcp14_sd(__mmask8 __U, __m128d __A, __m128d __B){ 7286 // CHECK-LABEL: test_mm_maskz_rcp14_sd 7287 // CHECK: @llvm.x86.avx512.rcp14.sd 7288 return _mm_maskz_rcp14_sd(__U, __A, __B); 7289 } 7290 7291 __m128 test_mm_mask_rcp14_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 7292 // CHECK-LABEL: test_mm_mask_rcp14_ss 7293 // CHECK: @llvm.x86.avx512.rcp14.ss 7294 return _mm_mask_rcp14_ss(__W, __U, __A, __B); 7295 } 7296 7297 __m128 test_mm_maskz_rcp14_ss(__mmask8 __U, __m128 __A, __m128 __B){ 7298 // CHECK-LABEL: test_mm_maskz_rcp14_ss 7299 // CHECK: @llvm.x86.avx512.rcp14.ss 7300 return _mm_maskz_rcp14_ss(__U, __A, __B); 7301 } 7302 7303 __m128d test_mm_mask_getexp_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 7304 // CHECK-LABEL: test_mm_mask_getexp_sd 7305 // CHECK: @llvm.x86.avx512.mask.getexp.sd 7306 return _mm_mask_getexp_sd(__W, __U, __A, __B); 7307 } 7308 7309 __m128d test_mm_mask_getexp_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 7310 // CHECK-LABEL: test_mm_mask_getexp_round_sd 7311 // CHECK: @llvm.x86.avx512.mask.getexp.sd 7312 return _mm_mask_getexp_round_sd(__W, __U, __A, __B, _MM_FROUND_NO_EXC); 7313 } 7314 7315 __m128d test_mm_maskz_getexp_sd(__mmask8 __U, __m128d __A, __m128d __B){ 7316 // CHECK-LABEL: test_mm_maskz_getexp_sd 7317 // CHECK: @llvm.x86.avx512.mask.getexp.sd 7318 return _mm_maskz_getexp_sd(__U, __A, __B); 7319 } 7320 7321 __m128d test_mm_maskz_getexp_round_sd(__mmask8 __U, __m128d __A, __m128d __B){ 7322 // CHECK-LABEL: test_mm_maskz_getexp_round_sd 7323 // CHECK: @llvm.x86.avx512.mask.getexp.sd 7324 return _mm_maskz_getexp_round_sd(__U, __A, __B, _MM_FROUND_NO_EXC); 7325 } 7326 7327 __m128 test_mm_mask_getexp_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 7328 // CHECK-LABEL: test_mm_mask_getexp_ss 7329 // CHECK: @llvm.x86.avx512.mask.getexp.ss 7330 return _mm_mask_getexp_ss(__W, __U, __A, __B); 7331 } 7332 7333 __m128 test_mm_mask_getexp_round_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 7334 // CHECK-LABEL: test_mm_mask_getexp_round_ss 7335 // CHECK: @llvm.x86.avx512.mask.getexp.ss 7336 return _mm_mask_getexp_round_ss(__W, __U, __A, __B, _MM_FROUND_NO_EXC); 7337 } 7338 7339 __m128 test_mm_maskz_getexp_ss(__mmask8 __U, __m128 __A, __m128 __B){ 7340 // CHECK-LABEL: test_mm_maskz_getexp_ss 7341 // CHECK: @llvm.x86.avx512.mask.getexp.ss 7342 return _mm_maskz_getexp_ss(__U, __A, __B); 7343 } 7344 7345 __m128 test_mm_maskz_getexp_round_ss(__mmask8 __U, __m128 __A, __m128 __B){ 7346 // CHECK-LABEL: test_mm_maskz_getexp_round_ss 7347 // CHECK: @llvm.x86.avx512.mask.getexp.ss 7348 return _mm_maskz_getexp_round_ss(__U, __A, __B, _MM_FROUND_NO_EXC); 7349 } 7350 7351 __m128d test_mm_mask_getmant_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 7352 // CHECK-LABEL: test_mm_mask_getmant_sd 7353 // CHECK: @llvm.x86.avx512.mask.getmant.sd 7354 return _mm_mask_getmant_sd(__W, __U, __A, __B, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan); 7355 } 7356 7357 __m128d test_mm_mask_getmant_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 7358 // CHECK-LABEL: test_mm_mask_getmant_round_sd 7359 // CHECK: @llvm.x86.avx512.mask.getmant.sd 7360 return _mm_mask_getmant_round_sd(__W, __U, __A, __B, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC); 7361 } 7362 7363 __m128d test_mm_maskz_getmant_sd(__mmask8 __U, __m128d __A, __m128d __B){ 7364 // CHECK-LABEL: test_mm_maskz_getmant_sd 7365 // CHECK: @llvm.x86.avx512.mask.getmant.sd 7366 return _mm_maskz_getmant_sd(__U, __A, __B, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan); 7367 } 7368 7369 __m128d test_mm_maskz_getmant_round_sd(__mmask8 __U, __m128d __A, __m128d __B){ 7370 // CHECK-LABEL: test_mm_maskz_getmant_round_sd 7371 // CHECK: @llvm.x86.avx512.mask.getmant.sd 7372 return _mm_maskz_getmant_round_sd(__U, __A, __B, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC); 7373 } 7374 7375 __m128 test_mm_mask_getmant_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 7376 // CHECK-LABEL: test_mm_mask_getmant_ss 7377 // CHECK: @llvm.x86.avx512.mask.getmant.ss 7378 return _mm_mask_getmant_ss(__W, __U, __A, __B, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan); 7379 } 7380 7381 __m128 test_mm_mask_getmant_round_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 7382 // CHECK-LABEL: test_mm_mask_getmant_round_ss 7383 // CHECK: @llvm.x86.avx512.mask.getmant.ss 7384 return _mm_mask_getmant_round_ss(__W, __U, __A, __B, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC); 7385 } 7386 7387 __m128 test_mm_maskz_getmant_ss(__mmask8 __U, __m128 __A, __m128 __B){ 7388 // CHECK-LABEL: test_mm_maskz_getmant_ss 7389 // CHECK: @llvm.x86.avx512.mask.getmant.ss 7390 return _mm_maskz_getmant_ss(__U, __A, __B, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan); 7391 } 7392 7393 __m128 test_mm_maskz_getmant_round_ss(__mmask8 __U, __m128 __A, __m128 __B){ 7394 // CHECK-LABEL: test_mm_maskz_getmant_round_ss 7395 // CHECK: @llvm.x86.avx512.mask.getmant.ss 7396 return _mm_maskz_getmant_round_ss(__U, __A, __B, _MM_MANT_NORM_p5_2, _MM_MANT_SIGN_nan, _MM_FROUND_NO_EXC); 7397 } 7398 7399 __m128 test_mm_mask_fmadd_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 7400 // CHECK-LABEL: test_mm_mask_fmadd_ss 7401 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7402 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7403 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7404 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.fma.f32(float [[A]], float [[B]], float [[C]]) 7405 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7406 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7407 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float [[A]] 7408 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[SEL]], i64 0 7409 return _mm_mask_fmadd_ss(__W, __U, __A, __B); 7410 } 7411 7412 __m128 test_mm_fmadd_round_ss(__m128 __A, __m128 __B, __m128 __C){ 7413 // CHECK-LABEL: test_mm_fmadd_round_ss 7414 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7415 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7416 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7417 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.x86.avx512.vfmadd.f32(float [[A]], float [[B]], float [[C]], i32 11) 7418 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[FMA]], i64 0 7419 return _mm_fmadd_round_ss(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7420 } 7421 7422 __m128 test_mm_mask_fmadd_round_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 7423 // CHECK-LABEL: test_mm_mask_fmadd_round_ss 7424 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7425 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7426 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7427 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.x86.avx512.vfmadd.f32(float [[A]], float [[B]], float [[C]], i32 11) 7428 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7429 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7430 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float [[A]] 7431 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[SEL]], i64 0 7432 return _mm_mask_fmadd_round_ss(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7433 } 7434 7435 __m128 test_mm_maskz_fmadd_ss(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C){ 7436 // CHECK-LABEL: test_mm_maskz_fmadd_ss 7437 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7438 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7439 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7440 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.fma.f32(float [[A]], float [[B]], float [[C]]) 7441 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7442 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7443 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float 0.000000e+00 7444 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[SEL]], i64 0 7445 return _mm_maskz_fmadd_ss(__U, __A, __B, __C); 7446 } 7447 7448 __m128 test_mm_maskz_fmadd_round_ss(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C){ 7449 // CHECK-LABEL: test_mm_maskz_fmadd_round_ss 7450 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7451 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7452 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7453 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.x86.avx512.vfmadd.f32(float [[A]], float [[B]], float [[C]], i32 11) 7454 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7455 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7456 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float 0.000000e+00 7457 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[SEL]], i64 0 7458 return _mm_maskz_fmadd_round_ss(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7459 } 7460 7461 __m128 test_mm_mask3_fmadd_ss(__m128 __W, __m128 __X, __m128 __Y, __mmask8 __U){ 7462 // CHECK-LABEL: test_mm_mask3_fmadd_ss 7463 // CHECK: [[A:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7464 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7465 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[ORIGC:%.+]], i64 0 7466 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.fma.f32(float [[A]], float [[B]], float [[C]]) 7467 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7468 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7469 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float [[C]] 7470 // CHECK-NEXT: insertelement <4 x float> [[ORIGC]], float [[SEL]], i64 0 7471 return _mm_mask3_fmadd_ss(__W, __X, __Y, __U); 7472 } 7473 7474 __m128 test_mm_mask3_fmadd_round_ss(__m128 __W, __m128 __X, __m128 __Y, __mmask8 __U){ 7475 // CHECK-LABEL: test_mm_mask3_fmadd_round_ss 7476 // CHECK: [[A:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7477 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7478 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[ORIGC:%.+]], i64 0 7479 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.x86.avx512.vfmadd.f32(float [[A]], float [[B]], float [[C]], i32 11) 7480 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7481 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7482 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float [[C]] 7483 // CHECK-NEXT: insertelement <4 x float> [[ORIGC]], float [[SEL]], i64 0 7484 return _mm_mask3_fmadd_round_ss(__W, __X, __Y, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7485 } 7486 7487 __m128 test_mm_mask_fmsub_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 7488 // CHECK-LABEL: test_mm_mask_fmsub_ss 7489 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7490 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7491 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7492 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7493 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.fma.f32(float [[A]], float [[B]], float [[C]]) 7494 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7495 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7496 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float [[A]] 7497 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[SEL]], i64 0 7498 return _mm_mask_fmsub_ss(__W, __U, __A, __B); 7499 } 7500 7501 __m128 test_mm_fmsub_round_ss(__m128 __A, __m128 __B, __m128 __C){ 7502 // CHECK-LABEL: test_mm_fmsub_round_ss 7503 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7504 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7505 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7506 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7507 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.x86.avx512.vfmadd.f32(float [[A]], float [[B]], float [[C]], i32 11) 7508 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[FMA]], i64 0 7509 return _mm_fmsub_round_ss(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7510 } 7511 7512 __m128 test_mm_mask_fmsub_round_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 7513 // CHECK-LABEL: test_mm_mask_fmsub_round_ss 7514 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7515 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7516 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7517 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7518 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.x86.avx512.vfmadd.f32(float [[A]], float [[B]], float [[C]], i32 11) 7519 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7520 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7521 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float [[A]] 7522 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[SEL]], i64 0 7523 return _mm_mask_fmsub_round_ss(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7524 } 7525 7526 __m128 test_mm_maskz_fmsub_ss(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C){ 7527 // CHECK-LABEL: test_mm_maskz_fmsub_ss 7528 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7529 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7530 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7531 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7532 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.fma.f32(float [[A]], float [[B]], float [[C]]) 7533 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7534 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7535 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float 0.000000e+00 7536 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[SEL]], i64 0 7537 return _mm_maskz_fmsub_ss(__U, __A, __B, __C); 7538 } 7539 7540 __m128 test_mm_maskz_fmsub_round_ss(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C){ 7541 // CHECK-LABEL: test_mm_maskz_fmsub_round_ss 7542 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7543 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7544 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7545 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7546 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.x86.avx512.vfmadd.f32(float [[A]], float [[B]], float [[C]], i32 11) 7547 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7548 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7549 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float 0.000000e+00 7550 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[SEL]], i64 0 7551 return _mm_maskz_fmsub_round_ss(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7552 } 7553 7554 __m128 test_mm_mask3_fmsub_ss(__m128 __W, __m128 __X, __m128 __Y, __mmask8 __U){ 7555 // CHECK-LABEL: test_mm_mask3_fmsub_ss 7556 // CHECK: [[NEG:%.+]] = fneg <4 x float> [[ORIGC:%.+]] 7557 // CHECK: [[A:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7558 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7559 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7560 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.fma.f32(float [[A]], float [[B]], float [[C]]) 7561 // CHECK-NEXT: [[C2:%.+]] = extractelement <4 x float> [[ORIGC]], i64 0 7562 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7563 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7564 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float [[C2]] 7565 // CHECK-NEXT: insertelement <4 x float> [[ORIGC]], float [[SEL]], i64 0 7566 return _mm_mask3_fmsub_ss(__W, __X, __Y, __U); 7567 } 7568 7569 __m128 test_mm_mask3_fmsub_round_ss(__m128 __W, __m128 __X, __m128 __Y, __mmask8 __U){ 7570 // CHECK-LABEL: test_mm_mask3_fmsub_round_ss 7571 // CHECK: [[NEG:%.+]] = fneg <4 x float> [[ORIGC:%.+]] 7572 // CHECK: [[A:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7573 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7574 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7575 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.x86.avx512.vfmadd.f32(float [[A]], float [[B]], float [[C]], i32 11) 7576 // CHECK-NEXT: [[C2:%.+]] = extractelement <4 x float> [[ORIGC]], i64 0 7577 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7578 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7579 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float [[C2]] 7580 // CHECK-NEXT: insertelement <4 x float> [[ORIGC]], float [[SEL]], i64 0 7581 return _mm_mask3_fmsub_round_ss(__W, __X, __Y, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7582 } 7583 7584 __m128 test_mm_mask_fnmadd_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 7585 // CHECK-LABEL: test_mm_mask_fnmadd_ss 7586 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7587 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7588 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7589 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7590 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.fma.f32(float [[A]], float [[B]], float [[C]]) 7591 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7592 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7593 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float [[A]] 7594 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[SEL]], i64 0 7595 return _mm_mask_fnmadd_ss(__W, __U, __A, __B); 7596 } 7597 7598 __m128 test_mm_fnmadd_round_ss(__m128 __A, __m128 __B, __m128 __C){ 7599 // CHECK-LABEL: test_mm_fnmadd_round_ss 7600 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7601 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7602 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7603 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7604 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.x86.avx512.vfmadd.f32(float [[A]], float [[B]], float [[C]], i32 11) 7605 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[FMA]], i64 0 7606 return _mm_fnmadd_round_ss(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7607 } 7608 7609 __m128 test_mm_mask_fnmadd_round_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 7610 // CHECK-LABEL: test_mm_mask_fnmadd_round_ss 7611 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7612 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7613 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7614 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7615 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.x86.avx512.vfmadd.f32(float [[A]], float [[B]], float [[C]], i32 11) 7616 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7617 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7618 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float [[A]] 7619 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[SEL]], i64 0 7620 return _mm_mask_fnmadd_round_ss(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7621 } 7622 7623 __m128 test_mm_maskz_fnmadd_ss(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C){ 7624 // CHECK-LABEL: test_mm_maskz_fnmadd_ss 7625 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7626 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7627 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7628 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7629 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.fma.f32(float [[A]], float [[B]], float [[C]]) 7630 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7631 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7632 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float 0.000000e+00 7633 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[SEL]], i64 0 7634 return _mm_maskz_fnmadd_ss(__U, __A, __B, __C); 7635 } 7636 7637 __m128 test_mm_maskz_fnmadd_round_ss(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C){ 7638 // CHECK-LABEL: test_mm_maskz_fnmadd_round_ss 7639 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7640 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7641 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7642 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7643 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.x86.avx512.vfmadd.f32(float [[A]], float [[B]], float [[C]], i32 11) 7644 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7645 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7646 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float 0.000000e+00 7647 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[SEL]], i64 0 7648 return _mm_maskz_fnmadd_round_ss(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7649 } 7650 7651 __m128 test_mm_mask3_fnmadd_ss(__m128 __W, __m128 __X, __m128 __Y, __mmask8 __U){ 7652 // CHECK-LABEL: test_mm_mask3_fnmadd_ss 7653 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7654 // CHECK: [[A:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7655 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7656 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[ORIGC:%.+]], i64 0 7657 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.fma.f32(float [[A]], float [[B]], float [[C]]) 7658 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7659 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7660 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float [[C]] 7661 // CHECK-NEXT: insertelement <4 x float> [[ORIGC]], float [[SEL]], i64 0 7662 return _mm_mask3_fnmadd_ss(__W, __X, __Y, __U); 7663 } 7664 7665 __m128 test_mm_mask3_fnmadd_round_ss(__m128 __W, __m128 __X, __m128 __Y, __mmask8 __U){ 7666 // CHECK-LABEL: test_mm_mask3_fnmadd_round_ss 7667 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7668 // CHECK: [[A:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7669 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7670 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[ORIGC:%.+]], i64 0 7671 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.x86.avx512.vfmadd.f32(float [[A]], float [[B]], float [[C]], i32 11) 7672 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7673 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7674 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float [[C]] 7675 // CHECK-NEXT: insertelement <4 x float> [[ORIGC]], float [[SEL]], i64 0 7676 return _mm_mask3_fnmadd_round_ss(__W, __X, __Y, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7677 } 7678 7679 __m128 test_mm_mask_fnmsub_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 7680 // CHECK-LABEL: test_mm_mask_fnmsub_ss 7681 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7682 // CHECK: [[NEG2:%.+]] = fneg <4 x float> %{{.*}} 7683 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7684 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7685 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[NEG2]], i64 0 7686 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.fma.f32(float [[A]], float [[B]], float [[C]]) 7687 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7688 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7689 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float [[A]] 7690 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[SEL]], i64 0 7691 return _mm_mask_fnmsub_ss(__W, __U, __A, __B); 7692 } 7693 7694 __m128 test_mm_fnmsub_round_ss(__m128 __A, __m128 __B, __m128 __C){ 7695 // CHECK-LABEL: test_mm_fnmsub_round_ss 7696 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7697 // CHECK: [[NEG2:%.+]] = fneg <4 x float> %{{.*}} 7698 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7699 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7700 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[NEG2]], i64 0 7701 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.x86.avx512.vfmadd.f32(float [[A]], float [[B]], float [[C]], i32 11) 7702 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[FMA]], i64 0 7703 return _mm_fnmsub_round_ss(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7704 } 7705 7706 __m128 test_mm_mask_fnmsub_round_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B){ 7707 // CHECK-LABEL: test_mm_mask_fnmsub_round_ss 7708 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7709 // CHECK: [[NEG2:%.+]] = fneg <4 x float> %{{.*}} 7710 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7711 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7712 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[NEG2]], i64 0 7713 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.x86.avx512.vfmadd.f32(float [[A]], float [[B]], float [[C]], i32 11) 7714 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7715 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7716 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float [[A]] 7717 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[SEL]], i64 0 7718 return _mm_mask_fnmsub_round_ss(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7719 } 7720 7721 __m128 test_mm_maskz_fnmsub_ss(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C){ 7722 // CHECK-LABEL: test_mm_maskz_fnmsub_ss 7723 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7724 // CHECK: [[NEG2:%.+]] = fneg <4 x float> %{{.*}} 7725 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7726 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7727 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[NEG2]], i64 0 7728 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.fma.f32(float [[A]], float [[B]], float [[C]]) 7729 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7730 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7731 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float 0.000000e+00 7732 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[SEL]], i64 0 7733 return _mm_maskz_fnmsub_ss(__U, __A, __B, __C); 7734 } 7735 7736 __m128 test_mm_maskz_fnmsub_round_ss(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C){ 7737 // CHECK-LABEL: test_mm_maskz_fnmsub_round_ss 7738 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7739 // CHECK: [[NEG2:%.+]] = fneg <4 x float> %{{.*}} 7740 // CHECK: [[A:%.+]] = extractelement <4 x float> [[ORIGA:%.+]], i64 0 7741 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7742 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[NEG2]], i64 0 7743 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.x86.avx512.vfmadd.f32(float [[A]], float [[B]], float [[C]], i32 11) 7744 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7745 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7746 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float 0.000000e+00 7747 // CHECK-NEXT: insertelement <4 x float> [[ORIGA]], float [[SEL]], i64 0 7748 return _mm_maskz_fnmsub_round_ss(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7749 } 7750 7751 __m128 test_mm_mask3_fnmsub_ss(__m128 __W, __m128 __X, __m128 __Y, __mmask8 __U){ 7752 // CHECK-LABEL: test_mm_mask3_fnmsub_ss 7753 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7754 // CHECK: [[NEG2:%.+]] = fneg <4 x float> [[ORIGC:%.+]] 7755 // CHECK: [[A:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7756 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7757 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[NEG2]], i64 0 7758 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.fma.f32(float [[A]], float [[B]], float [[C]]) 7759 // CHECK-NEXT: [[C2:%.+]] = extractelement <4 x float> [[ORIGC]], i64 0 7760 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7761 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7762 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float [[C2]] 7763 // CHECK-NEXT: insertelement <4 x float> [[ORIGC]], float [[SEL]], i64 0 7764 return _mm_mask3_fnmsub_ss(__W, __X, __Y, __U); 7765 } 7766 7767 __m128 test_mm_mask3_fnmsub_round_ss(__m128 __W, __m128 __X, __m128 __Y, __mmask8 __U){ 7768 // CHECK-LABEL: test_mm_mask3_fnmsub_round_ss 7769 // CHECK: [[NEG:%.+]] = fneg <4 x float> %{{.*}} 7770 // CHECK: [[NEG2:%.+]] = fneg <4 x float> [[ORIGC:%.+]] 7771 // CHECK: [[A:%.+]] = extractelement <4 x float> %{{.*}}, i64 0 7772 // CHECK-NEXT: [[B:%.+]] = extractelement <4 x float> [[NEG]], i64 0 7773 // CHECK-NEXT: [[C:%.+]] = extractelement <4 x float> [[NEG2]], i64 0 7774 // CHECK-NEXT: [[FMA:%.+]] = call float @llvm.x86.avx512.vfmadd.f32(float [[A]], float [[B]], float [[C]], i32 11) 7775 // CHECK-NEXT: [[C2:%.+]] = extractelement <4 x float> [[ORIGC]], i64 0 7776 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7777 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7778 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, float [[FMA]], float [[C2]] 7779 // CHECK-NEXT: insertelement <4 x float> [[ORIGC]], float [[SEL]], i64 0 7780 return _mm_mask3_fnmsub_round_ss(__W, __X, __Y, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7781 } 7782 7783 __m128d test_mm_mask_fmadd_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 7784 // CHECK-LABEL: test_mm_mask_fmadd_sd 7785 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.+]], i64 0 7786 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7787 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7788 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.fma.f64(double [[A]], double [[B]], double [[C]]) 7789 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7790 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7791 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double [[A]] 7792 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[SEL]], i64 0 7793 return _mm_mask_fmadd_sd(__W, __U, __A, __B); 7794 } 7795 7796 __m128d test_mm_fmadd_round_sd(__m128d __A, __m128d __B, __m128d __C){ 7797 // CHECK-LABEL: test_mm_fmadd_round_sd 7798 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.+]], i64 0 7799 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7800 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7801 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.x86.avx512.vfmadd.f64(double [[A]], double [[B]], double [[C]], i32 11) 7802 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[FMA]], i64 0 7803 return _mm_fmadd_round_sd(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7804 } 7805 7806 __m128d test_mm_mask_fmadd_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 7807 // CHECK-LABEL: test_mm_mask_fmadd_round_sd 7808 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.+]], i64 0 7809 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7810 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7811 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.x86.avx512.vfmadd.f64(double [[A]], double [[B]], double [[C]], i32 11) 7812 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7813 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7814 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double [[A]] 7815 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[SEL]], i64 0 7816 return _mm_mask_fmadd_round_sd(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7817 } 7818 7819 __m128d test_mm_maskz_fmadd_sd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C){ 7820 // CHECK-LABEL: test_mm_maskz_fmadd_sd 7821 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.+]], i64 0 7822 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7823 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7824 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.fma.f64(double [[A]], double [[B]], double [[C]]) 7825 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7826 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7827 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double 0.000000e+00 7828 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[SEL]], i64 0 7829 return _mm_maskz_fmadd_sd(__U, __A, __B, __C); 7830 } 7831 7832 __m128d test_mm_maskz_fmadd_round_sd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C){ 7833 // CHECK-LABEL: test_mm_maskz_fmadd_round_sd 7834 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.+]], i64 0 7835 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7836 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7837 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.x86.avx512.vfmadd.f64(double [[A]], double [[B]], double [[C]], i32 11) 7838 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7839 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7840 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double 0.000000e+00 7841 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[SEL]], i64 0 7842 return _mm_maskz_fmadd_round_sd(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7843 } 7844 7845 __m128d test_mm_mask3_fmadd_sd(__m128d __W, __m128d __X, __m128d __Y, __mmask8 __U){ 7846 // CHECK-LABEL: test_mm_mask3_fmadd_sd 7847 // CHECK: [[A:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7848 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7849 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[ORIGC:%.+]], i64 0 7850 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.fma.f64(double [[A]], double [[B]], double [[C]]) 7851 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7852 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7853 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double [[C]] 7854 // CHECK-NEXT: insertelement <2 x double> [[ORIGC]], double [[SEL]], i64 0 7855 return _mm_mask3_fmadd_sd(__W, __X, __Y, __U); 7856 } 7857 7858 __m128d test_mm_mask3_fmadd_round_sd(__m128d __W, __m128d __X, __m128d __Y, __mmask8 __U){ 7859 // CHECK-LABEL: test_mm_mask3_fmadd_round_sd 7860 // CHECK: [[A:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7861 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7862 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[ORIGC:%.+]], i64 0 7863 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.x86.avx512.vfmadd.f64(double [[A]], double [[B]], double [[C]], i32 11) 7864 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7865 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7866 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double [[C]] 7867 // CHECK-NEXT: insertelement <2 x double> [[ORIGC]], double [[SEL]], i64 0 7868 return _mm_mask3_fmadd_round_sd(__W, __X, __Y, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7869 } 7870 7871 __m128d test_mm_mask_fmsub_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 7872 // CHECK-LABEL: test_mm_mask_fmsub_sd 7873 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 7874 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.+]], i64 0 7875 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7876 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[NEG]], i64 0 7877 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.fma.f64(double [[A]], double [[B]], double [[C]]) 7878 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7879 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7880 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double [[A]] 7881 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[SEL]], i64 0 7882 return _mm_mask_fmsub_sd(__W, __U, __A, __B); 7883 } 7884 7885 __m128d test_mm_fmsub_round_sd(__m128d __A, __m128d __B, __m128d __C){ 7886 // CHECK-LABEL: test_mm_fmsub_round_sd 7887 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 7888 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.+]], i64 0 7889 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7890 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[NEG]], i64 0 7891 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.x86.avx512.vfmadd.f64(double [[A]], double [[B]], double [[C]], i32 11) 7892 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[FMA]], i64 0 7893 return _mm_fmsub_round_sd(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7894 } 7895 7896 __m128d test_mm_mask_fmsub_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 7897 // CHECK-LABEL: test_mm_mask_fmsub_round_sd 7898 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 7899 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.+]], i64 0 7900 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7901 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[NEG]], i64 0 7902 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.x86.avx512.vfmadd.f64(double [[A]], double [[B]], double [[C]], i32 11) 7903 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7904 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7905 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double [[A]] 7906 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[SEL]], i64 0 7907 return _mm_mask_fmsub_round_sd(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7908 } 7909 7910 __m128d test_mm_maskz_fmsub_sd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C){ 7911 // CHECK-LABEL: test_mm_maskz_fmsub_sd 7912 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 7913 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.+]], i64 0 7914 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7915 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[NEG]], i64 0 7916 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.fma.f64(double [[A]], double [[B]], double [[C]]) 7917 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7918 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7919 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double 0.000000e+00 7920 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[SEL]], i64 0 7921 return _mm_maskz_fmsub_sd(__U, __A, __B, __C); 7922 } 7923 7924 __m128d test_mm_maskz_fmsub_round_sd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C){ 7925 // CHECK-LABEL: test_mm_maskz_fmsub_round_sd 7926 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 7927 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.+]], i64 0 7928 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7929 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[NEG]], i64 0 7930 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.x86.avx512.vfmadd.f64(double [[A]], double [[B]], double [[C]], i32 11) 7931 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7932 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7933 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double 0.000000e+00 7934 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[SEL]], i64 0 7935 return _mm_maskz_fmsub_round_sd(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7936 } 7937 7938 __m128d test_mm_mask3_fmsub_sd(__m128d __W, __m128d __X, __m128d __Y, __mmask8 __U){ 7939 // CHECK-LABEL: test_mm_mask3_fmsub_sd 7940 // CHECK: [[NEG:%.+]] = fneg <2 x double> [[ORIGC:%.+]] 7941 // CHECK: [[A:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7942 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7943 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[NEG]], i64 0 7944 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.fma.f64(double [[A]], double [[B]], double [[C]]) 7945 // CHECK-NEXT: [[C2:%.+]] = extractelement <2 x double> [[ORIGC]], i64 0 7946 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7947 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7948 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double [[C2]] 7949 // CHECK-NEXT: insertelement <2 x double> [[ORIGC]], double [[SEL]], i64 0 7950 return _mm_mask3_fmsub_sd(__W, __X, __Y, __U); 7951 } 7952 7953 __m128d test_mm_mask3_fmsub_round_sd(__m128d __W, __m128d __X, __m128d __Y, __mmask8 __U){ 7954 // CHECK-LABEL: test_mm_mask3_fmsub_round_sd 7955 // CHECK: [[NEG:%.+]] = fneg <2 x double> [[ORIGC:%.+]] 7956 // CHECK: [[A:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7957 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7958 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[NEG]], i64 0 7959 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.x86.avx512.vfmadd.f64(double [[A]], double [[B]], double [[C]], i32 11) 7960 // CHECK-NEXT: [[C2:%.+]] = extractelement <2 x double> [[ORIGC]], i64 0 7961 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7962 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7963 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double [[C2]] 7964 // CHECK-NEXT: insertelement <2 x double> [[ORIGC]], double [[SEL]], i64 0 7965 return _mm_mask3_fmsub_round_sd(__W, __X, __Y, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7966 } 7967 7968 __m128d test_mm_mask_fnmadd_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 7969 // CHECK-LABEL: test_mm_mask_fnmadd_sd 7970 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 7971 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.+]], i64 0 7972 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> [[NEG]], i64 0 7973 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7974 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.fma.f64(double [[A]], double [[B]], double [[C]]) 7975 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 7976 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 7977 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double [[A]] 7978 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[SEL]], i64 0 7979 return _mm_mask_fnmadd_sd(__W, __U, __A, __B); 7980 } 7981 7982 __m128d test_mm_fnmadd_round_sd(__m128d __A, __m128d __B, __m128d __C){ 7983 // CHECK-LABEL: test_mm_fnmadd_round_sd 7984 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 7985 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.+]], i64 0 7986 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> [[NEG]], i64 0 7987 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7988 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.x86.avx512.vfmadd.f64(double [[A]], double [[B]], double [[C]], i32 11) 7989 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[FMA]], i64 0 7990 return _mm_fnmadd_round_sd(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 7991 } 7992 7993 __m128d test_mm_mask_fnmadd_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 7994 // CHECK-LABEL: test_mm_mask_fnmadd_round_sd 7995 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 7996 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.+]], i64 0 7997 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> [[NEG]], i64 0 7998 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 7999 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.x86.avx512.vfmadd.f64(double [[A]], double [[B]], double [[C]], i32 11) 8000 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 8001 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 8002 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double [[A]] 8003 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[SEL]], i64 0 8004 return _mm_mask_fnmadd_round_sd(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 8005 } 8006 8007 __m128d test_mm_maskz_fnmadd_sd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C){ 8008 // CHECK-LABEL: test_mm_maskz_fnmadd_sd 8009 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 8010 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.+]], i64 0 8011 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> [[NEG]], i64 0 8012 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 8013 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.fma.f64(double [[A]], double [[B]], double [[C]]) 8014 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 8015 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 8016 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double 0.000000e+00 8017 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[SEL]], i64 0 8018 return _mm_maskz_fnmadd_sd(__U, __A, __B, __C); 8019 } 8020 8021 __m128d test_mm_maskz_fnmadd_round_sd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C){ 8022 // CHECK-LABEL: test_mm_maskz_fnmadd_round_sd 8023 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 8024 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.+]], i64 0 8025 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> [[NEG]], i64 0 8026 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 8027 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.x86.avx512.vfmadd.f64(double [[A]], double [[B]], double [[C]], i32 11) 8028 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 8029 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 8030 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double 0.000000e+00 8031 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[SEL]], i64 0 8032 return _mm_maskz_fnmadd_round_sd(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 8033 } 8034 8035 __m128d test_mm_mask3_fnmadd_sd(__m128d __W, __m128d __X, __m128d __Y, __mmask8 __U){ 8036 // CHECK-LABEL: test_mm_mask3_fnmadd_sd 8037 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 8038 // CHECK: [[A:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 8039 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> [[NEG]], i64 0 8040 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[ORIGC:%.+]], i64 0 8041 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.fma.f64(double [[A]], double [[B]], double [[C]]) 8042 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 8043 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 8044 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double [[C]] 8045 // CHECK-NEXT: insertelement <2 x double> [[ORIGC]], double [[SEL]], i64 0 8046 return _mm_mask3_fnmadd_sd(__W, __X, __Y, __U); 8047 } 8048 8049 __m128d test_mm_mask3_fnmadd_round_sd(__m128d __W, __m128d __X, __m128d __Y, __mmask8 __U){ 8050 // CHECK-LABEL: test_mm_mask3_fnmadd_round_sd 8051 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 8052 // CHECK: [[A:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 8053 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> [[NEG]], i64 0 8054 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[ORIGC:%.+]], i64 0 8055 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.x86.avx512.vfmadd.f64(double [[A]], double [[B]], double [[C]], i32 11) 8056 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 8057 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 8058 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double [[C]] 8059 // CHECK-NEXT: insertelement <2 x double> [[ORIGC]], double [[SEL]], i64 0 8060 return _mm_mask3_fnmadd_round_sd(__W, __X, __Y, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 8061 } 8062 8063 __m128d test_mm_mask_fnmsub_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 8064 // CHECK-LABEL: test_mm_mask_fnmsub_sd 8065 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 8066 // CHECK: [[NEG2:%.+]] = fneg <2 x double> %{{.*}} 8067 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.]], i64 0 8068 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> [[NEG]], i64 0 8069 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[NEG2]], i64 0 8070 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.fma.f64(double [[A]], double [[B]], double [[C]]) 8071 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 8072 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 8073 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double [[A]] 8074 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[SEL]], i64 0 8075 return _mm_mask_fnmsub_sd(__W, __U, __A, __B); 8076 } 8077 8078 __m128d test_mm_fnmsub_round_sd(__m128d __A, __m128d __B, __m128d __C){ 8079 // CHECK-LABEL: test_mm_fnmsub_round_sd 8080 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 8081 // CHECK: [[NEG2:%.+]] = fneg <2 x double> %{{.*}} 8082 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.]], i64 0 8083 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> [[NEG]], i64 0 8084 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[NEG2]], i64 0 8085 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.x86.avx512.vfmadd.f64(double [[A]], double [[B]], double [[C]], i32 11) 8086 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[FMA]], i64 0 8087 return _mm_fnmsub_round_sd(__A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 8088 } 8089 8090 __m128d test_mm_mask_fnmsub_round_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B){ 8091 // CHECK-LABEL: test_mm_mask_fnmsub_round_sd 8092 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 8093 // CHECK: [[NEG2:%.+]] = fneg <2 x double> %{{.*}} 8094 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.]], i64 0 8095 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> [[NEG]], i64 0 8096 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[NEG2]], i64 0 8097 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.x86.avx512.vfmadd.f64(double [[A]], double [[B]], double [[C]], i32 11) 8098 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 8099 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 8100 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double [[A]] 8101 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[SEL]], i64 0 8102 return _mm_mask_fnmsub_round_sd(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 8103 } 8104 8105 __m128d test_mm_maskz_fnmsub_sd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C){ 8106 // CHECK-LABEL: test_mm_maskz_fnmsub_sd 8107 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 8108 // CHECK: [[NEG2:%.+]] = fneg <2 x double> %{{.*}} 8109 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.]], i64 0 8110 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> [[NEG]], i64 0 8111 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[NEG2]], i64 0 8112 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.fma.f64(double [[A]], double [[B]], double [[C]]) 8113 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 8114 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 8115 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double 0.000000e+00 8116 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[SEL]], i64 0 8117 return _mm_maskz_fnmsub_sd(__U, __A, __B, __C); 8118 } 8119 8120 __m128d test_mm_maskz_fnmsub_round_sd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C){ 8121 // CHECK-LABEL: test_mm_maskz_fnmsub_round_sd 8122 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 8123 // CHECK: [[NEG2:%.+]] = fneg <2 x double> %{{.*}} 8124 // CHECK: [[A:%.+]] = extractelement <2 x double> [[ORIGA:%.]], i64 0 8125 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> [[NEG]], i64 0 8126 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[NEG2]], i64 0 8127 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.x86.avx512.vfmadd.f64(double [[A]], double [[B]], double [[C]], i32 11) 8128 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 8129 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 8130 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double 0.000000e+00 8131 // CHECK-NEXT: insertelement <2 x double> [[ORIGA]], double [[SEL]], i64 0 8132 return _mm_maskz_fnmsub_round_sd(__U, __A, __B, __C, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 8133 } 8134 8135 __m128d test_mm_mask3_fnmsub_sd(__m128d __W, __m128d __X, __m128d __Y, __mmask8 __U){ 8136 // CHECK-LABEL: test_mm_mask3_fnmsub_sd 8137 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 8138 // CHECK: [[NEG2:%.+]] = fneg <2 x double> [[ORIGC:%.+]] 8139 // CHECK: [[A:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 8140 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> [[NEG]], i64 0 8141 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[NEG2]], i64 0 8142 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.fma.f64(double [[A]], double [[B]], double [[C]]) 8143 // CHECK-NEXT: [[C2:%.+]] = extractelement <2 x double> [[ORIGC]], i64 0 8144 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 8145 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 8146 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double [[C2]] 8147 // CHECK-NEXT: insertelement <2 x double> [[ORIGC]], double [[SEL]], i64 0 8148 return _mm_mask3_fnmsub_sd(__W, __X, __Y, __U); 8149 } 8150 8151 __m128d test_mm_mask3_fnmsub_round_sd(__m128d __W, __m128d __X, __m128d __Y, __mmask8 __U){ 8152 // CHECK-LABEL: test_mm_mask3_fnmsub_round_sd 8153 // CHECK: [[NEG:%.+]] = fneg <2 x double> %{{.*}} 8154 // CHECK: [[NEG2:%.+]] = fneg <2 x double> [[ORIGC:%.+]] 8155 // CHECK: [[A:%.+]] = extractelement <2 x double> %{{.*}}, i64 0 8156 // CHECK-NEXT: [[B:%.+]] = extractelement <2 x double> [[NEG]], i64 0 8157 // CHECK-NEXT: [[C:%.+]] = extractelement <2 x double> [[NEG2]], i64 0 8158 // CHECK-NEXT: [[FMA:%.+]] = call double @llvm.x86.avx512.vfmadd.f64(double [[A]], double [[B]], double [[C]], i32 11) 8159 // CHECK-NEXT: [[C2:%.+]] = extractelement <2 x double> [[ORIGC]], i64 0 8160 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 8161 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 8162 // CHECK-NEXT: [[SEL:%.+]] = select i1 %{{.*}}, double [[FMA]], double [[C2]] 8163 // CHECK-NEXT: insertelement <2 x double> [[ORIGC]], double [[SEL]], i64 0 8164 return _mm_mask3_fnmsub_round_sd(__W, __X, __Y, __U, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 8165 } 8166 8167 __m512d test_mm512_permutex_pd(__m512d __X) { 8168 // CHECK-LABEL: test_mm512_permutex_pd 8169 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> poison, <8 x i32> <i32 0, i32 0, i32 0, i32 0, i32 4, i32 4, i32 4, i32 4> 8170 return _mm512_permutex_pd(__X, 0); 8171 } 8172 8173 __m512d test_mm512_mask_permutex_pd(__m512d __W, __mmask8 __U, __m512d __X) { 8174 // CHECK-LABEL: test_mm512_mask_permutex_pd 8175 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> poison, <8 x i32> <i32 0, i32 0, i32 0, i32 0, i32 4, i32 4, i32 4, i32 4> 8176 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 8177 return _mm512_mask_permutex_pd(__W, __U, __X, 0); 8178 } 8179 8180 __m512d test_mm512_maskz_permutex_pd(__mmask8 __U, __m512d __X) { 8181 // CHECK-LABEL: test_mm512_maskz_permutex_pd 8182 // CHECK: shufflevector <8 x double> %{{.*}}, <8 x double> poison, <8 x i32> <i32 0, i32 0, i32 0, i32 0, i32 4, i32 4, i32 4, i32 4> 8183 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 8184 return _mm512_maskz_permutex_pd(__U, __X, 0); 8185 } 8186 8187 __m512i test_mm512_permutex_epi64(__m512i __X) { 8188 // CHECK-LABEL: test_mm512_permutex_epi64 8189 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> poison, <8 x i32> <i32 0, i32 0, i32 0, i32 0, i32 4, i32 4, i32 4, i32 4> 8190 return _mm512_permutex_epi64(__X, 0); 8191 } 8192 8193 __m512i test_mm512_mask_permutex_epi64(__m512i __W, __mmask8 __M, __m512i __X) { 8194 // CHECK-LABEL: test_mm512_mask_permutex_epi64 8195 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> poison, <8 x i32> <i32 0, i32 0, i32 0, i32 0, i32 4, i32 4, i32 4, i32 4> 8196 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 8197 return _mm512_mask_permutex_epi64(__W, __M, __X, 0); 8198 } 8199 8200 __m512i test_mm512_maskz_permutex_epi64(__mmask8 __M, __m512i __X) { 8201 // CHECK-LABEL: test_mm512_maskz_permutex_epi64 8202 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> poison, <8 x i32> <i32 0, i32 0, i32 0, i32 0, i32 4, i32 4, i32 4, i32 4> 8203 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 8204 return _mm512_maskz_permutex_epi64(__M, __X, 0); 8205 } 8206 8207 __m512d test_mm512_permutexvar_pd(__m512i __X, __m512d __Y) { 8208 // CHECK-LABEL: test_mm512_permutexvar_pd 8209 // CHECK: @llvm.x86.avx512.permvar.df.512 8210 return _mm512_permutexvar_pd(__X, __Y); 8211 } 8212 8213 __m512d test_mm512_mask_permutexvar_pd(__m512d __W, __mmask8 __U, __m512i __X, __m512d __Y) { 8214 // CHECK-LABEL: test_mm512_mask_permutexvar_pd 8215 // CHECK: @llvm.x86.avx512.permvar.df.512 8216 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 8217 return _mm512_mask_permutexvar_pd(__W, __U, __X, __Y); 8218 } 8219 8220 __m512d test_mm512_maskz_permutexvar_pd(__mmask8 __U, __m512i __X, __m512d __Y) { 8221 // CHECK-LABEL: test_mm512_maskz_permutexvar_pd 8222 // CHECK: @llvm.x86.avx512.permvar.df.512 8223 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 8224 return _mm512_maskz_permutexvar_pd(__U, __X, __Y); 8225 } 8226 8227 __m512i test_mm512_maskz_permutexvar_epi64(__mmask8 __M, __m512i __X, __m512i __Y) { 8228 // CHECK-LABEL: test_mm512_maskz_permutexvar_epi64 8229 // CHECK: @llvm.x86.avx512.permvar.di.512 8230 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 8231 return _mm512_maskz_permutexvar_epi64(__M, __X, __Y); 8232 } 8233 8234 __m512i test_mm512_permutexvar_epi64(__m512i __X, __m512i __Y) { 8235 // CHECK-LABEL: test_mm512_permutexvar_epi64 8236 // CHECK: @llvm.x86.avx512.permvar.di.512 8237 return _mm512_permutexvar_epi64(__X, __Y); 8238 } 8239 8240 __m512i test_mm512_mask_permutexvar_epi64(__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y) { 8241 // CHECK-LABEL: test_mm512_mask_permutexvar_epi64 8242 // CHECK: @llvm.x86.avx512.permvar.di.512 8243 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 8244 return _mm512_mask_permutexvar_epi64(__W, __M, __X, __Y); 8245 } 8246 8247 __m512 test_mm512_permutexvar_ps(__m512i __X, __m512 __Y) { 8248 // CHECK-LABEL: test_mm512_permutexvar_ps 8249 // CHECK: @llvm.x86.avx512.permvar.sf.512 8250 return _mm512_permutexvar_ps(__X, __Y); 8251 } 8252 8253 __m512 test_mm512_mask_permutexvar_ps(__m512 __W, __mmask16 __U, __m512i __X, __m512 __Y) { 8254 // CHECK-LABEL: test_mm512_mask_permutexvar_ps 8255 // CHECK: @llvm.x86.avx512.permvar.sf.512 8256 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 8257 return _mm512_mask_permutexvar_ps(__W, __U, __X, __Y); 8258 } 8259 8260 __m512 test_mm512_maskz_permutexvar_ps(__mmask16 __U, __m512i __X, __m512 __Y) { 8261 // CHECK-LABEL: test_mm512_maskz_permutexvar_ps 8262 // CHECK: @llvm.x86.avx512.permvar.sf.512 8263 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 8264 return _mm512_maskz_permutexvar_ps(__U, __X, __Y); 8265 } 8266 8267 __m512i test_mm512_maskz_permutexvar_epi32(__mmask16 __M, __m512i __X, __m512i __Y) { 8268 // CHECK-LABEL: test_mm512_maskz_permutexvar_epi32 8269 // CHECK: @llvm.x86.avx512.permvar.si.512 8270 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 8271 return _mm512_maskz_permutexvar_epi32(__M, __X, __Y); 8272 } 8273 8274 __m512i test_mm512_permutexvar_epi32(__m512i __X, __m512i __Y) { 8275 // CHECK-LABEL: test_mm512_permutexvar_epi32 8276 // CHECK: @llvm.x86.avx512.permvar.si.512 8277 return _mm512_permutexvar_epi32(__X, __Y); 8278 } 8279 8280 __m512i test_mm512_mask_permutexvar_epi32(__m512i __W, __mmask16 __M, __m512i __X, __m512i __Y) { 8281 // CHECK-LABEL: test_mm512_mask_permutexvar_epi32 8282 // CHECK: @llvm.x86.avx512.permvar.si.512 8283 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 8284 return _mm512_mask_permutexvar_epi32(__W, __M, __X, __Y); 8285 } 8286 8287 __mmask16 test_mm512_kand(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) { 8288 // CHECK-LABEL: test_mm512_kand 8289 // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8290 // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8291 // CHECK: [[RES:%.*]] = and <16 x i1> [[LHS]], [[RHS]] 8292 // CHECK: bitcast <16 x i1> {{.*}} to i16 8293 return _mm512_mask_cmpneq_epu32_mask(_mm512_kand(_mm512_cmpneq_epu32_mask(__A, __B), 8294 _mm512_cmpneq_epu32_mask(__C, __D)), 8295 __E, __F); 8296 } 8297 8298 __mmask16 test_mm512_kandn(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) { 8299 // CHECK-LABEL: test_mm512_kandn 8300 // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8301 // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8302 // CHECK: [[NOT:%.*]] = xor <16 x i1> [[LHS]], splat (i1 true) 8303 // CHECK: [[RES:%.*]] = and <16 x i1> [[NOT]], [[RHS]] 8304 // CHECK: bitcast <16 x i1> {{.*}} to i16 8305 return _mm512_mask_cmpneq_epu32_mask(_mm512_kandn(_mm512_cmpneq_epu32_mask(__A, __B), 8306 _mm512_cmpneq_epu32_mask(__C, __D)), 8307 __E, __F); 8308 } 8309 8310 __mmask16 test_mm512_kor(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) { 8311 // CHECK-LABEL: test_mm512_kor 8312 // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8313 // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8314 // CHECK: [[RES:%.*]] = or <16 x i1> [[LHS]], [[RHS]] 8315 // CHECK: bitcast <16 x i1> {{.*}} to i16 8316 return _mm512_mask_cmpneq_epu32_mask(_mm512_kor(_mm512_cmpneq_epu32_mask(__A, __B), 8317 _mm512_cmpneq_epu32_mask(__C, __D)), 8318 __E, __F); 8319 } 8320 8321 int test_mm512_kortestc(__m512i __A, __m512i __B, __m512i __C, __m512i __D) { 8322 // CHECK-LABEL: test_mm512_kortestc 8323 // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8324 // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8325 // CHECK: [[OR:%.*]] = or <16 x i1> [[LHS]], [[RHS]] 8326 // CHECK: [[CAST:%.*]] = bitcast <16 x i1> [[OR]] to i16 8327 // CHECK: [[CMP:%.*]] = icmp eq i16 [[CAST]], -1 8328 // CHECK: zext i1 [[CMP]] to i32 8329 return _mm512_kortestc(_mm512_cmpneq_epu32_mask(__A, __B), 8330 _mm512_cmpneq_epu32_mask(__C, __D)); 8331 } 8332 8333 int test_mm512_kortestz(__m512i __A, __m512i __B, __m512i __C, __m512i __D) { 8334 // CHECK-LABEL: test_mm512_kortestz 8335 // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8336 // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8337 // CHECK: [[OR:%.*]] = or <16 x i1> [[LHS]], [[RHS]] 8338 // CHECK: [[CAST:%.*]] = bitcast <16 x i1> [[OR]] to i16 8339 // CHECK: [[CMP:%.*]] = icmp eq i16 [[CAST]], 0 8340 // CHECK: zext i1 [[CMP]] to i32 8341 return _mm512_kortestz(_mm512_cmpneq_epu32_mask(__A, __B), 8342 _mm512_cmpneq_epu32_mask(__C, __D)); 8343 } 8344 8345 unsigned char test_kortestz_mask16_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D) { 8346 // CHECK-LABEL: test_kortestz_mask16_u8 8347 // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8348 // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8349 // CHECK: [[OR:%.*]] = or <16 x i1> [[LHS]], [[RHS]] 8350 // CHECK: [[CAST:%.*]] = bitcast <16 x i1> [[OR]] to i16 8351 // CHECK: [[CMP:%.*]] = icmp eq i16 [[CAST]], 0 8352 // CHECK: [[ZEXT:%.*]] = zext i1 [[CMP]] to i32 8353 // CHECK: trunc i32 [[ZEXT]] to i8 8354 return _kortestz_mask16_u8(_mm512_cmpneq_epu32_mask(__A, __B), 8355 _mm512_cmpneq_epu32_mask(__C, __D)); 8356 } 8357 8358 unsigned char test_kortestc_mask16_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D) { 8359 // CHECK-LABEL: test_kortestc_mask16_u8 8360 // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8361 // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8362 // CHECK: [[OR:%.*]] = or <16 x i1> [[LHS]], [[RHS]] 8363 // CHECK: [[CAST:%.*]] = bitcast <16 x i1> [[OR]] to i16 8364 // CHECK: [[CMP:%.*]] = icmp eq i16 [[CAST]], -1 8365 // CHECK: [[ZEXT:%.*]] = zext i1 [[CMP]] to i32 8366 // CHECK: trunc i32 [[ZEXT]] to i8 8367 return _kortestc_mask16_u8(_mm512_cmpneq_epu32_mask(__A, __B), 8368 _mm512_cmpneq_epu32_mask(__C, __D)); 8369 } 8370 8371 unsigned char test_kortest_mask16_u8(__m512i __A, __m512i __B, __m512i __C, __m512i __D, unsigned char *CF) { 8372 // CHECK-LABEL: test_kortest_mask16_u8 8373 // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8374 // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8375 // CHECK: [[OR:%.*]] = or <16 x i1> [[LHS]], [[RHS]] 8376 // CHECK: [[CAST:%.*]] = bitcast <16 x i1> [[OR]] to i16 8377 // CHECK: [[CMP:%.*]] = icmp eq i16 [[CAST]], -1 8378 // CHECK: [[ZEXT:%.*]] = zext i1 [[CMP]] to i32 8379 // CHECK: trunc i32 [[ZEXT]] to i8 8380 // CHECK: [[LHS2:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8381 // CHECK: [[RHS2:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8382 // CHECK: [[OR2:%.*]] = or <16 x i1> [[LHS2]], [[RHS2]] 8383 // CHECK: [[CAST2:%.*]] = bitcast <16 x i1> [[OR2]] to i16 8384 // CHECK: [[CMP2:%.*]] = icmp eq i16 [[CAST2]], 0 8385 // CHECK: [[ZEXT2:%.*]] = zext i1 [[CMP2]] to i32 8386 // CHECK: trunc i32 [[ZEXT2]] to i8 8387 return _kortest_mask16_u8(_mm512_cmpneq_epu32_mask(__A, __B), 8388 _mm512_cmpneq_epu32_mask(__C, __D), CF); 8389 } 8390 8391 __mmask16 test_mm512_kunpackb(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) { 8392 // CHECK-LABEL: test_mm512_kunpackb 8393 // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8394 // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8395 // CHECK: [[LHS2:%.*]] = shufflevector <16 x i1> [[LHS]], <16 x i1> [[LHS]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 8396 // CHECK: [[RHS2:%.*]] = shufflevector <16 x i1> [[RHS]], <16 x i1> [[RHS]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 8397 // CHECK: [[CONCAT:%.*]] = shufflevector <8 x i1> [[RHS2]], <8 x i1> [[LHS2]], <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15> 8398 // CHECK: bitcast <16 x i1> [[CONCAT]] to i16 8399 return _mm512_mask_cmpneq_epu32_mask(_mm512_kunpackb(_mm512_cmpneq_epu32_mask(__A, __B), 8400 _mm512_cmpneq_epu32_mask(__C, __D)), 8401 __E, __F); 8402 } 8403 8404 __mmask16 test_mm512_kxnor(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) { 8405 // CHECK-LABEL: test_mm512_kxnor 8406 // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8407 // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8408 // CHECK: [[NOT:%.*]] = xor <16 x i1> [[LHS]], splat (i1 true) 8409 // CHECK: [[RES:%.*]] = xor <16 x i1> [[NOT]], [[RHS]] 8410 // CHECK: bitcast <16 x i1> {{.*}} to i16 8411 return _mm512_mask_cmpneq_epu32_mask(_mm512_kxnor(_mm512_cmpneq_epu32_mask(__A, __B), 8412 _mm512_cmpneq_epu32_mask(__C, __D)), 8413 __E, __F); 8414 } 8415 8416 __mmask16 test_mm512_kxor(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) { 8417 // CHECK-LABEL: test_mm512_kxor 8418 // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8419 // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8420 // CHECK: [[RES:%.*]] = xor <16 x i1> [[LHS]], [[RHS]] 8421 // CHECK: bitcast <16 x i1> {{.*}} to i16 8422 return _mm512_mask_cmpneq_epu32_mask(_mm512_kxor(_mm512_cmpneq_epu32_mask(__A, __B), 8423 _mm512_cmpneq_epu32_mask(__C, __D)), 8424 __E, __F); 8425 } 8426 8427 __mmask16 test_knot_mask16(__mmask16 a) { 8428 // CHECK-LABEL: test_knot_mask16 8429 // CHECK: [[IN:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8430 // CHECK: [[NOT:%.*]] = xor <16 x i1> [[IN]], splat (i1 true) 8431 // CHECK: bitcast <16 x i1> [[NOT]] to i16 8432 return _knot_mask16(a); 8433 } 8434 8435 __mmask16 test_kand_mask16(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) { 8436 // CHECK-LABEL: test_kand_mask16 8437 // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8438 // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8439 // CHECK: [[RES:%.*]] = and <16 x i1> [[LHS]], [[RHS]] 8440 // CHECK: bitcast <16 x i1> {{.*}} to i16 8441 return _mm512_mask_cmpneq_epu32_mask(_kand_mask16(_mm512_cmpneq_epu32_mask(__A, __B), 8442 _mm512_cmpneq_epu32_mask(__C, __D)), 8443 __E, __F); 8444 } 8445 8446 __mmask16 test_kandn_mask16(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) { 8447 // CHECK-LABEL: test_kandn_mask16 8448 // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8449 // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8450 // CHECK: [[NOT:%.*]] = xor <16 x i1> [[LHS]], splat (i1 true) 8451 // CHECK: [[RES:%.*]] = and <16 x i1> [[NOT]], [[RHS]] 8452 // CHECK: bitcast <16 x i1> {{.*}} to i16 8453 return _mm512_mask_cmpneq_epu32_mask(_kandn_mask16(_mm512_cmpneq_epu32_mask(__A, __B), 8454 _mm512_cmpneq_epu32_mask(__C, __D)), 8455 __E, __F); 8456 } 8457 8458 __mmask16 test_kor_mask16(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) { 8459 // CHECK-LABEL: test_kor_mask16 8460 // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8461 // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8462 // CHECK: [[RES:%.*]] = or <16 x i1> [[LHS]], [[RHS]] 8463 // CHECK: bitcast <16 x i1> {{.*}} to i16 8464 return _mm512_mask_cmpneq_epu32_mask(_kor_mask16(_mm512_cmpneq_epu32_mask(__A, __B), 8465 _mm512_cmpneq_epu32_mask(__C, __D)), 8466 __E, __F); 8467 } 8468 8469 __mmask16 test_kxnor_mask16(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) { 8470 // CHECK-LABEL: test_kxnor_mask16 8471 // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8472 // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8473 // CHECK: [[NOT:%.*]] = xor <16 x i1> [[LHS]], splat (i1 true) 8474 // CHECK: [[RES:%.*]] = xor <16 x i1> [[NOT]], [[RHS]] 8475 // CHECK: bitcast <16 x i1> {{.*}} to i16 8476 return _mm512_mask_cmpneq_epu32_mask(_kxnor_mask16(_mm512_cmpneq_epu32_mask(__A, __B), 8477 _mm512_cmpneq_epu32_mask(__C, __D)), 8478 __E, __F); 8479 } 8480 8481 __mmask16 test_kxor_mask16(__m512i __A, __m512i __B, __m512i __C, __m512i __D, __m512i __E, __m512i __F) { 8482 // CHECK-LABEL: test_kxor_mask16 8483 // CHECK: [[LHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8484 // CHECK: [[RHS:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8485 // CHECK: [[RES:%.*]] = xor <16 x i1> [[LHS]], [[RHS]] 8486 // CHECK: bitcast <16 x i1> {{.*}} to i16 8487 return _mm512_mask_cmpneq_epu32_mask(_kxor_mask16(_mm512_cmpneq_epu32_mask(__A, __B), 8488 _mm512_cmpneq_epu32_mask(__C, __D)), 8489 __E, __F); 8490 } 8491 8492 __mmask16 test_kshiftli_mask16(__m512i A, __m512i B, __m512i C, __m512i D) { 8493 // CHECK-LABEL: test_kshiftli_mask16 8494 // CHECK: [[VAL:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8495 // CHECK: [[RES:%.*]] = shufflevector <16 x i1> zeroinitializer, <16 x i1> [[VAL]], <16 x i32> <i32 15, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30> 8496 // CHECK: bitcast <16 x i1> {{.*}} to i16 8497 return _mm512_mask_cmpneq_epu32_mask(_kshiftli_mask16(_mm512_cmpneq_epu32_mask(A, B), 1), C, D); 8498 } 8499 8500 __mmask16 test_kshiftri_mask16(__m512i A, __m512i B, __m512i C, __m512i D) { 8501 // CHECK-LABEL: test_kshiftri_mask16 8502 // CHECK: [[VAL:%.*]] = bitcast i16 %{{.*}} to <16 x i1> 8503 // CHECK: [[RES:%.*]] = shufflevector <16 x i1> [[VAL]], <16 x i1> zeroinitializer, <16 x i32> <i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15, i32 16> 8504 // CHECK: bitcast <16 x i1> {{.*}} to i16 8505 return _mm512_mask_cmpneq_epu32_mask(_kshiftri_mask16(_mm512_cmpneq_epu32_mask(A, B), 1), C, D); 8506 } 8507 8508 unsigned int test_cvtmask16_u32(__m512i A, __m512i B) { 8509 // CHECK-LABEL: test_cvtmask16_u32 8510 // CHECK: bitcast <16 x i1> %{{.*}} to i16 8511 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 8512 // CHECK: zext i16 %{{.*}} to i32 8513 return _cvtmask16_u32(_mm512_cmpneq_epu32_mask(A, B)); 8514 } 8515 8516 __mmask16 test_cvtu32_mask16(__m512i A, __m512i B, unsigned int C) { 8517 // CHECK-LABEL: test_cvtu32_mask16 8518 // CHECK: trunc i32 %{{.*}} to i16 8519 // CHECK: bitcast i16 %{{.*}} to <16 x i1> 8520 return _mm512_mask_cmpneq_epu32_mask(_cvtu32_mask16(C), A, B); 8521 } 8522 8523 __mmask16 test_load_mask16(__mmask16 *A, __m512i B, __m512i C) { 8524 // CHECK-LABEL: test_load_mask16 8525 // CHECK: [[LOAD:%.*]] = load i16, ptr %{{.*}}{{$}} 8526 // CHECK: bitcast i16 [[LOAD]] to <16 x i1> 8527 return _mm512_mask_cmpneq_epu32_mask(_load_mask16(A), B, C); 8528 } 8529 8530 void test_store_mask16(__mmask16 *A, __m512i B, __m512i C) { 8531 // CHECK-LABEL: test_store_mask16 8532 // CHECK: bitcast <16 x i1> %{{.*}} to i16 8533 // CHECK: store i16 %{{.*}}, ptr %{{.*}} 8534 _store_mask16(A, _mm512_cmpneq_epu32_mask(B, C)); 8535 } 8536 8537 void test_mm512_stream_si512(__m512i * __P, __m512i __A) { 8538 // CHECK-LABEL: test_mm512_stream_si512 8539 // CHECK: store <8 x i64> %{{.*}}, ptr %{{.*}}, align 64, !nontemporal [[NONTEMPORAL:![0-9]+]] 8540 _mm512_stream_si512(__P, __A); 8541 } 8542 8543 void test_mm512_stream_si512_2(void * __P, __m512i __A) { 8544 // CHECK-LABEL: test_mm512_stream_si512 8545 // CHECK: store <8 x i64> %{{.*}}, ptr %{{.*}}, align 64, !nontemporal [[NONTEMPORAL]] 8546 _mm512_stream_si512(__P, __A); 8547 } 8548 8549 __m512i test_mm512_stream_load_si512(void *__P) { 8550 // CHECK-LABEL: test_mm512_stream_load_si512 8551 // CHECK: load <8 x i64>, ptr %{{.*}}, align 64, !nontemporal [[NONTEMPORAL]]{{$}} 8552 return _mm512_stream_load_si512(__P); 8553 } 8554 8555 __m512i test_mm512_stream_load_si512_const(void const *__P) { 8556 // CHECK-LABEL: test_mm512_stream_load_si512_const 8557 // CHECK: load <8 x i64>, ptr %{{.*}}, align 64, !nontemporal [[NONTEMPORAL]]{{$}} 8558 return _mm512_stream_load_si512(__P); 8559 } 8560 8561 void test_mm512_stream_pd(double *__P, __m512d __A) { 8562 // CHECK-LABEL: test_mm512_stream_pd 8563 // CHECK: store <8 x double> %{{.*}}, ptr %{{.*}}, align 64, !nontemporal [[NONTEMPORAL]] 8564 return _mm512_stream_pd(__P, __A); 8565 } 8566 8567 void test_mm512_stream_pd_2(void *__P, __m512d __A) { 8568 // CHECK-LABEL: test_mm512_stream_pd 8569 // CHECK: store <8 x double> %{{.*}}, ptr %{{.*}}, align 64, !nontemporal [[NONTEMPORAL]] 8570 return _mm512_stream_pd(__P, __A); 8571 } 8572 8573 void test_mm512_stream_ps(float *__P, __m512 __A) { 8574 // CHECK-LABEL: test_mm512_stream_ps 8575 // CHECK: store <16 x float> %{{.*}}, ptr %{{.*}}, align 64, !nontemporal [[NONTEMPORAL]] 8576 _mm512_stream_ps(__P, __A); 8577 } 8578 8579 void test_mm512_stream_ps_2(void *__P, __m512 __A) { 8580 // CHECK-LABEL: test_mm512_stream_ps 8581 // CHECK: store <16 x float> %{{.*}}, ptr %{{.*}}, align 64, !nontemporal [[NONTEMPORAL]] 8582 _mm512_stream_ps(__P, __A); 8583 } 8584 __m512d test_mm512_mask_compress_pd(__m512d __W, __mmask8 __U, __m512d __A) { 8585 // CHECK-LABEL: test_mm512_mask_compress_pd 8586 // CHECK: @llvm.x86.avx512.mask.compress 8587 return _mm512_mask_compress_pd(__W, __U, __A); 8588 } 8589 8590 __m512d test_mm512_maskz_compress_pd(__mmask8 __U, __m512d __A) { 8591 // CHECK-LABEL: test_mm512_maskz_compress_pd 8592 // CHECK: @llvm.x86.avx512.mask.compress 8593 return _mm512_maskz_compress_pd(__U, __A); 8594 } 8595 8596 __m512i test_mm512_mask_compress_epi64(__m512i __W, __mmask8 __U, __m512i __A) { 8597 // CHECK-LABEL: test_mm512_mask_compress_epi64 8598 // CHECK: @llvm.x86.avx512.mask.compress 8599 return _mm512_mask_compress_epi64(__W, __U, __A); 8600 } 8601 8602 __m512i test_mm512_maskz_compress_epi64(__mmask8 __U, __m512i __A) { 8603 // CHECK-LABEL: test_mm512_maskz_compress_epi64 8604 // CHECK: @llvm.x86.avx512.mask.compress 8605 return _mm512_maskz_compress_epi64(__U, __A); 8606 } 8607 8608 __m512 test_mm512_mask_compress_ps(__m512 __W, __mmask16 __U, __m512 __A) { 8609 // CHECK-LABEL: test_mm512_mask_compress_ps 8610 // CHECK: @llvm.x86.avx512.mask.compress 8611 return _mm512_mask_compress_ps(__W, __U, __A); 8612 } 8613 8614 __m512 test_mm512_maskz_compress_ps(__mmask16 __U, __m512 __A) { 8615 // CHECK-LABEL: test_mm512_maskz_compress_ps 8616 // CHECK: @llvm.x86.avx512.mask.compress 8617 return _mm512_maskz_compress_ps(__U, __A); 8618 } 8619 8620 __m512i test_mm512_mask_compress_epi32(__m512i __W, __mmask16 __U, __m512i __A) { 8621 // CHECK-LABEL: test_mm512_mask_compress_epi32 8622 // CHECK: @llvm.x86.avx512.mask.compress 8623 return _mm512_mask_compress_epi32(__W, __U, __A); 8624 } 8625 8626 __m512i test_mm512_maskz_compress_epi32(__mmask16 __U, __m512i __A) { 8627 // CHECK-LABEL: test_mm512_maskz_compress_epi32 8628 // CHECK: @llvm.x86.avx512.mask.compress 8629 return _mm512_maskz_compress_epi32(__U, __A); 8630 } 8631 8632 __mmask8 test_mm_cmp_round_ss_mask(__m128 __X, __m128 __Y) { 8633 // CHECK-LABEL: test_mm_cmp_round_ss_mask 8634 // CHECK: @llvm.x86.avx512.mask.cmp 8635 return _mm_cmp_round_ss_mask(__X, __Y, _CMP_NLT_US, _MM_FROUND_NO_EXC); 8636 } 8637 8638 __mmask8 test_mm_mask_cmp_round_ss_mask(__mmask8 __M, __m128 __X, __m128 __Y) { 8639 // CHECK-LABEL: test_mm_mask_cmp_round_ss_mask 8640 // CHECK: @llvm.x86.avx512.mask.cmp 8641 return _mm_mask_cmp_round_ss_mask(__M, __X, __Y, _CMP_NLT_US, _MM_FROUND_NO_EXC); 8642 } 8643 8644 __mmask8 test_mm_cmp_ss_mask(__m128 __X, __m128 __Y) { 8645 // CHECK-LABEL: test_mm_cmp_ss_mask 8646 // CHECK: @llvm.x86.avx512.mask.cmp 8647 return _mm_cmp_ss_mask(__X, __Y, _CMP_NLT_US); 8648 } 8649 8650 __mmask8 test_mm_mask_cmp_ss_mask(__mmask8 __M, __m128 __X, __m128 __Y) { 8651 // CHECK-LABEL: test_mm_mask_cmp_ss_mask 8652 // CHECK: @llvm.x86.avx512.mask.cmp 8653 return _mm_mask_cmp_ss_mask(__M, __X, __Y, _CMP_NLT_US); 8654 } 8655 8656 __mmask8 test_mm_cmp_round_sd_mask(__m128d __X, __m128d __Y) { 8657 // CHECK-LABEL: test_mm_cmp_round_sd_mask 8658 // CHECK: @llvm.x86.avx512.mask.cmp 8659 return _mm_cmp_round_sd_mask(__X, __Y, _CMP_NLT_US, _MM_FROUND_NO_EXC); 8660 } 8661 8662 __mmask8 test_mm_mask_cmp_round_sd_mask(__mmask8 __M, __m128d __X, __m128d __Y) { 8663 // CHECK-LABEL: test_mm_mask_cmp_round_sd_mask 8664 // CHECK: @llvm.x86.avx512.mask.cmp 8665 return _mm_mask_cmp_round_sd_mask(__M, __X, __Y, _CMP_NLT_US, _MM_FROUND_NO_EXC); 8666 } 8667 8668 __mmask8 test_mm_cmp_sd_mask(__m128d __X, __m128d __Y) { 8669 // CHECK-LABEL: test_mm_cmp_sd_mask 8670 // CHECK: @llvm.x86.avx512.mask.cmp 8671 return _mm_cmp_sd_mask(__X, __Y, _CMP_NLT_US); 8672 } 8673 8674 __mmask8 test_mm_mask_cmp_sd_mask(__mmask8 __M, __m128d __X, __m128d __Y) { 8675 // CHECK-LABEL: test_mm_mask_cmp_sd_mask 8676 // CHECK: @llvm.x86.avx512.mask.cmp 8677 return _mm_mask_cmp_sd_mask(__M, __X, __Y, _CMP_NLT_US); 8678 } 8679 8680 __m512 test_mm512_movehdup_ps(__m512 __A) { 8681 // CHECK-LABEL: test_mm512_movehdup_ps 8682 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 1, i32 1, i32 3, i32 3, i32 5, i32 5, i32 7, i32 7, i32 9, i32 9, i32 11, i32 11, i32 13, i32 13, i32 15, i32 15> 8683 return _mm512_movehdup_ps(__A); 8684 } 8685 8686 __m512 test_mm512_mask_movehdup_ps(__m512 __W, __mmask16 __U, __m512 __A) { 8687 // CHECK-LABEL: test_mm512_mask_movehdup_ps 8688 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 1, i32 1, i32 3, i32 3, i32 5, i32 5, i32 7, i32 7, i32 9, i32 9, i32 11, i32 11, i32 13, i32 13, i32 15, i32 15> 8689 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 8690 return _mm512_mask_movehdup_ps(__W, __U, __A); 8691 } 8692 8693 __m512 test_mm512_maskz_movehdup_ps(__mmask16 __U, __m512 __A) { 8694 // CHECK-LABEL: test_mm512_maskz_movehdup_ps 8695 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 1, i32 1, i32 3, i32 3, i32 5, i32 5, i32 7, i32 7, i32 9, i32 9, i32 11, i32 11, i32 13, i32 13, i32 15, i32 15> 8696 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 8697 return _mm512_maskz_movehdup_ps(__U, __A); 8698 } 8699 8700 __m512 test_mm512_moveldup_ps(__m512 __A) { 8701 // CHECK-LABEL: test_mm512_moveldup_ps 8702 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 0, i32 2, i32 2, i32 4, i32 4, i32 6, i32 6, i32 8, i32 8, i32 10, i32 10, i32 12, i32 12, i32 14, i32 14> 8703 return _mm512_moveldup_ps(__A); 8704 } 8705 8706 __m512 test_mm512_mask_moveldup_ps(__m512 __W, __mmask16 __U, __m512 __A) { 8707 // CHECK-LABEL: test_mm512_mask_moveldup_ps 8708 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 0, i32 2, i32 2, i32 4, i32 4, i32 6, i32 6, i32 8, i32 8, i32 10, i32 10, i32 12, i32 12, i32 14, i32 14> 8709 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 8710 return _mm512_mask_moveldup_ps(__W, __U, __A); 8711 } 8712 8713 __m512 test_mm512_maskz_moveldup_ps(__mmask16 __U, __m512 __A) { 8714 // CHECK-LABEL: test_mm512_maskz_moveldup_ps 8715 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <16 x i32> <i32 0, i32 0, i32 2, i32 2, i32 4, i32 4, i32 6, i32 6, i32 8, i32 8, i32 10, i32 10, i32 12, i32 12, i32 14, i32 14> 8716 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 8717 return _mm512_maskz_moveldup_ps(__U, __A); 8718 } 8719 8720 __m512i test_mm512_shuffle_epi32(__m512i __A) { 8721 // CHECK-LABEL: test_mm512_shuffle_epi32 8722 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> poison, <16 x i32> <i32 1, i32 0, i32 0, i32 0, i32 5, i32 4, i32 4, i32 4, i32 9, i32 8, i32 8, i32 8, i32 13, i32 12, i32 12, i32 12> 8723 return _mm512_shuffle_epi32(__A, 1); 8724 } 8725 8726 __m512i test_mm512_mask_shuffle_epi32(__m512i __W, __mmask16 __U, __m512i __A) { 8727 // CHECK-LABEL: test_mm512_mask_shuffle_epi32 8728 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> poison, <16 x i32> <i32 1, i32 0, i32 0, i32 0, i32 5, i32 4, i32 4, i32 4, i32 9, i32 8, i32 8, i32 8, i32 13, i32 12, i32 12, i32 12> 8729 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 8730 return _mm512_mask_shuffle_epi32(__W, __U, __A, 1); 8731 } 8732 8733 __m512i test_mm512_maskz_shuffle_epi32(__mmask16 __U, __m512i __A) { 8734 // CHECK-LABEL: test_mm512_maskz_shuffle_epi32 8735 // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> poison, <16 x i32> <i32 1, i32 0, i32 0, i32 0, i32 5, i32 4, i32 4, i32 4, i32 9, i32 8, i32 8, i32 8, i32 13, i32 12, i32 12, i32 12> 8736 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 8737 return _mm512_maskz_shuffle_epi32(__U, __A, 1); 8738 } 8739 8740 __m512d test_mm512_mask_expand_pd(__m512d __W, __mmask8 __U, __m512d __A) { 8741 // CHECK-LABEL: test_mm512_mask_expand_pd 8742 // CHECK: @llvm.x86.avx512.mask.expand 8743 return _mm512_mask_expand_pd(__W, __U, __A); 8744 } 8745 8746 __m512d test_mm512_maskz_expand_pd(__mmask8 __U, __m512d __A) { 8747 // CHECK-LABEL: test_mm512_maskz_expand_pd 8748 // CHECK: @llvm.x86.avx512.mask.expand 8749 return _mm512_maskz_expand_pd(__U, __A); 8750 } 8751 8752 __m512i test_mm512_mask_expand_epi64(__m512i __W, __mmask8 __U, __m512i __A) { 8753 // CHECK-LABEL: test_mm512_mask_expand_epi64 8754 // CHECK: @llvm.x86.avx512.mask.expand 8755 return _mm512_mask_expand_epi64(__W, __U, __A); 8756 } 8757 8758 __m512i test_mm512_maskz_expand_epi64(__mmask8 __U, __m512i __A) { 8759 // CHECK-LABEL: test_mm512_maskz_expand_epi64 8760 // CHECK: @llvm.x86.avx512.mask.expand 8761 return _mm512_maskz_expand_epi64(__U, __A); 8762 } 8763 __m512i test_mm512_mask_expandloadu_epi64(__m512i __W, __mmask8 __U, void const *__P) { 8764 // CHECK-LABEL: test_mm512_mask_expandloadu_epi64 8765 // CHECK: @llvm.masked.expandload.v8i64(ptr %{{.*}}, <8 x i1> %{{.*}}, <8 x i64> %{{.*}}) 8766 return _mm512_mask_expandloadu_epi64(__W, __U, __P); 8767 } 8768 8769 __m512i test_mm512_maskz_expandloadu_epi64(__mmask8 __U, void const *__P) { 8770 // CHECK-LABEL: test_mm512_maskz_expandloadu_epi64 8771 // CHECK: @llvm.masked.expandload.v8i64(ptr %{{.*}}, <8 x i1> %{{.*}}, <8 x i64> %{{.*}}) 8772 return _mm512_maskz_expandloadu_epi64(__U, __P); 8773 } 8774 8775 __m512d test_mm512_mask_expandloadu_pd(__m512d __W, __mmask8 __U, void const *__P) { 8776 // CHECK-LABEL: test_mm512_mask_expandloadu_pd 8777 // CHECK: @llvm.masked.expandload.v8f64(ptr %{{.*}}, <8 x i1> %{{.*}}, <8 x double> %{{.*}}) 8778 return _mm512_mask_expandloadu_pd(__W, __U, __P); 8779 } 8780 8781 __m512d test_mm512_maskz_expandloadu_pd(__mmask8 __U, void const *__P) { 8782 // CHECK-LABEL: test_mm512_maskz_expandloadu_pd 8783 // CHECK: @llvm.masked.expandload.v8f64(ptr %{{.*}}, <8 x i1> %{{.*}}, <8 x double> %{{.*}}) 8784 return _mm512_maskz_expandloadu_pd(__U, __P); 8785 } 8786 8787 __m512i test_mm512_mask_expandloadu_epi32(__m512i __W, __mmask16 __U, void const *__P) { 8788 // CHECK-LABEL: test_mm512_mask_expandloadu_epi32 8789 // CHECK: @llvm.masked.expandload.v16i32(ptr %{{.*}}, <16 x i1> %{{.*}}, <16 x i32> %{{.*}}) 8790 return _mm512_mask_expandloadu_epi32(__W, __U, __P); 8791 } 8792 8793 __m512i test_mm512_maskz_expandloadu_epi32(__mmask16 __U, void const *__P) { 8794 // CHECK-LABEL: test_mm512_maskz_expandloadu_epi32 8795 // CHECK: @llvm.masked.expandload.v16i32(ptr %{{.*}}, <16 x i1> %{{.*}}, <16 x i32> %{{.*}}) 8796 return _mm512_maskz_expandloadu_epi32(__U, __P); 8797 } 8798 8799 __m512 test_mm512_mask_expandloadu_ps(__m512 __W, __mmask16 __U, void const *__P) { 8800 // CHECK-LABEL: test_mm512_mask_expandloadu_ps 8801 // CHECK: @llvm.masked.expandload.v16f32(ptr %{{.*}}, <16 x i1> %{{.*}}, <16 x float> %{{.*}}) 8802 return _mm512_mask_expandloadu_ps(__W, __U, __P); 8803 } 8804 8805 __m512 test_mm512_maskz_expandloadu_ps(__mmask16 __U, void const *__P) { 8806 // CHECK-LABEL: test_mm512_maskz_expandloadu_ps 8807 // CHECK: @llvm.masked.expandload.v16f32(ptr %{{.*}}, <16 x i1> %{{.*}}, <16 x float> %{{.*}}) 8808 return _mm512_maskz_expandloadu_ps(__U, __P); 8809 } 8810 8811 __m512 test_mm512_mask_expand_ps(__m512 __W, __mmask16 __U, __m512 __A) { 8812 // CHECK-LABEL: test_mm512_mask_expand_ps 8813 // CHECK: @llvm.x86.avx512.mask.expand 8814 return _mm512_mask_expand_ps(__W, __U, __A); 8815 } 8816 8817 __m512 test_mm512_maskz_expand_ps(__mmask16 __U, __m512 __A) { 8818 // CHECK-LABEL: test_mm512_maskz_expand_ps 8819 // CHECK: @llvm.x86.avx512.mask.expand 8820 return _mm512_maskz_expand_ps(__U, __A); 8821 } 8822 8823 __m512i test_mm512_mask_expand_epi32(__m512i __W, __mmask16 __U, __m512i __A) { 8824 // CHECK-LABEL: test_mm512_mask_expand_epi32 8825 // CHECK: @llvm.x86.avx512.mask.expand 8826 return _mm512_mask_expand_epi32(__W, __U, __A); 8827 } 8828 8829 __m512i test_mm512_maskz_expand_epi32(__mmask16 __U, __m512i __A) { 8830 // CHECK-LABEL: test_mm512_maskz_expand_epi32 8831 // CHECK: @llvm.x86.avx512.mask.expand 8832 return _mm512_maskz_expand_epi32(__U, __A); 8833 } 8834 __m512d test_mm512_cvt_roundps_pd(__m256 __A) { 8835 // CHECK-LABEL: test_mm512_cvt_roundps_pd 8836 // CHECK: @llvm.x86.avx512.mask.cvtps2pd.512 8837 return _mm512_cvt_roundps_pd(__A, _MM_FROUND_NO_EXC); 8838 } 8839 8840 __m512d test_mm512_mask_cvt_roundps_pd(__m512d __W, __mmask8 __U, __m256 __A) { 8841 // CHECK-LABEL: test_mm512_mask_cvt_roundps_pd 8842 // CHECK: @llvm.x86.avx512.mask.cvtps2pd.512 8843 return _mm512_mask_cvt_roundps_pd(__W, __U, __A, _MM_FROUND_NO_EXC); 8844 } 8845 8846 __m512d test_mm512_maskz_cvt_roundps_pd(__mmask8 __U, __m256 __A) { 8847 // CHECK-LABEL: test_mm512_maskz_cvt_roundps_pd 8848 // CHECK: @llvm.x86.avx512.mask.cvtps2pd.512 8849 return _mm512_maskz_cvt_roundps_pd(__U, __A, _MM_FROUND_NO_EXC); 8850 } 8851 8852 __m512d test_mm512_cvtps_pd(__m256 __A) { 8853 // CHECK-LABEL: test_mm512_cvtps_pd 8854 // CHECK: fpext <8 x float> %{{.*}} to <8 x double> 8855 return _mm512_cvtps_pd(__A); 8856 } 8857 8858 __m512d test_mm512_cvtpslo_pd(__m512 __A) { 8859 // CHECK-LABEL: test_mm512_cvtpslo_pd 8860 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 8861 // CHECK: fpext <8 x float> %{{.*}} to <8 x double> 8862 return _mm512_cvtpslo_pd(__A); 8863 } 8864 8865 __m512d test_mm512_mask_cvtps_pd(__m512d __W, __mmask8 __U, __m256 __A) { 8866 // CHECK-LABEL: test_mm512_mask_cvtps_pd 8867 // CHECK: fpext <8 x float> %{{.*}} to <8 x double> 8868 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 8869 return _mm512_mask_cvtps_pd(__W, __U, __A); 8870 } 8871 8872 __m512d test_mm512_mask_cvtpslo_pd(__m512d __W, __mmask8 __U, __m512 __A) { 8873 // CHECK-LABEL: test_mm512_mask_cvtpslo_pd 8874 // CHECK: shufflevector <16 x float> %{{.*}}, <16 x float> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 8875 // CHECK: fpext <8 x float> %{{.*}} to <8 x double> 8876 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 8877 return _mm512_mask_cvtpslo_pd(__W, __U, __A); 8878 } 8879 8880 __m512d test_mm512_maskz_cvtps_pd(__mmask8 __U, __m256 __A) { 8881 // CHECK-LABEL: test_mm512_maskz_cvtps_pd 8882 // CHECK: fpext <8 x float> %{{.*}} to <8 x double> 8883 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 8884 return _mm512_maskz_cvtps_pd(__U, __A); 8885 } 8886 __m512d test_mm512_mask_mov_pd(__m512d __W, __mmask8 __U, __m512d __A) { 8887 // CHECK-LABEL: test_mm512_mask_mov_pd 8888 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 8889 return _mm512_mask_mov_pd(__W, __U, __A); 8890 } 8891 8892 __m512d test_mm512_maskz_mov_pd(__mmask8 __U, __m512d __A) { 8893 // CHECK-LABEL: test_mm512_maskz_mov_pd 8894 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 8895 return _mm512_maskz_mov_pd(__U, __A); 8896 } 8897 8898 __m512 test_mm512_mask_mov_ps(__m512 __W, __mmask16 __U, __m512 __A) { 8899 // CHECK-LABEL: test_mm512_mask_mov_ps 8900 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 8901 return _mm512_mask_mov_ps(__W, __U, __A); 8902 } 8903 8904 __m512 test_mm512_maskz_mov_ps(__mmask16 __U, __m512 __A) { 8905 // CHECK-LABEL: test_mm512_maskz_mov_ps 8906 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 8907 return _mm512_maskz_mov_ps(__U, __A); 8908 } 8909 8910 void test_mm512_mask_compressstoreu_pd(void *__P, __mmask8 __U, __m512d __A) { 8911 // CHECK-LABEL: test_mm512_mask_compressstoreu_pd 8912 // CHECK: @llvm.masked.compressstore.v8f64(<8 x double> %{{.*}}, ptr %{{.*}}, <8 x i1> %{{.*}}) 8913 return _mm512_mask_compressstoreu_pd(__P, __U, __A); 8914 } 8915 8916 void test_mm512_mask_compressstoreu_epi64(void *__P, __mmask8 __U, __m512i __A) { 8917 // CHECK-LABEL: test_mm512_mask_compressstoreu_epi64 8918 // CHECK: @llvm.masked.compressstore.v8i64(<8 x i64> %{{.*}}, ptr %{{.*}}, <8 x i1> %{{.*}}) 8919 return _mm512_mask_compressstoreu_epi64(__P, __U, __A); 8920 } 8921 8922 void test_mm512_mask_compressstoreu_ps(void *__P, __mmask16 __U, __m512 __A) { 8923 // CHECK-LABEL: test_mm512_mask_compressstoreu_ps 8924 // CHECK: @llvm.masked.compressstore.v16f32(<16 x float> %{{.*}}, ptr %{{.*}}, <16 x i1> %{{.*}}) 8925 return _mm512_mask_compressstoreu_ps(__P, __U, __A); 8926 } 8927 8928 void test_mm512_mask_compressstoreu_epi32(void *__P, __mmask16 __U, __m512i __A) { 8929 // CHECK-LABEL: test_mm512_mask_compressstoreu_epi32 8930 // CHECK: @llvm.masked.compressstore.v16i32(<16 x i32> %{{.*}}, ptr %{{.*}}, <16 x i1> %{{.*}}) 8931 return _mm512_mask_compressstoreu_epi32(__P, __U, __A); 8932 } 8933 8934 __m256i test_mm512_cvtt_roundpd_epu32(__m512d __A) { 8935 // CHECK-LABEL: test_mm512_cvtt_roundpd_epu32 8936 // CHECK: @llvm.x86.avx512.mask.cvttpd2udq.512 8937 return _mm512_cvtt_roundpd_epu32(__A, _MM_FROUND_NO_EXC); 8938 } 8939 8940 __m256i test_mm512_mask_cvtt_roundpd_epu32(__m256i __W, __mmask8 __U, __m512d __A) { 8941 // CHECK-LABEL: test_mm512_mask_cvtt_roundpd_epu32 8942 // CHECK: @llvm.x86.avx512.mask.cvttpd2udq.512 8943 return _mm512_mask_cvtt_roundpd_epu32(__W, __U, __A, _MM_FROUND_NO_EXC); 8944 } 8945 8946 __m256i test_mm512_maskz_cvtt_roundpd_epu32(__mmask8 __U, __m512d __A) { 8947 // CHECK-LABEL: test_mm512_maskz_cvtt_roundpd_epu32 8948 // CHECK: @llvm.x86.avx512.mask.cvttpd2udq.512 8949 return _mm512_maskz_cvtt_roundpd_epu32(__U, __A, _MM_FROUND_NO_EXC); 8950 } 8951 8952 __m256i test_mm512_cvttpd_epu32(__m512d __A) { 8953 // CHECK-LABEL: test_mm512_cvttpd_epu32 8954 // CHECK: @llvm.x86.avx512.mask.cvttpd2udq.512 8955 return _mm512_cvttpd_epu32(__A); 8956 } 8957 8958 __m256i test_mm512_mask_cvttpd_epu32(__m256i __W, __mmask8 __U, __m512d __A) { 8959 // CHECK-LABEL: test_mm512_mask_cvttpd_epu32 8960 // CHECK: @llvm.x86.avx512.mask.cvttpd2udq.512 8961 return _mm512_mask_cvttpd_epu32(__W, __U, __A); 8962 } 8963 8964 __m256i test_mm512_maskz_cvttpd_epu32(__mmask8 __U, __m512d __A) { 8965 // CHECK-LABEL: test_mm512_maskz_cvttpd_epu32 8966 // CHECK: @llvm.x86.avx512.mask.cvttpd2udq.512 8967 return _mm512_maskz_cvttpd_epu32(__U, __A); 8968 } 8969 8970 __m512 test_mm512_castpd_ps (__m512d __A) 8971 { 8972 // CHECK-LABEL: test_mm512_castpd_ps 8973 // CHECK: bitcast <8 x double> %{{.}} to <16 x float> 8974 return _mm512_castpd_ps (__A); 8975 } 8976 8977 __m512d test_mm512_castps_pd (__m512 __A) 8978 { 8979 // CHECK-LABEL: test_mm512_castps_pd 8980 // CHECK: bitcast <16 x float> %{{.}} to <8 x double> 8981 return _mm512_castps_pd (__A); 8982 } 8983 8984 __m512i test_mm512_castpd_si512 (__m512d __A) 8985 { 8986 // CHECK-LABEL: test_mm512_castpd_si512 8987 // CHECK: bitcast <8 x double> %{{.}} to <8 x i64> 8988 return _mm512_castpd_si512 (__A); 8989 } 8990 8991 __m512 test_mm512_castps128_ps512(__m128 __A) { 8992 // CHECK-LABEL: test_mm512_castps128_ps512 8993 // CHECK: [[B:%.*]] = freeze <8 x float> poison 8994 // CHECK: store <8 x float> [[B]], ptr [[BA:%.*]] 8995 // CHECK: [[A:%.*]] = freeze <4 x float> poison 8996 // CHECK: [[SV:%.*]] = 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> 8997 // CHECK: [[C:%.*]] = load <8 x float>, ptr [[BA]] 8998 // CHECK: shufflevector <8 x float> [[SV]], <8 x float> [[C]], <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15> 8999 return _mm512_castps128_ps512(__A); 9000 } 9001 9002 __m512d test_mm512_castpd128_pd512(__m128d __A) { 9003 // CHECK-LABEL: test_mm512_castpd128_pd512 9004 // CHECK: [[B:%.*]] = freeze <4 x double> poison 9005 // CHECK: store <4 x double> [[B]], ptr [[BA:%.*]] 9006 // CHECK: [[A:%.*]] = freeze <2 x double> poison 9007 // CHECK: [[SV:%.*]] = shufflevector <2 x double> %{{.*}}, <2 x double> [[A]], <4 x i32> <i32 0, i32 1, i32 2, i32 3> 9008 // CHECK: [[C:%.*]] = load <4 x double>, ptr [[BA]] 9009 // CHECK: shufflevector <4 x double> [[SV]], <4 x double> [[C]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 9010 return _mm512_castpd128_pd512(__A); 9011 } 9012 9013 __m512i test_mm512_set1_epi8(char d) 9014 { 9015 // CHECK-LABEL: test_mm512_set1_epi8 9016 // CHECK: insertelement <64 x i8> {{.*}}, i32 0 9017 // CHECK: insertelement <64 x i8> {{.*}}, i32 1 9018 // CHECK: insertelement <64 x i8> {{.*}}, i32 2 9019 // CHECK: insertelement <64 x i8> {{.*}}, i32 3 9020 // CHECK: insertelement <64 x i8> {{.*}}, i32 4 9021 // CHECK: insertelement <64 x i8> {{.*}}, i32 5 9022 // CHECK: insertelement <64 x i8> {{.*}}, i32 6 9023 // CHECK: insertelement <64 x i8> {{.*}}, i32 7 9024 // CHECK: insertelement <64 x i8> {{.*}}, i32 63 9025 return _mm512_set1_epi8(d); 9026 } 9027 9028 __m512i test_mm512_set1_epi16(short d) 9029 { 9030 // CHECK-LABEL: test_mm512_set1_epi16 9031 // CHECK: insertelement <32 x i16> {{.*}}, i32 0 9032 // CHECK: insertelement <32 x i16> {{.*}}, i32 1 9033 // CHECK: insertelement <32 x i16> {{.*}}, i32 2 9034 // CHECK: insertelement <32 x i16> {{.*}}, i32 3 9035 // CHECK: insertelement <32 x i16> {{.*}}, i32 4 9036 // CHECK: insertelement <32 x i16> {{.*}}, i32 5 9037 // CHECK: insertelement <32 x i16> {{.*}}, i32 6 9038 // CHECK: insertelement <32 x i16> {{.*}}, i32 7 9039 // CHECK: insertelement <32 x i16> {{.*}}, i32 31 9040 return _mm512_set1_epi16(d); 9041 } 9042 9043 __m512i test_mm512_set4_epi32 (int __A, int __B, int __C, int __D) 9044 { 9045 // CHECK-LABEL: test_mm512_set4_epi32 9046 // CHECK: insertelement <16 x i32> {{.*}}, i32 15 9047 return _mm512_set4_epi32 (__A,__B,__C,__D); 9048 } 9049 9050 __m512i test_mm512_set4_epi64 (long long __A, long long __B, long long __C, long long __D) 9051 { 9052 // CHECK-LABEL: test_mm512_set4_epi64 9053 // CHECK: insertelement <8 x i64> {{.*}}, i32 7 9054 return _mm512_set4_epi64 (__A,__B,__C,__D); 9055 } 9056 9057 __m512d test_mm512_set4_pd (double __A, double __B, double __C, double __D) 9058 { 9059 // CHECK-LABEL: test_mm512_set4_pd 9060 // CHECK: insertelement <8 x double> {{.*}}, i32 7 9061 return _mm512_set4_pd (__A,__B,__C,__D); 9062 } 9063 9064 __m512 test_mm512_set4_ps (float __A, float __B, float __C, float __D) 9065 { 9066 // CHECK-LABEL: test_mm512_set4_ps 9067 // CHECK: insertelement <16 x float> {{.*}}, i32 15 9068 return _mm512_set4_ps (__A,__B,__C,__D); 9069 } 9070 9071 __m512i test_mm512_setr4_epi32(int e0, int e1, int e2, int e3) 9072 { 9073 // CHECK-LABEL: test_mm512_setr4_epi32 9074 // CHECK: insertelement <16 x i32> {{.*}}, i32 15 9075 return _mm512_setr4_epi32(e0, e1, e2, e3); 9076 } 9077 9078 __m512i test_mm512_setr4_epi64(long long e0, long long e1, long long e2, long long e3) 9079 { 9080 // CHECK-LABEL: test_mm512_setr4_epi64 9081 // CHECK: insertelement <8 x i64> {{.*}}, i32 7 9082 return _mm512_setr4_epi64(e0, e1, e2, e3); 9083 } 9084 9085 __m512d test_mm512_setr4_pd(double e0, double e1, double e2, double e3) 9086 { 9087 // CHECK-LABEL: test_mm512_setr4_pd 9088 // CHECK: insertelement <8 x double> {{.*}}, i32 7 9089 return _mm512_setr4_pd(e0,e1,e2,e3); 9090 } 9091 9092 __m512 test_mm512_setr4_ps(float e0, float e1, float e2, float e3) 9093 { 9094 // CHECK-LABEL: test_mm512_setr4_ps 9095 // CHECK: insertelement <16 x float> {{.*}}, i32 15 9096 return _mm512_setr4_ps(e0,e1,e2,e3); 9097 } 9098 9099 __m512d test_mm512_castpd256_pd512(__m256d a) 9100 { 9101 // CHECK-LABEL: test_mm512_castpd256_pd512 9102 // CHECK: [[A:%.*]] = freeze <4 x double> poison 9103 // CHECK: shufflevector <4 x double> %{{.}}, <4 x double> [[A]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 9104 return _mm512_castpd256_pd512(a); 9105 } 9106 9107 __m256d test_mm512_castpd512_pd256 (__m512d __A) 9108 { 9109 // CHECK-LABEL: test_mm512_castpd512_pd256 9110 // CHECK: shufflevector <8 x double> %{{.}}, <8 x double> %{{.}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 9111 return _mm512_castpd512_pd256 (__A); 9112 } 9113 9114 __m256 test_mm512_castps512_ps256 (__m512 __A) 9115 { 9116 // CHECK-LABEL: test_mm512_castps512_ps256 9117 // CHECK: shufflevector <16 x float> %{{.}}, <16 x float> %{{.}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 9118 return _mm512_castps512_ps256 (__A); 9119 } 9120 9121 __m512i test_mm512_castps_si512 (__m512 __A) 9122 { 9123 // CHECK-LABEL: test_mm512_castps_si512 9124 // CHECK: bitcast <16 x float> %{{.}} to <8 x i64> 9125 return _mm512_castps_si512 (__A); 9126 } 9127 __m512i test_mm512_castsi128_si512(__m128i __A) { 9128 // CHECK-LABEL: test_mm512_castsi128_si512 9129 // CHECK: [[B:%.*]] = freeze <4 x i64> poison 9130 // CHECK: store <4 x i64> [[B]], ptr [[BA:%.*]] 9131 // CHECK: [[A:%.*]] = freeze <2 x i64> poison 9132 // CHECK: [[SV:%.*]] = shufflevector <2 x i64> %{{.*}}, <2 x i64> [[A]], <4 x i32> <i32 0, i32 1, i32 2, i32 3> 9133 // CHECK: [[C:%.*]] = load <4 x i64>, ptr [[BA]] 9134 // CHECK: shufflevector <4 x i64> [[SV]], <4 x i64> [[C]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 9135 return _mm512_castsi128_si512(__A); 9136 } 9137 9138 __m512i test_mm512_castsi256_si512(__m256i __A) { 9139 // CHECK-LABEL: test_mm512_castsi256_si512 9140 // CHECK: [[A:%.*]] = freeze <4 x i64> poison 9141 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> [[A]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 9142 return _mm512_castsi256_si512(__A); 9143 } 9144 9145 __m512 test_mm512_castsi512_ps (__m512i __A) 9146 { 9147 // CHECK-LABEL: test_mm512_castsi512_ps 9148 // CHECK: bitcast <8 x i64> %{{.}} to <16 x float> 9149 return _mm512_castsi512_ps (__A); 9150 } 9151 9152 __m512d test_mm512_castsi512_pd (__m512i __A) 9153 { 9154 // CHECK-LABEL: test_mm512_castsi512_pd 9155 // CHECK: bitcast <8 x i64> %{{.}} to <8 x double> 9156 return _mm512_castsi512_pd (__A); 9157 } 9158 9159 __m128i test_mm512_castsi512_si128 (__m512i __A) 9160 { 9161 // CHECK-LABEL: test_mm512_castsi512_si128 9162 // CHECK: shufflevector <8 x i64> %{{.}}, <8 x i64> %{{.}}, <2 x i32> <i32 0, i32 1> 9163 return _mm512_castsi512_si128 (__A); 9164 } 9165 9166 __m256i test_mm512_castsi512_si256 (__m512i __A) 9167 { 9168 // CHECK-LABEL: test_mm512_castsi512_si256 9169 // CHECK: shufflevector <8 x i64> %{{.}}, <8 x i64> %{{.}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 9170 return _mm512_castsi512_si256 (__A); 9171 } 9172 9173 __m128 test_mm_cvt_roundsd_ss(__m128 __A, __m128d __B) { 9174 // CHECK-LABEL: test_mm_cvt_roundsd_ss 9175 // CHECK: @llvm.x86.avx512.mask.cvtsd2ss.round 9176 return _mm_cvt_roundsd_ss(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 9177 } 9178 9179 __m128 test_mm_mask_cvt_roundsd_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128d __B) { 9180 // CHECK-LABEL: test_mm_mask_cvt_roundsd_ss 9181 // CHECK: @llvm.x86.avx512.mask.cvtsd2ss.round 9182 return _mm_mask_cvt_roundsd_ss(__W, __U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 9183 } 9184 9185 __m128 test_mm_maskz_cvt_roundsd_ss(__mmask8 __U, __m128 __A, __m128d __B) { 9186 // CHECK-LABEL: test_mm_maskz_cvt_roundsd_ss 9187 // CHECK: @llvm.x86.avx512.mask.cvtsd2ss.round 9188 return _mm_maskz_cvt_roundsd_ss(__U, __A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 9189 } 9190 9191 #ifdef __x86_64__ 9192 __m128d test_mm_cvt_roundi64_sd(__m128d __A, long long __B) { 9193 // CHECK-LABEL: test_mm_cvt_roundi64_sd 9194 // CHECK: @llvm.x86.avx512.cvtsi2sd64 9195 return _mm_cvt_roundi64_sd(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 9196 } 9197 9198 __m128d test_mm_cvt_roundsi64_sd(__m128d __A, long long __B) { 9199 // CHECK-LABEL: test_mm_cvt_roundsi64_sd 9200 // CHECK: @llvm.x86.avx512.cvtsi2sd64 9201 return _mm_cvt_roundsi64_sd(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 9202 } 9203 #endif 9204 9205 __m128 test_mm_cvt_roundsi32_ss(__m128 __A, int __B) { 9206 // CHECK-LABEL: test_mm_cvt_roundsi32_ss 9207 // CHECK: @llvm.x86.avx512.cvtsi2ss32 9208 return _mm_cvt_roundsi32_ss(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 9209 } 9210 9211 __m128 test_mm_cvt_roundi32_ss(__m128 __A, int __B) { 9212 // CHECK-LABEL: test_mm_cvt_roundi32_ss 9213 // CHECK: @llvm.x86.avx512.cvtsi2ss32 9214 return _mm_cvt_roundi32_ss(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 9215 } 9216 9217 #ifdef __x86_64__ 9218 __m128 test_mm_cvt_roundsi64_ss(__m128 __A, long long __B) { 9219 // CHECK-LABEL: test_mm_cvt_roundsi64_ss 9220 // CHECK: @llvm.x86.avx512.cvtsi2ss64 9221 return _mm_cvt_roundsi64_ss(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 9222 } 9223 9224 __m128 test_mm_cvt_roundi64_ss(__m128 __A, long long __B) { 9225 // CHECK-LABEL: test_mm_cvt_roundi64_ss 9226 // CHECK: @llvm.x86.avx512.cvtsi2ss64 9227 return _mm_cvt_roundi64_ss(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 9228 } 9229 #endif 9230 9231 __m128d test_mm_cvt_roundss_sd(__m128d __A, __m128 __B) { 9232 // CHECK-LABEL: test_mm_cvt_roundss_sd 9233 // CHECK: @llvm.x86.avx512.mask.cvtss2sd.round 9234 return _mm_cvt_roundss_sd(__A, __B, _MM_FROUND_NO_EXC); 9235 } 9236 9237 __m128d test_mm_mask_cvt_roundss_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128 __B) { 9238 // CHECK-LABEL: test_mm_mask_cvt_roundss_sd 9239 // CHECK: @llvm.x86.avx512.mask.cvtss2sd.round 9240 return _mm_mask_cvt_roundss_sd(__W, __U, __A, __B, _MM_FROUND_NO_EXC); 9241 } 9242 9243 __m128d test_mm_maskz_cvt_roundss_sd( __mmask8 __U, __m128d __A, __m128 __B) { 9244 // CHECK-LABEL: test_mm_maskz_cvt_roundss_sd 9245 // CHECK: @llvm.x86.avx512.mask.cvtss2sd.round 9246 return _mm_maskz_cvt_roundss_sd( __U, __A, __B, _MM_FROUND_NO_EXC); 9247 } 9248 9249 __m128d test_mm_cvtu32_sd(__m128d __A, unsigned __B) { 9250 // CHECK-LABEL: test_mm_cvtu32_sd 9251 // CHECK: uitofp i32 %{{.*}} to double 9252 // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0 9253 return _mm_cvtu32_sd(__A, __B); 9254 } 9255 9256 #ifdef __x86_64__ 9257 __m128d test_mm_cvt_roundu64_sd(__m128d __A, unsigned long long __B) { 9258 // CHECK-LABEL: test_mm_cvt_roundu64_sd 9259 // CHECK: @llvm.x86.avx512.cvtusi642sd 9260 return _mm_cvt_roundu64_sd(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 9261 } 9262 9263 __m128d test_mm_cvtu64_sd(__m128d __A, unsigned long long __B) { 9264 // CHECK-LABEL: test_mm_cvtu64_sd 9265 // CHECK: uitofp i64 %{{.*}} to double 9266 // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0 9267 return _mm_cvtu64_sd(__A, __B); 9268 } 9269 #endif 9270 9271 __m128 test_mm_cvt_roundu32_ss(__m128 __A, unsigned __B) { 9272 // CHECK-LABEL: test_mm_cvt_roundu32_ss 9273 // CHECK: @llvm.x86.avx512.cvtusi2ss 9274 return _mm_cvt_roundu32_ss(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 9275 } 9276 9277 __m128 test_mm_cvtu32_ss(__m128 __A, unsigned __B) { 9278 // CHECK-LABEL: test_mm_cvtu32_ss 9279 // CHECK: uitofp i32 %{{.*}} to float 9280 // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 0 9281 return _mm_cvtu32_ss(__A, __B); 9282 } 9283 9284 #ifdef __x86_64__ 9285 __m128 test_mm_cvt_roundu64_ss(__m128 __A, unsigned long long __B) { 9286 // CHECK-LABEL: test_mm_cvt_roundu64_ss 9287 // CHECK: @llvm.x86.avx512.cvtusi642ss 9288 return _mm_cvt_roundu64_ss(__A, __B, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC); 9289 } 9290 9291 __m128 test_mm_cvtu64_ss(__m128 __A, unsigned long long __B) { 9292 // CHECK-LABEL: test_mm_cvtu64_ss 9293 // CHECK: uitofp i64 %{{.*}} to float 9294 // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 0 9295 return _mm_cvtu64_ss(__A, __B); 9296 } 9297 #endif 9298 9299 __m512i test_mm512_mask_cvttps_epu32 (__m512i __W, __mmask16 __U, __m512 __A) 9300 { 9301 // CHECK-LABEL: test_mm512_mask_cvttps_epu32 9302 // CHECK: @llvm.x86.avx512.mask.cvttps2udq.512 9303 return _mm512_mask_cvttps_epu32 (__W,__U,__A); 9304 } 9305 9306 __m512i test_mm512_maskz_cvttps_epu32 (__mmask16 __U, __m512 __A) 9307 { 9308 // CHECK-LABEL: test_mm512_maskz_cvttps_epu32 9309 // CHECK: @llvm.x86.avx512.mask.cvttps2udq.512 9310 return _mm512_maskz_cvttps_epu32 (__U,__A); 9311 } 9312 9313 __m512 test_mm512_cvtepu32_ps (__m512i __A) 9314 { 9315 // CHECK-LABEL: test_mm512_cvtepu32_ps 9316 // CHECK: uitofp <16 x i32> %{{.*}} to <16 x float> 9317 return _mm512_cvtepu32_ps (__A); 9318 } 9319 9320 __m512 test_mm512_mask_cvtepu32_ps (__m512 __W, __mmask16 __U, __m512i __A) 9321 { 9322 // CHECK-LABEL: test_mm512_mask_cvtepu32_ps 9323 // CHECK: uitofp <16 x i32> %{{.*}} to <16 x float> 9324 // CHECK: select <16 x i1> {{.*}}, <16 x float> {{.*}}, <16 x float> {{.*}} 9325 return _mm512_mask_cvtepu32_ps (__W,__U,__A); 9326 } 9327 9328 __m512 test_mm512_maskz_cvtepu32_ps (__mmask16 __U, __m512i __A) 9329 { 9330 // CHECK-LABEL: test_mm512_maskz_cvtepu32_ps 9331 // CHECK: uitofp <16 x i32> %{{.*}} to <16 x float> 9332 // CHECK: select <16 x i1> {{.*}}, <16 x float> {{.*}}, <16 x float> {{.*}} 9333 return _mm512_maskz_cvtepu32_ps (__U,__A); 9334 } 9335 9336 __m512d test_mm512_cvtepi32_pd (__m256i __A) 9337 { 9338 // CHECK-LABEL: test_mm512_cvtepi32_pd 9339 // CHECK: sitofp <8 x i32> %{{.*}} to <8 x double> 9340 return _mm512_cvtepi32_pd (__A); 9341 } 9342 9343 __m512d test_mm512_mask_cvtepi32_pd (__m512d __W, __mmask8 __U, __m256i __A) 9344 { 9345 // CHECK-LABEL: test_mm512_mask_cvtepi32_pd 9346 // CHECK: sitofp <8 x i32> %{{.*}} to <8 x double> 9347 // CHECK: select <8 x i1> {{.*}}, <8 x double> {{.*}}, <8 x double> {{.*}} 9348 return _mm512_mask_cvtepi32_pd (__W,__U,__A); 9349 } 9350 9351 __m512d test_mm512_maskz_cvtepi32_pd (__mmask8 __U, __m256i __A) 9352 { 9353 // CHECK-LABEL: test_mm512_maskz_cvtepi32_pd 9354 // CHECK: sitofp <8 x i32> %{{.*}} to <8 x double> 9355 // CHECK: select <8 x i1> {{.*}}, <8 x double> {{.*}}, <8 x double> {{.*}} 9356 return _mm512_maskz_cvtepi32_pd (__U,__A); 9357 } 9358 9359 __m512d test_mm512_cvtepi32lo_pd (__m512i __A) 9360 { 9361 // CHECK-LABEL: test_mm512_cvtepi32lo_pd 9362 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 9363 // CHECK: sitofp <8 x i32> %{{.*}} to <8 x double> 9364 return _mm512_cvtepi32lo_pd (__A); 9365 } 9366 9367 __m512d test_mm512_mask_cvtepi32lo_pd (__m512d __W, __mmask8 __U, __m512i __A) 9368 { 9369 // CHECK-LABEL: test_mm512_mask_cvtepi32lo_pd 9370 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 9371 // CHECK: sitofp <8 x i32> %{{.*}} to <8 x double> 9372 // CHECK: select <8 x i1> {{.*}}, <8 x double> {{.*}}, <8 x double> {{.*}} 9373 return _mm512_mask_cvtepi32lo_pd (__W, __U, __A); 9374 } 9375 9376 __m512 test_mm512_cvtepi32_ps (__m512i __A) 9377 { 9378 // CHECK-LABEL: test_mm512_cvtepi32_ps 9379 // CHECK: sitofp <16 x i32> %{{.*}} to <16 x float> 9380 return _mm512_cvtepi32_ps (__A); 9381 } 9382 9383 __m512 test_mm512_mask_cvtepi32_ps (__m512 __W, __mmask16 __U, __m512i __A) 9384 { 9385 // CHECK-LABEL: test_mm512_mask_cvtepi32_ps 9386 // CHECK: sitofp <16 x i32> %{{.*}} to <16 x float> 9387 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 9388 return _mm512_mask_cvtepi32_ps (__W,__U,__A); 9389 } 9390 9391 __m512 test_mm512_maskz_cvtepi32_ps (__mmask16 __U, __m512i __A) 9392 { 9393 // CHECK-LABEL: test_mm512_maskz_cvtepi32_ps 9394 // CHECK: sitofp <16 x i32> %{{.*}} to <16 x float> 9395 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 9396 return _mm512_maskz_cvtepi32_ps (__U,__A); 9397 } 9398 9399 __m512d test_mm512_cvtepu32_pd(__m256i __A) 9400 { 9401 // CHECK-LABEL: test_mm512_cvtepu32_pd 9402 // CHECK: uitofp <8 x i32> %{{.*}} to <8 x double> 9403 return _mm512_cvtepu32_pd(__A); 9404 } 9405 9406 __m512d test_mm512_mask_cvtepu32_pd (__m512d __W, __mmask8 __U, __m256i __A) 9407 { 9408 // CHECK-LABEL: test_mm512_mask_cvtepu32_pd 9409 // CHECK: uitofp <8 x i32> %{{.*}} to <8 x double> 9410 // CHECK: select <8 x i1> {{.*}}, <8 x double> {{.*}}, <8 x double> {{.*}} 9411 return _mm512_mask_cvtepu32_pd (__W,__U,__A); 9412 } 9413 9414 __m512d test_mm512_maskz_cvtepu32_pd (__mmask8 __U, __m256i __A) 9415 { 9416 // CHECK-LABEL: test_mm512_maskz_cvtepu32_pd 9417 // CHECK: uitofp <8 x i32> %{{.*}} to <8 x double> 9418 // CHECK: select <8 x i1> {{.*}}, <8 x double> {{.*}}, <8 x double> {{.*}} 9419 return _mm512_maskz_cvtepu32_pd (__U,__A); 9420 } 9421 9422 __m512d test_mm512_cvtepu32lo_pd (__m512i __A) 9423 { 9424 // CHECK-LABEL: test_mm512_cvtepu32lo_pd 9425 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 9426 // CHECK: uitofp <8 x i32> %{{.*}} to <8 x double> 9427 return _mm512_cvtepu32lo_pd (__A); 9428 } 9429 9430 __m512d test_mm512_mask_cvtepu32lo_pd (__m512d __W, __mmask8 __U, __m512i __A) 9431 { 9432 // CHECK-LABEL: test_mm512_mask_cvtepu32lo_pd 9433 // CHECK: shufflevector <8 x i64> %{{.*}}, <8 x i64> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> 9434 // CHECK: uitofp <8 x i32> %{{.*}} to <8 x double> 9435 // CHECK: select <8 x i1> {{.*}}, <8 x double> {{.*}}, <8 x double> {{.*}} 9436 return _mm512_mask_cvtepu32lo_pd (__W, __U, __A); 9437 } 9438 9439 __m256 test_mm512_cvtpd_ps (__m512d __A) 9440 { 9441 // CHECK-LABEL: test_mm512_cvtpd_ps 9442 // CHECK: @llvm.x86.avx512.mask.cvtpd2ps.512 9443 return _mm512_cvtpd_ps (__A); 9444 } 9445 9446 __m256 test_mm512_mask_cvtpd_ps (__m256 __W, __mmask8 __U, __m512d __A) 9447 { 9448 // CHECK-LABEL: test_mm512_mask_cvtpd_ps 9449 // CHECK: @llvm.x86.avx512.mask.cvtpd2ps.512 9450 return _mm512_mask_cvtpd_ps (__W,__U,__A); 9451 } 9452 9453 __m512 test_mm512_cvtpd_pslo(__m512d __A) 9454 { 9455 // CHECK-LABEL: test_mm512_cvtpd_pslo 9456 // CHECK: @llvm.x86.avx512.mask.cvtpd2ps.512 9457 // CHECK: zeroinitializer 9458 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15> 9459 return _mm512_cvtpd_pslo(__A); 9460 } 9461 9462 __m512 test_mm512_mask_cvtpd_pslo(__m512 __W, __mmask8 __U, __m512d __A) { 9463 // CHECK-LABEL: test_mm512_mask_cvtpd_pslo 9464 // CHECK: @llvm.x86.avx512.mask.cvtpd2ps.512 9465 // CHECK: zeroinitializer 9466 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15> 9467 return _mm512_mask_cvtpd_pslo(__W, __U, __A); 9468 } 9469 9470 __m256 test_mm512_maskz_cvtpd_ps (__mmask8 __U, __m512d __A) 9471 { 9472 // CHECK-LABEL: test_mm512_maskz_cvtpd_ps 9473 // CHECK: @llvm.x86.avx512.mask.cvtpd2ps.512 9474 return _mm512_maskz_cvtpd_ps (__U,__A); 9475 } 9476 9477 __m512 test_mm512_cvtph_ps (__m256i __A) 9478 { 9479 // CHECK-LABEL: test_mm512_cvtph_ps 9480 // CHECK: bitcast <4 x i64> %{{.*}} to <16 x i16> 9481 // CHECK: bitcast <16 x i16> %{{.*}} to <16 x half> 9482 // CHECK: fpext <16 x half> %{{.*}} to <16 x float> 9483 return _mm512_cvtph_ps (__A); 9484 } 9485 9486 __m512 test_mm512_mask_cvtph_ps (__m512 __W, __mmask16 __U, __m256i __A) 9487 { 9488 // CHECK-LABEL: test_mm512_mask_cvtph_ps 9489 // CHECK: bitcast <4 x i64> %{{.*}} to <16 x i16> 9490 // CHECK: bitcast <16 x i16> %{{.*}} to <16 x half> 9491 // CHECK: fpext <16 x half> %{{.*}} to <16 x float> 9492 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 9493 return _mm512_mask_cvtph_ps (__W,__U,__A); 9494 } 9495 9496 __m512 test_mm512_maskz_cvtph_ps (__mmask16 __U, __m256i __A) 9497 { 9498 // CHECK-LABEL: test_mm512_maskz_cvtph_ps 9499 // CHECK: bitcast <4 x i64> %{{.*}} to <16 x i16> 9500 // CHECK: bitcast <16 x i16> %{{.*}} to <16 x half> 9501 // CHECK: fpext <16 x half> %{{.*}} to <16 x float> 9502 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 9503 return _mm512_maskz_cvtph_ps (__U,__A); 9504 } 9505 9506 __m256i test_mm512_mask_cvttpd_epi32 (__m256i __W, __mmask8 __U, __m512d __A) 9507 { 9508 // CHECK-LABEL: test_mm512_mask_cvttpd_epi32 9509 // CHECK: @llvm.x86.avx512.mask.cvttpd2dq.512 9510 return _mm512_mask_cvttpd_epi32 (__W,__U,__A); 9511 } 9512 9513 __m256i test_mm512_maskz_cvttpd_epi32 (__mmask8 __U, __m512d __A) 9514 { 9515 // CHECK-LABEL: test_mm512_maskz_cvttpd_epi32 9516 // CHECK: @llvm.x86.avx512.mask.cvttpd2dq.512 9517 return _mm512_maskz_cvttpd_epi32 (__U,__A); 9518 } 9519 9520 __m512i test_mm512_mask_cvttps_epi32 (__m512i __W, __mmask16 __U, __m512 __A) 9521 { 9522 // CHECK-LABEL: test_mm512_mask_cvttps_epi32 9523 // CHECK: @llvm.x86.avx512.mask.cvttps2dq.512 9524 return _mm512_mask_cvttps_epi32 (__W,__U,__A); 9525 } 9526 9527 __m512i test_mm512_maskz_cvttps_epi32 (__mmask16 __U, __m512 __A) 9528 { 9529 // CHECK-LABEL: test_mm512_maskz_cvttps_epi32 9530 // CHECK: @llvm.x86.avx512.mask.cvttps2dq.512 9531 return _mm512_maskz_cvttps_epi32 (__U,__A); 9532 } 9533 9534 __m512i test_mm512_cvtps_epi32 (__m512 __A) 9535 { 9536 // CHECK-LABEL: test_mm512_cvtps_epi32 9537 // CHECK: @llvm.x86.avx512.mask.cvtps2dq.512 9538 return _mm512_cvtps_epi32 (__A); 9539 } 9540 9541 __m512i test_mm512_mask_cvtps_epi32 (__m512i __W, __mmask16 __U, __m512 __A) 9542 { 9543 // CHECK-LABEL: test_mm512_mask_cvtps_epi32 9544 // CHECK: @llvm.x86.avx512.mask.cvtps2dq.512 9545 return _mm512_mask_cvtps_epi32 (__W,__U,__A); 9546 } 9547 9548 __m512i test_mm512_maskz_cvtps_epi32 (__mmask16 __U, __m512 __A) 9549 { 9550 // CHECK-LABEL: test_mm512_maskz_cvtps_epi32 9551 // CHECK: @llvm.x86.avx512.mask.cvtps2dq.512 9552 return _mm512_maskz_cvtps_epi32 (__U,__A); 9553 } 9554 9555 __m256i test_mm512_cvtpd_epi32 (__m512d __A) 9556 { 9557 // CHECK-LABEL: test_mm512_cvtpd_epi32 9558 // CHECK: @llvm.x86.avx512.mask.cvtpd2dq.512 9559 return _mm512_cvtpd_epi32 (__A); 9560 } 9561 9562 __m256i test_mm512_mask_cvtpd_epi32 (__m256i __W, __mmask8 __U, __m512d __A) 9563 { 9564 // CHECK-LABEL: test_mm512_mask_cvtpd_epi32 9565 // CHECK: @llvm.x86.avx512.mask.cvtpd2dq.512 9566 return _mm512_mask_cvtpd_epi32 (__W,__U,__A); 9567 } 9568 9569 __m256i test_mm512_maskz_cvtpd_epi32 (__mmask8 __U, __m512d __A) 9570 { 9571 // CHECK-LABEL: test_mm512_maskz_cvtpd_epi32 9572 // CHECK: @llvm.x86.avx512.mask.cvtpd2dq.512 9573 return _mm512_maskz_cvtpd_epi32 (__U,__A); 9574 } 9575 9576 __m256i test_mm512_cvtpd_epu32 (__m512d __A) 9577 { 9578 // CHECK-LABEL: test_mm512_cvtpd_epu32 9579 // CHECK: @llvm.x86.avx512.mask.cvtpd2udq.512 9580 return _mm512_cvtpd_epu32 (__A); 9581 } 9582 9583 __m256i test_mm512_mask_cvtpd_epu32 (__m256i __W, __mmask8 __U, __m512d __A) 9584 { 9585 // CHECK-LABEL: test_mm512_mask_cvtpd_epu32 9586 // CHECK: @llvm.x86.avx512.mask.cvtpd2udq.512 9587 return _mm512_mask_cvtpd_epu32 (__W,__U,__A); 9588 } 9589 9590 __m256i test_mm512_maskz_cvtpd_epu32 (__mmask8 __U, __m512d __A) 9591 { 9592 // CHECK-LABEL: test_mm512_maskz_cvtpd_epu32 9593 // CHECK: @llvm.x86.avx512.mask.cvtpd2udq.512 9594 return _mm512_maskz_cvtpd_epu32 (__U,__A); 9595 } 9596 9597 __m256i test_mm512_mask_cvtps_ph(__m256i src, __mmask16 k, __m512 a) 9598 { 9599 // CHECK-LABEL: test_mm512_mask_cvtps_ph 9600 // CHECK: @llvm.x86.avx512.mask.vcvtps2ph.512 9601 return _mm512_mask_cvtps_ph(src, k, a,_MM_FROUND_TO_ZERO); 9602 } 9603 9604 __m256i test_mm512_maskz_cvtps_ph (__mmask16 k, __m512 a) 9605 { 9606 // CHECK-LABEL: test_mm512_maskz_cvtps_ph 9607 // CHECK: @llvm.x86.avx512.mask.vcvtps2ph.512 9608 return _mm512_maskz_cvtps_ph( k, a,_MM_FROUND_TO_ZERO); 9609 } 9610 9611 __m512i test_mm512_cvtps_epu32 ( __m512 __A) 9612 { 9613 // CHECK-LABEL: test_mm512_cvtps_epu32 9614 // CHECK: @llvm.x86.avx512.mask.cvtps2udq.512 9615 return _mm512_cvtps_epu32(__A); 9616 } 9617 9618 __m512i test_mm512_mask_cvtps_epu32 (__m512i __W, __mmask16 __U, __m512 __A) 9619 { 9620 // CHECK-LABEL: test_mm512_mask_cvtps_epu32 9621 // CHECK: @llvm.x86.avx512.mask.cvtps2udq.512 9622 return _mm512_mask_cvtps_epu32( __W, __U, __A); 9623 } 9624 __m512i test_mm512_maskz_cvtps_epu32 (__mmask16 __U, __m512 __A) 9625 { 9626 // CHECK-LABEL: test_mm512_maskz_cvtps_epu32 9627 // CHECK: @llvm.x86.avx512.mask.cvtps2udq.512 9628 return _mm512_maskz_cvtps_epu32( __U, __A); 9629 } 9630 9631 double test_mm512_cvtsd_f64(__m512d A) { 9632 // CHECK-LABEL: test_mm512_cvtsd_f64 9633 // CHECK: extractelement <8 x double> %{{.*}}, i32 0 9634 return _mm512_cvtsd_f64(A); 9635 } 9636 9637 float test_mm512_cvtss_f32(__m512 A) { 9638 // CHECK-LABEL: test_mm512_cvtss_f32 9639 // CHECK: extractelement <16 x float> %{{.*}}, i32 0 9640 return _mm512_cvtss_f32(A); 9641 } 9642 9643 __m512d test_mm512_mask_max_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) 9644 { 9645 // CHECK-LABEL: test_mm512_mask_max_pd 9646 // CHECK: @llvm.x86.avx512.max.pd.512 9647 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 9648 return _mm512_mask_max_pd (__W,__U,__A,__B); 9649 } 9650 9651 __m512d test_mm512_maskz_max_pd (__mmask8 __U, __m512d __A, __m512d __B) 9652 { 9653 // CHECK-LABEL: test_mm512_maskz_max_pd 9654 // CHECK: @llvm.x86.avx512.max.pd.512 9655 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 9656 return _mm512_maskz_max_pd (__U,__A,__B); 9657 } 9658 9659 __m512 test_mm512_mask_max_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) 9660 { 9661 // CHECK-LABEL: test_mm512_mask_max_ps 9662 // CHECK: @llvm.x86.avx512.max.ps.512 9663 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 9664 return _mm512_mask_max_ps (__W,__U,__A,__B); 9665 } 9666 9667 __m512d test_mm512_mask_max_round_pd(__m512d __W,__mmask8 __U,__m512d __A,__m512d __B) 9668 { 9669 // CHECK-LABEL: test_mm512_mask_max_round_pd 9670 // CHECK: @llvm.x86.avx512.max.pd.512 9671 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 9672 return _mm512_mask_max_round_pd(__W,__U,__A,__B,_MM_FROUND_NO_EXC); 9673 } 9674 9675 __m512d test_mm512_maskz_max_round_pd(__mmask8 __U,__m512d __A,__m512d __B) 9676 { 9677 // CHECK-LABEL: test_mm512_maskz_max_round_pd 9678 // CHECK: @llvm.x86.avx512.max.pd.512 9679 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 9680 return _mm512_maskz_max_round_pd(__U,__A,__B,_MM_FROUND_NO_EXC); 9681 } 9682 9683 __m512d test_mm512_max_round_pd(__m512d __A,__m512d __B) 9684 { 9685 // CHECK-LABEL: test_mm512_max_round_pd 9686 // CHECK: @llvm.x86.avx512.max.pd.512 9687 return _mm512_max_round_pd(__A,__B,_MM_FROUND_NO_EXC); 9688 } 9689 9690 __m512 test_mm512_maskz_max_ps (__mmask16 __U, __m512 __A, __m512 __B) 9691 { 9692 // CHECK-LABEL: test_mm512_maskz_max_ps 9693 // CHECK: @llvm.x86.avx512.max.ps.512 9694 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 9695 return _mm512_maskz_max_ps (__U,__A,__B); 9696 } 9697 9698 __m512 test_mm512_mask_max_round_ps(__m512 __W,__mmask16 __U,__m512 __A,__m512 __B) 9699 { 9700 // CHECK-LABEL: test_mm512_mask_max_round_ps 9701 // CHECK: @llvm.x86.avx512.max.ps.512 9702 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 9703 return _mm512_mask_max_round_ps(__W,__U,__A,__B,_MM_FROUND_NO_EXC); 9704 } 9705 9706 __m512 test_mm512_maskz_max_round_ps(__mmask16 __U,__m512 __A,__m512 __B) 9707 { 9708 // CHECK-LABEL: test_mm512_maskz_max_round_ps 9709 // CHECK: @llvm.x86.avx512.max.ps.512 9710 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 9711 return _mm512_maskz_max_round_ps(__U,__A,__B,_MM_FROUND_NO_EXC); 9712 } 9713 9714 __m512 test_mm512_max_round_ps(__m512 __A,__m512 __B) 9715 { 9716 // CHECK-LABEL: test_mm512_max_round_ps 9717 // CHECK: @llvm.x86.avx512.max.ps.512 9718 return _mm512_max_round_ps(__A,__B,_MM_FROUND_NO_EXC); 9719 } 9720 9721 __m512d test_mm512_mask_min_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) 9722 { 9723 // CHECK-LABEL: test_mm512_mask_min_pd 9724 // CHECK: @llvm.x86.avx512.min.pd.512 9725 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 9726 return _mm512_mask_min_pd (__W,__U,__A,__B); 9727 } 9728 9729 __m512d test_mm512_maskz_min_pd (__mmask8 __U, __m512d __A, __m512d __B) 9730 { 9731 // CHECK-LABEL: test_mm512_maskz_min_pd 9732 // CHECK: @llvm.x86.avx512.min.pd.512 9733 return _mm512_maskz_min_pd (__U,__A,__B); 9734 } 9735 9736 __m512d test_mm512_mask_min_round_pd(__m512d __W,__mmask8 __U,__m512d __A,__m512d __B) 9737 { 9738 // CHECK-LABEL: test_mm512_mask_min_round_pd 9739 // CHECK: @llvm.x86.avx512.min.pd.512 9740 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 9741 return _mm512_mask_min_round_pd(__W,__U,__A,__B,_MM_FROUND_NO_EXC); 9742 } 9743 9744 __m512d test_mm512_maskz_min_round_pd(__mmask8 __U,__m512d __A,__m512d __B) 9745 { 9746 // CHECK-LABEL: test_mm512_maskz_min_round_pd 9747 // CHECK: @llvm.x86.avx512.min.pd.512 9748 // CHECK: select <8 x i1> %{{.*}}, <8 x double> %{{.*}}, <8 x double> %{{.*}} 9749 return _mm512_maskz_min_round_pd(__U,__A,__B,_MM_FROUND_NO_EXC); 9750 } 9751 9752 __m512d test_mm512_min_round_pd( __m512d __A,__m512d __B) 9753 { 9754 // CHECK-LABEL: test_mm512_min_round_pd 9755 // CHECK: @llvm.x86.avx512.min.pd.512 9756 return _mm512_min_round_pd(__A,__B,_MM_FROUND_NO_EXC); 9757 } 9758 9759 __m512 test_mm512_mask_min_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) 9760 { 9761 // CHECK-LABEL: test_mm512_mask_min_ps 9762 // CHECK: @llvm.x86.avx512.min.ps.512 9763 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 9764 return _mm512_mask_min_ps (__W,__U,__A,__B); 9765 } 9766 9767 __m512 test_mm512_maskz_min_ps (__mmask16 __U, __m512 __A, __m512 __B) 9768 { 9769 // CHECK-LABEL: test_mm512_maskz_min_ps 9770 // CHECK: @llvm.x86.avx512.min.ps.512 9771 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 9772 return _mm512_maskz_min_ps (__U,__A,__B); 9773 } 9774 9775 __m512 test_mm512_mask_min_round_ps(__m512 __W,__mmask16 __U,__m512 __A,__m512 __B) 9776 { 9777 // CHECK-LABEL: test_mm512_mask_min_round_ps 9778 // CHECK: @llvm.x86.avx512.min.ps.512 9779 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 9780 return _mm512_mask_min_round_ps(__W,__U,__A,__B,_MM_FROUND_NO_EXC); 9781 } 9782 9783 __m512 test_mm512_maskz_min_round_ps(__mmask16 __U,__m512 __A,__m512 __B) 9784 { 9785 // CHECK-LABEL: test_mm512_maskz_min_round_ps 9786 // CHECK: @llvm.x86.avx512.min.ps.512 9787 // CHECK: select <16 x i1> %{{.*}}, <16 x float> %{{.*}}, <16 x float> %{{.*}} 9788 return _mm512_maskz_min_round_ps(__U,__A,__B,_MM_FROUND_NO_EXC); 9789 } 9790 9791 __m512 test_mm512_min_round_ps(__m512 __A,__m512 __B) 9792 { 9793 // CHECK-LABEL: test_mm512_min_round_ps 9794 // CHECK: @llvm.x86.avx512.min.ps.512 9795 return _mm512_min_round_ps(__A,__B,_MM_FROUND_NO_EXC); 9796 } 9797 9798 __m512 test_mm512_mask_floor_ps (__m512 __W, __mmask16 __U, __m512 __A) 9799 { 9800 // CHECK-LABEL: test_mm512_mask_floor_ps 9801 // CHECK: @llvm.x86.avx512.mask.rndscale.ps.512 9802 return _mm512_mask_floor_ps (__W,__U,__A); 9803 } 9804 9805 __m512d test_mm512_mask_floor_pd (__m512d __W, __mmask8 __U, __m512d __A) 9806 { 9807 // CHECK-LABEL: test_mm512_mask_floor_pd 9808 // CHECK: @llvm.x86.avx512.mask.rndscale.pd.512 9809 return _mm512_mask_floor_pd (__W,__U,__A); 9810 } 9811 9812 __m512 test_mm512_mask_ceil_ps (__m512 __W, __mmask16 __U, __m512 __A) 9813 { 9814 // CHECK-LABEL: test_mm512_mask_ceil_ps 9815 // CHECK: @llvm.x86.avx512.mask.rndscale.ps.512 9816 return _mm512_mask_ceil_ps (__W,__U,__A); 9817 } 9818 9819 __m512d test_mm512_mask_ceil_pd (__m512d __W, __mmask8 __U, __m512d __A) 9820 { 9821 // CHECK-LABEL: test_mm512_mask_ceil_pd 9822 // CHECK: @llvm.x86.avx512.mask.rndscale.pd.512 9823 return _mm512_mask_ceil_pd (__W,__U,__A); 9824 } 9825 9826 __m512 test_mm512_mask_roundscale_ps(__m512 __W, __mmask16 __U, __m512 __A) 9827 { 9828 // CHECK-LABEL: test_mm512_mask_roundscale_ps 9829 // CHECK: @llvm.x86.avx512.mask.rndscale.ps.512 9830 return _mm512_mask_roundscale_ps(__W,__U,__A, 1); 9831 } 9832 9833 __m512 test_mm512_maskz_roundscale_ps(__mmask16 __U, __m512 __A) 9834 { 9835 // CHECK-LABEL: test_mm512_maskz_roundscale_ps 9836 // CHECK: @llvm.x86.avx512.mask.rndscale.ps.512 9837 return _mm512_maskz_roundscale_ps(__U,__A, 1); 9838 } 9839 9840 __m512 test_mm512_mask_roundscale_round_ps(__m512 __A,__mmask16 __U,__m512 __C) 9841 { 9842 // CHECK-LABEL: test_mm512_mask_roundscale_round_ps 9843 // CHECK: @llvm.x86.avx512.mask.rndscale.ps.512 9844 return _mm512_mask_roundscale_round_ps(__A,__U,__C,_MM_FROUND_TO_ZERO,_MM_FROUND_NO_EXC); 9845 } 9846 9847 __m512 test_mm512_maskz_roundscale_round_ps(__m512 __A,__mmask16 __U) 9848 { 9849 // CHECK-LABEL: test_mm512_maskz_roundscale_round_ps 9850 // CHECK: @llvm.x86.avx512.mask.rndscale.ps.512 9851 return _mm512_maskz_roundscale_round_ps(__U,__A,_MM_FROUND_TO_ZERO,_MM_FROUND_NO_EXC); 9852 } 9853 9854 __m512 test_mm512_roundscale_round_ps(__m512 __A) 9855 { 9856 // CHECK-LABEL: test_mm512_roundscale_round_ps 9857 // CHECK: @llvm.x86.avx512.mask.rndscale.ps.512 9858 return _mm512_roundscale_round_ps(__A,_MM_FROUND_TO_ZERO,_MM_FROUND_NO_EXC); 9859 } 9860 9861 __m512d test_mm512_mask_roundscale_pd(__m512d __W, __mmask8 __U, __m512d __A) 9862 { 9863 // CHECK-LABEL: test_mm512_mask_roundscale_pd 9864 // CHECK: @llvm.x86.avx512.mask.rndscale.pd.512 9865 return _mm512_mask_roundscale_pd(__W,__U,__A, 1); 9866 } 9867 9868 __m512d test_mm512_maskz_roundscale_pd(__mmask8 __U, __m512d __A) 9869 { 9870 // CHECK-LABEL: test_mm512_maskz_roundscale_pd 9871 // CHECK: @llvm.x86.avx512.mask.rndscale.pd.512 9872 return _mm512_maskz_roundscale_pd(__U,__A, 1); 9873 } 9874 9875 __m512d test_mm512_mask_roundscale_round_pd(__m512d __A,__mmask8 __U,__m512d __C) 9876 { 9877 // CHECK-LABEL: test_mm512_mask_roundscale_round_pd 9878 // CHECK: @llvm.x86.avx512.mask.rndscale.pd.512 9879 return _mm512_mask_roundscale_round_pd(__A,__U,__C,_MM_FROUND_TO_ZERO,_MM_FROUND_NO_EXC); 9880 } 9881 9882 __m512d test_mm512_maskz_roundscale_round_pd(__m512d __A,__mmask8 __U) 9883 { 9884 // CHECK-LABEL: test_mm512_maskz_roundscale_round_pd 9885 // CHECK: @llvm.x86.avx512.mask.rndscale.pd.512 9886 return _mm512_maskz_roundscale_round_pd(__U,__A,_MM_FROUND_TO_ZERO,_MM_FROUND_NO_EXC); 9887 } 9888 9889 __m512d test_mm512_roundscale_round_pd(__m512d __A) 9890 { 9891 // CHECK-LABEL: test_mm512_roundscale_round_pd 9892 // CHECK: @llvm.x86.avx512.mask.rndscale.pd.512 9893 return _mm512_roundscale_round_pd(__A,_MM_FROUND_TO_ZERO,_MM_FROUND_NO_EXC); 9894 } 9895 9896 __m512i test_mm512_max_epi32 (__m512i __A, __m512i __B) 9897 { 9898 // CHECK-LABEL: test_mm512_max_epi32 9899 // CHECK: call <16 x i32> @llvm.smax.v16i32(<16 x i32> %{{.*}}, <16 x i32> %{{.*}}) 9900 return _mm512_max_epi32 (__A,__B); 9901 } 9902 9903 __m512i test_mm512_mask_max_epi32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B) 9904 { 9905 // CHECK-LABEL: test_mm512_mask_max_epi32 9906 // CHECK: call <16 x i32> @llvm.smax.v16i32(<16 x i32> %{{.*}}, <16 x i32> %{{.*}}) 9907 // CHECK: select <16 x i1> {{.*}}, <16 x i32> {{.*}}, <16 x i32> {{.*}} 9908 return _mm512_mask_max_epi32 (__W,__M,__A,__B); 9909 } 9910 9911 __m512i test_mm512_maskz_max_epi32 (__mmask16 __M, __m512i __A, __m512i __B) 9912 { 9913 // CHECK-LABEL: test_mm512_maskz_max_epi32 9914 // CHECK: call <16 x i32> @llvm.smax.v16i32(<16 x i32> %{{.*}}, <16 x i32> %{{.*}}) 9915 // CHECK: select <16 x i1> {{.*}}, <16 x i32> {{.*}}, <16 x i32> {{.*}} 9916 return _mm512_maskz_max_epi32 (__M,__A,__B); 9917 } 9918 9919 __m512i test_mm512_max_epi64 (__m512i __A, __m512i __B) 9920 { 9921 // CHECK-LABEL: test_mm512_max_epi64 9922 // CHECK: call {{.*}}<8 x i64> @llvm.smax.v8i64(<8 x i64> %{{.*}}, <8 x i64> %{{.*}}) 9923 return _mm512_max_epi64 (__A,__B); 9924 } 9925 9926 __m512i test_mm512_mask_max_epi64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B) 9927 { 9928 // CHECK-LABEL: test_mm512_mask_max_epi64 9929 // CHECK: call {{.*}}<8 x i64> @llvm.smax.v8i64(<8 x i64> %{{.*}}, <8 x i64> %{{.*}}) 9930 // CHECK: select <8 x i1> {{.*}}, <8 x i64> {{.*}}, <8 x i64> {{.*}} 9931 return _mm512_mask_max_epi64 (__W,__M,__A,__B); 9932 } 9933 9934 __m512i test_mm512_maskz_max_epi64 (__mmask8 __M, __m512i __A, __m512i __B) 9935 { 9936 // CHECK-LABEL: test_mm512_maskz_max_epi64 9937 // CHECK: call {{.*}}<8 x i64> @llvm.smax.v8i64(<8 x i64> %{{.*}}, <8 x i64> %{{.*}}) 9938 // CHECK: select <8 x i1> {{.*}}, <8 x i64> {{.*}}, <8 x i64> {{.*}} 9939 return _mm512_maskz_max_epi64 (__M,__A,__B); 9940 } 9941 9942 __m512i test_mm512_max_epu64 (__m512i __A, __m512i __B) 9943 { 9944 // CHECK-LABEL: test_mm512_max_epu64 9945 // CHECK: call {{.*}}<8 x i64> @llvm.umax.v8i64(<8 x i64> %{{.*}}, <8 x i64> %{{.*}}) 9946 return _mm512_max_epu64 (__A,__B); 9947 } 9948 9949 __m512i test_mm512_mask_max_epu64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B) 9950 { 9951 // CHECK-LABEL: test_mm512_mask_max_epu64 9952 // CHECK: call {{.*}}<8 x i64> @llvm.umax.v8i64(<8 x i64> %{{.*}}, <8 x i64> %{{.*}}) 9953 // CHECK: select <8 x i1> {{.*}}, <8 x i64> {{.*}}, <8 x i64> {{.*}} 9954 return _mm512_mask_max_epu64 (__W,__M,__A,__B); 9955 } 9956 9957 __m512i test_mm512_maskz_max_epu64 (__mmask8 __M, __m512i __A, __m512i __B) 9958 { 9959 // CHECK-LABEL: test_mm512_maskz_max_epu64 9960 // CHECK: call {{.*}}<8 x i64> @llvm.umax.v8i64(<8 x i64> %{{.*}}, <8 x i64> %{{.*}}) 9961 // CHECK: select <8 x i1> {{.*}}, <8 x i64> {{.*}}, <8 x i64> {{.*}} 9962 return _mm512_maskz_max_epu64 (__M,__A,__B); 9963 } 9964 9965 __m512i test_mm512_max_epu32 (__m512i __A, __m512i __B) 9966 { 9967 // CHECK-LABEL: test_mm512_max_epu32 9968 // CHECK: call <16 x i32> @llvm.umax.v16i32(<16 x i32> %{{.*}}, <16 x i32> %{{.*}}) 9969 return _mm512_max_epu32 (__A,__B); 9970 } 9971 9972 __m512i test_mm512_mask_max_epu32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B) 9973 { 9974 // CHECK-LABEL: test_mm512_mask_max_epu32 9975 // CHECK: call <16 x i32> @llvm.umax.v16i32(<16 x i32> %{{.*}}, <16 x i32> %{{.*}}) 9976 // CHECK: select <16 x i1> {{.*}}, <16 x i32> {{.*}}, <16 x i32> {{.*}} 9977 return _mm512_mask_max_epu32 (__W,__M,__A,__B); 9978 } 9979 9980 __m512i test_mm512_maskz_max_epu32 (__mmask16 __M, __m512i __A, __m512i __B) 9981 { 9982 // CHECK-LABEL: test_mm512_maskz_max_epu32 9983 // CHECK: call <16 x i32> @llvm.umax.v16i32(<16 x i32> %{{.*}}, <16 x i32> %{{.*}}) 9984 // CHECK: select <16 x i1> {{.*}}, <16 x i32> {{.*}}, <16 x i32> {{.*}} 9985 return _mm512_maskz_max_epu32 (__M,__A,__B); 9986 } 9987 9988 __m512i test_mm512_min_epi32 (__m512i __A, __m512i __B) 9989 { 9990 // CHECK-LABEL: test_mm512_min_epi32 9991 // CHECK: call <16 x i32> @llvm.smin.v16i32(<16 x i32> %{{.*}}, <16 x i32> %{{.*}}) 9992 return _mm512_min_epi32 (__A,__B); 9993 } 9994 9995 __m512i test_mm512_mask_min_epi32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B) 9996 { 9997 // CHECK-LABEL: test_mm512_mask_min_epi32 9998 // CHECK: call <16 x i32> @llvm.smin.v16i32(<16 x i32> %{{.*}}, <16 x i32> %{{.*}}) 9999 // CHECK: select <16 x i1> {{.*}}, <16 x i32> {{.*}}, <16 x i32> {{.*}} 10000 return _mm512_mask_min_epi32 (__W,__M,__A,__B); 10001 } 10002 10003 __m512i test_mm512_maskz_min_epi32 (__mmask16 __M, __m512i __A, __m512i __B) 10004 { 10005 // CHECK-LABEL: test_mm512_maskz_min_epi32 10006 // CHECK: call <16 x i32> @llvm.smin.v16i32(<16 x i32> %{{.*}}, <16 x i32> %{{.*}}) 10007 // CHECK: select <16 x i1> {{.*}}, <16 x i32> {{.*}}, <16 x i32> {{.*}} 10008 return _mm512_maskz_min_epi32 (__M,__A,__B); 10009 } 10010 10011 __m512i test_mm512_min_epu32 (__m512i __A, __m512i __B) 10012 { 10013 // CHECK-LABEL: test_mm512_min_epu32 10014 // CHECK: call <16 x i32> @llvm.umin.v16i32(<16 x i32> %{{.*}}, <16 x i32> %{{.*}}) 10015 return _mm512_min_epu32 (__A,__B); 10016 } 10017 10018 __m512i test_mm512_mask_min_epu32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B) 10019 { 10020 // CHECK-LABEL: test_mm512_mask_min_epu32 10021 // CHECK: call <16 x i32> @llvm.umin.v16i32(<16 x i32> %{{.*}}, <16 x i32> %{{.*}}) 10022 // CHECK: select <16 x i1> {{.*}}, <16 x i32> {{.*}}, <16 x i32> {{.*}} 10023 return _mm512_mask_min_epu32 (__W,__M,__A,__B); 10024 } 10025 10026 __m512i test_mm512_maskz_min_epu32 (__mmask16 __M, __m512i __A, __m512i __B) 10027 { 10028 // CHECK-LABEL: test_mm512_maskz_min_epu32 10029 // CHECK: call <16 x i32> @llvm.umin.v16i32(<16 x i32> %{{.*}}, <16 x i32> %{{.*}}) 10030 // CHECK: select <16 x i1> {{.*}}, <16 x i32> {{.*}}, <16 x i32> {{.*}} 10031 return _mm512_maskz_min_epu32 (__M,__A,__B); 10032 } 10033 10034 __m512i test_mm512_min_epi64 (__m512i __A, __m512i __B) 10035 { 10036 // CHECK-LABEL: test_mm512_min_epi64 10037 // CHECK: call {{.*}}<8 x i64> @llvm.smin.v8i64(<8 x i64> %{{.*}}, <8 x i64> %{{.*}}) 10038 return _mm512_min_epi64 (__A,__B); 10039 } 10040 10041 __m512i test_mm512_mask_min_epi64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B) 10042 { 10043 // CHECK-LABEL: test_mm512_mask_min_epi64 10044 // CHECK: call {{.*}}<8 x i64> @llvm.smin.v8i64(<8 x i64> %{{.*}}, <8 x i64> %{{.*}}) 10045 // CHECK: select <8 x i1> {{.*}}, <8 x i64> {{.*}}, <8 x i64> {{.*}} 10046 return _mm512_mask_min_epi64 (__W,__M,__A,__B); 10047 } 10048 10049 __m512i test_mm512_maskz_min_epi64 (__mmask8 __M, __m512i __A, __m512i __B) 10050 { 10051 // CHECK-LABEL: test_mm512_maskz_min_epi64 10052 // CHECK: call {{.*}}<8 x i64> @llvm.smin.v8i64(<8 x i64> %{{.*}}, <8 x i64> %{{.*}}) 10053 // CHECK: select <8 x i1> {{.*}}, <8 x i64> {{.*}}, <8 x i64> {{.*}} 10054 return _mm512_maskz_min_epi64 (__M,__A,__B); 10055 } 10056 10057 __m512i test_mm512_min_epu64 (__m512i __A, __m512i __B) 10058 { 10059 // CHECK-LABEL: test_mm512_min_epu64 10060 // CHECK: call {{.*}}<8 x i64> @llvm.umin.v8i64(<8 x i64> %{{.*}}, <8 x i64> %{{.*}}) 10061 return _mm512_min_epu64 (__A,__B); 10062 } 10063 10064 __m512i test_mm512_mask_min_epu64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B) 10065 { 10066 // CHECK-LABEL: test_mm512_mask_min_epu64 10067 // CHECK: call {{.*}}<8 x i64> @llvm.umin.v8i64(<8 x i64> %{{.*}}, <8 x i64> %{{.*}}) 10068 // CHECK: select <8 x i1> {{.*}}, <8 x i64> {{.*}}, <8 x i64> {{.*}} 10069 return _mm512_mask_min_epu64 (__W,__M,__A,__B); 10070 } 10071 10072 __m512i test_mm512_maskz_min_epu64 (__mmask8 __M, __m512i __A, __m512i __B) 10073 { 10074 // CHECK-LABEL: test_mm512_maskz_min_epu64 10075 // CHECK: call {{.*}}<8 x i64> @llvm.umin.v8i64(<8 x i64> %{{.*}}, <8 x i64> %{{.*}}) 10076 // CHECK: select <8 x i1> {{.*}}, <8 x i64> {{.*}}, <8 x i64> {{.*}} 10077 return _mm512_maskz_min_epu64 (__M,__A,__B); 10078 } 10079 10080 __m512i test_mm512_mask_set1_epi32 (__m512i __O, __mmask16 __M, int __A) 10081 { 10082 // CHECK-LABEL: test_mm512_mask_set1_epi32 10083 // CHECK: insertelement <16 x i32> poison, i32 %{{.*}}, i32 0 10084 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 1 10085 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 2 10086 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 3 10087 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 4 10088 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 5 10089 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 6 10090 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 7 10091 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 8 10092 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 9 10093 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 10 10094 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 11 10095 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 12 10096 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 13 10097 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 14 10098 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 15 10099 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 10100 return _mm512_mask_set1_epi32 ( __O, __M, __A); 10101 } 10102 10103 __m512i test_mm512_maskz_set1_epi32(__mmask16 __M, int __A) 10104 { 10105 // CHECK-LABEL: test_mm512_maskz_set1_epi32 10106 // CHECK: insertelement <16 x i32> poison, i32 %{{.*}}, i32 0 10107 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 1 10108 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 2 10109 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 3 10110 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 4 10111 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 5 10112 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 6 10113 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 7 10114 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 8 10115 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 9 10116 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 10 10117 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 11 10118 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 12 10119 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 13 10120 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 14 10121 // CHECK: insertelement <16 x i32> %{{.*}}, i32 %{{.*}}, i32 15 10122 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 10123 return _mm512_maskz_set1_epi32(__M, __A); 10124 } 10125 10126 10127 __m512i test_mm512_set_epi8(char e63, char e62, char e61, char e60, char e59, 10128 char e58, char e57, char e56, char e55, char e54, char e53, char e52, 10129 char e51, char e50, char e49, char e48, char e47, char e46, char e45, 10130 char e44, char e43, char e42, char e41, char e40, char e39, char e38, 10131 char e37, char e36, char e35, char e34, char e33, char e32, char e31, 10132 char e30, char e29, char e28, char e27, char e26, char e25, char e24, 10133 char e23, char e22, char e21, char e20, char e19, char e18, char e17, 10134 char e16, char e15, char e14, char e13, char e12, char e11, char e10, 10135 char e9, char e8, char e7, char e6, char e5, char e4, char e3, char e2, 10136 char e1, char e0) { 10137 10138 //CHECK-LABEL: test_mm512_set_epi8 10139 //CHECK: load i8, ptr %{{.*}}, align 1 10140 //CHECK: load i8, ptr %{{.*}}, align 1 10141 //CHECK: load i8, ptr %{{.*}}, align 1 10142 //CHECK: load i8, ptr %{{.*}}, align 1 10143 //CHECK: load i8, ptr %{{.*}}, align 1 10144 //CHECK: load i8, ptr %{{.*}}, align 1 10145 //CHECK: load i8, ptr %{{.*}}, align 1 10146 //CHECK: load i8, ptr %{{.*}}, align 1 10147 //CHECK: load i8, ptr %{{.*}}, align 1 10148 //CHECK: load i8, ptr %{{.*}}, align 1 10149 //CHECK: load i8, ptr %{{.*}}, align 1 10150 //CHECK: load i8, ptr %{{.*}}, align 1 10151 //CHECK: load i8, ptr %{{.*}}, align 1 10152 //CHECK: load i8, ptr %{{.*}}, align 1 10153 //CHECK: load i8, ptr %{{.*}}, align 1 10154 //CHECK: load i8, ptr %{{.*}}, align 1 10155 //CHECK: load i8, ptr %{{.*}}, align 1 10156 //CHECK: load i8, ptr %{{.*}}, align 1 10157 //CHECK: load i8, ptr %{{.*}}, align 1 10158 //CHECK: load i8, ptr %{{.*}}, align 1 10159 //CHECK: load i8, ptr %{{.*}}, align 1 10160 //CHECK: load i8, ptr %{{.*}}, align 1 10161 //CHECK: load i8, ptr %{{.*}}, align 1 10162 //CHECK: load i8, ptr %{{.*}}, align 1 10163 //CHECK: load i8, ptr %{{.*}}, align 1 10164 //CHECK: load i8, ptr %{{.*}}, align 1 10165 //CHECK: load i8, ptr %{{.*}}, align 1 10166 //CHECK: load i8, ptr %{{.*}}, align 1 10167 //CHECK: load i8, ptr %{{.*}}, align 1 10168 //CHECK: load i8, ptr %{{.*}}, align 1 10169 //CHECK: load i8, ptr %{{.*}}, align 1 10170 //CHECK: load i8, ptr %{{.*}}, align 1 10171 //CHECK: load i8, ptr %{{.*}}, align 1 10172 //CHECK: load i8, ptr %{{.*}}, align 1 10173 //CHECK: load i8, ptr %{{.*}}, align 1 10174 //CHECK: load i8, ptr %{{.*}}, align 1 10175 //CHECK: load i8, ptr %{{.*}}, align 1 10176 //CHECK: load i8, ptr %{{.*}}, align 1 10177 //CHECK: load i8, ptr %{{.*}}, align 1 10178 //CHECK: load i8, ptr %{{.*}}, align 1 10179 //CHECK: load i8, ptr %{{.*}}, align 1 10180 //CHECK: load i8, ptr %{{.*}}, align 1 10181 //CHECK: load i8, ptr %{{.*}}, align 1 10182 //CHECK: load i8, ptr %{{.*}}, align 1 10183 //CHECK: load i8, ptr %{{.*}}, align 1 10184 //CHECK: load i8, ptr %{{.*}}, align 1 10185 //CHECK: load i8, ptr %{{.*}}, align 1 10186 //CHECK: load i8, ptr %{{.*}}, align 1 10187 //CHECK: load i8, ptr %{{.*}}, align 1 10188 //CHECK: load i8, ptr %{{.*}}, align 1 10189 //CHECK: load i8, ptr %{{.*}}, align 1 10190 //CHECK: load i8, ptr %{{.*}}, align 1 10191 //CHECK: load i8, ptr %{{.*}}, align 1 10192 //CHECK: load i8, ptr %{{.*}}, align 1 10193 //CHECK: load i8, ptr %{{.*}}, align 1 10194 //CHECK: load i8, ptr %{{.*}}, align 1 10195 //CHECK: load i8, ptr %{{.*}}, align 1 10196 //CHECK: load i8, ptr %{{.*}}, align 1 10197 //CHECK: load i8, ptr %{{.*}}, align 1 10198 //CHECK: load i8, ptr %{{.*}}, align 1 10199 //CHECK: load i8, ptr %{{.*}}, align 1 10200 //CHECK: load i8, ptr %{{.*}}, align 1 10201 //CHECK: load i8, ptr %{{.*}}, align 1 10202 //CHECK: load i8, ptr %{{.*}}, align 1 10203 return _mm512_set_epi8(e63, e62, e61, e60, e59, e58, e57, e56, e55, e54, 10204 e53, e52, e51, e50, e49, e48,e47, e46, e45, e44, e43, e42, e41, e40, 10205 e39, e38, e37, e36, e35, e34, e33, e32,e31, e30, e29, e28, e27, e26, 10206 e25, e24, e23, e22, e21, e20, e19, e18, e17, e16, e15, e14, e13, e12, 10207 e11, e10, e9, e8, e7, e6, e5, e4, e3, e2, e1, e0); 10208 } 10209 10210 __m512i test_mm512_set_epi16(short e31, short e30, short e29, short e28, 10211 short e27, short e26, short e25, short e24, short e23, short e22, 10212 short e21, short e20, short e19, short e18, short e17, 10213 short e16, short e15, short e14, short e13, short e12, 10214 short e11, short e10, short e9, short e8, short e7, 10215 short e6, short e5, short e4, short e3, short e2, short e1, short e0) { 10216 //CHECK-LABEL: test_mm512_set_epi16 10217 //CHECK: insertelement{{.*}}i32 0 10218 //CHECK: insertelement{{.*}}i32 1 10219 //CHECK: insertelement{{.*}}i32 2 10220 //CHECK: insertelement{{.*}}i32 3 10221 //CHECK: insertelement{{.*}}i32 4 10222 //CHECK: insertelement{{.*}}i32 5 10223 //CHECK: insertelement{{.*}}i32 6 10224 //CHECK: insertelement{{.*}}i32 7 10225 //CHECK: insertelement{{.*}}i32 8 10226 //CHECK: insertelement{{.*}}i32 9 10227 //CHECK: insertelement{{.*}}i32 10 10228 //CHECK: insertelement{{.*}}i32 11 10229 //CHECK: insertelement{{.*}}i32 12 10230 //CHECK: insertelement{{.*}}i32 13 10231 //CHECK: insertelement{{.*}}i32 14 10232 //CHECK: insertelement{{.*}}i32 15 10233 //CHECK: insertelement{{.*}}i32 16 10234 //CHECK: insertelement{{.*}}i32 17 10235 //CHECK: insertelement{{.*}}i32 18 10236 //CHECK: insertelement{{.*}}i32 19 10237 //CHECK: insertelement{{.*}}i32 20 10238 //CHECK: insertelement{{.*}}i32 21 10239 //CHECK: insertelement{{.*}}i32 22 10240 //CHECK: insertelement{{.*}}i32 23 10241 //CHECK: insertelement{{.*}}i32 24 10242 //CHECK: insertelement{{.*}}i32 25 10243 //CHECK: insertelement{{.*}}i32 26 10244 //CHECK: insertelement{{.*}}i32 27 10245 //CHECK: insertelement{{.*}}i32 28 10246 //CHECK: insertelement{{.*}}i32 29 10247 //CHECK: insertelement{{.*}}i32 30 10248 //CHECK: insertelement{{.*}}i32 31 10249 return _mm512_set_epi16(e31, e30, e29, e28, e27, e26, e25, e24, e23, e22, 10250 e21, e20, e19, e18, e17, e16, e15, e14, e13, e12, e11, e10, e9, e8, e7, 10251 e6, e5, e4, e3, e2, e1, e0); 10252 10253 } 10254 __m512i test_mm512_set_epi32 (int __A, int __B, int __C, int __D, 10255 int __E, int __F, int __G, int __H, 10256 int __I, int __J, int __K, int __L, 10257 int __M, int __N, int __O, int __P) 10258 { 10259 //CHECK-LABEL: test_mm512_set_epi32 10260 //CHECK: insertelement{{.*}}i32 0 10261 //CHECK: insertelement{{.*}}i32 1 10262 //CHECK: insertelement{{.*}}i32 2 10263 //CHECK: insertelement{{.*}}i32 3 10264 //CHECK: insertelement{{.*}}i32 4 10265 //CHECK: insertelement{{.*}}i32 5 10266 //CHECK: insertelement{{.*}}i32 6 10267 //CHECK: insertelement{{.*}}i32 7 10268 //CHECK: insertelement{{.*}}i32 8 10269 //CHECK: insertelement{{.*}}i32 9 10270 //CHECK: insertelement{{.*}}i32 10 10271 //CHECK: insertelement{{.*}}i32 11 10272 //CHECK: insertelement{{.*}}i32 12 10273 //CHECK: insertelement{{.*}}i32 13 10274 //CHECK: insertelement{{.*}}i32 14 10275 //CHECK: insertelement{{.*}}i32 15 10276 return _mm512_set_epi32( __A, __B, __C, __D,__E, __F, __G, __H, 10277 __I, __J, __K, __L,__M, __N, __O, __P); 10278 } 10279 10280 __m512i test_mm512_setr_epi32 (int __A, int __B, int __C, int __D, 10281 int __E, int __F, int __G, int __H, 10282 int __I, int __J, int __K, int __L, 10283 int __M, int __N, int __O, int __P) 10284 { 10285 //CHECK-LABEL: test_mm512_setr_epi32 10286 //CHECK: load{{.*}}%{{.*}}, align 4 10287 //CHECK: load{{.*}}%{{.*}}, align 4 10288 //CHECK: load{{.*}}%{{.*}}, align 4 10289 //CHECK: load{{.*}}%{{.*}}, align 4 10290 //CHECK: load{{.*}}%{{.*}}, align 4 10291 //CHECK: load{{.*}}%{{.*}}, align 4 10292 //CHECK: load{{.*}}%{{.*}}, align 4 10293 //CHECK: load{{.*}}%{{.*}}, align 4 10294 //CHECK: load{{.*}}%{{.*}}, align 4 10295 //CHECK: load{{.*}}%{{.*}}, align 4 10296 //CHECK: load{{.*}}%{{.*}}, align 4 10297 //CHECK: load{{.*}}%{{.*}}, align 4 10298 //CHECK: load{{.*}}%{{.*}}, align 4 10299 //CHECK: load{{.*}}%{{.*}}, align 4 10300 //CHECK: load{{.*}}%{{.*}}, align 4 10301 //CHECK: load{{.*}}%{{.*}}, align 4 10302 //CHECK: insertelement{{.*}}i32 0 10303 //CHECK: insertelement{{.*}}i32 1 10304 //CHECK: insertelement{{.*}}i32 2 10305 //CHECK: insertelement{{.*}}i32 3 10306 //CHECK: insertelement{{.*}}i32 4 10307 //CHECK: insertelement{{.*}}i32 5 10308 //CHECK: insertelement{{.*}}i32 6 10309 //CHECK: insertelement{{.*}}i32 7 10310 //CHECK: insertelement{{.*}}i32 8 10311 //CHECK: insertelement{{.*}}i32 9 10312 //CHECK: insertelement{{.*}}i32 10 10313 //CHECK: insertelement{{.*}}i32 11 10314 //CHECK: insertelement{{.*}}i32 12 10315 //CHECK: insertelement{{.*}}i32 13 10316 //CHECK: insertelement{{.*}}i32 14 10317 //CHECK: insertelement{{.*}}i32 15 10318 return _mm512_setr_epi32( __A, __B, __C, __D,__E, __F, __G, __H, 10319 __I, __J, __K, __L,__M, __N, __O, __P); 10320 } 10321 10322 __m512i test_mm512_mask_set1_epi64 (__m512i __O, __mmask8 __M, long long __A) 10323 { 10324 // CHECK-LABEL: test_mm512_mask_set1_epi64 10325 // CHECK: insertelement <8 x i64> poison, i64 %{{.*}}, i32 0 10326 // CHECK: insertelement <8 x i64> %{{.*}}, i64 %{{.*}}, i32 1 10327 // CHECK: insertelement <8 x i64> %{{.*}}, i64 %{{.*}}, i32 2 10328 // CHECK: insertelement <8 x i64> %{{.*}}, i64 %{{.*}}, i32 3 10329 // CHECK: insertelement <8 x i64> %{{.*}}, i64 %{{.*}}, i32 4 10330 // CHECK: insertelement <8 x i64> %{{.*}}, i64 %{{.*}}, i32 5 10331 // CHECK: insertelement <8 x i64> %{{.*}}, i64 %{{.*}}, i32 6 10332 // CHECK: insertelement <8 x i64> %{{.*}}, i64 %{{.*}}, i32 7 10333 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 10334 return _mm512_mask_set1_epi64 (__O, __M, __A); 10335 } 10336 10337 __m512i test_mm512_maskz_set1_epi64 (__mmask8 __M, long long __A) 10338 { 10339 // CHECK-LABEL: test_mm512_maskz_set1_epi64 10340 // CHECK: insertelement <8 x i64> poison, i64 %{{.*}}, i32 0 10341 // CHECK: insertelement <8 x i64> %{{.*}}, i64 %{{.*}}, i32 1 10342 // CHECK: insertelement <8 x i64> %{{.*}}, i64 %{{.*}}, i32 2 10343 // CHECK: insertelement <8 x i64> %{{.*}}, i64 %{{.*}}, i32 3 10344 // CHECK: insertelement <8 x i64> %{{.*}}, i64 %{{.*}}, i32 4 10345 // CHECK: insertelement <8 x i64> %{{.*}}, i64 %{{.*}}, i32 5 10346 // CHECK: insertelement <8 x i64> %{{.*}}, i64 %{{.*}}, i32 6 10347 // CHECK: insertelement <8 x i64> %{{.*}}, i64 %{{.*}}, i32 7 10348 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> %{{.*}}, <8 x i64> %{{.*}} 10349 return _mm512_maskz_set1_epi64 (__M, __A); 10350 } 10351 10352 10353 __m512i test_mm512_set_epi64 (long long __A, long long __B, long long __C, 10354 long long __D, long long __E, long long __F, 10355 long long __G, long long __H) 10356 { 10357 //CHECK-LABEL: test_mm512_set_epi64 10358 //CHECK: insertelement{{.*}}i32 0 10359 //CHECK: insertelement{{.*}}i32 1 10360 //CHECK: insertelement{{.*}}i32 2 10361 //CHECK: insertelement{{.*}}i32 3 10362 //CHECK: insertelement{{.*}}i32 4 10363 //CHECK: insertelement{{.*}}i32 5 10364 //CHECK: insertelement{{.*}}i32 6 10365 //CHECK: insertelement{{.*}}i32 7 10366 return _mm512_set_epi64(__A, __B, __C, __D, __E, __F, __G, __H ); 10367 } 10368 10369 __m512i test_mm512_setr_epi64 (long long __A, long long __B, long long __C, 10370 long long __D, long long __E, long long __F, 10371 long long __G, long long __H) 10372 { 10373 //CHECK-LABEL: test_mm512_setr_epi64 10374 //CHECK: load{{.*}}%{{.*}}, align 8 10375 //CHECK: load{{.*}}%{{.*}}, align 8 10376 //CHECK: load{{.*}}%{{.*}}, align 8 10377 //CHECK: load{{.*}}%{{.*}}, align 8 10378 //CHECK: load{{.*}}%{{.*}}, align 8 10379 //CHECK: load{{.*}}%{{.*}}, align 8 10380 //CHECK: load{{.*}}%{{.*}}, align 8 10381 //CHECK: load{{.*}}%{{.*}}, align 8 10382 //CHECK: insertelement{{.*}}i32 0 10383 //CHECK: insertelement{{.*}}i32 1 10384 //CHECK: insertelement{{.*}}i32 2 10385 //CHECK: insertelement{{.*}}i32 3 10386 //CHECK: insertelement{{.*}}i32 4 10387 //CHECK: insertelement{{.*}}i32 5 10388 //CHECK: insertelement{{.*}}i32 6 10389 //CHECK: insertelement{{.*}}i32 7 10390 return _mm512_setr_epi64(__A, __B, __C, __D, __E, __F, __G, __H ); 10391 } 10392 10393 __m512d test_mm512_set_pd (double __A, double __B, double __C, double __D, 10394 double __E, double __F, double __G, double __H) 10395 { 10396 //CHECK-LABEL: test_mm512_set_pd 10397 //CHECK: insertelement{{.*}}i32 0 10398 //CHECK: insertelement{{.*}}i32 1 10399 //CHECK: insertelement{{.*}}i32 2 10400 //CHECK: insertelement{{.*}}i32 3 10401 //CHECK: insertelement{{.*}}i32 4 10402 //CHECK: insertelement{{.*}}i32 5 10403 //CHECK: insertelement{{.*}}i32 6 10404 //CHECK: insertelement{{.*}}i32 7 10405 return _mm512_set_pd( __A, __B, __C, __D, __E, __F, __G, __H); 10406 } 10407 10408 __m512d test_mm512_setr_pd (double __A, double __B, double __C, double __D, 10409 double __E, double __F, double __G, double __H) 10410 { 10411 //CHECK-LABEL: test_mm512_setr_pd 10412 //CHECK: load{{.*}}%{{.*}}, align 8 10413 //CHECK: load{{.*}}%{{.*}}, align 8 10414 //CHECK: load{{.*}}%{{.*}}, align 8 10415 //CHECK: load{{.*}}%{{.*}}, align 8 10416 //CHECK: load{{.*}}%{{.*}}, align 8 10417 //CHECK: load{{.*}}%{{.*}}, align 8 10418 //CHECK: load{{.*}}%{{.*}}, align 8 10419 //CHECK: load{{.*}}%{{.*}}, align 8 10420 //CHECK: insertelement{{.*}}i32 0 10421 //CHECK: insertelement{{.*}}i32 1 10422 //CHECK: insertelement{{.*}}i32 2 10423 //CHECK: insertelement{{.*}}i32 3 10424 //CHECK: insertelement{{.*}}i32 4 10425 //CHECK: insertelement{{.*}}i32 5 10426 //CHECK: insertelement{{.*}}i32 6 10427 //CHECK: insertelement{{.*}}i32 7 10428 return _mm512_setr_pd( __A, __B, __C, __D, __E, __F, __G, __H); 10429 } 10430 10431 __m512 test_mm512_set_ps (float __A, float __B, float __C, float __D, 10432 float __E, float __F, float __G, float __H, 10433 float __I, float __J, float __K, float __L, 10434 float __M, float __N, float __O, float __P) 10435 { 10436 //CHECK-LABEL: test_mm512_set_ps 10437 //CHECK: insertelement{{.*}}i32 0 10438 //CHECK: insertelement{{.*}}i32 1 10439 //CHECK: insertelement{{.*}}i32 2 10440 //CHECK: insertelement{{.*}}i32 3 10441 //CHECK: insertelement{{.*}}i32 4 10442 //CHECK: insertelement{{.*}}i32 5 10443 //CHECK: insertelement{{.*}}i32 6 10444 //CHECK: insertelement{{.*}}i32 7 10445 //CHECK: insertelement{{.*}}i32 8 10446 //CHECK: insertelement{{.*}}i32 9 10447 //CHECK: insertelement{{.*}}i32 10 10448 //CHECK: insertelement{{.*}}i32 11 10449 //CHECK: insertelement{{.*}}i32 12 10450 //CHECK: insertelement{{.*}}i32 13 10451 //CHECK: insertelement{{.*}}i32 14 10452 //CHECK: insertelement{{.*}}i32 15 10453 return _mm512_set_ps( __A, __B, __C, __D, __E, __F, __G, __H, 10454 __I, __J, __K, __L, __M, __N, __O, __P); 10455 } 10456 10457 __m512i test_mm512_mask_abs_epi64 (__m512i __W, __mmask8 __U, __m512i __A) 10458 { 10459 // CHECK-LABEL: test_mm512_mask_abs_epi64 10460 // CHECK: [[ABS:%.*]] = call {{.*}}<8 x i64> @llvm.abs.v8i64(<8 x i64> %{{.*}}, i1 false) 10461 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> [[ABS]], <8 x i64> %{{.*}} 10462 return _mm512_mask_abs_epi64 (__W,__U,__A); 10463 } 10464 10465 __m512i test_mm512_maskz_abs_epi64 (__mmask8 __U, __m512i __A) 10466 { 10467 // CHECK-LABEL: test_mm512_maskz_abs_epi64 10468 // CHECK: [[ABS:%.*]] = call {{.*}}<8 x i64> @llvm.abs.v8i64(<8 x i64> %{{.*}}, i1 false) 10469 // CHECK: select <8 x i1> %{{.*}}, <8 x i64> [[ABS]], <8 x i64> %{{.*}} 10470 return _mm512_maskz_abs_epi64 (__U,__A); 10471 } 10472 10473 __m512i test_mm512_mask_abs_epi32 (__m512i __W, __mmask16 __U, __m512i __A) 10474 { 10475 // CHECK-LABEL: test_mm512_mask_abs_epi32 10476 // CHECK: [[ABS:%.*]] = call <16 x i32> @llvm.abs.v16i32(<16 x i32> %{{.*}}, i1 false) 10477 // CHECK: [[TMP:%.*]] = bitcast <16 x i32> [[ABS]] to <8 x i64> 10478 // CHECK: [[ABS:%.*]] = bitcast <8 x i64> [[TMP]] to <16 x i32> 10479 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> [[ABS]], <16 x i32> %{{.*}} 10480 return _mm512_mask_abs_epi32 (__W,__U,__A); 10481 } 10482 10483 __m512i test_mm512_maskz_abs_epi32 (__mmask16 __U, __m512i __A) 10484 { 10485 // CHECK-LABEL: test_mm512_maskz_abs_epi32 10486 // CHECK: [[ABS:%.*]] = call <16 x i32> @llvm.abs.v16i32(<16 x i32> %{{.*}}, i1 false) 10487 // CHECK: [[TMP:%.*]] = bitcast <16 x i32> [[ABS]] to <8 x i64> 10488 // CHECK: [[ABS:%.*]] = bitcast <8 x i64> [[TMP]] to <16 x i32> 10489 // CHECK: select <16 x i1> %{{.*}}, <16 x i32> [[ABS]], <16 x i32> %{{.*}} 10490 return _mm512_maskz_abs_epi32 (__U,__A); 10491 } 10492 10493 __m512 test_mm512_setr_ps (float __A, float __B, float __C, float __D, 10494 float __E, float __F, float __G, float __H, 10495 float __I, float __J, float __K, float __L, 10496 float __M, float __N, float __O, float __P) 10497 { 10498 //CHECK-LABEL: test_mm512_setr_ps 10499 //CHECK: load{{.*}}%{{.*}}, align 4 10500 //CHECK: load{{.*}}%{{.*}}, align 4 10501 //CHECK: load{{.*}}%{{.*}}, align 4 10502 //CHECK: load{{.*}}%{{.*}}, align 4 10503 //CHECK: load{{.*}}%{{.*}}, align 4 10504 //CHECK: load{{.*}}%{{.*}}, align 4 10505 //CHECK: load{{.*}}%{{.*}}, align 4 10506 //CHECK: load{{.*}}%{{.*}}, align 4 10507 //CHECK: load{{.*}}%{{.*}}, align 4 10508 //CHECK: load{{.*}}%{{.*}}, align 4 10509 //CHECK: load{{.*}}%{{.*}}, align 4 10510 //CHECK: load{{.*}}%{{.*}}, align 4 10511 //CHECK: load{{.*}}%{{.*}}, align 4 10512 //CHECK: load{{.*}}%{{.*}}, align 4 10513 //CHECK: load{{.*}}%{{.*}}, align 4 10514 //CHECK: load{{.*}}%{{.*}}, align 4 10515 //CHECK: insertelement{{.*}}i32 0 10516 //CHECK: insertelement{{.*}}i32 1 10517 //CHECK: insertelement{{.*}}i32 2 10518 //CHECK: insertelement{{.*}}i32 3 10519 //CHECK: insertelement{{.*}}i32 4 10520 //CHECK: insertelement{{.*}}i32 5 10521 //CHECK: insertelement{{.*}}i32 6 10522 //CHECK: insertelement{{.*}}i32 7 10523 //CHECK: insertelement{{.*}}i32 8 10524 //CHECK: insertelement{{.*}}i32 9 10525 //CHECK: insertelement{{.*}}i32 10 10526 //CHECK: insertelement{{.*}}i32 11 10527 //CHECK: insertelement{{.*}}i32 12 10528 //CHECK: insertelement{{.*}}i32 13 10529 //CHECK: insertelement{{.*}}i32 14 10530 //CHECK: insertelement{{.*}}i32 15 10531 return _mm512_setr_ps( __A, __B, __C, __D, __E, __F, __G, __H, 10532 __I, __J, __K, __L, __M, __N, __O, __P); 10533 } 10534 10535 int test_mm_cvtss_i32(__m128 A) { 10536 // CHECK-LABEL: test_mm_cvtss_i32 10537 // CHECK: call {{.*}}i32 @llvm.x86.sse.cvtss2si(<4 x float> %{{.*}}) 10538 return _mm_cvtss_i32(A); 10539 } 10540 10541 #ifdef __x86_64__ 10542 long long test_mm_cvtss_i64(__m128 A) { 10543 // CHECK-LABEL: test_mm_cvtss_i64 10544 // CHECK: call {{.*}}i64 @llvm.x86.sse.cvtss2si64(<4 x float> %{{.*}}) 10545 return _mm_cvtss_i64(A); 10546 } 10547 #endif 10548 10549 __m128d test_mm_cvti32_sd(__m128d A, int B) { 10550 // CHECK-LABEL: test_mm_cvti32_sd 10551 // CHECK: sitofp i32 %{{.*}} to double 10552 // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0 10553 return _mm_cvti32_sd(A, B); 10554 } 10555 10556 #ifdef __x86_64__ 10557 __m128d test_mm_cvti64_sd(__m128d A, long long B) { 10558 // CHECK-LABEL: test_mm_cvti64_sd 10559 // CHECK: sitofp i64 %{{.*}} to double 10560 // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0 10561 return _mm_cvti64_sd(A, B); 10562 } 10563 #endif 10564 10565 __m128 test_mm_cvti32_ss(__m128 A, int B) { 10566 // CHECK-LABEL: test_mm_cvti32_ss 10567 // CHECK: sitofp i32 %{{.*}} to float 10568 // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 0 10569 return _mm_cvti32_ss(A, B); 10570 } 10571 10572 #ifdef __x86_64__ 10573 __m128 test_mm_cvti64_ss(__m128 A, long long B) { 10574 // CHECK-LABEL: test_mm_cvti64_ss 10575 // CHECK: sitofp i64 %{{.*}} to float 10576 // CHECK: insertelement <4 x float> %{{.*}}, float %{{.*}}, i32 0 10577 return _mm_cvti64_ss(A, B); 10578 } 10579 #endif 10580 10581 int test_mm_cvtsd_i32(__m128d A) { 10582 // CHECK-LABEL: test_mm_cvtsd_i32 10583 // CHECK: call {{.*}}i32 @llvm.x86.sse2.cvtsd2si(<2 x double> %{{.*}}) 10584 return _mm_cvtsd_i32(A); 10585 } 10586 10587 #ifdef __x86_64__ 10588 long long test_mm_cvtsd_i64(__m128d A) { 10589 // CHECK-LABEL: test_mm_cvtsd_i64 10590 // CHECK: call {{.*}}i64 @llvm.x86.sse2.cvtsd2si64(<2 x double> %{{.*}}) 10591 return _mm_cvtsd_i64(A); 10592 } 10593 #endif 10594 10595 __m128d test_mm_mask_cvtss_sd(__m128d __W, __mmask8 __U, __m128d __A, __m128 __B) { 10596 // CHECK-LABEL: test_mm_mask_cvtss_sd 10597 // CHECK: @llvm.x86.avx512.mask.cvtss2sd.round 10598 return _mm_mask_cvtss_sd(__W, __U, __A, __B); 10599 } 10600 10601 __m128d test_mm_maskz_cvtss_sd( __mmask8 __U, __m128d __A, __m128 __B) { 10602 // CHECK-LABEL: test_mm_maskz_cvtss_sd 10603 // CHECK: @llvm.x86.avx512.mask.cvtss2sd.round 10604 return _mm_maskz_cvtss_sd( __U, __A, __B); 10605 } 10606 10607 __m128 test_mm_mask_cvtsd_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128d __B) { 10608 // CHECK-LABEL: test_mm_mask_cvtsd_ss 10609 // CHECK: @llvm.x86.avx512.mask.cvtsd2ss.round 10610 return _mm_mask_cvtsd_ss(__W, __U, __A, __B); 10611 } 10612 10613 __m128 test_mm_maskz_cvtsd_ss(__mmask8 __U, __m128 __A, __m128d __B) { 10614 // CHECK-LABEL: test_mm_maskz_cvtsd_ss 10615 // CHECK: @llvm.x86.avx512.mask.cvtsd2ss.round 10616 return _mm_maskz_cvtsd_ss(__U, __A, __B); 10617 } 10618 10619 __m512i test_mm512_setzero_epi32(void) 10620 { 10621 // CHECK-LABEL: test_mm512_setzero_epi32 10622 // CHECK: zeroinitializer 10623 return _mm512_setzero_epi32(); 10624 } 10625 TEST_CONSTEXPR(match_m512i(_mm512_setzero_epi32(), 0, 0, 0, 0, 0, 0, 0, 0)); 10626 10627 __m512 test_mm512_setzero(void) 10628 { 10629 // CHECK-LABEL: test_mm512_setzero 10630 // CHECK: zeroinitializer 10631 return _mm512_setzero(); 10632 } 10633 TEST_CONSTEXPR(match_m512(_mm512_setzero(), +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f)); 10634 10635 __m512i test_mm512_setzero_si512(void) 10636 { 10637 // CHECK-LABEL: test_mm512_setzero_si512 10638 // CHECK: zeroinitializer 10639 return _mm512_setzero_si512(); 10640 } 10641 TEST_CONSTEXPR(match_m512i(_mm512_setzero_si512(), 0, 0, 0, 0, 0, 0, 0, 0)); 10642 10643 __m512 test_mm512_setzero_ps(void) 10644 { 10645 // CHECK-LABEL: test_mm512_setzero_ps 10646 // CHECK: zeroinitializer 10647 return _mm512_setzero_ps(); 10648 } 10649 TEST_CONSTEXPR(match_m512(_mm512_setzero_ps(), +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f, +0.0f)); 10650 10651 __m512d test_mm512_setzero_pd(void) 10652 { 10653 // CHECK-LABEL: test_mm512_setzero_pd 10654 // CHECK: zeroinitializer 10655 return _mm512_setzero_pd(); 10656 } 10657 TEST_CONSTEXPR(match_m512d(_mm512_setzero_pd(), 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)); 10658 10659 __mmask16 test_mm512_int2mask(int __a) 10660 { 10661 // CHECK-LABEL: test_mm512_int2mask 10662 // CHECK: trunc i32 %{{.*}} to i16 10663 return _mm512_int2mask(__a); 10664 } 10665 10666 int test_mm512_mask2int(__mmask16 __a) 10667 { 10668 // CHECK-LABEL: test_mm512_mask2int 10669 // CHECK: zext i16 %{{.*}} to i32 10670 return _mm512_mask2int(__a); 10671 } 10672 10673 __m128 test_mm_mask_move_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) 10674 { 10675 // CHECK-LABEL: test_mm_mask_move_ss 10676 // CHECK: [[EXT:%.*]] = extractelement <4 x float> %{{.*}}, i32 0 10677 // CHECK: insertelement <4 x float> %{{.*}}, float [[EXT]], i32 0 10678 // CHECK: [[A:%.*]] = extractelement <4 x float> [[VEC:%.*]], i64 0 10679 // CHECK-NEXT: [[B:%.*]] = extractelement <4 x float> %{{.*}}, i64 0 10680 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 10681 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 10682 // CHECK-NEXT: [[SEL:%.*]] = select i1 %{{.*}}, float [[A]], float [[B]] 10683 // CHECK-NEXT: insertelement <4 x float> [[VEC]], float [[SEL]], i64 0 10684 return _mm_mask_move_ss ( __W, __U, __A, __B); 10685 } 10686 10687 __m128 test_mm_maskz_move_ss (__mmask8 __U, __m128 __A, __m128 __B) 10688 { 10689 // CHECK-LABEL: test_mm_maskz_move_ss 10690 // CHECK: [[EXT:%.*]] = extractelement <4 x float> %{{.*}}, i32 0 10691 // CHECK: insertelement <4 x float> %{{.*}}, float [[EXT]], i32 0 10692 // CHECK: [[A:%.*]] = extractelement <4 x float> [[VEC:%.*]], i64 0 10693 // CHECK-NEXT: [[B:%.*]] = extractelement <4 x float> %{{.*}}, i64 0 10694 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 10695 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 10696 // CHECK-NEXT: [[SEL:%.*]] = select i1 %{{.*}}, float [[A]], float [[B]] 10697 // CHECK-NEXT: insertelement <4 x float> [[VEC]], float [[SEL]], i64 0 10698 return _mm_maskz_move_ss (__U, __A, __B); 10699 } 10700 10701 __m128d test_mm_mask_move_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) 10702 { 10703 // CHECK-LABEL: test_mm_mask_move_sd 10704 // CHECK: [[EXT:%.*]] = extractelement <2 x double> %{{.*}}, i32 0 10705 // CHECK: insertelement <2 x double> %{{.*}}, double [[EXT]], i32 0 10706 // CHECK: [[A:%.*]] = extractelement <2 x double> [[VEC:%.*]], i64 0 10707 // CHECK-NEXT: [[B:%.*]] = extractelement <2 x double> %{{.*}}, i64 0 10708 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 10709 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 10710 // CHECK-NEXT: [[SEL:%.*]] = select i1 %{{.*}}, double [[A]], double [[B]] 10711 // CHECK-NEXT: insertelement <2 x double> [[VEC]], double [[SEL]], i64 0 10712 return _mm_mask_move_sd ( __W, __U, __A, __B); 10713 } 10714 10715 __m128d test_mm_maskz_move_sd (__mmask8 __U, __m128d __A, __m128d __B) 10716 { 10717 // CHECK-LABEL: test_mm_maskz_move_sd 10718 // CHECK: [[EXT:%.*]] = extractelement <2 x double> %{{.*}}, i32 0 10719 // CHECK: insertelement <2 x double> %{{.*}}, double [[EXT]], i32 0 10720 // CHECK: [[A:%.*]] = extractelement <2 x double> [[VEC:%.*]], i64 0 10721 // CHECK-NEXT: [[B:%.*]] = extractelement <2 x double> %{{.*}}, i64 0 10722 // CHECK-NEXT: bitcast i8 %{{.*}} to <8 x i1> 10723 // CHECK-NEXT: extractelement <8 x i1> %{{.*}}, i64 0 10724 // CHECK-NEXT: [[SEL:%.*]] = select i1 %13, double [[A]], double [[B]] 10725 // CHECK-NEXT: insertelement <2 x double> [[VEC]], double [[SEL]], i64 0 10726 return _mm_maskz_move_sd (__U, __A, __B); 10727 } 10728 10729 void test_mm_mask_store_ss(float * __P, __mmask8 __U, __m128 __A) 10730 { 10731 // CHECK-LABEL: test_mm_mask_store_ss 10732 // CHECK: call void @llvm.masked.store.v4f32.p0(<4 x float> %{{.*}}, ptr %{{.*}}, i32 1, <4 x i1> %{{.*}}) 10733 _mm_mask_store_ss(__P, __U, __A); 10734 } 10735 10736 void test_mm_mask_store_sd(double * __P, __mmask8 __U, __m128d __A) 10737 { 10738 // CHECK-LABEL: test_mm_mask_store_sd 10739 // CHECK: call void @llvm.masked.store.v2f64.p0(<2 x double> %{{.*}}, ptr %{{.*}}, i32 1, <2 x i1> %{{.*}}) 10740 _mm_mask_store_sd(__P, __U, __A); 10741 } 10742 10743 __m128 test_mm_mask_load_ss(__m128 __A, __mmask8 __U, const float* __W) 10744 { 10745 // CHECK-LABEL: test_mm_mask_load_ss 10746 // CHECK: call {{.*}}<4 x float> @llvm.masked.load.v4f32.p0(ptr %{{.*}}, i32 1, <4 x i1> %{{.*}}, <4 x float> %{{.*}}) 10747 return _mm_mask_load_ss(__A, __U, __W); 10748 } 10749 10750 __m128 test_mm_maskz_load_ss (__mmask8 __U, const float * __W) 10751 { 10752 // CHECK-LABEL: test_mm_maskz_load_ss 10753 // CHECK: call {{.*}}<4 x float> @llvm.masked.load.v4f32.p0(ptr %{{.*}}, i32 1, <4 x i1> %{{.*}}, <4 x float> %{{.*}}) 10754 return _mm_maskz_load_ss (__U, __W); 10755 } 10756 10757 __m128d test_mm_mask_load_sd (__m128d __A, __mmask8 __U, const double * __W) 10758 { 10759 // CHECK-LABEL: test_mm_mask_load_sd 10760 // CHECK: call {{.*}}<2 x double> @llvm.masked.load.v2f64.p0(ptr %{{.*}}, i32 1, <2 x i1> %{{.*}}, <2 x double> %{{.*}}) 10761 return _mm_mask_load_sd (__A, __U, __W); 10762 } 10763 10764 __m128d test_mm_maskz_load_sd (__mmask8 __U, const double * __W) 10765 { 10766 // CHECK-LABEL: test_mm_maskz_load_sd 10767 // CHECK: call {{.*}}<2 x double> @llvm.masked.load.v2f64.p0(ptr %{{.*}}, i32 1, <2 x i1> %{{.*}}, <2 x double> %{{.*}}) 10768 return _mm_maskz_load_sd (__U, __W); 10769 } 10770 10771 __m512d test_mm512_abs_pd(__m512d a){ 10772 // CHECK-LABEL: test_mm512_abs_pd 10773 // CHECK: and <8 x i64> 10774 return _mm512_abs_pd(a); 10775 } 10776 10777 __m512d test_mm512_mask_abs_pd (__m512d __W, __mmask8 __U, __m512d __A){ 10778 // CHECK-LABEL: test_mm512_mask_abs_pd 10779 // CHECK: %[[AND_RES:.*]] = and <8 x i64> 10780 // CHECK: %[[MASK:.*]] = bitcast i8 %{{.*}} to <8 x i1> 10781 // CHECK: select <8 x i1> %[[MASK]], <8 x i64> %[[AND_RES]], <8 x i64> %{{.*}} 10782 return _mm512_mask_abs_pd (__W,__U,__A); 10783 } 10784 10785 __m512 test_mm512_abs_ps(__m512 a){ 10786 // CHECK-LABEL: test_mm512_abs_ps 10787 // CHECK: and <16 x i32> 10788 return _mm512_abs_ps(a); 10789 } 10790 10791 __m512 test_mm512_mask_abs_ps(__m512 __W, __mmask16 __U, __m512 __A){ 10792 // CHECK-LABEL: test_mm512_mask_abs_ps 10793 // CHECK: and <16 x i32> 10794 // CHECK: %[[MASK:.*]] = bitcast i16 %{{.*}} to <16 x i1> 10795 // CHECK: select <16 x i1> %[[MASK]], <16 x i32> %{{.*}}, <16 x i32> %{{.*}} 10796 return _mm512_mask_abs_ps( __W, __U, __A); 10797 } 10798 10799 __m512d test_mm512_zextpd128_pd512(__m128d A) { 10800 // CHECK-LABEL: test_mm512_zextpd128_pd512 10801 // CHECK: store <2 x double> zeroinitializer 10802 // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 2, i32 3, i32 2, i32 3> 10803 return _mm512_zextpd128_pd512(A); 10804 } 10805 10806 __m512d test_mm512_zextpd256_pd512(__m256d A) { 10807 // CHECK-LABEL: test_mm512_zextpd256_pd512 10808 // CHECK: store <4 x double> zeroinitializer 10809 // CHECK: shufflevector <4 x double> %{{.*}}, <4 x double> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 10810 return _mm512_zextpd256_pd512(A); 10811 } 10812 10813 __m512 test_mm512_zextps128_ps512(__m128 A) { 10814 // CHECK-LABEL: test_mm512_zextps128_ps512 10815 // CHECK: store <4 x float> zeroinitializer 10816 // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 4, i32 5, i32 6, i32 7, i32 4, i32 5, i32 6, i32 7> 10817 return _mm512_zextps128_ps512(A); 10818 } 10819 10820 __m512 test_mm512_zextps256_ps512(__m256 A) { 10821 // CHECK-LABEL: test_mm512_zextps256_ps512 10822 // CHECK: store <8 x float> zeroinitializer 10823 // CHECK: shufflevector <8 x float> %{{.*}}, <8 x float> %{{.*}}, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15> 10824 return _mm512_zextps256_ps512(A); 10825 } 10826 10827 __m512i test_mm512_zextsi128_si512(__m128i A) { 10828 // CHECK-LABEL: test_mm512_zextsi128_si512 10829 // CHECK: store <2 x i64> zeroinitializer 10830 // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 2, i32 3, i32 2, i32 3> 10831 return _mm512_zextsi128_si512(A); 10832 } 10833 10834 __m512i test_mm512_zextsi256_si512(__m256i A) { 10835 // CHECK-LABEL: test_mm512_zextsi256_si512 10836 // CHECK: store <4 x i64> zeroinitializer 10837 // CHECK: shufflevector <4 x i64> %{{.*}}, <4 x i64> %{{.*}}, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7> 10838 return _mm512_zextsi256_si512(A); 10839 } 10840 10841 __m512d test_mm512_i32logather_pd(__m512i __index, void const *__addr) { 10842 // CHECK-LABEL: test_mm512_i32logather_pd 10843 // CHECK: @llvm.x86.avx512.mask.gather.dpd.512 10844 return _mm512_i32logather_pd(__index, __addr, 2); 10845 } 10846 10847 __m512d test_mm512_mask_i32logather_pd(__m512d __v1_old, __mmask8 __mask, __m512i __index, void const *__addr) { 10848 // CHECK-LABEL: test_mm512_mask_i32logather_pd 10849 // CHECK: @llvm.x86.avx512.mask.gather.dpd.512 10850 return _mm512_mask_i32logather_pd(__v1_old, __mask, __index, __addr, 2); 10851 } 10852 10853 void test_mm512_i32loscatter_pd(void *__addr, __m512i __index, __m512d __v1) { 10854 // CHECK-LABEL: test_mm512_i32loscatter_pd 10855 // CHECK: @llvm.x86.avx512.mask.scatter.dpd.512 10856 return _mm512_i32loscatter_pd(__addr, __index, __v1, 2); 10857 } 10858 10859 void test_mm512_mask_i32loscatter_pd(void *__addr, __mmask8 __mask, __m512i __index, __m512d __v1) { 10860 // CHECK-LABEL: test_mm512_mask_i32loscatter_pd 10861 // CHECK: @llvm.x86.avx512.mask.scatter.dpd.512 10862 return _mm512_mask_i32loscatter_pd(__addr, __mask, __index, __v1, 2); 10863 } 10864 10865 __m512i test_mm512_i32logather_epi64(__m512i __index, void const *__addr) { 10866 // CHECK-LABEL: test_mm512_i32logather_epi64 10867 // CHECK: @llvm.x86.avx512.mask.gather.dpq.512 10868 return _mm512_i32logather_epi64(__index, __addr, 2); 10869 } 10870 10871 __m512i test_mm512_mask_i32logather_epi64(__m512i __v1_old, __mmask8 __mask, __m512i __index, void const *__addr) { 10872 // CHECK-LABEL: test_mm512_mask_i32logather_epi64 10873 // CHECK: @llvm.x86.avx512.mask.gather.dpq.512 10874 return _mm512_mask_i32logather_epi64(__v1_old, __mask, __index, __addr, 2); 10875 } 10876 10877 void test_mm512_i32loscatter_epi64(void *__addr, __m512i __index, __m512i __v1) { 10878 // CHECK-LABEL: test_mm512_i32loscatter_epi64 10879 // CHECK: @llvm.x86.avx512.mask.scatter.dpq.512 10880 _mm512_i32loscatter_epi64(__addr, __index, __v1, 2); 10881 } 10882 10883 void test_mm512_mask_i32loscatter_epi64(void *__addr, __mmask8 __mask, __m512i __index, __m512i __v1) { 10884 // CHECK-LABEL: test_mm512_mask_i32loscatter_epi64 10885 // CHECK: @llvm.x86.avx512.mask.scatter.dpq.512 10886 _mm512_mask_i32loscatter_epi64(__addr, __mask, __index, __v1, 2); 10887 } 10888