Support FNeg ConstantExpr folding

[cameron.mcinally]

Summary

Also, fix ConstantExpr::getFNeg(...) so that it actually returns an FNeg(X), not an FSub(-0.0, X).

[arsenm]

llvm/lib/IR/ConstantFold.cpp

948–949

You can use neg(CV) and remove C1V

[arsenm]

llvm/test/CodeGen/X86/fp-fold.ll

226–242

These tests don't really belong in codegen (same for the vector cases).

Can you also add a test with some weird constant expressions as a source?

[cameron.mcinally]

Use neg(...) instead of changeSign().

[cameron.mcinally]

llvm/test/CodeGen/X86/fp-fold.ll

226–242

These tests don't really belong in codegen (same for the vector cases).

I'm not that familiar with LLVM's testing layout. Where should they go?

Can you also add a test with some weird constant expressions as a source?

Do you mean like the 42.0 I see everywhere? Or something more exotic?

There are existing tests that exercise NaN, Inf, and undef in place now. Those came for free from the old FNEG(X) -> FSUB(-0.0, X) work.

[arsenm]

llvm/test/CodeGen/X86/fp-fold.ll

226–242

Looks like test/Analysis/ConstantFolding is probably the right place.

I mean something like a bitcast of a global address, that isa<Constant>, but isn't ConstantFP

[spatel]

Let me know if I'm not seeing it correctly, but the DAG change is independent of the IR changes, so it should be a stand-alone patch.

[cameron.mcinally]

llvm/test/CodeGen/X86/fp-fold.ll

226–242

Sorry, my ignorance is showing here...

Looks like test/Analysis/ConstantFolding is probably the right place.

It looks like all the RUN: lines in that directory invoke opt with a specific pass or general optimization level. I think I need llc to trigger the constant folder for this patch. Is that correct? Or am I missing something obvious...

[arsenm]

llvm/test/CodeGen/X86/fp-fold.ll

226–242

llc should definitely not be needed.

I would expect -instsimplify to work.

[cameron.mcinally]

In D61419#1487834, @spatel wrote:

Let me know if I'm not seeing it correctly, but the DAG change is independent of the IR changes, so it should be a stand-alone patch.

Yes, you're correct. Kind of... I noticed that FNeg wasn't folding vectors with some undef elements correctly while working on this change. I can separate that patch if you'd like.

[cameron.mcinally]

llvm/test/CodeGen/X86/fp-fold.ll

226–242

I would expect -instsimplify to work.

It does not. Not even with -O3.

This is probably a problem with my understanding of Constant Folding. The code I added only folds constants when a new ConstantExpr is created. I don't see any hooks for an opt pass to do folding on the fly though. I'll keep digging to see if I can find my problem...

Or maybe I should just be writing more complex tests that regenerate the FNeg after one of its operands are optimized. I'm not sure...

[cameron.mcinally]

llvm/test/CodeGen/X86/fp-fold.ll

226–242

