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

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