int main(int argc, const char** argv)
{
fesetround(FE_TOWARDZERO);
CTestVm virtualMachine;
for(const auto& factory : s_factories)
{
virtualMachine.Reset();
auto test = factory();
test->Execute(virtualMachine);
delete test;
}
return 0;
}
void CAdd64Test::Execute(CTestVm& virtualMachine)
{
const uint32 baseAddress = 0x100;
const uint64 constantValue0 = 0xFFF0FFFFFFFFFFFFULL;
const uint64 constantValue1 = 0x8000000000000001ULL;
CMIPS::REGISTER valueRegister0 = CMIPS::A0;
CMIPS::REGISTER valueRegister1 = CMIPS::A1;
CMIPS::REGISTER addReg32Result = CMIPS::T0;
CMIPS::REGISTER addReg64Result = CMIPS::T1;
CMIPS::REGISTER addCst32Result = CMIPS::T2;
CMIPS::REGISTER addCst64Result = CMIPS::T3;
virtualMachine.Reset();
{
CMIPSAssembler assembler(reinterpret_cast<uint32*>(virtualMachine.m_ram + baseAddress));
assembler.ADDU(addReg32Result, valueRegister0, valueRegister1);
assembler.DADDU(addReg64Result, valueRegister0, valueRegister1);
assembler.ADDIU(addCst32Result, valueRegister0, constantValue1);
assembler.DADDIU(addCst64Result, valueRegister0, constantValue1);
assembler.SYSCALL();
}
//Setup initial state
virtualMachine.m_cpu.m_State.nGPR[valueRegister0].nD0 = constantValue0;
virtualMachine.m_cpu.m_State.nGPR[valueRegister1].nD0 = constantValue1;
//Execute
virtualMachine.ExecuteTest(baseAddress);
//Check final state
TEST_VERIFY(virtualMachine.m_cpu.m_State.nGPR[valueRegister0].nD0 == constantValue0);
TEST_VERIFY(virtualMachine.m_cpu.m_State.nGPR[valueRegister1].nD0 == constantValue1);
TEST_VERIFY(virtualMachine.m_cpu.m_State.nGPR[addReg32Result].nD0 == static_cast<int32>(constantValue0 + constantValue1));
TEST_VERIFY(virtualMachine.m_cpu.m_State.nGPR[addReg64Result].nD0 == constantValue0 + constantValue1);
TEST_VERIFY(virtualMachine.m_cpu.m_State.nGPR[addCst32Result].nD0 == static_cast<int32>(constantValue0 + static_cast<int16>(constantValue1)));
TEST_VERIFY(virtualMachine.m_cpu.m_State.nGPR[addCst64Result].nD0 == constantValue0 + static_cast<int16>(constantValue1));
}
void CTriAceTest::Execute(CTestVm& virtualMachine)
{
virtualMachine.Reset();
auto microMem = reinterpret_cast<uint32*>(virtualMachine.m_microMem);
//From Radiata Stories - Needs accurate floating point handling to work
CVuAssembler assembler(microMem);
assembler.Write(
CVuAssembler::Upper::NOP() | CVuAssembler::Upper::I_BIT,
0x42FECCCD);
//X
assembler.Write(
CVuAssembler::Upper::MULi(CVuAssembler::DEST_X, CVuAssembler::VF2, CVuAssembler::VF1) | CVuAssembler::Upper::I_BIT,
0x42546666);
assembler.Write(
CVuAssembler::Upper::ADDi(CVuAssembler::DEST_X, CVuAssembler::VF3, CVuAssembler::VF2) | CVuAssembler::Upper::I_BIT,
0x43D80D3E);
//Y
assembler.Write(
CVuAssembler::Upper::MULi(CVuAssembler::DEST_Y, CVuAssembler::VF2, CVuAssembler::VF1) | CVuAssembler::Upper::I_BIT,
0xC7F079B3);
assembler.Write(
CVuAssembler::Upper::ADDi(CVuAssembler::DEST_Y, CVuAssembler::VF3, CVuAssembler::VF2) | CVuAssembler::Upper::I_BIT,
0x43A0DA10);
//Z
assembler.Write(
CVuAssembler::Upper::MULi(CVuAssembler::DEST_Z, CVuAssembler::VF2, CVuAssembler::VF1) | CVuAssembler::Upper::I_BIT,
0x43A02666);
assembler.Write(
CVuAssembler::Upper::ADDi(CVuAssembler::DEST_Z, CVuAssembler::VF3, CVuAssembler::VF2) | CVuAssembler::Upper::I_BIT,
0x43546E14);
//W
assembler.Write(
CVuAssembler::Upper::MULi(CVuAssembler::DEST_W, CVuAssembler::VF2, CVuAssembler::VF1) | CVuAssembler::Upper::I_BIT,
0x42F23333);
assembler.Write(
CVuAssembler::Upper::ADDi(CVuAssembler::DEST_W, CVuAssembler::VF3, CVuAssembler::VF2) | CVuAssembler::Upper::I_BIT,
0x3DD3DD98);
assembler.Write(
CVuAssembler::Upper::NOP() | CVuAssembler::Upper::E_BIT,
CVuAssembler::Lower::NOP());
assembler.Write(
CVuAssembler::Upper::NOP(),
CVuAssembler::Lower::NOP());
virtualMachine.m_cpu.m_State.nCOP2[1].nV0 = 0xB063B75B;
virtualMachine.m_cpu.m_State.nCOP2[1].nV1 = 0x8701CE82;
virtualMachine.m_cpu.m_State.nCOP2[1].nV2 = 0x46FCC888;
virtualMachine.m_cpu.m_State.nCOP2[1].nV3 = 0x793CC535;
virtualMachine.ExecuteTest(0);
TEST_VERIFY(virtualMachine.m_cpu.m_State.nCOP2[3].nV0 == 0x42546666);
TEST_VERIFY(virtualMachine.m_cpu.m_State.nCOP2[3].nV1 == 0xC7F079B3);
TEST_VERIFY(virtualMachine.m_cpu.m_State.nCOP2[3].nV2 == 0x4B1ED5E7);
TEST_VERIFY(virtualMachine.m_cpu.m_State.nCOP2[3].nV3 == 0x7D1CA47B);
}
void CPackedMultiplyTest::Execute(CTestVm& virtualMachine)
{
auto& cpu = virtualMachine.m_cpu;
const uint32 baseAddress = 0x100;
const uint32 constantValue0 = 0x11110000;
const uint32 constantValue1 = 0x33332222;
const uint32 constantValue2 = 0x55554444;
const uint32 constantValue3 = 0x77776666;
const uint32 constantValue4 = 0x99998888;
const uint32 constantValue5 = 0xBBBBAAAA;
const uint32 constantValue6 = 0xDDDDCCCC;
const uint32 constantValue7 = 0xFFFFEEEE;
const uint64 multhResultLow = 0xF49F3E9400000000ULL;
const uint64 multhResultHigh = 0xF92C06D4F2589630ULL;
const uint64 multhLoLow = 0xF92C5C2900000000ULL;
const uint64 multhLoHigh = 0xF49F0B61F2589630ULL;
const uint64 multhHiLow = 0xF258A741F49F3E94ULL;
const uint64 multhHiHigh = 0xFFFF8889F92C06D4ULL;
const uint64 mfhlUwResultLow = 0xF258A741F92C5C29ULL;
const uint64 mfhlUwResultHigh = 0xFFFF8889F49F0B61ULL;
const uint64 mfhlLhResultLow = 0xA7413E945C290000ULL;
const uint64 mfhlLhResultHigh = 0x888906D40B619630ULL;
auto valueRegister0 = CMIPS::A0;
auto valueRegister1 = CMIPS::A1;
auto multhResult = CMIPS::T0;
auto multhLo = CMIPS::T1;
auto multhHi = CMIPS::T2;
auto multhSelfResult = CMIPS::T3;
auto multhSelfLo = CMIPS::T4;
auto multhSelfHi = CMIPS::T5;
auto mfhlUwResult = CMIPS::T6;
auto mfhlLhResult = CMIPS::T7;
virtualMachine.Reset();
{
CEEAssembler assembler(reinterpret_cast<uint32*>(virtualMachine.m_ram + baseAddress));
//PMULTH
assembler.PMULTH(multhResult, valueRegister0, valueRegister1);
assembler.PMFLO(multhLo);
assembler.PMFHI(multhHi);
//PMULTH (self)
assembler.PADDW(multhSelfResult, valueRegister0, CMIPS::R0);
assembler.PMULTH(multhSelfResult, multhSelfResult, valueRegister1);
assembler.PMFLO(multhSelfLo);
assembler.PMFHI(multhSelfHi);
//PMFHL.UW
assembler.PMFHL_UW(mfhlUwResult);
//PMFHL.LH
assembler.PMFHL_LH(mfhlLhResult);
assembler.SYSCALL();
}
//Setup initial state
cpu.m_State.nGPR[valueRegister0].nV[0] = constantValue0;
cpu.m_State.nGPR[valueRegister0].nV[1] = constantValue1;
cpu.m_State.nGPR[valueRegister0].nV[2] = constantValue2;
cpu.m_State.nGPR[valueRegister0].nV[3] = constantValue3;
cpu.m_State.nGPR[valueRegister1].nV[0] = constantValue4;
cpu.m_State.nGPR[valueRegister1].nV[1] = constantValue5;
cpu.m_State.nGPR[valueRegister1].nV[2] = constantValue6;
cpu.m_State.nGPR[valueRegister1].nV[3] = constantValue7;
//Execute
virtualMachine.ExecuteTest(baseAddress);
//Check final state
TEST_VERIFY(cpu.m_State.nGPR[valueRegister0].nV[0] == constantValue0);
TEST_VERIFY(cpu.m_State.nGPR[valueRegister0].nV[1] == constantValue1);
TEST_VERIFY(cpu.m_State.nGPR[valueRegister0].nV[2] == constantValue2);
TEST_VERIFY(cpu.m_State.nGPR[valueRegister0].nV[3] == constantValue3);
TEST_VERIFY(cpu.m_State.nGPR[valueRegister1].nV[0] == constantValue4);
TEST_VERIFY(cpu.m_State.nGPR[valueRegister1].nV[1] == constantValue5);
TEST_VERIFY(cpu.m_State.nGPR[valueRegister1].nV[2] == constantValue6);
TEST_VERIFY(cpu.m_State.nGPR[valueRegister1].nV[3] == constantValue7);
TEST_VERIFY(cpu.m_State.nGPR[multhResult].nD0 == multhResultLow);
TEST_VERIFY(cpu.m_State.nGPR[multhResult].nD1 == multhResultHigh);
TEST_VERIFY(cpu.m_State.nGPR[multhLo].nD0 == multhLoLow);
TEST_VERIFY(cpu.m_State.nGPR[multhLo].nD1 == multhLoHigh);
TEST_VERIFY(cpu.m_State.nGPR[multhHi].nD0 == multhHiLow);
TEST_VERIFY(cpu.m_State.nGPR[multhHi].nD1 == multhHiHigh);
TEST_VERIFY(cpu.m_State.nGPR[multhSelfResult].nD0 == multhResultLow);
TEST_VERIFY(cpu.m_State.nGPR[multhSelfResult].nD1 == multhResultHigh);
TEST_VERIFY(cpu.m_State.nGPR[multhSelfLo].nD0 == multhLoLow);
TEST_VERIFY(cpu.m_State.nGPR[multhSelfLo].nD1 == multhLoHigh);
TEST_VERIFY(cpu.m_State.nGPR[multhSelfHi].nD0 == multhHiLow);
TEST_VERIFY(cpu.m_State.nGPR[multhSelfHi].nD1 == multhHiHigh);
TEST_VERIFY(cpu.m_State.nGPR[mfhlUwResult].nD0 == mfhlUwResultLow);
TEST_VERIFY(cpu.m_State.nGPR[mfhlUwResult].nD1 == mfhlUwResultHigh);
TEST_VERIFY(cpu.m_State.nGPR[mfhlLhResult].nD0 == mfhlLhResultLow);
TEST_VERIFY(cpu.m_State.nGPR[mfhlLhResult].nD1 == mfhlLhResultHigh);
}
void CPackTest::Execute(CTestVm& virtualMachine)
{
auto& cpu = virtualMachine.m_cpu;
const uint32 baseAddress = 0x100;
const uint32 constantValue0 = 0x00000000;
const uint32 constantValue1 = 0x11111111;
const uint32 constantValue2 = 0x22222222;
const uint32 constantValue3 = 0x33333333;
const uint32 constantValue4 = 0x44444444;
const uint32 constantValue5 = 0x55555555;
const uint32 constantValue6 = 0x66666666;
const uint32 constantValue7 = 0x77777777;
const uint64 pachResultLow = 0x7777666655554444ULL;
const uint64 pachResultHigh = 0x3333222211110000ULL;
const uint64 pacwResultLow = 0x6666666644444444ULL;
const uint64 pacwResultHigh = 0x2222222200000000ULL;
auto valueRegister0 = CMIPS::A0;
auto valueRegister1 = CMIPS::A1;
auto pachResult = CMIPS::T0;
auto pachSelfResult = CMIPS::T1;
auto pacwResult = CMIPS::T2;
auto pacwSelfResult = CMIPS::T3;
virtualMachine.Reset();
{
CEEAssembler assembler(reinterpret_cast<uint32*>(virtualMachine.m_ram + baseAddress));
//PPACH
assembler.PPACH(pachResult, valueRegister0, valueRegister1);
//PPACH (self)
assembler.PADDW(pachSelfResult, valueRegister0, CMIPS::R0);
assembler.PPACH(pachSelfResult, pachSelfResult, valueRegister1);
//PPACW
assembler.PPACW(pacwResult, valueRegister0, valueRegister1);
//PPACW (self)
assembler.PADDW(pacwSelfResult, valueRegister0, CMIPS::R0);
assembler.PPACW(pacwSelfResult, pacwSelfResult, valueRegister1);
assembler.SYSCALL();
}
//Setup initial state
cpu.m_State.nGPR[valueRegister0].nV[0] = constantValue0;
cpu.m_State.nGPR[valueRegister0].nV[1] = constantValue1;
cpu.m_State.nGPR[valueRegister0].nV[2] = constantValue2;
cpu.m_State.nGPR[valueRegister0].nV[3] = constantValue3;
cpu.m_State.nGPR[valueRegister1].nV[0] = constantValue4;
cpu.m_State.nGPR[valueRegister1].nV[1] = constantValue5;
cpu.m_State.nGPR[valueRegister1].nV[2] = constantValue6;
cpu.m_State.nGPR[valueRegister1].nV[3] = constantValue7;
//Execute
virtualMachine.ExecuteTest(baseAddress);
//Check final state
TEST_VERIFY(cpu.m_State.nGPR[valueRegister0].nV[0] == constantValue0);
TEST_VERIFY(cpu.m_State.nGPR[valueRegister0].nV[1] == constantValue1);
TEST_VERIFY(cpu.m_State.nGPR[valueRegister0].nV[2] == constantValue2);
TEST_VERIFY(cpu.m_State.nGPR[valueRegister0].nV[3] == constantValue3);
TEST_VERIFY(cpu.m_State.nGPR[valueRegister1].nV[0] == constantValue4);
TEST_VERIFY(cpu.m_State.nGPR[valueRegister1].nV[1] == constantValue5);
TEST_VERIFY(cpu.m_State.nGPR[valueRegister1].nV[2] == constantValue6);
TEST_VERIFY(cpu.m_State.nGPR[valueRegister1].nV[3] == constantValue7);
TEST_VERIFY(cpu.m_State.nGPR[pachResult].nD0 == pachResultLow);
TEST_VERIFY(cpu.m_State.nGPR[pachResult].nD1 == pachResultHigh);
TEST_VERIFY(cpu.m_State.nGPR[pachSelfResult].nD0 == pachResultLow);
TEST_VERIFY(cpu.m_State.nGPR[pachSelfResult].nD1 == pachResultHigh);
TEST_VERIFY(cpu.m_State.nGPR[pacwResult].nD0 == pacwResultLow);
TEST_VERIFY(cpu.m_State.nGPR[pacwResult].nD1 == pacwResultHigh);
TEST_VERIFY(cpu.m_State.nGPR[pacwSelfResult].nD0 == pacwResultLow);
TEST_VERIFY(cpu.m_State.nGPR[pacwSelfResult].nD1 == pacwResultHigh);
}
