InstCombine: Fold fneg (ldexp x, n) -> ldexp (fneg x), n

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

2532

Seems like 2 changes at once? The change to oneuse checks of (fneg (fmul/fdiv)) and the new transform. Maybe split?

llvm/test/Transforms/InstCombine/fneg.ll

989

Can you precommit the tests?

[arsenm]

Precommit test

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

2532

It's not behaviorally changing, it's just avoiding repeating it 3x

[arsenm]

Rebase

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

2529–2533

IRBuilder is unused?

2531

style: No branches around single expression if

2536

ibid

llvm/test/Transforms/InstCombine/fneg.ll

989

This was erroneously marked done?

[arsenm]

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

2529–2533

It's a flag guard, it only does anything on destruct. The actual builder is the member

2531

It covers multiple lines

[jcranmer-intel]

llvm/test/Transforms/InstCombine/fneg.ll

840

The optimization doesn't seem to be kicking in for these tests?

[arsenm]

Fix diff after test split

[arsenm]

Rebase and ping

[goldstein.w.n]

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

2538

Doesn't exponent need to by odd for this? I.e

-(X ^ 2) != ((-X) ^ 2).

[arsenm]

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

2538

It’s not a square, it’s X * 2^N

[goldstein.w.n]

LGTM.

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

2538

Err yeah :/

[arsenm]

f7f5d348a315d96c907b57e6cafea4cbcb620340

[foad]

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

395

Function needs a comment and a better name, since it doesn't just handle fmul and fdiv now.

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

static Instruction *foldFNegIntoConstant(Instruction &I, const DataLayout &DL) {
   // -(X + C) --> -X + -C --> -C - X
   if (I.hasNoSignedZeros() && match(FNegOp, m_FAdd(m_Value(X), m_Constant(C))))
     if (Constant *NegC = ConstantFoldUnaryOpOperand(Instruction::FNeg, C, DL))
       return BinaryOperator::CreateFSubFMF(NegC, X, &I);
 
   return nullptr;
 }
 
