InstCombine: Fold fneg (copysign x, y) -> copysign x, (fneg y)

[arsenm]

Move CreateCopySign to correct patch

[arsenm]

ping

[arsenm]

ping

[jcranmer-intel]

There might be some cases where we can maintain some fast-math flags that would otherwise be dropped... but it's almost certainly not worth the bother here, since I expect the vast majority of cases will have all the relevant operations have the same fast-math flags.

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

2443–2446

It took me some thinking through all the cases, but I'm now convinced that it's required that both the fneg and copysign *need* to get the intersection of fast-math flags.

[arsenm]

8ab032fbe5e4e27d44dc9da9c3289f741a3334c9

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

2443–2446

I eventually just wrote out all the cases and let alive2 tell me it was wrong

llvm/include/llvm/IR/IRBuilder.h

CallInst *CreateMinimum(Value *LHS, Value *RHS, const Twine &Name = "") {
     return CreateBinaryIntrinsic(Intrinsic::minimum, LHS, RHS, nullptr, Name);
   }
 
   /// Create call to the maximum intrinsic.
   CallInst *CreateMaximum(Value *LHS, Value *RHS, const Twine &Name = "") {
     return CreateBinaryIntrinsic(Intrinsic::maximum, LHS, RHS, nullptr, Name);
   }
 
+  /// Create call to the copysign intrinsic.
+  CallInst *CreateCopySign(Value *LHS, Value *RHS,
+                           Instruction *FMFSource = nullptr,
+                           const Twine &Name = "") {
+    return CreateBinaryIntrinsic(Intrinsic::copysign, LHS, RHS, FMFSource,
+                                 Name);
+  }
+
   /// Create a call to the arithmetic_fence intrinsic.
   CallInst *CreateArithmeticFence(Value *Val, Type *DstType,
                                   const Twine &Name = "") {
     return CreateIntrinsic(Intrinsic::arithmetic_fence, DstType, Val, nullptr,
                            Name);
   }
 
   /// Create a call to the vector.extract intrinsic.

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

