[FPEnv] WIP on threading fneg through llvm

[kpn]

Summary

This is my work-in-progress code for threading fneg from the IRBuilder on through the optimization passes. It isn't in shape to commit, but perhaps should be seen for discussion on direction at least.

At least some of the optimization passes use the IRBuilder, so adding FNeg there means the optimization passes must be changed in concert. Otherwise code quality is affected.

Currently some of the tests are still failing because the Reassociate pass doesn't know how to deal with a unary instruction. I don't know what comes after that is fixed.

[cameron.mcinally]

Thanks for working on this, Kevin. It looks like the general direction is good. A couple small comments inline. I also noticed some of the tests still need updating to replace fsub's, but I assume you know that.

@spatel I'm not a PatternMatch expert, but I think that change is what we wanted. That is, to continue to match FSub(-0.0, X) as an FNeg(X).

I'm currently working on ConstantExpr folding for FNeg in D61419. And soon to be looking at FNeg folding in InstructionSimplify. Just FYI...

lib/Transforms/InstCombine/InstCombineAddSub.cpp

1938

We should also do:

-undef -> undef

lib/Transforms/Scalar/Reassociate.cpp

887

Comment needs to be updated.

[cameron.mcinally]

In D61447#1488502, @cameron.mcinally wrote:

@spatel I'm not a PatternMatch expert, but I think that change is what we wanted. That is, to continue to match FSub(-0.0, X) as an FNeg(X).

Just FYI that an equivalent patch was made to the PatternMatcher in D61520. I needed this for some FNeg constant folding work. Thanks for the inspirations, Kevin.

[kpn]

In D61447#1490050, @cameron.mcinally wrote:

In D61447#1488502, @cameron.mcinally wrote:

@spatel I'm not a PatternMatch expert, but I think that change is what we wanted. That is, to continue to match FSub(-0.0, X) as an FNeg(X).

Just FYI that an equivalent patch was made to the PatternMatcher in D61520. I needed this for some FNeg constant folding work. Thanks for the inspirations, Kevin.

Glad to help!

[kpn]

I don't think this needs to be open anymore.

include/llvm/IR/IRBuilder.h

public:
   Value *CreateNUWNeg(Value *V, const Twine &Name = "") {
     return CreateNeg(V, Name, true, false);
   }
 
   Value *CreateFNeg(Value *V, const Twine &Name = "",
                     MDNode *FPMathTag = nullptr) {
     if (auto *VC = dyn_cast<Constant>(V))
       return Insert(Folder.CreateFNeg(VC), Name);
-    return Insert(setFPAttrs(BinaryOperator::CreateFNeg(V), FPMathTag, FMF),
-                  Name);
+    return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V, Name), FPMathTag, 
+                             FMF), Name);
+  }
+
+  /// Copy fast-math-flags from an instruction rather than using the builder's
+  /// default FMF.
+  Value *CreateFNegFMF(Value *V, Instruction *FMFSource,
+                       const Twine &Name = "") {
+    if (auto *VC = dyn_cast<Constant>(V))
+      return Insert(Folder.CreateFNeg(VC), Name);
+    Instruction *I = setFPAttrs(UnaryOperator::CreateFNeg(V, Name), nullptr,
+                                FMFSource->getFastMathFlags());
+    return Insert(I, Name);
   }
 
   Value *CreateNot(Value *V, const Twine &Name = "") {
     if (auto *VC = dyn_cast<Constant>(V))
       return Insert(Folder.CreateNot(VC), Name);
     return Insert(BinaryOperator::CreateNot(V), Name);
   }
 

include/llvm/IR/InstrTypes.h

#undef DEFINE_HELPERS
   static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name = "",
                                       Instruction *InsertBefore = nullptr);
   static BinaryOperator *CreateNSWNeg(Value *Op, const Twine &Name,
                                       BasicBlock *InsertAtEnd);
   static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name = "",
                                       Instruction *InsertBefore = nullptr);
   static BinaryOperator *CreateNUWNeg(Value *Op, const Twine &Name,
                                       BasicBlock *InsertAtEnd);
+#if 0
   static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name = "",
                                     Instruction *InsertBefore = nullptr);
   static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name,
                                     BasicBlock *InsertAtEnd);
+#endif
   static BinaryOperator *CreateNot(Value *Op, const Twine &Name = "",
                                    Instruction *InsertBefore = nullptr);
   static BinaryOperator *CreateNot(Value *Op, const Twine &Name,
                                    BasicBlock *InsertAtEnd);
 
   BinaryOps getOpcode() const {
     return static_cast<BinaryOps>(Instruction::getOpcode());
   }

include/llvm/IR/Instructions.h

static UnaryInstruction *Create##OPC(Value *V, \
                                        const Twine &Name, Instruction *I) {\
     return Create(Instruction::OPC, V, Name, I);\
   }
 #include "llvm/IR/Instruction.def"
 
   UnaryOps getOpcode() const {
     return static_cast<UnaryOps>(Instruction::getOpcode());
   }
+
+  static UnaryOperator *CreateFNegFMF(Value *Op, Instruction *FMFSource,
+                                       const Twine &Name = "") {
+    UnaryOperator *UO = Create(Instruction::FNeg, Op, Name);
+    UO->copyIRFlags(FMFSource);
+    return UO;
+  }
+
+#if 0
+  static UnaryOperator *CreateFNeg(Value *Op, const Twine &Name = "",
+                                   Instruction *InsertBefore = nullptr);
+  static UnaryOperator *CreateFNeg(Value *Op, const Twine &Name,
+                                   BasicBlock *InsertAtEnd);
+#endif
 };
 
 //===----------------------------------------------------------------------===//
 //                               ICmpInst Class
 //===----------------------------------------------------------------------===//
 
 /// This instruction compares its operands according to the predicate given
 /// to the constructor. It only operates on integers or pointers. The operands

include/llvm/IR/NoFolder.h

Instruction *CreateNSWNeg(Constant *C) const {
     return BinaryOperator::CreateNSWNeg(C);
   }
 
   Instruction *CreateNUWNeg(Constant *C) const {
     return BinaryOperator::CreateNUWNeg(C);
   }
 
   Instruction *CreateFNeg(Constant *C) const {
-    return BinaryOperator::CreateFNeg(C);
+    return UnaryOperator::CreateFNeg(C);
   }
 
   Instruction *CreateNot(Constant *C) const {
     return BinaryOperator::CreateNot(C);
   }
 
   //===--------------------------------------------------------------------===//
   // Memory Instructions

include/llvm/IR/PatternMatch.h

 }
 
 template <typename Op_t> struct FNeg_match {
   Op_t X;
 
   FNeg_match(const Op_t &Op) : X(Op) {}
   template <typename OpTy> bool match(OpTy *V) {
     auto *FPMO = dyn_cast<FPMathOperator>(V);
-    if (!FPMO || FPMO->getOpcode() != Instruction::FSub)
+    if (!FPMO)
       return false;
+    else
+    if (FPMO->getOpcode() != Instruction::FSub &&
+        FPMO->getOpcode() != Instruction::FNeg)
+      return false;
+    if (FPMO->getOpcode() == Instruction::FSub)
+    {
       if (FPMO->hasNoSignedZeros()) {
         // With 'nsz', any zero goes.
         if (!cstfp_pred_ty<is_any_zero_fp>().match(FPMO->getOperand(0)))
           return false;
       } else {
         // Without 'nsz', we need fsub -0.0, X exactly.
         if (!cstfp_pred_ty<is_neg_zero_fp>().match(FPMO->getOperand(0)))
           return false;
       }
       return X.match(FPMO->getOperand(1));
     }
+    else
+      return X.match(FPMO->getOperand(0));
+  }
 };
 
-/// Match 'fneg X' as 'fsub -0.0, X'.
+/// Match 'fneg X' as 'fsub -0.0, X'. Also match 'fneg X'.
 template <typename OpTy>
 inline FNeg_match<OpTy>
 m_FNeg(const OpTy &X) {
   return FNeg_match<OpTy>(X);
 }
 
 /// Match 'fneg X' as 'fsub +-0.0, X'.
 template <typename RHS>

lib/IR/Instructions.cpp

 
 void CallInst::init(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args,
                     ArrayRef<OperandBundleDef> Bundles, const Twine &NameStr) {
   this->FTy = FTy;
   assert(getNumOperands() == Args.size() + CountBundleInputs(Bundles) + 1 &&
          "NumOperands not set up?");
   setCalledOperand(Func);
 
+  for (unsigned i = 0; i != Args.size(); ++i) {
+     Type *ftyptype = FTy->getParamType(i);
+     Type *argtype = Args[i]->getType();
+     if (ftyptype != argtype) {
+        argtype = nullptr;
+     }
+  }
 #ifndef NDEBUG
   assert((Args.size() == FTy->getNumParams() ||
           (FTy->isVarArg() && Args.size() > FTy->getNumParams())) &&
          "Calling a function with bad signature!");
 
   for (unsigned i = 0; i != Args.size(); ++i)
     assert((i >= FTy->getNumParams() ||
             FTy->getParamType(i) == Args[i]->getType()) &&
assert(getType()->isFPOrFPVectorTy() &&
            "Tried to create a floating-point operation on a "
            "non-floating-point type!");
     break;
   default: llvm_unreachable("Invalid opcode provided");
   }
 #endif
 }
 
