Subversion Repositories scarts

/* Copyright (C) 2004 Free Software Foundation.

   Check that constant folding of the rounding math functions doesn't

   break anything and produces the expected results.

   Written by Kaveh Ghazi, 2004-04-29.  */

/* { dg-do link } */

#define PROTOTYPE(FN) \

  PROTOTYPE_LINK_ERROR(FN) \

  extern double FN (double); \

  extern float FN##f (float); \

  extern long double FN##l (long double);

#define PROTOTYPE_RET(FN, RET) \

  PROTOTYPE_LINK_ERROR(FN) \

  extern RET FN (double); \

  extern RET FN##f (float); \

  extern RET FN##l (long double);

#define PROTOTYPE_LINK_ERROR(FN) \

  extern void link_error_##FN(void); \

  extern void link_error_##FN##f(void); \

  extern void link_error_##FN##l(void);

#define TEST(FN, VALUE, RESULT) \

  if (FN (VALUE) != RESULT) link_error_##FN(); \

  if (FN##f (VALUE) != RESULT) link_error_##FN##f(); \

  if (FN##l (VALUE) != RESULT) link_error_##FN##l(); \

PROTOTYPE (trunc);

PROTOTYPE (floor);

PROTOTYPE (ceil);

PROTOTYPE (round);

PROTOTYPE_RET (lround, long);

PROTOTYPE_RET (llround, long long);

int

main (void)

{

  TEST(trunc,   0, 0);

  TEST(floor,   0, 0);

  TEST(ceil,    0, 0);

  TEST(round,   0, 0);

  TEST(lround,  0, 0);

  TEST(llround, 0, 0);

  TEST(trunc,   6, 6);

  TEST(floor,   6, 6);

  TEST(ceil,    6, 6);

  TEST(round,   6, 6);

  TEST(lround,  6, 6);

  TEST(llround, 6, 6);

  TEST(trunc,   -8, -8);

  TEST(floor,   -8, -8);

  TEST(ceil,    -8, -8);

  TEST(round,   -8, -8);

  TEST(lround,  -8, -8);

  TEST(llround, -8, -8);

  TEST(trunc,   3.2, 3);

  TEST(floor,   3.2, 3);

  TEST(ceil,    3.2, 4);

  TEST(round,   3.2, 3);

  TEST(lround,  3.2, 3);

  TEST(llround, 3.2, 3);

  TEST(trunc,   -2.8, -2);

  TEST(floor,   -2.8, -3);

  TEST(ceil,    -2.8, -2);

  TEST(round,   -2.8, -3);

  TEST(lround,  -2.8, -3);

  TEST(llround, -2.8, -3);

  TEST(trunc,   0.01, 0);

  TEST(floor,   0.01, 0);

  TEST(ceil,    0.01, 1);

  TEST(round,   0.01, 0);

  TEST(lround,  0.01, 0);

  TEST(llround, 0.01, 0);

  TEST(trunc,   -0.7, 0);

  TEST(floor,   -0.7, -1);

  TEST(ceil,    -0.7, 0);

  TEST(round,   -0.7, -1);

  TEST(lround,  -0.7, -1);

  TEST(llround, -0.7, -1);

  TEST(trunc,   2.5, 2);

  TEST(floor,   2.5, 2);

  TEST(ceil,    2.5, 3);

  TEST(round,   2.5, 3);

  TEST(lround,  2.5, 3);

  TEST(llround, 2.5, 3);

  TEST(trunc,   -1.5, -1);

  TEST(floor,   -1.5, -2);

  TEST(ceil,    -1.5, -1);

  TEST(round,   -1.5, -2);

  TEST(lround,  -1.5, -2);

  TEST(llround, -1.5, -2);

  return 0;

}