x-cvsweb-markup(13)

软件浮点数计算功能

    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 */
</PRE>