fenv.h

Go to the documentation of this file.

#ifndef _FENV_H
#define _FENV_H

#include <nlibc.h>

// Exception Masks

#define FE_AU_BAD_OP_H               0x00001
#define FE_AU_BAD_OP_L               0x00002
#define FE_AU_DEN_IN_H               0x00004
#define FE_AU_DEN_IN_L               0x00008
#define FE_AU_DEN_OUT_H              0x00010
#define FE_AU_DEN_OUT_L              0x00020
#define FE_AU_OVERFLOW_H             0x00040
#define FE_AU_OVERFLOW_L             0x00080
#define FE_LUT_BAD_OP_H              0x00100
#define FE_LUT_BAD_OP_L              0x00200
#define FE_LUT_DEN_IN_H              0x00400
#define FE_LUT_DEN_IN_L              0x00800
#define FE_LUT_DEN_OUT_H             0x01000
#define FE_LUT_DEN_OUT_L             0x02000
#define FE_LUT_OVFLW_H               0x04000
#define FE_LUT_OVFLW_L               0x08000
#define FE_AGU_MULT_OVF              0x10000
#define FE_AGU_ADD_OVF               0x20000
#define FE_AGU_ILLEGAL_INSTRUCTION   0x40000

#define FE_ALL_EXCEPT ( FE_AU_BAD_OP_H    \
        |   FE_AU_BAD_OP_L     \
        |   FE_AU_DEN_IN_H     \
        |   FE_AU_DEN_IN_L     \
        |   FE_AU_DEN_OUT_H    \
        |   FE_AU_DEN_OUT_L    \
        |   FE_AU_OVERFLOW_H   \
        |   FE_AU_OVERFLOW_L   \
        |   FE_LUT_BAD_OP_H    \
        |   FE_LUT_BAD_OP_L    \
        |   FE_LUT_DEN_IN_H    \
        |   FE_LUT_DEN_IN_L    \
        |   FE_LUT_DEN_OUT_H   \
        |   FE_LUT_DEN_OUT_L   \
        |   FE_LUT_OVFLW_H     \
        |   FE_LUT_OVFLW_L     \
        |   FE_AGU_MULT_OVF    \
        |   FE_AGU_ADD_OVF     \
        |   FE_AGU_ILLEGAL_INSTRUCTION )

#undef FE_DOWNWARD
#undef FE_TONEAREST
#undef FE_TOWARDZERO
#undef FE_UPWARD 

// Data Types

typedef int   fexcept_t;    /* represents the entire floating-point exceptions */
typedef int   fmask_t;      /* represents the entire floating-point masks */

typedef struct
  {
     fexcept_t __exc_reg;
     fmask_t __msk_reg;
  }
fenv_t;                     /* represents the entire floating-point environment */

// Functions:

int feclearexcept(int excepts); 
int fegetexceptflag(fexcept_t *flagp, int excepts); 
int feraiseexcept(int excepts); 
int fesetexceptflag(const fexcept_t *flagp, int excepts);
int fetestexcept(int excepts); 
int fegetenv(fenv_t *envp); 
int feholdexcept(fenv_t *envp); 
int fesetenv(const fenv_t *envp); 
int feupdateenv(const fenv_t *envp); 
int feclearmask(int mask);
int fegetmaskflag(fmask_t *flagp, int mask);
int feraisemask(int mask);
int fesetmaskflag(const fmask_t *flagp, int mask);
int fetestmask(int mask);

/* ------------------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------------------- */
int feclearexcept(int excepts) 
{
  int tmp_exc;

  asm("\tctr %0 0x30" : "=r" (tmp_exc));
  tmp_exc &= ~excepts;
  asm("\trtc 0x30 %0" : : "r" (tmp_exc)  );

  return(0);
}


/* ------------------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------------------- */
int fegetexceptflag(fexcept_t *flagp, int excepts) 
{
  int tmp_exc;

  asm("\tctr %0 0x30" : "=r" (tmp_exc));
  *flagp=tmp_exc&excepts;

  return(0);
}

