Remove BinaryOperator::CreateFNeg

[simoll]

Summary

With the introduction of the native fneg instruction, the
fsub -0.0, %x idiom is obsolete. This patch makes LLVM
emit fneg instead of the idiom in all places.

[simoll]

• rebased
• fixed clang complex-math test

[xbolva00]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

341

What about this TODO?

[simoll]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

341

Ok. So this seems to be a hack to update the FSub idiom on the fly.
How about we get rid of the TODO and the code below in a separate patch?

[xbolva00]

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

341

I agree

[cameron.mcinally]

LGTM, with the TODO to be handled under a separate patch.

Thank you for taking care of this, Simon.

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

341

+1

[simoll]

• rebased

clang/test/CodeGen/complex-math.c

float _Complex div_float_rc(float a, float _Complex b) {
   // BD = 0
   // ACpBD = AC
   //
   // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast float [[C]], [[C]]
   // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast float [[D]], [[D]]
   // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast float [[CC]], [[DD]]
   //
   // BC = 0
-  // AARCH64-FASTMATH: [[NEGA:%.*]] = fsub fast float -0.000000e+00, %a
+  // AARCH64-FASTMATH: [[NEGA:%.*]] = fneg fast float %a
   // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast float  [[D]], [[NEGA]]
   //
   // AARCH64-FASTMATH: fdiv fast float [[AC]], [[CCpDD]]
   // AARCH64-FASTMATH: fdiv fast float [[AD]], [[CCpDD]]
   // AARCH64-FASTMATH: ret
   return a / b;
 }
 float _Complex div_float_cc(float _Complex a, float _Complex b) {
double _Complex div_double_rc(double a, double _Complex b) {
   // BD = 0
   // ACpBD = AC
   //
   // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast double [[C]], [[C]]
   // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast double [[D]], [[D]]
   // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast double [[CC]], [[DD]]
   //
   // BC = 0
-  // AARCH64-FASTMATH: [[NEGA:%.*]] = fsub fast double -0.000000e+00, %a
+  // AARCH64-FASTMATH: [[NEGA:%.*]] = fneg fast double %a
   // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast double [[D]], [[NEGA]]
   //
   // AARCH64-FASTMATH: fdiv fast double [[AC]], [[CCpDD]]
   // AARCH64-FASTMATH: fdiv fast double [[AD]], [[CCpDD]]
   // AARCH64-FASTMATH: ret
   return a / b;
 }
 double _Complex div_double_cc(double _Complex a, double _Complex b) {
long double _Complex div_long_double_rc(long double a, long double _Complex b) {
   // BD = 0
   // ACpBD = AC
   //
   // AARCH64-FASTMATH: [[CC:%.*]] = fmul fast fp128 [[C]], [[C]]
   // AARCH64-FASTMATH: [[DD:%.*]] = fmul fast fp128 [[D]], [[D]]
   // AARCH64-FASTMATH: [[CCpDD:%.*]] = fadd fast fp128 [[CC]], [[DD]]
   //
   // BC = 0
-  // AARCH64-FASTMATH: [[NEGA:%.*]] = fsub fast fp128 0xL00000000000000008000000000000000, %a
+  // AARCH64-FASTMATH: [[NEGA:%.*]] = fneg fast fp128 %a
   // AARCH64-FASTMATH: [[AD:%.*]] = fmul fast fp128 [[D]], [[NEGA]]
   //
   // AARCH64-FASTMATH: fdiv fast fp128 [[AC]], [[CCpDD]]
   // AARCH64-FASTMATH: fdiv fast fp128 [[AD]], [[CCpDD]]
   // AARCH64-FASTMATH: ret
   return a / b;
 }
 long double _Complex div_long_double_cc(long double _Complex a, long double _Complex b) {

llvm/include/llvm/IR/InstrTypes.h

 #include "llvm/IR/Instruction.def"
 #define HANDLE_UNARY_INST(N, OPC, CLASS) \
   static UnaryOperator *Create##OPC(Value *V, const Twine &Name, \
                                     Instruction *I) {\
     return Create(Instruction::OPC, V, Name, I);\
   }
 #include "llvm/IR/Instruction.def"
 
-  static UnaryOperator *CreateWithCopiedFlags(UnaryOps Opc,
-                                              Value *V,
-                                              Instruction *CopyO,
-                                              const Twine &Name = "") {
-    UnaryOperator *UO = Create(Opc, V, Name);
+  static UnaryOperator *
+  CreateWithCopiedFlags(UnaryOps Opc, Value *V, Instruction *CopyO,
+                        const Twine &Name = "",
+                        Instruction *InsertBefore = nullptr) {
+    UnaryOperator *UO = Create(Opc, V, Name, InsertBefore);
     UO->copyIRFlags(CopyO);
     return UO;
   }
 
   static UnaryOperator *CreateFNegFMF(Value *Op, Instruction *FMFSource,
-                                      const Twine &Name = "") {
-    return CreateWithCopiedFlags(Instruction::FNeg, Op, FMFSource, Name);
+                                      const Twine &Name = "",
+                                      Instruction *InsertBefore = nullptr) {
+    return CreateWithCopiedFlags(Instruction::FNeg, Op, FMFSource, Name,
+                                 InsertBefore);
   }
 
   UnaryOps getOpcode() const {
     return static_cast<UnaryOps>(Instruction::getOpcode());
   }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
static BinaryOperator *CreateFDivFMF(Value *V1, Value *V2,
                                        const Twine &Name = "") {
     return CreateWithCopiedFlags(Instruction::FDiv, V1, V2, FMFSource, Name);
   }
   static BinaryOperator *CreateFRemFMF(Value *V1, Value *V2,
                                        Instruction *FMFSource,
                                        const Twine &Name = "") {
     return CreateWithCopiedFlags(Instruction::FRem, V1, V2, FMFSource, Name);
   }
-  static BinaryOperator *CreateFNegFMF(Value *Op, Instruction *FMFSource,
-                                       const Twine &Name = "") {
-    Value *Zero = ConstantFP::getNegativeZero(Op->getType());
-    return CreateWithCopiedFlags(Instruction::FSub, Zero, Op, FMFSource, Name);
-  }
 
   static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2,
                                    const Twine &Name = "") {
     BinaryOperator *BO = Create(Opc, V1, V2, Name);
     BO->setHasNoSignedWrap(true);
     return BO;
   }
   static BinaryOperator *CreateNSW(BinaryOps Opc, Value *V1, Value *V2,
#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);
-  static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name = "",
-                                    Instruction *InsertBefore = nullptr);
-  static BinaryOperator *CreateFNeg(Value *Op, const Twine &Name,
-                                    BasicBlock *InsertAtEnd);
   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());
   }

