[ConstantFold] fold fsub -0.0, undef to undef rather than NaN

[spatel]

Summary

A question about this behavior came up on llvm-dev:
http://lists.llvm.org/pipermail/llvm-dev/2020-February/139003.html
...and as part of backend improvements in D73978, but let's see if we can reach agreement on the transforms in IR first because we already have fairly thorough tests in place here.

If one constant operand to {fadd/fsub/fmul/fdiv/frem} is not {NaN/Inf/0.0/-0.0} and the other constant operand is undef, then we can choose 'undef' as some other value that changes all of the fields (sign, exponent, fraction) in the result FP value. Is that enough to say the result is undef?

[efriedma]

Is that enough to say the result is undef?

Theoretically, no. To take a simple integer example, suppose you have "max(undef, 1)". You can toggle any of the bits separately, but you can't produce 0, so converting it to "undef" is wrong. Alive2 does these sorts of proofs if you want mechanical verification (although I don't think it handles fp).

Practically, I doubt anyone would notice if "1e100+undef" produced an impossible result.

[lebedev.ri]

llvm/test/Analysis/ConstantFolding/vector-undef-elts.ll

46–52 ↗

(On Diff #244962)

----------------------------------------
define <3 x float> @fadd() {
%0:
  %c = fadd <3 x float> { undef, 42.000000, undef }, undef
  ret <3 x float> %c
}
=>
define <3 x float> @fadd() {
%0:
  ret <3 x float> undef
}
Transformation doesn't verify!
ERROR: Value mismatch

Example:

Source:
<3 x float> %c = < undef, #x42280000 (42)       [based on undef value], NaN     [based on undef value] >

Target:
Source value: < NaN     [based on undef value], #x42280000 (42), NaN >
Target value: < #x00000000 (+0.0), #x00000020 (0.000000000000?), NaN >

Summary:
  0 correct transformations
  1 incorrect transformations
  0 errors

[lebedev.ri]

llvm/test/Transforms/InstSimplify/fp-undef.ll

211–212 ↗

(On Diff #244962)

This is correct

----------------------------------------
define float @fadd_undef_op0_nnan_constant(float %x) {
%0:
  %r = fadd nnan float undef, 1.000000
  ret float %r
}
=>
define float @fadd_undef_op0_nnan_constant(float %x) {
%0:
  %r = fadd nnan float undef, 1.000000
  ret float undef
}
Transformation seems to be correct!

Summary:
  1 correct transformations
  0 incorrect transformations
  0 errors

218–224 ↗

(On Diff #244962)

This is not correct

----------------------------------------
define float @fadd_undef_op1_constant(float %x) {
%0:
  %r = fadd float 2.000000, undef
  ret float %r
}
=>
define float @fadd_undef_op1_constant(float %x) {
%0:
  %r = fadd float 2.000000, undef
  ret float undef
}
Transformation doesn't verify!
ERROR: Value mismatch

Example:
float %x = poison

Source:
float %r = NaN  [based on undef value]

Target:
float %r = NaN  [based on undef value]
Source value: NaN
Target value: #x84000400 (-0.000000000000?)

Summary:
  0 correct transformations
  1 incorrect transformations
  0 errors

234–240 ↗

(On Diff #244962)

Again, no

----------------------------------------
define float @fsub_undef_op1_constant(float %x) {
%0:
  %r = fsub float 4.000000, undef
  ret float %r
}
=>
define float @fsub_undef_op1_constant(float %x) {
%0:
  %r = fsub float 4.000000, undef
  ret float undef
}
Transformation doesn't verify!
ERROR: Value mismatch

Example:
float %x = poison

Source:
float %r = NaN  [based on undef value]

Target:
float %r = NaN  [based on undef value]
Source value: NaN
Target value: #x84000400 (-0.000000000000?)

Summary:
  0 correct transformations
  1 incorrect transformations
  0 errors

242–248 ↗

(On Diff #244962)

This is correct

250–256 ↗

(On Diff #244962)

No

----------------------------------------
define float @fmul_undef_op1_constant(float %x) {
%0:
  %r = fmul float 6.000000, undef
  ret float %r
}
=>
define float @fmul_undef_op1_constant(float %x) {
%0:
  %r = fmul float 6.000000, undef
  ret float undef
}
Transformation doesn't verify!
ERROR: Value mismatch

Example:
float %x = poison

Source:
float %r = NaN  [based on undef value]

Target:
float %r = NaN  [based on undef value]
Source value: NaN
Target value: #x00001000 (0.000000000000?)

Summary:
  0 correct transformations
  1 incorrect transformations
  0 errors

[spatel]

llvm/test/Transforms/InstSimplify/fp-undef.ll

218–224 ↗

(On Diff #244962)

Apologies for not having recent Alive installed anywhere at the moment to test this myself, but how should we interpret this output?

Is it saying that there is no value that we can assign to the undef operand that will produce the exact 0x84000400 output value?

[nlopes]

llvm/test/Transforms/InstSimplify/fp-undef.ll

218–224 ↗

(On Diff #244962)

Exactly!
"2.0 + x" can never be -1.5048164E-36 (0x84000400) for any x.

[spatel]

In D74713#1879563, @efriedma wrote:

Is that enough to say the result is undef?

Theoretically, no. To take a simple integer example, suppose you have "max(undef, 1)". You can toggle any of the bits separately, but you can't produce 0, so converting it to "undef" is wrong. Alive2 does these sorts of proofs if you want mechanical verification (although I don't think it handles fp).

Practically, I doubt anyone would notice if "1e100+undef" produced an impossible result.

That's what I was expecting: each FP opcode has exact bit patterns that can never be created given one known constant operand. However, we do not have the FP analysis to determine those patterns in LLVM currently, and even if we did, there's no practical way to use that knowledge for optimization.

Having these fold to undef would make things like D73978 and vector demanded elements easier, but if the consensus is to keep things theoretically pure, we'll have to work around the NaN folding.

[spatel]

Patch updated:
Only handle the fneg-like form of fsub.

[efriedma]

LGTM

[lebedev.ri]

This is fine in general for half/float/double for fsub nnan float undef, %x/fsub nnan float %x, undef.

llvm/lib/IR/ConstantFold.cpp

case Instruction::Shl:
       // X << undef -> undef
       if (isa<UndefValue>(C2))
         return C2;
       // undef << 0 -> undef
       if (match(C2, m_Zero()))
         return C1;
       // undef << X -> 0
       return Constant::getNullValue(C1->getType());
-    case Instruction::FAdd:
     case Instruction::FSub:
+      // -0.0 - undef --> undef (consistent with "fneg undef")
+      if (match(C1, m_NegZeroFP()) && isa<UndefValue>(C2))
+        return C2;
+      LLVM_FALLTHROUGH;
+    case Instruction::FAdd:
     case Instruction::FMul:
     case Instruction::FDiv:
     case Instruction::FRem:
       // [any flop] undef, undef -> undef
       if (isa<UndefValue>(C1) && isa<UndefValue>(C2))
         return C1;
       // [any flop] C, undef -> NaN
       // [any flop] undef, C -> NaN

llvm/test/Analysis/ConstantFolding/fp-undef.ll

 ; CHECK-NEXT:    ret double 0x7FF8000000000000
 ;
   %r = fsub double undef, 0x8000000000000000
   ret double %r
 }
 
 define double @fsub_undef_op1_constant_neg0(double %x) {
 ; CHECK-LABEL: @fsub_undef_op1_constant_neg0(
-; CHECK-NEXT:    ret double 0x7FF8000000000000
+; CHECK-NEXT:    ret double undef
 ;
   %r = fsub double 0x8000000000000000, undef
   ret double %r
 }
 
 define double @fmul_undef_op0_constant_neg0(double %x) {
 ; CHECK-LABEL: @fmul_undef_op0_constant_neg0(
 ; CHECK-NEXT:    ret double 0x7FF8000000000000