diff --git a/CMakeLists.txt b/CMakeLists.txt
index d9064cbf14..5edd305185 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1556,6 +1556,8 @@ set(CoreExtra ${CoreExtra}
Core/MIPS/IR/IRInterpreter.h
Core/MIPS/IR/IRJit.cpp
Core/MIPS/IR/IRJit.h
+ Core/MIPS/IR/IRNativeCommon.cpp
+ Core/MIPS/IR/IRNativeCommon.h
Core/MIPS/IR/IRPassSimplify.cpp
Core/MIPS/IR/IRPassSimplify.h
Core/MIPS/IR/IRRegCache.cpp
diff --git a/Common/CodeBlock.h b/Common/CodeBlock.h
index f7fc8a2481..766d0a1cca 100644
--- a/Common/CodeBlock.h
+++ b/Common/CodeBlock.h
@@ -32,7 +32,7 @@ public:
virtual const u8 *GetCodePtr() const = 0;
- u8 *GetBasePtr() {
+ u8 *GetBasePtr() const {
return region;
}
diff --git a/Core/Core.vcxproj b/Core/Core.vcxproj
index 9794f02f81..9a83c34f78 100644
--- a/Core/Core.vcxproj
+++ b/Core/Core.vcxproj
@@ -591,6 +591,7 @@
+
@@ -1170,6 +1171,7 @@
+
diff --git a/Core/Core.vcxproj.filters b/Core/Core.vcxproj.filters
index e437d0d813..9378881742 100644
--- a/Core/Core.vcxproj.filters
+++ b/Core/Core.vcxproj.filters
@@ -1240,6 +1240,9 @@
MIPS\IR
+
+ MIPS\IR
+
@@ -1998,6 +2001,9 @@
MIPS\IR
+
+ MIPS\IR
+
diff --git a/Core/MIPS/IR/IRJit.h b/Core/MIPS/IR/IRJit.h
index 35387e7e44..241e43fc41 100644
--- a/Core/MIPS/IR/IRJit.h
+++ b/Core/MIPS/IR/IRJit.h
@@ -124,6 +124,13 @@ public:
return nullptr;
}
}
+ const IRBlock *GetBlock(int i) const {
+ if (i >= 0 && i < (int)blocks_.size()) {
+ return &blocks_[i];
+ } else {
+ return nullptr;
+ }
+ }
int FindPreloadBlock(u32 em_address);
int FindByCookie(int cookie);
@@ -180,7 +187,7 @@ public:
void UnlinkBlock(u8 *checkedEntry, u32 originalAddress) override;
protected:
- virtual bool CompileBlock(u32 em_address, std::vector &instructions, u32 &mipsBytes, bool preload);
+ bool CompileBlock(u32 em_address, std::vector &instructions, u32 &mipsBytes, bool preload);
virtual bool CompileTargetBlock(IRBlock *block, int block_num, bool preload) { return true; }
JitOptions jo;
diff --git a/Core/MIPS/IR/IRNativeCommon.cpp b/Core/MIPS/IR/IRNativeCommon.cpp
new file mode 100644
index 0000000000..eb56319d75
--- /dev/null
+++ b/Core/MIPS/IR/IRNativeCommon.cpp
@@ -0,0 +1,590 @@
+// Copyright (c) 2023- 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 "Common/Profiler/Profiler.h"
+#include "Common/StringUtils.h"
+#include "Common/TimeUtil.h"
+#include "Core/MIPS/MIPSTables.h"
+#include "Core/MIPS/IR/IRNativeCommon.h"
+
+using namespace MIPSComp;
+
+namespace MIPSComp {
+
+// Compile time flag to enable debug stats for not compiled ops.
+static constexpr bool enableDebugStats = false;
+
+// Used only for debugging when enableDebug is true above.
+static std::map debugSeenNotCompiledIR;
+static std::map debugSeenNotCompiled;
+static double lastDebugStatsLog = 0.0;
+
+static void LogDebugStats() {
+ if (!enableDebugStats)
+ return;
+
+ double now = time_now_d();
+ if (now < lastDebugStatsLog + 1.0)
+ return;
+ lastDebugStatsLog = now;
+
+ int worstIROp = -1;
+ int worstIRVal = 0;
+ for (auto it : debugSeenNotCompiledIR) {
+ if (it.second > worstIRVal) {
+ worstIRVal = it.second;
+ worstIROp = it.first;
+ }
+ }
+ debugSeenNotCompiledIR.clear();
+
+ const char *worstName = nullptr;
+ int worstVal = 0;
+ for (auto it : debugSeenNotCompiled) {
+ if (it.second > worstVal) {
+ worstVal = it.second;
+ worstName = it.first;
+ }
+ }
+ debugSeenNotCompiled.clear();
+
+ if (worstIROp != -1)
+ WARN_LOG(JIT, "Most not compiled IR op: %s (%d)", GetIRMeta((IROp)worstIROp)->name, worstIRVal);
+ if (worstName != nullptr)
+ WARN_LOG(JIT, "Most not compiled op: %s (%d)", worstName, worstVal);
+}
+
+bool IRNativeBackend::DebugStatsEnabled() const {
+ return enableDebugStats;
+}
+
+void IRNativeBackend::NotifyMIPSInterpret(const char *name) {
+ _assert_(enableDebugStats);
+ debugSeenNotCompiled[name]++;
+}
+
+void IRNativeBackend::DoMIPSInst(uint32_t value) {
+ MIPSOpcode op;
+ memcpy(&op, &value, sizeof(op));
+
+ if constexpr (enableDebugStats)
+ debugSeenNotCompiled[MIPSGetName(op)]++;
+
+ MIPSInterpret(op);
+}
+
+uint32_t IRNativeBackend::DoIRInst(uint64_t value) {
+ IRInst inst;
+ memcpy(&inst, &value, sizeof(inst));
+
+ if constexpr (enableDebugStats)
+ debugSeenNotCompiledIR[(uint8_t)inst.op]++;
+
+ return IRInterpret(currentMIPS, &inst, 1);
+}
+
+void IRNativeBackend::CompileIRInst(IRInst inst) {
+ switch (inst.op) {
+ case IROp::Nop:
+ break;
+
+ case IROp::SetConst:
+ case IROp::SetConstF:
+ case IROp::Downcount:
+ case IROp::SetPC:
+ case IROp::SetPCConst:
+ CompIR_Basic(inst);
+ break;
+
+ case IROp::Add:
+ case IROp::Sub:
+ case IROp::AddConst:
+ case IROp::SubConst:
+ case IROp::Neg:
+ CompIR_Arith(inst);
+ break;
+
+ case IROp::And:
+ case IROp::Or:
+ case IROp::Xor:
+ case IROp::AndConst:
+ case IROp::OrConst:
+ case IROp::XorConst:
+ case IROp::Not:
+ CompIR_Logic(inst);
+ break;
+
+ case IROp::Mov:
+ case IROp::Ext8to32:
+ case IROp::Ext16to32:
+ CompIR_Assign(inst);
+ break;
+
+ case IROp::ReverseBits:
+ case IROp::BSwap16:
+ case IROp::BSwap32:
+ case IROp::Clz:
+ CompIR_Bits(inst);
+ break;
+
+ case IROp::Shl:
+ case IROp::Shr:
+ case IROp::Sar:
+ case IROp::Ror:
+ case IROp::ShlImm:
+ case IROp::ShrImm:
+ case IROp::SarImm:
+ case IROp::RorImm:
+ CompIR_Shift(inst);
+ break;
+
+ case IROp::Slt:
+ case IROp::SltConst:
+ case IROp::SltU:
+ case IROp::SltUConst:
+ CompIR_Compare(inst);
+ break;
+
+ case IROp::MovZ:
+ case IROp::MovNZ:
+ case IROp::Max:
+ case IROp::Min:
+ CompIR_CondAssign(inst);
+ break;
+
+ case IROp::MtLo:
+ case IROp::MtHi:
+ case IROp::MfLo:
+ case IROp::MfHi:
+ CompIR_HiLo(inst);
+ break;
+
+ case IROp::Mult:
+ case IROp::MultU:
+ case IROp::Madd:
+ case IROp::MaddU:
+ case IROp::Msub:
+ case IROp::MsubU:
+ CompIR_Mult(inst);
+ break;
+
+ case IROp::Div:
+ case IROp::DivU:
+ CompIR_Div(inst);
+ break;
+
+ case IROp::Load8:
+ case IROp::Load8Ext:
+ case IROp::Load16:
+ case IROp::Load16Ext:
+ case IROp::Load32:
+ case IROp::Load32Linked:
+ CompIR_Load(inst);
+ break;
+
+ case IROp::Load32Left:
+ case IROp::Load32Right:
+ CompIR_LoadShift(inst);
+ break;
+
+ case IROp::LoadFloat:
+ CompIR_FLoad(inst);
+ break;
+
+ case IROp::LoadVec4:
+ CompIR_VecLoad(inst);
+ break;
+
+ case IROp::Store8:
+ case IROp::Store16:
+ case IROp::Store32:
+ CompIR_Store(inst);
+ break;
+
+ case IROp::Store32Conditional:
+ CompIR_CondStore(inst);
+ break;
+
+ case IROp::Store32Left:
+ case IROp::Store32Right:
+ CompIR_StoreShift(inst);
+ break;
+
+ case IROp::StoreFloat:
+ CompIR_FStore(inst);
+ break;
+
+ case IROp::StoreVec4:
+ CompIR_VecStore(inst);
+ break;
+
+ case IROp::FAdd:
+ case IROp::FSub:
+ case IROp::FMul:
+ case IROp::FDiv:
+ case IROp::FSqrt:
+ case IROp::FNeg:
+ CompIR_FArith(inst);
+ break;
+
+ case IROp::FMin:
+ case IROp::FMax:
+ CompIR_FCondAssign(inst);
+ break;
+
+ case IROp::FMov:
+ case IROp::FAbs:
+ case IROp::FSign:
+ CompIR_FAssign(inst);
+ break;
+
+ case IROp::FRound:
+ case IROp::FTrunc:
+ case IROp::FCeil:
+ case IROp::FFloor:
+ CompIR_FRound(inst);
+ break;
+
+ case IROp::FCvtWS:
+ case IROp::FCvtSW:
+ case IROp::FCvtScaledWS:
+ case IROp::FCvtScaledSW:
+ CompIR_FCvt(inst);
+ break;
+
+ case IROp::FSat0_1:
+ case IROp::FSatMinus1_1:
+ CompIR_FSat(inst);
+ break;
+
+ case IROp::FCmp:
+ case IROp::FCmovVfpuCC:
+ case IROp::FCmpVfpuBit:
+ case IROp::FCmpVfpuAggregate:
+ CompIR_FCompare(inst);
+ break;
+
+ case IROp::RestoreRoundingMode:
+ case IROp::ApplyRoundingMode:
+ case IROp::UpdateRoundingMode:
+ CompIR_RoundingMode(inst);
+ break;
+
+ case IROp::SetCtrlVFPU:
+ case IROp::SetCtrlVFPUReg:
+ case IROp::SetCtrlVFPUFReg:
+ case IROp::FpCondToReg:
+ case IROp::ZeroFpCond:
+ case IROp::FpCtrlFromReg:
+ case IROp::FpCtrlToReg:
+ case IROp::VfpuCtrlToReg:
+ case IROp::FMovFromGPR:
+ case IROp::FMovToGPR:
+ CompIR_Transfer(inst);
+ break;
+
+ case IROp::Vec4Init:
+ case IROp::Vec4Shuffle:
+ case IROp::Vec4Mov:
+ CompIR_VecAssign(inst);
+ break;
+
+ case IROp::Vec4Add:
+ case IROp::Vec4Sub:
+ case IROp::Vec4Mul:
+ case IROp::Vec4Div:
+ case IROp::Vec4Scale:
+ case IROp::Vec4Neg:
+ case IROp::Vec4Abs:
+ CompIR_VecArith(inst);
+ break;
+
+ case IROp::Vec4Dot:
+ CompIR_VecHoriz(inst);
+ break;
+
+ case IROp::Vec2Unpack16To31:
+ case IROp::Vec2Unpack16To32:
+ case IROp::Vec4Unpack8To32:
+ case IROp::Vec4DuplicateUpperBitsAndShift1:
+ case IROp::Vec4Pack31To8:
+ case IROp::Vec4Pack32To8:
+ case IROp::Vec2Pack31To16:
+ case IROp::Vec2Pack32To16:
+ CompIR_VecPack(inst);
+ break;
+
+ case IROp::Vec4ClampToZero:
+ case IROp::Vec2ClampToZero:
+ CompIR_VecClamp(inst);
+ break;
+
+ case IROp::FSin:
+ case IROp::FCos:
+ case IROp::FRSqrt:
+ case IROp::FRecip:
+ case IROp::FAsin:
+ CompIR_FSpecial(inst);
+ break;
+
+ case IROp::Interpret:
+ CompIR_Interpret(inst);
+ break;
+
+ case IROp::Syscall:
+ case IROp::CallReplacement:
+ case IROp::Break:
+ CompIR_System(inst);
+ break;
+
+ case IROp::Breakpoint:
+ case IROp::MemoryCheck:
+ CompIR_Breakpoint(inst);
+ break;
+
+ case IROp::ValidateAddress8:
+ case IROp::ValidateAddress16:
+ case IROp::ValidateAddress32:
+ case IROp::ValidateAddress128:
+ CompIR_ValidateAddress(inst);
+ break;
+
+ case IROp::ExitToConst:
+ case IROp::ExitToReg:
+ case IROp::ExitToPC:
+ CompIR_Exit(inst);
+ break;
+
+ case IROp::ExitToConstIfEq:
+ case IROp::ExitToConstIfNeq:
+ case IROp::ExitToConstIfGtZ:
+ case IROp::ExitToConstIfGeZ:
+ case IROp::ExitToConstIfLtZ:
+ case IROp::ExitToConstIfLeZ:
+ case IROp::ExitToConstIfFpTrue:
+ case IROp::ExitToConstIfFpFalse:
+ CompIR_ExitIf(inst);
+ break;
+
+ default:
+ _assert_msg_(false, "Unexpected IR op %d", (int)inst.op);
+ CompIR_Generic(inst);
+ break;
+ }
+}
+
+IRNativeJit::IRNativeJit(MIPSState *mipsState)
+ : IRJit(mipsState), debugInterface_(blocks_) {}
+
+void IRNativeJit::Init(IRNativeBackend &backend) {
+ backend_ = &backend;
+ debugInterface_.Init(&backend_->CodeBlock());
+ backend_->GenerateFixedCode();
+
+ // Wanted this to be a reference, but vtbls get in the way. Shouldn't change.
+ hooks_ = backend.GetNativeHooks();
+}
+
+bool IRNativeJit::CompileTargetBlock(IRBlock *block, int block_num, bool preload) {
+ return backend_->CompileBlock(block, block_num, preload);
+}
+
+void IRNativeJit::RunLoopUntil(u64 globalticks) {
+ if constexpr (enableDebugStats) {
+ LogDebugStats();
+ }
+
+ PROFILE_THIS_SCOPE("jit");
+ hooks_.enterDispatcher();
+}
+
+void IRNativeJit::ClearCache() {
+ IRJit::ClearCache();
+ backend_->ClearAllBlocks();
+}
+
+bool IRNativeJit::DescribeCodePtr(const u8 *ptr, std::string &name) {
+ if (ptr != nullptr && backend_->DescribeCodePtr(ptr, name))
+ return true;
+
+ int offset = backend_->OffsetFromCodePtr(ptr);
+ if (offset == -1)
+ return false;
+
+ int block_num = -1;
+ for (int i = 0; i < blocks_.GetNumBlocks(); ++i) {
+ const auto &b = blocks_.GetBlock(i);
+ // We allocate linearly.
+ if (b->GetTargetOffset() <= offset)
+ block_num = i;
+ if (b->GetTargetOffset() > offset)
+ break;
+ }
+
+ if (block_num == -1) {
+ name = "(unknown or deleted block)";
+ return true;
+ }
+
+ const IRBlock *block = blocks_.GetBlock(block_num);
+ if (block) {
+ u32 start = 0, size = 0;
+ block->GetRange(start, size);
+ name = StringFromFormat("(block %d at %08x)", block_num, start);
+ return true;
+ }
+ return false;
+}
+
+bool IRNativeJit::CodeInRange(const u8 *ptr) const {
+ return backend_->CodeInRange(ptr);
+}
+
+bool IRNativeJit::IsAtDispatchFetch(const u8 *ptr) const {
+ return ptr == backend_->GetNativeHooks().dispatchFetch;
+}
+
+const u8 *IRNativeJit::GetDispatcher() const {
+ return backend_->GetNativeHooks().dispatcher;
+}
+
+const u8 *IRNativeJit::GetCrashHandler() const {
+ return backend_->GetNativeHooks().crashHandler;
+}
+
+JitBlockCacheDebugInterface *IRNativeJit::GetBlockCacheDebugInterface() {
+ return &debugInterface_;
+}
+
+bool IRNativeBackend::CodeInRange(const u8 *ptr) const {
+ return CodeBlock().IsInSpace(ptr);
+}
+
+bool IRNativeBackend::DescribeCodePtr(const u8 *ptr, std::string &name) const {
+ if (!CodeBlock().IsInSpace(ptr))
+ return false;
+
+ // Used in disassembly viewer.
+ if (ptr == (const uint8_t *)hooks_.enterDispatcher) {
+ name = "enterDispatcher";
+ } else if (ptr == hooks_.dispatcher) {
+ name = "dispatcher";
+ } else if (ptr == hooks_.dispatchFetch) {
+ name = "dispatchFetch";
+ } else if (ptr == hooks_.crashHandler) {
+ name = "crashHandler";
+ } else {
+ return false;
+ }
+ return true;
+}
+
+int IRNativeBackend::OffsetFromCodePtr(const u8 *ptr) {
+ auto &codeBlock = CodeBlock();
+ if (!codeBlock.IsInSpace(ptr))
+ return -1;
+ return (int)codeBlock.GetOffset(ptr);
+}
+
+} // namespace MIPSComp
+
+IRNativeBlockCacheDebugInterface::IRNativeBlockCacheDebugInterface(const IRBlockCache &irBlocks)
+ : irBlocks_(irBlocks) {}
+
+void IRNativeBlockCacheDebugInterface::Init(const CodeBlockCommon *codeBlock) {
+ codeBlock_ = codeBlock;
+}
+
+int IRNativeBlockCacheDebugInterface::GetNumBlocks() const {
+ return irBlocks_.GetNumBlocks();
+}
+
+int IRNativeBlockCacheDebugInterface::GetBlockNumberFromStartAddress(u32 em_address, bool realBlocksOnly) const {
+ return irBlocks_.GetBlockNumberFromStartAddress(em_address, realBlocksOnly);
+}
+
+void IRNativeBlockCacheDebugInterface::GetBlockCodeRange(int blockNum, int *startOffset, int *size) const {
+ int blockOffset = irBlocks_.GetBlock(blockNum)->GetTargetOffset();
+ int endOffset;
+ // We assume linear allocation. Maybe a bit dangerous, should always be right.
+ if (blockNum + 1 >= GetNumBlocks()) {
+ // Last block, get from current code pointer.
+ endOffset = (int)codeBlock_->GetOffset(codeBlock_->GetCodePtr());
+ } else {
+ endOffset = irBlocks_.GetBlock(blockNum + 1)->GetTargetOffset();
+ _assert_msg_(endOffset >= blockOffset, "Next block not sequential, block=%d/%08x, next=%d/%08x", blockNum, blockOffset, blockNum + 1, endOffset);
+ }
+
+ *startOffset = blockOffset;
+ *size = endOffset - blockOffset;
+}
+
+JitBlockDebugInfo IRNativeBlockCacheDebugInterface::GetBlockDebugInfo(int blockNum) const {
+ JitBlockDebugInfo debugInfo = irBlocks_.GetBlockDebugInfo(blockNum);
+
+ int blockOffset, codeSize;
+ GetBlockCodeRange(blockNum, &blockOffset, &codeSize);
+
+ // TODO: Normal entry?
+ const u8 *blockStart = codeBlock_->GetBasePtr() + blockOffset;
+#if PPSSPP_ARCH(ARM)
+ debugInfo.targetDisasm = DisassembleArm2(blockStart, codeSize);
+#elif PPSSPP_ARCH(ARM64)
+ debugInfo.targetDisasm = DisassembleArm64(blockStart, codeSize);
+#elif PPSSPP_ARCH(X86) || PPSSPP_ARCH(AMD64)
+ debugInfo.targetDisasm = DisassembleX86(blockStart, codeSize);
+#elif PPSSPP_ARCH(RISCV64)
+ debugInfo.targetDisasm = DisassembleRV64(blockStart, codeSize);
+#endif
+ return debugInfo;
+}
+
+void IRNativeBlockCacheDebugInterface::ComputeStats(BlockCacheStats &bcStats) const {
+ double totalBloat = 0.0;
+ double maxBloat = 0.0;
+ double minBloat = 1000000000.0;
+ int numBlocks = GetNumBlocks();
+ for (int i = 0; i < numBlocks; ++i) {
+ const IRBlock &b = *irBlocks_.GetBlock(i);
+
+ // Native size, not IR size.
+ int blockOffset, codeSize;
+ GetBlockCodeRange(i, &blockOffset, &codeSize);
+ if (codeSize == 0)
+ continue;
+
+ // MIPS (PSP) size.
+ u32 origAddr, origSize;
+ b.GetRange(origAddr, origSize);
+
+ double bloat = (double)codeSize / (double)origSize;
+ if (bloat < minBloat) {
+ minBloat = bloat;
+ bcStats.minBloatBlock = origAddr;
+ }
+ if (bloat > maxBloat) {
+ maxBloat = bloat;
+ bcStats.maxBloatBlock = origAddr;
+ }
+ totalBloat += bloat;
+ bcStats.bloatMap[(float)bloat] = origAddr;
+ }
+ bcStats.numBlocks = numBlocks;
+ bcStats.minBloat = (float)minBloat;
+ bcStats.maxBloat = (float)maxBloat;
+ bcStats.avgBloat = (float)(totalBloat / (double)numBlocks);
+}
diff --git a/Core/MIPS/IR/IRNativeCommon.h b/Core/MIPS/IR/IRNativeCommon.h
new file mode 100644
index 0000000000..b9678dd12f
--- /dev/null
+++ b/Core/MIPS/IR/IRNativeCommon.h
@@ -0,0 +1,154 @@
+// Copyright (c) 2023- 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 "Core/MIPS/IR/IRJit.h"
+#include "Core/MIPS/JitCommon/JitBlockCache.h"
+
+class IRNativeBlockCacheDebugInterface : public JitBlockCacheDebugInterface {
+public:
+ IRNativeBlockCacheDebugInterface(const MIPSComp::IRBlockCache &irBlocks);
+ void Init(const CodeBlockCommon *codeBlock);
+ int GetNumBlocks() const;
+ int GetBlockNumberFromStartAddress(u32 em_address, bool realBlocksOnly = true) const;
+ JitBlockDebugInfo GetBlockDebugInfo(int blockNum) const;
+ void ComputeStats(BlockCacheStats &bcStats) const;
+
+private:
+ void GetBlockCodeRange(int blockNum, int *startOffset, int *size) const;
+
+ const MIPSComp::IRBlockCache &irBlocks_;
+ const CodeBlockCommon *codeBlock_ = nullptr;
+};
+
+namespace MIPSComp {
+
+typedef void (*IRNativeFuncNoArg)();
+
+struct IRNativeHooks {
+ IRNativeFuncNoArg enterDispatcher = nullptr;
+
+ const uint8_t *dispatcher = nullptr;
+ const uint8_t *dispatchFetch = nullptr;
+ const uint8_t *crashHandler = nullptr;
+};
+
+class IRNativeBackend {
+public:
+ virtual ~IRNativeBackend() {}
+
+ void CompileIRInst(IRInst inst);
+
+ virtual bool DescribeCodePtr(const u8 *ptr, std::string &name) const;
+ bool CodeInRange(const u8 *ptr) const;
+ int OffsetFromCodePtr(const u8 *ptr);
+
+ virtual void GenerateFixedCode() = 0;
+ virtual bool CompileBlock(IRBlock *block, int block_num, bool preload) = 0;
+ virtual void ClearAllBlocks() = 0;
+
+ const IRNativeHooks &GetNativeHooks() const {
+ return hooks_;
+ }
+
+ virtual const CodeBlockCommon &CodeBlock() const = 0;
+
+protected:
+ virtual void CompIR_Arith(IRInst inst) = 0;
+ virtual void CompIR_Assign(IRInst inst) = 0;
+ virtual void CompIR_Basic(IRInst inst) = 0;
+ virtual void CompIR_Bits(IRInst inst) = 0;
+ virtual void CompIR_Breakpoint(IRInst inst) = 0;
+ virtual void CompIR_Compare(IRInst inst) = 0;
+ virtual void CompIR_CondAssign(IRInst inst) = 0;
+ virtual void CompIR_CondStore(IRInst inst) = 0;
+ virtual void CompIR_Div(IRInst inst) = 0;
+ virtual void CompIR_Exit(IRInst inst) = 0;
+ virtual void CompIR_ExitIf(IRInst inst) = 0;
+ virtual void CompIR_FArith(IRInst inst) = 0;
+ virtual void CompIR_FAssign(IRInst inst) = 0;
+ virtual void CompIR_FCompare(IRInst inst) = 0;
+ virtual void CompIR_FCondAssign(IRInst inst) = 0;
+ virtual void CompIR_FCvt(IRInst inst) = 0;
+ virtual void CompIR_FLoad(IRInst inst) = 0;
+ virtual void CompIR_FRound(IRInst inst) = 0;
+ virtual void CompIR_FSat(IRInst inst) = 0;
+ virtual void CompIR_FSpecial(IRInst inst) = 0;
+ virtual void CompIR_FStore(IRInst inst) = 0;
+ virtual void CompIR_Generic(IRInst inst) = 0;
+ virtual void CompIR_HiLo(IRInst inst) = 0;
+ virtual void CompIR_Interpret(IRInst inst) = 0;
+ virtual void CompIR_Load(IRInst inst) = 0;
+ virtual void CompIR_LoadShift(IRInst inst) = 0;
+ virtual void CompIR_Logic(IRInst inst) = 0;
+ virtual void CompIR_Mult(IRInst inst) = 0;
+ virtual void CompIR_RoundingMode(IRInst inst) = 0;
+ virtual void CompIR_Shift(IRInst inst) = 0;
+ virtual void CompIR_Store(IRInst inst) = 0;
+ virtual void CompIR_StoreShift(IRInst inst) = 0;
+ virtual void CompIR_System(IRInst inst) = 0;
+ virtual void CompIR_Transfer(IRInst inst) = 0;
+ virtual void CompIR_VecArith(IRInst inst) = 0;
+ virtual void CompIR_VecAssign(IRInst inst) = 0;
+ virtual void CompIR_VecClamp(IRInst inst) = 0;
+ virtual void CompIR_VecHoriz(IRInst inst) = 0;
+ virtual void CompIR_VecLoad(IRInst inst) = 0;
+ virtual void CompIR_VecPack(IRInst inst) = 0;
+ virtual void CompIR_VecStore(IRInst inst) = 0;
+ virtual void CompIR_ValidateAddress(IRInst inst) = 0;
+
+ // Returns true when debugging statistics should be compiled in.
+ bool DebugStatsEnabled() const;
+
+ // Callback (compile when DebugStatsEnabled()) to log a base interpreter hit.
+ // Call the func returned by MIPSGetInterpretFunc(op) directly for interpret.
+ static void NotifyMIPSInterpret(const char *name);
+
+ // Callback to log AND perform a base interpreter op. Alternative to NotifyMIPSInterpret().
+ static void DoMIPSInst(uint32_t op);
+
+ // Callback to log AND perform an IR interpreter inst. Returns 0 or a PC to jump to.
+ static uint32_t DoIRInst(uint64_t inst);
+
+ IRNativeHooks hooks_;
+};
+
+class IRNativeJit : public IRJit {
+public:
+ IRNativeJit(MIPSState *mipsState);
+
+ void RunLoopUntil(u64 globalticks) override;
+
+ void ClearCache() override;
+
+ bool DescribeCodePtr(const u8 *ptr, std::string &name) override;
+ bool CodeInRange(const u8 *ptr) const override;
+ bool IsAtDispatchFetch(const u8 *ptr) const override;
+ const u8 *GetDispatcher() const override;
+ const u8 *GetCrashHandler() const override;
+
+ JitBlockCacheDebugInterface *GetBlockCacheDebugInterface() override;
+
+protected:
+ void Init(IRNativeBackend &backend);
+ bool CompileTargetBlock(IRBlock *block, int block_num, bool preload) override;
+
+ IRNativeBackend *backend_ = nullptr;
+ IRNativeHooks hooks_;
+ IRNativeBlockCacheDebugInterface debugInterface_;
+};
+
+} // namespace MIPSComp
diff --git a/Core/MIPS/RiscV/RiscVAsm.cpp b/Core/MIPS/RiscV/RiscVAsm.cpp
index e07b59760b..b38aba928e 100644
--- a/Core/MIPS/RiscV/RiscVAsm.cpp
+++ b/Core/MIPS/RiscV/RiscVAsm.cpp
@@ -44,17 +44,7 @@ static void ShowPC(u32 downcount, void *membase, void *jitbase) {
count++;
}
-static void ShowBlockError(int type) {
- if (type == 1) {
- ERROR_LOG(JIT, "[%08x] ShowBlockError: block num was out of range in emuhack", currentMIPS->pc);
- } else if (type == 2) {
- ERROR_LOG(JIT, "[%08x] ShowBlockError: block num pointed to null jitblock", currentMIPS->pc);
- } else {
- ERROR_LOG(JIT, "[%08x] ShowBlockError: invalid error type", currentMIPS->pc);
- }
-}
-
-void RiscVJit::GenerateFixedCode(const JitOptions &jo) {
+void RiscVJitBackend::GenerateFixedCode() {
BeginWrite(GetMemoryProtectPageSize());
const u8 *start = AlignCodePage();
@@ -104,7 +94,7 @@ void RiscVJit::GenerateFixedCode(const JitOptions &jo) {
RET();
}
- enterDispatcher_ = AlignCode16();
+ hooks_.enterDispatcher = (IRNativeFuncNoArg)AlignCode16();
// Start by saving some regs on the stack. There are 12 GPs and 12 FPs we want.
// Note: we leave R_SP as, well, SP, so it doesn't need to be saved.
@@ -157,7 +147,7 @@ void RiscVJit::GenerateFixedCode(const JitOptions &jo) {
dispatcherPCInSCRATCH1_ = GetCodePtr();
MovToPC(SCRATCH1);
- dispatcher_ = GetCodePtr();
+ hooks_.dispatcher = GetCodePtr();
FixupBranch bail = BLT(DOWNCOUNTREG, R_ZERO);
SetJumpTarget(skipToRealDispatch);
@@ -177,7 +167,7 @@ void RiscVJit::GenerateFixedCode(const JitOptions &jo) {
AND(SCRATCH1, SCRATCH1, SCRATCH2);
#endif
ADD(SCRATCH1, SCRATCH1, MEMBASEREG);
- dispatcherFetch_ = GetCodePtr();
+ hooks_.dispatchFetch = GetCodePtr();
LWU(SCRATCH1, SCRATCH1, 0);
SRLI(SCRATCH2, SCRATCH1, 24);
// We're in other words comparing to the top 8 bits of MIPS_EMUHACK_OPCODE by subtracting.
@@ -224,7 +214,7 @@ void RiscVJit::GenerateFixedCode(const JitOptions &jo) {
RET();
- crashHandler_ = GetCodePtr();
+ hooks_.crashHandler = GetCodePtr();
LI(SCRATCH1, &coreState, SCRATCH2);
LI(SCRATCH2, CORE_RUNTIME_ERROR);
SW(SCRATCH2, SCRATCH1, 0);
diff --git a/Core/MIPS/RiscV/RiscVCompALU.cpp b/Core/MIPS/RiscV/RiscVCompALU.cpp
index 5cb2ff256c..e2f28683dc 100644
--- a/Core/MIPS/RiscV/RiscVCompALU.cpp
+++ b/Core/MIPS/RiscV/RiscVCompALU.cpp
@@ -35,7 +35,7 @@ namespace MIPSComp {
using namespace RiscVGen;
using namespace RiscVJitConstants;
-void RiscVJit::CompIR_Arith(IRInst inst) {
+void RiscVJitBackend::CompIR_Arith(IRInst inst) {
CONDITIONAL_DISABLE;
bool allowPtrMath = true;
@@ -96,7 +96,7 @@ void RiscVJit::CompIR_Arith(IRInst inst) {
}
}
-void RiscVJit::CompIR_Logic(IRInst inst) {
+void RiscVJitBackend::CompIR_Logic(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -187,7 +187,7 @@ void RiscVJit::CompIR_Logic(IRInst inst) {
}
}
-void RiscVJit::CompIR_Assign(IRInst inst) {
+void RiscVJitBackend::CompIR_Assign(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -227,7 +227,7 @@ void RiscVJit::CompIR_Assign(IRInst inst) {
}
}
-void RiscVJit::CompIR_Bits(IRInst inst) {
+void RiscVJitBackend::CompIR_Bits(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -269,7 +269,7 @@ void RiscVJit::CompIR_Bits(IRInst inst) {
}
}
-void RiscVJit::CompIR_Shift(IRInst inst) {
+void RiscVJitBackend::CompIR_Shift(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -367,7 +367,7 @@ void RiscVJit::CompIR_Shift(IRInst inst) {
}
}
-void RiscVJit::CompIR_Compare(IRInst inst) {
+void RiscVJitBackend::CompIR_Compare(IRInst inst) {
CONDITIONAL_DISABLE;
RiscVReg lhs = INVALID_REG;
@@ -445,7 +445,7 @@ void RiscVJit::CompIR_Compare(IRInst inst) {
}
}
-void RiscVJit::CompIR_CondAssign(IRInst inst) {
+void RiscVJitBackend::CompIR_CondAssign(IRInst inst) {
CONDITIONAL_DISABLE;
RiscVReg lhs = INVALID_REG;
@@ -519,7 +519,7 @@ void RiscVJit::CompIR_CondAssign(IRInst inst) {
}
}
-void RiscVJit::CompIR_HiLo(IRInst inst) {
+void RiscVJitBackend::CompIR_HiLo(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -553,7 +553,7 @@ void RiscVJit::CompIR_HiLo(IRInst inst) {
}
}
-void RiscVJit::CompIR_Mult(IRInst inst) {
+void RiscVJitBackend::CompIR_Mult(IRInst inst) {
CONDITIONAL_DISABLE;
auto makeArgsUnsigned = [&](RiscVReg *lhs, RiscVReg *rhs) {
@@ -652,7 +652,7 @@ void RiscVJit::CompIR_Mult(IRInst inst) {
}
}
-void RiscVJit::CompIR_Div(IRInst inst) {
+void RiscVJitBackend::CompIR_Div(IRInst inst) {
CONDITIONAL_DISABLE;
RiscVReg numReg, denomReg;
diff --git a/Core/MIPS/RiscV/RiscVCompBranch.cpp b/Core/MIPS/RiscV/RiscVCompBranch.cpp
index aa9d2467a0..121b3fa789 100644
--- a/Core/MIPS/RiscV/RiscVCompBranch.cpp
+++ b/Core/MIPS/RiscV/RiscVCompBranch.cpp
@@ -34,7 +34,7 @@ namespace MIPSComp {
using namespace RiscVGen;
using namespace RiscVJitConstants;
-void RiscVJit::CompIR_Exit(IRInst inst) {
+void RiscVJitBackend::CompIR_Exit(IRInst inst) {
CONDITIONAL_DISABLE;
RiscVReg exitReg = INVALID_REG;
@@ -64,7 +64,7 @@ void RiscVJit::CompIR_Exit(IRInst inst) {
}
}
-void RiscVJit::CompIR_ExitIf(IRInst inst) {
+void RiscVJitBackend::CompIR_ExitIf(IRInst inst) {
CONDITIONAL_DISABLE;
RiscVReg lhs = INVALID_REG;
diff --git a/Core/MIPS/RiscV/RiscVCompFPU.cpp b/Core/MIPS/RiscV/RiscVCompFPU.cpp
index 18cd1a00c2..9dd2ea6958 100644
--- a/Core/MIPS/RiscV/RiscVCompFPU.cpp
+++ b/Core/MIPS/RiscV/RiscVCompFPU.cpp
@@ -34,7 +34,7 @@ namespace MIPSComp {
using namespace RiscVGen;
using namespace RiscVJitConstants;
-void RiscVJit::CompIR_FArith(IRInst inst) {
+void RiscVJitBackend::CompIR_FArith(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -108,7 +108,7 @@ void RiscVJit::CompIR_FArith(IRInst inst) {
}
}
-void RiscVJit::CompIR_FCondAssign(IRInst inst) {
+void RiscVJitBackend::CompIR_FCondAssign(IRInst inst) {
CONDITIONAL_DISABLE;
if (inst.op != IROp::FMin && inst.op != IROp::FMax)
INVALIDOP;
@@ -174,7 +174,7 @@ void RiscVJit::CompIR_FCondAssign(IRInst inst) {
SetJumpTarget(finish);
}
-void RiscVJit::CompIR_FAssign(IRInst inst) {
+void RiscVJitBackend::CompIR_FAssign(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -220,7 +220,7 @@ void RiscVJit::CompIR_FAssign(IRInst inst) {
}
}
-void RiscVJit::CompIR_FRound(IRInst inst) {
+void RiscVJitBackend::CompIR_FRound(IRInst inst) {
CONDITIONAL_DISABLE;
// TODO: If this is followed by a GPR transfer, might want to combine.
@@ -251,7 +251,7 @@ void RiscVJit::CompIR_FRound(IRInst inst) {
FMV(FMv::W, FMv::X, fpr.R(inst.dest), SCRATCH1);
}
-void RiscVJit::CompIR_FCvt(IRInst inst) {
+void RiscVJitBackend::CompIR_FCvt(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -274,7 +274,7 @@ void RiscVJit::CompIR_FCvt(IRInst inst) {
}
}
-void RiscVJit::CompIR_FSat(IRInst inst) {
+void RiscVJitBackend::CompIR_FSat(IRInst inst) {
CONDITIONAL_DISABLE;
RiscVReg tempReg = INVALID_REG;
@@ -334,7 +334,7 @@ void RiscVJit::CompIR_FSat(IRInst inst) {
}
}
-void RiscVJit::CompIR_FCompare(IRInst inst) {
+void RiscVJitBackend::CompIR_FCompare(IRInst inst) {
CONDITIONAL_DISABLE;
constexpr IRRegIndex IRREG_VFPUL_CC = IRREG_VFPU_CTRL_BASE + VFPU_CTRL_CC;
@@ -548,7 +548,7 @@ void RiscVJit::CompIR_FCompare(IRInst inst) {
}
}
-void RiscVJit::CompIR_RoundingMode(IRInst inst) {
+void RiscVJitBackend::CompIR_RoundingMode(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -570,7 +570,7 @@ void RiscVJit::CompIR_RoundingMode(IRInst inst) {
}
}
-void RiscVJit::CompIR_FSpecial(IRInst inst) {
+void RiscVJitBackend::CompIR_FSpecial(IRInst inst) {
CONDITIONAL_DISABLE;
#ifdef __riscv_float_abi_soft
diff --git a/Core/MIPS/RiscV/RiscVCompLoadStore.cpp b/Core/MIPS/RiscV/RiscVCompLoadStore.cpp
index d6a49e6f13..0713016d6c 100644
--- a/Core/MIPS/RiscV/RiscVCompLoadStore.cpp
+++ b/Core/MIPS/RiscV/RiscVCompLoadStore.cpp
@@ -34,7 +34,7 @@ namespace MIPSComp {
using namespace RiscVGen;
using namespace RiscVJitConstants;
-void RiscVJit::SetScratch1ToSrc1Address(IRReg src1) {
+void RiscVJitBackend::SetScratch1ToSrc1Address(IRReg src1) {
gpr.MapReg(src1);
#ifdef MASKED_PSP_MEMORY
SLLIW(SCRATCH1, gpr.R(src1), 2);
@@ -53,7 +53,7 @@ void RiscVJit::SetScratch1ToSrc1Address(IRReg src1) {
#endif
}
-int32_t RiscVJit::AdjustForAddressOffset(RiscVGen::RiscVReg *reg, int32_t constant, int32_t range) {
+int32_t RiscVJitBackend::AdjustForAddressOffset(RiscVGen::RiscVReg *reg, int32_t constant, int32_t range) {
if (constant < -2048 || constant + range > 2047) {
LI(SCRATCH2, constant);
ADD(SCRATCH1, *reg, SCRATCH2);
@@ -63,7 +63,7 @@ int32_t RiscVJit::AdjustForAddressOffset(RiscVGen::RiscVReg *reg, int32_t consta
return constant;
}
-void RiscVJit::CompIR_Load(IRInst inst) {
+void RiscVJitBackend::CompIR_Load(IRInst inst) {
CONDITIONAL_DISABLE;
gpr.SpillLock(inst.dest, inst.src1);
@@ -124,7 +124,7 @@ void RiscVJit::CompIR_Load(IRInst inst) {
}
}
-void RiscVJit::CompIR_LoadShift(IRInst inst) {
+void RiscVJitBackend::CompIR_LoadShift(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -140,7 +140,7 @@ void RiscVJit::CompIR_LoadShift(IRInst inst) {
}
}
-void RiscVJit::CompIR_FLoad(IRInst inst) {
+void RiscVJitBackend::CompIR_FLoad(IRInst inst) {
CONDITIONAL_DISABLE;
RiscVReg addrReg = INVALID_REG;
@@ -173,7 +173,7 @@ void RiscVJit::CompIR_FLoad(IRInst inst) {
}
}
-void RiscVJit::CompIR_VecLoad(IRInst inst) {
+void RiscVJitBackend::CompIR_VecLoad(IRInst inst) {
CONDITIONAL_DISABLE;
RiscVReg addrReg = INVALID_REG;
@@ -210,7 +210,7 @@ void RiscVJit::CompIR_VecLoad(IRInst inst) {
}
}
-void RiscVJit::CompIR_Store(IRInst inst) {
+void RiscVJitBackend::CompIR_Store(IRInst inst) {
CONDITIONAL_DISABLE;
gpr.SpillLock(inst.src3, inst.src1);
@@ -255,7 +255,7 @@ void RiscVJit::CompIR_Store(IRInst inst) {
}
}
-void RiscVJit::CompIR_CondStore(IRInst inst) {
+void RiscVJitBackend::CompIR_CondStore(IRInst inst) {
CONDITIONAL_DISABLE;
if (inst.op != IROp::Store32Conditional)
INVALIDOP;
@@ -297,7 +297,7 @@ void RiscVJit::CompIR_CondStore(IRInst inst) {
}
}
-void RiscVJit::CompIR_StoreShift(IRInst inst) {
+void RiscVJitBackend::CompIR_StoreShift(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -313,7 +313,7 @@ void RiscVJit::CompIR_StoreShift(IRInst inst) {
}
}
-void RiscVJit::CompIR_FStore(IRInst inst) {
+void RiscVJitBackend::CompIR_FStore(IRInst inst) {
CONDITIONAL_DISABLE;
RiscVReg addrReg = INVALID_REG;
@@ -346,7 +346,7 @@ void RiscVJit::CompIR_FStore(IRInst inst) {
}
}
-void RiscVJit::CompIR_VecStore(IRInst inst) {
+void RiscVJitBackend::CompIR_VecStore(IRInst inst) {
CONDITIONAL_DISABLE;
RiscVReg addrReg = INVALID_REG;
diff --git a/Core/MIPS/RiscV/RiscVCompSystem.cpp b/Core/MIPS/RiscV/RiscVCompSystem.cpp
index 727465fad0..ec519e66fd 100644
--- a/Core/MIPS/RiscV/RiscVCompSystem.cpp
+++ b/Core/MIPS/RiscV/RiscVCompSystem.cpp
@@ -38,7 +38,7 @@ namespace MIPSComp {
using namespace RiscVGen;
using namespace RiscVJitConstants;
-void RiscVJit::CompIR_Basic(IRInst inst) {
+void RiscVJitBackend::CompIR_Basic(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -85,7 +85,7 @@ void RiscVJit::CompIR_Basic(IRInst inst) {
}
}
-void RiscVJit::CompIR_Transfer(IRInst inst) {
+void RiscVJitBackend::CompIR_Transfer(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -177,7 +177,7 @@ void RiscVJit::CompIR_Transfer(IRInst inst) {
}
}
-void RiscVJit::CompIR_System(IRInst inst) {
+void RiscVJitBackend::CompIR_System(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -236,7 +236,7 @@ void RiscVJit::CompIR_System(IRInst inst) {
}
}
-void RiscVJit::CompIR_Breakpoint(IRInst inst) {
+void RiscVJitBackend::CompIR_Breakpoint(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -251,7 +251,7 @@ void RiscVJit::CompIR_Breakpoint(IRInst inst) {
}
}
-void RiscVJit::CompIR_ValidateAddress(IRInst inst) {
+void RiscVJitBackend::CompIR_ValidateAddress(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
diff --git a/Core/MIPS/RiscV/RiscVCompVec.cpp b/Core/MIPS/RiscV/RiscVCompVec.cpp
index 8140f2b856..08739152ae 100644
--- a/Core/MIPS/RiscV/RiscVCompVec.cpp
+++ b/Core/MIPS/RiscV/RiscVCompVec.cpp
@@ -34,7 +34,7 @@ namespace MIPSComp {
using namespace RiscVGen;
using namespace RiscVJitConstants;
-void RiscVJit::CompIR_VecAssign(IRInst inst) {
+void RiscVJitBackend::CompIR_VecAssign(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -129,7 +129,7 @@ void RiscVJit::CompIR_VecAssign(IRInst inst) {
}
}
-void RiscVJit::CompIR_VecArith(IRInst inst) {
+void RiscVJitBackend::CompIR_VecArith(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -184,7 +184,7 @@ void RiscVJit::CompIR_VecArith(IRInst inst) {
}
}
-void RiscVJit::CompIR_VecHoriz(IRInst inst) {
+void RiscVJitBackend::CompIR_VecHoriz(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -230,7 +230,7 @@ void RiscVJit::CompIR_VecHoriz(IRInst inst) {
}
}
-void RiscVJit::CompIR_VecPack(IRInst inst) {
+void RiscVJitBackend::CompIR_VecPack(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
@@ -266,7 +266,7 @@ void RiscVJit::CompIR_VecPack(IRInst inst) {
}
}
-void RiscVJit::CompIR_VecClamp(IRInst inst) {
+void RiscVJitBackend::CompIR_VecClamp(IRInst inst) {
CONDITIONAL_DISABLE;
switch (inst.op) {
diff --git a/Core/MIPS/RiscV/RiscVJit.cpp b/Core/MIPS/RiscV/RiscVJit.cpp
index 04e0c23bf3..983e104e6c 100644
--- a/Core/MIPS/RiscV/RiscVJit.cpp
+++ b/Core/MIPS/RiscV/RiscVJit.cpp
@@ -15,62 +15,18 @@
// Official git repository and contact information can be found at
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
-#include "Common/StringUtils.h"
-#include "Common/TimeUtil.h"
#include "Core/MemMap.h"
#include "Core/MIPS/MIPSTables.h"
#include "Core/MIPS/RiscV/RiscVJit.h"
#include "Core/MIPS/RiscV/RiscVRegCache.h"
-#include "Common/Profiler/Profiler.h"
namespace MIPSComp {
using namespace RiscVGen;
using namespace RiscVJitConstants;
-static constexpr bool enableDebug = false;
-
-static std::map debugSeenNotCompiledIR;
-static std::map debugSeenNotCompiled;
-double lastDebugLog = 0.0;
-
-static void LogDebugNotCompiled() {
- if (!enableDebug)
- return;
-
- double now = time_now_d();
- if (now < lastDebugLog + 1.0)
- return;
- lastDebugLog = now;
-
- int worstIROp = -1;
- int worstIRVal = 0;
- for (auto it : debugSeenNotCompiledIR) {
- if (it.second > worstIRVal) {
- worstIRVal = it.second;
- worstIROp = it.first;
- }
- }
- debugSeenNotCompiledIR.clear();
-
- const char *worstName = nullptr;
- int worstVal = 0;
- for (auto it : debugSeenNotCompiled) {
- if (it.second > worstVal) {
- worstVal = it.second;
- worstName = it.first;
- }
- }
- debugSeenNotCompiled.clear();
-
- if (worstIROp != -1)
- WARN_LOG(JIT, "Most not compiled IR op: %s (%d)", GetIRMeta((IROp)worstIROp)->name, worstIRVal);
- if (worstName != nullptr)
- WARN_LOG(JIT, "Most not compiled op: %s (%d)", worstName, worstVal);
-}
-
-RiscVJit::RiscVJit(MIPSState *mipsState)
- : IRJit(mipsState), gpr(mipsState, &jo), fpr(mipsState, &jo), debugInterface_(blocks_, *this) {
+RiscVJitBackend::RiscVJitBackend(MIPSState *mipsState, JitOptions &jitopt)
+ : mips_(mipsState), jo(jitopt), gpr(mipsState, &jo), fpr(mipsState, &jo) {
// Automatically disable incompatible options.
if (((intptr_t)Memory::base & 0x00000000FFFFFFFFUL) != 0) {
jo.enablePointerify = false;
@@ -83,31 +39,16 @@ RiscVJit::RiscVJit(MIPSState *mipsState)
gpr.Init(this);
fpr.Init(this);
-
- GenerateFixedCode(jo);
}
-RiscVJit::~RiscVJit() {
-}
-
-void RiscVJit::RunLoopUntil(u64 globalticks) {
- if constexpr (enableDebug) {
- LogDebugNotCompiled();
- }
-
- PROFILE_THIS_SCOPE("jit");
- ((void (*)())enterDispatcher_)();
-}
-
-JitBlockCacheDebugInterface *MIPSComp::RiscVJit::GetBlockCacheDebugInterface() {
- return &debugInterface_;
+RiscVJitBackend::~RiscVJitBackend() {
}
static void NoBlockExits() {
_assert_msg_(false, "Never exited block, invalid IR?");
}
-bool RiscVJit::CompileTargetBlock(IRBlock *block, int block_num, bool preload) {
+bool RiscVJitBackend::CompileBlock(IRBlock *block, int block_num, bool preload) {
if (GetSpaceLeft() < 0x800)
return false;
@@ -138,9 +79,10 @@ bool RiscVJit::CompileTargetBlock(IRBlock *block, int block_num, bool preload) {
}
// We should've written an exit above. If we didn't, bad things will happen.
- if (enableDebug) {
+ // Only check if debug stats are enabled - needlessly wastes jit space.
+ if (DebugStatsEnabled()) {
QuickCallFunction(&NoBlockExits);
- QuickJ(R_RA, crashHandler_);
+ QuickJ(R_RA, hooks_.crashHandler);
}
FlushIcache();
@@ -148,307 +90,7 @@ bool RiscVJit::CompileTargetBlock(IRBlock *block, int block_num, bool preload) {
return true;
}
-void RiscVJit::CompileIRInst(IRInst inst) {
- switch (inst.op) {
- case IROp::Nop:
- break;
-
- case IROp::SetConst:
- case IROp::SetConstF:
- case IROp::Downcount:
- case IROp::SetPC:
- case IROp::SetPCConst:
- CompIR_Basic(inst);
- break;
-
- case IROp::Add:
- case IROp::Sub:
- case IROp::AddConst:
- case IROp::SubConst:
- case IROp::Neg:
- CompIR_Arith(inst);
- break;
-
- case IROp::And:
- case IROp::Or:
- case IROp::Xor:
- case IROp::AndConst:
- case IROp::OrConst:
- case IROp::XorConst:
- case IROp::Not:
- CompIR_Logic(inst);
- break;
-
- case IROp::Mov:
- case IROp::Ext8to32:
- case IROp::Ext16to32:
- CompIR_Assign(inst);
- break;
-
- case IROp::ReverseBits:
- case IROp::BSwap16:
- case IROp::BSwap32:
- case IROp::Clz:
- CompIR_Bits(inst);
- break;
-
- case IROp::Shl:
- case IROp::Shr:
- case IROp::Sar:
- case IROp::Ror:
- case IROp::ShlImm:
- case IROp::ShrImm:
- case IROp::SarImm:
- case IROp::RorImm:
- CompIR_Shift(inst);
- break;
-
- case IROp::Slt:
- case IROp::SltConst:
- case IROp::SltU:
- case IROp::SltUConst:
- CompIR_Compare(inst);
- break;
-
- case IROp::MovZ:
- case IROp::MovNZ:
- case IROp::Max:
- case IROp::Min:
- CompIR_CondAssign(inst);
- break;
-
- case IROp::MtLo:
- case IROp::MtHi:
- case IROp::MfLo:
- case IROp::MfHi:
- CompIR_HiLo(inst);
- break;
-
- case IROp::Mult:
- case IROp::MultU:
- case IROp::Madd:
- case IROp::MaddU:
- case IROp::Msub:
- case IROp::MsubU:
- CompIR_Mult(inst);
- break;
-
- case IROp::Div:
- case IROp::DivU:
- CompIR_Div(inst);
- break;
-
- case IROp::Load8:
- case IROp::Load8Ext:
- case IROp::Load16:
- case IROp::Load16Ext:
- case IROp::Load32:
- case IROp::Load32Linked:
- CompIR_Load(inst);
- break;
-
- case IROp::Load32Left:
- case IROp::Load32Right:
- CompIR_LoadShift(inst);
- break;
-
- case IROp::LoadFloat:
- CompIR_FLoad(inst);
- break;
-
- case IROp::LoadVec4:
- CompIR_VecLoad(inst);
- break;
-
- case IROp::Store8:
- case IROp::Store16:
- case IROp::Store32:
- CompIR_Store(inst);
- break;
-
- case IROp::Store32Conditional:
- CompIR_CondStore(inst);
- break;
-
- case IROp::Store32Left:
- case IROp::Store32Right:
- CompIR_StoreShift(inst);
- break;
-
- case IROp::StoreFloat:
- CompIR_FStore(inst);
- break;
-
- case IROp::StoreVec4:
- CompIR_VecStore(inst);
- break;
-
- case IROp::FAdd:
- case IROp::FSub:
- case IROp::FMul:
- case IROp::FDiv:
- case IROp::FSqrt:
- case IROp::FNeg:
- CompIR_FArith(inst);
- break;
-
- case IROp::FMin:
- case IROp::FMax:
- CompIR_FCondAssign(inst);
- break;
-
- case IROp::FMov:
- case IROp::FAbs:
- case IROp::FSign:
- CompIR_FAssign(inst);
- break;
-
- case IROp::FRound:
- case IROp::FTrunc:
- case IROp::FCeil:
- case IROp::FFloor:
- CompIR_FRound(inst);
- break;
-
- case IROp::FCvtWS:
- case IROp::FCvtSW:
- case IROp::FCvtScaledWS:
- case IROp::FCvtScaledSW:
- CompIR_FCvt(inst);
- break;
-
- case IROp::FSat0_1:
- case IROp::FSatMinus1_1:
- CompIR_FSat(inst);
- break;
-
- case IROp::FCmp:
- case IROp::FCmovVfpuCC:
- case IROp::FCmpVfpuBit:
- case IROp::FCmpVfpuAggregate:
- CompIR_FCompare(inst);
- break;
-
- case IROp::RestoreRoundingMode:
- case IROp::ApplyRoundingMode:
- case IROp::UpdateRoundingMode:
- CompIR_RoundingMode(inst);
- break;
-
- case IROp::SetCtrlVFPU:
- case IROp::SetCtrlVFPUReg:
- case IROp::SetCtrlVFPUFReg:
- case IROp::FpCondToReg:
- case IROp::ZeroFpCond:
- case IROp::FpCtrlFromReg:
- case IROp::FpCtrlToReg:
- case IROp::VfpuCtrlToReg:
- case IROp::FMovFromGPR:
- case IROp::FMovToGPR:
- CompIR_Transfer(inst);
- break;
-
- case IROp::Vec4Init:
- case IROp::Vec4Shuffle:
- case IROp::Vec4Mov:
- CompIR_VecAssign(inst);
- break;
-
- case IROp::Vec4Add:
- case IROp::Vec4Sub:
- case IROp::Vec4Mul:
- case IROp::Vec4Div:
- case IROp::Vec4Scale:
- case IROp::Vec4Neg:
- case IROp::Vec4Abs:
- CompIR_VecArith(inst);
- break;
-
- case IROp::Vec4Dot:
- CompIR_VecHoriz(inst);
- break;
-
- case IROp::Vec2Unpack16To31:
- case IROp::Vec2Unpack16To32:
- case IROp::Vec4Unpack8To32:
- case IROp::Vec4DuplicateUpperBitsAndShift1:
- case IROp::Vec4Pack31To8:
- case IROp::Vec4Pack32To8:
- case IROp::Vec2Pack31To16:
- case IROp::Vec2Pack32To16:
- CompIR_VecPack(inst);
- break;
-
- case IROp::Vec4ClampToZero:
- case IROp::Vec2ClampToZero:
- CompIR_VecClamp(inst);
- break;
-
- case IROp::FSin:
- case IROp::FCos:
- case IROp::FRSqrt:
- case IROp::FRecip:
- case IROp::FAsin:
- CompIR_FSpecial(inst);
- break;
-
- case IROp::Interpret:
- CompIR_Interpret(inst);
- break;
-
- case IROp::Syscall:
- case IROp::CallReplacement:
- case IROp::Break:
- CompIR_System(inst);
- break;
-
- case IROp::Breakpoint:
- case IROp::MemoryCheck:
- CompIR_Breakpoint(inst);
- break;
-
- case IROp::ValidateAddress8:
- case IROp::ValidateAddress16:
- case IROp::ValidateAddress32:
- case IROp::ValidateAddress128:
- CompIR_ValidateAddress(inst);
- break;
-
- case IROp::ExitToConst:
- case IROp::ExitToReg:
- case IROp::ExitToPC:
- CompIR_Exit(inst);
- break;
-
- case IROp::ExitToConstIfEq:
- case IROp::ExitToConstIfNeq:
- case IROp::ExitToConstIfGtZ:
- case IROp::ExitToConstIfGeZ:
- case IROp::ExitToConstIfLtZ:
- case IROp::ExitToConstIfLeZ:
- case IROp::ExitToConstIfFpTrue:
- case IROp::ExitToConstIfFpFalse:
- CompIR_ExitIf(inst);
- break;
-
- default:
- _assert_msg_(false, "Unexpected IR op %d", (int)inst.op);
- CompIR_Generic(inst);
- break;
- }
-}
-
-static u32 DoIRInst(uint64_t value) {
- IRInst inst;
- memcpy(&inst, &value, sizeof(inst));
-
- if constexpr (enableDebug)
- debugSeenNotCompiledIR[(uint8_t)inst.op]++;
-
- return IRInterpret(currentMIPS, &inst, 1);
-}
-
-void RiscVJit::CompIR_Generic(IRInst inst) {
+void RiscVJitBackend::CompIR_Generic(IRInst inst) {
// If we got here, we're going the slow way.
uint64_t value;
memcpy(&value, &inst, sizeof(inst));
@@ -473,36 +115,29 @@ void RiscVJit::CompIR_Generic(IRInst inst) {
}
}
-static void DebugInterpretHit(const char *name) {
- if (enableDebug)
- debugSeenNotCompiled[name]++;
-}
-
-void RiscVJit::CompIR_Interpret(IRInst inst) {
+void RiscVJitBackend::CompIR_Interpret(IRInst inst) {
MIPSOpcode op(inst.constant);
// IR protects us against this being a branching instruction (well, hopefully.)
FlushAll();
SaveStaticRegisters();
- if (enableDebug) {
+ if (DebugStatsEnabled()) {
LI(X10, MIPSGetName(op));
- QuickCallFunction(&DebugInterpretHit);
+ QuickCallFunction(&NotifyMIPSInterpret);
}
LI(X10, (int32_t)inst.constant);
QuickCallFunction((const u8 *)MIPSGetInterpretFunc(op));
LoadStaticRegisters();
}
-void RiscVJit::FlushAll() {
+void RiscVJitBackend::FlushAll() {
gpr.FlushAll();
fpr.FlushAll();
}
-bool RiscVJit::DescribeCodePtr(const u8 *ptr, std::string &name) {
+bool RiscVJitBackend::DescribeCodePtr(const u8 *ptr, std::string &name) const {
// Used in disassembly viewer.
- if (ptr == dispatcher_) {
- name = "dispatcher";
- } else if (ptr == dispatcherPCInSCRATCH1_) {
+ if (ptr == dispatcherPCInSCRATCH1_) {
name = "dispatcher (PC in SCRATCH1)";
} else if (ptr == dispatcherNoCheck_) {
name = "dispatcherNoCheck";
@@ -510,81 +145,36 @@ bool RiscVJit::DescribeCodePtr(const u8 *ptr, std::string &name) {
name = "saveStaticRegisters";
} else if (ptr == loadStaticRegisters_) {
name = "loadStaticRegisters";
- } else if (ptr == enterDispatcher_) {
- name = "enterDispatcher";
} else if (ptr == applyRoundingMode_) {
name = "applyRoundingMode";
- } else if (!IsInSpace(ptr)) {
- return false;
} else {
- int offset = (int)GetOffset(ptr);
- int block_num = -1;
- for (int i = 0; i < blocks_.GetNumBlocks(); ++i) {
- const auto &b = blocks_.GetBlock(i);
- // We allocate linearly.
- if (b->GetTargetOffset() <= offset)
- block_num = i;
- if (b->GetTargetOffset() > offset)
- break;
- }
-
- if (block_num == -1) {
- name = "(unknown or deleted block)";
- return true;
- }
-
- const IRBlock *block = blocks_.GetBlock(block_num);
- if (block) {
- u32 start = 0, size = 0;
- block->GetRange(start, size);
- name = StringFromFormat("(block %d at %08x)", block_num, start);
- return true;
- }
- return false;
+ return IRNativeBackend::DescribeCodePtr(ptr, name);
}
return true;
}
-bool RiscVJit::CodeInRange(const u8 *ptr) const {
- return IsInSpace(ptr);
-}
-
-bool RiscVJit::IsAtDispatchFetch(const u8 *ptr) const {
- return ptr == dispatcherFetch_;
-}
-
-const u8 *RiscVJit::GetDispatcher() const {
- return dispatcher_;
-}
-
-const u8 *RiscVJit::GetCrashHandler() const {
- return crashHandler_;
-}
-
-void RiscVJit::ClearCache() {
- IRJit::ClearCache();
-
+void RiscVJitBackend::ClearAllBlocks() {
ClearCodeSpace(jitStartOffset_);
FlushIcacheSection(region + jitStartOffset_, region + region_size - jitStartOffset_);
}
-void RiscVJit::RestoreRoundingMode(bool force) {
+void RiscVJitBackend::RestoreRoundingMode(bool force) {
FSRMI(Round::NEAREST_EVEN);
}
-void RiscVJit::ApplyRoundingMode(bool force) {
+void RiscVJitBackend::ApplyRoundingMode(bool force) {
QuickCallFunction(applyRoundingMode_);
}
-void RiscVJit::MovFromPC(RiscVReg r) {
+void RiscVJitBackend::MovFromPC(RiscVReg r) {
LWU(r, CTXREG, offsetof(MIPSState, pc));
}
-void RiscVJit::MovToPC(RiscVReg r) {
+void RiscVJitBackend::MovToPC(RiscVReg r) {
SW(r, CTXREG, offsetof(MIPSState, pc));
}
-void RiscVJit::SaveStaticRegisters() {
+void RiscVJitBackend::SaveStaticRegisters() {
if (jo.useStaticAlloc) {
QuickCallFunction(saveStaticRegisters_);
} else {
@@ -593,7 +183,7 @@ void RiscVJit::SaveStaticRegisters() {
}
}
-void RiscVJit::LoadStaticRegisters() {
+void RiscVJitBackend::LoadStaticRegisters() {
if (jo.useStaticAlloc) {
QuickCallFunction(loadStaticRegisters_);
} else {
@@ -601,16 +191,16 @@ void RiscVJit::LoadStaticRegisters() {
}
}
-void RiscVJit::NormalizeSrc1(IRInst inst, RiscVReg *reg, RiscVReg tempReg, bool allowOverlap) {
+void RiscVJitBackend::NormalizeSrc1(IRInst inst, RiscVReg *reg, RiscVReg tempReg, bool allowOverlap) {
*reg = NormalizeR(inst.src1, allowOverlap ? 0 : inst.dest, tempReg);
}
-void RiscVJit::NormalizeSrc12(IRInst inst, RiscVReg *lhs, RiscVReg *rhs, RiscVReg lhsTempReg, RiscVReg rhsTempReg, bool allowOverlap) {
+void RiscVJitBackend::NormalizeSrc12(IRInst inst, RiscVReg *lhs, RiscVReg *rhs, RiscVReg lhsTempReg, RiscVReg rhsTempReg, bool allowOverlap) {
*lhs = NormalizeR(inst.src1, allowOverlap ? 0 : inst.dest, lhsTempReg);
*rhs = NormalizeR(inst.src2, allowOverlap ? 0 : inst.dest, rhsTempReg);
}
-RiscVReg RiscVJit::NormalizeR(IRRegIndex rs, IRRegIndex rd, RiscVReg tempReg) {
+RiscVReg RiscVJitBackend::NormalizeR(IRRegIndex rs, IRRegIndex rd, RiscVReg tempReg) {
// For proper compare, we must sign extend so they both match or don't match.
// But don't change pointers, in case one is SP (happens in LittleBigPlanet.)
if (gpr.IsImm(rs) && gpr.GetImm(rs) == 0) {
@@ -622,78 +212,4 @@ RiscVReg RiscVJit::NormalizeR(IRRegIndex rs, IRRegIndex rd, RiscVReg tempReg) {
}
}
-RiscVBlockCacheDebugInterface::RiscVBlockCacheDebugInterface(IRBlockCache &irBlocks, RiscVJit &jit)
- : irBlocks_(irBlocks), jit_(jit) {}
-
-int RiscVBlockCacheDebugInterface::GetNumBlocks() const {
- return irBlocks_.GetNumBlocks();
-}
-
-int RiscVBlockCacheDebugInterface::GetBlockNumberFromStartAddress(u32 em_address, bool realBlocksOnly) const {
- return irBlocks_.GetBlockNumberFromStartAddress(em_address, realBlocksOnly);
-}
-
-void RiscVBlockCacheDebugInterface::GetBlockCodeRange(int blockNum, int *startOffset, int *size) const {
- int blockOffset = irBlocks_.GetBlock(blockNum)->GetTargetOffset();
- int endOffset;
- // We assume linear allocation. Maybe a bit dangerous, should always be right.
- if (blockNum + 1 >= GetNumBlocks()) {
- // Last block, get from current code pointer.
- endOffset = (int)jit_.GetOffset(jit_.GetCodePointer());
- } else {
- endOffset = irBlocks_.GetBlock(blockNum + 1)->GetTargetOffset();
- _assert_msg_(endOffset >= blockOffset, "Next block not sequential, block=%d/%08x, next=%d/%08x", blockNum, blockOffset, blockNum + 1, endOffset);
- }
-
- *startOffset = blockOffset;
- *size = endOffset - blockOffset;
-}
-
-JitBlockDebugInfo RiscVBlockCacheDebugInterface::GetBlockDebugInfo(int blockNum) const {
- JitBlockDebugInfo debugInfo = irBlocks_.GetBlockDebugInfo(blockNum);
-
-#if PPSSPP_ARCH(RISCV64)
- int blockOffset, codeSize;
- GetBlockCodeRange(blockNum, &blockOffset, &codeSize);
- debugInfo.targetDisasm = DisassembleRV64(jit_.GetBasePtr() + blockOffset, codeSize);
-#endif
- return debugInfo;
-}
-
-void RiscVBlockCacheDebugInterface::ComputeStats(BlockCacheStats &bcStats) const {
- double totalBloat = 0.0;
- double maxBloat = 0.0;
- double minBloat = 1000000000.0;
- int numBlocks = GetNumBlocks();
- for (int i = 0; i < numBlocks; ++i) {
- const IRBlock &b = *irBlocks_.GetBlock(i);
-
- // RISC-V (jit) size.
- int blockOffset, codeSize;
- GetBlockCodeRange(i, &blockOffset, &codeSize);
- if (codeSize == 0)
- continue;
-
- // MIPS (PSP) size.
- u32 origAddr, mipsBytes;
- b.GetRange(origAddr, mipsBytes);
-
- double bloat = (double)codeSize / (double)mipsBytes;
- if (bloat < minBloat) {
- minBloat = bloat;
- bcStats.minBloatBlock = origAddr;
- }
- if (bloat > maxBloat) {
- maxBloat = bloat;
- bcStats.maxBloatBlock = origAddr;
- }
- totalBloat += bloat;
- bcStats.bloatMap[bloat] = origAddr;
- }
- bcStats.numBlocks = numBlocks;
- bcStats.minBloat = minBloat;
- bcStats.maxBloat = maxBloat;
- bcStats.avgBloat = totalBloat / (double)numBlocks;
-}
-
} // namespace MIPSComp
diff --git a/Core/MIPS/RiscV/RiscVJit.h b/Core/MIPS/RiscV/RiscVJit.h
index 74c221fecb..ca1d77f68d 100644
--- a/Core/MIPS/RiscV/RiscVJit.h
+++ b/Core/MIPS/RiscV/RiscVJit.h
@@ -21,6 +21,7 @@
#include
#include "Common/RiscVEmitter.h"
#include "Core/MIPS/IR/IRJit.h"
+#include "Core/MIPS/IR/IRNativeCommon.h"
#include "Core/MIPS/JitCommon/JitState.h"
#include "Core/MIPS/JitCommon/JitCommon.h"
#include "Core/MIPS/RiscV/RiscVRegCache.h"
@@ -28,48 +29,23 @@
namespace MIPSComp {
-class RiscVJit;
-
-class RiscVBlockCacheDebugInterface : public JitBlockCacheDebugInterface {
+class RiscVJitBackend : public RiscVGen::RiscVCodeBlock, public IRNativeBackend {
public:
- RiscVBlockCacheDebugInterface(IRBlockCache &irBlocks, RiscVJit &jit);
- int GetNumBlocks() const;
- int GetBlockNumberFromStartAddress(u32 em_address, bool realBlocksOnly = true) const;
- JitBlockDebugInfo GetBlockDebugInfo(int blockNum) const;
- void ComputeStats(BlockCacheStats &bcStats) const;
+ RiscVJitBackend(MIPSState *mipsState, JitOptions &jo);
+ ~RiscVJitBackend();
-private:
- void GetBlockCodeRange(int blockNum, int *startOffset, int *size) const;
+ bool DescribeCodePtr(const u8 *ptr, std::string &name) const override;
- IRBlockCache &irBlocks_;
- RiscVJit &jit_;
-};
-
-class RiscVJit : public RiscVGen::RiscVCodeBlock, public IRJit {
-public:
- RiscVJit(MIPSState *mipsState);
- ~RiscVJit();
-
- void RunLoopUntil(u64 globalticks) override;
-
- bool DescribeCodePtr(const u8 *ptr, std::string &name) override;
- bool CodeInRange(const u8 *ptr) const override;
- bool IsAtDispatchFetch(const u8 *ptr) const override;
- const u8 *GetDispatcher() const override;
- const u8 *GetCrashHandler() const override;
-
- void ClearCache() override;
-
- JitBlockCacheDebugInterface *GetBlockCacheDebugInterface() override;
+ void GenerateFixedCode() override;
+ bool CompileBlock(IRBlock *block, int block_num, bool preload) override;
+ void ClearAllBlocks() override;
protected:
- bool CompileTargetBlock(IRBlock *block, int block_num, bool preload) override;
-
- void CompileIRInst(IRInst inst);
+ const CodeBlockCommon &CodeBlock() const override {
+ return *this;
+ }
private:
- void GenerateFixedCode(const JitOptions &jo);
-
void RestoreRoundingMode(bool force = false);
void ApplyRoundingMode(bool force = false);
void MovFromPC(RiscVGen::RiscVReg r);
@@ -81,48 +57,48 @@ private:
// Note: destroys SCRATCH1.
void FlushAll();
- void CompIR_Arith(IRInst inst);
- void CompIR_Assign(IRInst inst);
- void CompIR_Basic(IRInst inst);
- void CompIR_Bits(IRInst inst);
- void CompIR_Breakpoint(IRInst inst);
- void CompIR_Compare(IRInst inst);
- void CompIR_CondAssign(IRInst inst);
- void CompIR_CondStore(IRInst inst);
- void CompIR_Div(IRInst inst);
- void CompIR_Exit(IRInst inst);
- void CompIR_ExitIf(IRInst inst);
- void CompIR_FArith(IRInst inst);
- void CompIR_FAssign(IRInst inst);
- void CompIR_FCompare(IRInst inst);
- void CompIR_FCondAssign(IRInst inst);
- void CompIR_FCvt(IRInst inst);
- void CompIR_FLoad(IRInst inst);
- void CompIR_FRound(IRInst inst);
- void CompIR_FSat(IRInst inst);
- void CompIR_FSpecial(IRInst inst);
- void CompIR_FStore(IRInst inst);
- void CompIR_Generic(IRInst inst);
- void CompIR_HiLo(IRInst inst);
- void CompIR_Interpret(IRInst inst);
- void CompIR_Load(IRInst inst);
- void CompIR_LoadShift(IRInst inst);
- void CompIR_Logic(IRInst inst);
- void CompIR_Mult(IRInst inst);
- void CompIR_RoundingMode(IRInst inst);
- void CompIR_Shift(IRInst inst);
- void CompIR_Store(IRInst inst);
- void CompIR_StoreShift(IRInst inst);
- void CompIR_System(IRInst inst);
- void CompIR_Transfer(IRInst inst);
- void CompIR_VecArith(IRInst inst);
- void CompIR_VecAssign(IRInst inst);
- void CompIR_VecClamp(IRInst inst);
- void CompIR_VecHoriz(IRInst inst);
- void CompIR_VecLoad(IRInst inst);
- void CompIR_VecPack(IRInst inst);
- void CompIR_VecStore(IRInst inst);
- void CompIR_ValidateAddress(IRInst inst);
+ void CompIR_Arith(IRInst inst) override;
+ void CompIR_Assign(IRInst inst) override;
+ void CompIR_Basic(IRInst inst) override;
+ void CompIR_Bits(IRInst inst) override;
+ void CompIR_Breakpoint(IRInst inst) override;
+ void CompIR_Compare(IRInst inst) override;
+ void CompIR_CondAssign(IRInst inst) override;
+ void CompIR_CondStore(IRInst inst) override;
+ void CompIR_Div(IRInst inst) override;
+ void CompIR_Exit(IRInst inst) override;
+ void CompIR_ExitIf(IRInst inst) override;
+ void CompIR_FArith(IRInst inst) override;
+ void CompIR_FAssign(IRInst inst) override;
+ void CompIR_FCompare(IRInst inst) override;
+ void CompIR_FCondAssign(IRInst inst) override;
+ void CompIR_FCvt(IRInst inst) override;
+ void CompIR_FLoad(IRInst inst) override;
+ void CompIR_FRound(IRInst inst) override;
+ void CompIR_FSat(IRInst inst) override;
+ void CompIR_FSpecial(IRInst inst) override;
+ void CompIR_FStore(IRInst inst) override;
+ void CompIR_Generic(IRInst inst) override;
+ void CompIR_HiLo(IRInst inst) override;
+ void CompIR_Interpret(IRInst inst) override;
+ void CompIR_Load(IRInst inst) override;
+ void CompIR_LoadShift(IRInst inst) override;
+ void CompIR_Logic(IRInst inst) override;
+ void CompIR_Mult(IRInst inst) override;
+ void CompIR_RoundingMode(IRInst inst) override;
+ void CompIR_Shift(IRInst inst) override;
+ void CompIR_Store(IRInst inst) override;
+ void CompIR_StoreShift(IRInst inst) override;
+ void CompIR_System(IRInst inst) override;
+ void CompIR_Transfer(IRInst inst) override;
+ void CompIR_VecArith(IRInst inst) override;
+ void CompIR_VecAssign(IRInst inst) override;
+ void CompIR_VecClamp(IRInst inst) override;
+ void CompIR_VecHoriz(IRInst inst) override;
+ void CompIR_VecLoad(IRInst inst) override;
+ void CompIR_VecPack(IRInst inst) override;
+ void CompIR_VecStore(IRInst inst) override;
+ void CompIR_ValidateAddress(IRInst inst) override;
void SetScratch1ToSrc1Address(IRReg src1);
// Modifies SCRATCH regs.
@@ -131,27 +107,34 @@ private:
void NormalizeSrc12(IRInst inst, RiscVGen::RiscVReg *lhs, RiscVGen::RiscVReg *rhs, RiscVGen::RiscVReg lhsTempReg, RiscVGen::RiscVReg rhsTempReg, bool allowOverlap);
RiscVGen::RiscVReg NormalizeR(IRRegIndex rs, IRRegIndex rd, RiscVGen::RiscVReg tempReg);
+ // TODO: Maybe just a param to GenerateFixedCode().
+ MIPSState *mips_;
+ JitOptions &jo;
RiscVRegCache gpr;
RiscVRegCacheFPU fpr;
- RiscVBlockCacheDebugInterface debugInterface_;
-
- const u8 *enterDispatcher_ = nullptr;
const u8 *outerLoop_ = nullptr;
const u8 *outerLoopPCInSCRATCH1_ = nullptr;
const u8 *dispatcherCheckCoreState_ = nullptr;
const u8 *dispatcherPCInSCRATCH1_ = nullptr;
- const u8 *dispatcher_ = nullptr;
const u8 *dispatcherNoCheck_ = nullptr;
- const u8 *dispatcherFetch_ = nullptr;
const u8 *applyRoundingMode_ = nullptr;
const u8 *saveStaticRegisters_ = nullptr;
const u8 *loadStaticRegisters_ = nullptr;
- const u8 *crashHandler_ = nullptr;
-
int jitStartOffset_ = 0;
};
+class RiscVJit : public IRNativeJit {
+public:
+ RiscVJit(MIPSState *mipsState)
+ : IRNativeJit(mipsState), rvBackend_(mipsState, jo) {
+ Init(rvBackend_);
+ }
+
+private:
+ RiscVJitBackend rvBackend_;
+};
+
} // namespace MIPSComp
diff --git a/UWP/CoreUWP/CoreUWP.vcxproj b/UWP/CoreUWP/CoreUWP.vcxproj
index 5af1ee85d0..38e408470a 100644
--- a/UWP/CoreUWP/CoreUWP.vcxproj
+++ b/UWP/CoreUWP/CoreUWP.vcxproj
@@ -302,6 +302,7 @@
+
@@ -562,6 +563,7 @@
+
diff --git a/UWP/CoreUWP/CoreUWP.vcxproj.filters b/UWP/CoreUWP/CoreUWP.vcxproj.filters
index 363504bba7..acfd6e128b 100644
--- a/UWP/CoreUWP/CoreUWP.vcxproj.filters
+++ b/UWP/CoreUWP/CoreUWP.vcxproj.filters
@@ -645,6 +645,9 @@
MIPS\IR
+
+ MIPS\IR
+
MIPS\IR
@@ -1670,6 +1673,9 @@
MIPS\IR
+
+ MIPS\IR
+
MIPS\IR
diff --git a/android/jni/Android.mk b/android/jni/Android.mk
index 3edfbdfc9d..830f7e1f4f 100644
--- a/android/jni/Android.mk
+++ b/android/jni/Android.mk
@@ -400,6 +400,7 @@ EXEC_AND_LIB_FILES := \
$(SRC)/Core/MIPS/IR/IRCompVFPU.cpp \
$(SRC)/Core/MIPS/IR/IRInst.cpp \
$(SRC)/Core/MIPS/IR/IRInterpreter.cpp \
+ $(SRC)/Core/MIPS/IR/IRNativeCommon.cpp \
$(SRC)/Core/MIPS/IR/IRPassSimplify.cpp \
$(SRC)/Core/MIPS/IR/IRRegCache.cpp \
$(SRC)/GPU/Math3D.cpp \
diff --git a/libretro/Makefile.common b/libretro/Makefile.common
index 70c00dfee2..6f40aa7fbd 100644
--- a/libretro/Makefile.common
+++ b/libretro/Makefile.common
@@ -677,9 +677,10 @@ SOURCES_CXX += \
$(COREDIR)/MIPS/IR/IRCompFPU.cpp \
$(COREDIR)/MIPS/IR/IRCompLoadStore.cpp \
$(COREDIR)/MIPS/IR/IRCompVFPU.cpp \
+ $(COREDIR)/MIPS/IR/IRInst.cpp \
$(COREDIR)/MIPS/IR/IRInterpreter.cpp \
$(COREDIR)/MIPS/IR/IRJit.cpp \
- $(COREDIR)/MIPS/IR/IRInst.cpp \
+ $(COREDIR)/MIPS/IR/IRNativeCommon.cpp \
$(COREDIR)/MIPS/IR/IRPassSimplify.cpp \
$(COREDIR)/MIPS/IR/IRRegCache.cpp \
$(COREDIR)/MIPS/IR/IRFrontend.cpp \