[X86] Fix some vector cmp builtins - TRUE/FALSE predicates

[GBuella]

Summary

This patch removes on optimization used with the TRUE/FALSE
predicates, as was suggested in https://reviews.llvm.org/D45616
for r335339.
The optimization was buggy, since r335339 used it also
for *_mask builtins, without actually applying the mask -- the
mask argument was just ignored.

[spatel]

test/CodeGen/avx-builtins.c

1423

Why are we deleting tests instead of replacing the CHECK lines with the new output?

[GBuella]

test/CodeGen/avx-builtins.c

1423

These cases were only added, when the TRUE/FALSE related special cases were added in CGBuiltin.cpp. Now that the special cases are removed from CGBuiltin.cpp, it seemed consistent to also remove the related special cases from the tests, as these are not special anymore.
Should we have tests with all predicates?

[spatel]

test/CodeGen/avx-builtins.c

1423

Yes. IIUC, we would have caught the bug before it was committed if we had proper tests for each predicate and C intrinsic.

[GBuella]

test/CodeGen/avx-builtins.c

1423

That is true!
I'll try to write a script that generates all cases, but not today.

[GBuella]

As suggested, I added test cases with all predicates (in r336346).

[GBuella]

ping @spatel

[spatel]

LGTM.

lib/CodeGen/CGBuiltin.cpp

