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

   1 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx -emit-llvm -ffp-exception-behavior=maytrap -o - -Wall -Werror | FileCheck %s
   2 // RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=i386-apple-darwin -target-feature +avx -emit-llvm -ffp-exception-behavior=maytrap -o - -Wall -Werror | FileCheck %s
   3
   4 // Test that the constrained intrinsics are picking up the exception
   5 // metadata from the AST instead of the global default from the command line.
   6
   7 #pragma float_control(except, on)
   8
   9
  10 #include <immintrin.h>
  11
  12 __m256d test_mm256_cmp_pd_eq_oq(__m256d a, __m256d b) {
  13   // CHECK-LABEL: test_mm256_cmp_pd_eq_oq
  14   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"oeq", metadata !"fpexcept.strict")
  15   return _mm256_cmp_pd(a, b, _CMP_EQ_OQ);
  16 }
  17
  18 __m256d test_mm256_cmp_pd_lt_os(__m256d a, __m256d b) {
  19   // CHECK-LABEL: test_mm256_cmp_pd_lt_os
  20   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"olt", metadata !"fpexcept.strict")
  21   return _mm256_cmp_pd(a, b, _CMP_LT_OS);
  22 }
  23
  24 __m256d test_mm256_cmp_pd_le_os(__m256d a, __m256d b) {
  25   // CHECK-LABEL: test_mm256_cmp_pd_le_os
  26   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"ole", metadata !"fpexcept.strict")
  27   return _mm256_cmp_pd(a, b, _CMP_LE_OS);
  28 }
  29
  30 __m256d test_mm256_cmp_pd_unord_q(__m256d a, __m256d b) {
  31   // CHECK-LABEL: test_mm256_cmp_pd_unord_q
  32   // CHECK: all <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"uno", metadata !"fpexcept.strict")
  33   return _mm256_cmp_pd(a, b, _CMP_UNORD_Q);
  34 }
  35
  36 __m256d test_mm256_cmp_pd_neq_uq(__m256d a, __m256d b) {
  37   // CHECK-LABEL: test_mm256_cmp_pd_neq_uq
  38   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"une", metadata !"fpexcept.strict")
  39   return _mm256_cmp_pd(a, b, _CMP_NEQ_UQ);
  40 }
  41
  42 __m256d test_mm256_cmp_pd_nlt_us(__m256d a, __m256d b) {
  43   // CHECK-LABEL: test_mm256_cmp_pd_nlt_us
  44   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"uge", metadata !"fpexcept.strict")
  45   return _mm256_cmp_pd(a, b, _CMP_NLT_US);
  46 }
  47
  48 __m256d test_mm256_cmp_pd_nle_us(__m256d a, __m256d b) {
  49   // CHECK-LABEL: test_mm256_cmp_pd_nle_us
  50   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"ugt", metadata !"fpexcept.strict")
  51   return _mm256_cmp_pd(a, b, _CMP_NLE_US);
  52 }
  53
  54 __m256d test_mm256_cmp_pd_ord_q(__m256d a, __m256d b) {
  55   // CHECK-LABEL: test_mm256_cmp_pd_ord_q
  56   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"ord", metadata !"fpexcept.strict")
  57   return _mm256_cmp_pd(a, b, _CMP_ORD_Q);
  58 }
  59
  60 __m256d test_mm256_cmp_pd_eq_uq(__m256d a, __m256d b) {
  61   // CHECK-LABEL: test_mm256_cmp_pd_eq_uq
  62   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"ueq", metadata !"fpexcept.strict")
  63   return _mm256_cmp_pd(a, b, _CMP_EQ_UQ);
  64 }
  65
  66 __m256d test_mm256_cmp_pd_nge_us(__m256d a, __m256d b) {
  67   // CHECK-LABEL: test_mm256_cmp_pd_nge_us
  68   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"ult", metadata !"fpexcept.strict")
  69   return _mm256_cmp_pd(a, b, _CMP_NGE_US);
  70 }
  71
  72 __m256d test_mm256_cmp_pd_ngt_us(__m256d a, __m256d b) {
  73   // CHECK-LABEL: test_mm256_cmp_pd_ngt_us
  74   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"ule", metadata !"fpexcept.strict")
  75   return _mm256_cmp_pd(a, b, _CMP_NGT_US);
  76 }
  77
  78 __m256d test_mm256_cmp_pd_false_oq(__m256d a, __m256d b) {
  79   // CHECK-LABEL: test_mm256_cmp_pd_false_oq
  80   // CHECK: call <4 x double> @llvm.x86.avx.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i8 11)
  81   return _mm256_cmp_pd(a, b, _CMP_FALSE_OQ);
  82 }
  83
  84 __m256d test_mm256_cmp_pd_neq_oq(__m256d a, __m256d b) {
  85   // CHECK-LABEL: test_mm256_cmp_pd_neq_oq
  86   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"one", metadata !"fpexcept.strict")
  87   return _mm256_cmp_pd(a, b, _CMP_NEQ_OQ);
  88 }
  89
  90 __m256d test_mm256_cmp_pd_ge_os(__m256d a, __m256d b) {
  91   // CHECK-LABEL: test_mm256_cmp_pd_ge_os
  92   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"oge", metadata !"fpexcept.strict")
  93   return _mm256_cmp_pd(a, b, _CMP_GE_OS);
  94 }
  95
  96 __m256d test_mm256_cmp_pd_gt_os(__m256d a, __m256d b) {
  97   // CHECK-LABEL: test_mm256_cmp_pd_gt_os
  98   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"ogt", metadata !"fpexcept.strict")
  99   return _mm256_cmp_pd(a, b, _CMP_GT_OS);
 100 }
 101
 102 __m256d test_mm256_cmp_pd_true_uq(__m256d a, __m256d b) {
 103   // CHECK-LABEL: test_mm256_cmp_pd_true_uq
 104   // CHECK: call <4 x double> @llvm.x86.avx.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i8 15)
 105   return _mm256_cmp_pd(a, b, _CMP_TRUE_UQ);
 106 }
 107
 108 __m256d test_mm256_cmp_pd_eq_os(__m256d a, __m256d b) {
 109   // CHECK-LABEL: test_mm256_cmp_pd_eq_os
 110   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"oeq", metadata !"fpexcept.strict")
 111   return _mm256_cmp_pd(a, b, _CMP_EQ_OS);
 112 }
 113
 114 __m256d test_mm256_cmp_pd_lt_oq(__m256d a, __m256d b) {
 115   // CHECK-LABEL: test_mm256_cmp_pd_lt_oq
 116   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"olt", metadata !"fpexcept.strict")
 117   return _mm256_cmp_pd(a, b, _CMP_LT_OQ);
 118 }
 119
 120 __m256d test_mm256_cmp_pd_le_oq(__m256d a, __m256d b) {
 121   // CHECK-LABEL: test_mm256_cmp_pd_le_oq
 122   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"ole", metadata !"fpexcept.strict")
 123   return _mm256_cmp_pd(a, b, _CMP_LE_OQ);
 124 }
 125
 126 __m256d test_mm256_cmp_pd_unord_s(__m256d a, __m256d b) {
 127   // CHECK-LABEL: test_mm256_cmp_pd_unord_s
 128   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"uno", metadata !"fpexcept.strict")
 129   return _mm256_cmp_pd(a, b, _CMP_UNORD_S);
 130 }
 131
 132 __m256d test_mm256_cmp_pd_neq_us(__m256d a, __m256d b) {
 133   // CHECK-LABEL: test_mm256_cmp_pd_neq_us
 134   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"une", metadata !"fpexcept.strict")
 135   return _mm256_cmp_pd(a, b, _CMP_NEQ_US);
 136 }
 137
 138 __m256d test_mm256_cmp_pd_nlt_uq(__m256d a, __m256d b) {
 139   // CHECK-LABEL: test_mm256_cmp_pd_nlt_uq
 140   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"uge", metadata !"fpexcept.strict")
 141   return _mm256_cmp_pd(a, b, _CMP_NLT_UQ);
 142 }
 143
 144 __m256d test_mm256_cmp_pd_nle_uq(__m256d a, __m256d b) {
 145   // CHECK-LABEL: test_mm256_cmp_pd_nle_uq
 146   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"ugt", metadata !"fpexcept.strict")
 147   return _mm256_cmp_pd(a, b, _CMP_NLE_UQ);
 148 }
 149
 150 __m256d test_mm256_cmp_pd_ord_s(__m256d a, __m256d b) {
 151   // CHECK-LABEL: test_mm256_cmp_pd_ord_s
 152   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"ord", metadata !"fpexcept.strict")
 153   return _mm256_cmp_pd(a, b, _CMP_ORD_S);
 154 }
 155
 156 __m256d test_mm256_cmp_pd_eq_us(__m256d a, __m256d b) {
 157   // CHECK-LABEL: test_mm256_cmp_pd_eq_us
 158   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"ueq", metadata !"fpexcept.strict")
 159   return _mm256_cmp_pd(a, b, _CMP_EQ_US);
 160 }
 161
 162 __m256d test_mm256_cmp_pd_nge_uq(__m256d a, __m256d b) {
 163   // CHECK-LABEL: test_mm256_cmp_pd_nge_uq
 164   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"ult", metadata !"fpexcept.strict")
 165   return _mm256_cmp_pd(a, b, _CMP_NGE_UQ);
 166 }
 167
 168 __m256d test_mm256_cmp_pd_ngt_uq(__m256d a, __m256d b) {
 169   // CHECK-LABEL: test_mm256_cmp_pd_ngt_uq
 170   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"ule", metadata !"fpexcept.strict")
 171   return _mm256_cmp_pd(a, b, _CMP_NGT_UQ);
 172 }
 173
 174 __m256d test_mm256_cmp_pd_false_os(__m256d a, __m256d b) {
 175   // CHECK-LABEL: test_mm256_cmp_pd_false_os
 176   // CHECK: call <4 x double> @llvm.x86.avx.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i8 27)
 177   return _mm256_cmp_pd(a, b, _CMP_FALSE_OS);
 178 }
 179
 180 __m256d test_mm256_cmp_pd_neq_os(__m256d a, __m256d b) {
 181   // CHECK-LABEL: test_mm256_cmp_pd_neq_os
 182   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"one", metadata !"fpexcept.strict")
 183   return _mm256_cmp_pd(a, b, _CMP_NEQ_OS);
 184 }
 185
 186 __m256d test_mm256_cmp_pd_ge_oq(__m256d a, __m256d b) {
 187   // CHECK-LABEL: test_mm256_cmp_pd_ge_oq
 188   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"oge", metadata !"fpexcept.strict")
 189   return _mm256_cmp_pd(a, b, _CMP_GE_OQ);
 190 }
 191
 192 __m256d test_mm256_cmp_pd_gt_oq(__m256d a, __m256d b) {
 193   // CHECK-LABEL: test_mm256_cmp_pd_gt_oq
 194   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, metadata !"ogt", metadata !"fpexcept.strict")
 195   return _mm256_cmp_pd(a, b, _CMP_GT_OQ);
 196 }
 197
 198 __m256d test_mm256_cmp_pd_true_us(__m256d a, __m256d b) {
 199   // CHECK-LABEL: test_mm256_cmp_pd_true_us
 200   // CHECK: call <4 x double> @llvm.x86.avx.cmp.pd.256(<4 x double> %{{.*}}, <4 x double> %{{.*}}, i8 31)
 201   return _mm256_cmp_pd(a, b, _CMP_TRUE_US);
 202 }
 203
 204 __m256 test_mm256_cmp_ps_eq_oq(__m256 a, __m256 b) {
 205   // CHECK-LABEL: test_mm256_cmp_ps_eq_oq
 206   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"oeq", metadata !"fpexcept.strict")
 207   return _mm256_cmp_ps(a, b, _CMP_EQ_OQ);
 208 }
 209
 210 __m256 test_mm256_cmp_ps_lt_os(__m256 a, __m256 b) {
 211   // CHECK-LABEL: test_mm256_cmp_ps_lt_os
 212   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"olt", metadata !"fpexcept.strict")
 213   return _mm256_cmp_ps(a, b, _CMP_LT_OS);
 214 }
 215
 216 __m256 test_mm256_cmp_ps_le_os(__m256 a, __m256 b) {
 217   // CHECK-LABEL: test_mm256_cmp_ps_le_os
 218   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"ole", metadata !"fpexcept.strict")
 219   return _mm256_cmp_ps(a, b, _CMP_LE_OS);
 220 }
 221
 222 __m256 test_mm256_cmp_ps_unord_q(__m256 a, __m256 b) {
 223   // CHECK-LABEL: test_mm256_cmp_ps_unord_q
 224   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"uno", metadata !"fpexcept.strict")
 225   return _mm256_cmp_ps(a, b, _CMP_UNORD_Q);
 226 }
 227
 228 __m256 test_mm256_cmp_ps_neq_uq(__m256 a, __m256 b) {
 229   // CHECK-LABEL: test_mm256_cmp_ps_neq_uq
 230   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"une", metadata !"fpexcept.strict")
 231   return _mm256_cmp_ps(a, b, _CMP_NEQ_UQ);
 232 }
 233
 234 __m256 test_mm256_cmp_ps_nlt_us(__m256 a, __m256 b) {
 235   // CHECK-LABEL: test_mm256_cmp_ps_nlt_us
 236   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"uge", metadata !"fpexcept.strict")
 237   return _mm256_cmp_ps(a, b, _CMP_NLT_US);
 238 }
 239
 240 __m256 test_mm256_cmp_ps_nle_us(__m256 a, __m256 b) {
 241   // CHECK-LABEL: test_mm256_cmp_ps_nle_us
 242   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"ugt", metadata !"fpexcept.strict")
 243   return _mm256_cmp_ps(a, b, _CMP_NLE_US);
 244 }
 245
 246 __m256 test_mm256_cmp_ps_ord_q(__m256 a, __m256 b) {
 247   // CHECK-LABEL: test_mm256_cmp_ps_ord_q
 248   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"ord", metadata !"fpexcept.strict")
 249   return _mm256_cmp_ps(a, b, _CMP_ORD_Q);
 250 }
 251
 252 __m256 test_mm256_cmp_ps_eq_uq(__m256 a, __m256 b) {
 253   // CHECK-LABEL: test_mm256_cmp_ps_eq_uq
 254   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"ueq", metadata !"fpexcept.strict")
 255   return _mm256_cmp_ps(a, b, _CMP_EQ_UQ);
 256 }
 257
 258 __m256 test_mm256_cmp_ps_nge_us(__m256 a, __m256 b) {
 259   // CHECK-LABEL: test_mm256_cmp_ps_nge_us
 260   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"ult", metadata !"fpexcept.strict")
 261   return _mm256_cmp_ps(a, b, _CMP_NGE_US);
 262 }
 263
 264 __m256 test_mm256_cmp_ps_ngt_us(__m256 a, __m256 b) {
 265   // CHECK-LABEL: test_mm256_cmp_ps_ngt_us
 266   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"ule", metadata !"fpexcept.strict")
 267   return _mm256_cmp_ps(a, b, _CMP_NGT_US);
 268 }
 269
 270 __m256 test_mm256_cmp_ps_false_oq(__m256 a, __m256 b) {
 271   // CHECK-LABEL: test_mm256_cmp_ps_false_oq
 272   // CHECK: call <8 x float> @llvm.x86.avx.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i8 11)
 273   return _mm256_cmp_ps(a, b, _CMP_FALSE_OQ);
 274 }
 275
 276 __m256 test_mm256_cmp_ps_neq_oq(__m256 a, __m256 b) {
 277   // CHECK-LABEL: test_mm256_cmp_ps_neq_oq
 278   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"one", metadata !"fpexcept.strict")
 279   return _mm256_cmp_ps(a, b, _CMP_NEQ_OQ);
 280 }
 281
 282 __m256 test_mm256_cmp_ps_ge_os(__m256 a, __m256 b) {
 283   // CHECK-LABEL: test_mm256_cmp_ps_ge_os
 284   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"oge", metadata !"fpexcept.strict")
 285   return _mm256_cmp_ps(a, b, _CMP_GE_OS);
 286 }
 287
 288 __m256 test_mm256_cmp_ps_gt_os(__m256 a, __m256 b) {
 289   // CHECK-LABEL: test_mm256_cmp_ps_gt_os
 290   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"ogt", metadata !"fpexcept.strict")
 291   return _mm256_cmp_ps(a, b, _CMP_GT_OS);
 292 }
 293
 294 __m256 test_mm256_cmp_ps_true_uq(__m256 a, __m256 b) {
 295   // CHECK-LABEL: test_mm256_cmp_ps_true_uq
 296   // CHECK: call <8 x float> @llvm.x86.avx.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i8 15)
 297   return _mm256_cmp_ps(a, b, _CMP_TRUE_UQ);
 298 }
 299
 300 __m256 test_mm256_cmp_ps_eq_os(__m256 a, __m256 b) {
 301   // CHECK-LABEL: test_mm256_cmp_ps_eq_os
 302   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"oeq", metadata !"fpexcept.strict")
 303   return _mm256_cmp_ps(a, b, _CMP_EQ_OS);
 304 }
 305
 306 __m256 test_mm256_cmp_ps_lt_oq(__m256 a, __m256 b) {
 307   // CHECK-LABEL: test_mm256_cmp_ps_lt_oq
 308   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"olt", metadata !"fpexcept.strict")
 309   return _mm256_cmp_ps(a, b, _CMP_LT_OQ);
 310 }
 311
 312 __m256 test_mm256_cmp_ps_le_oq(__m256 a, __m256 b) {
 313   // CHECK-LABEL: test_mm256_cmp_ps_le_oq
 314   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"ole", metadata !"fpexcept.strict")
 315   return _mm256_cmp_ps(a, b, _CMP_LE_OQ);
 316 }
 317
 318 __m256 test_mm256_cmp_ps_unord_s(__m256 a, __m256 b) {
 319   // CHECK-LABEL: test_mm256_cmp_ps_unord_s
 320   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"uno", metadata !"fpexcept.strict")
 321   return _mm256_cmp_ps(a, b, _CMP_UNORD_S);
 322 }
 323
 324 __m256 test_mm256_cmp_ps_neq_us(__m256 a, __m256 b) {
 325   // CHECK-LABEL: test_mm256_cmp_ps_neq_us
 326   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"une", metadata !"fpexcept.strict")
 327   return _mm256_cmp_ps(a, b, _CMP_NEQ_US);
 328 }
 329
 330 __m256 test_mm256_cmp_ps_nlt_uq(__m256 a, __m256 b) {
 331   // CHECK-LABEL: test_mm256_cmp_ps_nlt_uq
 332   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"uge", metadata !"fpexcept.strict")
 333   return _mm256_cmp_ps(a, b, _CMP_NLT_UQ);
 334 }
 335
 336 __m256 test_mm256_cmp_ps_nle_uq(__m256 a, __m256 b) {
 337   // CHECK-LABEL: test_mm256_cmp_ps_nle_uq
 338   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"ugt", metadata !"fpexcept.strict")
 339   return _mm256_cmp_ps(a, b, _CMP_NLE_UQ);
 340 }
 341
 342 __m256 test_mm256_cmp_ps_ord_s(__m256 a, __m256 b) {
 343   // CHECK-LABEL: test_mm256_cmp_ps_ord_s
 344   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"ord", metadata !"fpexcept.strict")
 345   return _mm256_cmp_ps(a, b, _CMP_ORD_S);
 346 }
 347
 348 __m256 test_mm256_cmp_ps_eq_us(__m256 a, __m256 b) {
 349   // CHECK-LABEL: test_mm256_cmp_ps_eq_us
 350   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"ueq", metadata !"fpexcept.strict")
 351   return _mm256_cmp_ps(a, b, _CMP_EQ_US);
 352 }
 353
 354 __m256 test_mm256_cmp_ps_nge_uq(__m256 a, __m256 b) {
 355   // CHECK-LABEL: test_mm256_cmp_ps_nge_uq
 356   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"ult", metadata !"fpexcept.strict")
 357   return _mm256_cmp_ps(a, b, _CMP_NGE_UQ);
 358 }
 359
 360 __m256 test_mm256_cmp_ps_ngt_uq(__m256 a, __m256 b) {
 361   // CHECK-LABEL: test_mm256_cmp_ps_ngt_uq
 362   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"ule", metadata !"fpexcept.strict")
 363   return _mm256_cmp_ps(a, b, _CMP_NGT_UQ);
 364 }
 365
 366 __m256 test_mm256_cmp_ps_false_os(__m256 a, __m256 b) {
 367   // CHECK-LABEL: test_mm256_cmp_ps_false_os
 368   // CHECK: call <8 x float> @llvm.x86.avx.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i8 27)
 369   return _mm256_cmp_ps(a, b, _CMP_FALSE_OS);
 370 }
 371
 372 __m256 test_mm256_cmp_ps_neq_os(__m256 a, __m256 b) {
 373   // CHECK-LABEL: test_mm256_cmp_ps_neq_os
 374   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmps.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"one", metadata !"fpexcept.strict")
 375   return _mm256_cmp_ps(a, b, _CMP_NEQ_OS);
 376 }
 377
 378 __m256 test_mm256_cmp_ps_ge_oq(__m256 a, __m256 b) {
 379   // CHECK-LABEL: test_mm256_cmp_ps_ge_oq
 380   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"oge", metadata !"fpexcept.strict")
 381   return _mm256_cmp_ps(a, b, _CMP_GE_OQ);
 382 }
 383
 384 __m256 test_mm256_cmp_ps_gt_oq(__m256 a, __m256 b) {
 385   // CHECK-LABEL: test_mm256_cmp_ps_gt_oq
 386   // CHECK: call <8 x i1> @llvm.experimental.constrained.fcmp.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, metadata !"ogt", metadata !"fpexcept.strict")
 387   return _mm256_cmp_ps(a, b, _CMP_GT_OQ);
 388 }
 389
 390 __m256 test_mm256_cmp_ps_true_us(__m256 a, __m256 b) {
 391   // CHECK-LABEL: test_mm256_cmp_ps_true_us
 392   // CHECK: call <8 x float> @llvm.x86.avx.cmp.ps.256(<8 x float> %{{.*}}, <8 x float> %{{.*}}, i8 31)
 393   return _mm256_cmp_ps(a, b, _CMP_TRUE_US);
 394 }
 395
 396 __m128d test_mm_cmp_pd_eq_oq(__m128d a, __m128d b) {
 397   // CHECK-LABEL: test_mm_cmp_pd_eq_oq
 398   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"oeq", metadata !"fpexcept.strict")
 399   return _mm_cmp_pd(a, b, _CMP_EQ_OQ);
 400 }
 401
 402 __m128d test_mm_cmp_pd_lt_os(__m128d a, __m128d b) {
 403   // CHECK-LABEL: test_mm_cmp_pd_lt_os
 404   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"olt", metadata !"fpexcept.strict")
 405   return _mm_cmp_pd(a, b, _CMP_LT_OS);
 406 }
 407
 408 __m128d test_mm_cmp_pd_le_os(__m128d a, __m128d b) {
 409   // CHECK-LABEL: test_mm_cmp_pd_le_os
 410   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ole", metadata !"fpexcept.strict")
 411   return _mm_cmp_pd(a, b, _CMP_LE_OS);
 412 }
 413
 414 __m128d test_mm_cmp_pd_unord_q(__m128d a, __m128d b) {
 415   // CHECK-LABEL: test_mm_cmp_pd_unord_q
 416   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"uno", metadata !"fpexcept.strict")
 417   return _mm_cmp_pd(a, b, _CMP_UNORD_Q);
 418 }
 419
 420 __m128d test_mm_cmp_pd_neq_uq(__m128d a, __m128d b) {
 421   // CHECK-LABEL: test_mm_cmp_pd_neq_uq
 422   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"une", metadata !"fpexcept.strict")
 423   return _mm_cmp_pd(a, b, _CMP_NEQ_UQ);
 424 }
 425
 426 __m128d test_mm_cmp_pd_nlt_us(__m128d a, __m128d b) {
 427   // CHECK-LABEL: test_mm_cmp_pd_nlt_us
 428   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"uge", metadata !"fpexcept.strict")
 429   return _mm_cmp_pd(a, b, _CMP_NLT_US);
 430 }
 431
 432 __m128d test_mm_cmp_pd_nle_us(__m128d a, __m128d b) {
 433   // CHECK-LABEL: test_mm_cmp_pd_nle_us
 434   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ugt", metadata !"fpexcept.strict")
 435   return _mm_cmp_pd(a, b, _CMP_NLE_US);
 436 }
 437
 438 __m128d test_mm_cmp_pd_ord_q(__m128d a, __m128d b) {
 439   // CHECK-LABEL: test_mm_cmp_pd_ord_q
 440   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ord", metadata !"fpexcept.strict")
 441   return _mm_cmp_pd(a, b, _CMP_ORD_Q);
 442 }
 443
 444 __m128d test_mm_cmp_pd_eq_uq(__m128d a, __m128d b) {
 445   // CHECK-LABEL: test_mm_cmp_pd_eq_uq
 446   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ueq", metadata !"fpexcept.strict")
 447   return _mm_cmp_pd(a, b, _CMP_EQ_UQ);
 448 }
 449
 450 __m128d test_mm_cmp_pd_nge_us(__m128d a, __m128d b) {
 451   // CHECK-LABEL: test_mm_cmp_pd_nge_us
 452   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ult", metadata !"fpexcept.strict")
 453   return _mm_cmp_pd(a, b, _CMP_NGE_US);
 454 }
 455
 456 __m128d test_mm_cmp_pd_ngt_us(__m128d a, __m128d b) {
 457   // CHECK-LABEL: test_mm_cmp_pd_ngt_us
 458   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ule", metadata !"fpexcept.strict")
 459   return _mm_cmp_pd(a, b, _CMP_NGT_US);
 460 }
 461
 462 __m128d test_mm_cmp_pd_false_oq(__m128d a, __m128d b) {
 463   // CHECK-LABEL: test_mm_cmp_pd_false_oq
 464   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 11)
 465   return _mm_cmp_pd(a, b, _CMP_FALSE_OQ);
 466 }
 467
 468 __m128d test_mm_cmp_pd_neq_oq(__m128d a, __m128d b) {
 469   // CHECK-LABEL: test_mm_cmp_pd_neq_oq
 470   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"one", metadata !"fpexcept.strict")
 471   return _mm_cmp_pd(a, b, _CMP_NEQ_OQ);
 472 }
 473
 474 __m128d test_mm_cmp_pd_ge_os(__m128d a, __m128d b) {
 475   // CHECK-LABEL: test_mm_cmp_pd_ge_os
 476   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"oge", metadata !"fpexcept.strict")
 477   return _mm_cmp_pd(a, b, _CMP_GE_OS);
 478 }
 479
 480 __m128d test_mm_cmp_pd_gt_os(__m128d a, __m128d b) {
 481   // CHECK-LABEL: test_mm_cmp_pd_gt_os
 482   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ogt", metadata !"fpexcept.strict")
 483   return _mm_cmp_pd(a, b, _CMP_GT_OS);
 484 }
 485
 486 __m128d test_mm_cmp_pd_true_uq(__m128d a, __m128d b) {
 487   // CHECK-LABEL: test_mm_cmp_pd_true_uq
 488   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 15)
 489   return _mm_cmp_pd(a, b, _CMP_TRUE_UQ);
 490 }
 491
 492 __m128d test_mm_cmp_pd_eq_os(__m128d a, __m128d b) {
 493   // CHECK-LABEL: test_mm_cmp_pd_eq_os
 494   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"oeq", metadata !"fpexcept.strict")
 495   return _mm_cmp_pd(a, b, _CMP_EQ_OS);
 496 }
 497
 498 __m128d test_mm_cmp_pd_lt_oq(__m128d a, __m128d b) {
 499   // CHECK-LABEL: test_mm_cmp_pd_lt_oq
 500   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"olt", metadata !"fpexcept.strict")
 501   return _mm_cmp_pd(a, b, _CMP_LT_OQ);
 502 }
 503
 504 __m128d test_mm_cmp_pd_le_oq(__m128d a, __m128d b) {
 505   // CHECK-LABEL: test_mm_cmp_pd_le_oq
 506   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ole", metadata !"fpexcept.strict")
 507   return _mm_cmp_pd(a, b, _CMP_LE_OQ);
 508 }
 509
 510 __m128d test_mm_cmp_pd_unord_s(__m128d a, __m128d b) {
 511   // CHECK-LABEL: test_mm_cmp_pd_unord_s
 512   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"uno", metadata !"fpexcept.strict")
 513   return _mm_cmp_pd(a, b, _CMP_UNORD_S);
 514 }
 515
 516 __m128d test_mm_cmp_pd_neq_us(__m128d a, __m128d b) {
 517   // CHECK-LABEL: test_mm_cmp_pd_neq_us
 518   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"une", metadata !"fpexcept.strict")
 519   return _mm_cmp_pd(a, b, _CMP_NEQ_US);
 520 }
 521
 522 __m128d test_mm_cmp_pd_nlt_uq(__m128d a, __m128d b) {
 523   // CHECK-LABEL: test_mm_cmp_pd_nlt_uq
 524   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"uge", metadata !"fpexcept.strict")
 525   return _mm_cmp_pd(a, b, _CMP_NLT_UQ);
 526 }
 527
 528 __m128d test_mm_cmp_pd_nle_uq(__m128d a, __m128d b) {
 529   // CHECK-LABEL: test_mm_cmp_pd_nle_uq
 530   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ugt", metadata !"fpexcept.strict")
 531   return _mm_cmp_pd(a, b, _CMP_NLE_UQ);
 532 }
 533
 534 __m128d test_mm_cmp_pd_ord_s(__m128d a, __m128d b) {
 535   // CHECK-LABEL: test_mm_cmp_pd_ord_s
 536   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ord", metadata !"fpexcept.strict")
 537   return _mm_cmp_pd(a, b, _CMP_ORD_S);
 538 }
 539
 540 __m128d test_mm_cmp_pd_eq_us(__m128d a, __m128d b) {
 541   // CHECK-LABEL: test_mm_cmp_pd_eq_us
 542   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ueq", metadata !"fpexcept.strict")
 543   return _mm_cmp_pd(a, b, _CMP_EQ_US);
 544 }
 545
 546 __m128d test_mm_cmp_pd_nge_uq(__m128d a, __m128d b) {
 547   // CHECK-LABEL: test_mm_cmp_pd_nge_uq
 548   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ult", metadata !"fpexcept.strict")
 549   return _mm_cmp_pd(a, b, _CMP_NGE_UQ);
 550 }
 551
 552 __m128d test_mm_cmp_pd_ngt_uq(__m128d a, __m128d b) {
 553   // CHECK-LABEL: test_mm_cmp_pd_ngt_uq
 554   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ule", metadata !"fpexcept.strict")
 555   return _mm_cmp_pd(a, b, _CMP_NGT_UQ);
 556 }
 557
 558 __m128d test_mm_cmp_pd_false_os(__m128d a, __m128d b) {
 559   // CHECK-LABEL: test_mm_cmp_pd_false_os
 560   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 27)
 561   return _mm_cmp_pd(a, b, _CMP_FALSE_OS);
 562 }
 563
 564 __m128d test_mm_cmp_pd_neq_os(__m128d a, __m128d b) {
 565   // CHECK-LABEL: test_mm_cmp_pd_neq_os
 566   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmps.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"one", metadata !"fpexcept.strict")
 567   return _mm_cmp_pd(a, b, _CMP_NEQ_OS);
 568 }
 569
 570 __m128d test_mm_cmp_pd_ge_oq(__m128d a, __m128d b) {
 571   // CHECK-LABEL: test_mm_cmp_pd_ge_oq
 572   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"oge", metadata !"fpexcept.strict")
 573   return _mm_cmp_pd(a, b, _CMP_GE_OQ);
 574 }
 575
 576 __m128d test_mm_cmp_pd_gt_oq(__m128d a, __m128d b) {
 577   // CHECK-LABEL: test_mm_cmp_pd_gt_oq
 578   // CHECK: call <2 x i1> @llvm.experimental.constrained.fcmp.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, metadata !"ogt", metadata !"fpexcept.strict")
 579   return _mm_cmp_pd(a, b, _CMP_GT_OQ);
 580 }
 581
 582 __m128d test_mm_cmp_pd_true_us(__m128d a, __m128d b) {
 583   // CHECK-LABEL: test_mm_cmp_pd_true_us
 584   // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 31)
 585   return _mm_cmp_pd(a, b, _CMP_TRUE_US);
 586 }
 587
 588 __m128 test_mm_cmp_ps_eq_oq(__m128 a, __m128 b) {
 589   // CHECK-LABEL: test_mm_cmp_ps_eq_oq
 590   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"oeq", metadata !"fpexcept.strict")
 591   return _mm_cmp_ps(a, b, _CMP_EQ_OQ);
 592 }
 593
 594 __m128 test_mm_cmp_ps_lt_os(__m128 a, __m128 b) {
 595   // CHECK-LABEL: test_mm_cmp_ps_lt_os
 596   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"olt", metadata !"fpexcept.strict")
 597   return _mm_cmp_ps(a, b, _CMP_LT_OS);
 598 }
 599
 600 __m128 test_mm_cmp_ps_le_os(__m128 a, __m128 b) {
 601   // CHECK-LABEL: test_mm_cmp_ps_le_os
 602   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ole", metadata !"fpexcept.strict")
 603   return _mm_cmp_ps(a, b, _CMP_LE_OS);
 604 }
 605
 606 __m128 test_mm_cmp_ps_unord_q(__m128 a, __m128 b) {
 607   // CHECK-LABEL: test_mm_cmp_ps_unord_q
 608   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"uno", metadata !"fpexcept.strict")
 609   return _mm_cmp_ps(a, b, _CMP_UNORD_Q);
 610 }
 611
 612 __m128 test_mm_cmp_ps_neq_uq(__m128 a, __m128 b) {
 613   // CHECK-LABEL: test_mm_cmp_ps_neq_uq
 614   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"une", metadata !"fpexcept.strict")
 615   return _mm_cmp_ps(a, b, _CMP_NEQ_UQ);
 616 }
 617
 618 __m128 test_mm_cmp_ps_nlt_us(__m128 a, __m128 b) {
 619   // CHECK-LABEL: test_mm_cmp_ps_nlt_us
 620   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"uge", metadata !"fpexcept.strict")
 621   return _mm_cmp_ps(a, b, _CMP_NLT_US);
 622 }
 623
 624 __m128 test_mm_cmp_ps_nle_us(__m128 a, __m128 b) {
 625   // CHECK-LABEL: test_mm_cmp_ps_nle_us
 626   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ugt", metadata !"fpexcept.strict")
 627   return _mm_cmp_ps(a, b, _CMP_NLE_US);
 628 }
 629
 630 __m128 test_mm_cmp_ps_ord_q(__m128 a, __m128 b) {
 631   // CHECK-LABEL: test_mm_cmp_ps_ord_q
 632   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ord", metadata !"fpexcept.strict")
 633   return _mm_cmp_ps(a, b, _CMP_ORD_Q);
 634 }
 635
 636 __m128 test_mm_cmp_ps_eq_uq(__m128 a, __m128 b) {
 637   // CHECK-LABEL: test_mm_cmp_ps_eq_uq
 638   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ueq", metadata !"fpexcept.strict")
 639   return _mm_cmp_ps(a, b, _CMP_EQ_UQ);
 640 }
 641
 642 __m128 test_mm_cmp_ps_nge_us(__m128 a, __m128 b) {
 643   // CHECK-LABEL: test_mm_cmp_ps_nge_us
 644   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ult", metadata !"fpexcept.strict")
 645   return _mm_cmp_ps(a, b, _CMP_NGE_US);
 646 }
 647
 648 __m128 test_mm_cmp_ps_ngt_us(__m128 a, __m128 b) {
 649   // CHECK-LABEL: test_mm_cmp_ps_ngt_us
 650   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ule", metadata !"fpexcept.strict")
 651   return _mm_cmp_ps(a, b, _CMP_NGT_US);
 652 }
 653
 654 __m128 test_mm_cmp_ps_false_oq(__m128 a, __m128 b) {
 655   // CHECK-LABEL: test_mm_cmp_ps_false_oq
 656   // CHECK: call <4 x float> @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 11)
 657   return _mm_cmp_ps(a, b, _CMP_FALSE_OQ);
 658 }
 659
 660 __m128 test_mm_cmp_ps_neq_oq(__m128 a, __m128 b) {
 661   // CHECK-LABEL: test_mm_cmp_ps_neq_oq
 662   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"one", metadata !"fpexcept.strict")
 663   return _mm_cmp_ps(a, b, _CMP_NEQ_OQ);
 664 }
 665
 666 __m128 test_mm_cmp_ps_ge_os(__m128 a, __m128 b) {
 667   // CHECK-LABEL: test_mm_cmp_ps_ge_os
 668   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"oge", metadata !"fpexcept.strict")
 669   return _mm_cmp_ps(a, b, _CMP_GE_OS);
 670 }
 671
 672 __m128 test_mm_cmp_ps_gt_os(__m128 a, __m128 b) {
 673   // CHECK-LABEL: test_mm_cmp_ps_gt_os
 674   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ogt", metadata !"fpexcept.strict")
 675   return _mm_cmp_ps(a, b, _CMP_GT_OS);
 676 }
 677
 678 __m128 test_mm_cmp_ps_true_uq(__m128 a, __m128 b) {
 679   // CHECK-LABEL: test_mm_cmp_ps_true_uq
 680   // CHECK: call <4 x float> @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 15)
 681   return _mm_cmp_ps(a, b, _CMP_TRUE_UQ);
 682 }
 683
 684 __m128 test_mm_cmp_ps_eq_os(__m128 a, __m128 b) {
 685   // CHECK-LABEL: test_mm_cmp_ps_eq_os
 686   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"oeq", metadata !"fpexcept.strict")
 687   return _mm_cmp_ps(a, b, _CMP_EQ_OS);
 688 }
 689
 690 __m128 test_mm_cmp_ps_lt_oq(__m128 a, __m128 b) {
 691   // CHECK-LABEL: test_mm_cmp_ps_lt_oq
 692   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"olt", metadata !"fpexcept.strict")
 693   return _mm_cmp_ps(a, b, _CMP_LT_OQ);
 694 }
 695
 696 __m128 test_mm_cmp_ps_le_oq(__m128 a, __m128 b) {
 697   // CHECK-LABEL: test_mm_cmp_ps_le_oq
 698   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ole", metadata !"fpexcept.strict")
 699   return _mm_cmp_ps(a, b, _CMP_LE_OQ);
 700 }
 701
 702 __m128 test_mm_cmp_ps_unord_s(__m128 a, __m128 b) {
 703   // CHECK-LABEL: test_mm_cmp_ps_unord_s
 704   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"uno", metadata !"fpexcept.strict")
 705   return _mm_cmp_ps(a, b, _CMP_UNORD_S);
 706 }
 707
 708 __m128 test_mm_cmp_ps_neq_us(__m128 a, __m128 b) {
 709   // CHECK-LABEL: test_mm_cmp_ps_neq_us
 710   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"une", metadata !"fpexcept.strict")
 711   return _mm_cmp_ps(a, b, _CMP_NEQ_US);
 712 }
 713
 714 __m128 test_mm_cmp_ps_nlt_uq(__m128 a, __m128 b) {
 715   // CHECK-LABEL: test_mm_cmp_ps_nlt_uq
 716   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"uge", metadata !"fpexcept.strict")
 717   return _mm_cmp_ps(a, b, _CMP_NLT_UQ);
 718 }
 719
 720 __m128 test_mm_cmp_ps_nle_uq(__m128 a, __m128 b) {
 721   // CHECK-LABEL: test_mm_cmp_ps_nle_uq
 722   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ugt", metadata !"fpexcept.strict")
 723   return _mm_cmp_ps(a, b, _CMP_NLE_UQ);
 724 }
 725
 726 __m128 test_mm_cmp_ps_ord_s(__m128 a, __m128 b) {
 727   // CHECK-LABEL: test_mm_cmp_ps_ord_s
 728   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ord", metadata !"fpexcept.strict")
 729   return _mm_cmp_ps(a, b, _CMP_ORD_S);
 730 }
 731
 732 __m128 test_mm_cmp_ps_eq_us(__m128 a, __m128 b) {
 733   // CHECK-LABEL: test_mm_cmp_ps_eq_us
 734   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ueq", metadata !"fpexcept.strict")
 735   return _mm_cmp_ps(a, b, _CMP_EQ_US);
 736 }
 737
 738 __m128 test_mm_cmp_ps_nge_uq(__m128 a, __m128 b) {
 739   // CHECK-LABEL: test_mm_cmp_ps_nge_uq
 740   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ult", metadata !"fpexcept.strict")
 741   return _mm_cmp_ps(a, b, _CMP_NGE_UQ);
 742 }
 743
 744 __m128 test_mm_cmp_ps_ngt_uq(__m128 a, __m128 b) {
 745   // CHECK-LABEL: test_mm_cmp_ps_ngt_uq
 746   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ule", metadata !"fpexcept.strict")
 747   return _mm_cmp_ps(a, b, _CMP_NGT_UQ);
 748 }
 749
 750 __m128 test_mm_cmp_ps_false_os(__m128 a, __m128 b) {
 751   // CHECK-LABEL: test_mm_cmp_ps_false_os
 752   // CHECK: call <4 x float> @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 27)
 753   return _mm_cmp_ps(a, b, _CMP_FALSE_OS);
 754 }
 755
 756 __m128 test_mm_cmp_ps_neq_os(__m128 a, __m128 b) {
 757   // CHECK-LABEL: test_mm_cmp_ps_neq_os
 758   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmps.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"one", metadata !"fpexcept.strict")
 759   return _mm_cmp_ps(a, b, _CMP_NEQ_OS);
 760 }
 761
 762 __m128 test_mm_cmp_ps_ge_oq(__m128 a, __m128 b) {
 763   // CHECK-LABEL: test_mm_cmp_ps_ge_oq
 764   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"oge", metadata !"fpexcept.strict")
 765   return _mm_cmp_ps(a, b, _CMP_GE_OQ);
 766 }
 767
 768 __m128 test_mm_cmp_ps_gt_oq(__m128 a, __m128 b) {
 769   // CHECK-LABEL: test_mm_cmp_ps_gt_oq
 770   // CHECK: call <4 x i1> @llvm.experimental.constrained.fcmp.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, metadata !"ogt", metadata !"fpexcept.strict")
 771   return _mm_cmp_ps(a, b, _CMP_GT_OQ);
 772 }
 773
 774 __m128 test_mm_cmp_ps_true_us(__m128 a, __m128 b) {
 775   // CHECK-LABEL: test_mm_cmp_ps_true_us
 776   // CHECK: call <4 x float> @llvm.x86.sse.cmp.ps(<4 x float> %{{.*}}, <4 x float> %{{.*}}, i8 31)
 777   return _mm_cmp_ps(a, b, _CMP_TRUE_US);
 778 }