x-cvsweb-markup(46)

软件浮点数计算功能

   that may be useful in this situation.  This first is for a primitive
   that requires normalization, the second for one that does not.  Look
   for UDIV_NEEDS_NORMALIZATION to tell which your machine needs.  */

#define _FP_DIV_MEAT_1_udiv_norm(fs, R, X, Y)                           \
  do {                                                                  \
    _FP_W_TYPE _nh, _nl, _q, _r, _y;                                    \
                                                                        \
    /* Normalize Y -- i.e. make the most significant bit set.  */       \
    _y = Y##_f << _FP_WFRACXBITS_##fs;                                  \
                                                                        \
    /* Shift X op correspondingly high, that is, up one full word.  */  \
    if (X##_f < Y##_f)                                                  \
      {                                                                 \
        R##_e--;                                                        \
        _nl = 0;                                                        \
        _nh = X##_f;                                                        \
      }                                                                 \
    else                                                                \
      {                                                                 \
        _nl = X##_f << (_FP_W_TYPE_SIZE - 1);                                \
        _nh = X##_f >> 1;                                                \
      }                                                                 \
                                                                        \
    udiv_qrnnd(_q, _r, _nh, _nl, _y);                                   \
    R##_f = _q | (_r != 0);                                             \
  } while (0)

#define _FP_DIV_MEAT_1_udiv(fs, R, X, Y)                \
  do {                                                  \
    _FP_W_TYPE _nh, _nl, _q, _r;                        \
    if (X##_f < Y##_f)                                  \
      {                                                 \
        R##_e--;                                        \
        _nl = X##_f << _FP_WFRACBITS_##fs;                \
        _nh = X##_f >> _FP_WFRACXBITS_##fs;                \
      }                                                 \
    else                                                \
      {                                                 \
        _nl = X##_f << (_FP_WFRACBITS_##fs - 1);        \
        _nh = X##_f >> (_FP_WFRACXBITS_##fs + 1);        \
      }                                                 \
    udiv_qrnnd(_q, _r, _nh, _nl, Y##_f);                \
    R##_f = _q | (_r != 0);                             \
  } while (0)
  
  
/*
 * Square root algorithms:
 * We have just one right now, maybe Newton approximation
 * should be added for those machines where division is fast.
 */
 
#define _FP_SQRT_MEAT_1(R, S, T, X, q)                  \
  do {                                                  \
    while (q != _FP_WORK_ROUND)                         \
      {                                                 \
        T##_f = S##_f + q;                              \
        if (T##_f <= X##_f)                             \
          {                                             \
            S##_f = T##_f + q;                          \
            X##_f -= T##_f;                             \
            R##_f += q;                                 \
          }                                             \
        _FP_FRAC_SLL_1(X, 1);                           \
        q >>= 1;                                        \
      }                                                 \
    if (X##_f)                                          \
      {                                                 \
        if (S##_f < X##_f)                                \
          R##_f |= _FP_WORK_ROUND;                        \
        R##_f |= _FP_WORK_STICKY;                        \
      }                                                 \
  } while (0)

/*
 * Assembly/disassembly for converting to/from integral types.  
 * No shifting or overflow handled here.
 */

#define _FP_FRAC_ASSEMBLE_1(r, X, rsize)        (r = X##_f)
#define _FP_FRAC_DISASSEMBLE_1(X, r, rsize)     (X##_f = r)


/*
 * Convert FP values between word sizes
 */

#define _FP_FRAC_CONV_1_1(dfs, sfs, D, S)                               \
  do {                                                                  \
    D##_f = S##_f;                                                      \
    if (_FP_WFRACBITS_##sfs > _FP_WFRACBITS_##dfs)                      \
      {                                                                 \
        if (S##_c != FP_CLS_NAN)                                        \
          _FP_FRAC_SRS_1(D, (_FP_WFRACBITS_##sfs-_FP_WFRACBITS_##dfs),        \
                         _FP_WFRACBITS_##sfs);                                \
        else                                                                \
          _FP_FRAC_SRL_1(D, (_FP_WFRACBITS_##sfs-_FP_WFRACBITS_##dfs));        \
      }                                                                 \
    else                                                                \
      D##_f <<= _FP_WFRACBITS_##dfs - _FP_WFRACBITS_##sfs;              \
  } while (0)
</PRE>