gcc/testsuite/gcc.target/aarch64/vreinterpret_f64_1.c

   1 /* Test vreinterpret_f64_* and vreinterpret_*_f64 intrinsics work correctly.  */
   2 /* { dg-do run } */
   3 /* { dg-options "-O3" } */
   4
   5 #include <arm_neon.h>
   6
   7 extern void abort (void);
   8
   9 #define ABS(a) __builtin_fabs (a)
  10 #define ISNAN(a) __builtin_isnan (a)
  11
  12 #define DOUBLE_EQUALS(a, b, epsilon)            \
  13 (                                               \
  14  ((a) == (b))                                   \
  15   || (ISNAN (a) && ISNAN (b))                   \
  16   || (ABS (a - b) < epsilon)                    \
  17 )
  18
  19 /* Pi accurate up to 16 digits.
  20    Further digits are a closest binary approximation.  */
  21 #define PI_F64 3.14159265358979311599796346854
  22 /* Hex representation in Double (IEEE754 Double precision 64-bit) is:
  23    0x400921FB54442D18.  */
  24
  25 /* E accurate up to 16 digits.
  26    Further digits are a closest binary approximation.  */
  27 #define E_F64 2.71828182845904509079559829843
  28 /* Hex representation in Double (IEEE754 Double precision 64-bit) is:
  29    0x4005BF0A8B145769.  */
  30
  31 float32x2_t __attribute__ ((noinline))
  32 wrap_vreinterpret_f32_f64 (float64x1_t __a)
  33 {
  34   return vreinterpret_f32_f64 (__a);
  35 }
  36
  37 int __attribute__ ((noinline))
  38 test_vreinterpret_f32_f64 ()
  39 {
  40   float64x1_t a;
  41   float32x2_t b;
  42   float64_t c[1] = { PI_F64 };
  43   /* Values { 0x54442D18, 0x400921FB } reinterpreted as f32.  */
  44   float32_t d[2] = { 3.3702805504E12, 2.1426990032196044921875E0 };
  45   float32_t e[2];
  46   int i;
  47
  48   a = vld1_f64 (c);
  49   b = wrap_vreinterpret_f32_f64 (a);
  50   vst1_f32 (e, b);
  51   for (i = 0; i < 2; i++)
  52     if (!DOUBLE_EQUALS (d[i], e[i], __FLT_EPSILON__))
  53       return 1;
  54   return 0;
  55 };
  56
  57 int8x8_t __attribute__ ((noinline))
  58 wrap_vreinterpret_s8_f64 (float64x1_t __a)
  59 {
  60   return vreinterpret_s8_f64 (__a);
  61 }
  62
  63 int __attribute__ ((noinline))
  64 test_vreinterpret_s8_f64 ()
  65 {
  66   float64x1_t a;
  67   int8x8_t b;
  68   float64_t c[1] = { PI_F64 };
  69   int8_t d[8] = { 0x18, 0x2D, 0x44, 0x54, 0xFB, 0x21, 0x09, 0x40 };
  70   int8_t e[8];
  71   int i;
  72
  73   a = vld1_f64 (c);
  74   b = wrap_vreinterpret_s8_f64 (a);
  75   vst1_s8 (e, b);
  76   for (i = 0; i < 8; i++)
  77     if (d[i] != e[i])
  78       return 1;
  79   return 0;
  80 };
  81
  82 int16x4_t __attribute__ ((noinline))
  83 wrap_vreinterpret_s16_f64 (float64x1_t __a)
  84 {
  85   return vreinterpret_s16_f64 (__a);
  86 }
  87
  88 int __attribute__ ((noinline))
  89 test_vreinterpret_s16_f64 ()
  90 {
  91   float64x1_t a;
  92   int16x4_t b;
  93   float64_t c[1] = { PI_F64 };
  94   int16_t d[4] = { 0x2D18, 0x5444, 0x21FB, 0x4009 };
  95   int16_t e[4];
  96   int i;
  97
  98   a = vld1_f64 (c);
  99   b = wrap_vreinterpret_s16_f64 (a);
 100   vst1_s16 (e, b);
 101   for (i = 0; i < 4; i++)
 102     if (d[i] != e[i])
 103       return 1;
 104   return 0;
 105 };
 106
 107 int32x2_t __attribute__ ((noinline))
 108 wrap_vreinterpret_s32_f64 (float64x1_t __a)
 109 {
 110   return vreinterpret_s32_f64 (__a);
 111 }
 112
 113 int __attribute__ ((noinline))
 114 test_vreinterpret_s32_f64 ()
 115 {
 116   float64x1_t a;
 117   int32x2_t b;
 118   float64_t c[1] = { PI_F64 };
 119   int32_t d[2] = { 0x54442D18, 0x400921FB };
 120   int32_t e[2];
 121   int i;
 122
 123   a = vld1_f64 (c);
 124   b = wrap_vreinterpret_s32_f64 (a);
 125   vst1_s32 (e, b);
 126   for (i = 0; i < 2; i++)
 127     if (d[i] != e[i])
 128       return 1;
 129   return 0;
 130 };
 131
 132 int64x1_t __attribute__ ((noinline))
 133 wrap_vreinterpret_s64_f64 (float64x1_t __a)
 134 {
 135   return vreinterpret_s64_f64 (__a);
 136 }
 137
 138 int __attribute__ ((noinline))
 139 test_vreinterpret_s64_f64 ()
 140 {
 141   float64x1_t a;
 142   int64x1_t b;
 143   float64_t c[1] = { PI_F64 };
 144   int64_t d[1] = { 0x400921FB54442D18 };
 145   int64_t e[1];
 146   int i;
 147
 148   a = vld1_f64 (c);
 149   b = wrap_vreinterpret_s64_f64 (a);
 150   vst1_s64 (e, b);
 151   if (d[0] != e[0])
 152     return 1;
 153   return 0;
 154 };
 155
 156 float32x4_t __attribute__ ((noinline))
 157 wrap_vreinterpretq_f32_f64 (float64x2_t __a)
 158 {
 159   return vreinterpretq_f32_f64 (__a);
 160 }
 161
 162 int __attribute__ ((noinline))
 163 test_vreinterpretq_f32_f64 ()
 164 {
 165   float64x2_t a;
 166   float32x4_t b;
 167   float64_t c[2] = { PI_F64, E_F64 };
 168
 169   /* Values corresponding to f32 reinterpret of
 170      { 0x54442D18, 0x400921FB, 0x8B145769, 0x4005BF0A }.  */
 171   float32_t d[4] = { 3.3702805504E12,
 172                      2.1426990032196044921875E0,
 173                      -2.8569523269651966444143014594E-32,
 174                      2.089785099029541015625E0 };
 175   float32_t e[4];
 176   int i;
 177
 178   a = vld1q_f64 (c);
 179   b = wrap_vreinterpretq_f32_f64 (a);
 180   vst1q_f32 (e, b);
 181   for (i = 0; i < 4; i++)
 182     {
 183       if (!DOUBLE_EQUALS (d[i], e[i], __FLT_EPSILON__))
 184         return 1;
 185     }
 186   return 0;
 187 };
 188
 189 int8x16_t __attribute__ ((noinline))
 190 wrap_vreinterpretq_s8_f64 (float64x2_t __a)
 191 {
 192   return vreinterpretq_s8_f64 (__a);
 193 }
 194
 195 int __attribute__ ((noinline))
 196 test_vreinterpretq_s8_f64 ()
 197 {
 198   float64x2_t a;
 199   int8x16_t b;
 200   float64_t c[2] = { PI_F64, E_F64 };
 201   int8_t d[16] = { 0x18, 0x2D, 0x44, 0x54, 0xFB, 0x21, 0x09, 0x40,
 202                    0x69, 0x57, 0x14, 0x8B, 0x0A, 0xBF, 0x05, 0x40 };
 203   int8_t e[16];
 204   int i;
 205
 206   a = vld1q_f64 (c);
 207   b = wrap_vreinterpretq_s8_f64 (a);
 208   vst1q_s8 (e, b);
 209   for (i = 0; i < 16; i++)
 210     if (d[i] != e[i])
 211       return 1;
 212   return 0;
 213 };
 214
 215 int16x8_t __attribute__ ((noinline))
 216 wrap_vreinterpretq_s16_f64 (float64x2_t __a)
 217 {
 218   return vreinterpretq_s16_f64 (__a);
 219 }
 220
 221 int __attribute__ ((noinline))
 222 test_vreinterpretq_s16_f64 ()
 223 {
 224   float64x2_t a;
 225   int16x8_t b;
 226   float64_t c[2] = { PI_F64, E_F64 };
 227   int16_t d[8] = { 0x2D18, 0x5444, 0x21FB, 0x4009,
 228                    0x5769, 0x8B14, 0xBF0A, 0x4005 };
 229   int16_t e[8];
 230   int i;
 231
 232   a = vld1q_f64 (c);
 233   b = wrap_vreinterpretq_s16_f64 (a);
 234   vst1q_s16 (e, b);
 235   for (i = 0; i < 8; i++)
 236     if (d[i] != e[i])
 237       return 1;
 238   return 0;
 239 };
 240
 241 int32x4_t __attribute__ ((noinline))
 242 wrap_vreinterpretq_s32_f64 (float64x2_t __a)
 243 {
 244   return vreinterpretq_s32_f64 (__a);
 245 }
 246
 247 int __attribute__ ((noinline))
 248 test_vreinterpretq_s32_f64 ()
 249 {
 250   float64x2_t a;
 251   int32x4_t b;
 252   float64_t c[2] = { PI_F64, E_F64 };
 253   int32_t d[4] = { 0x54442D18, 0x400921FB, 0x8B145769, 0x4005BF0A };
 254   int32_t e[4];
 255   int i;
 256
 257   a = vld1q_f64 (c);
 258   b = wrap_vreinterpretq_s32_f64 (a);
 259   vst1q_s32 (e, b);
 260   for (i = 0; i < 4; i++)
 261     if (d[i] != e[i])
 262       return 1;
 263   return 0;
 264 };
 265
 266 int64x2_t __attribute__ ((noinline))
 267 wrap_vreinterpretq_s64_f64 (float64x2_t __a)
 268 {
 269   return vreinterpretq_s64_f64 (__a);
 270 }
 271
 272 int __attribute__ ((noinline))
 273 test_vreinterpretq_s64_f64 ()
 274 {
 275   float64x2_t a;
 276   int64x2_t b;
 277   float64_t c[2] = { PI_F64, E_F64 };
 278   int64_t d[2] = { 0x400921FB54442D18, 0x4005BF0A8B145769 };
 279   int64_t e[2];
 280   int i;
 281
 282   a = vld1q_f64 (c);
 283   b = wrap_vreinterpretq_s64_f64 (a);
 284   vst1q_s64 (e, b);
 285   for (i = 0; i < 2; i++)
 286     if (d[i] != e[i])
 287       return 1;
 288   return 0;
 289 };
 290
 291 float64x1_t __attribute__ ((noinline))
 292 wrap_vreinterpret_f64_f32 (float32x2_t __a)
 293 {
 294   return vreinterpret_f64_f32 (__a);
 295 }
 296
 297 int __attribute__ ((noinline))
 298 test_vreinterpret_f64_f32 ()
 299 {
 300   float32x2_t a;
 301   float64x1_t b;
 302   /* Values { 0x54442D18, 0x400921FB } reinterpreted as f32.  */
 303   float32_t c[2] = { 3.3702805504E12, 2.1426990032196044921875E0 };
 304   float64_t d[1] = { PI_F64 };
 305   float64_t e[1];
 306   int i;
 307
 308   a = vld1_f32 (c);
 309   b = wrap_vreinterpret_f64_f32 (a);
 310   vst1_f64 (e, b);
 311   if (!DOUBLE_EQUALS (d[0], e[0], __DBL_EPSILON__))
 312     return 1;
 313   return 0;
 314 };
 315
 316 float64x1_t __attribute__ ((noinline))
 317 wrap_vreinterpret_f64_s8 (int8x8_t __a)
 318 {
 319   return vreinterpret_f64_s8 (__a);
 320 }
 321
 322 int __attribute__ ((noinline))
 323 test_vreinterpret_f64_s8 ()
 324 {
 325   int8x8_t a;
 326   float64x1_t b;
 327   int8_t c[8] = { 0x18, 0x2D, 0x44, 0x54, 0xFB, 0x21, 0x09, 0x40 };
 328   float64_t d[1] = { PI_F64 };
 329   float64_t e[1];
 330   int i;
 331
 332   a = vld1_s8 (c);
 333   b = wrap_vreinterpret_f64_s8 (a);
 334   vst1_f64 (e, b);
 335   if (!DOUBLE_EQUALS (d[0], e[0], __DBL_EPSILON__))
 336     return 1;
 337   return 0;
 338 };
 339
 340 float64x1_t __attribute__ ((noinline))
 341 wrap_vreinterpret_f64_s16 (int16x4_t __a)
 342 {
 343   return vreinterpret_f64_s16 (__a);
 344 }
 345
 346 int __attribute__ ((noinline))
 347 test_vreinterpret_f64_s16 ()
 348 {
 349   int16x4_t a;
 350   float64x1_t b;
 351   int16_t c[4] = { 0x2D18, 0x5444, 0x21FB, 0x4009 };
 352   float64_t d[1] = { PI_F64 };
 353   float64_t e[1];
 354   int i;
 355
 356   a = vld1_s16 (c);
 357   b = wrap_vreinterpret_f64_s16 (a);
 358   vst1_f64 (e, b);
 359   if (!DOUBLE_EQUALS (d[0], e[0], __DBL_EPSILON__))
 360     return 1;
 361   return 0;
 362 };
 363
 364 float64x1_t __attribute__ ((noinline))
 365 wrap_vreinterpret_f64_s32 (int32x2_t __a)
 366 {
 367   return vreinterpret_f64_s32 (__a);
 368 }
 369
 370 int __attribute__ ((noinline))
 371 test_vreinterpret_f64_s32 ()
 372 {
 373   int32x2_t a;
 374   float64x1_t b;
 375   int32_t c[2] = { 0x54442D18, 0x400921FB };
 376   float64_t d[1] = { PI_F64 };
 377   float64_t e[1];
 378   int i;
 379
 380   a = vld1_s32 (c);
 381   b = wrap_vreinterpret_f64_s32 (a);
 382   vst1_f64 (e, b);
 383   if (!DOUBLE_EQUALS (d[0], e[0], __DBL_EPSILON__))
 384     return 1;
 385   return 0;
 386 };
 387
 388 float64x1_t __attribute__ ((noinline))
 389 wrap_vreinterpret_f64_s64 (int64x1_t __a)
 390 {
 391   return vreinterpret_f64_s64 (__a);
 392 }
 393
 394 int __attribute__ ((noinline))
 395 test_vreinterpret_f64_s64 ()
 396 {
 397   int64x1_t a;
 398   float64x1_t b;
 399   int64_t c[1] = { 0x400921FB54442D18 };
 400   float64_t d[1] = { PI_F64 };
 401   float64_t e[1];
 402
 403   a = vld1_s64 (c);
 404   b = wrap_vreinterpret_f64_s64 (a);
 405   vst1_f64 (e, b);
 406   if (!DOUBLE_EQUALS (d[0], e[0], __DBL_EPSILON__))
 407     return 1;
 408   return 0;
 409 };
 410
 411 float64x2_t __attribute__ ((noinline))
 412 wrap_vreinterpretq_f64_f32 (float32x4_t __a)
 413 {
 414   return vreinterpretq_f64_f32 (__a);
 415 }
 416
 417 int __attribute__ ((noinline))
 418 test_vreinterpretq_f64_f32 ()
 419 {
 420   float32x4_t a;
 421   float64x2_t b;
 422   /* Values corresponding to f32 reinterpret of
 423      { 0x54442D18, 0x400921FB, 0x8B145769, 0x4005BF0A }.  */
 424   float32_t c[4] = { 3.3702805504E12,
 425                      2.1426990032196044921875E0,
 426                      -2.8569523269651966444143014594E-32,
 427                      2.089785099029541015625E0 };
 428
 429   float64_t d[2] = { PI_F64, E_F64 };
 430   float64_t e[2];
 431   int i;
 432
 433   a = vld1q_f32 (c);
 434   b = wrap_vreinterpretq_f64_f32 (a);
 435   vst1q_f64 (e, b);
 436   for (i = 0; i < 2; i++)
 437     if (!DOUBLE_EQUALS (d[i], e[i], __DBL_EPSILON__))
 438       return 1;
 439   return 0;
 440 };
 441
 442 float64x2_t __attribute__ ((noinline))
 443 wrap_vreinterpretq_f64_s8 (int8x16_t __a)
 444 {
 445   return vreinterpretq_f64_s8 (__a);
 446 }
 447
 448 int __attribute__ ((noinline))
 449 test_vreinterpretq_f64_s8 ()
 450 {
 451   int8x16_t a;
 452   float64x2_t b;
 453   int8_t c[16] = { 0x18, 0x2D, 0x44, 0x54, 0xFB, 0x21, 0x09, 0x40,
 454                    0x69, 0x57, 0x14, 0x8B, 0x0A, 0xBF, 0x05, 0x40 };
 455   float64_t d[2] = { PI_F64, E_F64 };
 456   float64_t e[2];
 457   int i;
 458
 459   a = vld1q_s8 (c);
 460   b = wrap_vreinterpretq_f64_s8 (a);
 461   vst1q_f64 (e, b);
 462   for (i = 0; i < 2; i++)
 463     if (!DOUBLE_EQUALS (d[i], e[i], __DBL_EPSILON__))
 464       return 1;
 465   return 0;
 466 };
 467
 468 float64x2_t __attribute__ ((noinline))
 469 wrap_vreinterpretq_f64_s16 (int16x8_t __a)
 470 {
 471   return vreinterpretq_f64_s16 (__a);
 472 }
 473
 474 int __attribute__ ((noinline))
 475 test_vreinterpretq_f64_s16 ()
 476 {
 477   int16x8_t a;
 478   float64x2_t b;
 479   int16_t c[8] = { 0x2D18, 0x5444, 0x21FB, 0x4009,
 480                    0x5769, 0x8B14, 0xBF0A, 0x4005 };
 481   float64_t d[2] = { PI_F64, E_F64 };
 482   float64_t e[2];
 483   int i;
 484
 485   a = vld1q_s16 (c);
 486   b = wrap_vreinterpretq_f64_s16 (a);
 487   vst1q_f64 (e, b);
 488   for (i = 0; i < 2; i++)
 489     if (!DOUBLE_EQUALS (d[i], e[i], __DBL_EPSILON__))
 490       return 1;
 491   return 0;
 492 };
 493
 494 float64x2_t __attribute__ ((noinline))
 495 wrap_vreinterpretq_f64_s32 (int32x4_t __a)
 496 {
 497   return vreinterpretq_f64_s32 (__a);
 498 }
 499
 500 int __attribute__ ((noinline))
 501 test_vreinterpretq_f64_s32 ()
 502 {
 503   int32x4_t a;
 504   float64x2_t b;
 505   int32_t c[4] = { 0x54442D18, 0x400921FB, 0x8B145769, 0x4005BF0A };
 506   float64_t d[2] = { PI_F64, E_F64 };
 507   float64_t e[2];
 508   int i;
 509
 510   a = vld1q_s32 (c);
 511   b = wrap_vreinterpretq_f64_s32 (a);
 512   vst1q_f64 (e, b);
 513   for (i = 0; i < 2; i++)
 514     if (!DOUBLE_EQUALS (d[i], e[i], __DBL_EPSILON__))
 515       return 1;
 516   return 0;
 517 };
 518
 519 float64x2_t __attribute__ ((noinline))
 520 wrap_vreinterpretq_f64_s64 (int64x2_t __a)
 521 {
 522   return vreinterpretq_f64_s64 (__a);
 523 }
 524
 525 int __attribute__ ((noinline))
 526 test_vreinterpretq_f64_s64 ()
 527 {
 528   int64x2_t a;
 529   float64x2_t b;
 530   int64_t c[2] = { 0x400921FB54442D18, 0x4005BF0A8B145769 };
 531   float64_t d[2] = { PI_F64, E_F64 };
 532   float64_t e[2];
 533   int i;
 534
 535   a = vld1q_s64 (c);
 536   b = wrap_vreinterpretq_f64_s64 (a);
 537   vst1q_f64 (e, b);
 538   for (i = 0; i < 2; i++)
 539     if (!DOUBLE_EQUALS (d[i], e[i], __DBL_EPSILON__))
 540       return 1;
 541   return 0;
 542 };
 543
 544 int
 545 main (int argc, char **argv)
 546 {
 547   if (test_vreinterpret_f32_f64 ())
 548     abort ();
 549
 550   if (test_vreinterpret_s8_f64 ())
 551     abort ();
 552   if (test_vreinterpret_s16_f64 ())
 553     abort ();
 554   if (test_vreinterpret_s32_f64 ())
 555     abort ();
 556   if (test_vreinterpret_s64_f64 ())
 557     abort ();
 558
 559   if (test_vreinterpretq_f32_f64 ())
 560     abort ();
 561
 562   if (test_vreinterpretq_s8_f64 ())
 563     abort ();
 564   if (test_vreinterpretq_s16_f64 ())
 565     abort ();
 566   if (test_vreinterpretq_s32_f64 ())
 567     abort ();
 568   if (test_vreinterpretq_s64_f64 ())
 569     abort ();
 570
 571   if (test_vreinterpret_f64_f32 ())
 572     abort ();
 573
 574   if (test_vreinterpret_f64_s8 ())
 575     abort ();
 576   if (test_vreinterpret_f64_s16 ())
 577     abort ();
 578   if (test_vreinterpret_f64_s32 ())
 579     abort ();
 580   if (test_vreinterpret_f64_s64 ())
 581     abort ();
 582
 583   if (test_vreinterpretq_f64_f32 ())
 584     abort ();
 585
 586   if (test_vreinterpretq_f64_s8 ())
 587     abort ();
 588   if (test_vreinterpretq_f64_s16 ())
 589     abort ();
 590   if (test_vreinterpretq_f64_s32 ())
 591     abort ();
 592   if (test_vreinterpretq_f64_s64 ())
 593     abort ();
 594
 595   return 0;
 596 }