source: icGREP/icgrep-devel/llvm-3.8.0.src/test/CodeGen/AArch64/arm64-big-endian-bitconverts.ll @ 5027

Last change on this file since 5027 was 5027, checked in by cameron, 3 years ago

Upgrade to llvm 3.8

File size: 30.4 KB
Line 
1; RUN: llc -mtriple aarch64_be < %s -aarch64-load-store-opt=false -O1 -o - | FileCheck %s
2; RUN: llc -mtriple aarch64_be < %s -aarch64-load-store-opt=false -O0 -fast-isel=true -o - | FileCheck %s
3
4; CHECK-LABEL: test_i64_f64:
5define void @test_i64_f64(double* %p, i64* %q) {
6; CHECK: ldr
7; CHECK: str
8    %1 = load double, double* %p
9    %2 = fadd double %1, %1
10    %3 = bitcast double %2 to i64
11    %4 = add i64 %3, %3
12    store i64 %4, i64* %q
13    ret void
14}
15
16; CHECK-LABEL: test_i64_v1i64:
17define void @test_i64_v1i64(<1 x i64>* %p, i64* %q) {
18; CHECK: ldr
19; CHECK: str
20    %1 = load <1 x i64>, <1 x i64>* %p
21    %2 = add <1 x i64> %1, %1
22    %3 = bitcast <1 x i64> %2 to i64
23    %4 = add i64 %3, %3
24    store i64 %4, i64* %q
25    ret void
26}
27
28; CHECK-LABEL: test_i64_v2f32:
29define void @test_i64_v2f32(<2 x float>* %p, i64* %q) {
30; CHECK: ld1 { v{{[0-9]+}}.2s }
31; CHECK: rev64 v{{[0-9]+}}.2s
32; CHECK: str
33    %1 = load <2 x float>, <2 x float>* %p
34    %2 = fadd <2 x float> %1, %1
35    %3 = bitcast <2 x float> %2 to i64
36    %4 = add i64 %3, %3
37    store i64 %4, i64* %q
38    ret void
39}
40
41; CHECK-LABEL: test_i64_v2i32:
42define void @test_i64_v2i32(<2 x i32>* %p, i64* %q) {
43; CHECK: ld1 { v{{[0-9]+}}.2s }
44; CHECK: rev64 v{{[0-9]+}}.2s
45; CHECK: str
46    %1 = load <2 x i32>, <2 x i32>* %p
47    %2 = add <2 x i32> %1, %1
48    %3 = bitcast <2 x i32> %2 to i64
49    %4 = add i64 %3, %3
50    store i64 %4, i64* %q
51    ret void
52}
53
54; CHECK-LABEL: test_i64_v4i16:
55define void @test_i64_v4i16(<4 x i16>* %p, i64* %q) {
56; CHECK: ld1 { v{{[0-9]+}}.4h }
57; CHECK: rev64 v{{[0-9]+}}.4h
58; CHECK: str
59    %1 = load <4 x i16>, <4 x i16>* %p
60    %2 = add <4 x i16> %1, %1
61    %3 = bitcast <4 x i16> %2 to i64
62    %4 = add i64 %3, %3
63    store i64 %4, i64* %q
64    ret void
65}
66
67; CHECK-LABEL: test_i64_v8i8:
68define void @test_i64_v8i8(<8 x i8>* %p, i64* %q) {
69; CHECK: ld1 { v{{[0-9]+}}.8b }
70; CHECK: rev64 v{{[0-9]+}}.8b
71; CHECK: str
72    %1 = load <8 x i8>, <8 x i8>* %p
73    %2 = add <8 x i8> %1, %1
74    %3 = bitcast <8 x i8> %2 to i64
75    %4 = add i64 %3, %3
76    store i64 %4, i64* %q
77    ret void
78}
79
80; CHECK-LABEL: test_f64_i64:
81define void @test_f64_i64(i64* %p, double* %q) {
82; CHECK: ldr
83; CHECK: str
84    %1 = load i64, i64* %p
85    %2 = add i64 %1, %1
86    %3 = bitcast i64 %2 to double
87    %4 = fadd double %3, %3
88    store double %4, double* %q
89    ret void
90}
91
92; CHECK-LABEL: test_f64_v1i64:
93define void @test_f64_v1i64(<1 x i64>* %p, double* %q) {
94; CHECK: ldr
95; CHECK: str
96    %1 = load <1 x i64>, <1 x i64>* %p
97    %2 = add <1 x i64> %1, %1
98    %3 = bitcast <1 x i64> %2 to double
99    %4 = fadd double %3, %3
100    store double %4, double* %q
101    ret void
102}
103
104; CHECK-LABEL: test_f64_v2f32:
105define void @test_f64_v2f32(<2 x float>* %p, double* %q) {
106; CHECK: ld1 { v{{[0-9]+}}.2s }
107; CHECK: rev64 v{{[0-9]+}}.2s
108; CHECK: str
109    %1 = load <2 x float>, <2 x float>* %p
110    %2 = fadd <2 x float> %1, %1
111    %3 = bitcast <2 x float> %2 to double
112    %4 = fadd double %3, %3
113    store double %4, double* %q
114    ret void
115}
116
117; CHECK-LABEL: test_f64_v2i32:
118define void @test_f64_v2i32(<2 x i32>* %p, double* %q) {
119; CHECK: ld1 { v{{[0-9]+}}.2s }
120; CHECK: rev64 v{{[0-9]+}}.2s
121; CHECK: str
122    %1 = load <2 x i32>, <2 x i32>* %p
123    %2 = add <2 x i32> %1, %1
124    %3 = bitcast <2 x i32> %2 to double
125    %4 = fadd double %3, %3
126    store double %4, double* %q
127    ret void
128}
129
130; CHECK-LABEL: test_f64_v4i16:
131define void @test_f64_v4i16(<4 x i16>* %p, double* %q) {
132; CHECK: ld1 { v{{[0-9]+}}.4h }
133; CHECK: rev64 v{{[0-9]+}}.4h
134; CHECK: str
135    %1 = load <4 x i16>, <4 x i16>* %p
136    %2 = add <4 x i16> %1, %1
137    %3 = bitcast <4 x i16> %2 to double
138    %4 = fadd double %3, %3
139    store double %4, double* %q
140    ret void
141}
142
143; CHECK-LABEL: test_f64_v8i8:
144define void @test_f64_v8i8(<8 x i8>* %p, double* %q) {
145; CHECK: ld1 { v{{[0-9]+}}.8b }
146; CHECK: rev64 v{{[0-9]+}}.8b
147; CHECK: str
148    %1 = load <8 x i8>, <8 x i8>* %p
149    %2 = add <8 x i8> %1, %1
150    %3 = bitcast <8 x i8> %2 to double
151    %4 = fadd double %3, %3
152    store double %4, double* %q
153    ret void
154}
155
156; CHECK-LABEL: test_v1i64_i64:
157define void @test_v1i64_i64(i64* %p, <1 x i64>* %q) {
158; CHECK: ldr
159; CHECK: str
160    %1 = load i64, i64* %p
161    %2 = add i64 %1, %1
162    %3 = bitcast i64 %2 to <1 x i64>
163    %4 = add <1 x i64> %3, %3
164    store <1 x i64> %4, <1 x i64>* %q
165    ret void
166}
167
168; CHECK-LABEL: test_v1i64_f64:
169define void @test_v1i64_f64(double* %p, <1 x i64>* %q) {
170; CHECK: ldr
171; CHECK: str
172    %1 = load double, double* %p
173    %2 = fadd double %1, %1
174    %3 = bitcast double %2 to <1 x i64>
175    %4 = add <1 x i64> %3, %3
176    store <1 x i64> %4, <1 x i64>* %q
177    ret void
178}
179
180; CHECK-LABEL: test_v1i64_v2f32:
181define void @test_v1i64_v2f32(<2 x float>* %p, <1 x i64>* %q) {
182; CHECK: ld1 { v{{[0-9]+}}.2s }
183; CHECK: rev64 v{{[0-9]+}}.2s
184; CHECK: str
185    %1 = load <2 x float>, <2 x float>* %p
186    %2 = fadd <2 x float> %1, %1
187    %3 = bitcast <2 x float> %2 to <1 x i64>
188    %4 = add <1 x i64> %3, %3
189    store <1 x i64> %4, <1 x i64>* %q
190    ret void
191}
192
193; CHECK-LABEL: test_v1i64_v2i32:
194define void @test_v1i64_v2i32(<2 x i32>* %p, <1 x i64>* %q) {
195; CHECK: ld1 { v{{[0-9]+}}.2s }
196; CHECK: rev64 v{{[0-9]+}}.2s
197; CHECK: str
198    %1 = load <2 x i32>, <2 x i32>* %p
199    %2 = add <2 x i32> %1, %1
200    %3 = bitcast <2 x i32> %2 to <1 x i64>
201    %4 = add <1 x i64> %3, %3
202    store <1 x i64> %4, <1 x i64>* %q
203    ret void
204}
205
206; CHECK-LABEL: test_v1i64_v4i16:
207define void @test_v1i64_v4i16(<4 x i16>* %p, <1 x i64>* %q) {
208; CHECK: ld1 { v{{[0-9]+}}.4h }
209; CHECK: rev64 v{{[0-9]+}}.4h
210; CHECK: str
211    %1 = load <4 x i16>, <4 x i16>* %p
212    %2 = add <4 x i16> %1, %1
213    %3 = bitcast <4 x i16> %2 to <1 x i64>
214    %4 = add <1 x i64> %3, %3
215    store <1 x i64> %4, <1 x i64>* %q
216    ret void
217}
218
219; CHECK-LABEL: test_v1i64_v8i8:
220define void @test_v1i64_v8i8(<8 x i8>* %p, <1 x i64>* %q) {
221; CHECK: ld1 { v{{[0-9]+}}.8b }
222; CHECK: rev64 v{{[0-9]+}}.8b
223; CHECK: str
224    %1 = load <8 x i8>, <8 x i8>* %p
225    %2 = add <8 x i8> %1, %1
226    %3 = bitcast <8 x i8> %2 to <1 x i64>
227    %4 = add <1 x i64> %3, %3
228    store <1 x i64> %4, <1 x i64>* %q
229    ret void
230}
231
232; CHECK-LABEL: test_v2f32_i64:
233define void @test_v2f32_i64(i64* %p, <2 x float>* %q) {
234; CHECK: ldr
235; CHECK: rev64 v{{[0-9]+}}.2s
236; CHECK: st1 { v{{[0-9]+}}.2s }
237    %1 = load i64, i64* %p
238    %2 = add i64 %1, %1
239    %3 = bitcast i64 %2 to <2 x float>
240    %4 = fadd <2 x float> %3, %3
241    store <2 x float> %4, <2 x float>* %q
242    ret void
243}
244
245; CHECK-LABEL: test_v2f32_f64:
246define void @test_v2f32_f64(double* %p, <2 x float>* %q) {
247; CHECK: ldr
248; CHECK: rev64 v{{[0-9]+}}.2s
249; CHECK: st1 { v{{[0-9]+}}.2s }
250    %1 = load double, double* %p
251    %2 = fadd double %1, %1
252    %3 = bitcast double %2 to <2 x float>
253    %4 = fadd <2 x float> %3, %3
254    store <2 x float> %4, <2 x float>* %q
255    ret void
256}
257
258; CHECK-LABEL: test_v2f32_v1i64:
259define void @test_v2f32_v1i64(<1 x i64>* %p, <2 x float>* %q) {
260; CHECK: ldr
261; CHECK: rev64 v{{[0-9]+}}.2s
262; CHECK: st1 { v{{[0-9]+}}.2s }
263    %1 = load <1 x i64>, <1 x i64>* %p
264    %2 = add <1 x i64> %1, %1
265    %3 = bitcast <1 x i64> %2 to <2 x float>
266    %4 = fadd <2 x float> %3, %3
267    store <2 x float> %4, <2 x float>* %q
268    ret void
269}
270
271; CHECK-LABEL: test_v2f32_v2i32:
272define void @test_v2f32_v2i32(<2 x i32>* %p, <2 x float>* %q) {
273; CHECK: ld1 { v{{[0-9]+}}.2s }
274; CHECK: st1 { v{{[0-9]+}}.2s }
275    %1 = load <2 x i32>, <2 x i32>* %p
276    %2 = add <2 x i32> %1, %1
277    %3 = bitcast <2 x i32> %2 to <2 x float>
278    %4 = fadd <2 x float> %3, %3
279    store <2 x float> %4, <2 x float>* %q
280    ret void
281}
282
283; CHECK-LABEL: test_v2f32_v4i16:
284define void @test_v2f32_v4i16(<4 x i16>* %p, <2 x float>* %q) {
285; CHECK: ld1 { v{{[0-9]+}}.4h }
286; CHECK: rev32 v{{[0-9]+}}.4h
287; CHECK: st1 { v{{[0-9]+}}.2s }
288    %1 = load <4 x i16>, <4 x i16>* %p
289    %2 = add <4 x i16> %1, %1
290    %3 = bitcast <4 x i16> %2 to <2 x float>
291    %4 = fadd <2 x float> %3, %3
292    store <2 x float> %4, <2 x float>* %q
293    ret void
294}
295
296; CHECK-LABEL: test_v2f32_v8i8:
297define void @test_v2f32_v8i8(<8 x i8>* %p, <2 x float>* %q) {
298; CHECK: ld1 { v{{[0-9]+}}.8b }
299; CHECK: rev32 v{{[0-9]+}}.8b
300; CHECK: st1 { v{{[0-9]+}}.2s }
301    %1 = load <8 x i8>, <8 x i8>* %p
302    %2 = add <8 x i8> %1, %1
303    %3 = bitcast <8 x i8> %2 to <2 x float>
304    %4 = fadd <2 x float> %3, %3
305    store <2 x float> %4, <2 x float>* %q
306    ret void
307}
308
309; CHECK-LABEL: test_v2i32_i64:
310define void @test_v2i32_i64(i64* %p, <2 x i32>* %q) {
311; CHECK: ldr
312; CHECK: rev64 v{{[0-9]+}}.2s
313; CHECK: st1 { v{{[0-9]+}}.2s }
314    %1 = load i64, i64* %p
315    %2 = add i64 %1, %1
316    %3 = bitcast i64 %2 to <2 x i32>
317    %4 = add <2 x i32> %3, %3
318    store <2 x i32> %4, <2 x i32>* %q
319    ret void
320}
321
322; CHECK-LABEL: test_v2i32_f64:
323define void @test_v2i32_f64(double* %p, <2 x i32>* %q) {
324; CHECK: ldr
325; CHECK: rev64 v{{[0-9]+}}.2s
326; CHECK: st1 { v{{[0-9]+}}.2s }
327    %1 = load double, double* %p
328    %2 = fadd double %1, %1
329    %3 = bitcast double %2 to <2 x i32>
330    %4 = add <2 x i32> %3, %3
331    store <2 x i32> %4, <2 x i32>* %q
332    ret void
333}
334
335; CHECK-LABEL: test_v2i32_v1i64:
336define void @test_v2i32_v1i64(<1 x i64>* %p, <2 x i32>* %q) {
337; CHECK: ldr
338; CHECK: rev64 v{{[0-9]+}}.2s
339; CHECK: st1 { v{{[0-9]+}}.2s }
340    %1 = load <1 x i64>, <1 x i64>* %p
341    %2 = add <1 x i64> %1, %1
342    %3 = bitcast <1 x i64> %2 to <2 x i32>
343    %4 = add <2 x i32> %3, %3
344    store <2 x i32> %4, <2 x i32>* %q
345    ret void
346}
347
348; CHECK-LABEL: test_v2i32_v2f32:
349define void @test_v2i32_v2f32(<2 x float>* %p, <2 x i32>* %q) {
350; CHECK: ld1 { v{{[0-9]+}}.2s }
351; CHECK: st1 { v{{[0-9]+}}.2s }
352    %1 = load <2 x float>, <2 x float>* %p
353    %2 = fadd <2 x float> %1, %1
354    %3 = bitcast <2 x float> %2 to <2 x i32>
355    %4 = add <2 x i32> %3, %3
356    store <2 x i32> %4, <2 x i32>* %q
357    ret void
358}
359
360; CHECK-LABEL: test_v2i32_v4i16:
361define void @test_v2i32_v4i16(<4 x i16>* %p, <2 x i32>* %q) {
362; CHECK: ld1 { v{{[0-9]+}}.4h }
363; CHECK: rev32 v{{[0-9]+}}.4h
364; CHECK: st1 { v{{[0-9]+}}.2s }
365    %1 = load <4 x i16>, <4 x i16>* %p
366    %2 = add <4 x i16> %1, %1
367    %3 = bitcast <4 x i16> %2 to <2 x i32>
368    %4 = add <2 x i32> %3, %3
369    store <2 x i32> %4, <2 x i32>* %q
370    ret void
371}
372
373; CHECK-LABEL: test_v2i32_v8i8:
374define void @test_v2i32_v8i8(<8 x i8>* %p, <2 x i32>* %q) {
375; CHECK: ld1 { v{{[0-9]+}}.8b }
376; CHECK: rev32 v{{[0-9]+}}.8b
377; CHECK: st1 { v{{[0-9]+}}.2s }
378    %1 = load <8 x i8>, <8 x i8>* %p
379    %2 = add <8 x i8> %1, %1
380    %3 = bitcast <8 x i8> %2 to <2 x i32>
381    %4 = add <2 x i32> %3, %3
382    store <2 x i32> %4, <2 x i32>* %q
383    ret void
384}
385
386; CHECK-LABEL: test_v4i16_i64:
387define void @test_v4i16_i64(i64* %p, <4 x i16>* %q) {
388; CHECK: ldr
389; CHECK: rev64 v{{[0-9]+}}.4h
390; CHECK: st1 { v{{[0-9]+}}.4h }
391    %1 = load i64, i64* %p
392    %2 = add i64 %1, %1
393    %3 = bitcast i64 %2 to <4 x i16>
394    %4 = add <4 x i16> %3, %3
395    store <4 x i16> %4, <4 x i16>* %q
396    ret void
397}
398
399; CHECK-LABEL: test_v4i16_f64:
400define void @test_v4i16_f64(double* %p, <4 x i16>* %q) {
401; CHECK: ldr
402; CHECK: rev64 v{{[0-9]+}}.4h
403; CHECK: st1 { v{{[0-9]+}}.4h }
404    %1 = load double, double* %p
405    %2 = fadd double %1, %1
406    %3 = bitcast double %2 to <4 x i16>
407    %4 = add <4 x i16> %3, %3
408    store <4 x i16> %4, <4 x i16>* %q
409    ret void
410}
411
412; CHECK-LABEL: test_v4i16_v1i64:
413define void @test_v4i16_v1i64(<1 x i64>* %p, <4 x i16>* %q) {
414; CHECK: ldr
415; CHECK: rev64 v{{[0-9]+}}.4h
416; CHECK: st1 { v{{[0-9]+}}.4h }
417    %1 = load <1 x i64>, <1 x i64>* %p
418    %2 = add <1 x i64> %1, %1
419    %3 = bitcast <1 x i64> %2 to <4 x i16>
420    %4 = add <4 x i16> %3, %3
421    store <4 x i16> %4, <4 x i16>* %q
422    ret void
423}
424
425; CHECK-LABEL: test_v4i16_v2f32:
426define void @test_v4i16_v2f32(<2 x float>* %p, <4 x i16>* %q) {
427; CHECK: ld1 { v{{[0-9]+}}.2s }
428; CHECK: rev32 v{{[0-9]+}}.4h
429; CHECK: st1 { v{{[0-9]+}}.4h }
430    %1 = load <2 x float>, <2 x float>* %p
431    %2 = fadd <2 x float> %1, %1
432    %3 = bitcast <2 x float> %2 to <4 x i16>
433    %4 = add <4 x i16> %3, %3
434    store <4 x i16> %4, <4 x i16>* %q
435    ret void
436}
437
438; CHECK-LABEL: test_v4i16_v2i32:
439define void @test_v4i16_v2i32(<2 x i32>* %p, <4 x i16>* %q) {
440; CHECK: ld1 { v{{[0-9]+}}.2s }
441; CHECK: rev32 v{{[0-9]+}}.4h
442; CHECK: st1 { v{{[0-9]+}}.4h }
443    %1 = load <2 x i32>, <2 x i32>* %p
444    %2 = add <2 x i32> %1, %1
445    %3 = bitcast <2 x i32> %2 to <4 x i16>
446    %4 = add <4 x i16> %3, %3
447    store <4 x i16> %4, <4 x i16>* %q
448    ret void
449}
450
451; CHECK-LABEL: test_v4i16_v8i8:
452define void @test_v4i16_v8i8(<8 x i8>* %p, <4 x i16>* %q) {
453; CHECK: ld1 { v{{[0-9]+}}.8b }
454; CHECK: rev16 v{{[0-9]+}}.8b
455; CHECK: st1 { v{{[0-9]+}}.4h }
456    %1 = load <8 x i8>, <8 x i8>* %p
457    %2 = add <8 x i8> %1, %1
458    %3 = bitcast <8 x i8> %2 to <4 x i16>
459    %4 = add <4 x i16> %3, %3
460    store <4 x i16> %4, <4 x i16>* %q
461    ret void
462}
463
464; CHECK-LABEL: test_v8i8_i64:
465define void @test_v8i8_i64(i64* %p, <8 x i8>* %q) {
466; CHECK: ldr
467; CHECK: rev64 v{{[0-9]+}}.8b
468; CHECK: st1 { v{{[0-9]+}}.8b }
469    %1 = load i64, i64* %p
470    %2 = add i64 %1, %1
471    %3 = bitcast i64 %2 to <8 x i8>
472    %4 = add <8 x i8> %3, %3
473    store <8 x i8> %4, <8 x i8>* %q
474    ret void
475}
476
477; CHECK-LABEL: test_v8i8_f64:
478define void @test_v8i8_f64(double* %p, <8 x i8>* %q) {
479; CHECK: ldr
480; CHECK: rev64 v{{[0-9]+}}.8b
481; CHECK: st1 { v{{[0-9]+}}.8b }
482    %1 = load double, double* %p
483    %2 = fadd double %1, %1
484    %3 = bitcast double %2 to <8 x i8>
485    %4 = add <8 x i8> %3, %3
486    store <8 x i8> %4, <8 x i8>* %q
487    ret void
488}
489
490; CHECK-LABEL: test_v8i8_v1i64:
491define void @test_v8i8_v1i64(<1 x i64>* %p, <8 x i8>* %q) {
492; CHECK: ldr
493; CHECK: rev64 v{{[0-9]+}}.8b
494; CHECK: st1 { v{{[0-9]+}}.8b }
495    %1 = load <1 x i64>, <1 x i64>* %p
496    %2 = add <1 x i64> %1, %1
497    %3 = bitcast <1 x i64> %2 to <8 x i8>
498    %4 = add <8 x i8> %3, %3
499    store <8 x i8> %4, <8 x i8>* %q
500    ret void
501}
502
503; CHECK-LABEL: test_v8i8_v2f32:
504define void @test_v8i8_v2f32(<2 x float>* %p, <8 x i8>* %q) {
505; CHECK: ld1 { v{{[0-9]+}}.2s }
506; CHECK: rev32 v{{[0-9]+}}.8b
507; CHECK: st1 { v{{[0-9]+}}.8b }
508    %1 = load <2 x float>, <2 x float>* %p
509    %2 = fadd <2 x float> %1, %1
510    %3 = bitcast <2 x float> %2 to <8 x i8>
511    %4 = add <8 x i8> %3, %3
512    store <8 x i8> %4, <8 x i8>* %q
513    ret void
514}
515
516; CHECK-LABEL: test_v8i8_v2i32:
517define void @test_v8i8_v2i32(<2 x i32>* %p, <8 x i8>* %q) {
518; CHECK: ld1 { v{{[0-9]+}}.2s }
519; CHECK: rev32 v{{[0-9]+}}.8b
520; CHECK: st1 { v{{[0-9]+}}.8b }
521    %1 = load <2 x i32>, <2 x i32>* %p
522    %2 = add <2 x i32> %1, %1
523    %3 = bitcast <2 x i32> %2 to <8 x i8>
524    %4 = add <8 x i8> %3, %3
525    store <8 x i8> %4, <8 x i8>* %q
526    ret void
527}
528
529; CHECK-LABEL: test_v8i8_v4i16:
530define void @test_v8i8_v4i16(<4 x i16>* %p, <8 x i8>* %q) {
531; CHECK: ld1 { v{{[0-9]+}}.4h }
532; CHECK: rev16 v{{[0-9]+}}.8b
533; CHECK: st1 { v{{[0-9]+}}.8b }
534    %1 = load <4 x i16>, <4 x i16>* %p
535    %2 = add <4 x i16> %1, %1
536    %3 = bitcast <4 x i16> %2 to <8 x i8>
537    %4 = add <8 x i8> %3, %3
538    store <8 x i8> %4, <8 x i8>* %q
539    ret void
540}
541
542; CHECK-LABEL: test_f128_v2f64:
543define void @test_f128_v2f64(<2 x double>* %p, fp128* %q) {
544; CHECK: ld1 { v{{[0-9]+}}.2d }
545; CHECK: ext
546; CHECK: str
547    %1 = load <2 x double>, <2 x double>* %p
548    %2 = fadd <2 x double> %1, %1
549    %3 = bitcast <2 x double> %2 to fp128
550    %4 = fadd fp128 %3, %3
551    store fp128 %4, fp128* %q
552    ret void
553}
554
555; CHECK-LABEL: test_f128_v2i64:
556define void @test_f128_v2i64(<2 x i64>* %p, fp128* %q) {
557; CHECK: ld1 { v{{[0-9]+}}.2d }
558; CHECK: ext
559; CHECK: str
560    %1 = load <2 x i64>, <2 x i64>* %p
561    %2 = add <2 x i64> %1, %1
562    %3 = bitcast <2 x i64> %2 to fp128
563    %4 = fadd fp128 %3, %3
564    store fp128 %4, fp128* %q
565    ret void
566}
567
568; CHECK-LABEL: test_f128_v4f32:
569define void @test_f128_v4f32(<4 x float>* %p, fp128* %q) {
570; CHECK: ld1 { v{{[0-9]+}}.2d }
571; CHECK: rev64 v{{[0-9]+}}.4s
572; CHECK: rev64 v{{[0-9]+}}.4s
573; CHECK: ext
574; CHECK: str q
575    %1 = load <4 x float>, <4 x float>* %p
576    %2 = fadd <4 x float> %1, %1
577    %3 = bitcast <4 x float> %2 to fp128
578    %4 = fadd fp128 %3, %3
579    store fp128 %4, fp128* %q
580    ret void
581}
582
583; CHECK-LABEL: test_f128_v4i32:
584define void @test_f128_v4i32(<4 x i32>* %p, fp128* %q) {
585; CHECK: ld1 { v{{[0-9]+}}.4s }
586; CHECK: rev64 v{{[0-9]+}}.4s
587; CHECK: ext
588; CHECK: str
589    %1 = load <4 x i32>, <4 x i32>* %p
590    %2 = add <4 x i32> %1, %1
591    %3 = bitcast <4 x i32> %2 to fp128
592    %4 = fadd fp128 %3, %3
593    store fp128 %4, fp128* %q
594    ret void
595}
596
597; CHECK-LABEL: test_f128_v8i16:
598define void @test_f128_v8i16(<8 x i16>* %p, fp128* %q) {
599; CHECK: ld1 { v{{[0-9]+}}.8h }
600; CHECK: rev64 v{{[0-9]+}}.8h
601; CHECK: ext
602; CHECK: str
603    %1 = load <8 x i16>, <8 x i16>* %p
604    %2 = add <8 x i16> %1, %1
605    %3 = bitcast <8 x i16> %2 to fp128
606    %4 = fadd fp128 %3, %3
607    store fp128 %4, fp128* %q
608    ret void
609}
610
611; CHECK-LABEL: test_f128_v16i8:
612define void @test_f128_v16i8(<16 x i8>* %p, fp128* %q) {
613; CHECK: ld1 { v{{[0-9]+}}.16b }
614; CHECK: ext
615; CHECK: str q
616    %1 = load <16 x i8>, <16 x i8>* %p
617    %2 = add <16 x i8> %1, %1
618    %3 = bitcast <16 x i8> %2 to fp128
619    %4 = fadd fp128 %3, %3
620    store fp128 %4, fp128* %q
621    ret void
622}
623
624; CHECK-LABEL: test_v2f64_f128:
625define void @test_v2f64_f128(fp128* %p, <2 x double>* %q) {
626; CHECK: ldr
627; CHECK: ext
628; CHECK: st1 { v{{[0-9]+}}.2d }
629    %1 = load fp128, fp128* %p
630    %2 = fadd fp128 %1, %1
631    %3 = bitcast fp128 %2 to <2 x double>
632    %4 = fadd <2 x double> %3, %3
633    store <2 x double> %4, <2 x double>* %q
634    ret void
635}
636
637; CHECK-LABEL: test_v2f64_v2i64:
638define void @test_v2f64_v2i64(<2 x i64>* %p, <2 x double>* %q) {
639; CHECK: ld1 { v{{[0-9]+}}.2d }
640; CHECK: st1 { v{{[0-9]+}}.2d }
641    %1 = load <2 x i64>, <2 x i64>* %p
642    %2 = add <2 x i64> %1, %1
643    %3 = bitcast <2 x i64> %2 to <2 x double>
644    %4 = fadd <2 x double> %3, %3
645    store <2 x double> %4, <2 x double>* %q
646    ret void
647}
648
649; CHECK-LABEL: test_v2f64_v4f32:
650define void @test_v2f64_v4f32(<4 x float>* %p, <2 x double>* %q) {
651; CHECK: ld1 { v{{[0-9]+}}.2d }
652; CHECK: rev64 v{{[0-9]+}}.4s
653; CHECK: rev64 v{{[0-9]+}}.4s
654; CHECK: st1 { v{{[0-9]+}}.2d }
655    %1 = load <4 x float>, <4 x float>* %p
656    %2 = fadd <4 x float> %1, %1
657    %3 = bitcast <4 x float> %2 to <2 x double>
658    %4 = fadd <2 x double> %3, %3
659    store <2 x double> %4, <2 x double>* %q
660    ret void
661}
662
663; CHECK-LABEL: test_v2f64_v4i32:
664define void @test_v2f64_v4i32(<4 x i32>* %p, <2 x double>* %q) {
665; CHECK: ld1 { v{{[0-9]+}}.4s }
666; CHECK: rev64 v{{[0-9]+}}.4s
667; CHECK: st1 { v{{[0-9]+}}.2d }
668    %1 = load <4 x i32>, <4 x i32>* %p
669    %2 = add <4 x i32> %1, %1
670    %3 = bitcast <4 x i32> %2 to <2 x double>
671    %4 = fadd <2 x double> %3, %3
672    store <2 x double> %4, <2 x double>* %q
673    ret void
674}
675
676; CHECK-LABEL: test_v2f64_v8i16:
677define void @test_v2f64_v8i16(<8 x i16>* %p, <2 x double>* %q) {
678; CHECK: ld1 { v{{[0-9]+}}.8h }
679; CHECK: rev64 v{{[0-9]+}}.8h
680; CHECK: st1 { v{{[0-9]+}}.2d }
681    %1 = load <8 x i16>, <8 x i16>* %p
682    %2 = add <8 x i16> %1, %1
683    %3 = bitcast <8 x i16> %2 to <2 x double>
684    %4 = fadd <2 x double> %3, %3
685    store <2 x double> %4, <2 x double>* %q
686    ret void
687}
688
689; CHECK-LABEL: test_v2f64_v16i8:
690define void @test_v2f64_v16i8(<16 x i8>* %p, <2 x double>* %q) {
691; CHECK: ld1 { v{{[0-9]+}}.16b }
692; CHECK: rev64 v{{[0-9]+}}.16b
693; CHECK: st1 { v{{[0-9]+}}.2d }
694    %1 = load <16 x i8>, <16 x i8>* %p
695    %2 = add <16 x i8> %1, %1
696    %3 = bitcast <16 x i8> %2 to <2 x double>
697    %4 = fadd <2 x double> %3, %3
698    store <2 x double> %4, <2 x double>* %q
699    ret void
700}
701
702; CHECK-LABEL: test_v2i64_f128:
703define void @test_v2i64_f128(fp128* %p, <2 x i64>* %q) {
704; CHECK: ldr
705; CHECK: ext
706; CHECK: st1 { v{{[0-9]+}}.2d }
707    %1 = load fp128, fp128* %p
708    %2 = fadd fp128 %1, %1
709    %3 = bitcast fp128 %2 to <2 x i64>
710    %4 = add <2 x i64> %3, %3
711    store <2 x i64> %4, <2 x i64>* %q
712    ret void
713}
714
715; CHECK-LABEL: test_v2i64_v2f64:
716define void @test_v2i64_v2f64(<2 x double>* %p, <2 x i64>* %q) {
717; CHECK: ld1 { v{{[0-9]+}}.2d }
718; CHECK: st1 { v{{[0-9]+}}.2d }
719    %1 = load <2 x double>, <2 x double>* %p
720    %2 = fadd <2 x double> %1, %1
721    %3 = bitcast <2 x double> %2 to <2 x i64>
722    %4 = add <2 x i64> %3, %3
723    store <2 x i64> %4, <2 x i64>* %q
724    ret void
725}
726
727; CHECK-LABEL: test_v2i64_v4f32:
728define void @test_v2i64_v4f32(<4 x float>* %p, <2 x i64>* %q) {
729; CHECK: ld1 { v{{[0-9]+}}.2d }
730; CHECK: rev64 v{{[0-9]+}}.4s
731; CHECK: rev64 v{{[0-9]+}}.4s
732; CHECK: st1 { v{{[0-9]+}}.2d }
733    %1 = load <4 x float>, <4 x float>* %p
734    %2 = fadd <4 x float> %1, %1
735    %3 = bitcast <4 x float> %2 to <2 x i64>
736    %4 = add <2 x i64> %3, %3
737    store <2 x i64> %4, <2 x i64>* %q
738    ret void
739}
740
741; CHECK-LABEL: test_v2i64_v4i32:
742define void @test_v2i64_v4i32(<4 x i32>* %p, <2 x i64>* %q) {
743; CHECK: ld1 { v{{[0-9]+}}.4s }
744; CHECK: rev64 v{{[0-9]+}}.4s
745; CHECK: st1 { v{{[0-9]+}}.2d }
746    %1 = load <4 x i32>, <4 x i32>* %p
747    %2 = add <4 x i32> %1, %1
748    %3 = bitcast <4 x i32> %2 to <2 x i64>
749    %4 = add <2 x i64> %3, %3
750    store <2 x i64> %4, <2 x i64>* %q
751    ret void
752}
753
754; CHECK-LABEL: test_v2i64_v8i16:
755define void @test_v2i64_v8i16(<8 x i16>* %p, <2 x i64>* %q) {
756; CHECK: ld1 { v{{[0-9]+}}.8h }
757; CHECK: rev64 v{{[0-9]+}}.8h
758; CHECK: st1 { v{{[0-9]+}}.2d }
759    %1 = load <8 x i16>, <8 x i16>* %p
760    %2 = add <8 x i16> %1, %1
761    %3 = bitcast <8 x i16> %2 to <2 x i64>
762    %4 = add <2 x i64> %3, %3
763    store <2 x i64> %4, <2 x i64>* %q
764    ret void
765}
766
767; CHECK-LABEL: test_v2i64_v16i8:
768define void @test_v2i64_v16i8(<16 x i8>* %p, <2 x i64>* %q) {
769; CHECK: ld1 { v{{[0-9]+}}.16b }
770; CHECK: rev64 v{{[0-9]+}}.16b
771; CHECK: st1 { v{{[0-9]+}}.2d }
772    %1 = load <16 x i8>, <16 x i8>* %p
773    %2 = add <16 x i8> %1, %1
774    %3 = bitcast <16 x i8> %2 to <2 x i64>
775    %4 = add <2 x i64> %3, %3
776    store <2 x i64> %4, <2 x i64>* %q
777    ret void
778}
779
780; CHECK-LABEL: test_v4f32_f128:
781define void @test_v4f32_f128(fp128* %p, <4 x float>* %q) {
782; CHECK: ldr q
783; CHECK: rev64 v{{[0-9]+}}.4s
784; CHECK: ext
785; CHECK: rev64 v{{[0-9]+}}.4s
786; CHECK: st1 { v{{[0-9]+}}.2d }
787    %1 = load fp128, fp128* %p
788    %2 = fadd fp128 %1, %1
789    %3 = bitcast fp128 %2 to <4 x float>
790    %4 = fadd <4 x float> %3, %3
791    store <4 x float> %4, <4 x float>* %q
792    ret void
793}
794
795; CHECK-LABEL: test_v4f32_v2f64:
796define void @test_v4f32_v2f64(<2 x double>* %p, <4 x float>* %q) {
797; CHECK: ld1 { v{{[0-9]+}}.2d }
798; CHECK: rev64 v{{[0-9]+}}.4s
799; CHECK: rev64 v{{[0-9]+}}.4s
800; CHECK: st1 { v{{[0-9]+}}.2d }
801    %1 = load <2 x double>, <2 x double>* %p
802    %2 = fadd <2 x double> %1, %1
803    %3 = bitcast <2 x double> %2 to <4 x float>
804    %4 = fadd <4 x float> %3, %3
805    store <4 x float> %4, <4 x float>* %q
806    ret void
807}
808
809; CHECK-LABEL: test_v4f32_v2i64:
810define void @test_v4f32_v2i64(<2 x i64>* %p, <4 x float>* %q) {
811; CHECK: ld1 { v{{[0-9]+}}.2d }
812; CHECK: rev64 v{{[0-9]+}}.4s
813; CHECK: rev64 v{{[0-9]+}}.4s
814; CHECK: st1 { v{{[0-9]+}}.2d }
815    %1 = load <2 x i64>, <2 x i64>* %p
816    %2 = add <2 x i64> %1, %1
817    %3 = bitcast <2 x i64> %2 to <4 x float>
818    %4 = fadd <4 x float> %3, %3
819    store <4 x float> %4, <4 x float>* %q
820    ret void
821}
822
823; CHECK-LABEL: test_v4f32_v4i32:
824define void @test_v4f32_v4i32(<4 x i32>* %p, <4 x float>* %q) {
825; CHECK: ld1 { v{{[0-9]+}}.4s }
826; CHECK: rev64 v{{[0-9]+}}.4s
827; CHECK: st1 { v{{[0-9]+}}.2d }
828    %1 = load <4 x i32>, <4 x i32>* %p
829    %2 = add <4 x i32> %1, %1
830    %3 = bitcast <4 x i32> %2 to <4 x float>
831    %4 = fadd <4 x float> %3, %3
832    store <4 x float> %4, <4 x float>* %q
833    ret void
834}
835
836; CHECK-LABEL: test_v4f32_v8i16:
837define void @test_v4f32_v8i16(<8 x i16>* %p, <4 x float>* %q) {
838; CHECK: ld1 { v{{[0-9]+}}.8h }
839; CHECK: rev32 v{{[0-9]+}}.8h
840; CHECK: rev64 v{{[0-9]+}}.4s
841; CHECK: st1 { v{{[0-9]+}}.2d }
842    %1 = load <8 x i16>, <8 x i16>* %p
843    %2 = add <8 x i16> %1, %1
844    %3 = bitcast <8 x i16> %2 to <4 x float>
845    %4 = fadd <4 x float> %3, %3
846    store <4 x float> %4, <4 x float>* %q
847    ret void
848}
849
850; CHECK-LABEL: test_v4f32_v16i8:
851define void @test_v4f32_v16i8(<16 x i8>* %p, <4 x float>* %q) {
852; CHECK: ld1 { v{{[0-9]+}}.16b }
853; CHECK: rev32 v{{[0-9]+}}.16b
854; CHECK: rev64 v{{[0-9]+}}.4s
855; CHECK: st1 { v{{[0-9]+}}.2d }
856    %1 = load <16 x i8>, <16 x i8>* %p
857    %2 = add <16 x i8> %1, %1
858    %3 = bitcast <16 x i8> %2 to <4 x float>
859    %4 = fadd <4 x float> %3, %3
860    store <4 x float> %4, <4 x float>* %q
861    ret void
862}
863
864; CHECK-LABEL: test_v4i32_f128:
865define void @test_v4i32_f128(fp128* %p, <4 x i32>* %q) {
866; CHECK: ldr
867; CHECK: rev64 v{{[0-9]+}}.4s
868; CHECK: ext
869; CHECK: st1 { v{{[0-9]+}}.4s }
870    %1 = load fp128, fp128* %p
871    %2 = fadd fp128 %1, %1
872    %3 = bitcast fp128 %2 to <4 x i32>
873    %4 = add <4 x i32> %3, %3
874    store <4 x i32> %4, <4 x i32>* %q
875    ret void
876}
877
878; CHECK-LABEL: test_v4i32_v2f64:
879define void @test_v4i32_v2f64(<2 x double>* %p, <4 x i32>* %q) {
880; CHECK: ld1 { v{{[0-9]+}}.2d }
881; CHECK: rev64 v{{[0-9]+}}.4s
882; CHECK: st1 { v{{[0-9]+}}.4s }
883    %1 = load <2 x double>, <2 x double>* %p
884    %2 = fadd <2 x double> %1, %1
885    %3 = bitcast <2 x double> %2 to <4 x i32>
886    %4 = add <4 x i32> %3, %3
887    store <4 x i32> %4, <4 x i32>* %q
888    ret void
889}
890
891; CHECK-LABEL: test_v4i32_v2i64:
892define void @test_v4i32_v2i64(<2 x i64>* %p, <4 x i32>* %q) {
893; CHECK: ld1 { v{{[0-9]+}}.2d }
894; CHECK: rev64 v{{[0-9]+}}.4s
895; CHECK: st1 { v{{[0-9]+}}.4s }
896    %1 = load <2 x i64>, <2 x i64>* %p
897    %2 = add <2 x i64> %1, %1
898    %3 = bitcast <2 x i64> %2 to <4 x i32>
899    %4 = add <4 x i32> %3, %3
900    store <4 x i32> %4, <4 x i32>* %q
901    ret void
902}
903
904; CHECK-LABEL: test_v4i32_v4f32:
905define void @test_v4i32_v4f32(<4 x float>* %p, <4 x i32>* %q) {
906; CHECK: ld1 { v{{[0-9]+}}.2d }
907; CHECK: rev64 v{{[0-9]+}}.4s
908; CHECK: st1 { v{{[0-9]+}}.4s }
909    %1 = load <4 x float>, <4 x float>* %p
910    %2 = fadd <4 x float> %1, %1
911    %3 = bitcast <4 x float> %2 to <4 x i32>
912    %4 = add <4 x i32> %3, %3
913    store <4 x i32> %4, <4 x i32>* %q
914    ret void
915}
916
917; CHECK-LABEL: test_v4i32_v8i16:
918define void @test_v4i32_v8i16(<8 x i16>* %p, <4 x i32>* %q) {
919; CHECK: ld1 { v{{[0-9]+}}.8h }
920; CHECK: rev32 v{{[0-9]+}}.8h
921; CHECK: st1 { v{{[0-9]+}}.4s }
922    %1 = load <8 x i16>, <8 x i16>* %p
923    %2 = add <8 x i16> %1, %1
924    %3 = bitcast <8 x i16> %2 to <4 x i32>
925    %4 = add <4 x i32> %3, %3
926    store <4 x i32> %4, <4 x i32>* %q
927    ret void
928}
929
930; CHECK-LABEL: test_v4i32_v16i8:
931define void @test_v4i32_v16i8(<16 x i8>* %p, <4 x i32>* %q) {
932; CHECK: ld1 { v{{[0-9]+}}.16b }
933; CHECK: rev32 v{{[0-9]+}}.16b
934; CHECK: st1 { v{{[0-9]+}}.4s }
935    %1 = load <16 x i8>, <16 x i8>* %p
936    %2 = add <16 x i8> %1, %1
937    %3 = bitcast <16 x i8> %2 to <4 x i32>
938    %4 = add <4 x i32> %3, %3
939    store <4 x i32> %4, <4 x i32>* %q
940    ret void
941}
942
943; CHECK-LABEL: test_v8i16_f128:
944define void @test_v8i16_f128(fp128* %p, <8 x i16>* %q) {
945; CHECK: ldr
946; CHECK: rev64 v{{[0-9]+}}.8h
947; CHECK: ext
948; CHECK: st1 { v{{[0-9]+}}.8h }
949    %1 = load fp128, fp128* %p
950    %2 = fadd fp128 %1, %1
951    %3 = bitcast fp128 %2 to <8 x i16>
952    %4 = add <8 x i16> %3, %3
953    store <8 x i16> %4, <8 x i16>* %q
954    ret void
955}
956
957; CHECK-LABEL: test_v8i16_v2f64:
958define void @test_v8i16_v2f64(<2 x double>* %p, <8 x i16>* %q) {
959; CHECK: ld1 { v{{[0-9]+}}.2d }
960; CHECK: rev64 v{{[0-9]+}}.8h
961; CHECK: st1 { v{{[0-9]+}}.8h }
962    %1 = load <2 x double>, <2 x double>* %p
963    %2 = fadd <2 x double> %1, %1
964    %3 = bitcast <2 x double> %2 to <8 x i16>
965    %4 = add <8 x i16> %3, %3
966    store <8 x i16> %4, <8 x i16>* %q
967    ret void
968}
969
970; CHECK-LABEL: test_v8i16_v2i64:
971define void @test_v8i16_v2i64(<2 x i64>* %p, <8 x i16>* %q) {
972; CHECK: ld1 { v{{[0-9]+}}.2d }
973; CHECK: rev64 v{{[0-9]+}}.8h
974; CHECK: st1 { v{{[0-9]+}}.8h }
975    %1 = load <2 x i64>, <2 x i64>* %p
976    %2 = add <2 x i64> %1, %1
977    %3 = bitcast <2 x i64> %2 to <8 x i16>
978    %4 = add <8 x i16> %3, %3
979    store <8 x i16> %4, <8 x i16>* %q
980    ret void
981}
982
983; CHECK-LABEL: test_v8i16_v4f32:
984define void @test_v8i16_v4f32(<4 x float>* %p, <8 x i16>* %q) {
985; CHECK: ld1 { v{{[0-9]+}}.2d }
986; CHECK: rev64 v{{[0-9]+}}.4s
987; CHECK: rev32 v{{[0-9]+}}.8h
988; CHECK: st1 { v{{[0-9]+}}.8h }
989    %1 = load <4 x float>, <4 x float>* %p
990    %2 = fadd <4 x float> %1, %1
991    %3 = bitcast <4 x float> %2 to <8 x i16>
992    %4 = add <8 x i16> %3, %3
993    store <8 x i16> %4, <8 x i16>* %q
994    ret void
995}
996
997; CHECK-LABEL: test_v8i16_v4i32:
998define void @test_v8i16_v4i32(<4 x i32>* %p, <8 x i16>* %q) {
999; CHECK: ld1 { v{{[0-9]+}}.4s }
1000; CHECK: rev32 v{{[0-9]+}}.8h
1001; CHECK: st1 { v{{[0-9]+}}.8h }
1002    %1 = load <4 x i32>, <4 x i32>* %p
1003    %2 = add <4 x i32> %1, %1
1004    %3 = bitcast <4 x i32> %2 to <8 x i16>
1005    %4 = add <8 x i16> %3, %3
1006    store <8 x i16> %4, <8 x i16>* %q
1007    ret void
1008}
1009
1010; CHECK-LABEL: test_v8i16_v16i8:
1011define void @test_v8i16_v16i8(<16 x i8>* %p, <8 x i16>* %q) {
1012; CHECK: ld1 { v{{[0-9]+}}.16b }
1013; CHECK: rev16 v{{[0-9]+}}.16b
1014; CHECK: st1 { v{{[0-9]+}}.8h }
1015    %1 = load <16 x i8>, <16 x i8>* %p
1016    %2 = add <16 x i8> %1, %1
1017    %3 = bitcast <16 x i8> %2 to <8 x i16>
1018    %4 = add <8 x i16> %3, %3
1019    store <8 x i16> %4, <8 x i16>* %q
1020    ret void
1021}
1022
1023; CHECK-LABEL: test_v16i8_f128:
1024define void @test_v16i8_f128(fp128* %p, <16 x i8>* %q) {
1025; CHECK: ldr q
1026; CHECK: rev64 v{{[0-9]+}}.16b
1027; CHECK: ext
1028; CHECK: st1 { v{{[0-9]+}}.16b }
1029    %1 = load fp128, fp128* %p
1030    %2 = fadd fp128 %1, %1
1031    %3 = bitcast fp128 %2 to <16 x i8>
1032    %4 = add <16 x i8> %3, %3
1033    store <16 x i8> %4, <16 x i8>* %q
1034    ret void
1035}
1036
1037; CHECK-LABEL: test_v16i8_v2f64:
1038define void @test_v16i8_v2f64(<2 x double>* %p, <16 x i8>* %q) {
1039; CHECK: ld1 { v{{[0-9]+}}.2d }
1040; CHECK: rev64 v{{[0-9]+}}.16b
1041; CHECK: st1 { v{{[0-9]+}}.16b }
1042    %1 = load <2 x double>, <2 x double>* %p
1043    %2 = fadd <2 x double> %1, %1
1044    %3 = bitcast <2 x double> %2 to <16 x i8>
1045    %4 = add <16 x i8> %3, %3
1046    store <16 x i8> %4, <16 x i8>* %q
1047    ret void
1048}
1049
1050; CHECK-LABEL: test_v16i8_v2i64:
1051define void @test_v16i8_v2i64(<2 x i64>* %p, <16 x i8>* %q) {
1052; CHECK: ld1 { v{{[0-9]+}}.2d }
1053; CHECK: rev64 v{{[0-9]+}}.16b
1054; CHECK: st1 { v{{[0-9]+}}.16b }
1055    %1 = load <2 x i64>, <2 x i64>* %p
1056    %2 = add <2 x i64> %1, %1
1057    %3 = bitcast <2 x i64> %2 to <16 x i8>
1058    %4 = add <16 x i8> %3, %3
1059    store <16 x i8> %4, <16 x i8>* %q
1060    ret void
1061}
1062
1063; CHECK-LABEL: test_v16i8_v4f32:
1064define void @test_v16i8_v4f32(<4 x float>* %p, <16 x i8>* %q) {
1065; CHECK: ld1 { v{{[0-9]+}}.2d }
1066; CHECK: rev64 v{{[0-9]+}}.4s
1067; CHECK: rev32 v{{[0-9]+}}.16b
1068; CHECK: st1 { v{{[0-9]+}}.16b }
1069    %1 = load <4 x float>, <4 x float>* %p
1070    %2 = fadd <4 x float> %1, %1
1071    %3 = bitcast <4 x float> %2 to <16 x i8>
1072    %4 = add <16 x i8> %3, %3
1073    store <16 x i8> %4, <16 x i8>* %q
1074    ret void
1075}
1076
1077; CHECK-LABEL: test_v16i8_v4i32:
1078define void @test_v16i8_v4i32(<4 x i32>* %p, <16 x i8>* %q) {
1079; CHECK: ld1 { v{{[0-9]+}}.4s }
1080; CHECK: rev32 v{{[0-9]+}}.16b
1081; CHECK: st1 { v{{[0-9]+}}.16b }
1082    %1 = load <4 x i32>, <4 x i32>* %p
1083    %2 = add <4 x i32> %1, %1
1084    %3 = bitcast <4 x i32> %2 to <16 x i8>
1085    %4 = add <16 x i8> %3, %3
1086    store <16 x i8> %4, <16 x i8>* %q
1087    ret void
1088}
1089
1090; CHECK-LABEL: test_v16i8_v8i16:
1091define void @test_v16i8_v8i16(<8 x i16>* %p, <16 x i8>* %q) {
1092; CHECK: ld1 { v{{[0-9]+}}.8h }
1093; CHECK: rev16 v{{[0-9]+}}.16b
1094; CHECK: st1 { v{{[0-9]+}}.16b }
1095    %1 = load <8 x i16>, <8 x i16>* %p
1096    %2 = add <8 x i16> %1, %1
1097    %3 = bitcast <8 x i16> %2 to <16 x i8>
1098    %4 = add <16 x i8> %3, %3
1099    store <16 x i8> %4, <16 x i8>* %q
1100    ret void
1101}
Note: See TracBrowser for help on using the repository browser.