Back to index

glibc  2.9
Defines | Functions
sfp-machine.h File Reference
#include <fpu_control.h>
#include <stdlib.h>

Go to the source code of this file.

Defines

#define _FP_W_TYPE_SIZE   32
#define _FP_W_TYPE   unsigned long
#define _FP_WS_TYPE   signed long
#define _FP_I_TYPE   long
#define _FP_MUL_MEAT_S(R, X, Y)   _FP_MUL_MEAT_1_wide(_FP_WFRACBITS_S,R,X,Y,umul_ppmm)
#define _FP_MUL_MEAT_D(R, X, Y)   _FP_MUL_MEAT_2_wide(_FP_WFRACBITS_D,R,X,Y,umul_ppmm)
#define _FP_MUL_MEAT_Q(R, X, Y)   _FP_MUL_MEAT_4_wide(_FP_WFRACBITS_Q,R,X,Y,umul_ppmm)
#define _FP_DIV_MEAT_S(R, X, Y)   _FP_DIV_MEAT_1_udiv(S,R,X,Y)
#define _FP_DIV_MEAT_D(R, X, Y)   _FP_DIV_MEAT_2_udiv(D,R,X,Y)
#define _FP_DIV_MEAT_Q(R, X, Y)   _FP_DIV_MEAT_4_udiv(Q,R,X,Y)
#define _FP_NANFRAC_S   ((_FP_QNANBIT_S << 1) - 1)
#define _FP_NANFRAC_D   ((_FP_QNANBIT_D << 1) - 1), -1
#define _FP_NANFRAC_Q   ((_FP_QNANBIT_Q << 1) - 1), -1, -1, -1
#define _FP_NANSIGN_S   0
#define _FP_NANSIGN_D   0
#define _FP_NANSIGN_Q   0
#define _FP_KEEPNANFRACP   1
#define _FP_CHOOSENAN(fs, wc, R, X, Y, OP)
#define __FP_FRAC_ADD_3(r2, r1, r0, x2, x1, x0, y2, y1, y0)
#define __FP_FRAC_SUB_3(r2, r1, r0, x2, x1, x0, y2, y1, y0)
#define __FP_FRAC_ADD_4(r3, r2, r1, r0, x3, x2, x1, x0, y3, y2, y1, y0)
#define __FP_FRAC_SUB_4(r3, r2, r1, r0, x3, x2, x1, x0, y3, y2, y1, y0)
#define __FP_FRAC_DEC_3(x2, x1, x0, y2, y1, y0)   __FP_FRAC_SUB_3(x2,x1,x0,x2,x1,x0,y2,y1,y0)
#define __FP_FRAC_DEC_4(x3, x2, x1, x0, y3, y2, y1, y0)   __FP_FRAC_SUB_4(x3,x2,x1,x0,x3,x2,x1,x0,y3,y2,y1,y0)
#define __FP_FRAC_ADDI_4(x3, x2, x1, x0, i)
#define FP_ROUNDMODE   ((_fcw >> 30) & 0x3)
#define FP_EX_INVALID   (1 << 4)
#define FP_EX_OVERFLOW   (1 << 3)
#define FP_EX_UNDERFLOW   (1 << 2)
#define FP_EX_DIVZERO   (1 << 1)
#define FP_EX_INEXACT   (1 << 0)
#define _FP_DECL_EX   fpu_control_t _fcw
#define FP_INIT_ROUNDMODE
#define FP_HANDLE_EXCEPTIONS

Functions

double ___Q_simulate_exceptions (int exc)

Define Documentation

#define __FP_FRAC_ADD_3 (   r2,
  r1,
  r0,
  x2,
  x1,
  x0,
  y2,
  y1,
  y0 
)
Value:
__asm__ ("addcc %r7,%8,%2\n\           addxcc %r5,%6,%1\n\         addx %r3,%4,%0"                                     \
          : "=r" ((USItype)(r2)),                              \
            "=&r" ((USItype)(r1)),                             \
            "=&r" ((USItype)(r0))                              \
          : "%rJ" ((USItype)(x2)),                             \
            "rI" ((USItype)(y2)),                              \
            "%rJ" ((USItype)(x1)),                             \
            "rI" ((USItype)(y1)),                              \
            "%rJ" ((USItype)(x0)),                             \
            "rI" ((USItype)(y0))                               \
          : "cc")

Definition at line 76 of file sfp-machine.h.

#define __FP_FRAC_ADD_4 (   r3,
  r2,
  r1,
  r0,
  x3,
  x2,
  x1,
  x0,
  y3,
  y2,
  y1,
  y0 
)
Value:
do {                                                           \
    /* We need to fool gcc,  as we need to pass more than 10          \
       input/outputs.  */                                      \
    register USItype _t1 __asm__ ("g1"), _t2 __asm__ ("g2");          \
    __asm__ __volatile__ ("\           addcc %r8,%9,%1\n\          addxcc %r6,%7,%0\n\         addxcc %r4,%5,%%g2\n\       addx %r2,%3,%%g1"                                          \
          : "=&r" ((USItype)(r1)),                             \
            "=&r" ((USItype)(r0))                              \
          : "%rJ" ((USItype)(x3)),                             \
            "rI" ((USItype)(y3)),                              \
            "%rJ" ((USItype)(x2)),                             \
            "rI" ((USItype)(y2)),                              \
            "%rJ" ((USItype)(x1)),                             \
            "rI" ((USItype)(y1)),                              \
            "%rJ" ((USItype)(x0)),                             \
            "rI" ((USItype)(y0))                               \
          : "cc", "g1", "g2");                                        \
    __asm__ __volatile__ ("" : "=r" (_t1), "=r" (_t2));               \
    r3 = _t1; r2 = _t2;                                               \
  } while (0)