llvm/lib/IR/Instructions.cpp

 }
 
 BinaryOperator *BinaryOperator::CreateNUWNeg(Value *Op, const Twine &Name,
                                              BasicBlock *InsertAtEnd) {
   Value *zero = ConstantFP::getZeroValueForNegation(Op->getType());
   return BinaryOperator::CreateNUWSub(zero, Op, Name, InsertAtEnd);
 }
 
-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);
-}
-
 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);
 }
 
 BinaryOperator *BinaryOperator::CreateNot(Value *Op, const Twine &Name,

llvm/lib/Transforms/InstCombine/InstCombineAddSub.cpp

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);
 
   if (Instruction *X = foldFNegIntoConstant(I))
     return X;
 
   if (Instruction *R = hoistFNegAboveFMulFDiv(I, Builder))
     return R;
 
   Value *X, *Y;
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)))) {

llvm/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.

llvm/lib/Transforms/InstCombine/InstCombineCasts.cpp

if (isa<FPMathOperator>(Op))
       Builder.setFastMathFlags(Op->getFastMathFlags());
 
     if (match(Op, m_FNeg(m_Value(X)))) {
       Value *InnerTrunc = Builder.CreateFPTrunc(X, Ty);
 
       // FIXME: Once we're sure that unary FNeg optimizations are on par with
       // binary FNeg, this should always return a unary operator.
       if (isa<BinaryOperator>(Op))
-        return BinaryOperator::CreateFNegFMF(InnerTrunc, Op);
+        return UnaryOperator::CreateFNegFMF(InnerTrunc, Op);
       return UnaryOperator::CreateFNegFMF(InnerTrunc, Op);
     }
 
     // If we are truncating a select that has an extended operand, we can
     // narrow the other operand and do the select as a narrow op.
     Value *Cond, *X, *Y;
     if (match(Op, m_Select(m_Value(Cond), m_FPExt(m_Value(X)), m_Value(Y))) &&
         X->getType() == Ty) {

llvm/lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

if (Instruction *FoldedMul = foldBinOpIntoSelectOrPhi(I))
     return FoldedMul;
 
   if (Value *FoldedMul = foldMulSelectToNegate(I, Builder))
     return replaceInstUsesWith(I, 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;

llvm/lib/Transforms/InstCombine/InstCombineSelect.cpp

return CastInst::Create(Instruction::CastOps(TI->getOpcode()), NewSI,
                             TI->getType());
   }
 
   // Cond ? -X : -Y --> -(Cond ? X : Y)
   Value *X, *Y;
   if (match(TI, m_FNeg(m_Value(X))) && match(FI, m_FNeg(m_Value(Y))) &&
       (TI->hasOneUse() || FI->hasOneUse())) {
     Value *NewSel = Builder.CreateSelect(Cond, X, Y, SI.getName() + ".v", &SI);
     // TODO: Remove the hack for the binop form when the unary op is optimized
     //       properly with all IR passes.
     if (TI->getOpcode() != Instruction::FNeg)
-      return BinaryOperator::CreateFNegFMF(NewSel, cast<BinaryOperator>(TI));
+      return UnaryOperator::CreateFNegFMF(NewSel, cast<BinaryOperator>(TI));
     return UnaryOperator::CreateFNeg(NewSel);
   }
 
   // Only handle binary operators (including two-operand getelementptr) with
   // one-use here. As with the cast case above, it may be possible to relax the
   // one-use constraint, but that needs be examined carefully since it may not
   // reduce the total number of instructions.
   if (TI->getNumOperands() != 2 || FI->getNumOperands() != 2 ||

llvm/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);
-    Res->setFastMathFlags(cast<FPMathOperator>(FlagsOp)->getFastMathFlags());
-    return Res;
-  }
+
+  if (auto *FMFSource = dyn_cast<Instruction>(FlagsOp))
+    return UnaryOperator::CreateFNegFMF(S1, FMFSource, Name, InsertBefore);
+
+  return UnaryOperator::CreateFNeg(S1, Name, InsertBefore);
 }
 
 /// Replace 0-X with X*-1.
 static BinaryOperator *LowerNegateToMultiply(Instruction *Neg) {
   assert((isa<UnaryOperator>(Neg) || isa<BinaryOperator>(Neg)) &&
          "Expected a Negate!");
   // FIXME: It's not safe to lower a unary FNeg into a FMul by -1.0.
   unsigned OpNo = isa<BinaryOperator>(Neg) ? 1 : 0;
if (TheNeg->getOpcode() == Instruction::Sub) {
       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()))) 

