Add FNeg IR constant folding

[cameron.mcinally]

Summary

Here's another subset of D61419. This patch contains the FNeg IR constant folding changes and some code in Analysis so that InstCombine can make use of it.

There are only two folds being performed right now:

fneg undef -> undef
fneg C -> -C

New tests for those 2 folds have been added to the existing InstCombine fneg.ll tests (which are all fsub(-0.0, X) tests right now).

In addition to the new tests, there are quite a few existing tests in place that used to operate on fsub(-0.0, X), so coverage is pretty good. If you'd like to convince yourself of this, you can comment out the call to ConstantFoldUnaryInstruction(...) in lib/IR/Constants.cpp.

[spatel]

llvm/include/llvm/Analysis/ConstantFolding.h

75–76

IIUC, this comment is wrong. If it fails, it returns a nullptr. No attempt is made to reduce a ConstExpr (ie, there is no SymbolicallyEvaluateUnOp()).

The existing comment below for binops looks misleading if I interpreted that correctly.

llvm/lib/Analysis/ConstantFolding.cpp

1002

I know this is modified from the existing comment line, but I don't see how either adds value. I'd remove both lines.

llvm/lib/IR/ConstantFold.cpp

931

We already asserted that we have a unary op, so can this be "default: llvm_unreachable..."?

llvm/lib/IR/Constants.cpp

1834

Code comment doesn't add anything IMO.

[spatel]

llvm/include/llvm/Analysis/ConstantFolding.h

75–76

Oops - disregard. I got my overloads mixed up.

llvm/test/Transforms/InstCombine/fneg.ll

158–159

Please pre-commit these tests to trunk, so we'll just show the test diffs from this code patch.

[cameron.mcinally]

llvm/lib/IR/ConstantFold.cpp

931

This was copied from ConstantFoldBinaryInstruction(...), so that should probably be updated to keep them in sync, as well as any similar switches. I can do that in a separate patch, if you'd like.

[cameron.mcinally]

Address Sanjay's comments.

[spatel]

LGTM - although you probably want to change that 'default' in the switch statement back to match based on the comments in D61555.

Also (and sorry I didn't see this earlier) - the new tests for the minimal constant folding really could go in test/Analysis/ConstantFolding/ and use 'opt -constprop'. Ie, we shouldn't need to run all of instcombine or even instsimplify to see those diffs. We don't have great separation for those boundaries in several existing cases, so I'd call it a 'nice to have' change rather than a requirement.

[cameron.mcinally]

Revert default case change from ConstantFoldUnaryInstruction(...) and move fneg.ll tests to new file test/Analysis/ConstantFolding/fneg.ll.

[cameron.mcinally]

Ack, forgot to include the Differential link in the commit log. Was merged with:

Author: mcinally
Date: Sun May  5 09:07:09 2019
New Revision: 359982

URL: http://llvm.org/viewvc/llvm-project?rev=359982&view=rev
Log:
Add FNeg IR constant folding support

Added:
    llvm/trunk/test/Analysis/ConstantFolding/fneg.ll
Modified:
    llvm/trunk/include/llvm/Analysis/ConstantFolding.h
    llvm/trunk/lib/Analysis/ConstantFolding.cpp
    llvm/trunk/lib/IR/ConstantFold.cpp
    llvm/trunk/lib/IR/ConstantFold.h
    llvm/trunk/lib/IR/Constants.cpp
    llvm/trunk/test/Transforms/InstCombine/fneg.ll
    llvm/trunk/test/Transforms/InstCombine/fsub.ll
    llvm/trunk/test/Transforms/InstCombine/inselt-binop.ll
    llvm/trunk/test/Transforms/Reassociate/crash2.ll
    llvm/trunk/unittests/IR/ConstantsTest.cpp

llvm/include/llvm/Analysis/ConstantFolding.h

 /// instruction (icmp/fcmp) with the specified operands.  If it fails, it
 /// returns a constant expression of the specified operands.
 ///
 Constant *
 ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS,
                                 Constant *RHS, const DataLayout &DL,
                                 const TargetLibraryInfo *TLI = nullptr);
 