Definition at line 106 of file sfp-machine.h.

#define __FP_FRAC_ADDI_4 (   x3,
  x2,
  x1,
  x0,
  i 
)
Value:
__asm__ ("addcc %3,%4,%3\n\     addxcc %2,%%g0,%2\n\        addxcc %1,%%g0,%1\n\        addx %0,%%g0,%0"                                    \
          : "=&r" ((USItype)(x3)),                             \
            "=&r" ((USItype)(x2)),                             \
            "=&r" ((USItype)(x1)),                             \
            "=&r" ((USItype)(x0))                              \
          : "rI" ((USItype)(i)),                               \
            "0" ((USItype)(x3)),                               \
            "1" ((USItype)(x2)),                               \
            "2" ((USItype)(x1)),                               \
            "3" ((USItype)(x0))                                \
          : "cc")

Definition at line 158 of file sfp-machine.h.

#define __FP_FRAC_DEC_3 (   x2,
  x1,
  x0,
  y2,
  y1,
  y0 
)    __FP_FRAC_SUB_3(x2,x1,x0,x2,x1,x0,y2,y1,y0)

Definition at line 154 of file sfp-machine.h.

#define __FP_FRAC_DEC_4 (   x3,
  x2,
  x1,
  x0,
  y3,
  y2,
  y1,
  y0 
)    __FP_FRAC_SUB_4(x3,x2,x1,x0,x3,x2,x1,x0,y3,y2,y1,y0)

Definition at line 156 of file sfp-machine.h.

#define __FP_FRAC_SUB_3 (   r2,
  r1,
  r0,
  x2,
  x1,
  x0,
  y2,
  y1,
  y0 
)
Value:
__asm__ ("subcc %r7,%8,%2\n\           subxcc %r5,%6,%1\n\         subx %r3,%4,%0"                                     \
          : "=r" ((USItype)(r2)),                              \
            "=&r" ((USItype)(r1)),                             \
            "=&r" ((USItype)(r0))                              \
          : "%rJ" ((USItype)(x2)),                             \
            "rI" ((USItype)(y2)),                              \
            "%rJ" ((USItype)(x1)),                             \
            "rI" ((USItype)(y1)),                              \
            "%rJ" ((USItype)(x0)),                             \
            "rI" ((USItype)(y0))                               \
          : "cc")

Definition at line 91 of file sfp-machine.h.

#define __FP_FRAC_SUB_4 (   r3,
  r2,
  r1,
  r0,
  x3,
  x2,
  x1,
  x0,
  y3,
  y2,
  y1,
  y0 
)
Value:
do {                                                           \
    /* We need to fool gcc,  as we need to pass more than 10          \
       input/outputs.  */                                      \
    register USItype _t1 __asm__ ("g1"), _t2 __asm__ ("g2");          \
    __asm__ __volatile__ ("\           subcc %r8,%9,%1\n\          subxcc %r6,%7,%0\n\         subxcc %r4,%5,%%g2\n\       subx %r2,%3,%%g1"                                          \
          : "=&r" ((USItype)(r1)),                             \
            "=&r" ((USItype)(r0))                              \
          : "%rJ" ((USItype)(x3)),                             \
            "rI" ((USItype)(y3)),                              \
            "%rJ" ((USItype)(x2)),                             \
            "rI" ((USItype)(y2)),                              \
            "%rJ" ((USItype)(x1)),                             \
            "rI" ((USItype)(y1)),                              \
            "%rJ" ((USItype)(x0)),                             \
            "rI" ((USItype)(y0))                               \
          : "cc", "g1", "g2");                                        \
    __asm__ __volatile__ ("" : "=r" (_t1), "=r" (_t2));               \
    r3 = _t1; r2 = _t2;                                               \
  } while (0)

Definition at line 130 of file sfp-machine.h.

