[InstCombine] Handle predicates for fold fcmp-of-copysign

[Chenbing.Zheng]

Summary

This patch complete predicates for fold fcmp-of-copysign

copysign(non-zero constant, X) <  0.0 --> (bitcast X) <  0
copysign(non-zero constant, X) >  0.0 --> (bitcast X) >  0
copysign(non-zero constant, X) <= 0.0 --> (bitcast X) <= 0
copysign(non-zero constant, X) >= 0.0 --> (bitcast X) >= 0

[spatel]

This is ok as a minimum enhancement, but it's not enough to remove the TODO entirely. We should be able to handle >=, <= too? Ordered vs. unordered does not matter?
Make a 'switch' to map FP predicates to integer predicates?

[Chenbing.Zheng]

address comment

[spatel]

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

6762–6763

This is not correct if X is 0.0 (0x00000000).
copysign(1.0, 0.0) <= 0.0 is false
(bitcast 0.0) <= 0 is true

Similarly:
copysign(1.0, 0.0) > 0.0 is true
(bitcast 0.0) > 0 is false

I don't think we can verify copysign with Alive2, so please write a test program to check edge values so we know the transform is always correct.

[spatel]

Also, please pre-commit the baseline tests for each new predicate.

[Chenbing.Zheng]

In D124150#3468367, @spatel wrote:

Also, please pre-commit the baseline tests for each new predicate.

I have committed other tests. But I have some doubts about this conversion now, so I want to abandon this commit first.

llvm/lib/Transforms/InstCombine/InstCombineCompares.cpp

if (match(Op1, m_APFloat(C))) {
         return new FCmpInst(Pred, X, NewC, "", &I);
       }
     }
   }
 
   // Convert a sign-bit test of an FP value into a cast and integer compare.
   // TODO: Simplify if the copysign constant is 0.0 or NaN.
   // TODO: Handle non-zero compare constants.
-  // TODO: Handle other predicates.
   const APFloat *C;
   if (match(Op0, m_OneUse(m_Intrinsic<Intrinsic::copysign>(m_APFloat(C),
                                                            m_Value(X)))) &&
       match(Op1, m_AnyZeroFP()) && !C->isZero() && !C->isNaN()) {
     Type *IntType = Builder.getIntNTy(X->getType()->getScalarSizeInBits());
     if (auto *VecTy = dyn_cast<VectorType>(OpType))
       IntType = VectorType::get(IntType, VecTy->getElementCount());
 
-    // copysign(non-zero constant, X) < 0.0 --> (bitcast X) < 0
-    if (Pred == FCmpInst::FCMP_OLT) {
-      Value *IntX = Builder.CreateBitCast(X, IntType);
-      return new ICmpInst(ICmpInst::ICMP_SLT, IntX,
+    // copysign(non-zero constant, X) <  0.0 --> (bitcast X) <  0
+    // copysign(non-zero constant, X) >  0.0 --> (bitcast X) >  0
+    // copysign(non-zero constant, X) <= 0.0 --> (bitcast X) <= 0
+    // copysign(non-zero constant, X) >= 0.0 --> (bitcast X) >= 0
+    switch (Pred) {
+    default:
+      break;
+    case FCmpInst::FCMP_OLT:
+    case FCmpInst::FCMP_ULT:
+      return new ICmpInst(ICmpInst::ICMP_SLT, Builder.CreateBitCast(X, IntType),
+                          ConstantInt::getNullValue(IntType));
+    case FCmpInst::FCMP_OGT:
+    case FCmpInst::FCMP_UGT:
+      return new ICmpInst(ICmpInst::ICMP_SGT, Builder.CreateBitCast(X, IntType),
+                          ConstantInt::getNullValue(IntType));
+    case FCmpInst::FCMP_OLE:
+    case FCmpInst::FCMP_ULE:
+      return new ICmpInst(ICmpInst::ICMP_SLE, Builder.CreateBitCast(X, IntType),
+                          ConstantInt::getNullValue(IntType));
+    case FCmpInst::FCMP_OGE:
+    case FCmpInst::FCMP_UGE:
+      return new ICmpInst(ICmpInst::ICMP_SGE, Builder.CreateBitCast(X, IntType),
                           ConstantInt::getNullValue(IntType));
     }
   }
 
   if (I.getType()->isVectorTy())
     if (Instruction *Res = foldVectorCmp(I, Builder))
       return Res;
 
   return Changed ? &I : nullptr;
 }

llvm/test/Transforms/InstCombine/fcmp.ll

 ; CHECK-NEXT:    [[R:%.*]] = icmp slt <2 x i64> [[TMP1]], zeroinitializer
 ; CHECK-NEXT:    ret <2 x i1> [[R]]
 ;
   %s = call <2 x double> @llvm.copysign.v2f64(<2 x double> <double 42.0, double 42.0>, <2 x double> %x)
   %r = fcmp olt <2 x double> %s, <double -0.0, double 0.0>
   ret <2 x i1> %r
 }
 
-; TODO: Handle different predicates.
-
 define i1 @is_signbit_clear(double %x) {
 ; CHECK-LABEL: @is_signbit_clear(
-; CHECK-NEXT:    [[S:%.*]] = call double @llvm.copysign.f64(double -4.200000e+01, double [[X:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fcmp ogt double [[S]], 0.000000e+00
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast double [[X:%.*]] to i64
+; CHECK-NEXT:    [[R:%.*]] = icmp sgt i64 [[TMP1]], 0
 ; CHECK-NEXT:    ret i1 [[R]]
 ;
   %s = call double @llvm.copysign.f64(double -42.0, double %x)
   %r = fcmp ogt double %s, 0.0
   ret i1 %r
 }
 
+define i1 @is_signbit_clear_1(double %x) {
+; CHECK-LABEL: @is_signbit_clear_1(
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast double [[X:%.*]] to i64
+; CHECK-NEXT:    [[R:%.*]] = icmp slt i64 [[TMP1]], 1
+; CHECK-NEXT:    ret i1 [[R]]
+;
+  %s = call double @llvm.copysign.f64(double -42.0, double %x)
+  %r = fcmp ule double %s, 0.0
+  ret i1 %r
+}
+
+define i1 @is_signbit_clear_2(double %x) {
+; CHECK-LABEL: @is_signbit_clear_2(
+; CHECK-NEXT:    [[TMP1:%.*]] = bitcast double [[X:%.*]] to i64
+; CHECK-NEXT:    [[R:%.*]] = icmp sgt i64 [[TMP1]], -1
+; CHECK-NEXT:    ret i1 [[R]]
+;
+  %s = call double @llvm.copysign.f64(double -42.0, double %x)
+  %r = fcmp uge double %s, 0.0
+  ret i1 %r
+}
+
 ; Negative test - uses
 
 define i1 @is_signbit_set_extra_use(double %x, double* %p) {
 ; CHECK-LABEL: @is_signbit_set_extra_use(
 ; CHECK-NEXT:    [[S:%.*]] = call double @llvm.copysign.f64(double 1.000000e+00, double [[X:%.*]])
 ; CHECK-NEXT:    store double [[S]], double* [[P:%.*]], align 8
 ; CHECK-NEXT:    [[R:%.*]] = fcmp olt double [[S]], 0.000000e+00
 ; CHECK-NEXT:    ret i1 [[R]]