I would expect ` to work

Ah, ok. So the instsimplify pass does it's own folding apart from ConstantExpr. That code will need updating too...

[cameron.mcinally]

Couple of updates...

In D61419#1487929, @cameron.mcinally wrote:

In D61419#1487834, @spatel wrote:

Let me know if I'm not seeing it correctly, but the DAG change is independent of the IR changes, so it should be a stand-alone patch.

Yes, you're correct. Kind of... I noticed that FNeg wasn't folding vectors with some undef elements correctly while working on this change. I can separate that patch if you'd like.

This actually can't be separated out. We were mistakenly generating an FSub, instead of an FNeg in the IRBuilder, so the DAG code won't trigger without the IRBuilder change. I won't be able to write a test for it without that change (at least that I know about right now) .

I would expect -instsimplify to work.

@arsenm, the InstructionSimplify pass has a whole different sets of folds from the ConstantExpr folds. Piling on top of that, we'll have to add support for UnaryInstructions to the other passes that make use of InstructionSimplify. That seems like a big change. @kpn is also working on D61447, which I just found out about. I propose adding the ConstantExpr folding changes as-is, with the expectation that InstructionSimplify folding (and probably other places that I don't know about) will have to be done too. Does anyone feel strongly against this?

[cameron.mcinally]

In D61419#1488170, @cameron.mcinally wrote:

Couple of updates...

In D61419#1487929, @cameron.mcinally wrote:

In D61419#1487834, @spatel wrote:

Let me know if I'm not seeing it correctly, but the DAG change is independent of the IR changes, so it should be a stand-alone patch.

Yes, you're correct. Kind of... I noticed that FNeg wasn't folding vectors with some undef elements correctly while working on this change. I can separate that patch if you'd like.

This actually can't be separated out. We were mistakenly generating an FSub, instead of an FNeg in the IRBuilder, so the DAG code won't trigger without the IRBuilder change. I won't be able to write a test for it without that change (at least that I know about right now) .

Oh, I suppose I could let the DAG change sit until after the IRBuilder change lands also.

[cameron.mcinally]

Remove DAG changes as @spatel suggested.

[cameron.mcinally]

In D61419#1488170, @cameron.mcinally wrote:

This actually can't be separated out. We were mistakenly generating an FSub, instead of an FNeg in the IRBuilder, so the DAG code won't trigger without the IRBuilder change. I won't be able to write a test for it without that change (at least that I know about right now) .

I would expect -instsimplify to work.

@arsenm, the InstructionSimplify pass has a whole different sets of folds from the ConstantExpr folds. Piling on top of that, we'll have to add support for UnaryInstructions to the other passes that make use of InstructionSimplify. That seems like a big change. @kpn is also working on D61447, which I just found out about. I propose adding the ConstantExpr folding changes as-is, with the expectation that InstructionSimplify folding (and probably other places that I don't know about) will have to be done too. Does anyone feel strongly against this?

I'll retract this statement. The InstructionSimplify work wasn't as bad as it first appeared. There are users of InstructionSimplify that will need to be updated to take advance of the UnaryOps, but those don't have to be done right away.

Patch incoming...

[cameron.mcinally]

Add support for FNeg constant folding in InstructionSimplify.

[cameron.mcinally]

Clean up PatternMatch.h logic and capture all of test/Analysis/ConstantFolding/fneg.ll

[arsenm]

llvm/test/CodeGen/X86/vec_fneg.ll

144

These should still not be codegen tests. Is this the constant folding that the asm parser does?

[cameron.mcinally]

llvm/test/CodeGen/X86/vec_fneg.ll

144

The folding I'd like to test is done whenever a ConstantExpr::get(...) or ConstantExpr::getFNeg(...) is called. So it's really all over the place. A quick grep shows it's mainly called in IR, but also in Analysis, Transforms, CodeGen, and the AsmParser.

unittests/IR/ConstantsTest.cpp seems like a candidate, but this doesn't really fit a unit test.

There is some prior art in CodeGen for constant folding tests, but I'm not sure what constant folder they're testing. E.g. @div_select_constant_fold(...):llvm/test/CodeGen/X86/fdiv-combine.ll.

[arsenm]

llvm/test/CodeGen/X86/vec_fneg.ll

144

If any codegen tests are testing the IR constant folding, that's just broken. I would try to just use the asm parser for this

[cameron.mcinally]

llvm/test/CodeGen/X86/vec_fneg.ll

144

I actually just shot a question out to llvm-dev about this. I'll wait to see if anyone knows for sure before making that change. Thanks, Matt.

[spatel]

There are still independent changes here from what I can tell.
Can we start with this: extract the pattern match diff and add a test for it to unittests/IR/PatternMatch.cpp ?

[cameron.mcinally]

llvm/test/CodeGen/X86/fp-fold.ll

226–242

Bah! Apologies, Matt. You were right all along. SimplifyFNegInst(...) in InstructionSimplify.cpp calls ConstantFoldUnaryOpOperand(...), which eventually ends up in ConstantExpr::get(...). So testing with -instsimplify is enough to exercise these new folds.

I'll remove these tests since they're already covered in Analysis/ConstantFolding/fneg-instcombine.ll.

[cameron.mcinally]

Remove misplaced test/CodeGen tests.

Also add support for UnOps to ConstantFoldInstOperandsImpl(...):lib/Analysis/ConstantFolding.cpp.

[cameron.mcinally]

In D61419#1489734, @spatel wrote:

There are still independent changes here from what I can tell.
Can we start with this: extract the pattern match diff and add a test for it to unittests/IR/PatternMatch.cpp ?

That's fair. This Diff grew too quickly in too many directions. Maybe we should start fresh in smaller chunks.

PatternMatcher patch coming soon...

[cameron.mcinally]

This comment was removed by cameron.mcinally.

[cameron.mcinally]

This patch was broken up into D61520, D61544, and D61573.

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

SDValue SelectionDAG::getNode(unsigned Opcode, const SDLoc &DL, EVT VT,
   case ISD::FNEG:
     // -(X-Y) -> (Y-X) is unsafe because when X==Y, -0.0 != +0.0
     if ((getTarget().Options.UnsafeFPMath || Flags.hasNoSignedZeros()) &&
         OpOpcode == ISD::FSUB)
       return getNode(ISD::FSUB, DL, VT, Operand.getOperand(1),
                      Operand.getOperand(0), Flags);
     if (OpOpcode == ISD::FNEG)  // --X -> X
       return Operand.getOperand(0);
+    if (OpOpcode == ISD::UNDEF)
+      return getUNDEF(VT);
     break;
   case ISD::FABS:
     if (OpOpcode == ISD::FNEG)  // abs(-X) -> abs(X)
       return getNode(ISD::FABS, DL, VT, Operand.getOperand(0));
     break;
   }
 
   SDNode *N;

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();
+    APFloat C1V = CV;  // copy for modification
+    switch (Opcode) {
+    default:
+      break;
+    case Instruction::FNeg:
+      (void)C1V.changeSign();
+      return ConstantFP::get(C->getContext(), C1V);
+    }
+  } 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;          // Fold a few common cases.
 
   if (OnlyIfReducedTy == C->getType())
     return nullptr;
 
   Constant *ArgVec[] = { C };
   ConstantExprKeyType Key(Opcode, ArgVec, 0, Flags);
 
   LLVMContextImpl *pImpl = C->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()));
 }
 
case Instruction::GetElementPtr: {
     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/CodeGen/X86/fp-fold.ll

 ; ANY-LABEL: fmul_x_const_const:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    mulss {{.*}}(%rip), %xmm0
 ; ANY-NEXT:    retq
   %mul = fmul reassoc float %x, 9.0
   %r = fmul reassoc float %mul, 4.0
   ret float %r
 }
+
+define float @fneg_undef() {
+; ANY-LABEL: fneg_undef:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %r = fneg float undef
+  ret float %r
+}
+
+define float @fneg_zero() {
+; ANY-LABEL: fneg_zero:
+; ANY:       # %bb.0:
+; ANY-NEXT:    movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
+; ANY-NEXT:    retq
+  %r = fneg float 0.0
+  ret float %r
+}

llvm/test/CodeGen/X86/vec_fneg.ll

 ; X64-SSE-LABEL: fneg:
 ; X64-SSE:       # %bb.0:
 ; X64-SSE-NEXT:    xorps {{.*}}(%rip), %xmm0
 ; X64-SSE-NEXT:    retq
   %tmp = fneg <4 x float> %Q
   ret <4 x float> %tmp
 }
 
+; fneg constant folding
 
+define <4 x float> @fneg_constant_elts_v4f32() {
+; X32-SSE-LABEL: fneg_constant_elts_v4f32:
+; X32-SSE:       # %bb.0:
+; X32-SSE-NEXT:    movaps {{.*#+}} xmm0 = [0.0E+0,-0.0E+0,1.0E+0,-1.0E+0]
+; X32-SSE-NEXT:    retl
+;
+; X64-SSE-LABEL: fneg_constant_elts_v4f32:
+; X64-SSE:       # %bb.0:
+; X64-SSE-NEXT:    movaps {{.*#+}} xmm0 = [0.0E+0,-0.0E+0,1.0E+0,-1.0E+0]
+; X64-SSE-NEXT:    retq
+  %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() {
+; X32-SSE-LABEL: fneg_constant_undef_elts_v4f32:
+; X32-SSE:       # %bb.0:
+; X32-SSE-NEXT:    movaps {{.*#+}} xmm0 = <0.0E+0,u,u,-1.0E+0>
+; X32-SSE-NEXT:    retl
+;
+; X64-SSE-LABEL: fneg_constant_undef_elts_v4f32:
+; X64-SSE:       # %bb.0:
+; X64-SSE-NEXT:    movaps {{.*#+}} xmm0 = <0.0E+0,u,u,-1.0E+0>
+; X64-SSE-NEXT:    retq
+  %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() {
+; X32-SSE-LABEL: fneg_constant_all_undef_elts_v4f32:
+; X32-SSE:       # %bb.0:
+; X32-SSE-NEXT:    retl
+;
+; X64-SSE-LABEL: fneg_constant_all_undef_elts_v4f32:
+; X64-SSE:       # %bb.0:
+; X64-SSE-NEXT:    retq
+  %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
 }
 

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);