/* ------------------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------------------- */
int feraiseexcept(int excepts) 
{
  int tmp_exc;

  asm("\tctr %0 0x30" : "=r" (tmp_exc));
  tmp_exc |= excepts;
  asm("\trtc 0x30 %0" : : "r" (tmp_exc)  );

  return(0);
}


/* ------------------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------------------- */
int fesetexceptflag(const fexcept_t *flagp, int excepts)
{
  int tmp_exc,tmp_exc2;

  asm("\tctr %0 0x30" : "=r" (tmp_exc));
  tmp_exc2 = (tmp_exc & (~(*flagp)));
  tmp_exc  = tmp_exc2 | (excepts&(*flagp));
  asm("\trtc 0x30 %0" : : "r" (tmp_exc)  );

  return(0);
}


/* ------------------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------------------- */
int fetestexcept(int excepts) 
{
  int tmp_exc;

  asm("\tctr %0 0x30" : "=r" (tmp_exc));
  tmp_exc &= excepts;

  return(tmp_exc);
}


/* ------------------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------------------- */
int fegetenv(fenv_t *envp) 
{
  
  envp->__exc_reg=fetestexcept(FE_ALL_EXCEPT);
  envp->__msk_reg=fetestmask(FE_ALL_EXCEPT);
  
  return(0);
}

/* ------------------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------------------- */
int feholdexcept(fenv_t *envp) 
{
  fenv_t tmp_exc;

  fegetenv(&tmp_exc);
  *envp = tmp_exc;
  tmp_exc.__exc_reg=0;
  tmp_exc.__msk_reg=FE_ALL_EXCEPT;
  fesetenv(&tmp_exc);

  return(0);
}


/* ------------------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------------------- */
int fesetenv(const fenv_t *envp) 
{

  asm("\trtc 0x31 %0" : : "r" (envp->__msk_reg)  );
  asm("\trtc 0x30 %0" : : "r" (envp->__exc_reg)  );

  return(0);
}


/* ------------------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------------------- */
int feupdateenv(const fenv_t *envp) 
{
  feraisemask(envp->__msk_reg);
  feraiseexcept(envp->__exc_reg);

  return(0);
}




/* ------------------------------------------------------------------------------------- */
//
// Additional apeNEXT specific routines:
// =====================================
//
/* ------------------------------------------------------------------------------------- */




/* ------------------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------------------- */
int feclearmask(int mask) 
{
  int tmp_msk;

  asm("\tctr %0 0x31" : "=r" (tmp_msk));
  tmp_msk &= ~mask;
  asm("\trtc 0x31 %0" : : "r" (tmp_msk)  );

  return(0);
}


/* ------------------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------------------- */
int fegetmaskflag(fmask_t *flagp, int mask) 
{
  int tmp_msk;

  asm("\tctr %0 0x31" : "=r" (tmp_msk));
  *flagp=tmp_msk&mask;

  return(0);
}

/* ------------------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------------------- */
int feraisemask(int mask) 
{
  int tmp_msk;

  asm("\tctr %0 0x31" : "=r" (tmp_msk));
  tmp_msk |= mask;
  asm("\trtc 0x31 %0" : : "r" (tmp_msk)  );

  return(0);
}


/* ------------------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------------------- */
int fesetmaskflag(const fmask_t *flagp, int mask)
{
  int tmp_msk,tmp_msk2;

  asm("\tctr %0 0x31" : "=r" (tmp_msk));
  tmp_msk2 = (tmp_msk & (~(*flagp)));
  tmp_msk  = tmp_msk2 | (mask&(*flagp));
  asm("\trtc 0x31 %0" : : "r" (tmp_msk)  );

  return(0);
}


/* ------------------------------------------------------------------------------------- */
/* ------------------------------------------------------------------------------------- */
int fetestmask(int mask) 
{
  int tmp_msk;

  asm("\tctr %0 0x31" : "=r" (tmp_msk));
  tmp_msk &= mask;

  return(tmp_msk);
}

#endif /* ifndef _FENV_H  */

---