Back to index

glibc  2.9
Defines
op-1.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines

#define _FP_FRAC_DECL_1(X)   _FP_W_TYPE X##_f
#define _FP_FRAC_COPY_1(D, S)   (D##_f = S##_f)
#define _FP_FRAC_SET_1(X, I)   (X##_f = I)
#define _FP_FRAC_HIGH_1(X)   (X##_f)
#define _FP_FRAC_LOW_1(X)   (X##_f)
#define _FP_FRAC_WORD_1(X, w)   (X##_f)
#define _FP_FRAC_ADDI_1(X, I)   (X##_f += I)
#define _FP_FRAC_SLL_1(X, N)
#define _FP_FRAC_SRL_1(X, N)   (X##_f >>= N)
#define _FP_FRAC_SRST_1(X, S, N, sz)   __FP_FRAC_SRST_1(X##_f, S, N, sz)
#define _FP_FRAC_SRS_1(X, N, sz)   __FP_FRAC_SRS_1(X##_f, N, sz)
#define __FP_FRAC_SRST_1(X, S, N, sz)
#define __FP_FRAC_SRS_1(X, N, sz)
#define _FP_FRAC_ADD_1(R, X, Y)   (R##_f = X##_f + Y##_f)
#define _FP_FRAC_SUB_1(R, X, Y)   (R##_f = X##_f - Y##_f)
#define _FP_FRAC_DEC_1(X, Y)   (X##_f -= Y##_f)
#define _FP_FRAC_CLZ_1(z, X)   __FP_CLZ(z, X##_f)
#define _FP_FRAC_NEGP_1(X)   ((_FP_WS_TYPE)X##_f < 0)
#define _FP_FRAC_ZEROP_1(X)   (X##_f == 0)
#define _FP_FRAC_OVERP_1(fs, X)   (X##_f & _FP_OVERFLOW_##fs)
#define _FP_FRAC_CLEAR_OVERP_1(fs, X)   (X##_f &= ~_FP_OVERFLOW_##fs)
#define _FP_FRAC_EQ_1(X, Y)   (X##_f == Y##_f)
#define _FP_FRAC_GE_1(X, Y)   (X##_f >= Y##_f)
#define _FP_FRAC_GT_1(X, Y)   (X##_f > Y##_f)
#define _FP_ZEROFRAC_1   0
#define _FP_MINFRAC_1   1
#define _FP_MAXFRAC_1   (~(_FP_WS_TYPE)0)
#define _FP_UNPACK_RAW_1(fs, X, val)
#define _FP_UNPACK_RAW_1_P(fs, X, val)
#define _FP_PACK_RAW_1(fs, val, X)
#define _FP_PACK_RAW_1_P(fs, val, X)
#define _FP_MUL_MEAT_1_imm(wfracbits, R, X, Y)
#define _FP_MUL_MEAT_1_wide(wfracbits, R, X, Y, doit)
#define _FP_MUL_MEAT_1_hard(wfracbits, R, X, Y)
#define _FP_DIV_MEAT_1_imm(fs, R, X, Y, doit)
#define _FP_DIV_MEAT_1_udiv_norm(fs, R, X, Y)
#define _FP_DIV_MEAT_1_udiv(fs, R, X, Y)
#define _FP_SQRT_MEAT_1(R, S, T, X, q)
#define _FP_FRAC_ASSEMBLE_1(r, X, rsize)   (r = X##_f)
#define _FP_FRAC_DISASSEMBLE_1(X, r, rsize)   (X##_f = r)
#define _FP_FRAC_COPY_1_1(D, S)   (D##_f = S##_f)

Define Documentation

#define __FP_FRAC_SRS_1 (   X,
  N,
  sz 
)
Value:
(X = (X >> (N) | (__builtin_constant_p(N) && (N) == 1          \
                   ? X & 1 : (X << (_FP_W_TYPE_SIZE - (N))) != 0)))

Definition at line 62 of file op-1.h.

#define __FP_FRAC_SRST_1 (   X,
  S,
  N,
  sz 
)
Value:
do {                                             \
  S = (__builtin_constant_p(N) && (N) == 1              \
       ? X & 1 : (X << (_FP_W_TYPE_SIZE - (N))) != 0);  \
  X = X >> (N);                                         \
} while (0)

Definition at line 55 of file op-1.h.

#define _FP_DIV_MEAT_1_imm (   fs,
  R,
  X,
  Y,
  doit 
)
Value:
do {                                             \
    _FP_W_TYPE _q, _r;                                  \
    X##_f <<= (X##_f < Y##_f                            \
              ? R##_e--, _FP_WFRACBITS_##fs             \
              : _FP_WFRACBITS_##fs - 1);         \
    doit(_q, _r, X##_f, Y##_f);                         \
    R##_f = _q | (_r != 0);                      \
  } while (0)

Definition at line 199 of file op-1.h.

#define _FP_DIV_MEAT_1_udiv (   fs,
  R,
  X,
  Y 
)
Value:
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)