-static Instruction *hoistFNegAboveFMulFDiv(Instruction &I,
-                                           InstCombiner::BuilderTy &Builder) {
+Instruction *InstCombinerImpl::hoistFNegAboveFMulFDiv(Instruction &I) {
   Value *FNeg;
-  if (!match(&I, m_FNeg(m_Value(FNeg))))
+  if (!match(&I, m_FNeg(m_OneUse(m_Value(FNeg)))))
     return nullptr;
 
   Value *X, *Y;
-  if (match(FNeg, m_OneUse(m_FMul(m_Value(X), m_Value(Y)))))
+  if (match(FNeg, m_FMul(m_Value(X), m_Value(Y))))
     return BinaryOperator::CreateFMulFMF(Builder.CreateFNegFMF(X, &I), Y, &I);
 
-  if (match(FNeg, m_OneUse(m_FDiv(m_Value(X), m_Value(Y)))))
+  if (match(FNeg, m_FDiv(m_Value(X), m_Value(Y))))
     return BinaryOperator::CreateFDivFMF(Builder.CreateFNegFMF(X, &I), Y, &I);
 
+  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(FNeg)) {
+    // Make sure to preserve flags and metadata on the call.
+    if (II->getIntrinsicID() == Intrinsic::ldexp) {
+      FastMathFlags FMF = I.getFastMathFlags();
+      FMF |= II->getFastMathFlags();
+
+      IRBuilder<>::FastMathFlagGuard FMFGuard(Builder);
+      Builder.setFastMathFlags(FMF);
+
+      CallInst *New = Builder.CreateCall(
+          II->getCalledFunction(),
+          {Builder.CreateFNeg(II->getArgOperand(0)), II->getArgOperand(1)});
+      New->copyMetadata(*II);
+      return replaceInstUsesWith(I, New);
+    }
+  }
+
   return nullptr;
 }
 
 Instruction *InstCombinerImpl::visitFNeg(UnaryOperator &I) {
   Value *Op = I.getOperand(0);
 
   if (Value *V = simplifyFNegInst(Op, I.getFastMathFlags(),
                                   getSimplifyQuery().getWithInstruction(&I)))
     return replaceInstUsesWith(I, V);
 
   if (Instruction *X = foldFNegIntoConstant(I, DL))
     return X;
 
   Value *X, *Y;
 
   // 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))
+  if (Instruction *R = hoistFNegAboveFMulFDiv(I))
     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;
Instruction *InstCombinerImpl::visitFSub(BinaryOperator &I) {
   // fneg Denorm ==> -Denorm
   Value *Op;
   if (match(&I, m_FNeg(m_Value(Op))))
     return UnaryOperator::CreateFNegFMF(Op, &I);
 
   if (Instruction *X = foldFNegIntoConstant(I, DL))
     return X;
 
-  if (Instruction *R = hoistFNegAboveFMulFDiv(I, Builder))
+  if (Instruction *R = hoistFNegAboveFMulFDiv(I))
     return R;
 
   Value *X, *Y;
   Constant *C;
 
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
   // If Op0 is not -0.0 or we can ignore -0.0: Z - (X - Y) --> Z + (Y - X)
   // Canonicalize to fadd to make analysis easier.

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

private:
 
   // 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);
 
+  Instruction *hoistFNegAboveFMulFDiv(Instruction &I);
+
 public:
   /// Create and insert the idiom we use to indicate a block is unreachable
   /// without having to rewrite the CFG from within InstCombine.
   void CreateNonTerminatorUnreachable(Instruction *InsertAt) {
     auto &Ctx = InsertAt->getContext();
     auto *SI = new StoreInst(ConstantInt::getTrue(Ctx),
                              PoisonValue::get(Type::getInt1PtrTy(Ctx)),
                              /*isVolatile*/ false, Align(1));

llvm/test/Transforms/InstCombine/fneg.ll

;
   %s = select i1 %b, float %nx, float %y
   call void @use(float %s)
   %r = fneg float %s
   ret float %r
 }
 
 define float @fneg_ldexp(float %x, i32 %n) {
 ; CHECK-LABEL: @fneg_ldexp(
-; CHECK-NEXT:    [[LDEXP:%.*]] = call float @llvm.ldexp.f32.i32(float [[X:%.*]], i32 [[N:%.*]])
-; CHECK-NEXT:    [[NEG:%.*]] = fneg float [[LDEXP]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg float [[X:%.*]]
+; CHECK-NEXT:    [[NEG:%.*]] = call float @llvm.ldexp.f32.i32(float [[TMP1]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret float [[NEG]]
 ;
   %ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n)
   %neg = fneg float %ldexp
   ret float %neg
 }
 
 define float @fsub_fneg_ldexp(float %x, i32 %n) {
 ; CHECK-LABEL: @fsub_fneg_ldexp(
-; CHECK-NEXT:    [[LDEXP:%.*]] = call float @llvm.ldexp.f32.i32(float [[X:%.*]], i32 [[N:%.*]])
-; CHECK-NEXT:    [[NEG:%.*]] = fneg float [[LDEXP]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg float [[X:%.*]]
+; CHECK-NEXT:    [[NEG:%.*]] = call float @llvm.ldexp.f32.i32(float [[TMP1]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret float [[NEG]]
 ;
   %ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n)
   %neg = fsub float -0.0, %ldexp
   ret float %neg
 }
 
 define float @fsub_fneg_ldexp_nsz(float %x, i32 %n) {
 ; CHECK-LABEL: @fsub_fneg_ldexp_nsz(
-; CHECK-NEXT:    [[LDEXP:%.*]] = call float @llvm.ldexp.f32.i32(float [[X:%.*]], i32 [[N:%.*]])
-; CHECK-NEXT:    [[NEG:%.*]] = fneg nsz float [[LDEXP]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg nsz float [[X:%.*]]
+; CHECK-NEXT:    [[NEG:%.*]] = call nsz float @llvm.ldexp.f32.i32(float [[TMP1]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret float [[NEG]]
 ;
   %ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n)
   %neg = fsub nsz float -0.0, %ldexp
   ret float %neg
 }
 
 define float @fsub_fneg_ldexp_p0_nsz(float %x, i32 %n) {
 ; CHECK-LABEL: @fsub_fneg_ldexp_p0_nsz(
-; CHECK-NEXT:    [[LDEXP:%.*]] = call float @llvm.ldexp.f32.i32(float [[X:%.*]], i32 [[N:%.*]])
-; CHECK-NEXT:    [[NEG:%.*]] = fneg nsz float [[LDEXP]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg nsz float [[X:%.*]]
+; CHECK-NEXT:    [[NEG:%.*]] = call nsz float @llvm.ldexp.f32.i32(float [[TMP1]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret float [[NEG]]
 ;
   %ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n)
   %neg = fsub nsz float 0.0, %ldexp
   ret float %neg
 }
 
 define float @fsub_fneg_ldexp_p0(float %x, i32 %n) {
 ; CHECK-LABEL: @fsub_fneg_ldexp_p0(
 ; CHECK-NEXT:    [[LDEXP:%.*]] = call float @llvm.ldexp.f32.i32(float [[X:%.*]], i32 [[N:%.*]])
 ; CHECK-NEXT:    [[NEG:%.*]] = fsub float 0.000000e+00, [[LDEXP]]
 ; CHECK-NEXT:    ret float [[NEG]]
 ;
   %ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n)
   %neg = fsub float 0.0, %ldexp
   ret float %neg
 }
 
 define <2 x float> @fneg_ldexp_vector(<2 x float> %x, <2 x i32> %n) {
 ; CHECK-LABEL: @fneg_ldexp_vector(
-; CHECK-NEXT:    [[LDEXP:%.*]] = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> [[X:%.*]], <2 x i32> [[N:%.*]])
-; CHECK-NEXT:    [[NEG:%.*]] = fneg <2 x float> [[LDEXP]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg <2 x float> [[X:%.*]]
+; CHECK-NEXT:    [[NEG:%.*]] = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> [[TMP1]], <2 x i32> [[N:%.*]])
 ; CHECK-NEXT:    ret <2 x float> [[NEG]]
 ;
   %ldexp = call <2 x float> @llvm.ldexp.v2f32.v2i32(<2 x float> %x, <2 x i32> %n)
   %neg = fneg <2 x float> %ldexp
   ret <2 x float> %neg
 }
 
 define float @fneg_ldexp_multiuse(float %x, i32 %n, ptr %ptr) {
 ; CHECK-LABEL: @fneg_ldexp_multiuse(
 ; CHECK-NEXT:    [[LDEXP:%.*]] = call float @llvm.ldexp.f32.i32(float [[X:%.*]], i32 [[N:%.*]])
 ; CHECK-NEXT:    store float [[LDEXP]], ptr [[PTR:%.*]], align 4
 ; CHECK-NEXT:    [[NEG:%.*]] = fneg float [[LDEXP]]
 ; CHECK-NEXT:    ret float [[NEG]]
 ;
   %ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n)
   store float %ldexp, ptr %ptr
   %neg = fneg float %ldexp
   ret float %neg
 }
 
 define float @fneg_ldexp_fmf_ldexp(float %x, i32 %n) {
 ; CHECK-LABEL: @fneg_ldexp_fmf_ldexp(
-; CHECK-NEXT:    [[LDEXP:%.*]] = call nnan float @llvm.ldexp.f32.i32(float [[X:%.*]], i32 [[N:%.*]])
-; CHECK-NEXT:    [[NEG:%.*]] = fneg float [[LDEXP]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg nnan float [[X:%.*]]
+; CHECK-NEXT:    [[NEG:%.*]] = call nnan float @llvm.ldexp.f32.i32(float [[TMP1]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret float [[NEG]]
 ;
   %ldexp = call nnan float @llvm.ldexp.f32.i32(float %x, i32 %n)
   %neg = fneg float %ldexp
   ret float %neg
 }
 
 define float @fneg_ldexp_fmf_neg(float %x, i32 %n) {
 ; CHECK-LABEL: @fneg_ldexp_fmf_neg(
-; CHECK-NEXT:    [[LDEXP:%.*]] = call float @llvm.ldexp.f32.i32(float [[X:%.*]], i32 [[N:%.*]])
-; CHECK-NEXT:    [[NEG:%.*]] = fneg nnan float [[LDEXP]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg nnan float [[X:%.*]]
+; CHECK-NEXT:    [[NEG:%.*]] = call nnan float @llvm.ldexp.f32.i32(float [[TMP1]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret float [[NEG]]
 ;
   %ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n)
   %neg = fneg nnan float %ldexp
   ret float %neg
 }
 
 define float @fneg_ldexp_fmf(float %x, i32 %n) {
 ; CHECK-LABEL: @fneg_ldexp_fmf(
-; CHECK-NEXT:    [[LDEXP:%.*]] = call ninf float @llvm.ldexp.f32.i32(float [[X:%.*]], i32 [[N:%.*]])
-; CHECK-NEXT:    [[NEG:%.*]] = fneg nnan float [[LDEXP]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg nnan ninf float [[X:%.*]]
+; CHECK-NEXT:    [[NEG:%.*]] = call nnan ninf float @llvm.ldexp.f32.i32(float [[TMP1]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret float [[NEG]]
 ;
   %ldexp = call ninf float @llvm.ldexp.f32.i32(float %x, i32 %n)
   %neg = fneg nnan float %ldexp
   ret float %neg
 }
 
 define float @fneg_ldexp_contract0(float %x, i32 %n) {
 ; CHECK-LABEL: @fneg_ldexp_contract0(
-; CHECK-NEXT:    [[LDEXP:%.*]] = call contract float @llvm.ldexp.f32.i32(float [[X:%.*]], i32 [[N:%.*]])
-; CHECK-NEXT:    [[NEG:%.*]] = fneg float [[LDEXP]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg contract float [[X:%.*]]
+; CHECK-NEXT:    [[NEG:%.*]] = call contract float @llvm.ldexp.f32.i32(float [[TMP1]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret float [[NEG]]
 ;
   %ldexp = call contract float @llvm.ldexp.f32.i32(float %x, i32 %n)
   %neg = fneg float %ldexp
   ret float %neg
 }
 
 define float @fneg_ldexp_contract1(float %x, i32 %n) {
 ; CHECK-LABEL: @fneg_ldexp_contract1(
-; CHECK-NEXT:    [[LDEXP:%.*]] = call float @llvm.ldexp.f32.i32(float [[X:%.*]], i32 [[N:%.*]])
-; CHECK-NEXT:    [[NEG:%.*]] = fneg contract float [[LDEXP]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg contract float [[X:%.*]]
+; CHECK-NEXT:    [[NEG:%.*]] = call contract float @llvm.ldexp.f32.i32(float [[TMP1]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret float [[NEG]]
 ;
   %ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n)
   %neg = fneg contract float %ldexp
   ret float %neg
 }
 
 define float @fneg_ldexp_contract(float %x, i32 %n) {
 ; CHECK-LABEL: @fneg_ldexp_contract(
-; CHECK-NEXT:    [[LDEXP:%.*]] = call contract float @llvm.ldexp.f32.i32(float [[X:%.*]], i32 [[N:%.*]])
-; CHECK-NEXT:    [[NEG:%.*]] = fneg contract float [[LDEXP]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg contract float [[X:%.*]]
+; CHECK-NEXT:    [[NEG:%.*]] = call contract float @llvm.ldexp.f32.i32(float [[TMP1]], i32 [[N:%.*]])
 ; CHECK-NEXT:    ret float [[NEG]]
 ;
   %ldexp = call contract float @llvm.ldexp.f32.i32(float %x, i32 %n)
   %neg = fneg contract float %ldexp
   ret float %neg
 }
 
 define float @fneg_ldexp_metadata(float %x, i32 %n) {
 ; CHECK-LABEL: @fneg_ldexp_metadata(
-; CHECK-NEXT:    [[LDEXP:%.*]] = call float @llvm.ldexp.f32.i32(float [[X:%.*]], i32 [[N:%.*]]), !arst !0
-; CHECK-NEXT:    [[NEG:%.*]] = fneg float [[LDEXP]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg float [[X:%.*]]
+; CHECK-NEXT:    [[NEG:%.*]] = call float @llvm.ldexp.f32.i32(float [[TMP1]], i32 [[N:%.*]]), !arst !0
 ; CHECK-NEXT:    ret float [[NEG]]
 ;
   %ldexp = call float @llvm.ldexp.f32.i32(float %x, i32 %n), !arst !0
   %neg = fneg float %ldexp
   ret float %neg
 }
 
 !0 = !{}