pspfpu.h

Go to the documentation of this file.

/*
 * PSP Software Development Kit - https://github.com/pspdev
 * -----------------------------------------------------------------------
 * Licensed under the BSD license, see LICENSE in PSPSDK root for details.
 *
 * pspfpu.h - Prototypes for the FPU library
 *
 * Copyright (c) 2009 JetCube
 * Copyright (c) 2006 TyRaNiD (James F.)
 *
 */
#ifndef __PSPFPU_H__
#define __PSPFPU_H__
 
#include <stdint.h>
 
/* Note the bit settings in here come from an NEC MIPSv4 document,
 * they seem sensible.
 */
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum PspFpuRoundMode
{
        PSP_FPU_RN = 0,
        PSP_FPU_RZ = 1,
        PSP_FPU_RP = 2,
        PSP_FPU_RM = 3,
};
 
#define PSP_FPU_RM_MASK 0x03
 
enum PspFpuExceptions
{
        PSP_FPU_EXCEPTION_INEXACT   = 0x01,
        PSP_FPU_EXCEPTION_UNDERFLOW = 0x02,
        PSP_FPU_EXCEPTION_OVERFLOW  = 0x04,
        PSP_FPU_EXCEPTION_DIVBYZERO = 0x08,
        PSP_FPU_EXCEPTION_INVALIDOP = 0x10,
        PSP_FPU_EXCEPTION_UNIMPOP   = 0x20,
        PSP_FPU_EXCEPTION_ALL       = 0x3F
};
 
#define PSP_FPU_FLAGS_POS   2
#define PSP_FPU_ENABLE_POS 7
#define PSP_FPU_CAUSE_POS  12
#define PSP_FPU_CC0_POS    23
#define PSP_FPU_FS_POS     24
#define PSP_FPU_CC17_POS   25
 
#define PSP_FPU_FLAGS_MASK  (0x1F << PSP_FPU_FLAGS_POS)
#define PSP_FPU_ENABLE_MASK (0x1F << PSP_FPU_ENABLE_POS)
#define PSP_FPU_CAUSE_MASK  (0x3F << PSP_FPU_CAUSE_POS)
#define PSP_FPU_CC0_MASK    (1 << PSP_FPU_CC0_POS)
#define PSP_FPU_FS_MASK     (1 << PSP_FPU_FS_POS)
#define PSP_FPU_CC17_MASK   (0x7F << PSP_FPU_CC17_POS)
 
uint32_t pspFpuGetFCR31(void);
 
void pspFpuSetFCR31(uint32_t var);
 
void pspFpuSetRoundmode(enum PspFpuRoundMode mode);
 
enum PspFpuRoundMode pspFpuGetRoundmode(void);
 
uint32_t pspFpuGetFlags(void);
 
void pspFpuClearFlags(uint32_t clear);
 
uint32_t pspFpuGetEnable(void);
 
void pspFpuSetEnable(uint32_t enable);
 
uint32_t pspFpuGetCause(void);
 
void pspFpuClearCause(uint32_t clear);
 
uint32_t pspFpuGetFS(void);
 
void pspFpuSetFS(uint32_t fs);
 
uint32_t pspFpuGetCondbits(void);
 
void pspFpuClearCondbits(uint32_t clear);
 
float pspFpuAbs(float f);
 
int   pspFpuCeil(float f);
 
int   pspFpuFloor(float f);
 
float pspFpuMax(float f1, float f2);
 
float pspFpuMin(float f1, float f2);
 
float pspFpuNeg(float f);
 
int pspFpuRound(float f);
 
/*
 * Reciprocal of square root
 */
float pspFpuRsqrt(float f);
 
float pspFpuSqrt(float f);
 
int pspFpuTrunc(float f);
 
float pspFpuFmod(float fs, float fd);
 
float pspFpuFrac(float f);
 
float pspFpuReinterpretFloat(uint32_t ui);
 
uint32_t pspFpuReinterpretUint(float f);
 
int pspFpuIsEqual(float f1, float f2);
 
float pspFpuSignFloat(float f);
 
int pspFpuSignInt(float f);
 
float pspFpuPositiveZero(void);
 
float pspFpuNegativeZero(void);
 
int pspFpuIsZero(float f);
 
int pspFpuIsPositiveZero(float f);
 
int pspFpuIsNegativeZero(float f);
 
int pspFpuIsDenormal(float f);
 
int pspFpuIsZeroOrDenormal(float f);
 
float pspFpuPositiveInf(void);
 
float pspFpuNegativeInf(void);
 
int pspFpuIsInf(float f);
 
float pspFpuPositiveNaN(void);
 
float pspFpuNegativeNaN(void);
 
float pspFpuPositiveQNaN(void);
 
float pspFpuNegativeQNaN(void);
 
float pspFpuPositiveSNaN(unsigned int uiSignal);
 
float pspFpuNegativeSNaN(unsigned int uiSignal);
 
int pspFpuIsNaN(float f);
 
int pspFpuIsInfOrNaN(float f);
 
float pspFpuNormalizePhase(float f);
 
float pspFpuSin(float x);
 
float pspFpuCos(float x);
 
float pspFpuAtan(float x);
 
float pspFpuLog(float x);
 
float pspFpuExp(float x);
 
float pspFpuAsin(float x);
 
float pspFpuAcos(float x);
 
double pspFpuFloatToDouble(float a);
 
float  pspFpuDoubleToFloat(double a);
 
#ifdef __cplusplus
}
#endif
 
#endif  /* __PSPFPU_H__ */