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

   1 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512fp16 -emit-llvm -ffp-exception-behavior=strict -o - -Wall -Werror | FileCheck %s
   2
   3 #include <immintrin.h>
   4
   5 __mmask32 test_mm512_cmp_round_ph_mask(__m512h a, __m512h b) {
   6   // CHECK-LABEL: @test_mm512_cmp_round_ph_mask
   7   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 0, <32 x i1> {{.*}}, i32 8)
   8   return _mm512_cmp_round_ph_mask(a, b, _CMP_EQ_OQ, _MM_FROUND_NO_EXC);
   9 }
  10
  11 __mmask32 test_mm512_mask_cmp_round_ph_mask(__mmask32 m, __m512h a, __m512h b) {
  12   // CHECK-LABEL: @test_mm512_mask_cmp_round_ph_mask
  13   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 0, <32 x i1> {{.*}}, i32 8)
  14   return _mm512_mask_cmp_round_ph_mask(m, a, b, _CMP_EQ_OQ, _MM_FROUND_NO_EXC);
  15 }
  16
  17 __mmask8 test_mm_cmp_ph_mask_eq_oq(__m128h a, __m128h b) {
  18   // CHECK-LABEL: @test_mm_cmp_ph_mask_eq_oq
  19   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 0, <8 x i1> {{.*}})
  20   return _mm_cmp_ph_mask(a, b, _CMP_EQ_OQ);
  21 }
  22
  23 __mmask8 test_mm_cmp_ph_mask_lt_os(__m128h a, __m128h b) {
  24   // CHECK-LABEL: test_mm_cmp_ph_mask_lt_os
  25   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 1, <8 x i1> {{.*}})
  26   return _mm_cmp_ph_mask(a, b, _CMP_LT_OS);
  27 }
  28
  29 __mmask8 test_mm_cmp_ph_mask_le_os(__m128h a, __m128h b) {
  30   // CHECK-LABEL: test_mm_cmp_ph_mask_le_os
  31   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 2, <8 x i1> {{.*}})
  32   return _mm_cmp_ph_mask(a, b, _CMP_LE_OS);
  33 }
  34
  35 __mmask8 test_mm_cmp_ph_mask_unord_q(__m128h a, __m128h b) {
  36   // CHECK-LABEL: test_mm_cmp_ph_mask_unord_q
  37   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 3, <8 x i1> {{.*}})
  38   return _mm_cmp_ph_mask(a, b, _CMP_UNORD_Q);
  39 }
  40
  41 __mmask8 test_mm_cmp_ph_mask_neq_uq(__m128h a, __m128h b) {
  42   // CHECK-LABEL: test_mm_cmp_ph_mask_neq_uq
  43   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 4, <8 x i1> {{.*}})
  44   return _mm_cmp_ph_mask(a, b, _CMP_NEQ_UQ);
  45 }
  46
  47 __mmask8 test_mm_cmp_ph_mask_nlt_us(__m128h a, __m128h b) {
  48   // CHECK-LABEL: test_mm_cmp_ph_mask_nlt_us
  49   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 5, <8 x i1> {{.*}})
  50   return _mm_cmp_ph_mask(a, b, _CMP_NLT_US);
  51 }
  52
  53 __mmask8 test_mm_cmp_ph_mask_nle_us(__m128h a, __m128h b) {
  54   // CHECK-LABEL: test_mm_cmp_ph_mask_nle_us
  55   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 6, <8 x i1> {{.*}})
  56   return _mm_cmp_ph_mask(a, b, _CMP_NLE_US);
  57 }
  58
  59 __mmask8 test_mm_cmp_ph_mask_ord_q(__m128h a, __m128h b) {
  60   // CHECK-LABEL: test_mm_cmp_ph_mask_ord_q
  61   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 7, <8 x i1> {{.*}})
  62   return _mm_cmp_ph_mask(a, b, _CMP_ORD_Q);
  63 }
  64
  65 __mmask8 test_mm_cmp_ph_mask_eq_uq(__m128h a, __m128h b) {
  66   // CHECK-LABEL: test_mm_cmp_ph_mask_eq_uq
  67   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 8, <8 x i1> {{.*}})
  68   return _mm_cmp_ph_mask(a, b, _CMP_EQ_UQ);
  69 }
  70
  71 __mmask8 test_mm_cmp_ph_mask_nge_us(__m128h a, __m128h b) {
  72   // CHECK-LABEL: test_mm_cmp_ph_mask_nge_us
  73   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 9, <8 x i1> {{.*}})
  74   return _mm_cmp_ph_mask(a, b, _CMP_NGE_US);
  75 }
  76
  77 __mmask8 test_mm_cmp_ph_mask_ngt_us(__m128h a, __m128h b) {
  78   // CHECK-LABEL: test_mm_cmp_ph_mask_ngt_us
  79   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 10, <8 x i1> {{.*}})
  80   return _mm_cmp_ph_mask(a, b, _CMP_NGT_US);
  81 }
  82
  83 __mmask8 test_mm_cmp_ph_mask_false_oq(__m128h a, __m128h b) {
  84   // CHECK-LABEL: test_mm_cmp_ph_mask_false_oq
  85   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 11, <8 x i1> {{.*}})
  86   return _mm_cmp_ph_mask(a, b, _CMP_FALSE_OQ);
  87 }
  88
  89 __mmask8 test_mm_cmp_ph_mask_neq_oq(__m128h a, __m128h b) {
  90   // CHECK-LABEL: test_mm_cmp_ph_mask_neq_oq
  91   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 12, <8 x i1> {{.*}})
  92   return _mm_cmp_ph_mask(a, b, _CMP_NEQ_OQ);
  93 }
  94
  95 __mmask8 test_mm_cmp_ph_mask_ge_os(__m128h a, __m128h b) {
  96   // CHECK-LABEL: test_mm_cmp_ph_mask_ge_os
  97   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 13, <8 x i1> {{.*}})
  98   return _mm_cmp_ph_mask(a, b, _CMP_GE_OS);
  99 }
 100
 101 __mmask8 test_mm_cmp_ph_mask_gt_os(__m128h a, __m128h b) {
 102   // CHECK-LABEL: test_mm_cmp_ph_mask_gt_os
 103   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 14, <8 x i1> {{.*}})
 104   return _mm_cmp_ph_mask(a, b, _CMP_GT_OS);
 105 }
 106
 107 __mmask8 test_mm_cmp_ph_mask_true_uq(__m128h a, __m128h b) {
 108   // CHECK-LABEL: test_mm_cmp_ph_mask_true_uq
 109   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 15, <8 x i1> {{.*}})
 110   return _mm_cmp_ph_mask(a, b, _CMP_TRUE_UQ);
 111 }
 112
 113 __mmask8 test_mm_cmp_ph_mask_eq_os(__m128h a, __m128h b) {
 114   // CHECK-LABEL: test_mm_cmp_ph_mask_eq_os
 115   // CHECK: call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %{{.*}}, <8 x half> %{{.*}}, i32 16, <8 x i1> {{.*}})
 116   return _mm_cmp_ph_mask(a, b, _CMP_EQ_OS);
 117 }
 118
 119 __mmask16 test_mm256_cmp_ph_mask_lt_oq(__m256h a, __m256h b) {
 120   // CHECK-LABEL: test_mm256_cmp_ph_mask_lt_oq
 121   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 17, <16 x i1> {{.*}})
 122   return _mm256_cmp_ph_mask(a, b, _CMP_LT_OQ);
 123 }
 124
 125 __mmask16 test_mm256_cmp_ph_mask_le_oq(__m256h a, __m256h b) {
 126   // CHECK-LABEL: test_mm256_cmp_ph_mask_le_oq
 127   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 18, <16 x i1> {{.*}})
 128   return _mm256_cmp_ph_mask(a, b, _CMP_LE_OQ);
 129 }
 130
 131 __mmask16 test_mm256_cmp_ph_mask_unord_s(__m256h a, __m256h b) {
 132   // CHECK-LABEL: test_mm256_cmp_ph_mask_unord_s
 133   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 19, <16 x i1> {{.*}})
 134   return _mm256_cmp_ph_mask(a, b, _CMP_UNORD_S);
 135 }
 136
 137 __mmask16 test_mm256_cmp_ph_mask_neq_us(__m256h a, __m256h b) {
 138   // CHECK-LABEL: test_mm256_cmp_ph_mask_neq_us
 139   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 20, <16 x i1> {{.*}})
 140   return _mm256_cmp_ph_mask(a, b, _CMP_NEQ_US);
 141 }
 142
 143 __mmask16 test_mm256_cmp_ph_mask_nlt_uq(__m256h a, __m256h b) {
 144   // CHECK-LABEL: test_mm256_cmp_ph_mask_nlt_uq
 145   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 21, <16 x i1> {{.*}})
 146   return _mm256_cmp_ph_mask(a, b, _CMP_NLT_UQ);
 147 }
 148
 149 __mmask16 test_mm256_cmp_ph_mask_nle_uq(__m256h a, __m256h b) {
 150   // CHECK-LABEL: test_mm256_cmp_ph_mask_nle_uq
 151   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 22, <16 x i1> {{.*}})
 152   return _mm256_cmp_ph_mask(a, b, _CMP_NLE_UQ);
 153 }
 154
 155 __mmask16 test_mm256_cmp_ph_mask_ord_s(__m256h a, __m256h b) {
 156   // CHECK-LABEL: test_mm256_cmp_ph_mask_ord_s
 157   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 23, <16 x i1> {{.*}})
 158   return _mm256_cmp_ph_mask(a, b, _CMP_ORD_S);
 159 }
 160
 161 __mmask16 test_mm256_cmp_ph_mask_eq_us(__m256h a, __m256h b) {
 162   // CHECK-LABEL: test_mm256_cmp_ph_mask_eq_us
 163   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 24, <16 x i1> {{.*}})
 164   return _mm256_cmp_ph_mask(a, b, _CMP_EQ_US);
 165 }
 166
 167 __mmask16 test_mm256_cmp_ph_mask_nge_uq(__m256h a, __m256h b) {
 168   // CHECK-LABEL: test_mm256_cmp_ph_mask_nge_uq
 169   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 25, <16 x i1> {{.*}})
 170   return _mm256_cmp_ph_mask(a, b, _CMP_NGE_UQ);
 171 }
 172
 173 __mmask16 test_mm256_cmp_ph_mask_ngt_uq(__m256h a, __m256h b) {
 174   // CHECK-LABEL: test_mm256_cmp_ph_mask_ngt_uq
 175   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 26, <16 x i1> {{.*}})
 176   return _mm256_cmp_ph_mask(a, b, _CMP_NGT_UQ);
 177 }
 178
 179 __mmask16 test_mm256_cmp_ph_mask_false_os(__m256h a, __m256h b) {
 180   // CHECK-LABEL: test_mm256_cmp_ph_mask_false_os
 181   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 27, <16 x i1> {{.*}})
 182   return _mm256_cmp_ph_mask(a, b, _CMP_FALSE_OS);
 183 }
 184
 185 __mmask16 test_mm256_cmp_ph_mask_neq_os(__m256h a, __m256h b) {
 186   // CHECK-LABEL: test_mm256_cmp_ph_mask_neq_os
 187   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 28, <16 x i1> {{.*}})
 188   return _mm256_cmp_ph_mask(a, b, _CMP_NEQ_OS);
 189 }
 190
 191 __mmask16 test_mm256_cmp_ph_mask_ge_oq(__m256h a, __m256h b) {
 192   // CHECK-LABEL: test_mm256_cmp_ph_mask_ge_oq
 193   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 29, <16 x i1> {{.*}})
 194   return _mm256_cmp_ph_mask(a, b, _CMP_GE_OQ);
 195 }
 196
 197 __mmask16 test_mm256_cmp_ph_mask_gt_oq(__m256h a, __m256h b) {
 198   // CHECK-LABEL: test_mm256_cmp_ph_mask_gt_oq
 199   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 30, <16 x i1> {{.*}})
 200   return _mm256_cmp_ph_mask(a, b, _CMP_GT_OQ);
 201 }
 202
 203 __mmask16 test_mm256_cmp_ph_mask_true_us(__m256h a, __m256h b) {
 204   // CHECK-LABEL: test_mm256_cmp_ph_mask_true_us
 205   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 31, <16 x i1> {{.*}})
 206   return _mm256_cmp_ph_mask(a, b, _CMP_TRUE_US);
 207 }
 208
 209 __mmask16 test_mm256_mask_cmp_ph_mask_eq_oq(__mmask16 m, __m256h a, __m256h b) {
 210   // CHECK-LABEL: @test_mm256_mask_cmp_ph_mask_eq_oq
 211   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 0, <16 x i1> {{.*}})
 212   return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_EQ_OQ);
 213 }
 214
 215 __mmask16 test_mm256_mask_cmp_ph_mask_lt_os(__mmask16 m, __m256h a, __m256h b) {
 216   // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_lt_os
 217   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 1, <16 x i1> {{.*}})
 218   return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_LT_OS);
 219 }
 220
 221 __mmask16 test_mm256_mask_cmp_ph_mask_le_os(__mmask16 m, __m256h a, __m256h b) {
 222   // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_le_os
 223   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 2, <16 x i1> {{.*}})
 224   return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_LE_OS);
 225 }
 226
 227 __mmask16 test_mm256_mask_cmp_ph_mask_unord_q(__mmask16 m, __m256h a, __m256h b) {
 228   // CHECK-LABEL: test_mm256_mask_cmp_ph_mask_unord_q
 229   // CHECK: call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %{{.*}}, <16 x half> %{{.*}}, i32 3, <16 x i1> {{.*}})
 230   return _mm256_mask_cmp_ph_mask(m, a, b, _CMP_UNORD_Q);
 231 }
 232
 233 __mmask32 test_mm512_mask_cmp_ph_mask_neq_uq(__mmask32 m, __m512h a, __m512h b) {
 234   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_neq_uq
 235   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 4, <32 x i1> {{.*}})
 236   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NEQ_UQ);
 237 }
 238
 239 __mmask32 test_mm512_mask_cmp_ph_mask_nlt_us(__mmask32 m, __m512h a, __m512h b) {
 240   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_nlt_us
 241   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 5, <32 x i1> {{.*}})
 242   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NLT_US);
 243 }
 244
 245 __mmask32 test_mm512_mask_cmp_ph_mask_nle_us(__mmask32 m, __m512h a, __m512h b) {
 246   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_nle_us
 247   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 6, <32 x i1> {{.*}})
 248   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NLE_US);
 249 }
 250
 251 __mmask32 test_mm512_mask_cmp_ph_mask_ord_q(__mmask32 m, __m512h a, __m512h b) {
 252   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_ord_q
 253   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 7, <32 x i1> {{.*}})
 254   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_ORD_Q);
 255 }
 256
 257 __mmask32 test_mm512_mask_cmp_ph_mask_eq_uq(__mmask32 m, __m512h a, __m512h b) {
 258   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_eq_uq
 259   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 8, <32 x i1> {{.*}})
 260   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_EQ_UQ);
 261 }
 262
 263 __mmask32 test_mm512_mask_cmp_ph_mask_nge_us(__mmask32 m, __m512h a, __m512h b) {
 264   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_nge_us
 265   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 9, <32 x i1> {{.*}})
 266   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NGE_US);
 267 }
 268
 269 __mmask32 test_mm512_mask_cmp_ph_mask_ngt_us(__mmask32 m, __m512h a, __m512h b) {
 270   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_ngt_us
 271   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 10, <32 x i1> {{.*}})
 272   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NGT_US);
 273 }
 274
 275 __mmask32 test_mm512_mask_cmp_ph_mask_false_oq(__mmask32 m, __m512h a, __m512h b) {
 276   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_false_oq
 277   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 11, <32 x i1> {{.*}})
 278   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_FALSE_OQ);
 279 }
 280
 281 __mmask32 test_mm512_mask_cmp_ph_mask_neq_oq(__mmask32 m, __m512h a, __m512h b) {
 282   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_neq_oq
 283   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 12, <32 x i1> {{.*}})
 284   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NEQ_OQ);
 285 }
 286
 287 __mmask32 test_mm512_mask_cmp_ph_mask_ge_os(__mmask32 m, __m512h a, __m512h b) {
 288   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_ge_os
 289   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 13, <32 x i1> {{.*}})
 290   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_GE_OS);
 291 }
 292
 293 __mmask32 test_mm512_mask_cmp_ph_mask_gt_os(__mmask32 m, __m512h a, __m512h b) {
 294   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_gt_os
 295   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 14, <32 x i1> {{.*}})
 296   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_GT_OS);
 297 }
 298
 299 __mmask32 test_mm512_mask_cmp_ph_mask_true_uq(__mmask32 m, __m512h a, __m512h b) {
 300   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_true_uq
 301   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 15, <32 x i1> {{.*}})
 302   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_TRUE_UQ);
 303 }
 304
 305 __mmask32 test_mm512_mask_cmp_ph_mask_eq_os(__mmask32 m, __m512h a, __m512h b) {
 306   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_eq_os
 307   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 16, <32 x i1> {{.*}})
 308   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_EQ_OS);
 309 }
 310
 311 __mmask32 test_mm512_mask_cmp_ph_mask_lt_oq(__mmask32 m, __m512h a, __m512h b) {
 312   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_lt_oq
 313   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 17, <32 x i1> {{.*}})
 314   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_LT_OQ);
 315 }
 316
 317 __mmask32 test_mm512_mask_cmp_ph_mask_le_oq(__mmask32 m, __m512h a, __m512h b) {
 318   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_le_oq
 319   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 18, <32 x i1> {{.*}})
 320   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_LE_OQ);
 321 }
 322
 323 __mmask32 test_mm512_mask_cmp_ph_mask_unord_s(__mmask32 m, __m512h a, __m512h b) {
 324   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_unord_s
 325   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 19, <32 x i1> {{.*}})
 326   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_UNORD_S);
 327 }
 328
 329 __mmask32 test_mm512_mask_cmp_ph_mask_neq_us(__mmask32 m, __m512h a, __m512h b) {
 330   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_neq_us
 331   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 20, <32 x i1> {{.*}})
 332   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NEQ_US);
 333 }
 334
 335 __mmask32 test_mm512_mask_cmp_ph_mask_nlt_uq(__mmask32 m, __m512h a, __m512h b) {
 336   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_nlt_uq
 337   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 21, <32 x i1> {{.*}})
 338   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NLT_UQ);
 339 }
 340
 341 __mmask32 test_mm512_mask_cmp_ph_mask_nle_uq(__mmask32 m, __m512h a, __m512h b) {
 342   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_nle_uq
 343   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 22, <32 x i1> {{.*}})
 344   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NLE_UQ);
 345 }
 346
 347 __mmask32 test_mm512_mask_cmp_ph_mask_ord_s(__mmask32 m, __m512h a, __m512h b) {
 348   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_ord_s
 349   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 23, <32 x i1> {{.*}})
 350   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_ORD_S);
 351 }
 352
 353 __mmask32 test_mm512_mask_cmp_ph_mask_eq_us(__mmask32 m, __m512h a, __m512h b) {
 354   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_eq_us
 355   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 24, <32 x i1> {{.*}})
 356   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_EQ_US);
 357 }
 358
 359 __mmask32 test_mm512_mask_cmp_ph_mask_nge_uq(__mmask32 m, __m512h a, __m512h b) {
 360   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_nge_uq
 361   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 25, <32 x i1> {{.*}})
 362   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NGE_UQ);
 363 }
 364
 365 __mmask32 test_mm512_mask_cmp_ph_mask_ngt_uq(__mmask32 m, __m512h a, __m512h b) {
 366   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_ngt_uq
 367   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 26, <32 x i1> {{.*}})
 368   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NGT_UQ);
 369 }
 370
 371 __mmask32 test_mm512_mask_cmp_ph_mask_false_os(__mmask32 m, __m512h a, __m512h b) {
 372   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_false_os
 373   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 27, <32 x i1> {{.*}})
 374   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_FALSE_OS);
 375 }
 376
 377 __mmask32 test_mm512_mask_cmp_ph_mask_neq_os(__mmask32 m, __m512h a, __m512h b) {
 378   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_neq_os
 379   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 28, <32 x i1> {{.*}})
 380   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_NEQ_OS);
 381 }
 382
 383 __mmask32 test_mm512_mask_cmp_ph_mask_ge_oq(__mmask32 m, __m512h a, __m512h b) {
 384   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_ge_oq
 385   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 29, <32 x i1> {{.*}})
 386   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_GE_OQ);
 387 }
 388
 389 __mmask32 test_mm512_mask_cmp_ph_mask_gt_oq(__mmask32 m, __m512h a, __m512h b) {
 390   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_gt_oq
 391   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 30, <32 x i1> {{.*}})
 392   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_GT_OQ);
 393 }
 394
 395 __mmask32 test_mm512_mask_cmp_ph_mask_true_us(__mmask32 m, __m512h a, __m512h b) {
 396   // CHECK-LABEL: test_mm512_mask_cmp_ph_mask_true_us
 397   // CHECK: call <32 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.512(<32 x half> %{{.*}}, <32 x half> %{{.*}}, i32 31, <32 x i1> {{.*}})
 398   return _mm512_mask_cmp_ph_mask(m, a, b, _CMP_TRUE_US);
 399 }