+#if 0
+UnaryOperator *UnaryOperator::CreateFNeg(Value *Op, const Twine &Name,
+                                           Instruction *InsertBefore) {
+  Value *zero = ConstantFP::getZeroValueForNegation(Op->getType());
+  return new BinaryOperator(Instruction::FSub, zero, Op,
+                            Op->getType(), Name, InsertBefore);
+}
+ 
+BinaryOperator *BinaryOperator::CreateFNeg(Value *Op, const Twine &Name,
+                                           BasicBlock *InsertAtEnd) {
+  Value *zero = ConstantFP::getZeroValueForNegation(Op->getType());
+  return new BinaryOperator(Instruction::FSub, zero, Op,
+                            Op->getType(), Name, InsertAtEnd);
+}
+#endif
+
 //===----------------------------------------------------------------------===//
 //                             BinaryOperator Class
 //===----------------------------------------------------------------------===//
 
 BinaryOperator::BinaryOperator(BinaryOps iType, Value *S1, Value *S2,
                                Type *Ty, const Twine &Name,
                                Instruction *InsertBefore)
   : Instruction(Ty, iType,

 }
 
 BinaryOperator *BinaryOperator::CreateNUWNeg(Value *Op, const Twine &Name,
                                              BasicBlock *InsertAtEnd) {
   Value *zero = ConstantFP::getZeroValueForNegation(Op->getType());
   return BinaryOperator::CreateNUWSub(zero, Op, Name, InsertAtEnd);
 }
 
+#if 0
 BinaryOperator *BinaryOperator::CreateFNeg(Value *Op, const Twine &Name,
                                            Instruction *InsertBefore) {
   Value *zero = ConstantFP::getZeroValueForNegation(Op->getType());
   return new BinaryOperator(Instruction::FSub, zero, Op,
                             Op->getType(), Name, InsertBefore);
 }
 
 BinaryOperator *BinaryOperator::CreateFNeg(Value *Op, const Twine &Name,
                                            BasicBlock *InsertAtEnd) {
   Value *zero = ConstantFP::getZeroValueForNegation(Op->getType());
   return new BinaryOperator(Instruction::FSub, zero, Op,
                             Op->getType(), Name, InsertAtEnd);
 }
+#endif
 
 BinaryOperator *BinaryOperator::CreateNot(Value *Op, const Twine &Name,
                                           Instruction *InsertBefore) {
   Constant *C = Constant::getAllOnesValue(Op->getType());
   return new BinaryOperator(Instruction::Xor, Op, C,
                             Op->getType(), Name, InsertBefore);
 }
 

