| /* Test vreinterpret_f64_* and vreinterpret_*_f64 intrinsics work correctly. */ |
| /* { dg-do run } */ |
| /* { dg-options "-O3" } */ |
| |
| #include <arm_neon.h> |
| |
| extern void abort (void); |
| |
| #define ABS(a) __builtin_fabs (a) |
| #define ISNAN(a) __builtin_isnan (a) |
| |
| #define DOUBLE_EQUALS(a, b, epsilon) \ |
| ( \ |
| ((a) == (b)) \ |
| || (ISNAN (a) && ISNAN (b)) \ |
| || (ABS (a - b) < epsilon) \ |
| ) |
| |
| /* Pi accurate up to 16 digits. |
| Further digits are a closest binary approximation. */ |
| #define PI_F64 3.14159265358979311599796346854 |
| /* Hex representation in Double (IEEE754 Double precision 64-bit) is: |
| 0x400921FB54442D18. */ |
| |
| /* E accurate up to 16 digits. |
| Further digits are a closest binary approximation. */ |
| #define E_F64 2.71828182845904509079559829843 |
| /* Hex representation in Double (IEEE754 Double precision 64-bit) is: |
| 0x4005BF0A8B145769. */ |
| |
| float32x2_t __attribute__ ((noinline)) |
| wrap_vreinterpret_f32_f64 (float64x1_t __a) |
| { |
| return vreinterpret_f32_f64 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpret_f32_f64 () |
| { |
| float64x1_t a; |
| float32x2_t b; |
| float64_t c[1] = { PI_F64 }; |
| /* Values { 0x54442D18, 0x400921FB } reinterpreted as f32. */ |
| float32_t d[2] = { 3.3702805504E12, 2.1426990032196044921875E0 }; |
| float32_t e[2]; |
| int i; |
| |
| a = vld1_f64 (c); |
| b = wrap_vreinterpret_f32_f64 (a); |
| vst1_f32 (e, b); |
| for (i = 0; i < 2; i++) |
| if (!DOUBLE_EQUALS (d[i], e[i], __FLT_EPSILON__)) |
| return 1; |
| return 0; |
| }; |
| |
| int8x8_t __attribute__ ((noinline)) |
| wrap_vreinterpret_s8_f64 (float64x1_t __a) |
| { |
| return vreinterpret_s8_f64 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpret_s8_f64 () |
| { |
| float64x1_t a; |
| int8x8_t b; |
| float64_t c[1] = { PI_F64 }; |
| int8_t d[8] = { 0x18, 0x2D, 0x44, 0x54, 0xFB, 0x21, 0x09, 0x40 }; |
| int8_t e[8]; |
| int i; |
| |
| a = vld1_f64 (c); |
| b = wrap_vreinterpret_s8_f64 (a); |
| vst1_s8 (e, b); |
| for (i = 0; i < 8; i++) |
| if (d[i] != e[i]) |
| return 1; |
| return 0; |
| }; |
| |
| int16x4_t __attribute__ ((noinline)) |
| wrap_vreinterpret_s16_f64 (float64x1_t __a) |
| { |
| return vreinterpret_s16_f64 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpret_s16_f64 () |
| { |
| float64x1_t a; |
| int16x4_t b; |
| float64_t c[1] = { PI_F64 }; |
| int16_t d[4] = { 0x2D18, 0x5444, 0x21FB, 0x4009 }; |
| int16_t e[4]; |
| int i; |
| |
| a = vld1_f64 (c); |
| b = wrap_vreinterpret_s16_f64 (a); |
| vst1_s16 (e, b); |
| for (i = 0; i < 4; i++) |
| if (d[i] != e[i]) |
| return 1; |
| return 0; |
| }; |
| |
| int32x2_t __attribute__ ((noinline)) |
| wrap_vreinterpret_s32_f64 (float64x1_t __a) |
| { |
| return vreinterpret_s32_f64 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpret_s32_f64 () |
| { |
| float64x1_t a; |
| int32x2_t b; |
| float64_t c[1] = { PI_F64 }; |
| int32_t d[2] = { 0x54442D18, 0x400921FB }; |
| int32_t e[2]; |
| int i; |
| |
| a = vld1_f64 (c); |
| b = wrap_vreinterpret_s32_f64 (a); |
| vst1_s32 (e, b); |
| for (i = 0; i < 2; i++) |
| if (d[i] != e[i]) |
| return 1; |
| return 0; |
| }; |
| |
| int64x1_t __attribute__ ((noinline)) |
| wrap_vreinterpret_s64_f64 (float64x1_t __a) |
| { |
| return vreinterpret_s64_f64 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpret_s64_f64 () |
| { |
| float64x1_t a; |
| int64x1_t b; |
| float64_t c[1] = { PI_F64 }; |
| int64_t d[1] = { 0x400921FB54442D18 }; |
| int64_t e[1]; |
| int i; |
| |
| a = vld1_f64 (c); |
| b = wrap_vreinterpret_s64_f64 (a); |
| vst1_s64 (e, b); |
| if (d[0] != e[0]) |
| return 1; |
| return 0; |
| }; |
| |
| float32x4_t __attribute__ ((noinline)) |
| wrap_vreinterpretq_f32_f64 (float64x2_t __a) |
| { |
| return vreinterpretq_f32_f64 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpretq_f32_f64 () |
| { |
| float64x2_t a; |
| float32x4_t b; |
| float64_t c[2] = { PI_F64, E_F64 }; |
| |
| /* Values corresponding to f32 reinterpret of |
| { 0x54442D18, 0x400921FB, 0x8B145769, 0x4005BF0A }. */ |
| float32_t d[4] = { 3.3702805504E12, |
| 2.1426990032196044921875E0, |
| -2.8569523269651966444143014594E-32, |
| 2.089785099029541015625E0 }; |
| float32_t e[4]; |
| int i; |
| |
| a = vld1q_f64 (c); |
| b = wrap_vreinterpretq_f32_f64 (a); |
| vst1q_f32 (e, b); |
| for (i = 0; i < 4; i++) |
| { |
| if (!DOUBLE_EQUALS (d[i], e[i], __FLT_EPSILON__)) |
| return 1; |
| } |
| return 0; |
| }; |
| |
| int8x16_t __attribute__ ((noinline)) |
| wrap_vreinterpretq_s8_f64 (float64x2_t __a) |
| { |
| return vreinterpretq_s8_f64 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpretq_s8_f64 () |
| { |
| float64x2_t a; |
| int8x16_t b; |
| float64_t c[2] = { PI_F64, E_F64 }; |
| int8_t d[16] = { 0x18, 0x2D, 0x44, 0x54, 0xFB, 0x21, 0x09, 0x40, |
| 0x69, 0x57, 0x14, 0x8B, 0x0A, 0xBF, 0x05, 0x40 }; |
| int8_t e[16]; |
| int i; |
| |
| a = vld1q_f64 (c); |
| b = wrap_vreinterpretq_s8_f64 (a); |
| vst1q_s8 (e, b); |
| for (i = 0; i < 16; i++) |
| if (d[i] != e[i]) |
| return 1; |
| return 0; |
| }; |
| |
| int16x8_t __attribute__ ((noinline)) |
| wrap_vreinterpretq_s16_f64 (float64x2_t __a) |
| { |
| return vreinterpretq_s16_f64 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpretq_s16_f64 () |
| { |
| float64x2_t a; |
| int16x8_t b; |
| float64_t c[2] = { PI_F64, E_F64 }; |
| int16_t d[8] = { 0x2D18, 0x5444, 0x21FB, 0x4009, |
| 0x5769, 0x8B14, 0xBF0A, 0x4005 }; |
| int16_t e[8]; |
| int i; |
| |
| a = vld1q_f64 (c); |
| b = wrap_vreinterpretq_s16_f64 (a); |
| vst1q_s16 (e, b); |
| for (i = 0; i < 8; i++) |
| if (d[i] != e[i]) |
| return 1; |
| return 0; |
| }; |
| |
| int32x4_t __attribute__ ((noinline)) |
| wrap_vreinterpretq_s32_f64 (float64x2_t __a) |
| { |
| return vreinterpretq_s32_f64 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpretq_s32_f64 () |
| { |
| float64x2_t a; |
| int32x4_t b; |
| float64_t c[2] = { PI_F64, E_F64 }; |
| int32_t d[4] = { 0x54442D18, 0x400921FB, 0x8B145769, 0x4005BF0A }; |
| int32_t e[4]; |
| int i; |
| |
| a = vld1q_f64 (c); |
| b = wrap_vreinterpretq_s32_f64 (a); |
| vst1q_s32 (e, b); |
| for (i = 0; i < 4; i++) |
| if (d[i] != e[i]) |
| return 1; |
| return 0; |
| }; |
| |
| int64x2_t __attribute__ ((noinline)) |
| wrap_vreinterpretq_s64_f64 (float64x2_t __a) |
| { |
| return vreinterpretq_s64_f64 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpretq_s64_f64 () |
| { |
| float64x2_t a; |
| int64x2_t b; |
| float64_t c[2] = { PI_F64, E_F64 }; |
| int64_t d[2] = { 0x400921FB54442D18, 0x4005BF0A8B145769 }; |
| int64_t e[2]; |
| int i; |
| |
| a = vld1q_f64 (c); |
| b = wrap_vreinterpretq_s64_f64 (a); |
| vst1q_s64 (e, b); |
| for (i = 0; i < 2; i++) |
| if (d[i] != e[i]) |
| return 1; |
| return 0; |
| }; |
| |
| float64x1_t __attribute__ ((noinline)) |
| wrap_vreinterpret_f64_f32 (float32x2_t __a) |
| { |
| return vreinterpret_f64_f32 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpret_f64_f32 () |
| { |
| float32x2_t a; |
| float64x1_t b; |
| /* Values { 0x54442D18, 0x400921FB } reinterpreted as f32. */ |
| float32_t c[2] = { 3.3702805504E12, 2.1426990032196044921875E0 }; |
| float64_t d[1] = { PI_F64 }; |
| float64_t e[1]; |
| int i; |
| |
| a = vld1_f32 (c); |
| b = wrap_vreinterpret_f64_f32 (a); |
| vst1_f64 (e, b); |
| if (!DOUBLE_EQUALS (d[0], e[0], __DBL_EPSILON__)) |
| return 1; |
| return 0; |
| }; |
| |
| float64x1_t __attribute__ ((noinline)) |
| wrap_vreinterpret_f64_s8 (int8x8_t __a) |
| { |
| return vreinterpret_f64_s8 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpret_f64_s8 () |
| { |
| int8x8_t a; |
| float64x1_t b; |
| int8_t c[8] = { 0x18, 0x2D, 0x44, 0x54, 0xFB, 0x21, 0x09, 0x40 }; |
| float64_t d[1] = { PI_F64 }; |
| float64_t e[1]; |
| int i; |
| |
| a = vld1_s8 (c); |
| b = wrap_vreinterpret_f64_s8 (a); |
| vst1_f64 (e, b); |
| if (!DOUBLE_EQUALS (d[0], e[0], __DBL_EPSILON__)) |
| return 1; |
| return 0; |
| }; |
| |
| float64x1_t __attribute__ ((noinline)) |
| wrap_vreinterpret_f64_s16 (int16x4_t __a) |
| { |
| return vreinterpret_f64_s16 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpret_f64_s16 () |
| { |
| int16x4_t a; |
| float64x1_t b; |
| int16_t c[4] = { 0x2D18, 0x5444, 0x21FB, 0x4009 }; |
| float64_t d[1] = { PI_F64 }; |
| float64_t e[1]; |
| int i; |
| |
| a = vld1_s16 (c); |
| b = wrap_vreinterpret_f64_s16 (a); |
| vst1_f64 (e, b); |
| if (!DOUBLE_EQUALS (d[0], e[0], __DBL_EPSILON__)) |
| return 1; |
| return 0; |
| }; |
| |
| float64x1_t __attribute__ ((noinline)) |
| wrap_vreinterpret_f64_s32 (int32x2_t __a) |
| { |
| return vreinterpret_f64_s32 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpret_f64_s32 () |
| { |
| int32x2_t a; |
| float64x1_t b; |
| int32_t c[2] = { 0x54442D18, 0x400921FB }; |
| float64_t d[1] = { PI_F64 }; |
| float64_t e[1]; |
| int i; |
| |
| a = vld1_s32 (c); |
| b = wrap_vreinterpret_f64_s32 (a); |
| vst1_f64 (e, b); |
| if (!DOUBLE_EQUALS (d[0], e[0], __DBL_EPSILON__)) |
| return 1; |
| return 0; |
| }; |
| |
| float64x1_t __attribute__ ((noinline)) |
| wrap_vreinterpret_f64_s64 (int64x1_t __a) |
| { |
| return vreinterpret_f64_s64 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpret_f64_s64 () |
| { |
| int64x1_t a; |
| float64x1_t b; |
| int64_t c[1] = { 0x400921FB54442D18 }; |
| float64_t d[1] = { PI_F64 }; |
| float64_t e[1]; |
| |
| a = vld1_s64 (c); |
| b = wrap_vreinterpret_f64_s64 (a); |
| vst1_f64 (e, b); |
| if (!DOUBLE_EQUALS (d[0], e[0], __DBL_EPSILON__)) |
| return 1; |
| return 0; |
| }; |
| |
| float64x2_t __attribute__ ((noinline)) |
| wrap_vreinterpretq_f64_f32 (float32x4_t __a) |
| { |
| return vreinterpretq_f64_f32 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpretq_f64_f32 () |
| { |
| float32x4_t a; |
| float64x2_t b; |
| /* Values corresponding to f32 reinterpret of |
| { 0x54442D18, 0x400921FB, 0x8B145769, 0x4005BF0A }. */ |
| float32_t c[4] = { 3.3702805504E12, |
| 2.1426990032196044921875E0, |
| -2.8569523269651966444143014594E-32, |
| 2.089785099029541015625E0 }; |
| |
| float64_t d[2] = { PI_F64, E_F64 }; |
| float64_t e[2]; |
| int i; |
| |
| a = vld1q_f32 (c); |
| b = wrap_vreinterpretq_f64_f32 (a); |
| vst1q_f64 (e, b); |
| for (i = 0; i < 2; i++) |
| if (!DOUBLE_EQUALS (d[i], e[i], __DBL_EPSILON__)) |
| return 1; |
| return 0; |
| }; |
| |
| float64x2_t __attribute__ ((noinline)) |
| wrap_vreinterpretq_f64_s8 (int8x16_t __a) |
| { |
| return vreinterpretq_f64_s8 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpretq_f64_s8 () |
| { |
| int8x16_t a; |
| float64x2_t b; |
| int8_t c[16] = { 0x18, 0x2D, 0x44, 0x54, 0xFB, 0x21, 0x09, 0x40, |
| 0x69, 0x57, 0x14, 0x8B, 0x0A, 0xBF, 0x05, 0x40 }; |
| float64_t d[2] = { PI_F64, E_F64 }; |
| float64_t e[2]; |
| int i; |
| |
| a = vld1q_s8 (c); |
| b = wrap_vreinterpretq_f64_s8 (a); |
| vst1q_f64 (e, b); |
| for (i = 0; i < 2; i++) |
| if (!DOUBLE_EQUALS (d[i], e[i], __DBL_EPSILON__)) |
| return 1; |
| return 0; |
| }; |
| |
| float64x2_t __attribute__ ((noinline)) |
| wrap_vreinterpretq_f64_s16 (int16x8_t __a) |
| { |
| return vreinterpretq_f64_s16 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpretq_f64_s16 () |
| { |
| int16x8_t a; |
| float64x2_t b; |
| int16_t c[8] = { 0x2D18, 0x5444, 0x21FB, 0x4009, |
| 0x5769, 0x8B14, 0xBF0A, 0x4005 }; |
| float64_t d[2] = { PI_F64, E_F64 }; |
| float64_t e[2]; |
| int i; |
| |
| a = vld1q_s16 (c); |
| b = wrap_vreinterpretq_f64_s16 (a); |
| vst1q_f64 (e, b); |
| for (i = 0; i < 2; i++) |
| if (!DOUBLE_EQUALS (d[i], e[i], __DBL_EPSILON__)) |
| return 1; |
| return 0; |
| }; |
| |
| float64x2_t __attribute__ ((noinline)) |
| wrap_vreinterpretq_f64_s32 (int32x4_t __a) |
| { |
| return vreinterpretq_f64_s32 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpretq_f64_s32 () |
| { |
| int32x4_t a; |
| float64x2_t b; |
| int32_t c[4] = { 0x54442D18, 0x400921FB, 0x8B145769, 0x4005BF0A }; |
| float64_t d[2] = { PI_F64, E_F64 }; |
| float64_t e[2]; |
| int i; |
| |
| a = vld1q_s32 (c); |
| b = wrap_vreinterpretq_f64_s32 (a); |
| vst1q_f64 (e, b); |
| for (i = 0; i < 2; i++) |
| if (!DOUBLE_EQUALS (d[i], e[i], __DBL_EPSILON__)) |
| return 1; |
| return 0; |
| }; |
| |
| float64x2_t __attribute__ ((noinline)) |
| wrap_vreinterpretq_f64_s64 (int64x2_t __a) |
| { |
| return vreinterpretq_f64_s64 (__a); |
| } |
| |
| int __attribute__ ((noinline)) |
| test_vreinterpretq_f64_s64 () |
| { |
| int64x2_t a; |
| float64x2_t b; |
| int64_t c[2] = { 0x400921FB54442D18, 0x4005BF0A8B145769 }; |
| float64_t d[2] = { PI_F64, E_F64 }; |
| float64_t e[2]; |
| int i; |
| |
| a = vld1q_s64 (c); |
| b = wrap_vreinterpretq_f64_s64 (a); |
| vst1q_f64 (e, b); |
| for (i = 0; i < 2; i++) |
| if (!DOUBLE_EQUALS (d[i], e[i], __DBL_EPSILON__)) |
| return 1; |
| return 0; |
| }; |
| |
| int |
| main (int argc, char **argv) |
| { |
| if (test_vreinterpret_f32_f64 ()) |
| abort (); |
| |
| if (test_vreinterpret_s8_f64 ()) |
| abort (); |
| if (test_vreinterpret_s16_f64 ()) |
| abort (); |
| if (test_vreinterpret_s32_f64 ()) |
| abort (); |
| if (test_vreinterpret_s64_f64 ()) |
| abort (); |
| |
| if (test_vreinterpretq_f32_f64 ()) |
| abort (); |
| |
| if (test_vreinterpretq_s8_f64 ()) |
| abort (); |
| if (test_vreinterpretq_s16_f64 ()) |
| abort (); |
| if (test_vreinterpretq_s32_f64 ()) |
| abort (); |
| if (test_vreinterpretq_s64_f64 ()) |
| abort (); |
| |
| if (test_vreinterpret_f64_f32 ()) |
| abort (); |
| |
| if (test_vreinterpret_f64_s8 ()) |
| abort (); |
| if (test_vreinterpret_f64_s16 ()) |
| abort (); |
| if (test_vreinterpret_f64_s32 ()) |
| abort (); |
| if (test_vreinterpret_f64_s64 ()) |
| abort (); |
| |
| if (test_vreinterpretq_f64_f32 ()) |
| abort (); |
| |
| if (test_vreinterpretq_f64_s8 ()) |
| abort (); |
| if (test_vreinterpretq_f64_s16 ()) |
| abort (); |
| if (test_vreinterpretq_f64_s32 ()) |
| abort (); |
| if (test_vreinterpretq_f64_s64 ()) |
| abort (); |
| |
| return 0; |
| } |