case X86::BI__builtin_ia32_cmppd512_mask: {
     // range [0, 31]
     unsigned CC = cast<llvm::ConstantInt>(Ops[2])->getZExtValue() & 0x1f;
 
     // Lowering to IR fcmp instruction.
     // Ignoring requested signaling behaviour,
     // e.g. both _CMP_GT_OS & _CMP_GT_OQ are translated to FCMP_OGT.
     FCmpInst::Predicate Pred;
     switch (CC) {
-    case 0x00: Pred = FCmpInst::FCMP_OEQ; break;
-    case 0x01: Pred = FCmpInst::FCMP_OLT; break;
-    case 0x02: Pred = FCmpInst::FCMP_OLE; break;
-    case 0x03: Pred = FCmpInst::FCMP_UNO; break;
-    case 0x04: Pred = FCmpInst::FCMP_UNE; break;
-    case 0x05: Pred = FCmpInst::FCMP_UGE; break;
-    case 0x06: Pred = FCmpInst::FCMP_UGT; break;
-    case 0x07: Pred = FCmpInst::FCMP_ORD; break;
-    case 0x08: Pred = FCmpInst::FCMP_UEQ; break;
-    case 0x09: Pred = FCmpInst::FCMP_ULT; break;
-    case 0x0a: Pred = FCmpInst::FCMP_ULE; break;
-    case 0x0c: Pred = FCmpInst::FCMP_ONE; break;
-    case 0x0d: Pred = FCmpInst::FCMP_OGE; break;
-    case 0x0e: Pred = FCmpInst::FCMP_OGT; break;
-    case 0x10: Pred = FCmpInst::FCMP_OEQ; break;
-    case 0x11: Pred = FCmpInst::FCMP_OLT; break;
-    case 0x12: Pred = FCmpInst::FCMP_OLE; break;
-    case 0x13: Pred = FCmpInst::FCMP_UNO; break;
-    case 0x14: Pred = FCmpInst::FCMP_UNE; break;
-    case 0x15: Pred = FCmpInst::FCMP_UGE; break;
-    case 0x16: Pred = FCmpInst::FCMP_UGT; break;
-    case 0x17: Pred = FCmpInst::FCMP_ORD; break;
-    case 0x18: Pred = FCmpInst::FCMP_UEQ; break;
-    case 0x19: Pred = FCmpInst::FCMP_ULT; break;
-    case 0x1a: Pred = FCmpInst::FCMP_ULE; break;
-    case 0x1c: Pred = FCmpInst::FCMP_ONE; break;
-    case 0x1d: Pred = FCmpInst::FCMP_OGE; break;
-    case 0x1e: Pred = FCmpInst::FCMP_OGT; break;
-    // _CMP_TRUE_UQ, _CMP_TRUE_US produce -1,-1... vector
-    // on any input and _CMP_FALSE_OQ, _CMP_FALSE_OS produce 0, 0...
-    case 0x0b: // FALSE_OQ
-    case 0x1b: // FALSE_OS
-      return llvm::Constant::getNullValue(ConvertType(E->getType()));
-    case 0x0f: // TRUE_UQ
-    case 0x1f: // TRUE_US
-      return llvm::Constant::getAllOnesValue(ConvertType(E->getType()));
-
+    case 0x00: Pred = FCmpInst::FCMP_OEQ;   break;
+    case 0x01: Pred = FCmpInst::FCMP_OLT;   break;
+    case 0x02: Pred = FCmpInst::FCMP_OLE;   break;
+    case 0x03: Pred = FCmpInst::FCMP_UNO;   break;
+    case 0x04: Pred = FCmpInst::FCMP_UNE;   break;
+    case 0x05: Pred = FCmpInst::FCMP_UGE;   break;
+    case 0x06: Pred = FCmpInst::FCMP_UGT;   break;
+    case 0x07: Pred = FCmpInst::FCMP_ORD;   break;
+    case 0x08: Pred = FCmpInst::FCMP_UEQ;   break;
+    case 0x09: Pred = FCmpInst::FCMP_ULT;   break;
+    case 0x0a: Pred = FCmpInst::FCMP_ULE;   break;
+    case 0x0b: Pred = FCmpInst::FCMP_FALSE; break;
+    case 0x0c: Pred = FCmpInst::FCMP_ONE;   break;
+    case 0x0d: Pred = FCmpInst::FCMP_OGE;   break;
+    case 0x0e: Pred = FCmpInst::FCMP_OGT;   break;
+    case 0x0f: Pred = FCmpInst::FCMP_TRUE;  break;
+    case 0x10: Pred = FCmpInst::FCMP_OEQ;   break;
+    case 0x11: Pred = FCmpInst::FCMP_OLT;   break;
+    case 0x12: Pred = FCmpInst::FCMP_OLE;   break;
+    case 0x13: Pred = FCmpInst::FCMP_UNO;   break;
+    case 0x14: Pred = FCmpInst::FCMP_UNE;   break;
+    case 0x15: Pred = FCmpInst::FCMP_UGE;   break;
+    case 0x16: Pred = FCmpInst::FCMP_UGT;   break;
+    case 0x17: Pred = FCmpInst::FCMP_ORD;   break;
+    case 0x18: Pred = FCmpInst::FCMP_UEQ;   break;
+    case 0x19: Pred = FCmpInst::FCMP_ULT;   break;
+    case 0x1a: Pred = FCmpInst::FCMP_ULE;   break;
+    case 0x1b: Pred = FCmpInst::FCMP_FALSE; break;
+    case 0x1c: Pred = FCmpInst::FCMP_ONE;   break;
+    case 0x1d: Pred = FCmpInst::FCMP_OGE;   break;
+    case 0x1e: Pred = FCmpInst::FCMP_OGT;   break;
+    case 0x1f: Pred = FCmpInst::FCMP_TRUE;  break;
     default: llvm_unreachable("Unhandled CC");
     }
 
     // Builtins without the _mask suffix return a vector of integers
     // of the same width as the input vectors
     switch (BuiltinID) {
     case X86::BI__builtin_ia32_cmpps512_mask:
     case X86::BI__builtin_ia32_cmppd512_mask:

test/CodeGen/avx-builtins.c

 }
 
 float test_mm256_cvtss_f32(__m256 __a)
 {
   // CHECK-LABEL: @test_mm256_cvtss_f32
   // CHECK: extractelement <8 x float> %{{.*}}, i32 0
   return _mm256_cvtss_f32(__a);
 }
-
-__m256 test_mm256_cmp_ps_true(__m256 a, __m256 b) {
-  // CHECK-LABEL: @test_mm256_cmp_ps_true
-  // CHECK: ret <8 x float> <float 0xFFFFFFFFE0000000,
-  return _mm256_cmp_ps(a, b, _CMP_TRUE_UQ);
-}
-
-__m256d test_mm256_cmp_pd_true(__m256d a, __m256d b) {
-  // CHECK-LABEL: @test_mm256_cmp_pd_true
-  // CHECK: ret <4 x double> <double 0xFFFFFFFFFFFFFFFF,
-  return _mm256_cmp_pd(a, b, _CMP_TRUE_UQ);
-}
-
-__m256 test_mm256_cmp_ps_false(__m256 a, __m256 b) {
-  // CHECK-LABEL: @test_mm256_cmp_ps_false
-  // CHECK: ret <8 x float> zeroinitializer
-  return _mm256_cmp_ps(a, b, _CMP_FALSE_OQ);
-}
-
-__m256d test_mm256_cmp_pd_false(__m256d a, __m256d b) {
-  // CHECK-LABEL: @test_mm256_cmp_pd_false
-  // CHECK: ret <4 x double> zeroinitializer
-  return _mm256_cmp_pd(a, b, _CMP_FALSE_OQ);
-}
-
-__m256 test_mm256_cmp_ps_strue(__m256 a, __m256 b) {
-  // CHECK-LABEL: @test_mm256_cmp_ps_strue
-  // CHECK: ret <8 x float> <float 0xFFFFFFFFE0000000,
-  return _mm256_cmp_ps(a, b, _CMP_TRUE_US);
-}
-
-__m256d test_mm256_cmp_pd_strue(__m256d a, __m256d b) {
-  // CHECK-LABEL: @test_mm256_cmp_pd_strue
-  // CHECK: ret <4 x double> <double 0xFFFFFFFFFFFFFFFF,
-  return _mm256_cmp_pd(a, b, _CMP_TRUE_US);
-}
-
-__m256 test_mm256_cmp_ps_sfalse(__m256 a, __m256 b) {
-  // CHECK-LABEL: @test_mm256_cmp_ps_sfalse
-  // CHECK: ret <8 x float> zeroinitializer
-  return _mm256_cmp_ps(a, b, _CMP_FALSE_OS);
-}
-
-__m256d test_mm256_cmp_pd_sfalse(__m256d a, __m256d b) {
-  // CHECK-LABEL: @test_mm256_cmp_pd_sfalse
-  // CHECK: ret <4 x double> zeroinitializer
-  return _mm256_cmp_pd(a, b, _CMP_FALSE_OS);
-}
-
-__m128 test_mm_cmp_ps_true(__m128 a, __m128 b) {
-  // CHECK-LABEL: @test_mm_cmp_ps_true
-  // CHECK: ret <4 x float> <float 0xFFFFFFFFE0000000,
-  return _mm_cmp_ps(a, b, _CMP_TRUE_UQ);
-}
-
-__m128 test_mm_cmp_pd_true(__m128 a, __m128 b) {
-  // CHECK-LABEL: @test_mm_cmp_pd_true
-  // CHECK: ret <4 x float> <float 0xFFFFFFFFE0000000,
-  return _mm_cmp_pd(a, b, _CMP_TRUE_UQ);
-}
-
-__m128 test_mm_cmp_ps_false(__m128 a, __m128 b) {
-  // CHECK-LABEL: @test_mm_cmp_ps_false
-  // CHECK: ret <4 x float> zeroinitializer
-  return _mm_cmp_ps(a, b, _CMP_FALSE_OQ);
-}
-
-__m128 test_mm_cmp_pd_false(__m128 a, __m128 b) {
-  // CHECK-LABEL: @test_mm_cmp_pd_false
-  // CHECK: ret <4 x float> zeroinitializer
-  return _mm_cmp_pd(a, b, _CMP_FALSE_OQ);
-}
-
-__m128 test_mm_cmp_ps_strue(__m128 a, __m128 b) {
-  // CHECK-LABEL: @test_mm_cmp_ps_strue
-  // CHECK: ret <4 x float> <float 0xFFFFFFFFE0000000,
-  return _mm_cmp_ps(a, b, _CMP_TRUE_US);
-}
-
-__m128 test_mm_cmp_pd_strue(__m128 a, __m128 b) {
-  // CHECK-LABEL: @test_mm_cmp_pd_strue
-  // CHECK: ret <4 x float> <float 0xFFFFFFFFE0000000,
-  return _mm_cmp_pd(a, b, _CMP_TRUE_US);
-}
-
-__m128 test_mm_cmp_ps_sfalse(__m128 a, __m128 b) {
-  // CHECK-LABEL: @test_mm_cmp_ps_sfalse
-  // CHECK: ret <4 x float> zeroinitializer
-  return _mm_cmp_ps(a, b, _CMP_FALSE_OS);
-}
-
-__m128 test_mm_cmp_pd_sfalse(__m128 a, __m128 b) {
-  // CHECK-LABEL: @test_mm_cmp_pd_sfalse
-  // CHECK: ret <4 x float> zeroinitializer
-  return _mm_cmp_pd(a, b, _CMP_FALSE_OS);
-}

test/CodeGen/avx512f-builtins.c

 }
 
 __mmask16 test_mm512_cmp_ps_mask(__m512 a, __m512 b) {
   // CHECK-LABEL: @test_mm512_cmp_ps_mask
   // CHECK: fcmp oeq <16 x float> %{{.*}}, %{{.*}}
   return _mm512_cmp_ps_mask(a, b, 0);
 }
 
