diff options
Diffstat (limited to 'gcc/testsuite/gcc.target/avr/torture')
24 files changed, 1710 insertions, 1 deletions
diff --git a/gcc/testsuite/gcc.target/avr/torture/avr-torture.exp b/gcc/testsuite/gcc.target/avr/torture/avr-torture.exp index 61cd3197fb..3e5fdfbd42 100644 --- a/gcc/testsuite/gcc.target/avr/torture/avr-torture.exp +++ b/gcc/testsuite/gcc.target/avr/torture/avr-torture.exp @@ -1,4 +1,4 @@ -# Copyright (C) 2008 Free Software Foundation, Inc. +# Copyright (C) 2008-2014 Free Software Foundation, Inc. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by diff --git a/gcc/testsuite/gcc.target/avr/torture/builtins-3-absfx.c b/gcc/testsuite/gcc.target/avr/torture/builtins-3-absfx.c new file mode 100644 index 0000000000..a8bde2952d --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/builtins-3-absfx.c @@ -0,0 +1,171 @@ +/* { dg-options "-std=gnu99" } */ +/* { dg-do run } */ + +#include <stdfix.h> + +extern void abort (void); + +short fract test1_hr (short fract x) +{ + return abshr (x); +} + +fract test1_r (fract x) +{ + return absr (x); +} + +long fract test1_lr (long fract x) +{ + return abslr (x); +} + +long long fract test1_llr (long long fract x) +{ + return absllr (x); +} + +short accum test1_hk (short accum x) +{ + return abshk (x); +} + +accum test1_k (accum x) +{ + return absk (x); +} + +long accum test1_lk (long accum x) +{ + return abslk (x); +} + +long long accum test1_llk (long long accum x) +{ + return absllk (x); +} + + +short fract test2_hr (void) +{ + return abshr (-0.12hr); +} + +fract test2_r (void) +{ + return absr (-0.12r); +} + +long fract test2_lr (void) +{ + return abslr (-0.12lr); +} + +long long fract test2_llr (void) +{ + return absllr (-0.123456llr); +} + +short accum test2_hk (void) +{ + return abshk (-221.12hk); +} + +accum test2_k (void) +{ + return absk (-4321.12k); +} + +long accum test2_lk (void) +{ + return abslk (-4321.12lk); +} + +long long accum test2_llk (void) +{ + return absllk (-4321.12llk); +} + +#define TEST1(VAL,FX) \ + if (abs ## FX (-VAL ## FX -v) != VAL ## FX + v) \ + abort(); \ + if (abs ## FX (-VAL ## FX -v) != abs ## FX (VAL ## FX + v)) \ + abort(); + +#define TEST2(VAL,FX) \ + if (abs ## FX (-VAL ## FX) != VAL ## FX) \ + abort(); \ + if (abs ## FX (-VAL ## FX) != abs ## FX (VAL ## FX)) \ + abort(); + +const __flash short fract volatile v = 0.33hr; +const __flash short fract volatile z = 0hr; + +void test1 (void) +{ + TEST1 (0.123, hr); + TEST1 (0.123, r); + TEST1 (0.1234567, lr); + TEST1 (0.1234567, llr); + + TEST1 (223.123, hk); + TEST1 (12345.123, k); + TEST1 (12342345.123, lk); + TEST1 (12345.123, llk); +} + + +void test2 (void) +{ + TEST2 (0.123, hr); + TEST2 (0.123, r); + TEST2 (0.1234567, lr); + TEST2 (0.1234567, llr); + + TEST2 (223.123, hk); + TEST2 (12345.123, k); + TEST2 (12342345.123, lk); + TEST2 (12345.123, llk); +} + +#define MINMAX(T,FX) \ + { \ + int_ ## FX ## _t imin \ + = (int_ ## FX ## _t) 1 << (8 * sizeof (int_ ## FX ## _t) -1); \ + int_ ## FX ## _t imax = ~imin; \ + T fmin = FX ## bits (imin); \ + T fmax = FX ## bits (imax); \ + \ + if (abs ## FX (fmin) != fmax) \ + abort(); \ + if (abs ## FX (fmin) != abs ## FX (fmax)) \ + abort(); \ + if (abs ## FX (fmin + z) != fmax + z) \ + abort(); \ + if (abs ## FX (fmin - z) != abs ## FX (fmax + z)) \ + abort(); \ + } + +void test3 (void) +{ + MINMAX (short fract, hr); + MINMAX (fract, r); + MINMAX (long fract, lr); + MINMAX (long long fract, llr); + + MINMAX (short accum, hk); + MINMAX (accum, k); + MINMAX (long accum, lk); + MINMAX (long long accum, llk); +} + + +int main (void) +{ + test1(); + test2(); + test3(); + + return 0; +} + diff --git a/gcc/testsuite/gcc.target/avr/torture/builtins-4-roundfx.c b/gcc/testsuite/gcc.target/avr/torture/builtins-4-roundfx.c new file mode 100644 index 0000000000..46e915a6c8 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/builtins-4-roundfx.c @@ -0,0 +1,164 @@ +/* { dg-options "-std=gnu99" } */ +/* { dg-do run } */ + +#include <stdfix.h> + +extern void abort (void); + +typedef short _Fract fx_hr_t; +typedef _Fract fx_r_t; +typedef long _Fract fx_lr_t; +typedef long long _Fract fx_llr_t; + +typedef unsigned short _Fract fx_uhr_t; +typedef unsigned _Fract fx_ur_t; +typedef unsigned long _Fract fx_ulr_t; +typedef unsigned long long _Fract fx_ullr_t; + +typedef short _Accum fx_hk_t; +typedef _Accum fx_k_t; +typedef long _Accum fx_lk_t; +typedef long long _Accum fx_llk_t; + +typedef unsigned short _Accum fx_uhk_t; +typedef unsigned _Accum fx_uk_t; +typedef unsigned long _Accum fx_ulk_t; +typedef unsigned long long _Accum fx_ullk_t; + + +typedef unsigned char int_uhr_t; +typedef unsigned int int_ur_t; +typedef unsigned long int_ulr_t; +typedef unsigned long long int_ullr_t; + +typedef unsigned int int_uhk_t; +typedef unsigned long int_uk_t; +typedef unsigned long long int_ulk_t; +typedef unsigned long long int_ullk_t; + + +#define DEFTEST1(T,FX) \ + T test1_##FX (T x, int rp) \ + { \ + return round##FX (x, rp); \ + } \ + \ + unsigned T test1_u##FX (unsigned T x, int rp) \ + { \ + return roundu##FX (x, rp); \ + } + +DEFTEST1 (short fract, hr) +DEFTEST1 (fract, r) +DEFTEST1 (long fract, lr) +DEFTEST1 (long long fract, llr) + +DEFTEST1 (short accum, hk) +DEFTEST1 (accum, k) + +DEFTEST1 (long accum, lk) +DEFTEST1 (long long accum, llk) + + +#define TEST2(FX, RP, VAL, ROUND) \ + { \ + if (round##FX (FX##bits (VAL), RP) != FX##bits (ROUND)) \ + abort(); \ + fx_##FX##_t (*f)(fx_##FX##_t,int) = round##FX; \ + asm ("" : "+r" (f)); \ + if (f (FX##bits (VAL), RP) != FX##bits (ROUND)) \ + abort(); \ + } + +static void test2hr (void) +{ + TEST2 (hr, 1, 0x7f, 0x7f); + TEST2 (hr, 2, 0x70, 0x7f); + TEST2 (hr, 3, 0x78, 0x7f); + TEST2 (hr, 4, 0x7f, 0x7f); + + TEST2 (uhr, 1, 0x7f, 0x80); + TEST2 (uhr, 2, 0x7f, 0x80); + TEST2 (uhr, 3, 0x7f, 0x80); + TEST2 (uhr, 4, 0x7f, 0x80); +} + +void test2k (void) +{ + TEST2 (k, 1, 0x7fffff00, 0x7fffffff); + TEST2 (k, 2, 0x7ffffff0, 0x7fffffff); + TEST2 (k, 2, 0x7ffff000, 0x7fffffff); + TEST2 (k, 3, 0x7ffff000, 0x7ffff000); + TEST2 (k, 3, 0x7ffff800, 0x7fffffff); + TEST2 (k, 3, 0x7ffff7ff, 0x7ffff000); + TEST2 (k, 4, 0x7ffff7ff, 0x7ffff800); + + TEST2 (uk, 1, 0x7fffffff, 1ul << 31); + TEST2 (uk, 2, 0x7fffffff, 1ul << 31); + TEST2 (uk, 3, 0x7fffffff, 1ul << 31); + TEST2 (uk, 4, 0x7fffffff, 1ul << 31); +} + +#define DEFTEST3(FX, FBIT) \ + void test3##FX (void) \ + { \ + TEST2 (FX, FBIT-1, 0b01100, 0b01100); \ + TEST2 (FX, FBIT-2, 0b01100, 0b01100); \ + TEST2 (FX, FBIT-3, 0b01100, 0b10000); \ + TEST2 (FX, FBIT-4, 0b01100, 0b10000); \ + TEST2 (FX, FBIT-5, 0b01100, 0); \ + \ + if (FX##bits ((int_##FX##_t) -1) > 0) \ + return; \ + \ + TEST2 (FX, FBIT-1, -0b01100, -0b01100); \ + TEST2 (FX, FBIT-2, -0b01100, -0b01100); \ + TEST2 (FX, FBIT-3, -0b01100, -0b01000); \ + TEST2 (FX, FBIT-4, -0b01100, -0b10000); \ + TEST2 (FX, FBIT-5, -0b01100, -0b00000); \ + } + +DEFTEST3 (hr, SFRACT_FBIT) +DEFTEST3 (r, FRACT_FBIT) +DEFTEST3 (lr, LFRACT_FBIT) + +DEFTEST3 (uhr, USFRACT_FBIT) +DEFTEST3 (ur, UFRACT_FBIT) +DEFTEST3 (ulr, ULFRACT_FBIT) + +DEFTEST3 (hk, SACCUM_FBIT) +DEFTEST3 (k, ACCUM_FBIT) +DEFTEST3 (lk, LACCUM_FBIT) +DEFTEST3 (llk, LLACCUM_FBIT) + +DEFTEST3 (uhk, USACCUM_FBIT) +DEFTEST3 (uk, UACCUM_FBIT) +DEFTEST3 (ulk, ULACCUM_FBIT) +DEFTEST3 (ullk, ULLACCUM_FBIT) + +int main (void) +{ + test2hr(); + test2k(); + + test3hr(); + test3r(); + test3lr(); + + test3uhr(); + test3ur(); + test3ulr(); + + test3hk(); + test3k(); + test3lk(); + test3llk(); + + test3uhk(); + test3uk(); + test3ulk(); + test3ullk(); + + return 0; +} + diff --git a/gcc/testsuite/gcc.target/avr/torture/builtins-5-countlsfx.c b/gcc/testsuite/gcc.target/avr/torture/builtins-5-countlsfx.c new file mode 100644 index 0000000000..b0ff5e3d48 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/builtins-5-countlsfx.c @@ -0,0 +1,82 @@ +/* { dg-options "-std=gnu99" } */ +/* { dg-do run } */ + +#include <stdfix.h> + +extern void abort (void); + +#define DEFTEST1(T,FX) \ + int test1_##FX (T x) \ + { \ + return countls##FX (x); \ + } \ + \ + int test1_u##FX (unsigned T x) \ + { \ + return countlsu##FX (x); \ + } + +DEFTEST1 (short fract, hr) +DEFTEST1 (fract, r) +DEFTEST1 (long fract, lr) +DEFTEST1 (long long fract, llr) + +DEFTEST1 (short accum, hk) +DEFTEST1 (accum, k) +DEFTEST1 (long accum, lk) +DEFTEST1 (long long accum, llk) + + +#define TEST2P(FX, VAL, DD) \ + { \ + if (countls##FX (FX##bits (VAL)) != 8 * sizeof (0##FX) - DD) \ + abort(); \ + \ + if (countlsu##FX (u##FX##bits (VAL)) != 8 * sizeof (0u##FX) + 1 - DD) \ + abort(); \ + } + + +#define TEST2M(FX, VAL, DD) \ + { \ + if (countls##FX (FX##bits (VAL)) != 8 * sizeof (0##FX) - (DD)) \ + abort(); \ + \ + if (countlsu##FX (u##FX##bits (VAL)) != 0) \ + abort(); \ + } + + +#define TEST2PX(VAL, DD) \ + TEST2P (hr, VAL, DD); \ + TEST2P (r, VAL, DD); \ + TEST2P (lr, VAL, DD); \ + \ + TEST2P (hk, VAL, DD); \ + TEST2P (k, VAL, DD); \ + TEST2P (lk, VAL, DD); \ + TEST2P (llk, VAL, DD) + +#define TEST2MX(VAL, DD) \ + TEST2M (hr, VAL, DD); \ + TEST2M (r, VAL, DD); \ + TEST2M (lr, VAL, DD); \ + \ + TEST2M (hk, VAL, DD); \ + TEST2M (k, VAL, DD); \ + TEST2M (lk, VAL, DD); \ + TEST2M (llk, VAL, DD) + + +int main (void) +{ + TEST2PX (1, 2); + TEST2PX (2, 3); + TEST2PX (3, 3); + + TEST2MX (-1, 1); + TEST2MX (-2, 2); + TEST2MX (-3, 3); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/avr/torture/fix-types.h b/gcc/testsuite/gcc.target/avr/torture/fix-types.h new file mode 100644 index 0000000000..f6a2aeb6fa --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/fix-types.h @@ -0,0 +1,134 @@ +typedef __INT8_TYPE__ int_hr_t; +typedef __UINT8_TYPE__ int_uhr_t; + +typedef __INT16_TYPE__ int_hk_t; +typedef __UINT16_TYPE__ int_uhk_t; +typedef __INT16_TYPE__ int_r_t; +typedef __UINT16_TYPE__ int_ur_t; + +typedef __INT32_TYPE__ int_k_t; +typedef __UINT32_TYPE__ int_uk_t; +typedef __INT32_TYPE__ int_lr_t; +typedef __UINT32_TYPE__ int_ulr_t; + +typedef __INT64_TYPE__ int_lk_t; +typedef __UINT64_TYPE__ int_ulk_t; +typedef __INT64_TYPE__ int_llr_t; +typedef __UINT64_TYPE__ int_ullr_t; +typedef __INT64_TYPE__ int_llk_t; +typedef __UINT64_TYPE__ int_ullk_t; + +typedef __INT16_TYPE__ xint_hr_t; +typedef __UINT16_TYPE__ xint_uhr_t; + +typedef __INT32_TYPE__ xint_hk_t; +typedef __UINT32_TYPE__ xint_uhk_t; +typedef __INT32_TYPE__ xint_r_t; +typedef __UINT32_TYPE__ xint_ur_t; + +typedef __INT64_TYPE__ xint_k_t; +typedef __UINT64_TYPE__ xint_uk_t; +typedef __INT64_TYPE__ xint_lr_t; +typedef __UINT64_TYPE__ xint_ulr_t; + +#define INThr_MAX __INT8_MAX__ +#define INThr_MIN (-__INT8_MAX__-1) +#define INTuhr_MAX __UINT8_MAX__ + +#define INTr_MAX __INT16_MAX__ +#define INTr_MIN (-__INT16_MAX__-1) +#define INTur_MAX __UINT16_MAX__ + +#define INThk_MAX __INT16_MAX__ +#define INThk_MIN (-__INT16_MAX__-1) +#define INTuhk_MAX __UINT16_MAX__ + +#define INTlr_MAX __INT32_MAX__ +#define INTlr_MIN (-__INT32_MAX__-1) +#define INTulr_MAX __UINT32_MAX__ + +#define INTk_MAX __INT32_MAX__ +#define INTk_MIN (-__INT32_MAX__-1) +#define INTuk_MAX __UINT32_MAX__ + +#define INTlk_MAX __INT64_MAX__ +#define INTlk_MIN (-__INT64_MAX__-1) +#define INTulk_MAX __UINT64_MAX__ + +#define INTllk_MAX __INT64_MAX__ +#define INTllk_MIN (-__INT64_MAX__-1) +#define INTullk_MAX __UINT64_MAX__ + +#define SS_FUN(NAME, OP, T, FX) \ + T __attribute__((noinline,noclone)) \ + NAME##_##FX (T fa, T fb) \ + { \ + int_##FX##_t ia; \ + int_##FX##_t ib; \ + xint_##FX##_t ic; \ + __builtin_memcpy (&ia, &fa, sizeof (ia)); \ + __builtin_memcpy (&ib, &fb, sizeof (ib)); \ + ic = (xint_##FX##_t) ia OP ib; \ + if (ic > INT##FX##_MAX) \ + ic = INT##FX##_MAX; \ + else if (ic < INT##FX##_MIN) \ + ic = INT##FX##_MIN; \ + ia = (int_##FX##_t) ic; \ + __builtin_memcpy (&fa, &ia, sizeof (ia)); \ + return fa; \ + } + +#define US_FUN(NAME, OP, T, FX) \ + T __attribute__((noinline,noclone)) \ + NAME##_##FX (T fa, T fb) \ + { \ + int_##FX##_t ia; \ + int_##FX##_t ib; \ + xint_##FX##_t ic; \ + __builtin_memcpy (&ia, &fa, sizeof (ia)); \ + __builtin_memcpy (&ib, &fb, sizeof (ib)); \ + ic = (xint_##FX##_t) ia OP ib; \ + if (ic > INT##FX##_MAX) \ + ic = INT##FX##_MAX; \ + else if (ic < 0) \ + ic = 0; \ + ia = (int_##FX##_t) ic; \ + __builtin_memcpy (&fa, &ia, sizeof (ia)); \ + return fa; \ + } + +#define SS_LFUN(NAME, OP, T, FX, CMP) \ + T __attribute__((noinline,noclone)) \ + NAME##_##FX (T fa, T fb) \ + { \ + int_##FX##_t ia; \ + int_##FX##_t ib; \ + int_##FX##_t ic; \ + __builtin_memcpy (&ia, &fa, sizeof (ia)); \ + __builtin_memcpy (&ib, &fb, sizeof (ib)); \ + ic = (int_##FX##_t) ia OP ib; \ + if (ic < ia && ib CMP 0) \ + ic = INT##FX##_MAX; \ + else if (ic > ia && 0 CMP ib) \ + ic = INT##FX##_MIN; \ + __builtin_memcpy (&fa, &ic, sizeof (ic)); \ + return fa; \ + } + +#define US_LFUN(NAME, OP, T, FX, CMP) \ + T __attribute__((noinline,noclone)) \ + NAME##_##FX (T fa, T fb) \ + { \ + int_##FX##_t ia; \ + int_##FX##_t ib; \ + int_##FX##_t ic; \ + __builtin_memcpy (&ia, &fa, sizeof (ia)); \ + __builtin_memcpy (&ib, &fb, sizeof (ib)); \ + ic = (int_##FX##_t) ia OP ib; \ + if (ia CMP ic && 1 CMP 0) \ + ic = INT##FX##_MAX; \ + if (ia CMP ic && 0 CMP 1) \ + ic = 0; \ + __builtin_memcpy (&fa, &ic, sizeof (ic)); \ + return fa; \ + } diff --git a/gcc/testsuite/gcc.target/avr/torture/pr57631.c b/gcc/testsuite/gcc.target/avr/torture/pr57631.c new file mode 100644 index 0000000000..ecefbfc81b --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/pr57631.c @@ -0,0 +1,17 @@ +/* PR target/57631 */ +/* { dg-do compile } */ + +void __attribute__((signal)) func1 (void) __asm ("__vector1"); +void func1 (void) +{ +} + +void __attribute__((signal)) func2 (void) __asm ("__vecto1"); +void func2 (void) /* { dg-warning "misspelled signal handler" } */ +{ +} + +void __attribute__((signal)) __vector_3 (void) __asm ("__vecto1"); +void __vector_3 (void) /* { dg-warning "misspelled signal handler" } */ +{ +} diff --git a/gcc/testsuite/gcc.target/avr/torture/pr61055.c b/gcc/testsuite/gcc.target/avr/torture/pr61055.c new file mode 100644 index 0000000000..9dd1f427d0 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/pr61055.c @@ -0,0 +1,88 @@ +/* { dg-do run } */ +/* { dg-options { -fno-peephole2 } } */ + +#include <stdlib.h> + +typedef __UINT16_TYPE__ uint16_t; +typedef __INT16_TYPE__ int16_t; +typedef __UINT8_TYPE__ uint8_t; + +uint8_t __attribute__((noinline,noclone)) +fun_inc (uint8_t c0) +{ + register uint8_t c asm ("r15") = c0; + + /* Force target value into R15 (lower register) */ + asm ("" : "+l" (c)); + + c++; + if (c >= 0x80) + c = 0; + + asm ("" : "+l" (c)); + + return c; +} + +uint8_t __attribute__((noinline,noclone)) +fun_dec (uint8_t c0) +{ + register uint8_t c asm ("r15") = c0; + + /* Force target value into R15 (lower register) */ + asm ("" : "+l" (c)); + + c--; + if (c < 0x80) + c = 0; + + asm ("" : "+l" (c)); + + return c; +} + + +uint8_t __attribute__((noinline,noclone)) +fun_neg (uint8_t c0) +{ + register uint8_t c asm ("r15") = c0; + + c = -c; + if (c >= 0x80) + c = 0; + + return c; +} + +uint16_t __attribute__((noinline,noclone)) +fun_adiw (uint16_t c0) +{ + register uint16_t c asm ("r24") = c0; + + /* Force target value into R24 (for ADIW) */ + asm ("" : "+r" (c)); + + c += 2; + if (c >= 0x8000) + c = 0; + + asm ("" : "+r" (c)); + + return c; +} + + +int main() +{ + if (fun_inc (0x7f) != 0) + abort(); + + if (fun_neg (0x80) != 0) + abort(); + + if (fun_adiw (0x7ffe) != 0) + abort(); + + exit (0); + return 0; +} diff --git a/gcc/testsuite/gcc.target/avr/torture/pr61443.c b/gcc/testsuite/gcc.target/avr/torture/pr61443.c new file mode 100644 index 0000000000..12c6bca666 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/pr61443.c @@ -0,0 +1,134 @@ +/* { dg-do run } */ +/* { dg-options "-std=gnu99" } */ + +#include <stdlib.h> +#include <stdarg.h> + +#define NC __attribute__((noinline,noclone)) + +void NC vfun (char n, ...) +{ + va_list ap; + + va_start (ap, n); + + switch (n) + { + default: + abort(); + case 1: + if (11 != va_arg (ap, int)) + abort(); + break; + case 2: + if (2222 != va_arg (ap, int)) + abort(); + break; + case 3: + if (333333 != va_arg (ap, __int24)) + abort(); + break; + case 4: + if (44444444 != va_arg (ap, long)) + abort(); + break; + case 8: + if (8888888888888888 != va_arg (ap, long long)) + abort(); + break; + } + + va_end (ap); +} + + +void NC boo_qi (const __flash char *p) +{ + vfun (1, *p); +} + +void NC boox_qi (const __memx char *p) +{ + vfun (1, *p); +} + +void NC boo_hi (const __flash int *p) +{ + vfun (2, *p); +} + +void NC boox_hi (const __memx int *p) +{ + vfun (2, *p); +} + +void NC boo_psi (const __flash __int24 *p) +{ + vfun (3, *p); +} + +void NC boox_psi (const __memx __int24 *p) +{ + vfun (3, *p); +} + +void NC boo_si (const __flash long *p) +{ + vfun (4, *p); +} + +void NC boox_si (const __memx long *p) +{ + vfun (4, *p); +} + +void NC boo_di (const __flash long long *p) +{ + vfun (8, *p); +} + +void NC boox_di (const __memx long long *p) +{ + vfun (8, *p); +} + +const __flash char f_qi = 11; +const __flash int f_hi = 2222; +const __flash __int24 f_psi = 333333; +const __flash long f_si = 44444444; +const __flash long long f_di = 8888888888888888; + +const __memx char x_qi = 11; +const __memx int x_hi = 2222; +const __memx __int24 x_psi = 333333; +const __memx long x_si = 44444444; +const __memx long long x_di = 8888888888888888; + +char r_qi = 11; +int r_hi = 2222; +__int24 r_psi = 333333; +long r_si = 44444444; +long long r_di = 8888888888888888; + +int main (void) +{ + boo_qi (&f_qi); + boo_hi (&f_hi); + boo_psi (&f_psi); + boo_si (&f_si); + boo_di (&f_di); + + boox_qi (&x_qi); + boox_hi (&x_hi); + boox_psi (&x_psi); + boox_si (&x_si); + boox_di (&x_di); + + boox_qi (&r_qi); + boox_hi (&r_hi); + boox_psi (&r_psi); + boox_si (&r_si); + boox_di (&r_di); + + exit (0); +} diff --git a/gcc/testsuite/gcc.target/avr/torture/sat-hr-plus-minus.c b/gcc/testsuite/gcc.target/avr/torture/sat-hr-plus-minus.c new file mode 100644 index 0000000000..1e6215e4f4 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/sat-hr-plus-minus.c @@ -0,0 +1,98 @@ +/* { dg-do run } */ +/* { dg-options "-std=gnu99 -fwrapv" } */ + +#include "fix-types.h" + +extern void abort (void); +extern void exit (int); + +typedef short _Fract fx_t; +typedef short _Sat _Fract satfx_t; +typedef char intfx_t; + +SS_FUN (ss_add, +, fx_t, hr) +SS_FUN (ss_sub, -, fx_t, hr) + +#define VAL(N, X) \ + __attribute__((noinline,noclone)) \ + satfx_t ss_add2_##N (satfx_t a) \ + { \ + return ss_add_hr (a, X##P##-##7hr); \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t ss_add_##N (satfx_t a) \ + { \ + return a + X##P##-##7hr; \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t ss_sub2_##N (satfx_t a) \ + { \ + return ss_sub_hr (a, X##P##-##7hr); \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t ss_sub_##N (satfx_t a) \ + { \ + return a - X##P##-##7hr; \ + } +#include "vals-hr.def" +#undef VAL + +__attribute__((noinline,noclone)) +satfx_t ss_add2_99 (satfx_t a) +{ + return ss_add_hr (a, __FRACT_MIN__); +} + +__attribute__((noinline,noclone)) +satfx_t ss_add_99 (satfx_t a) +{ + return a + __FRACT_MIN__; +} + +__attribute__((noinline,noclone)) +satfx_t ss_sub2_99 (satfx_t a) +{ + return ss_sub_hr (a, __FRACT_MIN__); +} + +__attribute__((noinline,noclone)) +satfx_t ss_sub_99 (satfx_t a) +{ + return a - __FRACT_MIN__; +} + + +satfx_t (* __flash const fun[])(satfx_t) = +{ +#define VAL(N, X) \ + ss_add_##N, ss_add2_##N, \ + ss_sub_##N, ss_sub2_##N, +#include "vals-hr.def" + VAL (99,) +#undef VAL +}; + + +const volatile __flash intfx_t vals[] = + { + 0, 1, 2, 0x7f, 0x80, 0x81, 0xff, + 0x40, 0x3e, 0x3f, 0xbf, 0xc0, 0xc1 + }; + +int main (void) +{ + for (unsigned int i = 0; i < sizeof (vals) / sizeof (*vals); i++) + { + satfx_t a, f1, f2; + intfx_t val = vals[i]; + __builtin_memcpy (&a, &val, sizeof (satfx_t)); + for (unsigned int f = 0; f < sizeof (fun) / sizeof (*fun); f += 2) + { + if (fun[f](a) != fun[f+1](a)) + abort(); + } + } + + exit (0); + return 0; +} diff --git a/gcc/testsuite/gcc.target/avr/torture/sat-k-plus-minus.c b/gcc/testsuite/gcc.target/avr/torture/sat-k-plus-minus.c new file mode 100644 index 0000000000..8a26ffeeb3 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/sat-k-plus-minus.c @@ -0,0 +1,108 @@ +/* { dg-do run } */ +/* { dg-options "-std=gnu99 -fwrapv" } */ + +#include "fix-types.h" + +extern void abort (void); +extern void exit (int); + +typedef _Accum fx_t; +typedef _Sat _Accum satfx_t; +typedef long intfx_t; + +SS_FUN (ss_add, +, fx_t, k) +SS_FUN (ss_sub, -, fx_t, k) + +#define VAL(N, X) \ + __attribute__((noinline,noclone)) \ + satfx_t ss_add2_##N (satfx_t a) \ + { \ + return ss_add_k (a, X##P##-##16k); \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t ss_add_##N (satfx_t a) \ + { \ + return a + X##P##-##16k; \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t ss_sub2_##N (satfx_t a) \ + { \ + return ss_sub_k (a, X##P##-##16k); \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t ss_sub_##N (satfx_t a) \ + { \ + return a - X##P##-##16k; \ + } +#include "vals-k.def" +#undef VAL + +__attribute__((noinline,noclone)) +satfx_t ss_add2_99 (satfx_t a) +{ + return ss_add_k (a, __ACCUM_MIN__); +} + +__attribute__((noinline,noclone)) +satfx_t ss_add_99 (satfx_t a) +{ + return a + __ACCUM_MIN__; +} + +__attribute__((noinline,noclone)) +satfx_t ss_sub2_99 (satfx_t a) +{ + return ss_sub_k (a, __ACCUM_MIN__); +} + +__attribute__((noinline,noclone)) +satfx_t ss_sub_99 (satfx_t a) +{ + return a - __ACCUM_MIN__; +} + + +satfx_t (* __flash const fun[])(satfx_t) = +{ +#define VAL(N, X) \ + ss_add_##N, ss_add2_##N, \ + ss_sub_##N, ss_sub2_##N, +#include "vals-k.def" + VAL (99,) +#undef VAL +}; + + +const volatile __flash intfx_t vals[] = + { + 0, -1, 1, -2, 2, -127, -128, -129, + 0x7f, 0x80, 0x81, 0x100, + 0x40000000, 0x3e800000, 0x3f800000, + 0x7ffffffe, 0x7fffffff, 0x7f800000, + 0x7f7f7f7f, 0x7f810080, 0x7f008000, + 0x7f000001, + 0x80000000, 0x80000001, 0x80808080, + 0x80810000, 0x80ffffff, 0x80fffffe, + 0x81000000, 0x81800000, 0x81800000, + 0xff000000, 0xffffff01, 0xffffff80, + 0xffffff7f, 0xff80ff80 + }; + + +int main (void) +{ + for (unsigned int i = 0; i < sizeof (vals) / sizeof (*vals); i++) + { + satfx_t a, f1, f2; + intfx_t val = vals[i]; + __builtin_memcpy (&a, &val, sizeof (satfx_t)); + for (unsigned int f = 0; f < sizeof (fun) / sizeof (*fun); f += 2) + { + if (fun[f](a) != fun[f+1](a)) + abort(); + } + } + + exit (0); + return 0; +} diff --git a/gcc/testsuite/gcc.target/avr/torture/sat-llk-plus-minus.c b/gcc/testsuite/gcc.target/avr/torture/sat-llk-plus-minus.c new file mode 100644 index 0000000000..e81cbb187e --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/sat-llk-plus-minus.c @@ -0,0 +1,108 @@ +/* { dg-do run } */ +/* { dg-options "-std=gnu99 -fwrapv" } */ + +#include "fix-types.h" + +extern void abort (void); +extern void exit (int); + +typedef long long _Accum fx_t; +typedef long long _Sat _Accum satfx_t; +typedef long long intfx_t; + +SS_LFUN (ss_add, +, fx_t, llk, >) +SS_LFUN (ss_sub, -, fx_t, llk, <) + +#define VAL(N, X) \ + __attribute__((noinline,noclone)) \ + satfx_t ss_add2_##N (satfx_t a) \ + { \ + return ss_add_llk (a, X##P##-##48llk); \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t ss_add_##N (satfx_t a) \ + { \ + return a + X##P##-##48llk; \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t ss_sub2_##N (satfx_t a) \ + { \ + return ss_sub_llk (a, X##P##-##48llk); \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t ss_sub_##N (satfx_t a) \ + { \ + return a - X##P##-##48llk; \ + } +#include "vals-llk.def" +#undef VAL + +__attribute__((noinline,noclone)) +satfx_t ss_add2_99 (satfx_t a) +{ + return ss_add_llk (a, __LLACCUM_MIN__); +} + +__attribute__((noinline,noclone)) +satfx_t ss_add_99 (satfx_t a) +{ + return a + __LLACCUM_MIN__; +} + +__attribute__((noinline,noclone)) +satfx_t ss_sub2_99 (satfx_t a) +{ + return ss_sub_llk (a, __LLACCUM_MIN__); +} + +__attribute__((noinline,noclone)) +satfx_t ss_sub_99 (satfx_t a) +{ + return a - __LLACCUM_MIN__; +} + + +satfx_t (* __flash const fun[])(satfx_t) = +{ +#define VAL(N, X) \ + ss_add_##N, ss_add2_##N, \ + ss_sub_##N, ss_sub2_##N, +#include "vals-llk.def" + VAL (99,) +#undef VAL +}; + + +const volatile __flash intfx_t vals[] = + { + 0, -1, 1, -2, 2, -127, -128, -129, + 0x7f, 0x80, 0x81, 0x100, + 0x4000000000000000, 0x3e80000000000000, 0x3f80000000000000, + 0x7ffffffffffffffe, 0x7fffffffffffffff, 0x7f80000000000000, + 0x7f7f7f7f7f7f7f7f, 0x7f81000000000080, 0x7f00000080000000, + 0x7f00000000000001, + 0x8000000000000000, 0x8000000000000001, 0x8080808080808080, + 0x8081000000000000, 0x80ffffffffffffff, 0x80fffffffffffffe, + 0x8100000000000000, 0x8180000000000000, 0x818000000000000, + 0xff00000000000000, 0xffffffffffffff01, 0xffffffffffffff80, + 0xffffffffffffff7f, 0xff80ff80ff80ff80 + }; + + +int main (void) +{ + for (unsigned int i = 0; i < sizeof (vals) / sizeof (*vals); i++) + { + satfx_t a, f1, f2; + intfx_t val = vals[i]; + __builtin_memcpy (&a, &val, sizeof (satfx_t)); + for (unsigned int f = 0; f < sizeof (fun) / sizeof (*fun); f += 2) + { + if (fun[f](a) != fun[f+1](a)) + abort(); + } + } + + exit (0); + return 0; +} diff --git a/gcc/testsuite/gcc.target/avr/torture/sat-r-plus-minus.c b/gcc/testsuite/gcc.target/avr/torture/sat-r-plus-minus.c new file mode 100644 index 0000000000..e59bcf655a --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/sat-r-plus-minus.c @@ -0,0 +1,107 @@ +/* { dg-do run } */ +/* { dg-options "-std=gnu99 -fwrapv" } */ + +#include "fix-types.h" + +extern void abort (void); +extern void exit (int); + +typedef _Fract fx_t; +typedef _Sat _Fract satfx_t; +typedef int intfx_t; + +SS_FUN (ss_add, +, fx_t, r) +SS_FUN (ss_sub, -, fx_t, r) + +#define VAL(N, X) \ + __attribute__((noinline,noclone)) \ + satfx_t ss_add2_##N (satfx_t a) \ + { \ + return ss_add_r (a, X##P##-##15r); \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t ss_add_##N (satfx_t a) \ + { \ + return a + X##P##-##15r; \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t ss_sub2_##N (satfx_t a) \ + { \ + return ss_sub_r (a, X##P##-##15r); \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t ss_sub_##N (satfx_t a) \ + { \ + return a - X##P##-##15r; \ + } +#include "vals-r.def" +#undef VAL + +__attribute__((noinline,noclone)) +satfx_t ss_add2_99 (satfx_t a) +{ + return ss_add_r (a, __FRACT_MIN__); +} + +__attribute__((noinline,noclone)) +satfx_t ss_add_99 (satfx_t a) +{ + return a + __FRACT_MIN__; +} + +__attribute__((noinline,noclone)) +satfx_t ss_sub2_99 (satfx_t a) +{ + return ss_sub_r (a, __FRACT_MIN__); +} + +__attribute__((noinline,noclone)) +satfx_t ss_sub_99 (satfx_t a) +{ + return a - __FRACT_MIN__; +} + + +satfx_t (* __flash const fun[])(satfx_t) = +{ +#define VAL(N, X) \ + ss_add_##N, ss_add2_##N, \ + ss_sub_##N, ss_sub2_##N, +#include "vals-r.def" + VAL (99,) +#undef VAL +}; + + +const volatile __flash intfx_t vals[] = + { + 0, -1, 1, -2, 2, -127, -128, -129, + 0x7f, 0x80, 0x81, 0x100, + 0x4000, 0x3e80, 0x3f80, + 0x7ffe, 0x7fff, + 0x7f7f, 0x7f81, 0x7f80, + 0x7f01, + 0x8000, 0x8001, 0x8080, + 0x8081, 0x80ff, 0x80fe, + 0x8100, 0x8180, 0x817f, + 0xff00, 0xff01, 0xff01, + 0xff7f, 0xff80 + }; + +int main (void) +{ + for (unsigned int i = 0; i < sizeof (vals) / sizeof (*vals); i++) + { + satfx_t a, f1, f2; + intfx_t val = vals[i]; + __builtin_memcpy (&a, &val, sizeof (satfx_t)); + for (unsigned int f = 0; f < sizeof (fun) / sizeof (*fun); f += 2) + { + if (fun[f](a) != fun[f+1](a)) + abort(); + } + } + + exit (0); + return 0; +} diff --git a/gcc/testsuite/gcc.target/avr/torture/sat-uhr-plus-minus.c b/gcc/testsuite/gcc.target/avr/torture/sat-uhr-plus-minus.c new file mode 100644 index 0000000000..6dd191f7ac --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/sat-uhr-plus-minus.c @@ -0,0 +1,73 @@ +/* { dg-do run } */ +/* { dg-options "-std=gnu99 -fwrapv" } */ + +#include "fix-types.h" + +extern void abort (void); +extern void exit (int); + +typedef unsigned short _Fract fx_t; +typedef unsigned short _Sat _Fract satfx_t; +typedef unsigned char intfx_t; + +US_LFUN (us_add, +, fx_t, uhr, >) +US_LFUN (us_sub, -, fx_t, uhr, <) + +#define VAL(N, X) \ + __attribute__((noinline,noclone)) \ + satfx_t us_add2_##N (satfx_t a) \ + { \ + return us_add_uhr (a, X##P##-##8uhr); \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t us_add_##N (satfx_t a) \ + { \ + return a + X##P##-##8uhr; \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t us_sub2_##N (satfx_t a) \ + { \ + return us_sub_uhr (a, X##P##-##8uhr); \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t us_sub_##N (satfx_t a) \ + { \ + return a - X##P##-##8uhr; \ + } +#include "vals-uhr.def" +#undef VAL + +satfx_t (* __flash const fun[])(satfx_t) = +{ +#define VAL(N, X) \ + us_add_##N, us_add2_##N, \ + us_sub_##N, us_sub2_##N, +#include "vals-uhr.def" +#undef VAL +}; + + +const volatile __flash intfx_t vals[] = + { + 0, 1, 2, 0x7f, 0x80, 0x81, 0xff, + 0x40, 0x3e, 0x3f, 0xbf, 0xc0, 0xc1 + }; + + +int main (void) +{ + for (unsigned int i = 0; i < sizeof (vals) / sizeof (*vals); i++) + { + satfx_t a, f1, f2; + intfx_t val = vals[i]; + __builtin_memcpy (&a, &val, sizeof (satfx_t)); + for (unsigned int f = 0; f < sizeof (fun) / sizeof (*fun); f += 2) + { + if (fun[f](a) != fun[f+1](a)) + abort(); + } + } + + exit (0); + return 0; +} diff --git a/gcc/testsuite/gcc.target/avr/torture/sat-uk-plus-minus.c b/gcc/testsuite/gcc.target/avr/torture/sat-uk-plus-minus.c new file mode 100644 index 0000000000..c9a7cd6ba4 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/sat-uk-plus-minus.c @@ -0,0 +1,82 @@ +/* { dg-do run } */ +/* { dg-options "-std=gnu99 -fwrapv" } */ + +#include "fix-types.h" + +extern void abort (void); +extern void exit (int); + +typedef unsigned _Accum fx_t; +typedef unsigned _Sat _Accum satfx_t; +typedef unsigned long intfx_t; + +US_LFUN (us_add, +, fx_t, uk, >) +US_LFUN (us_sub, -, fx_t, uk, <) + +#define VAL(N, X) \ + __attribute__((noinline,noclone)) \ + satfx_t us_add2_##N (satfx_t a) \ + { \ + return us_add_uk (a, X##P##-##16uk); \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t us_add_##N (satfx_t a) \ + { \ + return a + X##P##-##16uk; \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t us_sub2_##N (satfx_t a) \ + { \ + return us_sub_uk (a, X##P##-##16uk); \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t us_sub_##N (satfx_t a) \ + { \ + return a - X##P##-##16uk; \ + } +#include "vals-uk.def" +#undef VAL + +satfx_t (* __flash const fun[])(satfx_t) = +{ +#define VAL(N, X) \ + us_add_##N, us_add2_##N, \ + us_sub_##N, us_sub2_##N, +#include "vals-uk.def" +#undef VAL +}; + + +const volatile __flash intfx_t vals[] = + { + 0, -1, 1, -2, 2, -127, -128, -129, + 0x7f, 0x80, 0x81, 0x100, + 0x40000000, 0x3e800000, 0x3f800000, + 0x7ffffffe, 0x7fffffff, 0x7f800000, + 0x7f7f7f7f, 0x7f810080, 0x7f008000, + 0x7f000001, + 0x80000000, 0x80000001, 0x80808080, + 0x80810000, 0x80ffffff, 0x80fffffe, + 0x81000000, 0x81800000, 0x81800000, + 0xff000000, 0xffffff01, 0xffffff80, + 0xffffff7f, 0xff80ff80 + }; + + +int main (void) +{ + for (unsigned int i = 0; i < sizeof (vals) / sizeof (*vals); i++) + { + satfx_t a, f1, f2; + intfx_t val = vals[i]; + __builtin_memcpy (&a, &val, sizeof (satfx_t)); + for (unsigned int f = 0; f < sizeof (fun) / sizeof (*fun); f += 2) + { + if (fun[f](a) != fun[f+1](a)) + abort(); + } + } + + exit (0); + return 0; +} diff --git a/gcc/testsuite/gcc.target/avr/torture/sat-ullk-plus-minus.c b/gcc/testsuite/gcc.target/avr/torture/sat-ullk-plus-minus.c new file mode 100644 index 0000000000..22ebb8af50 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/sat-ullk-plus-minus.c @@ -0,0 +1,82 @@ +/* { dg-do run } */ +/* { dg-options "-std=gnu99 -fwrapv" } */ + +#include "fix-types.h" + +extern void abort (void); +extern void exit (int); + +typedef unsigned long long _Accum fx_t; +typedef unsigned long long _Sat _Accum satfx_t; +typedef unsigned long long intfx_t; + +US_LFUN (us_add, +, fx_t, ullk, >) +US_LFUN (us_sub, -, fx_t, ullk, <) + +#define VAL(N, X) \ + __attribute__((noinline,noclone)) \ + satfx_t us_add2_##N (satfx_t a) \ + { \ + return us_add_ullk (a, X##P##-##48ullk); \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t us_add_##N (satfx_t a) \ + { \ + return a + X##P##-##48ullk; \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t us_sub2_##N (satfx_t a) \ + { \ + return us_sub_ullk (a, X##P##-##48ullk); \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t us_sub_##N (satfx_t a) \ + { \ + return a - X##P##-##48ullk; \ + } +#include "vals-ullk.def" +#undef VAL + +satfx_t (* __flash const fun[])(satfx_t) = +{ +#define VAL(N, X) \ + us_add_##N, us_add2_##N, \ + us_sub_##N, us_sub2_##N, +#include "vals-ullk.def" +#undef VAL +}; + + +const volatile __flash intfx_t vals[] = + { + 0, -1, 1, -2, 2, -127, -128, -129, + 0x7f, 0x80, 0x81, 0x100, + 0x4000000000000000, 0x3e80000000000000, 0x3f80000000000000, + 0x7ffffffffffffffe, 0x7fffffffffffffff, 0x7f80000000000000, + 0x7f7f7f7f7f7f7f7f, 0x7f81000000000080, 0x7f00000080000000, + 0x7f00000000000001, + 0x8000000000000000, 0x8000000000000001, 0x8080808080808080, + 0x8081000000000000, 0x80ffffffffffffff, 0x80fffffffffffffe, + 0x8100000000000000, 0x8180000000000000, 0x818000000000000, + 0xff00000000000000, 0xffffffffffffff01, 0xffffffffffffff80, + 0xffffffffffffff7f, 0xff80ff80ff80ff80 + }; + + +int main (void) +{ + for (unsigned int i = 0; i < sizeof (vals) / sizeof (*vals); i++) + { + satfx_t a, f1, f2; + intfx_t val = vals[i]; + __builtin_memcpy (&a, &val, sizeof (satfx_t)); + for (unsigned int f = 0; f < sizeof (fun) / sizeof (*fun); f += 2) + { + if (fun[f](a) != fun[f+1](a)) + abort(); + } + } + + exit (0); + return 0; +} diff --git a/gcc/testsuite/gcc.target/avr/torture/sat-ur-plus-minus.c b/gcc/testsuite/gcc.target/avr/torture/sat-ur-plus-minus.c new file mode 100644 index 0000000000..bc3c0bbcd9 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/sat-ur-plus-minus.c @@ -0,0 +1,82 @@ +/* { dg-do run } */ +/* { dg-options "-std=gnu99 -fwrapv" } */ + +#include "fix-types.h" + +extern void abort (void); +extern void exit (int); + +typedef unsigned _Fract fx_t; +typedef unsigned _Sat _Fract satfx_t; +typedef unsigned int intfx_t; + +US_LFUN (us_add, +, fx_t, ur, >) +US_LFUN (us_sub, -, fx_t, ur, <) + +#define VAL(N, X) \ + __attribute__((noinline,noclone)) \ + satfx_t us_add2_##N (satfx_t a) \ + { \ + return us_add_ur (a, X##P##-##16ur); \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t us_add_##N (satfx_t a) \ + { \ + return a + X##P##-##16ur; \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t us_sub2_##N (satfx_t a) \ + { \ + return us_sub_ur (a, X##P##-##16ur); \ + } \ + __attribute__((noinline,noclone)) \ + satfx_t us_sub_##N (satfx_t a) \ + { \ + return a - X##P##-##16ur; \ + } +#include "vals-ur.def" +#undef VAL + +satfx_t (* __flash const fun[])(satfx_t) = +{ +#define VAL(N, X) \ + us_add_##N, us_add2_##N, \ + us_sub_##N, us_sub2_##N, +#include "vals-ur.def" +#undef VAL +}; + + +const volatile __flash intfx_t vals[] = + { + 0, -1, 1, -2, 2, -127, -128, -129, + 0x7f, 0x80, 0x81, 0x100, + 0x4000, 0x3e80, 0x3f80, + 0x7ffe, 0x7fff, + 0x7f7f, 0x7f81, 0x7f80, + 0x7f01, + 0x8000, 0x8001, 0x8080, + 0x8081, 0x80ff, 0x80fe, + 0x8100, 0x8180, 0x817f, + 0xff00, 0xff01, 0xff01, + 0xff7f, 0xff80 + }; + + +int main (void) +{ + for (unsigned int i = 0; i < sizeof (vals) / sizeof (*vals); i++) + { + satfx_t a, f1, f2; + intfx_t val = vals[i]; + __builtin_memcpy (&a, &val, sizeof (satfx_t)); + for (unsigned int f = 0; f < sizeof (fun) / sizeof (*fun); f += 2) + { + if (fun[f](a) != fun[f+1](a)) + abort(); + } + } + + exit (0); + return 0; +} diff --git a/gcc/testsuite/gcc.target/avr/torture/vals-hr.def b/gcc/testsuite/gcc.target/avr/torture/vals-hr.def new file mode 100644 index 0000000000..f6619c2ff5 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/vals-hr.def @@ -0,0 +1,12 @@ +VAL (01, 0x0) +VAL (02, 0x1) +VAL (03, 0x3f) +VAL (04,-0x3f) +VAL (07, 0x40) +VAL (08,-0x40) +VAL (10,-0x1) +VAL (12, 0x3f) +VAL (13,-0x3f) +VAL (14, 0x7f) +VAL (15,-0x7f) + diff --git a/gcc/testsuite/gcc.target/avr/torture/vals-k.def b/gcc/testsuite/gcc.target/avr/torture/vals-k.def new file mode 100644 index 0000000000..a490c69b36 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/vals-k.def @@ -0,0 +1,32 @@ +VAL (01, 0x0) +VAL (02, 0x1) +VAL (03, 0x3f) +VAL (04, 0x80) +VAL (05, -0x1) +VAL (06, -0x3f) +VAL (07, 0x40000000) +VAL (08,-0x40000000) + +VAL (10,-0x7fffffff) +VAL (11, 0x7fffffff) +VAL (12, 0x7f800000) +VAL (13,-0x7f800000) +VAL (14, 0x7f800001) +VAL (15,-0x7f800001) +VAL (16, 0x7f7f7f7f) +VAL (17,-0x7f7f7f7f) +VAL (18, 0x7f808080) +VAL (19,-0x7f808080) +VAL (20, 0x3e800000) +VAL (21,-0x3e800000) +VAL (22, 0x3f800000) +VAL (23,-0x3f800000) +VAL (24, 0x400000) +VAL (25,-0x400000) +VAL (26, 0x3f000000) +VAL (27,-0x3f000000) +VAL (28, 0xffff00) +VAL (29,-0xffff00) +VAL (30, 0x00ff00ff) +VAL (31,-0x00ff00ff) + diff --git a/gcc/testsuite/gcc.target/avr/torture/vals-llk.def b/gcc/testsuite/gcc.target/avr/torture/vals-llk.def new file mode 100644 index 0000000000..726a7ebed3 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/vals-llk.def @@ -0,0 +1,32 @@ +VAL (01, 0x0) +VAL (02, 0x1) +VAL (03, 0x3f) +VAL (04, 0x80) +VAL (05, -0x1) +VAL (06, -0x3f) +VAL (07, 0x4000000000000000) +VAL (08,-0x4000000000000000) + +VAL (10,-0x7fffffffffffffff) +VAL (11, 0x7fffffffffffffff) +VAL (12, 0x7f80000000000000) +VAL (13,-0x7f80000000000000) +VAL (14, 0x7f80000000000001) +VAL (15,-0x7f80000000000001) +VAL (16, 0x7f7f7f7f7f7f7f7f) +VAL (17,-0x7f7f7f7f7f7f7f7f) +VAL (18, 0x7f80808080808000) +VAL (19,-0x7f80808080808000) +VAL (20, 0x3e80000000000000) +VAL (21,-0x3e80000000000000) +VAL (22, 0x3f80000000000000) +VAL (23,-0x3f80000000000000) +VAL (24, 0x40000000000000) +VAL (25,-0x40000000000000) +VAL (26, 0x3f000000000000) +VAL (27,-0x3f000000000000) +VAL (28, 0xffffff00) +VAL (29,-0xffffff00) +VAL (30, 0x00ff00ff00ff00ff) +VAL (31,-0x00ff00ff00ff00ff) + diff --git a/gcc/testsuite/gcc.target/avr/torture/vals-r.def b/gcc/testsuite/gcc.target/avr/torture/vals-r.def new file mode 100644 index 0000000000..0c5f83f7d0 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/vals-r.def @@ -0,0 +1,30 @@ +VAL (01, 0x0) +VAL (02, 0x1) +VAL (03, 0x3f) +VAL (04, 0x80) +VAL (05, -0x1) +VAL (06, -0x3f) +VAL (07, 0x4000) +VAL (08,-0x4000) + +VAL (10,-0x7fff) +VAL (11, 0x7fff) +VAL (12, 0x7f80) +VAL (13,-0x7f80) +VAL (14, 0x7f81) +VAL (15,-0x7f81) +VAL (16, 0x7f7f) +VAL (17,-0x7f7f) +VAL (18, 0x7f80) +VAL (19,-0x7f80) +VAL (20, 0x3e80) +VAL (21,-0x3e80) +VAL (22, 0x3f80) +VAL (23,-0x3f80) +VAL (24, 0x40) +VAL (25,-0x40) +VAL (26, 0x3f00) +VAL (27,-0x3f00) +VAL (30, 0x00ff) +VAL (31,-0x00ff) + diff --git a/gcc/testsuite/gcc.target/avr/torture/vals-uhr.def b/gcc/testsuite/gcc.target/avr/torture/vals-uhr.def new file mode 100644 index 0000000000..71441567ca --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/vals-uhr.def @@ -0,0 +1,13 @@ +VAL (01, 0x0) +VAL (02, 0x1) +VAL (03, 0x3f) +VAL (07, 0x40) +VAL (08, 0xc0) +VAL (10, 0xc1) +VAL (12, 0xff) +VAL (14, 0x7f) +VAL (16, 0x81) +VAL (20, 0xbf) + +VAL (99, 0x80) + diff --git a/gcc/testsuite/gcc.target/avr/torture/vals-uk.def b/gcc/testsuite/gcc.target/avr/torture/vals-uk.def new file mode 100644 index 0000000000..3e212836f4 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/vals-uk.def @@ -0,0 +1,23 @@ +VAL (01, 0x0) +VAL (02, 0x1) +VAL (03, 0x3f) +VAL (04, 0x80) +VAL (07, 0x40000000) +VAL (08, 0xc0000000) +VAL (10, 0x7fffffff) +VAL (12, 0x7f800000) +VAL (14, 0x7f800001) +VAL (16, 0x7f7f7f7f) +VAL (18, 0x7f808000) +VAL (20, 0x3e800000) +VAL (22, 0x3f800000) +VAL (24, 0x40000000) +VAL (26, 0x3f000000) +VAL (28, 0xffff00) +VAL (30, 0x00ff00ff) +VAL (31, 0xff00ff00) +VAL (32, 0x10000000) +VAL (33, 0xff000000) + +VAL (99, 0x80000000) + diff --git a/gcc/testsuite/gcc.target/avr/torture/vals-ullk.def b/gcc/testsuite/gcc.target/avr/torture/vals-ullk.def new file mode 100644 index 0000000000..620182be64 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/vals-ullk.def @@ -0,0 +1,20 @@ +VAL (01, 0x0) +VAL (02, 0x1) +VAL (03, 0x3f) +VAL (04, 0x80) +VAL (07, 0x4000000000000000) +VAL (08, 0x4000000000000000) +VAL (10, 0x7fffffffffffffff) +VAL (12, 0x7f80000000000000) +VAL (14, 0x7f80000000000001) +VAL (16, 0x7f7f7f7f7f7f7f7f) +VAL (18, 0x7f80808080808000) +VAL (20, 0x3e80000000000000) +VAL (22, 0x3f80000000000000) +VAL (24, 0x40000000000000) +VAL (26, 0x3f000000000000) +VAL (28, 0xffffff00) +VAL (30, 0x00ff00ff00ff00ff) + +VAL (99, 0x8000000000000000) + diff --git a/gcc/testsuite/gcc.target/avr/torture/vals-ur.def b/gcc/testsuite/gcc.target/avr/torture/vals-ur.def new file mode 100644 index 0000000000..d6ea8f1c50 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/vals-ur.def @@ -0,0 +1,17 @@ +VAL (01, 0x0) +VAL (02, 0x1) +VAL (03, 0x3f) +VAL (04, 0x80) +VAL (07, 0x4000) +VAL (08, 0xc000) +VAL (10, 0x7fff) +VAL (12, 0x7f80) +VAL (14, 0x7f81) +VAL (16, 0x7f7f) +VAL (20, 0x3e80) +VAL (22, 0x3f80) +VAL (26, 0x3f00) +VAL (32, 0x100) + +VAL (99, 0x8000) + |