mirror of
https://github.com/hrydgard/ppsspp.git
synced 2025-04-02 11:01:50 -04:00
214 lines
6.5 KiB
C++
214 lines
6.5 KiB
C++
// Copyright (c) 2016- 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/IRAnalysis.h"
|
|
|
|
// For std::min
|
|
#include <algorithm>
|
|
|
|
|
|
static bool IRReadsFrom(const IRInstMeta &inst, int reg, char type, bool *directly) {
|
|
if (inst.m.types[1] == type && inst.src1 == reg) {
|
|
if (directly)
|
|
*directly = true;
|
|
return true;
|
|
}
|
|
if (inst.m.types[2] == type && inst.src2 == reg) {
|
|
if (directly)
|
|
*directly = true;
|
|
return true;
|
|
}
|
|
if ((inst.m.flags & (IRFLAG_SRC3 | IRFLAG_SRC3DST)) != 0 && inst.m.types[0] == type && inst.src3 == reg) {
|
|
if (directly)
|
|
*directly = true;
|
|
return true;
|
|
}
|
|
|
|
if (directly)
|
|
*directly = false;
|
|
if ((inst.m.flags & (IRFLAG_EXIT | IRFLAG_BARRIER)) != 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool IRReadsFromFPR(const IRInstMeta &inst, int reg, bool *directly) {
|
|
if (IRReadsFrom(inst, reg, 'F', directly))
|
|
return true;
|
|
|
|
// We also need to check V and 2. Indirect reads already checked, don't check again.
|
|
if (inst.m.types[1] == 'V' && reg >= inst.src1 && reg < inst.src1 + 4)
|
|
return true;
|
|
if (inst.m.types[1] == '2' && reg >= inst.src1 && reg < inst.src1 + 2)
|
|
return true;
|
|
if (inst.m.types[2] == 'V' && reg >= inst.src2 && reg < inst.src2 + 4)
|
|
return true;
|
|
if (inst.m.types[2] == '2' && reg >= inst.src2 && reg < inst.src2 + 2)
|
|
return true;
|
|
if ((inst.m.flags & (IRFLAG_SRC3 | IRFLAG_SRC3DST)) != 0) {
|
|
if (inst.m.types[0] == 'V' && reg >= inst.src3 && reg <= inst.src3 + 4)
|
|
return true;
|
|
if (inst.m.types[0] == '2' && reg >= inst.src3 && reg <= inst.src3 + 2)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static int IRReadsFromList(const IRInstMeta &inst, IRReg regs[4], char type) {
|
|
int c = 0;
|
|
|
|
if (inst.m.types[1] == type)
|
|
regs[c++] = inst.src1;
|
|
if (inst.m.types[2] == type)
|
|
regs[c++] = inst.src2;
|
|
if ((inst.m.flags & (IRFLAG_SRC3 | IRFLAG_SRC3DST)) != 0 && inst.m.types[0] == type)
|
|
regs[c++] = inst.src3;
|
|
|
|
if (inst.op == IROp::Interpret || inst.op == IROp::CallReplacement || inst.op == IROp::Syscall || inst.op == IROp::Break)
|
|
return -1;
|
|
if (inst.op == IROp::Breakpoint || inst.op == IROp::MemoryCheck)
|
|
return -1;
|
|
|
|
return c;
|
|
}
|
|
|
|
bool IRReadsFromGPR(const IRInstMeta &inst, int reg, bool *directly) {
|
|
return IRReadsFrom(inst, reg, 'G', directly);
|
|
}
|
|
|
|
int IRDestGPR(const IRInstMeta &inst) {
|
|
if ((inst.m.flags & IRFLAG_SRC3) == 0 && inst.m.types[0] == 'G') {
|
|
return inst.dest;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
bool IRWritesToGPR(const IRInstMeta &inst, int reg) {
|
|
return IRDestGPR(inst) == reg;
|
|
}
|
|
|
|
bool IRWritesToFPR(const IRInstMeta &inst, int reg) {
|
|
// Doesn't write to anything.
|
|
if ((inst.m.flags & IRFLAG_SRC3) != 0)
|
|
return false;
|
|
|
|
if (inst.m.types[0] == 'F' && reg == inst.dest)
|
|
return true;
|
|
if (inst.m.types[0] == 'V' && reg >= inst.dest && reg < inst.dest + 4)
|
|
return true;
|
|
if (inst.m.types[0] == '2' && reg >= inst.dest && reg < inst.dest + 2)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
int IRDestFPRs(const IRInstMeta &inst, IRReg regs[4]) {
|
|
// Doesn't write to anything.
|
|
if ((inst.m.flags & IRFLAG_SRC3) != 0)
|
|
return 0;
|
|
|
|
if (inst.m.types[0] == 'F') {
|
|
regs[0] = inst.dest;
|
|
return 1;
|
|
}
|
|
if (inst.m.types[0] == 'V') {
|
|
for (int i = 0; i < 4; ++i)
|
|
regs[i] = inst.dest + i;
|
|
return 4;
|
|
}
|
|
if (inst.m.types[0] == '2') {
|
|
for (int i = 0; i < 2; ++i)
|
|
regs[i] = inst.dest + i;
|
|
return 2;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int IRReadsFromGPRs(const IRInstMeta &inst, IRReg regs[4]) {
|
|
return IRReadsFromList(inst, regs, 'G');
|
|
}
|
|
|
|
int IRReadsFromFPRs(const IRInstMeta &inst, IRReg regs[16]) {
|
|
int c = IRReadsFromList(inst, regs, 'F');
|
|
if (c != 0)
|
|
return c;
|
|
|
|
// We also need to check V and 2. Indirect reads already checked, don't check again.
|
|
if (inst.m.types[1] == 'V' || inst.m.types[1] == '2') {
|
|
for (int i = 0; i < (inst.m.types[1] == 'V' ? 4 : 2); ++i)
|
|
regs[c++] = inst.src1 + i;
|
|
}
|
|
if (inst.m.types[2] == 'V' || inst.m.types[2] == '2') {
|
|
for (int i = 0; i < (inst.m.types[2] == 'V' ? 4 : 2); ++i)
|
|
regs[c++] = inst.src2 + i;
|
|
}
|
|
if ((inst.m.flags & (IRFLAG_SRC3 | IRFLAG_SRC3DST)) != 0) {
|
|
if (inst.m.types[0] == 'V' || inst.m.types[0] == '2') {
|
|
for (int i = 0; i < (inst.m.types[0] == 'V' ? 4 : 2); ++i)
|
|
regs[c++] = inst.src3 + i;
|
|
}
|
|
}
|
|
return c;
|
|
}
|
|
|
|
IRUsage IRNextGPRUsage(int gpr, const IRSituation &info) {
|
|
// Exclude any "special" regs from this logic for now.
|
|
if (gpr >= 32)
|
|
return IRUsage::UNKNOWN;
|
|
|
|
int count = std::min(info.numInstructions - info.currentIndex, info.lookaheadCount);
|
|
for (int i = 0; i < count; ++i) {
|
|
const IRInstMeta inst = GetIRMeta(info.instructions[info.currentIndex + i]);
|
|
if (IRReadsFromGPR(inst, gpr))
|
|
return IRUsage::READ;
|
|
// We say WRITE when the current instruction writes. It's not useful for spilling.
|
|
if (IRDestGPR(inst) == gpr)
|
|
return i == 0 ? IRUsage::WRITE : IRUsage::CLOBBERED;
|
|
}
|
|
|
|
return IRUsage::UNUSED;
|
|
}
|
|
|
|
IRUsage IRNextFPRUsage(int fpr, const IRSituation &info) {
|
|
// Let's only pay attention to standard FP regs and temps.
|
|
// See MIPS.h for these offsets.
|
|
if (fpr < 0 || (fpr >= 160 && fpr < 192) || fpr >= 208)
|
|
return IRUsage::UNKNOWN;
|
|
|
|
int count = std::min(info.numInstructions - info.currentIndex, info.lookaheadCount);
|
|
for (int i = 0; i < count; ++i) {
|
|
const IRInstMeta inst = GetIRMeta(info.instructions[info.currentIndex + i]);
|
|
|
|
if (IRReadsFromFPR(inst, fpr)) {
|
|
// Special case a broadcast that clobbers it.
|
|
if (inst.op == IROp::Vec4Shuffle && inst.src2 == 0 && inst.dest == inst.src1)
|
|
return inst.src1 == fpr ? IRUsage::READ : IRUsage::CLOBBERED;
|
|
|
|
// If this is an exit reading a temp, ignore it.
|
|
if (fpr < IRVTEMP_PFX_S || (GetIRMeta(inst.op)->flags & IRFLAG_EXIT) == 0)
|
|
return IRUsage::READ;
|
|
}
|
|
// We say WRITE when the current instruction writes. It's not useful for spilling.
|
|
if (IRWritesToFPR(inst, fpr)) {
|
|
return i == 0 ? IRUsage::WRITE : IRUsage::CLOBBERED;
|
|
}
|
|
}
|
|
|
|
// This means we only had exits and hit the end.
|
|
if (fpr >= IRVTEMP_PFX_S && count == info.numInstructions - info.currentIndex)
|
|
return IRUsage::CLOBBERED;
|
|
|
|
return IRUsage::UNUSED;
|
|
}
|