+/// Attempt to constant fold a unary operation with the specified
+/// operand. If it fails, it returns a constant expression of the specified
+/// operands.
+Constant *ConstantFoldUnaryOpOperand(unsigned Opcode, Constant *Op,
+                                     const DataLayout &DL);
+
 /// Attempt to constant fold a binary operation with the specified
 /// operands.  If it fails, it returns a constant expression of the specified
 /// operands.
 Constant *ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS,
                                        Constant *RHS, const DataLayout &DL);
 
 /// Attempt to constant fold a select instruction with the specified
 /// operands. The constant result is returned if successful; if not, null is

llvm/lib/Analysis/ConstantFolding.cpp

 /// attempting to fold instructions like loads and stores, which have no
 /// constant expression form.
 Constant *ConstantFoldInstOperandsImpl(const Value *InstOrCE, unsigned Opcode,
                                        ArrayRef<Constant *> Ops,
                                        const DataLayout &DL,
                                        const TargetLibraryInfo *TLI) {
   Type *DestTy = InstOrCE->getType();
 
-  // Handle easy binops first.
+  if (Instruction::isUnaryOp(Opcode))
+    return ConstantFoldUnaryOpOperand(Opcode, Ops[0], DL);
+
   if (Instruction::isBinaryOp(Opcode))
     return ConstantFoldBinaryOpOperands(Opcode, Ops[0], Ops[1], DL);
 
   if (Instruction::isCast(Opcode))
     return ConstantFoldCastOperand(Opcode, Ops[0], DestTy, DL);
 
   if (auto *GEP = dyn_cast<GEPOperator>(InstOrCE)) {
     if (Constant *C = SymbolicallyEvaluateGEP(GEP, Ops, DL, TLI))
if (auto *CE0 = dyn_cast<ConstantExpr>(Ops0)) {
     // operands and try again.
     Predicate = ICmpInst::getSwappedPredicate((ICmpInst::Predicate)Predicate);
     return ConstantFoldCompareInstOperands(Predicate, Ops1, Ops0, DL, TLI);
   }
 
   return ConstantExpr::getCompare(Predicate, Ops0, Ops1);
 }
 
+Constant *llvm::ConstantFoldUnaryOpOperand(unsigned Opcode, Constant *Op,
+                                           const DataLayout &DL) {
+  assert(Instruction::isUnaryOp(Opcode));
+
+  return ConstantExpr::get(Opcode, Op);
+}
+
 Constant *llvm::ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS,
                                              Constant *RHS,
                                              const DataLayout &DL) {
   assert(Instruction::isBinaryOp(Opcode));
   if (isa<ConstantExpr>(LHS) || isa<ConstantExpr>(RHS))
     if (Constant *C = SymbolicallyEvaluateBinop(Opcode, LHS, RHS, DL))
       return C;
 

llvm/lib/IR/ConstantFold.h

template <typename T> class ArrayRef;
   Constant *ConstantFoldInsertElementInstruction(Constant *Val, Constant *Elt,
                                                  Constant *Idx);
   Constant *ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2,
                                                  Constant *Mask);
   Constant *ConstantFoldExtractValueInstruction(Constant *Agg,
                                                 ArrayRef<unsigned> Idxs);
   Constant *ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val,
                                                ArrayRef<unsigned> Idxs);
+  Constant *ConstantFoldUnaryInstruction(unsigned Opcode, Constant *V);
   Constant *ConstantFoldBinaryInstruction(unsigned Opcode, Constant *V1,
                                           Constant *V2);
   Constant *ConstantFoldCompareInstruction(unsigned short predicate,
                                            Constant *C1, Constant *C2);
   Constant *ConstantFoldGetElementPtr(Type *Ty, Constant *C, bool InBounds,
                                       Optional<unsigned> InRangeIndex,
                                       ArrayRef<Value *> Idxs);
 } // End llvm namespace
 
 #endif

llvm/lib/IR/ConstantFold.cpp

