1 ; RUN: llc -mtriple arm64_be < %s -arm64-load-store-opt=false -O1 -o - | FileCheck %s
2 ; RUN: llc -mtriple arm64_be < %s -arm64-load-store-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) {
9 %2 = fadd double %1, %1
10 %3 = bitcast double %2 to i64
16 ; CHECK-LABEL: test_i64_v1i64:
17 define void @test_i64_v1i64(<1 x i64>* %p, i64* %q) {
20 %1 = load <1 x i64>* %p
21 %2 = add <1 x i64> %1, %1
22 %3 = bitcast <1 x i64> %2 to i64
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
33 %1 = load <2 x float>* %p
34 %2 = fadd <2 x float> %1, %1
35 %3 = bitcast <2 x float> %2 to i64
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
46 %1 = load <2 x i32>* %p
47 %2 = add <2 x i32> %1, %1
48 %3 = bitcast <2 x i32> %2 to i64
54 ; CHECK-LABEL: test_i64_v4i16:
55 define void @test_i64_v4i16(<4 x i16>* %p, i64* %q) {
56 ; CHECK: ld1 { v{{[0-9]+}}.4h }
57 ; CHECK: rev64 v{{[0-9]+}}.4h
59 %1 = load <4 x i16>* %p
60 %2 = add <4 x i16> %1, %1
61 %3 = bitcast <4 x i16> %2 to i64
67 ; CHECK-LABEL: test_i64_v8i8:
68 define void @test_i64_v8i8(<8 x i8>* %p, i64* %q) {
69 ; CHECK: ld1 { v{{[0-9]+}}.8b }
70 ; CHECK: rev64 v{{[0-9]+}}.8b
72 %1 = load <8 x i8>* %p
73 %2 = add <8 x i8> %1, %1
74 %3 = bitcast <8 x i8> %2 to i64
80 ; CHECK-LABEL: test_f64_i64:
81 define void @test_f64_i64(i64* %p, double* %q) {
86 %3 = bitcast i64 %2 to double
87 %4 = fadd double %3, %3
88 store double %4, double* %q
92 ; CHECK-LABEL: test_f64_v1i64:
93 define void @test_f64_v1i64(<1 x i64>* %p, double* %q) {
96 %1 = load <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
104 ; CHECK-LABEL: test_f64_v2f32:
105 define void @test_f64_v2f32(<2 x float>* %p, double* %q) {
106 ; CHECK: ld1 { v{{[0-9]+}}.2s }
107 ; CHECK: rev64 v{{[0-9]+}}.2s
109 %1 = load <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
117 ; CHECK-LABEL: test_f64_v2i32:
118 define void @test_f64_v2i32(<2 x i32>* %p, double* %q) {
119 ; CHECK: ld1 { v{{[0-9]+}}.2s }
120 ; CHECK: rev64 v{{[0-9]+}}.2s
122 %1 = load <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
130 ; CHECK-LABEL: test_f64_v4i16:
131 define void @test_f64_v4i16(<4 x i16>* %p, double* %q) {
132 ; CHECK: ld1 { v{{[0-9]+}}.4h }
133 ; CHECK: rev64 v{{[0-9]+}}.4h
135 %1 = load <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
143 ; CHECK-LABEL: test_f64_v8i8:
144 define void @test_f64_v8i8(<8 x i8>* %p, double* %q) {
145 ; CHECK: ld1 { v{{[0-9]+}}.8b }
146 ; CHECK: rev64 v{{[0-9]+}}.8b
148 %1 = load <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
156 ; CHECK-LABEL: test_v1i64_i64:
157 define void @test_v1i64_i64(i64* %p, <1 x i64>* %q) {
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
168 ; CHECK-LABEL: test_v1i64_f64:
169 define void @test_v1i64_f64(double* %p, <1 x i64>* %q) {
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
180 ; CHECK-LABEL: test_v1i64_v2f32:
181 define 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
185 %1 = load <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
193 ; CHECK-LABEL: test_v1i64_v2i32:
194 define 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
198 %1 = load <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
206 ; CHECK-LABEL: test_v1i64_v4i16:
207 define 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
211 %1 = load <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
219 ; CHECK-LABEL: test_v1i64_v8i8:
220 define 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
224 %1 = load <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
232 ; CHECK-LABEL: test_v2f32_i64:
233 define void @test_v2f32_i64(i64* %p, <2 x float>* %q) {
235 ; CHECK: rev64 v{{[0-9]+}}.2s
236 ; CHECK: st1 { v{{[0-9]+}}.2s }
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
245 ; CHECK-LABEL: test_v2f32_f64:
246 define void @test_v2f32_f64(double* %p, <2 x float>* %q) {
248 ; CHECK: rev64 v{{[0-9]+}}.2s
249 ; CHECK: st1 { v{{[0-9]+}}.2s }
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
258 ; CHECK-LABEL: test_v2f32_v1i64:
259 define void @test_v2f32_v1i64(<1 x i64>* %p, <2 x float>* %q) {
261 ; CHECK: rev64 v{{[0-9]+}}.2s
262 ; CHECK: st1 { v{{[0-9]+}}.2s }
263 %1 = load <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
271 ; CHECK-LABEL: test_v2f32_v2i32:
272 define 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>* %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
283 ; CHECK-LABEL: test_v2f32_v4i16:
284 define 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>* %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
296 ; CHECK-LABEL: test_v2f32_v8i8:
297 define 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>* %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
309 ; CHECK-LABEL: test_v2i32_i64:
310 define void @test_v2i32_i64(i64* %p, <2 x i32>* %q) {
312 ; CHECK: rev64 v{{[0-9]+}}.2s
313 ; CHECK: st1 { v{{[0-9]+}}.2s }
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
322 ; CHECK-LABEL: test_v2i32_f64:
323 define void @test_v2i32_f64(double* %p, <2 x i32>* %q) {
325 ; CHECK: rev64 v{{[0-9]+}}.2s
326 ; CHECK: st1 { v{{[0-9]+}}.2s }
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
335 ; CHECK-LABEL: test_v2i32_v1i64:
336 define void @test_v2i32_v1i64(<1 x i64>* %p, <2 x i32>* %q) {
338 ; CHECK: rev64 v{{[0-9]+}}.2s
339 ; CHECK: st1 { v{{[0-9]+}}.2s }
340 %1 = load <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
348 ; CHECK-LABEL: test_v2i32_v2f32:
349 define 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>* %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
360 ; CHECK-LABEL: test_v2i32_v4i16:
361 define 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>* %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
373 ; CHECK-LABEL: test_v2i32_v8i8:
374 define 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>* %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
386 ; CHECK-LABEL: test_v4i16_i64:
387 define void @test_v4i16_i64(i64* %p, <4 x i16>* %q) {
389 ; CHECK: rev64 v{{[0-9]+}}.4h
390 ; CHECK: st1 { v{{[0-9]+}}.4h }
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
399 ; CHECK-LABEL: test_v4i16_f64:
400 define void @test_v4i16_f64(double* %p, <4 x i16>* %q) {
402 ; CHECK: rev64 v{{[0-9]+}}.4h
403 ; CHECK: st1 { v{{[0-9]+}}.4h }
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
412 ; CHECK-LABEL: test_v4i16_v1i64:
413 define void @test_v4i16_v1i64(<1 x i64>* %p, <4 x i16>* %q) {
415 ; CHECK: rev64 v{{[0-9]+}}.4h
416 ; CHECK: st1 { v{{[0-9]+}}.4h }
417 %1 = load <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
425 ; CHECK-LABEL: test_v4i16_v2f32:
426 define 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>* %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
438 ; CHECK-LABEL: test_v4i16_v2i32:
439 define 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>* %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
451 ; CHECK-LABEL: test_v4i16_v8i8:
452 define 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>* %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
464 ; CHECK-LABEL: test_v8i8_i64:
465 define void @test_v8i8_i64(i64* %p, <8 x i8>* %q) {
467 ; CHECK: rev64 v{{[0-9]+}}.8b
468 ; CHECK: st1 { v{{[0-9]+}}.8b }
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
477 ; CHECK-LABEL: test_v8i8_f64:
478 define void @test_v8i8_f64(double* %p, <8 x i8>* %q) {
480 ; CHECK: rev64 v{{[0-9]+}}.8b
481 ; CHECK: st1 { v{{[0-9]+}}.8b }
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
490 ; CHECK-LABEL: test_v8i8_v1i64:
491 define void @test_v8i8_v1i64(<1 x i64>* %p, <8 x i8>* %q) {
493 ; CHECK: rev64 v{{[0-9]+}}.8b
494 ; CHECK: st1 { v{{[0-9]+}}.8b }
495 %1 = load <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
503 ; CHECK-LABEL: test_v8i8_v2f32:
504 define 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>* %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
516 ; CHECK-LABEL: test_v8i8_v2i32:
517 define 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>* %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
529 ; CHECK-LABEL: test_v8i8_v4i16:
530 define 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>* %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
542 ; CHECK-LABEL: test_f128_v2f64:
543 define void @test_f128_v2f64(<2 x double>* %p, fp128* %q) {
544 ; CHECK: ld1 { v{{[0-9]+}}.2d }
547 %1 = load <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
555 ; CHECK-LABEL: test_f128_v2i64:
556 define void @test_f128_v2i64(<2 x i64>* %p, fp128* %q) {
557 ; CHECK: ld1 { v{{[0-9]+}}.2d }
560 %1 = load <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
568 ; CHECK-LABEL: test_f128_v4f32:
569 define 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
575 %1 = load <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
583 ; CHECK-LABEL: test_f128_v4i32:
584 define void @test_f128_v4i32(<4 x i32>* %p, fp128* %q) {
585 ; CHECK: ld1 { v{{[0-9]+}}.4s }
586 ; CHECK: rev64 v{{[0-9]+}}.4s
589 %1 = load <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
597 ; CHECK-LABEL: test_f128_v8i16:
598 define void @test_f128_v8i16(<8 x i16>* %p, fp128* %q) {
599 ; CHECK: ld1 { v{{[0-9]+}}.8h }
600 ; CHECK: rev64 v{{[0-9]+}}.8h
603 %1 = load <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
611 ; CHECK-LABEL: test_f128_v16i8:
612 define void @test_f128_v16i8(<16 x i8>* %p, fp128* %q) {
613 ; CHECK: ld1 { v{{[0-9]+}}.16b }
616 %1 = load <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
624 ; CHECK-LABEL: test_v2f64_f128:
625 define void @test_v2f64_f128(fp128* %p, <2 x double>* %q) {
628 ; CHECK: st1 { v{{[0-9]+}}.2d }
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
637 ; CHECK-LABEL: test_v2f64_v2i64:
638 define 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>* %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
649 ; CHECK-LABEL: test_v2f64_v4f32:
650 define 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>* %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
663 ; CHECK-LABEL: test_v2f64_v4i32:
664 define 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>* %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
676 ; CHECK-LABEL: test_v2f64_v8i16:
677 define 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>* %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
689 ; CHECK-LABEL: test_v2f64_v16i8:
690 define 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>* %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
702 ; CHECK-LABEL: test_v2i64_f128:
703 define void @test_v2i64_f128(fp128* %p, <2 x i64>* %q) {
706 ; CHECK: st1 { v{{[0-9]+}}.2d }
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
715 ; CHECK-LABEL: test_v2i64_v2f64:
716 define 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>* %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
727 ; CHECK-LABEL: test_v2i64_v4f32:
728 define 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>* %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
741 ; CHECK-LABEL: test_v2i64_v4i32:
742 define 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>* %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
754 ; CHECK-LABEL: test_v2i64_v8i16:
755 define 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>* %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
767 ; CHECK-LABEL: test_v2i64_v16i8:
768 define 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>* %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
780 ; CHECK-LABEL: test_v4f32_f128:
781 define void @test_v4f32_f128(fp128* %p, <4 x float>* %q) {
783 ; CHECK: rev64 v{{[0-9]+}}.4s
785 ; CHECK: rev64 v{{[0-9]+}}.4s
786 ; CHECK: st1 { v{{[0-9]+}}.2d }
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
795 ; CHECK-LABEL: test_v4f32_v2f64:
796 define 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>* %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
809 ; CHECK-LABEL: test_v4f32_v2i64:
810 define 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>* %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
823 ; CHECK-LABEL: test_v4f32_v4i32:
824 define 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>* %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
836 ; CHECK-LABEL: test_v4f32_v8i16:
837 define 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>* %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
850 ; CHECK-LABEL: test_v4f32_v16i8:
851 define 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>* %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
864 ; CHECK-LABEL: test_v4i32_f128:
865 define void @test_v4i32_f128(fp128* %p, <4 x i32>* %q) {
867 ; CHECK: rev64 v{{[0-9]+}}.4s
869 ; CHECK: st1 { v{{[0-9]+}}.4s }
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
878 ; CHECK-LABEL: test_v4i32_v2f64:
879 define 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>* %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
891 ; CHECK-LABEL: test_v4i32_v2i64:
892 define 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>* %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
904 ; CHECK-LABEL: test_v4i32_v4f32:
905 define 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>* %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
917 ; CHECK-LABEL: test_v4i32_v8i16:
918 define 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>* %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
930 ; CHECK-LABEL: test_v4i32_v16i8:
931 define 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>* %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
943 ; CHECK-LABEL: test_v8i16_f128:
944 define void @test_v8i16_f128(fp128* %p, <8 x i16>* %q) {
946 ; CHECK: rev64 v{{[0-9]+}}.8h
948 ; CHECK: st1 { v{{[0-9]+}}.8h }
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
957 ; CHECK-LABEL: test_v8i16_v2f64:
958 define 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>* %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
970 ; CHECK-LABEL: test_v8i16_v2i64:
971 define 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>* %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
983 ; CHECK-LABEL: test_v8i16_v4f32:
984 define 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>* %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
997 ; CHECK-LABEL: test_v8i16_v4i32:
998 define 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>* %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
1010 ; CHECK-LABEL: test_v8i16_v16i8:
1011 define 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>* %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
1023 ; CHECK-LABEL: test_v16i8_f128:
1024 define void @test_v16i8_f128(fp128* %p, <16 x i8>* %q) {
1026 ; CHECK: rev64 v{{[0-9]+}}.16b
1028 ; CHECK: st1 { v{{[0-9]+}}.16b }
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
1037 ; CHECK-LABEL: test_v16i8_v2f64:
1038 define 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>* %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
1050 ; CHECK-LABEL: test_v16i8_v2i64:
1051 define 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>* %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
1063 ; CHECK-LABEL: test_v16i8_v4f32:
1064 define 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>* %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
1077 ; CHECK-LABEL: test_v16i8_v4i32:
1078 define 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>* %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
1090 ; CHECK-LABEL: test_v16i8_v8i16:
1091 define 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>* %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