ushmedia.h

linux下的gcc编译器

__inline__ static
int   
sh_media_FCMPUN_S (float fg, float fh)
{
  int res;
  __asm__ ("fcmpun.s	%1, %2, %0" : "=f" (res) : "f" (fg), "f" (fh));
  return res;
}

__inline__ static
float 
sh_media_FGETSCR (void)
{
  float res;
  __asm__ ("fgetscr	%0" : "=f" (res));
  return res;
}

__inline__ static
float 
sh_media_FIPR_S (const void *fvg, const void *fvh)
{
  float res;
  __asm__ ("fipr.s	%1, %2, %0" : "=f" (res)
	   : "f" (*(const __GCC_FV *)fvg), "f" (*(const __GCC_FV *)fvh));
  return res;
}

__inline__ static
float 
sh_media_FMAC_S (float fg, float fh, float fq)
{
  float res;
  __asm__ ("fmac.s	%1, %2, %0" : "=f" (res)
	   : "f" (fg), "f" (fh), "0" (fq));
  return res;
}

__inline__ static
long long
sh_media_FMOV_DQ (double dg)
{
  long long res;
  __asm__ ("fmov.dq	%1, %0" : "=r" (res) : "f" (dg));
  return res;
}

__inline__ static
float
sh_media_FMOV_LS (int mm)
{
  float res;
  __asm__ ("fmov.ls	%1, %0" : "=f" (res) : "r" (mm));
  return res;
}

__inline__ static
double
sh_media_FMOV_QD (long long mm)
{
  double res;
  __asm__ ("fmov.qd	%1, %0" : "=f" (res) : "r" (mm));
  return res;
}

__inline__ static
int
sh_media_FMOV_SL (float fg)
{
  int res;
  __asm__ ("fmov.sl	%1, %0" : "=r" (res) : "f" (fg));
  return res;
}

__inline__ static
void  
sh_media_FPUTSCR (float fg)
{
  __asm__ ("fputscr	%0" : : "f" (fg));
}

__inline__ static
double
sh_media_FSQRT_D (double dg)
{
  double res;
  __asm__ ("fsqrt.d	%1, %0" : "=f" (res) : "f" (dg));
  return res;
}

__inline__ static
float 
sh_media_FSQRT_S (float fg)
{
  float res;
  __asm__ ("fsqrt.s	%1, %0" : "=f" (res) : "f" (fg));
  return res;
}

__inline__ static
void  
sh_media_FTRV_S (const void *mtrxg, const void *fvh, void *fvf)
{
  __asm__ ("ftrv.s	%2, %1, %0" : "=f" (*(__GCC_FV *)fvf)
	   : "f" (*(const __GCC_FV *)fvh), "f" (*(const __GCC_MTRX *)mtrxg));
}
#endif /* ! __SH4_NOFPU__ */

__inline__ static
unsigned long long
sh_media_LDHI_L (void *p, int s)
{
  unsigned long long res;
  __asm__ ("ldhi.l	%m1, %0" : "=r" (res) : "o" (((char*)p)[s]));
  return res;
}

__inline__ static
unsigned long long
sh_media_LDHI_Q (void *p, int s)
{
  unsigned long long res;
  __asm__ ("ldhi.q	%m1, %0" : "=r" (res) : "o" (((char*)p)[s]));
  return res;
}

__inline__ static
unsigned long long
sh_media_LDLO_L (void *p, int s)
{
  unsigned long long res;
  __asm__ ("ldlo.l	%m1, %0" : "=r" (res) : "o" (((char*)p)[s]));
  return res;
}

__inline__ static
unsigned long long
sh_media_LDLO_Q (void *p, int s)
{
  unsigned long long res;
  __asm__ ("ldlo.q	%m1, %0" : "=r" (res) : "o" (((char*)p)[s]));
  return res;
}

__inline__ static
void     
sh_media_STHI_L (void *p, int s, unsigned int mw)
{
  __asm__ ("sthi.l %m0, %1" : "+o" (((char*)p)[s]) : "r" (mw));
}

__inline__ static
void     
sh_media_STHI_Q (void *p, int s, unsigned long long mw)
{
  __asm__ ("sthi.q %m0, %1" : "+o" (((char*)p)[s]) : "r" (mw));
}

