x-cvsweb-markup(50)

软件浮点数计算功能

  case _FP_EXPMAX_##fs:                                                 \
    if (_FP_FRAC_ZEROP_##wc(X))                                         \
      X##_c = FP_CLS_INF;                                               \
    else                                                                \
      {                                                                 \
        X##_c = FP_CLS_NAN;                                                \
        /* Check for signaling NaN */                                        \
        if (!(_FP_FRAC_HIGH_RAW_##fs(X) & _FP_QNANBIT_##fs))                \
          FP_SET_EXCEPTION(FP_EX_INVALID);                                \
      }                                                                 \
    break;                                                              \
  }                                                                     \
} while (0)

/*
 * Before packing the bits back into the native fp result, take care
 * of such mundane things as rounding and overflow.  Also, for some
 * kinds of fp values, the original parts may not have been fully
 * extracted -- but that is ok, we can regenerate them now.
 */

#define _FP_PACK_CANONICAL(fs, wc, X)                           \
do {                                                            \
  switch (X##_c)                                                \
  {                                                             \
  case FP_CLS_NORMAL:                                           \
    X##_e += _FP_EXPBIAS_##fs;                                  \
    if (X##_e > 0)                                              \
      {                                                         \
        _FP_ROUND(wc, X);                                        \
        if (_FP_FRAC_OVERP_##wc(fs, X))                                \
          {                                                        \
            _FP_FRAC_SRL_##wc(X, (_FP_WORKBITS+1));                \
            X##_e++;                                                \
          }                                                        \
        else                                                        \
          _FP_FRAC_SRL_##wc(X, _FP_WORKBITS);                        \
        if (X##_e >= _FP_EXPMAX_##fs)                                \
          {                                                        \
            /* overflow */                                        \
            switch (FP_ROUNDMODE)                                \
              {                                                        \
              case FP_RND_NEAREST:                                \
                X##_c = FP_CLS_INF;                                \
                break;                                                \
              case FP_RND_PINF:                                        \
                if (!X##_s) X##_c = FP_CLS_INF;                        \
                break;                                                \
              case FP_RND_MINF:                                        \
                if (X##_s) X##_c = FP_CLS_INF;                        \
                break;                                                \
              }                                                        \
            if (X##_c == FP_CLS_INF)                                \
              {                                                        \
                /* Overflow to infinity */                        \
                X##_e = _FP_EXPMAX_##fs;                        \
                _FP_FRAC_SET_##wc(X, _FP_ZEROFRAC_##wc);        \
              }                                                        \
            else                                                \
              {                                                        \
                /* Overflow to maximum normal */                \
                X##_e = _FP_EXPMAX_##fs - 1;                        \
                _FP_FRAC_SET_##wc(X, _FP_MAXFRAC_##wc);                \
              }                                                        \
            FP_SET_EXCEPTION(FP_EX_OVERFLOW);                        \
            FP_SET_EXCEPTION(FP_EX_INEXACT);                    \
          }                                                        \
      }                                                         \
    else                                                        \
      {                                                         \
        /* we've got a denormalized number */                        \
        X##_e = -X##_e + 1;                                        \