clang/test/CodeGen/X86/avx512f-builtins-constrained-cmp.c

   1 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512f -emit-llvm -ffp-exception-behavior=strict -o - -Wall -Werror | FileCheck %s
   2
   3 #include <immintrin.h>
   4
   5 __mmask16 test_mm512_cmp_round_ps_mask(__m512 a, __m512 b) {
   6   // CHECK-LABEL: @test_mm512_cmp_round_ps_mask
   7   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 0, <16 x i1> {{.*}}, i32 8)
   8   return _mm512_cmp_round_ps_mask(a, b, _CMP_EQ_OQ, _MM_FROUND_NO_EXC);
   9 }
  10
  11 __mmask16 test_mm512_mask_cmp_round_ps_mask(__mmask16 m, __m512 a, __m512 b) {
  12   // CHECK-LABEL: @test_mm512_mask_cmp_round_ps_mask
  13   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 0, <16 x i1> {{.*}}, i32 8)
  14   return _mm512_mask_cmp_round_ps_mask(m, a, b, _CMP_EQ_OQ, _MM_FROUND_NO_EXC);
  15 }
  16
  17 __mmask16 test_mm512_cmp_ps_mask_eq_oq(__m512 a, __m512 b) {
  18   // CHECK-LABEL: @test_mm512_cmp_ps_mask_eq_oq
  19   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 0, <16 x i1> {{.*}}, i32 4)
  20   return _mm512_cmp_ps_mask(a, b, _CMP_EQ_OQ);
  21 }
  22
  23 __mmask16 test_mm512_cmp_ps_mask_lt_os(__m512 a, __m512 b) {
  24   // CHECK-LABEL: test_mm512_cmp_ps_mask_lt_os
  25   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 1, <16 x i1> {{.*}}, i32 4)
  26   return _mm512_cmp_ps_mask(a, b, _CMP_LT_OS);
  27 }
  28
  29 __mmask16 test_mm512_cmp_ps_mask_le_os(__m512 a, __m512 b) {
  30   // CHECK-LABEL: test_mm512_cmp_ps_mask_le_os
  31   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 2, <16 x i1> {{.*}}, i32 4)
  32   return _mm512_cmp_ps_mask(a, b, _CMP_LE_OS);
  33 }
  34
  35 __mmask16 test_mm512_cmp_ps_mask_unord_q(__m512 a, __m512 b) {
  36   // CHECK-LABEL: test_mm512_cmp_ps_mask_unord_q
  37   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 3, <16 x i1> {{.*}}, i32 4)
  38   return _mm512_cmp_ps_mask(a, b, _CMP_UNORD_Q);
  39 }
  40
  41 __mmask16 test_mm512_cmp_ps_mask_neq_uq(__m512 a, __m512 b) {
  42   // CHECK-LABEL: test_mm512_cmp_ps_mask_neq_uq
  43   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 4, <16 x i1> {{.*}}, i32 4)
  44   return _mm512_cmp_ps_mask(a, b, _CMP_NEQ_UQ);
  45 }
  46
  47 __mmask16 test_mm512_cmp_ps_mask_nlt_us(__m512 a, __m512 b) {
  48   // CHECK-LABEL: test_mm512_cmp_ps_mask_nlt_us
  49   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 5, <16 x i1> {{.*}}, i32 4)
  50   return _mm512_cmp_ps_mask(a, b, _CMP_NLT_US);
  51 }
  52
  53 __mmask16 test_mm512_cmp_ps_mask_nle_us(__m512 a, __m512 b) {
  54   // CHECK-LABEL: test_mm512_cmp_ps_mask_nle_us
  55   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 6, <16 x i1> {{.*}}, i32 4)
  56   return _mm512_cmp_ps_mask(a, b, _CMP_NLE_US);
  57 }
  58
  59 __mmask16 test_mm512_cmp_ps_mask_ord_q(__m512 a, __m512 b) {
  60   // CHECK-LABEL: test_mm512_cmp_ps_mask_ord_q
  61   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 7, <16 x i1> {{.*}}, i32 4)
  62   return _mm512_cmp_ps_mask(a, b, _CMP_ORD_Q);
  63 }
  64
  65 __mmask16 test_mm512_cmp_ps_mask_eq_uq(__m512 a, __m512 b) {
  66   // CHECK-LABEL: test_mm512_cmp_ps_mask_eq_uq
  67   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 8, <16 x i1> {{.*}}, i32 4)
  68   return _mm512_cmp_ps_mask(a, b, _CMP_EQ_UQ);
  69 }
  70
  71 __mmask16 test_mm512_cmp_ps_mask_nge_us(__m512 a, __m512 b) {
  72   // CHECK-LABEL: test_mm512_cmp_ps_mask_nge_us
  73   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 9, <16 x i1> {{.*}}, i32 4)
  74   return _mm512_cmp_ps_mask(a, b, _CMP_NGE_US);
  75 }
  76
  77 __mmask16 test_mm512_cmp_ps_mask_ngt_us(__m512 a, __m512 b) {
  78   // CHECK-LABEL: test_mm512_cmp_ps_mask_ngt_us
  79   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 10, <16 x i1> {{.*}}, i32 4)
  80   return _mm512_cmp_ps_mask(a, b, _CMP_NGT_US);
  81 }
  82
  83 __mmask16 test_mm512_cmp_ps_mask_false_oq(__m512 a, __m512 b) {
  84   // CHECK-LABEL: test_mm512_cmp_ps_mask_false_oq
  85   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 11, <16 x i1> {{.*}}, i32 4)
  86   return _mm512_cmp_ps_mask(a, b, _CMP_FALSE_OQ);
  87 }
  88
  89 __mmask16 test_mm512_cmp_ps_mask_neq_oq(__m512 a, __m512 b) {
  90   // CHECK-LABEL: test_mm512_cmp_ps_mask_neq_oq
  91   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 12, <16 x i1> {{.*}}, i32 4)
  92   return _mm512_cmp_ps_mask(a, b, _CMP_NEQ_OQ);
  93 }
  94
  95 __mmask16 test_mm512_cmp_ps_mask_ge_os(__m512 a, __m512 b) {
  96   // CHECK-LABEL: test_mm512_cmp_ps_mask_ge_os
  97   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 13, <16 x i1> {{.*}}, i32 4)
  98   return _mm512_cmp_ps_mask(a, b, _CMP_GE_OS);
  99 }
 100
 101 __mmask16 test_mm512_cmp_ps_mask_gt_os(__m512 a, __m512 b) {
 102   // CHECK-LABEL: test_mm512_cmp_ps_mask_gt_os
 103   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 14, <16 x i1> {{.*}}, i32 4)
 104   return _mm512_cmp_ps_mask(a, b, _CMP_GT_OS);
 105 }
 106
 107 __mmask16 test_mm512_cmp_ps_mask_true_uq(__m512 a, __m512 b) {
 108   // CHECK-LABEL: test_mm512_cmp_ps_mask_true_uq
 109   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 15, <16 x i1> {{.*}}, i32 4)
 110   return _mm512_cmp_ps_mask(a, b, _CMP_TRUE_UQ);
 111 }
 112
 113 __mmask16 test_mm512_cmp_ps_mask_eq_os(__m512 a, __m512 b) {
 114   // CHECK-LABEL: test_mm512_cmp_ps_mask_eq_os
 115   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 16, <16 x i1> {{.*}}, i32 4)
 116   return _mm512_cmp_ps_mask(a, b, _CMP_EQ_OS);
 117 }
 118
 119 __mmask16 test_mm512_cmp_ps_mask_lt_oq(__m512 a, __m512 b) {
 120   // CHECK-LABEL: test_mm512_cmp_ps_mask_lt_oq
 121   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 17, <16 x i1> {{.*}}, i32 4)
 122   return _mm512_cmp_ps_mask(a, b, _CMP_LT_OQ);
 123 }
 124
 125 __mmask16 test_mm512_cmp_ps_mask_le_oq(__m512 a, __m512 b) {
 126   // CHECK-LABEL: test_mm512_cmp_ps_mask_le_oq
 127   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 18, <16 x i1> {{.*}}, i32 4)
 128   return _mm512_cmp_ps_mask(a, b, _CMP_LE_OQ);
 129 }
 130
 131 __mmask16 test_mm512_cmp_ps_mask_unord_s(__m512 a, __m512 b) {
 132   // CHECK-LABEL: test_mm512_cmp_ps_mask_unord_s
 133   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 19, <16 x i1> {{.*}}, i32 4)
 134   return _mm512_cmp_ps_mask(a, b, _CMP_UNORD_S);
 135 }
 136
 137 __mmask16 test_mm512_cmp_ps_mask_neq_us(__m512 a, __m512 b) {
 138   // CHECK-LABEL: test_mm512_cmp_ps_mask_neq_us
 139   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 20, <16 x i1> {{.*}}, i32 4)
 140   return _mm512_cmp_ps_mask(a, b, _CMP_NEQ_US);
 141 }
 142
 143 __mmask16 test_mm512_cmp_ps_mask_nlt_uq(__m512 a, __m512 b) {
 144   // CHECK-LABEL: test_mm512_cmp_ps_mask_nlt_uq
 145   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 21, <16 x i1> {{.*}}, i32 4)
 146   return _mm512_cmp_ps_mask(a, b, _CMP_NLT_UQ);
 147 }
 148
 149 __mmask16 test_mm512_cmp_ps_mask_nle_uq(__m512 a, __m512 b) {
 150   // CHECK-LABEL: test_mm512_cmp_ps_mask_nle_uq
 151   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 22, <16 x i1> {{.*}}, i32 4)
 152   return _mm512_cmp_ps_mask(a, b, _CMP_NLE_UQ);
 153 }
 154
 155 __mmask16 test_mm512_cmp_ps_mask_ord_s(__m512 a, __m512 b) {
 156   // CHECK-LABEL: test_mm512_cmp_ps_mask_ord_s
 157   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 23, <16 x i1> {{.*}}, i32 4)
 158   return _mm512_cmp_ps_mask(a, b, _CMP_ORD_S);
 159 }
 160
 161 __mmask16 test_mm512_cmp_ps_mask_eq_us(__m512 a, __m512 b) {
 162   // CHECK-LABEL: test_mm512_cmp_ps_mask_eq_us
 163   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 24, <16 x i1> {{.*}}, i32 4)
 164   return _mm512_cmp_ps_mask(a, b, _CMP_EQ_US);
 165 }
 166
 167 __mmask16 test_mm512_cmp_ps_mask_nge_uq(__m512 a, __m512 b) {
 168   // CHECK-LABEL: test_mm512_cmp_ps_mask_nge_uq
 169   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 25, <16 x i1> {{.*}}, i32 4)
 170   return _mm512_cmp_ps_mask(a, b, _CMP_NGE_UQ);
 171 }
 172
 173 __mmask16 test_mm512_cmp_ps_mask_ngt_uq(__m512 a, __m512 b) {
 174   // CHECK-LABEL: test_mm512_cmp_ps_mask_ngt_uq
 175   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 26, <16 x i1> {{.*}}, i32 4)
 176   return _mm512_cmp_ps_mask(a, b, _CMP_NGT_UQ);
 177 }
 178
 179 __mmask16 test_mm512_cmp_ps_mask_false_os(__m512 a, __m512 b) {
 180   // CHECK-LABEL: test_mm512_cmp_ps_mask_false_os
 181   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 27, <16 x i1> {{.*}}, i32 4)
 182   return _mm512_cmp_ps_mask(a, b, _CMP_FALSE_OS);
 183 }
 184
 185 __mmask16 test_mm512_cmp_ps_mask_neq_os(__m512 a, __m512 b) {
 186   // CHECK-LABEL: test_mm512_cmp_ps_mask_neq_os
 187   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 28, <16 x i1> {{.*}}, i32 4)
 188   return _mm512_cmp_ps_mask(a, b, _CMP_NEQ_OS);
 189 }
 190
 191 __mmask16 test_mm512_cmp_ps_mask_ge_oq(__m512 a, __m512 b) {
 192   // CHECK-LABEL: test_mm512_cmp_ps_mask_ge_oq
 193   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 29, <16 x i1> {{.*}}, i32 4)
 194   return _mm512_cmp_ps_mask(a, b, _CMP_GE_OQ);
 195 }
 196
 197 __mmask16 test_mm512_cmp_ps_mask_gt_oq(__m512 a, __m512 b) {
 198   // CHECK-LABEL: test_mm512_cmp_ps_mask_gt_oq
 199   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 30, <16 x i1> {{.*}}, i32 4)
 200   return _mm512_cmp_ps_mask(a, b, _CMP_GT_OQ);
 201 }
 202
 203 __mmask16 test_mm512_cmp_ps_mask_true_us(__m512 a, __m512 b) {
 204   // CHECK-LABEL: test_mm512_cmp_ps_mask_true_us
 205   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 31, <16 x i1> {{.*}}, i32 4)
 206   return _mm512_cmp_ps_mask(a, b, _CMP_TRUE_US);
 207 }
 208
 209 __mmask16 test_mm512_mask_cmp_ps_mask_eq_oq(__mmask16 m, __m512 a, __m512 b) {
 210   // CHECK-LABEL: @test_mm512_mask_cmp_ps_mask_eq_oq
 211   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 0, <16 x i1> {{.*}}, i32 4)
 212   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_EQ_OQ);
 213 }
 214
 215 __mmask16 test_mm512_mask_cmp_ps_mask_lt_os(__mmask16 m, __m512 a, __m512 b) {
 216   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_lt_os
 217   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 1, <16 x i1> {{.*}}, i32 4)
 218   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_LT_OS);
 219 }
 220
 221 __mmask16 test_mm512_mask_cmp_ps_mask_le_os(__mmask16 m, __m512 a, __m512 b) {
 222   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_le_os
 223   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 2, <16 x i1> {{.*}}, i32 4)
 224   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_LE_OS);
 225 }
 226
 227 __mmask16 test_mm512_mask_cmp_ps_mask_unord_q(__mmask16 m, __m512 a, __m512 b) {
 228   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_unord_q
 229   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 3, <16 x i1> {{.*}}, i32 4)
 230   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_UNORD_Q);
 231 }
 232
 233 __mmask16 test_mm512_mask_cmp_ps_mask_neq_uq(__mmask16 m, __m512 a, __m512 b) {
 234   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_neq_uq
 235   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 4, <16 x i1> {{.*}}, i32 4)
 236   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_UQ);
 237 }
 238
 239 __mmask16 test_mm512_mask_cmp_ps_mask_nlt_us(__mmask16 m, __m512 a, __m512 b) {
 240   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_nlt_us
 241   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 5, <16 x i1> {{.*}}, i32 4)
 242   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NLT_US);
 243 }
 244
 245 __mmask16 test_mm512_mask_cmp_ps_mask_nle_us(__mmask16 m, __m512 a, __m512 b) {
 246   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_nle_us
 247   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 6, <16 x i1> {{.*}}, i32 4)
 248   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NLE_US);
 249 }
 250
 251 __mmask16 test_mm512_mask_cmp_ps_mask_ord_q(__mmask16 m, __m512 a, __m512 b) {
 252   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_ord_q
 253   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 7, <16 x i1> {{.*}}, i32 4)
 254   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_ORD_Q);
 255 }
 256
 257 __mmask16 test_mm512_mask_cmp_ps_mask_eq_uq(__mmask16 m, __m512 a, __m512 b) {
 258   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_eq_uq
 259   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 8, <16 x i1> {{.*}}, i32 4)
 260   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_EQ_UQ);
 261 }
 262
 263 __mmask16 test_mm512_mask_cmp_ps_mask_nge_us(__mmask16 m, __m512 a, __m512 b) {
 264   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_nge_us
 265   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 9, <16 x i1> {{.*}}, i32 4)
 266   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NGE_US);
 267 }
 268
 269 __mmask16 test_mm512_mask_cmp_ps_mask_ngt_us(__mmask16 m, __m512 a, __m512 b) {
 270   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_ngt_us
 271   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 10, <16 x i1> {{.*}}, i32 4)
 272   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NGT_US);
 273 }
 274
 275 __mmask16 test_mm512_mask_cmp_ps_mask_false_oq(__mmask16 m, __m512 a, __m512 b) {
 276   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_false_oq
 277   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 11, <16 x i1> {{.*}}, i32 4)
 278   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_FALSE_OQ);
 279 }
 280
 281 __mmask16 test_mm512_mask_cmp_ps_mask_neq_oq(__mmask16 m, __m512 a, __m512 b) {
 282   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_neq_oq
 283   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 12, <16 x i1> {{.*}}, i32 4)
 284   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_OQ);
 285 }
 286
 287 __mmask16 test_mm512_mask_cmp_ps_mask_ge_os(__mmask16 m, __m512 a, __m512 b) {
 288   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_ge_os
 289   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 13, <16 x i1> {{.*}}, i32 4)
 290   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_GE_OS);
 291 }
 292
 293 __mmask16 test_mm512_mask_cmp_ps_mask_gt_os(__mmask16 m, __m512 a, __m512 b) {
 294   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_gt_os
 295   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 14, <16 x i1> {{.*}}, i32 4)
 296   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_GT_OS);
 297 }
 298
 299 __mmask16 test_mm512_mask_cmp_ps_mask_true_uq(__mmask16 m, __m512 a, __m512 b) {
 300   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_true_uq
 301   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 15, <16 x i1> {{.*}}, i32 4)
 302   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_TRUE_UQ);
 303 }
 304
 305 __mmask16 test_mm512_mask_cmp_ps_mask_eq_os(__mmask16 m, __m512 a, __m512 b) {
 306   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_eq_os
 307   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 16, <16 x i1> {{.*}}, i32 4)
 308   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_EQ_OS);
 309 }
 310
 311 __mmask16 test_mm512_mask_cmp_ps_mask_lt_oq(__mmask16 m, __m512 a, __m512 b) {
 312   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_lt_oq
 313   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 17, <16 x i1> {{.*}}, i32 4)
 314   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_LT_OQ);
 315 }
 316
 317 __mmask16 test_mm512_mask_cmp_ps_mask_le_oq(__mmask16 m, __m512 a, __m512 b) {
 318   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_le_oq
 319   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 18, <16 x i1> {{.*}}, i32 4)
 320   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_LE_OQ);
 321 }
 322
 323 __mmask16 test_mm512_mask_cmp_ps_mask_unord_s(__mmask16 m, __m512 a, __m512 b) {
 324   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_unord_s
 325   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 19, <16 x i1> {{.*}}, i32 4)
 326   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_UNORD_S);
 327 }
 328
 329 __mmask16 test_mm512_mask_cmp_ps_mask_neq_us(__mmask16 m, __m512 a, __m512 b) {
 330   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_neq_us
 331   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 20, <16 x i1> {{.*}}, i32 4)
 332   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_US);
 333 }
 334
 335 __mmask16 test_mm512_mask_cmp_ps_mask_nlt_uq(__mmask16 m, __m512 a, __m512 b) {
 336   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_nlt_uq
 337   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 21, <16 x i1> {{.*}}, i32 4)
 338   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NLT_UQ);
 339 }
 340
 341 __mmask16 test_mm512_mask_cmp_ps_mask_nle_uq(__mmask16 m, __m512 a, __m512 b) {
 342   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_nle_uq
 343   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 22, <16 x i1> {{.*}}, i32 4)
 344   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NLE_UQ);
 345 }
 346
 347 __mmask16 test_mm512_mask_cmp_ps_mask_ord_s(__mmask16 m, __m512 a, __m512 b) {
 348   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_ord_s
 349   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 23, <16 x i1> {{.*}}, i32 4)
 350   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_ORD_S);
 351 }
 352
 353 __mmask16 test_mm512_mask_cmp_ps_mask_eq_us(__mmask16 m, __m512 a, __m512 b) {
 354   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_eq_us
 355   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 24, <16 x i1> {{.*}}, i32 4)
 356   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_EQ_US);
 357 }
 358
 359 __mmask16 test_mm512_mask_cmp_ps_mask_nge_uq(__mmask16 m, __m512 a, __m512 b) {
 360   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_nge_uq
 361   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 25, <16 x i1> {{.*}}, i32 4)
 362   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NGE_UQ);
 363 }
 364
 365 __mmask16 test_mm512_mask_cmp_ps_mask_ngt_uq(__mmask16 m, __m512 a, __m512 b) {
 366   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_ngt_uq
 367   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 26, <16 x i1> {{.*}}, i32 4)
 368   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NGT_UQ);
 369 }
 370
 371 __mmask16 test_mm512_mask_cmp_ps_mask_false_os(__mmask16 m, __m512 a, __m512 b) {
 372   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_false_os
 373   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 27, <16 x i1> {{.*}}, i32 4)
 374   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_FALSE_OS);
 375 }
 376
 377 __mmask16 test_mm512_mask_cmp_ps_mask_neq_os(__mmask16 m, __m512 a, __m512 b) {
 378   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_neq_os
 379   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 28, <16 x i1> {{.*}}, i32 4)
 380   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_OS);
 381 }
 382
 383 __mmask16 test_mm512_mask_cmp_ps_mask_ge_oq(__mmask16 m, __m512 a, __m512 b) {
 384   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_ge_oq
 385   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 29, <16 x i1> {{.*}}, i32 4)
 386   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_GE_OQ);
 387 }
 388
 389 __mmask16 test_mm512_mask_cmp_ps_mask_gt_oq(__mmask16 m, __m512 a, __m512 b) {
 390   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_gt_oq
 391   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 30, <16 x i1> {{.*}}, i32 4)
 392   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_GT_OQ);
 393 }
 394
 395 __mmask16 test_mm512_mask_cmp_ps_mask_true_us(__mmask16 m, __m512 a, __m512 b) {
 396   // CHECK-LABEL: test_mm512_mask_cmp_ps_mask_true_us
 397   // CHECK: call <16 x i1> @llvm.x86.avx512.mask.cmp.ps.512(<16 x float> %{{.*}}, <16 x float> %{{.*}}, i32 31, <16 x i1> {{.*}}, i32 4)
 398   return _mm512_mask_cmp_ps_mask(m, a, b, _CMP_TRUE_US);
 399 }
 400
 401 __mmask8 test_mm512_cmp_round_pd_mask(__m512d a, __m512d b) {
 402   // CHECK-LABEL: @test_mm512_cmp_round_pd_mask
 403   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 0, <8 x i1> {{.*}}, i32 8)
 404   return _mm512_cmp_round_pd_mask(a, b, _CMP_EQ_OQ, _MM_FROUND_NO_EXC);
 405 }
 406
 407 __mmask8 test_mm512_mask_cmp_round_pd_mask(__mmask8 m, __m512d a, __m512d b) {
 408   // CHECK-LABEL: @test_mm512_mask_cmp_round_pd_mask
 409   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 0, <8 x i1> {{.*}}, i32 8)
 410   return _mm512_mask_cmp_round_pd_mask(m, a, b, _CMP_EQ_OQ, _MM_FROUND_NO_EXC);
 411 }
 412
 413 __mmask8 test_mm512_cmp_pd_mask_eq_oq(__m512d a, __m512d b) {
 414   // CHECK-LABEL: @test_mm512_cmp_pd_mask_eq_oq
 415   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 0, <8 x i1> {{.*}}, i32 4)
 416   return _mm512_cmp_pd_mask(a, b, _CMP_EQ_OQ);
 417 }
 418
 419 __mmask8 test_mm512_cmp_pd_mask_lt_os(__m512d a, __m512d b) {
 420   // CHECK-LABEL: test_mm512_cmp_pd_mask_lt_os
 421   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 1, <8 x i1> {{.*}}, i32 4)
 422   return _mm512_cmp_pd_mask(a, b, _CMP_LT_OS);
 423 }
 424
 425 __mmask8 test_mm512_cmp_pd_mask_le_os(__m512d a, __m512d b) {
 426   // CHECK-LABEL: test_mm512_cmp_pd_mask_le_os
 427   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 2, <8 x i1> {{.*}}, i32 4)
 428   return _mm512_cmp_pd_mask(a, b, _CMP_LE_OS);
 429 }
 430
 431 __mmask8 test_mm512_cmp_pd_mask_unord_q(__m512d a, __m512d b) {
 432   // CHECK-LABEL: test_mm512_cmp_pd_mask_unord_q
 433   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 3, <8 x i1> {{.*}}, i32 4)
 434   return _mm512_cmp_pd_mask(a, b, _CMP_UNORD_Q);
 435 }
 436
 437 __mmask8 test_mm512_cmp_pd_mask_neq_uq(__m512d a, __m512d b) {
 438   // CHECK-LABEL: test_mm512_cmp_pd_mask_neq_uq
 439   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 4, <8 x i1> {{.*}}, i32 4)
 440   return _mm512_cmp_pd_mask(a, b, _CMP_NEQ_UQ);
 441 }
 442
 443 __mmask8 test_mm512_cmp_pd_mask_nlt_us(__m512d a, __m512d b) {
 444   // CHECK-LABEL: test_mm512_cmp_pd_mask_nlt_us
 445   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 5, <8 x i1> {{.*}}, i32 4)
 446   return _mm512_cmp_pd_mask(a, b, _CMP_NLT_US);
 447 }
 448
 449 __mmask8 test_mm512_cmp_pd_mask_nle_us(__m512d a, __m512d b) {
 450   // CHECK-LABEL: test_mm512_cmp_pd_mask_nle_us
 451   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 6, <8 x i1> {{.*}}, i32 4)
 452   return _mm512_cmp_pd_mask(a, b, _CMP_NLE_US);
 453 }
 454
 455 __mmask8 test_mm512_cmp_pd_mask_ord_q(__m512d a, __m512d b) {
 456   // CHECK-LABEL: test_mm512_cmp_pd_mask_ord_q
 457   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 7, <8 x i1> {{.*}}, i32 4)
 458   return _mm512_cmp_pd_mask(a, b, _CMP_ORD_Q);
 459 }
 460
 461 __mmask8 test_mm512_cmp_pd_mask_eq_uq(__m512d a, __m512d b) {
 462   // CHECK-LABEL: test_mm512_cmp_pd_mask_eq_uq
 463   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 8, <8 x i1> {{.*}}, i32 4)
 464   return _mm512_cmp_pd_mask(a, b, _CMP_EQ_UQ);
 465 }
 466
 467 __mmask8 test_mm512_cmp_pd_mask_nge_us(__m512d a, __m512d b) {
 468   // CHECK-LABEL: test_mm512_cmp_pd_mask_nge_us
 469   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 9, <8 x i1> {{.*}}, i32 4)
 470   return _mm512_cmp_pd_mask(a, b, _CMP_NGE_US);
 471 }
 472
 473 __mmask8 test_mm512_cmp_pd_mask_ngt_us(__m512d a, __m512d b) {
 474   // CHECK-LABEL: test_mm512_cmp_pd_mask_ngt_us
 475   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 10, <8 x i1> {{.*}}, i32 4)
 476   return _mm512_cmp_pd_mask(a, b, _CMP_NGT_US);
 477 }
 478
 479 __mmask8 test_mm512_cmp_pd_mask_false_oq(__m512d a, __m512d b) {
 480   // CHECK-LABEL: test_mm512_cmp_pd_mask_false_oq
 481   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 11, <8 x i1> {{.*}}, i32 4)
 482   return _mm512_cmp_pd_mask(a, b, _CMP_FALSE_OQ);
 483 }
 484
 485 __mmask8 test_mm512_cmp_pd_mask_neq_oq(__m512d a, __m512d b) {
 486   // CHECK-LABEL: test_mm512_cmp_pd_mask_neq_oq
 487   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 12, <8 x i1> {{.*}}, i32 4)
 488   return _mm512_cmp_pd_mask(a, b, _CMP_NEQ_OQ);
 489 }
 490
 491 __mmask8 test_mm512_cmp_pd_mask_ge_os(__m512d a, __m512d b) {
 492   // CHECK-LABEL: test_mm512_cmp_pd_mask_ge_os
 493   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 13, <8 x i1> {{.*}}, i32 4)
 494   return _mm512_cmp_pd_mask(a, b, _CMP_GE_OS);
 495 }
 496
 497 __mmask8 test_mm512_cmp_pd_mask_gt_os(__m512d a, __m512d b) {
 498   // CHECK-LABEL: test_mm512_cmp_pd_mask_gt_os
 499   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 14, <8 x i1> {{.*}}, i32 4)
 500   return _mm512_cmp_pd_mask(a, b, _CMP_GT_OS);
 501 }
 502
 503 __mmask8 test_mm512_cmp_pd_mask_true_uq(__m512d a, __m512d b) {
 504   // CHECK-LABEL: test_mm512_cmp_pd_mask_true_uq
 505   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 15, <8 x i1> {{.*}}, i32 4)
 506   return _mm512_cmp_pd_mask(a, b, _CMP_TRUE_UQ);
 507 }
 508
 509 __mmask8 test_mm512_cmp_pd_mask_eq_os(__m512d a, __m512d b) {
 510   // CHECK-LABEL: test_mm512_cmp_pd_mask_eq_os
 511   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 16, <8 x i1> {{.*}}, i32 4)
 512   return _mm512_cmp_pd_mask(a, b, _CMP_EQ_OS);
 513 }
 514
 515 __mmask8 test_mm512_cmp_pd_mask_lt_oq(__m512d a, __m512d b) {
 516   // CHECK-LABEL: test_mm512_cmp_pd_mask_lt_oq
 517   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 17, <8 x i1> {{.*}}, i32 4)
 518   return _mm512_cmp_pd_mask(a, b, _CMP_LT_OQ);
 519 }
 520
 521 __mmask8 test_mm512_cmp_pd_mask_le_oq(__m512d a, __m512d b) {
 522   // CHECK-LABEL: test_mm512_cmp_pd_mask_le_oq
 523   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 18, <8 x i1> {{.*}}, i32 4)
 524   return _mm512_cmp_pd_mask(a, b, _CMP_LE_OQ);
 525 }
 526
 527 __mmask8 test_mm512_cmp_pd_mask_unord_s(__m512d a, __m512d b) {
 528   // CHECK-LABEL: test_mm512_cmp_pd_mask_unord_s
 529   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 19, <8 x i1> {{.*}}, i32 4)
 530   return _mm512_cmp_pd_mask(a, b, _CMP_UNORD_S);
 531 }
 532
 533 __mmask8 test_mm512_cmp_pd_mask_neq_us(__m512d a, __m512d b) {
 534   // CHECK-LABEL: test_mm512_cmp_pd_mask_neq_us
 535   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 20, <8 x i1> {{.*}}, i32 4)
 536   return _mm512_cmp_pd_mask(a, b, _CMP_NEQ_US);
 537 }
 538
 539 __mmask8 test_mm512_cmp_pd_mask_nlt_uq(__m512d a, __m512d b) {
 540   // CHECK-LABEL: test_mm512_cmp_pd_mask_nlt_uq
 541   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 21, <8 x i1> {{.*}}, i32 4)
 542   return _mm512_cmp_pd_mask(a, b, _CMP_NLT_UQ);
 543 }
 544
 545 __mmask8 test_mm512_cmp_pd_mask_nle_uq(__m512d a, __m512d b) {
 546   // CHECK-LABEL: test_mm512_cmp_pd_mask_nle_uq
 547   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 22, <8 x i1> {{.*}}, i32 4)
 548   return _mm512_cmp_pd_mask(a, b, _CMP_NLE_UQ);
 549 }
 550
 551 __mmask8 test_mm512_cmp_pd_mask_ord_s(__m512d a, __m512d b) {
 552   // CHECK-LABEL: test_mm512_cmp_pd_mask_ord_s
 553   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 23, <8 x i1> {{.*}}, i32 4)
 554   return _mm512_cmp_pd_mask(a, b, _CMP_ORD_S);
 555 }
 556
 557 __mmask8 test_mm512_cmp_pd_mask_eq_us(__m512d a, __m512d b) {
 558   // CHECK-LABEL: test_mm512_cmp_pd_mask_eq_us
 559   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 24, <8 x i1> {{.*}}, i32 4)
 560   return _mm512_cmp_pd_mask(a, b, _CMP_EQ_US);
 561 }
 562
 563 __mmask8 test_mm512_cmp_pd_mask_nge_uq(__m512d a, __m512d b) {
 564   // CHECK-LABEL: test_mm512_cmp_pd_mask_nge_uq
 565   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 25, <8 x i1> {{.*}}, i32 4)
 566   return _mm512_cmp_pd_mask(a, b, _CMP_NGE_UQ);
 567 }
 568
 569 __mmask8 test_mm512_cmp_pd_mask_ngt_uq(__m512d a, __m512d b) {
 570   // CHECK-LABEL: test_mm512_cmp_pd_mask_ngt_uq
 571   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 26, <8 x i1> {{.*}}, i32 4)
 572   return _mm512_cmp_pd_mask(a, b, _CMP_NGT_UQ);
 573 }
 574
 575 __mmask8 test_mm512_cmp_pd_mask_false_os(__m512d a, __m512d b) {
 576   // CHECK-LABEL: test_mm512_cmp_pd_mask_false_os
 577   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 27, <8 x i1> {{.*}}, i32 4)
 578   return _mm512_cmp_pd_mask(a, b, _CMP_FALSE_OS);
 579 }
 580
 581 __mmask8 test_mm512_cmp_pd_mask_neq_os(__m512d a, __m512d b) {
 582   // CHECK-LABEL: test_mm512_cmp_pd_mask_neq_os
 583   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 28, <8 x i1> {{.*}}, i32 4)
 584   return _mm512_cmp_pd_mask(a, b, _CMP_NEQ_OS);
 585 }
 586
 587 __mmask8 test_mm512_cmp_pd_mask_ge_oq(__m512d a, __m512d b) {
 588   // CHECK-LABEL: test_mm512_cmp_pd_mask_ge_oq
 589   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 29, <8 x i1> {{.*}}, i32 4)
 590   return _mm512_cmp_pd_mask(a, b, _CMP_GE_OQ);
 591 }
 592
 593 __mmask8 test_mm512_cmp_pd_mask_gt_oq(__m512d a, __m512d b) {
 594   // CHECK-LABEL: test_mm512_cmp_pd_mask_gt_oq
 595   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 30, <8 x i1> {{.*}}, i32 4)
 596   return _mm512_cmp_pd_mask(a, b, _CMP_GT_OQ);
 597 }
 598
 599 __mmask8 test_mm512_cmp_pd_mask_true_us(__m512d a, __m512d b) {
 600   // CHECK-LABEL: test_mm512_cmp_pd_mask_true_us
 601   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 31, <8 x i1> {{.*}}, i32 4)
 602   return _mm512_cmp_pd_mask(a, b, _CMP_TRUE_US);
 603 }
 604
 605 __mmask8 test_mm512_mask_cmp_pd_mask_eq_oq(__mmask8 m, __m512d a, __m512d b) {
 606   // CHECK-LABEL: @test_mm512_mask_cmp_pd_mask_eq_oq
 607   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 0, <8 x i1> {{.*}}, i32 4)
 608   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_EQ_OQ);
 609 }
 610
 611 __mmask8 test_mm512_mask_cmp_pd_mask_lt_os(__mmask8 m, __m512d a, __m512d b) {
 612   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_lt_os
 613   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 1, <8 x i1> {{.*}}, i32 4)
 614   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_LT_OS);
 615 }
 616
 617 __mmask8 test_mm512_mask_cmp_pd_mask_le_os(__mmask8 m, __m512d a, __m512d b) {
 618   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_le_os
 619   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 2, <8 x i1> {{.*}}, i32 4)
 620   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_LE_OS);
 621 }
 622
 623 __mmask8 test_mm512_mask_cmp_pd_mask_unord_q(__mmask8 m, __m512d a, __m512d b) {
 624   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_unord_q
 625   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 3, <8 x i1> {{.*}}, i32 4)
 626   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_UNORD_Q);
 627 }
 628
 629 __mmask8 test_mm512_mask_cmp_pd_mask_neq_uq(__mmask8 m, __m512d a, __m512d b) {
 630   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_neq_uq
 631   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 4, <8 x i1> {{.*}}, i32 4)
 632   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_UQ);
 633 }
 634
 635 __mmask8 test_mm512_mask_cmp_pd_mask_nlt_us(__mmask8 m, __m512d a, __m512d b) {
 636   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_nlt_us
 637   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 5, <8 x i1> {{.*}}, i32 4)
 638   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NLT_US);
 639 }
 640
 641 __mmask8 test_mm512_mask_cmp_pd_mask_nle_us(__mmask8 m, __m512d a, __m512d b) {
 642   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_nle_us
 643   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 6, <8 x i1> {{.*}}, i32 4)
 644   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NLE_US);
 645 }
 646
 647 __mmask8 test_mm512_mask_cmp_pd_mask_ord_q(__mmask8 m, __m512d a, __m512d b) {
 648   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_ord_q
 649   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 7, <8 x i1> {{.*}}, i32 4)
 650   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_ORD_Q);
 651 }
 652
 653 __mmask8 test_mm512_mask_cmp_pd_mask_eq_uq(__mmask8 m, __m512d a, __m512d b) {
 654   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_eq_uq
 655   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 8, <8 x i1> {{.*}}, i32 4)
 656   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_EQ_UQ);
 657 }
 658
 659 __mmask8 test_mm512_mask_cmp_pd_mask_nge_us(__mmask8 m, __m512d a, __m512d b) {
 660   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_nge_us
 661   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 9, <8 x i1> {{.*}}, i32 4)
 662   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NGE_US);
 663 }
 664
 665 __mmask8 test_mm512_mask_cmp_pd_mask_ngt_us(__mmask8 m, __m512d a, __m512d b) {
 666   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_ngt_us
 667   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 10, <8 x i1> {{.*}}, i32 4)
 668   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NGT_US);
 669 }
 670
 671 __mmask8 test_mm512_mask_cmp_pd_mask_false_oq(__mmask8 m, __m512d a, __m512d b) {
 672   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_false_oq
 673   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 11, <8 x i1> {{.*}}, i32 4)
 674   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_FALSE_OQ);
 675 }
 676
 677 __mmask8 test_mm512_mask_cmp_pd_mask_neq_oq(__mmask8 m, __m512d a, __m512d b) {
 678   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_neq_oq
 679   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 12, <8 x i1> {{.*}}, i32 4)
 680   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_OQ);
 681 }
 682
 683 __mmask8 test_mm512_mask_cmp_pd_mask_ge_os(__mmask8 m, __m512d a, __m512d b) {
 684   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_ge_os
 685   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 13, <8 x i1> {{.*}}, i32 4)
 686   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_GE_OS);
 687 }
 688
 689 __mmask8 test_mm512_mask_cmp_pd_mask_gt_os(__mmask8 m, __m512d a, __m512d b) {
 690   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_gt_os
 691   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 14, <8 x i1> {{.*}}, i32 4)
 692   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_GT_OS);
 693 }
 694
 695 __mmask8 test_mm512_mask_cmp_pd_mask_true_uq(__mmask8 m, __m512d a, __m512d b) {
 696   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_true_uq
 697   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 15, <8 x i1> {{.*}}, i32 4)
 698   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_TRUE_UQ);
 699 }
 700
 701 __mmask8 test_mm512_mask_cmp_pd_mask_eq_os(__mmask8 m, __m512d a, __m512d b) {
 702   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_eq_os
 703   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 16, <8 x i1> {{.*}}, i32 4)
 704   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_EQ_OS);
 705 }
 706
 707 __mmask8 test_mm512_mask_cmp_pd_mask_lt_oq(__mmask8 m, __m512d a, __m512d b) {
 708   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_lt_oq
 709   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 17, <8 x i1> {{.*}}, i32 4)
 710   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_LT_OQ);
 711 }
 712
 713 __mmask8 test_mm512_mask_cmp_pd_mask_le_oq(__mmask8 m, __m512d a, __m512d b) {
 714   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_le_oq
 715   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 18, <8 x i1> {{.*}}, i32 4)
 716   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_LE_OQ);
 717 }
 718
 719 __mmask8 test_mm512_mask_cmp_pd_mask_unord_s(__mmask8 m, __m512d a, __m512d b) {
 720   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_unord_s
 721   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 19, <8 x i1> {{.*}}, i32 4)
 722   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_UNORD_S);
 723 }
 724
 725 __mmask8 test_mm512_mask_cmp_pd_mask_neq_us(__mmask8 m, __m512d a, __m512d b) {
 726   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_neq_us
 727   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 20, <8 x i1> {{.*}}, i32 4)
 728   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_US);
 729 }
 730
 731 __mmask8 test_mm512_mask_cmp_pd_mask_nlt_uq(__mmask8 m, __m512d a, __m512d b) {
 732   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_nlt_uq
 733   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 21, <8 x i1> {{.*}}, i32 4)
 734   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NLT_UQ);
 735 }
 736
 737 __mmask8 test_mm512_mask_cmp_pd_mask_nle_uq(__mmask8 m, __m512d a, __m512d b) {
 738   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_nle_uq
 739   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 22, <8 x i1> {{.*}}, i32 4)
 740   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NLE_UQ);
 741 }
 742
 743 __mmask8 test_mm512_mask_cmp_pd_mask_ord_s(__mmask8 m, __m512d a, __m512d b) {
 744   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_ord_s
 745   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 23, <8 x i1> {{.*}}, i32 4)
 746   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_ORD_S);
 747 }
 748
 749 __mmask8 test_mm512_mask_cmp_pd_mask_eq_us(__mmask8 m, __m512d a, __m512d b) {
 750   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_eq_us
 751   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 24, <8 x i1> {{.*}}, i32 4)
 752   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_EQ_US);
 753 }
 754
 755 __mmask8 test_mm512_mask_cmp_pd_mask_nge_uq(__mmask8 m, __m512d a, __m512d b) {
 756   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_nge_uq
 757   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 25, <8 x i1> {{.*}}, i32 4)
 758   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NGE_UQ);
 759 }
 760
 761 __mmask8 test_mm512_mask_cmp_pd_mask_ngt_uq(__mmask8 m, __m512d a, __m512d b) {
 762   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_ngt_uq
 763   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 26, <8 x i1> {{.*}}, i32 4)
 764   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NGT_UQ);
 765 }
 766
 767 __mmask8 test_mm512_mask_cmp_pd_mask_false_os(__mmask8 m, __m512d a, __m512d b) {
 768   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_false_os
 769   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 27, <8 x i1> {{.*}}, i32 4)
 770   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_FALSE_OS);
 771 }
 772
 773 __mmask8 test_mm512_mask_cmp_pd_mask_neq_os(__mmask8 m, __m512d a, __m512d b) {
 774   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_neq_os
 775   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 28, <8 x i1> {{.*}}, i32 4)
 776   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_OS);
 777 }
 778
 779 __mmask8 test_mm512_mask_cmp_pd_mask_ge_oq(__mmask8 m, __m512d a, __m512d b) {
 780   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_ge_oq
 781   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 29, <8 x i1> {{.*}}, i32 4)
 782   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_GE_OQ);
 783 }
 784
 785 __mmask8 test_mm512_mask_cmp_pd_mask_gt_oq(__mmask8 m, __m512d a, __m512d b) {
 786   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_gt_oq
 787   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 30, <8 x i1> {{.*}}, i32 4)
 788   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_GT_OQ);
 789 }
 790
 791 __mmask8 test_mm512_mask_cmp_pd_mask_true_us(__mmask8 m, __m512d a, __m512d b) {
 792   // CHECK-LABEL: test_mm512_mask_cmp_pd_mask_true_us
 793   // CHECK: call <8 x i1> @llvm.x86.avx512.mask.cmp.pd.512(<8 x double> %{{.*}}, <8 x double> %{{.*}}, i32 31, <8 x i1> {{.*}}, i32 4)
 794   return _mm512_mask_cmp_pd_mask(m, a, b, _CMP_TRUE_US);
 795 }