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

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