x-cvsweb-markup(13)

软件浮点数计算功能

#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 {                                                          \