Definition at line 238 of file op-1.h.

#define _FP_DIV_MEAT_1_udiv_norm (   fs,
  R,
  X,
  Y 
)
Value:
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)

Definition at line 214 of file op-1.h.

#define _FP_FRAC_ADD_1 (   R,
  X,
  Y 
)    (R##_f = X##_f + Y##_f)

Definition at line 66 of file op-1.h.

#define _FP_FRAC_ADDI_1 (   X,
  I 
)    (X##_f += I)

Definition at line 41 of file op-1.h.

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

Definition at line 290 of file op-1.h.

#define _FP_FRAC_CLEAR_OVERP_1 (   fs,
  X 
)    (X##_f &= ~_FP_OVERFLOW_##fs)

Definition at line 75 of file op-1.h.

#define _FP_FRAC_CLZ_1 (   z,
  X 
)    __FP_CLZ(z, X##_f)

Definition at line 69 of file op-1.h.

#define _FP_FRAC_COPY_1 (   D,
  S 
)    (D##_f = S##_f)

Definition at line 35 of file op-1.h.

#define _FP_FRAC_COPY_1_1 (   D,
  S 
)    (D##_f = S##_f)

Definition at line 298 of file op-1.h.

#define _FP_FRAC_DEC_1 (   X,
  Y 
)    (X##_f -= Y##_f)

Definition at line 68 of file op-1.h.

#define _FP_FRAC_DECL_1 (   X)    _FP_W_TYPE X##_f

Definition at line 34 of file op-1.h.

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

Definition at line 291 of file op-1.h.

#define _FP_FRAC_EQ_1 (   X,
  Y 
)    (X##_f == Y##_f)

Definition at line 76 of file op-1.h.

#define _FP_FRAC_GE_1 (   X,
  Y 
)    (X##_f >= Y##_f)

Definition at line 77 of file op-1.h.

#define _FP_FRAC_GT_1 (   X,
  Y 
)    (X##_f > Y##_f)

Definition at line 78 of file op-1.h.

#define _FP_FRAC_HIGH_1 (   X)    (X##_f)

Definition at line 37 of file op-1.h.

#define _FP_FRAC_LOW_1 (   X)    (X##_f)

Definition at line 38 of file op-1.h.

#define _FP_FRAC_NEGP_1 (   X)    ((_FP_WS_TYPE)X##_f < 0)

Definition at line 72 of file op-1.h.

#define _FP_FRAC_OVERP_1 (   fs,
  X 
)    (X##_f & _FP_OVERFLOW_##fs)

Definition at line 74 of file op-1.h.

#define _FP_FRAC_SET_1 (   X,
  I 
)    (X##_f = I)

Definition at line 36 of file op-1.h.

#define _FP_FRAC_SLL_1 (   X,
  N 
)
Value:
do {                                      \
    if (__builtin_constant_p(N) && (N) == 1)     \
      X##_f += X##_f;                            \
    else                                  \
      X##_f <<= (N);                      \
  } while (0)

Definition at line 42 of file op-1.h.

