1540 lines · c
1// RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512f -target-feature +avx512vl -emit-llvm -ffp-exception-behavior=strict -o - -Wall -Werror | FileCheck %s2 3#include <immintrin.h>4 5__mmask8 test_mm256_cmp_ps_mask_eq_oq(__m256 a, __m256 b) {6 // CHECK-LABEL: @test_mm256_cmp_ps_mask_eq_oq7 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 0, <8 x i1> {{.*}})8 return _mm256_cmp_ps_mask(a, b, _CMP_EQ_OQ);9}10 11__mmask8 test_mm256_cmp_ps_mask_lt_os(__m256 a, __m256 b) {12 // CHECK-LABEL: test_mm256_cmp_ps_mask_lt_os13 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 1, <8 x i1> {{.*}})14 return _mm256_cmp_ps_mask(a, b, _CMP_LT_OS);15}16 17__mmask8 test_mm256_cmp_ps_mask_le_os(__m256 a, __m256 b) {18 // CHECK-LABEL: test_mm256_cmp_ps_mask_le_os19 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 2, <8 x i1> {{.*}})20 return _mm256_cmp_ps_mask(a, b, _CMP_LE_OS);21}22 23__mmask8 test_mm256_cmp_ps_mask_unord_q(__m256 a, __m256 b) {24 // CHECK-LABEL: test_mm256_cmp_ps_mask_unord_q25 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 3, <8 x i1> {{.*}})26 return _mm256_cmp_ps_mask(a, b, _CMP_UNORD_Q);27}28 29__mmask8 test_mm256_cmp_ps_mask_neq_uq(__m256 a, __m256 b) {30 // CHECK-LABEL: test_mm256_cmp_ps_mask_neq_uq31 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 4, <8 x i1> {{.*}})32 return _mm256_cmp_ps_mask(a, b, _CMP_NEQ_UQ);33}34 35__mmask8 test_mm256_cmp_ps_mask_nlt_us(__m256 a, __m256 b) {36 // CHECK-LABEL: test_mm256_cmp_ps_mask_nlt_us37 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 5, <8 x i1> {{.*}})38 return _mm256_cmp_ps_mask(a, b, _CMP_NLT_US);39}40 41__mmask8 test_mm256_cmp_ps_mask_nle_us(__m256 a, __m256 b) {42 // CHECK-LABEL: test_mm256_cmp_ps_mask_nle_us43 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 6, <8 x i1> {{.*}})44 return _mm256_cmp_ps_mask(a, b, _CMP_NLE_US);45}46 47__mmask8 test_mm256_cmp_ps_mask_ord_q(__m256 a, __m256 b) {48 // CHECK-LABEL: test_mm256_cmp_ps_mask_ord_q49 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 7, <8 x i1> {{.*}})50 return _mm256_cmp_ps_mask(a, b, _CMP_ORD_Q);51}52 53__mmask8 test_mm256_cmp_ps_mask_eq_uq(__m256 a, __m256 b) {54 // CHECK-LABEL: test_mm256_cmp_ps_mask_eq_uq55 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 8, <8 x i1> {{.*}})56 return _mm256_cmp_ps_mask(a, b, _CMP_EQ_UQ);57}58 59__mmask8 test_mm256_cmp_ps_mask_nge_us(__m256 a, __m256 b) {60 // CHECK-LABEL: test_mm256_cmp_ps_mask_nge_us61 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 9, <8 x i1> {{.*}})62 return _mm256_cmp_ps_mask(a, b, _CMP_NGE_US);63}64 65__mmask8 test_mm256_cmp_ps_mask_ngt_us(__m256 a, __m256 b) {66 // CHECK-LABEL: test_mm256_cmp_ps_mask_ngt_us67 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 10, <8 x i1> {{.*}})68 return _mm256_cmp_ps_mask(a, b, _CMP_NGT_US);69}70 71__mmask8 test_mm256_cmp_ps_mask_false_oq(__m256 a, __m256 b) {72 // CHECK-LABEL: test_mm256_cmp_ps_mask_false_oq73 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 11, <8 x i1> {{.*}})74 return _mm256_cmp_ps_mask(a, b, _CMP_FALSE_OQ);75}76 77__mmask8 test_mm256_cmp_ps_mask_neq_oq(__m256 a, __m256 b) {78 // CHECK-LABEL: test_mm256_cmp_ps_mask_neq_oq79 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 12, <8 x i1> {{.*}})80 return _mm256_cmp_ps_mask(a, b, _CMP_NEQ_OQ);81}82 83__mmask8 test_mm256_cmp_ps_mask_ge_os(__m256 a, __m256 b) {84 // CHECK-LABEL: test_mm256_cmp_ps_mask_ge_os85 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 13, <8 x i1> {{.*}})86 return _mm256_cmp_ps_mask(a, b, _CMP_GE_OS);87}88 89__mmask8 test_mm256_cmp_ps_mask_gt_os(__m256 a, __m256 b) {90 // CHECK-LABEL: test_mm256_cmp_ps_mask_gt_os91 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 14, <8 x i1> {{.*}})92 return _mm256_cmp_ps_mask(a, b, _CMP_GT_OS);93}94 95__mmask8 test_mm256_cmp_ps_mask_true_uq(__m256 a, __m256 b) {96 // CHECK-LABEL: test_mm256_cmp_ps_mask_true_uq97 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 15, <8 x i1> {{.*}})98 return _mm256_cmp_ps_mask(a, b, _CMP_TRUE_UQ);99}100 101__mmask8 test_mm256_cmp_ps_mask_eq_os(__m256 a, __m256 b) {102 // CHECK-LABEL: test_mm256_cmp_ps_mask_eq_os103 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 16, <8 x i1> {{.*}})104 return _mm256_cmp_ps_mask(a, b, _CMP_EQ_OS);105}106 107__mmask8 test_mm256_cmp_ps_mask_lt_oq(__m256 a, __m256 b) {108 // CHECK-LABEL: test_mm256_cmp_ps_mask_lt_oq109 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 17, <8 x i1> {{.*}})110 return _mm256_cmp_ps_mask(a, b, _CMP_LT_OQ);111}112 113__mmask8 test_mm256_cmp_ps_mask_le_oq(__m256 a, __m256 b) {114 // CHECK-LABEL: test_mm256_cmp_ps_mask_le_oq115 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 18, <8 x i1> {{.*}})116 return _mm256_cmp_ps_mask(a, b, _CMP_LE_OQ);117}118 119__mmask8 test_mm256_cmp_ps_mask_unord_s(__m256 a, __m256 b) {120 // CHECK-LABEL: test_mm256_cmp_ps_mask_unord_s121 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 19, <8 x i1> {{.*}})122 return _mm256_cmp_ps_mask(a, b, _CMP_UNORD_S);123}124 125__mmask8 test_mm256_cmp_ps_mask_neq_us(__m256 a, __m256 b) {126 // CHECK-LABEL: test_mm256_cmp_ps_mask_neq_us127 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 20, <8 x i1> {{.*}})128 return _mm256_cmp_ps_mask(a, b, _CMP_NEQ_US);129}130 131__mmask8 test_mm256_cmp_ps_mask_nlt_uq(__m256 a, __m256 b) {132 // CHECK-LABEL: test_mm256_cmp_ps_mask_nlt_uq133 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 21, <8 x i1> {{.*}})134 return _mm256_cmp_ps_mask(a, b, _CMP_NLT_UQ);135}136 137__mmask8 test_mm256_cmp_ps_mask_nle_uq(__m256 a, __m256 b) {138 // CHECK-LABEL: test_mm256_cmp_ps_mask_nle_uq139 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 22, <8 x i1> {{.*}})140 return _mm256_cmp_ps_mask(a, b, _CMP_NLE_UQ);141}142 143__mmask8 test_mm256_cmp_ps_mask_ord_s(__m256 a, __m256 b) {144 // CHECK-LABEL: test_mm256_cmp_ps_mask_ord_s145 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 23, <8 x i1> {{.*}})146 return _mm256_cmp_ps_mask(a, b, _CMP_ORD_S);147}148 149__mmask8 test_mm256_cmp_ps_mask_eq_us(__m256 a, __m256 b) {150 // CHECK-LABEL: test_mm256_cmp_ps_mask_eq_us151 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 24, <8 x i1> {{.*}})152 return _mm256_cmp_ps_mask(a, b, _CMP_EQ_US);153}154 155__mmask8 test_mm256_cmp_ps_mask_nge_uq(__m256 a, __m256 b) {156 // CHECK-LABEL: test_mm256_cmp_ps_mask_nge_uq157 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 25, <8 x i1> {{.*}})158 return _mm256_cmp_ps_mask(a, b, _CMP_NGE_UQ);159}160 161__mmask8 test_mm256_cmp_ps_mask_ngt_uq(__m256 a, __m256 b) {162 // CHECK-LABEL: test_mm256_cmp_ps_mask_ngt_uq163 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 26, <8 x i1> {{.*}})164 return _mm256_cmp_ps_mask(a, b, _CMP_NGT_UQ);165}166 167__mmask8 test_mm256_cmp_ps_mask_false_os(__m256 a, __m256 b) {168 // CHECK-LABEL: test_mm256_cmp_ps_mask_false_os169 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 27, <8 x i1> {{.*}})170 return _mm256_cmp_ps_mask(a, b, _CMP_FALSE_OS);171}172 173__mmask8 test_mm256_cmp_ps_mask_neq_os(__m256 a, __m256 b) {174 // CHECK-LABEL: test_mm256_cmp_ps_mask_neq_os175 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 28, <8 x i1> {{.*}})176 return _mm256_cmp_ps_mask(a, b, _CMP_NEQ_OS);177}178 179__mmask8 test_mm256_cmp_ps_mask_ge_oq(__m256 a, __m256 b) {180 // CHECK-LABEL: test_mm256_cmp_ps_mask_ge_oq181 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 29, <8 x i1> {{.*}})182 return _mm256_cmp_ps_mask(a, b, _CMP_GE_OQ);183}184 185__mmask8 test_mm256_cmp_ps_mask_gt_oq(__m256 a, __m256 b) {186 // CHECK-LABEL: test_mm256_cmp_ps_mask_gt_oq187 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 30, <8 x i1> {{.*}})188 return _mm256_cmp_ps_mask(a, b, _CMP_GT_OQ);189}190 191__mmask8 test_mm256_cmp_ps_mask_true_us(__m256 a, __m256 b) {192 // CHECK-LABEL: test_mm256_cmp_ps_mask_true_us193 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 31, <8 x i1> {{.*}})194 return _mm256_cmp_ps_mask(a, b, _CMP_TRUE_US);195}196 197__mmask8 test_mm256_mask_cmp_ps_mask_eq_oq(__mmask8 m, __m256 a, __m256 b) {198 // CHECK-LABEL: @test_mm256_mask_cmp_ps_mask_eq_oq199 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 0, <8 x i1> {{.*}})200 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_EQ_OQ);201}202 203__mmask8 test_mm256_mask_cmp_ps_mask_lt_os(__mmask8 m, __m256 a, __m256 b) {204 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_lt_os205 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 1, <8 x i1> {{.*}})206 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_LT_OS);207}208 209__mmask8 test_mm256_mask_cmp_ps_mask_le_os(__mmask8 m, __m256 a, __m256 b) {210 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_le_os211 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 2, <8 x i1> {{.*}})212 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_LE_OS);213}214 215__mmask8 test_mm256_mask_cmp_ps_mask_unord_q(__mmask8 m, __m256 a, __m256 b) {216 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_unord_q217 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 3, <8 x i1> {{.*}})218 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_UNORD_Q);219}220 221__mmask8 test_mm256_mask_cmp_ps_mask_neq_uq(__mmask8 m, __m256 a, __m256 b) {222 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_neq_uq223 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 4, <8 x i1> {{.*}})224 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_UQ);225}226 227__mmask8 test_mm256_mask_cmp_ps_mask_nlt_us(__mmask8 m, __m256 a, __m256 b) {228 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_nlt_us229 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 5, <8 x i1> {{.*}})230 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NLT_US);231}232 233__mmask8 test_mm256_mask_cmp_ps_mask_nle_us(__mmask8 m, __m256 a, __m256 b) {234 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_nle_us235 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 6, <8 x i1> {{.*}})236 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NLE_US);237}238 239__mmask8 test_mm256_mask_cmp_ps_mask_ord_q(__mmask8 m, __m256 a, __m256 b) {240 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_ord_q241 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 7, <8 x i1> {{.*}})242 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_ORD_Q);243}244 245__mmask8 test_mm256_mask_cmp_ps_mask_eq_uq(__mmask8 m, __m256 a, __m256 b) {246 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_eq_uq247 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 8, <8 x i1> {{.*}})248 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_EQ_UQ);249}250 251__mmask8 test_mm256_mask_cmp_ps_mask_nge_us(__mmask8 m, __m256 a, __m256 b) {252 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_nge_us253 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 9, <8 x i1> {{.*}})254 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NGE_US);255}256 257__mmask8 test_mm256_mask_cmp_ps_mask_ngt_us(__mmask8 m, __m256 a, __m256 b) {258 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_ngt_us259 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 10, <8 x i1> {{.*}})260 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NGT_US);261}262 263__mmask8 test_mm256_mask_cmp_ps_mask_false_oq(__mmask8 m, __m256 a, __m256 b) {264 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_false_oq265 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 11, <8 x i1> {{.*}})266 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_FALSE_OQ);267}268 269__mmask8 test_mm256_mask_cmp_ps_mask_neq_oq(__mmask8 m, __m256 a, __m256 b) {270 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_neq_oq271 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 12, <8 x i1> {{.*}})272 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_OQ);273}274 275__mmask8 test_mm256_mask_cmp_ps_mask_ge_os(__mmask8 m, __m256 a, __m256 b) {276 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_ge_os277 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 13, <8 x i1> {{.*}})278 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_GE_OS);279}280 281__mmask8 test_mm256_mask_cmp_ps_mask_gt_os(__mmask8 m, __m256 a, __m256 b) {282 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_gt_os283 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 14, <8 x i1> {{.*}})284 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_GT_OS);285}286 287__mmask8 test_mm256_mask_cmp_ps_mask_true_uq(__mmask8 m, __m256 a, __m256 b) {288 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_true_uq289 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 15, <8 x i1> {{.*}})290 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_TRUE_UQ);291}292 293__mmask8 test_mm256_mask_cmp_ps_mask_eq_os(__mmask8 m, __m256 a, __m256 b) {294 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_eq_os295 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 16, <8 x i1> {{.*}})296 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_EQ_OS);297}298 299__mmask8 test_mm256_mask_cmp_ps_mask_lt_oq(__mmask8 m, __m256 a, __m256 b) {300 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_lt_oq301 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 17, <8 x i1> {{.*}})302 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_LT_OQ);303}304 305__mmask8 test_mm256_mask_cmp_ps_mask_le_oq(__mmask8 m, __m256 a, __m256 b) {306 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_le_oq307 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 18, <8 x i1> {{.*}})308 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_LE_OQ);309}310 311__mmask8 test_mm256_mask_cmp_ps_mask_unord_s(__mmask8 m, __m256 a, __m256 b) {312 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_unord_s313 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 19, <8 x i1> {{.*}})314 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_UNORD_S);315}316 317__mmask8 test_mm256_mask_cmp_ps_mask_neq_us(__mmask8 m, __m256 a, __m256 b) {318 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_neq_us319 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 20, <8 x i1> {{.*}})320 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_US);321}322 323__mmask8 test_mm256_mask_cmp_ps_mask_nlt_uq(__mmask8 m, __m256 a, __m256 b) {324 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_nlt_uq325 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 21, <8 x i1> {{.*}})326 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NLT_UQ);327}328 329__mmask8 test_mm256_mask_cmp_ps_mask_nle_uq(__mmask8 m, __m256 a, __m256 b) {330 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_nle_uq331 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 22, <8 x i1> {{.*}})332 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NLE_UQ);333}334 335__mmask8 test_mm256_mask_cmp_ps_mask_ord_s(__mmask8 m, __m256 a, __m256 b) {336 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_ord_s337 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 23, <8 x i1> {{.*}})338 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_ORD_S);339}340 341__mmask8 test_mm256_mask_cmp_ps_mask_eq_us(__mmask8 m, __m256 a, __m256 b) {342 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_eq_us343 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 24, <8 x i1> {{.*}})344 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_EQ_US);345}346 347__mmask8 test_mm256_mask_cmp_ps_mask_nge_uq(__mmask8 m, __m256 a, __m256 b) {348 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_nge_uq349 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 25, <8 x i1> {{.*}})350 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NGE_UQ);351}352 353__mmask8 test_mm256_mask_cmp_ps_mask_ngt_uq(__mmask8 m, __m256 a, __m256 b) {354 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_ngt_uq355 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 26, <8 x i1> {{.*}})356 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NGT_UQ);357}358 359__mmask8 test_mm256_mask_cmp_ps_mask_false_os(__mmask8 m, __m256 a, __m256 b) {360 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_false_os361 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 27, <8 x i1> {{.*}})362 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_FALSE_OS);363}364 365__mmask8 test_mm256_mask_cmp_ps_mask_neq_os(__mmask8 m, __m256 a, __m256 b) {366 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_neq_os367 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 28, <8 x i1> {{.*}})368 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_OS);369}370 371__mmask8 test_mm256_mask_cmp_ps_mask_ge_oq(__mmask8 m, __m256 a, __m256 b) {372 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_ge_oq373 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 29, <8 x i1> {{.*}})374 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_GE_OQ);375}376 377__mmask8 test_mm256_mask_cmp_ps_mask_gt_oq(__mmask8 m, __m256 a, __m256 b) {378 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_gt_oq379 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 30, <8 x i1> {{.*}})380 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_GT_OQ);381}382 383__mmask8 test_mm256_mask_cmp_ps_mask_true_us(__mmask8 m, __m256 a, __m256 b) {384 // CHECK-LABEL: test_mm256_mask_cmp_ps_mask_true_us385 // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i32 31, <8 x i1> {{.*}})386 return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_TRUE_US);387}388 389__mmask8 test_mm256_cmp_pd_mask_eq_oq(__m256d a, __m256d b) {390 // CHECK-LABEL: @test_mm256_cmp_pd_mask_eq_oq391 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 0, <4 x i1> {{.*}})392 return _mm256_cmp_pd_mask(a, b, _CMP_EQ_OQ);393}394 395__mmask8 test_mm256_cmp_pd_mask_lt_os(__m256d a, __m256d b) {396 // CHECK-LABEL: test_mm256_cmp_pd_mask_lt_os397 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 1, <4 x i1> {{.*}})398 return _mm256_cmp_pd_mask(a, b, _CMP_LT_OS);399}400 401__mmask8 test_mm256_cmp_pd_mask_le_os(__m256d a, __m256d b) {402 // CHECK-LABEL: test_mm256_cmp_pd_mask_le_os403 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 2, <4 x i1> {{.*}})404 return _mm256_cmp_pd_mask(a, b, _CMP_LE_OS);405}406 407__mmask8 test_mm256_cmp_pd_mask_unord_q(__m256d a, __m256d b) {408 // CHECK-LABEL: test_mm256_cmp_pd_mask_unord_q409 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 3, <4 x i1> {{.*}})410 return _mm256_cmp_pd_mask(a, b, _CMP_UNORD_Q);411}412 413__mmask8 test_mm256_cmp_pd_mask_neq_uq(__m256d a, __m256d b) {414 // CHECK-LABEL: test_mm256_cmp_pd_mask_neq_uq415 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 4, <4 x i1> {{.*}})416 return _mm256_cmp_pd_mask(a, b, _CMP_NEQ_UQ);417}418 419__mmask8 test_mm256_cmp_pd_mask_nlt_us(__m256d a, __m256d b) {420 // CHECK-LABEL: test_mm256_cmp_pd_mask_nlt_us421 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 5, <4 x i1> {{.*}})422 return _mm256_cmp_pd_mask(a, b, _CMP_NLT_US);423}424 425__mmask8 test_mm256_cmp_pd_mask_nle_us(__m256d a, __m256d b) {426 // CHECK-LABEL: test_mm256_cmp_pd_mask_nle_us427 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 6, <4 x i1> {{.*}})428 return _mm256_cmp_pd_mask(a, b, _CMP_NLE_US);429}430 431__mmask8 test_mm256_cmp_pd_mask_ord_q(__m256d a, __m256d b) {432 // CHECK-LABEL: test_mm256_cmp_pd_mask_ord_q433 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 7, <4 x i1> {{.*}})434 return _mm256_cmp_pd_mask(a, b, _CMP_ORD_Q);435}436 437__mmask8 test_mm256_cmp_pd_mask_eq_uq(__m256d a, __m256d b) {438 // CHECK-LABEL: test_mm256_cmp_pd_mask_eq_uq439 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 8, <4 x i1> {{.*}})440 return _mm256_cmp_pd_mask(a, b, _CMP_EQ_UQ);441}442 443__mmask8 test_mm256_cmp_pd_mask_nge_us(__m256d a, __m256d b) {444 // CHECK-LABEL: test_mm256_cmp_pd_mask_nge_us445 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 9, <4 x i1> {{.*}})446 return _mm256_cmp_pd_mask(a, b, _CMP_NGE_US);447}448 449__mmask8 test_mm256_cmp_pd_mask_ngt_us(__m256d a, __m256d b) {450 // CHECK-LABEL: test_mm256_cmp_pd_mask_ngt_us451 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 10, <4 x i1> {{.*}})452 return _mm256_cmp_pd_mask(a, b, _CMP_NGT_US);453}454 455__mmask8 test_mm256_cmp_pd_mask_false_oq(__m256d a, __m256d b) {456 // CHECK-LABEL: test_mm256_cmp_pd_mask_false_oq457 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 11, <4 x i1> {{.*}})458 return _mm256_cmp_pd_mask(a, b, _CMP_FALSE_OQ);459}460 461__mmask8 test_mm256_cmp_pd_mask_neq_oq(__m256d a, __m256d b) {462 // CHECK-LABEL: test_mm256_cmp_pd_mask_neq_oq463 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 12, <4 x i1> {{.*}})464 return _mm256_cmp_pd_mask(a, b, _CMP_NEQ_OQ);465}466 467__mmask8 test_mm256_cmp_pd_mask_ge_os(__m256d a, __m256d b) {468 // CHECK-LABEL: test_mm256_cmp_pd_mask_ge_os469 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 13, <4 x i1> {{.*}})470 return _mm256_cmp_pd_mask(a, b, _CMP_GE_OS);471}472 473__mmask8 test_mm256_cmp_pd_mask_gt_os(__m256d a, __m256d b) {474 // CHECK-LABEL: test_mm256_cmp_pd_mask_gt_os475 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 14, <4 x i1> {{.*}})476 return _mm256_cmp_pd_mask(a, b, _CMP_GT_OS);477}478 479__mmask8 test_mm256_cmp_pd_mask_true_uq(__m256d a, __m256d b) {480 // CHECK-LABEL: test_mm256_cmp_pd_mask_true_uq481 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 15, <4 x i1> {{.*}})482 return _mm256_cmp_pd_mask(a, b, _CMP_TRUE_UQ);483}484 485__mmask8 test_mm256_cmp_pd_mask_eq_os(__m256d a, __m256d b) {486 // CHECK-LABEL: test_mm256_cmp_pd_mask_eq_os487 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 16, <4 x i1> {{.*}})488 return _mm256_cmp_pd_mask(a, b, _CMP_EQ_OS);489}490 491__mmask8 test_mm256_cmp_pd_mask_lt_oq(__m256d a, __m256d b) {492 // CHECK-LABEL: test_mm256_cmp_pd_mask_lt_oq493 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 17, <4 x i1> {{.*}})494 return _mm256_cmp_pd_mask(a, b, _CMP_LT_OQ);495}496 497__mmask8 test_mm256_cmp_pd_mask_le_oq(__m256d a, __m256d b) {498 // CHECK-LABEL: test_mm256_cmp_pd_mask_le_oq499 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 18, <4 x i1> {{.*}})500 return _mm256_cmp_pd_mask(a, b, _CMP_LE_OQ);501}502 503__mmask8 test_mm256_cmp_pd_mask_unord_s(__m256d a, __m256d b) {504 // CHECK-LABEL: test_mm256_cmp_pd_mask_unord_s505 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 19, <4 x i1> {{.*}})506 return _mm256_cmp_pd_mask(a, b, _CMP_UNORD_S);507}508 509__mmask8 test_mm256_cmp_pd_mask_neq_us(__m256d a, __m256d b) {510 // CHECK-LABEL: test_mm256_cmp_pd_mask_neq_us511 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 20, <4 x i1> {{.*}})512 return _mm256_cmp_pd_mask(a, b, _CMP_NEQ_US);513}514 515__mmask8 test_mm256_cmp_pd_mask_nlt_uq(__m256d a, __m256d b) {516 // CHECK-LABEL: test_mm256_cmp_pd_mask_nlt_uq517 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 21, <4 x i1> {{.*}})518 return _mm256_cmp_pd_mask(a, b, _CMP_NLT_UQ);519}520 521__mmask8 test_mm256_cmp_pd_mask_nle_uq(__m256d a, __m256d b) {522 // CHECK-LABEL: test_mm256_cmp_pd_mask_nle_uq523 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 22, <4 x i1> {{.*}})524 return _mm256_cmp_pd_mask(a, b, _CMP_NLE_UQ);525}526 527__mmask8 test_mm256_cmp_pd_mask_ord_s(__m256d a, __m256d b) {528 // CHECK-LABEL: test_mm256_cmp_pd_mask_ord_s529 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 23, <4 x i1> {{.*}})530 return _mm256_cmp_pd_mask(a, b, _CMP_ORD_S);531}532 533__mmask8 test_mm256_cmp_pd_mask_eq_us(__m256d a, __m256d b) {534 // CHECK-LABEL: test_mm256_cmp_pd_mask_eq_us535 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 24, <4 x i1> {{.*}})536 return _mm256_cmp_pd_mask(a, b, _CMP_EQ_US);537}538 539__mmask8 test_mm256_cmp_pd_mask_nge_uq(__m256d a, __m256d b) {540 // CHECK-LABEL: test_mm256_cmp_pd_mask_nge_uq541 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 25, <4 x i1> {{.*}})542 return _mm256_cmp_pd_mask(a, b, _CMP_NGE_UQ);543}544 545__mmask8 test_mm256_cmp_pd_mask_ngt_uq(__m256d a, __m256d b) {546 // CHECK-LABEL: test_mm256_cmp_pd_mask_ngt_uq547 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 26, <4 x i1> {{.*}})548 return _mm256_cmp_pd_mask(a, b, _CMP_NGT_UQ);549}550 551__mmask8 test_mm256_cmp_pd_mask_false_os(__m256d a, __m256d b) {552 // CHECK-LABEL: test_mm256_cmp_pd_mask_false_os553 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 27, <4 x i1> {{.*}})554 return _mm256_cmp_pd_mask(a, b, _CMP_FALSE_OS);555}556 557__mmask8 test_mm256_cmp_pd_mask_neq_os(__m256d a, __m256d b) {558 // CHECK-LABEL: test_mm256_cmp_pd_mask_neq_os559 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 28, <4 x i1> {{.*}})560 return _mm256_cmp_pd_mask(a, b, _CMP_NEQ_OS);561}562 563__mmask8 test_mm256_cmp_pd_mask_ge_oq(__m256d a, __m256d b) {564 // CHECK-LABEL: test_mm256_cmp_pd_mask_ge_oq565 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 29, <4 x i1> {{.*}})566 return _mm256_cmp_pd_mask(a, b, _CMP_GE_OQ);567}568 569__mmask8 test_mm256_cmp_pd_mask_gt_oq(__m256d a, __m256d b) {570 // CHECK-LABEL: test_mm256_cmp_pd_mask_gt_oq571 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 30, <4 x i1> {{.*}})572 return _mm256_cmp_pd_mask(a, b, _CMP_GT_OQ);573}574 575__mmask8 test_mm256_cmp_pd_mask_true_us(__m256d a, __m256d b) {576 // CHECK-LABEL: test_mm256_cmp_pd_mask_true_us577 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 31, <4 x i1> {{.*}})578 return _mm256_cmp_pd_mask(a, b, _CMP_TRUE_US);579}580 581__mmask8 test_mm256_mask_cmp_pd_mask_eq_oq(__mmask8 m, __m256d a, __m256d b) {582 // CHECK-LABEL: @test_mm256_mask_cmp_pd_mask_eq_oq583 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 0, <4 x i1> {{.*}})584 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_EQ_OQ);585}586 587__mmask8 test_mm256_mask_cmp_pd_mask_lt_os(__mmask8 m, __m256d a, __m256d b) {588 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_lt_os589 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 1, <4 x i1> {{.*}})590 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_LT_OS);591}592 593__mmask8 test_mm256_mask_cmp_pd_mask_le_os(__mmask8 m, __m256d a, __m256d b) {594 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_le_os595 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 2, <4 x i1> {{.*}})596 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_LE_OS);597}598 599__mmask8 test_mm256_mask_cmp_pd_mask_unord_q(__mmask8 m, __m256d a, __m256d b) {600 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_unord_q601 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 3, <4 x i1> {{.*}})602 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_UNORD_Q);603}604 605__mmask8 test_mm256_mask_cmp_pd_mask_neq_uq(__mmask8 m, __m256d a, __m256d b) {606 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_neq_uq607 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 4, <4 x i1> {{.*}})608 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_UQ);609}610 611__mmask8 test_mm256_mask_cmp_pd_mask_nlt_us(__mmask8 m, __m256d a, __m256d b) {612 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_nlt_us613 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 5, <4 x i1> {{.*}})614 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NLT_US);615}616 617__mmask8 test_mm256_mask_cmp_pd_mask_nle_us(__mmask8 m, __m256d a, __m256d b) {618 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_nle_us619 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 6, <4 x i1> {{.*}})620 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NLE_US);621}622 623__mmask8 test_mm256_mask_cmp_pd_mask_ord_q(__mmask8 m, __m256d a, __m256d b) {624 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_ord_q625 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 7, <4 x i1> {{.*}})626 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_ORD_Q);627}628 629__mmask8 test_mm256_mask_cmp_pd_mask_eq_uq(__mmask8 m, __m256d a, __m256d b) {630 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_eq_uq631 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 8, <4 x i1> {{.*}})632 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_EQ_UQ);633}634 635__mmask8 test_mm256_mask_cmp_pd_mask_nge_us(__mmask8 m, __m256d a, __m256d b) {636 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_nge_us637 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 9, <4 x i1> {{.*}})638 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NGE_US);639}640 641__mmask8 test_mm256_mask_cmp_pd_mask_ngt_us(__mmask8 m, __m256d a, __m256d b) {642 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_ngt_us643 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 10, <4 x i1> {{.*}})644 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NGT_US);645}646 647__mmask8 test_mm256_mask_cmp_pd_mask_false_oq(__mmask8 m, __m256d a, __m256d b) {648 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_false_oq649 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 11, <4 x i1> {{.*}})650 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_FALSE_OQ);651}652 653__mmask8 test_mm256_mask_cmp_pd_mask_neq_oq(__mmask8 m, __m256d a, __m256d b) {654 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_neq_oq655 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 12, <4 x i1> {{.*}})656 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_OQ);657}658 659__mmask8 test_mm256_mask_cmp_pd_mask_ge_os(__mmask8 m, __m256d a, __m256d b) {660 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_ge_os661 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 13, <4 x i1> {{.*}})662 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_GE_OS);663}664 665__mmask8 test_mm256_mask_cmp_pd_mask_gt_os(__mmask8 m, __m256d a, __m256d b) {666 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_gt_os667 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 14, <4 x i1> {{.*}})668 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_GT_OS);669}670 671__mmask8 test_mm256_mask_cmp_pd_mask_true_uq(__mmask8 m, __m256d a, __m256d b) {672 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_true_uq673 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 15, <4 x i1> {{.*}})674 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_TRUE_UQ);675}676 677__mmask8 test_mm256_mask_cmp_pd_mask_eq_os(__mmask8 m, __m256d a, __m256d b) {678 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_eq_os679 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 16, <4 x i1> {{.*}})680 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_EQ_OS);681}682 683__mmask8 test_mm256_mask_cmp_pd_mask_lt_oq(__mmask8 m, __m256d a, __m256d b) {684 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_lt_oq685 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 17, <4 x i1> {{.*}})686 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_LT_OQ);687}688 689__mmask8 test_mm256_mask_cmp_pd_mask_le_oq(__mmask8 m, __m256d a, __m256d b) {690 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_le_oq691 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 18, <4 x i1> {{.*}})692 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_LE_OQ);693}694 695__mmask8 test_mm256_mask_cmp_pd_mask_unord_s(__mmask8 m, __m256d a, __m256d b) {696 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_unord_s697 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 19, <4 x i1> {{.*}})698 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_UNORD_S);699}700 701__mmask8 test_mm256_mask_cmp_pd_mask_neq_us(__mmask8 m, __m256d a, __m256d b) {702 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_neq_us703 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 20, <4 x i1> {{.*}})704 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_US);705}706 707__mmask8 test_mm256_mask_cmp_pd_mask_nlt_uq(__mmask8 m, __m256d a, __m256d b) {708 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_nlt_uq709 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 21, <4 x i1> {{.*}})710 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NLT_UQ);711}712 713__mmask8 test_mm256_mask_cmp_pd_mask_nle_uq(__mmask8 m, __m256d a, __m256d b) {714 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_nle_uq715 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 22, <4 x i1> {{.*}})716 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NLE_UQ);717}718 719__mmask8 test_mm256_mask_cmp_pd_mask_ord_s(__mmask8 m, __m256d a, __m256d b) {720 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_ord_s721 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 23, <4 x i1> {{.*}})722 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_ORD_S);723}724 725__mmask8 test_mm256_mask_cmp_pd_mask_eq_us(__mmask8 m, __m256d a, __m256d b) {726 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_eq_us727 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 24, <4 x i1> {{.*}})728 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_EQ_US);729}730 731__mmask8 test_mm256_mask_cmp_pd_mask_nge_uq(__mmask8 m, __m256d a, __m256d b) {732 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_nge_uq733 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 25, <4 x i1> {{.*}})734 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NGE_UQ);735}736 737__mmask8 test_mm256_mask_cmp_pd_mask_ngt_uq(__mmask8 m, __m256d a, __m256d b) {738 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_ngt_uq739 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 26, <4 x i1> {{.*}})740 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NGT_UQ);741}742 743__mmask8 test_mm256_mask_cmp_pd_mask_false_os(__mmask8 m, __m256d a, __m256d b) {744 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_false_os745 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 27, <4 x i1> {{.*}})746 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_FALSE_OS);747}748 749__mmask8 test_mm256_mask_cmp_pd_mask_neq_os(__mmask8 m, __m256d a, __m256d b) {750 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_neq_os751 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 28, <4 x i1> {{.*}})752 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_OS);753}754 755__mmask8 test_mm256_mask_cmp_pd_mask_ge_oq(__mmask8 m, __m256d a, __m256d b) {756 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_ge_oq757 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 29, <4 x i1> {{.*}})758 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_GE_OQ);759}760 761__mmask8 test_mm256_mask_cmp_pd_mask_gt_oq(__mmask8 m, __m256d a, __m256d b) {762 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_gt_oq763 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 30, <4 x i1> {{.*}})764 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_GT_OQ);765}766 767__mmask8 test_mm256_mask_cmp_pd_mask_true_us(__mmask8 m, __m256d a, __m256d b) {768 // CHECK-LABEL: test_mm256_mask_cmp_pd_mask_true_us769 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i32 31, <4 x i1> {{.*}})770 return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_TRUE_US);771}772 773__mmask8 test_mm_cmp_ps_mask_eq_oq(__m128 a, __m128 b) {774 // CHECK-LABEL: @test_mm_cmp_ps_mask_eq_oq775 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 0, <4 x i1> {{.*}})776 return _mm_cmp_ps_mask(a, b, _CMP_EQ_OQ);777}778 779__mmask8 test_mm_cmp_ps_mask_lt_os(__m128 a, __m128 b) {780 // CHECK-LABEL: test_mm_cmp_ps_mask_lt_os781 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 1, <4 x i1> {{.*}})782 return _mm_cmp_ps_mask(a, b, _CMP_LT_OS);783}784 785__mmask8 test_mm_cmp_ps_mask_le_os(__m128 a, __m128 b) {786 // CHECK-LABEL: test_mm_cmp_ps_mask_le_os787 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 2, <4 x i1> {{.*}})788 return _mm_cmp_ps_mask(a, b, _CMP_LE_OS);789}790 791__mmask8 test_mm_cmp_ps_mask_unord_q(__m128 a, __m128 b) {792 // CHECK-LABEL: test_mm_cmp_ps_mask_unord_q793 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 3, <4 x i1> {{.*}})794 return _mm_cmp_ps_mask(a, b, _CMP_UNORD_Q);795}796 797__mmask8 test_mm_cmp_ps_mask_neq_uq(__m128 a, __m128 b) {798 // CHECK-LABEL: test_mm_cmp_ps_mask_neq_uq799 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 4, <4 x i1> {{.*}})800 return _mm_cmp_ps_mask(a, b, _CMP_NEQ_UQ);801}802 803__mmask8 test_mm_cmp_ps_mask_nlt_us(__m128 a, __m128 b) {804 // CHECK-LABEL: test_mm_cmp_ps_mask_nlt_us805 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 5, <4 x i1> {{.*}})806 return _mm_cmp_ps_mask(a, b, _CMP_NLT_US);807}808 809__mmask8 test_mm_cmp_ps_mask_nle_us(__m128 a, __m128 b) {810 // CHECK-LABEL: test_mm_cmp_ps_mask_nle_us811 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 6, <4 x i1> {{.*}})812 return _mm_cmp_ps_mask(a, b, _CMP_NLE_US);813}814 815__mmask8 test_mm_cmp_ps_mask_ord_q(__m128 a, __m128 b) {816 // CHECK-LABEL: test_mm_cmp_ps_mask_ord_q817 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 7, <4 x i1> {{.*}})818 return _mm_cmp_ps_mask(a, b, _CMP_ORD_Q);819}820 821__mmask8 test_mm_cmp_ps_mask_eq_uq(__m128 a, __m128 b) {822 // CHECK-LABEL: test_mm_cmp_ps_mask_eq_uq823 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 8, <4 x i1> {{.*}})824 return _mm_cmp_ps_mask(a, b, _CMP_EQ_UQ);825}826 827__mmask8 test_mm_cmp_ps_mask_nge_us(__m128 a, __m128 b) {828 // CHECK-LABEL: test_mm_cmp_ps_mask_nge_us829 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 9, <4 x i1> {{.*}})830 return _mm_cmp_ps_mask(a, b, _CMP_NGE_US);831}832 833__mmask8 test_mm_cmp_ps_mask_ngt_us(__m128 a, __m128 b) {834 // CHECK-LABEL: test_mm_cmp_ps_mask_ngt_us835 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 10, <4 x i1> {{.*}})836 return _mm_cmp_ps_mask(a, b, _CMP_NGT_US);837}838 839__mmask8 test_mm_cmp_ps_mask_false_oq(__m128 a, __m128 b) {840 // CHECK-LABEL: test_mm_cmp_ps_mask_false_oq841 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 11, <4 x i1> {{.*}})842 return _mm_cmp_ps_mask(a, b, _CMP_FALSE_OQ);843}844 845__mmask8 test_mm_cmp_ps_mask_neq_oq(__m128 a, __m128 b) {846 // CHECK-LABEL: test_mm_cmp_ps_mask_neq_oq847 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 12, <4 x i1> {{.*}})848 return _mm_cmp_ps_mask(a, b, _CMP_NEQ_OQ);849}850 851__mmask8 test_mm_cmp_ps_mask_ge_os(__m128 a, __m128 b) {852 // CHECK-LABEL: test_mm_cmp_ps_mask_ge_os853 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 13, <4 x i1> {{.*}})854 return _mm_cmp_ps_mask(a, b, _CMP_GE_OS);855}856 857__mmask8 test_mm_cmp_ps_mask_gt_os(__m128 a, __m128 b) {858 // CHECK-LABEL: test_mm_cmp_ps_mask_gt_os859 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 14, <4 x i1> {{.*}})860 return _mm_cmp_ps_mask(a, b, _CMP_GT_OS);861}862 863__mmask8 test_mm_cmp_ps_mask_true_uq(__m128 a, __m128 b) {864 // CHECK-LABEL: test_mm_cmp_ps_mask_true_uq865 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 15, <4 x i1> {{.*}})866 return _mm_cmp_ps_mask(a, b, _CMP_TRUE_UQ);867}868 869__mmask8 test_mm_cmp_ps_mask_eq_os(__m128 a, __m128 b) {870 // CHECK-LABEL: test_mm_cmp_ps_mask_eq_os871 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 16, <4 x i1> {{.*}})872 return _mm_cmp_ps_mask(a, b, _CMP_EQ_OS);873}874 875__mmask8 test_mm_cmp_ps_mask_lt_oq(__m128 a, __m128 b) {876 // CHECK-LABEL: test_mm_cmp_ps_mask_lt_oq877 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 17, <4 x i1> {{.*}})878 return _mm_cmp_ps_mask(a, b, _CMP_LT_OQ);879}880 881__mmask8 test_mm_cmp_ps_mask_le_oq(__m128 a, __m128 b) {882 // CHECK-LABEL: test_mm_cmp_ps_mask_le_oq883 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 18, <4 x i1> {{.*}})884 return _mm_cmp_ps_mask(a, b, _CMP_LE_OQ);885}886 887__mmask8 test_mm_cmp_ps_mask_unord_s(__m128 a, __m128 b) {888 // CHECK-LABEL: test_mm_cmp_ps_mask_unord_s889 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 19, <4 x i1> {{.*}})890 return _mm_cmp_ps_mask(a, b, _CMP_UNORD_S);891}892 893__mmask8 test_mm_cmp_ps_mask_neq_us(__m128 a, __m128 b) {894 // CHECK-LABEL: test_mm_cmp_ps_mask_neq_us895 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 20, <4 x i1> {{.*}})896 return _mm_cmp_ps_mask(a, b, _CMP_NEQ_US);897}898 899__mmask8 test_mm_cmp_ps_mask_nlt_uq(__m128 a, __m128 b) {900 // CHECK-LABEL: test_mm_cmp_ps_mask_nlt_uq901 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 21, <4 x i1> {{.*}})902 return _mm_cmp_ps_mask(a, b, _CMP_NLT_UQ);903}904 905__mmask8 test_mm_cmp_ps_mask_nle_uq(__m128 a, __m128 b) {906 // CHECK-LABEL: test_mm_cmp_ps_mask_nle_uq907 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 22, <4 x i1> {{.*}})908 return _mm_cmp_ps_mask(a, b, _CMP_NLE_UQ);909}910 911__mmask8 test_mm_cmp_ps_mask_ord_s(__m128 a, __m128 b) {912 // CHECK-LABEL: test_mm_cmp_ps_mask_ord_s913 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 23, <4 x i1> {{.*}})914 return _mm_cmp_ps_mask(a, b, _CMP_ORD_S);915}916 917__mmask8 test_mm_cmp_ps_mask_eq_us(__m128 a, __m128 b) {918 // CHECK-LABEL: test_mm_cmp_ps_mask_eq_us919 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 24, <4 x i1> {{.*}})920 return _mm_cmp_ps_mask(a, b, _CMP_EQ_US);921}922 923__mmask8 test_mm_cmp_ps_mask_nge_uq(__m128 a, __m128 b) {924 // CHECK-LABEL: test_mm_cmp_ps_mask_nge_uq925 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 25, <4 x i1> {{.*}})926 return _mm_cmp_ps_mask(a, b, _CMP_NGE_UQ);927}928 929__mmask8 test_mm_cmp_ps_mask_ngt_uq(__m128 a, __m128 b) {930 // CHECK-LABEL: test_mm_cmp_ps_mask_ngt_uq931 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 26, <4 x i1> {{.*}})932 return _mm_cmp_ps_mask(a, b, _CMP_NGT_UQ);933}934 935__mmask8 test_mm_cmp_ps_mask_false_os(__m128 a, __m128 b) {936 // CHECK-LABEL: test_mm_cmp_ps_mask_false_os937 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 27, <4 x i1> {{.*}})938 return _mm_cmp_ps_mask(a, b, _CMP_FALSE_OS);939}940 941__mmask8 test_mm_cmp_ps_mask_neq_os(__m128 a, __m128 b) {942 // CHECK-LABEL: test_mm_cmp_ps_mask_neq_os943 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 28, <4 x i1> {{.*}})944 return _mm_cmp_ps_mask(a, b, _CMP_NEQ_OS);945}946 947__mmask8 test_mm_cmp_ps_mask_ge_oq(__m128 a, __m128 b) {948 // CHECK-LABEL: test_mm_cmp_ps_mask_ge_oq949 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 29, <4 x i1> {{.*}})950 return _mm_cmp_ps_mask(a, b, _CMP_GE_OQ);951}952 953__mmask8 test_mm_cmp_ps_mask_gt_oq(__m128 a, __m128 b) {954 // CHECK-LABEL: test_mm_cmp_ps_mask_gt_oq955 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 30, <4 x i1> {{.*}})956 return _mm_cmp_ps_mask(a, b, _CMP_GT_OQ);957}958 959__mmask8 test_mm_cmp_ps_mask_true_us(__m128 a, __m128 b) {960 // CHECK-LABEL: test_mm_cmp_ps_mask_true_us961 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 31, <4 x i1> {{.*}})962 return _mm_cmp_ps_mask(a, b, _CMP_TRUE_US);963}964 965__mmask8 test_mm_mask_cmp_ps_mask_eq_oq(__mmask8 m, __m128 a, __m128 b) {966 // CHECK-LABEL: @test_mm_mask_cmp_ps_mask_eq_oq967 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 0, <4 x i1> {{.*}})968 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_EQ_OQ);969}970 971__mmask8 test_mm_mask_cmp_ps_mask_lt_os(__mmask8 m, __m128 a, __m128 b) {972 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_lt_os973 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 1, <4 x i1> {{.*}})974 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_LT_OS);975}976 977__mmask8 test_mm_mask_cmp_ps_mask_le_os(__mmask8 m, __m128 a, __m128 b) {978 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_le_os979 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 2, <4 x i1> {{.*}})980 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_LE_OS);981}982 983__mmask8 test_mm_mask_cmp_ps_mask_unord_q(__mmask8 m, __m128 a, __m128 b) {984 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_unord_q985 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 3, <4 x i1> {{.*}})986 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_UNORD_Q);987}988 989__mmask8 test_mm_mask_cmp_ps_mask_neq_uq(__mmask8 m, __m128 a, __m128 b) {990 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_neq_uq991 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 4, <4 x i1> {{.*}})992 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_UQ);993}994 995__mmask8 test_mm_mask_cmp_ps_mask_nlt_us(__mmask8 m, __m128 a, __m128 b) {996 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_nlt_us997 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 5, <4 x i1> {{.*}})998 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NLT_US);999}1000 1001__mmask8 test_mm_mask_cmp_ps_mask_nle_us(__mmask8 m, __m128 a, __m128 b) {1002 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_nle_us1003 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 6, <4 x i1> {{.*}})1004 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NLE_US);1005}1006 1007__mmask8 test_mm_mask_cmp_ps_mask_ord_q(__mmask8 m, __m128 a, __m128 b) {1008 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_ord_q1009 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 7, <4 x i1> {{.*}})1010 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_ORD_Q);1011}1012 1013__mmask8 test_mm_mask_cmp_ps_mask_eq_uq(__mmask8 m, __m128 a, __m128 b) {1014 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_eq_uq1015 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 8, <4 x i1> {{.*}})1016 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_EQ_UQ);1017}1018 1019__mmask8 test_mm_mask_cmp_ps_mask_nge_us(__mmask8 m, __m128 a, __m128 b) {1020 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_nge_us1021 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 9, <4 x i1> {{.*}})1022 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NGE_US);1023}1024 1025__mmask8 test_mm_mask_cmp_ps_mask_ngt_us(__mmask8 m, __m128 a, __m128 b) {1026 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_ngt_us1027 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 10, <4 x i1> {{.*}})1028 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NGT_US);1029}1030 1031__mmask8 test_mm_mask_cmp_ps_mask_false_oq(__mmask8 m, __m128 a, __m128 b) {1032 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_false_oq1033 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 11, <4 x i1> {{.*}})1034 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_FALSE_OQ);1035}1036 1037__mmask8 test_mm_mask_cmp_ps_mask_neq_oq(__mmask8 m, __m128 a, __m128 b) {1038 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_neq_oq1039 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 12, <4 x i1> {{.*}})1040 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_OQ);1041}1042 1043__mmask8 test_mm_mask_cmp_ps_mask_ge_os(__mmask8 m, __m128 a, __m128 b) {1044 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_ge_os1045 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 13, <4 x i1> {{.*}})1046 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_GE_OS);1047}1048 1049__mmask8 test_mm_mask_cmp_ps_mask_gt_os(__mmask8 m, __m128 a, __m128 b) {1050 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_gt_os1051 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 14, <4 x i1> {{.*}})1052 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_GT_OS);1053}1054 1055__mmask8 test_mm_mask_cmp_ps_mask_true_uq(__mmask8 m, __m128 a, __m128 b) {1056 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_true_uq1057 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 15, <4 x i1> {{.*}})1058 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_TRUE_UQ);1059}1060 1061__mmask8 test_mm_mask_cmp_ps_mask_eq_os(__mmask8 m, __m128 a, __m128 b) {1062 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_eq_os1063 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 16, <4 x i1> {{.*}})1064 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_EQ_OS);1065}1066 1067__mmask8 test_mm_mask_cmp_ps_mask_lt_oq(__mmask8 m, __m128 a, __m128 b) {1068 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_lt_oq1069 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 17, <4 x i1> {{.*}})1070 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_LT_OQ);1071}1072 1073__mmask8 test_mm_mask_cmp_ps_mask_le_oq(__mmask8 m, __m128 a, __m128 b) {1074 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_le_oq1075 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 18, <4 x i1> {{.*}})1076 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_LE_OQ);1077}1078 1079__mmask8 test_mm_mask_cmp_ps_mask_unord_s(__mmask8 m, __m128 a, __m128 b) {1080 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_unord_s1081 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 19, <4 x i1> {{.*}})1082 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_UNORD_S);1083}1084 1085__mmask8 test_mm_mask_cmp_ps_mask_neq_us(__mmask8 m, __m128 a, __m128 b) {1086 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_neq_us1087 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 20, <4 x i1> {{.*}})1088 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_US);1089}1090 1091__mmask8 test_mm_mask_cmp_ps_mask_nlt_uq(__mmask8 m, __m128 a, __m128 b) {1092 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_nlt_uq1093 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 21, <4 x i1> {{.*}})1094 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NLT_UQ);1095}1096 1097__mmask8 test_mm_mask_cmp_ps_mask_nle_uq(__mmask8 m, __m128 a, __m128 b) {1098 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_nle_uq1099 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 22, <4 x i1> {{.*}})1100 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NLE_UQ);1101}1102 1103__mmask8 test_mm_mask_cmp_ps_mask_ord_s(__mmask8 m, __m128 a, __m128 b) {1104 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_ord_s1105 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 23, <4 x i1> {{.*}})1106 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_ORD_S);1107}1108 1109__mmask8 test_mm_mask_cmp_ps_mask_eq_us(__mmask8 m, __m128 a, __m128 b) {1110 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_eq_us1111 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 24, <4 x i1> {{.*}})1112 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_EQ_US);1113}1114 1115__mmask8 test_mm_mask_cmp_ps_mask_nge_uq(__mmask8 m, __m128 a, __m128 b) {1116 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_nge_uq1117 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 25, <4 x i1> {{.*}})1118 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NGE_UQ);1119}1120 1121__mmask8 test_mm_mask_cmp_ps_mask_ngt_uq(__mmask8 m, __m128 a, __m128 b) {1122 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_ngt_uq1123 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 26, <4 x i1> {{.*}})1124 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NGT_UQ);1125}1126 1127__mmask8 test_mm_mask_cmp_ps_mask_false_os(__mmask8 m, __m128 a, __m128 b) {1128 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_false_os1129 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 27, <4 x i1> {{.*}})1130 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_FALSE_OS);1131}1132 1133__mmask8 test_mm_mask_cmp_ps_mask_neq_os(__mmask8 m, __m128 a, __m128 b) {1134 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_neq_os1135 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 28, <4 x i1> {{.*}})1136 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_OS);1137}1138 1139__mmask8 test_mm_mask_cmp_ps_mask_ge_oq(__mmask8 m, __m128 a, __m128 b) {1140 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_ge_oq1141 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 29, <4 x i1> {{.*}})1142 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_GE_OQ);1143}1144 1145__mmask8 test_mm_mask_cmp_ps_mask_gt_oq(__mmask8 m, __m128 a, __m128 b) {1146 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_gt_oq1147 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 30, <4 x i1> {{.*}})1148 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_GT_OQ);1149}1150 1151__mmask8 test_mm_mask_cmp_ps_mask_true_us(__mmask8 m, __m128 a, __m128 b) {1152 // CHECK-LABEL: test_mm_mask_cmp_ps_mask_true_us1153 // CHECK: call <4 x i1> @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i32 31, <4 x i1> {{.*}})1154 return _mm_mask_cmp_ps_mask(m, a, b, _CMP_TRUE_US);1155}1156 1157__mmask8 test_mm_cmp_pd_mask_eq_oq(__m128d a, __m128d b) {1158 // CHECK-LABEL: @test_mm_cmp_pd_mask_eq_oq1159 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 0, <2 x i1> {{.*}})1160 return _mm_cmp_pd_mask(a, b, _CMP_EQ_OQ);1161}1162 1163__mmask8 test_mm_cmp_pd_mask_lt_os(__m128d a, __m128d b) {1164 // CHECK-LABEL: test_mm_cmp_pd_mask_lt_os1165 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 1, <2 x i1> {{.*}})1166 return _mm_cmp_pd_mask(a, b, _CMP_LT_OS);1167}1168 1169__mmask8 test_mm_cmp_pd_mask_le_os(__m128d a, __m128d b) {1170 // CHECK-LABEL: test_mm_cmp_pd_mask_le_os1171 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 2, <2 x i1> {{.*}})1172 return _mm_cmp_pd_mask(a, b, _CMP_LE_OS);1173}1174 1175__mmask8 test_mm_cmp_pd_mask_unord_q(__m128d a, __m128d b) {1176 // CHECK-LABEL: test_mm_cmp_pd_mask_unord_q1177 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 3, <2 x i1> {{.*}})1178 return _mm_cmp_pd_mask(a, b, _CMP_UNORD_Q);1179}1180 1181__mmask8 test_mm_cmp_pd_mask_neq_uq(__m128d a, __m128d b) {1182 // CHECK-LABEL: test_mm_cmp_pd_mask_neq_uq1183 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 4, <2 x i1> {{.*}})1184 return _mm_cmp_pd_mask(a, b, _CMP_NEQ_UQ);1185}1186 1187__mmask8 test_mm_cmp_pd_mask_nlt_us(__m128d a, __m128d b) {1188 // CHECK-LABEL: test_mm_cmp_pd_mask_nlt_us1189 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 5, <2 x i1> {{.*}})1190 return _mm_cmp_pd_mask(a, b, _CMP_NLT_US);1191}1192 1193__mmask8 test_mm_cmp_pd_mask_nle_us(__m128d a, __m128d b) {1194 // CHECK-LABEL: test_mm_cmp_pd_mask_nle_us1195 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 6, <2 x i1> {{.*}})1196 return _mm_cmp_pd_mask(a, b, _CMP_NLE_US);1197}1198 1199__mmask8 test_mm_cmp_pd_mask_ord_q(__m128d a, __m128d b) {1200 // CHECK-LABEL: test_mm_cmp_pd_mask_ord_q1201 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 7, <2 x i1> {{.*}})1202 return _mm_cmp_pd_mask(a, b, _CMP_ORD_Q);1203}1204 1205__mmask8 test_mm_cmp_pd_mask_eq_uq(__m128d a, __m128d b) {1206 // CHECK-LABEL: test_mm_cmp_pd_mask_eq_uq1207 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 8, <2 x i1> {{.*}})1208 return _mm_cmp_pd_mask(a, b, _CMP_EQ_UQ);1209}1210 1211__mmask8 test_mm_cmp_pd_mask_nge_us(__m128d a, __m128d b) {1212 // CHECK-LABEL: test_mm_cmp_pd_mask_nge_us1213 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 9, <2 x i1> {{.*}})1214 return _mm_cmp_pd_mask(a, b, _CMP_NGE_US);1215}1216 1217__mmask8 test_mm_cmp_pd_mask_ngt_us(__m128d a, __m128d b) {1218 // CHECK-LABEL: test_mm_cmp_pd_mask_ngt_us1219 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 10, <2 x i1> {{.*}})1220 return _mm_cmp_pd_mask(a, b, _CMP_NGT_US);1221}1222 1223__mmask8 test_mm_cmp_pd_mask_false_oq(__m128d a, __m128d b) {1224 // CHECK-LABEL: test_mm_cmp_pd_mask_false_oq1225 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 11, <2 x i1> {{.*}})1226 return _mm_cmp_pd_mask(a, b, _CMP_FALSE_OQ);1227}1228 1229__mmask8 test_mm_cmp_pd_mask_neq_oq(__m128d a, __m128d b) {1230 // CHECK-LABEL: test_mm_cmp_pd_mask_neq_oq1231 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 12, <2 x i1> {{.*}})1232 return _mm_cmp_pd_mask(a, b, _CMP_NEQ_OQ);1233}1234 1235__mmask8 test_mm_cmp_pd_mask_ge_os(__m128d a, __m128d b) {1236 // CHECK-LABEL: test_mm_cmp_pd_mask_ge_os1237 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 13, <2 x i1> {{.*}})1238 return _mm_cmp_pd_mask(a, b, _CMP_GE_OS);1239}1240 1241__mmask8 test_mm_cmp_pd_mask_gt_os(__m128d a, __m128d b) {1242 // CHECK-LABEL: test_mm_cmp_pd_mask_gt_os1243 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 14, <2 x i1> {{.*}})1244 return _mm_cmp_pd_mask(a, b, _CMP_GT_OS);1245}1246 1247__mmask8 test_mm_cmp_pd_mask_true_uq(__m128d a, __m128d b) {1248 // CHECK-LABEL: test_mm_cmp_pd_mask_true_uq1249 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 15, <2 x i1> {{.*}})1250 return _mm_cmp_pd_mask(a, b, _CMP_TRUE_UQ);1251}1252 1253__mmask8 test_mm_cmp_pd_mask_eq_os(__m128d a, __m128d b) {1254 // CHECK-LABEL: test_mm_cmp_pd_mask_eq_os1255 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 16, <2 x i1> {{.*}})1256 return _mm_cmp_pd_mask(a, b, _CMP_EQ_OS);1257}1258 1259__mmask8 test_mm_cmp_pd_mask_lt_oq(__m128d a, __m128d b) {1260 // CHECK-LABEL: test_mm_cmp_pd_mask_lt_oq1261 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 17, <2 x i1> {{.*}})1262 return _mm_cmp_pd_mask(a, b, _CMP_LT_OQ);1263}1264 1265__mmask8 test_mm_cmp_pd_mask_le_oq(__m128d a, __m128d b) {1266 // CHECK-LABEL: test_mm_cmp_pd_mask_le_oq1267 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 18, <2 x i1> {{.*}})1268 return _mm_cmp_pd_mask(a, b, _CMP_LE_OQ);1269}1270 1271__mmask8 test_mm_cmp_pd_mask_unord_s(__m128d a, __m128d b) {1272 // CHECK-LABEL: test_mm_cmp_pd_mask_unord_s1273 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 19, <2 x i1> {{.*}})1274 return _mm_cmp_pd_mask(a, b, _CMP_UNORD_S);1275}1276 1277__mmask8 test_mm_cmp_pd_mask_neq_us(__m128d a, __m128d b) {1278 // CHECK-LABEL: test_mm_cmp_pd_mask_neq_us1279 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 20, <2 x i1> {{.*}})1280 return _mm_cmp_pd_mask(a, b, _CMP_NEQ_US);1281}1282 1283__mmask8 test_mm_cmp_pd_mask_nlt_uq(__m128d a, __m128d b) {1284 // CHECK-LABEL: test_mm_cmp_pd_mask_nlt_uq1285 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 21, <2 x i1> {{.*}})1286 return _mm_cmp_pd_mask(a, b, _CMP_NLT_UQ);1287}1288 1289__mmask8 test_mm_cmp_pd_mask_nle_uq(__m128d a, __m128d b) {1290 // CHECK-LABEL: test_mm_cmp_pd_mask_nle_uq1291 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 22, <2 x i1> {{.*}})1292 return _mm_cmp_pd_mask(a, b, _CMP_NLE_UQ);1293}1294 1295__mmask8 test_mm_cmp_pd_mask_ord_s(__m128d a, __m128d b) {1296 // CHECK-LABEL: test_mm_cmp_pd_mask_ord_s1297 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 23, <2 x i1> {{.*}})1298 return _mm_cmp_pd_mask(a, b, _CMP_ORD_S);1299}1300 1301__mmask8 test_mm_cmp_pd_mask_eq_us(__m128d a, __m128d b) {1302 // CHECK-LABEL: test_mm_cmp_pd_mask_eq_us1303 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 24, <2 x i1> {{.*}})1304 return _mm_cmp_pd_mask(a, b, _CMP_EQ_US);1305}1306 1307__mmask8 test_mm_cmp_pd_mask_nge_uq(__m128d a, __m128d b) {1308 // CHECK-LABEL: test_mm_cmp_pd_mask_nge_uq1309 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 25, <2 x i1> {{.*}})1310 return _mm_cmp_pd_mask(a, b, _CMP_NGE_UQ);1311}1312 1313__mmask8 test_mm_cmp_pd_mask_ngt_uq(__m128d a, __m128d b) {1314 // CHECK-LABEL: test_mm_cmp_pd_mask_ngt_uq1315 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 26, <2 x i1> {{.*}})1316 return _mm_cmp_pd_mask(a, b, _CMP_NGT_UQ);1317}1318 1319__mmask8 test_mm_cmp_pd_mask_false_os(__m128d a, __m128d b) {1320 // CHECK-LABEL: test_mm_cmp_pd_mask_false_os1321 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 27, <2 x i1> {{.*}})1322 return _mm_cmp_pd_mask(a, b, _CMP_FALSE_OS);1323}1324 1325__mmask8 test_mm_cmp_pd_mask_neq_os(__m128d a, __m128d b) {1326 // CHECK-LABEL: test_mm_cmp_pd_mask_neq_os1327 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 28, <2 x i1> {{.*}})1328 return _mm_cmp_pd_mask(a, b, _CMP_NEQ_OS);1329}1330 1331__mmask8 test_mm_cmp_pd_mask_ge_oq(__m128d a, __m128d b) {1332 // CHECK-LABEL: test_mm_cmp_pd_mask_ge_oq1333 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 29, <2 x i1> {{.*}})1334 return _mm_cmp_pd_mask(a, b, _CMP_GE_OQ);1335}1336 1337__mmask8 test_mm_cmp_pd_mask_gt_oq(__m128d a, __m128d b) {1338 // CHECK-LABEL: test_mm_cmp_pd_mask_gt_oq1339 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 30, <2 x i1> {{.*}})1340 return _mm_cmp_pd_mask(a, b, _CMP_GT_OQ);1341}1342 1343__mmask8 test_mm_cmp_pd_mask_true_us(__m128d a, __m128d b) {1344 // CHECK-LABEL: test_mm_cmp_pd_mask_true_us1345 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 31, <2 x i1> {{.*}})1346 return _mm_cmp_pd_mask(a, b, _CMP_TRUE_US);1347}1348 1349__mmask8 test_mm_mask_cmp_pd_mask_eq_oq(__mmask8 m, __m128d a, __m128d b) {1350 // CHECK-LABEL: @test_mm_mask_cmp_pd_mask_eq_oq1351 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 0, <2 x i1> {{.*}})1352 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_EQ_OQ);1353}1354 1355__mmask8 test_mm_mask_cmp_pd_mask_lt_os(__mmask8 m, __m128d a, __m128d b) {1356 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_lt_os1357 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 1, <2 x i1> {{.*}})1358 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_LT_OS);1359}1360 1361__mmask8 test_mm_mask_cmp_pd_mask_le_os(__mmask8 m, __m128d a, __m128d b) {1362 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_le_os1363 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 2, <2 x i1> {{.*}})1364 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_LE_OS);1365}1366 1367__mmask8 test_mm_mask_cmp_pd_mask_unord_q(__mmask8 m, __m128d a, __m128d b) {1368 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_unord_q1369 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 3, <2 x i1> {{.*}})1370 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_UNORD_Q);1371}1372 1373__mmask8 test_mm_mask_cmp_pd_mask_neq_uq(__mmask8 m, __m128d a, __m128d b) {1374 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_neq_uq1375 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 4, <2 x i1> {{.*}})1376 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_UQ);1377}1378 1379__mmask8 test_mm_mask_cmp_pd_mask_nlt_us(__mmask8 m, __m128d a, __m128d b) {1380 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_nlt_us1381 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 5, <2 x i1> {{.*}})1382 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NLT_US);1383}1384 1385__mmask8 test_mm_mask_cmp_pd_mask_nle_us(__mmask8 m, __m128d a, __m128d b) {1386 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_nle_us1387 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 6, <2 x i1> {{.*}})1388 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NLE_US);1389}1390 1391__mmask8 test_mm_mask_cmp_pd_mask_ord_q(__mmask8 m, __m128d a, __m128d b) {1392 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_ord_q1393 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 7, <2 x i1> {{.*}})1394 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_ORD_Q);1395}1396 1397__mmask8 test_mm_mask_cmp_pd_mask_eq_uq(__mmask8 m, __m128d a, __m128d b) {1398 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_eq_uq1399 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 8, <2 x i1> {{.*}})1400 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_EQ_UQ);1401}1402 1403__mmask8 test_mm_mask_cmp_pd_mask_nge_us(__mmask8 m, __m128d a, __m128d b) {1404 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_nge_us1405 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 9, <2 x i1> {{.*}})1406 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NGE_US);1407}1408 1409__mmask8 test_mm_mask_cmp_pd_mask_ngt_us(__mmask8 m, __m128d a, __m128d b) {1410 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_ngt_us1411 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 10, <2 x i1> {{.*}})1412 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NGT_US);1413}1414 1415__mmask8 test_mm_mask_cmp_pd_mask_false_oq(__mmask8 m, __m128d a, __m128d b) {1416 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_false_oq1417 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 11, <2 x i1> {{.*}})1418 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_FALSE_OQ);1419}1420 1421__mmask8 test_mm_mask_cmp_pd_mask_neq_oq(__mmask8 m, __m128d a, __m128d b) {1422 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_neq_oq1423 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 12, <2 x i1> {{.*}})1424 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_OQ);1425}1426 1427__mmask8 test_mm_mask_cmp_pd_mask_ge_os(__mmask8 m, __m128d a, __m128d b) {1428 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_ge_os1429 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 13, <2 x i1> {{.*}})1430 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_GE_OS);1431}1432 1433__mmask8 test_mm_mask_cmp_pd_mask_gt_os(__mmask8 m, __m128d a, __m128d b) {1434 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_gt_os1435 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 14, <2 x i1> {{.*}})1436 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_GT_OS);1437}1438 1439__mmask8 test_mm_mask_cmp_pd_mask_true_uq(__mmask8 m, __m128d a, __m128d b) {1440 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_true_uq1441 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 15, <2 x i1> {{.*}})1442 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_TRUE_UQ);1443}1444 1445__mmask8 test_mm_mask_cmp_pd_mask_eq_os(__mmask8 m, __m128d a, __m128d b) {1446 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_eq_os1447 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 16, <2 x i1> {{.*}})1448 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_EQ_OS);1449}1450 1451__mmask8 test_mm_mask_cmp_pd_mask_lt_oq(__mmask8 m, __m128d a, __m128d b) {1452 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_lt_oq1453 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 17, <2 x i1> {{.*}})1454 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_LT_OQ);1455}1456 1457__mmask8 test_mm_mask_cmp_pd_mask_le_oq(__mmask8 m, __m128d a, __m128d b) {1458 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_le_oq1459 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 18, <2 x i1> {{.*}})1460 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_LE_OQ);1461}1462 1463__mmask8 test_mm_mask_cmp_pd_mask_unord_s(__mmask8 m, __m128d a, __m128d b) {1464 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_unord_s1465 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 19, <2 x i1> {{.*}})1466 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_UNORD_S);1467}1468 1469__mmask8 test_mm_mask_cmp_pd_mask_neq_us(__mmask8 m, __m128d a, __m128d b) {1470 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_neq_us1471 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 20, <2 x i1> {{.*}})1472 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_US);1473}1474 1475__mmask8 test_mm_mask_cmp_pd_mask_nlt_uq(__mmask8 m, __m128d a, __m128d b) {1476 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_nlt_uq1477 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 21, <2 x i1> {{.*}})1478 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NLT_UQ);1479}1480 1481__mmask8 test_mm_mask_cmp_pd_mask_nle_uq(__mmask8 m, __m128d a, __m128d b) {1482 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_nle_uq1483 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 22, <2 x i1> {{.*}})1484 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NLE_UQ);1485}1486 1487__mmask8 test_mm_mask_cmp_pd_mask_ord_s(__mmask8 m, __m128d a, __m128d b) {1488 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_ord_s1489 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 23, <2 x i1> {{.*}})1490 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_ORD_S);1491}1492 1493__mmask8 test_mm_mask_cmp_pd_mask_eq_us(__mmask8 m, __m128d a, __m128d b) {1494 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_eq_us1495 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 24, <2 x i1> {{.*}})1496 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_EQ_US);1497}1498 1499__mmask8 test_mm_mask_cmp_pd_mask_nge_uq(__mmask8 m, __m128d a, __m128d b) {1500 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_nge_uq1501 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 25, <2 x i1> {{.*}})1502 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NGE_UQ);1503}1504 1505__mmask8 test_mm_mask_cmp_pd_mask_ngt_uq(__mmask8 m, __m128d a, __m128d b) {1506 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_ngt_uq1507 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 26, <2 x i1> {{.*}})1508 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NGT_UQ);1509}1510 1511__mmask8 test_mm_mask_cmp_pd_mask_false_os(__mmask8 m, __m128d a, __m128d b) {1512 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_false_os1513 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 27, <2 x i1> {{.*}})1514 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_FALSE_OS);1515}1516 1517__mmask8 test_mm_mask_cmp_pd_mask_neq_os(__mmask8 m, __m128d a, __m128d b) {1518 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_neq_os1519 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 28, <2 x i1> {{.*}})1520 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_OS);1521}1522 1523__mmask8 test_mm_mask_cmp_pd_mask_ge_oq(__mmask8 m, __m128d a, __m128d b) {1524 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_ge_oq1525 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 29, <2 x i1> {{.*}})1526 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_GE_OQ);1527}1528 1529__mmask8 test_mm_mask_cmp_pd_mask_gt_oq(__mmask8 m, __m128d a, __m128d b) {1530 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_gt_oq1531 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 30, <2 x i1> {{.*}})1532 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_GT_OQ);1533}1534 1535__mmask8 test_mm_mask_cmp_pd_mask_true_us(__mmask8 m, __m128d a, __m128d b) {1536 // CHECK-LABEL: test_mm_mask_cmp_pd_mask_true_us1537 // CHECK: call <2 x i1> @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i32 31, <2 x i1> {{.*}})1538 return _mm_mask_cmp_pd_mask(m, a, b, _CMP_TRUE_US);1539}1540