InstCombine: Fold negations of is_fpclass intrinsics

[arsenm]

Summary

Can invert the result by inverting the test mask.

[sepavloff]

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

3715–3717

It must work for IEEE numbers. But for non-IEEE it is possible that a value does not belong to any of the classes known to is_fpclass. For example, type x86_fp80 has so-called unsupported values. Do you think this transformation can be safely applied to such numbers also or it is better to limit it to IEEE numbers only?

[arsenm]

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

3715–3717

I don't know anything about x87. How is the intrinsic lowered for it?

Is it just these "pseudo-X" cases? I'd assume those are covered by the non-pseudo tests?

[sepavloff]

LGTM.

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

3715–3717

Yes, these are pseudo numbers. They are mapped to IEEE classes in more complex way, for example glibc recognizes pseudo-infinity as a NaN, and pseudo-denormals as normals.

Nevertheless any such number is mapped to one of IEEE classes and this optimization must work no matter how the mapping is realized.

[jcranmer-intel]

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

3715–3717

From what I can tell, all of the non-standard values for x86_fp80 are mapped to returns true iff is_fpclass checks for both sNaN and qNaN, but not solely one.

I think ~is_fpclass(x, mask) => is_fpclass(x, ~mask) is a valid transformation even for x86_fp80, even with this weird quirk.

[arsenm]

19d428f717e773d9c74f5a8452c68c1bb56fc6f0

llvm/lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

if (match(NotOp, m_MaxOrMin(m_Value(X), m_Value(Y))) &&
       return replaceInstUsesWith(I, InvMaxMin);
     }
     if (match(NotOp, m_c_MaxOrMin(m_Not(m_Value(X)), m_Value(Y)))) {
       Intrinsic::ID InvID = getInverseMinMaxIntrinsic(II->getIntrinsicID());
       Value *NotY = Builder.CreateNot(Y);
       Value *InvMaxMin = Builder.CreateBinaryIntrinsic(InvID, X, NotY);
       return replaceInstUsesWith(I, InvMaxMin);
     }
+
+    if (II->getIntrinsicID() == Intrinsic::is_fpclass) {
+      ConstantInt *ClassMask = cast<ConstantInt>(II->getArgOperand(1));
+      II->setArgOperand(
+          1, ConstantInt::get(ClassMask->getType(),
+                              ~ClassMask->getZExtValue() & fcAllFlags));
+      return replaceInstUsesWith(I, II);
+    }
   }
 
   if (NotOp->hasOneUse()) {
     // Pull 'not' into operands of select if both operands are one-use compares
     // or one is one-use compare and the other one is a constant.
     // Inverting the predicates eliminates the 'not' operation.
     // Example:
     //   not (select ?, (cmp TPred, ?, ?), (cmp FPred, ?, ?) -->

llvm/test/Transforms/InstCombine/is_fpclass.ll

;
   %class = call i1 @llvm.is.fpclass.f32(float %x, i32 3)
   store i1 %class, ptr %ptr
   %not = xor i1 %class, true
   ret i1 %not
 }
 
 define i1 @test_class_not_is_inf_nan(float %x) {
 ; CHECK-LABEL: @test_class_not_is_inf_nan(
-; CHECK-NEXT:    [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[X:%.*]], i32 519)
-; CHECK-NEXT:    [[NOT:%.*]] = xor i1 [[CLASS]], true
-; CHECK-NEXT:    ret i1 [[NOT]]
+; CHECK-NEXT:    [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[X:%.*]], i32 504)
+; CHECK-NEXT:    ret i1 [[CLASS]]
 ;
   %class = call i1 @llvm.is.fpclass.f32(float %x, i32 519)
   %not = xor i1 %class, true
   ret i1 %not
 }
 
 define i1 @test_class_not_is_normal(float %x) {
 ; CHECK-LABEL: @test_class_not_is_normal(
-; CHECK-NEXT:    [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[X:%.*]], i32 264)
-; CHECK-NEXT:    [[NOT:%.*]] = xor i1 [[CLASS]], true
-; CHECK-NEXT:    ret i1 [[NOT]]
+; CHECK-NEXT:    [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[X:%.*]], i32 759)
+; CHECK-NEXT:    ret i1 [[CLASS]]
 ;
   %class = call i1 @llvm.is.fpclass.f32(float %x, i32 264)
   %not = xor i1 %class, true
   ret i1 %not
 }
 
 define i1 @test_class_xor_false(float %x) {
 ; CHECK-LABEL: @test_class_xor_false(
 ; CHECK-NEXT:    [[CLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[X:%.*]], i32 33)
 ; CHECK-NEXT:    ret i1 [[CLASS]]
 ;
   %class = call i1 @llvm.is.fpclass.f32(float %x, i32 33)
   %not = xor i1 %class, false
   ret i1 %not
 }
 
 define <2 x i1> @test_class_not_vector(<2 x float> %x) {
 ; CHECK-LABEL: @test_class_not_vector(
-; CHECK-NEXT:    [[CLASS:%.*]] = call <2 x i1> @llvm.is.fpclass.v2f32(<2 x float> [[X:%.*]], i32 33)
-; CHECK-NEXT:    [[NOT:%.*]] = xor <2 x i1> [[CLASS]], <i1 true, i1 true>
-; CHECK-NEXT:    ret <2 x i1> [[NOT]]
+; CHECK-NEXT:    [[CLASS:%.*]] = call <2 x i1> @llvm.is.fpclass.v2f32(<2 x float> [[X:%.*]], i32 990)
+; CHECK-NEXT:    ret <2 x i1> [[CLASS]]
 ;
   %class = call <2 x i1> @llvm.is.fpclass.v2f32(<2 x float> %x, i32 33)
   %not = xor <2 x i1> %class, <i1 true, i1 true>
   ret <2 x i1> %not
 }
 
 define <2 x i1> @test_class_xor_vector(<2 x float> %x) {
 ; CHECK-LABEL: @test_class_xor_vector(