-__mmask16 test_mm512_cmp_ps_mask_true_uq(__m512 a, __m512 b) {
-  // CHECK-LABEL: @test_mm512_cmp_ps_mask_true_uq
-  // CHECK-NOT: call
-  // CHECK: ret i16 -1
-  return _mm512_cmp_ps_mask(a, b, _CMP_TRUE_UQ);
-}
-
-__mmask16 test_mm512_cmp_ps_mask_true_us(__m512 a, __m512 b) {
-  // CHECK-LABEL: @test_mm512_cmp_ps_mask_true_us
-  // CHECK-NOT: call
-  // CHECK: ret i16 -1
-  return _mm512_cmp_ps_mask(a, b, _CMP_TRUE_US);
-}
-
-__mmask16 test_mm512_cmp_ps_mask_false_oq(__m512 a, __m512 b) {
-  // CHECK-LABEL: @test_mm512_cmp_ps_mask_false_oq
-  // CHECK-NOT: call
-  // CHECK: ret i16 0
-  return _mm512_cmp_ps_mask(a, b, _CMP_FALSE_OQ);
-}
-
-__mmask16 test_mm512_cmp_ps_mask_false_os(__m512 a, __m512 b) {
-  // CHECK-LABEL: @test_mm512_cmp_ps_mask_false_os
-  // CHECK-NOT: call
-  // CHECK: ret i16 0
-  return _mm512_cmp_ps_mask(a, b, _CMP_FALSE_OS);
-}
-
 __mmask16 test_mm512_mask_cmp_ps_mask(__mmask16 m, __m512 a, __m512 b) {
   // CHECK-LABEL: @test_mm512_mask_cmp_ps_mask
   // CHECK: [[CMP:%.*]] = fcmp oeq <16 x float> %{{.*}}, %{{.*}}
   // CHECK: and <16 x i1> [[CMP]], {{.*}}
   return _mm512_mask_cmp_ps_mask(m, a, b, 0);
 }
 
 __mmask8 test_mm512_cmp_round_pd_mask(__m512d a, __m512d b) {

 }
 
 __mmask8 test_mm512_cmp_pd_mask(__m512d a, __m512d b) {
   // CHECK-LABEL: @test_mm512_cmp_pd_mask
   // CHECK: fcmp oeq <8 x double> %{{.*}}, %{{.*}}
   return _mm512_cmp_pd_mask(a, b, 0);
 }
 
