preserve-emulation/ppsspp
1
0
Fork 0
mirror of https://github.com/hrydgard/ppsspp.git synced 2026-07-11 01:25:07 +02:00
Code Issues Packages Projects Releases Wiki Activity

Remove old rudimentary start at a MIPS->MIPS jit

Browse Source
This commit is contained in:
Henrik Rydgård
2026-02-11 22:50:04 +01:00
parent e1b638aaab
commit d5444a7f46
9 changed files with 2 additions and 605 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
-5
View File
@@ -1862,11 +1862,6 @@ list(APPEND CoreExtra
GPU/Software/SamplerX86.cpp
)
list(APPEND CoreExtra
Core/MIPS/MIPS/MipsJit.cpp
Core/MIPS/MIPS/MipsJit.h
)
list(APPEND CoreExtra
Core/MIPS/RiscV/RiscVAsm.cpp
Core/MIPS/RiscV/RiscVCompALU.cpp
Core/Core.vcxproj
-16
View File
@@ -847,14 +847,6 @@
<ClCompile Include="MIPS\MIPSTables.cpp" />
<ClCompile Include="MIPS\MIPSVFPUUtils.cpp" />
<ClCompile Include="MIPS\MIPSTracer.cpp" />
<ClCompile Include="MIPS\MIPS\MipsJit.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="MIPS\x86\Asm.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">true</ExcludedFromBuild>
@@ -1236,14 +1228,6 @@
<ClInclude Include="MIPS\MIPSTables.h" />
<ClInclude Include="MIPS\MIPSVFPUUtils.h" />
<ClInclude Include="MIPS\MIPSTracer.h" />
<ClInclude Include="MIPS\MIPS\MipsJit.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="MIPS\x86\JitSafeMem.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">true</ExcludedFromBuild>
Core/Core.vcxproj.filters
-9
View File
@@ -13,9 +13,6 @@
<Filter Include="MIPS\ARM">
<UniqueIdentifier>{8a5bebeb-575f-483d-8bd2-4b7eac163a7d}</UniqueIdentifier>
</Filter>
<Filter Include="MIPS\MIPS">
<UniqueIdentifier>{aaaaaaaa-575f-483d-8bd2-4b7eac163a7d}</UniqueIdentifier>
</Filter>
<Filter Include="MIPS\JitCommon">
<UniqueIdentifier>{37896407-c373-44a3-b6ec-b57bceb2c4a3}</UniqueIdentifier>
</Filter>
@@ -438,9 +435,6 @@
<ClCompile Include="MIPS\ARM\ArmJit.cpp">
<Filter>MIPS\ARM</Filter>
</ClCompile>
<ClCompile Include="MIPS\MIPS\MipsJit.cpp">
<Filter>MIPS\MIPS</Filter>
</ClCompile>
<ClCompile Include="MIPS\ARM\ArmRegCache.cpp">
<Filter>MIPS\ARM</Filter>
</ClCompile>
@@ -1722,9 +1716,6 @@
<ClInclude Include="MIPS\ARM\ArmJit.h">
<Filter>MIPS\ARM</Filter>
</ClInclude>
<ClInclude Include="MIPS\MIPS\MipsJit.h">
<Filter>MIPS\MIPS</Filter>
</ClInclude>
<ClInclude Include="MIPS\ARM\ArmRegCache.h">
<Filter>MIPS\ARM</Filter>
</ClInclude>
Core/MIPS/ARM64/Arm64Jit.cpp
-1
View File
@@ -240,7 +240,6 @@ void Arm64Jit::CompileDelaySlot(int flags) {
_MSR(FIELD_NZCV, FLAGTEMPREG); // Restore flags register
}
void Arm64Jit::Compile(u32 em_address) {
PROFILE_THIS_SCOPE("jitc");
if (GetSpaceLeft() < 0x10000 || blocks.IsFull()) {
Core/MIPS/JitCommon/JitCommon.cpp
-4
View File
@@ -47,8 +47,6 @@
#elif PPSSPP_ARCH(X86) || PPSSPP_ARCH(AMD64)
#include "../x86/Jit.h"
#include "../x86/X64IRJit.h"
#elif PPSSPP_ARCH(MIPS)
#include "../MIPS/MipsJit.h"
#elif PPSSPP_ARCH(RISCV64)
#include "../RiscV/RiscVJit.h"
#elif PPSSPP_ARCH(LOONGARCH64)
@@ -118,8 +116,6 @@ namespace MIPSComp {
if (useIR)
return new MIPSComp::X64IRJit(mipsState);
return new MIPSComp::Jit(mipsState);
#elif PPSSPP_ARCH(MIPS)
return new MIPSComp::MipsJit(mipsState);
#elif PPSSPP_ARCH(RISCV64)
return new MIPSComp::RiscVJit(mipsState);
#elif PPSSPP_ARCH(LOONGARCH64)
Core/MIPS/MIPS/MipsJit.cpp
-369
View File
@@ -1,369 +0,0 @@
// Copyright (c) 2012- 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 "ppsspp_config.h"
#if PPSSPP_ARCH(MIPS)
#include "Common/Profiler/Profiler.h"
#include "Common/Serialize/Serializer.h"
#include "Common/Serialize/SerializeFuncs.h"
#include "Core/Reporting.h"
#include "Core/Config.h"
#include "Core/Core.h"
#include "Core/CoreTiming.h"
#include "Core/Debugger/SymbolMap.h"
#include "Core/MemMap.h"
#include "Core/MIPS/MIPS.h"
#include "Core/MIPS/MIPSCodeUtils.h"
#include "Core/MIPS/MIPSInt.h"
#include "Core/MIPS/MIPSTables.h"
#include "Core/HLE/ReplaceTables.h"
#include "MipsJit.h"
#include "CPUDetect.h"
void DisassembleMIPS(const u8 *data, int size) {
}
namespace MIPSComp
{
MipsJit::MipsJit(MIPSState *mipsState) : blocks(mipsState, this), mips_(mipsState)
{
logBlocks = 0;
dontLogBlocks = 0;
blocks.Init();
AllocCodeSpace(1024 * 1024 * 16);
js.startDefaultPrefix = mips_->HasDefaultPrefix();
}
void MipsJit::DoState(PointerWrap &p)
{
auto s = p.Section("Jit", 1, 2);
if (!s)
return;
Do(p, js.startDefaultPrefix);
if (s >= 2) {
Do(p, js.hasSetRounding);
if (p.mode == PointerWrap::MODE_READ) {
js.lastSetRounding = 0;
}
} else {
js.hasSetRounding = 1;
}
}
void MipsJit::UpdateFCR31() {
}
void MipsJit::FlushAll()
{
//gpr.FlushAll();
//fpr.FlushAll();
FlushPrefixV();
}
void MipsJit::FlushPrefixV()
{
}
MIPSOpcode MipsJit::GetOriginalOp(MIPSOpcode op) {
JitBlockCache *bc = GetBlockCache();
int block_num = bc->GetBlockNumberFromEmuHackOp(op, true);
if (block_num >= 0) {
return bc->GetOriginalFirstOp(block_num);
} else {
return op;
}
}
void MipsJit::ClearCache()
{
blocks.Clear();
ClearCodeSpace(0);
//GenerateFixedCode();
}
void MipsJit::InvalidateCacheAt(u32 em_address, int length) {
if (blocks.RangeMayHaveEmuHacks(em_address, em_address + length)) {
blocks.InvalidateICache(em_address, length);
}
}
void MipsJit::EatInstruction(MIPSOpcode op) {
MIPSInfo info = MIPSGetInfo(op);
if (info & DELAYSLOT) {
ERROR_LOG_REPORT_ONCE(ateDelaySlot, JIT, "Ate a branch op.");
}
if (js.inDelaySlot) {
ERROR_LOG_REPORT_ONCE(ateInDelaySlot, JIT, "Ate an instruction inside a delay slot.");
}
js.numInstructions++;
js.compilerPC += 4;
js.downcountAmount += MIPSGetInstructionCycleEstimate(op);
}
void MipsJit::CompileDelaySlot(int flags)
{
//if (flags & DELAYSLOT_SAFE)
// Save flags here
js.inDelaySlot = true;
MIPSOpcode op = Memory::Read_Opcode_JIT(js.compilerPC + 4);
MIPSCompileOp(op, this);
js.inDelaySlot = false;
if (flags & DELAYSLOT_FLUSH)
FlushAll();
//if (flags & DELAYSLOT_SAFE)
// Restore flags here
}
void MipsJit::Compile(u32 em_address) {
PROFILE_THIS_SCOPE("jitc");
if (GetSpaceLeft() < 0x10000 || blocks.IsFull()) {
ClearCache();
}
int block_num = blocks.AllocateBlock(em_address);
JitBlock *b = blocks.GetBlock(block_num);
DoJit(em_address, b);
blocks.FinalizeBlock(block_num, jo.enableBlocklink);
bool cleanSlate = false;
if (js.hasSetRounding && !js.lastSetRounding) {
WARN_LOG(Log::JIT, "Detected rounding mode usage, rebuilding jit with checks");
// Won't loop, since hasSetRounding is only ever set to 1.
js.lastSetRounding = js.hasSetRounding;
cleanSlate = true;
}
if (cleanSlate) {
// Our assumptions are all wrong so it's clean-slate time.
ClearCache();
Compile(em_address);
}
}
void MipsJit::RunLoopUntil(u64 globalticks)
{
PROFILE_THIS_SCOPE("jit");
((void (*)())enterCode)();
}
const u8 *MipsJit::DoJit(u32 em_address, JitBlock *b)
{
js.cancel = false;
js.blockStart = js.compilerPC = mips_->pc;
js.lastContinuedPC = 0;
js.initialBlockSize = 0;
js.nextExit = 0;
js.downcountAmount = 0;
js.curBlock = b;
js.compiling = true;
js.inDelaySlot = false;
js.PrefixStart();
b->normalEntry = GetCodePtr();
js.numInstructions = 0;
while (js.compiling)
{
MIPSOpcode inst = Memory::Read_Opcode_JIT(js.compilerPC);
js.downcountAmount += MIPSGetInstructionCycleEstimate(inst);
MIPSCompileOp(inst, this);
js.compilerPC += 4;
js.numInstructions++;
// Safety check, in case we get a bunch of really large jit ops without a lot of branching.
if (GetSpaceLeft() < 0x800 || js.numInstructions >= JitBlockCache::MAX_BLOCK_INSTRUCTIONS)
{
FlushAll();
WriteExit(js.compilerPC, js.nextExit++);
js.compiling = false;
}
}
b->codeSize = GetCodePtr() - b->normalEntry;
// Don't forget to zap the newly written instructions in the instruction cache!
FlushIcache();
if (js.lastContinuedPC == 0)
b->originalSize = js.numInstructions;
else
{
// We continued at least once. Add the last proxy and set the originalSize correctly.
blocks.ProxyBlock(js.blockStart, js.lastContinuedPC, (js.compilerPC - js.lastContinuedPC) / sizeof(u32), GetCodePtr());
b->originalSize = js.initialBlockSize;
}
return b->normalEntry;
}
void MipsJit::AddContinuedBlock(u32 dest)
{
// The first block is the root block. When we continue, we create proxy blocks after that.
if (js.lastContinuedPC == 0)
js.initialBlockSize = js.numInstructions;
else
blocks.ProxyBlock(js.blockStart, js.lastContinuedPC, (js.compilerPC - js.lastContinuedPC) / sizeof(u32), GetCodePtr());
js.lastContinuedPC = dest;
}
bool MipsJit::DescribeCodePtr(const u8 *ptr, std::string &name)
{
// TODO: Not used by anything yet.
return false;
}
void MipsJit::Comp_RunBlock(MIPSOpcode op)
{
// This shouldn't be necessary, the dispatcher should catch us before we get here.
ERROR_LOG(Log::JIT, "Comp_RunBlock should never be reached!");
}
void MipsJit::LinkBlock(u8 *exitPoint, const u8 *checkedEntry) {
// TODO
}
void MipsJit::UnlinkBlock(u8 *checkedEntry, u32 originalAddress) {
// TODO
}
bool MipsJit::ReplaceJalTo(u32 dest) {
const ReplacementTableEntry *entry = nullptr;
u32 funcSize = 0;
if (!CanReplaceJalTo(dest, &entry, &funcSize)) {
return false;
}
return false;
}
void MipsJit::Comp_ReplacementFunc(MIPSOpcode op)
{
}
void MipsJit::Comp_Generic(MIPSOpcode op)
{
FlushAll();
MIPSInterpretFunc func = MIPSGetInterpretFunc(op);
if (func)
{
//SaveDowncount();
RestoreRoundingMode();
// Move Imm32(js.compilerPC) in to M(&mips_->pc)
QuickCallFunction(V1, (void *)func);
ApplyRoundingMode();
//RestoreDowncount();
}
const MIPSInfo info = MIPSGetInfo(op);
if ((info & IS_VFPU) != 0 && (info & VFPU_NO_PREFIX) == 0)
{
// If it does eat them, it'll happen in MIPSCompileOp().
if ((info & OUT_EAT_PREFIX) == 0)
js.PrefixUnknown();
}
}
void MipsJit::MovFromPC(MIPSReg r) {
}
void MipsJit::MovToPC(MIPSReg r) {
}
void MipsJit::SaveDowncount() {
}
void MipsJit::RestoreDowncount() {
}
void MipsJit::WriteDownCount(int offset) {
}
void MipsJit::WriteDownCountR(MIPSReg reg) {
}
void MipsJit::RestoreRoundingMode(bool force) {
}
void MipsJit::ApplyRoundingMode(bool force) {
}
void MipsJit::UpdateRoundingMode() {
}
void MipsJit::WriteExit(u32 destination, int exit_num)
{
//WriteDownCount();
JitBlock *b = js.curBlock;
b->exitAddress[exit_num] = destination;
b->exitPtrs[exit_num] = GetWritableCodePtr();
// Link opportunity!
int block = blocks.GetBlockNumberFromStartAddress(destination);
if (block >= 0 && jo.enableBlocklink) {
// It exists! Joy of joy!
B(blocks.GetBlock(block)->checkedEntry);
b->linkStatus[exit_num] = true;
} else {
//gpr.SetRegImm(V0, destination);
//B((const void *)dispatcherPCInV0);
}
}
void MipsJit::WriteExitDestInR(MIPSReg Reg)
{
MovToPC(Reg);
//WriteDownCount();
// TODO: shouldn't need an indirect branch here...
B((const void *)dispatcher);
}
void MipsJit::WriteSyscallExit()
{
//WriteDownCount();
B((const void *)dispatcherCheckCoreState);
}
#define _RS ((op>>21) & 0x1F)
#define _RT ((op>>16) & 0x1F)
#define _RD ((op>>11) & 0x1F)
#define _FS ((op>>11) & 0x1F)
#define _FT ((op>>16) & 0x1F)
#define _FD ((op>>6) & 0x1F)
#define _POS ((op>>6) & 0x1F)
#define _SIZE ((op>>11) & 0x1F)
//memory regions:
//
// 08-0A
// 48-4A
// 04-05
// 44-45
// mov eax, addrreg
// shr eax, 28
// mov eax, [table+eax]
// mov dreg, [eax+offreg]
}
#endif // PPSSPP_ARCH(MIPS)
Core/MIPS/MIPS/MipsJit.h
-199
View File
@@ -1,199 +0,0 @@
// Copyright (c) 2012- 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/.
#pragma once
#include "Common/MipsEmitter.h"
using namespace MIPSGen;
#include "Core/MIPS/JitCommon/JitCommon.h"
#include "Core/MIPS/JitCommon/JitState.h"
#include "Core/MIPS/JitCommon/JitBlockCache.h"
#include "../MIPSVFPUUtils.h"
#ifndef offsetof
#include "stddef.h"
#endif
namespace MIPSComp
{
class MipsJit : public MIPSGen::MIPSCodeBlock, public JitInterface, public MIPSFrontendInterface
{
public:
MipsJit(MIPSState *mipsState);
void DoState(PointerWrap &p) override;
// Compiled ops should ignore delay slots
// the compiler will take care of them by itself
// OR NOT
void Comp_Generic(MIPSOpcode op) override;
void RunLoopUntil(u64 globalticks) override;
void Compile(u32 em_address) override; // Compiles a block at current MIPS PC
const u8 *DoJit(u32 em_address, JitBlock *b);
const u8 *GetCrashHandler() const override { return nullptr; }
bool CodeInRange(const u8 *ptr) const override { return IsInSpace(ptr); }
bool DescribeCodePtr(const u8 *ptr, std::string &name);
void CompileDelaySlot(int flags);
void EatInstruction(MIPSOpcode op);
void AddContinuedBlock(u32 dest);
void Comp_RunBlock(MIPSOpcode op) override;
void Comp_ReplacementFunc(MIPSOpcode op) override;
// Ops
void Comp_ITypeMem(MIPSOpcode op) override {}
void Comp_StoreSync(MIPSOpcode op) override {}
void Comp_Cache(MIPSOpcode op) override {}
void Comp_RelBranch(MIPSOpcode op) override {}
void Comp_RelBranchRI(MIPSOpcode op) override {}
void Comp_FPUBranch(MIPSOpcode op) override {}
void Comp_FPULS(MIPSOpcode op) override {}
void Comp_FPUComp(MIPSOpcode op) override {}
void Comp_Jump(MIPSOpcode op) override {}
void Comp_JumpReg(MIPSOpcode op) override {}
void Comp_Syscall(MIPSOpcode op) override {}
void Comp_Break(MIPSOpcode op) override {}
void Comp_IType(MIPSOpcode op) override {}
void Comp_RType2(MIPSOpcode op) override {}
void Comp_RType3(MIPSOpcode op) override {}
void Comp_ShiftType(MIPSOpcode op) override {}
void Comp_Allegrex(MIPSOpcode op) override {}
void Comp_Allegrex2(MIPSOpcode op) override {}
void Comp_VBranch(MIPSOpcode op) override {}
void Comp_MulDivType(MIPSOpcode op) override {}
void Comp_Special3(MIPSOpcode op) override {}
void Comp_FPU3op(MIPSOpcode op) override {}
void Comp_FPU2op(MIPSOpcode op) override {}
void Comp_mxc1(MIPSOpcode op) override {}
void Comp_DoNothing(MIPSOpcode op) override {}
void Comp_SV(MIPSOpcode op) override {}
void Comp_SVQ(MIPSOpcode op) override {}
void Comp_VPFX(MIPSOpcode op) override {}
void Comp_VVectorInit(MIPSOpcode op) override {}
void Comp_VMatrixInit(MIPSOpcode op) override {}
void Comp_VDot(MIPSOpcode op) override {}
void Comp_VecDo3(MIPSOpcode op) override {}
void Comp_VV2Op(MIPSOpcode op) override {}
void Comp_Mftv(MIPSOpcode op) override {}
void Comp_Vmfvc(MIPSOpcode op) override {}
void Comp_Vmtvc(MIPSOpcode op) override {}
void Comp_Vmmov(MIPSOpcode op) override {}
void Comp_VScl(MIPSOpcode op) override {}
void Comp_Vmmul(MIPSOpcode op) override {}
void Comp_Vmscl(MIPSOpcode op) override {}
void Comp_Vtfm(MIPSOpcode op) override {}
void Comp_VHdp(MIPSOpcode op) override {}
void Comp_VCrs(MIPSOpcode op) override {}
void Comp_VDet(MIPSOpcode op) override {}
void Comp_Vi2x(MIPSOpcode op) override {}
void Comp_Vx2i(MIPSOpcode op) override {}
void Comp_Vf2i(MIPSOpcode op) override {}
void Comp_Vi2f(MIPSOpcode op) override {}
void Comp_Vh2f(MIPSOpcode op) override {}
void Comp_Vcst(MIPSOpcode op) override {}
void Comp_Vhoriz(MIPSOpcode op) override {}
void Comp_VRot(MIPSOpcode op) override {}
void Comp_VIdt(MIPSOpcode op) override {}
void Comp_Vcmp(MIPSOpcode op) override {}
void Comp_Vcmov(MIPSOpcode op) override {}
void Comp_Viim(MIPSOpcode op) override {}
void Comp_Vfim(MIPSOpcode op) override {}
void Comp_VCrossQuat(MIPSOpcode op) override {}
void Comp_Vsgn(MIPSOpcode op) override {}
void Comp_Vocp(MIPSOpcode op) override {}
void Comp_ColorConv(MIPSOpcode op) override {}
int Replace_fabsf() override { return 0; }
void Comp_Vbfy(MIPSOpcode op) {}
JitBlockCache *GetBlockCache() override { return &blocks; }
JitBlockCacheDebugInterface *GetBlockCacheDebugInterface() override { return &blocks; }
MIPSOpcode GetOriginalOp(MIPSOpcode op) override;
std::vector<u32> SaveAndClearEmuHackOps() override { return blocks.SaveAndClearEmuHackOps(); }
void RestoreSavedEmuHackOps(std::vector<u32> saved) override { blocks.RestoreSavedEmuHackOps(saved); }
void ClearCache() override;
void InvalidateCacheAt(u32 em_address, int length = 4) override;
void UpdateFCR31() override;
const u8 *GetDispatcher() const override {
return dispatcher;
}
void LinkBlock(u8 *exitPoint, const u8 *checkedEntry) override;
void UnlinkBlock(u8 *checkedEntry, u32 originalAddress) override;
void EatPrefix() override { js.EatPrefix(); }
private:
void GenerateFixedCode();
void FlushAll();
void FlushPrefixV();
void WriteDownCount(int offset = 0);
void WriteDownCountR(MIPSReg reg);
void RestoreRoundingMode(bool force = false);
void ApplyRoundingMode(bool force = false);
void UpdateRoundingMode();
void MovFromPC(MIPSReg r);
void MovToPC(MIPSReg r);
bool ReplaceJalTo(u32 dest);
void SaveDowncount();
void RestoreDowncount();
void WriteExit(u32 destination, int exit_num);
void WriteExitDestInR(MIPSReg Reg);
void WriteSyscallExit();
JitBlockCache blocks;
JitOptions jo;
JitState js;
MIPSState *mips_;
int dontLogBlocks;
int logBlocks;
public:
// Code pointers
const u8 *enterCode;
const u8 *outerLoop;
const u8 *outerLoopPCInR0;
const u8 *dispatcherCheckCoreState;
const u8 *dispatcherPCInR0;
const u8 *dispatcher;
const u8 *dispatcherNoCheck;
};
} // namespace MIPSComp
Core/MIPS/x86/Jit.cpp
+1 -1
View File
@@ -359,7 +359,7 @@ MIPSOpcode Jit::GetOffsetInstruction(int offset) {
return Memory::Read_Instruction(GetCompilerPC() + 4 * offset);
}
const u8 *Jit::DoJit(u32 em_address, JitBlock *b) {
void Jit::DoJit(u32 em_address, JitBlock *b) {
js.cancel = false;
js.blockStart = em_address;
js.compilerPC = em_address;
Core/MIPS/x86/Jit.h
+1 -1
View File
@@ -58,7 +58,7 @@ public:
void RunLoopUntil(u64 globalticks) override;
void Compile(u32 em_address) override; // Compiles a block at current MIPS PC
const u8 *DoJit(u32 em_address, JitBlock *b);
void DoJit(u32 em_address, JitBlock *b);
const u8 *GetCrashHandler() const override { return crashHandler; }
bool CodeInRange(const u8 *ptr) const override { return IsInSpace(ptr); }