libquadmath/quadmath-imp.h

   1 /* GCC Quad-Precision Math Library
   2    Copyright (C) 2010, 2011 Free Software Foundation, Inc.
   3    Written by Francois-Xavier Coudert  <fxcoudert@gcc.gnu.org>
   4
   5 This file is part of the libquadmath library.
   6 Libquadmath is free software; you can redistribute it and/or
   7 modify it under the terms of the GNU Library General Public
   8 License as published by the Free Software Foundation; either
   9 version 2 of the License, or (at your option) any later version.
  10
  11 Libquadmath is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 Library General Public License for more details.
  15
  16 You should have received a copy of the GNU Library General Public
  17 License along with libquadmath; see the file COPYING.LIB.  If
  18 not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
  19 Boston, MA 02110-1301, USA.  */
  20
  21 #ifndef QUADMATH_IMP_H
  22 #define QUADMATH_IMP_H
  23
  24 #include <stdint.h>
  25 #include <stdlib.h>
  26 #include "quadmath.h"
  27 #include "config.h"
  28
  29
  30 /* Under IEEE 754, an architecture may determine tininess of
  31    floating-point results either "before rounding" or "after
  32    rounding", but must do so in the same way for all operations
  33    returning binary results.  Define TININESS_AFTER_ROUNDING to 1 for
  34    "after rounding" architectures, 0 for "before rounding"
  35    architectures.  */
  36
  37 #define TININESS_AFTER_ROUNDING   1
  38
  39
  40 /* Prototypes for internal functions.  */
  41 extern int32_t __quadmath_rem_pio2q (__float128, __float128 *);
  42 extern void __quadmath_kernel_sincosq (__float128, __float128, __float128 *,
  43                                        __float128 *, int);
  44 extern __float128 __quadmath_kernel_sinq (__float128, __float128, int);
  45 extern __float128 __quadmath_kernel_cosq (__float128, __float128);
  46 extern __float128 __quadmath_x2y2m1q (__float128 x, __float128 y);
  47 extern int __quadmath_isinf_nsq (__float128 x);
  48
  49
  50
  51
  52
  53 /* Frankly, if you have __float128, you have 64-bit integers, right?  */
  54 #ifndef UINT64_C
  55 # error "No way!"
  56 #endif
  57
  58
  59 /* Main union type we use to manipulate the floating-point type.  */
  60 typedef union
  61 {
  62   __float128 value;
  63
  64   struct
  65 #ifdef __MINGW32__
  66   /* On mingw targets the ms-bitfields option is active by default.
  67      Therefore enforce gnu-bitfield style.  */
  68   __attribute__ ((gcc_struct))
  69 #endif
  70   {
  71 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
  72     unsigned negative:1;
  73     unsigned exponent:15;
  74     uint64_t mant_high:48;
  75     uint64_t mant_low:64;
  76 #else
  77     uint64_t mant_low:64;
  78     uint64_t mant_high:48;
  79     unsigned exponent:15;
  80     unsigned negative:1;
  81 #endif
  82   } ieee;
  83
  84   struct
  85   {
  86 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
  87     uint64_t high;
  88     uint64_t low;
  89 #else
  90     uint64_t low;
  91     uint64_t high;
  92 #endif
  93   } words64;
  94
  95   struct
  96   {
  97 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
  98     uint32_t w0;
  99     uint32_t w1;
 100     uint32_t w2;
 101     uint32_t w3;
 102 #else
 103     uint32_t w3;
 104     uint32_t w2;
 105     uint32_t w1;
 106     uint32_t w0;
 107 #endif
 108   } words32;
 109
 110   struct
 111 #ifdef __MINGW32__
 112   /* Make sure we are using gnu-style bitfield handling.  */
 113   __attribute__ ((gcc_struct))
 114 #endif
 115   {
 116 #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 117     unsigned negative:1;
 118     unsigned exponent:15;
 119     unsigned quiet_nan:1;
 120     uint64_t mant_high:47;
 121     uint64_t mant_low:64;
 122 #else
 123     uint64_t mant_low:64;
 124     uint64_t mant_high:47;
 125     unsigned quiet_nan:1;
 126     unsigned exponent:15;
 127     unsigned negative:1;
 128 #endif
 129   } nan;
 130
 131 } ieee854_float128;
 132
 133
 134 /* Get two 64 bit ints from a long double.  */
 135 #define GET_FLT128_WORDS64(ix0,ix1,d)  \
 136 do {                                   \
 137   ieee854_float128 u;                  \
 138   u.value = (d);                       \
 139   (ix0) = u.words64.high;              \
 140   (ix1) = u.words64.low;               \
 141 } while (0)
 142
 143 /* Set a long double from two 64 bit ints.  */
 144 #define SET_FLT128_WORDS64(d,ix0,ix1)  \
 145 do {                                   \
 146   ieee854_float128 u;                  \
 147   u.words64.high = (ix0);              \
 148   u.words64.low = (ix1);               \
 149   (d) = u.value;                       \
 150 } while (0)
 151
 152 /* Get the more significant 64 bits of a long double mantissa.  */
 153 #define GET_FLT128_MSW64(v,d)          \
 154 do {                                   \
 155   ieee854_float128 u;                  \
 156   u.value = (d);                       \
 157   (v) = u.words64.high;                \
 158 } while (0)
 159
 160 /* Set the more significant 64 bits of a long double mantissa from an int.  */
 161 #define SET_FLT128_MSW64(d,v)          \
 162 do {                                   \
 163   ieee854_float128 u;                  \
 164   u.value = (d);                       \
 165   u.words64.high = (v);                \
 166   (d) = u.value;                       \
 167 } while (0)
 168
 169 /* Get the least significant 64 bits of a long double mantissa.  */
 170 #define GET_FLT128_LSW64(v,d)          \
 171 do {                                   \
 172   ieee854_float128 u;                  \
 173   u.value = (d);                       \
 174   (v) = u.words64.low;                 \
 175 } while (0)
 176
 177
 178 #define IEEE854_FLOAT128_BIAS 0x3fff
 179
 180 #define QUADFP_NAN              0
 181 #define QUADFP_INFINITE         1
 182 #define QUADFP_ZERO             2
 183 #define QUADFP_SUBNORMAL        3
 184 #define QUADFP_NORMAL           4
 185 #define fpclassifyq(x) \
 186   __builtin_fpclassify (QUADFP_NAN, QUADFP_INFINITE, QUADFP_NORMAL, \
 187                         QUADFP_SUBNORMAL, QUADFP_ZERO, x)
 188
 189 #ifndef math_opt_barrier
 190 # define math_opt_barrier(x) \
 191 ({ __typeof (x) __x = (x); __asm ("" : "+m" (__x)); __x; })
 192 # define math_force_eval(x) \
 193 ({ __typeof (x) __x = (x); __asm __volatile__ ("" : : "m" (__x)); })
 194 #endif
 195
 196 /* math_narrow_eval reduces its floating-point argument to the range
 197    and precision of its semantic type.  (The original evaluation may
 198    still occur with excess range and precision, so the result may be
 199    affected by double rounding.)  */
 200 #define math_narrow_eval(x) (x)
 201
 202 /* If X (which is not a NaN) is subnormal, force an underflow
 203    exception.  */
 204 #define math_check_force_underflow(x)                           \
 205   do                                                            \
 206     {                                                           \
 207       __float128 force_underflow_tmp = (x);                     \
 208       if (fabsq (force_underflow_tmp) < FLT128_MIN)             \
 209         {                                                       \
 210           __float128 force_underflow_tmp2                       \
 211             = force_underflow_tmp * force_underflow_tmp;        \
 212           math_force_eval (force_underflow_tmp2);               \
 213         }                                                       \
 214     }                                                           \
 215   while (0)
 216 /* Likewise, but X is also known to be nonnegative.  */
 217 #define math_check_force_underflow_nonneg(x)                    \
 218   do                                                            \
 219     {                                                           \
 220       __float128 force_underflow_tmp = (x);                     \
 221       if (force_underflow_tmp < FLT128_MIN)                     \
 222         {                                                       \
 223           __float128 force_underflow_tmp2                       \
 224             = force_underflow_tmp * force_underflow_tmp;        \
 225           math_force_eval (force_underflow_tmp2);               \
 226         }                                                       \
 227     }                                                           \
 228   while (0)
 229
 230 #endif