#define _FP_CHOOSENAN (   fs,
  wc,
  R,
  X,
  Y,
  OP 
)
Value:
do {                                                    \
    if ((_FP_FRAC_HIGH_RAW_##fs(X) & _FP_QNANBIT_##fs)         \
       && !(_FP_FRAC_HIGH_RAW_##fs(Y) & _FP_QNANBIT_##fs))     \
      {                                                        \
       R##_s = Y##_s;                                          \
       _FP_FRAC_COPY_##wc(R,Y);                         \
      }                                                        \
    else                                                \
      {                                                        \
       R##_s = X##_s;                                          \
       _FP_FRAC_COPY_##wc(R,X);                         \
      }                                                        \
    R##_c = FP_CLS_NAN;                                        \
  } while (0)

Definition at line 59 of file sfp-machine.h.

#define _FP_DECL_EX   fpu_control_t _fcw

Definition at line 186 of file sfp-machine.h.

#define _FP_DIV_MEAT_D (   R,
  X,
  Y 
)    _FP_DIV_MEAT_2_udiv(D,R,X,Y)

Definition at line 40 of file sfp-machine.h.

#define _FP_DIV_MEAT_Q (   R,
  X,
  Y 
)    _FP_DIV_MEAT_4_udiv(Q,R,X,Y)

Definition at line 41 of file sfp-machine.h.

#define _FP_DIV_MEAT_S (   R,
  X,
  Y 
)    _FP_DIV_MEAT_1_udiv(S,R,X,Y)

Definition at line 39 of file sfp-machine.h.

#define _FP_I_TYPE   long

Definition at line 30 of file sfp-machine.h.

#define _FP_KEEPNANFRACP   1

Definition at line 50 of file sfp-machine.h.

#define _FP_MUL_MEAT_D (   R,
  X,
  Y 
)    _FP_MUL_MEAT_2_wide(_FP_WFRACBITS_D,R,X,Y,umul_ppmm)

Definition at line 34 of file sfp-machine.h.

#define _FP_MUL_MEAT_Q (   R,
  X,
  Y 
)    _FP_MUL_MEAT_4_wide(_FP_WFRACBITS_Q,R,X,Y,umul_ppmm)

Definition at line 36 of file sfp-machine.h.

#define _FP_MUL_MEAT_S (   R,
  X,
  Y 
)    _FP_MUL_MEAT_1_wide(_FP_WFRACBITS_S,R,X,Y,umul_ppmm)

Definition at line 32 of file sfp-machine.h.

#define _FP_NANFRAC_D   ((_FP_QNANBIT_D << 1) - 1), -1

Definition at line 44 of file sfp-machine.h.

#define _FP_NANFRAC_Q   ((_FP_QNANBIT_Q << 1) - 1), -1, -1, -1

Definition at line 45 of file sfp-machine.h.

#define _FP_NANFRAC_S   ((_FP_QNANBIT_S << 1) - 1)

Definition at line 43 of file sfp-machine.h.

#define _FP_NANSIGN_D   0

Definition at line 47 of file sfp-machine.h.

#define _FP_NANSIGN_Q   0

Definition at line 48 of file sfp-machine.h.

#define _FP_NANSIGN_S   0

Definition at line 46 of file sfp-machine.h.

#define _FP_W_TYPE   unsigned long

Definition at line 28 of file sfp-machine.h.

#define _FP_W_TYPE_SIZE   32

Definition at line 27 of file sfp-machine.h.

#define _FP_WS_TYPE   signed long

Definition at line 29 of file sfp-machine.h.

#define FP_EX_DIVZERO   (1 << 1)

Definition at line 183 of file sfp-machine.h.

#define FP_EX_INEXACT   (1 << 0)

Definition at line 184 of file sfp-machine.h.

#define FP_EX_INVALID   (1 << 4)

Definition at line 180 of file sfp-machine.h.

#define FP_EX_OVERFLOW   (1 << 3)

Definition at line 181 of file sfp-machine.h.

#define FP_EX_UNDERFLOW   (1 << 2)

Definition at line 182 of file sfp-machine.h.

Value:
do {                                                    \
  if (!_fex)                                            \
    {                                                   \
      /* This is the common case, so we do it inline.          \
       * We need to clear cexc bits if any.                    \
       */                                               \
      extern unsigned long long ___Q_numbers[];                \
      __asm__ __volatile__("\             ldd [%0], %%f30\n\          faddd %%f30, %%f30, %%f30\         " : : "r" (___Q_numbers) : "f30");               \
    }                                                   \
  else								\
    ___Q_simulate_exceptions (_fex);                            \
} while (0)

Definition at line 196 of file sfp-machine.h.

Value:
do {                                                    \
  _FPU_GETCW(_fcw);                                     \
} while (0)

Definition at line 188 of file sfp-machine.h.

#define FP_ROUNDMODE   ((_fcw >> 30) & 0x3)

Definition at line 176 of file sfp-machine.h.


Function Documentation

double ___Q_simulate_exceptions ( int  exc)

Definition at line 32 of file q_util.c.

{
  double d, *p = (double *)___Q_numbers;
  if (exceptions & FP_EX_INVALID)
    d = p[0]/p[0];
  if (exceptions & FP_EX_OVERFLOW)
    {
      d = p[3] + p[3];
      exceptions &= ~FP_EX_INEXACT;
    }
  if (exceptions & FP_EX_UNDERFLOW)
    {
      if (exceptions & FP_EX_INEXACT)
        {
         d = p[2] * p[2];
         exceptions &= ~FP_EX_INEXACT;
       }
      else
       d = p[1] - p[2];
    }
  if (exceptions & FP_EX_DIVZERO)
    d = 1.0/p[0];
  if (exceptions & FP_EX_INEXACT)
    d = p[3] - p[2];
  return d;
}