lib/Transforms/InstCombine/InstCombineAddSub.cpp

 Value *FAddCombine::createFSub(Value *Opnd0, Value *Opnd1) {
   Value *V = Builder.CreateFSub(Opnd0, Opnd1);
   if (Instruction *I = dyn_cast<Instruction>(V))
     createInstPostProc(I);
   return V;
 }
 
 Value *FAddCombine::createFNeg(Value *V) {
-  Value *Zero = cast<Value>(ConstantFP::getZeroValueForNegation(V->getType()));
-  Value *NewV = createFSub(Zero, V);
+  Value *NewV = Builder.CreateFNeg(V);
   if (Instruction *I = dyn_cast<Instruction>(NewV))
-    createInstPostProc(I, true); // fneg's don't receive instruction numbers.
+    createInstPostProc(I);
   return NewV;
 }
 
 Value *FAddCombine::createFAdd(Value *Opnd0, Value *Opnd1) {
   Value *V = Builder.CreateFAdd(Opnd0, Opnd1);
   if (Instruction *I = dyn_cast<Instruction>(V))
     createInstPostProc(I);
   return V;
Instruction *InstCombiner::visitFSub(BinaryOperator &I) {
 
   if (Instruction *X = foldVectorBinop(I))
     return X;
 
   // Subtraction from -0.0 is the canonical form of fneg.
   // fsub nsz 0, X ==> fsub nsz -0.0, X
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
   if (I.hasNoSignedZeros() && match(Op0, m_PosZeroFP()))
-    return BinaryOperator::CreateFNegFMF(Op1, &I);
+    return UnaryOperator::CreateFNegFMF(Op1, &I);
 
   Value *X, *Y;
   Constant *C;
 
   // Fold negation into constant operand. This is limited with one-use because
   // fneg is assumed better for analysis and cheaper in codegen than fmul/fdiv.
   // -(X * C) --> X * (-C)
   if (match(&I, m_FNeg(m_OneUse(m_FMul(m_Value(X), m_Constant(C))))))
Instruction *InstCombiner::visitFSub(BinaryOperator &I) {
 
   // Handle special cases for FSub with selects feeding the operation
   if (Value *V = SimplifySelectsFeedingBinaryOp(I, Op0, Op1))
     return replaceInstUsesWith(I, V);
 
   if (I.hasAllowReassoc() && I.hasNoSignedZeros()) {
     // (Y - X) - Y --> -X
     if (match(Op0, m_FSub(m_Specific(Op1), m_Value(X))))
-      return BinaryOperator::CreateFNegFMF(X, &I);
+      return UnaryOperator::CreateFNegFMF(X, &I);
 
     // Y - (X + Y) --> -X
     // Y - (Y + X) --> -X
     if (match(Op1, m_c_FAdd(m_Specific(Op0), m_Value(X))))
-      return BinaryOperator::CreateFNegFMF(X, &I);
+      return UnaryOperator::CreateFNegFMF(X, &I);
 
     // (X * C) - X --> X * (C - 1.0)
     if (match(Op0, m_FMul(m_Specific(Op1), m_Constant(C)))) {
       Constant *CSubOne = ConstantExpr::getFSub(C, ConstantFP::get(Ty, 1.0));
       return BinaryOperator::CreateFMulFMF(Op1, CSubOne, &I);
     }
     // X - (X * C) --> X * (1.0 - C)
     if (match(Op1, m_FMul(m_Specific(Op0), m_Constant(C)))) {
if (I.hasAllowReassoc() && I.hasNoSignedZeros()) {
     // InstSimplify. We should let a dedicated reassociation pass handle more
     // complex pattern matching and remove this from InstCombine.
     if (Value *V = FAddCombine(Builder).simplify(&I))
       return replaceInstUsesWith(I, V);
   }
 
   return nullptr;
 }
+
+Instruction *InstCombiner::visitFNeg(UnaryOperator &I) {
+  Value *Op0 = I.getOperand(0);
+  Value *X;
+
+  // -(-X) -> X
+  if (match(Op0, m_FNeg(m_Value(X))))
+    if (auto *XI = dyn_cast<Instruction>(X)) {
+      if (XI->getOpcode() == Instruction::FSub)
+        return replaceInstUsesWith(I, XI->getOperand(1));
+      else if (XI->getOpcode() == Instruction::FNeg)
+        return replaceInstUsesWith(I, XI->getOperand(0));
+    }
+
+  return nullptr;
+}

lib/Transforms/InstCombine/InstCombineCalls.cpp

if (match(Arg0, m_FNeg(m_Value(X))) && match(Arg1, m_FNeg(m_Value(Y))) &&
         break;
       case Intrinsic::minimum:
         NewIID = Intrinsic::maximum;
         break;
       default:
         llvm_unreachable("unexpected intrinsic ID");
       }
       Value *NewCall = Builder.CreateBinaryIntrinsic(NewIID, X, Y, II);
-      Instruction *FNeg = BinaryOperator::CreateFNeg(NewCall);
+      Instruction *FNeg = UnaryOperator::CreateFNeg(NewCall);
       FNeg->copyIRFlags(II);
       return FNeg;
     }
 
     // m(m(X, C2), C1) -> m(X, C)
     const APFloat *C1, *C2;
     if (auto *M = dyn_cast<IntrinsicInst>(Arg0)) {
       if (M->getIntrinsicID() == IID && match(Arg1, m_APFloat(C1)) &&
case Intrinsic::amdgcn_cos: {
     }
     break;
   }
   case Intrinsic::sin: {
     Value *X;
     if (match(II->getArgOperand(0), m_OneUse(m_FNeg(m_Value(X))))) {
       // sin(-x) --> -sin(x)
       Value *NewSin = Builder.CreateUnaryIntrinsic(Intrinsic::sin, X, II);
-      Instruction *FNeg = BinaryOperator::CreateFNeg(NewSin);
+      Instruction *FNeg = UnaryOperator::CreateFNeg(NewSin);
       FNeg->copyFastMathFlags(II);
       return FNeg;
     }
     break;
   }
   case Intrinsic::ppc_altivec_lvx:
   case Intrinsic::ppc_altivec_lvxl:
     // Turn PPC lvx -> load if the pointer is known aligned.

lib/Transforms/InstCombine/InstCombineCasts.cpp

switch (OpI->getOpcode()) {
         return CastInst::CreateFPCast(ExactResult, Ty);
       }
     }
 
     // (fptrunc (fneg x)) -> (fneg (fptrunc x))
     Value *X;
     if (match(OpI, m_FNeg(m_Value(X)))) {
       Value *InnerTrunc = Builder.CreateFPTrunc(X, Ty);
-      return BinaryOperator::CreateFNegFMF(InnerTrunc, OpI);
+      return UnaryOperator::CreateFNegFMF(InnerTrunc, OpI);
     }
   }
 
   if (auto *II = dyn_cast<IntrinsicInst>(FPT.getOperand(0))) {
     switch (II->getIntrinsicID()) {
     default: break;
     case Intrinsic::ceil:
     case Intrinsic::fabs:

lib/Transforms/InstCombine/InstCombineInternal.h

public:
   //     I          - Change was made, I is still valid, I may be dead though
   //   otherwise    - Change was made, replace I with returned instruction
   //
   Instruction *visitAdd(BinaryOperator &I);
   Instruction *visitFAdd(BinaryOperator &I);
   Value *OptimizePointerDifference(Value *LHS, Value *RHS, Type *Ty);
   Instruction *visitSub(BinaryOperator &I);
   Instruction *visitFSub(BinaryOperator &I);
+  Instruction *visitFNeg(UnaryOperator &I);
   Instruction *visitMul(BinaryOperator &I);
   Instruction *visitFMul(BinaryOperator &I);
   Instruction *visitURem(BinaryOperator &I);
   Instruction *visitSRem(BinaryOperator &I);
   Instruction *visitFRem(BinaryOperator &I);
   bool simplifyDivRemOfSelectWithZeroOp(BinaryOperator &I);
   Instruction *commonRemTransforms(BinaryOperator &I);
   Instruction *commonIRemTransforms(BinaryOperator &I);

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

if (Instruction *X = foldVectorBinop(I))
     return X;
 
   if (Instruction *FoldedMul = foldBinOpIntoSelectOrPhi(I))
     return FoldedMul;
 
   // X * -1.0 --> -X
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
   if (match(Op1, m_SpecificFP(-1.0)))
-    return BinaryOperator::CreateFNegFMF(Op0, &I);
+    return UnaryOperator::CreateFNegFMF(Op0, &I);
 
   // -X * -Y --> X * Y
   Value *X, *Y;
   if (match(Op0, m_FNeg(m_Value(X))) && match(Op1, m_FNeg(m_Value(Y))))
     return BinaryOperator::CreateFMulFMF(X, Y, &I);
 
   // -X * C --> X * -C
   Constant *C;
   if (match(Op0, m_FNeg(m_Value(X))) && match(Op1, m_Constant(C)))
     return BinaryOperator::CreateFMulFMF(X, ConstantExpr::getFNeg(C), &I);
 
   // Sink negation: -X * Y --> -(X * Y)
   if (match(Op0, m_OneUse(m_FNeg(m_Value(X)))))
-    return BinaryOperator::CreateFNegFMF(Builder.CreateFMulFMF(X, Op1, &I), &I);
+    return UnaryOperator::CreateFNegFMF(Builder.CreateFMulFMF(X, Op1, &I), &I);
 
   // Sink negation: Y * -X --> -(X * Y)
   if (match(Op1, m_OneUse(m_FNeg(m_Value(X)))))
-    return BinaryOperator::CreateFNegFMF(Builder.CreateFMulFMF(X, Op0, &I), &I);
+    return UnaryOperator::CreateFNegFMF(Builder.CreateFMulFMF(X, Op0, &I), &I);
 
   // fabs(X) * fabs(X) -> X * X
   if (Op0 == Op1 && match(Op0, m_Intrinsic<Intrinsic::fabs>(m_Value(X))))
     return BinaryOperator::CreateFMulFMF(X, X, &I);
 
   // (select A, B, C) * (select A, D, E) --> select A, (B*D), (C*E)
   if (Value *V = SimplifySelectsFeedingBinaryOp(I, Op0, Op1))
     return replaceInstUsesWith(I, V);

lib/Transforms/Scalar/Reassociate.cpp

static BinaryOperator *CreateMul(Value *S1, Value *S2, const Twine &Name,
   else {
     BinaryOperator *Res =
       BinaryOperator::CreateFMul(S1, S2, Name, InsertBefore);
     Res->setFastMathFlags(cast<FPMathOperator>(FlagsOp)->getFastMathFlags());
     return Res;
   }
 }
 
-static BinaryOperator *CreateNeg(Value *S1, const Twine &Name,
-                                 Instruction *InsertBefore, Value *FlagsOp) {
+static Instruction *CreateNeg(Value *S1, const Twine &Name,
   if (S1->getType()->isIntOrIntVectorTy())
     return BinaryOperator::CreateNeg(S1, Name, InsertBefore);
   else {
-    BinaryOperator *Res = BinaryOperator::CreateFNeg(S1, Name, InsertBefore);
+    UnaryInstruction *Res = UnaryOperator::CreateFNeg(S1, Name, InsertBefore);
     Res->setFastMathFlags(cast<FPMathOperator>(FlagsOp)->getFastMathFlags());
     return Res;
   }
 }
 
 /// Replace 0-X with X*-1.
 static BinaryOperator *LowerNegateToMultiply(Instruction *Neg) {
   Type *Ty = Neg->getType();
static Value *NegateValue(Value *V, Instruction *BI,
   for (User *U : V->users()) {
     if (!match(U, m_Neg(m_Value())) && !match(U, m_FNeg(m_Value())))
       continue;
 
     // We found one!  Now we have to make sure that the definition dominates
     // this use.  We do this by moving it to the entry block (if it is a
     // non-instruction value) or right after the definition.  These negates will
     // be zapped by reassociate later, so we don't need much finesse here.
-    BinaryOperator *TheNeg = cast<BinaryOperator>(U);
+    Instruction *TheNeg = cast<Instruction>(U);
 
     // Verify that the negate is in this function, V might be a constant expr.
     if (TheNeg->getParent()->getParent() != BI->getParent()->getParent())
       continue;
 
     BasicBlock::iterator InsertPt;
     if (Instruction *InstInput = dyn_cast<Instruction>(V)) {
       if (InvokeInst *II = dyn_cast<InvokeInst>(InstInput)) {
for (User *U : V->users()) {
     } else {
       TheNeg->andIRFlags(BI);
     }
     ToRedo.insert(TheNeg);
     return TheNeg;
   }
 
   // Insert a 'neg' instruction that subtracts the value from zero to get the
   // negation.
-  BinaryOperator *NewNeg = CreateNeg(V, V->getName() + ".neg", BI, BI);
+  Instruction *NewNeg = CreateNeg(V, V->getName() + ".neg", BI, BI);
   ToRedo.insert(NewNeg);
   return NewNeg;
 }
 
 /// Return true if we should break up this subtract of X-Y into (X + -Y).
 static bool ShouldBreakUpSubtract(Instruction *Sub) {
   // If this is a negation, we can't split it up!
   if (match(Sub, m_Neg(m_Value())) || match(Sub, m_FNeg(m_Value()))) 

test/Transforms/InstCombine/cos-1.ll

 
 ; cos(-x) -> cos(x);
 
 define double @cos_negated_arg(double %x) {
 ; ANY-LABEL: @cos_negated_arg(
 ; ANY-NEXT:    [[COS:%.*]] = call double @cos(double [[X:%.*]])
 ; ANY-NEXT:    ret double [[COS]]
 ;
-  %neg = fsub double -0.0, %x
+  %neg = fneg double %x
   %r = call double @cos(double %neg)
   ret double %r
 }
 
 define float @cosf_negated_arg(float %x) {
 ; ANY-LABEL: @cosf_negated_arg(
 ; ANY-NEXT:    [[COS:%.*]] = call float @cosf(float [[X:%.*]])
 ; ANY-NEXT:    ret float [[COS]]
 ;
-  %neg = fsub float -0.0, %x
+  %neg = fneg float %x
   %r = call float @cosf(float %neg)
   ret float %r
 }
 
 define float @cosf_negated_arg_FMF(float %x) {
 ; ANY-LABEL: @cosf_negated_arg_FMF(
 ; ANY-NEXT:    [[COS:%.*]] = call reassoc nnan float @cosf(float [[X:%.*]])
 ; ANY-NEXT:    ret float [[COS]]
 ;
-  %neg = fsub float -0.0, %x
+  %neg = fneg float %x
   %r = call nnan reassoc float @cosf(float %neg)
   ret float %r
 }
 
 ; sin(-x) -> -sin(x);
 
 define double @sin_negated_arg(double %x) {
 ; ANY-LABEL: @sin_negated_arg(
 ; ANY-NEXT:    [[TMP1:%.*]] = call double @sin(double [[X:%.*]])
-; ANY-NEXT:    [[TMP2:%.*]] = fsub double -0.000000e+00, [[TMP1]]
+; ANY-NEXT:    [[TMP2:%.*]] = fneg double [[TMP1]]
 ; ANY-NEXT:    ret double [[TMP2]]
 ;
-  %neg = fsub double -0.0, %x
+  %neg = fneg double %x
   %r = call double @sin(double %neg)
   ret double %r
 }
 
 define float @sinf_negated_arg(float %x) {
 ; ANY-LABEL: @sinf_negated_arg(
 ; ANY-NEXT:    [[TMP1:%.*]] = call float @sinf(float [[X:%.*]])
-; ANY-NEXT:    [[TMP2:%.*]] = fsub float -0.000000e+00, [[TMP1]]
+; ANY-NEXT:    [[TMP2:%.*]] = fneg float [[TMP1]]
 ; ANY-NEXT:    ret float [[TMP2]]
 ;
-  %neg = fsub float -0.0, %x
+  %neg = fneg float %x
   %r = call float @sinf(float %neg)
   ret float %r
 }
 
 define float @sinf_negated_arg_FMF(float %x) {
 ; ANY-LABEL: @sinf_negated_arg_FMF(
 ; ANY-NEXT:    [[TMP1:%.*]] = call nnan afn float @sinf(float [[X:%.*]])
-; ANY-NEXT:    [[TMP2:%.*]] = fsub nnan afn float -0.000000e+00, [[TMP1]]
+; ANY-NEXT:    [[TMP2:%.*]] = fneg nnan afn float [[TMP1]]
 ; ANY-NEXT:    ret float [[TMP2]]
 ;
-  %neg = fsub ninf float -0.0, %x
+  %neg = fneg ninf float %x
   %r = call afn nnan float @sinf(float %neg)
   ret float %r
 }
 
 declare void @use(double)
 
 define double @sin_negated_arg_extra_use(double %x) {
 ; ANY-LABEL: @sin_negated_arg_extra_use(
-; ANY-NEXT:    [[NEG:%.*]] = fsub double -0.000000e+00, [[X:%.*]]
+; ANY-NEXT:    [[NEG:%.*]] = fneg double [[X:%.*]]
 ; ANY-NEXT:    [[R:%.*]] = call double @sin(double [[NEG]])
 ; ANY-NEXT:    call void @use(double [[NEG]])
 ; ANY-NEXT:    ret double [[R]]
 ;
-  %neg = fsub double -0.0, %x
+  %neg = fneg double %x
   %r = call double @sin(double %neg)
   call void @use(double %neg)
   ret double %r
 }
 
 ; -sin(-x) --> sin(x)
 ; PR38458: https://bugs.llvm.org/show_bug.cgi?id=38458
 
 define double @neg_sin_negated_arg(double %x) {
 ; ANY-LABEL: @neg_sin_negated_arg(
 ; ANY-NEXT:    [[TMP1:%.*]] = call double @sin(double [[X:%.*]])
 ; ANY-NEXT:    ret double [[TMP1]]
 ;
-  %neg = fsub double -0.0, %x
+  %neg = fneg double %x
   %r = call double @sin(double %neg)
-  %rn = fsub double -0.0, %r
+  %rn = fneg double %r
   ret double %rn
 }
 
 ; tan(-x) -> -tan(x);
 
 define double @tan_negated_arg(double %x) {
 ; ANY-LABEL: @tan_negated_arg(
 ; ANY-NEXT:    [[TMP1:%.*]] = call double @tan(double [[X:%.*]])
-; ANY-NEXT:    [[TMP2:%.*]] = fsub double -0.000000e+00, [[TMP1]]
+; ANY-NEXT:    [[TMP2:%.*]] = fneg double [[TMP1]]
 ; ANY-NEXT:    ret double [[TMP2]]
 ;
-  %neg = fsub double -0.0, %x
+  %neg = fneg double %x
   %r = call double @tan(double %neg)
   ret double %r
 }
 
 ; tanl(-x) -> -tanl(x);
 
 define fp128 @tanl_negated_arg(fp128 %x) {
 ; ANY-LABEL: @tanl_negated_arg(
 ; ANY-NEXT:    [[TMP1:%.*]] = call fp128 @tanl(fp128 [[X:%.*]])
-; ANY-NEXT:    [[TMP2:%.*]] = fsub fp128 0xL00000000000000008000000000000000, [[TMP1]]
+; ANY-NEXT:    [[TMP2:%.*]] = fneg fp128 [[TMP1]]
 ; ANY-NEXT:    ret fp128 [[TMP2]]
 ;
-  %neg = fsub fp128 0xL00000000000000008000000000000000, %x
+  %neg = fneg fp128 %x
   %r = call fp128 @tanl(fp128 %neg)
   ret fp128 %r
 }
 
 define float @negated_and_shrinkable_libcall(float %f) {
 ; NO-FLOAT-SHRINK-LABEL: @negated_and_shrinkable_libcall(
 ; NO-FLOAT-SHRINK-NEXT:    [[CONV1:%.*]] = fpext float [[F:%.*]] to double
 ; NO-FLOAT-SHRINK-NEXT:    [[COS1:%.*]] = call double @cos(double [[CONV1]])
 ; NO-FLOAT-SHRINK-NEXT:    [[CONV2:%.*]] = fptrunc double [[COS1]] to float
 ; NO-FLOAT-SHRINK-NEXT:    ret float [[CONV2]]
 ;
 ; DO-FLOAT-SHRINK-LABEL: @negated_and_shrinkable_libcall(
 ; DO-FLOAT-SHRINK-NEXT:    [[COSF:%.*]] = call float @cosf(float [[F:%.*]])
 ; DO-FLOAT-SHRINK-NEXT:    ret float [[COSF]]
 ;
   %conv1 = fpext float %f to double
-  %neg = fsub double -0.0, %conv1
+  %neg = fneg double %conv1
   %cos = call double @cos(double %neg)
   %conv2 = fptrunc double %cos to float
   ret float %conv2
 }
 
 ; TODO: It was ok to shrink the libcall, so the intrinsic should shrink too?
 
 define float @negated_and_shrinkable_intrinsic(float %f) {
 ; ANY-LABEL: @negated_and_shrinkable_intrinsic(
 ; ANY-NEXT:    [[CONV1:%.*]] = fpext float [[F:%.*]] to double
 ; ANY-NEXT:    [[COS:%.*]] = call double @llvm.cos.f64(double [[CONV1]])
 ; ANY-NEXT:    [[CONV2:%.*]] = fptrunc double [[COS]] to float
 ; ANY-NEXT:    ret float [[CONV2]]
 ;
   %conv1 = fpext float %f to double
-  %neg = fsub double -0.0, %conv1
+  %neg = fneg double %conv1
   %cos = call double @llvm.cos.f64(double %neg)
   %conv2 = fptrunc double %cos to float
   ret float %conv2
 }
 

test/Transforms/InstCombine/cos-sin-intrinsic.ll

 
 ; Negate is canonicalized after sin.
 
 declare <2 x float> @llvm.sin.v2f32(<2 x float>)
 
 define <2 x float> @fneg_sin(<2 x float> %x){
 ; CHECK-LABEL: @fneg_sin(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x float> @llvm.sin.v2f32(<2 x float> [[X:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fsub <2 x float> <float -0.000000e+00, float -0.000000e+00>, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg <2 x float> [[TMP1]]
 ; CHECK-NEXT:    ret <2 x float> [[R]]
 ;
   %negx = fsub <2 x float> <float -0.0, float -0.0>, %x
   %r = call <2 x float> @llvm.sin.v2f32(<2 x float> %negx)
   ret <2 x float> %r
 }
 
 ; FMF are not required, but they should propagate.
 
 define <2 x float> @fneg_sin_fmf(<2 x float> %x){
 ; CHECK-LABEL: @fneg_sin_fmf(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call nnan arcp afn <2 x float> @llvm.sin.v2f32(<2 x float> [[X:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fsub nnan arcp afn <2 x float> <float -0.000000e+00, float -0.000000e+00>, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg nnan arcp afn <2 x float> [[TMP1]]
 ; CHECK-NEXT:    ret <2 x float> [[R]]
 ;
   %negx = fsub fast <2 x float> <float -0.0, float -0.0>, %x
   %r = call nnan arcp afn <2 x float> @llvm.sin.v2f32(<2 x float> %negx)
   ret <2 x float> %r
 }
 

test/Transforms/InstCombine/fast-math.ll

;
   %t4 = fadd reassoc float %t3, %f1
   ret float %t4
 }
 
 ; Y - (X + Y) --> -X
 
 define float @fsub_fadd_common_op_fneg(float %x, float %y) {
 ; CHECK-LABEL: @fsub_fadd_common_op_fneg(
-; CHECK-NEXT:    [[R:%.*]] = fsub fast float -0.000000e+00, [[X:%.*]]
+; CHECK-NEXT:    [[R:%.*]] = fneg fast float [[X:%.*]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %a = fadd float %x, %y
   %r = fsub fast float %y, %a
   ret float %r
 }
 
 ; Y - (X + Y) --> -X
 ; Check again with 'reassoc' and 'nsz'.
 ; nsz is required because: 0.0 - (0.0 + 0.0) -> 0.0, not -0.0
 
 define float @fsub_fadd_common_op_fneg_reassoc_nsz(float %x, float %y) {
 ; CHECK-LABEL: @fsub_fadd_common_op_fneg_reassoc_nsz(
-; CHECK-NEXT:    [[R:%.*]] = fsub reassoc nsz float -0.000000e+00, [[X:%.*]]
+; CHECK-NEXT:    [[R:%.*]] = fneg reassoc nsz float [[X:%.*]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %a = fadd float %x, %y
   %r = fsub reassoc nsz float %y, %a
   ret float %r
 }
 
 ; Y - (X + Y) --> -X
 
 define <2 x float> @fsub_fadd_common_op_fneg_vec(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @fsub_fadd_common_op_fneg_vec(
-; CHECK-NEXT:    [[R:%.*]] = fsub reassoc nsz <2 x float> <float -0.000000e+00, float -0.000000e+00>, [[X:%.*]]
+; CHECK-NEXT:    [[R:%.*]] = fneg reassoc nsz <2 x float> [[X:%.*]]
 ; CHECK-NEXT:    ret <2 x float> [[R]]
 ;
   %a = fadd <2 x float> %x, %y
   %r = fsub nsz reassoc <2 x float> %y, %a
   ret <2 x float> %r
 }
 
 ; Y - (Y + X) --> -X
 ; Commute operands of the 'add'.
 
 define float @fsub_fadd_common_op_fneg_commute(float %x, float %y) {
 ; CHECK-LABEL: @fsub_fadd_common_op_fneg_commute(
-; CHECK-NEXT:    [[R:%.*]] = fsub reassoc nsz float -0.000000e+00, [[X:%.*]]
+; CHECK-NEXT:    [[R:%.*]] = fneg reassoc nsz float [[X:%.*]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %a = fadd float %y, %x
   %r = fsub reassoc nsz float %y, %a
   ret float %r
 }
 
 ; Y - (Y + X) --> -X
 
 define <2 x float> @fsub_fadd_common_op_fneg_commute_vec(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @fsub_fadd_common_op_fneg_commute_vec(
-; CHECK-NEXT:    [[R:%.*]] = fsub reassoc nsz <2 x float> <float -0.000000e+00, float -0.000000e+00>, [[X:%.*]]
+; CHECK-NEXT:    [[R:%.*]] = fneg reassoc nsz <2 x float> [[X:%.*]]
 ; CHECK-NEXT:    ret <2 x float> [[R]]
 ;
   %a = fadd <2 x float> %y, %x
   %r = fsub reassoc nsz <2 x float> %y, %a
   ret <2 x float> %r
 }
 
 ; (Y - X) - Y --> -X
 ; nsz is required because: (0.0 - 0.0) - 0.0 -> 0.0, not -0.0
 
 define float @fsub_fsub_common_op_fneg(float %x, float %y) {
 ; CHECK-LABEL: @fsub_fsub_common_op_fneg(
-; CHECK-NEXT:    [[R:%.*]] = fsub reassoc nsz float -0.000000e+00, [[X:%.*]]
+; CHECK-NEXT:    [[R:%.*]] = fneg reassoc nsz float [[X:%.*]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %s = fsub float %y, %x
   %r = fsub reassoc nsz float %s, %y
   ret float %r
 }
 
 ; (Y - X) - Y --> -X
 
 define <2 x float> @fsub_fsub_common_op_fneg_vec(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @fsub_fsub_common_op_fneg_vec(
-; CHECK-NEXT:    [[R:%.*]] = fsub reassoc nsz <2 x float> <float -0.000000e+00, float -0.000000e+00>, [[X:%.*]]
+; CHECK-NEXT:    [[R:%.*]] = fneg reassoc nsz <2 x float> [[X:%.*]]
 ; CHECK-NEXT:    ret <2 x float> [[R]]
 ;
   %s = fsub <2 x float> %y, %x
   %r = fsub reassoc nsz <2 x float> %s, %y
   ret <2 x float> %r
 }
 
 ; TODO: This doesn't require 'nsz'.  It should fold to 0 - f2
;
   %add = fadd fast float %conv3, %conv3
   %add2 = fadd fast float %add, %conv3
   ret float %add2
 }
 
 define double @fail2(double %f1, double %f2) {
 ; CHECK-LABEL: @fail2(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fadd fast double [[F2:%.*]], [[F2]]
-; CHECK-NEXT:    [[TMP2:%.*]] = fsub fast double -0.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[TMP2:%.*]] = fneg fast double [[TMP1]]
 ; CHECK-NEXT:    ret double [[TMP2]]
 ;
   %t1 = fsub fast double %f1, %f2
   %t2 = fadd fast double %f1, %f2
   %t3 = fsub fast double %t1, %t2
   ret double %t3
 }
 
;
   ret float %sub
 }
 
 ; (select X+Y, X-Y) => X + (select Y, -Y)
 ; This is always safe.  No FMF required.
 define float @fold16(float %x, float %y) {
 ; CHECK-LABEL: @fold16(
 ; CHECK-NEXT:    [[CMP:%.*]] = fcmp ogt float [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[TMP1:%.*]] = fsub float -0.000000e+00, [[Y]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg float [[Y]]
 ; CHECK-NEXT:    [[R_P:%.*]] = select i1 [[CMP]], float [[Y]], float [[TMP1]]
 ; CHECK-NEXT:    [[R:%.*]] = fadd float [[R_P]], [[X]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %cmp = fcmp ogt float %x, %y
   %plus = fadd float %x, %y
   %minus = fsub float %x, %y
   %r = select i1 %cmp, float %plus, float %minus
;
   %sub = fsub float -0.000000e+00, %f1
   %sub1 = fsub nsz float 0.000000e+00, %f2
   %mul = fmul float %sub, %sub1
   ret float %mul
 }
 
 define float @fneg2(float %x) {
 ; CHECK-LABEL: @fneg2(
-; CHECK-NEXT:    [[SUB:%.*]] = fsub nsz float -0.000000e+00, [[X:%.*]]
+; CHECK-NEXT:    [[SUB:%.*]] = fneg nsz float [[X:%.*]]
 ; CHECK-NEXT:    ret float [[SUB]]
 ;
   %sub = fsub nsz float 0.0, %x
   ret float %sub
 }
 
 define <2 x float> @fneg2_vec_undef(<2 x float> %x) {
 ; CHECK-LABEL: @fneg2_vec_undef(
-; CHECK-NEXT:    [[SUB:%.*]] = fsub nsz <2 x float> <float -0.000000e+00, float -0.000000e+00>, [[X:%.*]]
+; CHECK-NEXT:    [[SUB:%.*]] = fneg nsz <2 x float> [[X:%.*]]
 ; CHECK-NEXT:    ret <2 x float> [[SUB]]
 ;
   %sub = fsub nsz <2 x float> <float undef, float 0.0>, %x
   ret <2 x float> %sub
 }
 
 ; =========================================================================
 ;

test/Transforms/InstCombine/fmul.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -instcombine < %s | FileCheck %s
 
-; (-0.0 - X) * C => X * -C
+; -X * C => X * -C
 define float @neg_constant(float %x) {
 ; CHECK-LABEL: @neg_constant(
 ; CHECK-NEXT:    [[MUL:%.*]] = fmul ninf float [[X:%.*]], -2.000000e+01
 ; CHECK-NEXT:    ret float [[MUL]]
 ;
   %sub = fsub float -0.0, %x
   %mul = fmul ninf float %sub, 2.0e+1
   ret float %mul

 ; CHECK-NEXT:    [[MUL:%.*]] = fmul ninf <2 x float> [[X:%.*]], <float -2.000000e+00, float -3.000000e+00>
 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
 ;
   %sub = fsub <2 x float> <float undef, float -0.0>, %x
   %mul = fmul ninf <2 x float> %sub, <float 2.0, float 3.0>
   ret <2 x float> %mul
 }
 
-; (0.0 - X) * C => X * -C
+; -X * C => X * -C
 define float @neg_nsz_constant(float %x) {
 ; CHECK-LABEL: @neg_nsz_constant(
 ; CHECK-NEXT:    [[MUL:%.*]] = fmul nnan float [[X:%.*]], -2.000000e+01
 ; CHECK-NEXT:    ret float [[MUL]]
 ;
   %sub = fsub nsz float 0.0, %x
   %mul = fmul nnan float %sub, 2.0e+1
   ret float %mul
 }
 
-; (-0.0 - X) * (-0.0 - Y) => X * Y
+; -X * -Y => X * Y
 define float @neg_neg(float %x, float %y) {
 ; CHECK-LABEL: @neg_neg(
 ; CHECK-NEXT:    [[MUL:%.*]] = fmul arcp float [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret float [[MUL]]
 ;
   %sub1 = fsub float -0.0, %x
   %sub2 = fsub float -0.0, %y
   %mul = fmul arcp float %sub1, %sub2

 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
 ;
   %sub1 = fsub <2 x float> <float -0.0, float undef>, %x
   %sub2 = fsub <2 x float> <float undef, float -0.0>, %y
   %mul = fmul arcp <2 x float> %sub1, %sub2
   ret <2 x float> %mul
 }
 
-; (0.0 - X) * (0.0 - Y) => X * Y
+; -X * -Y => X * Y
 define float @neg_neg_nsz(float %x, float %y) {
 ; CHECK-LABEL: @neg_neg_nsz(
 ; CHECK-NEXT:    [[MUL:%.*]] = fmul afn float [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    ret float [[MUL]]
 ;
   %sub1 = fsub nsz float 0.0, %x
   %sub2 = fsub nsz float 0.0, %y
   %mul = fmul afn float %sub1, %sub2
;
   %nx = fsub float -0.0, %x
   %ny = fsub float -0.0, %y
   %mul = fmul afn float %nx, %ny
   call void @use_f32(float %nx)
   call void @use_f32(float %ny)
   ret float %mul
 }
 
-; (-0.0 - X) * Y => -0.0 - (X * Y)
+; -X * Y => -(X * Y)
 define float @neg_sink(float %x, float %y) {
 ; CHECK-LABEL: @neg_sink(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul float [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[MUL:%.*]] = fsub float -0.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[MUL:%.*]] = fneg float [[TMP1]]
 ; CHECK-NEXT:    ret float [[MUL]]
 ;
   %sub = fsub float -0.0, %x
   %mul = fmul float %sub, %y
   ret float %mul
 }
 
 define <2 x float> @neg_sink_vec(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @neg_sink_vec(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul <2 x float> [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[MUL:%.*]] = fsub <2 x float> <float -0.000000e+00, float -0.000000e+00>, [[TMP1]]
+; CHECK-NEXT:    [[MUL:%.*]] = fneg <2 x float> [[TMP1]]
 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
 ;
   %sub = fsub <2 x float> <float -0.0, float -0.0>, %x
   %mul = fmul <2 x float> %sub, %y
   ret <2 x float> %mul
 }
 
 define <2 x float> @neg_sink_vec_undef(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @neg_sink_vec_undef(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul <2 x float> [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[MUL:%.*]] = fsub <2 x float> <float -0.000000e+00, float -0.000000e+00>, [[TMP1]]
+; CHECK-NEXT:    [[MUL:%.*]] = fneg <2 x float> [[TMP1]]
 ; CHECK-NEXT:    ret <2 x float> [[MUL]]
 ;
   %sub = fsub <2 x float> <float undef, float -0.0>, %x
   %mul = fmul <2 x float> %sub, %y
   ret <2 x float> %mul
 }
 
-; (0.0 - X) * Y => 0.0 - (X * Y)
+; -X * Y => -(X * Y)
 define float @neg_sink_nsz(float %x, float %y) {
 ; CHECK-LABEL: @neg_sink_nsz(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fmul float [[X:%.*]], [[Y:%.*]]
-; CHECK-NEXT:    [[MUL:%.*]] = fsub float -0.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[MUL:%.*]] = fneg float [[TMP1]]
 ; CHECK-NEXT:    ret float [[MUL]]
 ;
   %sub1 = fsub nsz float 0.0, %x
   %mul = fmul float %sub1, %y
   ret float %mul
 }
 
-; "(-0.0 - X) * Y => -0.0 - (X * Y)" is disabled if expression "-0.0 - X"
+; "-X * Y => -(X * Y)" is disabled if expression "-X"
 ; has multiple uses.
 define float @neg_sink_multi_use(float %x, float %y) {
 ; CHECK-LABEL: @neg_sink_multi_use(
 ; CHECK-NEXT:    [[SUB1:%.*]] = fsub float -0.000000e+00, [[X:%.*]]
 ; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[SUB1]], [[Y:%.*]]
 ; CHECK-NEXT:    [[MUL2:%.*]] = fmul float [[MUL]], [[SUB1]]
 ; CHECK-NEXT:    ret float [[MUL2]]
 ;

 for.body:                                         ; preds = %for.cond
   %2 = insertelement <4 x float> %local_var_7.0, float 0.000000e+00, i32 2
   br label %for.cond
 
 for.end:                                          ; preds = %for.cond
   ret void
 }
 
-; X * -1.0 => -0.0 - X
+; X * -1.0 => -X
 define float @test9(float %x) {
 ; CHECK-LABEL: @test9(
-; CHECK-NEXT:    [[MUL:%.*]] = fsub float -0.000000e+00, [[X:%.*]]
+; CHECK-NEXT:    [[MUL:%.*]] = fneg float [[X:%.*]]
 ; CHECK-NEXT:    ret float [[MUL]]
 ;
   %mul = fmul float %x, -1.0
   ret float %mul
 }
 
 ; PR18532
 define <4 x float> @test10(<4 x float> %x) {
 ; CHECK-LABEL: @test10(
-; CHECK-NEXT:    [[MUL:%.*]] = fsub arcp afn <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, [[X:%.*]]
+; CHECK-NEXT:    [[MUL:%.*]] = fneg arcp afn <4 x float> [[X:%.*]]
 ; CHECK-NEXT:    ret <4 x float> [[MUL]]
 ;
   %mul = fmul arcp afn <4 x float> %x, <float -1.0, float -1.0, float -1.0, float -1.0>
   ret <4 x float> %mul
 }
 
 define float @test11(float %x, float %y) {
 ; CHECK-LABEL: @test11(

test/Transforms/InstCombine/fpcast.ll

;
   %b = call float @llvm.fabs.f32(float %a)
   %c = fptrunc float %b to half
   ret half %c
 }
 
 define half @fneg_fptrunc(float %a) {
 ; CHECK-LABEL: @fneg_fptrunc(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fptrunc float [[A:%.*]] to half
-; CHECK-NEXT:    [[C:%.*]] = fsub half 0xH8000, [[TMP1]]
+; CHECK-NEXT:    [[C:%.*]] = fneg half [[TMP1]]
 ; CHECK-NEXT:    ret half [[C]]
 ;
   %b = fsub float -0.0, %a
   %c = fptrunc float %b to half
   ret half %c
 }
 
 define <2 x half> @fneg_fptrunc_vec_undef(<2 x float> %a) {
 ; CHECK-LABEL: @fneg_fptrunc_vec_undef(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fptrunc <2 x float> [[A:%.*]] to <2 x half>
-; CHECK-NEXT:    [[C:%.*]] = fsub <2 x half> <half 0xH8000, half 0xH8000>, [[TMP1]]
+; CHECK-NEXT:    [[C:%.*]] = fneg <2 x half> [[TMP1]]
 ; CHECK-NEXT:    ret <2 x half> [[C]]
 ;
   %b = fsub <2 x float> <float -0.0, float undef>, %a
   %c = fptrunc <2 x float> %b to <2 x half>
   ret <2 x half> %c
 }
 
 define half @test4-fast(float %a) {
 ; CHECK-LABEL: @test4-fast(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fptrunc float [[A:%.*]] to half
-; CHECK-NEXT:    [[C:%.*]] = fsub fast half 0xH8000, [[TMP1]]
+; CHECK-NEXT:    [[C:%.*]] = fneg fast half [[TMP1]]
 ; CHECK-NEXT:    ret half [[C]]
 ;
   %b = fsub fast float -0.0, %a
   %c = fptrunc float %b to half
   ret half %c
 }
 
 define half @test5(float %a, float %b, float %c) {

test/Transforms/InstCombine/fsub.ll

 
 ; One-use fptrunc is always hoisted above fneg, so the corresponding
 ; multi-use bug for fptrunc isn't visible with a fold starting from
 ; the last fsub.
 
 define float @neg_trunc_op1_extra_use(double %a, float %b) {
 ; CHECK-LABEL: @neg_trunc_op1_extra_use(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fptrunc double [[A:%.*]] to float
-; CHECK-NEXT:    [[T2:%.*]] = fsub float -0.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[T2:%.*]] = fneg float [[TMP1]]
 ; CHECK-NEXT:    [[T3:%.*]] = fadd float [[TMP1]], [[B:%.*]]
 ; CHECK-NEXT:    call void @use(float [[T2]])
 ; CHECK-NEXT:    ret float [[T3]]
 ;
   %t1 = fsub double -0.0, %a
   %t2 = fptrunc double %t1 to float
   %t3 = fsub float %b, %t2
   call void @use(float %t2)

test/Transforms/InstCombine/maximum.ll

;
   ret float %c
 }
 
 ; PR37404 - https://bugs.llvm.org/show_bug.cgi?id=37404
 
 define <2 x float> @neg_neg(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @neg_neg(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x float> @llvm.minimum.v2f32(<2 x float> [[X:%.*]], <2 x float> [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fsub <2 x float> <float -0.000000e+00, float -0.000000e+00>, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg <2 x float> [[TMP1]]
 ; CHECK-NEXT:    ret <2 x float> [[R]]
 ;
   %negx = fsub <2 x float> <float -0.0, float -0.0>, %x
   %negy = fsub <2 x float> <float -0.0, float -0.0>, %y
   %r = call <2 x float> @llvm.maximum.v2f32(<2 x float> %negx, <2 x float> %negy)
   ret <2 x float> %r
 }
 
 ; FMF is not required, but it should be propagated from the intrinsic (not the fnegs).
 
 define float @neg_neg_vec_fmf(float %x, float %y) {
 ; CHECK-LABEL: @neg_neg_vec_fmf(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call fast float @llvm.minimum.f32(float [[X:%.*]], float [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fsub fast float -0.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg fast float [[TMP1]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %negx = fsub arcp float -0.0, %x
   %negy = fsub afn float -0.0, %y
   %r = call fast float @llvm.maximum.f32(float %negx, float %negy)
   ret float %r
 }
 
 ; 1 extra use of an intermediate value should still allow the fold,
 ; but 2 would require more instructions than we started with.
 
 declare void @use(float)
 define float @neg_neg_extra_use_x(float %x, float %y) {
 ; CHECK-LABEL: @neg_neg_extra_use_x(
 ; CHECK-NEXT:    [[NEGX:%.*]] = fsub float -0.000000e+00, [[X:%.*]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.minimum.f32(float [[X]], float [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fsub float -0.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg float [[TMP1]]
 ; CHECK-NEXT:    call void @use(float [[NEGX]])
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %negx = fsub float -0.0, %x
   %negy = fsub float -0.0, %y
   %r = call float @llvm.maximum.f32(float %negx, float %negy)
   call void @use(float %negx)
   ret float %r
 }
 
 define float @neg_neg_extra_use_y(float %x, float %y) {
 ; CHECK-LABEL: @neg_neg_extra_use_y(
 ; CHECK-NEXT:    [[NEGY:%.*]] = fsub float -0.000000e+00, [[Y:%.*]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float [[Y]])
-; CHECK-NEXT:    [[R:%.*]] = fsub float -0.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg float [[TMP1]]
 ; CHECK-NEXT:    call void @use(float [[NEGY]])
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %negx = fsub float -0.0, %x
   %negy = fsub float -0.0, %y
   %r = call float @llvm.maximum.f32(float %negx, float %negy)
   call void @use(float %negy)
   ret float %r

test/Transforms/InstCombine/maxnum.ll

;
   ret float %c
 }
 
 ; PR37404 - https://bugs.llvm.org/show_bug.cgi?id=37404
 
 define <2 x float> @neg_neg(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @neg_neg(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call <2 x float> @llvm.minnum.v2f32(<2 x float> [[X:%.*]], <2 x float> [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fsub <2 x float> <float -0.000000e+00, float -0.000000e+00>, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg <2 x float> [[TMP1]]
 ; CHECK-NEXT:    ret <2 x float> [[R]]
 ;
   %negx = fsub <2 x float> <float -0.0, float -0.0>, %x
   %negy = fsub <2 x float> <float -0.0, float -0.0>, %y
   %r = call <2 x float> @llvm.maxnum.v2f32(<2 x float> %negx, <2 x float> %negy)
   ret <2 x float> %r
 }
 
 ; FMF is not required, but it should be propagated from the intrinsic (not the fnegs).
 
 define float @neg_neg_vec_fmf(float %x, float %y) {
 ; CHECK-LABEL: @neg_neg_vec_fmf(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call fast float @llvm.minnum.f32(float [[X:%.*]], float [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fsub fast float -0.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg fast float [[TMP1]]
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %negx = fsub arcp float -0.0, %x
   %negy = fsub afn float -0.0, %y
   %r = call fast float @llvm.maxnum.f32(float %negx, float %negy)
   ret float %r
 }
 
 ; 1 extra use of an intermediate value should still allow the fold,
 ; but 2 would require more instructions than we started with.
 
 declare void @use(float)
 define float @neg_neg_extra_use_x(float %x, float %y) {
 ; CHECK-LABEL: @neg_neg_extra_use_x(
 ; CHECK-NEXT:    [[NEGX:%.*]] = fsub float -0.000000e+00, [[X:%.*]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.minnum.f32(float [[X]], float [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fsub float -0.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg float [[TMP1]]
 ; CHECK-NEXT:    call void @use(float [[NEGX]])
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %negx = fsub float -0.0, %x
   %negy = fsub float -0.0, %y
   %r = call float @llvm.maxnum.f32(float %negx, float %negy)
   call void @use(float %negx)
   ret float %r
 }
 
 define float @neg_neg_extra_use_y(float %x, float %y) {
 ; CHECK-LABEL: @neg_neg_extra_use_y(
 ; CHECK-NEXT:    [[NEGY:%.*]] = fsub float -0.000000e+00, [[Y:%.*]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float [[Y]])
-; CHECK-NEXT:    [[R:%.*]] = fsub float -0.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg float [[TMP1]]
 ; CHECK-NEXT:    call void @use(float [[NEGY]])
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %negx = fsub float -0.0, %x
   %negy = fsub float -0.0, %y
   %r = call float @llvm.maxnum.f32(float %negx, float %negy)
   call void @use(float %negy)
   ret float %r

test/Transforms/InstCombine/minimum.ll

;
   ret float %b
 }
 
 ; PR37405 - https://bugs.llvm.org/show_bug.cgi?id=37405
 
 define double @neg_neg(double %x, double %y) {
 ; CHECK-LABEL: @neg_neg(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.maximum.f64(double [[X:%.*]], double [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fsub double -0.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg double [[TMP1]]
 ; CHECK-NEXT:    ret double [[R]]
 ;
   %negx = fsub double -0.0, %x
   %negy = fsub double -0.0, %y
   %r = call double @llvm.minimum.f64(double %negx, double %negy)
   ret double %r
 }
 
 ; FMF is not required, but it should be propagated from the intrinsic (not the fnegs).
 ; Also, make sure this works with vectors.
 
 define <2 x double> @neg_neg_vec_fmf(<2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: @neg_neg_vec_fmf(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call nnan ninf <2 x double> @llvm.maximum.v2f64(<2 x double> [[X:%.*]], <2 x double> [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fsub nnan ninf <2 x double> <double -0.000000e+00, double -0.000000e+00>, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg nnan ninf <2 x double> [[TMP1]]
 ; CHECK-NEXT:    ret <2 x double> [[R]]
 ;
   %negx = fsub reassoc <2 x double> <double -0.0, double -0.0>, %x
   %negy = fsub fast <2 x double> <double -0.0, double -0.0>, %y
   %r = call nnan ninf <2 x double> @llvm.minimum.v2f64(<2 x double> %negx, <2 x double> %negy)
   ret <2 x double> %r
 }
 
 ; 1 extra use of an intermediate value should still allow the fold,
 ; but 2 would require more instructions than we started with.
 
 declare void @use(double)
 define double @neg_neg_extra_use_x(double %x, double %y) {
 ; CHECK-LABEL: @neg_neg_extra_use_x(
 ; CHECK-NEXT:    [[NEGX:%.*]] = fsub double -0.000000e+00, [[X:%.*]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.maximum.f64(double [[X]], double [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fsub double -0.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg double [[TMP1]]
 ; CHECK-NEXT:    call void @use(double [[NEGX]])
 ; CHECK-NEXT:    ret double [[R]]
 ;
   %negx = fsub double -0.0, %x
   %negy = fsub double -0.0, %y
   %r = call double @llvm.minimum.f64(double %negx, double %negy)
   call void @use(double %negx)
   ret double %r
 }
 
 define double @neg_neg_extra_use_y(double %x, double %y) {
 ; CHECK-LABEL: @neg_neg_extra_use_y(
 ; CHECK-NEXT:    [[NEGY:%.*]] = fsub double -0.000000e+00, [[Y:%.*]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.maximum.f64(double [[X:%.*]], double [[Y]])
-; CHECK-NEXT:    [[R:%.*]] = fsub double -0.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg double [[TMP1]]
 ; CHECK-NEXT:    call void @use(double [[NEGY]])
 ; CHECK-NEXT:    ret double [[R]]
 ;
   %negx = fsub double -0.0, %x
   %negy = fsub double -0.0, %y
   %r = call double @llvm.minimum.f64(double %negx, double %negy)
   call void @use(double %negy)
   ret double %r

test/Transforms/InstCombine/minnum.ll

;
   ret float %b
 }
 
 ; PR37405 - https://bugs.llvm.org/show_bug.cgi?id=37405
 
 define double @neg_neg(double %x, double %y) {
 ; CHECK-LABEL: @neg_neg(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fsub double -0.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg double [[TMP1]]
 ; CHECK-NEXT:    ret double [[R]]
 ;
   %negx = fsub double -0.0, %x
   %negy = fsub double -0.0, %y
   %r = call double @llvm.minnum.f64(double %negx, double %negy)
   ret double %r
 }
 
 ; FMF is not required, but it should be propagated from the intrinsic (not the fnegs).
 ; Also, make sure this works with vectors.
 
 define <2 x double> @neg_neg_vec_fmf(<2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: @neg_neg_vec_fmf(
 ; CHECK-NEXT:    [[TMP1:%.*]] = call nnan ninf <2 x double> @llvm.maxnum.v2f64(<2 x double> [[X:%.*]], <2 x double> [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fsub nnan ninf <2 x double> <double -0.000000e+00, double -0.000000e+00>, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg nnan ninf <2 x double> [[TMP1]]
 ; CHECK-NEXT:    ret <2 x double> [[R]]
 ;
   %negx = fsub reassoc <2 x double> <double -0.0, double -0.0>, %x
   %negy = fsub fast <2 x double> <double -0.0, double -0.0>, %y
   %r = call nnan ninf <2 x double> @llvm.minnum.v2f64(<2 x double> %negx, <2 x double> %negy)
   ret <2 x double> %r
 }
 
 ; 1 extra use of an intermediate value should still allow the fold,
 ; but 2 would require more instructions than we started with.
 
 declare void @use(double)
 define double @neg_neg_extra_use_x(double %x, double %y) {
 ; CHECK-LABEL: @neg_neg_extra_use_x(
 ; CHECK-NEXT:    [[NEGX:%.*]] = fsub double -0.000000e+00, [[X:%.*]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.maxnum.f64(double [[X]], double [[Y:%.*]])
-; CHECK-NEXT:    [[R:%.*]] = fsub double -0.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg double [[TMP1]]
 ; CHECK-NEXT:    call void @use(double [[NEGX]])
 ; CHECK-NEXT:    ret double [[R]]
 ;
   %negx = fsub double -0.0, %x
   %negy = fsub double -0.0, %y
   %r = call double @llvm.minnum.f64(double %negx, double %negy)
   call void @use(double %negx)
   ret double %r
 }
 
 define double @neg_neg_extra_use_y(double %x, double %y) {
 ; CHECK-LABEL: @neg_neg_extra_use_y(
 ; CHECK-NEXT:    [[NEGY:%.*]] = fsub double -0.000000e+00, [[Y:%.*]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = call double @llvm.maxnum.f64(double [[X:%.*]], double [[Y]])
-; CHECK-NEXT:    [[R:%.*]] = fsub double -0.000000e+00, [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fneg double [[TMP1]]
 ; CHECK-NEXT:    call void @use(double [[NEGY]])
 ; CHECK-NEXT:    ret double [[R]]
 ;
   %negx = fsub double -0.0, %x
   %negy = fsub double -0.0, %y
   %r = call double @llvm.minnum.f64(double %negx, double %negy)
   call void @use(double %negy)
   ret double %r

test/Transforms/InstCombine/pow-1.ll

 ; MSVC-NEXT:   ret <2 x double> [[POW]]
 ;
   %retval = call <2 x double> @llvm.pow.v2f64(<2 x double> <double 2.0, double 2.0>, <2 x double> %x)
   ret <2 x double> %retval
 }
 
 define <2 x float> @test_simplify4vn(<2 x float> %x) {
 ; CHECK-LABEL: @test_simplify4vn(
-; ANY-NEXT:    [[MUL:%.*]] = fsub <2 x float> <float -0.000000e+00, float -0.000000e+00>, [[X:%.*]]
+; ANY-NEXT:    [[MUL:%.*]] = fneg <2 x float> [[X:%.*]]
 ; ANY-NEXT:    [[EXP2:%.*]] = call <2 x float> @llvm.exp2.v2f32(<2 x float> [[MUL]])
 ; ANY-NEXT:    ret <2 x float> [[EXP2]]
 ; MSVC-NEXT:   [[POW:%.*]] = call <2 x float> @llvm.pow.v2f32(<2 x float> <float 5.000000e-01, float 5.000000e-01>, <2 x float> [[X:%.*]])
 ; MSVC-NEXT:   ret <2 x float> [[POW]]
 ;
   %retval = call <2 x float> @llvm.pow.v2f32(<2 x float> <float 0.5, float 0.5>, <2 x float> %x)
   ret <2 x float> %retval
 }

test/Transforms/InstCombine/select-crash.ll

 ; RUN: opt < %s -instcombine -S | FileCheck %s
 ; Formerly crashed, PR8490.
 
 define fastcc double @gimp_operation_color_balance_map(float %value, double %highlights) nounwind readnone inlinehint {
 entry:
 ; CHECK: gimp_operation_color_balance_map
-; CHECK: fsub double -0.000000
+; CHECK: fneg double
   %conv = fpext float %value to double
   %div = fdiv double %conv, 1.600000e+01
   %add = fadd double %div, 1.000000e+00
   %div1 = fdiv double 1.000000e+00, %add
   %sub = fsub double 1.075000e+00, %div1
   %sub24 = fsub double 1.000000e+00, %sub
   %add26 = fadd double %sub, 1.000000e+00
   %cmp86 = fcmp ogt double %highlights, 0.000000e+00
   %cond90 = select i1 %cmp86, double %sub24, double %add26
   %mul91 = fmul double %highlights, %cond90
   %add94 = fadd double %mul91, %mul91
   ret double %add94
 }
 
 ; PR10180: same crash, but with vectors
 define <4 x float> @foo(i1 %b, <4 x float> %x, <4 x float> %y, <4 x float> %z) {
 ; CHECK-LABEL: @foo(
-; CHECK: fsub <4 x float>
+; CHECK: fneg <4 x float>
 ; CHECK: select
 ; CHECK: fadd <4 x float>
   %a = fadd <4 x float> %x, %y
   %sub = fsub <4 x float> %x, %z
   %sel = select i1 %b, <4 x float> %a, <4 x float> %sub 
   ret <4 x float> %sel
 }

test/Transforms/Reassociate/fast-SubReassociate.ll

 
 define float @test4(float %A, float %B, float %C, float %D) {
 ; FIXME: InstCombine should be able to get us to the following:
 ; %sum = fadd fast float %B, %A
 ; %sum1 = fadd fast float %sum, %C
 ; %Q = fsub fast float %D, %sum1
 ; ret i32 %Q
 ; CHECK-LABEL: @test4(
-; CHECK-NEXT:    [[B_NEG:%.*]] = fsub fast float -0.000000e+00, %B
+; CHECK-NEXT:    [[B_NEG:%.*]] = fneg fast float %B
 ; CHECK-NEXT:    [[O_NEG:%.*]] = fsub fast float [[B_NEG]], %A
 ; CHECK-NEXT:    [[P:%.*]] = fsub fast float [[O_NEG]], %C
 ; CHECK-NEXT:    [[Q:%.*]] = fadd fast float [[P]], %D
 ; CHECK-NEXT:    ret float [[Q]]
 ;
   %M = fadd fast float 1.200000e+01, %A
   %N = fadd fast float %M, %B
   %O = fadd fast float %N, %C

test/Transforms/Reassociate/fast-basictest.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt < %s -reassociate -gvn -instcombine -S | FileCheck %s
 
 ; With reassociation, constant folding can eliminate the 12 and -12 constants.
 define float @test1(float %arg) {
 ; CHECK-LABEL: @test1(
-; CHECK-NEXT:    [[ARG_NEG:%.*]] = fsub fast float -0.000000e+00, [[ARG:%.*]]
+; CHECK-NEXT:    [[ARG_NEG:%.*]] = fneg fast float [[ARG:%.*]]
 ; CHECK-NEXT:    ret float [[ARG_NEG]]
 ;
   %t1 = fsub fast float -1.200000e+01, %arg
   %t2 = fadd fast float %t1, 1.200000e+01
   ret float %t2
 }
 
 ; Check again using the minimal subset of FMF.
 ; Both 'reassoc' and 'nsz' are required.
 define float @test1_minimal(float %arg) {
 ; CHECK-LABEL: @test1_minimal(
-; CHECK-NEXT:    [[ARG_NEG:%.*]] = fsub reassoc nsz float -0.000000e+00, [[ARG:%.*]]
+; CHECK-NEXT:    [[ARG_NEG:%.*]] = fneg reassoc nsz float [[ARG:%.*]]
 ; CHECK-NEXT:    ret float [[ARG_NEG]]
 ;
   %t1 = fsub reassoc nsz float -1.200000e+01, %arg
   %t2 = fadd reassoc nsz float %t1, 1.200000e+01
   ret float %t2
 }
 
 ; Verify the fold is not done with only 'reassoc' ('nsz' is required).

 
 ; With sub reassociation, constant folding can eliminate the uses of %a.
 define float @test20(float %a, float %b, float %c) nounwind  {
 ; FIXME: Should be able to generate the below, which may expose more
 ;        opportunites for FAdd reassociation.
 ; %sum = fadd fast float %c, %b
 ; %t7 = fsub fast float 0, %sum
 ; CHECK-LABEL: @test20(
-; CHECK-NEXT:    [[B_NEG:%.*]] = fsub fast float -0.000000e+00, [[B:%.*]]
+; CHECK-NEXT:    [[B_NEG:%.*]] = fneg fast float [[B:%.*]]
 ; CHECK-NEXT:    [[T7:%.*]] = fsub fast float [[B_NEG]], [[C:%.*]]
 ; CHECK-NEXT:    ret float [[T7]]
 ;
   %t3 = fsub fast float %a, %b
   %t5 = fsub fast float %t3, %c
   %t7 = fsub fast float %t5, %a
   ret float %t7
 }

test/Transforms/Reassociate/fp-expr.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -reassociate < %s | FileCheck %s
 
 define void @test1() {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    [[T1:%.*]] = tail call <4 x float> @blam()
-; CHECK-NEXT:    [[T1_NEG:%.*]] = fsub fast <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, [[T1]]
+; CHECK-NEXT:    [[T1_NEG:%.*]] = fneg fast <4 x float> [[T1]]
 ; CHECK-NEXT:    [[T24:%.*]] = fadd fast <4 x float> [[T1_NEG]], undef
 ; CHECK-NEXT:    tail call void @wombat(<4 x float> [[T24]])
 ; CHECK-NEXT:    ret void
 ;
   %t1 = tail call <4 x float> @blam()
   %t23 = fsub fast <4 x float> undef, %t1
   %t24 = fadd fast <4 x float> %t23, undef
   tail call void @wombat(<4 x float> %t24)
   ret void
 }
 
 define half @test2() {
 ; CHECK-LABEL: @test2(
 ; CHECK-NEXT:    [[T15:%.*]] = fsub fast half undef, undef
-; CHECK-NEXT:    [[T15_NEG:%.*]] = fsub fast half 0xH8000, [[T15]]
+; CHECK-NEXT:    [[T15_NEG:%.*]] = fneg fast half [[T15]]
 ; CHECK-NEXT:    [[T18:%.*]] = fadd fast half [[T15_NEG]], undef
 ; CHECK-NEXT:    ret half [[T18]]
 ;
   %t15 = fsub fast half undef, undef
   %t17 = fsub fast half undef, %t15
   %t18 = fadd fast half undef, %t17
   ret half %t18
 }

unittests/IR/IRBuilderTest.cpp

TEST_F(IRBuilderTest, GetIntTy) {
   unsigned IntPtrBitSize =  DL->getPointerSizeInBits(0);
   EXPECT_EQ(IntPtrTy, IntegerType::get(Ctx, IntPtrBitSize));
   delete DL;
 }
 
 TEST_F(IRBuilderTest, FastMathFlags) {
   IRBuilder<> Builder(BB);
   Value *F, *FC;
-  Instruction *FDiv, *FAdd, *FCmp, *FCall;
+  Instruction *FDiv, *FAdd, *FNeg, *FCmp, *FCall;
 
   F = Builder.CreateLoad(GV->getValueType(), GV);
   F = Builder.CreateFAdd(F, F);
 
   EXPECT_FALSE(Builder.getFastMathFlags().any());
   ASSERT_TRUE(isa<Instruction>(F));
   FAdd = cast<Instruction>(F);
   EXPECT_FALSE(FAdd->hasNoNaNs());
 
+  F = Builder.CreateFNeg(F);
+  ASSERT_TRUE(isa<Instruction>(F));
+  FNeg = cast<Instruction>(F);
+  EXPECT_FALSE(FNeg->hasNoNaNs());
+  EXPECT_TRUE(FNeg->getOpcode() == Instruction::FNeg);
+
   FastMathFlags FMF;
   Builder.setFastMathFlags(FMF);
 
   // By default, no flags are set.
   F = Builder.CreateFAdd(F, F);
   EXPECT_FALSE(Builder.getFastMathFlags().any());
   ASSERT_TRUE(isa<Instruction>(F));
   FAdd = cast<Instruction>(F);