RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2024-11-25 12:49:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Convert floating point division by a constant into multiplication by the

Browse Source 
reciprocal if converting to the reciprocal is exact.  Do it even if inexact
if -ffast-math.  This substantially speeds up ac.f90 from the polyhedron
benchmarks.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@154265 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan Sands 2012-04-07 20:04:00 +00:00
parent 5cd79bc14c
commit 961d666be4
3 changed files with 51 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
lib/CodeGen/SelectionDAG/DAGCombiner.cpp
View File

@ -5725,6 +5725,19 @@ SDValue DAGCombiner::visitFDIV(SDNode *N) {
if (N0CFP && N1CFP && VT != MVT::ppcf128)
return DAG.getNode(ISD::FDIV, N->getDebugLoc(), VT, N0, N1);
// fold (fdiv X, c2) -> fmul X, 1/c2 if there is no precision loss or if
// losing precision is acceptable.
if (N1CFP && VT != MVT::ppcf128) {
// Compute the reciprocal 1.0 / c2.
APFloat N1APF = N1CFP->getValueAPF();
APFloat Recip(N1APF.getSemantics(), 1); // 1.0
APFloat::opStatus st = Recip.divide(N1APF, APFloat::rmNearestTiesToEven);
// Only do the transform if the reciprocal is not too horrible (eg not NaN).
if (st == APFloat::opOK || (st == APFloat::opInexact &&
DAG.getTarget().Options.UnsafeFPMath))
return DAG.getNode(ISD::FMUL, N->getDebugLoc(), VT, N0,
DAG.getConstantFP(Recip, VT));
}
// (fdiv (fneg X), (fneg Y)) -> (fdiv X, Y)
if (char LHSNeg = isNegatibleForFree(N0, LegalOperations, TLI,

12
test/CodeGen/ARM/vdiv_combine.ll
View File

@ -8,7 +8,7 @@ declare void @foo_int32x4_t(<4 x i32>)
; Test signed conversion.
; CHECK: t1
; CHECK-NOT: vdiv
; CHECK-NOT: {{vdiv|vmul}}
define void @t1() nounwind {
entry:
%tmp = load i32* @iin, align 4, !tbaa !3
@ -24,7 +24,7 @@ declare void @foo_float32x2_t(<2 x float>)
; Test unsigned conversion.
; CHECK: t2
; CHECK-NOT: vdiv
; CHECK-NOT: {{vdiv|vmul}}
define void @t2() nounwind {
entry:
%tmp = load i32* @uin, align 4, !tbaa !3
@ -38,7 +38,7 @@ entry:
; Test which should not fold due to non-power of 2.
; CHECK: t3
; CHECK: vdiv
; CHECK: {{vdiv|vmul}}
define void @t3() nounwind {
entry:
%tmp = load i32* @iin, align 4, !tbaa !3
@ -52,7 +52,7 @@ entry:
; Test which should not fold due to power of 2 out of range.
; CHECK: t4
; CHECK: vdiv
; CHECK: {{vdiv|vmul}}
define void @t4() nounwind {
entry:
%tmp = load i32* @iin, align 4, !tbaa !3
@ -66,7 +66,7 @@ entry:
; Test case where const is max power of 2 (i.e., 2^32).
; CHECK: t5
; CHECK-NOT: vdiv
; CHECK-NOT: {{vdiv|vmul}}
define void @t5() nounwind {
entry:
%tmp = load i32* @iin, align 4, !tbaa !3
@ -80,7 +80,7 @@ entry:
; Test quadword.
; CHECK: t6
; CHECK-NOT: vdiv
; CHECK-NOT: {{vdiv|vmul}}
define void @t6() nounwind {
entry:
%tmp = load i32* @iin, align 4, !tbaa !3

32
test/CodeGen/X86/fdiv.ll Normal file
View File

@ -0,0 +1,32 @@
; RUN: llc < %s -march=x86-64 | FileCheck %s
; RUN: llc < %s -march=x86-64 -enable-unsafe-fp-math | FileCheck -check-prefix=UNSAFE %s
define double @exact(double %x) {
; Exact division by a constant always converted to multiplication.
; CHECK: @exact
; CHECK: mulsd
; UNSAFE: @exact
; UNSAFE: mulsd
%div = fdiv double %x, 2.0
ret double %div
}
define double @inexact(double %x) {
; Inexact division by a constant converted to multiplication if unsafe-math.
; CHECK: @inexact
; CHECK: divsd
; UNSAFE: @inexact
; UNSAFE: mulsd
%div = fdiv double %x, 0x41DFFFFFFFC00000
ret double %div
}
define double @funky(double %x) {
; No conversion to multiplication if too funky.
; CHECK: @funky
; CHECK: divsd
; UNSAFE: @funky
; UNSAFE: divsd
%div = fdiv double %x, 0.0
ret double %div
}