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

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

void SelectionDAGBuilder::visitBinary(const User &I, unsigned Opcode) {
   }
   if (auto *ExactOp = dyn_cast<PossiblyExactOperator>(&I)) {
     Flags.setExact(ExactOp->isExact());
   }
   if (isVectorReductionOp(&I)) {
     Flags.setVectorReduction(true);
     LLVM_DEBUG(dbgs() << "Detected a reduction operation:" << I << "\n");
   }
+  // need Flags for Selection DAG decisions here
+  if (auto *FPMO = dyn_cast<FPMathOperator>(&I)) {
+    Flags.copyFMF(*FPMO);
+  }
 
   SDValue Op1 = getValue(I.getOperand(0));
   SDValue Op2 = getValue(I.getOperand(1));
   SDValue BinNodeValue = DAG.getNode(Opcode, getCurSDLoc(), Op1.getValueType(),
                                      Op1, Op2, Flags);
   setValue(&I, BinNodeValue);
 }
 

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
+; ANY-LABEL: fadd_undef_op0:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %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
+; ANY-LABEL: fadd_undef_op1:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %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
+; ANY-LABEL: fsub_undef_op1:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %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
+; ANY-LABEL: fmul_undef_op0:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %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
+; ANY-LABEL: fmul_undef_op1:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %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
+; ANY-LABEL: fdiv_undef_op1:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %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
+; ANY-LABEL: frem_undef_op1:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %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:
 ; STRICT-NEXT:    addss %xmm0, %xmm0
 ; STRICT-NEXT:    retq
 ;
 ; UNSAFE-LABEL: fadd_undef_op0_nnan:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
   %r = fadd nnan float undef, %x
   ret float %r
 }
 
 define float @fadd_undef_op1_fast(float %x) {
-; STRICT-LABEL: fadd_undef_op1_fast:
-; STRICT:       # %bb.0:
-; STRICT-NEXT:    addss %xmm0, %xmm0
-; STRICT-NEXT:    retq
-;
-; UNSAFE-LABEL: fadd_undef_op1_fast:
-; UNSAFE:       # %bb.0:
-; UNSAFE-NEXT:    retq
+; ANY-LABEL: fadd_undef_op1_fast:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
   %r = fadd fast float %x, undef
   ret float %r
 }
 
 define float @fsub_undef_op0_fast(float %x) {
 ; ANY-LABEL: fsub_undef_op0_fast:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq

 ; UNSAFE-LABEL: fmul_undef_op0_nnan:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
   %r = fmul nnan float undef, %x
   ret float %r
 }
 
 define float @fmul_undef_op1_fast(float %x) {
-; STRICT-LABEL: fmul_undef_op1_fast:
-; STRICT:       # %bb.0:
-; STRICT-NEXT:    mulss %xmm0, %xmm0
-; STRICT-NEXT:    retq
-;
-; UNSAFE-LABEL: fmul_undef_op1_fast:
-; UNSAFE:       # %bb.0:
-; UNSAFE-NEXT:    retq
+; ANY-LABEL: fmul_undef_op1_fast:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
   %r = fmul fast float %x, undef
   ret float %r
 }
 
 define float @fdiv_undef_op0_fast(float %x) {
 ; ANY-LABEL: fdiv_undef_op0_fast:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq

 ; ANY-LABEL: frem_undef_op0_nnan:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq
   %r = frem nnan float undef, %x
   ret float %r
 }
 
 define float @frem_undef_op1_fast(float %x) {
-; STRICT-LABEL: frem_undef_op1_fast:
-; STRICT:       # %bb.0:
-; STRICT-NEXT:    jmp fmodf # TAILCALL
-;
-; UNSAFE-LABEL: frem_undef_op1_fast:
-; UNSAFE:       # %bb.0:
-; UNSAFE-NEXT:    retq
+; ANY-LABEL: frem_undef_op1_fast:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
   %r = frem fast float %x, undef
   ret float %r
 }
 
 ; Constant folding - undef undef.
 
 define double @fadd_undef_undef(double %x) {
-; STRICT-LABEL: fadd_undef_undef:
-; STRICT:       # %bb.0:
-; STRICT-NEXT:    addsd %xmm0, %xmm0
-; STRICT-NEXT:    retq
-;
-; UNSAFE-LABEL: fadd_undef_undef:
-; UNSAFE:       # %bb.0:
-; UNSAFE-NEXT:    retq
-  %r = fadd double undef, undef
+; ANY-LABEL: fadd_undef_undef:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %r = fadd fast double undef, undef
   ret double %r
 }
 
 define double @fsub_undef_undef(double %x) {
 ; ANY-LABEL: fsub_undef_undef:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq
-  %r = fsub double undef, undef
+  %r = fsub fast double undef, undef
   ret double %r
 }
 
 define double @fmul_undef_undef(double %x) {
-; STRICT-LABEL: fmul_undef_undef:
-; STRICT:       # %bb.0:
-; STRICT-NEXT:    mulsd %xmm0, %xmm0
-; STRICT-NEXT:    retq
-;
-; UNSAFE-LABEL: fmul_undef_undef:
-; UNSAFE:       # %bb.0:
-; UNSAFE-NEXT:    retq
-  %r = fmul double undef, undef
+; ANY-LABEL: fmul_undef_undef:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %r = fmul fast double undef, undef
   ret double %r
 }
 
 define double @fdiv_undef_undef(double %x) {
 ; ANY-LABEL: fdiv_undef_undef:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq
-  %r = fdiv double undef, undef
+  %r = fdiv fast double undef, undef
   ret double %r
 }
 
 define double @frem_undef_undef(double %x) {
 ; ANY-LABEL: frem_undef_undef:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq
-  %r = frem double undef, undef
+  %r = frem fast double undef, undef
   ret double %r
 }
 
 ; Constant folding.
 
 define float @fadd_undef_op0_nnan_constant(float %x) {
 ; STRICT-LABEL: fadd_undef_op0_nnan_constant:
 ; STRICT:       # %bb.0:
 ; STRICT-NEXT:    addss {{.*}}(%rip), %xmm0
 ; STRICT-NEXT:    retq
 ;
 ; UNSAFE-LABEL: fadd_undef_op0_nnan_constant:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
   %r = fadd nnan float undef, 1.0
   ret float %r
 }
 
 define float @fadd_undef_op1_constant(float %x) {
-; STRICT-LABEL: fadd_undef_op1_constant:
-; STRICT:       # %bb.0:
-; STRICT-NEXT:    addss {{.*}}(%rip), %xmm0
-; STRICT-NEXT:    retq
-;
-; UNSAFE-LABEL: fadd_undef_op1_constant:
-; UNSAFE:       # %bb.0:
-; UNSAFE-NEXT:    retq
-  %r = fadd float 2.0, undef
+; ANY-LABEL: fadd_undef_op1_constant:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %r = fadd fast float 2.0, undef
   ret float %r
 }
 
 define float @fsub_undef_op0_fast_constant(float %x) {
 ; ANY-LABEL: fsub_undef_op0_fast_constant:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq
   %r = fsub fast float undef, 3.0
   ret float %r
 }
 
 define float @fsub_undef_op1_constant(float %x) {
-; STRICT-LABEL: fsub_undef_op1_constant:
-; STRICT:       # %bb.0:
-; STRICT-NEXT:    movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
-; STRICT-NEXT:    subss %xmm0, %xmm0
-; STRICT-NEXT:    retq
-;
-; UNSAFE-LABEL: fsub_undef_op1_constant:
-; UNSAFE:       # %bb.0:
-; UNSAFE-NEXT:    retq
-  %r = fsub float 4.0, undef
+; ANY-LABEL: fsub_undef_op1_constant:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %r = fsub fast float 4.0, undef
   ret float %r
 }
 
 define float @fmul_undef_op0_nnan_constant(float %x) {
 ; STRICT-LABEL: fmul_undef_op0_nnan_constant:
 ; STRICT:       # %bb.0:
 ; STRICT-NEXT:    mulss {{.*}}(%rip), %xmm0
 ; STRICT-NEXT:    retq
 ;
 ; UNSAFE-LABEL: fmul_undef_op0_nnan_constant:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
   %r = fmul nnan float undef, 5.0
   ret float %r
 }
 
 define float @fmul_undef_op1_constant(float %x) {
-; STRICT-LABEL: fmul_undef_op1_constant:
-; STRICT:       # %bb.0:
-; STRICT-NEXT:    mulss {{.*}}(%rip), %xmm0
-; STRICT-NEXT:    retq
-;
-; UNSAFE-LABEL: fmul_undef_op1_constant:
-; UNSAFE:       # %bb.0:
-; UNSAFE-NEXT:    retq
-  %r = fmul float 6.0, undef
+; ANY-LABEL: fmul_undef_op1_constant:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %r = fmul fast float 6.0, undef
   ret float %r
 }
 
 define float @fdiv_undef_op0_fast_constant(float %x) {
 ; ANY-LABEL: fdiv_undef_op0_fast_constant:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq
   %r = fdiv fast float undef, 7.0
   ret float %r
 }
 
 define float @fdiv_undef_op1_constant(float %x) {
-; STRICT-LABEL: fdiv_undef_op1_constant:
-; STRICT:       # %bb.0:
-; STRICT-NEXT:    movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
-; STRICT-NEXT:    divss %xmm0, %xmm0
-; STRICT-NEXT:    retq
-;
-; UNSAFE-LABEL: fdiv_undef_op1_constant:
-; UNSAFE:       # %bb.0:
-; UNSAFE-NEXT:    retq
-  %r = fdiv float 8.0, undef
+; ANY-LABEL: fdiv_undef_op1_constant:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %r = fdiv fast float 8.0, undef
   ret float %r
 }
 
 define float @frem_undef_op0_nnan_constant(float %x) {
 ; ANY-LABEL: frem_undef_op0_nnan_constant:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq
   %r = frem nnan float undef, 9.0
   ret float %r
 }
 
 define float @frem_undef_op1_constant(float %x) {
-; STRICT-LABEL: frem_undef_op1_constant:
-; STRICT:       # %bb.0:
-; STRICT-NEXT:    movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
-; STRICT-NEXT:    jmp fmodf # TAILCALL
-;
-; UNSAFE-LABEL: frem_undef_op1_constant:
-; UNSAFE:       # %bb.0:
-; UNSAFE-NEXT:    retq
-  %r = frem float 10.0, undef
+; ANY-LABEL: frem_undef_op1_constant:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %r = frem fast float 10.0, undef
   ret float %r
 }
 
 ; Constant folding - special constants: NaN.
 
 define double @fadd_undef_op0_constant_nan(double %x) {
-; STRICT-LABEL: fadd_undef_op0_constant_nan:
-; STRICT:       # %bb.0:
-; STRICT-NEXT:    addsd {{.*}}(%rip), %xmm0
-; STRICT-NEXT:    retq
-;
-; UNSAFE-LABEL: fadd_undef_op0_constant_nan:
-; UNSAFE:       # %bb.0:
-; UNSAFE-NEXT:    retq
-  %r = fadd double undef, 0x7FF8000000000000
+; ANY-LABEL: fadd_undef_op0_constant_nan:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %r = fadd fast 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
+; ANY-LABEL: fadd_undef_op1_fast_constant_nan:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
   %r = fadd fast double 0xFFF0000000000001, undef
   ret double %r
 }
 
 define double @fsub_undef_op0_constant_nan(double %x) {
 ; ANY-LABEL: fsub_undef_op0_constant_nan:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq

 ; UNSAFE-LABEL: fsub_undef_op1_nnan_constant_nan:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
   %r = fsub nnan double 0x7FF0000000000011, undef
   ret double %r
 }
 
 define double @fmul_undef_op0_constant_nan(double %x) {
-; STRICT-LABEL: fmul_undef_op0_constant_nan:
-; STRICT:       # %bb.0:
-; STRICT-NEXT:    mulsd {{.*}}(%rip), %xmm0
-; STRICT-NEXT:    retq
-;
-; UNSAFE-LABEL: fmul_undef_op0_constant_nan:
-; UNSAFE:       # %bb.0:
-; UNSAFE-NEXT:    retq
-  %r = fmul double undef, 0x7FF8000000000100
+; ANY-LABEL: fmul_undef_op0_constant_nan:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %r = fmul fast 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
+; ANY-LABEL: fmul_undef_op1_fast_constant_nan:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
   %r = fmul fast double 0xFFF0000000000101, undef
   ret double %r
 }
 
 define double @fdiv_undef_op0_constant_nan(double %x) {
 ; ANY-LABEL: fdiv_undef_op0_constant_nan:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq
; UNSAFE-NEXT:    retq
   %r = fdiv nnan double 0x7FF0000000000111, undef
   ret double %r
 }
 
 define double @frem_undef_op0_constant_nan(double %x) {
 ; ANY-LABEL: frem_undef_op0_constant_nan:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq
-  %r = frem double undef, 0x7FF8000000001000
+  %r = frem fast double undef, 0x7FF8000000001000
   ret double %r
 }
 
 define double @frem_undef_op1_fast_constant_nan(double %x) {
-; STRICT-LABEL: frem_undef_op1_fast_constant_nan:
-; STRICT:       # %bb.0:
-; STRICT-NEXT:    movsd {{.*#+}} xmm0 = mem[0],zero
-; STRICT-NEXT:    jmp fmod # TAILCALL
-;
-; UNSAFE-LABEL: frem_undef_op1_fast_constant_nan:
-; UNSAFE:       # %bb.0:
-; UNSAFE-NEXT:    retq
+; ANY-LABEL: frem_undef_op1_fast_constant_nan:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
   %r = frem fast double 0xFFF0000000001001, undef
   ret double %r
 }
 
 ; Constant folding - special constants: Inf.
 
 define double @fadd_undef_op0_constant_inf(double %x) {
-; STRICT-LABEL: fadd_undef_op0_constant_inf:
-; STRICT:       # %bb.0:
-; STRICT-NEXT:    addsd {{.*}}(%rip), %xmm0
-; STRICT-NEXT:    retq
-;
-; UNSAFE-LABEL: fadd_undef_op0_constant_inf:
-; UNSAFE:       # %bb.0:
-; UNSAFE-NEXT:    retq
-  %r = fadd double undef, 0x7FF0000000000000
+; ANY-LABEL: fadd_undef_op0_constant_inf:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %r = fadd fast 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
+; ANY-LABEL: fadd_undef_op1_fast_constant_inf:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
   %r = fadd fast double 0xFFF0000000000000, undef
   ret double %r
 }
 
 define double @fsub_undef_op0_constant_inf(double %x) {
 ; ANY-LABEL: fsub_undef_op0_constant_inf:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq
-  %r = fsub double undef, 0xFFF0000000000000
+  %r = fsub fast double undef, 0xFFF0000000000000
   ret double %r
 }
 
 define double @fsub_undef_op1_ninf_constant_inf(double %x) {
 ; STRICT-LABEL: fsub_undef_op1_ninf_constant_inf:
 ; STRICT:       # %bb.0:
 ; STRICT-NEXT:    movsd {{.*#+}} xmm0 = mem[0],zero
 ; STRICT-NEXT:    subsd %xmm0, %xmm0
 ; STRICT-NEXT:    retq
 ;
 ; UNSAFE-LABEL: fsub_undef_op1_ninf_constant_inf:
 ; UNSAFE:       # %bb.0:
 ; UNSAFE-NEXT:    retq
   %r = fsub ninf double 0x7FF0000000000000, undef
   ret double %r
 }
 
 define double @fmul_undef_op0_constant_inf(double %x) {
-; STRICT-LABEL: fmul_undef_op0_constant_inf:
-; STRICT:       # %bb.0:
-; STRICT-NEXT:    mulsd {{.*}}(%rip), %xmm0
-; STRICT-NEXT:    retq
-;
-; UNSAFE-LABEL: fmul_undef_op0_constant_inf:
-; UNSAFE:       # %bb.0:
-; UNSAFE-NEXT:    retq
-  %r = fmul double undef, 0x7FF0000000000000
+; ANY-LABEL: fmul_undef_op0_constant_inf:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
+  %r = fmul fast 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
+; ANY-LABEL: fmul_undef_op1_fast_constant_inf:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
   %r = fmul fast double 0xFFF0000000000000, undef
   ret double %r
 }
 
 define double @fdiv_undef_op0_constant_inf(double %x) {
 ; ANY-LABEL: fdiv_undef_op0_constant_inf:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq
; UNSAFE-NEXT:    retq
   %r = fdiv ninf double 0x7FF0000000000000, undef
   ret double %r
 }
 
 define double @frem_undef_op0_constant_inf(double %x) {
 ; ANY-LABEL: frem_undef_op0_constant_inf:
 ; ANY:       # %bb.0:
 ; ANY-NEXT:    retq
-  %r = frem double undef, 0x7FF0000000000000
+  %r = frem fast double undef, 0x7FF0000000000000
   ret double %r
 }
 
 define double @frem_undef_op1_fast_constant_inf(double %x) {
-; STRICT-LABEL: frem_undef_op1_fast_constant_inf:
-; STRICT:       # %bb.0:
-; STRICT-NEXT:    movsd {{.*#+}} xmm0 = mem[0],zero
-; STRICT-NEXT:    jmp fmod # TAILCALL
-;
-; UNSAFE-LABEL: frem_undef_op1_fast_constant_inf:
-; UNSAFE:       # %bb.0:
-; UNSAFE-NEXT:    retq
+; ANY-LABEL: frem_undef_op1_fast_constant_inf:
+; ANY:       # %bb.0:
+; ANY-NEXT:    retq
   %r = frem fast double 0xFFF0000000000000, undef
   ret double %r
 }