[DAGCombine]: Fold X/Sqrt(X) to Sqrt(X).

[venkataramanan.kumar.llvm]

Summary

Under -ffast-math ( "nnan" and " reassoc") fold X/Sqrt(X) to Sqrt(X).

[venkataramanan.kumar.llvm]

Hi Sanjay,

As discussed in InstCombine patch, moving the transformation to generic "DagCombine". I have adjusted the test case for X86_64 target. I am not sure if I need to do add/change test cases for other targets.

[spatel]

In D86403#2232094, @venkataramanan.kumar.llvm wrote:

Hi Sanjay,

As discussed in InstCombine patch, moving the transformation to generic "DagCombine". I have adjusted the test case for X86_64 target. I am not sure if I need to do add/change test cases for other targets.

Yes, you need to update any tests that are no longer passing with this patch. That's why the buildbot flagged this patch with failures.

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

13360

I don't think 'nnan' is required. A NAN input results in NAN output either way.
NAN/sqrt(NAN) == NAN == sqrt(NAN)

I included 'arcp' in the tests that I added just to make sure that we were bypassing the sqrt estimate creation.

[spatel]

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

13361

Also, 'reassoc' generally means anything can happen, but if we want to be safer, we could require 'nsz' because this transform would change the result for a -0.0 input.

[venkataramanan.kumar.llvm]

Updated the patch as per the comments given by Sanjay. Adjusted the test cases.

[spatel]

See inline for a couple of minor points, otherwise LGTM.
Adding potential reviewers from the earlier patch review to see if anyone else has comments.

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

13362–13364

Formatting nit: the LLVM coding standards are flexible about when to use braces, but the choice here seems to not have any advantages. It would be better to either (1) omit braces entirely or (2) use braces on the first 'if' only.

llvm/test/CodeGen/AArch64/sqrt-fastmath.ll

494

In general, I prefer to make test changes in a preliminary commit, so there's no question about the functional difference created by the change in the compiler code. I can do that on your behalf if you do not have commit privileges.

[venkataramanan.kumar.llvm]

llvm/test/CodeGen/AArch64/sqrt-fastmath.ll

494

Sure please do on behalf me.

[venkataramanan.kumar.llvm]

Updated patch as per the comments from Sanjay.

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

if (Options.UnsafeFPMath || Flags.hasAllowReciprocal()) {
     }
 
     // Fold into a reciprocal estimate and multiply instead of a real divide.
     if (Options.NoInfsFPMath || Flags.hasNoInfs())
       if (SDValue RV = BuildDivEstimate(N0, N1, Flags))
         return RV;
   }
 
+  // Fold X/Sqrt(X) -> Sqrt(X)
+  if ((Options.NoSignedZerosFPMath || Flags.hasNoSignedZeros()) &&
+      (Options.UnsafeFPMath || Flags.hasAllowReassociation()))
+    if (N1.getOpcode() == ISD::FSQRT && N0 == N1.getOperand(0))
+      return N1;
+
   // (fdiv (fneg X), (fneg Y)) -> (fdiv X, Y)
   TargetLowering::NegatibleCost CostN0 =
       TargetLowering::NegatibleCost::Expensive;
   TargetLowering::NegatibleCost CostN1 =
       TargetLowering::NegatibleCost::Expensive;
   SDValue NegN0 =
       TLI.getNegatedExpression(N0, DAG, LegalOperations, ForCodeSize, CostN0);
   SDValue NegN1 =

llvm/test/CodeGen/AArch64/sqrt-fastmath.ll