-__mmask8 test_mm512_cmp_pd_mask_true_uq(__m512d a, __m512d b) {
-  // CHECK-LABEL: @test_mm512_cmp_pd_mask_true_uq
-  // CHECK-NOT: call
-  // CHECK: ret i8 -1
-  return _mm512_cmp_pd_mask(a, b, _CMP_TRUE_UQ);
-}
-
-__mmask8 test_mm512_cmp_pd_mask_true_us(__m512d a, __m512d b) {
-  // CHECK-LABEL: @test_mm512_cmp_pd_mask_true_us
-  // CHECK-NOT: call
-  // CHECK: ret i8 -1
-  return _mm512_cmp_pd_mask(a, b, _CMP_TRUE_US);
-}
-
-__mmask8 test_mm512_cmp_pd_mask_false_oq(__m512d a, __m512d b) {
-  // CHECK-LABEL: @test_mm512_cmp_pd_mask_false_oq
-  // CHECK-NOT: call
-  // CHECK: ret i8 0
-  return _mm512_cmp_pd_mask(a, b, _CMP_FALSE_OQ);
-}
-
-__mmask8 test_mm512_cmp_pd_mask_false_os(__m512d a, __m512d b) {
-  // CHECK-LABEL: @test_mm512_cmp_pd_mask_false_os
-  // CHECK-NOT: call
-  // CHECK: ret i8 0
-  return _mm512_cmp_pd_mask(a, b, _CMP_FALSE_OS);
-}
-
 __mmask8 test_mm512_mask_cmp_pd_mask(__mmask8 m, __m512d a, __m512d b) {
   // CHECK-LABEL: @test_mm512_mask_cmp_pd_mask
   // CHECK: [[CMP:%.*]] = fcmp oeq <8 x double> %{{.*}}, %{{.*}}
   // CHECK: and <8 x i1> [[CMP]], {{.*}}
   return _mm512_mask_cmp_pd_mask(m, a, b, 0);
 }
 
 __mmask8 test_mm512_cmpeq_pd_mask(__m512d a, __m512d b) {

test/CodeGen/avx512vl-builtins.c

 }
 
 __mmask8 test_mm256_cmp_ps_mask(__m256 __A, __m256 __B) {
   // CHECK-LABEL: @test_mm256_cmp_ps_mask
   // CHECK: fcmp oeq <8 x float> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_cmp_ps_mask(__A, __B, 0);
 }
 
