llvm-mirror/test/CodeGen/X86/fdiv.ll

; RUN: llc < %s -march=x86-64 -enable-unsafe-fp-math | FileCheck %s

define double @exact(double %x) {
; Exact division by a constant converted to multiplication.
; CHECK-LABEL: exact:
; CHECK:       ## BB#0:
; CHECK-NEXT:    mulsd {{.*}}(%rip), %xmm0
; CHECK-NEXT:    retq
  %div = fdiv double %x, 2.0
  ret double %div
}

define double @inexact(double %x) {
; Inexact division by a constant converted to multiplication.
; CHECK-LABEL: inexact:
; CHECK:       ## BB#0:
; CHECK-NEXT:    mulsd {{.*}}(%rip), %xmm0
; CHECK-NEXT:    retq
  %div = fdiv double %x, 0x41DFFFFFFFC00000
  ret double %div
}

define double @funky(double %x) {
; No conversion to multiplication if too funky.
; CHECK-LABEL: funky:
; CHECK:       ## BB#0:
; CHECK-NEXT:    xorpd %xmm1, %xmm1
; CHECK-NEXT:    divsd %xmm1, %xmm0
; CHECK-NEXT:    retq
  %div = fdiv double %x, 0.0
  ret double %div
}

define double @denormal1(double %x) {
; Don't generate multiplication by a denormal.
; CHECK-LABEL: denormal1:
; CHECK:       ## BB#0:
; CHECK-NEXT:    divsd {{.*}}(%rip), %xmm0
; CHECK-NEXT:    retq
  %div = fdiv double %x, 0x7FD0000000000001
  ret double %div
}

define double @denormal2(double %x) {
; Don't generate multiplication by a denormal.
; CHECK-LABEL: denormal2:
; CHECK:       ## BB#0:
; CHECK-NEXT:    divsd {{.*}}(%rip), %xmm0
; CHECK-NEXT:    retq
  %div = fdiv double %x, 0x7FEFFFFFFFFFFFFF
  ret double %div
}
Only have codegen turn fdiv by a constant into fmul by the reciprocal when -ffast-math, i.e. don't just always do it if the reciprocal can be formed exactly. There is already an IR level transform that does that, and it does it more carefully. llvm-svn: 154296 2012-04-08 20:08:12 +02:00			`; RUN: llc < %s -march=x86-64 -enable-unsafe-fp-math \| FileCheck %s`
Convert floating point division by a constant into multiplication by the 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. llvm-svn: 154265 2012-04-07 22:04:00 +02:00
			`define double @exact(double %x) {`
Only have codegen turn fdiv by a constant into fmul by the reciprocal when -ffast-math, i.e. don't just always do it if the reciprocal can be formed exactly. There is already an IR level transform that does that, and it does it more carefully. llvm-svn: 154296 2012-04-08 20:08:12 +02:00			`; Exact division by a constant converted to multiplication.`
tighten checks using update_llc_test_checks.py llvm-svn: 244360 2015-08-07 23:38:53 +02:00			`; CHECK-LABEL: exact:`
			`; CHECK: ## BB#0:`
			`; CHECK-NEXT: mulsd {{.*}}(%rip), %xmm0`
			`; CHECK-NEXT: retq`
Convert floating point division by a constant into multiplication by the 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. llvm-svn: 154265 2012-04-07 22:04:00 +02:00			`%div = fdiv double %x, 2.0`
			`ret double %div`
			`}`

			`define double @inexact(double %x) {`
Only have codegen turn fdiv by a constant into fmul by the reciprocal when -ffast-math, i.e. don't just always do it if the reciprocal can be formed exactly. There is already an IR level transform that does that, and it does it more carefully. llvm-svn: 154296 2012-04-08 20:08:12 +02:00			`; Inexact division by a constant converted to multiplication.`
tighten checks using update_llc_test_checks.py llvm-svn: 244360 2015-08-07 23:38:53 +02:00			`; CHECK-LABEL: inexact:`
			`; CHECK: ## BB#0:`
			`; CHECK-NEXT: mulsd {{.*}}(%rip), %xmm0`
			`; CHECK-NEXT: retq`
			`%div = fdiv double %x, 0x41DFFFFFFFC00000`
Convert floating point division by a constant into multiplication by the 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. llvm-svn: 154265 2012-04-07 22:04:00 +02:00			`ret double %div`
			`}`

			`define double @funky(double %x) {`
			`; No conversion to multiplication if too funky.`
tighten checks using update_llc_test_checks.py llvm-svn: 244360 2015-08-07 23:38:53 +02:00			`; CHECK-LABEL: funky:`
			`; CHECK: ## BB#0:`
			`; CHECK-NEXT: xorpd %xmm1, %xmm1`
			`; CHECK-NEXT: divsd %xmm1, %xmm0`
			`; CHECK-NEXT: retq`
Convert floating point division by a constant into multiplication by the 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. llvm-svn: 154265 2012-04-07 22:04:00 +02:00			`%div = fdiv double %x, 0.0`
			`ret double %div`
			`}`
Add a comment noting that the fdiv -> fmul conversion won't generate multiplication by a denormal, and some tests checking that. llvm-svn: 154431 2012-04-10 22:35:27 +02:00
			`define double @denormal1(double %x) {`
			`; Don't generate multiplication by a denormal.`
tighten checks using update_llc_test_checks.py llvm-svn: 244360 2015-08-07 23:38:53 +02:00			`; CHECK-LABEL: denormal1:`
			`; CHECK: ## BB#0:`
			`; CHECK-NEXT: divsd {{.*}}(%rip), %xmm0`
			`; CHECK-NEXT: retq`
Add a comment noting that the fdiv -> fmul conversion won't generate multiplication by a denormal, and some tests checking that. llvm-svn: 154431 2012-04-10 22:35:27 +02:00			`%div = fdiv double %x, 0x7FD0000000000001`
			`ret double %div`
			`}`

			`define double @denormal2(double %x) {`
			`; Don't generate multiplication by a denormal.`
tighten checks using update_llc_test_checks.py llvm-svn: 244360 2015-08-07 23:38:53 +02:00			`; CHECK-LABEL: denormal2:`
			`; CHECK: ## BB#0:`
			`; CHECK-NEXT: divsd {{.*}}(%rip), %xmm0`
			`; CHECK-NEXT: retq`
Add a comment noting that the fdiv -> fmul conversion won't generate multiplication by a denormal, and some tests checking that. llvm-svn: 154431 2012-04-10 22:35:27 +02:00			`%div = fdiv double %x, 0x7FEFFFFFFFFFFFFF`
			`ret double %div`
			`}`
tighten checks using update_llc_test_checks.py llvm-svn: 244360 2015-08-07 23:38:53 +02:00