[InstCombine] Signed saturation patterns
[llvm-complete.git] / test / CodeGen / AArch64 / arm64-big-endian-bitconverts.ll
blob5cd96d09b14d0fde3b68854568a35931af09dae8
1 ; RUN: llc -mtriple aarch64_be < %s -aarch64-enable-ldst-opt=false -O1 -o - | FileCheck %s
2 ; RUN: llc -mtriple aarch64_be < %s -aarch64-enable-ldst-opt=false -O0 -fast-isel=true -o - | FileCheck %s
4 ; CHECK-LABEL: test_i64_f64:
5 define 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
16 ; CHECK-LABEL: test_i64_v1i64:
17 define 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
28 ; CHECK-LABEL: test_i64_v2f32:
29 define 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
41 ; CHECK-LABEL: test_i64_v2i32:
42 define 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
54 ; CHECK-LABEL: test_i64_v4f16:
55 define void @test_i64_v4f16(<4 x half>* %p, i64* %q) {
56 ; CHECK: ld1 { v{{[0-9]+}}.4h }
57 ; CHECK-NOT: rev
58 ; CHECK: fadd
59 ; CHECK: rev64 v{{[0-9]+}}.4h
60 ; CHECK: str
61     %1 = load <4 x half>, <4 x half>* %p
62     %2 = fadd <4 x half> %1, %1
63     %3 = bitcast <4 x half> %2 to i64
64     %4 = add i64 %3, %3
65     store i64 %4, i64* %q
66     ret void
69 ; CHECK-LABEL: test_i64_v4i16:
70 define void @test_i64_v4i16(<4 x i16>* %p, i64* %q) {
71 ; CHECK: ld1 { v{{[0-9]+}}.4h }
72 ; CHECK: rev64 v{{[0-9]+}}.4h
73 ; CHECK: str
74     %1 = load <4 x i16>, <4 x i16>* %p
75     %2 = add <4 x i16> %1, %1
76     %3 = bitcast <4 x i16> %2 to i64
77     %4 = add i64 %3, %3
78     store i64 %4, i64* %q
79     ret void
82 ; CHECK-LABEL: test_i64_v8i8:
83 define void @test_i64_v8i8(<8 x i8>* %p, i64* %q) {
84 ; CHECK: ld1 { v{{[0-9]+}}.8b }
85 ; CHECK: rev64 v{{[0-9]+}}.8b
86 ; CHECK: str
87     %1 = load <8 x i8>, <8 x i8>* %p
88     %2 = add <8 x i8> %1, %1
89     %3 = bitcast <8 x i8> %2 to i64
90     %4 = add i64 %3, %3
91     store i64 %4, i64* %q
92     ret void
95 ; CHECK-LABEL: test_f64_i64:
96 define void @test_f64_i64(i64* %p, double* %q) {
97 ; CHECK: ldr
98 ; CHECK: str
99     %1 = load i64, i64* %p
100     %2 = add i64 %1, %1
101     %3 = bitcast i64 %2 to double
102     %4 = fadd double %3, %3
103     store double %4, double* %q
104     ret void
107 ; CHECK-LABEL: test_f64_v1i64:
108 define void @test_f64_v1i64(<1 x i64>* %p, double* %q) {
109 ; CHECK: ldr
110 ; CHECK: str
111     %1 = load <1 x i64>, <1 x i64>* %p
112     %2 = add <1 x i64> %1, %1
113     %3 = bitcast <1 x i64> %2 to double
114     %4 = fadd double %3, %3
115     store double %4, double* %q
116     ret void
119 ; CHECK-LABEL: test_f64_v2f32:
120 define void @test_f64_v2f32(<2 x float>* %p, double* %q) {
121 ; CHECK: ld1 { v{{[0-9]+}}.2s }
122 ; CHECK: rev64 v{{[0-9]+}}.2s
123 ; CHECK: str
124     %1 = load <2 x float>, <2 x float>* %p
125     %2 = fadd <2 x float> %1, %1
126     %3 = bitcast <2 x float> %2 to double
127     %4 = fadd double %3, %3
128     store double %4, double* %q
129     ret void
132 ; CHECK-LABEL: test_f64_v2i32:
133 define void @test_f64_v2i32(<2 x i32>* %p, double* %q) {
134 ; CHECK: ld1 { v{{[0-9]+}}.2s }
135 ; CHECK: rev64 v{{[0-9]+}}.2s
136 ; CHECK: str
137     %1 = load <2 x i32>, <2 x i32>* %p
138     %2 = add <2 x i32> %1, %1
139     %3 = bitcast <2 x i32> %2 to double
140     %4 = fadd double %3, %3
141     store double %4, double* %q
142     ret void
145 ; CHECK-LABEL: test_f64_v4i16:
146 define void @test_f64_v4i16(<4 x i16>* %p, double* %q) {
147 ; CHECK: ld1 { v{{[0-9]+}}.4h }
148 ; CHECK: rev64 v{{[0-9]+}}.4h
149 ; CHECK: str
150     %1 = load <4 x i16>, <4 x i16>* %p
151     %2 = add <4 x i16> %1, %1
152     %3 = bitcast <4 x i16> %2 to double
153     %4 = fadd double %3, %3
154     store double %4, double* %q
155     ret void
158 ; CHECK-LABEL: test_f64_v4f16:
159 define void @test_f64_v4f16(<4 x half>* %p, double* %q) {
160 ; CHECK: ld1 { v{{[0-9]+}}.4h }
161 ; CHECK-NOT: rev
162 ; CHECK: fadd
163 ; CHECK: rev64 v{{[0-9]+}}.4h
164 ; CHECK: fadd
165 ; CHECK: str
166     %1 = load <4 x half>, <4 x half>* %p
167     %2 = fadd <4 x half> %1, %1
168     %3 = bitcast <4 x half> %2 to double
169     %4 = fadd double %3, %3
170     store double %4, double* %q
171     ret void
174 ; CHECK-LABEL: test_f64_v8i8:
175 define void @test_f64_v8i8(<8 x i8>* %p, double* %q) {
176 ; CHECK: ld1 { v{{[0-9]+}}.8b }
177 ; CHECK: rev64 v{{[0-9]+}}.8b
178 ; CHECK: str
179     %1 = load <8 x i8>, <8 x i8>* %p
180     %2 = add <8 x i8> %1, %1
181     %3 = bitcast <8 x i8> %2 to double
182     %4 = fadd double %3, %3
183     store double %4, double* %q
184     ret void
187 ; CHECK-LABEL: test_v1i64_i64:
188 define void @test_v1i64_i64(i64* %p, <1 x i64>* %q) {
189 ; CHECK: ldr
190 ; CHECK: str
191     %1 = load i64, i64* %p
192     %2 = add i64 %1, %1
193     %3 = bitcast i64 %2 to <1 x i64>
194     %4 = add <1 x i64> %3, %3
195     store <1 x i64> %4, <1 x i64>* %q
196     ret void
199 ; CHECK-LABEL: test_v1i64_f64:
200 define void @test_v1i64_f64(double* %p, <1 x i64>* %q) {
201 ; CHECK: ldr
202 ; CHECK: str
203     %1 = load double, double* %p
204     %2 = fadd double %1, %1
205     %3 = bitcast double %2 to <1 x i64>
206     %4 = add <1 x i64> %3, %3
207     store <1 x i64> %4, <1 x i64>* %q
208     ret void
211 ; CHECK-LABEL: test_v1i64_v2f32:
212 define void @test_v1i64_v2f32(<2 x float>* %p, <1 x i64>* %q) {
213 ; CHECK: ld1 { v{{[0-9]+}}.2s }
214 ; CHECK: rev64 v{{[0-9]+}}.2s
215 ; CHECK: str
216     %1 = load <2 x float>, <2 x float>* %p
217     %2 = fadd <2 x float> %1, %1
218     %3 = bitcast <2 x float> %2 to <1 x i64>
219     %4 = add <1 x i64> %3, %3
220     store <1 x i64> %4, <1 x i64>* %q
221     ret void
224 ; CHECK-LABEL: test_v1i64_v2i32:
225 define void @test_v1i64_v2i32(<2 x i32>* %p, <1 x i64>* %q) {
226 ; CHECK: ld1 { v{{[0-9]+}}.2s }
227 ; CHECK: rev64 v{{[0-9]+}}.2s
228 ; CHECK: str
229     %1 = load <2 x i32>, <2 x i32>* %p
230     %2 = add <2 x i32> %1, %1
231     %3 = bitcast <2 x i32> %2 to <1 x i64>
232     %4 = add <1 x i64> %3, %3
233     store <1 x i64> %4, <1 x i64>* %q
234     ret void
237 ; CHECK-LABEL: test_v1i64_v4f16:
238 define void @test_v1i64_v4f16(<4 x half>* %p, <1 x i64>* %q) {
239 ; CHECK: ld1 { v{{[0-9]+}}.4h }
240 ; CHECK-NOT: rev
241 ; CHECK: fadd
242 ; CHECK: rev64 v{{[0-9]+}}.4h
243 ; CHECK: str
244     %1 = load <4 x half>, <4 x half>* %p
245     %2 = fadd <4 x half> %1, %1
246     %3 = bitcast <4 x half> %2 to <1 x i64>
247     %4 = add <1 x i64> %3, %3
248     store <1 x i64> %4, <1 x i64>* %q
249     ret void
252 ; CHECK-LABEL: test_v1i64_v4i16:
253 define void @test_v1i64_v4i16(<4 x i16>* %p, <1 x i64>* %q) {
254 ; CHECK: ld1 { v{{[0-9]+}}.4h }
255 ; CHECK: rev64 v{{[0-9]+}}.4h
256 ; CHECK: str
257     %1 = load <4 x i16>, <4 x i16>* %p
258     %2 = add <4 x i16> %1, %1
259     %3 = bitcast <4 x i16> %2 to <1 x i64>
260     %4 = add <1 x i64> %3, %3
261     store <1 x i64> %4, <1 x i64>* %q
262     ret void
265 ; CHECK-LABEL: test_v1i64_v8i8:
266 define void @test_v1i64_v8i8(<8 x i8>* %p, <1 x i64>* %q) {
267 ; CHECK: ld1 { v{{[0-9]+}}.8b }
268 ; CHECK: rev64 v{{[0-9]+}}.8b
269 ; CHECK: str
270     %1 = load <8 x i8>, <8 x i8>* %p
271     %2 = add <8 x i8> %1, %1
272     %3 = bitcast <8 x i8> %2 to <1 x i64>
273     %4 = add <1 x i64> %3, %3
274     store <1 x i64> %4, <1 x i64>* %q
275     ret void
278 ; CHECK-LABEL: test_v2f32_i64:
279 define void @test_v2f32_i64(i64* %p, <2 x float>* %q) {
280 ; CHECK: ldr
281 ; CHECK: rev64 v{{[0-9]+}}.2s
282 ; CHECK: st1 { v{{[0-9]+}}.2s }
283     %1 = load i64, i64* %p
284     %2 = add i64 %1, %1
285     %3 = bitcast i64 %2 to <2 x float>
286     %4 = fadd <2 x float> %3, %3
287     store <2 x float> %4, <2 x float>* %q
288     ret void
291 ; CHECK-LABEL: test_v2f32_f64:
292 define void @test_v2f32_f64(double* %p, <2 x float>* %q) {
293 ; CHECK: ldr
294 ; CHECK: rev64 v{{[0-9]+}}.2s
295 ; CHECK: st1 { v{{[0-9]+}}.2s }
296     %1 = load double, double* %p
297     %2 = fadd double %1, %1
298     %3 = bitcast double %2 to <2 x float>
299     %4 = fadd <2 x float> %3, %3
300     store <2 x float> %4, <2 x float>* %q
301     ret void
304 ; CHECK-LABEL: test_v2f32_v1i64:
305 define void @test_v2f32_v1i64(<1 x i64>* %p, <2 x float>* %q) {
306 ; CHECK: ldr
307 ; CHECK: rev64 v{{[0-9]+}}.2s
308 ; CHECK: st1 { v{{[0-9]+}}.2s }
309     %1 = load <1 x i64>, <1 x i64>* %p
310     %2 = add <1 x i64> %1, %1
311     %3 = bitcast <1 x i64> %2 to <2 x float>
312     %4 = fadd <2 x float> %3, %3
313     store <2 x float> %4, <2 x float>* %q
314     ret void
317 ; CHECK-LABEL: test_v2f32_v2i32:
318 define void @test_v2f32_v2i32(<2 x i32>* %p, <2 x float>* %q) {
319 ; CHECK: ld1 { v{{[0-9]+}}.2s }
320 ; CHECK: st1 { v{{[0-9]+}}.2s }
321     %1 = load <2 x i32>, <2 x i32>* %p
322     %2 = add <2 x i32> %1, %1
323     %3 = bitcast <2 x i32> %2 to <2 x float>
324     %4 = fadd <2 x float> %3, %3
325     store <2 x float> %4, <2 x float>* %q
326     ret void
329 ; CHECK-LABEL: test_v2f32_v4i16:
330 define void @test_v2f32_v4i16(<4 x i16>* %p, <2 x float>* %q) {
331 ; CHECK: ld1 { v{{[0-9]+}}.4h }
332 ; CHECK: rev32 v{{[0-9]+}}.4h
333 ; CHECK: st1 { v{{[0-9]+}}.2s }
334     %1 = load <4 x i16>, <4 x i16>* %p
335     %2 = add <4 x i16> %1, %1
336     %3 = bitcast <4 x i16> %2 to <2 x float>
337     %4 = fadd <2 x float> %3, %3
338     store <2 x float> %4, <2 x float>* %q
339     ret void
342 ; CHECK-LABEL: test_v2f32_v4f16:
343 define void @test_v2f32_v4f16(<4 x half>* %p, <2 x float>* %q) {
344 ; CHECK: ld1 { v{{[0-9]+}}.4h }
345 ; CHECK-NOT: rev
346 ; CHECK: fadd
347 ; CHECK: rev32 v{{[0-9]+}}.4h
348 ; CHECK: st1 { v{{[0-9]+}}.2s }
349     %1 = load <4 x half>, <4 x half>* %p
350     %2 = fadd <4 x half> %1, %1
351     %3 = bitcast <4 x half> %2 to <2 x float>
352     %4 = fadd <2 x float> %3, %3
353     store <2 x float> %4, <2 x float>* %q
354     ret void
357 ; CHECK-LABEL: test_v2f32_v8i8:
358 define void @test_v2f32_v8i8(<8 x i8>* %p, <2 x float>* %q) {
359 ; CHECK: ld1 { v{{[0-9]+}}.8b }
360 ; CHECK: rev32 v{{[0-9]+}}.8b
361 ; CHECK: st1 { v{{[0-9]+}}.2s }
362     %1 = load <8 x i8>, <8 x i8>* %p
363     %2 = add <8 x i8> %1, %1
364     %3 = bitcast <8 x i8> %2 to <2 x float>
365     %4 = fadd <2 x float> %3, %3
366     store <2 x float> %4, <2 x float>* %q
367     ret void
370 ; CHECK-LABEL: test_v2i32_i64:
371 define void @test_v2i32_i64(i64* %p, <2 x i32>* %q) {
372 ; CHECK: ldr
373 ; CHECK: rev64 v{{[0-9]+}}.2s
374 ; CHECK: st1 { v{{[0-9]+}}.2s }
375     %1 = load i64, i64* %p
376     %2 = add i64 %1, %1
377     %3 = bitcast i64 %2 to <2 x i32>
378     %4 = add <2 x i32> %3, %3
379     store <2 x i32> %4, <2 x i32>* %q
380     ret void
383 ; CHECK-LABEL: test_v2i32_f64:
384 define void @test_v2i32_f64(double* %p, <2 x i32>* %q) {
385 ; CHECK: ldr
386 ; CHECK: rev64 v{{[0-9]+}}.2s
387 ; CHECK: st1 { v{{[0-9]+}}.2s }
388     %1 = load double, double* %p
389     %2 = fadd double %1, %1
390     %3 = bitcast double %2 to <2 x i32>
391     %4 = add <2 x i32> %3, %3
392     store <2 x i32> %4, <2 x i32>* %q
393     ret void
396 ; CHECK-LABEL: test_v2i32_v1i64:
397 define void @test_v2i32_v1i64(<1 x i64>* %p, <2 x i32>* %q) {
398 ; CHECK: ldr
399 ; CHECK: rev64 v{{[0-9]+}}.2s
400 ; CHECK: st1 { v{{[0-9]+}}.2s }
401     %1 = load <1 x i64>, <1 x i64>* %p
402     %2 = add <1 x i64> %1, %1
403     %3 = bitcast <1 x i64> %2 to <2 x i32>
404     %4 = add <2 x i32> %3, %3
405     store <2 x i32> %4, <2 x i32>* %q
406     ret void
409 ; CHECK-LABEL: test_v2i32_v2f32:
410 define void @test_v2i32_v2f32(<2 x float>* %p, <2 x i32>* %q) {
411 ; CHECK: ld1 { v{{[0-9]+}}.2s }
412 ; CHECK: st1 { v{{[0-9]+}}.2s }
413     %1 = load <2 x float>, <2 x float>* %p
414     %2 = fadd <2 x float> %1, %1
415     %3 = bitcast <2 x float> %2 to <2 x i32>
416     %4 = add <2 x i32> %3, %3
417     store <2 x i32> %4, <2 x i32>* %q
418     ret void
421 ; CHECK-LABEL: test_v2i32_v4i16:
422 define void @test_v2i32_v4i16(<4 x i16>* %p, <2 x i32>* %q) {
423 ; CHECK: ld1 { v{{[0-9]+}}.4h }
424 ; CHECK: rev32 v{{[0-9]+}}.4h
425 ; CHECK: st1 { v{{[0-9]+}}.2s }
426     %1 = load <4 x i16>, <4 x i16>* %p
427     %2 = add <4 x i16> %1, %1
428     %3 = bitcast <4 x i16> %2 to <2 x i32>
429     %4 = add <2 x i32> %3, %3
430     store <2 x i32> %4, <2 x i32>* %q
431     ret void
434 ; CHECK-LABEL: test_v2i32_v8i8:
435 define void @test_v2i32_v8i8(<8 x i8>* %p, <2 x i32>* %q) {
436 ; CHECK: ld1 { v{{[0-9]+}}.8b }
437 ; CHECK: rev32 v{{[0-9]+}}.8b
438 ; CHECK: st1 { v{{[0-9]+}}.2s }
439     %1 = load <8 x i8>, <8 x i8>* %p
440     %2 = add <8 x i8> %1, %1
441     %3 = bitcast <8 x i8> %2 to <2 x i32>
442     %4 = add <2 x i32> %3, %3
443     store <2 x i32> %4, <2 x i32>* %q
444     ret void
447 ; CHECK-LABEL: test_v4i16_i64:
448 define void @test_v4i16_i64(i64* %p, <4 x i16>* %q) {
449 ; CHECK: ldr
450 ; CHECK: rev64 v{{[0-9]+}}.4h
451 ; CHECK: st1 { v{{[0-9]+}}.4h }
452     %1 = load i64, i64* %p
453     %2 = add i64 %1, %1
454     %3 = bitcast i64 %2 to <4 x i16>
455     %4 = add <4 x i16> %3, %3
456     store <4 x i16> %4, <4 x i16>* %q
457     ret void
460 ; CHECK-LABEL: test_v4i16_f64:
461 define void @test_v4i16_f64(double* %p, <4 x i16>* %q) {
462 ; CHECK: ldr
463 ; CHECK: rev64 v{{[0-9]+}}.4h
464 ; CHECK: st1 { v{{[0-9]+}}.4h }
465     %1 = load double, double* %p
466     %2 = fadd double %1, %1
467     %3 = bitcast double %2 to <4 x i16>
468     %4 = add <4 x i16> %3, %3
469     store <4 x i16> %4, <4 x i16>* %q
470     ret void
473 ; CHECK-LABEL: test_v4i16_v1i64:
474 define void @test_v4i16_v1i64(<1 x i64>* %p, <4 x i16>* %q) {
475 ; CHECK: ldr
476 ; CHECK: rev64 v{{[0-9]+}}.4h
477 ; CHECK: st1 { v{{[0-9]+}}.4h }
478     %1 = load <1 x i64>, <1 x i64>* %p
479     %2 = add <1 x i64> %1, %1
480     %3 = bitcast <1 x i64> %2 to <4 x i16>
481     %4 = add <4 x i16> %3, %3
482     store <4 x i16> %4, <4 x i16>* %q
483     ret void
486 ; CHECK-LABEL: test_v4i16_v2f32:
487 define void @test_v4i16_v2f32(<2 x float>* %p, <4 x i16>* %q) {
488 ; CHECK: ld1 { v{{[0-9]+}}.2s }
489 ; CHECK: rev32 v{{[0-9]+}}.4h
490 ; CHECK: st1 { v{{[0-9]+}}.4h }
491     %1 = load <2 x float>, <2 x float>* %p
492     %2 = fadd <2 x float> %1, %1
493     %3 = bitcast <2 x float> %2 to <4 x i16>
494     %4 = add <4 x i16> %3, %3
495     store <4 x i16> %4, <4 x i16>* %q
496     ret void
499 ; CHECK-LABEL: test_v4i16_v2i32:
500 define void @test_v4i16_v2i32(<2 x i32>* %p, <4 x i16>* %q) {
501 ; CHECK: ld1 { v{{[0-9]+}}.2s }
502 ; CHECK: rev32 v{{[0-9]+}}.4h
503 ; CHECK: st1 { v{{[0-9]+}}.4h }
504     %1 = load <2 x i32>, <2 x i32>* %p
505     %2 = add <2 x i32> %1, %1
506     %3 = bitcast <2 x i32> %2 to <4 x i16>
507     %4 = add <4 x i16> %3, %3
508     store <4 x i16> %4, <4 x i16>* %q
509     ret void
512 ; CHECK-LABEL: test_v4i16_v4f16:
513 define void @test_v4i16_v4f16(<4 x half>* %p, <4 x i16>* %q) {
514 ; CHECK: ld1 { v{{[0-9]+}}.4h }
515 ; CHECK-NOT: rev
516 ; CHECK: st1 { v{{[0-9]+}}.4h }
517     %1 = load <4 x half>, <4 x half>* %p
518     %2 = fadd <4 x half> %1, %1
519     %3 = bitcast <4 x half> %2 to <4 x i16>
520     %4 = add <4 x i16> %3, %3
521     store <4 x i16> %4, <4 x i16>* %q
522     ret void
525 ; CHECK-LABEL: test_v4i16_v8i8:
526 define void @test_v4i16_v8i8(<8 x i8>* %p, <4 x i16>* %q) {
527 ; CHECK: ld1 { v{{[0-9]+}}.8b }
528 ; CHECK: rev16 v{{[0-9]+}}.8b
529 ; CHECK: st1 { v{{[0-9]+}}.4h }
530     %1 = load <8 x i8>, <8 x i8>* %p
531     %2 = add <8 x i8> %1, %1
532     %3 = bitcast <8 x i8> %2 to <4 x i16>
533     %4 = add <4 x i16> %3, %3
534     store <4 x i16> %4, <4 x i16>* %q
535     ret void
538 ; CHECK-LABEL: test_v4f16_i64:
539 define void @test_v4f16_i64(i64* %p, <4 x half>* %q) {
540 ; CHECK: ldr
541 ; CHECK: rev64 v{{[0-9]+}}.4h
542 ; CHECK: fadd
543 ; CHECK-NOT: rev
544 ; CHECK: st1 { v{{[0-9]+}}.4h }
545     %1 = load i64, i64* %p
546     %2 = add i64 %1, %1
547     %3 = bitcast i64 %2 to <4 x half>
548     %4 = fadd <4 x half> %3, %3
549     store <4 x half> %4, <4 x half>* %q
550     ret void
553 ; CHECK-LABEL: test_v4f16_f64:
554 define void @test_v4f16_f64(double* %p, <4 x half>* %q) {
555 ; CHECK: ldr
556 ; CHECK: rev64 v{{[0-9]+}}.4h
557 ; CHECK: fadd
558 ; CHECK-NOT: rev
559 ; CHECK: st1 { v{{[0-9]+}}.4h }
560     %1 = load double, double* %p
561     %2 = fadd double %1, %1
562     %3 = bitcast double %2 to <4 x half>
563     %4 = fadd <4 x half> %3, %3
564     store <4 x half> %4, <4 x half>* %q
565     ret void
568 ; CHECK-LABEL: test_v4f16_v1i64:
569 define void @test_v4f16_v1i64(<1 x i64>* %p, <4 x half>* %q) {
570 ; CHECK: ldr
571 ; CHECK: rev64 v{{[0-9]+}}.4h
572 ; CHECK: fadd
573 ; CHECK-NOT: rev
574 ; CHECK: st1 { v{{[0-9]+}}.4h }
575     %1 = load <1 x i64>, <1 x i64>* %p
576     %2 = add <1 x i64> %1, %1
577     %3 = bitcast <1 x i64> %2 to <4 x half>
578     %4 = fadd <4 x half> %3, %3
579     store <4 x half> %4, <4 x half>* %q
580     ret void
583 ; CHECK-LABEL: test_v4f16_v2f32:
584 define void @test_v4f16_v2f32(<2 x float>* %p, <4 x half>* %q) {
585 ; CHECK: ld1 { v{{[0-9]+}}.2s }
586 ; CHECK: rev32 v{{[0-9]+}}.4h
587 ; CHECK: fadd
588 ; CHECK-NOT: rev
589 ; CHECK: st1 { v{{[0-9]+}}.4h }
590     %1 = load <2 x float>, <2 x float>* %p
591     %2 = fadd <2 x float> %1, %1
592     %3 = bitcast <2 x float> %2 to <4 x half>
593     %4 = fadd <4 x half> %3, %3
594     store <4 x half> %4, <4 x half>* %q
595     ret void
598 ; CHECK-LABEL: test_v4f16_v2i32:
599 define void @test_v4f16_v2i32(<2 x i32>* %p, <4 x half>* %q) {
600 ; CHECK: ld1 { v{{[0-9]+}}.2s }
601 ; CHECK: rev32 v{{[0-9]+}}.4h
602 ; CHECK: fadd
603 ; CHECK-NOT: rev
604 ; CHECK: st1 { v{{[0-9]+}}.4h }
605     %1 = load <2 x i32>, <2 x i32>* %p
606     %2 = add <2 x i32> %1, %1
607     %3 = bitcast <2 x i32> %2 to <4 x half>
608     %4 = fadd <4 x half> %3, %3
609     store <4 x half> %4, <4 x half>* %q
610     ret void
613 ; CHECK-LABEL: test_v4f16_v4i16:
614 define void @test_v4f16_v4i16(<4 x i16>* %p, <4 x half>* %q) {
615 ; CHECK: ld1 { v{{[0-9]+}}.4h }
616 ; CHECK-NOT: rev
617 ; CHECK: st1 { v{{[0-9]+}}.4h }
618     %1 = load <4 x i16>, <4 x i16>* %p
619     %2 = add <4 x i16> %1, %1
620     %3 = bitcast <4 x i16> %2 to <4 x half>
621     %4 = fadd <4 x half> %3, %3
622     store <4 x half> %4, <4 x half>* %q
623     ret void
626 ; CHECK-LABEL: test_v4f16_v8i8:
627 define void @test_v4f16_v8i8(<8 x i8>* %p, <4 x half>* %q) {
628 ; CHECK: ld1 { v{{[0-9]+}}.8b }
629 ; CHECK: rev16 v{{[0-9]+}}.8b
630 ; CHECK: fadd
631 ; CHECK-NOT: rev
632 ; CHECK: st1 { v{{[0-9]+}}.4h }
633     %1 = load <8 x i8>, <8 x i8>* %p
634     %2 = add <8 x i8> %1, %1
635     %3 = bitcast <8 x i8> %2 to <4 x half>
636     %4 = fadd <4 x half> %3, %3
637     store <4 x half> %4, <4 x half>* %q
638     ret void
641 ; CHECK-LABEL: test_v8i8_i64:
642 define void @test_v8i8_i64(i64* %p, <8 x i8>* %q) {
643 ; CHECK: ldr
644 ; CHECK: rev64 v{{[0-9]+}}.8b
645 ; CHECK: st1 { v{{[0-9]+}}.8b }
646     %1 = load i64, i64* %p
647     %2 = add i64 %1, %1
648     %3 = bitcast i64 %2 to <8 x i8>
649     %4 = add <8 x i8> %3, %3
650     store <8 x i8> %4, <8 x i8>* %q
651     ret void
654 ; CHECK-LABEL: test_v8i8_f64:
655 define void @test_v8i8_f64(double* %p, <8 x i8>* %q) {
656 ; CHECK: ldr
657 ; CHECK: rev64 v{{[0-9]+}}.8b
658 ; CHECK: st1 { v{{[0-9]+}}.8b }
659     %1 = load double, double* %p
660     %2 = fadd double %1, %1
661     %3 = bitcast double %2 to <8 x i8>
662     %4 = add <8 x i8> %3, %3
663     store <8 x i8> %4, <8 x i8>* %q
664     ret void
667 ; CHECK-LABEL: test_v8i8_v1i64:
668 define void @test_v8i8_v1i64(<1 x i64>* %p, <8 x i8>* %q) {
669 ; CHECK: ldr
670 ; CHECK: rev64 v{{[0-9]+}}.8b
671 ; CHECK: st1 { v{{[0-9]+}}.8b }
672     %1 = load <1 x i64>, <1 x i64>* %p
673     %2 = add <1 x i64> %1, %1
674     %3 = bitcast <1 x i64> %2 to <8 x i8>
675     %4 = add <8 x i8> %3, %3
676     store <8 x i8> %4, <8 x i8>* %q
677     ret void
680 ; CHECK-LABEL: test_v8i8_v2f32:
681 define void @test_v8i8_v2f32(<2 x float>* %p, <8 x i8>* %q) {
682 ; CHECK: ld1 { v{{[0-9]+}}.2s }
683 ; CHECK: rev32 v{{[0-9]+}}.8b
684 ; CHECK: st1 { v{{[0-9]+}}.8b }
685     %1 = load <2 x float>, <2 x float>* %p
686     %2 = fadd <2 x float> %1, %1
687     %3 = bitcast <2 x float> %2 to <8 x i8>
688     %4 = add <8 x i8> %3, %3
689     store <8 x i8> %4, <8 x i8>* %q
690     ret void
693 ; CHECK-LABEL: test_v8i8_v2i32:
694 define void @test_v8i8_v2i32(<2 x i32>* %p, <8 x i8>* %q) {
695 ; CHECK: ld1 { v{{[0-9]+}}.2s }
696 ; CHECK: rev32 v{{[0-9]+}}.8b
697 ; CHECK: st1 { v{{[0-9]+}}.8b }
698     %1 = load <2 x i32>, <2 x i32>* %p
699     %2 = add <2 x i32> %1, %1
700     %3 = bitcast <2 x i32> %2 to <8 x i8>
701     %4 = add <8 x i8> %3, %3
702     store <8 x i8> %4, <8 x i8>* %q
703     ret void
706 ; CHECK-LABEL: test_v8i8_v4i16:
707 define void @test_v8i8_v4i16(<4 x i16>* %p, <8 x i8>* %q) {
708 ; CHECK: ld1 { v{{[0-9]+}}.4h }
709 ; CHECK: rev16 v{{[0-9]+}}.8b
710 ; CHECK: st1 { v{{[0-9]+}}.8b }
711     %1 = load <4 x i16>, <4 x i16>* %p
712     %2 = add <4 x i16> %1, %1
713     %3 = bitcast <4 x i16> %2 to <8 x i8>
714     %4 = add <8 x i8> %3, %3
715     store <8 x i8> %4, <8 x i8>* %q
716     ret void
719 ; CHECK-LABEL: test_f128_v2f64:
720 define void @test_f128_v2f64(<2 x double>* %p, fp128* %q) {
721 ; CHECK: ld1 { v{{[0-9]+}}.2d }
722 ; CHECK: ext
723 ; CHECK: str
724     %1 = load <2 x double>, <2 x double>* %p
725     %2 = fadd <2 x double> %1, %1
726     %3 = bitcast <2 x double> %2 to fp128
727     %4 = fadd fp128 %3, %3
728     store fp128 %4, fp128* %q
729     ret void
732 ; CHECK-LABEL: test_f128_v2i64:
733 define void @test_f128_v2i64(<2 x i64>* %p, fp128* %q) {
734 ; CHECK: ld1 { v{{[0-9]+}}.2d }
735 ; CHECK: ext
736 ; CHECK: str
737     %1 = load <2 x i64>, <2 x i64>* %p
738     %2 = add <2 x i64> %1, %1
739     %3 = bitcast <2 x i64> %2 to fp128
740     %4 = fadd fp128 %3, %3
741     store fp128 %4, fp128* %q
742     ret void
745 ; CHECK-LABEL: test_f128_v4f32:
746 define void @test_f128_v4f32(<4 x float>* %p, fp128* %q) {
747 ; CHECK: ld1 { v{{[0-9]+}}.4s }
748 ; CHECK-NOT: rev
749 ; CHECK: fadd
750 ; CHECK: rev64 v{{[0-9]+}}.4s
751 ; CHECK: ext
752 ; CHECK: str q
753     %1 = load <4 x float>, <4 x float>* %p
754     %2 = fadd <4 x float> %1, %1
755     %3 = bitcast <4 x float> %2 to fp128
756     %4 = fadd fp128 %3, %3
757     store fp128 %4, fp128* %q
758     ret void
761 ; CHECK-LABEL: test_f128_v4i32:
762 define void @test_f128_v4i32(<4 x i32>* %p, fp128* %q) {
763 ; CHECK: ld1 { v{{[0-9]+}}.4s }
764 ; CHECK: rev64 v{{[0-9]+}}.4s
765 ; CHECK: ext
766 ; CHECK: str
767     %1 = load <4 x i32>, <4 x i32>* %p
768     %2 = add <4 x i32> %1, %1
769     %3 = bitcast <4 x i32> %2 to fp128
770     %4 = fadd fp128 %3, %3
771     store fp128 %4, fp128* %q
772     ret void
775 ; CHECK-LABEL: test_f128_v8i16:
776 define void @test_f128_v8i16(<8 x i16>* %p, fp128* %q) {
777 ; CHECK: ld1 { v{{[0-9]+}}.8h }
778 ; CHECK: rev64 v{{[0-9]+}}.8h
779 ; CHECK: ext
780 ; CHECK: str
781     %1 = load <8 x i16>, <8 x i16>* %p
782     %2 = add <8 x i16> %1, %1
783     %3 = bitcast <8 x i16> %2 to fp128
784     %4 = fadd fp128 %3, %3
785     store fp128 %4, fp128* %q
786     ret void
789 ; CHECK-LABEL: test_f128_v16i8:
790 define void @test_f128_v16i8(<16 x i8>* %p, fp128* %q) {
791 ; CHECK: ld1 { v{{[0-9]+}}.16b }
792 ; CHECK: ext
793 ; CHECK: str q
794     %1 = load <16 x i8>, <16 x i8>* %p
795     %2 = add <16 x i8> %1, %1
796     %3 = bitcast <16 x i8> %2 to fp128
797     %4 = fadd fp128 %3, %3
798     store fp128 %4, fp128* %q
799     ret void
802 ; CHECK-LABEL: test_v2f64_f128:
803 define void @test_v2f64_f128(fp128* %p, <2 x double>* %q) {
804 ; CHECK: ldr
805 ; CHECK: ext
806 ; CHECK: st1 { v{{[0-9]+}}.2d }
807     %1 = load fp128, fp128* %p
808     %2 = fadd fp128 %1, %1
809     %3 = bitcast fp128 %2 to <2 x double>
810     %4 = fadd <2 x double> %3, %3
811     store <2 x double> %4, <2 x double>* %q
812     ret void
815 ; CHECK-LABEL: test_v2f64_v2i64:
816 define void @test_v2f64_v2i64(<2 x i64>* %p, <2 x double>* %q) {
817 ; CHECK: ld1 { v{{[0-9]+}}.2d }
818 ; CHECK: st1 { v{{[0-9]+}}.2d }
819     %1 = load <2 x i64>, <2 x i64>* %p
820     %2 = add <2 x i64> %1, %1
821     %3 = bitcast <2 x i64> %2 to <2 x double>
822     %4 = fadd <2 x double> %3, %3
823     store <2 x double> %4, <2 x double>* %q
824     ret void
827 ; CHECK-LABEL: test_v2f64_v4f32:
828 define void @test_v2f64_v4f32(<4 x float>* %p, <2 x double>* %q) {
829 ; CHECK: ld1 { v{{[0-9]+}}.4s }
830 ; CHECK-NOT: rev
831 ; CHECK: fadd
832 ; CHECK: rev64 v{{[0-9]+}}.4s
833 ; CHECK: st1 { v{{[0-9]+}}.2d }
834     %1 = load <4 x float>, <4 x float>* %p
835     %2 = fadd <4 x float> %1, %1
836     %3 = bitcast <4 x float> %2 to <2 x double>
837     %4 = fadd <2 x double> %3, %3
838     store <2 x double> %4, <2 x double>* %q
839     ret void
842 ; CHECK-LABEL: test_v2f64_v4i32:
843 define void @test_v2f64_v4i32(<4 x i32>* %p, <2 x double>* %q) {
844 ; CHECK: ld1 { v{{[0-9]+}}.4s }
845 ; CHECK: rev64 v{{[0-9]+}}.4s
846 ; CHECK: st1 { v{{[0-9]+}}.2d }
847     %1 = load <4 x i32>, <4 x i32>* %p
848     %2 = add <4 x i32> %1, %1
849     %3 = bitcast <4 x i32> %2 to <2 x double>
850     %4 = fadd <2 x double> %3, %3
851     store <2 x double> %4, <2 x double>* %q
852     ret void
855 ; CHECK-LABEL: test_v2f64_v8i16:
856 define void @test_v2f64_v8i16(<8 x i16>* %p, <2 x double>* %q) {
857 ; CHECK: ld1 { v{{[0-9]+}}.8h }
858 ; CHECK: rev64 v{{[0-9]+}}.8h
859 ; CHECK: st1 { v{{[0-9]+}}.2d }
860     %1 = load <8 x i16>, <8 x i16>* %p
861     %2 = add <8 x i16> %1, %1
862     %3 = bitcast <8 x i16> %2 to <2 x double>
863     %4 = fadd <2 x double> %3, %3
864     store <2 x double> %4, <2 x double>* %q
865     ret void
868 ; CHECK-LABEL: test_v2f64_v16i8:
869 define void @test_v2f64_v16i8(<16 x i8>* %p, <2 x double>* %q) {
870 ; CHECK: ld1 { v{{[0-9]+}}.16b }
871 ; CHECK: rev64 v{{[0-9]+}}.16b
872 ; CHECK: st1 { v{{[0-9]+}}.2d }
873     %1 = load <16 x i8>, <16 x i8>* %p
874     %2 = add <16 x i8> %1, %1
875     %3 = bitcast <16 x i8> %2 to <2 x double>
876     %4 = fadd <2 x double> %3, %3
877     store <2 x double> %4, <2 x double>* %q
878     ret void
881 ; CHECK-LABEL: test_v2i64_f128:
882 define void @test_v2i64_f128(fp128* %p, <2 x i64>* %q) {
883 ; CHECK: ldr
884 ; CHECK: ext
885 ; CHECK: st1 { v{{[0-9]+}}.2d }
886     %1 = load fp128, fp128* %p
887     %2 = fadd fp128 %1, %1
888     %3 = bitcast fp128 %2 to <2 x i64>
889     %4 = add <2 x i64> %3, %3
890     store <2 x i64> %4, <2 x i64>* %q
891     ret void
894 ; CHECK-LABEL: test_v2i64_v2f64:
895 define void @test_v2i64_v2f64(<2 x double>* %p, <2 x i64>* %q) {
896 ; CHECK: ld1 { v{{[0-9]+}}.2d }
897 ; CHECK: st1 { v{{[0-9]+}}.2d }
898     %1 = load <2 x double>, <2 x double>* %p
899     %2 = fadd <2 x double> %1, %1
900     %3 = bitcast <2 x double> %2 to <2 x i64>
901     %4 = add <2 x i64> %3, %3
902     store <2 x i64> %4, <2 x i64>* %q
903     ret void
906 ; CHECK-LABEL: test_v2i64_v4f32:
907 define void @test_v2i64_v4f32(<4 x float>* %p, <2 x i64>* %q) {
908 ; CHECK: ld1 { v{{[0-9]+}}.4s }
909 ; CHECK-NOT: rev
910 ; CHECK: fadd
911 ; CHECK: rev64 v{{[0-9]+}}.4s
912 ; CHECK: add
913 ; CHECK: st1 { v{{[0-9]+}}.2d }
914     %1 = load <4 x float>, <4 x float>* %p
915     %2 = fadd <4 x float> %1, %1
916     %3 = bitcast <4 x float> %2 to <2 x i64>
917     %4 = add <2 x i64> %3, %3
918     store <2 x i64> %4, <2 x i64>* %q
919     ret void
922 ; CHECK-LABEL: test_v2i64_v4i32:
923 define void @test_v2i64_v4i32(<4 x i32>* %p, <2 x i64>* %q) {
924 ; CHECK: ld1 { v{{[0-9]+}}.4s }
925 ; CHECK: rev64 v{{[0-9]+}}.4s
926 ; CHECK: st1 { v{{[0-9]+}}.2d }
927     %1 = load <4 x i32>, <4 x i32>* %p
928     %2 = add <4 x i32> %1, %1
929     %3 = bitcast <4 x i32> %2 to <2 x i64>
930     %4 = add <2 x i64> %3, %3
931     store <2 x i64> %4, <2 x i64>* %q
932     ret void
935 ; CHECK-LABEL: test_v2i64_v8i16:
936 define void @test_v2i64_v8i16(<8 x i16>* %p, <2 x i64>* %q) {
937 ; CHECK: ld1 { v{{[0-9]+}}.8h }
938 ; CHECK: rev64 v{{[0-9]+}}.8h
939 ; CHECK: st1 { v{{[0-9]+}}.2d }
940     %1 = load <8 x i16>, <8 x i16>* %p
941     %2 = add <8 x i16> %1, %1
942     %3 = bitcast <8 x i16> %2 to <2 x i64>
943     %4 = add <2 x i64> %3, %3
944     store <2 x i64> %4, <2 x i64>* %q
945     ret void
948 ; CHECK-LABEL: test_v2i64_v16i8:
949 define void @test_v2i64_v16i8(<16 x i8>* %p, <2 x i64>* %q) {
950 ; CHECK: ld1 { v{{[0-9]+}}.16b }
951 ; CHECK: rev64 v{{[0-9]+}}.16b
952 ; CHECK: st1 { v{{[0-9]+}}.2d }
953     %1 = load <16 x i8>, <16 x i8>* %p
954     %2 = add <16 x i8> %1, %1
955     %3 = bitcast <16 x i8> %2 to <2 x i64>
956     %4 = add <2 x i64> %3, %3
957     store <2 x i64> %4, <2 x i64>* %q
958     ret void
961 ; CHECK-LABEL: test_v4f32_f128:
962 define void @test_v4f32_f128(fp128* %p, <4 x float>* %q) {
963 ; CHECK: ldr q
964 ; CHECK: rev64 v{{[0-9]+}}.4s
965 ; CHECK: ext
966 ; CHECK-NOT: rev
967 ; CHECK: st1 { v{{[0-9]+}}.4s }
968     %1 = load fp128, fp128* %p
969     %2 = fadd fp128 %1, %1
970     %3 = bitcast fp128 %2 to <4 x float>
971     %4 = fadd <4 x float> %3, %3
972     store <4 x float> %4, <4 x float>* %q
973     ret void
976 ; CHECK-LABEL: test_v4f32_v2f64:
977 define void @test_v4f32_v2f64(<2 x double>* %p, <4 x float>* %q) {
978 ; CHECK: ld1 { v{{[0-9]+}}.2d }
979 ; CHECK: rev64 v{{[0-9]+}}.4s
980 ; CHECK-NOT: rev
981 ; CHECK: st1 { v{{[0-9]+}}.4s }
982     %1 = load <2 x double>, <2 x double>* %p
983     %2 = fadd <2 x double> %1, %1
984     %3 = bitcast <2 x double> %2 to <4 x float>
985     %4 = fadd <4 x float> %3, %3
986     store <4 x float> %4, <4 x float>* %q
987     ret void
990 ; CHECK-LABEL: test_v4f32_v2i64:
991 define void @test_v4f32_v2i64(<2 x i64>* %p, <4 x float>* %q) {
992 ; CHECK: ld1 { v{{[0-9]+}}.2d }
993 ; CHECK: rev64 v{{[0-9]+}}.4s
994 ; CHECK: fadd
995 ; CHECK-NOT: rev
996 ; CHECK: st1 { v{{[0-9]+}}.4s }
997     %1 = load <2 x i64>, <2 x i64>* %p
998     %2 = add <2 x i64> %1, %1
999     %3 = bitcast <2 x i64> %2 to <4 x float>
1000     %4 = fadd <4 x float> %3, %3
1001     store <4 x float> %4, <4 x float>* %q
1002     ret void
1005 ; CHECK-LABEL: test_v4f32_v4i32:
1006 define void @test_v4f32_v4i32(<4 x i32>* %p, <4 x float>* %q) {
1007 ; CHECK: ld1 { v{{[0-9]+}}.4s }
1008 ; CHECK-NOT: rev
1009 ; CHECK: st1 { v{{[0-9]+}}.4s }
1010     %1 = load <4 x i32>, <4 x i32>* %p
1011     %2 = add <4 x i32> %1, %1
1012     %3 = bitcast <4 x i32> %2 to <4 x float>
1013     %4 = fadd <4 x float> %3, %3
1014     store <4 x float> %4, <4 x float>* %q
1015     ret void
1018 ; CHECK-LABEL: test_v4f32_v8i16:
1019 define void @test_v4f32_v8i16(<8 x i16>* %p, <4 x float>* %q) {
1020 ; CHECK: ld1 { v{{[0-9]+}}.8h }
1021 ; CHECK: rev32 v{{[0-9]+}}.8h
1022 ; CHECK-NOT: rev
1023 ; CHECK: st1 { v{{[0-9]+}}.4s }
1024     %1 = load <8 x i16>, <8 x i16>* %p
1025     %2 = add <8 x i16> %1, %1
1026     %3 = bitcast <8 x i16> %2 to <4 x float>
1027     %4 = fadd <4 x float> %3, %3
1028     store <4 x float> %4, <4 x float>* %q
1029     ret void
1032 ; CHECK-LABEL: test_v4f32_v16i8:
1033 define void @test_v4f32_v16i8(<16 x i8>* %p, <4 x float>* %q) {
1034 ; CHECK: ld1 { v{{[0-9]+}}.16b }
1035 ; CHECK: rev32 v{{[0-9]+}}.16b
1036 ; CHECK-NOT: rev
1037 ; CHECK: st1 { v{{[0-9]+}}.4s }
1038     %1 = load <16 x i8>, <16 x i8>* %p
1039     %2 = add <16 x i8> %1, %1
1040     %3 = bitcast <16 x i8> %2 to <4 x float>
1041     %4 = fadd <4 x float> %3, %3
1042     store <4 x float> %4, <4 x float>* %q
1043     ret void
1046 ; CHECK-LABEL: test_v4i32_f128:
1047 define void @test_v4i32_f128(fp128* %p, <4 x i32>* %q) {
1048 ; CHECK: ldr
1049 ; CHECK: rev64 v{{[0-9]+}}.4s
1050 ; CHECK: ext
1051 ; CHECK: st1 { v{{[0-9]+}}.4s }
1052     %1 = load fp128, fp128* %p
1053     %2 = fadd fp128 %1, %1
1054     %3 = bitcast fp128 %2 to <4 x i32>
1055     %4 = add <4 x i32> %3, %3
1056     store <4 x i32> %4, <4 x i32>* %q
1057     ret void
1060 ; CHECK-LABEL: test_v4i32_v2f64:
1061 define void @test_v4i32_v2f64(<2 x double>* %p, <4 x i32>* %q) {
1062 ; CHECK: ld1 { v{{[0-9]+}}.2d }
1063 ; CHECK: rev64 v{{[0-9]+}}.4s
1064 ; CHECK: st1 { v{{[0-9]+}}.4s }
1065     %1 = load <2 x double>, <2 x double>* %p
1066     %2 = fadd <2 x double> %1, %1
1067     %3 = bitcast <2 x double> %2 to <4 x i32>
1068     %4 = add <4 x i32> %3, %3
1069     store <4 x i32> %4, <4 x i32>* %q
1070     ret void
1073 ; CHECK-LABEL: test_v4i32_v2i64:
1074 define void @test_v4i32_v2i64(<2 x i64>* %p, <4 x i32>* %q) {
1075 ; CHECK: ld1 { v{{[0-9]+}}.2d }
1076 ; CHECK: rev64 v{{[0-9]+}}.4s
1077 ; CHECK: st1 { v{{[0-9]+}}.4s }
1078     %1 = load <2 x i64>, <2 x i64>* %p
1079     %2 = add <2 x i64> %1, %1
1080     %3 = bitcast <2 x i64> %2 to <4 x i32>
1081     %4 = add <4 x i32> %3, %3
1082     store <4 x i32> %4, <4 x i32>* %q
1083     ret void
1086 ; CHECK-LABEL: test_v4i32_v4f32:
1087 define void @test_v4i32_v4f32(<4 x float>* %p, <4 x i32>* %q) {
1088 ; CHECK: ld1 { v{{[0-9]+}}.4s }
1089 ; CHECK-NOT: rev
1090 ; CHECK: st1 { v{{[0-9]+}}.4s }
1091     %1 = load <4 x float>, <4 x float>* %p
1092     %2 = fadd <4 x float> %1, %1
1093     %3 = bitcast <4 x float> %2 to <4 x i32>
1094     %4 = add <4 x i32> %3, %3
1095     store <4 x i32> %4, <4 x i32>* %q
1096     ret void
1099 ; CHECK-LABEL: test_v4i32_v8i16:
1100 define void @test_v4i32_v8i16(<8 x i16>* %p, <4 x i32>* %q) {
1101 ; CHECK: ld1 { v{{[0-9]+}}.8h }
1102 ; CHECK: rev32 v{{[0-9]+}}.8h
1103 ; CHECK: st1 { v{{[0-9]+}}.4s }
1104     %1 = load <8 x i16>, <8 x i16>* %p
1105     %2 = add <8 x i16> %1, %1
1106     %3 = bitcast <8 x i16> %2 to <4 x i32>
1107     %4 = add <4 x i32> %3, %3
1108     store <4 x i32> %4, <4 x i32>* %q
1109     ret void
1112 ; CHECK-LABEL: test_v4i32_v16i8:
1113 define void @test_v4i32_v16i8(<16 x i8>* %p, <4 x i32>* %q) {
1114 ; CHECK: ld1 { v{{[0-9]+}}.16b }
1115 ; CHECK: rev32 v{{[0-9]+}}.16b
1116 ; CHECK: st1 { v{{[0-9]+}}.4s }
1117     %1 = load <16 x i8>, <16 x i8>* %p
1118     %2 = add <16 x i8> %1, %1
1119     %3 = bitcast <16 x i8> %2 to <4 x i32>
1120     %4 = add <4 x i32> %3, %3
1121     store <4 x i32> %4, <4 x i32>* %q
1122     ret void
1125 ; CHECK-LABEL: test_v8i16_f128:
1126 define void @test_v8i16_f128(fp128* %p, <8 x i16>* %q) {
1127 ; CHECK: ldr
1128 ; CHECK: rev64 v{{[0-9]+}}.8h
1129 ; CHECK: ext
1130 ; CHECK: st1 { v{{[0-9]+}}.8h }
1131     %1 = load fp128, fp128* %p
1132     %2 = fadd fp128 %1, %1
1133     %3 = bitcast fp128 %2 to <8 x i16>
1134     %4 = add <8 x i16> %3, %3
1135     store <8 x i16> %4, <8 x i16>* %q
1136     ret void
1139 ; CHECK-LABEL: test_v8i16_v2f64:
1140 define void @test_v8i16_v2f64(<2 x double>* %p, <8 x i16>* %q) {
1141 ; CHECK: ld1 { v{{[0-9]+}}.2d }
1142 ; CHECK: rev64 v{{[0-9]+}}.8h
1143 ; CHECK: st1 { v{{[0-9]+}}.8h }
1144     %1 = load <2 x double>, <2 x double>* %p
1145     %2 = fadd <2 x double> %1, %1
1146     %3 = bitcast <2 x double> %2 to <8 x i16>
1147     %4 = add <8 x i16> %3, %3
1148     store <8 x i16> %4, <8 x i16>* %q
1149     ret void
1152 ; CHECK-LABEL: test_v8i16_v2i64:
1153 define void @test_v8i16_v2i64(<2 x i64>* %p, <8 x i16>* %q) {
1154 ; CHECK: ld1 { v{{[0-9]+}}.2d }
1155 ; CHECK: rev64 v{{[0-9]+}}.8h
1156 ; CHECK: st1 { v{{[0-9]+}}.8h }
1157     %1 = load <2 x i64>, <2 x i64>* %p
1158     %2 = add <2 x i64> %1, %1
1159     %3 = bitcast <2 x i64> %2 to <8 x i16>
1160     %4 = add <8 x i16> %3, %3
1161     store <8 x i16> %4, <8 x i16>* %q
1162     ret void
1165 ; CHECK-LABEL: test_v8i16_v4f32:
1166 define void @test_v8i16_v4f32(<4 x float>* %p, <8 x i16>* %q) {
1167 ; CHECK: ld1 { v{{[0-9]+}}.4s }
1168 ; CHECK: rev32 v{{[0-9]+}}.8h
1169 ; CHECK-NOT: rev
1170 ; CHECK: st1 { v{{[0-9]+}}.8h }
1171     %1 = load <4 x float>, <4 x float>* %p
1172     %2 = fadd <4 x float> %1, %1
1173     %3 = bitcast <4 x float> %2 to <8 x i16>
1174     %4 = add <8 x i16> %3, %3
1175     store <8 x i16> %4, <8 x i16>* %q
1176     ret void
1179 ; CHECK-LABEL: test_v8i16_v4i32:
1180 define void @test_v8i16_v4i32(<4 x i32>* %p, <8 x i16>* %q) {
1181 ; CHECK: ld1 { v{{[0-9]+}}.4s }
1182 ; CHECK: rev32 v{{[0-9]+}}.8h
1183 ; CHECK: st1 { v{{[0-9]+}}.8h }
1184     %1 = load <4 x i32>, <4 x i32>* %p
1185     %2 = add <4 x i32> %1, %1
1186     %3 = bitcast <4 x i32> %2 to <8 x i16>
1187     %4 = add <8 x i16> %3, %3
1188     store <8 x i16> %4, <8 x i16>* %q
1189     ret void
1192 ; CHECK-LABEL: test_v8i16_v8f16:
1193 define void @test_v8i16_v8f16(<8 x half>* %p, <8 x i16>* %q) {
1194 ; CHECK: ld1 { v{{[0-9]+}}.8h }
1195 ; CHECK-NOT: rev
1196 ; CHECK: st1 { v{{[0-9]+}}.8h }
1197     %1 = load <8 x half>, <8 x half>* %p
1198     %2 = fadd <8 x half> %1, %1
1199     %3 = bitcast <8 x half> %2 to <8 x i16>
1200     %4 = add <8 x i16> %3, %3
1201     store <8 x i16> %4, <8 x i16>* %q
1202     ret void
1205 ; CHECK-LABEL: test_v8i16_v16i8:
1206 define void @test_v8i16_v16i8(<16 x i8>* %p, <8 x i16>* %q) {
1207 ; CHECK: ld1 { v{{[0-9]+}}.16b }
1208 ; CHECK: rev16 v{{[0-9]+}}.16b
1209 ; CHECK: st1 { v{{[0-9]+}}.8h }
1210     %1 = load <16 x i8>, <16 x i8>* %p
1211     %2 = add <16 x i8> %1, %1
1212     %3 = bitcast <16 x i8> %2 to <8 x i16>
1213     %4 = add <8 x i16> %3, %3
1214     store <8 x i16> %4, <8 x i16>* %q
1215     ret void
1218 ; CHECK-LABEL: test_v16i8_f128:
1219 define void @test_v16i8_f128(fp128* %p, <16 x i8>* %q) {
1220 ; CHECK: ldr q
1221 ; CHECK: rev64 v{{[0-9]+}}.16b
1222 ; CHECK: ext
1223 ; CHECK: st1 { v{{[0-9]+}}.16b }
1224     %1 = load fp128, fp128* %p
1225     %2 = fadd fp128 %1, %1
1226     %3 = bitcast fp128 %2 to <16 x i8>
1227     %4 = add <16 x i8> %3, %3
1228     store <16 x i8> %4, <16 x i8>* %q
1229     ret void
1232 ; CHECK-LABEL: test_v16i8_v2f64:
1233 define void @test_v16i8_v2f64(<2 x double>* %p, <16 x i8>* %q) {
1234 ; CHECK: ld1 { v{{[0-9]+}}.2d }
1235 ; CHECK: rev64 v{{[0-9]+}}.16b
1236 ; CHECK: st1 { v{{[0-9]+}}.16b }
1237     %1 = load <2 x double>, <2 x double>* %p
1238     %2 = fadd <2 x double> %1, %1
1239     %3 = bitcast <2 x double> %2 to <16 x i8>
1240     %4 = add <16 x i8> %3, %3
1241     store <16 x i8> %4, <16 x i8>* %q
1242     ret void
1245 ; CHECK-LABEL: test_v16i8_v2i64:
1246 define void @test_v16i8_v2i64(<2 x i64>* %p, <16 x i8>* %q) {
1247 ; CHECK: ld1 { v{{[0-9]+}}.2d }
1248 ; CHECK: rev64 v{{[0-9]+}}.16b
1249 ; CHECK: st1 { v{{[0-9]+}}.16b }
1250     %1 = load <2 x i64>, <2 x i64>* %p
1251     %2 = add <2 x i64> %1, %1
1252     %3 = bitcast <2 x i64> %2 to <16 x i8>
1253     %4 = add <16 x i8> %3, %3
1254     store <16 x i8> %4, <16 x i8>* %q
1255     ret void
1258 ; CHECK-LABEL: test_v16i8_v4f32:
1259 define void @test_v16i8_v4f32(<4 x float>* %p, <16 x i8>* %q) {
1260 ; CHECK: ld1 { v{{[0-9]+}}.4s }
1261 ; CHECK: rev32 v{{[0-9]+}}.16b
1262 ; CHECK-NOT: rev
1263 ; CHECK: st1 { v{{[0-9]+}}.16b }
1264     %1 = load <4 x float>, <4 x float>* %p
1265     %2 = fadd <4 x float> %1, %1
1266     %3 = bitcast <4 x float> %2 to <16 x i8>
1267     %4 = add <16 x i8> %3, %3
1268     store <16 x i8> %4, <16 x i8>* %q
1269     ret void
1272 ; CHECK-LABEL: test_v16i8_v4i32:
1273 define void @test_v16i8_v4i32(<4 x i32>* %p, <16 x i8>* %q) {
1274 ; CHECK: ld1 { v{{[0-9]+}}.4s }
1275 ; CHECK: rev32 v{{[0-9]+}}.16b
1276 ; CHECK: st1 { v{{[0-9]+}}.16b }
1277     %1 = load <4 x i32>, <4 x i32>* %p
1278     %2 = add <4 x i32> %1, %1
1279     %3 = bitcast <4 x i32> %2 to <16 x i8>
1280     %4 = add <16 x i8> %3, %3
1281     store <16 x i8> %4, <16 x i8>* %q
1282     ret void
1285 ; CHECK-LABEL: test_v16i8_v8f16:
1286 define void @test_v16i8_v8f16(<8 x half>* %p, <16 x i8>* %q) {
1287 ; CHECK: ld1 { v{{[0-9]+}}.8h }
1288 ; CHECK: rev16 v{{[0-9]+}}.16b
1289 ; CHECK-NOT: rev
1290 ; CHECK: st1 { v{{[0-9]+}}.16b }
1291     %1 = load <8 x half>, <8 x half>* %p
1292     %2 = fadd <8 x half> %1, %1
1293     %3 = bitcast <8 x half> %2 to <16 x i8>
1294     %4 = add <16 x i8> %3, %3
1295     store <16 x i8> %4, <16 x i8>* %q
1296     ret void
1299 ; CHECK-LABEL: test_v16i8_v8i16:
1300 define void @test_v16i8_v8i16(<8 x i16>* %p, <16 x i8>* %q) {
1301 ; CHECK: ld1 { v{{[0-9]+}}.8h }
1302 ; CHECK: rev16 v{{[0-9]+}}.16b
1303 ; CHECK: st1 { v{{[0-9]+}}.16b }
1304     %1 = load <8 x i16>, <8 x i16>* %p
1305     %2 = add <8 x i16> %1, %1
1306     %3 = bitcast <8 x i16> %2 to <16 x i8>
1307     %4 = add <16 x i8> %3, %3
1308     store <16 x i8> %4, <16 x i8>* %q
1309     ret void
1312 ; CHECK-LABEL: test_v4f16_struct:
1313 %struct.struct1 = type { half, half, half, half }
1314 define %struct.struct1 @test_v4f16_struct(%struct.struct1* %ret) {
1315 entry:
1316 ; CHECK: ld1 { {{v[0-9]+}}.4h }
1317 ; CHECK-NOT: rev
1318   %0 = bitcast %struct.struct1* %ret to <4 x half>*
1319   %1 = load <4 x half>, <4 x half>* %0, align 2
1320   %2 = extractelement <4 x half> %1, i32 0
1321   %.fca.0.insert = insertvalue %struct.struct1 undef, half %2, 0
1322   ret %struct.struct1 %.fca.0.insert