Instruction *InstCombinerImpl::visitFNeg(UnaryOperator &I) {
   // If we can ignore the sign of zeros: -(X - Y) --> (Y - X)
   if (I.hasNoSignedZeros() &&
       match(Op, m_OneUse(m_FSub(m_Value(X), m_Value(Y)))))
     return BinaryOperator::CreateFSubFMF(Y, X, &I);
 
   if (Instruction *R = hoistFNegAboveFMulFDiv(I, Builder))
     return R;
 
+  Value *OneUse;
+  if (!match(Op, m_OneUse(m_Value(OneUse))))
+    return nullptr;
+
   // Try to eliminate fneg if at least 1 arm of the select is negated.
   Value *Cond;
-  if (match(Op, m_OneUse(m_Select(m_Value(Cond), m_Value(X), m_Value(Y))))) {
+  if (match(OneUse, m_Select(m_Value(Cond), m_Value(X), m_Value(Y)))) {
     // Unlike most transforms, this one is not safe to propagate nsz unless
     // it is present on the original select. (We are conservatively intersecting
     // the nsz flags from the select and root fneg instruction.)
     auto propagateSelectFMF = [&](SelectInst *S, bool CommonOperand) {
       S->copyFastMathFlags(&I);
       if (auto *OldSel = dyn_cast<SelectInst>(Op))
         if (!OldSel->hasNoSignedZeros() && !CommonOperand &&
             !isGuaranteedNotToBeUndefOrPoison(OldSel->getCondition()))
if (match(OneUse, m_Select(m_Value(Cond), m_Value(X), m_Value(Y)))) {
     if (match(Y, m_FNeg(m_Value(P)))) {
       Value *NegX = Builder.CreateFNegFMF(X, &I, X->getName() + ".neg");
       SelectInst *NewSel = SelectInst::Create(Cond, NegX, P);
       propagateSelectFMF(NewSel, P == X);
       return NewSel;
     }
   }
 
+  // fneg (copysign x, y) -> copysign x, (fneg y)
+  if (match(OneUse, m_CopySign(m_Value(X), m_Value(Y)))) {
+    // The source copysign has an additional value input, so we can't propagate
+    // flags the copysign doesn't also have.
+    FastMathFlags FMF = I.getFastMathFlags();
+    FMF &= cast<FPMathOperator>(OneUse)->getFastMathFlags();
+
+    IRBuilder<>::FastMathFlagGuard FMFGuard(Builder);
+    Builder.setFastMathFlags(FMF);
+
+    Value *NegY = Builder.CreateFNeg(Y);
+    Value *NewCopySign = Builder.CreateCopySign(X, NegY);
+    return replaceInstUsesWith(I, NewCopySign);
+  }
+
   return nullptr;
 }
 
 Instruction *InstCombinerImpl::visitFSub(BinaryOperator &I) {
   if (Value *V = simplifyFSubInst(I.getOperand(0), I.getOperand(1),
                                   I.getFastMathFlags(),
                                   getSimplifyQuery().getWithInstruction(&I)))
     return replaceInstUsesWith(I, V);

llvm/test/Transforms/InstCombine/copysign-fneg-fabs.ll

;
   %fabs.y = call half @llvm.fabs.f16(half %y)
   %fneg.fabs.y = fneg half %fabs.y
   %copysign = call half @llvm.copysign.f16(half %x, half %fneg.fabs.y)
   ret half %copysign
 }
 
 define half @fneg_copysign(half %x, half %y) {
 ; CHECK-LABEL: @fneg_copysign(
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = call half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]])
-; CHECK-NEXT:    [[FNEG_COPYSIGN:%.*]] = fneg half [[COPYSIGN]]
-; CHECK-NEXT:    ret half [[FNEG_COPYSIGN]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg half [[Y:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = call half @llvm.copysign.f16(half [[X:%.*]], half [[TMP1]])
+; CHECK-NEXT:    ret half [[TMP2]]
 ;
   %copysign = call half @llvm.copysign.f16(half %x, half %y)
   %fneg.copysign = fneg half %copysign
   ret half %fneg.copysign
 }
 
 define half @fneg_fabs_copysign(half %x, half %y) {
 ; CHECK-LABEL: @fneg_fabs_copysign(

 ;
   %copysign = call half @llvm.copysign.f16(half %x, half %y)
   %fabs.copysign = call half @llvm.fabs.f16(half %copysign)
   ret half %fabs.copysign
 }
 
 define <2 x half> @fneg_copysign_vector(<2 x half> %x, <2 x half> %y) {
 ; CHECK-LABEL: @fneg_copysign_vector(
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = call <2 x half> @llvm.copysign.v2f16(<2 x half> [[X:%.*]], <2 x half> [[Y:%.*]])
-; CHECK-NEXT:    [[FNEG_COPYSIGN:%.*]] = fneg <2 x half> [[COPYSIGN]]
-; CHECK-NEXT:    ret <2 x half> [[FNEG_COPYSIGN]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg <2 x half> [[Y:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = call <2 x half> @llvm.copysign.v2f16(<2 x half> [[X:%.*]], <2 x half> [[TMP1]])
+; CHECK-NEXT:    ret <2 x half> [[TMP2]]
 ;
   %copysign = call <2 x half> @llvm.copysign.v2f16(<2 x half> %x, <2 x half> %y)
   %fneg.copysign = fneg <2 x half> %copysign
   ret <2 x half> %fneg.copysign
 }
 
 define <2 x half> @fneg_fabs_copysign_vector(<2 x half> %x, <2 x half> %y) {
 ; CHECK-LABEL: @fneg_fabs_copysign_vector(

 ;
   %copysign = call <2 x half> @llvm.copysign.v2f16(<2 x half> %x, <2 x half> %y)
   %fabs.copysign = call <2 x half> @llvm.fabs.v2f16(<2 x half> %copysign)
   ret <2 x half> %fabs.copysign
 }
 
 define half @fneg_copysign_flags(half %x, half %y) {
 ; CHECK-LABEL: @fneg_copysign_flags(
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = call nnan nsz half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]])
-; CHECK-NEXT:    [[FNEG_COPYSIGN:%.*]] = fneg ninf nsz half [[COPYSIGN]]
-; CHECK-NEXT:    ret half [[FNEG_COPYSIGN]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg nsz half [[Y:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = call nsz half @llvm.copysign.f16(half [[X:%.*]], half [[TMP1]])
+; CHECK-NEXT:    ret half [[TMP2]]
 ;
   %copysign = call nnan nsz half @llvm.copysign.f16(half %x, half %y)
   %fneg.copysign = fneg ninf nsz half %copysign
   ret half %fneg.copysign
 }
 
 define half @fneg_fabs_copysign_flags(half %x, half %y) {
 ; CHECK-LABEL: @fneg_fabs_copysign_flags(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call nnan ninf afn half @llvm.fabs.f16(half [[X:%.*]])
 ; CHECK-NEXT:    [[FNEG_FABS_COPYSIGN:%.*]] = fneg reassoc ninf half [[TMP1]]
 ; CHECK-NEXT:    ret half [[FNEG_FABS_COPYSIGN]]
 ;
   %copysign = call nnan nsz ninf half @llvm.copysign.f16(half %x, half %y)
   %fabs.copysign = call nnan afn ninf half @llvm.fabs.f16(half %copysign)
   %fneg.fabs.copysign = fneg reassoc ninf half %fabs.copysign
   ret half %fneg.fabs.copysign
 }
 
 ; Make sure we don't break things by polluting copysign with nsz
 define half @fneg_nsz_copysign(half %x, half %y) {
 ; CHECK-LABEL: @fneg_nsz_copysign(
-; CHECK-NEXT:    [[COPYSIGN:%.*]] = call half @llvm.copysign.f16(half [[X:%.*]], half [[Y:%.*]])
-; CHECK-NEXT:    [[FNEG_COPYSIGN:%.*]] = fneg nsz half [[COPYSIGN]]
-; CHECK-NEXT:    ret half [[FNEG_COPYSIGN]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg half [[Y:%.*]]
+; CHECK-NEXT:    [[TMP2:%.*]] = call half @llvm.copysign.f16(half [[X:%.*]], half [[TMP1]])
+; CHECK-NEXT:    ret half [[TMP2]]
 ;
   %copysign = call half @llvm.copysign.f16(half %x, half %y)
   %fneg.copysign = fneg nsz half %copysign
   ret half %fneg.copysign
 }
 
 define half @fneg_fabs_copysign_flags_none_fabs(half %x, half %y) {
 ; CHECK-LABEL: @fneg_fabs_copysign_flags_none_fabs(