#define _FP_FRAC_SRL_1 (   X,
  N 
)    (X##_f >>= N)

Definition at line 49 of file op-1.h.

#define _FP_FRAC_SRS_1 (   X,
  N,
  sz 
)    __FP_FRAC_SRS_1(X##_f, N, sz)

Definition at line 53 of file op-1.h.

#define _FP_FRAC_SRST_1 (   X,
  S,
  N,
  sz 
)    __FP_FRAC_SRST_1(X##_f, S, N, sz)

Definition at line 52 of file op-1.h.

#define _FP_FRAC_SUB_1 (   R,
  X,
  Y 
)    (R##_f = X##_f - Y##_f)

Definition at line 67 of file op-1.h.

#define _FP_FRAC_WORD_1 (   X,
 
)    (X##_f)

Definition at line 39 of file op-1.h.

#define _FP_FRAC_ZEROP_1 (   X)    (X##_f == 0)

Definition at line 73 of file op-1.h.

#define _FP_MAXFRAC_1   (~(_FP_WS_TYPE)0)

Definition at line 82 of file op-1.h.

#define _FP_MINFRAC_1   1

Definition at line 81 of file op-1.h.

#define _FP_MUL_MEAT_1_hard (   wfracbits,
  R,
  X,
  Y 
)
Value:
do {                                                           \
    _FP_W_TYPE _xh, _xl, _yh, _yl, _z_f0, _z_f1, _a_f0, _a_f1;        \
                                                               \
    /* split the words in half */                              \
    _xh = X##_f >> (_FP_W_TYPE_SIZE/2);                               \
    _xl = X##_f & (((_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE/2)) - 1);              \
    _yh = Y##_f >> (_FP_W_TYPE_SIZE/2);                               \
    _yl = Y##_f & (((_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE/2)) - 1);              \
                                                               \
    /* multiply the pieces */                                         \
    _z_f0 = _xl * _yl;                                                \
    _a_f0 = _xh * _yl;                                                \
    _a_f1 = _xl * _yh;                                                \
    _z_f1 = _xh * _yh;                                                \
                                                               \
    /* reassemble into two full words */                       \
    if ((_a_f0 += _a_f1) < _a_f1)                              \
      _z_f1 += (_FP_W_TYPE)1 << (_FP_W_TYPE_SIZE/2);                  \
    _a_f1 = _a_f0 >> (_FP_W_TYPE_SIZE/2);                      \
    _a_f0 = _a_f0 << (_FP_W_TYPE_SIZE/2);                      \
    _FP_FRAC_ADD_2(_z, _z, _a);                                       \
                                                               \
    /* normalize */                                            \
    _FP_FRAC_SRS_2(_z, wfracbits - 1, 2*wfracbits);                   \
    R##_f = _z_f0;                                             \
  } while (0)

Definition at line 161 of file op-1.h.

#define _FP_MUL_MEAT_1_imm (   wfracbits,
  R,
  X,
  Y 
)
Value:
do {                                                           \
    R##_f = X##_f * Y##_f;                                     \
    /* Normalize since we know where the msb of the multiplicands     \
       were (bit B), we know that the msb of the of the product is    \
       at either 2B or 2B-1.  */                               \
    _FP_FRAC_SRS_1(R, wfracbits-1, 2*wfracbits);               \
  } while (0)

Definition at line 141 of file op-1.h.

#define _FP_MUL_MEAT_1_wide (   wfracbits,
  R,
  X,
  Y,
  doit 
)
Value:
do {                                                           \
    _FP_W_TYPE _Z_f0, _Z_f1;                                          \
    doit(_Z_f1, _Z_f0, X##_f, Y##_f);                                 \
    /* Normalize since we know where the msb of the multiplicands     \
       were (bit B), we know that the msb of the of the product is    \
       at either 2B or 2B-1.  */                               \
    _FP_FRAC_SRS_2(_Z, wfracbits-1, 2*wfracbits);                     \
    R##_f = _Z_f0;                                             \
  } while (0)

Definition at line 150 of file op-1.h.

#define _FP_PACK_RAW_1 (   fs,
  val,
  X 
)
Value:
do {                                                    \
    union _FP_UNION_##fs _flo;                                 \
                                                        \
    _flo.bits.frac = X##_f;                             \
    _flo.bits.exp  = X##_e;                             \
    _flo.bits.sign = X##_s;                             \
                                                        \
    (val) = _flo.flt;                                          \
  } while (0)

Definition at line 112 of file op-1.h.

#define _FP_PACK_RAW_1_P (   fs,
  val,
  X 
)
Value:
do {                                                    \
    union _FP_UNION_##fs *_flo =                        \
      (union _FP_UNION_##fs *)(val);                           \
                                                        \
    _flo->bits.frac = X##_f;                                   \
    _flo->bits.exp  = X##_e;                                   \
    _flo->bits.sign = X##_s;                                   \
  } while (0)

Definition at line 123 of file op-1.h.

#define _FP_SQRT_MEAT_1 (   R,
  S,
  T,
  X,
 
)
Value:
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)

Definition at line 263 of file op-1.h.

#define _FP_UNPACK_RAW_1 (   fs,
  X,
  val 
)
Value:
do {                                                    \
    union _FP_UNION_##fs _flo; _flo.flt = (val);        \
                                                        \
    X##_f = _flo.bits.frac;                             \
    X##_e = _flo.bits.exp;                              \
    X##_s = _flo.bits.sign;                             \
  } while (0)

Definition at line 89 of file op-1.h.

#define _FP_UNPACK_RAW_1_P (   fs,
  X,
  val 
)
Value:
do {                                                    \
    union _FP_UNION_##fs *_flo =                        \
      (union _FP_UNION_##fs *)(val);                           \
                                                        \
    X##_f = _flo->bits.frac;                                   \
    X##_e = _flo->bits.exp;                             \
    X##_s = _flo->bits.sign;                                   \
  } while (0)

Definition at line 98 of file op-1.h.

#define _FP_ZEROFRAC_1   0

Definition at line 80 of file op-1.h.