/* { dg-do run { target { fixed_point } } } */
/* { dg-options "-std=gnu99" } */

/* Check basic arithmetic ops for ARM fixed-point/saturating operation support.
   Not target-independent since we make various assumptions about precision and
   magnitudes of various types.  */

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <stdfix.h>

#define TEST(TYPE, OP, NAME, SUFFIX)				\
  TYPE NAME##SUFFIX (TYPE A, TYPE B)				\
    {								\
      return A OP B;						\
    }

#define VARIANTS(TYPE, OP, NAME)				\
  TEST (short TYPE, OP, NAME, _short);				\
  TEST (TYPE, OP, NAME, _regular);				\
  TEST (long TYPE, OP, NAME, _long);				\
  TEST (_Sat short TYPE, OP, NAME, _sat_short);			\
  TEST (_Sat TYPE, OP, NAME, _sat_regular);			\
  TEST (_Sat long TYPE, OP, NAME, _sat_long);			\
  TEST (unsigned short TYPE, OP, NAME, _uns_short);		\
  TEST (unsigned TYPE, OP, NAME, _uns_regular);			\
  TEST (unsigned long TYPE, OP, NAME, _uns_long);		\
  TEST (unsigned _Sat short TYPE, OP, NAME, _uns_sat_short);	\
  TEST (unsigned _Sat TYPE, OP, NAME, _uns_sat_regular);	\
  TEST (unsigned _Sat long TYPE, OP, NAME, _uns_sat_long)

VARIANTS (_Fract, +, plus_fract);
VARIANTS (_Accum, +, plus_accum);
VARIANTS (_Fract, -, minus_fract);
VARIANTS (_Accum, -, minus_accum);
VARIANTS (_Fract, *, mult_fract);
VARIANTS (_Accum, *, mult_accum);
VARIANTS (_Accum, /, div_accum);

/* Inputs for signed add, multiply fractional tests.  */
short _Fract sf_a = 0.9hr;
short _Fract sf_b = -0.8hr;
_Fract f_a = 0.9r;
_Fract f_b = -0.8r;
long _Fract lf_a = 0.9lr;
long _Fract lf_b = -0.8lr;

/* Inputs for signed subtract fractional tests.  */
short _Fract sf_c = 0.7hr;
short _Fract sf_d = 0.9hr;
_Fract f_c = 0.7r;
_Fract f_d = 0.9r;
long _Fract lf_c = 0.7lr;
long _Fract lf_d = 0.9lr;

/* Inputs for unsigned add, subtract, multiply fractional tests.  */
unsigned short _Fract usf_a = 0.4uhr;
unsigned short _Fract usf_b = 0.3uhr;
unsigned _Fract uf_a = 0.4ur;
unsigned _Fract uf_b = 0.3ur;
unsigned long _Fract ulf_a = 0.4ulr;
unsigned long _Fract ulf_b = 0.3ulr;

/* Inputs for saturating signed add tests.  */
short _Sat _Fract sf_e = 0.8hr;
short _Sat _Fract sf_f = 0.8hr;
_Sat _Fract f_e = 0.8r;
_Sat _Fract f_f = 0.8r;
long _Sat _Fract lf_e = 0.8r;
long _Sat _Fract lf_f = 0.8r;

short _Sat _Fract sf_g = -0.8hr;
short _Sat _Fract sf_h = -0.8hr;
_Sat _Fract f_g = -0.8r;
_Sat _Fract f_h = -0.8r;
long _Sat _Fract lf_g = -0.8r;
long _Sat _Fract lf_h = -0.8r;

/* Inputs for saturating unsigned subtract tests.  */
unsigned short _Sat _Fract usf_c = 0.3uhr;
unsigned short _Sat _Fract usf_d = 0.4uhr;
unsigned _Sat _Fract uf_c = 0.3ur;
unsigned _Sat _Fract uf_d = 0.4ur;
unsigned long _Sat _Fract ulf_c = 0.3ulr;
unsigned long _Sat _Fract ulf_d = 0.4ulr;

/* Inputs for signed accumulator tests.  */

