izzy/dolphin
0
0
Fork 0
mirror of https://github.com/izzy2lost/dolphin.git synced 2026-06-19 01:16:48 -07:00
Code Issues Packages Projects Releases Wiki Activity

Roll back R3801. Dolphin works again. Seriously, if you're not even testing huge freaking changes like this...

Browse Source 
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@3807 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
hrydgard
2009-07-15 20:15:34 +00:00
parent 4533cc39b3
commit 3ebf5a5f1f
40 changed files with 560 additions and 1016 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/Core/Common/Src/DebugInterface.h
+1 -1
View File
@@ -11,7 +11,7 @@ protected:
public:
virtual void disasm(unsigned int /*address*/, char *dest, int /*max_size*/) {strcpy(dest, "NODEBUGGER");}
virtual void getRawMemoryString(int memory, unsigned int /*address*/, char *dest, int /*max_size*/) {strcpy(dest, "NODEBUGGER");}
virtual void getRawMemoryString(int /*memory*/, unsigned int /*address*/, char *dest, int /*max_size*/) {strcpy(dest, "NODEBUGGER");}
virtual int getInstructionSize(int /*instruction*/) {return 1;}
virtual bool isAlive() {return true;}
virtual bool isBreakpoint(unsigned int /*address*/) {return false;}
Source/Core/Core/Core.vcproj
+4 -28
View File
@@ -943,14 +943,6 @@
<Filter
Name="PowerPC"
>
<File
RelativePath=".\Src\PowerPC\CoreGeneralize.cpp"
>
</File>
<File
RelativePath=".\Src\PowerPC\CoreGeneralize.h"
>
</File>
<File
RelativePath=".\Src\PowerPC\Gekko.h"
>
@@ -1166,26 +1158,6 @@
/>
</FileConfiguration>
</File>
<File
RelativePath=".\Src\PowerPC\Jit64\Jit_Util.cpp"
>
<FileConfiguration
Name="Release_JITIL|Win32"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
<FileConfiguration
Name="Release_JITIL|x64"
ExcludedFromBuild="true"
>
<Tool
Name="VCCLCompilerTool"
/>
</FileConfiguration>
</File>
<File
RelativePath=".\Src\PowerPC\Jit64\Jit_Integer.cpp"
>
@@ -2010,6 +1982,10 @@
RelativePath=".\Src\PowerPC\JitCommon\Jit_Tables.h"
>
</File>
<File
RelativePath=".\Src\PowerPC\JitCommon\Jit_Util.cpp"
>
</File>
<File
RelativePath=".\Src\PowerPC\JitCommon\JitBackpatch.cpp"
>
Source/Core/Core/Src/Debugger/PPCDebugInterface.cpp
+2 -2
View File
@@ -111,13 +111,13 @@ bool PPCDebugInterface::isBreakpoint(unsigned int address)
void PPCDebugInterface::setBreakpoint(unsigned int address)
{
if (PowerPC::breakpoints.Add(address))
jit->NotifyBreakpoint(address, true);
jit.NotifyBreakpoint(address, true);
}
void PPCDebugInterface::clearBreakpoint(unsigned int address)
{
if (PowerPC::breakpoints.Remove(address))
jit->NotifyBreakpoint(address, false);
jit.NotifyBreakpoint(address, false);
}
void PPCDebugInterface::clearAllBreakpoints() {}
Source/Core/Core/Src/HW/Memmap.cpp
+1 -1
View File
@@ -538,7 +538,7 @@ u32 Read_Instruction(const u32 em_address)
{
UGeckoInstruction inst = ReadUnchecked_U32(em_address);
if (inst.OPCD == 0)
inst.hex = jit->GetBlockCache()->GetOriginalCode(em_address);
inst.hex = jit.GetBlockCache()->GetOriginalCode(em_address);
if (inst.OPCD == 1)
return HLE::GetOrigInstruction(em_address);
else
Source/Core/Core/Src/MemTools.cpp
+4 -4
View File
@@ -65,7 +65,7 @@ LONG NTAPI Handler(PEXCEPTION_POINTERS pPtrs)
PVOID codeAddr = pPtrs->ExceptionRecord->ExceptionAddress;
unsigned char *codePtr = (unsigned char*)codeAddr;
if (!jit->IsInCodeSpace(codePtr)) {
if (!jit.IsInCodeSpace(codePtr)) {
// Let's not prevent debugging.
return (DWORD)EXCEPTION_CONTINUE_SEARCH;
}
@@ -95,7 +95,7 @@ LONG NTAPI Handler(PEXCEPTION_POINTERS pPtrs)
//We could emulate the memory accesses here, but then they would still be around to take up
//execution resources. Instead, we backpatch into a generic memory call and retry.
const u8 *new_rip = jit->BackPatch(codePtr, accessType, emAddress, ctx);
const u8 *new_rip = jit.BackPatch(codePtr, accessType, emAddress, ctx);
// Rip/Eip needs to be updated.
if (new_rip)
@@ -190,7 +190,7 @@ void sigsegv_handler(int signal, siginfo_t *info, void *raw_context)
#else
u8 *fault_instruction_ptr = (u8 *)CREG_EIP(ctx);
#endif
if (!jit->IsInCodeSpace(fault_instruction_ptr)) {
if (!jit.IsInCodeSpace(fault_instruction_ptr)) {
// Let's not prevent debugging.
return;
}
@@ -217,7 +217,7 @@ void sigsegv_handler(int signal, siginfo_t *info, void *raw_context)
fake_ctx.Eax = CREG_EAX(ctx);
fake_ctx.Eip = CREG_EIP(ctx);
#endif
const u8 *new_rip = jit->BackPatch(fault_instruction_ptr, access_type, em_address, &fake_ctx);
const u8 *new_rip = jit.BackPatch(fault_instruction_ptr, access_type, em_address, &fake_ctx);
if (new_rip) {
#ifdef _M_X64
CREG_RAX(ctx) = fake_ctx.Rax;
Source/Core/Core/Src/PowerPC/CoreGeneralize.cpp
-2
View File
@@ -1,2 +0,0 @@
#include "CoreGeneralize.h"
Source/Core/Core/Src/PowerPC/CoreGeneralize.h
-273
View File
@@ -1,273 +0,0 @@
// Copyright (C) 2003-2009 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.
// 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/
#ifndef _CORE_GENERALIZE_H
#define _CORE_GENERALIZE_H
#include "PPCAnalyst.h"
#include "JitCommon/JitCache.h"
#include "Jit64/JitRegCache.h" // These two Jit Includes NEED to be dropped
#include "x64Emitter.h"
#include "x64Analyzer.h"
#include "Jit64IL/IR.h"
#ifndef _WIN32
// A bit of a hack to get things building under linux. We manually fill in this structure as needed
// from the real context.
struct CONTEXT
{
#ifdef _M_X64
u64 Rip;
u64 Rax;
#else
u32 Eip;
u32 Eax;
#endif
};
#endif
class TrampolineCache : public Gen::XCodeBlock
{
public:
void Init();
void Shutdown();
const u8 *GetReadTrampoline(const InstructionInfo &info);
const u8 *GetWriteTrampoline(const InstructionInfo &info);
};
class cCore : public Gen::XCodeBlock
{
private:
struct JitState
{
u32 compilerPC;
u32 next_compilerPC;
u32 blockStart;
bool cancel;
UGeckoInstruction next_inst; // for easy peephole opt.
int blockSize;
int instructionNumber;
int downcountAmount;
int block_flags;
bool isLastInstruction;
bool blockSetsQuantizers;
int fifoBytesThisBlock;
PPCAnalyst::BlockStats st;
PPCAnalyst::BlockRegStats gpa;
PPCAnalyst::BlockRegStats fpa;
PPCAnalyst::CodeOp *op;
u8* rewriteStart;
JitBlock *curBlock;
};
struct JitOptions
{
bool optimizeStack;
bool assumeFPLoadFromMem;
bool enableBlocklink;
bool fpAccurateFlags;
bool enableFastMem;
bool optimizeGatherPipe;
bool fastInterrupts;
bool accurateSinglePrecision;
};
JitBlockCache blocks;
TrampolineCache trampolines;
#if !(defined JITTEST && JITTEST)
GPRRegCache gpr;
FPURegCache fpr;
#endif
// The default code buffer. We keep it around to not have to alloc/dealloc a
// large chunk of memory for each recompiled block.
PPCAnalyst::CodeBuffer code_buffer;
public:
cCore() : code_buffer(32000){}
~cCore(){}
JitState js;
JitOptions jo;
IREmitter::IRBuilder ibuild;
// Initialization, etc
virtual void Init() = 0;
virtual void Shutdown() = 0;
// Jit!
virtual void Jit(u32 em_address) = 0;
virtual const u8* DoJit(u32 em_address, PPCAnalyst::CodeBuffer *code_buffer, JitBlock *b) = 0;
virtual JitBlockCache *GetBlockCache() { return &blocks; }
virtual void NotifyBreakpoint(u32 em_address, bool set) = 0;
virtual void ClearCache() = 0;
// Run!
virtual void Run() = 0;
virtual void SingleStep() = 0;
const u8 *BackPatch(u8 *codePtr, int accessType, u32 em_address, CONTEXT *ctx);
#define JIT_OPCODE 0
// Utilities for use by opcodes
virtual void WriteExit(u32 destination, int exit_num) = 0;
virtual void WriteExitDestInEAX(int exit_num) = 0;
virtual void WriteExceptionExit(u32 exception) = 0;
virtual void WriteRfiExitDestInEAX() = 0;
virtual void WriteCallInterpreter(UGeckoInstruction _inst) = 0;
virtual void Cleanup() = 0;
virtual void UnsafeLoadRegToReg(Gen::X64Reg reg_addr, Gen::X64Reg reg_value, int accessSize, s32 offset = 0, bool signExtend = false) = 0;
virtual void UnsafeWriteRegToReg(Gen::X64Reg reg_value, Gen::X64Reg reg_addr, int accessSize, s32 offset = 0) = 0;
virtual void SafeLoadRegToEAX(Gen::X64Reg reg, int accessSize, s32 offset, bool signExtend = false) = 0;
virtual void SafeWriteRegToReg(Gen::X64Reg reg_value, Gen::X64Reg reg_addr, int accessSize, s32 offset) = 0;
virtual void WriteToConstRamAddress(int accessSize, const Gen::OpArg& arg, u32 address) = 0;
virtual void WriteFloatToConstRamAddress(const Gen::X64Reg& xmm_reg, u32 address) = 0;
virtual void GenerateCarry(Gen::X64Reg temp_reg) = 0;
virtual void ForceSinglePrecisionS(Gen::X64Reg xmm) = 0;
virtual void ForceSinglePrecisionP(Gen::X64Reg xmm) = 0;
virtual void JitClearCA() = 0;
virtual void JitSetCA() = 0;
virtual void tri_op(int d, int a, int b, bool reversible, void (XEmitter::*op)(Gen::X64Reg, Gen::OpArg)) = 0;
typedef u32 (*Operation)(u32 a, u32 b);
virtual void regimmop(int d, int a, bool binary, u32 value, Operation doop, void (XEmitter::*op)(int, const Gen::OpArg&, const Gen::OpArg&), bool Rc = false, bool carry = false) = 0;
virtual void fp_tri_op(int d, int a, int b, bool reversible, bool dupe, void (XEmitter::*op)(Gen::X64Reg, Gen::OpArg)) = 0;
void WriteCode();
// OPCODES
virtual void unknown_instruction(UGeckoInstruction _inst) = 0;
virtual void Default(UGeckoInstruction _inst) = 0;
virtual void DoNothing(UGeckoInstruction _inst) = 0;
virtual void HLEFunction(UGeckoInstruction _inst) = 0;
void DynaRunTable4(UGeckoInstruction _inst);
void DynaRunTable19(UGeckoInstruction _inst);
void DynaRunTable31(UGeckoInstruction _inst);
void DynaRunTable59(UGeckoInstruction _inst);
void DynaRunTable63(UGeckoInstruction _inst);
virtual void addx(UGeckoInstruction inst) = 0;
virtual void orx(UGeckoInstruction inst) = 0;
virtual void xorx(UGeckoInstruction inst) = 0;
virtual void andx(UGeckoInstruction inst) = 0;
virtual void mulli(UGeckoInstruction inst) = 0;
virtual void mulhwux(UGeckoInstruction inst) = 0;
virtual void mullwx(UGeckoInstruction inst) = 0;
virtual void divwux(UGeckoInstruction inst) = 0;
virtual void srawix(UGeckoInstruction inst) = 0;
virtual void srawx(UGeckoInstruction inst) = 0;
virtual void addex(UGeckoInstruction inst) = 0;
virtual void addzex(UGeckoInstruction inst) = 0;
virtual void extsbx(UGeckoInstruction inst) = 0;
virtual void extshx(UGeckoInstruction inst) = 0;
virtual void sc(UGeckoInstruction _inst) = 0;
virtual void rfi(UGeckoInstruction _inst) = 0;
virtual void bx(UGeckoInstruction inst) = 0;
virtual void bclrx(UGeckoInstruction _inst) = 0;
virtual void bcctrx(UGeckoInstruction _inst) = 0;
virtual void bcx(UGeckoInstruction inst) = 0;
virtual void mtspr(UGeckoInstruction inst) = 0;
virtual void mfspr(UGeckoInstruction inst) = 0;
virtual void mtmsr(UGeckoInstruction inst) = 0;
virtual void mfmsr(UGeckoInstruction inst) = 0;
virtual void mftb(UGeckoInstruction inst) = 0;
virtual void mtcrf(UGeckoInstruction inst) = 0;
virtual void mfcr(UGeckoInstruction inst) = 0;
virtual void reg_imm(UGeckoInstruction inst) = 0;
virtual void ps_sel(UGeckoInstruction inst) = 0;
virtual void ps_mr(UGeckoInstruction inst) = 0;
virtual void ps_sign(UGeckoInstruction inst) = 0; //aggregate
virtual void ps_arith(UGeckoInstruction inst) = 0; //aggregate
virtual void ps_mergeXX(UGeckoInstruction inst) = 0;
virtual void ps_maddXX(UGeckoInstruction inst) = 0;
virtual void ps_rsqrte(UGeckoInstruction inst) = 0;
virtual void ps_sum(UGeckoInstruction inst) = 0;
virtual void ps_muls(UGeckoInstruction inst) = 0;
virtual void fp_arith_s(UGeckoInstruction inst) = 0;
virtual void fcmpx(UGeckoInstruction inst) = 0;
virtual void fmrx(UGeckoInstruction inst) = 0;
virtual void cmpXX(UGeckoInstruction inst) = 0;
virtual void cntlzwx(UGeckoInstruction inst) = 0;
virtual void lfs(UGeckoInstruction inst) = 0;
virtual void lfd(UGeckoInstruction inst) = 0;
virtual void stfd(UGeckoInstruction inst) = 0;
virtual void stfs(UGeckoInstruction inst) = 0;
virtual void stfsx(UGeckoInstruction inst) = 0;
virtual void psq_l(UGeckoInstruction inst) = 0;
virtual void psq_st(UGeckoInstruction inst) = 0;
virtual void fmaddXX(UGeckoInstruction inst) = 0;
virtual void stX(UGeckoInstruction inst) = 0; //stw sth stb
virtual void lXz(UGeckoInstruction inst) = 0;
virtual void lha(UGeckoInstruction inst) = 0;
virtual void rlwinmx(UGeckoInstruction inst) = 0;
virtual void rlwimix(UGeckoInstruction inst) = 0;
virtual void rlwnmx(UGeckoInstruction inst) = 0;
virtual void negx(UGeckoInstruction inst) = 0;
virtual void slwx(UGeckoInstruction inst) = 0;
virtual void srwx(UGeckoInstruction inst) = 0;
virtual void dcbz(UGeckoInstruction inst) = 0;
virtual void lfsx(UGeckoInstruction inst) = 0;
virtual void subfic(UGeckoInstruction inst) = 0;
virtual void subfcx(UGeckoInstruction inst) = 0;
virtual void subfx(UGeckoInstruction inst) = 0;
virtual void subfex(UGeckoInstruction inst) = 0;
virtual void lXzx(UGeckoInstruction inst) = 0;
//virtual void lbzx(UGeckoInstruction inst) = 0;
//virtual void lwzx(UGeckoInstruction inst) = 0;
virtual void lhax(UGeckoInstruction inst) = 0;
//virtual void lwzux(UGeckoInstruction inst) = 0;
virtual void stXx(UGeckoInstruction inst) = 0;
virtual void lmw(UGeckoInstruction inst) = 0;
virtual void stmw(UGeckoInstruction inst) = 0;
};
extern cCore *jit; // jit to retain backwards compatibility
#endif
Source/Core/Core/Src/PowerPC/Interpreter/Interpreter_FloatingPoint.cpp
-7
View File
@@ -36,13 +36,6 @@
#include "Interpreter.h"
#include "MathUtil.h"
// F-ZERO IS BEING A ROYAL PAIN
// POSSIBLE APPROACHES:
// * Full SW FPU. Urgh.
// * Partial SW FPU, emulate just as much as necessary for f-zero. Feasible, I guess.
// * HLE hacking. Figure out what all the evil functions really do and fake them.
// This worked well for Monkey Ball, not so much for F-Zero.
using namespace MathUtil;
namespace Interpreter
Source/Core/Core/Src/PowerPC/Jit64/Jit.cpp
+3 -1
View File
@@ -179,6 +179,8 @@ static void CheckForNans()
}
}
Jit64 jit;
int CODE_SIZE = 1024*1024*16;
namespace CPUCompare
@@ -188,7 +190,7 @@ namespace CPUCompare
void Jit(u32 em_address)
{
jit->Jit(em_address);
jit.Jit(em_address);
}
void Jit64::Init()
Source/Core/Core/Src/PowerPC/Jit64/Jit.h
+31 -4
View File
@@ -50,7 +50,6 @@
#include "JitRegCache.h"
#include "x64Emitter.h"
#include "x64Analyzer.h"
#include "../CoreGeneralize.h"
#ifdef _WIN32
#include <windows.h>
@@ -64,6 +63,23 @@
void Jit(u32 em_address);
#ifndef _WIN32
// A bit of a hack to get things building under linux. We manually fill in this structure as needed
// from the real context.
struct CONTEXT
{
#ifdef _M_X64
u64 Rip;
u64 Rax;
#else
u32 Eip;
u32 Eax;
#endif
};
#endif
// Use these to control the instruction selection
// #define INSTRUCTION_START Default(inst); return;
// #define INSTRUCTION_START PPCTables::CountInstruction(inst);
@@ -71,7 +87,18 @@ void Jit(u32 em_address);
///////////////////////////////////
class Jit64 : public cCore
class TrampolineCache : public Gen::XCodeBlock
{
public:
void Init();
void Shutdown();
const u8 *GetReadTrampoline(const InstructionInfo &info);
const u8 *GetWriteTrampoline(const InstructionInfo &info);
};
class Jit64 : public Gen::XCodeBlock
{
private:
struct JitState
@@ -203,7 +230,6 @@ public:
void srawix(UGeckoInstruction inst);
void srawx(UGeckoInstruction inst);
void addex(UGeckoInstruction inst);
void addzex(UGeckoInstruction inst);
void extsbx(UGeckoInstruction inst);
void extshx(UGeckoInstruction inst);
@@ -276,7 +302,6 @@ public:
void lhax(UGeckoInstruction inst);
void lwzux(UGeckoInstruction inst);
void lXzx(UGeckoInstruction inst);
void stXx(UGeckoInstruction inst);
@@ -284,5 +309,7 @@ public:
void stmw(UGeckoInstruction inst);
};
extern Jit64 jit;
#endif // _JIT_H
#endif // JITTEST
Source/Core/Core/Src/PowerPC/Jit64/JitAsm.cpp
+1 -1
View File
@@ -70,7 +70,7 @@ void AsmRoutineManager::Generate()
#ifndef _M_IX86
// Two statically allocated registers.
MOV(64, R(RBX), Imm64((u64)Memory::base));
MOV(64, R(R15), Imm64((u64)jit->GetBlockCache()->GetCodePointers())); //It's below 2GB so 32 bits are good enough
MOV(64, R(R15), Imm64((u64)jit.GetBlockCache()->GetCodePointers())); //It's below 2GB so 32 bits are good enough
#endif
const u8 *outerLoop = GetCodePtr();
Source/Core/Core/Src/PowerPC/Jit64/Jit_Integer.cpp
+1 -5
View File
@@ -246,11 +246,7 @@
gpr.UnlockAll();
}
void Jit64::addzex(UGeckoInstruction inst)
{
Default(inst);
return;
}
void Jit64::orx(UGeckoInstruction inst)
{
if(Core::g_CoreStartupParameter.bJITOff || Core::g_CoreStartupParameter.bJITIntegerOff)
Source/Core/Core/Src/PowerPC/Jit64/Jit_LoadStore.cpp
+45 -73
View File
@@ -35,76 +35,31 @@
#include "JitAsm.h"
#include "JitRegCache.h"
void Jit64::lXzx(UGeckoInstruction inst)
void Jit64::lbzx(UGeckoInstruction inst)
{
if(Core::g_CoreStartupParameter.bJITOff || Core::g_CoreStartupParameter.bJITLoadStoreOff
|| Core::g_CoreStartupParameter.bJITLoadStorelbzxOff)
{Default(inst); return;} // turn off from debugger
INSTRUCTION_START;
int a = inst.RA, b = inst.RB, d = inst.RD;
switch(inst.OPCD)
{
case 23: //lwzx
gpr.Lock(a, b, d);
gpr.FlushLockX(ABI_PARAM1);
if (b == d || a == d)
gpr.LoadToX64(d, true, true);
else
gpr.LoadToX64(d, false, true);
MOV(32, R(ABI_PARAM1), gpr.R(b));
if (a)
ADD(32, R(ABI_PARAM1), gpr.R(a));
#if 1
SafeLoadRegToEAX(ABI_PARAM1, 32, 0);
MOV(32, gpr.R(d), R(EAX));
#else
UnsafeLoadRegToReg(ABI_PARAM1, gpr.RX(d), 32, 0, false);
#endif
gpr.UnlockAll();
gpr.UnlockAllX();
break;
case 55: //lwzux
if (!a || a == d || a == b)
{
Default(inst);
return;
}
gpr.Lock(a, b, d);
gpr.LoadToX64(d, b == d, true);
gpr.LoadToX64(a, true, true);
ADD(32, gpr.R(a), gpr.R(b));
MOV(32, R(EAX), gpr.R(a));
SafeLoadRegToEAX(EAX, 32, 0, false);
MOV(32, gpr.R(d), R(EAX));
gpr.UnlockAll();
break;
case 87: //lbzx
gpr.Lock(a, b, d);
gpr.FlushLockX(ABI_PARAM1);
if (b == d || a == d)
gpr.LoadToX64(d, true, true);
else
gpr.LoadToX64(d, false, true);
MOV(32, R(ABI_PARAM1), gpr.R(b));
if (a)
ADD(32, R(ABI_PARAM1), gpr.R(a));
#if 0
SafeLoadRegToEAX(ABI_PARAM1, 8, 0);
MOV(32, gpr.R(d), R(EAX));
#else
UnsafeLoadRegToReg(ABI_PARAM1, gpr.RX(d), 8, 0, false);
#endif
gpr.UnlockAll();
gpr.UnlockAllX();
break;
default:
Default(inst);
return;
break;
}
gpr.Lock(a, b, d);
gpr.FlushLockX(ABI_PARAM1);
if (b == d || a == d)
gpr.LoadToX64(d, true, true);
else
gpr.LoadToX64(d, false, true);
MOV(32, R(ABI_PARAM1), gpr.R(b));
if (a)
ADD(32, R(ABI_PARAM1), gpr.R(a));
#if 0
SafeLoadRegToEAX(ABI_PARAM1, 8, 0);
MOV(32, gpr.R(d), R(EAX));
#else
UnsafeLoadRegToReg(ABI_PARAM1, gpr.RX(d), 8, 0, false);
#endif
gpr.UnlockAll();
gpr.UnlockAllX();
}
void Jit64::lwzx(UGeckoInstruction inst)
@@ -164,15 +119,7 @@
|| Core::g_CoreStartupParameter.bJITLoadStorelXzOff)
{Default(inst); return;} // turn off from debugger
INSTRUCTION_START;
switch(inst.OPCD)
{
case 33: // lwzu
case 35: // lbzu
case 41: // lhzu
Default(inst);
return;
break;
}
int d = inst.RD;
int a = inst.RA;
@@ -306,6 +253,31 @@
return;
}
void Jit64::lwzux(UGeckoInstruction inst)
{
if(Core::g_CoreStartupParameter.bJITOff || Core::g_CoreStartupParameter.bJITLoadStoreOff)
{Default(inst); return;} // turn off from debugger
INSTRUCTION_START;
int a = inst.RA, b = inst.RB, d = inst.RD;
if (!a || a == d || a == b)
{
Default(inst);
return;
}
gpr.Lock(a, b, d);
gpr.LoadToX64(d, b == d, true);
gpr.LoadToX64(a, true, true);
ADD(32, gpr.R(a), gpr.R(b));
MOV(32, R(EAX), gpr.R(a));
SafeLoadRegToEAX(EAX, 32, 0, false);
MOV(32, gpr.R(d), R(EAX));
gpr.UnlockAll();
return;
}
// Zero cache line.
void Jit64::dcbz(UGeckoInstruction inst)
{
Source/Core/Core/Src/PowerPC/Jit64IL/IR_X86.cpp
+30 -34
View File
@@ -52,7 +52,7 @@ using namespace IREmitter;
using namespace Gen;
struct RegInfo {
Jit64IL* Jit;
Jit64* Jit;
IRBuilder* Build;
InstLoc FirstI;
std::vector<unsigned> IInfo;
@@ -65,7 +65,7 @@ struct RegInfo {
unsigned numProfiledLoads;
unsigned exitNumber;
RegInfo(Jit64IL* j, InstLoc f, unsigned insts) : Jit(j), FirstI(f), IInfo(insts) {
RegInfo(Jit64* j, InstLoc f, unsigned insts) : Jit(j), FirstI(f), IInfo(insts) {
for (unsigned i = 0; i < 16; i++) {
regs[i] = 0;
fregs[i] = 0;
@@ -296,7 +296,7 @@ static void fregNormalRegClear(RegInfo& RI, InstLoc I) {
}
static void regEmitBinInst(RegInfo& RI, InstLoc I,
void (Jit64IL::*op)(int, const OpArg&,
void (Jit64::*op)(int, const OpArg&,
const OpArg&),
bool commutable = false) {
X64Reg reg;
@@ -327,7 +327,7 @@ static void regEmitBinInst(RegInfo& RI, InstLoc I,
}
static void fregEmitBinInst(RegInfo& RI, InstLoc I,
void (Jit64IL::*op)(X64Reg, OpArg)) {
void (Jit64::*op)(X64Reg, OpArg)) {
X64Reg reg;
if (RI.IInfo[I - RI.FirstI] & 4) {
reg = fregEnsureInReg(RI, getOp1(I));
@@ -561,7 +561,7 @@ static void regEmitMemStore(RegInfo& RI, InstLoc I, unsigned Size) {
regClearInst(RI, getOp1(I));
}
static void regEmitShiftInst(RegInfo& RI, InstLoc I, void (Jit64IL::*op)(int, OpArg, OpArg))
static void regEmitShiftInst(RegInfo& RI, InstLoc I, void (Jit64::*op)(int, OpArg, OpArg))
{
X64Reg reg = regBinLHSReg(RI, I);
if (isImm(*getOp2(I))) {
@@ -630,7 +630,7 @@ static void regWriteExit(RegInfo& RI, InstLoc dest) {
}
}
static void DoWriteCode(IRBuilder* ibuild, Jit64IL* Jit, bool UseProfile, bool MakeProfile) {
static void DoWriteCode(IRBuilder* ibuild, Jit64* Jit, bool UseProfile, bool MakeProfile) {
//printf("Writing block: %x\n", js.blockStart);
RegInfo RI(Jit, ibuild->getFirstInst(), ibuild->getNumInsts());
RI.Build = ibuild;
@@ -977,27 +977,27 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64IL* Jit, bool UseProfile, bool M
}
case And: {
if (!thisUsed) break;
regEmitBinInst(RI, I, &Jit64IL::AND, true);
regEmitBinInst(RI, I, &Jit64::AND, true);
break;
}
case Xor: {
if (!thisUsed) break;
regEmitBinInst(RI, I, &Jit64IL::XOR, true);
regEmitBinInst(RI, I, &Jit64::XOR, true);
break;
}
case Sub: {
if (!thisUsed) break;
regEmitBinInst(RI, I, &Jit64IL::SUB);
regEmitBinInst(RI, I, &Jit64::SUB);
break;
}
case Or: {
if (!thisUsed) break;
regEmitBinInst(RI, I, &Jit64IL::OR, true);
regEmitBinInst(RI, I, &Jit64::OR, true);
break;
}
case Add: {
if (!thisUsed) break;
regEmitBinInst(RI, I, &Jit64IL::ADD, true);
regEmitBinInst(RI, I, &Jit64::ADD, true);
break;
}
case Mul: {
@@ -1020,22 +1020,22 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64IL* Jit, bool UseProfile, bool M
}
case Rol: {
if (!thisUsed) break;
regEmitShiftInst(RI, I, &Jit64IL::ROL);
regEmitShiftInst(RI, I, &Jit64::ROL);
break;
}
case Shl: {
if (!thisUsed) break;
regEmitShiftInst(RI, I, &Jit64IL::SHL);
regEmitShiftInst(RI, I, &Jit64::SHL);
break;
}
case Shrl: {
if (!thisUsed) break;
regEmitShiftInst(RI, I, &Jit64IL::SHR);
regEmitShiftInst(RI, I, &Jit64::SHR);
break;
}
case Sarl: {
if (!thisUsed) break;
regEmitShiftInst(RI, I, &Jit64IL::SAR);
regEmitShiftInst(RI, I, &Jit64::SAR);
break;
}
case ICmpEq: {
@@ -1359,17 +1359,17 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64IL* Jit, bool UseProfile, bool M
}
case FSMul: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64IL::MULSS);
fregEmitBinInst(RI, I, &Jit64::MULSS);
break;
}
case FSAdd: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64IL::ADDSS);
fregEmitBinInst(RI, I, &Jit64::ADDSS);
break;
}
case FSSub: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64IL::SUBSS);
fregEmitBinInst(RI, I, &Jit64::SUBSS);
break;
}
case FSRSqrt: {
@@ -1382,17 +1382,17 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64IL* Jit, bool UseProfile, bool M
}
case FDMul: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64IL::MULSD);
fregEmitBinInst(RI, I, &Jit64::MULSD);
break;
}
case FDAdd: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64IL::ADDSD);
fregEmitBinInst(RI, I, &Jit64::ADDSD);
break;
}
case FDSub: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64IL::SUBSD);
fregEmitBinInst(RI, I, &Jit64::SUBSD);
break;
}
case FDCmpCR: {
@@ -1426,17 +1426,17 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64IL* Jit, bool UseProfile, bool M
}
case FPAdd: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64IL::ADDPS);
fregEmitBinInst(RI, I, &Jit64::ADDPS);
break;
}
case FPMul: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64IL::MULPS);
fregEmitBinInst(RI, I, &Jit64::MULPS);
break;
}
case FPSub: {
if (!thisUsed) break;
fregEmitBinInst(RI, I, &Jit64IL::SUBPS);
fregEmitBinInst(RI, I, &Jit64::SUBPS);
break;
}
case FPMerge00: {
@@ -1614,17 +1614,13 @@ static void DoWriteCode(IRBuilder* ibuild, Jit64IL* Jit, bool UseProfile, bool M
Jit->UD2();
}
void Jit64IL::WriteCode() {
void Jit64::WriteCode() {
DoWriteCode(&ibuild, this, false, Core::GetStartupParameter().bJITProfiledReJIT);
}
void ProfiledReJit() {
Jit64IL *jitil = dynamic_cast<Jit64IL *>(jit);
if(jitil)
jitil->ProfiledReJit();
}
void Jit64IL::ProfiledReJit() {
jit->SetCodePtr(jit->js.rewriteStart);
DoWriteCode(&jit->ibuild, this, true, false);
jit->js.curBlock->codeSize = (int)(jit->GetCodePtr() - jit->js.rewriteStart);
jit->GetBlockCache()->FinalizeBlock(jit->js.curBlock->blockNum, jit->jo.enableBlocklink, jit->js.curBlock->normalEntry);
jit.SetCodePtr(jit.js.rewriteStart);
DoWriteCode(&jit.ibuild, &jit, true, false);
jit.js.curBlock->codeSize = (int)(jit.GetCodePtr() - jit.js.rewriteStart);
jit.GetBlockCache()->FinalizeBlock(jit.js.curBlock->blockNum, jit.jo.enableBlocklink, jit.js.curBlock->normalEntry);
}
Source/Core/Core/Src/PowerPC/Jit64IL/Jit.cpp
+21 -19
View File
@@ -156,6 +156,8 @@ ps_adds1
*/
Jit64 jit;
int CODE_SIZE = 1024*1024*16;
namespace CPUCompare
@@ -165,10 +167,10 @@ namespace CPUCompare
void Jit(u32 em_address)
{
jit->Jit(em_address);
jit.Jit(em_address);
}
void Jit64IL::Init()
void Jit64::Init()
{
asm_routines.compareEnabled = ::Core::g_CoreStartupParameter.bRunCompareClient;
if (Core::g_CoreStartupParameter.bJITUnlimitedCache)
@@ -198,14 +200,14 @@ void Jit64IL::Init()
asm_routines.Init();
}
void Jit64IL::ClearCache()
void Jit64::ClearCache()
{
blocks.Clear();
trampolines.ClearCodeSpace();
ClearCodeSpace();
}
void Jit64IL::Shutdown()
void Jit64::Shutdown()
{
FreeCodeSpace();
@@ -215,7 +217,7 @@ void Jit64IL::Shutdown()
}
void Jit64IL::WriteCallInterpreter(UGeckoInstruction inst)
void Jit64::WriteCallInterpreter(UGeckoInstruction inst)
{
if (js.isLastInstruction)
{
@@ -231,32 +233,32 @@ void Jit64IL::WriteCallInterpreter(UGeckoInstruction inst)
}
}
void Jit64IL::unknown_instruction(UGeckoInstruction inst)
void Jit64::unknown_instruction(UGeckoInstruction inst)
{
// CCPU::Break();
PanicAlert("unknown_instruction %08x - Fix me ;)", inst.hex);
}
void Jit64IL::Default(UGeckoInstruction _inst)
void Jit64::Default(UGeckoInstruction _inst)
{
ibuild.EmitInterpreterFallback(
ibuild.EmitIntConst(_inst.hex),
ibuild.EmitIntConst(js.compilerPC));
}
void Jit64IL::HLEFunction(UGeckoInstruction _inst)
void Jit64::HLEFunction(UGeckoInstruction _inst)
{
ABI_CallFunctionCC((void*)&HLE::Execute, js.compilerPC, _inst.hex);
MOV(32, R(EAX), M(&NPC));
WriteExitDestInEAX(0);
}
void Jit64IL::DoNothing(UGeckoInstruction _inst)
void Jit64::DoNothing(UGeckoInstruction _inst)
{
// Yup, just don't do anything.
}
void Jit64IL::NotifyBreakpoint(u32 em_address, bool set)
void Jit64::NotifyBreakpoint(u32 em_address, bool set)
{
int block_num = blocks.GetBlockNumberFromStartAddress(em_address);
if (block_num >= 0)
@@ -294,13 +296,13 @@ void ImHere()
been_here[PC] = 1;
}
void Jit64IL::Cleanup()
void Jit64::Cleanup()
{
if (jo.optimizeGatherPipe && js.fifoBytesThisBlock > 0)
ABI_CallFunction((void *)&GPFifo::CheckGatherPipe);
}
void Jit64IL::WriteExit(u32 destination, int exit_num)
void Jit64::WriteExit(u32 destination, int exit_num)
{
Cleanup();
SUB(32, M(&CoreTiming::downcount), js.downcountAmount > 127 ? Imm32(js.downcountAmount) : Imm8(js.downcountAmount));
@@ -325,7 +327,7 @@ void Jit64IL::WriteExit(u32 destination, int exit_num)
}
}
void Jit64IL::WriteExitDestInEAX(int exit_num)
void Jit64::WriteExitDestInEAX(int exit_num)
{
MOV(32, M(&PC), R(EAX));
Cleanup();
@@ -333,7 +335,7 @@ void Jit64IL::WriteExitDestInEAX(int exit_num)
JMP(asm_routines.dispatcher, true);
}
void Jit64IL::WriteRfiExitDestInEAX()
void Jit64::WriteRfiExitDestInEAX()
{
MOV(32, M(&PC), R(EAX));
Cleanup();
@@ -341,7 +343,7 @@ void Jit64IL::WriteRfiExitDestInEAX()
JMP(asm_routines.testExceptions, true);
}
void Jit64IL::WriteExceptionExit(u32 exception)
void Jit64::WriteExceptionExit(u32 exception)
{
Cleanup();
OR(32, M(&PowerPC::ppcState.Exceptions), Imm32(exception));
@@ -349,14 +351,14 @@ void Jit64IL::WriteExceptionExit(u32 exception)
JMP(asm_routines.testExceptions, true);
}
void STACKALIGN Jit64IL::Run()
void STACKALIGN Jit64::Run()
{
CompiledCode pExecAddr = (CompiledCode)asm_routines.enterCode;
pExecAddr();
//Will return when PowerPC::state changes
}
void Jit64IL::SingleStep()
void Jit64::SingleStep()
{
// NOT USED, NOT TESTED, PROBABLY NOT WORKING YET
// PanicAlert("Single");
@@ -368,7 +370,7 @@ void Jit64IL::SingleStep()
pExecAddr();*/
}
void STACKALIGN Jit64IL::Jit(u32 em_address)
void STACKALIGN Jit64::Jit(u32 em_address)
{
if (GetSpaceLeft() < 0x10000 || blocks.IsFull())
{
@@ -385,7 +387,7 @@ void STACKALIGN Jit64IL::Jit(u32 em_address)
blocks.FinalizeBlock(block_num, jo.enableBlocklink, DoJit(em_address, &code_buffer, b));
}
const u8* Jit64IL::DoJit(u32 em_address, PPCAnalyst::CodeBuffer *code_buffer, JitBlock *b)
const u8* Jit64::DoJit(u32 em_address, PPCAnalyst::CodeBuffer *code_buffer, JitBlock *b)
{
if (em_address == 0)
PanicAlert("ERROR : Trying to compile at 0. LR=%08x", LR);
Source/Core/Core/Src/PowerPC/Jit64IL/Jit.h
+30 -5
View File
@@ -34,7 +34,6 @@
#include "../JitCommon/JitCache.h"
#include "x64Emitter.h"
#include "x64Analyzer.h"
#include "../CoreGeneralize.h"
#include "IR.h"
#ifdef _WIN32
@@ -42,6 +41,20 @@
#include <windows.h>
#else
// A bit of a hack to get things building under linux. We manually fill in this structure as needed
// from the real context.
struct CONTEXT
{
#ifdef _M_X64
u64 Rip;
u64 Rax;
#else
u32 Eip;
u32 Eax;
#endif
};
#endif
// #define INSTRUCTION_START Default(inst); return;
@@ -60,7 +73,19 @@
#define DISABLE64
#endif
class Jit64IL : public cCore
class TrampolineCache : public Gen::XCodeBlock
{
public:
void Init();
void Shutdown();
const u8 *GetReadTrampoline(const InstructionInfo &info);
const u8 *GetWriteTrampoline(const InstructionInfo &info);
};
class Jit64 : public Gen::XCodeBlock
{
private:
struct JitState
@@ -109,8 +134,8 @@ private:
PPCAnalyst::CodeBuffer code_buffer;
public:
Jit64IL() : code_buffer(32000) {}
~Jit64IL() {}
Jit64() : code_buffer(32000) {}
~Jit64() {}
JitState js;
JitOptions jo;
@@ -138,7 +163,6 @@ public:
void SingleStep();
const u8 *BackPatch(u8 *codePtr, int accessType, u32 em_address, CONTEXT *ctx);
void ProfiledReJit();
#define JIT_OPCODE 0
@@ -271,6 +295,7 @@ public:
void stmw(UGeckoInstruction inst);
};
extern Jit64 jit;
void Jit(u32 em_address);
Source/Core/Core/Src/PowerPC/Jit64IL/JitAsm.cpp
+1 -1
View File
@@ -70,7 +70,7 @@ void AsmRoutineManager::Generate()
#ifndef _M_IX86
// Two statically allocated registers.
MOV(64, R(RBX), Imm64((u64)Memory::base));
MOV(64, R(R15), Imm64((u64)jit->GetBlockCache()->GetCodePointers())); //It's below 2GB so 32 bits are good enough
MOV(64, R(R15), Imm64((u64)jit.GetBlockCache()->GetCodePointers())); //It's below 2GB so 32 bits are good enough
#endif
// INT3();
Source/Core/Core/Src/PowerPC/Jit64IL/Jit_Branch.cpp
+6 -6
View File
@@ -44,17 +44,17 @@
using namespace Gen;
void Jit64IL::sc(UGeckoInstruction inst)
void Jit64::sc(UGeckoInstruction inst)
{
ibuild.EmitSystemCall(ibuild.EmitIntConst(js.compilerPC));
}
void Jit64IL::rfi(UGeckoInstruction inst)
void Jit64::rfi(UGeckoInstruction inst)
{
ibuild.EmitRFIExit();
}
void Jit64IL::bx(UGeckoInstruction inst)
void Jit64::bx(UGeckoInstruction inst)
{
NORMALBRANCH_START
INSTRUCTION_START;
@@ -113,7 +113,7 @@ static IREmitter::InstLoc TestBranch(IREmitter::IRBuilder& ibuild, UGeckoInstruc
return Test;
}
void Jit64IL::bcx(UGeckoInstruction inst)
void Jit64::bcx(UGeckoInstruction inst)
{
NORMALBRANCH_START
if (inst.LK)
@@ -144,7 +144,7 @@ void Jit64IL::bcx(UGeckoInstruction inst)
ibuild.EmitBranchUncond(ibuild.EmitIntConst(js.compilerPC + 4));
}
void Jit64IL::bcctrx(UGeckoInstruction inst)
void Jit64::bcctrx(UGeckoInstruction inst)
{
NORMALBRANCH_START
if ((inst.BO & 4) == 0) {
@@ -173,7 +173,7 @@ void Jit64IL::bcctrx(UGeckoInstruction inst)
ibuild.EmitBranchUncond(destination);
}
void Jit64IL::bclrx(UGeckoInstruction inst)
void Jit64::bclrx(UGeckoInstruction inst)
{
NORMALBRANCH_START
if (inst.hex == 0x4e800020) {
Source/Core/Core/Src/PowerPC/Jit64IL/Jit_FloatingPoint.cpp
+4 -4
View File
@@ -27,7 +27,7 @@
//#define INSTRUCTION_START Default(inst); return;
#define INSTRUCTION_START
void Jit64IL::fp_arith_s(UGeckoInstruction inst)
void Jit64::fp_arith_s(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(FloatingPoint)
@@ -66,7 +66,7 @@ void Jit64IL::fp_arith_s(UGeckoInstruction inst)
ibuild.EmitStoreFReg(val, inst.FD);
}
void Jit64IL::fmaddXX(UGeckoInstruction inst)
void Jit64::fmaddXX(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(FloatingPoint)
@@ -91,7 +91,7 @@ void Jit64IL::fmaddXX(UGeckoInstruction inst)
ibuild.EmitStoreFReg(val, inst.FD);
}
void Jit64IL::fmrx(UGeckoInstruction inst)
void Jit64::fmrx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(FloatingPoint)
@@ -103,7 +103,7 @@ void Jit64IL::fmrx(UGeckoInstruction inst)
ibuild.EmitStoreFReg(val, inst.FD);
}
void Jit64IL::fcmpx(UGeckoInstruction inst)
void Jit64::fcmpx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(FloatingPoint)
Source/Core/Core/Src/PowerPC/Jit64IL/Jit_Integer.cpp
+27 -27
View File
@@ -37,7 +37,7 @@ static void ComputeRC(IREmitter::IRBuilder& ibuild,
ibuild.EmitStoreCR(res, 0);
}
void Jit64IL::reg_imm(UGeckoInstruction inst)
void Jit64::reg_imm(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -105,7 +105,7 @@ void Jit64IL::reg_imm(UGeckoInstruction inst)
}
}
void Jit64IL::cmpXX(UGeckoInstruction inst)
void Jit64::cmpXX(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -129,7 +129,7 @@ void Jit64IL::cmpXX(UGeckoInstruction inst)
ibuild.EmitStoreCR(res, inst.CRFD);
}
void Jit64IL::orx(UGeckoInstruction inst)
void Jit64::orx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -142,7 +142,7 @@ void Jit64IL::orx(UGeckoInstruction inst)
// m_GPR[_inst.RA] = m_GPR[_inst.RS] ^ m_GPR[_inst.RB];
void Jit64IL::xorx(UGeckoInstruction inst)
void Jit64::xorx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -153,7 +153,7 @@ void Jit64IL::xorx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64IL::andx(UGeckoInstruction inst)
void Jit64::andx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -164,7 +164,7 @@ void Jit64IL::andx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64IL::extsbx(UGeckoInstruction inst)
void Jit64::extsbx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -175,7 +175,7 @@ void Jit64IL::extsbx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64IL::extshx(UGeckoInstruction inst)
void Jit64::extshx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -186,7 +186,7 @@ void Jit64IL::extshx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64IL::subfic(UGeckoInstruction inst)
void Jit64::subfic(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -205,7 +205,7 @@ void Jit64IL::subfic(UGeckoInstruction inst)
ibuild.EmitStoreCarry(test);
}
void Jit64IL::subfcx(UGeckoInstruction inst)
void Jit64::subfcx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -222,7 +222,7 @@ void Jit64IL::subfcx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64IL::subfex(UGeckoInstruction inst)
void Jit64::subfex(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -243,7 +243,7 @@ void Jit64IL::subfex(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64IL::subfx(UGeckoInstruction inst)
void Jit64::subfx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -255,7 +255,7 @@ void Jit64IL::subfx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64IL::mulli(UGeckoInstruction inst)
void Jit64::mulli(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -264,7 +264,7 @@ void Jit64IL::mulli(UGeckoInstruction inst)
ibuild.EmitStoreGReg(val, inst.RD);
}
void Jit64IL::mullwx(UGeckoInstruction inst)
void Jit64::mullwx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -275,7 +275,7 @@ void Jit64IL::mullwx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64IL::mulhwux(UGeckoInstruction inst)
void Jit64::mulhwux(UGeckoInstruction inst)
{
Default(inst); return;
#if 0
@@ -310,7 +310,7 @@ void Jit64IL::mulhwux(UGeckoInstruction inst)
}
// skipped some of the special handling in here - if we get crashes, let the interpreter handle this op
void Jit64IL::divwux(UGeckoInstruction inst) {
void Jit64::divwux(UGeckoInstruction inst) {
Default(inst); return;
#if 0
int a = inst.RA, b = inst.RB, d = inst.RD;
@@ -343,7 +343,7 @@ u32 Helper_Mask(u8 mb, u8 me)
);
}
void Jit64IL::addx(UGeckoInstruction inst)
void Jit64::addx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -354,7 +354,7 @@ void Jit64IL::addx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64IL::addzex(UGeckoInstruction inst)
void Jit64::addzex(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -368,7 +368,7 @@ void Jit64IL::addzex(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
// This can be optimized
void Jit64IL::addex(UGeckoInstruction inst)
void Jit64::addex(UGeckoInstruction inst)
{
Default(inst); return;
#if 0
@@ -399,7 +399,7 @@ void Jit64IL::addex(UGeckoInstruction inst)
#endif
}
void Jit64IL::rlwinmx(UGeckoInstruction inst)
void Jit64::rlwinmx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -413,7 +413,7 @@ void Jit64IL::rlwinmx(UGeckoInstruction inst)
}
void Jit64IL::rlwimix(UGeckoInstruction inst)
void Jit64::rlwimix(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -429,7 +429,7 @@ void Jit64IL::rlwimix(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64IL::rlwnmx(UGeckoInstruction inst)
void Jit64::rlwnmx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -442,7 +442,7 @@ void Jit64IL::rlwnmx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64IL::negx(UGeckoInstruction inst)
void Jit64::negx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -453,7 +453,7 @@ void Jit64IL::negx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64IL::srwx(UGeckoInstruction inst)
void Jit64::srwx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -472,7 +472,7 @@ void Jit64IL::srwx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64IL::slwx(UGeckoInstruction inst)
void Jit64::slwx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -491,7 +491,7 @@ void Jit64IL::slwx(UGeckoInstruction inst)
ComputeRC(ibuild, val);
}
void Jit64IL::srawx(UGeckoInstruction inst)
void Jit64::srawx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -514,7 +514,7 @@ void Jit64IL::srawx(UGeckoInstruction inst)
ibuild.EmitStoreCarry(test);
}
void Jit64IL::srawix(UGeckoInstruction inst)
void Jit64::srawix(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)
@@ -531,7 +531,7 @@ void Jit64IL::srawix(UGeckoInstruction inst)
}
// count leading zeroes
void Jit64IL::cntlzwx(UGeckoInstruction inst)
void Jit64::cntlzwx(UGeckoInstruction inst)
{
INSTRUCTION_START
JITDISABLE(Integer)

Some files were not shown because too many files have changed in this diff Show More