mirror of
https://github.com/hrydgard/ppsspp.git
synced 2026-11-16 11:03:45 +01:00
Merge pull request #8042 from hrydgard/debloat-rounding-2
Pregenerate rounding code and call it
This commit is contained in:
commit
4c4e95743a
16 files changed
+335
-322
No files matched your search
@@ -1091,7 +1091,6 @@ elseif(ARM64)
|
||||
elseif(X86)
|
||||
set(CoreExtra ${CoreExtra}
|
||||
Core/MIPS/x86/Asm.cpp
|
||||
Core/MIPS/x86/Asm.h
|
||||
Core/MIPS/x86/CompALU.cpp
|
||||
Core/MIPS/x86/CompBranch.cpp
|
||||
Core/MIPS/x86/CompFPU.cpp
|
||||
|
||||
@@ -679,7 +679,6 @@
|
||||
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
|
||||
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
|
||||
</ClInclude>
|
||||
<ClInclude Include="MIPS\x86\Asm.h" />
|
||||
<ClInclude Include="MIPS\x86\JitSafeMem.h" />
|
||||
<ClInclude Include="MIPS\x86\RegCacheFPU.h" />
|
||||
<ClInclude Include="MIPS\x86\Jit.h" />
|
||||
|
||||
@@ -666,9 +666,6 @@
|
||||
<ClInclude Include="MIPS\x86\Jit.h">
|
||||
<Filter>MIPS\x86</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="MIPS\x86\Asm.h">
|
||||
<Filter>MIPS\x86</Filter>
|
||||
</ClInclude>
|
||||
<ClInclude Include="MIPS\x86\RegCache.h">
|
||||
<Filter>MIPS\x86</Filter>
|
||||
</ClInclude>
|
||||
|
||||
@@ -31,6 +31,7 @@ using namespace ArmGen;
|
||||
//static int temp32; // unused?
|
||||
|
||||
static const bool enableDebug = false;
|
||||
static const bool disasm = false;
|
||||
|
||||
//static bool enableStatistics = false; //unused?
|
||||
|
||||
@@ -70,9 +71,82 @@ namespace MIPSComp {
|
||||
|
||||
using namespace ArmJitConstants;
|
||||
|
||||
void ArmJit::GenerateFixedCode()
|
||||
{
|
||||
enterCode = AlignCode16();
|
||||
void ArmJit::GenerateFixedCode() {
|
||||
const u8 *start = GetCodePtr();
|
||||
|
||||
// LR == SCRATCHREG2 on ARM32 so it needs to be pushed.
|
||||
restoreRoundingMode = AlignCode16(); {
|
||||
PUSH(1, R_LR);
|
||||
VMRS(SCRATCHREG2);
|
||||
// Assume we're always in round-to-nearest mode beforehand. Flush-to-zero is off.
|
||||
BIC(SCRATCHREG2, SCRATCHREG2, AssumeMakeOperand2((3 | 4) << 22));
|
||||
VMSR(SCRATCHREG2);
|
||||
POP(1, R_PC);
|
||||
}
|
||||
|
||||
// Must preserve SCRATCHREG1 (R0), destroys SCRATCHREG2 (LR)
|
||||
applyRoundingMode = AlignCode16(); {
|
||||
PUSH(2, SCRATCHREG1, R_LR);
|
||||
LDR(SCRATCHREG2, CTXREG, offsetof(MIPSState, fcr31));
|
||||
|
||||
TST(SCRATCHREG2, AssumeMakeOperand2(1 << 24));
|
||||
AND(SCRATCHREG2, SCRATCHREG2, Operand2(3));
|
||||
SetCC(CC_NEQ);
|
||||
ADD(SCRATCHREG2, SCRATCHREG2, Operand2(4));
|
||||
SetCC(CC_AL);
|
||||
// We can only skip if the rounding mode is zero and flush is not set.
|
||||
CMP(SCRATCHREG2, Operand2(3));
|
||||
|
||||
// At this point, if it was zero, we can skip the rest. (could even return)
|
||||
FixupBranch skip = B_CC(CC_EQ);
|
||||
|
||||
// MIPS Rounding Mode: ARM Rounding Mode
|
||||
// 0: Round nearest 0
|
||||
// 1: Round to zero 3
|
||||
// 2: Round up (ceil) 1
|
||||
// 3: Round down (floor) 2
|
||||
AND(SCRATCHREG1, SCRATCHREG2, Operand2(3));
|
||||
CMP(SCRATCHREG1, Operand2(1));
|
||||
|
||||
SetCC(CC_EQ); ADD(SCRATCHREG2, SCRATCHREG2, Operand2(2));
|
||||
SetCC(CC_GT); SUB(SCRATCHREG2, SCRATCHREG2, Operand2(1));
|
||||
SetCC(CC_AL);
|
||||
|
||||
VMRS(SCRATCHREG1);
|
||||
// Assume we're always in round-to-nearest mode beforehand.
|
||||
// But we need to clear flush to zero in this case anyway.
|
||||
BIC(SCRATCHREG1, SCRATCHREG1, AssumeMakeOperand2((3 | 4) << 22));
|
||||
ORR(SCRATCHREG1, SCRATCHREG1, Operand2(SCRATCHREG2, ST_LSL, 22));
|
||||
VMSR(SCRATCHREG1);
|
||||
|
||||
SetJumpTarget(skip);
|
||||
POP(2, SCRATCHREG1, R_PC);
|
||||
}
|
||||
|
||||
// Must preserve SCRATCHREG1 (R0), destroys SCRATCHREG2 (LR)
|
||||
updateRoundingMode = AlignCode16(); {
|
||||
PUSH(2, SCRATCHREG1, R_LR);
|
||||
LDR(SCRATCHREG2, CTXREG, offsetof(MIPSState, fcr31));
|
||||
|
||||
TST(SCRATCHREG2, AssumeMakeOperand2(1 << 24));
|
||||
AND(SCRATCHREG2, SCRATCHREG2, Operand2(3));
|
||||
SetCC(CC_NEQ);
|
||||
ADD(SCRATCHREG2, SCRATCHREG2, Operand2(4));
|
||||
SetCC(CC_AL);
|
||||
// We can only skip if the rounding mode is zero and flush is not set.
|
||||
CMP(SCRATCHREG2, Operand2(3));
|
||||
|
||||
FixupBranch skip = B_CC(CC_EQ);
|
||||
MOVI2R(SCRATCHREG2, 1);
|
||||
MOVP2R(SCRATCHREG1, &js.hasSetRounding);
|
||||
STRB(SCRATCHREG2, SCRATCHREG1, 0);
|
||||
SetJumpTarget(skip);
|
||||
POP(2, SCRATCHREG1, R_PC);
|
||||
}
|
||||
|
||||
FlushLitPool();
|
||||
|
||||
enterDispatcher = AlignCode16();
|
||||
|
||||
DEBUG_LOG(JIT, "Base: %08x", (u32)Memory::base);
|
||||
|
||||
@@ -203,9 +277,11 @@ void ArmJit::GenerateFixedCode()
|
||||
|
||||
|
||||
// Uncomment if you want to see the output...
|
||||
// INFO_LOG(JIT, "THE DISASM ========================");
|
||||
// DisassembleArm(enterCode, GetCodePtr() - enterCode);
|
||||
// INFO_LOG(JIT, "END OF THE DISASM ========================");
|
||||
if (disasm) {
|
||||
INFO_LOG(JIT, "THE DISASM ========================");
|
||||
DisassembleArm(start, GetCodePtr() - start);
|
||||
INFO_LOG(JIT, "END OF THE DISASM ========================");
|
||||
}
|
||||
|
||||
// Don't forget to zap the instruction cache!
|
||||
FlushLitPool();
|
||||
|
||||
@@ -234,7 +234,7 @@ void ArmJit::Compile(u32 em_address) {
|
||||
|
||||
void ArmJit::RunLoopUntil(u64 globalticks) {
|
||||
PROFILE_THIS_SCOPE("jit");
|
||||
((void (*)())enterCode)();
|
||||
((void (*)())enterDispatcher)();
|
||||
}
|
||||
|
||||
u32 ArmJit::GetCompilerPC() {
|
||||
@@ -387,7 +387,7 @@ void ArmJit::AddContinuedBlock(u32 dest)
|
||||
|
||||
bool ArmJit::DescribeCodePtr(const u8 *ptr, std::string &name)
|
||||
{
|
||||
// TODO: Not used by anything yet.
|
||||
// TODO: Not used by anything yet (except the modified VerySleepy on Windows)
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -585,77 +585,25 @@ void ArmJit::WriteDownCountR(ARMReg reg) {
|
||||
}
|
||||
}
|
||||
|
||||
// Destroys SCRATCHREG2. Does not destroy SCRATCHREG1.
|
||||
void ArmJit::RestoreRoundingMode(bool force) {
|
||||
// If the game has never set an interesting rounding mode, we can safely skip this.
|
||||
if (force || js.hasSetRounding) {
|
||||
VMRS(SCRATCHREG2);
|
||||
// Assume we're always in round-to-nearest mode beforehand. Flush-to-zero is off.
|
||||
BIC(SCRATCHREG2, SCRATCHREG2, AssumeMakeOperand2((3 | 4) << 22));
|
||||
VMSR(SCRATCHREG2);
|
||||
QuickCallFunction(R1, restoreRoundingMode);
|
||||
}
|
||||
}
|
||||
|
||||
// Does not destroy R0 (SCRATCHREG1). Destroys R14 (SCRATCHREG2).
|
||||
void ArmJit::ApplyRoundingMode(bool force) {
|
||||
// NOTE: Must not destroy R0.
|
||||
// If the game has never set an interesting rounding mode, we can safely skip this.
|
||||
if (force || js.hasSetRounding) {
|
||||
LDR(SCRATCHREG2, CTXREG, offsetof(MIPSState, fcr31));
|
||||
|
||||
TST(SCRATCHREG2, AssumeMakeOperand2(1 << 24));
|
||||
AND(SCRATCHREG2, SCRATCHREG2, Operand2(3));
|
||||
SetCC(CC_NEQ);
|
||||
ADD(SCRATCHREG2, SCRATCHREG2, Operand2(4));
|
||||
SetCC(CC_AL);
|
||||
// We can only skip if the rounding mode is zero and flush is not set.
|
||||
CMP(SCRATCHREG2, Operand2(3));
|
||||
|
||||
// At this point, if it was zero, we can skip the rest.
|
||||
FixupBranch skip = B_CC(CC_EQ);
|
||||
PUSH(1, SCRATCHREG1);
|
||||
|
||||
// MIPS Rounding Mode: ARM Rounding Mode
|
||||
// 0: Round nearest 0
|
||||
// 1: Round to zero 3
|
||||
// 2: Round up (ceil) 1
|
||||
// 3: Round down (floor) 2
|
||||
AND(SCRATCHREG1, SCRATCHREG2, Operand2(3));
|
||||
CMP(SCRATCHREG1, Operand2(1));
|
||||
|
||||
SetCC(CC_EQ); ADD(SCRATCHREG2, SCRATCHREG2, Operand2(2));
|
||||
SetCC(CC_GT); SUB(SCRATCHREG2, SCRATCHREG2, Operand2(1));
|
||||
SetCC(CC_AL);
|
||||
|
||||
VMRS(SCRATCHREG1);
|
||||
// Assume we're always in round-to-nearest mode beforehand.
|
||||
// But we need to clear flush to zero in this case anyway.
|
||||
BIC(SCRATCHREG1, SCRATCHREG1, AssumeMakeOperand2((3 | 4) << 22));
|
||||
ORR(SCRATCHREG1, SCRATCHREG1, Operand2(SCRATCHREG2, ST_LSL, 22));
|
||||
VMSR(SCRATCHREG1);
|
||||
|
||||
POP(1, SCRATCHREG1);
|
||||
SetJumpTarget(skip);
|
||||
QuickCallFunction(R1, applyRoundingMode);
|
||||
}
|
||||
}
|
||||
|
||||
// Does (must!) not destroy R0 (SCRATCHREG1). Destroys R14 (SCRATCHREG2).
|
||||
void ArmJit::UpdateRoundingMode() {
|
||||
// NOTE: Must not destroy R0.
|
||||
LDR(SCRATCHREG2, CTXREG, offsetof(MIPSState, fcr31));
|
||||
|
||||
TST(SCRATCHREG2, AssumeMakeOperand2(1 << 24));
|
||||
AND(SCRATCHREG2, SCRATCHREG2, Operand2(3));
|
||||
SetCC(CC_NEQ);
|
||||
ADD(SCRATCHREG2, SCRATCHREG2, Operand2(4));
|
||||
SetCC(CC_AL);
|
||||
// We can only skip if the rounding mode is zero and flush is not set.
|
||||
CMP(SCRATCHREG2, Operand2(3));
|
||||
|
||||
FixupBranch skip = B_CC(CC_EQ);
|
||||
PUSH(1, SCRATCHREG1);
|
||||
MOVI2R(SCRATCHREG2, 1);
|
||||
MOVP2R(SCRATCHREG1, &js.hasSetRounding);
|
||||
STRB(SCRATCHREG2, SCRATCHREG1, 0);
|
||||
POP(1, SCRATCHREG1);
|
||||
SetJumpTarget(skip);
|
||||
QuickCallFunction(R1, updateRoundingMode);
|
||||
}
|
||||
|
||||
// IDEA - could have a WriteDualExit that takes two destinations and two condition flags,
|
||||
|
||||
@@ -287,7 +287,7 @@ private:
|
||||
|
||||
public:
|
||||
// Code pointers
|
||||
const u8 *enterCode;
|
||||
const u8 *enterDispatcher;
|
||||
|
||||
const u8 *outerLoop;
|
||||
const u8 *outerLoopPCInR0;
|
||||
@@ -296,6 +296,10 @@ public:
|
||||
const u8 *dispatcher;
|
||||
const u8 *dispatcherNoCheck;
|
||||
|
||||
const u8 *restoreRoundingMode;
|
||||
const u8 *applyRoundingMode;
|
||||
const u8 *updateRoundingMode;
|
||||
|
||||
const u8 *breakpointBailout;
|
||||
};
|
||||
|
||||
|
||||
@@ -94,7 +94,7 @@ namespace MIPSComp {
|
||||
using namespace Arm64JitConstants;
|
||||
|
||||
void Arm64Jit::GenerateFixedCode(const JitOptions &jo) {
|
||||
const u8 *start = nullptr;
|
||||
const u8 *start = AlignCode16();
|
||||
if (jo.useStaticAlloc) {
|
||||
saveStaticRegisters = AlignCode16();
|
||||
STR(INDEX_UNSIGNED, DOWNCOUNTREG, CTXREG, offsetof(MIPSState, downcount));
|
||||
@@ -112,9 +112,84 @@ void Arm64Jit::GenerateFixedCode(const JitOptions &jo) {
|
||||
loadStaticRegisters = nullptr;
|
||||
}
|
||||
|
||||
enterCode = AlignCode16();
|
||||
if (!start)
|
||||
start = enterCode;
|
||||
restoreRoundingMode = AlignCode16(); {
|
||||
MRS(SCRATCH2_64, FIELD_FPCR);
|
||||
// We are not in flush-to-zero mode outside the JIT, so let's turn it off.
|
||||
uint32_t mask = ~(4 << 22);
|
||||
// Assume we're always in round-to-nearest mode beforehand.
|
||||
mask &= ~(3 << 22);
|
||||
ANDI2R(SCRATCH2, SCRATCH2, mask);
|
||||
_MSR(FIELD_FPCR, SCRATCH2_64);
|
||||
RET();
|
||||
}
|
||||
|
||||
applyRoundingMode = AlignCode16(); {
|
||||
LDR(INDEX_UNSIGNED, SCRATCH2, CTXREG, offsetof(MIPSState, fcr31));
|
||||
TSTI2R(SCRATCH2, 1 << 24);
|
||||
ANDI2R(SCRATCH2, SCRATCH2, 3);
|
||||
FixupBranch skip1 = B(CC_EQ);
|
||||
ADDI2R(SCRATCH2, SCRATCH2, 4);
|
||||
SetJumpTarget(skip1);
|
||||
// We can only skip if the rounding mode is zero and flush is set.
|
||||
CMPI2R(SCRATCH2, 4);
|
||||
// At this point, if it was zero, we can skip the rest.
|
||||
FixupBranch skip = B(CC_EQ);
|
||||
|
||||
// MIPS Rounding Mode: ARM Rounding Mode
|
||||
// 0: Round nearest 0
|
||||
// 1: Round to zero 3
|
||||
// 2: Round up (ceil) 1
|
||||
// 3: Round down (floor) 2
|
||||
ANDI2R(SCRATCH1, SCRATCH2, 3);
|
||||
CMPI2R(SCRATCH1, 1);
|
||||
|
||||
FixupBranch skipadd = B(CC_NEQ);
|
||||
ADDI2R(SCRATCH2, SCRATCH2, 2);
|
||||
SetJumpTarget(skipadd);
|
||||
FixupBranch skipsub = B(CC_LE);
|
||||
SUBI2R(SCRATCH2, SCRATCH2, 1);
|
||||
SetJumpTarget(skipsub);
|
||||
|
||||
MRS(SCRATCH1_64, FIELD_FPCR);
|
||||
|
||||
// Clear both flush-to-zero and rounding before re-setting them.
|
||||
ANDI2R(SCRATCH1, SCRATCH1, ~((4 | 3) << 22));
|
||||
|
||||
ORR(SCRATCH1, SCRATCH1, SCRATCH2, ArithOption(SCRATCH2, ST_LSL, 22));
|
||||
_MSR(FIELD_FPCR, SCRATCH1_64);
|
||||
|
||||
// Let's update js.currentRoundingFunc with the right convertS0ToSCRATCH1 func.
|
||||
MOVP2R(SCRATCH1_64, convertS0ToSCRATCH1);
|
||||
// We already index this array including the FZ bit. Easy.
|
||||
LSL(SCRATCH2, SCRATCH2, 3);
|
||||
LDR(SCRATCH2_64, SCRATCH1_64, SCRATCH2);
|
||||
MOVP2R(SCRATCH1_64, &js.currentRoundingFunc);
|
||||
STR(INDEX_UNSIGNED, SCRATCH2_64, SCRATCH1_64, 0);
|
||||
|
||||
SetJumpTarget(skip);
|
||||
RET();
|
||||
}
|
||||
|
||||
updateRoundingMode = AlignCode16(); {
|
||||
LDR(INDEX_UNSIGNED, SCRATCH2, CTXREG, offsetof(MIPSState, fcr31));
|
||||
|
||||
TSTI2R(SCRATCH2, 1 << 24);
|
||||
ANDI2R(SCRATCH2, SCRATCH2, 3);
|
||||
FixupBranch skip = B(CC_EQ);
|
||||
ADDI2R(SCRATCH2, SCRATCH2, 4);
|
||||
SetJumpTarget(skip);
|
||||
|
||||
// We can only skip if the rounding mode is zero and flush is not set.
|
||||
CMPI2R(SCRATCH2, 3);
|
||||
|
||||
FixupBranch skip2 = B(CC_EQ);
|
||||
MOVI2R(SCRATCH2, 1);
|
||||
MOVP2R(SCRATCH1_64, &js.hasSetRounding);
|
||||
STRB(INDEX_UNSIGNED, SCRATCH2, SCRATCH1_64, 0);
|
||||
SetJumpTarget(skip2);
|
||||
}
|
||||
|
||||
enterDispatcher = AlignCode16();
|
||||
|
||||
BitSet32 regs_to_save(Arm64Gen::ALL_CALLEE_SAVED);
|
||||
BitSet32 regs_to_save_fp(Arm64Gen::ALL_CALLEE_SAVED_FP);
|
||||
@@ -176,7 +251,7 @@ void Arm64Jit::GenerateFixedCode(const JitOptions &jo) {
|
||||
|
||||
LDR(INDEX_UNSIGNED, SCRATCH1, CTXREG, offsetof(MIPSState, pc));
|
||||
LDR(SCRATCH1, MEMBASEREG, SCRATCH1_64);
|
||||
LSR(SCRATCH2, SCRATCH1, 24);
|
||||
LSR(SCRATCH2, SCRATCH1, 24); // or UBFX(SCRATCH2, SCRATCH1, 24, 8)
|
||||
ANDI2R(SCRATCH1, SCRATCH1, 0x00FFFFFF);
|
||||
CMP(SCRATCH2, MIPS_EMUHACK_OPCODE >> 24);
|
||||
FixupBranch skipJump = B(CC_NEQ);
|
||||
|
||||
@@ -220,7 +220,7 @@ void Arm64Jit::Compile(u32 em_address) {
|
||||
|
||||
void Arm64Jit::RunLoopUntil(u64 globalticks) {
|
||||
PROFILE_THIS_SCOPE("jit");
|
||||
((void (*)())enterCode)();
|
||||
((void (*)())enterDispatcher)();
|
||||
}
|
||||
|
||||
u32 Arm64Jit::GetCompilerPC() {
|
||||
@@ -350,7 +350,7 @@ void Arm64Jit::AddContinuedBlock(u32 dest) {
|
||||
}
|
||||
|
||||
bool Arm64Jit::DescribeCodePtr(const u8 *ptr, std::string &name) {
|
||||
// TODO: Not used by anything yet.
|
||||
// TODO: Not used by anything yet (except the modified VerySleepy on Windows)
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -528,13 +528,7 @@ void Arm64Jit::WriteDownCountR(ARM64Reg reg, bool updateFlags) {
|
||||
void Arm64Jit::RestoreRoundingMode(bool force) {
|
||||
// If the game has never set an interesting rounding mode, we can safely skip this.
|
||||
if (force || js.hasSetRounding) {
|
||||
MRS(SCRATCH2_64, FIELD_FPCR);
|
||||
// We are not in flush-to-zero mode outside the JIT, so let's turn it off.
|
||||
uint32_t mask = ~(4 << 22);
|
||||
// Assume we're always in round-to-nearest mode beforehand.
|
||||
mask &= ~(3 << 22);
|
||||
ANDI2R(SCRATCH2, SCRATCH2, mask);
|
||||
_MSR(FIELD_FPCR, SCRATCH2_64);
|
||||
QuickCallFunction(SCRATCH2_64, restoreRoundingMode);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -542,70 +536,13 @@ void Arm64Jit::RestoreRoundingMode(bool force) {
|
||||
void Arm64Jit::ApplyRoundingMode(bool force) {
|
||||
// If the game has never set an interesting rounding mode, we can safely skip this.
|
||||
if (force || js.hasSetRounding) {
|
||||
LDR(INDEX_UNSIGNED, SCRATCH2, CTXREG, offsetof(MIPSState, fcr31));
|
||||
TSTI2R(SCRATCH2, 1 << 24);
|
||||
ANDI2R(SCRATCH2, SCRATCH2, 3);
|
||||
FixupBranch skip1 = B(CC_EQ);
|
||||
ADDI2R(SCRATCH2, SCRATCH2, 4);
|
||||
SetJumpTarget(skip1);
|
||||
// We can only skip if the rounding mode is zero and flush is set.
|
||||
CMPI2R(SCRATCH2, 4);
|
||||
// At this point, if it was zero, we can skip the rest.
|
||||
FixupBranch skip = B(CC_EQ);
|
||||
|
||||
// MIPS Rounding Mode: ARM Rounding Mode
|
||||
// 0: Round nearest 0
|
||||
// 1: Round to zero 3
|
||||
// 2: Round up (ceil) 1
|
||||
// 3: Round down (floor) 2
|
||||
ANDI2R(SCRATCH1, SCRATCH2, 3);
|
||||
CMPI2R(SCRATCH1, 1);
|
||||
|
||||
FixupBranch skipadd = B(CC_NEQ);
|
||||
ADDI2R(SCRATCH2, SCRATCH2, 2);
|
||||
SetJumpTarget(skipadd);
|
||||
FixupBranch skipsub = B(CC_LE);
|
||||
SUBI2R(SCRATCH2, SCRATCH2, 1);
|
||||
SetJumpTarget(skipsub);
|
||||
|
||||
MRS(SCRATCH1_64, FIELD_FPCR);
|
||||
|
||||
// Clear both flush-to-zero and rounding before re-setting them.
|
||||
ANDI2R(SCRATCH1, SCRATCH1, ~((4 | 3) << 22));
|
||||
|
||||
ORR(SCRATCH1, SCRATCH1, SCRATCH2, ArithOption(SCRATCH2, ST_LSL, 22));
|
||||
_MSR(FIELD_FPCR, SCRATCH1_64);
|
||||
|
||||
// Let's update js.currentRoundingFunc with the right convertS0ToSCRATCH1 func.
|
||||
MOVP2R(SCRATCH1_64, convertS0ToSCRATCH1);
|
||||
// We already index this array including the FZ bit. Easy.
|
||||
LSL(SCRATCH2, SCRATCH2, 3);
|
||||
LDR(SCRATCH2_64, SCRATCH1_64, SCRATCH2);
|
||||
MOVP2R(SCRATCH1_64, &js.currentRoundingFunc);
|
||||
STR(INDEX_UNSIGNED, SCRATCH2_64, SCRATCH1_64, 0);
|
||||
|
||||
SetJumpTarget(skip);
|
||||
QuickCallFunction(SCRATCH2_64, applyRoundingMode);
|
||||
}
|
||||
}
|
||||
|
||||
// Destroys SCRATCH1 and SCRATCH2
|
||||
void Arm64Jit::UpdateRoundingMode() {
|
||||
LDR(INDEX_UNSIGNED, SCRATCH2, CTXREG, offsetof(MIPSState, fcr31));
|
||||
|
||||
TSTI2R(SCRATCH2, 1 << 24);
|
||||
ANDI2R(SCRATCH2, SCRATCH2, 3);
|
||||
FixupBranch skip = B(CC_EQ);
|
||||
ADDI2R(SCRATCH2, SCRATCH2, 4);
|
||||
SetJumpTarget(skip);
|
||||
|
||||
// We can only skip if the rounding mode is zero and flush is not set.
|
||||
CMPI2R(SCRATCH2, 3);
|
||||
|
||||
FixupBranch skip2 = B(CC_EQ);
|
||||
MOVI2R(SCRATCH2, 1);
|
||||
MOVP2R(SCRATCH1_64, &js.hasSetRounding);
|
||||
STRB(INDEX_UNSIGNED, SCRATCH2, SCRATCH1_64, 0);
|
||||
SetJumpTarget(skip2);
|
||||
QuickCallFunction(SCRATCH2_64, updateRoundingMode);
|
||||
}
|
||||
|
||||
// IDEA - could have a WriteDualExit that takes two destinations and two condition flags,
|
||||
|
||||
@@ -251,7 +251,7 @@ private:
|
||||
|
||||
public:
|
||||
// Code pointers
|
||||
const u8 *enterCode;
|
||||
const u8 *enterDispatcher;
|
||||
|
||||
const u8 *outerLoop;
|
||||
const u8 *outerLoopPCInSCRATCH1;
|
||||
@@ -265,6 +265,10 @@ public:
|
||||
const u8 *saveStaticRegisters;
|
||||
const u8 *loadStaticRegisters;
|
||||
|
||||
const u8 *restoreRoundingMode;
|
||||
const u8 *applyRoundingMode;
|
||||
const u8 *updateRoundingMode;
|
||||
|
||||
// Indexed by FPCR FZ:RN bits for convenience. Uses SCRATCH2.
|
||||
const u8 *convertS0ToSCRATCH1[8];
|
||||
};
|
||||
|
||||
@@ -46,7 +46,6 @@
|
||||
|
||||
#if defined(_M_IX86) || defined(_M_X64)
|
||||
#include "Common/x64Analyzer.h"
|
||||
#include "Core/MIPS/x86/Asm.h"
|
||||
#endif
|
||||
// #include "JitBase.h"
|
||||
|
||||
@@ -593,7 +592,7 @@ void JitBlockCache::DestroyBlock(int block_num, bool invalidate) {
|
||||
// Spurious entrances from previously linked blocks can only come through checkedEntry
|
||||
XEmitter emit((u8 *)b->checkedEntry);
|
||||
emit.MOV(32, M(&mips_->pc), Imm32(b->originalAddress));
|
||||
emit.JMP(MIPSComp::jit->Asm().dispatcher, true);
|
||||
emit.JMP(MIPSComp::jit->GetDispatcher(), true);
|
||||
|
||||
#elif defined(ARM64)
|
||||
|
||||
|
||||
@@ -154,15 +154,12 @@ const char *ppsspp_resolver(struct ud*,
|
||||
*offset = addr - (uint64_t)(¤tMIPS->v[0]);
|
||||
return "mips.v";
|
||||
}
|
||||
|
||||
// But these do.
|
||||
if (MIPSComp::jit->IsInSpace((u8 *)(intptr_t)addr)) {
|
||||
*offset = addr - (uint64_t)MIPSComp::jit->GetBasePtr();
|
||||
return "jitcode";
|
||||
}
|
||||
if (MIPSComp::jit->Asm().IsInSpace((u8 *)(intptr_t)addr)) {
|
||||
*offset = addr - (uint64_t)MIPSComp::jit->Asm().GetBasePtr();
|
||||
return "dispatcher";
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
+86
-24
@@ -28,15 +28,20 @@
|
||||
#include "Common/MemoryUtil.h"
|
||||
|
||||
#include "Core/MIPS/JitCommon/JitCommon.h"
|
||||
#include "Core/MIPS/x86/Asm.h"
|
||||
#include "Core/MIPS/x86/Jit.h"
|
||||
|
||||
using namespace Gen;
|
||||
using namespace X64JitConstants;
|
||||
|
||||
extern volatile CoreState coreState;
|
||||
|
||||
namespace MIPSComp
|
||||
{
|
||||
|
||||
//TODO - make an option
|
||||
//#if _DEBUG
|
||||
static bool enableDebug = false;
|
||||
|
||||
//#else
|
||||
// bool enableDebug = false;
|
||||
//#endif
|
||||
@@ -53,34 +58,87 @@ static bool enableDebug = false;
|
||||
//R14 - Pointer to fpr/gpr regs
|
||||
//R15 - Pointer to array of block pointers
|
||||
|
||||
extern volatile CoreState coreState;
|
||||
|
||||
void ImHere()
|
||||
{
|
||||
void ImHere() {
|
||||
DEBUG_LOG(CPU, "JIT Here: %08x", currentMIPS->pc);
|
||||
}
|
||||
|
||||
void AsmRoutineManager::Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp::JitOptions *jo)
|
||||
{
|
||||
enterCode = AlignCode16();
|
||||
void Jit::GenerateFixedCode(JitOptions &jo) {
|
||||
const u8 *start = AlignCode16();
|
||||
|
||||
restoreRoundingMode = AlignCode16(); {
|
||||
STMXCSR(M(&mips_->temp));
|
||||
// Clear the rounding mode and flush-to-zero bits back to 0.
|
||||
AND(32, M(&mips_->temp), Imm32(~(7 << 13)));
|
||||
LDMXCSR(M(&mips_->temp));
|
||||
RET();
|
||||
}
|
||||
|
||||
applyRoundingMode = AlignCode16(); {
|
||||
MOV(32, R(EAX), M(&mips_->fcr31));
|
||||
AND(32, R(EAX), Imm32(0x1000003));
|
||||
|
||||
// If it's 0, we don't actually bother setting. This is the most common.
|
||||
// We always use nearest as the default rounding mode with
|
||||
// flush-to-zero disabled.
|
||||
FixupBranch skip = J_CC(CC_Z);
|
||||
|
||||
STMXCSR(M(&mips_->temp));
|
||||
|
||||
// The MIPS bits don't correspond exactly, so we have to adjust.
|
||||
// 0 -> 0 (skip2), 1 -> 3, 2 -> 2 (skip2), 3 -> 1
|
||||
TEST(8, R(AL), Imm8(1));
|
||||
FixupBranch skip2 = J_CC(CC_Z);
|
||||
XOR(32, R(EAX), Imm8(2));
|
||||
SetJumpTarget(skip2);
|
||||
|
||||
SHL(32, R(EAX), Imm8(13));
|
||||
OR(32, M(&mips_->temp), R(EAX));
|
||||
|
||||
TEST(32, M(&mips_->fcr31), Imm32(1 << 24));
|
||||
FixupBranch skip3 = J_CC(CC_Z);
|
||||
OR(32, M(&mips_->temp), Imm32(1 << 15));
|
||||
SetJumpTarget(skip3);
|
||||
|
||||
LDMXCSR(M(&mips_->temp));
|
||||
SetJumpTarget(skip);
|
||||
RET();
|
||||
}
|
||||
|
||||
updateRoundingMode = AlignCode16(); {
|
||||
// If it's only ever 0, we don't actually bother applying or restoring it.
|
||||
// This is the most common situation.
|
||||
TEST(32, M(&mips_->fcr31), Imm32(0x01000003));
|
||||
FixupBranch skip = J_CC(CC_Z);
|
||||
#ifdef _M_X64
|
||||
// TODO: Move the hasSetRounding flag somewhere we can reach it through the context pointer, or something.
|
||||
MOV(64, R(RAX), Imm64((uintptr_t)&js.hasSetRounding));
|
||||
MOV(8, MatR(RAX), Imm8(1));
|
||||
#else
|
||||
MOV(8, M(&js.hasSetRounding), Imm8(1));
|
||||
#endif
|
||||
SetJumpTarget(skip);
|
||||
|
||||
RET();
|
||||
}
|
||||
|
||||
enterDispatcher = AlignCode16();
|
||||
ABI_PushAllCalleeSavedRegsAndAdjustStack();
|
||||
#ifdef _M_X64
|
||||
// Two statically allocated registers.
|
||||
MOV(64, R(MEMBASEREG), ImmPtr(Memory::base));
|
||||
uintptr_t jitbase = (uintptr_t)jit->GetBasePtr();
|
||||
if (jitbase > 0x7FFFFFFFULL)
|
||||
{
|
||||
MOV(64, R(JITBASEREG), ImmPtr(jit->GetBasePtr()));
|
||||
jo->reserveR15ForAsm = true;
|
||||
uintptr_t jitbase = (uintptr_t)GetBasePtr();
|
||||
if (jitbase > 0x7FFFFFFFULL) {
|
||||
MOV(64, R(JITBASEREG), ImmPtr(GetBasePtr()));
|
||||
jo.reserveR15ForAsm = true;
|
||||
}
|
||||
#endif
|
||||
// From the start of the FP reg, a single byte offset can reach all GPR + all FPR (but no VFPUR)
|
||||
MOV(PTRBITS, R(CTXREG), ImmPtr(&mips->f[0]));
|
||||
MOV(PTRBITS, R(CTXREG), ImmPtr(&mips_->f[0]));
|
||||
|
||||
outerLoop = GetCodePtr();
|
||||
jit->RestoreRoundingMode(true, this);
|
||||
RestoreRoundingMode(true);
|
||||
ABI_CallFunction(reinterpret_cast<void *>(&CoreTiming::Advance));
|
||||
jit->ApplyRoundingMode(true, this);
|
||||
ApplyRoundingMode(true);
|
||||
FixupBranch skipToRealDispatch = J(); //skip the sync and compare first time
|
||||
|
||||
dispatcherCheckCoreState = GetCodePtr();
|
||||
@@ -104,7 +162,7 @@ void AsmRoutineManager::Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp::
|
||||
|
||||
dispatcherNoCheck = GetCodePtr();
|
||||
|
||||
MOV(32, R(EAX), M(&mips->pc));
|
||||
MOV(32, R(EAX), M(&mips_->pc));
|
||||
dispatcherInEAXNoCheck = GetCodePtr();
|
||||
|
||||
#ifdef _M_IX86
|
||||
@@ -121,14 +179,14 @@ void AsmRoutineManager::Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp::
|
||||
FixupBranch notfound = J_CC(CC_NE);
|
||||
if (enableDebug)
|
||||
{
|
||||
ADD(32, M(&mips->debugCount), Imm8(1));
|
||||
ADD(32, M(&mips_->debugCount), Imm8(1));
|
||||
}
|
||||
//grab from list and jump to it
|
||||
AND(32, R(EAX), Imm32(MIPS_EMUHACK_VALUE_MASK));
|
||||
#ifdef _M_IX86
|
||||
ADD(32, R(EAX), ImmPtr(jit->GetBasePtr()));
|
||||
ADD(32, R(EAX), ImmPtr(GetBasePtr()));
|
||||
#elif _M_X64
|
||||
if (jo->reserveR15ForAsm)
|
||||
if (jo.reserveR15ForAsm)
|
||||
ADD(64, R(RAX), R(JITBASEREG));
|
||||
else
|
||||
ADD(64, R(EAX), Imm32(jitbase));
|
||||
@@ -137,9 +195,9 @@ void AsmRoutineManager::Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp::
|
||||
SetJumpTarget(notfound);
|
||||
|
||||
//Ok, no block, let's jit
|
||||
jit->RestoreRoundingMode(true, this);
|
||||
RestoreRoundingMode(true);
|
||||
ABI_CallFunction(&MIPSComp::JitAt);
|
||||
jit->ApplyRoundingMode(true, this);
|
||||
ApplyRoundingMode(true);
|
||||
JMP(dispatcherNoCheck, true); // Let's just dispatch again, we'll enter the block since we know it's there.
|
||||
|
||||
SetJumpTarget(bail);
|
||||
@@ -149,12 +207,16 @@ void AsmRoutineManager::Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp::
|
||||
J_CC(CC_Z, outerLoop, true);
|
||||
|
||||
SetJumpTarget(badCoreState);
|
||||
jit->RestoreRoundingMode(true, this);
|
||||
RestoreRoundingMode(true);
|
||||
ABI_PopAllCalleeSavedRegsAndAdjustStack();
|
||||
RET();
|
||||
|
||||
breakpointBailout = GetCodePtr();
|
||||
jit->RestoreRoundingMode(true, this);
|
||||
RestoreRoundingMode(true);
|
||||
ABI_PopAllCalleeSavedRegsAndAdjustStack();
|
||||
RET();
|
||||
|
||||
endOfPregeneratedCode = GetCodePtr();
|
||||
}
|
||||
|
||||
} // namespace
|
||||
@@ -1,50 +0,0 @@
|
||||
// Copyright (C) 2003 Dolphin 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 SVN repository and contact information can be found at
|
||||
// http://code.google.com/p/dolphin-emu/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "Common/x64Emitter.h"
|
||||
#include "Core/MIPS/MIPS.h"
|
||||
|
||||
// Runtime generated assembly routines, like the Dispatcher.
|
||||
|
||||
namespace MIPSComp {
|
||||
class Jit;
|
||||
struct JitOptions;
|
||||
}
|
||||
|
||||
class AsmRoutineManager : public Gen::XCodeBlock {
|
||||
private:
|
||||
void Generate(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp::JitOptions *jo);
|
||||
|
||||
public:
|
||||
void Init(MIPSState *mips, MIPSComp::Jit *jit, MIPSComp::JitOptions *jo) {
|
||||
AllocCodeSpace(8192);
|
||||
Generate(mips, jit, jo);
|
||||
WriteProtect();
|
||||
}
|
||||
|
||||
const u8 *enterCode;
|
||||
|
||||
const u8 *outerLoop;
|
||||
const u8 *dispatcher;
|
||||
const u8 *dispatcherCheckCoreState;
|
||||
const u8 *dispatcherNoCheck;
|
||||
const u8 *dispatcherInEAXNoCheck;
|
||||
|
||||
const u8 *breakpointBailout;
|
||||
};
|
||||
+37
-88
@@ -119,13 +119,13 @@ static void JitLogMiss(MIPSOpcode op)
|
||||
// JitBlockCache doesn't use this, just stores it.
|
||||
#pragma warning(disable:4355)
|
||||
#endif
|
||||
Jit::Jit(MIPSState *mips) : blocks(mips, this), mips_(mips)
|
||||
{
|
||||
Jit::Jit(MIPSState *mips)
|
||||
: blocks(mips, this), mips_(mips) {
|
||||
blocks.Init();
|
||||
gpr.SetEmitter(this);
|
||||
fpr.SetEmitter(this);
|
||||
AllocCodeSpace(1024 * 1024 * 16);
|
||||
asm_.Init(mips, this, &jo);
|
||||
GenerateFixedCode(jo);
|
||||
safeMemFuncs.Init(&thunks);
|
||||
|
||||
js.startDefaultPrefix = mips_->HasDefaultPrefix();
|
||||
@@ -220,80 +220,29 @@ void Jit::WriteDowncount(int offset)
|
||||
SUB(32, M(&mips_->downcount), downcount > 127 ? Imm32(downcount) : Imm8(downcount));
|
||||
}
|
||||
|
||||
void Jit::RestoreRoundingMode(bool force, XEmitter *emitter)
|
||||
{
|
||||
void Jit::RestoreRoundingMode(bool force) {
|
||||
// If the game has never set an interesting rounding mode, we can safely skip this.
|
||||
if (force || js.hasSetRounding)
|
||||
{
|
||||
if (emitter == NULL)
|
||||
emitter = this;
|
||||
emitter->STMXCSR(M(&mips_->temp));
|
||||
// Clear the rounding mode and flush-to-zero bits back to 0.
|
||||
emitter->AND(32, M(&mips_->temp), Imm32(~(7 << 13)));
|
||||
emitter->LDMXCSR(M(&mips_->temp));
|
||||
if (force || js.hasSetRounding) {
|
||||
CALL(restoreRoundingMode);
|
||||
}
|
||||
}
|
||||
|
||||
void Jit::ApplyRoundingMode(bool force, XEmitter *emitter)
|
||||
{
|
||||
void Jit::ApplyRoundingMode(bool force) {
|
||||
// If the game has never set an interesting rounding mode, we can safely skip this.
|
||||
if (force || js.hasSetRounding)
|
||||
{
|
||||
if (emitter == NULL)
|
||||
emitter = this;
|
||||
emitter->MOV(32, R(EAX), M(&mips_->fcr31));
|
||||
emitter->AND(32, R(EAX), Imm32(0x1000003));
|
||||
|
||||
// If it's 0, we don't actually bother setting. This is the most common.
|
||||
// We always use nearest as the default rounding mode with
|
||||
// flush-to-zero disabled.
|
||||
FixupBranch skip = emitter->J_CC(CC_Z);
|
||||
|
||||
emitter->STMXCSR(M(&mips_->temp));
|
||||
|
||||
// The MIPS bits don't correspond exactly, so we have to adjust.
|
||||
// 0 -> 0 (skip2), 1 -> 3, 2 -> 2 (skip2), 3 -> 1
|
||||
emitter->TEST(8, R(AL), Imm8(1));
|
||||
FixupBranch skip2 = emitter->J_CC(CC_Z);
|
||||
emitter->XOR(32, R(EAX), Imm8(2));
|
||||
emitter->SetJumpTarget(skip2);
|
||||
|
||||
emitter->SHL(32, R(EAX), Imm8(13));
|
||||
emitter->OR(32, M(&mips_->temp), R(EAX));
|
||||
|
||||
emitter->TEST(32, M(&mips_->fcr31), Imm32(1 << 24));
|
||||
FixupBranch skip3 = emitter->J_CC(CC_Z);
|
||||
emitter->OR(32, M(&mips_->temp), Imm32(1 << 15));
|
||||
emitter->SetJumpTarget(skip3);
|
||||
|
||||
emitter->LDMXCSR(M(&mips_->temp));
|
||||
emitter->SetJumpTarget(skip);
|
||||
if (force || js.hasSetRounding) {
|
||||
CALL(applyRoundingMode);
|
||||
}
|
||||
}
|
||||
|
||||
void Jit::UpdateRoundingMode(XEmitter *emitter)
|
||||
{
|
||||
if (emitter == NULL)
|
||||
emitter = this;
|
||||
|
||||
// If it's only ever 0, we don't actually bother applying or restoring it.
|
||||
// This is the most common situation.
|
||||
emitter->TEST(32, M(&mips_->fcr31), Imm32(0x01000003));
|
||||
FixupBranch skip = emitter->J_CC(CC_Z);
|
||||
#ifdef _M_X64
|
||||
// TODO: Move the hasSetRounding flag somewhere we can reach it through the context pointer, or something.
|
||||
emitter->MOV(64, R(RAX), Imm64((uintptr_t)&js.hasSetRounding));
|
||||
emitter->MOV(8, MatR(RAX), Imm8(1));
|
||||
#else
|
||||
emitter->MOV(8, M(&js.hasSetRounding), Imm8(1));
|
||||
#endif
|
||||
emitter->SetJumpTarget(skip);
|
||||
void Jit::UpdateRoundingMode() {
|
||||
CALL(updateRoundingMode);
|
||||
}
|
||||
|
||||
void Jit::ClearCache()
|
||||
{
|
||||
blocks.Clear();
|
||||
ClearCodeSpace();
|
||||
GenerateFixedCode(jo);
|
||||
}
|
||||
|
||||
void Jit::InvalidateCache()
|
||||
@@ -383,7 +332,7 @@ void Jit::Compile(u32 em_address)
|
||||
void Jit::RunLoopUntil(u64 globalticks)
|
||||
{
|
||||
PROFILE_THIS_SCOPE("jit");
|
||||
((void (*)())asm_.enterCode)();
|
||||
((void (*)())enterDispatcher)();
|
||||
}
|
||||
|
||||
u32 Jit::GetCompilerPC() {
|
||||
@@ -413,7 +362,7 @@ const u8 *Jit::DoJit(u32 em_address, JitBlock *b)
|
||||
// Downcount flag check. The last block decremented downcounter, and the flag should still be available.
|
||||
FixupBranch skip = J_CC(CC_NS);
|
||||
MOV(32, M(&mips_->pc), Imm32(js.blockStart));
|
||||
JMP(asm_.outerLoop, true); // downcount hit zero - go advance.
|
||||
JMP(outerLoop, true); // downcount hit zero - go advance.
|
||||
SetJumpTarget(skip);
|
||||
|
||||
b->normalEntry = GetCodePtr();
|
||||
@@ -491,15 +440,13 @@ void Jit::AddContinuedBlock(u32 dest)
|
||||
js.lastContinuedPC = dest;
|
||||
}
|
||||
|
||||
bool Jit::DescribeCodePtr(const u8 *ptr, std::string &name)
|
||||
{
|
||||
bool Jit::DescribeCodePtr(const u8 *ptr, std::string &name) {
|
||||
u32 jitAddr = blocks.GetAddressFromBlockPtr(ptr);
|
||||
|
||||
// Returns 0 when it's valid, but unknown.
|
||||
if (jitAddr == 0)
|
||||
if (jitAddr == 0) {
|
||||
name = "UnknownOrDeletedBlock";
|
||||
else if (jitAddr != (u32)-1)
|
||||
{
|
||||
} else if (jitAddr != (u32)-1) {
|
||||
char temp[1024];
|
||||
const std::string label = symbolMap.GetDescription(jitAddr);
|
||||
if (!label.empty())
|
||||
@@ -507,18 +454,20 @@ bool Jit::DescribeCodePtr(const u8 *ptr, std::string &name)
|
||||
else
|
||||
snprintf(temp, sizeof(temp), "%08x", jitAddr);
|
||||
name = temp;
|
||||
}
|
||||
else if (asm_.IsInSpace(ptr))
|
||||
name = "RunLoopUntil";
|
||||
else if (thunks.IsInSpace(ptr))
|
||||
} else if (IsInSpace(ptr)) {
|
||||
if (ptr < endOfPregeneratedCode) {
|
||||
name = "PreGenCode";
|
||||
} else {
|
||||
name = "Unknown";
|
||||
}
|
||||
} else if (thunks.IsInSpace(ptr)) {
|
||||
name = "Thunk";
|
||||
else if (safeMemFuncs.IsInSpace(ptr))
|
||||
} else if (safeMemFuncs.IsInSpace(ptr)) {
|
||||
name = "JitSafeMem";
|
||||
else if (IsInSpace(ptr))
|
||||
name = "Unknown";
|
||||
// Not anywhere in jit, then.
|
||||
else
|
||||
} else {
|
||||
// Not anywhere in jit, then.
|
||||
return false;
|
||||
}
|
||||
|
||||
// If we got here, one of the above cases matched.
|
||||
return true;
|
||||
@@ -706,7 +655,7 @@ void Jit::WriteExit(u32 destination, int exit_num)
|
||||
} else {
|
||||
// No blocklinking.
|
||||
MOV(32, M(&mips_->pc), Imm32(destination));
|
||||
JMP(asm_.dispatcher, true);
|
||||
JMP(dispatcher, true);
|
||||
|
||||
// Normally, exits are 15 bytes (MOV + &pc + dest + JMP + dest) on 64 or 32 bit.
|
||||
// But just in case we somehow optimized, pad.
|
||||
@@ -745,8 +694,8 @@ void Jit::WriteExitDestInReg(X64Reg reg)
|
||||
// Need to set neg flag again.
|
||||
SUB(32, M(&mips_->downcount), Imm8(0));
|
||||
if (reg == EAX)
|
||||
J_CC(CC_NS, asm_.dispatcherInEAXNoCheck, true);
|
||||
JMP(asm_.dispatcher, true);
|
||||
J_CC(CC_NS, dispatcherInEAXNoCheck, true);
|
||||
JMP(dispatcher, true);
|
||||
|
||||
SetJumpTarget(tooLow);
|
||||
SetJumpTarget(tooHigh);
|
||||
@@ -763,15 +712,15 @@ void Jit::WriteExitDestInReg(X64Reg reg)
|
||||
}
|
||||
|
||||
SUB(32, M(&mips_->downcount), Imm8(0));
|
||||
JMP(asm_.dispatcherCheckCoreState, true);
|
||||
JMP(dispatcherCheckCoreState, true);
|
||||
}
|
||||
else if (reg == EAX)
|
||||
{
|
||||
J_CC(CC_NS, asm_.dispatcherInEAXNoCheck, true);
|
||||
JMP(asm_.dispatcher, true);
|
||||
J_CC(CC_NS, dispatcherInEAXNoCheck, true);
|
||||
JMP(dispatcher, true);
|
||||
}
|
||||
else
|
||||
JMP(asm_.dispatcher, true);
|
||||
JMP(dispatcher, true);
|
||||
}
|
||||
|
||||
void Jit::WriteSyscallExit()
|
||||
@@ -782,7 +731,7 @@ void Jit::WriteSyscallExit()
|
||||
ABI_CallFunction(&JitMemCheckCleanup);
|
||||
ApplyRoundingMode();
|
||||
}
|
||||
JMP(asm_.dispatcherCheckCoreState, true);
|
||||
JMP(dispatcherCheckCoreState, true);
|
||||
}
|
||||
|
||||
bool Jit::CheckJitBreakpoint(u32 addr, int downcountOffset)
|
||||
@@ -802,7 +751,7 @@ bool Jit::CheckJitBreakpoint(u32 addr, int downcountOffset)
|
||||
ApplyRoundingMode();
|
||||
// Just to fix the stack.
|
||||
LOAD_FLAGS;
|
||||
JMP(asm_.dispatcherCheckCoreState, true);
|
||||
JMP(dispatcherCheckCoreState, true);
|
||||
SetJumpTarget(skip);
|
||||
|
||||
ApplyRoundingMode();
|
||||
|
||||
+25
-7
@@ -20,7 +20,6 @@
|
||||
#include "Common/CommonTypes.h"
|
||||
#include "Common/Thunk.h"
|
||||
#include "Common/x64Emitter.h"
|
||||
#include "Core/MIPS/x86/Asm.h"
|
||||
|
||||
#if defined(ARM)
|
||||
#error DO NOT BUILD X86 JIT ON ARM
|
||||
@@ -140,7 +139,6 @@ public:
|
||||
void Comp_DoNothing(MIPSOpcode op);
|
||||
|
||||
int Replace_fabsf();
|
||||
int Replace_dl_write_matrix();
|
||||
|
||||
void ApplyPrefixST(u8 *vregs, u32 prefix, VectorSize sz);
|
||||
void ApplyPrefixD(const u8 *vregs, VectorSize sz);
|
||||
@@ -157,12 +155,11 @@ public:
|
||||
void GetVectorRegsPrefixD(u8 *regs, VectorSize sz, int vectorReg);
|
||||
void EatPrefix() { js.EatPrefix(); }
|
||||
|
||||
void RestoreRoundingMode(bool force = false, XEmitter *emitter = NULL);
|
||||
void ApplyRoundingMode(bool force = false, XEmitter *emitter = NULL);
|
||||
void UpdateRoundingMode(XEmitter *emitter = NULL);
|
||||
void RestoreRoundingMode(bool force = false);
|
||||
void ApplyRoundingMode(bool force = false);
|
||||
void UpdateRoundingMode();
|
||||
|
||||
JitBlockCache *GetBlockCache() { return &blocks; }
|
||||
AsmRoutineManager &Asm() { return asm_; }
|
||||
|
||||
void ClearCache();
|
||||
void InvalidateCache();
|
||||
@@ -172,7 +169,12 @@ public:
|
||||
}
|
||||
}
|
||||
|
||||
const u8 *GetDispatcher() const {
|
||||
return dispatcher;
|
||||
}
|
||||
|
||||
private:
|
||||
void GenerateFixedCode(JitOptions &jo);
|
||||
void GetStateAndFlushAll(RegCacheState &state);
|
||||
void RestoreState(const RegCacheState& state);
|
||||
void FlushAll();
|
||||
@@ -296,12 +298,28 @@ private:
|
||||
GPRRegCache gpr;
|
||||
FPURegCache fpr;
|
||||
|
||||
AsmRoutineManager asm_;
|
||||
ThunkManager thunks;
|
||||
JitSafeMemFuncs safeMemFuncs;
|
||||
|
||||
MIPSState *mips_;
|
||||
|
||||
|
||||
const u8 *enterDispatcher;
|
||||
|
||||
const u8 *outerLoop;
|
||||
const u8 *dispatcher;
|
||||
const u8 *dispatcherCheckCoreState;
|
||||
const u8 *dispatcherNoCheck;
|
||||
const u8 *dispatcherInEAXNoCheck;
|
||||
|
||||
const u8 *breakpointBailout;
|
||||
|
||||
const u8 *restoreRoundingMode;
|
||||
const u8 *applyRoundingMode;
|
||||
const u8 *updateRoundingMode;
|
||||
|
||||
const u8 *endOfPregeneratedCode;
|
||||
|
||||
friend class JitSafeMem;
|
||||
friend class JitSafeMemFuncs;
|
||||
};
|
||||
|
||||
@@ -23,7 +23,6 @@
|
||||
#include "Core/MIPS/MIPSTables.h"
|
||||
#include "Core/MIPS/MIPSAnalyst.h"
|
||||
#include "Core/MIPS/x86/Jit.h"
|
||||
#include "Core/MIPS/x86/Asm.h"
|
||||
#include "Core/MIPS/x86/RegCache.h"
|
||||
|
||||
using namespace Gen;
|
||||
|
||||
Reference in new issue
Block a user