Extending undef support for float arithmetic to isFast IR flags

[mcberg2017]

Summary

The patch addresses a single transform of selection DAG optimization, namely a few special cases of undef optimization, extending the guard for isFast on the SDNodeFlags passed to getNode for fadd, fsub, fmul, fdiv and frem.

[mcberg2017]

This review is initially for discussion over the issues in undef that have yet to be resolved. I will change the patch as needed as we go.

[mcberg2017]

Updated test for addition of Flag information. I will remove SelectionDAGBuilder.cpp if D46968 gets checked in first or visa versa as the change is needed in both places for correct behavior.

[spatel]

Sorry if my earlier comment wasn't clear, but this is functionally wrong. These folds shouldn't depend on unsafe/fast at all...assuming we're going to use the same logic that we do in IR. I'm working on that patch. I think you can ignore this part of the FMF problem for now and work on independent parts of the puzzle?

[spatel]

In D46973#1102975, @spatel wrote:

Sorry if my earlier comment wasn't clear, but this is functionally wrong. These folds shouldn't depend on unsafe/fast at all...assuming we're going to use the same logic that we do in IR. I'm working on that patch.

For reference, here's that proposal:
D47026

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

if (N2.isUndef()) {
     case ISD::SRL:
     case ISD::SHL:
       return getUNDEF(VT);       // fold op(arg1, undef) -> undef
     case ISD::FADD:
     case ISD::FSUB:
     case ISD::FMUL:
     case ISD::FDIV:
     case ISD::FREM:
-      if (getTarget().Options.UnsafeFPMath)
+      if (getTarget().Options.UnsafeFPMath || Flags.isFast())
         return N2;
       break;
     case ISD::MUL:
     case ISD::AND:
       return getConstant(0, DL, VT);  // fold op(arg1, undef) -> 0
     case ISD::OR:
       return getAllOnesConstant(DL, VT);
     }

