InstCombine: Fix assert when reassociating fsub with undef

[arsenm]

Summary

There is logic to track the expected number of instructions
produced. It thought in this case an instruction would
be necessary to negate the result, but here it folded
into a ConstantExpr fneg when the non-undef value operand
was cancelled out by the second fsub.

I'm not sure why we don't fold constant FP ops with undef currently,
but I think that would also avoid this problem.

[arsenm]

ping

[majnemer]

LGTM

[arsenm]

r301199

lib/Transforms/InstCombine/InstCombineAddSub.cpp

unsigned FAddCombine::calcInstrNumber(const AddendVect &Opnds) {
   // The number of addends in the form of "(-1)*x".
   unsigned NegOpndNum = 0;
 
   // Adjust the number of instructions needed to emit the N-ary add.
   for (const FAddend *Opnd : Opnds) {
     if (Opnd->isConstant())
       continue;
 
+    // The constant check above is really for a few special constant
+    // coefficients.
+    if (isa<UndefValue>(Opnd->getSymVal()))
+      continue;
+
     const FAddendCoef &CE = Opnd->getCoef();
     if (CE.isMinusOne() || CE.isMinusTwo())
       NegOpndNum++;
 
     // Let the addend be "c * x". If "c == +/-1", the value of the addend
     // is immediately available; otherwise, it needs exactly one instruction
     // to evaluate the value.
     if (!CE.isMinusOne() && !CE.isOne())

test/Transforms/InstCombine/fsub.ll

define double @test2(double %x, double %y) nounwind {
   %t1 = fadd double %x, %y
   %t2 = fsub double %x, %t1
 
 ; CHECK:      %t1 = fadd double %x, %y
 ; CHECK-NEXT: %t2 = fsub double %x, %t1
 
   ret double %t2
 }
+
+; CHECK-LABEL: @fsub_undef(
+; CHECK: %sub = fsub float %val, undef
+define float @fsub_undef(float %val) {
+bb:
+  %sub = fsub float %val, undef
+  ret float %sub
+}
+
+; XXX - Why doesn't this fold to undef?
+; CHECK-LABEL: @fsub_fast_undef(
+; CHCK: %sub = fsub fast float %val, undef
+define float @fsub_fast_undef(float %val) {
+bb:
+  %sub = fsub fast float %val, undef
+  ret float %sub
+}
+
+; CHECK-LABEL: @fneg_undef(
+; CHECK: ret float fsub (float -0.000000e+00, float undef)
+define float @fneg_undef(float %val) {
+bb:
+  %sub = fsub float -0.0, undef
+  ret float %sub
+}
+
+; CHECK-LABEL: @fneg_fast_undef(
+; CHECK: ret float fsub (float -0.000000e+00, float undef)
+define float @fneg_fast_undef(float %val) {
+bb:
+  %sub = fsub fast float -0.0, undef
+  ret float %sub
+}
+
+; This folds to a constant expression, which produced 0 instructions
+; contrary to the expected one for negation.
+; CHECK-LABEL: @inconsistent_numbers_fsub_undef(
+; CHECK: ret float fsub (float -0.000000e+00, float undef)
+define float @inconsistent_numbers_fsub_undef(float %val) {
+bb:
+  %sub0 = fsub fast float %val, undef
+  %sub1 = fsub fast float %sub0, %val
+  ret float %sub1
+}