InstCombine: Fold fdiv nnan x, 0 -> copysign(inf, x)

[arsenm]

Summary

https://alive2.llvm.org/ce/z/gLBFKB

[kpn]

Precommit tests?

[arsenm]

Rebase on baseline tests

[kpn]

llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

1406

Is this part of a future change? I'm wondering if it belongs in this patch.

1427

This looks fine to me, but I'll let Sanjay give the word. I've never worked in InstCombine.

[arsenm]

llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

1406

No, this needed to move into the class for replaceInstUsesWith

[spatel]

llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

1420

If we're changing this function from static to a member of InstCombinerImpl, then we can use the already instantiated IRBuilder for the class, so it'd be something like:

CallInst *CopySign = Builder.CreateIntrinsic(...);

Alternatively, we can leave this function static and use the raw creator API:

Function *F = Intrinsic::getDeclaration(I.getModule(), Intrinsic::copysign, C->getType());
return CallInst::Create(F, {Infinity, I.getOperand(0)});

[arsenm]

Use existing IRBuilder

[spatel]

LGTM

[arsenm]

e661185fb3e5a94177404e474d6000f386594090

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

Value *foldAndOrOfICmpsOfAndWithPow2(ICmpInst *LHS, ICmpInst *RHS,
                                        Instruction *CxtI, bool IsAnd,
                                        bool IsLogical = false);
   Value *matchSelectFromAndOr(Value *A, Value *B, Value *C, Value *D);
   Value *getSelectCondition(Value *A, Value *B);
 
   Instruction *foldExtractOfOverflowIntrinsic(ExtractValueInst &EV);
   Instruction *foldIntrinsicWithOverflowCommon(IntrinsicInst *II);
   Instruction *foldFPSignBitOps(BinaryOperator &I);
+  Instruction *foldFDivConstantDivisor(BinaryOperator &I);
 
   // Optimize one of these forms:
   //   and i1 Op, SI / select i1 Op, i1 SI, i1 false (if IsAnd = true)
   //   or i1 Op, SI  / select i1 Op, i1 true, i1 SI  (if IsAnd = false)
   // into simplier select instruction using isImpliedCondition.
   Instruction *foldAndOrOfSelectUsingImpliedCond(Value *Op, SelectInst &SI,
                                                  bool IsAnd);
 

llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/ true, 0, &I)) {
       return BO;
     }
   }
 
   return nullptr;
 }
 
 /// Remove negation and try to convert division into multiplication.
-static Instruction *foldFDivConstantDivisor(BinaryOperator &I) {
+Instruction *InstCombinerImpl::foldFDivConstantDivisor(BinaryOperator &I) {
   Constant *C;
   if (!match(I.getOperand(1), m_Constant(C)))
     return nullptr;
 
   // -X / C --> X / -C
   Value *X;
   const DataLayout &DL = I.getModule()->getDataLayout();
   if (match(I.getOperand(0), m_FNeg(m_Value(X))))
     if (Constant *NegC = ConstantFoldUnaryOpOperand(Instruction::FNeg, C, DL))
       return BinaryOperator::CreateFDivFMF(X, NegC, &I);
 
+  // nnan X / +0.0 -> copysign(inf, X)
+  if (I.hasNoNaNs() && match(I.getOperand(1), m_Zero())) {
+    // TODO: nnan nsz X / -0.0 -> copysign(inf, X)
+    CallInst *CopySign = Builder.CreateIntrinsic(
+        Intrinsic::copysign, {C->getType()},
+        {ConstantFP::getInfinity(I.getType()), I.getOperand(0)}, &I);
+    CopySign->takeName(&I);
+    return replaceInstUsesWith(I, CopySign);
+  }
+
   // If the constant divisor has an exact inverse, this is always safe. If not,
   // then we can still create a reciprocal if fast-math-flags allow it and the
   // constant is a regular number (not zero, infinite, or denormal).
   if (!(C->hasExactInverseFP() || (I.hasAllowReciprocal() && C->isNormalFP())))
     return nullptr;
 
   // Disallow denormal constants because we don't know what would happen
   // on all targets.

llvm/test/Transforms/InstCombine/fdiv.ll

 ;
   %fdiv = fdiv float %x, 0.0
   ret float %fdiv
 }
 
 ; https://alive2.llvm.org/ce/z/gLBFKB
 define float @fdiv_nnan_zero_f32(float %x) {
 ; CHECK-LABEL: @fdiv_nnan_zero_f32(
-; CHECK-NEXT:    [[FDIV:%.*]] = fdiv nnan float [[X:%.*]], 0.000000e+00
+; CHECK-NEXT:    [[FDIV:%.*]] = call nnan float @llvm.copysign.f32(float 0x7FF0000000000000, float [[X:%.*]])
 ; CHECK-NEXT:    ret float [[FDIV]]
 ;
   %fdiv = fdiv nnan float %x, 0.0
   ret float %fdiv
 }
 
 define <2 x float> @fdiv_nnan_zero_v2f32(<2 x float> %x) {
 ; CHECK-LABEL: @fdiv_nnan_zero_v2f32(
-; CHECK-NEXT:    [[FDIV:%.*]] = fdiv nnan <2 x float> [[X:%.*]], zeroinitializer
+; CHECK-NEXT:    [[FDIV:%.*]] = call nnan <2 x float> @llvm.copysign.v2f32(<2 x float> <float 0x7FF0000000000000, float 0x7FF0000000000000>, <2 x float> [[X:%.*]])
 ; CHECK-NEXT:    ret <2 x float> [[FDIV]]
 ;
   %fdiv = fdiv nnan <2 x float> %x, zeroinitializer
   ret <2 x float> %fdiv
 }
 
 define float @fdiv_nnan_zero_f32_fmf(float %x) {
 ; CHECK-LABEL: @fdiv_nnan_zero_f32_fmf(
-; CHECK-NEXT:    [[FDIV:%.*]] = fdiv nnan nsz float [[X:%.*]], 0.000000e+00
+; CHECK-NEXT:    [[FDIV:%.*]] = call nnan nsz float @llvm.copysign.f32(float 0x7FF0000000000000, float [[X:%.*]])
 ; CHECK-NEXT:    ret float [[FDIV]]
 ;
   %fdiv = fdiv nnan nsz float %x, 0.0
   ret float %fdiv
 }
 
 define <2 x float> @fdiv_nnan_zero_v2f32_fmf(<2 x float> %x) {
 ; CHECK-LABEL: @fdiv_nnan_zero_v2f32_fmf(
-; CHECK-NEXT:    [[FDIV:%.*]] = fdiv nnan nsz <2 x float> [[X:%.*]], zeroinitializer
+; CHECK-NEXT:    [[FDIV:%.*]] = call nnan nsz <2 x float> @llvm.copysign.v2f32(<2 x float> <float 0x7FF0000000000000, float 0x7FF0000000000000>, <2 x float> [[X:%.*]])
 ; CHECK-NEXT:    ret <2 x float> [[FDIV]]
 ;
   %fdiv = fdiv nnan nsz <2 x float> %x, zeroinitializer
   ret <2 x float> %fdiv
 }
 
 define float @fdiv_nnan_neg_zero_f32(float %x) {
 ; CHECK-LABEL: @fdiv_nnan_neg_zero_f32(
 ; CHECK-NEXT:    [[FDIV:%.*]] = fdiv nnan float [[X:%.*]], -0.000000e+00
 ; CHECK-NEXT:    ret float [[FDIV]]
 ;
   %fdiv = fdiv nnan float %x, -0.0
   ret float %fdiv
 }