short _Accum sa_a = 1.25hk;
short _Accum sa_b = -1.5hk;
_Accum a_a = 100.25k;
_Accum a_b = -100.5k;
long _Accum la_a = 1000.25lk;
long _Accum la_b = -1000.5lk;

/* Inputs for unsigned accumulator tests.  */

unsigned short _Accum usa_a = 2.5uhk;
unsigned short _Accum usa_b = 1.75uhk;
unsigned _Accum ua_a = 255.5uk;
unsigned _Accum ua_b = 170.25uk;
unsigned long _Accum ula_a = 1550.5ulk;
unsigned long _Accum ula_b = 999.5ulk;

/* Inputs for signed saturating accumulator tests.  */

short _Sat _Accum sa_c = 240.0hk;
short _Sat _Accum sa_d = 250.0hk;
short _Sat _Accum sa_e = -240.0hk;
short _Sat _Accum sa_f = -250.0hk;
short _Sat _Accum sa_g = 0.5hk;

_Sat _Accum a_c = 65000.0k;
_Sat _Accum a_d = 20000.0k;
_Sat _Accum a_e = -65000.0k;
_Sat _Accum a_f = -20000.0k;
_Sat _Accum a_g = 0.5k;

long _Sat _Accum la_c = 3472883712.0lk;
long _Sat _Accum la_d = 3456106496.0lk;
long _Sat _Accum la_e = -3472883712.0lk;
long _Sat _Accum la_f = -3456106496.0lk;
long _Sat _Accum la_g = 0.5lk;

/* Inputs for unsigned saturating accumulator tests.  */

unsigned short _Sat _Accum usa_c = 250.0uhk;
unsigned short _Sat _Accum usa_d = 240.0uhk;
unsigned short _Sat _Accum usa_e = 0.5uhk;

unsigned _Sat _Accum ua_c = 65000.0uk;
unsigned _Sat _Accum ua_d = 20000.0uk;
unsigned _Sat _Accum ua_e = 0.5uk;

unsigned long _Sat _Accum ula_c = 3472883712.0ulk;
unsigned long _Sat _Accum ula_d = 3456106496.0ulk;
unsigned long _Sat _Accum ula_e = 0.5ulk;

#define CHECK(FN, EXP) do {						     \
  if (fabs ((float) (FN) - (EXP)) > 0.05)				     \
    {									     \
      fprintf (stderr, "result for " #FN " (as float): %f\n", (double) (FN));\
      abort ();								     \
    }									     \
  } while (0)

#define CHECK_EXACT(FN, EXP) do {					     \
  if ((FN) != (EXP))							     \
    {									     \
      fprintf (stderr, "result for " #FN " (as float): %f, should be %f\n",  \
	       (double) (FN), (double) (EXP));				     \
      abort ();								     \
    }									     \
  } while (0)