; CHECK-NEXT:    ret
   %1 = tail call fast <4 x double> @llvm.sqrt.v4f64(<4 x double> %a)
   %2 = fdiv fast <4 x double> <double 1.000000e+00, double 1.000000e+00, double 1.000000e+00, double 1.000000e+00>, %1
   ret <4 x double> %2
 }
 
 define double @sqrt_fdiv_common_operand(double %x) nounwind {
 ; FAULT-LABEL: sqrt_fdiv_common_operand:
 ; FAULT:       // %bb.0:
-; FAULT-NEXT:    fsqrt d1, d0
-; FAULT-NEXT:    fdiv d0, d0, d1
+; FAULT-NEXT:    fsqrt d0, d0
 ; FAULT-NEXT:    ret
 ;
 ; CHECK-LABEL: sqrt_fdiv_common_operand:
 ; CHECK:       // %bb.0:
 ; CHECK-NEXT:    frsqrte d1, d0
 ; CHECK-NEXT:    fmul d2, d1, d1
 ; CHECK-NEXT:    frsqrts d2, d0, d2
 ; CHECK-NEXT:    fmul d1, d1, d2
 ; CHECK-NEXT:    fmul d2, d1, d1
 ; CHECK-NEXT:    frsqrts d2, d0, d2
 ; CHECK-NEXT:    fmul d1, d1, d2
 ; CHECK-NEXT:    fmul d2, d1, d1
 ; CHECK-NEXT:    frsqrts d2, d0, d2
 ; CHECK-NEXT:    fmul d1, d1, d2
 ; CHECK-NEXT:    fmul d0, d0, d1
 ; CHECK-NEXT:    ret
   %sqrt = call fast double @llvm.sqrt.f64(double %x)
   %r = fdiv fast double %x, %sqrt
   ret double %r
 }
 
 define <2 x double> @sqrt_fdiv_common_operand_vec(<2 x double> %x) nounwind {
 ; FAULT-LABEL: sqrt_fdiv_common_operand_vec:
 ; FAULT:       // %bb.0:
-; FAULT-NEXT:    fsqrt v1.2d, v0.2d
-; FAULT-NEXT:    fdiv v0.2d, v0.2d, v1.2d
+; FAULT-NEXT:    fsqrt v0.2d, v0.2d
 ; FAULT-NEXT:    ret
 ;
 ; CHECK-LABEL: sqrt_fdiv_common_operand_vec:
 ; CHECK:       // %bb.0:
 ; CHECK-NEXT:    frsqrte v1.2d, v0.2d
 ; CHECK-NEXT:    fmul v2.2d, v1.2d, v1.2d
 ; CHECK-NEXT:    frsqrts v2.2d, v0.2d, v2.2d
 ; CHECK-NEXT:    fmul v1.2d, v1.2d, v2.2d
 ; CHECK-NEXT:    fmul v2.2d, v1.2d, v1.2d
 ; CHECK-NEXT:    frsqrts v2.2d, v0.2d, v2.2d
 ; CHECK-NEXT:    fmul v1.2d, v1.2d, v2.2d
 ; CHECK-NEXT:    fmul v2.2d, v1.2d, v1.2d
 ; CHECK-NEXT:    frsqrts v2.2d, v0.2d, v2.2d
 ; CHECK-NEXT:    fmul v1.2d, v1.2d, v2.2d
 ; CHECK-NEXT:    fmul v0.2d, v0.2d, v1.2d
 ; CHECK-NEXT:    ret
   %sqrt = call <2 x double> @llvm.sqrt.v2f64(<2 x double> %x)
-  %r = fdiv nsz arcp reassoc <2 x double> %x, %sqrt
+  %r = fdiv arcp nsz reassoc <2 x double> %x, %sqrt
   ret <2 x double> %r
 }
 
 define double @sqrt_fdiv_common_operand_extra_use(double %x, double* %p) nounwind {
 ; FAULT-LABEL: sqrt_fdiv_common_operand_extra_use:
 ; FAULT:       // %bb.0:
-; FAULT-NEXT:    fsqrt d1, d0
-; FAULT-NEXT:    fdiv d0, d0, d1
-; FAULT-NEXT:    str d1, [x0]
+; FAULT-NEXT:    fsqrt d0, d0
+; FAULT-NEXT:    str d0, [x0]
 ; FAULT-NEXT:    ret
 ;
 ; CHECK-LABEL: sqrt_fdiv_common_operand_extra_use:
 ; CHECK:       // %bb.0:
 ; CHECK-NEXT:    frsqrte d1, d0
 ; CHECK-NEXT:    fmul d2, d1, d1
 ; CHECK-NEXT:    frsqrts d2, d0, d2
 ; CHECK-NEXT:    fmul d1, d1, d2

llvm/test/CodeGen/X86/sqrt-fastmath.ll

; AVX512-NEXT:    retq
   %m = fmul reassoc <4 x float> %y, %s
   %d = fdiv reassoc arcp <4 x float> %x, %m
   ret <4 x float> %d
 }
 
 define double @sqrt_fdiv_common_operand(double %x) nounwind {
 ; SSE-LABEL: sqrt_fdiv_common_operand:
 ; SSE:       # %bb.0:
-; SSE-NEXT:    sqrtsd %xmm0, %xmm1
-; SSE-NEXT:    divsd %xmm1, %xmm0
+; SSE-NEXT:    sqrtsd %xmm0, %xmm0
 ; SSE-NEXT:    retq
 ;
 ; AVX-LABEL: sqrt_fdiv_common_operand:
 ; AVX:       # %bb.0:
-; AVX-NEXT:    vsqrtsd %xmm0, %xmm0, %xmm1
-; AVX-NEXT:    vdivsd %xmm1, %xmm0, %xmm0
+; AVX-NEXT:    vsqrtsd %xmm0, %xmm0, %xmm0
 ; AVX-NEXT:    retq
   %sqrt = call fast double @llvm.sqrt.f64(double %x)
   %r = fdiv fast double %x, %sqrt
   ret double %r
 }
 
 define <2 x double> @sqrt_fdiv_common_operand_vec(<2 x double> %x) nounwind {
 ; SSE-LABEL: sqrt_fdiv_common_operand_vec:
 ; SSE:       # %bb.0:
-; SSE-NEXT:    sqrtpd %xmm0, %xmm1
-; SSE-NEXT:    divpd %xmm1, %xmm0
+; SSE-NEXT:    sqrtpd %xmm0, %xmm0
 ; SSE-NEXT:    retq
 ;
 ; AVX-LABEL: sqrt_fdiv_common_operand_vec:
 ; AVX:       # %bb.0:
-; AVX-NEXT:    vsqrtpd %xmm0, %xmm1
-; AVX-NEXT:    vdivpd %xmm1, %xmm0, %xmm0
+; AVX-NEXT:    vsqrtpd %xmm0, %xmm0
 ; AVX-NEXT:    retq
   %sqrt = call <2 x double> @llvm.sqrt.v2f64(<2 x double> %x)
-  %r = fdiv nsz arcp reassoc <2 x double> %x, %sqrt
+  %r = fdiv arcp nsz reassoc <2 x double> %x, %sqrt
   ret <2 x double> %r
 }
 
 define double @sqrt_fdiv_common_operand_extra_use(double %x, double* %p) nounwind {
 ; SSE-LABEL: sqrt_fdiv_common_operand_extra_use:
 ; SSE:       # %bb.0:
-; SSE-NEXT:    sqrtsd %xmm0, %xmm1
-; SSE-NEXT:    movsd %xmm1, (%rdi)
-; SSE-NEXT:    divsd %xmm1, %xmm0
+; SSE-NEXT:    sqrtsd %xmm0, %xmm0
+; SSE-NEXT:    movsd %xmm0, (%rdi)
 ; SSE-NEXT:    retq
 ;
 ; AVX-LABEL: sqrt_fdiv_common_operand_extra_use:
 ; AVX:       # %bb.0:
-; AVX-NEXT:    vsqrtsd %xmm0, %xmm0, %xmm1
-; AVX-NEXT:    vmovsd %xmm1, (%rdi)
-; AVX-NEXT:    vdivsd %xmm1, %xmm0, %xmm0
+; AVX-NEXT:    vsqrtsd %xmm0, %xmm0, %xmm0
+; AVX-NEXT:    vmovsd %xmm0, (%rdi)
 ; AVX-NEXT:    retq
   %sqrt = call fast double @llvm.sqrt.f64(double %x)
   store double %sqrt, double* %p
   %r = fdiv fast double %x, %sqrt
   ret double %r
 }
 
 attributes #0 = { "unsafe-fp-math"="true" "reciprocal-estimates"="!sqrtf,!vec-sqrtf,!divf,!vec-divf" }
 attributes #1 = { "unsafe-fp-math"="true" "reciprocal-estimates"="sqrt,vec-sqrt" }
 attributes #2 = { nounwind readnone }
 attributes #3 = { "unsafe-fp-math"="true" "reciprocal-estimates"="sqrt,vec-sqrt" "denormal-fp-math"="ieee" }
 attributes #4 = { "unsafe-fp-math"="true" "reciprocal-estimates"="sqrt,vec-sqrt" "denormal-fp-math"="ieee,preserve-sign" }