Constant *llvm::ConstantFoldInsertValueInstruction(Constant *Agg,
 
   if (StructType *ST = dyn_cast<StructType>(Agg->getType()))
     return ConstantStruct::get(ST, Result);
   if (ArrayType *AT = dyn_cast<ArrayType>(Agg->getType()))
     return ConstantArray::get(AT, Result);
   return ConstantVector::get(Result);
 }
 
+Constant *llvm::ConstantFoldUnaryInstruction(unsigned Opcode, Constant *C) {
+  assert(Instruction::isUnaryOp(Opcode) && "Non-unary instruction detected");
+
+  // Handle scalar UndefValue. Vectors are always evaluated per element.
+  bool HasScalarUndef = !C->getType()->isVectorTy() && isa<UndefValue>(C);
+
+  if (HasScalarUndef) {
+    switch (static_cast<Instruction::UnaryOps>(Opcode)) {
+    case Instruction::FNeg:
+      return C; // -undef -> undef
+    case Instruction::UnaryOpsEnd:
+      llvm_unreachable("Invalid UnaryOp");
+    }
+  }
+
+  // Constant should not be UndefValue, unless these are vector constants.
+  assert(!HasScalarUndef && "Unexpected UndefValue");
+  // We only have FP UnaryOps right now.
+  assert(!isa<ConstantInt>(C) && "Unexpected Integer UnaryOp");
+
+  if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
+    const APFloat &CV = CFP->getValueAPF();
+    switch (Opcode) {
+    default:
+      break;
+    case Instruction::FNeg:
+      return ConstantFP::get(C->getContext(), neg(CV));
+    }
+  } else if (VectorType *VTy = dyn_cast<VectorType>(C->getType())) {
+    // Fold each element and create a vector constant from those constants.
+    SmallVector<Constant*, 16> Result;
+    Type *Ty = IntegerType::get(VTy->getContext(), 32);
+    for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) {
+      Constant *ExtractIdx = ConstantInt::get(Ty, i);
+      Constant *Elt = ConstantExpr::getExtractElement(C, ExtractIdx);
+
+      Result.push_back(ConstantExpr::get(Opcode, Elt));
+    }
+
+    return ConstantVector::get(Result);
+  }
+
+  // We don't know how to fold this.
+  return nullptr;
+}
+
 Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, Constant *C1,
                                               Constant *C2) {
   assert(Instruction::isBinaryOp(Opcode) && "Non-binary instruction detected");
 
   // Handle scalar UndefValue. Vectors are always evaluated per element.
   bool HasScalarUndef = !C1->getType()->isVectorTy() &&
                         (isa<UndefValue>(C1) || isa<UndefValue>(C2));
   if (HasScalarUndef) {

llvm/lib/IR/Constants.cpp

assert(C->getType()->isFPOrFPVectorTy() &&
            "Tried to create a floating-point operation on a "
            "non-floating-point type!");
     break;
   default:
     break;
   }
 #endif
 
-  // TODO: Try to constant fold operation.
+  if (Constant *FC = ConstantFoldUnaryInstruction(Opcode, C))
+    return FC;
 
   if (OnlyIfReducedTy == C->getType())
     return nullptr;
 
   Constant *ArgVec[] = { C };
   ConstantExprKeyType Key(Opcode, ArgVec, 0, Flags);
 
   LLVMContextImpl *pImpl = C->getContext().pImpl;
assert(C1->getType()->isIntOrIntVectorTy() &&
            "Tried to create a shift operation on a non-integer type!");
     break;
   default:
     break;
   }
 #endif
 
   if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2))
-    return FC;          // Fold a few common cases.
+    return FC;
 
   if (OnlyIfReducedTy == C1->getType())
     return nullptr;
 
   Constant *ArgVec[] = { C1, C2 };
   ConstantExprKeyType Key(Opcode, ArgVec, 0, Flags);
 
   LLVMContextImpl *pImpl = C1->getContext().pImpl;