int
main (int argc, char *argv[])
{
  /* Fract/fract operations, non-saturating.  */

  CHECK (plus_fract_short (sf_a, sf_b), 0.1);
  CHECK (plus_fract_regular (f_a, f_b), 0.1);
  CHECK (plus_fract_long (lf_a, lf_b), 0.1);

  CHECK (plus_fract_uns_short (usf_a, usf_b), 0.7);
  CHECK (plus_fract_uns_regular (uf_a, uf_b), 0.7);
  CHECK (plus_fract_uns_long (ulf_a, ulf_b), 0.7);

  CHECK (minus_fract_short (sf_c, sf_d), -0.2);
  CHECK (minus_fract_regular (f_c, f_d), -0.2);
  CHECK (minus_fract_long (lf_c, lf_d), -0.2);

  CHECK (minus_fract_uns_short (usf_a, usf_b), 0.1);
  CHECK (minus_fract_uns_regular (uf_a, uf_b), 0.1);
  CHECK (minus_fract_uns_long (ulf_a, ulf_b), 0.1);

  CHECK (mult_fract_short (sf_a, sf_b), -0.72);
  CHECK (mult_fract_regular (f_a, f_b), -0.72);
  CHECK (mult_fract_long (lf_a, lf_b), -0.72);

  CHECK (mult_fract_uns_short (usf_a, usf_b), 0.12);
  CHECK (mult_fract_uns_regular (uf_a, uf_b), 0.12);
  CHECK (mult_fract_uns_long (ulf_a, ulf_b), 0.12);

  /* Fract/fract operations, saturating.  */

  CHECK (plus_fract_sat_short (sf_e, sf_f), 1.0);
  CHECK (plus_fract_sat_regular (f_e, f_f), 1.0);
  CHECK (plus_fract_sat_long (lf_e, lf_f), 1.0);

  CHECK (plus_fract_sat_short (sf_g, sf_h), -1.0);
  CHECK (plus_fract_sat_regular (f_g, f_h), -1.0);
  CHECK (plus_fract_sat_long (lf_g, lf_h), -1.0);
  
  CHECK (plus_fract_uns_sat_short (sf_e, sf_f), 1.0);
  CHECK (plus_fract_uns_sat_regular (f_e, f_f), 1.0);
  CHECK (plus_fract_uns_sat_long (lf_e, lf_f), 1.0);

  CHECK (plus_fract_sat_short (sf_a, sf_b), 0.1);
  CHECK (plus_fract_sat_regular (f_a, f_b), 0.1);
  CHECK (plus_fract_sat_long (lf_a, lf_b), 0.1);
  
  CHECK (plus_fract_uns_sat_short (usf_a, usf_b), 0.7);
  CHECK (plus_fract_uns_sat_regular (uf_a, uf_b), 0.7);
  CHECK (plus_fract_uns_sat_long (ulf_a, ulf_b), 0.7);

  CHECK (minus_fract_uns_sat_short (usf_c, usf_d), 0.0);
  CHECK (minus_fract_uns_sat_regular (uf_c, uf_d), 0.0);
  CHECK (minus_fract_uns_sat_short (ulf_c, ulf_d), 0.0);
  
  CHECK (minus_fract_sat_short (sf_c, sf_d), -0.2);
  CHECK (minus_fract_sat_regular (f_c, f_d), -0.2);
  CHECK (minus_fract_sat_long (lf_c, lf_d), -0.2);

  /* Accum/accum operations, non-saturating.  */

  CHECK (plus_accum_short (sa_a, sa_b), -0.25);
  CHECK (plus_accum_regular (a_a, a_b), -0.25);
  CHECK (plus_accum_long (la_a, la_b), -0.25);

  CHECK (minus_accum_short (sa_a, sa_b), 2.75);
  CHECK (minus_accum_regular (a_a, a_b), 200.75);
  CHECK (minus_accum_long (la_a, la_b), 2000.75);
  
  CHECK (mult_accum_short (sa_a, sa_b), -1.875);
  CHECK (mult_accum_regular (a_a, a_b), -10075.125);
  CHECK (mult_accum_long (la_a, la_b), -1000750.125);

  CHECK (div_accum_short (sa_a, sa_b), -1.25/1.5);
  CHECK (div_accum_regular (a_a, a_b), -100.25/100.5);
  CHECK (div_accum_long (la_a, la_b), -1000.25/1000.5);

  /* Unsigned accum/accum operations, non-saturating.  */
  
  CHECK (plus_accum_uns_short (usa_a, usa_b), 4.25);
  CHECK (plus_accum_uns_regular (ua_a, ua_b), 425.75);
  CHECK (plus_accum_uns_long (ula_a, ula_b), 2550.0);

  CHECK (minus_accum_uns_short (usa_a, usa_b), 0.75);
  CHECK (minus_accum_uns_regular (ua_a, ua_b), 85.25);
  CHECK (minus_accum_uns_long (ula_a, ula_b), 551.0);
  
  CHECK (mult_accum_uns_short (usa_a, usa_b), 4.375);
  CHECK (mult_accum_uns_regular (ua_a, ua_b), 43498.875);
  CHECK (mult_accum_uns_long (ula_a, ula_b), 1549724.75);

  CHECK (div_accum_uns_short (usa_a, usa_b), 2.5/1.75);
  CHECK (div_accum_uns_regular (ua_a, ua_b), 255.5/170.25);
  CHECK (div_accum_uns_long (ula_a, ula_b), 1550.5/999.5);

  /* Signed accum/accum operations, saturating.  */
  
  CHECK_EXACT (plus_accum_sat_short (sa_c, sa_d), SACCUM_MAX);
  CHECK_EXACT (plus_accum_sat_short (sa_e, sa_f), SACCUM_MIN);
  CHECK_EXACT (plus_accum_sat_regular (a_c, a_d), ACCUM_MAX);
  CHECK_EXACT (plus_accum_sat_regular (a_e, a_f), ACCUM_MIN);
  CHECK_EXACT (plus_accum_sat_long (la_c, la_d), LACCUM_MAX);
  CHECK_EXACT (plus_accum_sat_long (la_e, la_f), LACCUM_MIN);

  CHECK_EXACT (minus_accum_sat_short (sa_e, sa_d), SACCUM_MIN);
  CHECK_EXACT (minus_accum_sat_short (sa_c, sa_f), SACCUM_MAX);
  CHECK_EXACT (minus_accum_sat_regular (a_e, a_d), ACCUM_MIN);
  CHECK_EXACT (minus_accum_sat_regular (a_c, a_f), ACCUM_MAX);
  CHECK_EXACT (minus_accum_sat_long (la_e, la_d), LACCUM_MIN);
  CHECK_EXACT (minus_accum_sat_long (la_c, la_f), LACCUM_MAX);

  CHECK_EXACT (mult_accum_sat_short (sa_c, sa_d), SACCUM_MAX);
  CHECK_EXACT (mult_accum_sat_short (sa_c, sa_e), SACCUM_MIN);
  CHECK_EXACT (mult_accum_sat_regular (a_c, a_d), ACCUM_MAX);
  CHECK_EXACT (mult_accum_sat_regular (a_c, a_e), ACCUM_MIN);
  CHECK_EXACT (mult_accum_sat_long (la_c, la_d), LACCUM_MAX);
  CHECK_EXACT (mult_accum_sat_long (la_c, la_e), LACCUM_MIN);
  
  CHECK_EXACT (div_accum_sat_short (sa_d, sa_g), SACCUM_MAX);
  CHECK_EXACT (div_accum_sat_short (sa_e, sa_g), SACCUM_MIN);
  CHECK_EXACT (div_accum_sat_regular (a_c, a_g), ACCUM_MAX);
  CHECK_EXACT (div_accum_sat_regular (a_e, a_g), ACCUM_MIN);
  CHECK_EXACT (div_accum_sat_long (la_d, la_g), LACCUM_MAX);
  CHECK_EXACT (div_accum_sat_long (la_e, la_g), LACCUM_MIN);

  /* Unsigned accum/accum operations, saturating.  */

  CHECK_EXACT (plus_accum_uns_sat_short (usa_c, usa_d), USACCUM_MAX);
  CHECK_EXACT (plus_accum_uns_sat_regular (ua_c, ua_d), UACCUM_MAX);
  CHECK_EXACT (plus_accum_uns_sat_long (ula_c, ula_d), ULACCUM_MAX);
  
  CHECK_EXACT (minus_accum_uns_sat_short (usa_d, usa_c), 0uhk);
  CHECK_EXACT (minus_accum_uns_sat_regular (ua_d, ua_c), 0uk);
  CHECK_EXACT (minus_accum_uns_sat_long (ula_d, ula_c), 0ulk);

  CHECK_EXACT (mult_accum_uns_sat_short (usa_c, usa_d), USACCUM_MAX);
  CHECK_EXACT (mult_accum_uns_sat_regular (ua_c, ua_d), UACCUM_MAX);
  CHECK_EXACT (mult_accum_uns_sat_long (ula_c, ula_d), ULACCUM_MAX);

  CHECK_EXACT (div_accum_uns_sat_short (usa_c, usa_e), USACCUM_MAX);
  CHECK_EXACT (div_accum_uns_sat_regular (ua_c, ua_e), UACCUM_MAX);
  CHECK_EXACT (div_accum_uns_sat_long (ula_c, ula_e), ULACCUM_MAX);

  return 0;
}