Logo Search packages:      
Sourcecode: glibc version File versions

extended.h

/* Software floating-point emulation.
   Definitions for IEEE Extended Precision.
   Copyright (C) 1999 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Jakub Jelinek (jj@ultra.linux.cz).

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#if _FP_W_TYPE_SIZE < 32
#error "Here's a nickel, kid. Go buy yourself a real computer."
#endif

#if _FP_W_TYPE_SIZE < 64
#define _FP_FRACTBITS_E         (4*_FP_W_TYPE_SIZE)
#else
#define _FP_FRACTBITS_E       (2*_FP_W_TYPE_SIZE)
#endif

#define _FP_FRACBITS_E        64
#define _FP_FRACXBITS_E       (_FP_FRACTBITS_E - _FP_FRACBITS_E)
#define _FP_WFRACBITS_E       (_FP_WORKBITS + _FP_FRACBITS_E)
#define _FP_WFRACXBITS_E      (_FP_FRACTBITS_E - _FP_WFRACBITS_E)
#define _FP_EXPBITS_E         15
#define _FP_EXPBIAS_E         16383
#define _FP_EXPMAX_E          32767

#define _FP_QNANBIT_E         \
      ((_FP_W_TYPE)1 << (_FP_FRACBITS_E-2) % _FP_W_TYPE_SIZE)
#define _FP_IMPLBIT_E         \
      ((_FP_W_TYPE)1 << (_FP_FRACBITS_E-1) % _FP_W_TYPE_SIZE)
#define _FP_OVERFLOW_E        \
      ((_FP_W_TYPE)1 << (_FP_WFRACBITS_E % _FP_W_TYPE_SIZE))

#if _FP_W_TYPE_SIZE < 64

union _FP_UNION_E
{
   long double flt;
   struct 
   {
#if __BYTE_ORDER == __BIG_ENDIAN
      unsigned long pad1 : _FP_W_TYPE_SIZE;
      unsigned long pad2 : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
      unsigned long sign : 1;
      unsigned long exp : _FP_EXPBITS_E;
      unsigned long frac1 : _FP_W_TYPE_SIZE;
      unsigned long frac0 : _FP_W_TYPE_SIZE;
#else
      unsigned long frac0 : _FP_W_TYPE_SIZE;
      unsigned long frac1 : _FP_W_TYPE_SIZE;
      unsigned exp : _FP_EXPBITS_E;
      unsigned sign : 1;
#endif /* not bigendian */
   } bits __attribute__((packed));
};


#define FP_DECL_E(X)          _FP_DECL(4,X)