assert(C->getType()->isIntOrIntVectorTy() &&
          "Cannot NEG a nonintegral value!");
   return getSub(ConstantFP::getZeroValueForNegation(C->getType()),
                 C, HasNUW, HasNSW);
 }
 
 Constant *ConstantExpr::getFNeg(Constant *C) {
   assert(C->getType()->isFPOrFPVectorTy() &&
          "Cannot FNEG a non-floating-point value!");
-  return getFSub(ConstantFP::getZeroValueForNegation(C->getType()), C);
+  return get(Instruction::FNeg, C);
 }
 
 Constant *ConstantExpr::getNot(Constant *C) {
   assert(C->getType()->isIntOrIntVectorTy() &&
          "Cannot NOT a nonintegral value!");
   return get(Instruction::Xor, C, Constant::getAllOnesValue(C->getType()));
 }
 
if (GO->isInBounds())
                                                Ops[0], Ops.slice(1));
     return GetElementPtrInst::Create(GO->getSourceElementType(), Ops[0],
                                      Ops.slice(1));
   }
   case Instruction::ICmp:
   case Instruction::FCmp:
     return CmpInst::Create((Instruction::OtherOps)getOpcode(),
                            (CmpInst::Predicate)getPredicate(), Ops[0], Ops[1]);
-
+  case Instruction::FNeg:
+    return UnaryOperator::Create((Instruction::UnaryOps)getOpcode(), Ops[0]);
   default:
     assert(getNumOperands() == 2 && "Must be binary operator?");
     BinaryOperator *BO =
       BinaryOperator::Create((Instruction::BinaryOps)getOpcode(),
                              Ops[0], Ops[1]);
     if (isa<OverflowingBinaryOperator>(BO)) {
       BO->setHasNoUnsignedWrap(SubclassOptionalData &
                                OverflowingBinaryOperator::NoUnsignedWrap);
       BO->setHasNoSignedWrap(SubclassOptionalData &
                              OverflowingBinaryOperator::NoSignedWrap);
     }
     if (isa<PossiblyExactOperator>(BO))
       BO->setIsExact(SubclassOptionalData & PossiblyExactOperator::IsExact);
     return BO;
   }
 }