__inline__ static
void     
sh_media_STLO_L (void *p, int s, unsigned int mw)
{
  __asm__ ("stlo.l %m0, %1" : "+o" (((char*)p)[s]) : "r" (mw));
}

__inline__ static
void     
sh_media_STLO_Q (void *p, int s, unsigned long long mw)
{
  __asm__ ("stlo.q %m0, %1" : "+o" (((char*)p)[s]) : "r" (mw));
}

__inline__ static
unsigned char
sh_media_NSB (long long mm)
{
  unsigned char res;
  __asm__ ("nsb	%1, %0" : "=r" (res) : "r" (mm));
  return res;
}

__inline__ static
unsigned long long
sh_media_BYTEREV (unsigned long long mm)
{
  unsigned long long res;
  __asm__ ("byterev	%1, %0" : "=r" (res) : "r" (mm));
  return res;
}

__inline__ static
unsigned long long
sh_media_CMVEQ (unsigned long long mm, unsigned long long mn, unsigned long long mw)
{
  unsigned long long res;
  __asm__ ("cmveq	%1, %2, %0" : "=r" (res)
	   : "r" (mm), "r" (mn), "0" (mw));
  return res;
}

__inline__ static
unsigned long long
sh_media_CMVNE (unsigned long long mm, unsigned long long mn, unsigned long long mw)
{
  unsigned long long res;
  __asm__ ("cmveq	%1, %2, %0" : "=r" (res)
	   : "r" (mm), "r" (mn), "0" (mw));
  return res;
}

__inline__ static
unsigned long long
sh_media_ADDZ_L (unsigned int mm, unsigned int mn)
{
  unsigned long long res;
  __asm__ ("addz.l	%1, %2, %0" : "=r" (res) : "r" (mm), "r" (mn));
  return res;
}

__inline__ static
void
sh_media_NOP (void)
{
  __asm__ __volatile__ ("nop" : :);
}

__inline__ static
unsigned long long
sh_media_SWAP_Q (void *mm, long long mn, unsigned long long mw)
{
  unsigned long long res;
  unsigned long long *addr = (unsigned long long *)((char *)mm + mn);
  __asm__ ("swap.q	%m1, %0" : "=r" (res), "+o" (*addr) : "0" (mw));
  return res;
}

__inline__ static
void     
sh_media_SYNCI (void)
{
  __asm__ __volatile__ ("synci");
}

__inline__ static
void     
sh_media_SYNCO (void)
{
  __asm__ __volatile__ ("synco");
}

__inline__ static
void
sh_media_ALLOCO (void *mm, int s)
{
  __asm__ __volatile__ ("alloco	%m0" : : "o" (((char*)mm)[s]));
}

__inline__ static
void
sh_media_ICBI (void *mm, int s)
{
  __asm__ __volatile__ ("icbi	%m0" : : "o" (((char*)mm)[s]));
}

__inline__ static
void
sh_media_OCBI (void *mm, int s)
{
  __asm__ __volatile__ ("ocbi	%m0" : : "o" (((char*)mm)[s]));
}

__inline__ static
void
sh_media_OCBP (void *mm, int s)
{
  __asm__ __volatile__ ("ocbp	%m0" : : "o" (((char*)mm)[s]));
}

__inline__ static
void
sh_media_OCBWB (void *mm, int s)
{
  __asm__ __volatile__ ("ocbwb	%m0" : : "o" (((char*)mm)[s]));
}

__inline__ static
void
sh_media_PREFI (void *mm, int s)
{
  __asm__ __volatile__ ("prefi	%m0" : : "o" (((char*)mm)[s]));
}

__inline__ static
void
sh_media_PREFO (void *mm, int s)
{
  __asm__ __volatile__ ("ld.b	%m0, r63" : : "o" (((char*)mm)[s]));
}

__inline__ static
void
sh_media_BRK (void)
{
  __asm__ __volatile__ ("brk");
}

__inline__ static
void
sh_media_TRAPA (unsigned long long mm)
{
  __asm__ __volatile__ ("trapa	%%0" : : "r" (mm));
}

