Reassociate x + -0.1234 * y into x - 0.1234 * y (part 2)

[mcrosier]

Summary

This is a follow up patch to http://reviews.llvm.org/D4904.

This gives CSE/GVN more options to eliminate duplicate expressions. However, this implementation is significantly less rigid and adds support for other operations such as integer add/sub/urem/srem/sdiv/etc. I need to rerun the performance numbers, but I thought I would begin the review process in the meantime.

Please have a look,

Chad

[mcrosier]

Ping. :)

[rengolin]

Hi Chad,

I get this failure when running on ARM:

/work/llvm/src/llvm/test/Transforms/Reassociate/canonicalize-neg-const.ll:120:15: error: expected string not found in input
; CHECK-NEXT: fmul double %y, 1.234000e-01

<stdin>:57:21: note: scanning from here
define double @test9(double %x, double %y) {

<stdin>:58:5: note: possible intended match here
%mul = fmul double 1.234000e-01, %y

Looks like the position of the arguments is not deterministic?

[mcrosier]

Renato,
Did you run the test multiple times to verify the non-determinism. It's possible I uploaded a stale patch. Regardless, I'll investigate.

Thanks,

Chad

[rengolin]

Chad,

It *always* happens on ARM. I believe this is not "random", but depends on other unknown (to me) dynamic factors.

cheers,
--renato

[mcrosier]

It *always* happens on ARM. I believe this is not "random", but depends on other unknown (to me) dynamic factors.

Thanks, Renato. I'll take a look.

One of the purposes of the reassociation pass is to canonicalize operands based on "rank." If the behavior isn't random, I imagine I just uploaded a stale patch.

Chad

[mcrosier]

Update and rebase to address Renato's comments.

[rengolin]

Hi Chad,

no issues on ARM. Thanks!

--renato

[chandlerc]

Generally looks good. Some minor code improvements suggested, but nothing significant really.

lib/Transforms/Scalar/Reassociate.cpp

1948–1955

Rather than this, it would be nice to write in a way that there is only one test of the constant type:

if (auto *CI = dyn_cast<ConstantInt>(C)) {
  // ..
} else if (auto *CF = dyn_cast<ConstantFP>(C)) {
  // ..
} else {
  return nullptr;
}

1977

The shortening "Usr" is a bit ... awkward to me. ;] Is there a problem with just calling it "UserOpcode"?

[mcrosier]

Thanks, Chandler. Committed r221171.

lib/Transforms/Scalar/Reassociate.cpp

bool CombineXorOpnd(Instruction *I, XorOpnd *Opnd1, XorOpnd *Opnd2,
                         APInt &ConstOpnd, Value *&Res);
     bool collectMultiplyFactors(SmallVectorImpl<ValueEntry> &Ops,
                                 SmallVectorImpl<Factor> &Factors);
     Value *buildMinimalMultiplyDAG(IRBuilder<> &Builder,
                                    SmallVectorImpl<Factor> &Factors);
     Value *OptimizeMul(BinaryOperator *I, SmallVectorImpl<ValueEntry> &Ops);
     Value *RemoveFactorFromExpression(Value *V, Value *Factor);
     void EraseInst(Instruction *I);
-    void optimizeFAddNegExpr(ConstantFP *ConstOperand, Instruction *I,
-                             int OperandNr);
     void OptimizeInst(Instruction *I);
+    Instruction *canonicalizeNegConstExpr(Instruction *I);
   };
 }
 
 XorOpnd::XorOpnd(Value *V) {
   assert(!isa<ConstantInt>(V) && "No ConstantInt");
   OrigVal = V;
   Instruction *I = dyn_cast<Instruction>(V);
   SymbolicRank = 0;
if (Instruction *Op = dyn_cast<Instruction>(Ops[i])) {
       unsigned Opcode = Op->getOpcode();
       while (Op->hasOneUse() && Op->user_back()->getOpcode() == Opcode &&
              Visited.insert(Op))
         Op = Op->user_back();
       RedoInsts.insert(Op);
     }
 }
 
