1230 lines
37 KiB
C++
1230 lines
37 KiB
C++
#include "stdafx.h"
|
|
|
|
unsigned int CRegInfo::m_fpuControl = 0;
|
|
|
|
char *Format_Name[] = {"Unknown","dword","qword","float","double"};
|
|
|
|
CRegInfo::CRegInfo ( void ) :
|
|
m_CycleCount(0),
|
|
m_Stack_TopPos(0),
|
|
m_Fpu_Used(false),
|
|
m_RoundingModel(RoundUnknown)
|
|
{
|
|
m_MIPS_RegState[0] = STATE_CONST_32;
|
|
m_MIPS_RegVal[0].DW = 0;
|
|
m_RegMapLo[0] = x86_Unknown;
|
|
m_RegMapHi[0] = x86_Unknown;
|
|
|
|
for (int i = 1; i < 32; i++ )
|
|
{
|
|
m_MIPS_RegState[i] = STATE_UNKNOWN;
|
|
m_MIPS_RegVal[i].DW = 0;
|
|
m_RegMapLo[i] = x86_Unknown;
|
|
m_RegMapHi[i] = x86_Unknown;
|
|
}
|
|
for (int i = 0, n = sizeof(m_x86reg_MappedTo) / sizeof(m_x86reg_MappedTo[0]); i < n; i++ )
|
|
{
|
|
m_x86reg_MappedTo[i] = NotMapped;
|
|
m_x86reg_Protected[i] = false;
|
|
m_x86reg_MapOrder[i] = 0;
|
|
}
|
|
for (int i = 0, n = sizeof(x86fpu_MappedTo) / sizeof(x86fpu_MappedTo[0]); i < n; i++ )
|
|
{
|
|
x86fpu_MappedTo[i] = -1;
|
|
x86fpu_State[i] = FPU_Unknown;
|
|
x86fpu_StateChanged[i] = false;
|
|
x86fpu_RoundingModel[i] = RoundDefault;
|
|
}
|
|
}
|
|
|
|
CRegInfo::CRegInfo(const CRegInfo& rhs)
|
|
{
|
|
*this = rhs;
|
|
}
|
|
|
|
CRegInfo::~CRegInfo()
|
|
{
|
|
}
|
|
|
|
CRegInfo& CRegInfo::operator=(const CRegInfo& right)
|
|
{
|
|
m_CycleCount = right.m_CycleCount;
|
|
m_Stack_TopPos = right.m_Stack_TopPos;
|
|
m_Fpu_Used = right.m_Fpu_Used;
|
|
m_RoundingModel = right.m_RoundingModel;
|
|
|
|
memcpy(&m_MIPS_RegState,&right.m_MIPS_RegState,sizeof(m_MIPS_RegState));
|
|
memcpy(&m_MIPS_RegVal,&right.m_MIPS_RegVal,sizeof(m_MIPS_RegVal));
|
|
memcpy(&m_RegMapLo,&right.m_RegMapLo,sizeof(m_RegMapLo));
|
|
memcpy(&m_RegMapHi,&right.m_RegMapHi,sizeof(m_RegMapHi));
|
|
memcpy(&m_x86reg_MappedTo,&right.m_x86reg_MappedTo,sizeof(m_x86reg_MappedTo));
|
|
memcpy(&m_x86reg_Protected,&right.m_x86reg_Protected,sizeof(m_x86reg_Protected));
|
|
memcpy(&m_x86reg_MapOrder,&right.m_x86reg_MapOrder,sizeof(m_x86reg_MapOrder));
|
|
|
|
memcpy(&x86fpu_MappedTo,&right.x86fpu_MappedTo,sizeof(x86fpu_MappedTo));
|
|
memcpy(&x86fpu_State,&right.x86fpu_State,sizeof(x86fpu_State));
|
|
memcpy(&x86fpu_StateChanged,&right.x86fpu_StateChanged,sizeof(x86fpu_StateChanged));
|
|
memcpy(&x86fpu_RoundingModel,&right.x86fpu_RoundingModel,sizeof(x86fpu_RoundingModel));
|
|
|
|
#ifdef _DEBUG
|
|
if (*this != right)
|
|
{
|
|
g_Notify->BreakPoint(__FILE__,__LINE__);
|
|
}
|
|
#endif
|
|
return *this;
|
|
}
|
|
|
|
bool CRegInfo::operator==(const CRegInfo& right) const
|
|
{
|
|
int count;
|
|
|
|
for (count = 0; count < 32; count ++ ) {
|
|
if (m_MIPS_RegState[count] != right.m_MIPS_RegState[count])
|
|
{
|
|
return false;
|
|
}
|
|
if (m_MIPS_RegState[count] == STATE_UNKNOWN)
|
|
{
|
|
continue;
|
|
}
|
|
if (m_MIPS_RegVal[count].DW != right.m_MIPS_RegVal[count].DW)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
for (count = 0; count < 10; count ++ ) {
|
|
if (m_x86reg_MappedTo[count] != right.m_x86reg_MappedTo[count]) { return false; }
|
|
if (m_x86reg_Protected[count] != right.m_x86reg_Protected[count]) { return false; }
|
|
if (m_x86reg_MapOrder[count] != right.m_x86reg_MapOrder[count]) { return false; }
|
|
}
|
|
if (m_CycleCount != right.m_CycleCount) { return false; }
|
|
if (m_Stack_TopPos != right.m_Stack_TopPos) { return false; }
|
|
|
|
for (count = 0; count < 8; count ++ ) {
|
|
if (x86fpu_MappedTo[count] != right.x86fpu_MappedTo[count]) { return false; }
|
|
if (x86fpu_State[count] != right.x86fpu_State[count]) { return false; }
|
|
if (x86fpu_RoundingModel[count] != right.x86fpu_RoundingModel[count]) { return false; }
|
|
}
|
|
if (m_Fpu_Used != right.m_Fpu_Used) { return false; }
|
|
if (GetRoundingModel() != right.GetRoundingModel()) { return false; }
|
|
return true;
|
|
}
|
|
|
|
bool CRegInfo::operator!=(const CRegInfo& right) const
|
|
{
|
|
return !(right == *this);
|
|
}
|
|
|
|
CRegInfo::REG_STATE CRegInfo::ConstantsType (__int64 Value)
|
|
{
|
|
if (((Value >> 32) == -1) && ((Value & 0x80000000) != 0)) { return STATE_CONST_32; }
|
|
if (((Value >> 32) == 0) && ((Value & 0x80000000) == 0)) { return STATE_CONST_32; }
|
|
return STATE_CONST_64;
|
|
}
|
|
|
|
void CRegInfo::FixRoundModel(FPU_ROUND RoundMethod )
|
|
{
|
|
if (GetRoundingModel() == RoundMethod)
|
|
{
|
|
return;
|
|
}
|
|
CPU_Message(" FixRoundModel: CurrentRoundingModel: %s targetRoundModel: %s",RoundingModelName(GetRoundingModel()),RoundingModelName(RoundMethod));
|
|
|
|
m_fpuControl = 0;
|
|
fpuStoreControl(&m_fpuControl, "m_fpuControl");
|
|
x86Reg reg = Map_TempReg(x86_Any,-1,FALSE);
|
|
MoveVariableToX86reg(&m_fpuControl, "m_fpuControl", reg);
|
|
AndConstToX86Reg(reg, 0xF3FF);
|
|
|
|
if (RoundMethod == RoundDefault)
|
|
{
|
|
x86Reg RoundReg = Map_TempReg(x86_Any,-1,FALSE);
|
|
MoveVariableToX86reg(&g_Reg->m_RoundingModel,"m_RoundingModel", RoundReg);
|
|
ShiftLeftSignImmed(RoundReg,2);
|
|
OrX86RegToX86Reg(reg,RoundReg);
|
|
SetX86Protected(RoundReg,false);
|
|
} else {
|
|
switch (RoundMethod) {
|
|
case RoundTruncate: OrConstToX86Reg(0x0C00, reg); break;
|
|
case RoundNearest: /*OrConstToX86Reg(0x0000, reg);*/ break;
|
|
case RoundDown: OrConstToX86Reg(0x0400, reg); break;
|
|
case RoundUp: OrConstToX86Reg(0x0800, reg); break;
|
|
default:
|
|
g_Notify->DisplayError("Unknown Rounding model");
|
|
}
|
|
}
|
|
MoveX86regToVariable(reg, &m_fpuControl, "m_fpuControl");
|
|
SetX86Protected(reg,false);
|
|
fpuLoadControl(&m_fpuControl, "m_fpuControl");
|
|
SetRoundingModel(RoundMethod);
|
|
}
|
|
|
|
void CRegInfo::ChangeFPURegFormat (int Reg, FPU_STATE OldFormat, FPU_STATE NewFormat, FPU_ROUND RoundingModel)
|
|
{
|
|
for (DWORD i = 0; i < 8; i++)
|
|
{
|
|
if (x86fpu_MappedTo[i] != Reg)
|
|
{
|
|
continue;
|
|
}
|
|
if (x86fpu_State[i] != OldFormat || x86fpu_StateChanged[i])
|
|
{
|
|
UnMap_FPR(Reg,TRUE);
|
|
Load_FPR_ToTop(Reg,Reg,OldFormat);
|
|
} else {
|
|
CPU_Message(" regcache: Changed format of ST(%d) from %s to %s", (i - StackTopPos() + 8) & 7,Format_Name[OldFormat],Format_Name[NewFormat]);
|
|
}
|
|
FpuRoundingModel(i) = RoundingModel;
|
|
x86fpu_State[i] = NewFormat;
|
|
x86fpu_StateChanged[i] = true;
|
|
return;
|
|
}
|
|
|
|
#ifndef EXTERNAL_RELEASE
|
|
g_Notify->DisplayError("ChangeFormat: Register not on stack!!");
|
|
#endif
|
|
}
|
|
|
|
void CRegInfo::Load_FPR_ToTop ( int Reg, int RegToLoad, FPU_STATE Format)
|
|
{
|
|
if (GetRoundingModel() != RoundDefault)
|
|
{
|
|
FixRoundModel(RoundDefault);
|
|
}
|
|
CPU_Message("CurrentRoundingModel: %s FpuRoundingModel(StackTopPos()): %s",RoundingModelName(GetRoundingModel()),RoundingModelName(FpuRoundingModel(StackTopPos())));
|
|
int i;
|
|
|
|
if (RegToLoad < 0) { g_Notify->DisplayError("Load_FPR_ToTop\nRegToLoad < 0 ???"); return; }
|
|
if (Reg < 0) { g_Notify->DisplayError("Load_FPR_ToTop\nReg < 0 ???"); return; }
|
|
|
|
if (Format == FPU_Double || Format == FPU_Qword) {
|
|
UnMap_FPR(Reg + 1,TRUE);
|
|
UnMap_FPR(RegToLoad + 1,TRUE);
|
|
} else {
|
|
if ((Reg & 1) != 0) {
|
|
for (i = 0; i < 8; i++) {
|
|
if (x86fpu_MappedTo[i] == (Reg - 1)) {
|
|
if (x86fpu_State[i] == FPU_Double || x86fpu_State[i] == FPU_Qword) {
|
|
UnMap_FPR(Reg,TRUE);
|
|
}
|
|
i = 8;
|
|
}
|
|
}
|
|
}
|
|
if ((RegToLoad & 1) != 0) {
|
|
for (i = 0; i < 8; i++) {
|
|
if (x86fpu_MappedTo[i] == (RegToLoad - 1)) {
|
|
if (x86fpu_State[i] == FPU_Double || x86fpu_State[i] == FPU_Qword) {
|
|
UnMap_FPR(RegToLoad,TRUE);
|
|
}
|
|
i = 8;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Reg == RegToLoad) {
|
|
//if different format then unmap original reg from stack
|
|
for (i = 0; i < 8; i++) {
|
|
if (x86fpu_MappedTo[i] != Reg)
|
|
{
|
|
continue;
|
|
}
|
|
if (x86fpu_State[i] != Format) {
|
|
UnMap_FPR(Reg,TRUE);
|
|
}
|
|
break;
|
|
}
|
|
} else {
|
|
//if different format then unmap original reg from stack
|
|
for (i = 0; i < 8; i++)
|
|
{
|
|
if (x86fpu_MappedTo[i] != Reg)
|
|
{
|
|
continue;
|
|
}
|
|
UnMap_FPR(Reg,x86fpu_State[i] != Format);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (RegInStack(RegToLoad,Format)) {
|
|
if (Reg != RegToLoad) {
|
|
if (x86fpu_MappedTo[(StackTopPos() - 1) & 7] != RegToLoad) {
|
|
UnMap_FPR(x86fpu_MappedTo[(StackTopPos() - 1) & 7],TRUE);
|
|
CPU_Message(" regcache: allocate ST(0) to %s", CRegName::FPR[Reg]);
|
|
fpuLoadReg(&StackTopPos(),StackPosition(RegToLoad));
|
|
FpuRoundingModel(StackTopPos()) = RoundDefault;
|
|
x86fpu_MappedTo[StackTopPos()] = Reg;
|
|
x86fpu_State[StackTopPos()] = Format;
|
|
x86fpu_StateChanged[StackTopPos()] = false;
|
|
} else {
|
|
UnMap_FPR(x86fpu_MappedTo[(StackTopPos() - 1) & 7],TRUE);
|
|
Load_FPR_ToTop (Reg, RegToLoad, Format);
|
|
}
|
|
} else {
|
|
x86FpuValues RegPos = x86_ST_Unknown;
|
|
for (DWORD i = 0; i < 8; i++) {
|
|
if (x86fpu_MappedTo[i] == Reg) {
|
|
RegPos = (x86FpuValues)i;
|
|
i = 8;
|
|
}
|
|
}
|
|
|
|
if (RegPos == StackTopPos()) {
|
|
return;
|
|
}
|
|
x86FpuValues StackPos = StackPosition(Reg);
|
|
|
|
FpuRoundingModel(RegPos) = FpuRoundingModel(StackTopPos());
|
|
x86fpu_MappedTo[RegPos] = x86fpu_MappedTo[StackTopPos()];
|
|
x86fpu_State[RegPos] = x86fpu_State[StackTopPos()];
|
|
x86fpu_StateChanged[RegPos] = x86fpu_StateChanged[StackTopPos()];
|
|
CPU_Message(" regcache: allocate ST(%d) to %s", StackPos,CRegName::FPR[x86fpu_MappedTo[RegPos]]);
|
|
CPU_Message(" regcache: allocate ST(0) to %s", CRegName::FPR[Reg]);
|
|
|
|
fpuExchange(StackPos);
|
|
|
|
FpuRoundingModel(StackTopPos()) = RoundDefault;
|
|
x86fpu_MappedTo[StackTopPos()] = Reg;
|
|
x86fpu_State[StackTopPos()] = Format;
|
|
x86fpu_StateChanged[StackTopPos()] = false;
|
|
}
|
|
} else {
|
|
char Name[50];
|
|
x86Reg TempReg;
|
|
|
|
UnMap_FPR(x86fpu_MappedTo[(StackTopPos() - 1) & 7],TRUE);
|
|
for (i = 0; i < 8; i++) {
|
|
if (x86fpu_MappedTo[i] == RegToLoad) {
|
|
UnMap_FPR(RegToLoad,TRUE);
|
|
i = 8;
|
|
}
|
|
}
|
|
CPU_Message(" regcache: allocate ST(0) to %s", CRegName::FPR[Reg]);
|
|
TempReg = Map_TempReg(x86_Any,-1,FALSE);
|
|
switch (Format) {
|
|
case FPU_Dword:
|
|
sprintf(Name,"m_FPR_S[%d]",RegToLoad);
|
|
MoveVariableToX86reg(&g_Reg->m_FPR_S[RegToLoad],Name,TempReg);
|
|
fpuLoadIntegerDwordFromX86Reg(&StackTopPos(),TempReg);
|
|
break;
|
|
case FPU_Qword:
|
|
sprintf(Name,"m_FPR_D[%d]",RegToLoad);
|
|
MoveVariableToX86reg(&g_Reg->m_FPR_D[RegToLoad],Name,TempReg);
|
|
fpuLoadIntegerQwordFromX86Reg(&StackTopPos(),TempReg);
|
|
break;
|
|
case FPU_Float:
|
|
sprintf(Name,"m_FPR_S[%d]",RegToLoad);
|
|
MoveVariableToX86reg(&g_Reg->m_FPR_S[RegToLoad],Name,TempReg);
|
|
fpuLoadDwordFromX86Reg(&StackTopPos(),TempReg);
|
|
break;
|
|
case FPU_Double:
|
|
sprintf(Name,"m_FPR_D[%d]",RegToLoad);
|
|
MoveVariableToX86reg(&g_Reg->m_FPR_D[RegToLoad],Name,TempReg);
|
|
fpuLoadQwordFromX86Reg(&StackTopPos(),TempReg);
|
|
break;
|
|
#ifndef EXTERNAL_RELEASE
|
|
default:
|
|
g_Notify->DisplayError("Load_FPR_ToTop\nUnkown format to load %d",Format);
|
|
#endif
|
|
}
|
|
SetX86Protected(TempReg,FALSE);
|
|
FpuRoundingModel(StackTopPos()) = RoundDefault;
|
|
x86fpu_MappedTo[StackTopPos()] = Reg;
|
|
x86fpu_State[StackTopPos()] = Format;
|
|
x86fpu_StateChanged[StackTopPos()] = false;
|
|
}
|
|
}
|
|
|
|
CRegInfo::x86FpuValues CRegInfo::StackPosition (int Reg)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
if (x86fpu_MappedTo[i] == Reg) {
|
|
return (x86FpuValues)((i - StackTopPos()) & 7);
|
|
}
|
|
}
|
|
return x86_ST_Unknown;
|
|
}
|
|
|
|
CX86Ops::x86Reg CRegInfo::FreeX86Reg ( void )
|
|
{
|
|
if (GetX86Mapped(x86_EDI) == NotMapped && !GetX86Protected(x86_EDI)) { return x86_EDI; }
|
|
if (GetX86Mapped(x86_ESI) == NotMapped && !GetX86Protected(x86_ESI)) { return x86_ESI; }
|
|
if (GetX86Mapped(x86_EBX) == NotMapped && !GetX86Protected(x86_EBX)) { return x86_EBX; }
|
|
if (GetX86Mapped(x86_EAX) == NotMapped && !GetX86Protected(x86_EAX)) { return x86_EAX; }
|
|
if (GetX86Mapped(x86_EDX) == NotMapped && !GetX86Protected(x86_EDX)) { return x86_EDX; }
|
|
if (GetX86Mapped(x86_ECX) == NotMapped && !GetX86Protected(x86_ECX)) { return x86_ECX; }
|
|
|
|
x86Reg Reg = UnMap_TempReg();
|
|
if (Reg != x86_Unknown) { return Reg; }
|
|
|
|
int count, MapCount[10];
|
|
x86Reg MapReg[10];
|
|
|
|
for (count = 0; count < 10; count ++)
|
|
{
|
|
MapCount[count] = GetX86MapOrder((x86Reg)count);
|
|
MapReg[count] = (x86Reg)count;
|
|
}
|
|
for (count = 0; count < 10; count ++) {
|
|
int i;
|
|
|
|
for (i = 0; i < 9; i ++) {
|
|
x86Reg tempReg;
|
|
DWORD temp;
|
|
|
|
if (MapCount[i] < MapCount[i+1]) {
|
|
temp = MapCount[i];
|
|
MapCount[i] = MapCount[i+1];
|
|
MapCount[i+1] = temp;
|
|
tempReg = MapReg[i];
|
|
MapReg[i] = MapReg[i+1];
|
|
MapReg[i+1] = tempReg;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
x86Reg StackReg = x86_Unknown;
|
|
for (count = 0; count < 10; count ++)
|
|
{
|
|
if (MapCount[count] > 0 && GetX86Mapped(MapReg[count]) != Stack_Mapped)
|
|
{
|
|
if (UnMap_X86reg((x86Reg)MapReg[count]))
|
|
{
|
|
return (x86Reg)MapReg[count];
|
|
}
|
|
}
|
|
if (GetX86Mapped(MapReg[count]) == Stack_Mapped) { StackReg = MapReg[count]; }
|
|
}
|
|
if (StackReg != x86_Unknown) {
|
|
UnMap_X86reg(StackReg);
|
|
return StackReg;
|
|
}
|
|
|
|
return x86_Unknown;
|
|
}
|
|
|
|
CX86Ops::x86Reg CRegInfo::Free8BitX86Reg ( void )
|
|
{
|
|
|
|
if (GetX86Mapped(x86_EBX) == NotMapped && !GetX86Protected(x86_EBX)) {return x86_EBX; }
|
|
if (GetX86Mapped(x86_EAX) == NotMapped && !GetX86Protected(x86_EAX)) {return x86_EAX; }
|
|
if (GetX86Mapped(x86_EDX) == NotMapped && !GetX86Protected(x86_EDX)) {return x86_EDX; }
|
|
if (GetX86Mapped(x86_ECX) == NotMapped && !GetX86Protected(x86_ECX)) {return x86_ECX; }
|
|
|
|
|
|
x86Reg Reg = UnMap_8BitTempReg();
|
|
if (Reg > 0) { return Reg; }
|
|
|
|
int count, MapCount[10], MapReg[10];
|
|
for (count = 0; count < 10; count ++) {
|
|
MapCount[count] = GetX86MapOrder((x86Reg)count);
|
|
MapReg[count] = count;
|
|
}
|
|
for (count = 0; count < 10; count ++) {
|
|
int i;
|
|
|
|
for (i = 0; i < 9; i ++) {
|
|
int temp;
|
|
|
|
if (MapCount[i] < MapCount[i+1]) {
|
|
temp = MapCount[i];
|
|
MapCount[i] = MapCount[i+1];
|
|
MapCount[i+1] = temp;
|
|
temp = MapReg[i];
|
|
MapReg[i] = MapReg[i+1];
|
|
MapReg[i+1] = temp;
|
|
}
|
|
}
|
|
|
|
}
|
|
for (count = 0; count < 10; count ++) {
|
|
if (MapCount[count] > 0) {
|
|
if (!Is8BitReg((x86Reg)count)) { continue; }
|
|
if (UnMap_X86reg((x86Reg)count)) {
|
|
return (x86Reg)count;
|
|
}
|
|
}
|
|
}
|
|
return x86_Unknown;
|
|
}
|
|
|
|
CX86Ops::x86Reg CRegInfo::UnMap_8BitTempReg (void )
|
|
{
|
|
int count;
|
|
|
|
for (count = 0; count < 10; count ++) {
|
|
if (!Is8BitReg((x86Reg)count)) { continue; }
|
|
if (GetMipsRegState((x86Reg)count) == Temp_Mapped) {
|
|
if (GetX86Protected((x86Reg)count) == FALSE) {
|
|
CPU_Message(" regcache: unallocate %s from temp storage",x86_Name((x86Reg)count));
|
|
SetX86Mapped((x86Reg)count, CRegInfo::NotMapped);
|
|
return (x86Reg)count;
|
|
}
|
|
}
|
|
}
|
|
return x86_Unknown;
|
|
}
|
|
|
|
CRegInfo::x86Reg CRegInfo::Get_MemoryStack ( void ) const
|
|
{
|
|
for (int i = 0, n = sizeof(x86_Registers)/ sizeof(x86_Registers[0]); i < n; i++)
|
|
{
|
|
if (GetX86Mapped(x86_Registers[i]) == Stack_Mapped)
|
|
{
|
|
return x86_Registers[i];
|
|
}
|
|
}
|
|
return x86_Unknown;
|
|
}
|
|
|
|
CRegInfo::x86Reg CRegInfo::Map_MemoryStack ( x86Reg Reg, bool bMapRegister, bool LoadValue)
|
|
{
|
|
x86Reg CurrentMap = Get_MemoryStack();
|
|
if (!bMapRegister)
|
|
{
|
|
//if not mapping then just return what the current mapping is
|
|
return CurrentMap;
|
|
}
|
|
|
|
if (CurrentMap != x86_Unknown && CurrentMap == Reg)
|
|
{
|
|
//already mapped to correct reg
|
|
return CurrentMap;
|
|
}
|
|
// map a register
|
|
if (Reg == x86_Any)
|
|
{
|
|
if (CurrentMap != x86_Unknown)
|
|
{
|
|
return CurrentMap;
|
|
}
|
|
Reg = FreeX86Reg();
|
|
if (Reg == x86_Unknown)
|
|
{
|
|
g_Notify->DisplayError("Map_MemoryStack\n\nOut of registers");
|
|
g_Notify->BreakPoint(__FILE__,__LINE__);
|
|
}
|
|
SetX86Mapped(Reg,CRegInfo::Stack_Mapped);
|
|
CPU_Message(" regcache: allocate %s as Memory Stack",x86_Name(Reg));
|
|
if (LoadValue)
|
|
{
|
|
MoveVariableToX86reg(&g_Recompiler->MemoryStackPos(),"MemoryStack",Reg);
|
|
}
|
|
return Reg;
|
|
}
|
|
|
|
//move to a register/allocate register
|
|
UnMap_X86reg(Reg);
|
|
if (CurrentMap != x86_Unknown)
|
|
{
|
|
CPU_Message(" regcache: change allocation of Memory Stack from %s to %s",x86_Name(CurrentMap),x86_Name(Reg));
|
|
SetX86Mapped(Reg, CRegInfo::Stack_Mapped);
|
|
SetX86Mapped(CurrentMap,CRegInfo::NotMapped);
|
|
MoveX86RegToX86Reg(CurrentMap,Reg);
|
|
} else {
|
|
SetX86Mapped(Reg,CRegInfo::Stack_Mapped);
|
|
CPU_Message(" regcache: allocate %s as Memory Stack",x86_Name(Reg));
|
|
if (LoadValue)
|
|
{
|
|
MoveVariableToX86reg(&g_Recompiler->MemoryStackPos(),"MemoryStack",Reg);
|
|
}
|
|
}
|
|
return Reg;
|
|
}
|
|
|
|
void CRegInfo::Map_GPR_32bit (int MipsReg, bool SignValue, int MipsRegToLoad)
|
|
{
|
|
int count;
|
|
|
|
x86Reg Reg;
|
|
if (MipsReg == 0)
|
|
{
|
|
g_Notify->BreakPoint(__FILE__,__LINE__);
|
|
return;
|
|
}
|
|
|
|
if (IsUnknown(MipsReg) || IsConst(MipsReg))
|
|
{
|
|
Reg = FreeX86Reg();
|
|
if (Reg < 0) {
|
|
#ifndef EXTERNAL_RELEASE
|
|
g_Notify->DisplayError("Map_GPR_32bit\n\nOut of registers");
|
|
#endif
|
|
g_Notify->BreakPoint(__FILE__,__LINE__);
|
|
return;
|
|
}
|
|
CPU_Message(" regcache: allocate %s to %s",x86_Name(Reg),CRegName::GPR[MipsReg]);
|
|
} else {
|
|
if (Is64Bit(MipsReg))
|
|
{
|
|
CPU_Message(" regcache: unallocate %s from high 32bit of %s",x86_Name(GetMipsRegMapHi(MipsReg)),CRegName::GPR_Hi[MipsReg]);
|
|
SetX86MapOrder(GetMipsRegMapHi(MipsReg),0);
|
|
SetX86Mapped(GetMipsRegMapHi(MipsReg),NotMapped);
|
|
SetX86Protected(GetMipsRegMapHi(MipsReg),FALSE);
|
|
SetMipsRegHi(MipsReg,0);
|
|
}
|
|
Reg = GetMipsRegMapLo(MipsReg);
|
|
}
|
|
for (count = 0; count < 10; count ++)
|
|
{
|
|
DWORD Count = GetX86MapOrder((x86Reg)count);
|
|
if ( Count > 0)
|
|
{
|
|
SetX86MapOrder((x86Reg)count,Count + 1);
|
|
}
|
|
}
|
|
SetX86MapOrder(Reg,1);
|
|
|
|
if (MipsRegToLoad > 0)
|
|
{
|
|
if (IsUnknown(MipsRegToLoad))
|
|
{
|
|
MoveVariableToX86reg(&_GPR[MipsRegToLoad].UW[0],CRegName::GPR_Lo[MipsRegToLoad],Reg);
|
|
} else if (IsMapped(MipsRegToLoad)) {
|
|
if (MipsReg != MipsRegToLoad)
|
|
{
|
|
MoveX86RegToX86Reg(GetMipsRegMapLo(MipsRegToLoad),Reg);
|
|
}
|
|
} else {
|
|
MoveConstToX86reg(GetMipsRegLo(MipsRegToLoad),Reg);
|
|
}
|
|
} else if (MipsRegToLoad == 0) {
|
|
XorX86RegToX86Reg(Reg,Reg);
|
|
}
|
|
SetX86Mapped(Reg,GPR_Mapped);
|
|
SetX86Protected(Reg,TRUE);
|
|
SetMipsRegMapLo(MipsReg,Reg);
|
|
SetMipsRegState(MipsReg,SignValue ? STATE_MAPPED_32_SIGN : STATE_MAPPED_32_ZERO);
|
|
}
|
|
|
|
void CRegInfo::Map_GPR_64bit ( int MipsReg, int MipsRegToLoad)
|
|
{
|
|
x86Reg x86Hi, x86lo;
|
|
int count;
|
|
|
|
if (MipsReg == 0) {
|
|
#ifndef EXTERNAL_RELEASE
|
|
g_Notify->DisplayError("Map_GPR_32bit\n\nWhy are you trying to map reg 0");
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
ProtectGPR(MipsReg);
|
|
if (IsUnknown(MipsReg) || IsConst(MipsReg)) {
|
|
x86Hi = FreeX86Reg();
|
|
if (x86Hi < 0) { g_Notify->DisplayError("Map_GPR_64bit\n\nOut of registers"); return; }
|
|
SetX86Protected(x86Hi,TRUE);
|
|
|
|
x86lo = FreeX86Reg();
|
|
if (x86lo < 0) { g_Notify->DisplayError("Map_GPR_64bit\n\nOut of registers"); return; }
|
|
SetX86Protected(x86lo,TRUE);
|
|
|
|
CPU_Message(" regcache: allocate %s to hi word of %s",x86_Name(x86Hi),CRegName::GPR[MipsReg]);
|
|
CPU_Message(" regcache: allocate %s to low word of %s",x86_Name(x86lo),CRegName::GPR[MipsReg]);
|
|
} else {
|
|
x86lo = GetMipsRegMapLo(MipsReg);
|
|
if (Is32Bit(MipsReg)) {
|
|
SetX86Protected(x86lo,TRUE);
|
|
x86Hi = FreeX86Reg();
|
|
if (x86Hi == x86_Unknown)
|
|
{
|
|
g_Notify->BreakPoint(__FILE__,__LINE__);
|
|
return;
|
|
}
|
|
SetX86Protected(x86Hi,TRUE);
|
|
|
|
CPU_Message(" regcache: allocate %s to hi word of %s",x86_Name(x86Hi),CRegName::GPR[MipsReg]);
|
|
} else {
|
|
x86Hi = GetMipsRegMapHi(MipsReg);
|
|
}
|
|
}
|
|
|
|
for (count = 0; count < 10; count ++)
|
|
{
|
|
int MapOrder = GetX86MapOrder((x86Reg)count);
|
|
if (MapOrder > 0)
|
|
{
|
|
SetX86MapOrder((x86Reg)count,MapOrder + 1);
|
|
}
|
|
}
|
|
|
|
SetX86MapOrder(x86Hi,1);
|
|
SetX86MapOrder(x86lo,1);
|
|
if (MipsRegToLoad > 0) {
|
|
if (IsUnknown(MipsRegToLoad)) {
|
|
MoveVariableToX86reg(&_GPR[MipsRegToLoad].UW[1],CRegName::GPR_Hi[MipsRegToLoad],x86Hi);
|
|
MoveVariableToX86reg(&_GPR[MipsRegToLoad].UW[0],CRegName::GPR_Lo[MipsRegToLoad],x86lo);
|
|
} else if (IsMapped(MipsRegToLoad)) {
|
|
if (Is32Bit(MipsRegToLoad)) {
|
|
if (IsSigned(MipsRegToLoad)) {
|
|
MoveX86RegToX86Reg(GetMipsRegMapLo(MipsRegToLoad),x86Hi);
|
|
ShiftRightSignImmed(x86Hi,31);
|
|
} else {
|
|
XorX86RegToX86Reg(x86Hi,x86Hi);
|
|
}
|
|
if (MipsReg != MipsRegToLoad) {
|
|
MoveX86RegToX86Reg(GetMipsRegMapLo(MipsRegToLoad),x86lo);
|
|
}
|
|
} else {
|
|
if (MipsReg != MipsRegToLoad) {
|
|
MoveX86RegToX86Reg(GetMipsRegMapHi(MipsRegToLoad),x86Hi);
|
|
MoveX86RegToX86Reg(GetMipsRegMapLo(MipsRegToLoad),x86lo);
|
|
}
|
|
}
|
|
} else {
|
|
CPU_Message("Map_GPR_64bit 11");
|
|
if (Is32Bit(MipsRegToLoad)) {
|
|
if (IsSigned(MipsRegToLoad)) {
|
|
MoveConstToX86reg(GetMipsRegLo_S(MipsRegToLoad) >> 31,x86Hi);
|
|
} else {
|
|
MoveConstToX86reg(0,x86Hi);
|
|
}
|
|
} else {
|
|
MoveConstToX86reg(GetMipsRegHi(MipsRegToLoad),x86Hi);
|
|
}
|
|
MoveConstToX86reg(GetMipsRegLo(MipsRegToLoad),x86lo);
|
|
}
|
|
} else if (MipsRegToLoad == 0) {
|
|
XorX86RegToX86Reg(x86Hi,x86Hi);
|
|
XorX86RegToX86Reg(x86lo,x86lo);
|
|
}
|
|
SetX86Mapped(x86Hi,GPR_Mapped);
|
|
SetX86Mapped(x86lo,GPR_Mapped);
|
|
SetMipsRegMapHi(MipsReg,x86Hi);
|
|
SetMipsRegMapLo(MipsReg,x86lo);
|
|
SetMipsRegState(MipsReg,STATE_MAPPED_64);
|
|
}
|
|
|
|
CX86Ops::x86Reg CRegInfo::Map_TempReg (CX86Ops::x86Reg Reg, int MipsReg, BOOL LoadHiWord)
|
|
{
|
|
int count;
|
|
|
|
if (Reg == x86_Any)
|
|
{
|
|
if (GetX86Mapped(x86_EAX) == Temp_Mapped && !GetX86Protected(x86_EAX)) { Reg = x86_EAX; }
|
|
else if (GetX86Mapped(x86_EBX) == Temp_Mapped && !GetX86Protected(x86_EBX)) { Reg = x86_EBX; }
|
|
else if (GetX86Mapped(x86_ECX) == Temp_Mapped && !GetX86Protected(x86_ECX)) { Reg = x86_ECX; }
|
|
else if (GetX86Mapped(x86_EDX) == Temp_Mapped && !GetX86Protected(x86_EDX)) { Reg = x86_EDX; }
|
|
else if (GetX86Mapped(x86_ESI) == Temp_Mapped && !GetX86Protected(x86_ESI)) { Reg = x86_ESI; }
|
|
else if (GetX86Mapped(x86_EDI) == Temp_Mapped && !GetX86Protected(x86_EDI)) { Reg = x86_EDI; }
|
|
else if (GetX86Mapped(x86_EBP) == Temp_Mapped && !GetX86Protected(x86_EBP)) { Reg = x86_EBP; }
|
|
else if (GetX86Mapped(x86_ESP) == Temp_Mapped && !GetX86Protected(x86_ESP)) { Reg = x86_ESP; }
|
|
|
|
if (Reg == x86_Any) {
|
|
Reg = FreeX86Reg();
|
|
if (Reg == x86_Unknown)
|
|
{
|
|
WriteTrace(TraceError,"CRegInfo::Map_TempReg: Failed to find a free register");
|
|
g_Notify->BreakPoint(__FILE__,__LINE__);
|
|
return x86_Unknown;
|
|
}
|
|
}
|
|
}
|
|
else if (Reg == x86_Any8Bit)
|
|
{
|
|
if (GetX86Mapped(x86_EAX) == Temp_Mapped && !GetX86Protected(x86_EAX)) { Reg = x86_EAX; }
|
|
else if (GetX86Mapped(x86_EBX) == Temp_Mapped && !GetX86Protected(x86_EBX)) { Reg = x86_EBX; }
|
|
else if (GetX86Mapped(x86_ECX) == Temp_Mapped && !GetX86Protected(x86_ECX)) { Reg = x86_ECX; }
|
|
else if (GetX86Mapped(x86_EDX) == Temp_Mapped && !GetX86Protected(x86_EDX)) { Reg = x86_EDX; }
|
|
|
|
if (Reg == x86_Any8Bit)
|
|
{
|
|
Reg = Free8BitX86Reg();
|
|
if (Reg < 0) {
|
|
WriteTrace(TraceError,"CRegInfo::Map_TempReg: Failed to find a free 8 bit register");
|
|
g_Notify->BreakPoint(__FILE__,__LINE__);
|
|
return x86_Unknown;
|
|
}
|
|
}
|
|
} else if (GetX86Mapped(Reg) == GPR_Mapped) {
|
|
if (GetX86Protected(Reg))
|
|
{
|
|
WriteTrace(TraceError,"CRegInfo::Map_TempReg: Register is protected");
|
|
g_Notify->BreakPoint(__FILE__,__LINE__);
|
|
return x86_Unknown;
|
|
}
|
|
|
|
SetX86Protected(Reg,true);
|
|
x86Reg NewReg = FreeX86Reg();
|
|
for (count = 1; count < 32; count ++)
|
|
{
|
|
if (!IsMapped(count))
|
|
{
|
|
continue;
|
|
}
|
|
if (GetMipsRegMapLo(count) == Reg)
|
|
{
|
|
if (NewReg == x86_Unknown)
|
|
{
|
|
UnMap_GPR(count,TRUE);
|
|
break;
|
|
}
|
|
CPU_Message(" regcache: change allocation of %s from %s to %s",CRegName::GPR[count],x86_Name(Reg),x86_Name(NewReg));
|
|
SetX86Mapped(NewReg,GPR_Mapped);
|
|
SetX86MapOrder(NewReg,GetX86MapOrder(Reg));
|
|
SetMipsRegMapLo(count,NewReg);
|
|
MoveX86RegToX86Reg(Reg,NewReg);
|
|
if (MipsReg == count && LoadHiWord == FALSE) { MipsReg = -1; }
|
|
break;
|
|
}
|
|
if (Is64Bit(count) && GetMipsRegMapHi(count) == Reg)
|
|
{
|
|
if (NewReg == x86_Unknown)
|
|
{
|
|
UnMap_GPR(count,TRUE);
|
|
break;
|
|
}
|
|
CPU_Message(" regcache: change allocation of %s from %s to %s",CRegName::GPR_Hi[count],x86_Name(Reg),x86_Name(NewReg));
|
|
SetX86Mapped(NewReg,GPR_Mapped);
|
|
SetX86MapOrder(NewReg,GetX86MapOrder(Reg));
|
|
SetMipsRegMapHi(count,NewReg);
|
|
MoveX86RegToX86Reg(Reg,NewReg);
|
|
if (MipsReg == count && LoadHiWord == TRUE) { MipsReg = -1; }
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if (GetX86Mapped(Reg) == Stack_Mapped)
|
|
{
|
|
UnMap_X86reg(Reg);
|
|
}
|
|
CPU_Message(" regcache: allocate %s as temp storage",x86_Name(Reg));
|
|
|
|
if (MipsReg >= 0) {
|
|
if (LoadHiWord) {
|
|
if (IsUnknown(MipsReg))
|
|
{
|
|
MoveVariableToX86reg(&_GPR[MipsReg].UW[1],CRegName::GPR_Hi[MipsReg],Reg);
|
|
}
|
|
else if (IsMapped(MipsReg))
|
|
{
|
|
if (Is64Bit(MipsReg)) {
|
|
MoveX86RegToX86Reg(GetMipsRegMapHi(MipsReg),Reg);
|
|
} else if (IsSigned(MipsReg)){
|
|
MoveX86RegToX86Reg(GetMipsRegMapLo(MipsReg),Reg);
|
|
ShiftRightSignImmed(Reg,31);
|
|
} else {
|
|
MoveConstToX86reg(0,Reg);
|
|
}
|
|
} else {
|
|
if (Is64Bit(MipsReg))
|
|
{
|
|
MoveConstToX86reg(GetMipsRegHi(MipsReg),Reg);
|
|
} else {
|
|
MoveConstToX86reg(GetMipsRegLo_S(MipsReg) >> 31,Reg);
|
|
}
|
|
}
|
|
} else {
|
|
if (IsUnknown(MipsReg)) {
|
|
MoveVariableToX86reg(&_GPR[MipsReg].UW[0],CRegName::GPR_Lo[MipsReg],Reg);
|
|
} else if (IsMapped(MipsReg)) {
|
|
MoveX86RegToX86Reg(GetMipsRegMapLo(MipsReg),Reg);
|
|
} else {
|
|
MoveConstToX86reg(GetMipsRegLo(MipsReg),Reg);
|
|
}
|
|
}
|
|
}
|
|
SetX86Mapped(Reg,Temp_Mapped);
|
|
SetX86Protected(Reg,TRUE);
|
|
for (count = 0; count < 10; count ++)
|
|
{
|
|
int MapOrder = GetX86MapOrder((x86Reg)count);
|
|
if (MapOrder > 0) {
|
|
SetX86MapOrder((x86Reg)count,MapOrder + 1);
|
|
}
|
|
}
|
|
SetX86MapOrder(Reg,1);
|
|
return Reg;
|
|
}
|
|
|
|
void CRegInfo::ProtectGPR(DWORD Reg) {
|
|
if (IsUnknown(Reg) || IsConst(Reg)) { return; }
|
|
if (Is64Bit(Reg)) {
|
|
SetX86Protected(GetMipsRegMapHi(Reg),TRUE);
|
|
}
|
|
SetX86Protected(GetMipsRegMapLo(Reg),TRUE);
|
|
}
|
|
|
|
void CRegInfo::UnProtectGPR(DWORD Reg) {
|
|
if (IsUnknown(Reg) || IsConst(Reg)) { return; }
|
|
if (Is64Bit(Reg)) {
|
|
SetX86Protected(GetMipsRegMapHi(Reg),false);
|
|
}
|
|
SetX86Protected(GetMipsRegMapLo(Reg),false);
|
|
}
|
|
|
|
void CRegInfo::ResetX86Protection (void)
|
|
{
|
|
for (int count = 0; count < 10; count ++)
|
|
{
|
|
SetX86Protected((x86Reg)count, false);
|
|
}
|
|
}
|
|
|
|
BOOL CRegInfo::RegInStack( int Reg, FPU_STATE Format) {
|
|
int i;
|
|
|
|
for (i = 0; i < 8; i++)
|
|
{
|
|
if (x86fpu_MappedTo[i] == Reg)
|
|
{
|
|
if (x86fpu_State[i] == Format || Format == FPU_Any)
|
|
{
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void CRegInfo::UnMap_AllFPRs ( void )
|
|
{
|
|
for (;;) {
|
|
int StackPos = StackTopPos();
|
|
if (x86fpu_MappedTo[StackPos] != -1 ) {
|
|
UnMap_FPR(x86fpu_MappedTo[StackPos],TRUE);
|
|
continue;
|
|
}
|
|
//see if any more registers mapped
|
|
int StartPos = StackTopPos();
|
|
for (int i = 0; i < 8; i++) {
|
|
if (x86fpu_MappedTo[(StartPos + i) & 7] != -1 ) { fpuIncStack(&StackTopPos()); }
|
|
}
|
|
if (StackPos != StackTopPos()) { continue; }
|
|
return;
|
|
}
|
|
}
|
|
|
|
void CRegInfo::UnMap_FPR (int Reg, int WriteBackValue )
|
|
{
|
|
char Name[50];
|
|
int i;
|
|
|
|
if (Reg < 0) { return; }
|
|
for (i = 0; i < 8; i++) {
|
|
if (x86fpu_MappedTo[i] != Reg) { continue; }
|
|
CPU_Message(" regcache: unallocate %s from ST(%d)",CRegName::FPR[Reg],(i - StackTopPos() + 8) & 7);
|
|
if (WriteBackValue) {
|
|
int RegPos;
|
|
|
|
if (((i - StackTopPos() + 8) & 7) != 0)
|
|
{
|
|
if (x86fpu_MappedTo[StackTopPos()] == -1 && x86fpu_MappedTo[(StackTopPos() + 1) & 7] == Reg)
|
|
{
|
|
fpuIncStack(&StackTopPos());
|
|
} else {
|
|
CRegInfo::FPU_ROUND RoundingModel = FpuRoundingModel(StackTopPos());
|
|
FPU_STATE RegState = x86fpu_State[StackTopPos()];
|
|
BOOL Changed = x86fpu_StateChanged[StackTopPos()];
|
|
DWORD MappedTo = x86fpu_MappedTo[StackTopPos()];
|
|
FpuRoundingModel(StackTopPos()) = FpuRoundingModel(i);
|
|
x86fpu_MappedTo[StackTopPos()] = x86fpu_MappedTo[i];
|
|
x86fpu_State[StackTopPos()] = x86fpu_State[i];
|
|
x86fpu_StateChanged[StackTopPos()] = x86fpu_StateChanged[i];
|
|
FpuRoundingModel(i) = RoundingModel;
|
|
x86fpu_MappedTo[i] = MappedTo;
|
|
x86fpu_State[i] = RegState;
|
|
x86fpu_StateChanged[i] = Changed;
|
|
fpuExchange((x86FpuValues)((i - StackTopPos()) & 7));
|
|
}
|
|
}
|
|
|
|
FixRoundModel(FpuRoundingModel(i));
|
|
|
|
RegPos = StackTopPos();
|
|
x86Reg TempReg = Map_TempReg(x86_Any,-1,FALSE);
|
|
switch (x86fpu_State[StackTopPos()]) {
|
|
case FPU_Dword:
|
|
sprintf(Name,"_FPR_S[%d]",x86fpu_MappedTo[StackTopPos()]);
|
|
MoveVariableToX86reg(&_FPR_S[x86fpu_MappedTo[StackTopPos()]],Name,TempReg);
|
|
fpuStoreIntegerDwordFromX86Reg(&StackTopPos(),TempReg, TRUE);
|
|
break;
|
|
case FPU_Qword:
|
|
sprintf(Name,"_FPR_D[%d]",x86fpu_MappedTo[StackTopPos()]);
|
|
MoveVariableToX86reg(&_FPR_D[x86fpu_MappedTo[StackTopPos()]],Name,TempReg);
|
|
fpuStoreIntegerQwordFromX86Reg(&StackTopPos(),TempReg, TRUE);
|
|
break;
|
|
case FPU_Float:
|
|
sprintf(Name,"_FPR_S[%d]",x86fpu_MappedTo[StackTopPos()]);
|
|
MoveVariableToX86reg(&_FPR_S[x86fpu_MappedTo[StackTopPos()]],Name,TempReg);
|
|
fpuStoreDwordFromX86Reg(&StackTopPos(),TempReg, TRUE);
|
|
break;
|
|
case FPU_Double:
|
|
sprintf(Name,"_FPR_D[%d]",x86fpu_MappedTo[StackTopPos()]);
|
|
MoveVariableToX86reg(&_FPR_D[x86fpu_MappedTo[StackTopPos()]],Name,TempReg);
|
|
fpuStoreQwordFromX86Reg(&StackTopPos(),TempReg, TRUE);
|
|
break;
|
|
#ifndef EXTERNAL_RELEASE
|
|
default:
|
|
g_Notify->DisplayError("UnMap_FPR\nUnknown format to load %d",x86fpu_State[StackTopPos()]);
|
|
#endif
|
|
}
|
|
SetX86Protected(TempReg,FALSE);
|
|
FpuRoundingModel(RegPos) = RoundDefault;
|
|
x86fpu_MappedTo[RegPos] = -1;
|
|
x86fpu_State[RegPos] = FPU_Unknown;
|
|
x86fpu_StateChanged[RegPos] = false;
|
|
} else {
|
|
fpuFree((x86FpuValues)((i - StackTopPos()) & 7));
|
|
FpuRoundingModel(i) = RoundDefault;
|
|
x86fpu_MappedTo[i] = -1;
|
|
x86fpu_State[i] = FPU_Unknown;
|
|
x86fpu_StateChanged[i] = false;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
void CRegInfo::UnMap_GPR (DWORD Reg, bool WriteBackValue)
|
|
{
|
|
if (Reg == 0) {
|
|
#ifndef EXTERNAL_RELEASE
|
|
g_Notify->DisplayError("UnMap_GPR\n\nWhy are you trying to unmap reg 0");
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
if (IsUnknown(Reg)) { return; }
|
|
//CPU_Message("UnMap_GPR: State: %X\tReg: %s\tWriteBack: %s",State,CRegName::GPR[Reg],WriteBackValue?"TRUE":"FALSE");
|
|
if (IsConst(Reg)) {
|
|
if (!WriteBackValue) {
|
|
SetMipsRegState(Reg,STATE_UNKNOWN);
|
|
return;
|
|
}
|
|
if (Is64Bit(Reg)) {
|
|
MoveConstToVariable(GetMipsRegHi(Reg),&_GPR[Reg].UW[1],CRegName::GPR_Hi[Reg]);
|
|
MoveConstToVariable(GetMipsRegLo(Reg),&_GPR[Reg].UW[0],CRegName::GPR_Lo[Reg]);
|
|
SetMipsRegState(Reg,STATE_UNKNOWN);
|
|
return;
|
|
}
|
|
if ((GetMipsRegLo(Reg) & 0x80000000) != 0) {
|
|
MoveConstToVariable(0xFFFFFFFF,&_GPR[Reg].UW[1],CRegName::GPR_Hi[Reg]);
|
|
} else {
|
|
MoveConstToVariable(0,&_GPR[Reg].UW[1],CRegName::GPR_Hi[Reg]);
|
|
}
|
|
MoveConstToVariable(GetMipsRegLo(Reg),&_GPR[Reg].UW[0],CRegName::GPR_Lo[Reg]);
|
|
SetMipsRegState(Reg,STATE_UNKNOWN);
|
|
return;
|
|
}
|
|
if (Is64Bit(Reg)) {
|
|
CPU_Message(" regcache: unallocate %s from %s",x86_Name(GetMipsRegMapHi(Reg)),CRegName::GPR_Hi[Reg]);
|
|
SetX86Mapped(GetMipsRegMapHi(Reg),NotMapped);
|
|
SetX86Protected(GetMipsRegMapHi(Reg),FALSE);
|
|
}
|
|
CPU_Message(" regcache: unallocate %s from %s",x86_Name(GetMipsRegMapLo(Reg)),CRegName::GPR_Lo[Reg]);
|
|
SetX86Mapped(GetMipsRegMapLo(Reg),NotMapped);
|
|
SetX86Protected(GetMipsRegMapLo(Reg),FALSE);
|
|
if (!WriteBackValue)
|
|
{
|
|
SetMipsRegState(Reg,STATE_UNKNOWN);
|
|
return;
|
|
}
|
|
MoveX86regToVariable(GetMipsRegMapLo(Reg),&_GPR[Reg].UW[0],CRegName::GPR_Lo[Reg]);
|
|
if (Is64Bit(Reg)) {
|
|
SetMipsRegMapLo(Reg, x86_Unknown);
|
|
MoveX86regToVariable(GetMipsRegMapHi(Reg),&_GPR[Reg].UW[1],CRegName::GPR_Hi[Reg]);
|
|
SetMipsRegMapHi(Reg,x86_Unknown);
|
|
} else {
|
|
if (!b32BitCore()) {
|
|
if (IsSigned(Reg)) {
|
|
ShiftRightSignImmed(GetMipsRegMapLo(Reg),31);
|
|
MoveX86regToVariable(GetMipsRegMapLo(Reg),&_GPR[Reg].UW[1],CRegName::GPR_Hi[Reg]);
|
|
} else {
|
|
MoveConstToVariable(0,&_GPR[Reg].UW[1],CRegName::GPR_Hi[Reg]);
|
|
}
|
|
}
|
|
SetMipsRegMapLo(Reg, x86_Unknown);
|
|
}
|
|
SetMipsRegState(Reg,STATE_UNKNOWN);
|
|
}
|
|
|
|
CX86Ops::x86Reg CRegInfo::UnMap_TempReg ( void )
|
|
{
|
|
CX86Ops::x86Reg Reg = x86_Unknown;
|
|
|
|
if (GetX86Mapped(x86_EAX) == Temp_Mapped && !GetX86Protected(x86_EAX)) { Reg = x86_EAX; }
|
|
else if (GetX86Mapped(x86_EBX) == Temp_Mapped && !GetX86Protected(x86_EBX)) { Reg = x86_EBX; }
|
|
else if (GetX86Mapped(x86_ECX) == Temp_Mapped && !GetX86Protected(x86_ECX)) { Reg = x86_ECX; }
|
|
else if (GetX86Mapped(x86_EDX) == Temp_Mapped && !GetX86Protected(x86_EDX)) { Reg = x86_EDX; }
|
|
else if (GetX86Mapped(x86_ESI) == Temp_Mapped && !GetX86Protected(x86_ESI)) { Reg = x86_ESI; }
|
|
else if (GetX86Mapped(x86_EDI) == Temp_Mapped && !GetX86Protected(x86_EDI)) { Reg = x86_EDI; }
|
|
else if (GetX86Mapped(x86_EBP) == Temp_Mapped && !GetX86Protected(x86_EBP)) { Reg = x86_EBP; }
|
|
else if (GetX86Mapped(x86_ESP) == Temp_Mapped && !GetX86Protected(x86_ESP)) { Reg = x86_ESP; }
|
|
|
|
if (Reg != x86_Unknown)
|
|
{
|
|
if (GetX86Mapped(Reg) == Temp_Mapped)
|
|
{
|
|
CPU_Message(" regcache: unallocate %s from temp storage",x86_Name(Reg));
|
|
}
|
|
SetX86Mapped(Reg,NotMapped);
|
|
}
|
|
return Reg;
|
|
}
|
|
|
|
bool CRegInfo::UnMap_X86reg ( CX86Ops::x86Reg Reg )
|
|
{
|
|
int count;
|
|
|
|
if (GetX86Mapped(Reg) == NotMapped)
|
|
{
|
|
if (!GetX86Protected(Reg))
|
|
{
|
|
return TRUE;
|
|
}
|
|
} else if (GetX86Mapped(Reg) == CRegInfo::GPR_Mapped) {
|
|
for (count = 1; count < 32; count ++)
|
|
{
|
|
if (!IsMapped(count))
|
|
{
|
|
continue;
|
|
}
|
|
if (Is64Bit(count) && GetMipsRegMapHi(count) == Reg)
|
|
{
|
|
if (GetX86Protected(Reg) == FALSE)
|
|
{
|
|
UnMap_GPR(count,TRUE);
|
|
return TRUE;
|
|
}
|
|
break;
|
|
}
|
|
if (GetMipsRegMapLo(count) == Reg)
|
|
{
|
|
if (GetX86Protected(Reg) == FALSE)
|
|
{
|
|
UnMap_GPR(count,TRUE);
|
|
return TRUE;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
} else if (GetX86Mapped(Reg) == CRegInfo::Temp_Mapped) {
|
|
if (GetX86Protected(Reg) == FALSE) {
|
|
CPU_Message(" regcache: unallocate %s from temp storage",x86_Name(Reg));
|
|
SetX86Mapped(Reg,NotMapped);
|
|
return TRUE;
|
|
}
|
|
} else if (GetX86Mapped(Reg) == CRegInfo::Stack_Mapped) {
|
|
CPU_Message(" regcache: unallocate %s from Memory Stack",x86_Name(Reg));
|
|
MoveX86regToVariable(Reg,&(g_Recompiler->MemoryStackPos()),"MemoryStack");
|
|
SetX86Mapped(Reg,NotMapped);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void CRegInfo::WriteBackRegisters ()
|
|
{
|
|
UnMap_AllFPRs();
|
|
|
|
int count;
|
|
BOOL bEdiZero = FALSE;
|
|
BOOL bEsiSign = FALSE;
|
|
|
|
int X86RegCount = sizeof(x86_Registers)/ sizeof(x86_Registers[0]);
|
|
for (int i = 0; i < X86RegCount; i++) { SetX86Protected(x86_Registers[i],FALSE); }
|
|
for (int i = 0; i < X86RegCount; i++) { UnMap_X86reg(x86_Registers[i]); }
|
|
|
|
/*************************************/
|
|
|
|
for (count = 1; count < 32; count ++) {
|
|
switch (GetMipsRegState(count)) {
|
|
case CRegInfo::STATE_UNKNOWN: break;
|
|
case CRegInfo::STATE_CONST_32:
|
|
if (!b32BitCore())
|
|
{
|
|
if (!bEdiZero && (!GetMipsRegLo(count) || !(GetMipsRegLo(count) & 0x80000000))) {
|
|
XorX86RegToX86Reg(x86_EDI, x86_EDI);
|
|
bEdiZero = TRUE;
|
|
}
|
|
if (!bEsiSign && (GetMipsRegLo(count) & 0x80000000)) {
|
|
MoveConstToX86reg(0xFFFFFFFF, x86_ESI);
|
|
bEsiSign = TRUE;
|
|
}
|
|
if ((GetMipsRegLo(count) & 0x80000000) != 0) {
|
|
MoveX86regToVariable(x86_ESI,&_GPR[count].UW[1],CRegName::GPR_Hi[count]);
|
|
} else {
|
|
MoveX86regToVariable(x86_EDI,&_GPR[count].UW[1],CRegName::GPR_Hi[count]);
|
|
}
|
|
}
|
|
|
|
if (GetMipsRegLo(count) == 0) {
|
|
if (b32BitCore())
|
|
{
|
|
if (!bEdiZero)
|
|
{
|
|
XorX86RegToX86Reg(x86_EDI, x86_EDI);
|
|
bEdiZero = TRUE;
|
|
}
|
|
}
|
|
MoveX86regToVariable(x86_EDI,&_GPR[count].UW[0],CRegName::GPR_Lo[count]);
|
|
} else if (GetMipsRegLo(count) == 0xFFFFFFFF) {
|
|
if (b32BitCore())
|
|
{
|
|
if (!bEsiSign)
|
|
{
|
|
MoveConstToX86reg(0xFFFFFFFF, x86_ESI);
|
|
bEsiSign = TRUE;
|
|
}
|
|
}
|
|
MoveX86regToVariable(x86_ESI,&_GPR[count].UW[0],CRegName::GPR_Lo[count]);
|
|
} else
|
|
MoveConstToVariable(GetMipsRegLo(count),&_GPR[count].UW[0],CRegName::GPR_Lo[count]);
|
|
|
|
SetMipsRegState(count, CRegInfo::STATE_UNKNOWN);
|
|
break;
|
|
case CRegInfo::STATE_CONST_64:
|
|
if (GetMipsRegLo(count) == 0 || GetMipsRegHi(count) == 0) {
|
|
XorX86RegToX86Reg(x86_EDI, x86_EDI);
|
|
bEdiZero = TRUE;
|
|
}
|
|
if (GetMipsRegLo(count) == 0xFFFFFFFF || GetMipsRegHi(count) == 0xFFFFFFFF) {
|
|
MoveConstToX86reg(0xFFFFFFFF, x86_ESI);
|
|
bEsiSign = TRUE;
|
|
}
|
|
|
|
if (GetMipsRegHi(count) == 0) {
|
|
MoveX86regToVariable(x86_EDI,&_GPR[count].UW[1],CRegName::GPR_Hi[count]);
|
|
} else if (GetMipsRegLo(count) == 0xFFFFFFFF) {
|
|
MoveX86regToVariable(x86_ESI,&_GPR[count].UW[1],CRegName::GPR_Hi[count]);
|
|
} else {
|
|
MoveConstToVariable(GetMipsRegHi(count),&_GPR[count].UW[1],CRegName::GPR_Hi[count]);
|
|
}
|
|
|
|
if (GetMipsRegLo(count) == 0) {
|
|
MoveX86regToVariable(x86_EDI,&_GPR[count].UW[0],CRegName::GPR_Lo[count]);
|
|
} else if (GetMipsRegLo(count) == 0xFFFFFFFF) {
|
|
MoveX86regToVariable(x86_ESI,&_GPR[count].UW[0],CRegName::GPR_Lo[count]);
|
|
} else {
|
|
MoveConstToVariable(GetMipsRegLo(count),&_GPR[count].UW[0],CRegName::GPR_Lo[count]);
|
|
}
|
|
SetMipsRegState(count, CRegInfo::STATE_UNKNOWN);
|
|
break;
|
|
default:
|
|
CPU_Message(__FUNCTION__ ": Unknown State: %d reg %d (%s)",GetMipsRegState(count),count,CRegName::GPR[count])
|
|
g_Notify->BreakPoint(__FILE__,__LINE__);
|
|
}
|
|
}
|
|
}
|
|
|
|
const char * CRegInfo::RoundingModelName ( FPU_ROUND RoundType )
|
|
{
|
|
switch (RoundType)
|
|
{
|
|
case RoundUnknown: return "RoundUnknown";
|
|
case RoundDefault: return "RoundDefault";
|
|
case RoundTruncate: return "RoundTruncate";
|
|
case RoundNearest: return "RoundNearest";
|
|
case RoundDown: return "RoundDown";
|
|
case RoundUp: return "RoundUp";
|
|
}
|
|
return "** Invalid **";
|
|
}
|