clang/test/CodeGen/X86/avx512vl-builtins-constrained-cmp.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 %s
   2
   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_oq
   7   // 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_os
  13   // 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_os
  19   // 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_q
  25   // 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_uq
  31   // 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_us
  37   // 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_us
  43   // 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_q
  49   // 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_uq
  55   // 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_us
  61   // 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_us
  67   // 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_oq
  73   // 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_oq
  79   // 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_os
  85   // 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_os
  91   // 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_uq
  97   // 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_os
 103   // 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_oq
 109   // 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_oq
 115   // 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_s
 121   // 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_us
 127   // 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_uq
 133   // 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_uq
 139   // 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_s
 145   // 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_us
 151   // 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_uq
 157   // 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_uq
 163   // 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_os
 169   // 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_os
 175   // 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_oq
 181   // 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_oq
 187   // 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_us
 193   // 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_oq
 199   // 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_os
 205   // 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_os
 211   // 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_q
 217   // 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_uq
 223   // 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_us
 229   // 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_us
 235   // 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_q
 241   // 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_uq
 247   // 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_us
 253   // 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_us
 259   // 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_oq
 265   // 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_oq
 271   // 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_os
 277   // 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_os
 283   // 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_uq
 289   // 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_os
 295   // 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_oq
 301   // 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_oq
 307   // 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_s
 313   // 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_us
 319   // 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_uq
 325   // 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_uq
 331   // 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_s
 337   // 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_us
 343   // 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_uq
 349   // 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_uq
 355   // 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_os
 361   // 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_os
 367   // 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_oq
 373   // 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_oq
 379   // 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_us
 385   // 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_oq
 391   // 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_os
 397   // 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_os
 403   // 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_q
 409   // 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_uq
 415   // 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_us
 421   // 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_us
 427   // 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_q
 433   // 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_uq
 439   // 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_us
 445   // 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_us
 451   // 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_oq
 457   // 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_oq
 463   // 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_os
 469   // 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_os
 475   // 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_uq
 481   // 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_os
 487   // 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_oq
 493   // 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_oq
 499   // 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_s
 505   // 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_us
 511   // 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_uq
 517   // 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_uq
 523   // 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_s
 529   // 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_us
 535   // 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_uq
 541   // 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_uq
 547   // 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_os
 553   // 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_os
 559   // 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_oq
 565   // 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_oq
 571   // 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_us
 577   // 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_oq
 583   // 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_os
 589   // 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_os
 595   // 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_q
 601   // 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_uq
 607   // 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_us
 613   // 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_us
 619   // 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_q
 625   // 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_uq
 631   // 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_us
 637   // 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_us
 643   // 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_oq
 649   // 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_oq
 655   // 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_os
 661   // 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_os
 667   // 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_uq
 673   // 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_os
 679   // 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_oq
 685   // 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_oq
 691   // 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_s
 697   // 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_us
 703   // 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_uq
 709   // 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_uq
 715   // 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_s
 721   // 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_us
 727   // 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_uq
 733   // 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_uq
 739   // 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_os
 745   // 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_os
 751   // 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_oq
 757   // 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_oq
 763   // 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_us
 769   // 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_oq
 775   // 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_os
 781   // 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_os
 787   // 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_q
 793   // 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_uq
 799   // 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_us
 805   // 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_us
 811   // 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_q
 817   // 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_uq
 823   // 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_us
 829   // 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_us
 835   // 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_oq
 841   // 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_oq
 847   // 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_os
 853   // 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_os
 859   // 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_uq
 865   // 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_os
 871   // 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_oq
 877   // 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_oq
 883   // 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_s
 889   // 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_us
 895   // 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_uq
 901   // 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_uq
 907   // 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_s
 913   // 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_us
 919   // 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_uq
 925   // 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_uq
 931   // 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_os
 937   // 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_os
 943   // 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_oq
 949   // 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_oq
 955   // 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_us
 961   // 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_oq
 967   // 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_os
 973   // 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_os
 979   // 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_q
 985   // 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_uq
 991   // 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_us
 997   // 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_us
1003   // 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_q
1009   // 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_uq
1015   // 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_us
1021   // 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_us
1027   // 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_oq
1033   // 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_oq
1039   // 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_os
1045   // 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_os
1051   // 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_uq
1057   // 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_os
1063   // 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_oq
1069   // 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_oq
1075   // 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_s
1081   // 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_us
1087   // 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_uq
1093   // 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_uq
1099   // 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_s
1105   // 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_us
1111   // 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_uq
1117   // 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_uq
1123   // 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_os
1129   // 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_os
1135   // 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_oq
1141   // 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_oq
1147   // 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_us
1153   // 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_oq
1159   // 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_os
1165   // 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_os
1171   // 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_q
1177   // 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_uq
1183   // 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_us
1189   // 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_us
1195   // 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_q
1201   // 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_uq
1207   // 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_us
1213   // 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_us
1219   // 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_oq
1225   // 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_oq
1231   // 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_os
1237   // 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_os
1243   // 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_uq
1249   // 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_os
1255   // 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_oq
1261   // 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_oq
1267   // 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_s
1273   // 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_us
1279   // 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_uq
1285   // 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_uq
1291   // 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_s
1297   // 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_us
1303   // 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_uq
1309   // 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_uq
1315   // 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_os
1321   // 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_os
1327   // 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_oq
1333   // 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_oq
1339   // 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_us
1345   // 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_oq
1351   // 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_os
1357   // 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_os
1363   // 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_q
1369   // 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_uq
1375   // 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_us
1381   // 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_us
1387   // 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_q
1393   // 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_uq
1399   // 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_us
1405   // 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_us
1411   // 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_oq
1417   // 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_oq
1423   // 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_os
1429   // 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_os
1435   // 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_uq
1441   // 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_os
1447   // 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_oq
1453   // 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_oq
1459   // 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_s
1465   // 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_us
1471   // 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_uq
1477   // 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_uq
1483   // 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_s
1489   // 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_us
1495   // 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_uq
1501   // 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_uq
1507   // 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_os
1513   // 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_os
1519   // 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_oq
1525   // 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_oq
1531   // 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_us
1537   // 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 }