-__mmask8 test_mm256_cmp_ps_mask_true_uq(__m256 __A, __m256 __B) {
-  // CHECK-LABEL: @test_mm256_cmp_ps_mask_true_uq
-  // CHECK-NOT: call
-  // CHECK: ret i8 -1
-  return (__mmask8)_mm256_cmp_ps_mask(__A, __B, _CMP_TRUE_UQ);
-}
-
-__mmask8 test_mm256_cmp_ps_mask_true_us(__m256 __A, __m256 __B) {
-  // CHECK-LABEL: @test_mm256_cmp_ps_mask_true_us
-  // CHECK-NOT: call
-  // CHECK: ret i8 -1
-  return (__mmask8)_mm256_cmp_ps_mask(__A, __B, _CMP_TRUE_US);
-}
-
-__mmask8 test_mm256_cmp_ps_mask_false_oq(__m256 __A, __m256 __B) {
-  // CHECK-LABEL: @test_mm256_cmp_ps_mask_false_oq
-  // CHECK-NOT: call
-  // CHECK: ret i8 0
-  return (__mmask8)_mm256_cmp_ps_mask(__A, __B, _CMP_FALSE_OQ);
-}
-
-__mmask8 test_mm256_cmp_ps_mask_false_os(__m256 __A, __m256 __B) {
-  // CHECK-LABEL: @test_mm256_cmp_ps_mask_false_os
-  // CHECK-NOT: call
-  // CHECK: ret i8 0
-  return (__mmask8)_mm256_cmp_ps_mask(__A, __B, _CMP_FALSE_OS);
-}
-
 __mmask8 test_mm256_mask_cmp_ps_mask(__mmask8 m, __m256 __A, __m256 __B) {
   // CHECK-LABEL: @test_mm256_mask_cmp_ps_mask
   // CHECK: fcmp oeq <8 x float> %{{.*}}, %{{.*}}
   // CHECK: and <8 x i1> %{{.*}}, %{{.*}}
   return _mm256_mask_cmp_ps_mask(m, __A, __B, 0);
 }
 
 __mmask8 test_mm_cmp_ps_mask(__m128 __A, __m128 __B) {
   // CHECK-LABEL: @test_mm_cmp_ps_mask
   // CHECK: fcmp oeq <4 x float> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmp_ps_mask(__A, __B, 0);
 }
 
