From 5f9a8fd1a1f646110b7b4f8b418decfdd223ec9e Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 6 Aug 2023 18:33:34 -0700 Subject: [PATCH 1/3] irjit: Rename IRRegCache to IRImmRegCache. For clarity, since it's not a native regcache. --- Core/MIPS/IR/IRPassSimplify.cpp | 2 +- Core/MIPS/IR/IRRegCache.cpp | 20 ++++++++++---------- Core/MIPS/IR/IRRegCache.h | 6 +++--- 3 files changed, 14 insertions(+), 14 deletions(-) diff --git a/Core/MIPS/IR/IRPassSimplify.cpp b/Core/MIPS/IR/IRPassSimplify.cpp index aaf07e639a..9ceb1a9aeb 100644 --- a/Core/MIPS/IR/IRPassSimplify.cpp +++ b/Core/MIPS/IR/IRPassSimplify.cpp @@ -418,7 +418,7 @@ bool RemoveLoadStoreLeftRight(const IRWriter &in, IRWriter &out, const IROptions bool PropagateConstants(const IRWriter &in, IRWriter &out, const IROptions &opts) { CONDITIONAL_DISABLE; - IRRegCache gpr(&out); + IRImmRegCache gpr(&out); bool logBlocks = false; for (int i = 0; i < (int)in.GetInstructions().size(); i++) { diff --git a/Core/MIPS/IR/IRRegCache.cpp b/Core/MIPS/IR/IRRegCache.cpp index d3bb519d04..ddd3677df4 100644 --- a/Core/MIPS/IR/IRRegCache.cpp +++ b/Core/MIPS/IR/IRRegCache.cpp @@ -3,7 +3,7 @@ #include "Core/MIPS/IR/IRRegCache.h" #include "Core/MIPS/IR/IRInst.h" -void IRRegCache::Flush(IRReg rd) { +void IRImmRegCache::Flush(IRReg rd) { if (rd == 0) { return; } @@ -14,52 +14,52 @@ void IRRegCache::Flush(IRReg rd) { } } -void IRRegCache::Discard(IRReg rd) { +void IRImmRegCache::Discard(IRReg rd) { if (rd == 0) { return; } reg_[rd].isImm = false; } -IRRegCache::IRRegCache(IRWriter *ir) : ir_(ir) { +IRImmRegCache::IRImmRegCache(IRWriter *ir) : ir_(ir) { memset(®_, 0, sizeof(reg_)); reg_[0].isImm = true; ir_ = ir; } -void IRRegCache::FlushAll() { +void IRImmRegCache::FlushAll() { for (int i = 0; i < TOTAL_MAPPABLE_MIPSREGS; i++) { Flush(i); } } -void IRRegCache::MapIn(IRReg rd) { +void IRImmRegCache::MapIn(IRReg rd) { Flush(rd); } -void IRRegCache::MapDirty(IRReg rd) { +void IRImmRegCache::MapDirty(IRReg rd) { Discard(rd); } -void IRRegCache::MapInIn(IRReg rs, IRReg rt) { +void IRImmRegCache::MapInIn(IRReg rs, IRReg rt) { Flush(rs); Flush(rt); } -void IRRegCache::MapInInIn(IRReg rd, IRReg rs, IRReg rt) { +void IRImmRegCache::MapInInIn(IRReg rd, IRReg rs, IRReg rt) { Flush(rd); Flush(rs); Flush(rt); } -void IRRegCache::MapDirtyIn(IRReg rd, IRReg rs) { +void IRImmRegCache::MapDirtyIn(IRReg rd, IRReg rs) { if (rs != rd) { Discard(rd); } Flush(rs); } -void IRRegCache::MapDirtyInIn(IRReg rd, IRReg rs, IRReg rt) { +void IRImmRegCache::MapDirtyInIn(IRReg rd, IRReg rs, IRReg rt) { if (rs != rd && rt != rd) { Discard(rd); } diff --git a/Core/MIPS/IR/IRRegCache.h b/Core/MIPS/IR/IRRegCache.h index 80fad1d6ef..5ab5d51d0a 100644 --- a/Core/MIPS/IR/IRRegCache.h +++ b/Core/MIPS/IR/IRRegCache.h @@ -1,6 +1,6 @@ #pragma once -// IRRegCache is only to perform pre-constant folding. This is worth it to get cleaner +// IRImmRegCache is only to perform pre-constant folding. This is worth it to get cleaner // IR. #include "Common/CommonTypes.h" @@ -19,9 +19,9 @@ struct RegIR { class IRWriter; // Transient -class IRRegCache { +class IRImmRegCache { public: - IRRegCache(IRWriter *ir); + IRImmRegCache(IRWriter *ir); void SetImm(IRReg r, u32 immVal) { reg_[r].isImm = true; From 3f97545f99cc044dd266b57a0d68627880d1ff3c Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 6 Aug 2023 18:55:30 -0700 Subject: [PATCH 2/3] irjit: Reduce exits from constants. This reduces bloat a bit, and may help with common funcs that enter short loops. --- Core/MIPS/IR/IRPassSimplify.cpp | 62 +++++++++++++++++++++++++++++---- 1 file changed, 55 insertions(+), 7 deletions(-) diff --git a/Core/MIPS/IR/IRPassSimplify.cpp b/Core/MIPS/IR/IRPassSimplify.cpp index 9ceb1a9aeb..1b361be7f5 100644 --- a/Core/MIPS/IR/IRPassSimplify.cpp +++ b/Core/MIPS/IR/IRPassSimplify.cpp @@ -421,6 +421,7 @@ bool PropagateConstants(const IRWriter &in, IRWriter &out, const IROptions &opts IRImmRegCache gpr(&out); bool logBlocks = false; + bool skipNextExitToConst = false; for (int i = 0; i < (int)in.GetInstructions().size(); i++) { IRInst inst = in.GetInstructions()[i]; bool symmetric = true; @@ -804,20 +805,67 @@ bool PropagateConstants(const IRWriter &in, IRWriter &out, const IROptions &opts gpr.MapDirtyIn(IRREG_VFPU_CC, IRREG_VFPU_CC); goto doDefault; + case IROp::ExitToConstIfEq: + case IROp::ExitToConstIfNeq: + if (gpr.IsImm(inst.src1) && gpr.IsImm(inst.src2)) { + bool passed = false; + switch (inst.op) { + case IROp::ExitToConstIfEq: passed = gpr.GetImm(inst.src1) == gpr.GetImm(inst.src2); break; + case IROp::ExitToConstIfNeq: passed = gpr.GetImm(inst.src1) != gpr.GetImm(inst.src2); break; + default: _assert_(false); break; + } + + // This is a bit common for the first cycle of loops. + // Reduce bloat by skipping on fail, and const exit on pass. + if (passed) { + gpr.FlushAll(); + out.Write(IROp::ExitToConst, out.AddConstant(inst.constant)); + skipNextExitToConst = true; + } + break; + } + gpr.FlushAll(); + goto doDefault; + + case IROp::ExitToConstIfGtZ: + case IROp::ExitToConstIfGeZ: + case IROp::ExitToConstIfLtZ: + case IROp::ExitToConstIfLeZ: + if (gpr.IsImm(inst.src1)) { + bool passed = false; + switch (inst.op) { + case IROp::ExitToConstIfGtZ: passed = (s32)gpr.GetImm(inst.src1) > 0; break; + case IROp::ExitToConstIfGeZ: passed = (s32)gpr.GetImm(inst.src1) >= 0; break; + case IROp::ExitToConstIfLtZ: passed = (s32)gpr.GetImm(inst.src1) < 0; break; + case IROp::ExitToConstIfLeZ: passed = (s32)gpr.GetImm(inst.src1) <= 0; break; + default: _assert_(false); break; + } + + if (passed) { + gpr.FlushAll(); + out.Write(IROp::ExitToConst, out.AddConstant(inst.constant)); + skipNextExitToConst = true; + } + break; + } + gpr.FlushAll(); + goto doDefault; + + case IROp::ExitToConst: + if (skipNextExitToConst) { + skipNextExitToConst = false; + break; + } + gpr.FlushAll(); + goto doDefault; + case IROp::CallReplacement: case IROp::Break: case IROp::Syscall: case IROp::Interpret: - case IROp::ExitToConst: case IROp::ExitToReg: - case IROp::ExitToConstIfEq: - case IROp::ExitToConstIfNeq: case IROp::ExitToConstIfFpFalse: case IROp::ExitToConstIfFpTrue: - case IROp::ExitToConstIfGeZ: - case IROp::ExitToConstIfGtZ: - case IROp::ExitToConstIfLeZ: - case IROp::ExitToConstIfLtZ: case IROp::Breakpoint: case IROp::MemoryCheck: default: From 31ff23746cb8eae31e6fb760a5b6d40121fb8027 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 6 Aug 2023 19:14:00 -0700 Subject: [PATCH 3/3] irjit: Prefer ExitToConst over ExitToReg. --- Core/MIPS/IR/IRPassSimplify.cpp | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/Core/MIPS/IR/IRPassSimplify.cpp b/Core/MIPS/IR/IRPassSimplify.cpp index 1b361be7f5..beecf7264e 100644 --- a/Core/MIPS/IR/IRPassSimplify.cpp +++ b/Core/MIPS/IR/IRPassSimplify.cpp @@ -859,11 +859,22 @@ bool PropagateConstants(const IRWriter &in, IRWriter &out, const IROptions &opts gpr.FlushAll(); goto doDefault; + case IROp::ExitToReg: + if (gpr.IsImm(inst.src1)) { + // This happens sometimes near loops. + // Prefer ExitToConst to allow block linking. + u32 dest = gpr.GetImm(inst.src1); + gpr.FlushAll(); + out.Write(IROp::ExitToConst, out.AddConstant(dest)); + break; + } + gpr.FlushAll(); + goto doDefault; + case IROp::CallReplacement: case IROp::Break: case IROp::Syscall: case IROp::Interpret: - case IROp::ExitToReg: case IROp::ExitToConstIfFpFalse: case IROp::ExitToConstIfFpTrue: case IROp::Breakpoint: