[ARM] Cortex-M4 schedule additions
[llvm-complete.git] / test / CodeGen / ARM / 2011-11-29-128bitArithmetics.ll
blob404aca13cdba6ac3a17c48d0a5749071e561f2b7
1 ; RUN: llc -mtriple=arm-eabi -float-abi=soft -mcpu=cortex-a9 %s -o - | FileCheck %s
3 @A = global <4 x float> <float 0., float 1., float 2., float 3.>
5 define void @test_sqrt(<4 x float>* %X) nounwind {
7 ; CHECK-LABEL: test_sqrt:
9 ; CHECK:      movw    r1, :lower16:{{.*}}
10 ; CHECK:      movt    r1, :upper16:{{.*}}
11 ; CHECK:      vld1.64 {{.*}}, [r1:128]
12 ; CHECK:      vsqrt.f32       {{s[0-9]+}}, {{s[0-9]+}}
13 ; CHECK:      vsqrt.f32       {{s[0-9]+}}, {{s[0-9]+}}
14 ; CHECK:      vsqrt.f32       {{s[0-9]+}}, {{s[0-9]+}}
15 ; CHECK:      vsqrt.f32       {{s[0-9]+}}, {{s[0-9]+}}
16 ; CHECK:      vst1.64  {{.*}}
18 L.entry:
19   %0 = load <4 x float>, <4 x float>* @A, align 16
20   %1 = call <4 x float> @llvm.sqrt.v4f32(<4 x float> %0)
21   store <4 x float> %1, <4 x float>* %X, align 16
22   ret void
25 declare <4 x float> @llvm.sqrt.v4f32(<4 x float>) nounwind readonly
28 define void @test_cos(<4 x float>* %X) nounwind {
30 ; CHECK-LABEL: test_cos:
32 ; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
33 ; CHECK:      movt  [[reg0]], :upper16:{{.*}}
34 ; CHECK:      vld1.64
36 ; CHECK:      {{v?mov(.32)?}}  r0,
37 ; CHECK:      bl  {{.*}}cosf
39 ; CHECK:      {{v?mov(.32)?}}  r0,
40 ; CHECK:      bl  {{.*}}cosf
42 ; CHECK:      {{v?mov(.32)?}}  r0,
43 ; CHECK:      bl  {{.*}}cosf
45 ; CHECK:      {{v?mov(.32)?}}  r0,
46 ; CHECK:      bl  {{.*}}cosf
48 ; CHECK:      vst1.64
50 L.entry:
51   %0 = load <4 x float>, <4 x float>* @A, align 16
52   %1 = call <4 x float> @llvm.cos.v4f32(<4 x float> %0)
53   store <4 x float> %1, <4 x float>* %X, align 16
54   ret void
57 declare <4 x float> @llvm.cos.v4f32(<4 x float>) nounwind readonly
59 define void @test_exp(<4 x float>* %X) nounwind {
61 ; CHECK-LABEL: test_exp:
63 ; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
64 ; CHECK:      movt  [[reg0]], :upper16:{{.*}}
65 ; CHECK:      vld1.64
67 ; CHECK:      {{v?mov(.32)?}}  r0,
68 ; CHECK:      bl  {{.*}}expf
70 ; CHECK:      {{v?mov(.32)?}}  r0,
71 ; CHECK:      bl  {{.*}}expf
73 ; CHECK:      {{v?mov(.32)?}}  r0,
74 ; CHECK:      bl  {{.*}}expf
76 ; CHECK:      {{v?mov(.32)?}}  r0,
77 ; CHECK:      bl  {{.*}}expf
79 ; CHECK:      vst1.64
81 L.entry:
82   %0 = load <4 x float>, <4 x float>* @A, align 16
83   %1 = call <4 x float> @llvm.exp.v4f32(<4 x float> %0)
84   store <4 x float> %1, <4 x float>* %X, align 16
85   ret void
88 declare <4 x float> @llvm.exp.v4f32(<4 x float>) nounwind readonly
90 define void @test_exp2(<4 x float>* %X) nounwind {
92 ; CHECK-LABEL: test_exp2:
94 ; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
95 ; CHECK:      movt  [[reg0]], :upper16:{{.*}}
96 ; CHECK:      vld1.64
98 ; CHECK:      {{v?mov(.32)?}}  r0,
99 ; CHECK:      bl  {{.*}}exp2f
101 ; CHECK:      {{v?mov(.32)?}}  r0,
102 ; CHECK:      bl  {{.*}}exp2f
104 ; CHECK:      {{v?mov(.32)?}}  r0,
105 ; CHECK:      bl  {{.*}}exp2f
107 ; CHECK:      {{v?mov(.32)?}}  r0,
108 ; CHECK:      bl  {{.*}}exp2f
110 ; CHECK:      vst1.64
112 L.entry:
113   %0 = load <4 x float>, <4 x float>* @A, align 16
114   %1 = call <4 x float> @llvm.exp2.v4f32(<4 x float> %0)
115   store <4 x float> %1, <4 x float>* %X, align 16
116   ret void
119 declare <4 x float> @llvm.exp2.v4f32(<4 x float>) nounwind readonly
121 define void @test_log10(<4 x float>* %X) nounwind {
123 ; CHECK-LABEL: test_log10:
125 ; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
126 ; CHECK:      movt  [[reg0]], :upper16:{{.*}}
127 ; CHECK:      vld1.64
129 ; CHECK:      {{v?mov(.32)?}}  r0,
130 ; CHECK:      bl  {{.*}}log10f
132 ; CHECK:      {{v?mov(.32)?}}  r0,
133 ; CHECK:      bl  {{.*}}log10f
135 ; CHECK:      {{v?mov(.32)?}}  r0,
136 ; CHECK:      bl  {{.*}}log10f
138 ; CHECK:      {{v?mov(.32)?}}  r0,
139 ; CHECK:      bl  {{.*}}log10f
141 ; CHECK:      vst1.64
143 L.entry:
144   %0 = load <4 x float>, <4 x float>* @A, align 16
145   %1 = call <4 x float> @llvm.log10.v4f32(<4 x float> %0)
146   store <4 x float> %1, <4 x float>* %X, align 16
147   ret void
150 declare <4 x float> @llvm.log10.v4f32(<4 x float>) nounwind readonly
152 define void @test_log(<4 x float>* %X) nounwind {
154 ; CHECK-LABEL: test_log:
156 ; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
157 ; CHECK:      movt  [[reg0]], :upper16:{{.*}}
158 ; CHECK:      vld1.64
160 ; CHECK:      {{v?mov(.32)?}}  r0,
161 ; CHECK:      bl  {{.*}}logf
163 ; CHECK:      {{v?mov(.32)?}}  r0,
164 ; CHECK:      bl  {{.*}}logf
166 ; CHECK:      {{v?mov(.32)?}}  r0,
167 ; CHECK:      bl  {{.*}}logf
169 ; CHECK:      {{v?mov(.32)?}}  r0,
170 ; CHECK:      bl  {{.*}}logf
172 ; CHECK:      vst1.64
174 L.entry:
175   %0 = load <4 x float>, <4 x float>* @A, align 16
176   %1 = call <4 x float> @llvm.log.v4f32(<4 x float> %0)
177   store <4 x float> %1, <4 x float>* %X, align 16
178   ret void
181 declare <4 x float> @llvm.log.v4f32(<4 x float>) nounwind readonly
183 define void @test_log2(<4 x float>* %X) nounwind {
185 ; CHECK-LABEL: test_log2:
187 ; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
188 ; CHECK:      movt  [[reg0]], :upper16:{{.*}}
189 ; CHECK:      vld1.64
191 ; CHECK:      {{v?mov(.32)?}}  r0,
192 ; CHECK:      bl  {{.*}}log2f
194 ; CHECK:      {{v?mov(.32)?}}  r0,
195 ; CHECK:      bl  {{.*}}log2f
197 ; CHECK:      {{v?mov(.32)?}}  r0,
198 ; CHECK:      bl  {{.*}}log2f
200 ; CHECK:      {{v?mov(.32)?}}  r0,
201 ; CHECK:      bl  {{.*}}log2f
203 ; CHECK:      vst1.64
205 L.entry:
206   %0 = load <4 x float>, <4 x float>* @A, align 16
207   %1 = call <4 x float> @llvm.log2.v4f32(<4 x float> %0)
208   store <4 x float> %1, <4 x float>* %X, align 16
209   ret void
212 declare <4 x float> @llvm.log2.v4f32(<4 x float>) nounwind readonly
215 define void @test_pow(<4 x float>* %X) nounwind {
217 ; CHECK-LABEL: test_pow:
219 ; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
220 ; CHECK:      movt  [[reg0]], :upper16:{{.*}}
221 ; CHECK:      vld1.64
223 ; CHECK:      {{v?mov(.32)?}}  r0,
224 ; CHECK:      bl  {{.*}}powf
226 ; CHECK:      {{v?mov(.32)?}}  r0,
227 ; CHECK:      bl  {{.*}}powf
229 ; CHECK:      {{v?mov(.32)?}}  r0,
230 ; CHECK:      bl  {{.*}}powf
232 ; CHECK:      {{v?mov(.32)?}}  r0,
233 ; CHECK:      bl  {{.*}}powf
235 ; CHECK:      vst1.64
237 L.entry:
239   %0 = load <4 x float>, <4 x float>* @A, align 16
240   %1 = call <4 x float> @llvm.pow.v4f32(<4 x float> %0, <4 x float> <float 2., float 2., float 2., float 2.>)
242   store <4 x float> %1, <4 x float>* %X, align 16
244   ret void
247 declare <4 x float> @llvm.pow.v4f32(<4 x float>, <4 x float>) nounwind readonly
249 define void @test_powi(<4 x float>* %X) nounwind {
251 ; CHECK-LABEL: test_powi:
253 ; CHECK:       movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
254 ; CHECK:       movt  [[reg0]], :upper16:{{.*}}
255 ; CHECK:       vld1.64 {{.*}}:128
256 ; CHECK:       vmul.f32 {{.*}}
258 ; CHECK:      vst1.64
260 L.entry:
262   %0 = load <4 x float>, <4 x float>* @A, align 16
263   %1 = call <4 x float> @llvm.powi.v4f32(<4 x float> %0, i32 2)
265   store <4 x float> %1, <4 x float>* %X, align 16
267   ret void
270 declare <4 x float> @llvm.powi.v4f32(<4 x float>, i32) nounwind readonly
272 define void @test_sin(<4 x float>* %X) nounwind {
274 ; CHECK-LABEL: test_sin:
276 ; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
277 ; CHECK:      movt  [[reg0]], :upper16:{{.*}}
278 ; CHECK:      vld1.64
280 ; CHECK:      {{v?mov(.32)?}}  r0,
281 ; CHECK:      bl  {{.*}}sinf
283 ; CHECK:      {{v?mov(.32)?}}  r0,
284 ; CHECK:      bl  {{.*}}sinf
286 ; CHECK:      {{v?mov(.32)?}}  r0,
287 ; CHECK:      bl  {{.*}}sinf
289 ; CHECK:      {{v?mov(.32)?}}  r0,
290 ; CHECK:      bl  {{.*}}sinf
292 ; CHECK:      vst1.64
294 L.entry:
295   %0 = load <4 x float>, <4 x float>* @A, align 16
296   %1 = call <4 x float> @llvm.sin.v4f32(<4 x float> %0)
297   store <4 x float> %1, <4 x float>* %X, align 16
298   ret void
301 declare <4 x float> @llvm.sin.v4f32(<4 x float>) nounwind readonly
303 define void @test_floor(<4 x float>* %X) nounwind {
305 ; CHECK-LABEL: test_floor:
307 ; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
308 ; CHECK:      movt  [[reg0]], :upper16:{{.*}}
309 ; CHECK:      vld1.64
311 ; CHECK:      {{v?mov(.32)?}}  r0,
312 ; CHECK:      bl  {{.*}}floorf
314 ; CHECK:      {{v?mov(.32)?}}  r0,
315 ; CHECK:      bl  {{.*}}floorf
317 ; CHECK:      {{v?mov(.32)?}}  r0,
318 ; CHECK:      bl  {{.*}}floorf
320 ; CHECK:      {{v?mov(.32)?}}  r0,
321 ; CHECK:      bl  {{.*}}floorf
323 ; CHECK:      vst1.64
325 L.entry:
326   %0 = load <4 x float>, <4 x float>* @A, align 16
327   %1 = call <4 x float> @llvm.floor.v4f32(<4 x float> %0)
328   store <4 x float> %1, <4 x float>* %X, align 16
329   ret void
332 declare <4 x float> @llvm.floor.v4f32(<4 x float>) nounwind readonly