llvm/test/Analysis/ConstantFolding/fneg.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -constprop -S | FileCheck %s
+
+define float @fneg_constant() {
+; CHECK-LABEL: @fneg_constant(
+; CHECK-NEXT:    ret float 0.000000e+00
+;
+  %r = fneg float -0.0
+  ret float %r
+}
+
+define float @fneg_undef() {
+; CHECK-LABEL: @fneg_undef(
+; CHECK-NEXT:    ret float undef
+;
+  %r = fneg float undef
+  ret float %r
+}
+
+define <4 x float> @fneg_constant_elts_v4f32() {
+; CHECK-LABEL: @fneg_constant_elts_v4f32(
+; CHECK-NEXT:    ret <4 x float> <float 0.000000e+00, float -0.000000e+00, float 1.000000e+00, float -1.000000e+00>
+;
+  %r = fneg <4 x float> <float -0.0, float 0.0, float -1.0, float 1.0>
+  ret <4 x float> %r
+}
+
+define <4 x float> @fneg_constant_undef_elts_v4f32() {
+; CHECK-LABEL: @fneg_constant_undef_elts_v4f32(
+; CHECK-NEXT:    ret <4 x float> <float 0.000000e+00, float undef, float undef, float -1.000000e+00>
+;
+  %r = fneg <4 x float> <float -0.0, float undef, float undef, float 1.0>
+  ret <4 x float> %r
+}
+
+define <4 x float> @fneg_constant_all_undef_elts_v4f32() {
+; CHECK-LABEL: @fneg_constant_all_undef_elts_v4f32(
+; CHECK-NEXT:    ret <4 x float> undef
+;
+  %r = fneg <4 x float> <float undef, float undef, float undef, float undef>
+  ret <4 x float> %r
+}

llvm/test/Transforms/InstCombine/fneg.ll

;
   call void @use(float %m)
   ret float %r
 }
 
 ; Try a vector. Use special constants (NaN, INF, undef) because they don't change anything.
 
 define <4 x double> @fmul_fneg_vec(<4 x double> %x) {
 ; CHECK-LABEL: @fmul_fneg_vec(
-; CHECK-NEXT:    [[R:%.*]] = fmul <4 x double> [[X:%.*]], <double -4.200000e+01, double 0x7F80000000000000, double 0xFFF0000000000000, double 0x7FF8000000000000>
+; CHECK-NEXT:    [[R:%.*]] = fmul <4 x double> [[X:%.*]], <double -4.200000e+01, double 0x7F80000000000000, double 0xFFF0000000000000, double undef>
 ; CHECK-NEXT:    ret <4 x double> [[R]]
 ;
   %m = fmul <4 x double> %x, <double 42.0, double 0x7FF80000000000000, double 0x7FF0000000000000, double undef>
   %r = fsub <4 x double> <double -0.0, double -0.0, double -0.0, double -0.0>, %m
   ret <4 x double> %r
 }
 
 ; -(X / C) --> X / (-C)
;
   call void @use(float %d)
   ret float %r
 }
 
 ; Try a vector. Use special constants (NaN, INF, undef) because they don't change anything.
 
 define <4 x double> @fdiv_op1_constant_fneg_vec(<4 x double> %x) {
 ; CHECK-LABEL: @fdiv_op1_constant_fneg_vec(
-; CHECK-NEXT:    [[R:%.*]] = fdiv <4 x double> [[X:%.*]], <double 4.200000e+01, double 0x7FF800000ABCD000, double 0x7FF0000000000000, double 0x7FF8000000000000>
+; CHECK-NEXT:    [[R:%.*]] = fdiv <4 x double> [[X:%.*]], <double 4.200000e+01, double 0x7FF800000ABCD000, double 0x7FF0000000000000, double undef>
 ; CHECK-NEXT:    ret <4 x double> [[R]]
 ;
   %d = fdiv <4 x double> %x, <double -42.0, double 0xFFF800000ABCD000, double 0xFFF0000000000000, double undef>
   %r = fsub <4 x double> <double -0.0, double -0.0, double -0.0, double -0.0>, %d
   ret <4 x double> %r
 }
 
 ; -(C / X) --> (-C) / X
;
   call void @use(float %d)
   ret float %r
 }
 
 ; Try a vector. Use special constants (NaN, INF, undef) because they don't change anything.
 
 define <4 x double> @fdiv_op0_constant_fneg_vec(<4 x double> %x) {
 ; CHECK-LABEL: @fdiv_op0_constant_fneg_vec(
-; CHECK-NEXT:    [[R:%.*]] = fdiv <4 x double> <double 4.200000e+01, double 0x7F80000000000000, double 0x7FF0000000000000, double 0x7FF8000000000000>, [[X:%.*]]
+; CHECK-NEXT:    [[R:%.*]] = fdiv <4 x double> <double 4.200000e+01, double 0x7F80000000000000, double 0x7FF0000000000000, double undef>, [[X:%.*]]
 ; CHECK-NEXT:    ret <4 x double> [[R]]
 ;
   %d = fdiv <4 x double> <double -42.0, double 0x7FF80000000000000, double 0xFFF0000000000000, double undef>, %x
   %r = fsub <4 x double> <double -0.0, double -0.0, double -0.0, double -0.0>, %d
   ret <4 x double> %r
 }
-
-; Actual fneg instructions.
-
-define float @fneg_constant() {
-; CHECK-LABEL: @fneg_constant(
-; CHECK-NEXT:    [[R:%.*]] = fneg float -0.000000e+00
-; CHECK-NEXT:    ret float [[R]]
-;
-  %r = fneg float -0.0
-  ret float %r
-}
-
-define float @fneg_undef() {
-; CHECK-LABEL: @fneg_undef(
-; CHECK-NEXT:    [[R:%.*]] = fneg float undef
-; CHECK-NEXT:    ret float [[R]]
-;
-  %r = fneg float undef
-  ret float %r
-}
-
-define <4 x float> @fneg_constant_elts_v4f32() {
-; CHECK-LABEL: @fneg_constant_elts_v4f32(
-; CHECK-NEXT:    [[R:%.*]] = fneg <4 x float> <float -0.000000e+00, float 0.000000e+00, float -1.000000e+00, float 1.000000e+00>
-; CHECK-NEXT:    ret <4 x float> [[R]]
-;
-  %r = fneg <4 x float> <float -0.0, float 0.0, float -1.0, float 1.0>
-  ret <4 x float> %r
-}
-
-define <4 x float> @fneg_constant_undef_elts_v4f32() {
-; CHECK-LABEL: @fneg_constant_undef_elts_v4f32(
-; CHECK-NEXT:    [[R:%.*]] = fneg <4 x float> <float -0.000000e+00, float undef, float undef, float 1.000000e+00>
-; CHECK-NEXT:    ret <4 x float> [[R]]
-;
-  %r = fneg <4 x float> <float -0.0, float undef, float undef, float 1.0>
-  ret <4 x float> %r
-}
-
-define <4 x float> @fneg_constant_all_undef_elts_v4f32() {
-; CHECK-LABEL: @fneg_constant_all_undef_elts_v4f32(
-; CHECK-NEXT:    [[R:%.*]] = fneg <4 x float> undef
-; CHECK-NEXT:    ret <4 x float> [[R]]
-;
-  %r = fneg <4 x float> <float undef, float undef, float undef, float undef>
-  ret <4 x float> %r
-}

llvm/test/Transforms/InstCombine/fsub.ll

;
   %t2 = fsub nsz float %z, %t1
   ret float %t2
 }
 
 ; With nsz and reassoc: Y - ((X * 5) + Y) --> X * -5
 
 define float @sub_add_neg_x(float %x, float %y) {
 ; CHECK-LABEL: @sub_add_neg_x(
-; CHECK-NEXT:    [[TMP1:%.*]] = fmul reassoc nsz float [[X:%.*]], -5.000000e+00
-; CHECK-NEXT:    ret float [[TMP1]]
+; CHECK-NEXT:    [[R:%.*]] = fmul reassoc nsz float [[X:%.*]], -5.000000e+00
+; CHECK-NEXT:    ret float [[R]]
 ;
   %mul = fmul float %x, 5.000000e+00
   %add = fadd float %mul, %y
   %r = fsub nsz reassoc float %y, %add
   ret float %r
 }
 
 ; Same as above: if 'Z' is not -0.0, swap fsub operands and convert to fadd.

 ; CHECK-NEXT:    ret <2 x float> [[R]]
 ;
   %r = fsub <2 x float> %x, <float 42.0, float -42.0>
   ret <2 x float> %r
 }
 
 define <2 x float> @constant_op1_vec_undef(<2 x float> %x, <2 x float> %y) {
 ; CHECK-LABEL: @constant_op1_vec_undef(
-; CHECK-NEXT:    [[R:%.*]] = fadd <2 x float> [[X:%.*]], <float 0x7FF8000000000000, float 4.200000e+01>
+; CHECK-NEXT:    [[R:%.*]] = fadd <2 x float> [[X:%.*]], <float undef, float 4.200000e+01>
 ; CHECK-NEXT:    ret <2 x float> [[R]]
 ;
   %r = fsub <2 x float> %x, <float undef, float -42.0>
   ret <2 x float> %r
 }
 
 ; X - (-Y) --> X + Y
 

llvm/test/Transforms/InstCombine/inselt-binop.ll

;
   %ins = insertelement <2 x float> undef, float %x, i32 1
   %bo = fsub nsz <2 x float> <float 42.0, float -42.0>, %ins
   ret <2 x float> %bo
 }
 
 define <2 x float> @fsub_constant_op1(float %x) {
 ; CHECK-LABEL: @fsub_constant_op1(
 ; CHECK-NEXT:    [[INS:%.*]] = insertelement <2 x float> undef, float [[X:%.*]], i32 1
-; CHECK-NEXT:    [[BO:%.*]] = fadd <2 x float> [[INS]], <float 0x7FF8000000000000, float -4.200000e+01>
+; CHECK-NEXT:    [[BO:%.*]] = fadd <2 x float> [[INS]], <float undef, float -4.200000e+01>
 ; CHECK-NEXT:    ret <2 x float> [[BO]]
 ;
   %ins = insertelement <2 x float> undef, float %x, i32 1
   %bo = fsub <2 x float> %ins, <float undef, float 42.0>
   ret <2 x float> %bo
 }
 
 define <2 x float> @fsub_constant_op1_not_undef_lane(float %x) {

llvm/test/Transforms/Reassociate/crash2.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -reassociate %s -S -o - | FileCheck %s
 
 ; Reassociate pass used to crash on these example
 
 @g = global i32 0
 
 define float @undef1() {
 ; CHECK-LABEL: @undef1(
-; CHECK-NEXT:    ret float fadd (float bitcast (i32 ptrtoint (i32* @g to i32) to float), float fadd (float bitcast (i32 ptrtoint (i32* @g to i32) to float), float fadd (float fsub (float -0.000000e+00, float bitcast (i32 ptrtoint (i32* @g to i32) to float)), float fsub (float -0.000000e+00, float bitcast (i32 ptrtoint (i32* @g to i32) to float)))))
+; CHECK-NEXT:    ret float fadd (float bitcast (i32 ptrtoint (i32* @g to i32) to float), float fadd (float bitcast (i32 ptrtoint (i32* @g to i32) to float), float fadd (float fneg (float bitcast (i32 ptrtoint (i32* @g to i32) to float)), float fneg (float bitcast (i32 ptrtoint (i32* @g to i32) to float)))))
 ;
   %t0 = fadd fast float bitcast (i32 ptrtoint (i32* @g to i32) to float), bitcast (i32 ptrtoint (i32* @g to i32) to float)
   %t1 = fsub fast float bitcast (i32 ptrtoint (i32* @g to i32) to float), %t0
   %t2 = fadd fast float bitcast (i32 ptrtoint (i32* @g to i32) to float), %t1
   ret float %t2
 }
 
 define void @undef2() {

llvm/unittests/IR/ConstantsTest.cpp

TEST(ConstantsTest, AsInstructionsTest) {
   #define P1STR "uitofp (i32 ptrtoint (i32** @dummy to i32) to float)"
   #define P2STR "uitofp (i32 ptrtoint (i32** @dummy to i32) to double)"
   #define P3STR "ptrtoint (i32** @dummy to i1)"
   #define P4STR "ptrtoint (i32** @dummy2 to i32)"
   #define P5STR "uitofp (i32 ptrtoint (i32** @dummy2 to i32) to float)"
   #define P6STR "bitcast (i32 ptrtoint (i32** @dummy2 to i32) to <2 x i16>)"
 
   CHECK(ConstantExpr::getNeg(P0), "sub i32 0, " P0STR);
-  CHECK(ConstantExpr::getFNeg(P1), "fsub float -0.000000e+00, " P1STR);
+  CHECK(ConstantExpr::getFNeg(P1), "fneg float " P1STR);
   CHECK(ConstantExpr::getNot(P0), "xor i32 " P0STR ", -1");
   CHECK(ConstantExpr::getAdd(P0, P0), "add i32 " P0STR ", " P0STR);
   CHECK(ConstantExpr::getAdd(P0, P0, false, true), "add nsw i32 " P0STR ", "
         P0STR);
   CHECK(ConstantExpr::getAdd(P0, P0, true, true), "add nuw nsw i32 " P0STR ", "
         P0STR);
   CHECK(ConstantExpr::getFAdd(P1, P1), "fadd float " P1STR ", " P1STR);
   CHECK(ConstantExpr::getSub(P0, P0), "sub i32 " P0STR ", " P0STR);