__inline__ static
short         
sh_media_unaligned_LD_W (void *p)
{
#if __LITTLE_ENDIAN__
  return (((unsigned char *)p)[0]
	  | (((short)((__signed__ char *)p)[1]) << 8));
#else
  return ((((short)((__signed__ char *)p)[0]) << 8)
	  | ((unsigned char *)p)[1]);
#endif
}

__inline__ static
unsigned short
sh_media_unaligned_LD_UW (void *p)
{
  unsigned char *addr = p;
#if __LITTLE_ENDIAN__
  return sh_media_MSHFLO_B (addr[0], addr[1]);
#else
  return sh_media_MSHFLO_B (addr[1], addr[0]);
#endif
}

__inline__ static
int           
sh_media_unaligned_LD_L (void *p)
{
#if __LITTLE_ENDIAN__
  return sh_media_LDHI_L (p, 3) | sh_media_LDLO_L (p, 0);
#else
  return sh_media_LDLO_L (p, 3) | sh_media_LDHI_L (p, 0);
#endif
}

__inline__ static
long long     
sh_media_unaligned_LD_Q (void *p)
{
#if __LITTLE_ENDIAN__
  return sh_media_LDHI_Q (p, 7) | sh_media_LDLO_Q (p, 0);
#else
  return sh_media_LDLO_Q (p, 7) | sh_media_LDHI_Q (p, 0);
#endif
}

__inline__ static
void
sh_media_unaligned_ST_W (void *p, unsigned int k)
{
  char *addr = p;
#if __LITTLE_ENDIAN__
  addr[0] = k;
  addr[1] = k >> 8;
#else
  addr[1] = k;
  addr[0] = k >> 8;
#endif
}

__inline__ static
void
sh_media_unaligned_ST_L (void *p, unsigned int k)
{
#if __LITTLE_ENDIAN__
  sh_media_STHI_L (p, 3, k);
  sh_media_STLO_L (p, 0, k);
#else
  sh_media_STLO_L (p, 3, k);
  sh_media_STHI_L (p, 0, k);
#endif
}

__inline__ static
void
sh_media_unaligned_ST_Q (void *p, unsigned long long k)
{
#if __LITTLE_ENDIAN__
  sh_media_STHI_Q (p, 7, k);
  sh_media_STLO_Q (p, 0, k);
#else
  sh_media_STLO_Q (p, 7, k);
  sh_media_STHI_Q (p, 0, k);
#endif
}

#if ! __SH4_NOFPU__
__inline__ static
void
sh_media_FVCOPY_S (const void *fvg, void *fvf)
{
  const __GCC_FV *g = fvg;
  __GCC_FV *f = fvf;
  *f = *g;
}

__inline__ static
void
sh_media_FVADD_S (const void *fvg, const void *fvh, void *fvf)
{
  const float *g = fvg, *h = fvh;
  float *f = fvf;
#if 1
  int i;

  for (i = 0; i < 4; i++)
    f[i] = g[i] + h[i];
#else
  f[0] = g[0] + h[0];
  f[1] = g[1] + h[1];
  f[2] = g[2] + h[2];
  f[3] = g[3] + h[3];
#endif
}

__inline__ static
void
sh_media_FVSUB_S (const void *fvg, const void *fvh, void *fvf)
{
  const float *g = fvg, *h = fvh;
  float *f = fvf;
#if 1
  int i;

  for (i = 0; i < 4; i++)
    f[i] = g[i] - h[i];
#else
  f[0] = g[0] - h[0];
  f[1] = g[1] - h[1];
  f[2] = g[2] - h[2];
  f[3] = g[3] - h[3];
#endif
}

__inline__ static
void
sh_media_FMTRXCOPY_S (const void *mtrxg, void *mtrxf)
{
  const __GCC_MTRX *g = mtrxg;
  __GCC_MTRX *f = mtrxf;
  *f = *g;
}

__inline__ static
void
sh_media_FMTRXADD_S (const void *mtrxg, const void *mtrxh, void *mtrxf)
{
  const __GCC_FV *g = mtrxg, *h = mtrxh;
  __GCC_FV *f = mtrxf;
#if 1
  int i;

  for (i = 0; i < 4; i++)
    sh_media_FVADD_S (&g[i], &h[i], &f[i]);
#else
  sh_media_FVADD_S (&g[0], &h[0], &f[0]);
  sh_media_FVADD_S (&g[1], &h[1], &f[1]);
  sh_media_FVADD_S (&g[2], &h[2], &f[2]);
  sh_media_FVADD_S (&g[3], &h[3], &f[3]);
#endif
}

