6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-04-02 10:33:53 +00:00
Code Issues Projects Releases Wiki Activity

[x86] set default reciprocal (division and square root) codegen to match GCC

Browse Source 
D8982 ( checked in at http://reviews.llvm.org/rL239001 ) added command-line 
options to allow reciprocal estimate instructions to be used in place of
divisions and square roots.

This patch changes the default settings for x86 targets to allow that recip
codegen (except for scalar division because that breaks too much code) when
using -ffast-math or its equivalent. 

This matches GCC behavior for this kind of codegen.

Differential Revision: http://reviews.llvm.org/D10396



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@240310 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Sanjay Patel 2015-06-22 18:29:44 +00:00
parent 060e38ab9f
commit 73aa02eb09
3 changed files with 63 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
lib/Target/X86/X86TargetMachine.cpp
View File

@ -110,12 +110,15 @@ X86TargetMachine::X86TargetMachine(const Target &T, const Triple &TT,
if (Subtarget.isTargetWin64())
this->Options.TrapUnreachable = true;
// TODO: By default, all reciprocal estimate operations are off because
// that matches the behavior before TargetRecip was added (except for btver2
// which used subtarget features to enable this type of codegen).
// We should change this to match GCC behavior where everything but
// scalar division estimates are turned on by default with -ffast-math.
this->Options.Reciprocals.setDefaults("all", false, 1);
// By default (and when -ffast-math is on), enable estimate codegen for
// everything except scalar division. By default, use 1 refinement step for
// all operations. Defaults may be overridden by using command-line options.
// Scalar division estimates are disabled because they break too much
// real-world code. These defaults match GCC behavior.
this->Options.Reciprocals.setDefaults("sqrtf", true, 1);
this->Options.Reciprocals.setDefaults("divf", false, 1);
this->Options.Reciprocals.setDefaults("vec-sqrtf", true, 1);
this->Options.Reciprocals.setDefaults("vec-divf", true, 1);
initAsmInfo();
}

38
test/CodeGen/X86/recip-fastmath.ll
View File

@ -1,4 +1,4 @@
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=sse2 | FileCheck %s
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=sse2 -recip=!divf,!vec-divf | FileCheck %s --check-prefix=NORECIP
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=avx -recip=divf,vec-divf | FileCheck %s --check-prefix=RECIP
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=avx -recip=divf:2,vec-divf:2 | FileCheck %s --check-prefix=REFINE
@ -14,11 +14,11 @@ define float @reciprocal_estimate(float %x) #0 {
%div = fdiv fast float 1.0, %x
ret float %div
; CHECK-LABEL: reciprocal_estimate:
; CHECK: movss
; CHECK-NEXT: divss
; CHECK-NEXT: movaps
; CHECK-NEXT: retq
; NORECIP-LABEL: reciprocal_estimate:
; NORECIP: movss
; NORECIP-NEXT: divss
; NORECIP-NEXT: movaps
; NORECIP-NEXT: retq
; RECIP-LABEL: reciprocal_estimate:
; RECIP: vrcpss
@ -45,11 +45,11 @@ define <4 x float> @reciprocal_estimate_v4f32(<4 x float> %x) #0 {
%div = fdiv fast <4 x float> <float 1.0, float 1.0, float 1.0, float 1.0>, %x
ret <4 x float> %div
; CHECK-LABEL: reciprocal_estimate_v4f32:
; CHECK: movaps
; CHECK-NEXT: divps
; CHECK-NEXT: movaps
; CHECK-NEXT: retq
; NORECIP-LABEL: reciprocal_estimate_v4f32:
; NORECIP: movaps
; NORECIP-NEXT: divps
; NORECIP-NEXT: movaps
; NORECIP-NEXT: retq
; RECIP-LABEL: reciprocal_estimate_v4f32:
; RECIP: vrcpps
@ -76,14 +76,14 @@ define <8 x float> @reciprocal_estimate_v8f32(<8 x float> %x) #0 {
%div = fdiv fast <8 x float> <float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0, float 1.0>, %x
ret <8 x float> %div
; CHECK-LABEL: reciprocal_estimate_v8f32:
; CHECK: movaps
; CHECK: movaps
; CHECK-NEXT: divps
; CHECK-NEXT: divps
; CHECK-NEXT: movaps
; CHECK-NEXT: movaps
; CHECK-NEXT: retq
; NORECIP-LABEL: reciprocal_estimate_v8f32:
; NORECIP: movaps
; NORECIP: movaps
; NORECIP-NEXT: divps
; NORECIP-NEXT: divps
; NORECIP-NEXT: movaps
; NORECIP-NEXT: movaps
; NORECIP-NEXT: retq
; RECIP-LABEL: reciprocal_estimate_v8f32:
; RECIP: vrcpps

70
test/CodeGen/X86/sqrt-fastmath.ll
View File

@ -1,4 +1,4 @@
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=sse2 | FileCheck %s
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=sse2 -recip=!sqrtf,!vec-sqrtf,!divf,!vec-divf | FileCheck %s --check-prefix=NORECIP
; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=avx -recip=sqrtf,vec-sqrtf | FileCheck %s --check-prefix=ESTIMATE
declare double @__sqrt_finite(double) #0
@ -10,10 +10,10 @@ declare <8 x float> @llvm.sqrt.v8f32(<8 x float>) #0
define double @fd(double %d) #0 {
; CHECK-LABEL: fd:
; CHECK: # BB#0:
; CHECK-NEXT: sqrtsd %xmm0, %xmm0
; CHECK-NEXT: retq
; NORECIP-LABEL: fd:
; NORECIP: # BB#0:
; NORECIP-NEXT: sqrtsd %xmm0, %xmm0
; NORECIP-NEXT: retq
;
; ESTIMATE-LABEL: fd:
; ESTIMATE: # BB#0:
@ -25,10 +25,10 @@ define double @fd(double %d) #0 {
define float @ff(float %f) #0 {
; CHECK-LABEL: ff:
; CHECK: # BB#0:
; CHECK-NEXT: sqrtss %xmm0, %xmm0
; CHECK-NEXT: retq
; NORECIP-LABEL: ff:
; NORECIP: # BB#0:
; NORECIP-NEXT: sqrtss %xmm0, %xmm0
; NORECIP-NEXT: retq
;
; ESTIMATE-LABEL: ff:
; ESTIMATE: # BB#0:
@ -49,11 +49,11 @@ define float @ff(float %f) #0 {
define x86_fp80 @fld(x86_fp80 %ld) #0 {
; CHECK-LABEL: fld:
; CHECK: # BB#0:
; CHECK-NEXT: fldt {{[0-9]+}}(%rsp)
; CHECK-NEXT: fsqrt
; CHECK-NEXT: retq
; NORECIP-LABEL: fld:
; NORECIP: # BB#0:
; NORECIP-NEXT: fldt {{[0-9]+}}(%rsp)
; NORECIP-NEXT: fsqrt
; NORECIP-NEXT: retq
;
; ESTIMATE-LABEL: fld:
; ESTIMATE: # BB#0:
@ -67,12 +67,12 @@ define x86_fp80 @fld(x86_fp80 %ld) #0 {
define float @reciprocal_square_root(float %x) #0 {
; CHECK-LABEL: reciprocal_square_root:
; CHECK: # BB#0:
; CHECK-NEXT: sqrtss %xmm0, %xmm1
; CHECK-NEXT: movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
; CHECK-NEXT: divss %xmm1, %xmm0
; CHECK-NEXT: retq
; NORECIP-LABEL: reciprocal_square_root:
; NORECIP: # BB#0:
; NORECIP-NEXT: sqrtss %xmm0, %xmm1
; NORECIP-NEXT: movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
; NORECIP-NEXT: divss %xmm1, %xmm0
; NORECIP-NEXT: retq
;
; ESTIMATE-LABEL: reciprocal_square_root:
; ESTIMATE: # BB#0:
@ -89,12 +89,12 @@ define float @reciprocal_square_root(float %x) #0 {
}
define <4 x float> @reciprocal_square_root_v4f32(<4 x float> %x) #0 {
; CHECK-LABEL: reciprocal_square_root_v4f32:
; CHECK: # BB#0:
; CHECK-NEXT: sqrtps %xmm0, %xmm1
; CHECK-NEXT: movaps {{.*#+}} xmm0 = [1.000000e+00,1.000000e+00,1.000000e+00,1.000000e+00]
; CHECK-NEXT: divps %xmm1, %xmm0
; CHECK-NEXT: retq
; NORECIP-LABEL: reciprocal_square_root_v4f32:
; NORECIP: # BB#0:
; NORECIP-NEXT: sqrtps %xmm0, %xmm1
; NORECIP-NEXT: movaps {{.*#+}} xmm0 = [1.000000e+00,1.000000e+00,1.000000e+00,1.000000e+00]
; NORECIP-NEXT: divps %xmm1, %xmm0
; NORECIP-NEXT: retq
;
; ESTIMATE-LABEL: reciprocal_square_root_v4f32:
; ESTIMATE: # BB#0:
@ -111,15 +111,15 @@ define <4 x float> @reciprocal_square_root_v4f32(<4 x float> %x) #0 {
}
define <8 x float> @reciprocal_square_root_v8f32(<8 x float> %x) #0 {
; CHECK-LABEL: reciprocal_square_root_v8f32:
; CHECK: # BB#0:
; CHECK-NEXT: sqrtps %xmm1, %xmm2
; CHECK-NEXT: sqrtps %xmm0, %xmm3
; CHECK-NEXT: movaps {{.*#+}} xmm1 = [1.000000e+00,1.000000e+00,1.000000e+00,1.000000e+00]
; CHECK-NEXT: movaps %xmm1, %xmm0
; CHECK-NEXT: divps %xmm3, %xmm0
; CHECK-NEXT: divps %xmm2, %xmm1
; CHECK-NEXT: retq
; NORECIP-LABEL: reciprocal_square_root_v8f32:
; NORECIP: # BB#0:
; NORECIP-NEXT: sqrtps %xmm1, %xmm2
; NORECIP-NEXT: sqrtps %xmm0, %xmm3
; NORECIP-NEXT: movaps {{.*#+}} xmm1 = [1.000000e+00,1.000000e+00,1.000000e+00,1.000000e+00]
; NORECIP-NEXT: movaps %xmm1, %xmm0
; NORECIP-NEXT: divps %xmm3, %xmm0
; NORECIP-NEXT: divps %xmm2, %xmm1
; NORECIP-NEXT: retq
;
; ESTIMATE-LABEL: reciprocal_square_root_v8f32:
; ESTIMATE: # BB#0: