gcc/testsuite/gcc.dg/torture/floatn-tg-3.h

   1 /* Tests for _FloatN / _FloatNx types: compile and execution tests for
   2    type-generic built-in functions: __builtin_fpclassify.  Before
   3    including this file, define WIDTH as the value N; define EXT to 1
   4    for _FloatNx and 0 for _FloatN.  */
   5
   6 #define __STDC_WANT_IEC_60559_TYPES_EXT__
   7 #include <float.h>
   8
   9 #define CONCATX(X, Y) X ## Y
  10 #define CONCAT(X, Y) CONCATX (X, Y)
  11 #define CONCAT3(X, Y, Z) CONCAT (CONCAT (X, Y), Z)
  12 #define CONCAT4(W, X, Y, Z) CONCAT (CONCAT (CONCAT (W, X), Y), Z)
  13
  14 #if EXT
  15 # define TYPE CONCAT3 (_Float, WIDTH, x)
  16 # define CST(C) CONCAT4 (C, f, WIDTH, x)
  17 # define MAX CONCAT3 (FLT, WIDTH, X_MAX)
  18 # define MIN CONCAT3 (FLT, WIDTH, X_MIN)
  19 # define TRUE_MIN CONCAT3 (FLT, WIDTH, X_TRUE_MIN)
  20 #else
  21 # define TYPE CONCAT (_Float, WIDTH)
  22 # define CST(C) CONCAT3 (C, f, WIDTH)
  23 # define MAX CONCAT3 (FLT, WIDTH, _MAX)
  24 # define MIN CONCAT3 (FLT, WIDTH, _MIN)
  25 # define TRUE_MIN CONCAT3 (FLT, WIDTH, _TRUE_MIN)
  26 #endif
  27
  28 extern void exit (int);
  29 extern void abort (void);
  30
  31 #define FP_NAN 0
  32 #define FP_INFINITE 1
  33 #define FP_ZERO 2
  34 #define FP_SUBNORMAL 3
  35 #define FP_NORMAL 4
  36
  37 #define fpclassify(X) __builtin_fpclassify (FP_NAN, FP_INFINITE,     \
  38                                             FP_NORMAL, FP_SUBNORMAL, \
  39                                             FP_ZERO, (X))
  40
  41 volatile TYPE inf = __builtin_inf (), nanval = __builtin_nan ("");
  42 volatile TYPE neginf = -__builtin_inf (), negnanval = -__builtin_nan ("");
  43 volatile TYPE zero = CST (0.0), negzero = -CST (0.0), one = CST (1.0);
  44 volatile TYPE max = MAX, negmax = -MAX, min = MIN, negmin = -MIN;
  45 volatile TYPE true_min = TRUE_MIN, negtrue_min = -TRUE_MIN;
  46
  47 /* Allow for any optimizations of comparisons involving the result of
  48    fpclassify by also testing case where result is stored in a
  49    volatile variable and so the comparison cannot be optimized.  */
  50 #define CHECK_FPCLASSIFY(VAL, EXP)              \
  51   do                                            \
  52     {                                           \
  53       volatile int c;                           \
  54       if (fpclassify (VAL) != (EXP))            \
  55         abort ();                               \
  56       c = fpclassify (VAL);                     \
  57       if (c != (EXP))                           \
  58         abort ();                               \
  59     }                                           \
  60   while (0)
  61
  62 int
  63 main (void)
  64 {
  65   CHECK_FPCLASSIFY (inf, FP_INFINITE);
  66   CHECK_FPCLASSIFY (neginf, FP_INFINITE);
  67   CHECK_FPCLASSIFY (nanval, FP_NAN);
  68   CHECK_FPCLASSIFY (negnanval, FP_NAN);
  69   CHECK_FPCLASSIFY (zero, FP_ZERO);
  70   CHECK_FPCLASSIFY (negzero, FP_ZERO);
  71   CHECK_FPCLASSIFY (one, FP_NORMAL);
  72   CHECK_FPCLASSIFY (max, FP_NORMAL);
  73   CHECK_FPCLASSIFY (negmax, FP_NORMAL);
  74   CHECK_FPCLASSIFY (min, FP_NORMAL);
  75   CHECK_FPCLASSIFY (negmin, FP_NORMAL);
  76   CHECK_FPCLASSIFY (true_min, FP_SUBNORMAL);
  77   CHECK_FPCLASSIFY (negtrue_min, FP_SUBNORMAL);
  78   exit (0);
  79 }