1; RUN: llc < %s -march=arm -mcpu=cortex-a9 | FileCheck %s
2
3@A = global <4 x float> <float 0., float 1., float 2., float 3.>
4
5define void @test_sqrt(<4 x float>* %X) nounwind {
6
7; CHECK-LABEL: test_sqrt:
8
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  {{.*}}
17
18L.entry:
19  %0 = load <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
23}
24
25declare <4 x float> @llvm.sqrt.v4f32(<4 x float>) nounwind readonly
26
27
28define void @test_cos(<4 x float>* %X) nounwind {
29
30; CHECK-LABEL: test_cos:
31
32; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
33; CHECK:      movt  [[reg0]], :upper16:{{.*}}
34; CHECK:      vld1.64
35
36; CHECK:      {{v?mov(.32)?}}  r0,
37; CHECK:      bl  {{.*}}cosf
38
39; CHECK:      {{v?mov(.32)?}}  r0,
40; CHECK:      bl  {{.*}}cosf
41
42; CHECK:      {{v?mov(.32)?}}  r0,
43; CHECK:      bl  {{.*}}cosf
44
45; CHECK:      {{v?mov(.32)?}}  r0,
46; CHECK:      bl  {{.*}}cosf
47
48; CHECK:      vst1.64
49
50L.entry:
51  %0 = load <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
55}
56
57declare <4 x float> @llvm.cos.v4f32(<4 x float>) nounwind readonly
58
59define void @test_exp(<4 x float>* %X) nounwind {
60
61; CHECK-LABEL: test_exp:
62
63; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
64; CHECK:      movt  [[reg0]], :upper16:{{.*}}
65; CHECK:      vld1.64
66
67; CHECK:      {{v?mov(.32)?}}  r0,
68; CHECK:      bl  {{.*}}expf
69
70; CHECK:      {{v?mov(.32)?}}  r0,
71; CHECK:      bl  {{.*}}expf
72
73; CHECK:      {{v?mov(.32)?}}  r0,
74; CHECK:      bl  {{.*}}expf
75
76; CHECK:      {{v?mov(.32)?}}  r0,
77; CHECK:      bl  {{.*}}expf
78
79; CHECK:      vst1.64
80
81L.entry:
82  %0 = load <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
86}
87
88declare <4 x float> @llvm.exp.v4f32(<4 x float>) nounwind readonly
89
90define void @test_exp2(<4 x float>* %X) nounwind {
91
92; CHECK-LABEL: test_exp2:
93
94; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
95; CHECK:      movt  [[reg0]], :upper16:{{.*}}
96; CHECK:      vld1.64
97
98; CHECK:      {{v?mov(.32)?}}  r0,
99; CHECK:      bl  {{.*}}exp2f
100
101; CHECK:      {{v?mov(.32)?}}  r0,
102; CHECK:      bl  {{.*}}exp2f
103
104; CHECK:      {{v?mov(.32)?}}  r0,
105; CHECK:      bl  {{.*}}exp2f
106
107; CHECK:      {{v?mov(.32)?}}  r0,
108; CHECK:      bl  {{.*}}exp2f
109
110; CHECK:      vst1.64
111
112L.entry:
113  %0 = load <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
117}
118
119declare <4 x float> @llvm.exp2.v4f32(<4 x float>) nounwind readonly
120
121define void @test_log10(<4 x float>* %X) nounwind {
122
123; CHECK-LABEL: test_log10:
124
125; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
126; CHECK:      movt  [[reg0]], :upper16:{{.*}}
127; CHECK:      vld1.64
128
129; CHECK:      {{v?mov(.32)?}}  r0,
130; CHECK:      bl  {{.*}}log10f
131
132; CHECK:      {{v?mov(.32)?}}  r0,
133; CHECK:      bl  {{.*}}log10f
134
135; CHECK:      {{v?mov(.32)?}}  r0,
136; CHECK:      bl  {{.*}}log10f
137
138; CHECK:      {{v?mov(.32)?}}  r0,
139; CHECK:      bl  {{.*}}log10f
140
141; CHECK:      vst1.64
142
143L.entry:
144  %0 = load <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
148}
149
150declare <4 x float> @llvm.log10.v4f32(<4 x float>) nounwind readonly
151
152define void @test_log(<4 x float>* %X) nounwind {
153
154; CHECK-LABEL: test_log:
155
156; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
157; CHECK:      movt  [[reg0]], :upper16:{{.*}}
158; CHECK:      vld1.64
159
160; CHECK:      {{v?mov(.32)?}}  r0,
161; CHECK:      bl  {{.*}}logf
162
163; CHECK:      {{v?mov(.32)?}}  r0,
164; CHECK:      bl  {{.*}}logf
165
166; CHECK:      {{v?mov(.32)?}}  r0,
167; CHECK:      bl  {{.*}}logf
168
169; CHECK:      {{v?mov(.32)?}}  r0,
170; CHECK:      bl  {{.*}}logf
171
172; CHECK:      vst1.64
173
174L.entry:
175  %0 = load <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
179}
180
181declare <4 x float> @llvm.log.v4f32(<4 x float>) nounwind readonly
182
183define void @test_log2(<4 x float>* %X) nounwind {
184
185; CHECK-LABEL: test_log2:
186
187; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
188; CHECK:      movt  [[reg0]], :upper16:{{.*}}
189; CHECK:      vld1.64
190
191; CHECK:      {{v?mov(.32)?}}  r0,
192; CHECK:      bl  {{.*}}log2f
193
194; CHECK:      {{v?mov(.32)?}}  r0,
195; CHECK:      bl  {{.*}}log2f
196
197; CHECK:      {{v?mov(.32)?}}  r0,
198; CHECK:      bl  {{.*}}log2f
199
200; CHECK:      {{v?mov(.32)?}}  r0,
201; CHECK:      bl  {{.*}}log2f
202
203; CHECK:      vst1.64
204
205L.entry:
206  %0 = load <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
210}
211
212declare <4 x float> @llvm.log2.v4f32(<4 x float>) nounwind readonly
213
214
215define void @test_pow(<4 x float>* %X) nounwind {
216
217; CHECK-LABEL: test_pow:
218
219; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
220; CHECK:      movt  [[reg0]], :upper16:{{.*}}
221; CHECK:      vld1.64
222
223; CHECK:      {{v?mov(.32)?}}  r0,
224; CHECK:      bl  {{.*}}powf
225
226; CHECK:      {{v?mov(.32)?}}  r0,
227; CHECK:      bl  {{.*}}powf
228
229; CHECK:      {{v?mov(.32)?}}  r0,
230; CHECK:      bl  {{.*}}powf
231
232; CHECK:      {{v?mov(.32)?}}  r0,
233; CHECK:      bl  {{.*}}powf
234
235; CHECK:      vst1.64
236
237L.entry:
238
239  %0 = load <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.>)
241
242  store <4 x float> %1, <4 x float>* %X, align 16
243
244  ret void
245}
246
247declare <4 x float> @llvm.pow.v4f32(<4 x float>, <4 x float>) nounwind readonly
248
249define void @test_powi(<4 x float>* %X) nounwind {
250
251; CHECK-LABEL: test_powi:
252
253; CHECK:       movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
254; CHECK:       movt  [[reg0]], :upper16:{{.*}}
255; CHECK:       vld1.64 {{.*}}:128
256; CHECK:       vmul.f32 {{.*}}
257
258; CHECK:      vst1.64
259
260L.entry:
261
262  %0 = load <4 x float>* @A, align 16
263  %1 = call <4 x float> @llvm.powi.v4f32(<4 x float> %0, i32 2)
264
265  store <4 x float> %1, <4 x float>* %X, align 16
266
267  ret void
268}
269
270declare <4 x float> @llvm.powi.v4f32(<4 x float>, i32) nounwind readonly
271
272define void @test_sin(<4 x float>* %X) nounwind {
273
274; CHECK-LABEL: test_sin:
275
276; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
277; CHECK:      movt  [[reg0]], :upper16:{{.*}}
278; CHECK:      vld1.64
279
280; CHECK:      {{v?mov(.32)?}}  r0,
281; CHECK:      bl  {{.*}}sinf
282
283; CHECK:      {{v?mov(.32)?}}  r0,
284; CHECK:      bl  {{.*}}sinf
285
286; CHECK:      {{v?mov(.32)?}}  r0,
287; CHECK:      bl  {{.*}}sinf
288
289; CHECK:      {{v?mov(.32)?}}  r0,
290; CHECK:      bl  {{.*}}sinf
291
292; CHECK:      vst1.64
293
294L.entry:
295  %0 = load <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
299}
300
301declare <4 x float> @llvm.sin.v4f32(<4 x float>) nounwind readonly
302
303define void @test_floor(<4 x float>* %X) nounwind {
304
305; CHECK-LABEL: test_floor:
306
307; CHECK:      movw  [[reg0:r[0-9]+]], :lower16:{{.*}}
308; CHECK:      movt  [[reg0]], :upper16:{{.*}}
309; CHECK:      vld1.64
310
311; CHECK:      {{v?mov(.32)?}}  r0,
312; CHECK:      bl  {{.*}}floorf
313
314; CHECK:      {{v?mov(.32)?}}  r0,
315; CHECK:      bl  {{.*}}floorf
316
317; CHECK:      {{v?mov(.32)?}}  r0,
318; CHECK:      bl  {{.*}}floorf
319
320; CHECK:      {{v?mov(.32)?}}  r0,
321; CHECK:      bl  {{.*}}floorf
322
323; CHECK:      vst1.64
324
325L.entry:
326  %0 = load <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
330}
331
332declare <4 x float> @llvm.floor.v4f32(<4 x float>) nounwind readonly
333
334