-void Reassociate::optimizeFAddNegExpr(ConstantFP *ConstOperand, Instruction *I,
-                                      int OperandNr) {
+// Canonicalize expressions of the following form:
+//  x + (-Constant * y) -> x - (Constant * y)
+//  x - (-Constant * y) -> x + (Constant * y)
+Instruction *Reassociate::canonicalizeNegConstExpr(Instruction *I) {
+  if (!I->hasOneUse() || I->getType()->isVectorTy())
+    return nullptr;
+
+  // Must have at least one constant operand.
+  Constant *C0 = dyn_cast<Constant>(I->getOperand(0));
+  Constant *C1 = dyn_cast<Constant>(I->getOperand(1));
+  if (!C0 && !C1)
+    return nullptr;
+
+  // Must be a negative ConstantInt or ConstantFP.
+  Constant *C = C0 ? C0 : C1;
+  unsigned ConstIdx = C0 ? 0 : 1;
+  if (!isa<ConstantInt>(C) && !isa<ConstantFP>(C))
+    return nullptr;
+  if (ConstantInt *CI = dyn_cast<ConstantInt>(C))
+    if (!CI->isNegative())
+      return nullptr;
+  if (ConstantFP *CF = dyn_cast<ConstantFP>(C))
+    if (!CF->isNegative())
+      return nullptr;
+
+  // User must be a binary operator with one or more uses.
+  Instruction *User = I->user_back();
+  if (!isa<BinaryOperator>(User) || !User->getNumUses())
+    return nullptr;
+
+  // Must be a binary operator with higher precedence that add/sub.
+  switch(I->getOpcode()) {
+  default:
+    return nullptr;
+  case Instruction::Mul:
+  case Instruction::FMul:
+  case Instruction::UDiv:
+  case Instruction::SDiv:
+  case Instruction::FDiv:
+  case Instruction::URem:
+  case Instruction::SRem:
+  case Instruction::FRem:
+   break;
+  }
+
+  unsigned UsrOpcode = User->getOpcode();
+  if (UsrOpcode != Instruction::Add && UsrOpcode != Instruction::FAdd &&
+      UsrOpcode != Instruction::Sub && UsrOpcode != Instruction::FSub)
+    return nullptr;
+
+  // Subtraction is not commutative. Explicitly, the following transform is
+  // not valid: (-Constant * y) - x  -> x + (Constant * y)
+  if (!User->isCommutative() && User->getOperand(1) != I)
+    return nullptr;
+
   // Change the sign of the constant.
-  APFloat Val = ConstOperand->getValueAPF();
+  if (ConstantInt *CI = dyn_cast<ConstantInt>(C))
+    I->setOperand(ConstIdx, ConstantInt::get(CI->getContext(), -CI->getValue()));
+  else {
+    ConstantFP *CF = cast<ConstantFP>(C);
+    APFloat Val = CF->getValueAPF();
     Val.changeSign();
-  I->setOperand(0, ConstantFP::get(ConstOperand->getContext(), Val));
-
-  assert(I->hasOneUse() && "Only a single use can be replaced.");
-  Instruction *Parent = I->user_back();
+    I->setOperand(ConstIdx, ConstantFP::get(CF->getContext(), Val));
+  }
 
-  Value *OtherOperand = Parent->getOperand(1 - OperandNr);
+  // Canonicalize I to RHS to simplify the next bit of logic. E.g.,
+  // ((-Const*y) + x) -> (x + (-Const*y)).
+  if (User->getOperand(0) == I && User->isCommutative())
+    cast<BinaryOperator>(User)->swapOperands();
+
+  Value *Op0 = User->getOperand(0);
+  Value *Op1 = User->getOperand(1);
+  BinaryOperator *NI;
+  switch(UsrOpcode) {
+  default:
+    llvm_unreachable("Unexpected Opcode!");
+  case Instruction::Add:
+    NI = BinaryOperator::CreateSub(Op0, Op1);
+    break;
+  case Instruction::Sub:
+    NI = BinaryOperator::CreateAdd(Op0, Op1);
+    break;
+  case Instruction::FAdd:
+    NI = BinaryOperator::CreateFSub(Op0, Op1);
+    NI->setFastMathFlags(cast<FPMathOperator>(User)->getFastMathFlags());
+    break;
+  case Instruction::FSub:
+    NI = BinaryOperator::CreateFAdd(Op0, Op1);
+    NI->setFastMathFlags(cast<FPMathOperator>(User)->getFastMathFlags());
+    break;
+  }
 
-  unsigned Opcode = Parent->getOpcode();
-  assert(Opcode == Instruction::FAdd ||
-         (Opcode == Instruction::FSub && Parent->getOperand(1) == I));
-
-  BinaryOperator *NI = Opcode == Instruction::FAdd
-                           ? BinaryOperator::CreateFSub(OtherOperand, I)
-                           : BinaryOperator::CreateFAdd(OtherOperand, I);
-  NI->setFastMathFlags(cast<FPMathOperator>(Parent)->getFastMathFlags());
-  NI->insertBefore(Parent);
-  NI->setName(Parent->getName() + ".repl");
-  Parent->replaceAllUsesWith(NI);
+  NI->insertBefore(User);
+  NI->setName(User->getName());
+  User->replaceAllUsesWith(NI);
   NI->setDebugLoc(I->getDebugLoc());
+  RedoInsts.insert(I);
   MadeChange = true;
+  return NI;
 }
 
 /// OptimizeInst - Inspect and optimize the given instruction. Note that erasing
 /// instructions is not allowed.
 void Reassociate::OptimizeInst(Instruction *I) {
   // Only consider operations that we understand.
   if (!isa<BinaryOperator>(I))
     return;
 
   if (I->getOpcode() == Instruction::Shl && isa<ConstantInt>(I->getOperand(1)))
     // If an operand of this shift is a reassociable multiply, or if the shift
     // is used by a reassociable multiply or add, turn into a multiply.
     if (isReassociableOp(I->getOperand(0), Instruction::Mul) ||
         (I->hasOneUse() &&
          (isReassociableOp(I->user_back(), Instruction::Mul) ||
           isReassociableOp(I->user_back(), Instruction::Add)))) {
       Instruction *NI = ConvertShiftToMul(I);
       RedoInsts.insert(I);
       MadeChange = true;
       I = NI;
     }
 
+  // Canocalize negative constants out of expressions.
+  if (Instruction *Res = canonicalizeNegConstExpr(I))
+    I = Res;
+
   // Commute floating point binary operators, to canonicalize the order of their
   // operands.  This can potentially expose more CSE opportunities, and makes
   // writing other transformations simpler.
   if (I->getType()->isFloatingPointTy() || I->getType()->isVectorTy()) {
 
     // FAdd and FMul can be commuted.
     unsigned Opcode = I->getOpcode();
     if (Opcode == Instruction::FMul || Opcode == Instruction::FAdd) {
       Value *LHS = I->getOperand(0);
       Value *RHS = I->getOperand(1);
       unsigned LHSRank = getRank(LHS);
       unsigned RHSRank = getRank(RHS);
 
       // Sort the operands by rank.
       if (RHSRank < LHSRank) {
         I->setOperand(0, RHS);
         I->setOperand(1, LHS);
       }
     }
 
-    // Reassociate: x + -ConstantFP * y -> x - ConstantFP * y
-    // The FMul can also be an FDiv, and FAdd can be a FSub.
-    if (Opcode == Instruction::FMul || Opcode == Instruction::FDiv) {
-      if (ConstantFP *LHSConst = dyn_cast<ConstantFP>(I->getOperand(0))) {
-        if (LHSConst->isNegative() && I->hasOneUse()) {
-          Instruction *Parent = I->user_back();
-          if (Parent->getOpcode() == Instruction::FAdd) {
-            if (Parent->getOperand(0) == I)
-              optimizeFAddNegExpr(LHSConst, I, 0);
-            else if (Parent->getOperand(1) == I)
-              optimizeFAddNegExpr(LHSConst, I, 1);
-          } else if (Parent->getOpcode() == Instruction::FSub)
-            if (Parent->getOperand(1) == I)
-              optimizeFAddNegExpr(LHSConst, I, 1);
-        }
-      }
-    }
-
     // FIXME: We should commute vector instructions as well.  However, this 
     // requires further analysis to determine the effect on later passes.
 
     // Don't try to optimize vector instructions or anything that doesn't have
     // unsafe algebra.
     if (I->getType()->isVectorTy() || !I->hasUnsafeAlgebra())
       return;
   }

test/Transforms/Reassociate/basictest.ll

 define i32 @test14(i32 %X1, i32 %X2) {
   %B = mul i32 %X1, 47   ; X1*47
   %C = mul i32 %X2, -47  ; X2*-47
   %D = add i32 %B, %C    ; X1*47 + X2*-47 -> 47*(X1-X2)
   ret i32 %D
 
 ; CHECK-LABEL: @test14
 ; CHECK-NEXT: sub i32 %X1, %X2
-; CHECK-NEXT: mul i32 %tmp, 47
+; CHECK-NEXT: mul i32 %B2, 47
 ; CHECK-NEXT: ret i32
 }
 
 ; Do not reassociate expressions of type i1
 define i32 @test15(i32 %X1, i32 %X2, i32 %X3) {
   %A = icmp ne i32 %X1, 0
   %B = icmp slt i32 %X2, %X3
   %C = and i1 %A, %B
   %D = select i1 %C, i32 %X1, i32 0
   ret i32 %D
 ; CHECK-LABEL: @test15
 ; CHECK: and i1 %A, %B
 }

test/Transforms/Reassociate/canonicalize-neg-const.ll

+; RUN: opt -reassociate -gvn -S < %s | FileCheck %s
+
+; (x + 0.1234 * y) * (x + -0.1234 * y) -> (x + 0.1234 * y) * (x - 0.1234 * y)
+define double @test1(double %x, double %y) {
+; CHECK-LABEL: @test1
+; CHECK-NEXT: fmul double 1.234000e-01, %y
+; CHECK-NEXT: fadd double %x, %mul
+; CHECK-NEXT: fsub double %x, %mul
+; CHECK-NEXT: fmul double %add{{.*}}, %add{{.*}}
+; CHECK-NEXT: ret double %mul
+
+  %mul = fmul double 1.234000e-01, %y
+  %add = fadd double %mul, %x
+  %mul1 = fmul double -1.234000e-01, %y
+  %add2 = fadd double %mul1, %x
+  %mul3 = fmul double %add, %add2
+  ret double %mul3
+}
+
+; (x + -0.1234 * y) * (x + -0.1234 * y) -> (x - 0.1234 * y) * (x - 0.1234 * y)
+define double @test2(double %x, double %y) {
+; CHECK-LABEL: @test2
+; CHECK-NEXT: fmul double 1.234000e-01, %y
+; CHECK-NEXT: fsub double %x, %mul
+; CHECK-NEXT: fmul double %add{{.*}}, %add{{.*}}
+; CHECK-NEXT: ret double %mul
+
+  %mul = fmul double %y, -1.234000e-01
+  %add = fadd double %mul, %x
+  %mul1 = fmul double %y, -1.234000e-01
+  %add2 = fadd double %mul1, %x
+  %mul3 = fmul double %add, %add2
+  ret double %mul3
+}
+
+; (x + 0.1234 / y) * (x + -0.1234 / y) -> (x + 0.1234 / y) * (x - 0.1234 / y)
+define double @test3(double %x, double %y) {
+; CHECK-LABEL: @test3
+; CHECK-NEXT: fdiv double 1.234000e-01, %y
+; CHECK-NEXT: fadd double %x, %div
+; CHECK-NEXT: fsub double %x, %div
+; CHECK-NEXT: fmul double %add{{.*}}, %add{{.*}}
+; CHECK-NEXT: ret double
+
+  %div = fdiv double 1.234000e-01, %y
+  %add = fadd double %div, %x
+  %div1 = fdiv double -1.234000e-01, %y
+  %add2 = fadd double %div1, %x
+  %mul3 = fmul double %add, %add2
+  ret double %mul3
+}
+
+; (x + 0.1234 * y) * (x - -0.1234 * y) -> (x + 0.1234 * y) * (x + 0.1234 * y)
+define double @test4(double %x, double %y) {
+; CHECK-LABEL: @test4
+; CHECK-NEXT: fmul double 1.234000e-01, %y
+; CHECK-NEXT: fadd double %x, %mul
+; CHECK-NEXT: fmul double %add{{.*}}, %add{{.*}}
+; CHECK-NEXT: ret double
+
+  %mul = fmul double %y, 1.234000e-01
+  %add = fadd double %mul, %x
+  %mul1 = fmul double %y, -1.234000e-01
+  %add2 = fsub double %x, %mul1
+  %mul3 = fmul double %add, %add2
+  ret double %mul3
+}
+
+; Canonicalize (x - -1234 * y)
+define i64 @test5(i64 %x, i64 %y) {
+; CHECK-LABEL: @test5
+; CHECK-NEXT: mul i64 %y, 1234
+; CHECK-NEXT: add i64 %mul, %x
+; CHECK-NEXT: ret i64 %sub
+
+  %mul = mul i64 %y, -1234
+  %sub = sub i64 %x, %mul
+  ret i64 %sub
+}
+
+; Canonicalize (x - -0.1234 * y)
+define double @test6(double %x, double %y) {
+; CHECK-LABEL: @test6
+; CHECK-NEXT: fmul double 1.234000e-01, %y
+; CHECK-NEXT: fadd double %x, %mul
+; CHECK-NEXT: ret double
+
+  %mul = fmul double -1.234000e-01, %y
+  %sub = fsub double %x, %mul
+  ret double %sub
+}
+
+; Don't modify (-0.1234 * y - x)
+define double @test7(double %x, double %y) {
+; CHECK-LABEL: @test7
+; CHECK-NEXT: fmul double -1.234000e-01, %y
+; CHECK-NEXT: fsub double %mul, %x
+; CHECK-NEXT: ret double %sub
+
+  %mul = fmul double -1.234000e-01, %y
+  %sub = fsub double %mul, %x
+  ret double %sub
+}
+
+; Canonicalize (-0.1234 * y + x) -> (x - 0.1234 * y)
+define double @test8(double %x, double %y) {
+; CHECK-LABEL: @test8
+; CHECK-NEXT: fmul double 1.234000e-01, %y
+; CHECK-NEXT: fsub double %x, %mul
+; CHECK-NEXT: ret double %add
+
+  %mul = fmul double -1.234000e-01, %y
+  %add = fadd double %mul, %x
+  ret double %add
+}
+
+; Canonicalize (y * -0.1234 + x) -> (x - 0.1234 * y)
+define double @test9(double %x, double %y) {
+; CHECK-LABEL: @test9
+; CHECK-NEXT: fmul double 1.234000e-01, %y
+; CHECK-NEXT: fsub double %x, %mul
+; CHECK-NEXT: ret double %add
+
+  %mul = fmul double %y, -1.234000e-01
+  %add = fadd double %mul, %x
+  ret double %add
+}
+
+; Canonicalize (x - -1234 udiv y)
+define i64 @test10(i64 %x, i64 %y) {
+; CHECK-LABEL: @test10
+; CHECK-NEXT: udiv i64 1234, %y
+; CHECK-NEXT: add i64 %div, %x
+; CHECK-NEXT: ret i64 %sub
+
+  %div = udiv i64 -1234, %y
+  %sub = sub i64 %x, %div
+  ret i64 %sub
+}
+
+; Canonicalize (x - -1234 sdiv y)
+define i64 @test11(i64 %x, i64 %y) {
+; CHECK-LABEL: @test11
+; CHECK-NEXT: sdiv i64 1234, %y
+; CHECK-NEXT: add i64 %div, %x
+; CHECK-NEXT: ret i64 %sub
+
+  %div = sdiv i64 -1234, %y
+  %sub = sub i64 %x, %div
+  ret i64 %sub
+}
+
+; Canonicalize (x - -0.1234 / y)
+define double @test12(double %x, double %y) {
+; CHECK-LABEL: @test12
+; CHECK-NEXT: fdiv double 1.234000e-01, %y
+; CHECK-NEXT: fadd double %x, %div
+; CHECK-NEXT: ret double %sub
+
+  %div = fdiv double -1.234000e-01, %y
+  %sub = fsub double %x, %div
+  ret double %sub
+}
+
+; Canonicalize (x - -0.1234 urem y)
+define i64 @test13(i64 %x, i64 %y) {
+; CHECK-LABEL: @test13
+; CHECK-NEXT: urem i64 1234, %y
+; CHECK-NEXT: add i64 %urem, %x
+; CHECK-NEXT: ret i64 %sub
+
+  %urem = urem i64 -1234, %y
+  %sub = sub i64 %x, %urem
+  ret i64 %sub
+}
+
+; Canonicalize (x + -0.1234 srem y)
+define i64 @test14(i64 %x, i64 %y) {
+; CHECK-LABEL: @test14
+; CHECK-NEXT: srem i64 1234, %y
+; CHECK-NEXT: sub i64 %x, %srem
+; CHECK-NEXT: ret i64 %add
+
+  %srem = srem i64 -1234, %y
+  %add = add i64 %x, %srem
+  ret i64 %add
+}
+
+; Don't modify (-0.1234 srem y - x)
+define i64 @test15(i64 %x, i64 %y) {
+; CHECK-LABEL: @test15
+; CHECK-NEXT: %srem = srem i64 -1234, %y
+; CHECK-NEXT: %sub = sub i64 %srem, %x
+; CHECK-NEXT: ret i64 %sub
+
+  %srem = srem i64 -1234, %y
+  %sub = sub i64 %srem, %x
+  ret i64 %sub
+}
+
+; Canonicalize (x - -0.1234 frem y)
+define double @test16(double %x, double %y) {
+; CHECK-LABEL: @test16
+; CHECK-NEXT: frem double 1.234000e-01, %y
+; CHECK-NEXT: fadd double %x, %rem
+; CHECK-NEXT: ret double %sub
+
+  %rem = frem double -1.234000e-01, %y
+  %sub = fsub double %x, %rem
+  ret double %sub
+}
+
+; Canonicalize (x + -0.1234 frem y)
+define double @test17(double %x, double %y) {
+; CHECK-LABEL: @test17
+; CHECK-NEXT: frem double 1.234000e-01, %y
+; CHECK-NEXT: fsub double %x, %rem
+; CHECK-NEXT: ret double %add
+
+  %rem = frem double -1.234000e-01, %y
+  %add = fadd double %x, %rem
+  ret double %add
+}
+
+; Canonicalize (-0.1234 frem y + x) -> (x - 0.1234 frem y)
+define double @test18(double %x, double %y) {
+; CHECK-LABEL: @test18
+; CHECK-NEXT: frem double 1.234000e-01, %y
+; CHECK-NEXT: fsub double %x, %rem
+; CHECK-NEXT: ret double %add
+
+  %rem = frem double -1.234000e-01, %y
+  %add = fadd double %x, %rem
+  ret double %add
+}

test/Transforms/Reassociate/liftsign.ll

-; RUN: opt -reassociate -gvn -S < %s | FileCheck %s
-
-; (x + 0.1234 * y) * (x + -0.1234 * y) -> (x + 0.1234 * y) * (x - 0.1234 * y)
-; so CSE can simplify it further
-define double @lift_sign1(double %x, double %y) nounwind readnone ssp uwtable {
-; CHECK-LABEL: @lift_sign1(
-  %mul = fmul double 1.234000e-01, %y
-  %add = fadd double %mul, %x
-  %mul1 = fmul double -1.234000e-01, %y
-  %add2 = fadd double %mul1, %x
-  %mul3 = fmul double %add, %add2
-; CHECK-NOT: %mul1 = fmul double -1.234000e-01, %y
-; CHECK-NOT: %add2 = fadd %mul1, %x
-; CHECK: %add2.repl = fsub double %x, %mul
-; CHECK: %mul3 = fmul double %add, %add2
-ret double %mul3
-}
-
-; (x + -0.1234 * y) * (x + -0.1234 * y) -> (x - 0.1234 * y) * (x - 0.1234 * y)
-; GVN can then rewrite it even further
-define double @lift_sign2(double %x, double %y) nounwind readnone ssp uwtable {
-; CHECK-LABEL: @lift_sign2(
-  %mul = fmul double %y, -1.234000e-01
-  %add = fadd double %mul, %x
-  %mul1 = fmul double %y, -1.234000e-01
-  %add2 = fadd double %mul1, %x
-  %mul3 = fmul double %add, %add2
-; CHECK-NOT: %mul = fmul double %y, -1.234000e-01
-; CHECK-NOT: %add = fadd double %mul, %x
-; CHECK-NOT: %mul1 = fmul double %y, -1.234000e-01
-; CHECK-NOT: %add2 = fadd double %mul1, %x
-; CHECK-NOT: %mul3 = fmul double %add, %add2
-; CHECK: %mul = fmul double 1.234000e-01, %y
-; CHECK: %add.repl = fsub double %x, %mul
-; CHECK: %mul3 = fmul double %add.repl, %add.repl
-  ret double %mul3
-}
-
-; (x + 0.1234 * y) * (x - -0.1234 * y) -> (x + 0.1234 * y) * (x + 0.1234 * y)
-define double @lift_sign3(double %x, double %y) nounwind readnone ssp uwtable {
-; CHECK-LABEL: @lift_sign3(
-  %mul = fmul double %y, 1.234000e-01
-  %add = fadd double %mul, %x
-  %mul1 = fmul double %y, -1.234000e-01
-  %add2 = fsub double %x, %mul1
-  %mul3 = fmul double %add, %add2
-; CHECK-NOT: %mul1 = fmul double %y, -1.234000e-01
-; CHECK-NOT: %add2 = fsub double %x, %mul1
-; CHECK-NOT: %mul3 = fmul double %add, %add2
-; CHECK: %mul3 = fmul double %add, %add
-  ret double %mul3
-}
-
-; (x + 0.1234 / y) * (x + -0.1234 / y) -> (x + 0.1234 / y) * (x - 0.1234 / y)
-; so CSE can simplify it further
-define double @lift_sign4(double %x, double %y) nounwind readnone ssp uwtable {
-; CHECK-LABEL: @lift_sign4(
-  %div = fdiv double 1.234000e-01, %y
-  %add = fadd double %div, %x
-  %div1 = fdiv double -1.234000e-01, %y
-  %add2 = fadd double %div1, %x
-  %mul3 = fmul double %add, %add2
-; CHECK-NOT: %div1 = fdiv double -1.234000e-01, %y
-; CHECK-NOT: %add2 = fadd double %div1, %x
-; CHECK-NOT: %mul3 = fmul double %add, %add2
-; CHECK: %add2.repl = fsub double %x, %div
-; CHECK: %mul3 = fmul double %add, %add2.repl
-  ret double %mul3
-}