ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #6517 from lioncash/ppctables 

PPCTables: Namespace all exposed functions
This commit is contained in:
Léo Lam 2018-03-24 22:17:36 +01:00 committed by GitHub
parent 3c3d2be5ff 8a7abd72b4
commit 328ac424c0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 45 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/Core/Core/PowerPC/CachedInterpreter/CachedInterpreter.cpp
View File

@ -241,7 +241,7 @@ void CachedInterpreter::Jit(u32 address)
if (endblock || memcheck) if (endblock || memcheck)
m_code.emplace_back(WritePC, ops[i].address); m_code.emplace_back(WritePC, ops[i].address);
m_code.emplace_back(GetInterpreterOp(ops[i].inst), ops[i].inst); m_code.emplace_back(PPCTables::GetInterpreterOp(ops[i].inst), ops[i].inst);
if (memcheck) if (memcheck)
m_code.emplace_back(CheckDSI, js.downcountAmount); m_code.emplace_back(CheckDSI, js.downcountAmount);
if (endblock) if (endblock)

2
Source/Core/Core/PowerPC/Interpreter/Interpreter.cpp
View File

@ -193,7 +193,7 @@ int Interpreter::SingleStepInner()
last_pc = PC; last_pc = PC;
PC = NPC; PC = NPC;
GekkoOPInfo* opinfo = GetOpInfo(instCode); const GekkoOPInfo* opinfo = PPCTables::GetOpInfo(instCode);
return opinfo->numCycles; return opinfo->numCycles;
} }

2
Source/Core/Core/PowerPC/Jit64/Jit.cpp
View File

@ -287,7 +287,7 @@ void Jit64::FallBackToInterpreter(UGeckoInstruction inst)
MOV(32, PPCSTATE(pc), Imm32(js.compilerPC)); MOV(32, PPCSTATE(pc), Imm32(js.compilerPC));
MOV(32, PPCSTATE(npc), Imm32(js.compilerPC + 4)); MOV(32, PPCSTATE(npc), Imm32(js.compilerPC + 4));
} }
Interpreter::Instruction instr = GetInterpreterOp(inst); Interpreter::Instruction instr = PPCTables::GetInterpreterOp(inst);
ABI_PushRegistersAndAdjustStack({}, 0); ABI_PushRegistersAndAdjustStack({}, 0);
ABI_CallFunctionC(instr, inst.hex); ABI_CallFunctionC(instr, inst.hex);
ABI_PopRegistersAndAdjustStack({}, 0); ABI_PopRegistersAndAdjustStack({}, 0);

2
Source/Core/Core/PowerPC/JitArm64/Jit.cpp
View File

@ -149,7 +149,7 @@ void JitArm64::FallBackToInterpreter(UGeckoInstruction inst)
gpr.Unlock(WA); gpr.Unlock(WA);
} }
Interpreter::Instruction instr = GetInterpreterOp(inst); Interpreter::Instruction instr = PPCTables::GetInterpreterOp(inst);
MOVI2R(W0, inst.hex); MOVI2R(W0, inst.hex);
MOVP2R(X30, instr); MOVP2R(X30, instr);
BLR(X30); BLR(X30);

4
Source/Core/Core/PowerPC/JitInterface.cpp
View File

@ -239,8 +239,8 @@ void CompileExceptionCheck(ExceptionType type)
if (type == ExceptionType::FIFOWrite) if (type == ExceptionType::FIFOWrite)
{ {
// Check in case the code has been replaced since: do we need to do this? // Check in case the code has been replaced since: do we need to do this?
const ::OpType optype = GetOpInfo(PowerPC::HostRead_U32(PC))->type; const OpType optype = PPCTables::GetOpInfo(PowerPC::HostRead_U32(PC))->type;
if (optype != ::OpType::Store && optype != ::OpType::StoreFP && optype != ::OpType::StorePS) if (optype != OpType::Store && optype != OpType::StoreFP && optype != OpType::StorePS)
return; return;
} }
exception_addresses->insert(PC); exception_addresses->insert(PC);