__inline__ static
void
sh_media_FMTRXSUB_S (const void *mtrxg, const void *mtrxh, void *mtrxf)
{
  const __GCC_FV *g = mtrxg, *h = mtrxh;
  __GCC_FV *f = mtrxf;
#if 1
  int i;

  for (i = 0; i < 4; i++)
    sh_media_FVSUB_S (&g[i], &h[i], &f[i]);
#else
  sh_media_FVSUB_S (&g[0], &h[0], &f[0]);
  sh_media_FVSUB_S (&g[1], &h[1], &f[1]);
  sh_media_FVSUB_S (&g[2], &h[2], &f[2]);
  sh_media_FVSUB_S (&g[3], &h[3], &f[3]);
#endif
}

__inline__ static
void
sh_media_FTRVADD_S (const void *mtrxg, const void *fvh, const void *fvi, void *fvf)
{
  sh_media_FTRV_S (mtrxg, fvh, fvf);
  sh_media_FVADD_S (fvf, fvi, fvf);
}

__inline__ static
void
sh_media_FTRVSUB_S (const void *mtrxg, const void *fvh, const void *fvi, void *fvf)
{
  sh_media_FTRV_S (mtrxg, fvh, fvf);
  sh_media_FVSUB_S (fvf, fvi, fvf);
}

__inline__ static
void
sh_media_FMTRXMUL_S (const void *mtrxg, const void *mtrxh, void *mtrxf)
{
  const __GCC_FV *g = mtrxg;
  __GCC_FV *f = mtrxf;
#if 1
  int j;

  for (j = 0; j < 4; j++)
    sh_media_FTRV_S (mtrxh, &g[j], &f[j]);
#else
  sh_media_FTRV_S (mtrxh, &g[0], &f[0]);
  sh_media_FTRV_S (mtrxh, &g[1], &f[1]);
  sh_media_FTRV_S (mtrxh, &g[2], &f[2]);
  sh_media_FTRV_S (mtrxh, &g[3], &f[3]);
#endif
}

__inline__ static
void
sh_media_FMTRXMULADD_S (const void *mtrxg, const void *mtrxh, const void *mtrxi, void *mtrxf)
{
  const __GCC_FV *g = mtrxg, *i = mtrxi;
  __GCC_FV *f = mtrxf;
#if 1
  int j;

  for (j = 0; j < 4; j++)
    sh_media_FTRVADD_S (mtrxh, &g[j], &i[j], &f[j]);
#else
  sh_media_FTRVADD_S (mtrxh, &g[0], &i[0], &f[0]);
  sh_media_FTRVADD_S (mtrxh, &g[1], &i[1], &f[1]);
  sh_media_FTRVADD_S (mtrxh, &g[2], &i[2], &f[2]);
  sh_media_FTRVADD_S (mtrxh, &g[3], &i[3], &f[3]);
#endif
}

__inline__ static
void
sh_media_FMTRXMULSUB_S (const void *mtrxg, const void *mtrxh, const void *mtrxi, void *mtrxf)
{
  const __GCC_FV *g = mtrxg, *i = mtrxi;
  __GCC_FV *f = mtrxf;
#if 1
  int j;

  for (j = 0; j < 4; j++)
    sh_media_FTRVSUB_S (mtrxh, &g[j], &i[j], &f[j]);
#else
  sh_media_FTRVSUB_S (mtrxh, &g[0], &i[0], &f[0]);
  sh_media_FTRVSUB_S (mtrxh, &g[1], &i[1], &f[1]);
  sh_media_FTRVSUB_S (mtrxh, &g[2], &i[2], &f[2]);
  sh_media_FTRVSUB_S (mtrxh, &g[3], &i[3], &f[3]);
#endif
}
#endif /* ! __SH4_NOFPU__ */

#endif /* __SHMEDIA__ */

#endif /* _USHMEDIA_H */