git.oblomov.eu Git - linux-2.6/blob - include/math-emu/extended.h

   1 /* Software floating-point emulation.
   2    Definitions for IEEE Extended Precision.
   3    Copyright (C) 1999 Free Software Foundation, Inc.
   4    This file is part of the GNU C Library.
   5    Contributed by Jakub Jelinek (jj@ultra.linux.cz).
   6
   7    The GNU C Library is free software; you can redistribute it and/or
   8    modify it under the terms of the GNU Library General Public License as
   9    published by the Free Software Foundation; either version 2 of the
  10    License, or (at your option) any later version.
  11
  12    The GNU C Library is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    Library General Public License for more details.
  16
  17    You should have received a copy of the GNU Library General Public
  18    License along with the GNU C Library; see the file COPYING.LIB.  If
  19    not, write to the Free Software Foundation, Inc.,
  20    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22
  23 #ifndef    __MATH_EMU_EXTENDED_H__
  24 #define    __MATH_EMU_EXTENDED_H__
  25
  26 #if _FP_W_TYPE_SIZE < 32
  27 #error "Here's a nickel, kid. Go buy yourself a real computer."
  28 #endif
  29
  30 #if _FP_W_TYPE_SIZE < 64
  31 #define _FP_FRACTBITS_E         (4*_FP_W_TYPE_SIZE)
  32 #else
  33 #define _FP_FRACTBITS_E         (2*_FP_W_TYPE_SIZE)
  34 #endif
  35
  36 #define _FP_FRACBITS_E          64
  37 #define _FP_FRACXBITS_E         (_FP_FRACTBITS_E - _FP_FRACBITS_E)
  38 #define _FP_WFRACBITS_E         (_FP_WORKBITS + _FP_FRACBITS_E)
  39 #define _FP_WFRACXBITS_E        (_FP_FRACTBITS_E - _FP_WFRACBITS_E)
  40 #define _FP_EXPBITS_E           15
  41 #define _FP_EXPBIAS_E           16383
  42 #define _FP_EXPMAX_E            32767
  43
  44 #define _FP_QNANBIT_E           \
  45         ((_FP_W_TYPE)1 << (_FP_FRACBITS_E-2) % _FP_W_TYPE_SIZE)
  46 #define _FP_IMPLBIT_E           \
  47         ((_FP_W_TYPE)1 << (_FP_FRACBITS_E-1) % _FP_W_TYPE_SIZE)
  48 #define _FP_OVERFLOW_E          \
  49         ((_FP_W_TYPE)1 << (_FP_WFRACBITS_E % _FP_W_TYPE_SIZE))
  50
  51 #if _FP_W_TYPE_SIZE < 64
  52
  53 union _FP_UNION_E
  54 {
  55    long double flt;
  56    struct
  57    {
  58 #if __BYTE_ORDER == __BIG_ENDIAN
  59       unsigned long pad1 : _FP_W_TYPE_SIZE;
  60       unsigned long pad2 : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
  61       unsigned long sign : 1;
  62       unsigned long exp : _FP_EXPBITS_E;
  63       unsigned long frac1 : _FP_W_TYPE_SIZE;
  64       unsigned long frac0 : _FP_W_TYPE_SIZE;
  65 #else
  66       unsigned long frac0 : _FP_W_TYPE_SIZE;
  67       unsigned long frac1 : _FP_W_TYPE_SIZE;
  68       unsigned exp : _FP_EXPBITS_E;
  69       unsigned sign : 1;
  70 #endif /* not bigendian */
  71    } bits __attribute__((packed));
  72 };
  73
  74
  75 #define FP_DECL_E(X)            _FP_DECL(4,X)
  76
  77 #define FP_UNPACK_RAW_E(X, val)                         \
  78   do {                                                  \
  79     union _FP_UNION_E _flo; _flo.flt = (val);           \
  80                                                         \
  81     X##_f[2] = 0; X##_f[3] = 0;                         \
  82     X##_f[0] = _flo.bits.frac0;                         \
  83     X##_f[1] = _flo.bits.frac1;                         \
  84     X##_e  = _flo.bits.exp;                             \
  85     X##_s  = _flo.bits.sign;                            \
  86     if (!X##_e && (X##_f[1] || X##_f[0])                \
  87         && !(X##_f[1] & _FP_IMPLBIT_E))                 \
  88       {                                                 \
  89         X##_e++;                                        \
  90         FP_SET_EXCEPTION(FP_EX_DENORM);                 \
  91       }                                                 \
  92   } while (0)
  93
  94 #define FP_UNPACK_RAW_EP(X, val)                        \
  95   do {                                                  \
  96     union _FP_UNION_E *_flo =                           \
  97     (union _FP_UNION_E *)(val);                         \
  98                                                         \
  99     X##_f[2] = 0; X##_f[3] = 0;                         \
 100     X##_f[0] = _flo->bits.frac0;                        \
 101     X##_f[1] = _flo->bits.frac1;                        \
 102     X##_e  = _flo->bits.exp;                            \
 103     X##_s  = _flo->bits.sign;                           \
 104     if (!X##_e && (X##_f[1] || X##_f[0])                \
 105         && !(X##_f[1] & _FP_IMPLBIT_E))                 \
 106       {                                                 \
 107         X##_e++;                                        \
 108         FP_SET_EXCEPTION(FP_EX_DENORM);                 \
 109       }                                                 \
 110   } while (0)
 111
 112 #define FP_PACK_RAW_E(val, X)                           \
 113   do {                                                  \
 114     union _FP_UNION_E _flo;                             \
 115                                                         \
 116     if (X##_e) X##_f[1] |= _FP_IMPLBIT_E;               \
 117     else X##_f[1] &= ~(_FP_IMPLBIT_E);                  \
 118     _flo.bits.frac0 = X##_f[0];                         \
 119     _flo.bits.frac1 = X##_f[1];                         \
 120     _flo.bits.exp   = X##_e;                            \
 121     _flo.bits.sign  = X##_s;                            \
 122                                                         \
 123     (val) = _flo.flt;                                   \
 124   } while (0)
 125
 126 #define FP_PACK_RAW_EP(val, X)                          \
 127   do {                                                  \
 128     if (!FP_INHIBIT_RESULTS)                            \
 129       {                                                 \
 130         union _FP_UNION_E *_flo =                       \
 131           (union _FP_UNION_E *)(val);                   \
 132                                                         \
 133         if (X##_e) X##_f[1] |= _FP_IMPLBIT_E;           \
 134         else X##_f[1] &= ~(_FP_IMPLBIT_E);              \
 135         _flo->bits.frac0 = X##_f[0];                    \
 136         _flo->bits.frac1 = X##_f[1];                    \
 137         _flo->bits.exp   = X##_e;                       \
 138         _flo->bits.sign  = X##_s;                       \
 139       }                                                 \
 140   } while (0)
 141
 142 #define FP_UNPACK_E(X,val)              \
 143   do {                                  \
 144     FP_UNPACK_RAW_E(X,val);             \
 145     _FP_UNPACK_CANONICAL(E,4,X);        \
 146   } while (0)
 147
 148 #define FP_UNPACK_EP(X,val)             \
 149   do {                                  \
 150     FP_UNPACK_RAW_2_P(X,val);           \
 151     _FP_UNPACK_CANONICAL(E,4,X);        \
 152   } while (0)
 153
 154 #define FP_PACK_E(val,X)                \
 155   do {                                  \
 156     _FP_PACK_CANONICAL(E,4,X);          \
 157     FP_PACK_RAW_E(val,X);               \
 158   } while (0)
 159
 160 #define FP_PACK_EP(val,X)               \
 161   do {                                  \
 162     _FP_PACK_CANONICAL(E,4,X);          \
 163     FP_PACK_RAW_EP(val,X);              \
 164   } while (0)
 165
 166 #define FP_ISSIGNAN_E(X)        _FP_ISSIGNAN(E,4,X)
 167 #define FP_NEG_E(R,X)           _FP_NEG(E,4,R,X)
 168 #define FP_ADD_E(R,X,Y)         _FP_ADD(E,4,R,X,Y)
 169 #define FP_SUB_E(R,X,Y)         _FP_SUB(E,4,R,X,Y)
 170 #define FP_MUL_E(R,X,Y)         _FP_MUL(E,4,R,X,Y)
 171 #define FP_DIV_E(R,X,Y)         _FP_DIV(E,4,R,X,Y)
 172 #define FP_SQRT_E(R,X)          _FP_SQRT(E,4,R,X)
 173
 174 /*
 175  * Square root algorithms:
 176  * We have just one right now, maybe Newton approximation
 177  * should be added for those machines where division is fast.
 178  * This has special _E version because standard _4 square
 179  * root would not work (it has to start normally with the
 180  * second word and not the first), but as we have to do it
 181  * anyway, we optimize it by doing most of the calculations
 182  * in two UWtype registers instead of four.
 183  */
 184
 185 #define _FP_SQRT_MEAT_E(R, S, T, X, q)                  \
 186   do {                                                  \
 187     q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1);         \
 188     _FP_FRAC_SRL_4(X, (_FP_WORKBITS));                  \
 189     while (q)                                           \
 190       {                                                 \
 191         T##_f[1] = S##_f[1] + q;                        \
 192         if (T##_f[1] <= X##_f[1])                       \
 193           {                                             \
 194             S##_f[1] = T##_f[1] + q;                    \
 195             X##_f[1] -= T##_f[1];                       \
 196             R##_f[1] += q;                              \
 197           }                                             \
 198         _FP_FRAC_SLL_2(X, 1);                           \
 199         q >>= 1;                                        \
 200       }                                                 \
 201     q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1);         \
 202     while (q)                                           \
 203       {                                                 \
 204         T##_f[0] = S##_f[0] + q;                        \
 205         T##_f[1] = S##_f[1];                            \
 206         if (T##_f[1] < X##_f[1] ||                      \
 207             (T##_f[1] == X##_f[1] &&                    \
 208              T##_f[0] <= X##_f[0]))                     \
 209           {                                             \
 210             S##_f[0] = T##_f[0] + q;                    \
 211             S##_f[1] += (T##_f[0] > S##_f[0]);          \
 212             _FP_FRAC_DEC_2(X, T);                       \
 213             R##_f[0] += q;                              \
 214           }                                             \
 215         _FP_FRAC_SLL_2(X, 1);                           \
 216         q >>= 1;                                        \
 217       }                                                 \
 218     _FP_FRAC_SLL_4(R, (_FP_WORKBITS));                  \
 219     if (X##_f[0] | X##_f[1])                            \
 220       {                                                 \
 221         if (S##_f[1] < X##_f[1] ||                      \
 222             (S##_f[1] == X##_f[1] &&                    \
 223              S##_f[0] < X##_f[0]))                      \
 224           R##_f[0] |= _FP_WORK_ROUND;                   \
 225         R##_f[0] |= _FP_WORK_STICKY;                    \
 226       }                                                 \
 227   } while (0)
 228
 229 #define FP_CMP_E(r,X,Y,un)      _FP_CMP(E,4,r,X,Y,un)
 230 #define FP_CMP_EQ_E(r,X,Y)      _FP_CMP_EQ(E,4,r,X,Y)
 231
 232 #define FP_TO_INT_E(r,X,rsz,rsg)        _FP_TO_INT(E,4,r,X,rsz,rsg)
 233 #define FP_TO_INT_ROUND_E(r,X,rsz,rsg)  _FP_TO_INT_ROUND(E,4,r,X,rsz,rsg)
 234 #define FP_FROM_INT_E(X,r,rs,rt)        _FP_FROM_INT(E,4,X,r,rs,rt)
 235
 236 #define _FP_FRAC_HIGH_E(X)      (X##_f[2])
 237 #define _FP_FRAC_HIGH_RAW_E(X)  (X##_f[1])
 238
 239 #else   /* not _FP_W_TYPE_SIZE < 64 */
 240 union _FP_UNION_E
 241 {
 242   long double flt /* __attribute__((mode(TF))) */ ;
 243   struct {
 244 #if __BYTE_ORDER == __BIG_ENDIAN
 245     unsigned long pad : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
 246     unsigned sign  : 1;
 247     unsigned exp   : _FP_EXPBITS_E;
 248     unsigned long frac : _FP_W_TYPE_SIZE;
 249 #else
 250     unsigned long frac : _FP_W_TYPE_SIZE;
 251     unsigned exp   : _FP_EXPBITS_E;
 252     unsigned sign  : 1;
 253 #endif
 254   } bits;
 255 };
 256
 257 #define FP_DECL_E(X)            _FP_DECL(2,X)
 258
 259 #define FP_UNPACK_RAW_E(X, val)                                 \
 260   do {                                                          \
 261     union _FP_UNION_E _flo; _flo.flt = (val);                   \
 262                                                                 \
 263     X##_f0 = _flo.bits.frac;                                    \
 264     X##_f1 = 0;                                                 \
 265     X##_e = _flo.bits.exp;                                      \
 266     X##_s = _flo.bits.sign;                                     \
 267     if (!X##_e && X##_f0 && !(X##_f0 & _FP_IMPLBIT_E))          \
 268       {                                                         \
 269         X##_e++;                                                \
 270         FP_SET_EXCEPTION(FP_EX_DENORM);                         \
 271       }                                                         \
 272   } while (0)
 273
 274 #define FP_UNPACK_RAW_EP(X, val)                                \
 275   do {                                                          \
 276     union _FP_UNION_E *_flo =                                   \
 277       (union _FP_UNION_E *)(val);                               \
 278                                                                 \
 279     X##_f0 = _flo->bits.frac;                                   \
 280     X##_f1 = 0;                                                 \
 281     X##_e = _flo->bits.exp;                                     \
 282     X##_s = _flo->bits.sign;                                    \
 283     if (!X##_e && X##_f0 && !(X##_f0 & _FP_IMPLBIT_E))          \
 284       {                                                         \
 285         X##_e++;                                                \
 286         FP_SET_EXCEPTION(FP_EX_DENORM);                         \
 287       }                                                         \
 288   } while (0)
 289
 290 #define FP_PACK_RAW_E(val, X)                                   \
 291   do {                                                          \
 292     union _FP_UNION_E _flo;                                     \
 293                                                                 \
 294     if (X##_e) X##_f0 |= _FP_IMPLBIT_E;                         \
 295     else X##_f0 &= ~(_FP_IMPLBIT_E);                            \
 296     _flo.bits.frac = X##_f0;                                    \
 297     _flo.bits.exp  = X##_e;                                     \
 298     _flo.bits.sign = X##_s;                                     \
 299                                                                 \
 300     (val) = _flo.flt;                                           \
 301   } while (0)
 302
 303 #define FP_PACK_RAW_EP(fs, val, X)                              \
 304   do {                                                          \
 305     if (!FP_INHIBIT_RESULTS)                                    \
 306       {                                                         \
 307         union _FP_UNION_E *_flo =                               \
 308           (union _FP_UNION_E *)(val);                           \
 309                                                                 \
 310         if (X##_e) X##_f0 |= _FP_IMPLBIT_E;                     \
 311         else X##_f0 &= ~(_FP_IMPLBIT_E);                        \
 312         _flo->bits.frac = X##_f0;                               \
 313         _flo->bits.exp  = X##_e;                                \
 314         _flo->bits.sign = X##_s;                                \
 315       }                                                         \
 316   } while (0)
 317
 318
 319 #define FP_UNPACK_E(X,val)              \
 320   do {                                  \
 321     FP_UNPACK_RAW_E(X,val);             \
 322     _FP_UNPACK_CANONICAL(E,2,X);        \
 323   } while (0)
 324
 325 #define FP_UNPACK_EP(X,val)             \
 326   do {                                  \
 327     FP_UNPACK_RAW_EP(X,val);            \
 328     _FP_UNPACK_CANONICAL(E,2,X);        \
 329   } while (0)
 330
 331 #define FP_PACK_E(val,X)                \
 332   do {                                  \
 333     _FP_PACK_CANONICAL(E,2,X);          \
 334     FP_PACK_RAW_E(val,X);               \
 335   } while (0)
 336
 337 #define FP_PACK_EP(val,X)               \
 338   do {                                  \
 339     _FP_PACK_CANONICAL(E,2,X);          \
 340     FP_PACK_RAW_EP(val,X);              \
 341   } while (0)
 342
 343 #define FP_ISSIGNAN_E(X)        _FP_ISSIGNAN(E,2,X)
 344 #define FP_NEG_E(R,X)           _FP_NEG(E,2,R,X)
 345 #define FP_ADD_E(R,X,Y)         _FP_ADD(E,2,R,X,Y)
 346 #define FP_SUB_E(R,X,Y)         _FP_SUB(E,2,R,X,Y)
 347 #define FP_MUL_E(R,X,Y)         _FP_MUL(E,2,R,X,Y)
 348 #define FP_DIV_E(R,X,Y)         _FP_DIV(E,2,R,X,Y)
 349 #define FP_SQRT_E(R,X)          _FP_SQRT(E,2,R,X)
 350
 351 /*
 352  * Square root algorithms:
 353  * We have just one right now, maybe Newton approximation
 354  * should be added for those machines where division is fast.
 355  * We optimize it by doing most of the calculations
 356  * in one UWtype registers instead of two, although we don't
 357  * have to.
 358  */
 359 #define _FP_SQRT_MEAT_E(R, S, T, X, q)                  \
 360   do {                                                  \
 361     q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1);         \
 362     _FP_FRAC_SRL_2(X, (_FP_WORKBITS));                  \
 363     while (q)                                           \
 364       {                                                 \
 365         T##_f0 = S##_f0 + q;                            \
 366         if (T##_f0 <= X##_f0)                           \
 367           {                                             \
 368             S##_f0 = T##_f0 + q;                        \
 369             X##_f0 -= T##_f0;                           \
 370             R##_f0 += q;                                \
 371           }                                             \
 372         _FP_FRAC_SLL_1(X, 1);                           \
 373         q >>= 1;                                        \
 374       }                                                 \
 375     _FP_FRAC_SLL_2(R, (_FP_WORKBITS));                  \
 376     if (X##_f0)                                         \
 377       {                                                 \
 378         if (S##_f0 < X##_f0)                            \
 379           R##_f0 |= _FP_WORK_ROUND;                     \
 380         R##_f0 |= _FP_WORK_STICKY;                      \
 381       }                                                 \
 382   } while (0)
 383
 384 #define FP_CMP_E(r,X,Y,un)      _FP_CMP(E,2,r,X,Y,un)
 385 #define FP_CMP_EQ_E(r,X,Y)      _FP_CMP_EQ(E,2,r,X,Y)
 386
 387 #define FP_TO_INT_E(r,X,rsz,rsg)        _FP_TO_INT(E,2,r,X,rsz,rsg)
 388 #define FP_TO_INT_ROUND_E(r,X,rsz,rsg)  _FP_TO_INT_ROUND(E,2,r,X,rsz,rsg)
 389 #define FP_FROM_INT_E(X,r,rs,rt)        _FP_FROM_INT(E,2,X,r,rs,rt)
 390
 391 #define _FP_FRAC_HIGH_E(X)      (X##_f1)
 392 #define _FP_FRAC_HIGH_RAW_E(X)  (X##_f0)
 393
 394 #endif /* not _FP_W_TYPE_SIZE < 64 */
 395
 396 #endif /* __MATH_EMU_EXTENDED_H__ */