Emulation/orbum
1
0
Fork 0
mirror of https://github.com/hch12907/orbum.git synced 2024-05-20 05:00:48 -04:00
Code Issues Packages Projects Releases Wiki Activity

EE/IOP/VU: Consistency

Browse source
This commit is contained in:
hch12907 2018-11-10 17:25:47 +08:00
parent 8089b206dd
commit 17bb55c132
7 changed files with 206 additions and 184 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
liborbum/src/Common/Types/Mips/BranchDelaySlot.hpp
View file

@ -20,6 +20,12 @@ template <size_t slots = 1, size_t inst_size = Constants::MIPS::SIZE_MIPS_INSTRU
class BranchDelaySlot
{
public:
enum BranchState
{
EmptyBranch = -1,
ShouldBranch = 0,
};
BranchDelaySlot() :
pending_branches { std::pair(-1, 0), std::pair(-1, 0) }
{
@ -121,12 +127,6 @@ protected:
// uptr of std::pair = address to branch to
std::array<std::pair<sword, uptr>, slots + 1> pending_branches;
enum BranchState
{
EmptyBranch = -1,
ShouldBranch = 0,
};
public:
template <class Archive>
void serialize(Archive& archive)

5
liborbum/src/Controller/Ee/Vpu/Vu/Interpreter/CVuInterpreter.cpp
View file

@ -34,15 +34,14 @@ int CVuInterpreter::time_step(const int ticks_available)
const uword upper_raw_inst = (raw_inst >> 32) & 0xFFFFFFFF;
const VuInstruction upper_inst = VuInstruction(upper_raw_inst);
const MipsInstructionInfo upper_info = upper_inst.lower_lookup();
const MipsInstructionInfo upper_info = upper_inst.get_upper_info();
const VuInstructionDecoder upper_decoder = VuInstructionDecoder(upper_inst, upper_info);
const uword lower_raw_inst = raw_inst & 0xFFFFFFFF;
const VuInstruction lower_inst = VuInstruction(lower_raw_inst);
const MipsInstructionInfo lower_info = lower_inst.lower_lookup();
const MipsInstructionInfo lower_info = lower_inst.get_lower_info();
const VuInstructionDecoder lower_decoder = VuInstructionDecoder(lower_inst, lower_info);
// Flush the pipelines
unit->efu.consume_cycle(1);
unit->fdiv.consume_cycle(1);

4
liborbum/src/Resources/Ee/Core/EeCoreInstruction.hpp
View file

@ -49,7 +49,7 @@ struct EeCoreInstruction : public MipsInstruction
static constexpr int CPI_COP_BRANCH_DELAY_LIKELY = 10;
/// Performs a lookup if required and returns the instruction details.
const MipsInstructionInfo* get_info()
const MipsInstructionInfo* get_info() const
{
if (!info)
info = lookup();
@ -58,7 +58,7 @@ struct EeCoreInstruction : public MipsInstruction
private:
/// Instruction information (from performing lookup).
MipsInstructionInfo* info;
mutable MipsInstructionInfo* info;
/// Determines what instruction this is by performing a lookup.
MipsInstructionInfo* lookup() const;

348
liborbum/src/Resources/Ee/Vpu/Vu/VuInstruction.cpp
View file

@ -197,110 +197,110 @@ MipsInstructionInfo VU_INSTRUCTION_TABLE[Constants::EE::VPU::VU::NUMBER_VU_INSTR
{"MSUBAi", 65, 6, VuPipeline::FMAC},
{"NOP", 85, 6, VuPipeline::FMAC}};
MipsInstructionInfo VuInstruction::lower_lookup() const
MipsInstructionInfo* VuInstruction::lower_lookup() const
{
switch (msb7())
{
case 0:
return VU_INSTRUCTION_TABLE[0];
return &VU_INSTRUCTION_TABLE[0];
case 1:
return VU_INSTRUCTION_TABLE[1];
return &VU_INSTRUCTION_TABLE[1];
case 4:
return VU_INSTRUCTION_TABLE[2];
return &VU_INSTRUCTION_TABLE[2];
case 5:
return VU_INSTRUCTION_TABLE[3];
return &VU_INSTRUCTION_TABLE[3];
case 8:
return VU_INSTRUCTION_TABLE[4];
return &VU_INSTRUCTION_TABLE[4];
case 9:
return VU_INSTRUCTION_TABLE[5];
return &VU_INSTRUCTION_TABLE[5];
case 16:
return VU_INSTRUCTION_TABLE[6];
return &VU_INSTRUCTION_TABLE[6];
case 17:
return VU_INSTRUCTION_TABLE[7];
return &VU_INSTRUCTION_TABLE[7];
case 18:
return VU_INSTRUCTION_TABLE[8];
return &VU_INSTRUCTION_TABLE[8];
case 19:
return VU_INSTRUCTION_TABLE[9];
return &VU_INSTRUCTION_TABLE[9];
case 20:
return VU_INSTRUCTION_TABLE[10];
return &VU_INSTRUCTION_TABLE[10];
case 21:
return VU_INSTRUCTION_TABLE[11];
return &VU_INSTRUCTION_TABLE[11];
case 22:
return VU_INSTRUCTION_TABLE[12];
return &VU_INSTRUCTION_TABLE[12];
case 23:
return VU_INSTRUCTION_TABLE[13];
return &VU_INSTRUCTION_TABLE[13];
case 24:
return VU_INSTRUCTION_TABLE[14];
return &VU_INSTRUCTION_TABLE[14];
case 25:
// fmset theoretically... but it doesn't exist.
case 26:
return VU_INSTRUCTION_TABLE[15];
return &VU_INSTRUCTION_TABLE[15];
case 27:
return VU_INSTRUCTION_TABLE[16];
return &VU_INSTRUCTION_TABLE[16];
case 28:
return VU_INSTRUCTION_TABLE[17];
return &VU_INSTRUCTION_TABLE[17];
case 32:
return VU_INSTRUCTION_TABLE[18];
return &VU_INSTRUCTION_TABLE[18];
case 33:
return VU_INSTRUCTION_TABLE[19];
return &VU_INSTRUCTION_TABLE[19];
case 36:
return VU_INSTRUCTION_TABLE[20];
return &VU_INSTRUCTION_TABLE[20];
case 37:
return VU_INSTRUCTION_TABLE[21];
return &VU_INSTRUCTION_TABLE[21];
case 40:
return VU_INSTRUCTION_TABLE[22];
return &VU_INSTRUCTION_TABLE[22];
case 41:
return VU_INSTRUCTION_TABLE[23];
return &VU_INSTRUCTION_TABLE[23];
case 44:
return VU_INSTRUCTION_TABLE[24];
return &VU_INSTRUCTION_TABLE[24];
case 45:
return VU_INSTRUCTION_TABLE[25];
return &VU_INSTRUCTION_TABLE[25];
case 46:
return VU_INSTRUCTION_TABLE[26];
return &VU_INSTRUCTION_TABLE[26];
case 47:
return VU_INSTRUCTION_TABLE[27];
return &VU_INSTRUCTION_TABLE[27];
case 64: // Lower OP
{
switch (opcode())
{
case 48:
return VU_INSTRUCTION_TABLE[28];
return &VU_INSTRUCTION_TABLE[28];
case 49:
return VU_INSTRUCTION_TABLE[29];
return &VU_INSTRUCTION_TABLE[29];
case 50:
return VU_INSTRUCTION_TABLE[30];
return &VU_INSTRUCTION_TABLE[30];
case 52:
return VU_INSTRUCTION_TABLE[31];
return &VU_INSTRUCTION_TABLE[31];
case 53:
return VU_INSTRUCTION_TABLE[32];
return &VU_INSTRUCTION_TABLE[32];
case 60:
{
switch (fd())
{
case 12:
return VU_INSTRUCTION_TABLE[33];
return &VU_INSTRUCTION_TABLE[33];
case 13:
return VU_INSTRUCTION_TABLE[34];
return &VU_INSTRUCTION_TABLE[34];
case 14:
return VU_INSTRUCTION_TABLE[35];
return &VU_INSTRUCTION_TABLE[35];
case 15:
return VU_INSTRUCTION_TABLE[36];
return &VU_INSTRUCTION_TABLE[36];
case 16:
return VU_INSTRUCTION_TABLE[37];
return &VU_INSTRUCTION_TABLE[37];
case 25:
return VU_INSTRUCTION_TABLE[38];
return &VU_INSTRUCTION_TABLE[38];
case 26:
return VU_INSTRUCTION_TABLE[39];
return &VU_INSTRUCTION_TABLE[39];
case 27:
return VU_INSTRUCTION_TABLE[40];
return &VU_INSTRUCTION_TABLE[40];
case 28:
return VU_INSTRUCTION_TABLE[41];
return &VU_INSTRUCTION_TABLE[41];
case 29:
return VU_INSTRUCTION_TABLE[42];
return &VU_INSTRUCTION_TABLE[42];
case 30:
return VU_INSTRUCTION_TABLE[43];
return &VU_INSTRUCTION_TABLE[43];
case 31:
return VU_INSTRUCTION_TABLE[44];
return &VU_INSTRUCTION_TABLE[44];
default:
throw std::runtime_error("VU: Could not determine the lower instruction");
}
@ -310,25 +310,25 @@ MipsInstructionInfo VuInstruction::lower_lookup() const
switch (fd())
{
case 12:
return VU_INSTRUCTION_TABLE[45];
return &VU_INSTRUCTION_TABLE[45];
case 13:
return VU_INSTRUCTION_TABLE[46];
return &VU_INSTRUCTION_TABLE[46];
case 14:
return VU_INSTRUCTION_TABLE[47];
return &VU_INSTRUCTION_TABLE[47];
case 15:
return VU_INSTRUCTION_TABLE[48];
return &VU_INSTRUCTION_TABLE[48];
case 16:
return VU_INSTRUCTION_TABLE[49];
return &VU_INSTRUCTION_TABLE[49];
case 26:
return VU_INSTRUCTION_TABLE[50];
return &VU_INSTRUCTION_TABLE[50];
case 28:
return VU_INSTRUCTION_TABLE[51];
return &VU_INSTRUCTION_TABLE[51];
case 29:
return VU_INSTRUCTION_TABLE[52];
return &VU_INSTRUCTION_TABLE[52];
case 30:
return VU_INSTRUCTION_TABLE[53];
return &VU_INSTRUCTION_TABLE[53];
case 31:
return VU_INSTRUCTION_TABLE[54];
return &VU_INSTRUCTION_TABLE[54];
default:
throw std::runtime_error("VU: Could not determine the lower instruction");
}
@ -338,21 +338,21 @@ MipsInstructionInfo VuInstruction::lower_lookup() const
switch (fd())
{
case 13:
return VU_INSTRUCTION_TABLE[55];
return &VU_INSTRUCTION_TABLE[55];
case 14:
return VU_INSTRUCTION_TABLE[56];
return &VU_INSTRUCTION_TABLE[56];
case 15:
return VU_INSTRUCTION_TABLE[57];
return &VU_INSTRUCTION_TABLE[57];
case 16:
return VU_INSTRUCTION_TABLE[58];
return &VU_INSTRUCTION_TABLE[58];
case 28:
return VU_INSTRUCTION_TABLE[59];
return &VU_INSTRUCTION_TABLE[59];
case 29:
return VU_INSTRUCTION_TABLE[60];
return &VU_INSTRUCTION_TABLE[60];
case 30:
return VU_INSTRUCTION_TABLE[61];
return &VU_INSTRUCTION_TABLE[61];
case 31:
return VU_INSTRUCTION_TABLE[62];
return &VU_INSTRUCTION_TABLE[62];
default:
throw std::runtime_error("VU: Could not determine the lower instruction");
}
@ -362,17 +362,17 @@ MipsInstructionInfo VuInstruction::lower_lookup() const
switch (fd())
{
case 13:
return VU_INSTRUCTION_TABLE[63];
return &VU_INSTRUCTION_TABLE[63];
case 14:
return VU_INSTRUCTION_TABLE[64];
return &VU_INSTRUCTION_TABLE[64];
case 15:
return VU_INSTRUCTION_TABLE[65];
return &VU_INSTRUCTION_TABLE[65];
case 16:
return VU_INSTRUCTION_TABLE[66];
return &VU_INSTRUCTION_TABLE[66];
case 28:
return VU_INSTRUCTION_TABLE[67];
return &VU_INSTRUCTION_TABLE[67];
case 30:
return VU_INSTRUCTION_TABLE[68];
return &VU_INSTRUCTION_TABLE[68];
default:
throw std::runtime_error("VU: Could not determine the lower instruction");
}
@ -388,134 +388,134 @@ MipsInstructionInfo VuInstruction::lower_lookup() const
}
}
MipsInstructionInfo VuInstruction::upper_lookup() const
MipsInstructionInfo* VuInstruction::upper_lookup() const
{
switch (opcode())
{
case 0:
return VU_INSTRUCTION_TABLE[69];
return &VU_INSTRUCTION_TABLE[69];
case 1:
return VU_INSTRUCTION_TABLE[70];
return &VU_INSTRUCTION_TABLE[70];
case 2:
return VU_INSTRUCTION_TABLE[71];
return &VU_INSTRUCTION_TABLE[71];
case 3:
return VU_INSTRUCTION_TABLE[72];
return &VU_INSTRUCTION_TABLE[72];
case 4:
return VU_INSTRUCTION_TABLE[73];
return &VU_INSTRUCTION_TABLE[73];
case 5:
return VU_INSTRUCTION_TABLE[74];
return &VU_INSTRUCTION_TABLE[74];
case 6:
return VU_INSTRUCTION_TABLE[75];
return &VU_INSTRUCTION_TABLE[75];
case 7:
return VU_INSTRUCTION_TABLE[76];
return &VU_INSTRUCTION_TABLE[76];
case 8:
return VU_INSTRUCTION_TABLE[77];
return &VU_INSTRUCTION_TABLE[77];
case 9:
return VU_INSTRUCTION_TABLE[78];
return &VU_INSTRUCTION_TABLE[78];
case 10:
return VU_INSTRUCTION_TABLE[79];
return &VU_INSTRUCTION_TABLE[79];
case 11:
return VU_INSTRUCTION_TABLE[80];
return &VU_INSTRUCTION_TABLE[80];
case 12:
return VU_INSTRUCTION_TABLE[81];
return &VU_INSTRUCTION_TABLE[81];
case 13:
return VU_INSTRUCTION_TABLE[82];
return &VU_INSTRUCTION_TABLE[82];
case 14:
return VU_INSTRUCTION_TABLE[83];
return &VU_INSTRUCTION_TABLE[83];
case 15:
return VU_INSTRUCTION_TABLE[84];
return &VU_INSTRUCTION_TABLE[84];
case 16:
return VU_INSTRUCTION_TABLE[85];
return &VU_INSTRUCTION_TABLE[85];
case 17:
return VU_INSTRUCTION_TABLE[86];
return &VU_INSTRUCTION_TABLE[86];
case 18:
return VU_INSTRUCTION_TABLE[87];
return &VU_INSTRUCTION_TABLE[87];
case 19:
return VU_INSTRUCTION_TABLE[88];
return &VU_INSTRUCTION_TABLE[88];
case 20:
return VU_INSTRUCTION_TABLE[89];
return &VU_INSTRUCTION_TABLE[89];
case 21:
return VU_INSTRUCTION_TABLE[90];
return &VU_INSTRUCTION_TABLE[90];
case 22:
return VU_INSTRUCTION_TABLE[91];
return &VU_INSTRUCTION_TABLE[91];
case 23:
return VU_INSTRUCTION_TABLE[92];
return &VU_INSTRUCTION_TABLE[92];
case 24:
return VU_INSTRUCTION_TABLE[93];
return &VU_INSTRUCTION_TABLE[93];
case 25:
return VU_INSTRUCTION_TABLE[94];
return &VU_INSTRUCTION_TABLE[94];
case 26:
return VU_INSTRUCTION_TABLE[95];
return &VU_INSTRUCTION_TABLE[95];
case 27:
return VU_INSTRUCTION_TABLE[96];
return &VU_INSTRUCTION_TABLE[96];
case 28:
return VU_INSTRUCTION_TABLE[97];
return &VU_INSTRUCTION_TABLE[97];
case 29:
return VU_INSTRUCTION_TABLE[98];
return &VU_INSTRUCTION_TABLE[98];
case 30:
return VU_INSTRUCTION_TABLE[99];
return &VU_INSTRUCTION_TABLE[99];
case 31:
return VU_INSTRUCTION_TABLE[100];
return &VU_INSTRUCTION_TABLE[100];
case 32:
return VU_INSTRUCTION_TABLE[101];
return &VU_INSTRUCTION_TABLE[101];
case 33:
return VU_INSTRUCTION_TABLE[102];
return &VU_INSTRUCTION_TABLE[102];
case 34:
return VU_INSTRUCTION_TABLE[103];
return &VU_INSTRUCTION_TABLE[103];
case 35:
return VU_INSTRUCTION_TABLE[104];
return &VU_INSTRUCTION_TABLE[104];
case 36:
return VU_INSTRUCTION_TABLE[105];
return &VU_INSTRUCTION_TABLE[105];
case 37:
return VU_INSTRUCTION_TABLE[106];
return &VU_INSTRUCTION_TABLE[106];
case 38:
return VU_INSTRUCTION_TABLE[107];
return &VU_INSTRUCTION_TABLE[107];
case 39:
return VU_INSTRUCTION_TABLE[108];
return &VU_INSTRUCTION_TABLE[108];
case 40:
return VU_INSTRUCTION_TABLE[109];
return &VU_INSTRUCTION_TABLE[109];
case 41:
return VU_INSTRUCTION_TABLE[110];
return &VU_INSTRUCTION_TABLE[110];
case 42:
return VU_INSTRUCTION_TABLE[111];
return &VU_INSTRUCTION_TABLE[111];
case 43:
return VU_INSTRUCTION_TABLE[112];
return &VU_INSTRUCTION_TABLE[112];
case 44:
return VU_INSTRUCTION_TABLE[113];
return &VU_INSTRUCTION_TABLE[113];
case 45:
return VU_INSTRUCTION_TABLE[114];
return &VU_INSTRUCTION_TABLE[114];
case 46:
return VU_INSTRUCTION_TABLE[115];
return &VU_INSTRUCTION_TABLE[115];
case 47:
return VU_INSTRUCTION_TABLE[116];
return &VU_INSTRUCTION_TABLE[116];
case 60:
{
switch (fd())
{
case 0:
return VU_INSTRUCTION_TABLE[117];
return &VU_INSTRUCTION_TABLE[117];
case 1:
return VU_INSTRUCTION_TABLE[118];
return &VU_INSTRUCTION_TABLE[118];
case 2:
return VU_INSTRUCTION_TABLE[119];
return &VU_INSTRUCTION_TABLE[119];
case 3:
return VU_INSTRUCTION_TABLE[120];
return &VU_INSTRUCTION_TABLE[120];
case 4:
return VU_INSTRUCTION_TABLE[121];
return &VU_INSTRUCTION_TABLE[121];
case 5:
return VU_INSTRUCTION_TABLE[122];
return &VU_INSTRUCTION_TABLE[122];
case 6:
return VU_INSTRUCTION_TABLE[123];
return &VU_INSTRUCTION_TABLE[123];
case 7:
return VU_INSTRUCTION_TABLE[124];
return &VU_INSTRUCTION_TABLE[124];
case 8:
return VU_INSTRUCTION_TABLE[125];
return &VU_INSTRUCTION_TABLE[125];
case 9:
return VU_INSTRUCTION_TABLE[126];
return &VU_INSTRUCTION_TABLE[126];
case 10:
return VU_INSTRUCTION_TABLE[127];
return &VU_INSTRUCTION_TABLE[127];
case 11:
return VU_INSTRUCTION_TABLE[128];
return &VU_INSTRUCTION_TABLE[128];
default:
throw std::runtime_error("VU: Could not determine the upper instruction");
}
@ -525,29 +525,29 @@ MipsInstructionInfo VuInstruction::upper_lookup() const
switch (fd())
{
case 0:
return VU_INSTRUCTION_TABLE[129];
return &VU_INSTRUCTION_TABLE[129];
case 1:
return VU_INSTRUCTION_TABLE[130];
return &VU_INSTRUCTION_TABLE[130];
case 2:
return VU_INSTRUCTION_TABLE[131];
return &VU_INSTRUCTION_TABLE[131];
case 3:
return VU_INSTRUCTION_TABLE[132];
return &VU_INSTRUCTION_TABLE[132];
case 4:
return VU_INSTRUCTION_TABLE[133];
return &VU_INSTRUCTION_TABLE[133];
case 5:
return VU_INSTRUCTION_TABLE[134];
return &VU_INSTRUCTION_TABLE[134];
case 6:
return VU_INSTRUCTION_TABLE[135];
return &VU_INSTRUCTION_TABLE[135];
case 7:
return VU_INSTRUCTION_TABLE[136];
return &VU_INSTRUCTION_TABLE[136];
case 8:
return VU_INSTRUCTION_TABLE[137];
return &VU_INSTRUCTION_TABLE[137];
case 9:
return VU_INSTRUCTION_TABLE[138];
return &VU_INSTRUCTION_TABLE[138];
case 10:
return VU_INSTRUCTION_TABLE[139];
return &VU_INSTRUCTION_TABLE[139];
case 11:
return VU_INSTRUCTION_TABLE[140];
return &VU_INSTRUCTION_TABLE[140];
default:
throw std::runtime_error("VU: Could not determine the upper instruction");
}
@ -557,29 +557,29 @@ MipsInstructionInfo VuInstruction::upper_lookup() const
switch (fd())
{
case 0:
return VU_INSTRUCTION_TABLE[141];
return &VU_INSTRUCTION_TABLE[141];
case 1:
return VU_INSTRUCTION_TABLE[142];
return &VU_INSTRUCTION_TABLE[142];
case 2:
return VU_INSTRUCTION_TABLE[143];
return &VU_INSTRUCTION_TABLE[143];
case 3:
return VU_INSTRUCTION_TABLE[144];
return &VU_INSTRUCTION_TABLE[144];
case 4:
return VU_INSTRUCTION_TABLE[145];
return &VU_INSTRUCTION_TABLE[145];
case 5:
return VU_INSTRUCTION_TABLE[146];
return &VU_INSTRUCTION_TABLE[146];
case 6:
return VU_INSTRUCTION_TABLE[147];
return &VU_INSTRUCTION_TABLE[147];
case 7:
return VU_INSTRUCTION_TABLE[148];
return &VU_INSTRUCTION_TABLE[148];
case 8:
return VU_INSTRUCTION_TABLE[149];
return &VU_INSTRUCTION_TABLE[149];
case 9:
return VU_INSTRUCTION_TABLE[150];
return &VU_INSTRUCTION_TABLE[150];
case 10:
return VU_INSTRUCTION_TABLE[151];
return &VU_INSTRUCTION_TABLE[151];
case 11:
return VU_INSTRUCTION_TABLE[152];
return &VU_INSTRUCTION_TABLE[152];
default:
throw std::runtime_error("VU: Could not determine the upper instruction");
}
@ -589,27 +589,27 @@ MipsInstructionInfo VuInstruction::upper_lookup() const
switch (fd())
{
case 0:
return VU_INSTRUCTION_TABLE[153];
return &VU_INSTRUCTION_TABLE[153];
case 1:
return VU_INSTRUCTION_TABLE[154];
return &VU_INSTRUCTION_TABLE[154];
case 2:
return VU_INSTRUCTION_TABLE[155];
return &VU_INSTRUCTION_TABLE[155];
case 3:
return VU_INSTRUCTION_TABLE[156];
return &VU_INSTRUCTION_TABLE[156];
case 4:
return VU_INSTRUCTION_TABLE[157];
return &VU_INSTRUCTION_TABLE[157];
case 5:
return VU_INSTRUCTION_TABLE[158];
return &VU_INSTRUCTION_TABLE[158];
case 6:
return VU_INSTRUCTION_TABLE[159];
return &VU_INSTRUCTION_TABLE[159];
case 7:
return VU_INSTRUCTION_TABLE[160];
return &VU_INSTRUCTION_TABLE[160];
case 8:
return VU_INSTRUCTION_TABLE[161];
return &VU_INSTRUCTION_TABLE[161];
case 9:
return VU_INSTRUCTION_TABLE[162];
return &VU_INSTRUCTION_TABLE[162];
case 11:
return VU_INSTRUCTION_TABLE[163];
return &VU_INSTRUCTION_TABLE[163];
default:
throw std::runtime_error("VU: Could not determine the upper instruction");
}
@ -619,3 +619,19 @@ MipsInstructionInfo VuInstruction::upper_lookup() const
throw std::runtime_error("VU: Could not determine the upper instruction");
}
}
MipsInstructionInfo& VuInstruction::get_lower_info() const
{
if (!lower_info)
lower_info = lower_lookup();
return *lower_info;
}
MipsInstructionInfo& VuInstruction::get_upper_info() const
{
if (!upper_info)
upper_info = upper_lookup();
return *upper_info;
}

11
liborbum/src/Resources/Ee/Vpu/Vu/VuInstruction.hpp
View file

@ -167,6 +167,13 @@ struct VuInstruction : public MipsInstruction
return W.extract_from(value) > 0;
}
MipsInstructionInfo lower_lookup() const;
MipsInstructionInfo upper_lookup() const;
MipsInstructionInfo& get_lower_info() const;
MipsInstructionInfo& get_upper_info() const;
private:
MipsInstructionInfo* lower_lookup() const;
MipsInstructionInfo* upper_lookup() const;
mutable MipsInstructionInfo* lower_info;
mutable MipsInstructionInfo* upper_info;
};

4
liborbum/src/Resources/Ee/Vpu/Vu/VuInstructionDecoder.cpp
View file

@ -246,7 +246,7 @@ std::optional<int> VuInstructionDecoder::try_get_src(int idx) const
default:
return std::nullopt;
}
};
case 1: switch (decoded)
{
@ -263,7 +263,7 @@ std::optional<int> VuInstructionDecoder::try_get_src(int idx) const
default:
return std::nullopt;
}
};
default:
return std::nullopt;

6
liborbum/src/Resources/Iop/Core/IopCoreInstruction.hpp
View file

@ -22,7 +22,7 @@ struct IopCoreInstruction : public MipsInstruction
static constexpr int CPI_COP_BRANCH_DELAY = 20;
/// Performs a lookup if required and returns the instruction details.
const MipsInstructionInfo* get_info()
const MipsInstructionInfo* get_info() const
{
if (!info)
info = lookup();
@ -31,8 +31,8 @@ struct IopCoreInstruction : public MipsInstruction
private:
/// Instruction information (from performing lookup).
MipsInstructionInfo* info;
mutable const MipsInstructionInfo* info;
/// Determines what instruction this is by performing a lookup.
MipsInstructionInfo* lookup() const;
};
};