1  #ifndef LONG_DOUBLE_WF_H
       2  #define LONG_DOUBLE_WF_H 1
       3  
       4  #include <math.h>
       5  
       6  #define ADD(x, y, z) ((x) + (z))
       7  #define DIV(x, y, z) ((x) / (z))
       8  #define FABSL(x, y, z) (fabsl (y))
       9  #define ISINFL(x, y, z) (isinfl (x) ? (y) : (z))
      10  #define MUL(x, y, z) ((x) * (z))
      11  #define MUL_ADD(x, y, z) ((x) * (y) + (z))
      12  #define MUL_SUB(x, y, z) ((x) * (y) - (z))
      13  #define NEG(x, y, z)                                                          \
      14    ({                                                                          \
      15      volatile long double r = -(y);                                            \
      16      r;                                                                        \
      17    })
      18  #define NEG_MUL_ADD(x, y, z) NEG (0, MUL_ADD (x, y, z), 0)
      19  #define NEG_MUL_SUB(x, y, z) NEG (0, MUL_SUB (x, y, z), 0)
      20  #define QUIET_IFEQUAL(x, y, z) ((x) == (y) ? (z) : 0)
      21  #define QUIET_IFGREATER(x, y, z) (__builtin_isgreater (x, y) ? (z) : 0)
      22  #define QUIET_IFLESS(x, y, z) (__builtin_isless (x, y) ? (z) : 0)
      23  #define QUIET_IFUNORDERED(x, y, z) (__builtin_isunordered (x, y) ? (z) : 0)
      24  #define SIGNALING_IFEQUAL(x, y, z) (((x) >= (y) && (x) <= (y)) ? (z) : 0)
      25  #define SIGNALING_IFGREATER(x, y, z) ((x) > (y) ? (z) : 0)
      26  #define SIGNALING_IFLESS(x, y, z) ((x) < (y) ? (z) : 0)
      27  #define ROUNDL(x, y, z) (roundl (y))
      28  #define SQRTL(x, y, z) (sqrtl (y))
      29  #define SUB(x, y, z) ((x) - (z))
      30  
      31  #define LONG_DOUBLE_WF(op)                                                    \
      32    long double test (                                                          \
      33        long double x0, long double x1, long double x2, long double x3,         \
      34        long double x4, long double x5, long double x6, long double x7,         \
      35        long double x8, long double x9, long double x10, long double x11,       \
      36        long double x12, long double x13, long double x14, long double x15)     \
      37    {                                                                           \
      38      while (x15 < 1E+30)                                                       \
      39        {                                                                       \
      40  	x0 = op (x1, x2, x3);                                                 \
      41  	x1 = op (x2, x3, x4) + 1;                                             \
      42  	x2 = op (x3, x4, x5) + 2;                                             \
      43  	x3 = op (x4, x5, x6) + 3;                                             \
      44  	x4 = op (x5, x6, x7) + 4;                                             \
      45  	x5 = op (x6, x7, x8) + 5;                                             \
      46  	x6 = op (x7, x8, x9) + 6;                                             \
      47  	x7 = op (x8, x9, x10) + 7;                                            \
      48  	x8 = op (x9, x10, x11) + 8;                                           \
      49  	x9 = op (x10, x11, x12) + 9;                                          \
      50  	x10 = op (x11, x12, x13) + 10;                                        \
      51  	x11 = op (x12, x13, x14) + 11;                                        \
      52  	x12 = op (x13, x14, x15) + 12;                                        \
      53  	x13 = op (x14, x15, x0) + 13;                                         \
      54  	x14 = op (x15, x0, x1) + 14;                                          \
      55  	x15 = op (x0, x1, x2) + 15;                                           \
      56        }                                                                       \
      57      return x15;                                                               \
      58    }
      59  
      60  #endif