llvm/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
 }
 
 define <2 x float> @unary_fneg_sin(<2 x float> %x){
 ; CHECK-LABEL: @unary_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 = fneg <2 x float> %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
 }
 
 define <2 x float> @unary_fneg_sin_fmf(<2 x float> %x){
 ; CHECK-LABEL: @unary_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 = fneg fast <2 x float> %x
   %r = call nnan arcp afn <2 x float> @llvm.sin.v2f32(<2 x float> %negx)
   ret <2 x float> %r
 }

llvm/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
;
   %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
 }
 
 ; =========================================================================
 ;

llvm/test/Transforms/InstCombine/fmul.ll

;
   %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
 define float @neg_sink_nsz(float %x, float %y) {
 ; CHECK-LABEL: @neg_sink_nsz(
-; CHECK-NEXT:    [[SUB1:%.*]] = fsub nsz float -0.000000e+00, [[X:%.*]]
+; CHECK-NEXT:    [[SUB1:%.*]] = fneg nsz float [[X:%.*]]
 ; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[SUB1]], [[Y:%.*]]
 ; CHECK-NEXT:    ret float [[MUL]]
 ;
   %sub1 = fsub nsz float 0.0, %x
   %mul = fmul float %sub1, %y
   ret float %mul
 }
 

 
 for.end:                                          ; preds = %for.cond
   ret void
 }
 
 ; X * -1.0 => -0.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(

llvm/test/Transforms/InstCombine/fneg.ll

 
 ; Legacy form of fneg should work too.
 
 define float @fsub_fsub_sel_extra_use1(float %x, float %y, i1 %cond) {
 ; CHECK-LABEL: @fsub_fsub_sel_extra_use1(
 ; CHECK-NEXT:    [[N1:%.*]] = fsub float -0.000000e+00, [[X:%.*]]
 ; CHECK-NEXT:    call void @use(float [[N1]])
 ; CHECK-NEXT:    [[SEL_V:%.*]] = select i1 [[COND:%.*]], float [[X]], float [[Y:%.*]]
-; CHECK-NEXT:    [[SEL:%.*]] = fsub float -0.000000e+00, [[SEL_V]]
+; CHECK-NEXT:    [[SEL:%.*]] = fneg float [[SEL_V]]
 ; CHECK-NEXT:    ret float [[SEL]]
 ;
   %n1 = fsub float -0.0, %x
   call void @use(float %n1)
   %n2 = fsub float -0.0, %y
   %sel = select i1 %cond, float %n1, float %n2
   ret float %sel
 }

llvm/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 half @unary_fneg_fptrunc(float %a) {
 ; CHECK-LABEL: @unary_fneg_fptrunc(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fptrunc float [[A:%.*]] to half
 ; CHECK-NEXT:    [[C:%.*]] = fneg half [[TMP1]]
 ; CHECK-NEXT:    ret half [[C]]
 ;
   %b = fneg float %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 <2 x half> @unary_fneg_fptrunc_vec(<2 x float> %a) {
 ; CHECK-LABEL: @unary_fneg_fptrunc_vec(
 ; CHECK-NEXT:    [[TMP1:%.*]] = fptrunc <2 x float> [[A:%.*]] to <2 x half>
 ; CHECK-NEXT:    [[C:%.*]] = fneg <2 x half> [[TMP1]]
 ; CHECK-NEXT:    ret <2 x half> [[C]]
 ;
   %b = fneg <2 x float> %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 @test4_unary_fneg-fast(float %a) {

llvm/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)

llvm/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
 }
 
 define <2 x float> @unary_neg_neg(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @unary_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 = fneg <2 x float> %x
   %negy = fneg <2 x float> %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
 }
 
 define float @unary_neg_neg_vec_fmf(float %x, float %y) {
 ; CHECK-LABEL: @unary_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 = fneg arcp float %x
   %negy = fneg afn float %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 @unary_neg_neg_extra_use_x(float %x, float %y) {
 ; CHECK-LABEL: @unary_neg_neg_extra_use_x(
 ; CHECK-NEXT:    [[NEGX:%.*]] = fneg float [[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 = fneg float %x
   %negy = fneg float %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
 }
 
 define float @unary_neg_neg_extra_use_y(float %x, float %y) {
 ; CHECK-LABEL: @unary_neg_neg_extra_use_y(
 ; CHECK-NEXT:    [[NEGY:%.*]] = fneg float [[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 = fneg float %x
   %negy = fneg float %y
   %r = call float @llvm.maximum.f32(float %negx, float %negy)
   call void @use(float %negy)
   ret float %r

llvm/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
 }
 
 define float @unary_neg_neg_vec_fmf(float %x, float %y) {
 ; CHECK-LABEL: @unary_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 = fneg arcp float %x
   %negy = fneg afn float %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 @unary_neg_neg_extra_use_x(float %x, float %y) {
 ; CHECK-LABEL: @unary_neg_neg_extra_use_x(
 ; CHECK-NEXT:    [[NEGX:%.*]] = fneg float [[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 = fneg float %x
   %negy = fneg float %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
 }
 
 define float @unary_neg_neg_extra_use_y(float %x, float %y) {
 ; CHECK-LABEL: @unary_neg_neg_extra_use_y(
 ; CHECK-NEXT:    [[NEGY:%.*]] = fneg float [[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 = fneg float %x
   %negy = fneg float %y
   %r = call float @llvm.maxnum.f32(float %negx, float %negy)
   call void @use(float %negy)
   ret float %r

llvm/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
 }
 
 define double @unary_neg_neg(double %x, double %y) {
 ; CHECK-LABEL: @unary_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 = fneg double %x
   %negy = fneg double %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
 }
 
 define <2 x double> @unary_neg_neg_vec_fmf(<2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: @unary_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 = fneg reassoc <2 x double> %x
   %negy = fneg fast <2 x double> %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 @unary_neg_neg_extra_use_x(double %x, double %y) {
 ; CHECK-LABEL: @unary_neg_neg_extra_use_x(
 ; CHECK-NEXT:    [[NEGX:%.*]] = fneg double [[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 = fneg double %x
   %negy = fneg double %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
 }
 
 define double @unary_neg_neg_extra_use_y(double %x, double %y) {
 ; CHECK-LABEL: @unary_neg_neg_extra_use_y(
 ; CHECK-NEXT:    [[NEGY:%.*]] = fneg double [[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 = fneg double %x
   %negy = fneg double %y
   %r = call double @llvm.minimum.f64(double %negx, double %negy)
   call void @use(double %negy)
   ret double %r

llvm/test/Transforms/InstCombine/minmax-fp.ll

;
   %max = select i1 %cond, float %n1, float %n2
   ret float %max
 }
 
 define <2 x float> @fsub_fmax(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: define {{[^@]+}}@fsub_fmax(
 ; CHECK-NEXT:    [[COND_INV:%.*]] = fcmp nnan nsz ogt <2 x float> [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = select nnan nsz <2 x i1> [[COND_INV]], <2 x float> [[Y]], <2 x float> [[X]]
-; CHECK-NEXT:    [[MAX:%.*]] = fsub <2 x float> <float -0.000000e+00, float -0.000000e+00>, [[TMP1]]
+; CHECK-NEXT:    [[MAX:%.*]] = fneg <2 x float> [[TMP1]]
 ; CHECK-NEXT:    ret <2 x float> [[MAX]]
 ;
   %n1 = fsub <2 x float> <float -0.0, float -0.0>, %x
   %n2 = fsub <2 x float> <float -0.0, float -0.0>, %y
   %cond = fcmp nsz nnan uge <2 x float> %n1, %n2
   %max = select <2 x i1> %cond, <2 x float> %n1, <2 x float> %n2
   ret <2 x float> %max
 }
 
 define <2 x double> @fsub_fmin(<2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: define {{[^@]+}}@fsub_fmin(
 ; CHECK-NEXT:    [[COND:%.*]] = fcmp nnan ogt <2 x double> [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    [[MAX_V:%.*]] = select <2 x i1> [[COND]], <2 x double> [[X]], <2 x double> [[Y]]
-; CHECK-NEXT:    [[MAX:%.*]] = fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, [[MAX_V]]
+; CHECK-NEXT:    [[MAX:%.*]] = fneg <2 x double> [[MAX_V]]
 ; CHECK-NEXT:    ret <2 x double> [[MAX]]
 ;
   %n1 = fsub <2 x double> <double -0.0, double -0.0>, %x
   %n2 = fsub <2 x double> <double -0.0, double -0.0>, %y
   %cond = fcmp nnan olt <2 x double> %n1, %n2
   %max = select <2 x i1> %cond, <2 x double> %n1, <2 x double> %n2
   ret <2 x double> %max
 }

llvm/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
 }
 
 define double @unary_neg_neg(double %x, double %y) {
 ; CHECK-LABEL: @unary_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 = fneg double %x
   %negy = fneg double %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
 }
 
 define <2 x double> @unary_neg_neg_vec_fmf(<2 x double> %x, <2 x double> %y) {
 ; CHECK-LABEL: @unary_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 = fneg reassoc <2 x double> %x
   %negy = fneg fast <2 x double> %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 @unary_neg_neg_extra_use_x(double %x, double %y) {
 ; CHECK-LABEL: @unary_neg_neg_extra_use_x(
 ; CHECK-NEXT:    [[NEGX:%.*]] = fneg double [[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 = fneg double %x
   %negy = fneg double %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
 }
 
 define double @unary_neg_neg_extra_use_y(double %x, double %y) {
 ; CHECK-LABEL: @unary_neg_neg_extra_use_y(
 ; CHECK-NEXT:    [[NEGY:%.*]] = fneg double [[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 = fneg double %x
   %negy = fneg double %y
   %r = call double @llvm.minnum.f64(double %negx, double %negy)
   call void @use(double %negy)
   ret double %r

llvm/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
 }

llvm/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:    [[TMP1:%.*]] = fsub reassoc nsz float -0.000000e+00, [[ARG:%.*]]
+; CHECK-NEXT:    [[TMP1:%.*]] = fneg reassoc nsz float [[ARG:%.*]]
 ; CHECK-NEXT:    ret float [[TMP1]]
 ;
   %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).

llvm/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
 }