2
Source/Core/Core/PowerPC/PPCAnalyst.cpp
View File

@ -726,7 +726,7 @@ u32 PPCAnalyzer::Analyze(u32 address, CodeBlock* block, CodeBuffer* buffer, u32
num_inst++; num_inst++;
memset(&code[i], 0, sizeof(CodeOp)); memset(&code[i], 0, sizeof(CodeOp));
GekkoOPInfo* opinfo = GetOpInfo(inst); GekkoOPInfo* opinfo = PPCTables::GetOpInfo(inst);
code[i].opinfo = opinfo; code[i].opinfo = opinfo;
code[i].address = address; code[i].address = address;

61
Source/Core/Core/PowerPC/PPCTables.cpp
View File

@ -41,25 +41,27 @@ const std::array<u64, 16> m_crTable = {{
}}; }};
} // namespace PowerPC } // namespace PowerPC
GekkoOPInfo* GetOpInfo(UGeckoInstruction _inst) namespace PPCTables
{ {
GekkoOPInfo* info = m_infoTable[_inst.OPCD]; GekkoOPInfo* GetOpInfo(UGeckoInstruction inst)
{
const GekkoOPInfo* info = m_infoTable[inst.OPCD];
if (info->type == OpType::Subtable) if (info->type == OpType::Subtable)
{ {
switch (_inst.OPCD) switch (inst.OPCD)
{ {
case 4: case 4:
return m_infoTable4[_inst.SUBOP10]; return m_infoTable4[inst.SUBOP10];
case 19: case 19:
return m_infoTable19[_inst.SUBOP10]; return m_infoTable19[inst.SUBOP10];
case 31: case 31:
return m_infoTable31[_inst.SUBOP10]; return m_infoTable31[inst.SUBOP10];
case 59: case 59:
return m_infoTable59[_inst.SUBOP5]; return m_infoTable59[inst.SUBOP5];
case 63: case 63:
return m_infoTable63[_inst.SUBOP10]; return m_infoTable63[inst.SUBOP10];
default: default:
ASSERT_MSG(POWERPC, 0, "GetOpInfo - invalid subtable op %08x @ %08x", _inst.hex, PC); ASSERT_MSG(POWERPC, 0, "GetOpInfo - invalid subtable op %08x @ %08x", inst.hex, PC);
return nullptr; return nullptr;
} }
} }
@ -67,32 +69,32 @@ GekkoOPInfo* GetOpInfo(UGeckoInstruction _inst)
{ {
if (info->type == OpType::Invalid) if (info->type == OpType::Invalid)
{ {
ASSERT_MSG(POWERPC, 0, "GetOpInfo - invalid op %08x @ %08x", _inst.hex, PC); ASSERT_MSG(POWERPC, 0, "GetOpInfo - invalid op %08x @ %08x", inst.hex, PC);
return nullptr; return nullptr;
} }
return m_infoTable[_inst.OPCD]; return m_infoTable[inst.OPCD];
} }
} }
Interpreter::Instruction GetInterpreterOp(UGeckoInstruction _inst) Interpreter::Instruction GetInterpreterOp(UGeckoInstruction inst)
{ {
const GekkoOPInfo* info = m_infoTable[_inst.OPCD]; const GekkoOPInfo* info = m_infoTable[inst.OPCD];
if (info->type == OpType::Subtable) if (info->type == OpType::Subtable)
{ {
switch (_inst.OPCD) switch (inst.OPCD)
{ {
case 4: case 4:
return Interpreter::m_op_table4[_inst.SUBOP10]; return Interpreter::m_op_table4[inst.SUBOP10];
case 19: case 19:
return Interpreter::m_op_table19[_inst.SUBOP10]; return Interpreter::m_op_table19[inst.SUBOP10];
case 31: case 31:
return Interpreter::m_op_table31[_inst.SUBOP10]; return Interpreter::m_op_table31[inst.SUBOP10];
case 59: case 59:
return Interpreter::m_op_table59[_inst.SUBOP5]; return Interpreter::m_op_table59[inst.SUBOP5];
case 63: case 63:
return Interpreter::m_op_table63[_inst.SUBOP10]; return Interpreter::m_op_table63[inst.SUBOP10];
default: default:
ASSERT_MSG(POWERPC, 0, "GetInterpreterOp - invalid subtable op %08x @ %08x", _inst.hex, PC); ASSERT_MSG(POWERPC, 0, "GetInterpreterOp - invalid subtable op %08x @ %08x", inst.hex, PC);
return nullptr; return nullptr;
} }
} }
@ -100,14 +102,13 @@ Interpreter::Instruction GetInterpreterOp(UGeckoInstruction _inst)
{ {
if (info->type == OpType::Invalid) if (info->type == OpType::Invalid)
{ {
ASSERT_MSG(POWERPC, 0, "GetInterpreterOp - invalid op %08x @ %08x", _inst.hex, PC); ASSERT_MSG(POWERPC, 0, "GetInterpreterOp - invalid op %08x @ %08x", inst.hex, PC);
return nullptr; return nullptr;
} }
return Interpreter::m_op_table[_inst.OPCD]; return Interpreter::m_op_table[inst.OPCD];
} }
} }
namespace PPCTables
{
bool UsesFPU(UGeckoInstruction inst) bool UsesFPU(UGeckoInstruction inst)
{ {
GekkoOPInfo* const info = GetOpInfo(inst); GekkoOPInfo* const info = GetOpInfo(inst);
@ -125,21 +126,21 @@ std::vector<u32> rsplocations;
} }
#endif #endif
const char* GetInstructionName(UGeckoInstruction _inst) const char* GetInstructionName(UGeckoInstruction inst)
{ {
const GekkoOPInfo* info = GetOpInfo(_inst); const GekkoOPInfo* info = GetOpInfo(inst);
return info ? info->opname : nullptr; return info ? info->opname : nullptr;
} }
bool IsValidInstruction(UGeckoInstruction _inst) bool IsValidInstruction(UGeckoInstruction inst)
{ {
const GekkoOPInfo* info = GetOpInfo(_inst); const GekkoOPInfo* info = GetOpInfo(inst);
return info != nullptr && info->type != OpType::Unknown; return info != nullptr && info->type != OpType::Unknown;
} }
void CountInstruction(UGeckoInstruction _inst) void CountInstruction(UGeckoInstruction inst)
{ {
GekkoOPInfo* info = GetOpInfo(_inst); GekkoOPInfo* info = GetOpInfo(inst);
if (info) if (info)
{ {
info->runCount++; info->runCount++;

14
Source/Core/Core/PowerPC/PPCTables.h
View File

@ -105,16 +105,16 @@ extern std::array<GekkoOPInfo*, 1024> m_infoTable63;
extern std::array<GekkoOPInfo*, 512> m_allInstructions; extern std::array<GekkoOPInfo*, 512> m_allInstructions;
extern size_t m_numInstructions; extern size_t m_numInstructions;
GekkoOPInfo* GetOpInfo(UGeckoInstruction _inst);
Interpreter::Instruction GetInterpreterOp(UGeckoInstruction _inst);
namespace PPCTables namespace PPCTables
{ {
bool IsValidInstruction(UGeckoInstruction _instCode); GekkoOPInfo* GetOpInfo(UGeckoInstruction inst);
bool UsesFPU(UGeckoInstruction _inst); Interpreter::Instruction GetInterpreterOp(UGeckoInstruction inst);
void CountInstruction(UGeckoInstruction _inst); bool IsValidInstruction(UGeckoInstruction inst);
bool UsesFPU(UGeckoInstruction inst);
void CountInstruction(UGeckoInstruction inst);
void PrintInstructionRunCounts(); void PrintInstructionRunCounts();
void LogCompiledInstructions(); void LogCompiledInstructions();
const char* GetInstructionName(UGeckoInstruction _inst); const char* GetInstructionName(UGeckoInstruction inst);
} // namespace PPCTables } // namespace PPCTables