test/CodeGen/X86/fp-undef.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown                        | FileCheck %s --check-prefixes=ANY,STRICT
 ; RUN: llc < %s -mtriple=x86_64-unknown-unknown -enable-unsafe-fp-math | FileCheck %s --check-prefixes=ANY,UNSAFE
 
 ; This is duplicated from tests for InstSimplify. If you're
 ; adding something here, you should probably add it there too.
 
 define float @fadd_undef_op0(float %x) {
 ; STRICT-LABEL: fadd_undef_op0:
 ; STRICT:       # %bb.0:
 ; STRICT-NEXT:    addss %xmm0, %xmm0
 ; STRICT-NEXT:    retq
 ;
 ; UNSAFE-LABEL: fadd_undef_op0:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
-  %r = fadd float undef, %x
+  %r = fadd fast float undef, %x
   ret float %r
 }
 
 define float @fadd_undef_op1(float %x) {
 ; STRICT-LABEL: fadd_undef_op1:
 ; STRICT:       # %bb.0:
 ; STRICT-NEXT:    addss %xmm0, %xmm0
 ; STRICT-NEXT:    retq
 ;
 ; UNSAFE-LABEL: fadd_undef_op1:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
-  %r = fadd float %x, undef
+  %r = fadd fast float %x, undef
   ret float %r
 }
 
 define float @fsub_undef_op0(float %x) {
 ; ANY-LABEL: fsub_undef_op0:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq
-  %r = fsub float undef, %x
+  %r = fsub fast float undef, %x
   ret float %r
 }
 
 define float @fsub_undef_op1(float %x) {
 ; STRICT-LABEL: fsub_undef_op1:
 ; STRICT:       # %bb.0:
 ; STRICT-NEXT:    subss %xmm0, %xmm0
 ; STRICT-NEXT:    retq
 ;
 ; UNSAFE-LABEL: fsub_undef_op1:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
-  %r = fsub float %x, undef
+  %r = fsub fast float %x, undef
   ret float %r
 }
 
 define float @fmul_undef_op0(float %x) {
 ; STRICT-LABEL: fmul_undef_op0:
 ; STRICT:       # %bb.0:
 ; STRICT-NEXT:    mulss %xmm0, %xmm0
 ; STRICT-NEXT:    retq
 ;
 ; UNSAFE-LABEL: fmul_undef_op0:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
-  %r = fmul float undef, %x
+  %r = fmul fast float undef, %x
   ret float %r
 }
 
 define float @fmul_undef_op1(float %x) {
 ; STRICT-LABEL: fmul_undef_op1:
 ; STRICT:       # %bb.0:
 ; STRICT-NEXT:    mulss %xmm0, %xmm0
 ; STRICT-NEXT:    retq
 ;
 ; UNSAFE-LABEL: fmul_undef_op1:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
-  %r = fmul float %x, undef
+  %r = fmul fast float %x, undef
   ret float %r
 }
 
 define float @fdiv_undef_op0(float %x) {
 ; ANY-LABEL: fdiv_undef_op0:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq
-  %r = fdiv float undef, %x
+  %r = fdiv fast float undef, %x
   ret float %r
 }
 
 define float @fdiv_undef_op1(float %x) {
 ; STRICT-LABEL: fdiv_undef_op1:
 ; STRICT:       # %bb.0:
 ; STRICT-NEXT:    divss %xmm0, %xmm0
 ; STRICT-NEXT:    retq
 ;
 ; UNSAFE-LABEL: fdiv_undef_op1:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
-  %r = fdiv float %x, undef
+  %r = fdiv fast float %x, undef
   ret float %r
 }
 
 define float @frem_undef_op0(float %x) {
 ; ANY-LABEL: frem_undef_op0:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq
-  %r = frem float undef, %x
+  %r = frem fast float undef, %x
   ret float %r
 }
 
 define float @frem_undef_op1(float %x) {
 ; STRICT-LABEL: frem_undef_op1:
 ; STRICT:       # %bb.0:
 ; STRICT-NEXT:    jmp fmodf # TAILCALL
 ;
 ; UNSAFE-LABEL: frem_undef_op1:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
-  %r = frem float %x, undef
+  %r = frem fast float %x, undef
   ret float %r
 }
 
 ; Repeat all tests with fast-math-flags. Alternate 'nnan' and 'fast' for more coverage.
 
 define float @fadd_undef_op0_nnan(float %x) {
 ; STRICT-LABEL: fadd_undef_op0_nnan:
 ; STRICT:       # %bb.0:

 ; UNSAFE-NEXT:    retq
   %r = fadd double undef, 0x7FF8000000000000
   ret double %r
 }
 
 define double @fadd_undef_op1_fast_constant_nan(double %x) {
 ; STRICT-LABEL: fadd_undef_op1_fast_constant_nan:
 ; STRICT:       # %bb.0:
-; STRICT-NEXT:    addsd {{.*}}(%rip), %xmm0
 ; STRICT-NEXT:    retq
 ;
 ; UNSAFE-LABEL: fadd_undef_op1_fast_constant_nan:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
   %r = fadd fast double 0xFFF0000000000001, undef
   ret double %r
 }

 ; UNSAFE-NEXT:    retq
   %r = fmul double undef, 0x7FF8000000000100
   ret double %r
 }
 
 define double @fmul_undef_op1_fast_constant_nan(double %x) {
 ; STRICT-LABEL: fmul_undef_op1_fast_constant_nan:
 ; STRICT:       # %bb.0:
-; STRICT-NEXT:    mulsd {{.*}}(%rip), %xmm0
 ; STRICT-NEXT:    retq
 ;
 ; UNSAFE-LABEL: fmul_undef_op1_fast_constant_nan:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
   %r = fmul fast double 0xFFF0000000000101, undef
   ret double %r
 }

 ; UNSAFE-NEXT:    retq
   %r = fadd double undef, 0x7FF0000000000000
   ret double %r
 }
 
 define double @fadd_undef_op1_fast_constant_inf(double %x) {
 ; STRICT-LABEL: fadd_undef_op1_fast_constant_inf:
 ; STRICT:       # %bb.0:
-; STRICT-NEXT:    addsd {{.*}}(%rip), %xmm0
 ; STRICT-NEXT:    retq
 ;
 ; UNSAFE-LABEL: fadd_undef_op1_fast_constant_inf:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
   %r = fadd fast double 0xFFF0000000000000, undef
   ret double %r
 }

 ; UNSAFE-NEXT:    retq
   %r = fmul double undef, 0x7FF0000000000000
   ret double %r
 }
 
 define double @fmul_undef_op1_fast_constant_inf(double %x) {
 ; STRICT-LABEL: fmul_undef_op1_fast_constant_inf:
 ; STRICT:       # %bb.0:
-; STRICT-NEXT:    mulsd {{.*}}(%rip), %xmm0
 ; STRICT-NEXT:    retq
 ;
 ; UNSAFE-LABEL: fmul_undef_op1_fast_constant_inf:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
   %r = fmul fast double 0xFFF0000000000000, undef
   ret double %r
 }