#define FP_UNPACK_RAW_E(X, val)                       \
  do {                                          \
    union _FP_UNION_E _flo; _flo.flt = (val);         \
                                          \
    X##_f[2] = 0; X##_f[3] = 0;                       \
    X##_f[0] = _flo.bits.frac0;                       \
    X##_f[1] = _flo.bits.frac1;                       \
    X##_e  = _flo.bits.exp;                     \
    X##_s  = _flo.bits.sign;                    \
    if (!X##_e && (X##_f[1] || X##_f[0])        \
        && !(X##_f[1] & _FP_IMPLBIT_E))               \
      {                                         \
        X##_e++;                          \
        FP_SET_EXCEPTION(FP_EX_DENORM);               \
      }                                         \
  } while (0)

#define FP_UNPACK_RAW_EP(X, val)                \
  do {                                          \
    union _FP_UNION_E *_flo =                   \
    (union _FP_UNION_E *)(val);                       \
                                          \
    X##_f[2] = 0; X##_f[3] = 0;                       \
    X##_f[0] = _flo->bits.frac0;                \
    X##_f[1] = _flo->bits.frac1;                \
    X##_e  = _flo->bits.exp;                    \
    X##_s  = _flo->bits.sign;                   \
    if (!X##_e && (X##_f[1] || X##_f[0])        \
        && !(X##_f[1] & _FP_IMPLBIT_E))               \
      {                                         \
        X##_e++;                          \
        FP_SET_EXCEPTION(FP_EX_DENORM);               \
      }                                         \
  } while (0)

#define FP_PACK_RAW_E(val, X)                   \
  do {                                          \
    union _FP_UNION_E _flo;                     \
                                          \
    if (X##_e) X##_f[1] |= _FP_IMPLBIT_E;       \
    else X##_f[1] &= ~(_FP_IMPLBIT_E);                \
    _flo.bits.frac0 = X##_f[0];                       \
    _flo.bits.frac1 = X##_f[1];                       \
    _flo.bits.exp   = X##_e;                    \
    _flo.bits.sign  = X##_s;                    \
                                          \
    (val) = _flo.flt;                           \
  } while (0)

#define FP_PACK_RAW_EP(val, X)                        \
  do {                                          \
    if (!FP_INHIBIT_RESULTS)                    \
      {                                         \
      union _FP_UNION_E *_flo =                 \
        (union _FP_UNION_E *)(val);             \
                                          \
      if (X##_e) X##_f[1] |= _FP_IMPLBIT_E;           \
      else X##_f[1] &= ~(_FP_IMPLBIT_E);        \
      _flo->bits.frac0 = X##_f[0];              \
      _flo->bits.frac1 = X##_f[1];              \
      _flo->bits.exp   = X##_e;                 \
      _flo->bits.sign  = X##_s;                 \
      }                                         \
  } while (0)

#define FP_UNPACK_E(X,val)          \
  do {                              \
    FP_UNPACK_RAW_E(X,val);         \
    _FP_UNPACK_CANONICAL(E,4,X);    \
  } while (0)

#define FP_UNPACK_EP(X,val)         \
  do {                              \
    FP_UNPACK_RAW_2_P(X,val);       \
    _FP_UNPACK_CANONICAL(E,4,X);    \
  } while (0)

#define FP_PACK_E(val,X)            \
  do {                              \
    _FP_PACK_CANONICAL(E,4,X);            \
    FP_PACK_RAW_E(val,X);           \
  } while (0)

#define FP_PACK_EP(val,X)           \
  do {                              \
    _FP_PACK_CANONICAL(E,4,X);            \
    FP_PACK_RAW_EP(val,X);          \
  } while (0)

#define FP_ISSIGNAN_E(X)      _FP_ISSIGNAN(E,4,X)
#define FP_NEG_E(R,X)         _FP_NEG(E,4,R,X)
#define FP_ADD_E(R,X,Y)       _FP_ADD(E,4,R,X,Y)
#define FP_SUB_E(R,X,Y)       _FP_SUB(E,4,R,X,Y)
#define FP_MUL_E(R,X,Y)       _FP_MUL(E,4,R,X,Y)
#define FP_DIV_E(R,X,Y)       _FP_DIV(E,4,R,X,Y)
#define FP_SQRT_E(R,X)        _FP_SQRT(E,4,R,X)

/*
 * Square root algorithms:
 * We have just one right now, maybe Newton approximation
 * should be added for those machines where division is fast.
 * This has special _E version because standard _4 square
 * root would not work (it has to start normally with the
 * second word and not the first), but as we have to do it
 * anyway, we optimize it by doing most of the calculations
 * in two UWtype registers instead of four.
 */
 
#define _FP_SQRT_MEAT_E(R, S, T, X, q)                \
  do {                                          \
    q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1);       \
    _FP_FRAC_SRL_4(X, (_FP_WORKBITS));                \
    while (q)                                   \
      {                                         \
      T##_f[1] = S##_f[1] + q;                  \
      if (T##_f[1] <= X##_f[1])                 \
        {                                 \
          S##_f[1] = T##_f[1] + q;              \
          X##_f[1] -= T##_f[1];                 \
          R##_f[1] += q;                        \
        }                                 \
      _FP_FRAC_SLL_2(X, 1);                     \
      q >>= 1;                            \
      }                                         \
    q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1);       \
    while (q)                                   \
      {                                         \
      T##_f[0] = S##_f[0] + q;                  \
      T##_f[1] = S##_f[1];                      \
      if (T##_f[1] < X##_f[1] ||                \
          (T##_f[1] == X##_f[1] &&              \
           T##_f[0] <= X##_f[0]))               \
        {                                 \
          S##_f[0] = T##_f[0] + q;              \
          S##_f[1] += (T##_f[0] > S##_f[0]);          \
          _FP_FRAC_DEC_2(X, T);                 \
          R##_f[0] += q;                        \
        }                                 \
      _FP_FRAC_SLL_2(X, 1);                     \
      q >>= 1;                            \
      }                                         \
    _FP_FRAC_SLL_4(R, (_FP_WORKBITS));                \
    if (X##_f[0] | X##_f[1])                    \
      {                                         \
      if (S##_f[1] < X##_f[1] ||                \
          (S##_f[1] == X##_f[1] &&              \
           S##_f[0] < X##_f[0]))                \
        R##_f[0] |= _FP_WORK_ROUND;             \
      R##_f[0] |= _FP_WORK_STICKY;              \
      }                                         \
  } while (0)

#define FP_CMP_E(r,X,Y,un)    _FP_CMP(E,4,r,X,Y,un)
#define FP_CMP_EQ_E(r,X,Y)    _FP_CMP_EQ(E,4,r,X,Y)

#define FP_TO_INT_E(r,X,rsz,rsg)    _FP_TO_INT(E,4,r,X,rsz,rsg)
#define FP_FROM_INT_E(X,r,rs,rt)    _FP_FROM_INT(E,4,X,r,rs,rt)

#define _FP_FRAC_HIGH_E(X)    (X##_f[2])
#define _FP_FRAC_HIGH_RAW_E(X)      (X##_f[1])

#else   /* not _FP_W_TYPE_SIZE < 64 */
union _FP_UNION_E
{
  long double flt /* __attribute__((mode(TF))) */ ;
  struct {
#if __BYTE_ORDER == __BIG_ENDIAN
    unsigned long pad : (_FP_W_TYPE_SIZE - 1 - _FP_EXPBITS_E);
    unsigned sign  : 1;
    unsigned exp   : _FP_EXPBITS_E;
    unsigned long frac : _FP_W_TYPE_SIZE;
#else
    unsigned long frac : _FP_W_TYPE_SIZE;
    unsigned exp   : _FP_EXPBITS_E;
    unsigned sign  : 1;
#endif
  } bits;
};

#define FP_DECL_E(X)          _FP_DECL(2,X)

#define FP_UNPACK_RAW_E(X, val)                             \
  do {                                                \
    union _FP_UNION_E _flo; _flo.flt = (val);               \
                                                \
    X##_f0 = _flo.bits.frac;                          \
    X##_f1 = 0;                                       \
    X##_e = _flo.bits.exp;                            \
    X##_s = _flo.bits.sign;                           \
    if (!X##_e && X##_f0 && !(X##_f0 & _FP_IMPLBIT_E))            \
      {                                               \
        X##_e++;                                \
        FP_SET_EXCEPTION(FP_EX_DENORM);                     \
      }                                               \
  } while (0)

#define FP_UNPACK_RAW_EP(X, val)                      \
  do {                                                \
    union _FP_UNION_E *_flo =                         \
      (union _FP_UNION_E *)(val);                     \
                                                \
    X##_f0 = _flo->bits.frac;                         \
    X##_f1 = 0;                                       \
    X##_e = _flo->bits.exp;                           \
    X##_s = _flo->bits.sign;                          \
    if (!X##_e && X##_f0 && !(X##_f0 & _FP_IMPLBIT_E))            \
      {                                               \
        X##_e++;                                \
        FP_SET_EXCEPTION(FP_EX_DENORM);                     \
      }                                               \
  } while (0)

#define FP_PACK_RAW_E(val, X)                         \
  do {                                                \
    union _FP_UNION_E _flo;                           \
                                                \
    if (X##_e) X##_f0 |= _FP_IMPLBIT_E;                     \
    else X##_f0 &= ~(_FP_IMPLBIT_E);                        \
    _flo.bits.frac = X##_f0;                          \
    _flo.bits.exp  = X##_e;                           \
    _flo.bits.sign = X##_s;                           \
                                                \
    (val) = _flo.flt;                                 \
  } while (0)

#define FP_PACK_RAW_EP(fs, val, X)                    \
  do {                                                \
    if (!FP_INHIBIT_RESULTS)                          \
      {                                               \
      union _FP_UNION_E *_flo =                       \
        (union _FP_UNION_E *)(val);                   \
                                                \
      if (X##_e) X##_f0 |= _FP_IMPLBIT_E;             \
      else X##_f0 &= ~(_FP_IMPLBIT_E);                \
      _flo->bits.frac = X##_f0;                       \
      _flo->bits.exp  = X##_e;                        \
      _flo->bits.sign = X##_s;                        \
      }                                               \
  } while (0)


#define FP_UNPACK_E(X,val)          \
  do {                              \
    FP_UNPACK_RAW_E(X,val);         \
    _FP_UNPACK_CANONICAL(E,2,X);    \
  } while (0)

#define FP_UNPACK_EP(X,val)         \
  do {                              \
    FP_UNPACK_RAW_EP(X,val);        \
    _FP_UNPACK_CANONICAL(E,2,X);    \
  } while (0)

#define FP_PACK_E(val,X)            \
  do {                              \
    _FP_PACK_CANONICAL(E,2,X);            \
    FP_PACK_RAW_E(val,X);           \
  } while (0)

#define FP_PACK_EP(val,X)           \
  do {                              \
    _FP_PACK_CANONICAL(E,2,X);            \
    FP_PACK_RAW_EP(val,X);          \
  } while (0)

#define FP_ISSIGNAN_E(X)      _FP_ISSIGNAN(E,2,X)
#define FP_NEG_E(R,X)         _FP_NEG(E,2,R,X)
#define FP_ADD_E(R,X,Y)       _FP_ADD(E,2,R,X,Y)
#define FP_SUB_E(R,X,Y)       _FP_SUB(E,2,R,X,Y)
#define FP_MUL_E(R,X,Y)       _FP_MUL(E,2,R,X,Y)
#define FP_DIV_E(R,X,Y)       _FP_DIV(E,2,R,X,Y)
#define FP_SQRT_E(R,X)        _FP_SQRT(E,2,R,X)

/*
 * Square root algorithms:
 * We have just one right now, maybe Newton approximation
 * should be added for those machines where division is fast.
 * We optimize it by doing most of the calculations
 * in one UWtype registers instead of two, although we don't
 * have to.
 */
#define _FP_SQRT_MEAT_E(R, S, T, X, q)                \
  do {                                          \
    q = (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE - 1);       \
    _FP_FRAC_SRL_2(X, (_FP_WORKBITS));                \
    while (q)                                   \
      {                                         \
        T##_f0 = S##_f0 + q;                    \
        if (T##_f0 <= X##_f0)                   \
          {                               \
            S##_f0 = T##_f0 + q;                \
            X##_f0 -= T##_f0;                   \
            R##_f0 += q;                        \
          }                               \
        _FP_FRAC_SLL_1(X, 1);                   \
        q >>= 1;                          \
      }                                         \
    _FP_FRAC_SLL_2(R, (_FP_WORKBITS));                \
    if (X##_f0)                                 \
      {                                         \
      if (S##_f0 < X##_f0)                      \
        R##_f0 |= _FP_WORK_ROUND;               \
      R##_f0 |= _FP_WORK_STICKY;                \
      }                                         \
  } while (0)
 
#define FP_CMP_E(r,X,Y,un)    _FP_CMP(E,2,r,X,Y,un)
#define FP_CMP_EQ_E(r,X,Y)    _FP_CMP_EQ(E,2,r,X,Y)

#define FP_TO_INT_E(r,X,rsz,rsg)    _FP_TO_INT(E,2,r,X,rsz,rsg)
#define FP_FROM_INT_E(X,r,rs,rt)    _FP_FROM_INT(E,2,X,r,rs,rt)

#define _FP_FRAC_HIGH_E(X)    (X##_f1)
#define _FP_FRAC_HIGH_RAW_E(X)      (X##_f0)

#endif /* not _FP_W_TYPE_SIZE < 64 */

Generated by  Doxygen 1.6.0   Back to index