mirror of
https://github.com/libretro/ppsspp.git
synced 2024-12-03 22:51:05 +00:00
303 lines
6.4 KiB
C++
303 lines
6.4 KiB
C++
// Copyright (c) 2012- PPSSPP Project.
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, version 2.0 or later versions.
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License 2.0 for more details.
|
|
|
|
// A copy of the GPL 2.0 should have been included with the program.
|
|
// If not, see http://www.gnu.org/licenses/
|
|
|
|
// Official git repository and contact information can be found at
|
|
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
|
|
|
|
#include "../CPU.h"
|
|
#include "MIPS.h"
|
|
|
|
#include "MIPSVFPUUtils.h"
|
|
|
|
#include <limits>
|
|
|
|
#define V(i) (currentMIPS->v[i])
|
|
#define VI(i) (*(u32*)(&(currentMIPS->v[i])))
|
|
|
|
void ReadVector(float *rd, VectorSize size, int reg)
|
|
{
|
|
int mtx = (reg >> 2) & 7;
|
|
int col = reg & 3;
|
|
int row = 0;
|
|
int length = 0;
|
|
int transpose = (reg>>5) & 1;
|
|
|
|
switch (size)
|
|
{
|
|
case V_Single: transpose = 0; row=(reg>>5)&3; length = 1; break;
|
|
case V_Pair: row=(reg>>5)&2; length = 2; break;
|
|
case V_Triple: row=(reg>>6)&1; length = 3; break;
|
|
case V_Quad: row=(reg>>5)&2; length = 4; break;
|
|
}
|
|
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
int index = mtx * 4;
|
|
if (transpose)
|
|
index += ((row+i)&3) + col*32;
|
|
else
|
|
index += col + ((row+i)&3)*32;
|
|
rd[i] = V(index);
|
|
}
|
|
}
|
|
|
|
void WriteVector(const float *rd, VectorSize size, int reg)
|
|
{
|
|
int mtx = (reg>>2)&7;
|
|
int col = reg & 3;
|
|
int row = 0;
|
|
int length = 0;
|
|
int transpose = (reg>>5)&1;
|
|
|
|
switch (size)
|
|
{
|
|
case V_Single: transpose = 0; row=(reg>>5)&3; length = 1; break;
|
|
case V_Pair: row=(reg>>5)&2; length = 2; break;
|
|
case V_Triple: row=(reg>>6)&1; length = 3; break;
|
|
case V_Quad: row=(reg>>5)&2; length = 4; break;
|
|
}
|
|
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
if (!currentMIPS->vfpuWriteMask[i])
|
|
{
|
|
int index = mtx * 4;
|
|
if (transpose)
|
|
index += ((row+i)&3) + col*32;
|
|
else
|
|
index += col + ((row+i)&3)*32;
|
|
V(index) = rd[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
void ReadMatrix(float *rd, MatrixSize size, int reg)
|
|
{
|
|
int mtx = (reg >> 2) & 7;
|
|
int col = reg & 3;
|
|
|
|
int row = 0;
|
|
int side = 0;
|
|
|
|
switch (size)
|
|
{
|
|
case M_2x2: row = (reg>>5)&2; side = 2; break;
|
|
case M_3x3: row = (reg>>6)&1; side = 3; break;
|
|
case M_4x4: row = (reg>>5)&2; side = 4; break;
|
|
}
|
|
|
|
int transpose = (reg>>5) & 1;
|
|
|
|
for (int i = 0; i < side; i++)
|
|
{
|
|
for (int j = 0; j < side; j++)
|
|
{
|
|
int index = mtx * 4;
|
|
if (transpose)
|
|
index += ((row+i)&3) + ((col+j)&3)*32;
|
|
else
|
|
index += ((col+j)&3) + ((row+i)&3)*32;
|
|
rd[j*4 + i] = V(index);
|
|
}
|
|
}
|
|
}
|
|
|
|
void WriteMatrix(const float *rd, MatrixSize size, int reg)
|
|
{
|
|
int mtx = (reg>>2)&7;
|
|
int col = reg&3;
|
|
|
|
int row = 0;
|
|
int side = 0;
|
|
|
|
switch (size)
|
|
{
|
|
case M_2x2: row = (reg>>5)&2; side = 2; break;
|
|
case M_3x3: row = (reg>>6)&1; side = 3; break;
|
|
case M_4x4: row = (reg>>5)&2; side = 4; break;
|
|
}
|
|
|
|
int transpose = (reg>>5)&1;
|
|
|
|
for (int i=0; i<side; i++)
|
|
{
|
|
for (int j=0; j<side; j++)
|
|
{
|
|
if (!currentMIPS->vfpuWriteMask[i])
|
|
{
|
|
int index = mtx * 4;
|
|
if (transpose)
|
|
index += ((row+i)&3) + ((col+j)&3)*32;
|
|
else
|
|
index += ((col+j)&3) + ((row+i)&3)*32;
|
|
V(index) = rd[j*4+i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
int GetNumVectorElements(VectorSize sz)
|
|
{
|
|
switch (sz)
|
|
{
|
|
case V_Single: return 1;
|
|
case V_Pair: return 2;
|
|
case V_Triple: return 3;
|
|
case V_Quad: return 4;
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
VectorSize GetHalfVectorSize(VectorSize sz)
|
|
{
|
|
switch (sz)
|
|
{
|
|
case V_Pair: return V_Single;
|
|
case V_Quad: return V_Pair;
|
|
default:
|
|
return V_Single;
|
|
}
|
|
}
|
|
|
|
VectorSize GetVecSize(u32 op)
|
|
{
|
|
int a = (op>>7)&1;
|
|
int b = (op>>15)&1;
|
|
a += (b<<1);
|
|
switch (a)
|
|
{
|
|
case 0: return V_Single;
|
|
case 1: return V_Pair;
|
|
case 2: return V_Triple;
|
|
case 3: return V_Quad;
|
|
default: return V_Quad;
|
|
}
|
|
}
|
|
|
|
MatrixSize GetMtxSize(u32 op)
|
|
{
|
|
int a = (op>>7)&1;
|
|
int b = (op>>15)&1;
|
|
a += (b<<1);
|
|
switch (a)
|
|
{
|
|
case 1: return M_2x2;
|
|
case 2: return M_3x3;
|
|
case 3: return M_4x4;
|
|
default: return M_4x4;
|
|
}
|
|
}
|
|
|
|
int GetMatrixSide(MatrixSize sz)
|
|
{
|
|
switch (sz)
|
|
{
|
|
case M_2x2: return 2;
|
|
case M_3x3: return 3;
|
|
case M_4x4: return 4;
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
const char *GetVectorNotation(int reg, VectorSize size)
|
|
{
|
|
static char hej[4][16];
|
|
static int yo=0;yo++;yo&=3;
|
|
int mtx = (reg>>2)&7;
|
|
int col = reg&3;
|
|
int row = 0;
|
|
int transpose = (reg>>5)&1;
|
|
char c;
|
|
switch (size)
|
|
{
|
|
case V_Single: transpose=0; c='S'; row=(reg>>5)&3; break;
|
|
case V_Pair: c='C'; row=(reg>>5)&2; break;
|
|
case V_Triple: c='C'; row=(reg>>6)&1; break;
|
|
case V_Quad: c='C'; row=(reg>>5)&2; break;
|
|
}
|
|
if (transpose && c == 'C') c='R';
|
|
sprintf(hej[yo],"%c%i%i%i",c,mtx,col,row);
|
|
return hej[yo];
|
|
}
|
|
|
|
const char *GetMatrixNotation(int reg, MatrixSize size)
|
|
{
|
|
static char hej[4][16];
|
|
static int yo=0;yo++;yo&=3;
|
|
int mtx = (reg>>2)&7;
|
|
int col = reg&3;
|
|
int row = 0;
|
|
int transpose = (reg>>5)&1;
|
|
char c;
|
|
switch (size)
|
|
{
|
|
case M_2x2: c='M'; row=(reg>>5)&2; break;
|
|
case M_3x3: c='M'; row=(reg>>6)&1; break;
|
|
case M_4x4: c='M'; row=(reg>>5)&2; break;
|
|
}
|
|
if (transpose && c=='M') c='E';
|
|
sprintf(hej[yo],"%c%i%i%i",c,mtx,col,row);
|
|
return hej[yo];
|
|
}
|
|
|
|
float Float16ToFloat32(unsigned short l)
|
|
{
|
|
union float2int {
|
|
unsigned int i;
|
|
float f;
|
|
} float2int;
|
|
|
|
unsigned short float16 = l;
|
|
unsigned int sign = (float16 >> VFPU_SH_FLOAT16_SIGN) & VFPU_MASK_FLOAT16_SIGN;
|
|
int exponent = (float16 >> VFPU_SH_FLOAT16_EXP) & VFPU_MASK_FLOAT16_EXP;
|
|
unsigned int fraction = float16 & VFPU_MASK_FLOAT16_FRAC;
|
|
|
|
float signf = (sign == 1) ? -1.0f : 1.0f;
|
|
|
|
float f;
|
|
if (exponent == VFPU_FLOAT16_EXP_MAX)
|
|
{
|
|
if (fraction == 0)
|
|
f = std::numeric_limits<float>::infinity(); //(*info->fprintf_func) (info->stream, "%cInf", signchar);
|
|
else
|
|
f = std::numeric_limits<float>::quiet_NaN(); //(*info->fprintf_func) (info->stream, "%cNaN", signchar);
|
|
}
|
|
else if (exponent == 0 && fraction == 0)
|
|
{
|
|
f = 0.0f * signf;
|
|
}
|
|
else
|
|
{
|
|
if (exponent == 0)
|
|
{
|
|
do
|
|
{
|
|
fraction <<= 1;
|
|
exponent--;
|
|
}
|
|
while (!(fraction & (VFPU_MASK_FLOAT16_FRAC + 1)));
|
|
|
|
fraction &= VFPU_MASK_FLOAT16_FRAC;
|
|
}
|
|
|
|
/* Convert to 32-bit single-precision IEEE754. */
|
|
float2int.i = sign << 31;
|
|
float2int.i |= (exponent + 112) << 23;
|
|
float2int.i |= fraction << 13;
|
|
f=float2int.f;
|
|
}
|
|
return f;
|
|
}
|