Use PPC reciprocal estimates with Newton iteration in fast-math mode
[oota-llvm.git] / test / CodeGen / PowerPC / recipest.ll
1 ; RUN: llc < %s -mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr7 -enable-unsafe-fp-math | FileCheck %s
2 ; RUN: llc < %s -mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr7 | FileCheck -check-prefix=CHECK-SAFE %s
3 target datalayout = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f128:128:128-v128:128:128-n32:64"
4 target triple = "powerpc64-unknown-linux-gnu"
5
6 declare double @llvm.sqrt.f64(double)
7 declare float @llvm.sqrt.f32(float)
8 declare <4 x float> @llvm.sqrt.v4f32(<4 x float>)
9
10 define double @foo(double %a, double %b) nounwind {
11 entry:
12   %x = call double @llvm.sqrt.f64(double %b)
13   %r = fdiv double %a, %x
14   ret double %r
15
16 ; CHECK: @foo
17 ; CHECK: frsqrte
18 ; CHECK: fnmsub
19 ; CHECK: fmul
20 ; CHECK: fmadd
21 ; CHECK: fmul
22 ; CHECK: fmul
23 ; CHECK: fmadd
24 ; CHECK: fmul
25 ; CHECK: fmul
26 ; CHECK: blr
27
28 ; CHECK-SAFE: @foo
29 ; CHECK-SAFE: fsqrt
30 ; CHECK-SAFE: fdiv
31 ; CHECK-SAFE: blr
32 }
33
34 define float @goo(float %a, float %b) nounwind {
35 entry:
36   %x = call float @llvm.sqrt.f32(float %b)
37   %r = fdiv float %a, %x
38   ret float %r
39
40 ; CHECK: @goo
41 ; CHECK: frsqrtes
42 ; CHECK: fnmsubs
43 ; CHECK: fmuls
44 ; CHECK: fmadds
45 ; CHECK: fmuls
46 ; CHECK: fmuls
47 ; CHECK: blr
48
49 ; CHECK-SAFE: @goo
50 ; CHECK-SAFE: fsqrts
51 ; CHECK-SAFE: fdivs
52 ; CHECK-SAFE: blr
53 }
54
55 define <4 x float> @hoo(<4 x float> %a, <4 x float> %b) nounwind {
56 entry:
57   %x = call <4 x float> @llvm.sqrt.v4f32(<4 x float> %b)
58   %r = fdiv <4 x float> %a, %x
59   ret <4 x float> %r
60
61 ; CHECK: @hoo
62 ; CHECK: vrsqrtefp
63
64 ; CHECK-SAFE: @hoo
65 ; CHECK-SAFE-NOT: vrsqrtefp
66 ; CHECK-SAFE: blr
67 }
68
69 define double @foo2(double %a, double %b) nounwind {
70 entry:
71   %r = fdiv double %a, %b
72   ret double %r
73
74 ; CHECK: @foo2
75 ; CHECK: fre
76 ; CHECK: fnmsub
77 ; CHECK: fmadd
78 ; CHECK: fnmsub
79 ; CHECK: fmadd
80 ; CHECK: fmul
81 ; CHECK: blr
82
83 ; CHECK-SAFE: @foo2
84 ; CHECK-SAFE: fdiv
85 ; CHECK-SAFE: blr
86 }
87
88 define float @goo2(float %a, float %b) nounwind {
89 entry:
90   %r = fdiv float %a, %b
91   ret float %r
92
93 ; CHECK: @goo2
94 ; CHECK: fres
95 ; CHECK: fnmsubs
96 ; CHECK: fmadds
97 ; CHECK: fmuls
98 ; CHECK: blr
99
100 ; CHECK-SAFE: @goo2
101 ; CHECK-SAFE: fdivs
102 ; CHECK-SAFE: blr
103 }
104
105 define <4 x float> @hoo2(<4 x float> %a, <4 x float> %b) nounwind {
106 entry:
107   %r = fdiv <4 x float> %a, %b
108   ret <4 x float> %r
109
110 ; CHECK: @hoo2
111 ; CHECK: vrefp
112
113 ; CHECK-SAFE: @hoo2
114 ; CHECK-SAFE-NOT: vrefp
115 ; CHECK-SAFE: blr
116 }
117
118 define double @foo3(double %a) nounwind {
119 entry:
120   %r = call double @llvm.sqrt.f64(double %a)
121   ret double %r
122
123 ; CHECK: @foo3
124 ; CHECK: frsqrte
125 ; CHECK: fnmsub
126 ; CHECK: fmul
127 ; CHECK: fmadd
128 ; CHECK: fmul
129 ; CHECK: fmul
130 ; CHECK: fmadd
131 ; CHECK: fmul
132 ; CHECK: fre
133 ; CHECK: fnmsub
134 ; CHECK: fmadd
135 ; CHECK: fnmsub
136 ; CHECK: fmadd
137 ; CHECK: blr
138
139 ; CHECK-SAFE: @foo3
140 ; CHECK-SAFE: fsqrt
141 ; CHECK-SAFE: blr
142 }
143
144 define float @goo3(float %a) nounwind {
145 entry:
146   %r = call float @llvm.sqrt.f32(float %a)
147   ret float %r
148
149 ; CHECK: @goo3
150 ; CHECK: frsqrtes
151 ; CHECK: fnmsubs
152 ; CHECK: fmuls
153 ; CHECK: fmadds
154 ; CHECK: fmuls
155 ; CHECK: fres
156 ; CHECK: fnmsubs
157 ; CHECK: fmadds
158 ; CHECK: blr
159
160 ; CHECK-SAFE: @goo3
161 ; CHECK-SAFE: fsqrts
162 ; CHECK-SAFE: blr
163 }
164
165 define <4 x float> @hoo3(<4 x float> %a) nounwind {
166 entry:
167   %r = call <4 x float> @llvm.sqrt.v4f32(<4 x float> %a)
168   ret <4 x float> %r
169
170 ; CHECK: @hoo3
171 ; CHECK: vrsqrtefp
172 ; CHECK: vrefp
173
174 ; CHECK-SAFE: @hoo3
175 ; CHECK-SAFE-NOT: vrsqrtefp
176 ; CHECK-SAFE: blr
177 }
178