-__mmask8 test_mm_cmp_ps_mask_true_uq(__m128 __A, __m128 __B) {
-  // CHECK-LABEL: @test_mm_cmp_ps_mask_true_uq
-  // CHECK-NOT: call
-  // CHECK: ret i8 -1
-  return (__mmask8)_mm_cmp_ps_mask(__A, __B, _CMP_TRUE_UQ);
-}
-
-__mmask8 test_mm_cmp_ps_mask_true_us(__m128 __A, __m128 __B) {
-  // CHECK-LABEL: @test_mm_cmp_ps_mask_true_us
-  // CHECK-NOT: call
-  // CHECK: ret i8 -1
-  return (__mmask8)_mm_cmp_ps_mask(__A, __B, _CMP_TRUE_US);
-}
-
-__mmask8 test_mm_cmp_ps_mask_false_oq(__m128 __A, __m128 __B) {
-  // CHECK-LABEL: @test_mm_cmp_ps_mask_false_oq
-  // CHECK-NOT: call
-  // CHECK: ret i8 0
-  return (__mmask8)_mm_cmp_ps_mask(__A, __B, _CMP_FALSE_OQ);
-}
-
-__mmask8 test_mm_cmp_ps_mask_false_os(__m128 __A, __m128 __B) {
-  // CHECK-LABEL: @test_mm_cmp_ps_mask_false_os
-  // CHECK-NOT: call
-  // CHECK: ret i8 0
-  return (__mmask8)_mm_cmp_ps_mask(__A, __B, _CMP_FALSE_OS);
-}
-
 __mmask8 test_mm_mask_cmp_ps_mask(__mmask8 m, __m128 __A, __m128 __B) {
   // CHECK-LABEL: @test_mm_mask_cmp_ps_mask
   // CHECK: fcmp oeq <4 x float> %{{.*}}, %{{.*}}
   // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return _mm_mask_cmp_ps_mask(m, __A, __B, 0);
 }
 
 __mmask8 test_mm256_cmp_pd_mask(__m256d __A, __m256d __B) {
   // CHECK-LABEL: @test_mm256_cmp_pd_mask
   // CHECK: fcmp oeq <4 x double> %{{.*}}, %{{.*}}
   return (__mmask8)_mm256_cmp_pd_mask(__A, __B, 0);
 }
 
-__mmask8 test_mm256_cmp_pd_mask_true_uq(__m256d __A, __m256d __B) {
-  // CHECK-LABEL: @test_mm256_cmp_pd_mask_true_uq
-  // CHECK-NOT: call
-  // CHECK: ret i8 -1
-  return (__mmask8)_mm256_cmp_pd_mask(__A, __B, _CMP_TRUE_UQ);
-}
-
-__mmask8 test_mm256_cmp_pd_mask_true_us(__m256d __A, __m256d __B) {
-  // CHECK-LABEL: @test_mm256_cmp_pd_mask_true_us
-  // CHECK-NOT: call
-  // CHECK: ret i8 -1
-  return (__mmask8)_mm256_cmp_pd_mask(__A, __B, _CMP_TRUE_US);
-}
-
-__mmask8 test_mm256_cmp_pd_mask_false_oq(__m256d __A, __m256d __B) {
-  // CHECK-LABEL: @test_mm256_cmp_pd_mask_false_oq
-  // CHECK-NOT: call
-  // CHECK: ret i8 0
-  return (__mmask8)_mm256_cmp_pd_mask(__A, __B, _CMP_FALSE_OQ);
-}
-
-__mmask8 test_mm256_cmp_pd_mask_false_os(__m256d __A, __m256d __B) {
-  // CHECK-LABEL: @test_mm256_cmp_pd_mask_false_os
-  // CHECK-NOT: call
-  // CHECK: ret i8 0
-  return (__mmask8)_mm256_cmp_pd_mask(__A, __B, _CMP_FALSE_OS);
-}
-
 __mmask8 test_mm256_mask_cmp_pd_mask(__mmask8 m, __m256d __A, __m256d __B) {
   // CHECK-LABEL: @test_mm256_mask_cmp_pd_mask
   // CHECK: fcmp oeq <4 x double> %{{.*}}, %{{.*}}
   // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
   // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return _mm256_mask_cmp_pd_mask(m, __A, __B, 0);
 }
 
 __mmask8 test_mm_cmp_pd_mask(__m128d __A, __m128d __B) {
   // CHECK-LABEL: @test_mm_cmp_pd_mask
   // CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}}
   return (__mmask8)_mm_cmp_pd_mask(__A, __B, 0);
 }
 
-__mmask8 test_mm_cmp_pd_mask_true_uq(__m128d __A, __m128d __B) {
-  // CHECK-LABEL: @test_mm_cmp_pd_mask_true_uq
-  // CHECK-NOT: call
-  // CHECK: ret i8 -1
-  return (__mmask8)_mm_cmp_pd_mask(__A, __B, _CMP_TRUE_UQ);
-}
-
-__mmask8 test_mm_cmp_pd_mask_true_us(__m128d __A, __m128d __B) {
-  // CHECK-LABEL: @test_mm_cmp_pd_mask_true_us
-  // CHECK-NOT: call
-  // CHECK: ret i8 -1
-  return (__mmask8)_mm_cmp_pd_mask(__A, __B, _CMP_TRUE_US);
-}
-
-__mmask8 test_mm_cmp_pd_mask_false_oq(__m128d __A, __m128d __B) {
-  // CHECK-LABEL: @test_mm_cmp_pd_mask_false_oq
-  // CHECK-NOT: call
-  // CHECK: ret i8 0
-  return (__mmask8)_mm_cmp_pd_mask(__A, __B, _CMP_FALSE_OQ);
-}
-
-__mmask8 test_mm_cmp_pd_mask_false_os(__m128d __A, __m128d __B) {
-  // CHECK-LABEL: @test_mm_cmp_pd_mask_false_os
-  // CHECK-NOT: call
-  // CHECK: ret i8 0
-  return (__mmask8)_mm_cmp_pd_mask(__A, __B, _CMP_FALSE_OS);
-}
-
 __mmask8 test_mm_mask_cmp_pd_mask(__mmask8 m, __m128d __A, __m128d __B) {
   // CHECK-LABEL: @test_mm_mask_cmp_pd_mask
   // CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}}
   // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <2 x i32> <i32 0, i32 1>
   // CHECK: and <2 x i1> %{{.*}}, %{{.*}}
   return _mm_mask_cmp_pd_mask(m, __A, __B, 0);
 }