Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/vdup_n_1.c

raw
1 /* Test vdup_lane intrinsics work correctly. */
2 /* { dg-do run } */
3 /* { dg-options "-O1 --save-temps" } */
4
5 #include <arm_neon.h>
6
7 extern void abort (void);
8
9 mfloat8x8_t __attribute__ ((noinline))
10 wrap_vdup_n_mf8 (mfloat8_t a)
11 {
12 return vdup_n_mf8 (a);
13 }
14
15 int __attribute__ ((noinline))
16 test_vdup_n_mf8 (mfloat8_t a)
17 {
18 mfloat8x8_t b;
19 mfloat8_t c[8];
20 int i;
21
22 b = wrap_vdup_n_mf8 (a);
23 vst1_mf8 (c, b);
24 for (i = 0; i < 8; i++)
25 if (__builtin_memcmp (&a, &c[i], 1) != 0)
26 return 1;
27 return 0;
28 }
29
30 mfloat8x16_t __attribute__ ((noinline))
31 wrap_vdupq_n_mf8 (mfloat8_t a)
32 {
33 return vdupq_n_mf8 (a);
34 }
35
36 int __attribute__ ((noinline))
37 test_vdupq_n_mf8 (mfloat8_t a)
38 {
39 mfloat8x16_t b;
40 mfloat8_t c[16];
41 int i;
42
43 b = wrap_vdupq_n_mf8 (a);
44 vst1q_mf8 (c, b);
45 for (i = 0; i < 16; i++)
46 if (__builtin_memcmp (&a, &c[i], 1) != 0)
47 return 1;
48 return 0;
49 }
50
51 float32x2_t __attribute__ ((noinline))
52 wrap_vdup_n_f32 (float32_t a)
53 {
54 return vdup_n_f32 (a);
55 }
56
57 int __attribute__ ((noinline))
58 test_vdup_n_f32 ()
59 {
60 float32_t a = 1.0;
61 float32x2_t b;
62 float32_t c[2];
63 int i;
64
65 b = wrap_vdup_n_f32 (a);
66 vst1_f32 (c, b);
67 for (i = 0; i < 2; i++)
68 if (a != c[i])
69 return 1;
70 return 0;
71 }
72
73 float32x4_t __attribute__ ((noinline))
74 wrap_vdupq_n_f32 (float32_t a)
75 {
76 return vdupq_n_f32 (a);
77 }
78
79 int __attribute__ ((noinline))
80 test_vdupq_n_f32 ()
81 {
82 float32_t a = 1.0;
83 float32x4_t b;
84 float32_t c[4];
85 int i;
86
87 b = wrap_vdupq_n_f32 (a);
88 vst1q_f32 (c, b);
89 for (i = 0; i < 4; i++)
90 if (a != c[i])
91 return 1;
92 return 0;
93 }
94
95 float64x1_t __attribute__ ((noinline))
96 wrap_vdup_n_f64 (float64_t a)
97 {
98 return vdup_n_f64 (a);
99 }
100
101 int __attribute__ ((noinline))
102 test_vdup_n_f64 ()
103 {
104 float64_t a = 1.0;
105 float64x1_t b;
106 float64_t c[1];
107 int i;
108
109 b = wrap_vdup_n_f64 (a);
110 vst1_f64 (c, b);
111 for (i = 0; i < 1; i++)
112 if (a != c[i])
113 return 1;
114 return 0;
115 }
116
117 float64x2_t __attribute__ ((noinline))
118 wrap_vdupq_n_f64 (float64_t a)
119 {
120 return vdupq_n_f64 (a);
121 }
122
123 int __attribute__ ((noinline))
124 test_vdupq_n_f64 ()
125 {
126 float64_t a = 1.0;
127 float64x2_t b;
128 float64_t c[2];
129 int i;
130
131 b = wrap_vdupq_n_f64 (a);
132 vst1q_f64 (c, b);
133 for (i = 0; i < 2; i++)
134 if (a != c[i])
135 return 1;
136 return 0;
137 }
138
139 poly8x8_t __attribute__ ((noinline))
140 wrap_vdup_n_p8 (poly8_t a)
141 {
142 return vdup_n_p8 (a);
143 }
144
145 int __attribute__ ((noinline))
146 test_vdup_n_p8 ()
147 {
148 poly8_t a = 1;
149 poly8x8_t b;
150 poly8_t c[8];
151 int i;
152
153 b = wrap_vdup_n_p8 (a);
154 vst1_p8 (c, b);
155 for (i = 0; i < 8; i++)
156 if (a != c[i])
157 return 1;
158 return 0;
159 }
160
161 poly8x16_t __attribute__ ((noinline))
162 wrap_vdupq_n_p8 (poly8_t a)
163 {
164 return vdupq_n_p8 (a);
165 }
166
167 int __attribute__ ((noinline))
168 test_vdupq_n_p8 ()
169 {
170 poly8_t a = 1;
171 poly8x16_t b;
172 poly8_t c[16];
173 int i;
174
175 b = wrap_vdupq_n_p8 (a);
176 vst1q_p8 (c, b);
177 for (i = 0; i < 16; i++)
178 if (a != c[i])
179 return 1;
180 return 0;
181 }
182
183 int8x8_t __attribute__ ((noinline))
184 wrap_vdup_n_s8 (int8_t a)
185 {
186 return vdup_n_s8 (a);
187 }
188
189 int __attribute__ ((noinline))
190 test_vdup_n_s8 ()
191 {
192 int8_t a = 1;
193 int8x8_t b;
194 int8_t c[8];
195 int i;
196
197 b = wrap_vdup_n_s8 (a);
198 vst1_s8 (c, b);
199 for (i = 0; i < 8; i++)
200 if (a != c[i])
201 return 1;
202 return 0;
203 }
204
205 int8x16_t __attribute__ ((noinline))
206 wrap_vdupq_n_s8 (int8_t a)
207 {
208 return vdupq_n_s8 (a);
209 }
210
211 int __attribute__ ((noinline))
212 test_vdupq_n_s8 ()
213 {
214 int8_t a = 1;
215 int8x16_t b;
216 int8_t c[16];
217 int i;
218
219 b = wrap_vdupq_n_s8 (a);
220 vst1q_s8 (c, b);
221 for (i = 0; i < 16; i++)
222 if (a != c[i])
223 return 1;
224 return 0;
225 }
226
227 uint8x8_t __attribute__ ((noinline))
228 wrap_vdup_n_u8 (uint8_t a)
229 {
230 return vdup_n_u8 (a);
231 }
232
233 int __attribute__ ((noinline))
234 test_vdup_n_u8 ()
235 {
236 uint8_t a = 1;
237 uint8x8_t b;
238 uint8_t c[8];
239 int i;
240
241 b = wrap_vdup_n_u8 (a);
242 vst1_u8 (c, b);
243 for (i = 0; i < 8; i++)
244 if (a != c[i])
245 return 1;
246 return 0;
247 }
248
249 uint8x16_t __attribute__ ((noinline))
250 wrap_vdupq_n_u8 (uint8_t a)
251 {
252 return vdupq_n_u8 (a);
253 }
254
255 int __attribute__ ((noinline))
256 test_vdupq_n_u8 ()
257 {
258 uint8_t a = 1;
259 uint8x16_t b;
260 uint8_t c[16];
261 int i;
262
263 b = wrap_vdupq_n_u8 (a);
264 vst1q_u8 (c, b);
265 for (i = 0; i < 16; i++)
266 if (a != c[i])
267 return 1;
268 return 0;
269 }
270
271 poly16x4_t __attribute__ ((noinline))
272 wrap_vdup_n_p16 (poly16_t a)
273 {
274 return vdup_n_p16 (a);
275 }
276
277 int __attribute__ ((noinline))
278 test_vdup_n_p16 ()
279 {
280 poly16_t a = 1;
281 poly16x4_t b;
282 poly16_t c[4];
283 int i;
284
285 b = wrap_vdup_n_p16 (a);
286 vst1_p16 (c, b);
287 for (i = 0; i < 4; i++)
288 if (a != c[i])
289 return 1;
290 return 0;
291 }
292
293 poly16x8_t __attribute__ ((noinline))
294 wrap_vdupq_n_p16 (poly16_t a)
295 {
296 return vdupq_n_p16 (a);
297 }
298
299 int __attribute__ ((noinline))
300 test_vdupq_n_p16 ()
301 {
302 poly16_t a = 1;
303 poly16x8_t b;
304 poly16_t c[8];
305 int i;
306
307 b = wrap_vdupq_n_p16 (a);
308 vst1q_p16 (c, b);
309 for (i = 0; i < 8; i++)
310 if (a != c[i])
311 return 1;
312 return 0;
313 }
314
315 int16x4_t __attribute__ ((noinline))
316 wrap_vdup_n_s16 (int16_t a)
317 {
318 return vdup_n_s16 (a);
319 }
320
321 int __attribute__ ((noinline))
322 test_vdup_n_s16 ()
323 {
324 int16_t a = 1;
325 int16x4_t b;
326 int16_t c[4];
327 int i;
328
329 b = wrap_vdup_n_s16 (a);
330 vst1_s16 (c, b);
331 for (i = 0; i < 4; i++)
332 if (a != c[i])
333 return 1;
334 return 0;
335 }
336
337 int16x8_t __attribute__ ((noinline))
338 wrap_vdupq_n_s16 (int16_t a)
339 {
340 return vdupq_n_s16 (a);
341 }
342
343 int __attribute__ ((noinline))
344 test_vdupq_n_s16 ()
345 {
346 int16_t a = 1;
347 int16x8_t b;
348 int16_t c[8];
349 int i;
350
351 b = wrap_vdupq_n_s16 (a);
352 vst1q_s16 (c, b);
353 for (i = 0; i < 8; i++)
354 if (a != c[i])
355 return 1;
356 return 0;
357 }
358
359 uint16x4_t __attribute__ ((noinline))
360 wrap_vdup_n_u16 (uint16_t a)
361 {
362 return vdup_n_u16 (a);
363 }
364
365 int __attribute__ ((noinline))
366 test_vdup_n_u16 ()
367 {
368 uint16_t a = 1;
369 uint16x4_t b;
370 uint16_t c[4];
371 int i;
372
373 b = wrap_vdup_n_u16 (a);
374 vst1_u16 (c, b);
375 for (i = 0; i < 4; i++)
376 if (a != c[i])
377 return 1;
378 return 0;
379 }
380
381 uint16x8_t __attribute__ ((noinline))
382 wrap_vdupq_n_u16 (uint16_t a)
383 {
384 return vdupq_n_u16 (a);
385 }
386
387 int __attribute__ ((noinline))
388 test_vdupq_n_u16 ()
389 {
390 uint16_t a = 1;
391 uint16x8_t b;
392 uint16_t c[8];
393 int i;
394
395 b = wrap_vdupq_n_u16 (a);
396 vst1q_u16 (c, b);
397 for (i = 0; i < 8; i++)
398 if (a != c[i])
399 return 1;
400 return 0;
401 }
402
403 int32x2_t __attribute__ ((noinline))
404 wrap_vdup_n_s32 (int32_t a)
405 {
406 return vdup_n_s32 (a);
407 }
408
409 int __attribute__ ((noinline))
410 test_vdup_n_s32 ()
411 {
412 int32_t a = 1;
413 int32x2_t b;
414 int32_t c[2];
415 int i;
416
417 b = wrap_vdup_n_s32 (a);
418 vst1_s32 (c, b);
419 for (i = 0; i < 2; i++)
420 if (a != c[i])
421 return 1;
422 return 0;
423 }
424
425 int32x4_t __attribute__ ((noinline))
426 wrap_vdupq_n_s32 (int32_t a)
427 {
428 return vdupq_n_s32 (a);
429 }
430
431 int __attribute__ ((noinline))
432 test_vdupq_n_s32 ()
433 {
434 int32_t a = 1;
435 int32x4_t b;
436 int32_t c[4];
437 int i;
438
439 b = wrap_vdupq_n_s32 (a);
440 vst1q_s32 (c, b);
441 for (i = 0; i < 4; i++)
442 if (a != c[i])
443 return 1;
444 return 0;
445 }
446
447 uint32x2_t __attribute__ ((noinline))
448 wrap_vdup_n_u32 (uint32_t a)
449 {
450 return vdup_n_u32 (a);
451 }
452
453 int __attribute__ ((noinline))
454 test_vdup_n_u32 ()
455 {
456 uint32_t a = 1;
457 uint32x2_t b;
458 uint32_t c[2];
459 int i;
460
461 b = wrap_vdup_n_u32 (a);
462 vst1_u32 (c, b);
463 for (i = 0; i < 2; i++)
464 if (a != c[i])
465 return 1;
466 return 0;
467 }
468
469 uint32x4_t __attribute__ ((noinline))
470 wrap_vdupq_n_u32 (uint32_t a)
471 {
472 return vdupq_n_u32 (a);
473 }
474
475 int __attribute__ ((noinline))
476 test_vdupq_n_u32 ()
477 {
478 uint32_t a = 1;
479 uint32x4_t b;
480 uint32_t c[4];
481 int i;
482
483 b = wrap_vdupq_n_u32 (a);
484 vst1q_u32 (c, b);
485 for (i = 0; i < 4; i++)
486 if (a != c[i])
487 return 1;
488 return 0;
489 }
490
491 int64x1_t __attribute__ ((noinline))
492 wrap_vdup_n_s64 (int64_t a)
493 {
494 return vdup_n_s64 (a);
495 }
496
497 int __attribute__ ((noinline))
498 test_vdup_n_s64 ()
499 {
500 int64_t a = 1;
501 int64x1_t b;
502 int64_t c[1];
503 int i;
504
505 b = wrap_vdup_n_s64 (a);
506 vst1_s64 (c, b);
507 for (i = 0; i < 1; i++)
508 if (a != c[i])
509 return 1;
510 return 0;
511 }
512
513 int64x2_t __attribute__ ((noinline))
514 wrap_vdupq_n_s64 (int64_t a)
515 {
516 return vdupq_n_s64 (a);
517 }
518
519 int __attribute__ ((noinline))
520 test_vdupq_n_s64 ()
521 {
522 int64_t a = 1;
523 int64x2_t b;
524 int64_t c[2];
525 int i;
526
527 b = wrap_vdupq_n_s64 (a);
528 vst1q_s64 (c, b);
529 for (i = 0; i < 2; i++)
530 if (a != c[i])
531 return 1;
532 return 0;
533 }
534
535 uint64x1_t __attribute__ ((noinline))
536 wrap_vdup_n_u64 (uint64_t a)
537 {
538 return vdup_n_u64 (a);
539 }
540
541 int __attribute__ ((noinline))
542 test_vdup_n_u64 ()
543 {
544 uint64_t a = 1;
545 uint64x1_t b;
546 uint64_t c[1];
547 int i;
548
549 b = wrap_vdup_n_u64 (a);
550 vst1_u64 (c, b);
551 for (i = 0; i < 1; i++)
552 if (a != c[i])
553 return 1;
554 return 0;
555 }
556
557 uint64x2_t __attribute__ ((noinline))
558 wrap_vdupq_n_u64 (uint64_t a)
559 {
560 return vdupq_n_u64 (a);
561 }
562
563 int __attribute__ ((noinline))
564 test_vdupq_n_u64 ()
565 {
566 uint64_t a = 1;
567 uint64x2_t b;
568 uint64_t c[2];
569 int i;
570
571 b = wrap_vdupq_n_u64 (a);
572 vst1q_u64 (c, b);
573 for (i = 0; i < 2; i++)
574 if (a != c[i])
575 return 1;
576 return 0;
577 }
578
579 int
580 main ()
581 {
582 mfloat8_t a, c;
583 uint8_t b = 11;
584 uint8_t d = 12;
585 __builtin_memcpy(&a, &b, 1);
586 __builtin_memcpy(&c, &d, 1);
587
588 if (test_vdup_n_mf8(a))
589 abort ();
590 if (test_vdupq_n_mf8(c))
591 abort ();
592 if (test_vdup_n_f32 ())
593 abort ();
594 if (test_vdup_n_f64 ())
595 abort ();
596 if (test_vdup_n_p8 ())
597 abort ();
598 if (test_vdup_n_u8 ())
599 abort ();
600 if (test_vdup_n_s8 ())
601 abort ();
602 if (test_vdup_n_p16 ())
603 abort ();
604 if (test_vdup_n_s16 ())
605 abort ();
606 if (test_vdup_n_u16 ())
607 abort ();
608 if (test_vdup_n_s32 ())
609 abort ();
610 if (test_vdup_n_u32 ())
611 abort ();
612 if (test_vdup_n_s64 ())
613 abort ();
614 if (test_vdup_n_u64 ())
615 abort ();
616 if (test_vdupq_n_f32 ())
617 abort ();
618 if (test_vdupq_n_f64 ())
619 abort ();
620 if (test_vdupq_n_p8 ())
621 abort ();
622 if (test_vdupq_n_u8 ())
623 abort ();
624 if (test_vdupq_n_s8 ())
625 abort ();
626 if (test_vdupq_n_p16 ())
627 abort ();
628 if (test_vdupq_n_s16 ())
629 abort ();
630 if (test_vdupq_n_u16 ())
631 abort ();
632 if (test_vdupq_n_s32 ())
633 abort ();
634 if (test_vdupq_n_u32 ())
635 abort ();
636 if (test_vdupq_n_s64 ())
637 abort ();
638 if (test_vdupq_n_u64 ())
639 abort ();
640 return 0;
641 }
642
643 /* No asm checks for vdup_n_f32, vdupq_n_f32, vdup_n_f64 and vdupq_n_f64.
644 Cannot force floating point value in general purpose regester. */
645
646 /* Asm check for test_vdup_n_mf8, test_vdup_n_p8, test_vdup_n_s8,
647 test_vdup_n_u8. */
648 /* { dg-final { scan-assembler-times "dup\\tv\[0-9\]+\.8b, w\[0-9\]+" 5 } } */
649
650 /* Asm check for test_vdupq_n_p8, test_vdupq_n_s8, test_vdupq_n_u8. */
651 /* { dg-final { scan-assembler-times "dup\\tv\[0-9\]+\.16b, w\[0-9\]+" 3 } } */
652
653 /* Asm check for test_vdupq_n_mf8. */
654 /* { dg-final { scan-assembler-times "dup\\tv\[0-9\]+\.16b, v\[0-9\]+\.b\\\[0\\\]" 1 } } */
655
656 /* Asm check for test_vdup_n_p16, test_vdup_n_s16, test_vdup_n_u16. */
657 /* { dg-final { scan-assembler-times "dup\\tv\[0-9\]+\.4h, w\[0-9\]+" 3 } } */
658
659 /* Asm check for test_vdupq_n_p16, test_vdupq_n_s16, test_vdupq_n_u16. */
660 /* { dg-final { scan-assembler-times "dup\\tv\[0-9\]+\.8h, w\[0-9\]+" 3 } } */
661
662 /* Asm check for test_vdup_n_s32, test_vdup_n_u32. */
663 /* { dg-final { scan-assembler-times "dup\\tv\[0-9\]+\.2s, w\[0-9\]+" 2 } } */
664
665 /* Asm check for test_vdupq_n_s32, test_vdupq_n_u32. */
666 /* { dg-final { scan-assembler-times "dup\\tv\[0-9\]+\.4s, w\[0-9\]+" 2 } } */
667
668 /* Asm check for test_vdup_n_s64, test_vdup_n_u64 are left out.
669 Attempts to make the compiler generate "dup\\td\[0-9\]+, x\[0-9\]+"
670 are not practical. */
671
672 /* Asm check for test_vdupq_n_s64, test_vdupq_n_u64. */
673 /* { dg-final { scan-assembler-times "dup\\tv\[0-9\]+\.2d, x\[0-9\]+" 2 } } */
674